code-auditor-mcp 3.10.0 → 4.0.0

package/dist/utils/astUtils.js

@@ -8,14 +8,10 @@
  * The `ts.SourceFile` parameter has been replaced with `ASTNode` (root node).
  * For source-code-dependent operations, `sourceCode: string` is passed separately.
  */
-import { walkAST, findNodes, getNodeText as bridgeGetNodeText, getLineAndColumn as bridgeGetLineAndColumn, isExported as bridgeIsExported, calculateComplexity as bridgeCalculateComplexity, hasModifier, } from '../languages/adapterBridge.js';
+import { walkAST, findNodes, getNodeText, getLineAndColumn as bridgeGetLineAndColumn, isExported as bridgeIsExported, calculateComplexity as bridgeCalculateComplexity, hasModifier, } from '../languages/adapterBridge.js';
 // ---------------------------------------------------------------------------
 // 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);
@@ -37,7 +33,7 @@ export function findNodesByType(root, predicate) {
  * Get the text content of a node.
  * Uses sourceCode if provided; falls back to raw tree-sitter text.
  */
-export { bridgeGetNodeText as getNodeText };
+export { getNodeText };
 // ---------------------------------------------------------------------------
 // Position helpers (re-exports from adapterBridge)
 // ---------------------------------------------------------------------------
@@ -61,7 +57,7 @@ export { bridgeCalculateComplexity as calculateComplexity };
  * Uses tree-sitter import_statement structure:
  *   import_statement → import_clause? → (identifier | named_imports) → string
  */
-export function getImports(root) {
+export function getImports(root, sourceCode) {
     const imports = [];
     const importNodes = findNodes(root, n => n.type === 'import_statement');
     for (const node of importNodes) {
@@ -69,18 +65,18 @@ export function getImports(root) {
         const moduleNode = findChildOfType(node, 'string');
         if (!moduleNode)
             continue;
-        const moduleSpecifier = rawText(moduleNode).replace(/^["']|["']$/g, '');
-        const importedNames = [];
+        const source = getNodeText(moduleNode, sourceCode).replace(/^["']|["']$/g, '');
+        const specifiers = [];
         const importClause = findChildOfType(node, 'import_clause');
-        let isTypeOnly = false;
         if (importClause) {
-            // Check for `type` keyword in import clause
-            const raw = importClause.raw;
-            isTypeOnly = raw?.children?.some(c => !c.isNamed && c.type === 'type') ?? false;
-            // Default import (identifier child of import_clause that's not 'type' modifier)
+            // Default import (identifier child of import_clause that's not the `type` keyword)
             const defaultId = importClause.children?.find(c => c.type === 'identifier');
             if (defaultId) {
-                importedNames.push(rawText(defaultId));
+                specifiers.push({
+                    name: getNodeText(defaultId, sourceCode),
+                    isDefault: true,
+                    isNamespace: false,
+                });
             }
             // Named imports
             const namedImports = findChildOfType(importClause, 'named_imports');
@@ -88,10 +84,17 @@ export function getImports(root) {
                 for (const child of namedImports.children ?? []) {
                     if (child.type !== 'import_specifier')
                         continue;
-                    // The identifier children — last one is the local name
+                    // import { name } / { name as alias } / { default as name }
                     const ids = child.children?.filter(c => c.type === 'identifier') ?? [];
                     if (ids.length > 0) {
-                        importedNames.push(rawText(ids[ids.length - 1]));
+                        const imported = getNodeText(ids[0], sourceCode);
+                        const local = getNodeText(ids[ids.length - 1], sourceCode);
+                        specifiers.push({
+                            name: local,
+                            alias: imported !== local ? imported : undefined,
+                            isDefault: imported === 'default',
+                            isNamespace: false,
+                        });
                     }
                 }
             }
@@ -100,12 +103,15 @@ export function getImports(root) {
             if (namespaceImport) {
                 const nsId = findChildOfType(namespaceImport, 'identifier');
                 if (nsId) {
-                    importedNames.push(`* as ${rawText(nsId)}`);
+                    specifiers.push({
+                        name: getNodeText(nsId, sourceCode),
+                        isDefault: false,
+                        isNamespace: true,
+                    });
                 }
             }
         }
-        const { line } = bridgeGetLineAndColumn(node);
-        imports.push({ moduleSpecifier, importedNames, isTypeOnly, line });
+        imports.push({ source, specifiers, location: node.location });
     }
     return imports;
 }
@@ -116,15 +122,14 @@ export function getImports(root) {
  * Extract export statements from an AST root node.
  * Uses tree-sitter export_statement structure.
  */
-export function getExports(root) {
+export function getExports(root, sourceCode) {
     const exports = [];
     // export declarations: export { name1, name2 }
     const exportNodes = findNodes(root, n => n.type === 'export_statement' || n.type === 'export_declaration');
     for (const node of exportNodes) {
         const { line } = bridgeGetLineAndColumn(node);
         // Check for type-only exports
-        const raw = node.raw;
-        const isTypeOnly = raw?.children?.some(c => !c.isNamed && c.type === 'type') ?? false;
+        const isTypeOnly = hasModifier(node, 'type');
         // export clause with named exports
         const exportClause = findChildOfType(node, 'export_clause');
         if (exportClause) {
@@ -136,7 +141,7 @@ export function getExports(root) {
                     const ids = child.children?.filter(c => c.type === 'identifier') ?? [];
                     if (ids.length > 0) {
                         exports.push({
-                            name: rawText(ids[ids.length - 1]),
+                            name: getNodeText(ids[ids.length - 1], sourceCode),
                             isDefault: false,
                             isTypeOnly,
                             line
@@ -146,14 +151,14 @@ export function getExports(root) {
             }
         }
         // Check for `default` keyword — export default X
-        const isDefault = raw?.children?.some(c => !c.isNamed && c.type === 'default') ?? false;
+        const isDefault = hasModifier(node, 'default');
         if (isDefault) {
             const exported = node.children?.find(c => c.type === 'identifier' || c.type === 'function_declaration' ||
                 c.type === 'class_declaration' || c.type === 'call_expression');
             if (exported) {
                 const nameNode = findChildOfType(exported, 'identifier');
                 exports.push({
-                    name: nameNode ? rawText(nameNode) : 'default',
+                    name: nameNode ? getNodeText(nameNode, sourceCode) : 'default',
                     isDefault: true,
                     isTypeOnly,
                     line
@@ -187,11 +192,11 @@ export function findClasses(root) {
 /**
  * Get AST node for inspection/debugging.
  */
-export function getASTNode(node) {
+export function getASTNode(node, sourceCode) {
     return {
         type: node.type,
-        text: rawText(node),
-        children: (node.children ?? []).map(child => getASTNode(child))
+        text: getNodeText(node, sourceCode),
+        children: (node.children ?? []).map(child => getASTNode(child, sourceCode))
     };
 }
 // ---------------------------------------------------------------------------
@@ -201,20 +206,20 @@ export function getASTNode(node) {
  * Check if a node has a specific decorator.
  * Tree-sitter parses decorators as `decorator` nodes.
  */
-export function hasDecorator(node, decoratorName) {
+export function hasDecorator(node, decoratorName, sourceCode) {
     const decorators = findNodes(node, n => n.type === 'decorator');
     return decorators.some(decorator => {
         // decorator → call_expression → identifier (e.g., @Component())
         const callExpr = findChildOfType(decorator, 'call_expression');
         if (callExpr) {
             const callee = callExpr.children?.[0];
-            if (callee?.type === 'identifier' && rawText(callee) === decoratorName) {
+            if (callee?.type === 'identifier' && getNodeText(callee, sourceCode) === decoratorName) {
                 return true;
             }
         }
         // decorator → identifier (e.g., @deprecated)
         const id = findChildOfType(decorator, 'identifier');
-        if (id && rawText(id) === decoratorName) {
+        if (id && getNodeText(id, sourceCode) === decoratorName) {
             return true;
         }
         return false;
@@ -227,7 +232,7 @@ export function hasDecorator(node, decoratorName) {
  * Get method names from a class declaration node.
  * Tree-sitter: class_declaration → class_body → method_definition / public_field_definition
  */
-export function getClassMethods(classNode) {
+export function getClassMethods(classNode, sourceCode) {
     const methods = [];
     const classBody = findChildOfType(classNode, 'class_body');
     if (!classBody)
@@ -236,7 +241,7 @@ export function getClassMethods(classNode) {
         if (member.type === 'method_definition' || member.type === 'public_field_definition') {
             const nameNode = member.children?.find(c => c.type === 'identifier' || c.type === 'property_identifier');
             if (nameNode) {
-                methods.push(rawText(nameNode));
+                methods.push(getNodeText(nameNode, sourceCode));
             }
         }
     }
@@ -334,7 +339,7 @@ export async function parseTypeScriptFile(filePath) {
     const ast = parseFile(filePath, content);
     if (!ast) {
         const failLocation = { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } };
-        const failAst = { root: { type: 'source_file', range: [0, 0], location: failLocation, raw: null }, language: 'unknown', filePath, errors: [{ message: 'Failed to parse file', location: failLocation, severity: 'error' }] };
+        const failAst = { root: { type: 'source_file', range: [0, 0], location: failLocation }, language: 'unknown', filePath, errors: [{ message: 'Failed to parse file', location: failLocation, severity: 'error' }] };
         return { ast: failAst, errors: [{ message: 'Failed to parse file', line: 0, column: 0 }] };
     }
     return { ast, errors: ast.errors ?? [] };
@@ -346,14 +351,14 @@ export async function parseTypeScriptFile(filePath) {
  * Enhanced version of getImports that returns detailed ImportMapping[].
  * Uses tree-sitter import_statement traversal.
  */
-export function getImportsDetailed(root) {
+export function getImportsDetailed(root, sourceCode) {
     const imports = [];
     const importNodes = findNodes(root, n => n.type === 'import_statement');
     for (const node of importNodes) {
         const moduleNode = findChildOfType(node, 'string');
         if (!moduleNode)
             continue;
-        const moduleSpecifier = rawText(moduleNode).replace(/^["']|["']$/g, '');
+        const moduleSpecifier = getNodeText(moduleNode, sourceCode).replace(/^["']|["']$/g, '');
         const importClause = findChildOfType(node, 'import_clause');
         if (!importClause) {
             // Side-effect import (no import clause)
@@ -366,13 +371,12 @@ export function getImportsDetailed(root) {
             });
             continue;
         }
-        const raw = importClause.raw;
-        const isTypeOnly = raw?.children?.some(c => !c.isNamed && c.type === 'type') ?? false;
+        const isTypeOnly = hasModifier(importClause, 'type');
         // Default import
         const defaultId = importClause.children?.find(c => c.type === 'identifier');
         if (defaultId) {
             imports.push({
-                localName: rawText(defaultId),
+                localName: getNodeText(defaultId, sourceCode),
                 importedName: 'default',
                 modulePath: moduleSpecifier,
                 importType: 'default',
@@ -388,8 +392,8 @@ export function getImportsDetailed(root) {
                 const identifiers = child.children?.filter(c => c.type === 'identifier') ?? [];
                 if (identifiers.length === 0)
                     continue;
-                const localName = rawText(identifiers[identifiers.length - 1]);
-                const importedName = identifiers.length > 1 ? rawText(identifiers[0]) : localName;
+                const localName = getNodeText(identifiers[identifiers.length - 1], sourceCode);
+                const importedName = identifiers.length > 1 ? getNodeText(identifiers[0], sourceCode) : localName;
                 imports.push({
                     localName,
                     importedName,
@@ -405,7 +409,7 @@ export function getImportsDetailed(root) {
             const nsId = findChildOfType(nsImport, 'identifier');
             if (nsId) {
                 imports.push({
-                    localName: rawText(nsId),
+                    localName: getNodeText(nsId, sourceCode),
                     importedName: '*',
                     modulePath: moduleSpecifier,
                     importType: 'namespace',
@@ -423,7 +427,7 @@ export function getImportsDetailed(root) {
  * Get re-exports from a source file.
  * Tree-sitter: export_statement → string (module specifier).
  */
-export function getReExports(root) {
+export function getReExports(root, sourceCode) {
     const reExports = [];
     const exportNodes = findNodes(root, n => n.type === 'export_statement' || n.type === 'export_declaration');
     for (const node of exportNodes) {
@@ -431,7 +435,7 @@ export function getReExports(root) {
         const moduleNode = findChildOfType(node, 'string');
         if (!moduleNode)
             continue;
-        const moduleSpecifier = rawText(moduleNode).replace(/^["']|["']$/g, '');
+        const moduleSpecifier = getNodeText(moduleNode, sourceCode).replace(/^["']|["']$/g, '');
         const exportClause = findChildOfType(node, 'export_clause');
         if (exportClause) {
             const namedExports = findChildOfType(exportClause, 'named_exports');
@@ -442,8 +446,8 @@ export function getReExports(root) {
                     const identifiers = child.children?.filter(c => c.type === 'identifier') ?? [];
                     if (identifiers.length > 0) {
                         const name = identifiers.length > 1
-                            ? rawText(identifiers[0])
-                            : rawText(identifiers[identifiers.length - 1]);
+                            ? getNodeText(identifiers[0], sourceCode)
+                            : getNodeText(identifiers[identifiers.length - 1], sourceCode);
                         reExports.push({ name, module: moduleSpecifier });
                     }
                 }
@@ -601,8 +605,7 @@ function isTypeOnlyUsage(identifier) {
     if (parent.type === 'generic_type' && parent.children?.[0] === identifier) {
         const heritageClause = parent.parent;
         if (heritageClause?.type === 'heritage_clause') {
-            const raw = heritageClause.raw;
-            const isExtends = raw?.children?.some(c => !c.isNamed && c.type === 'extends');
+            const isExtends = hasModifier(heritageClause, 'extends');
             if (isExtends) {
                 const interfaceNode = heritageClause.parent;
                 if (interfaceNode?.type === 'interface_declaration') {
@@ -617,8 +620,7 @@ function isTypeOnlyUsage(identifier) {
         if (grandParent?.type === 'generic_type') {
             const heritageClause = grandParent.parent;
             if (heritageClause?.type === 'heritage_clause') {
-                const raw = heritageClause.raw;
-                const isExtends = raw?.children?.some(c => !c.isNamed && c.type === 'extends');
+                const isExtends = hasModifier(heritageClause, 'extends');
                 if (isExtends) {
                     const interfaceNode = heritageClause.parent;
                     if (interfaceNode?.type === 'interface_declaration') {
@@ -640,8 +642,7 @@ function isTypeOnlyUsage(identifier) {
         for (const child of parent.children ?? []) {
             if (child.type !== 'heritage_clause')
                 continue;
-            const raw = child.raw;
-            const isImplements = raw?.children?.some(c => !c.isNamed && c.type === 'implements');
+            const isImplements = hasModifier(child, 'implements');
             if (!isImplements)
                 continue;
             for (const typeNode of child.children ?? []) {
@@ -799,7 +800,7 @@ export function extractIdentifierUsage(root, sourceCode, importNames) {
     walkAST(root, (node) => {
         // --- identifiers ---
         if (node.type === 'identifier') {
-            const name = rawText(node);
+            const name = getNodeText(node, sourceCode);
             if (importNames.has(name)) {
                 let shouldCount = true;
                 // Skip if part of an import declaration
@@ -842,16 +843,16 @@ export function extractIdentifierUsage(root, sourceCode, importNames) {
         // --- spread elements ---
         else if (SPREAD_TYPES.has(node.type)) {
             const expr = node.children?.find(c => c.type !== '...');
-            if (expr?.type === 'identifier' && importNames.has(rawText(expr))) {
+            if (expr?.type === 'identifier' && importNames.has(getNodeText(expr, sourceCode))) {
                 const { line } = bridgeGetLineAndColumn(expr);
-                const existing = usageMap.get(rawText(expr)) || {
+                const existing = usageMap.get(getNodeText(expr, sourceCode)) || {
                     usageType: 'direct',
                     usageCount: 0,
                     lineNumbers: [],
                 };
                 existing.usageCount++;
                 existing.lineNumbers.push(line);
-                usageMap.set(rawText(expr), existing);
+                usageMap.set(getNodeText(expr, sourceCode), existing);
             }
         }
         // --- JSX elements: <Button /> or <Button.Primary /> ---
@@ -867,29 +868,29 @@ export function extractIdentifierUsage(root, sourceCode, importNames) {
                 tagNameNode = node.children?.find(c => c.type === 'identifier' || c.type === 'member_expression');
             }
             if (tagNameNode) {
-                if (tagNameNode.type === 'identifier' && importNames.has(rawText(tagNameNode))) {
+                if (tagNameNode.type === 'identifier' && importNames.has(getNodeText(tagNameNode, sourceCode))) {
                     const { line } = bridgeGetLineAndColumn(tagNameNode);
-                    const existing = usageMap.get(rawText(tagNameNode)) || {
+                    const existing = usageMap.get(getNodeText(tagNameNode, sourceCode)) || {
                         usageType: 'direct',
                         usageCount: 0,
                         lineNumbers: [],
                     };
                     existing.usageCount++;
                     existing.lineNumbers.push(line);
-                    usageMap.set(rawText(tagNameNode), existing);
+                    usageMap.set(getNodeText(tagNameNode, sourceCode), existing);
                 }
                 else if (tagNameNode.type === 'member_expression') {
                     const leftmost = tagNameNode.children?.[0];
-                    if (leftmost?.type === 'identifier' && importNames.has(rawText(leftmost))) {
+                    if (leftmost?.type === 'identifier' && importNames.has(getNodeText(leftmost, sourceCode))) {
                         const { line } = bridgeGetLineAndColumn(leftmost);
-                        const existing = usageMap.get(rawText(leftmost)) || {
+                        const existing = usageMap.get(getNodeText(leftmost, sourceCode)) || {
                             usageType: 'direct',
                             usageCount: 0,
                             lineNumbers: [],
                         };
                         existing.usageCount++;
                         existing.lineNumbers.push(line);
-                        usageMap.set(rawText(leftmost), existing);
+                        usageMap.set(getNodeText(leftmost, sourceCode), existing);
                     }
                 }
             }
@@ -898,31 +899,31 @@ export function extractIdentifierUsage(root, sourceCode, importNames) {
         else if (node.type === 'decorator') {
             // decorator → identifier (e.g., @deprecated)
             const id = findChildOfType(node, 'identifier');
-            if (id && importNames.has(rawText(id))) {
+            if (id && importNames.has(getNodeText(id, sourceCode))) {
                 const { line } = bridgeGetLineAndColumn(id);
-                const existing = usageMap.get(rawText(id)) || {
+                const existing = usageMap.get(getNodeText(id, sourceCode)) || {
                     usageType: 'direct',
                     usageCount: 0,
                     lineNumbers: [],
                 };
                 existing.usageCount++;
                 existing.lineNumbers.push(line);
-                usageMap.set(rawText(id), existing);
+                usageMap.set(getNodeText(id, sourceCode), existing);
             }
             // decorator → call_expression → identifier (e.g., @Component())
             const callExpr = findChildOfType(node, 'call_expression');
             if (callExpr) {
                 const callee = callExpr.children?.[0];
-                if (callee?.type === 'identifier' && importNames.has(rawText(callee))) {
+                if (callee?.type === 'identifier' && importNames.has(getNodeText(callee, sourceCode))) {
                     const { line } = bridgeGetLineAndColumn(callee);
-                    const existing = usageMap.get(rawText(callee)) || {
+                    const existing = usageMap.get(getNodeText(callee, sourceCode)) || {
                         usageType: 'direct',
                         usageCount: 0,
                         lineNumbers: [],
                     };
                     existing.usageCount++;
                     existing.lineNumbers.push(line);
-                    usageMap.set(rawText(callee), existing);
+                    usageMap.set(getNodeText(callee, sourceCode), existing);
                 }
             }
         }
@@ -930,44 +931,44 @@ export function extractIdentifierUsage(root, sourceCode, importNames) {
         else if (node.type === 'pair') {
             const key = node.children?.find(c => c.type === 'property_identifier');
             const value = node.children?.find(c => c.type === 'identifier' && c !== key);
-            if (value && importNames.has(rawText(value))) {
+            if (value && importNames.has(getNodeText(value, sourceCode))) {
                 const { line } = bridgeGetLineAndColumn(value);
-                const existing = usageMap.get(rawText(value)) || {
+                const existing = usageMap.get(getNodeText(value, sourceCode)) || {
                     usageType: 'direct',
                     usageCount: 0,
                     lineNumbers: [],
                 };
                 existing.usageCount++;
                 existing.lineNumbers.push(line);
-                usageMap.set(rawText(value), existing);
+                usageMap.set(getNodeText(value, sourceCode), existing);
             }
         }
         // --- Shorthand property assignments: { ComponentA, ComponentB } ---
         else if (node.type === 'shorthand_property_identifier') {
             // The value node is a reference to an imported name
             const ref = node.children?.find(c => c.type === 'identifier');
-            if (ref && importNames.has(rawText(ref))) {
+            if (ref && importNames.has(getNodeText(ref, sourceCode))) {
                 const { line } = bridgeGetLineAndColumn(ref);
-                const existing = usageMap.get(rawText(ref)) || {
+                const existing = usageMap.get(getNodeText(ref, sourceCode)) || {
                     usageType: 'direct',
                     usageCount: 0,
                     lineNumbers: [],
                 };
                 existing.usageCount++;
                 existing.lineNumbers.push(line);
-                usageMap.set(rawText(ref), existing);
+                usageMap.set(getNodeText(ref, sourceCode), existing);
             }
-            else if (ref && importNames.has(rawText(ref))) {
+            else if (ref && importNames.has(getNodeText(ref, sourceCode))) {
                 // shorthand_property_identifier might itself be just text
                 const { line } = bridgeGetLineAndColumn(node);
-                const existing = usageMap.get(rawText(node)) || {
+                const existing = usageMap.get(getNodeText(node, sourceCode)) || {
                     usageType: 'direct',
                     usageCount: 0,
                     lineNumbers: [],
                 };
                 existing.usageCount++;
                 existing.lineNumbers.push(line);
-                usageMap.set(rawText(node), existing);
+                usageMap.set(getNodeText(node, sourceCode), existing);
             }
         }
     });
@@ -980,7 +981,7 @@ export function extractIdentifierUsage(root, sourceCode, importNames) {
  * Check if a function name is defined locally in the file.
  * Uses tree-sitter instead of TS API.
  */
-export function isLocalFunction(name, root) {
+export function isLocalFunction(name, root, sourceCode) {
     let found = false;
     walkAST(root, (node) => {
         if (found)
@@ -988,7 +989,7 @@ export function isLocalFunction(name, root) {
         // function declarations
         if (node.type === 'function_declaration') {
             const nameNode = findChildOfType(node, 'identifier');
-            if (nameNode && rawText(nameNode) === name) {
+            if (nameNode && getNodeText(nameNode, sourceCode) === name) {
                 found = true;
             }
         }
@@ -996,14 +997,14 @@ export function isLocalFunction(name, root) {
         if (node.type === 'variable_declarator') {
             const nameNode = findChildOfType(node, 'identifier');
             const initializer = node.children?.find(c => c.type === 'arrow_function' || c.type === 'function_expression');
-            if (nameNode && initializer && rawText(nameNode) === name) {
+            if (nameNode && initializer && getNodeText(nameNode, sourceCode) === name) {
                 found = true;
             }
         }
         // class declarations
         if (node.type === 'class_declaration') {
             const nameNode = findChildOfType(node, 'identifier');
-            if (nameNode && rawText(nameNode) === name) {
+            if (nameNode && getNodeText(nameNode, sourceCode) === name) {
                 found = true;
             }
         }