Code Context Provider MCP

Instructions

Implementation Reference

• index.js:921-1031 (handler)

  The main execution handler for the get_code_context tool. Handles input parameters, initializes Tree-sitter if needed for code analysis, generates directory tree and symbol analysis using helper functions, compiles the response.
  async ({ absolutePath, analyzeJs, includeSymbols, symbolType, filePatterns, maxDepth = 5 }) => { try { // Check if the path is C:/ drive root or common non-project directories on Windows OS if (process.platform === 'win32') { // Check for C: drive root or common system directories that are not project directories const nonProjectPaths = [ /^[cC]:[\\/]?$/, // C:/ or C: /^[cC]:[\\/]Users[\\/]?$/, // C:/Users/ /^[cC]:[\\/]Windows[\\/]?$/, // C:/Windows/ /^[cC]:[\\/]Program Files[\\/]?$/, // C:/Program Files/ /^[cC]:[\\/]Program Files \(x86\)[\\/]?$/ // C:/Program Files (x86)/ ]; if (nonProjectPaths.some(regex => regex.test(absolutePath))) { return { content: [{ type: "text", text: "C drive is not a project directory. Try different path" }], isError: true }; } } // Ensure TreeSitter is initialized if we're going to analyze code if (analyzeJs && !initialized) { // Create parsers directory and ensure it exists const parsersDir = ensureParsersDirectory(); console.error(`Using parsers directory: ${parsersDir}`); // Initialize TreeSitter await initializeTreeSitter(); if (!initialized) { return { content: [{ type: "text", text: "Error: Failed to initialize code analysis parser. WASM parsers may be missing." }], isError: true }; } } // Normalize path to handle both Windows and Unix-style paths const normalizedPath = path.normalize(absolutePath); console.error(`Analyzing directory: ${normalizedPath} (analyzeJs: ${analyzeJs}, maxAnalysisDepth: ${maxDepth !== 5 ? maxDepth : '5 (default)'})`); // Reset code symbols if analyzing JS if (analyzeJs) { codeSymbols.functions = {}; codeSymbols.variables = {}; codeSymbols.classes = {}; codeSymbols.imports = {}; codeSymbols.exports = {}; codeSymbols.files = new Set(); } // Get the directory tree, passing along all the symbol-related parameters const tree = await getDirectoryTree( normalizedPath, normalizedPath, [], filePatterns, '', analyzeJs, includeSymbols, symbolType, 0, maxDepth ); // Generate summary of analyzed files if applicable let analysisSummary = ''; if (analyzeJs && codeSymbols.files.size > 0) { const totalFunctions = Object.values(codeSymbols.functions).reduce((sum, arr) => sum + arr.length, 0); const totalVariables = Object.values(codeSymbols.variables).reduce((sum, arr) => sum + arr.length, 0); const totalClasses = Object.values(codeSymbols.classes).reduce((sum, arr) => sum + arr.length, 0); analysisSummary = `\n\nCode Analysis Summary: - Files analyzed: ${codeSymbols.files.size} - Total functions: ${totalFunctions} - Total variables: ${totalVariables} - Total classes: ${totalClasses}`; // Add language support info and custom pattern info if (filePatterns && filePatterns.length > 0) { analysisSummary += `\n\nAnalyzed files matching patterns: ${filePatterns.join(', ')}`; } else { analysisSummary += `\n\nNote: Symbol analysis is supported for JavaScript/TypeScript (.js, .jsx, .ts, .tsx) and Python (.py) files only.`; } // Add depth limit info if applicable if (maxDepth !== 5) { analysisSummary += `\n\nCode analysis limited to a maximum depth of ${maxDepth} directory levels.`; } else { analysisSummary += `\n\nCode analysis limited to a maximum depth of 5 directory levels (default).`; } } // Return the result return { content: [ { type: "text", text: `Directory structure for: ${normalizedPath}${analysisSummary}\n\n${tree}` } ] }; } catch (error) { console.error(`Error in get_code_context tool: ${error.message}`); return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true }; } }
• index.js:914-920 (schema)

  Zod input schema defining parameters for directory path, analysis options, symbol filtering, and depth limit.
  { absolutePath: z.string().describe("Absolute path to the directory to analyze. For windows, it is recommended to use forward slashes to avoid escaping (e.g. C:/Users/username/Documents/project/src)"), analyzeJs: z.boolean().optional().default(false).describe("Whether to analyze JavaScript/TypeScript and Python files. Returns the count of functions, variables, classes, imports, and exports in the codebase."), includeSymbols: z.boolean().optional().default(false).describe("Whether to include code symbols in the response. Returns the code symbols for each file."), symbolType: z.enum(['functions', 'variables', 'classes', 'imports', 'exports', 'all']).optional().default('all').describe("Type of symbols to include if includeSymbols is true. Otherwise, returns only the directory tree."), maxDepth: z.number().optional().default(5).describe("Maximum directory depth for code analysis (default: 5 levels). Directory tree will still be built for all levels. Reduce the depth if you only need a quick overview of the project.") },
• index.js:910-1032 (registration)

  Registers the get_code_context tool on the MCP server, providing name, description, input schema, and handler function.
  // Add the get_code_context tool server.tool( "get_code_context", "Returns Complete Context of a given project directory, including directory tree, and code symbols. Useful for getting a quick overview of a project. Use this tool when you need to get a comprehensive overview of a project's codebase. Useful at the start of a new task.", { absolutePath: z.string().describe("Absolute path to the directory to analyze. For windows, it is recommended to use forward slashes to avoid escaping (e.g. C:/Users/username/Documents/project/src)"), analyzeJs: z.boolean().optional().default(false).describe("Whether to analyze JavaScript/TypeScript and Python files. Returns the count of functions, variables, classes, imports, and exports in the codebase."), includeSymbols: z.boolean().optional().default(false).describe("Whether to include code symbols in the response. Returns the code symbols for each file."), symbolType: z.enum(['functions', 'variables', 'classes', 'imports', 'exports', 'all']).optional().default('all').describe("Type of symbols to include if includeSymbols is true. Otherwise, returns only the directory tree."), maxDepth: z.number().optional().default(5).describe("Maximum directory depth for code analysis (default: 5 levels). Directory tree will still be built for all levels. Reduce the depth if you only need a quick overview of the project.") }, async ({ absolutePath, analyzeJs, includeSymbols, symbolType, filePatterns, maxDepth = 5 }) => { try { // Check if the path is C:/ drive root or common non-project directories on Windows OS if (process.platform === 'win32') { // Check for C: drive root or common system directories that are not project directories const nonProjectPaths = [ /^[cC]:[\\/]?$/, // C:/ or C: /^[cC]:[\\/]Users[\\/]?$/, // C:/Users/ /^[cC]:[\\/]Windows[\\/]?$/, // C:/Windows/ /^[cC]:[\\/]Program Files[\\/]?$/, // C:/Program Files/ /^[cC]:[\\/]Program Files \(x86\)[\\/]?$/ // C:/Program Files (x86)/ ]; if (nonProjectPaths.some(regex => regex.test(absolutePath))) { return { content: [{ type: "text", text: "C drive is not a project directory. Try different path" }], isError: true }; } } // Ensure TreeSitter is initialized if we're going to analyze code if (analyzeJs && !initialized) { // Create parsers directory and ensure it exists const parsersDir = ensureParsersDirectory(); console.error(`Using parsers directory: ${parsersDir}`); // Initialize TreeSitter await initializeTreeSitter(); if (!initialized) { return { content: [{ type: "text", text: "Error: Failed to initialize code analysis parser. WASM parsers may be missing." }], isError: true }; } } // Normalize path to handle both Windows and Unix-style paths const normalizedPath = path.normalize(absolutePath); console.error(`Analyzing directory: ${normalizedPath} (analyzeJs: ${analyzeJs}, maxAnalysisDepth: ${maxDepth !== 5 ? maxDepth : '5 (default)'})`); // Reset code symbols if analyzing JS if (analyzeJs) { codeSymbols.functions = {}; codeSymbols.variables = {}; codeSymbols.classes = {}; codeSymbols.imports = {}; codeSymbols.exports = {}; codeSymbols.files = new Set(); } // Get the directory tree, passing along all the symbol-related parameters const tree = await getDirectoryTree( normalizedPath, normalizedPath, [], filePatterns, '', analyzeJs, includeSymbols, symbolType, 0, maxDepth ); // Generate summary of analyzed files if applicable let analysisSummary = ''; if (analyzeJs && codeSymbols.files.size > 0) { const totalFunctions = Object.values(codeSymbols.functions).reduce((sum, arr) => sum + arr.length, 0); const totalVariables = Object.values(codeSymbols.variables).reduce((sum, arr) => sum + arr.length, 0); const totalClasses = Object.values(codeSymbols.classes).reduce((sum, arr) => sum + arr.length, 0); analysisSummary = `\n\nCode Analysis Summary: - Files analyzed: ${codeSymbols.files.size} - Total functions: ${totalFunctions} - Total variables: ${totalVariables} - Total classes: ${totalClasses}`; // Add language support info and custom pattern info if (filePatterns && filePatterns.length > 0) { analysisSummary += `\n\nAnalyzed files matching patterns: ${filePatterns.join(', ')}`; } else { analysisSummary += `\n\nNote: Symbol analysis is supported for JavaScript/TypeScript (.js, .jsx, .ts, .tsx) and Python (.py) files only.`; } // Add depth limit info if applicable if (maxDepth !== 5) { analysisSummary += `\n\nCode analysis limited to a maximum depth of ${maxDepth} directory levels.`; } else { analysisSummary += `\n\nCode analysis limited to a maximum depth of 5 directory levels (default).`; } } // Return the result return { content: [ { type: "text", text: `Directory structure for: ${normalizedPath}${analysisSummary}\n\n${tree}` } ] }; } catch (error) { console.error(`Error in get_code_context tool: ${error.message}`); return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true }; } } );
• index.js:716-902 (helper)

  Key helper function that recursively builds the directory tree, applies ignore patterns, analyzes supported code files by extracting symbols, and formats output with optional details.
  async function getDirectoryTree(dirPath, rootPath = dirPath, ignorePatterns = [], filePatterns = null, indent = '', analyzeJs = false, includeSymbols = false, symbolType = 'all', currentDepth = 0, maxDepth = 5) { try { if (!fs.existsSync(dirPath)) { return `${indent}Path does not exist: ${dirPath}`; } // Default patterns to ignore common directories and files const defaultIgnorePatterns = [ '^node_modules($|/)', '^.git($|/)', '\\.log$', '\\.tmp$', '\\.temp$', '\\.swp$', '\\.DS_Store$', '\\.vscode($|/)', '\\.idea($|/)', '\\.vs($|/)', '^dist($|/)', '^build($|/)', '^coverage($|/)' ]; // Combine default patterns with any provided patterns let allIgnorePatterns = [...defaultIgnorePatterns, ...ignorePatterns]; // Check for .gitignore file in this directory const gitignorePath = path.join(dirPath, '.gitignore'); if (fs.existsSync(gitignorePath)) { const newPatterns = parseGitignore(gitignorePath); allIgnorePatterns = [...allIgnorePatterns, ...newPatterns]; } let output = ''; const items = fs.readdirSync(dirPath); for (let i = 0; i < items.length; i++) { const itemName = items[i]; const itemPath = path.join(dirPath, itemName); // Skip .gitignore files if (itemName === '.gitignore') { continue; } // Skip hidden files/directories if (itemName.startsWith('.')) { continue; } // Skip items that match ignore patterns if (shouldIgnore(itemPath, allIgnorePatterns, rootPath)) { continue; } const isLast = i === items.length - 1; const stats = fs.statSync(itemPath); // Generate the prefix for current item const prefix = isLast ? '└── ' : '├── '; // Generate the prefix for child items const childIndent = indent + (isLast ? ' ' : '│ '); if (stats.isDirectory()) { output += `${indent}${prefix}${itemName}/\n`; // Always recurse to build the directory tree, but only analyze code if we're within maxDepth const shouldAnalyze = analyzeJs && (currentDepth < maxDepth); output += await getDirectoryTree( itemPath, rootPath, allIgnorePatterns, filePatterns, childIndent, shouldAnalyze, // Only analyze if within depth limit includeSymbols, symbolType, currentDepth + 1, maxDepth ); } else { const sizeInKB = Math.ceil(stats.size / 1024); output += `${indent}${prefix}${itemName} (${sizeInKB} KB)\n`; // Analyze supported files if requested AND we're within the max depth limit if (analyzeJs && currentDepth <= maxDepth && isSupportedFile(itemPath, filePatterns)) { try { const fileContent = fs.readFileSync(itemPath, 'utf8'); const symbols = await extractCodeSymbols(itemPath, fileContent); if (symbols) { // Store the extracted symbols codeSymbols.functions[itemPath] = symbols.functions; codeSymbols.variables[itemPath] = symbols.variables; codeSymbols.classes[itemPath] = symbols.classes; codeSymbols.imports[itemPath] = symbols.imports; codeSymbols.exports[itemPath] = symbols.exports; codeSymbols.files.add(itemPath); // Add a summary of what was found output += `${childIndent}└── [Analyzed: ${symbols.functions.length} functions, ${symbols.variables.length} variables, ${symbols.classes.length} classes]\n`; // Add detailed symbol information if requested if (includeSymbols) { // Functions if ((symbolType === 'functions' || symbolType === 'all') && symbols.functions.length > 0) { // Always filter out anonymous functions by default const fileFunctions = symbols.functions.filter(fn => fn.name !== 'anonymous'); if (fileFunctions.length > 0) { output += `${childIndent} Functions:\n`; output += fileFunctions.map(fn => `${childIndent} - ${fn.name}${fn.parent ? ` (in ${fn.parent})` : ''} [${fn.position.startLine}:${fn.position.startCol}]` ).join('\n') + '\n'; } } // Variables if ((symbolType === 'variables' || symbolType === 'all') && symbols.variables.length > 0) { output += `${childIndent} Variables:\n`; output += symbols.variables.map(v => `${childIndent} - ${v.kind} ${v.name} [${v.position.startLine}:${v.position.startCol}]` ).join('\n') + '\n'; } // Classes if ((symbolType === 'classes' || symbolType === 'all') && symbols.classes.length > 0) { output += `${childIndent} Classes:\n`; output += symbols.classes.map(c => { let classInfo = `${childIndent} - ${c.name} [${c.position.startLine}:${c.position.startCol}]`; if (c.methods.length > 0) { classInfo += `\n${childIndent} Methods:\n`; classInfo += c.methods.map(m => `${childIndent} - ${m.isStatic ? 'static ' : ''}${m.name} [${m.position.startLine}:${m.position.startCol}]` ).join('\n'); } return classInfo; }).join('\n') + '\n'; } // Imports if ((symbolType === 'imports' || symbolType === 'all') && symbols.imports.length > 0) { output += `${childIndent} Imports:\n`; output += symbols.imports.map(imp => { let importInfo = `${childIndent} - from '${imp.source}'`; if (imp.items.length > 0) { importInfo += ': ' + imp.items.map(item => `${item.name}${item.alias ? ` as ${item.alias}` : ''}` ).join(', '); } return importInfo; }).join('\n') + '\n'; } // Exports if ((symbolType === 'exports' || symbolType === 'all') && symbols.exports.length > 0) { output += `${childIndent} Exports:\n`; output += symbols.exports.map(exp => { let exportInfo = `${childIndent} - ${exp.isDefault ? 'default export' : 'export'}`; if (exp.source) { exportInfo += ` from '${exp.source}'`; } if (exp.items.length > 0) { exportInfo += ': ' + exp.items.map(item => `${item.name}${item.alias ? ` as ${item.alias}` : ''}` ).join(', '); } return exportInfo; }).join('\n') + '\n'; } } } } catch (error) { console.error(`Error analyzing ${itemPath}: ${error.message}`); } } } } return output; } catch (error) { console.error(`Error processing directory ${dirPath}: ${error.message}`); return `${indent}Error: ${error.message}\n`; } }
• index.js:113-604 (helper)

  Core code analysis helper using Tree-sitter to parse files and extract detailed symbols (functions, variables, classes, imports, exports) for JS/TS/Python files.
  async function extractCodeSymbols(filePath, fileContent) { // Ensure TreeSitter is initialized if (!initialized) { await initializeTreeSitter(); } try { // Set the appropriate language based on file extension const wasmFile = getLanguageFromExtension(filePath); if (!wasmFile || !languageInstances[wasmFile]) { return null; // Unsupported language } const parser = new Parser(); parser.setLanguage(languageInstances[wasmFile]); const tree = parser.parse(fileContent); const rootNode = tree.rootNode; const functions = []; const variables = []; const classes = []; const imports = []; const exports = []; // Helper to get line and column info const getPosition = (node) => { return { startLine: node.startPosition.row + 1, startCol: node.startPosition.column, endLine: node.endPosition.row + 1, endCol: node.endPosition.column }; }; // Helper to check if a function is significant enough to track const isSignificantFunction = (node, name) => { // Skip tiny arrow functions like () => {} or x => x if (node.type === 'arrow_function' && node.text.length < 15) { return false; } // Skip callback functions in array methods if they're simple const parent = node.parent; if (parent && (parent.type === 'call_expression' || parent.type === 'member_expression') && node.text.length < 50) { // Check if it's a callback in common array methods const callText = parent.text.slice(0, 30).toLowerCase(); if (callText.includes('.map(') || callText.includes('.filter(') || callText.includes('.forEach(') || callText.includes('.find(') || callText.includes('.reduce(')) { return false; } } // Keep named functions and significant anonymous ones return name !== 'anonymous' || node.text.length > 100; }; // Helper to infer function name from context const inferFunctionName = (node) => { let name = 'anonymous'; // Check if function is assigned to a variable const parent = node.parent; if (parent) { if (parent.type === 'variable_declarator') { // Case: const myFunc = function() {...} or const myFunc = () => {...} const nameNode = parent.childForFieldName('name'); if (nameNode) { return nameNode.text; } } else if (parent.type === 'pair' && parent.parent && parent.parent.type === 'object') { // Case: { myMethod: function() {...} } or { myMethod: () => {...} } const keyNode = parent.childForFieldName('key'); if (keyNode) { return keyNode.text.replace(/['"]/g, ''); } } else if (parent.type === 'assignment_expression') { // Case: obj.method = function() {...} or MyClass.prototype.method = function() {...} const leftNode = parent.childForFieldName('left'); if (leftNode) { if (leftNode.type === 'member_expression') { // Get rightmost part, e.g., 'method' from 'obj.method' const propertyNode = leftNode.childForFieldName('property'); if (propertyNode) { return propertyNode.text; } } else { return leftNode.text; } } } else if (parent.type === 'property_identifier' && parent.parent && parent.parent.type === 'member_expression') { // Case for method callbacks like .then(() => {...}) return parent.text; } } return name; }; // Process different languages if (wasmFile === 'tree-sitter-javascript.wasm') { // Process JavaScript/TypeScript // Find function declarations const functionNodes = rootNode.descendantsOfType([ 'function_declaration', 'method_definition', 'arrow_function', 'function' ]); for (const node of functionNodes) { // Get function name let name = 'anonymous'; let parentFunction = null; if (node.type === 'function_declaration') { const nameNode = node.firstNamedChild; if (nameNode) name = nameNode.text; } else if (node.type === 'method_definition') { const nameNode = node.childForFieldName('name'); if (nameNode) name = nameNode.text; // Get parent class or object const classNode = node.parent?.parent; if (classNode?.type === 'class_declaration') { const classNameNode = classNode.childForFieldName('name'); if (classNameNode) parentFunction = classNameNode.text; } } else if (node.type === 'function' || node.type === 'arrow_function') { // Try to infer the name from context name = inferFunctionName(node); } // Only add significant functions if (isSignificantFunction(node, name)) { functions.push({ name, parent: parentFunction, position: getPosition(node), code: node.text }); } } // Find variable declarations const variableNodes = rootNode.descendantsOfType([ 'variable_declaration', 'lexical_declaration' ]); for (const node of variableNodes) { const declarators = node.descendantsOfType('variable_declarator'); for (const declarator of declarators) { const nameNode = declarator.childForFieldName('name'); if (nameNode) { variables.push({ name: nameNode.text, kind: node.childForFieldName('kind')?.text || 'var', position: getPosition(declarator), code: declarator.text }); } } } // Find class declarations const classNodes = rootNode.descendantsOfType('class_declaration'); for (const node of classNodes) { const nameNode = node.childForFieldName('name'); if (nameNode) { const className = nameNode.text; // Get class members const methods = []; const methodNodes = node.descendantsOfType('method_definition'); for (const methodNode of methodNodes) { const methodNameNode = methodNode.childForFieldName('name'); if (methodNameNode) { methods.push({ name: methodNameNode.text, position: getPosition(methodNode), isStatic: methodNode.childForFieldName('static')?.text === 'static', code: methodNode.text }); } } classes.push({ name: className, position: getPosition(node), methods, code: node.text }); } } // Find imports const importNodes = rootNode.descendantsOfType('import_statement'); for (const node of importNodes) { const sourceNode = node.childForFieldName('source'); if (sourceNode) { const source = sourceNode.text.replace(/['"]/g, ''); const importedItems = []; const specifiers = node.descendantsOfType([ 'import_specifier', 'namespace_import' ]); for (const specNode of specifiers) { if (specNode.type === 'import_specifier') { const nameNode = specNode.childForFieldName('name'); const aliasNode = specNode.childForFieldName('alias'); if (nameNode) { importedItems.push({ name: nameNode.text, alias: aliasNode ? aliasNode.text : null }); } } else if (specNode.type === 'namespace_import') { const nameNode = specNode.childForFieldName('name'); if (nameNode) { importedItems.push({ name: '*', alias: nameNode.text }); } } } // Check for default imports const defaultImportNode = node.descendantsOfType('identifier')[0]; if (defaultImportNode && !specifiers.length) { importedItems.push({ name: 'default', alias: defaultImportNode.text }); } imports.push({ source, items: importedItems, position: getPosition(node), code: node.text }); } } // Find exports const exportNodes = rootNode.descendantsOfType([ 'export_statement', 'lexical_declaration', 'function_declaration' ]); for (const node of exportNodes) { if (node.type === 'export_statement') { const sourceNode = node.childForFieldName('source'); const source = sourceNode ? sourceNode.text.replace(/['"]/g, '') : null; const exportedItems = []; const specifiers = node.descendantsOfType('export_specifier'); for (const specNode of specifiers) { const nameNode = specNode.childForFieldName('name'); const aliasNode = specNode.childForFieldName('alias'); if (nameNode) { exportedItems.push({ name: nameNode.text, alias: aliasNode ? aliasNode.text : null }); } } exports.push({ source, items: exportedItems, isDefault: node.childForFieldName('default')?.text === 'default', position: getPosition(node), code: node.text }); } else { // Check for export modifier on declaration const parent = node.parent; if (parent?.type === 'export_statement') { let name = ''; if (node.type === 'function_declaration') { const nameNode = node.childForFieldName('name'); if (nameNode) name = nameNode.text; } else if (node.type === 'lexical_declaration') { const declarator = node.descendantsOfType('variable_declarator')[0]; if (declarator) { const nameNode = declarator.childForFieldName('name'); if (nameNode) name = nameNode.text; } } if (name) { exports.push({ source: null, items: [{ name, alias: null }], isDefault: parent.childForFieldName('default')?.text === 'default', position: getPosition(parent), code: parent.text }); } } } } } else if (wasmFile === 'tree-sitter-python.wasm') { // Process Python // Find function declarations const functionNodes = rootNode.descendantsOfType('function_definition'); for (const node of functionNodes) { // Get function name let name = 'anonymous'; let parentFunction = null; const nameNode = node.childForFieldName('name'); if (nameNode) name = nameNode.text; // Check if this is a class method const parent = node.parent?.parent; if (parent?.type === 'class_definition') { const classNameNode = parent.childForFieldName('name'); if (classNameNode) parentFunction = classNameNode.text; } functions.push({ name, parent: parentFunction, position: getPosition(node), code: node.text }); } // Find variable assignments (global and class level) const assignmentNodes = rootNode.descendantsOfType('assignment'); for (const node of assignmentNodes) { // Only consider top-level or class-level assignments const parent = node.parent; if (parent?.type === 'module' || parent?.type === 'block' && parent.parent?.type === 'class_definition') { const left = node.childForFieldName('left'); if (left && left.type === 'identifier') { variables.push({ name: left.text, kind: 'var', // Python doesn't have explicit variable declarations position: getPosition(node), code: node.text }); } } } // Find class declarations const classNodes = rootNode.descendantsOfType('class_definition'); for (const node of classNodes) { const nameNode = node.childForFieldName('name'); if (nameNode) { const className = nameNode.text; // Get class methods const methods = []; const methodNodes = node.descendantsOfType('function_definition'); for (const methodNode of methodNodes) { const methodNameNode = methodNode.childForFieldName('name'); if (methodNameNode) { // Check if method is static (has @staticmethod decorator) let isStatic = false; const decorators = methodNode.childForFieldName('decorator_list'); if (decorators) { const decoratorNodes = decorators.children; for (const decorator of decoratorNodes) { if (decorator.text === '@staticmethod') { isStatic = true; break; } } } methods.push({ name: methodNameNode.text, position: getPosition(methodNode), isStatic, code: methodNode.text }); } } classes.push({ name: className, position: getPosition(node), methods, code: node.text }); } } // Find imports const importNodes = rootNode.descendantsOfType(['import_statement', 'import_from_statement']); for (const node of importNodes) { if (node.type === 'import_statement') { // Case: import module [as alias] const namesNode = node.childForFieldName('names'); if (namesNode) { const importedModules = namesNode.descendantsOfType('dotted_name'); for (const moduleNode of importedModules) { const moduleName = moduleNode.text; const aliasNode = moduleNode.nextNamedSibling; imports.push({ source: moduleName, items: [{ name: 'module', alias: aliasNode ? aliasNode.text : null }], position: getPosition(node), code: node.text }); } } } else if (node.type === 'import_from_statement') { // Case: from module import name [as alias], ... const moduleNode = node.childForFieldName('module'); const namesNode = node.childForFieldName('names'); if (moduleNode && namesNode) { const moduleName = moduleNode.text; const importedItems = []; const importedNames = namesNode.namedChildren; for (const nameNode of importedNames) { if (nameNode.type === 'aliased_import') { const name = nameNode.childForFieldName('name')?.text; const alias = nameNode.childForFieldName('alias')?.text; if (name) { importedItems.push({ name, alias }); } } else if (nameNode.type === 'identifier') { importedItems.push({ name: nameNode.text, alias: null }); } } imports.push({ source: moduleName, items: importedItems, position: getPosition(node), code: node.text }); } } } } return { functions, variables, classes, imports, exports }; } catch (error) { console.error(`Error parsing ${filePath}: ${error.message}`); return null; } }