code-auditor-mcp 3.4.12 → 3.4.14

package/dist/languages/go/GoAdapter.js

@@ -3,330 +3,156 @@
  *
  * Provides real AST-based analysis for Go source files. Replaces the previous
  * regex-based stub that returned empty arrays for most queries.
+ *
+ * The class is split across a small inheritance chain (Spec-33
+ * interface-segregation): each link contributes a cohesive slice of the
+ * adapter so no single class exceeds the SOLID class-size threshold. The
+ * chain is ordered leaf-first (traversal/name/doc/build helpers) so every
+ * method's callee lives in an ancestor class.
  */
-import { getParser } from '../tree-sitter/parser.js';
+import { getParser, parseWithRecovery } from '../tree-sitter/parser.js';
 import { toASTNode, toSourceLocation } from '../tree-sitter/converter.js';
 // ---------------------------------------------------------------------------
 // Source code storage
 // ---------------------------------------------------------------------------
 const sourceCodeMap = new WeakMap();
 // ---------------------------------------------------------------------------
-// Adapter
+// Traversal + name/documentation + Go-specific helpers slice (leaf helpers,
+// called across later chunks, so they form the base of the chain)
 // ---------------------------------------------------------------------------
-export class TreeSitterGoAdapter {
-    name = 'go';
-    fileExtensions = ['.go'];
-    // -- File detection -------------------------------------------------------
-    supportsFile(filePath) {
-        return filePath.endsWith('.go');
-    }
-    // -- Parsing --------------------------------------------------------------
-    async parse(filePath, content) {
-        const parser = getParser('go');
-        const tree = parser.parse(content);
-        if (!tree)
-            throw new Error(`Failed to parse Go file: ${filePath}`);
-        const errors = [];
-        this.collectErrors(tree.rootNode, errors);
-        const root = toASTNode(tree.rootNode, undefined, 'go');
-        const ast = {
-            root,
-            language: 'go',
-            filePath,
-            errors,
-        };
-        sourceCodeMap.set(ast, content);
-        return ast;
-    }
-    // -- AST Navigation -------------------------------------------------------
-    findNodes(ast, pattern) {
-        const results = [];
-        this.walk(ast.root, (node) => {
-            if (this.matchesPattern(node, pattern)) {
-                results.push(node);
-            }
-        });
-        return results;
-    }
-    getParent(node) {
-        return node.parent ?? null;
-    }
-    getChildren(node) {
-        return node.children ?? [];
-    }
-    getSiblings(node) {
-        if (!node.parent?.children)
-            return [];
-        return node.parent.children.filter((c) => c !== node);
-    }
-    // -- Node Information -----------------------------------------------------
-    getNodeType(node) {
-        return node.type;
-    }
-    getNodeText(node, sourceCode) {
-        return sourceCode.slice(node.range[0], node.range[1]);
-    }
-    getNodeName(node) {
-        return this.extractName(node.raw);
-    }
-    getNodeLocation(node) {
-        return node.location;
-    }
-    // -- Language-Specific Extraction -----------------------------------------
-    extractFunctions(ast) {
-        const sourceCode = sourceCodeMap.get(ast) ?? '';
-        const functions = [];
-        this.walk(ast.root, (astNode) => {
-            const node = astNode.raw;
-            if (node.type === 'function_declaration') {
-                const fn = this.buildFunctionInfo(node, sourceCode);
-                if (fn)
-                    functions.push(fn);
-            }
-        });
-        return functions;
-    }
-    extractClasses(ast) {
-        const sourceCode = sourceCodeMap.get(ast) ?? '';
-        const classes = [];
-        // Collect all function_declarations so we can match methods to structs
-        const allFunctions = this.extractFunctions(ast);
-        this.walk(ast.root, (astNode) => {
-            const node = astNode.raw;
-            if (node.type === 'type_declaration') {
-                const specs = this.findNamedChildren(node, 'type_spec');
-                for (const spec of specs) {
-                    const nameNode = spec.childForFieldName?.('name');
-                    if (!nameNode)
-                        continue;
-                    const typeNode = spec.childForFieldName?.('type');
-                    if (!typeNode || typeNode.type !== 'struct_type')
-                        continue;
-                    const structInfo = this.buildStructAsClass(spec, nameNode, typeNode, allFunctions, sourceCode);
-                    if (structInfo)
-                        classes.push(structInfo);
-                }
-            }
-        });
-        return classes;
-    }
-    extractImports(ast) {
-        const imports = [];
-        this.walk(ast.root, (astNode) => {
-            const node = astNode.raw;
-            if (node.type === 'import_declaration') {
-                for (const spec of node.namedChildren) {
-                    if (spec.type === 'import_spec') {
-                        const imp = this.buildImportInfo(spec);
-                        if (imp)
-                            imports.push(imp);
-                    }
-                }
-            }
-        });
-        return imports;
-    }
-    extractExports(ast) {
-        const exports = [];
-        this.walk(ast.root, (astNode) => {
-            const node = astNode.raw;
-            if (node.type === 'function_declaration') {
-                const name = this.extractName(node);
-                if (name && this.isExportedGo(name)) {
-                    exports.push({
-                        name,
-                        location: toSourceLocation(node),
-                        isDefault: false,
-                    });
-                }
-            }
-            else if (node.type === 'type_declaration') {
-                for (const spec of this.findNamedChildren(node, 'type_spec')) {
-                    const nameNode = spec.childForFieldName?.('name');
-                    if (nameNode && this.isExportedGo(nameNode.text)) {
-                        exports.push({
-                            name: nameNode.text,
-                            location: toSourceLocation(nameNode),
-                            isDefault: false,
-                        });
-                    }
-                }
-            }
-            else if (node.type === 'var_declaration') {
-                for (const spec of this.findNamedChildren(node, 'var_spec')) {
-                    const nameNode = spec.childForFieldName?.('name');
-                    if (nameNode && this.isExportedGo(nameNode.text)) {
-                        exports.push({
-                            name: nameNode.text,
-                            location: toSourceLocation(nameNode),
-                            isDefault: false,
-                        });
-                    }
-                }
+class GoTraversalHelpers {
+    // -- Tree traversal helpers ------------------------------------------------
+    walk(node, visitor) {
+        visitor(node);
+        if (node.children) {
+            for (const child of node.children) {
+                this.walk(child, visitor);
             }
-        });
-        return exports;
-    }
-    // -- Pattern Matching Helpers ---------------------------------------------
-    isClass(node) {
-        const n = node.raw;
-        if (n.type === 'type_spec') {
-            const typeNode = n.childForFieldName?.('type');
-            return typeNode?.type === 'struct_type';
         }
-        return n.type === 'struct_type';
     }
-    isFunction(node) {
-        return node.raw.type === 'function_declaration';
-    }
-    isMethod(node) {
-        const n = node.raw;
-        if (n.type !== 'function_declaration')
-            return false;
-        return n.childForFieldName?.('receiver') != null;
-    }
-    isInterface(node) {
-        const n = node.raw;
-        if (n.type === 'type_spec') {
-            const typeNode = n.childForFieldName?.('type');
-            return typeNode?.type === 'interface_type';
+    walkRaw(node, visitor) {
+        visitor(node);
+        for (const child of node.children) {
+            this.walkRaw(child, visitor);
         }
-        return n.type === 'interface_type';
-    }
-    isImport(node) {
-        return node.raw.type === 'import_declaration';
-    }
-    isExport(node) {
-        return false; // Go has no export keyword
-    }
-    isLoop(node) {
-        return node.raw.type === 'for_statement';
-    }
-    isConditional(node) {
-        const t = node.raw.type;
-        return (t === 'if_statement' ||
-            t === 'switch_statement' ||
-            t === 'expression_switch_statement' ||
-            t === 'type_switch_statement');
-    }
-    isVariableDeclaration(node) {
-        const t = node.raw.type;
-        return (t === 'var_declaration' ||
-            t === 'short_var_declaration' ||
-            t === 'var_spec' ||
-            t === 'const_declaration');
     }
-    // -- Advanced Features ----------------------------------------------------
-    getTypeInfo(node) {
-        const n = node.raw;
-        if (n.type === 'function_declaration') {
-            const result = n.childForFieldName?.('result');
-            if (result)
-                return result.text.trim();
-        }
-        if (n.type === 'var_spec' || n.type === 'const_spec') {
-            const typeNode = n.childForFieldName?.('type');
-            if (typeNode)
-                return typeNode.text.trim();
+    collectErrors(node, errors) {
+        if (node.type === 'ERROR' || node.isError) {
+            errors.push({
+                message: `Parse error near "${node.text.slice(0, 50)}"`,
+                location: toSourceLocation(node),
+                severity: 'error',
+            });
         }
-        if (n.type === 'field_declaration') {
-            const typeNode = n.childForFieldName?.('type');
-            if (typeNode)
-                return typeNode.text.trim();
+        for (const child of node.children) {
+            this.collectErrors(child, errors);
         }
-        return null;
-    }
-    getDocumentation(node) {
-        return this.extractDocumentation(node.raw);
-    }
-    getComplexity(node) {
-        return this.calculateComplexity(node.raw);
     }
-    // -- Optional: Interfaces -------------------------------------------------
-    extractInterfaces(ast) {
-        const interfaces = [];
-        this.walk(ast.root, (astNode) => {
-            const node = astNode.raw;
-            if (node.type === 'type_declaration') {
-                const specs = this.findNamedChildren(node, 'type_spec');
-                for (const spec of specs) {
-                    const nameNode = spec.childForFieldName?.('name');
-                    const typeNode = spec.childForFieldName?.('type');
-                    if (nameNode && typeNode?.type === 'interface_type') {
-                        const ifaceInfo = this.buildInterfaceInfo(nameNode, typeNode);
-                        if (ifaceInfo)
-                            interfaces.push(ifaceInfo);
-                    }
-                }
+    extractName(node) {
+        switch (node.type) {
+            case 'function_declaration':
+            case 'type_spec':
+            case 'field_declaration':
+            case 'method_spec': {
+                const nameNode = node.childForFieldName?.('name');
+                if (nameNode)
+                    return nameNode.text;
+                return null;
             }
-        });
-        return interfaces;
-    }
-    // -- Optional: Raw imports ------------------------------------------------
-    extractRawImports(_filePath, content) {
-        const results = [];
-        const parser = getParser('go');
-        const tree = parser.parse(content);
-        if (!tree)
-            return results;
-        this.walkRaw(tree.rootNode, (node) => {
-            if (node.type === 'import_declaration') {
-                for (const spec of node.namedChildren) {
-                    if (spec.type === 'import_spec') {
-                        for (const child of spec.namedChildren) {
-                            if (child.type === 'interpreted_string_literal' ||
-                                child.type === 'raw_string_literal') {
-                                results.push({
-                                    moduleSpecifier: child.text.slice(1, -1),
-                                    isStatic: true,
-                                    isDynamic: false,
-                                    isRequire: false,
-                                    line: child.startPosition.row,
-                                });
-                            }
-                        }
+            case 'import_spec': {
+                const nameNode = node.childForFieldName?.('name');
+                if (nameNode)
+                    return nameNode.text;
+                for (const child of node.namedChildren) {
+                    if (child.type === 'interpreted_string_literal' ||
+                        child.type === 'raw_string_literal') {
+                        return child.text.slice(1, -1);
                     }
                 }
+                return null;
             }
-        });
-        return results;
-    }
-    // -- Optional: Exported symbols -------------------------------------------
-    extractExportedSymbols(ast) {
-        return this.extractExports(ast).map((e) => ({
-            name: e.name,
-            line: e.location.start.line,
-        }));
+            case 'package_identifier':
+            case 'identifier':
+                return node.text;
+            default:
+                return null;
+        }
     }
-    // ---------------------------------------------------------------------------
-    // Internal helpers
-    // ---------------------------------------------------------------------------
-    walk(node, visitor) {
-        visitor(node);
-        if (node.children) {
-            for (const child of node.children) {
-                this.walk(child, visitor);
-            }
+    cleanCommentText(comment) {
+        if (comment.startsWith('/*')) {
+            let inner = comment.slice(2, -2);
+            inner = inner
+                .split('\n')
+                .map((line) => line.replace(/^\s*\*\s?/, ''))
+                .join('\n');
+            return inner.trim();
         }
+        if (comment.startsWith('//')) {
+            return comment.replace(/^\/\/\s*/, '').trim();
+        }
+        return comment.trim();
     }
-    walkRaw(node, visitor) {
-        visitor(node);
+    getOperator(node) {
         for (const child of node.children) {
-            this.walkRaw(child, visitor);
+            if (!child.isNamed &&
+                ['&&', '||', '+', '-', '*', '/', '%', '==', '!='].includes(child.type)) {
+                return child.type;
+            }
         }
+        return null;
     }
-    collectErrors(node, errors) {
-        if (node.type === 'ERROR' || node.isError) {
-            errors.push({
-                message: `Parse error near "${node.text.slice(0, 50)}"`,
-                location: toSourceLocation(node),
-                severity: 'error',
-            });
+    // -- Go-specific helpers ---------------------------------------------------
+    isExportedGo(name) {
+        return name.length > 0 && name[0] === name[0].toUpperCase();
+    }
+    getReceiverType(node) {
+        const receiver = node.childForFieldName?.('receiver');
+        if (!receiver)
+            return undefined;
+        for (const child of receiver.namedChildren) {
+            if (child.type === 'parameter_declaration') {
+                const typeNode = child.childForFieldName?.('type');
+                if (typeNode)
+                    return typeNode.text;
+            }
         }
-        for (const child of node.children) {
-            this.collectErrors(child, errors);
+        return undefined;
+    }
+    getReturnType(node) {
+        if (node.type !== 'function_declaration')
+            return null;
+        const result = node.childForFieldName?.('result');
+        if (result)
+            return result.text.trim();
+        return null;
+    }
+    extractParameters(node, _sourceCode) {
+        const params = [];
+        const paramList = node.childForFieldName?.('parameters');
+        if (!paramList)
+            return params;
+        for (const child of paramList.namedChildren) {
+            if (child.type === 'parameter_declaration') {
+                const nameNode = child.childForFieldName?.('name');
+                const typeNode = child.childForFieldName?.('type');
+                const name = nameNode?.text ?? typeNode?.text ?? child.text;
+                params.push({
+                    name: name || '<unknown>',
+                    type: typeNode?.text,
+                    optional: false,
+                });
+            }
         }
+        return params;
+    }
+    findNamedChildren(node, type) {
+        return node.namedChildren.filter((c) => c.type === type);
     }
+}
+// ---------------------------------------------------------------------------
+// Pattern matching + documentation/complexity + build helpers slice
+// ---------------------------------------------------------------------------
+class GoAnalysis extends GoTraversalHelpers {
     matchesPattern(node, pattern) {
         const syntaxNode = node.raw;
         if (pattern.type !== undefined) {
@@ -365,44 +191,14 @@ export class TreeSitterGoAdapter {
         }
         return true;
     }
-    extractName(node) {
-        switch (node.type) {
-            case 'function_declaration':
-            case 'type_spec':
-            case 'field_declaration':
-            case 'method_spec': {
-                const nameNode = node.childForFieldName?.('name');
-                if (nameNode)
-                    return nameNode.text;
-                return null;
-            }
-            case 'import_spec': {
-                const nameNode = node.childForFieldName?.('name');
-                if (nameNode)
-                    return nameNode.text;
-                for (const child of node.namedChildren) {
-                    if (child.type === 'interpreted_string_literal' ||
-                        child.type === 'raw_string_literal') {
-                        return child.text.slice(1, -1);
-                    }
-                }
-                return null;
-            }
-            case 'package_identifier':
-            case 'identifier':
-                return node.text;
-            default:
-                return null;
-        }
-    }
     extractDocumentation(node) {
         const parent = node.parent;
         if (!parent)
             return null;
-        const siblings = parent.namedChildren;
+        const siblings = parent.children;
         let myIndex = -1;
         for (let i = 0; i < siblings.length; i++) {
-            if (siblings[i] === node) {
+            if (siblings[i].equals(node)) {
                 myIndex = i;
                 break;
             }
@@ -415,7 +211,7 @@ export class TreeSitterGoAdapter {
             if (sibling.type === 'comment') {
                 comments.unshift(sibling.text);
             }
-            else {
+            else if (sibling.isNamed) {
                 break;
             }
         }
@@ -423,20 +219,6 @@ export class TreeSitterGoAdapter {
             return null;
         return this.cleanCommentText(comments.join('\n').trim());
     }
-    cleanCommentText(comment) {
-        if (comment.startsWith('/*')) {
-            let inner = comment.slice(2, -2);
-            inner = inner
-                .split('\n')
-                .map((line) => line.replace(/^\s*\*\s?/, ''))
-                .join('\n');
-            return inner.trim();
-        }
-        if (comment.startsWith('//')) {
-            return comment.replace(/^\/\/\s*/, '').trim();
-        }
-        return comment.trim();
-    }
     calculateComplexity(node) {
         let complexity = 1;
         this.walkRaw(node, (child) => {
@@ -465,15 +247,6 @@ export class TreeSitterGoAdapter {
         });
         return complexity;
     }
-    getOperator(node) {
-        for (const child of node.children) {
-            if (!child.isNamed &&
-                ['&&', '||', '+', '-', '*', '/', '%', '==', '!='].includes(child.type)) {
-                return child.type;
-            }
-        }
-        return null;
-    }
     // -- Build helpers ---------------------------------------------------------
     buildFunctionInfo(node, sourceCode) {
         const name = this.extractName(node);
@@ -495,10 +268,17 @@ export class TreeSitterGoAdapter {
             jsDoc: jsDoc ?? undefined,
         };
     }
-    buildStructAsClass(_typeSpec, nameNode, typeNode, allFunctions, _sourceCode) {
+    buildStructAsClass(_typeSpec, nameNode, typeNode, allFunctions) {
         const name = nameNode.text;
         const isExported = this.isExportedGo(name);
-        const jsDoc = this.extractDocumentation(_typeSpec);
+        // A single `type Foo struct { ... }` declaration carries its doc comment
+        // as a sibling of the enclosing `type_declaration`; a grouped
+        // `type ( ... )` declaration carries it as a sibling of the `type_spec`.
+        // Try the `type_spec` level first, then fall back to the `type_declaration`.
+        let jsDoc = this.extractDocumentation(_typeSpec);
+        if (!jsDoc && _typeSpec.parent?.type === 'type_declaration') {
+            jsDoc = this.extractDocumentation(_typeSpec.parent);
+        }
         // Collect fields as properties
         const properties = [];
         for (const field of this.findNamedChildren(typeNode, 'field_declaration')) {
@@ -569,72 +349,332 @@ export class TreeSitterGoAdapter {
                     });
                 }
             }
-            else if (member.type === 'type_elem') {
-                const embeddedName = member.childForFieldName?.('name')?.text ?? member.text;
-                if (embeddedName) {
-                    members.push({
-                        name: embeddedName,
-                        type: 'property',
-                        location: toSourceLocation(member),
-                    });
+            else if (member.type === 'type_elem') {
+                const embeddedName = member.childForFieldName?.('name')?.text ?? member.text;
+                if (embeddedName) {
+                    members.push({
+                        name: embeddedName,
+                        type: 'property',
+                        location: toSourceLocation(member),
+                    });
+                }
+            }
+        }
+        return {
+            name,
+            location: toSourceLocation(nameNode),
+            members,
+            isExported,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Parsing + AST navigation slice
+// ---------------------------------------------------------------------------
+class GoParserCore extends GoAnalysis {
+    name = 'go';
+    fileExtensions = ['.go'];
+    // -- File detection -------------------------------------------------------
+    supportsFile(filePath) {
+        return filePath.endsWith('.go');
+    }
+    // -- Parsing --------------------------------------------------------------
+    async parse(filePath, content) {
+        const tree = await parseWithRecovery('go', false, content);
+        if (!tree)
+            throw new Error(`Failed to parse Go file: ${filePath}`);
+        const errors = [];
+        this.collectErrors(tree.rootNode, errors);
+        const root = toASTNode(tree.rootNode, undefined, 'go');
+        const ast = {
+            root,
+            language: 'go',
+            filePath,
+            errors,
+            dispose: () => tree.delete(),
+        };
+        sourceCodeMap.set(ast, content);
+        return ast;
+    }
+    // -- AST Navigation -------------------------------------------------------
+    findNodes(ast, pattern) {
+        const results = [];
+        this.walk(ast.root, (node) => {
+            if (this.matchesPattern(node, pattern)) {
+                results.push(node);
+            }
+        });
+        return results;
+    }
+    getParent(node) {
+        return node.parent ?? null;
+    }
+    getChildren(node) {
+        return node.children ?? [];
+    }
+    getSiblings(node) {
+        if (!node.parent?.children)
+            return [];
+        return node.parent.children.filter((c) => c !== node);
+    }
+    // -- Node Information -----------------------------------------------------
+    getNodeType(node) {
+        return node.type;
+    }
+    getNodeText(node, sourceCode) {
+        return sourceCode.slice(node.range[0], node.range[1]);
+    }
+    getNodeName(node) {
+        return this.extractName(node.raw);
+    }
+    getNodeLocation(node) {
+        return node.location;
+    }
+}
+// ---------------------------------------------------------------------------
+// Language-specific extraction slice
+// ---------------------------------------------------------------------------
+class GoExtraction extends GoParserCore {
+    extractFunctions(ast) {
+        const sourceCode = sourceCodeMap.get(ast) ?? '';
+        const functions = [];
+        this.walk(ast.root, (astNode) => {
+            const node = astNode.raw;
+            if (node.type === 'function_declaration') {
+                const fn = this.buildFunctionInfo(node, sourceCode);
+                if (fn)
+                    functions.push(fn);
+            }
+        });
+        return functions;
+    }
+    extractClasses(ast) {
+        const classes = [];
+        // Collect all function_declarations so we can match methods to structs
+        const allFunctions = this.extractFunctions(ast);
+        this.walk(ast.root, (astNode) => {
+            const node = astNode.raw;
+            if (node.type === 'type_declaration') {
+                const specs = this.findNamedChildren(node, 'type_spec');
+                for (const spec of specs) {
+                    const nameNode = spec.childForFieldName?.('name');
+                    if (!nameNode)
+                        continue;
+                    const typeNode = spec.childForFieldName?.('type');
+                    if (!typeNode || typeNode.type !== 'struct_type')
+                        continue;
+                    const structInfo = this.buildStructAsClass(spec, nameNode, typeNode, allFunctions);
+                    if (structInfo)
+                        classes.push(structInfo);
+                }
+            }
+        });
+        return classes;
+    }
+    extractImports(ast) {
+        const imports = [];
+        this.walk(ast.root, (astNode) => {
+            const node = astNode.raw;
+            if (node.type === 'import_declaration') {
+                for (const spec of node.namedChildren) {
+                    if (spec.type === 'import_spec') {
+                        const imp = this.buildImportInfo(spec);
+                        if (imp)
+                            imports.push(imp);
+                    }
+                }
+            }
+        });
+        return imports;
+    }
+    extractExports(ast) {
+        const exports = [];
+        this.walk(ast.root, (astNode) => {
+            const node = astNode.raw;
+            if (node.type === 'function_declaration') {
+                const name = this.extractName(node);
+                if (name && this.isExportedGo(name)) {
+                    exports.push({
+                        name,
+                        location: toSourceLocation(node),
+                        isDefault: false,
+                    });
+                }
+            }
+            else if (node.type === 'type_declaration') {
+                for (const spec of this.findNamedChildren(node, 'type_spec')) {
+                    const nameNode = spec.childForFieldName?.('name');
+                    if (nameNode && this.isExportedGo(nameNode.text)) {
+                        exports.push({
+                            name: nameNode.text,
+                            location: toSourceLocation(nameNode),
+                            isDefault: false,
+                        });
+                    }
                 }
             }
-        }
-        return {
-            name,
-            location: toSourceLocation(nameNode),
-            members,
-            isExported,
-        };
-    }
-    extractParameters(node, _sourceCode) {
-        const params = [];
-        const paramList = node.childForFieldName?.('parameters');
-        if (!paramList)
-            return params;
-        for (const child of paramList.namedChildren) {
-            if (child.type === 'parameter_declaration') {
-                const nameNode = child.childForFieldName?.('name');
-                const typeNode = child.childForFieldName?.('type');
-                const name = nameNode?.text ?? typeNode?.text ?? child.text;
-                params.push({
-                    name: name || '<unknown>',
-                    type: typeNode?.text,
-                    optional: false,
-                });
+            else if (node.type === 'var_declaration') {
+                for (const spec of this.findNamedChildren(node, 'var_spec')) {
+                    const nameNode = spec.childForFieldName?.('name');
+                    if (nameNode && this.isExportedGo(nameNode.text)) {
+                        exports.push({
+                            name: nameNode.text,
+                            location: toSourceLocation(nameNode),
+                            isDefault: false,
+                        });
+                    }
+                }
             }
+        });
+        return exports;
+    }
+}
+// ---------------------------------------------------------------------------
+// Predicates + advanced-features slice
+// ---------------------------------------------------------------------------
+class GoPredicates extends GoExtraction {
+    isClass(node) {
+        const n = node.raw;
+        if (n.type === 'type_spec') {
+            const typeNode = n.childForFieldName?.('type');
+            return typeNode?.type === 'struct_type';
         }
-        return params;
+        return n.type === 'struct_type';
     }
-    // -- Go-specific helpers ---------------------------------------------------
-    isExportedGo(name) {
-        return name.length > 0 && name[0] === name[0].toUpperCase();
+    isFunction(node) {
+        return node.raw.type === 'function_declaration';
     }
-    getReceiverType(node) {
-        const receiver = node.childForFieldName?.('receiver');
-        if (!receiver)
-            return undefined;
-        for (const child of receiver.namedChildren) {
-            if (child.type === 'parameter_declaration') {
-                const typeNode = child.childForFieldName?.('type');
-                if (typeNode)
-                    return typeNode.text;
-            }
+    isMethod(node) {
+        const n = node.raw;
+        if (n.type !== 'function_declaration')
+            return false;
+        return n.childForFieldName?.('receiver') != null;
+    }
+    isInterface(node) {
+        const n = node.raw;
+        if (n.type === 'type_spec') {
+            const typeNode = n.childForFieldName?.('type');
+            return typeNode?.type === 'interface_type';
         }
-        return undefined;
+        return n.type === 'interface_type';
     }
-    getReturnType(node) {
-        if (node.type !== 'function_declaration')
-            return null;
-        const result = node.childForFieldName?.('result');
-        if (result)
-            return result.text.trim();
+    isImport(node) {
+        return node.raw.type === 'import_declaration';
+    }
+    isExport(node) {
+        return false; // Go has no export keyword
+    }
+    isLoop(node) {
+        return node.raw.type === 'for_statement';
+    }
+    isConditional(node) {
+        const t = node.raw.type;
+        return (t === 'if_statement' ||
+            t === 'switch_statement' ||
+            t === 'expression_switch_statement' ||
+            t === 'type_switch_statement');
+    }
+    isVariableDeclaration(node) {
+        const t = node.raw.type;
+        return (t === 'var_declaration' ||
+            t === 'short_var_declaration' ||
+            t === 'var_spec' ||
+            t === 'const_declaration');
+    }
+    // -- Advanced Features ----------------------------------------------------
+    getTypeInfo(node) {
+        const n = node.raw;
+        if (n.type === 'function_declaration') {
+            const result = n.childForFieldName?.('result');
+            if (result)
+                return result.text.trim();
+        }
+        if (n.type === 'var_spec' || n.type === 'const_spec') {
+            const typeNode = n.childForFieldName?.('type');
+            if (typeNode)
+                return typeNode.text.trim();
+        }
+        if (n.type === 'field_declaration') {
+            const typeNode = n.childForFieldName?.('type');
+            if (typeNode)
+                return typeNode.text.trim();
+        }
         return null;
     }
-    // -- Tree traversal helpers ------------------------------------------------
-    findNamedChildren(node, type) {
-        return node.namedChildren.filter((c) => c.type === type);
+    getDocumentation(node) {
+        return this.extractDocumentation(node.raw);
+    }
+    getComplexity(node) {
+        return this.calculateComplexity(node.raw);
+    }
+}
+// ---------------------------------------------------------------------------
+// Optional capabilities slice
+// ---------------------------------------------------------------------------
+class GoOptionalCapabilities extends GoPredicates {
+    extractInterfaces(ast) {
+        const interfaces = [];
+        this.walk(ast.root, (astNode) => {
+            const node = astNode.raw;
+            if (node.type === 'type_declaration') {
+                const specs = this.findNamedChildren(node, 'type_spec');
+                for (const spec of specs) {
+                    const nameNode = spec.childForFieldName?.('name');
+                    const typeNode = spec.childForFieldName?.('type');
+                    if (nameNode && typeNode?.type === 'interface_type') {
+                        const ifaceInfo = this.buildInterfaceInfo(nameNode, typeNode);
+                        if (ifaceInfo)
+                            interfaces.push(ifaceInfo);
+                    }
+                }
+            }
+        });
+        return interfaces;
+    }
+    // -- Optional: Raw imports ------------------------------------------------
+    extractRawImports(_filePath, content) {
+        const results = [];
+        const parser = getParser('go');
+        const tree = parser.parse(content);
+        if (!tree)
+            return results;
+        this.walkRaw(tree.rootNode, (node) => {
+            if (node.type === 'import_declaration') {
+                for (const spec of node.namedChildren) {
+                    if (spec.type === 'import_spec') {
+                        for (const child of spec.namedChildren) {
+                            if (child.type === 'interpreted_string_literal' ||
+                                child.type === 'raw_string_literal') {
+                                results.push({
+                                    moduleSpecifier: child.text.slice(1, -1),
+                                    isStatic: true,
+                                    isDynamic: false,
+                                    isRequire: false,
+                                    line: child.startPosition.row,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        return results;
+    }
+    // -- Optional: Exported symbols -------------------------------------------
+    extractExportedSymbols(ast) {
+        return this.extractExports(ast).map((e) => ({
+            name: e.name,
+            line: e.location.start.line,
+        }));
     }
+}
+// ---------------------------------------------------------------------------
+// Adapter (composes the slices above)
+// ---------------------------------------------------------------------------
+/**
+ * Tree sitter go adapter.
+ */
+export class TreeSitterGoAdapter extends GoOptionalCapabilities {
     // -- String Construction Capabilities (v3.4.7) ----------------------------
     /**
      * Returns true when the node is a dynamically-constructed string in Go:
@@ -642,6 +682,8 @@ export class TreeSitterGoAdapter {
      * - binary_expression with + operator (string concatenation)
      * Plain string literals (interpreted_string_literal, raw_string_literal)
      * are never dynamic.
+     * @param node
+     * @returns
      */
     isDynamicStringConstruction(node) {
         const raw = node.raw;
@@ -653,22 +695,9 @@ export class TreeSitterGoAdapter {
             // fmt.Sprintf("format", args...) — dynamic
             // strings.Join(parts, "sep") — dynamic
             // fmt.Sprint(args...) — dynamic
-            const funcText = func.text;
-            if (funcText === 'fmt.Sprintf' || funcText === 'fmt.Sprintf' ||
-                funcText === 'fmt.Sprint' || funcText === 'fmt.Sprintln' ||
-                funcText === 'fmt.Appendf' || funcText === 'fmt.Appendln' ||
-                funcText === 'fmt.Append' || funcText === 'fmt.Errorf' ||
-                funcText === 'fmt.Fprintf' || funcText === 'fmt.Fprintln' ||
-                funcText === 'fmt.Fprint' || funcText === 'strings.Join' ||
-                funcText === 'fmt.Scanf') {
+            if (isDynamicFormatFunction(func.text)) {
                 return true;
             }
-            // Also check for selector_expression patterns: pkg.Symbol()
-            const selectorMatch = /^(.*?\.)?(Sprintf|Sprintf|Sprint|Sprintln|Join|Appendf|Errorf|Fprintf)$/.test(funcText);
-            if (selectorMatch) {
-                // Verify it's actually fmt.* or strings.*
-                return funcText.startsWith('fmt.') || funcText.startsWith('strings.');
-            }
             // Recurse into arguments: query(fmt.Sprintf(...)) where the outer
             // call isn't itself a format function but passes a dynamic argument.
             for (const child of node.children ?? []) {
@@ -699,74 +728,80 @@ export class TreeSitterGoAdapter {
      * - For fmt.Sprintf: args after the format string are dynamic
      * - For binary +: non-literal operands are dynamic
      * - For strings.Join: the parts slice is dynamic
+     * @param node
+     * @param sourceCode
+     * @returns
      */
     getDynamicParts(node, sourceCode) {
         const raw = node.raw;
         const type = raw.type;
-        const parts = [];
         // For call_expressions that aren't known fmt/strings functions,
         // walk into the first argument that is itself a dynamic string construction.
         if (type === 'call_expression') {
             const funcText = raw.childForFieldName?.('function')?.text ?? '';
             const isKnownFormatter = /^(fmt\.|strings\.)(Sprintf|Fprintf|Errorf|Appendf|Sprint|Sprintln|Append|Appendln|Join|Scanf|Fprint|Fprintln|Sscanf)$/u.test(funcText);
             if (!isKnownFormatter) {
-                for (const child of node.children ?? []) {
-                    if (child.raw.type === 'argument_list') {
-                        for (const arg of child.children ?? []) {
-                            const argType = arg.raw.type;
-                            if (argType === '(' || argType === ')' || argType === ',')
-                                continue;
-                            if (this.isDynamicStringConstruction(arg)) {
-                                return this.getDynamicParts(arg, sourceCode);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if (type === 'call_expression') {
-            const argsNode = raw.childForFieldName?.('arguments');
-            if (!argsNode)
-                return parts;
-            const namedChildren = argsNode.namedChildren;
-            // fmt.Sprintf("format", arg1, arg2...): skip format string (first arg)
-            // strings.Join(parts, "sep"): first arg is dynamic
-            const funcText = raw.childForFieldName?.('function')?.text ?? '';
-            const isFormatFunc = /^fmt\.(Sprintf|Fprintf|Errorf|Appendf)$/u.test(funcText);
-            const startIdx = isFormatFunc ? 1 : 0;
-            for (let i = startIdx; i < namedChildren.length; i++) {
-                const arg = namedChildren[i];
-                const argType = arg.type;
-                // Skip string literals (they're the separator or static parts)
-                if (argType === 'interpreted_string_literal' || argType === 'raw_string_literal')
-                    continue;
-                const text = sourceCode.slice(arg.startIndex, arg.endIndex);
-                const isId = /^[\p{L}_][\p{L}\p{N}_]*$/u.test(text.trim());
-                const idNode = isId ? {
-                    type: argType,
-                    range: [arg.startIndex, arg.endIndex],
-                    location: {
-                        start: { line: arg.startPosition.row, column: arg.startPosition.column },
-                        end: { line: arg.endPosition.row, column: arg.endPosition.column },
-                    },
-                    raw: arg,
-                } : undefined;
-                parts.push({ text: text.trim(), isIdentifier: isId, node: idNode });
+                const arg = this.findFirstDynamicArgument(node);
+                if (arg)
+                    return this.getDynamicParts(arg, sourceCode);
             }
-            return parts;
+            return this.extractCallDynamicParts(raw, sourceCode);
         }
         if (type === 'binary_expression') {
-            for (const child of node.children ?? []) {
-                const childType = child.raw.type;
-                if (childType === 'interpreted_string_literal' ||
-                    childType === 'raw_string_literal' ||
-                    childType === '+')
+            return extractBinaryDynamicParts(node, sourceCode);
+        }
+        return [];
+    }
+    /**
+     * Finds the first argument of a call_expression that is itself a dynamic
+     * string construction, or null if none exists.
+     */
+    findFirstDynamicArgument(node) {
+        for (const child of node.children ?? []) {
+            if (child.raw.type !== 'argument_list')
+                continue;
+            for (const arg of child.children ?? []) {
+                const argType = arg.raw.type;
+                if (argType === '(' || argType === ')' || argType === ',')
                     continue;
-                const text = sourceCode.slice(child.range[0], child.range[1]);
-                const isId = /^[\p{L}_][\p{L}\p{N}_]*$/u.test(text.trim());
-                parts.push({ text: text.trim(), isIdentifier: isId, node: isId ? child : undefined });
+                if (this.isDynamicStringConstruction(arg))
+                    return arg;
             }
+        }
+        return null;
+    }
+    /**
+     * Extracts dynamic parts from a call_expression's argument list.
+     * fmt.Sprintf("format", arg1...): skips the format string (first arg).
+     * strings.Join(parts, "sep"): first arg is dynamic.
+     */
+    extractCallDynamicParts(raw, sourceCode) {
+        const parts = [];
+        const argsNode = raw.childForFieldName?.('arguments');
+        if (!argsNode)
             return parts;
+        const namedChildren = argsNode.namedChildren;
+        const funcText = raw.childForFieldName?.('function')?.text ?? '';
+        const isFormatFunc = /^fmt\.(Sprintf|Fprintf|Errorf|Appendf)$/u.test(funcText);
+        const startIdx = isFormatFunc ? 1 : 0;
+        for (let i = startIdx; i < namedChildren.length; i++) {
+            const arg = namedChildren[i];
+            const argType = arg.type;
+            // Skip string literals (they're the separator or static parts)
+            if (argType === 'interpreted_string_literal' || argType === 'raw_string_literal')
+                continue;
+            const text = sourceCode.slice(arg.startIndex, arg.endIndex);
+            const isId = /^[\p{L}_][\p{L}\p{N}_]*$/u.test(text.trim());
+            const idNode = isId ? {
+                type: argType,
+                range: [arg.startIndex, arg.endIndex],
+                location: {
+                    start: { line: arg.startPosition.row, column: arg.startPosition.column },
+                    end: { line: arg.endPosition.row, column: arg.endPosition.column },
+                },
+                raw: arg,
+            } : undefined;
+            parts.push({ text: text.trim(), isIdentifier: isId, node: idNode });
         }
         return parts;
     }
@@ -774,6 +809,10 @@ export class TreeSitterGoAdapter {
      * Resolves a Go local constant declaration for an identifier node.
      * Searches within the enclosing function scope for var/const/:=
      * declarations. Returns null for unresolvable identifiers.
+     * @param ast
+     * @param identifierNode
+     * @param sourceCode
+     * @returns
      */
     resolveLocalConstant(identifierNode, ast, sourceCode) {
         const idName = sourceCode.slice(identifierNode.range[0], identifierNode.range[1]).trim();
@@ -880,4 +919,44 @@ export class TreeSitterGoAdapter {
         return found;
     }
 }
+/**
+ * Whether a call_expression's function name denotes a dynamic string formatter
+ * (fmt.Sprint*, fmt.Errorf, strings.Join, etc.).
+ */
+function isDynamicFormatFunction(funcText) {
+    if (funcText === 'fmt.Sprintf' || funcText === 'fmt.Sprint' ||
+        funcText === 'fmt.Sprintln' || funcText === 'fmt.Appendf' ||
+        funcText === 'fmt.Appendln' || funcText === 'fmt.Append' ||
+        funcText === 'fmt.Errorf' || funcText === 'fmt.Fprintf' ||
+        funcText === 'fmt.Fprintln' || funcText === 'fmt.Fprint' ||
+        funcText === 'strings.Join' || funcText === 'fmt.Scanf') {
+        return true;
+    }
+    // Also check for selector_expression patterns: pkg.Symbol()
+    const selectorMatch = /^(.*?\.)?(Sprintf|Sprint|Sprintln|Join|Appendf|Errorf|Fprintf)$/.test(funcText);
+    if (selectorMatch) {
+        // Verify it's actually fmt.* or strings.*
+        return funcText.startsWith('fmt.') || funcText.startsWith('strings.');
+    }
+    return false;
+}
+/**
+ * Extracts dynamic parts from a Go binary string-concatenation expression
+ * (a + b + c). Non-literal operands are dynamic; literals and the `+` operator
+ * are skipped.
+ */
+function extractBinaryDynamicParts(node, sourceCode) {
+    const parts = [];
+    for (const child of node.children ?? []) {
+        const childType = child.raw.type;
+        if (childType === 'interpreted_string_literal' ||
+            childType === 'raw_string_literal' ||
+            childType === '+')
+            continue;
+        const text = sourceCode.slice(child.range[0], child.range[1]);
+        const isId = /^[\p{L}_][\p{L}\p{N}_]*$/u.test(text.trim());
+        parts.push({ text: text.trim(), isIdentifier: isId, node: isId ? child : undefined });
+    }
+    return parts;
+}
 //# sourceMappingURL=GoAdapter.js.map