code-auditor-mcp 2.6.2 → 3.0.1

package/dist/functionScanner.js

@@ -1,15 +1,34 @@
 /**
  * Function Scanner
  * Scans directories for functions using AST parsing
+ *
+ * ## Migration: TypeScript Compiler API → tree-sitter
+ *
+ * All `ts.Node`/`ts.SourceFile`/`ts.SyntaxKind` usage replaced with tree-sitter `ASTNode`
+ * and adapterBridge utilities. The old `import * as ts from 'typescript'` is removed.
  */
 import { discoverFiles } from './utils/fileDiscovery.js';
-import { parseTypeScriptFile } from './utils/astParser.js';
-import { findNodesByKind, getLineAndColumn } from './utils/astUtils.js';
-import { getImports, getImportsDetailed, extractIdentifierUsage, getReExports } from './utils/astUtils.js';
+import { findNodesByKind, getLineAndColumn, getImports, getImportsDetailed, extractIdentifierUsage, getReExports } from './utils/astUtils.js';
+import { parseFile, walkAST, hasModifier, isExported } from './languages/adapterBridge.js';
 import { isReactComponent, detectComponentType, getComponentName, extractHooks, extractPropTypes } from './utils/reactDetection.js';
 import { buildImportMap, extractFunctionCalls, getLocalFunctionNames, normalizeCallTarget } from './utils/dependencyExtractor.js';
-import * as ts from 'typescript';
+import { readFile } from 'fs/promises';
 import path from 'path';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Get raw text from a tree-sitter node (stored on ASTNode.raw). */
+function rawText(node) {
+    return node.raw?.text ?? '';
+}
+/** Find the first child of a given type. */
+function findChildOfType(node, type) {
+    return node.children?.find(c => c.type === type);
+}
+/** Check if a node type is a variable/lexical declaration. */
+function isVariableDecl(type) {
+    return type === 'lexical_declaration' || type === 'variable_declaration';
+}
 /**
  * Scan directory for functions
  */
@@ -47,27 +66,27 @@ export async function scanDirectoryForFunctions(dirPath, options) {
  */
 export async function extractFunctionsFromFile(filePath, options) {
     const functions = [];
-    // Parse file
-    const parseResult = await parseTypeScriptFile(filePath);
-    if (!parseResult.sourceFile) {
+    // Read content and parse
+    const content = await readFile(filePath, 'utf-8');
+    const ast = parseFile(filePath, content);
+    if (!ast)
         return functions;
-    }
-    const sourceFile = parseResult.sourceFile;
+    const root = ast.root;
     // Get file dependencies
-    const imports = getImports(sourceFile);
+    const imports = getImports(root);
     const dependencies = imports
         .map(imp => imp.moduleSpecifier)
         .filter(spec => !spec.startsWith('.') && !spec.startsWith('/'))
         .filter((v, i, a) => a.indexOf(v) === i); // Unique only
     // Build import map for dependency tracking
-    const importMap = buildImportMap(sourceFile);
-    const detailedImports = getImportsDetailed(sourceFile);
-    const localFunctions = getLocalFunctionNames(sourceFile);
+    const importMap = buildImportMap(root);
+    const detailedImports = getImportsDetailed(root);
+    const localFunctions = getLocalFunctionNames(root);
     // Track import usage across the file
     const importNames = new Set(detailedImports.map(imp => imp.localName));
-    const fileUsageMap = extractIdentifierUsage(sourceFile, sourceFile, importNames);
+    const fileUsageMap = extractIdentifierUsage(root, content, importNames);
     // Track re-exports - these imports are used even if not referenced in code
-    const reExports = getReExports(sourceFile);
+    const reExports = getReExports(root);
     for (const reExport of reExports) {
         // Find imports that match re-exported names
         for (const imp of detailedImports) {
@@ -91,260 +110,263 @@ export async function extractFunctionsFromFile(filePath, options) {
         }
     }
     // Find all function declarations
-    const functionDeclarations = findNodesByKind(sourceFile, ts.SyntaxKind.FunctionDeclaration);
+    const functionDeclarations = findNodesByKind(root, 'function_declaration');
     for (const func of functionDeclarations) {
-        const funcDecl = func;
-        if (funcDecl.name) {
-            const { line } = getLineAndColumn(sourceFile, func.getStart());
+        const nameNode = findChildOfType(func, 'identifier');
+        if (!nameNode)
+            continue;
+        const { line } = getLineAndColumn(func);
+        // Extract function calls
+        const body = findChildOfType(func, 'statement_block');
+        const functionCalls = body ? extractFunctionCalls(body, content, importMap) : [];
+        const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
+        // Track which imports this function uses
+        const functionUsageMap = extractIdentifierUsage(func, content, importNames);
+        const usedImports = Array.from(functionUsageMap.keys());
+        // Apply unused imports configuration
+        const config = options?.unusedImportsConfig;
+        let unusedImports = detailedImports
+            .filter(imp => {
+            // Skip side-effect imports - they're never "unused"
+            if (imp.importType === 'side-effect')
+                return false;
+            // Check if import is used in this function OR at module level
+            if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
+                return false;
+            // Apply type-only configuration
+            if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
+                return false;
+            // Apply ignore patterns
+            if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+                return false;
+            return true;
+        })
+            .map(imp => imp.localName);
+        // Get parameter count from formal_parameters
+        const params = findChildOfType(func, 'formal_parameters');
+        const paramCount = params?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
+        functions.push({
+            name: rawText(nameNode),
+            filePath,
+            lineNumber: line,
+            language: getLanguageFromPath(filePath),
+            dependencies,
+            purpose: `Function ${rawText(nameNode)} implementation`,
+            context: `Located in ${path.basename(filePath)}`,
+            metadata: {
+                kind: 'function',
+                isAsync: hasModifier(func, 'async'),
+                isExported: isExported(func),
+                parameterCount: paramCount,
+                functionCalls: normalizedCalls,
+                usedImports,
+                unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
+                body: body ? rawText(body) : undefined
+            }
+        });
+    }
+    // Find arrow functions assigned to variables
+    const varStmts = [
+        ...findNodesByKind(root, 'lexical_declaration'),
+        ...findNodesByKind(root, 'variable_declaration')
+    ];
+    for (const varStmt of varStmts) {
+        for (const varDecl of varStmt.children ?? []) {
+            if (varDecl.type !== 'variable_declarator')
+                continue;
+            const nameNode = findChildOfType(varDecl, 'identifier');
+            const arrowFunc = varDecl.children?.find(c => c.type === 'arrow_function');
+            if (!nameNode || !arrowFunc)
+                continue;
+            const { line } = getLineAndColumn(varDecl);
             // Extract function calls
-            const functionCalls = funcDecl.body ? extractFunctionCalls(funcDecl.body, sourceFile, importMap) : [];
+            const body = findChildOfType(arrowFunc, 'statement_block');
+            const functionCalls = body ? extractFunctionCalls(body, content, importMap) : [];
             const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
             // Track which imports this function uses
-            const functionUsageMap = funcDecl ?
-                extractIdentifierUsage(funcDecl, sourceFile, importNames) : new Map();
+            const functionUsageMap = extractIdentifierUsage(arrowFunc, content, importNames);
             const usedImports = Array.from(functionUsageMap.keys());
             // Apply unused imports configuration
-            const config = options?.unusedImportsConfig;
+            const fConfig = options?.unusedImportsConfig;
             let unusedImports = detailedImports
                 .filter(imp => {
-                // Skip side-effect imports - they're never "unused"
                 if (imp.importType === 'side-effect')
                     return false;
-                // Check if import is used in this function OR at module level
                 if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
                     return false;
-                // Apply type-only configuration
-                if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
+                if (!fConfig?.includeTypeOnlyImports && imp.isTypeOnly)
                     return false;
-                // Apply ignore patterns
-                if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+                if (fConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
                     return false;
                 return true;
             })
                 .map(imp => imp.localName);
+            const arrowParams = findChildOfType(arrowFunc, 'formal_parameters');
+            const arrowParamCount = arrowParams?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
             functions.push({
-                name: funcDecl.name.text,
+                name: rawText(nameNode),
                 filePath,
                 lineNumber: line,
                 language: getLanguageFromPath(filePath),
                 dependencies,
-                purpose: `Function ${funcDecl.name.text} implementation`,
-                context: `Located in ${path.basename(filePath)}`,
+                purpose: `Arrow function ${rawText(nameNode)}`,
+                context: `Defined in ${path.basename(filePath)}`,
                 metadata: {
-                    kind: 'function',
-                    isAsync: !!funcDecl.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword),
-                    isExported: !!funcDecl.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword),
-                    parameterCount: funcDecl.parameters.length,
+                    kind: 'arrow',
+                    isAsync: hasModifier(arrowFunc, 'async'),
+                    isExported: isExported(varStmt),
+                    parameterCount: arrowParamCount,
                     functionCalls: normalizedCalls,
                     usedImports,
                     unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                    body: funcDecl.body ? funcDecl.body.getText(sourceFile) : undefined
+                    body: body ? rawText(body) : undefined
                 }
             });
         }
     }
-    // Find arrow functions assigned to variables
-    const variableStatements = findNodesByKind(sourceFile, ts.SyntaxKind.VariableStatement);
-    for (const varStmt of variableStatements) {
-        const varDeclarations = varStmt.declarationList.declarations;
-        for (const varDecl of varDeclarations) {
-            if (varDecl.initializer &&
-                varDecl.initializer.kind === ts.SyntaxKind.ArrowFunction &&
-                ts.isIdentifier(varDecl.name)) {
-                const { line } = getLineAndColumn(sourceFile, varDecl.getStart());
-                const arrowFunc = varDecl.initializer;
-                const varStmtNode = varStmt;
-                // Extract function calls
-                const functionCalls = arrowFunc.body ? extractFunctionCalls(arrowFunc.body, sourceFile, importMap) : [];
-                const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
-                // Track which imports this function uses
-                const functionUsageMap = arrowFunc ?
-                    extractIdentifierUsage(arrowFunc, sourceFile, importNames) : new Map();
-                const usedImports = Array.from(functionUsageMap.keys());
-                // Apply unused imports configuration
-                const config = options?.unusedImportsConfig;
-                let unusedImports = detailedImports
-                    .filter(imp => {
-                    // Skip side-effect imports - they're never "unused"
-                    if (imp.importType === 'side-effect')
-                        return false;
-                    // Check if import is used in this function OR at module level
-                    if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
-                        return false;
-                    // Apply type-only configuration
-                    if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
-                        return false;
-                    // Apply ignore patterns
-                    if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
-                        return false;
-                    return true;
-                })
-                    .map(imp => imp.localName);
-                functions.push({
-                    name: varDecl.name.text,
-                    filePath,
-                    lineNumber: line,
-                    language: getLanguageFromPath(filePath),
-                    dependencies,
-                    purpose: `Arrow function ${varDecl.name.text}`,
-                    context: `Defined in ${path.basename(filePath)}`,
-                    metadata: {
-                        kind: 'arrow',
-                        isAsync: arrowFunc.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false,
-                        isExported: varStmtNode.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) || false,
-                        parameterCount: arrowFunc.parameters.length,
-                        functionCalls: normalizedCalls,
-                        usedImports,
-                        unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                        body: arrowFunc.body ? arrowFunc.body.getText(sourceFile) : undefined
-                    }
-                });
-            }
-        }
-    }
     // Find class methods
-    const classDeclarations = findNodesByKind(sourceFile, ts.SyntaxKind.ClassDeclaration);
+    const classDeclarations = findNodesByKind(root, 'class_declaration');
     for (const classDecl of classDeclarations) {
-        const className = classDecl.name?.text || 'AnonymousClass';
-        const methods = classDecl.members.filter(member => member.kind === ts.SyntaxKind.MethodDeclaration);
+        const classNameNode = findChildOfType(classDecl, 'identifier');
+        const className = classNameNode ? rawText(classNameNode) : 'AnonymousClass';
+        const classBody = findChildOfType(classDecl, 'class_body');
+        const methods = classBody?.children?.filter(m => m.type === 'method_definition') ?? [];
         for (const method of methods) {
-            if (ts.isIdentifier(method.name)) {
-                const { line } = getLineAndColumn(sourceFile, method.getStart());
-                // Extract function calls
-                const functionCalls = method.body ? extractFunctionCalls(method.body, sourceFile, importMap) : [];
-                const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
-                // Track which imports this method uses
-                const functionUsageMap = method ?
-                    extractIdentifierUsage(method, sourceFile, importNames) : new Map();
-                const usedImports = Array.from(functionUsageMap.keys());
-                // Apply unused imports configuration
-                const config = options?.unusedImportsConfig;
-                let unusedImports = detailedImports
-                    .filter(imp => {
-                    // Skip side-effect imports - they're never "unused"
-                    if (imp.importType === 'side-effect')
-                        return false;
-                    // Check if import is used in this method OR at module level
-                    if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
-                        return false;
-                    // Apply type-only configuration
-                    if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
-                        return false;
-                    // Apply ignore patterns
-                    if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
-                        return false;
-                    return true;
-                })
-                    .map(imp => imp.localName);
+            const methodNameNode = findChildOfType(method, 'identifier');
+            if (!methodNameNode)
+                continue;
+            const { line } = getLineAndColumn(method);
+            // Extract function calls
+            const body = findChildOfType(method, 'statement_block');
+            const functionCalls = body ? extractFunctionCalls(body, content, importMap) : [];
+            const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
+            // Track which imports this method uses
+            const functionUsageMap = extractIdentifierUsage(method, content, importNames);
+            const usedImports = Array.from(functionUsageMap.keys());
+            // Apply unused imports configuration
+            const mConfig = options?.unusedImportsConfig;
+            let unusedImports = detailedImports
+                .filter(imp => {
+                if (imp.importType === 'side-effect')
+                    return false;
+                if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
+                    return false;
+                if (!mConfig?.includeTypeOnlyImports && imp.isTypeOnly)
+                    return false;
+                if (mConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+                    return false;
+                return true;
+            })
+                .map(imp => imp.localName);
+            const methodParams = findChildOfType(method, 'formal_parameters');
+            const methodParamCount = methodParams?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
+            functions.push({
+                name: `${className}.${rawText(methodNameNode)}`,
+                filePath,
+                lineNumber: line,
+                language: getLanguageFromPath(filePath),
+                dependencies,
+                purpose: `Method ${rawText(methodNameNode)} of class ${className}`,
+                context: `Class method in ${path.basename(filePath)}`,
+                metadata: {
+                    kind: 'method',
+                    className,
+                    isAsync: hasModifier(method, 'async'),
+                    isStatic: hasModifier(method, 'static'),
+                    isPrivate: hasModifier(method, 'private'),
+                    parameterCount: methodParamCount,
+                    functionCalls: normalizedCalls,
+                    usedImports,
+                    unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
+                    body: body ? rawText(body) : undefined
+                }
+            });
+        }
+    }
+    // Check if this is a React file and scan for components
+    if (filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ||
+        (filePath.endsWith('.js') && dependencies.includes('react'))) {
+        // Walk all nodes for React components
+        walkAST(root, (node) => {
+            if (!isReactComponent(node))
+                return;
+            const componentType = detectComponentType(node);
+            if (!componentType)
+                return;
+            const componentName = getComponentName(node);
+            const { line } = getLineAndColumn(node);
+            const endLine = node.location?.end?.line ?? line;
+            // Determine which node to use for prop extraction
+            // For arrow functions, use the parent variable declarator
+            let nodeForProps = node;
+            if (node.type === 'arrow_function' &&
+                node.parent && (node.parent.type === 'variable_declarator' ||
+                isVariableDecl(node.parent.type))) {
+                nodeForProps = node.parent;
+            }
+            // Track which imports this component uses
+            const componentUsageMap = extractIdentifierUsage(node, content, importNames);
+            const usedImports = Array.from(componentUsageMap.keys());
+            // Apply unused imports configuration
+            const cConfig = options?.unusedImportsConfig;
+            let unusedImports = detailedImports
+                .filter(imp => {
+                if (imp.importType === 'side-effect')
+                    return false;
+                if (componentUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
+                    return false;
+                if (!cConfig?.includeTypeOnlyImports && imp.isTypeOnly)
+                    return false;
+                if (cConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+                    return false;
+                return true;
+            })
+                .map(imp => imp.localName);
+            // Check if we already indexed this as a regular function
+            const existingFunc = functions.find(f => f.name === componentName && f.lineNumber === line);
+            if (existingFunc) {
+                // Update the existing function with component metadata
+                existingFunc.purpose = `React ${componentType} component`;
+                existingFunc.metadata = {
+                    ...existingFunc.metadata,
+                    entityType: 'component',
+                    componentType,
+                    props: extractPropTypes(nodeForProps),
+                    hooks: extractHooks(node),
+                    jsxElements: extractJSXElements(node),
+                    isExported: isComponentExported(node),
+                    complexity: calculateComponentComplexity(node),
+                    body: getComponentBody(node)
+                };
+            }
+            else {
+                // Add new component
                 functions.push({
-                    name: `${className}.${method.name.text}`,
+                    name: componentName,
                     filePath,
                     lineNumber: line,
+                    startLine: line,
+                    endLine,
                     language: getLanguageFromPath(filePath),
                     dependencies,
-                    purpose: `Method ${method.name.text} of class ${className}`,
-                    context: `Class method in ${path.basename(filePath)}`,
+                    purpose: `React ${componentType} component`,
+                    context: `Located in ${path.basename(filePath)}`,
                     metadata: {
-                        kind: 'method',
-                        className,
-                        isAsync: !!method.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword),
-                        isStatic: !!method.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword),
-                        isPrivate: !!method.modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword),
-                        parameterCount: method.parameters.length,
-                        functionCalls: normalizedCalls,
-                        usedImports,
-                        unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                        body: method.body ? method.body.getText(sourceFile) : undefined
-                    }
-                });
-            }
-        }
-    }
-    // Check if this is a React file and scan for components
-    if (filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ||
-        (filePath.endsWith('.js') && dependencies.includes('react'))) {
-        // Check all nodes for React components
-        const checkNode = (node) => {
-            if (isReactComponent(node)) {
-                const componentType = detectComponentType(node);
-                const componentName = getComponentName(node);
-                const { line } = getLineAndColumn(sourceFile, node.getStart());
-                const endLine = getLineAndColumn(sourceFile, node.getEnd()).line;
-                // Skip if we already indexed this as a regular function
-                if (functions.some(f => f.name === componentName && f.lineNumber === line)) {
-                    // Update the existing function with component metadata
-                    const existingFunc = functions.find(f => f.name === componentName && f.lineNumber === line);
-                    existingFunc.purpose = `React ${componentType} component`;
-                    // For arrow functions, we need to check the parent variable declaration for types
-                    let nodeForProps = node;
-                    if (ts.isArrowFunction(node) && ts.isVariableDeclaration(node.parent)) {
-                        nodeForProps = node.parent;
-                    }
-                    existingFunc.metadata = {
-                        ...existingFunc.metadata,
                         entityType: 'component',
                         componentType,
-                        props: extractPropTypes(nodeForProps, sourceFile),
-                        hooks: extractHooks(node, sourceFile),
+                        props: extractPropTypes(nodeForProps),
+                        hooks: extractHooks(node),
                         jsxElements: extractJSXElements(node),
                         isExported: isComponentExported(node),
                         complexity: calculateComponentComplexity(node),
-                        body: getComponentBody(node, sourceFile)
-                    };
-                }
-                else {
-                    // Track which imports this component uses
-                    const componentUsageMap = extractIdentifierUsage(node, sourceFile, importNames);
-                    const usedImports = Array.from(componentUsageMap.keys());
-                    // Apply unused imports configuration
-                    const config = options?.unusedImportsConfig;
-                    let unusedImports = detailedImports
-                        .filter(imp => {
-                        // Skip side-effect imports - they're never "unused"
-                        if (imp.importType === 'side-effect')
-                            return false;
-                        // Check if import is used in this component OR at module level
-                        if (componentUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
-                            return false;
-                        // Apply type-only configuration
-                        if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
-                            return false;
-                        // Apply ignore patterns
-                        if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
-                            return false;
-                        return true;
-                    })
-                        .map(imp => imp.localName);
-                    // Add new component
-                    functions.push({
-                        name: componentName,
-                        filePath,
-                        lineNumber: line,
-                        startLine: line,
-                        endLine: endLine,
-                        language: getLanguageFromPath(filePath),
-                        dependencies,
-                        purpose: `React ${componentType} component`,
-                        context: `Located in ${path.basename(filePath)}`,
-                        metadata: {
-                            entityType: 'component',
-                            componentType,
-                            props: extractPropTypes(node, sourceFile),
-                            hooks: extractHooks(node, sourceFile),
-                            jsxElements: extractJSXElements(node),
-                            isExported: isComponentExported(node),
-                            complexity: calculateComponentComplexity(node),
-                            body: getComponentBody(node, sourceFile),
-                            usedImports,
-                            unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                            calledBy: []
-                        }
-                    });
-                }
+                        body: getComponentBody(node),
+                        usedImports,
+                        unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
+                        calledBy: []
+                    }
+                });
             }
-            ts.forEachChild(node, checkNode);
-        };
-        checkNode(sourceFile);
+        });
     }
     // Add file-level unused import analysis if configured
     if (options?.unusedImportsConfig?.checkLevel === 'file' && functions.length > 0) {
@@ -358,17 +380,14 @@ export async function extractFunctionsFromFile(filePath, options) {
             }
         }
         // Calculate file-level unused imports
-        const config = options.unusedImportsConfig;
+        const flConfig = options.unusedImportsConfig;
         const fileUnusedImports = detailedImports
             .filter(imp => {
-            // Check if import is used anywhere in the file
             if (allUsedImports.has(imp.localName))
                 return false;
-            // Apply type-only configuration
-            if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
+            if (!flConfig?.includeTypeOnlyImports && imp.isTypeOnly)
                 return false;
-            // Apply ignore patterns
-            if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+            if (flConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
                 return false;
             return true;
         })
@@ -394,38 +413,49 @@ export async function extractFunctionsFromFile(filePath, options) {
     }
     return functions;
 }
+// ---------------------------------------------------------------------------
 // Helper functions for React component extraction
+// ---------------------------------------------------------------------------
 function extractJSXElements(node) {
     const elements = new Set();
-    function visit(child) {
-        if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
-            const tagName = ts.isJsxElement(child)
-                ? child.openingElement.tagName
-                : child.tagName;
-            if (ts.isIdentifier(tagName)) {
-                elements.add(tagName.text);
+    walkAST(node, (child) => {
+        if (child.type === 'jsx_element') {
+            const openTag = findChildOfType(child, 'open_tag');
+            if (openTag) {
+                const tagNameNode = openTag.children?.find(c => c.type === 'identifier' || c.type === 'member_expression');
+                if (tagNameNode) {
+                    if (tagNameNode.type === 'identifier') {
+                        elements.add(rawText(tagNameNode));
+                    }
+                    else if (tagNameNode.type === 'member_expression') {
+                        elements.add(rawText(tagNameNode));
+                    }
+                }
             }
-            else if (ts.isPropertyAccessExpression(tagName)) {
-                elements.add(tagName.getText());
+        }
+        else if (child.type === 'jsx_self_closing_element') {
+            const tagNameNode = child.children?.find(c => c.type === 'identifier' || c.type === 'member_expression');
+            if (tagNameNode) {
+                if (tagNameNode.type === 'identifier') {
+                    elements.add(rawText(tagNameNode));
+                }
+                else if (tagNameNode.type === 'member_expression') {
+                    elements.add(rawText(tagNameNode));
+                }
             }
         }
-        ts.forEachChild(child, visit);
-    }
-    ts.forEachChild(node, visit);
+    });
     return Array.from(elements);
 }
 function isComponentExported(node) {
-    // Check for export modifier
-    if (ts.canHaveModifiers(node)) {
-        const modifiers = ts.getModifiers(node);
-        if (modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
-            return true;
-        }
+    // Check for export modifier on the node itself
+    if (isExported(node)) {
+        return true;
     }
     // Check if parent is an export statement
     let parent = node.parent;
     while (parent) {
-        if (ts.isExportAssignment(parent) || ts.isExportDeclaration(parent)) {
+        if (parent.type === 'export_statement' || parent.type === 'export_declaration') {
             return true;
         }
         parent = parent.parent;
@@ -434,29 +464,34 @@ function isComponentExported(node) {
 }
 function calculateComponentComplexity(node) {
     let complexity = 1; // Base complexity
-    function visit(child) {
+    walkAST(node, (child) => {
         // Control flow statements
-        if (ts.isIfStatement(child) || ts.isConditionalExpression(child)) {
+        if (child.type === 'if_statement' || child.type === 'ternary_expression') {
             complexity++;
         }
-        else if (ts.isForStatement(child) || ts.isForInStatement(child) ||
-            ts.isForOfStatement(child) || ts.isWhileStatement(child)) {
+        else if (child.type === 'for_statement' || child.type === 'for_in_statement' ||
+            child.type === 'while_statement') {
             complexity += 2;
         }
-        else if (ts.isSwitchStatement(child)) {
-            complexity += child.caseBlock.clauses.length;
+        else if (child.type === 'switch_statement') {
+            // Count switch_case children in switch body
+            const body = findChildOfType(child, 'switch_body');
+            if (body) {
+                const cases = body.children?.filter(c => c.type === 'switch_case' || c.type === 'switch_default') ?? [];
+                complexity += cases.length;
+            }
         }
         // Callbacks and event handlers
-        if (ts.isCallExpression(child)) {
-            const expression = child.expression;
-            if (ts.isPropertyAccessExpression(expression) &&
-                expression.name.text === 'map') {
-                complexity++;
+        if (child.type === 'call_expression') {
+            const expr = child.children?.[0];
+            if (expr?.type === 'member_expression') {
+                const propNode = expr.children?.[expr.children.length - 1];
+                if (propNode && rawText(propNode) === 'map') {
+                    complexity++;
+                }
             }
         }
-        ts.forEachChild(child, visit);
-    }
-    ts.forEachChild(node, visit);
+    });
     return complexity;
 }
 /**
@@ -488,115 +523,156 @@ export async function scanFunctionsInDirectory(dirPath, options) {
  */
 export class FunctionScanner {
     async scanFunctions(content, filePath, language) {
-        // Parse the content directly
         const functions = [];
-        // Create a TypeScript source file from content
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+        // Parse content directly via tree-sitter
+        const ast = parseFile(filePath, content);
+        if (!ast)
+            return functions;
+        const root = ast.root;
         // Get file dependencies
-        const imports = getImports(sourceFile);
+        const imports = getImports(root);
         const dependencies = imports
             .map(imp => imp.moduleSpecifier)
             .filter(spec => !spec.startsWith('.') && !spec.startsWith('/'))
             .filter((v, i, a) => a.indexOf(v) === i); // Unique only
+        // Build import map for dependency tracking
+        const importMap = buildImportMap(root);
         // Find all function declarations
-        const functionDeclarations = findNodesByKind(sourceFile, ts.SyntaxKind.FunctionDeclaration);
-        for (const func of functionDeclarations) {
-            const funcNode = func;
-            if (!funcNode.name)
+        for (const func of findNodesByKind(root, 'function_declaration')) {
+            const nameNode = findChildOfType(func, 'identifier');
+            if (!nameNode)
                 continue;
-            const { line } = getLineAndColumn(sourceFile, funcNode.getStart());
+            const { line } = getLineAndColumn(func);
+            const params = findChildOfType(func, 'formal_parameters');
+            const paramCount = params?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
+            // Build signature: text up to the statement block (before first '{' of body)
+            const bodyNode = findChildOfType(func, 'statement_block');
+            const fullText = rawText(func);
+            const signature = fullText.split('{')[0]?.trim() ?? undefined;
             functions.push({
-                name: funcNode.name.text,
-                filePath: filePath,
+                name: rawText(nameNode),
+                filePath,
                 lineNumber: line,
-                language: language,
+                language,
                 dependencies,
-                purpose: `Function ${funcNode.name.text} implementation`,
+                purpose: `Function ${rawText(nameNode)} implementation`,
                 context: `Located in ${path.basename(filePath)}`,
                 metadata: {
                     kind: 'function',
-                    isAsync: !!funcNode.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword),
-                    isExported: !!funcNode.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword),
-                    parameterCount: funcNode.parameters.length
+                    isAsync: hasModifier(func, 'async'),
+                    isExported: isExported(func),
+                    parameterCount: paramCount,
+                    signature,
+                    body: bodyNode ? rawText(bodyNode) : undefined,
                 }
             });
         }
         // Find arrow functions and variable declarations
-        const varDeclarations = findNodesByKind(sourceFile, ts.SyntaxKind.VariableStatement);
-        for (const varStmt of varDeclarations) {
-            const varStmtNode = varStmt;
-            for (const declaration of varStmtNode.declarationList.declarations) {
-                if (declaration.initializer &&
-                    declaration.initializer.kind === ts.SyntaxKind.ArrowFunction &&
-                    ts.isIdentifier(declaration.name)) {
-                    const arrowFunc = declaration.initializer;
-                    const { line } = getLineAndColumn(sourceFile, declaration.getStart());
-                    functions.push({
-                        name: declaration.name.text,
-                        filePath: filePath,
-                        lineNumber: line,
-                        language: language,
-                        dependencies,
-                        purpose: `Arrow function ${declaration.name.text}`,
-                        context: `Defined in ${path.basename(filePath)}`,
-                        metadata: {
-                            kind: 'arrow',
-                            isAsync: !!arrowFunc.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword),
-                            isExported: !!varStmtNode.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword),
-                            parameterCount: arrowFunc.parameters.length
-                        }
-                    });
-                }
+        for (const varStmt of [
+            ...findNodesByKind(root, 'lexical_declaration'),
+            ...findNodesByKind(root, 'variable_declaration')
+        ]) {
+            for (const declaration of varStmt.children ?? []) {
+                if (declaration.type !== 'variable_declarator')
+                    continue;
+                const nameNode = findChildOfType(declaration, 'identifier');
+                const init = declaration.children?.find(c => c.type === 'arrow_function');
+                if (!nameNode || !init)
+                    continue;
+                const { line } = getLineAndColumn(declaration);
+                const arrowParams = findChildOfType(init, 'formal_parameters');
+                const arrowParamCount = arrowParams?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
+                const fullText = rawText(init);
+                const signature = fullText.split('{')[0]?.trim() ?? undefined;
+                const bodyNode = findChildOfType(init, 'statement_block');
+                functions.push({
+                    name: rawText(nameNode),
+                    filePath,
+                    lineNumber: line,
+                    language,
+                    dependencies,
+                    purpose: `Arrow function ${rawText(nameNode)}`,
+                    context: `Defined in ${path.basename(filePath)}`,
+                    metadata: {
+                        kind: 'arrow',
+                        isAsync: hasModifier(init, 'async'),
+                        isExported: isExported(varStmt),
+                        parameterCount: arrowParamCount,
+                        signature,
+                        body: bodyNode ? rawText(bodyNode) : undefined,
+                    }
+                });
             }
         }
         // Find class methods
-        const classDeclarations = findNodesByKind(sourceFile, ts.SyntaxKind.ClassDeclaration);
-        for (const classDecl of classDeclarations) {
-            const classNode = classDecl;
-            if (!classNode.name)
+        for (const classDecl of findNodesByKind(root, 'class_declaration')) {
+            const nameNode = findChildOfType(classDecl, 'identifier');
+            if (!nameNode)
                 continue;
-            const className = classNode.name.text;
-            for (const member of classNode.members) {
-                if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
-                    const method = member;
-                    const { line } = getLineAndColumn(sourceFile, method.getStart());
-                    functions.push({
-                        name: `${className}.${method.name.text}`,
-                        filePath: filePath,
-                        lineNumber: line,
-                        language: language,
-                        dependencies,
-                        purpose: `Method ${method.name.text} of class ${className}`,
-                        context: `Class method in ${path.basename(filePath)}`,
-                        metadata: {
-                            kind: 'method',
-                            className,
-                            isAsync: !!method.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword),
-                            isStatic: !!method.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword),
-                            isPrivate: !!method.modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword),
-                            parameterCount: method.parameters.length
-                        }
-                    });
-                }
+            const className = rawText(nameNode);
+            const classBody = findChildOfType(classDecl, 'class_body');
+            for (const member of classBody?.children ?? []) {
+                if (member.type !== 'method_definition')
+                    continue;
+                const mNameNode = findChildOfType(member, 'identifier');
+                if (!mNameNode)
+                    continue;
+                const { line } = getLineAndColumn(member);
+                const methodParams = findChildOfType(member, 'formal_parameters');
+                const methodParamCount = methodParams?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
+                const fullText = rawText(member);
+                const signature = fullText.split('{')[0]?.trim() ?? undefined;
+                const bodyNode = findChildOfType(member, 'statement_block');
+                functions.push({
+                    name: `${className}.${rawText(mNameNode)}`,
+                    filePath,
+                    lineNumber: line,
+                    language,
+                    dependencies,
+                    purpose: `Method ${rawText(mNameNode)} of class ${className}`,
+                    context: `Class method in ${path.basename(filePath)}`,
+                    metadata: {
+                        kind: 'method',
+                        className,
+                        isAsync: hasModifier(member, 'async'),
+                        isStatic: hasModifier(member, 'static'),
+                        isPrivate: hasModifier(member, 'private'),
+                        parameterCount: methodParamCount,
+                        signature,
+                        body: bodyNode ? rawText(bodyNode) : undefined,
+                    }
+                });
             }
         }
         return functions;
     }
 }
+// ---------------------------------------------------------------------------
 // Helper function to get component body
-function getComponentBody(node, sourceFile) {
-    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
-        return node.body ? node.body.getText(sourceFile) : undefined;
+// ---------------------------------------------------------------------------
+function getComponentBody(node) {
+    if (node.type === 'function_declaration' || node.type === 'function_expression') {
+        const body = findChildOfType(node, 'statement_block');
+        return body ? rawText(body) : undefined;
     }
-    else if (ts.isArrowFunction(node)) {
-        return node.body ? node.body.getText(sourceFile) : undefined;
+    else if (node.type === 'arrow_function') {
+        const body = findChildOfType(node, 'statement_block');
+        return body ? rawText(body) : undefined;
     }
-    else if (ts.isClassDeclaration(node)) {
+    else if (node.type === 'class_declaration') {
         // For class components, get the render method body
-        const renderMethod = node.members.find(member => ts.isMethodDeclaration(member) &&
-            member.name && ts.isIdentifier(member.name) &&
-            member.name.text === 'render');
-        return renderMethod?.body ? renderMethod.body.getText(sourceFile) : undefined;
+        const classBody = findChildOfType(node, 'class_body');
+        if (!classBody)
+            return undefined;
+        for (const member of classBody.children ?? []) {
+            if (member.type !== 'method_definition')
+                continue;
+            const mNameNode = findChildOfType(member, 'identifier');
+            if (mNameNode && rawText(mNameNode) === 'render') {
+                const body = findChildOfType(member, 'statement_block');
+                return body ? rawText(body) : undefined;
+            }
+        }
     }
     return undefined;
 }