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;
    }
  }