code-auditor-mcp 2.6.2 → 3.0.1

package/dist/languages/go/GoAdapter.js

@@ -1,360 +1,639 @@
 /**
- * Go Language Adapter
- * Provides Go language support for the universal analyzer system
+ * Go language adapter using tree-sitter-go WASM parser.
+ *
+ * Provides real AST-based analysis for Go source files. Replaces the previous
+ * regex-based stub that returned empty arrays for most queries.
  */
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-export class GoAdapter {
+import { getParser } from '../tree-sitter/parser.js';
+import { toASTNode, toSourceLocation } from '../tree-sitter/converter.js';
+// ---------------------------------------------------------------------------
+// Source code storage
+// ---------------------------------------------------------------------------
+const sourceCodeMap = new WeakMap();
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+export class TreeSitterGoAdapter {
     name = 'go';
     fileExtensions = ['.go'];
-    /**
-     * Parse Go source code into an AST
-     */
-    async parse(filePath, content) {
-        try {
-            console.error('[DEBUG] Go: Parsing file:', filePath);
-            // For now, create a simple AST structure
-            // TODO: Implement actual Go parser integration
-            const ast = {
-                root: this.createSimpleGoAST(content, filePath),
-                language: 'go',
-                filePath,
-                errors: []
-            };
-            console.error('[DEBUG] Go: AST created successfully');
-            return ast;
-        }
-        catch (error) {
-            console.error('[DEBUG] Go: Parse error:', error);
-            return {
-                root: {
-                    type: 'Program',
-                    range: [0, content.length],
-                    location: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-                    raw: null
-                },
-                language: 'go',
-                filePath,
-                errors: [{
-                        message: error instanceof Error ? error.message : String(error),
-                        location: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-                        severity: 'error'
-                    }]
-            };
-        }
+    // -- File detection -------------------------------------------------------
+    supportsFile(filePath) {
+        return filePath.endsWith('.go');
     }
-    /**
-     * Create a simple Go AST from source code using regex patterns
-     * This is a basic implementation that will be enhanced later
-     */
-    createSimpleGoAST(content, filePath) {
-        const lines = content.split('\n');
-        const children = [];
-        // Extract functions using regex
-        const functionPattern = /^func\s+(\w+)\s*\([^)]*\)\s*(\([^)]*\))?\s*\{/gm;
-        let match;
-        while ((match = functionPattern.exec(content)) !== null) {
-            const functionName = match[1];
-            const startPos = match.index;
-            const startLine = content.substring(0, startPos).split('\n').length;
-            children.push({
-                type: 'FunctionDeclaration',
-                range: [startPos, startPos + match[0].length],
-                location: {
-                    start: { line: startLine, column: 0 },
-                    end: { line: startLine, column: match[0].length }
-                },
-                raw: {
-                    name: functionName,
-                    match: match[0]
-                }
-            });
-        }
-        // Extract structs using regex  
-        const structPattern = /^type\s+(\w+)\s+struct\s*\{/gm;
-        while ((match = structPattern.exec(content)) !== null) {
-            const structName = match[1];
-            const startPos = match.index;
-            const startLine = content.substring(0, startPos).split('\n').length;
-            children.push({
-                type: 'StructDeclaration',
-                range: [startPos, startPos + match[0].length],
-                location: {
-                    start: { line: startLine, column: 0 },
-                    end: { line: startLine, column: match[0].length }
-                },
-                raw: {
-                    name: structName,
-                    match: match[0]
-                }
-            });
-        }
-        // Extract interfaces using regex with member parsing
-        const interfacePattern = /type\s+(\w+)\s+interface\s*\{([\s\S]*?)\}/gm;
-        while ((match = interfacePattern.exec(content)) !== null) {
-            const interfaceName = match[1];
-            const interfaceBody = match[2];
-            const startPos = match.index;
-            const startLine = content.substring(0, startPos).split('\n').length;
-            // Count interface methods - look for method signatures
-            const methodMatches = interfaceBody.match(/^\s*\w+\s*\([^)]*\)\s*(\([^)]*\))?\s*(\w+)?\s*$/gm) || [];
-            const memberCount = methodMatches.length;
-            console.error(`[DEBUG] Go: Interface ${interfaceName} body:`, JSON.stringify(interfaceBody.substring(0, 200)));
-            console.error(`[DEBUG] Go: Interface ${interfaceName} method matches:`, methodMatches.length, methodMatches.slice(0, 3));
-            children.push({
-                type: 'InterfaceDeclaration',
-                range: [startPos, startPos + match[0].length],
-                location: {
-                    start: { line: startLine, column: 0 },
-                    end: { line: startLine, column: match[0].length }
-                },
-                raw: {
-                    name: interfaceName,
-                    match: match[0],
-                    memberCount: memberCount,
-                    methods: methodMatches
-                }
-            });
-        }
-        return {
-            type: 'Program',
-            range: [0, content.length],
-            location: {
-                start: { line: 1, column: 0 },
-                end: { line: lines.length, column: lines[lines.length - 1]?.length || 0 }
-            },
-            children,
-            raw: { content, filePath }
+    // -- 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;
     }
-    /**
-     * Check if this adapter supports a file
-     */
-    supportsFile(filePath) {
-        return this.fileExtensions.some(ext => filePath.endsWith(ext));
-    }
-    // AST Navigation
+    // -- AST Navigation -------------------------------------------------------
     findNodes(ast, pattern) {
         const results = [];
-        this.walkAST(ast.root, node => {
+        this.walk(ast.root, (node) => {
             if (this.matchesPattern(node, pattern)) {
                 results.push(node);
             }
         });
         return results;
     }
-    walkAST(node, callback) {
-        callback(node);
-        if (node.children) {
-            for (const child of node.children) {
-                this.walkAST(child, callback);
-            }
-        }
-    }
-    matchesPattern(node, pattern) {
-        if (pattern.type) {
-            const types = Array.isArray(pattern.type) ? pattern.type : [pattern.type];
-            if (!types.includes(node.type))
-                return false;
-        }
-        return true;
-    }
     getParent(node) {
-        return node.parent || null;
+        return node.parent ?? null;
     }
     getChildren(node) {
-        return node.children || [];
+        return node.children ?? [];
     }
     getSiblings(node) {
-        const parent = this.getParent(node);
-        if (!parent)
+        if (!node.parent?.children)
             return [];
-        return this.getChildren(parent).filter(child => child !== node);
+        return node.parent.children.filter((c) => c !== node);
     }
-    // Node Information
+    // -- Node Information -----------------------------------------------------
     getNodeType(node) {
         return node.type;
     }
     getNodeText(node, sourceCode) {
-        const [start, end] = node.range;
-        return sourceCode.substring(start, end);
+        return sourceCode.slice(node.range[0], node.range[1]);
     }
     getNodeName(node) {
-        if (node.raw && node.raw.name) {
-            return node.raw.name;
-        }
-        return null;
+        return this.extractName(node.raw);
     }
     getNodeLocation(node) {
         return node.location;
     }
-    // Language-Specific Extraction
+    // -- Language-Specific Extraction -----------------------------------------
     extractFunctions(ast) {
-        console.error('[DEBUG] Go: extractFunctions called for:', ast.filePath);
+        const sourceCode = sourceCodeMap.get(ast) ?? '';
         const functions = [];
-        this.walkAST(ast.root, node => {
-            if (this.isFunction(node)) {
-                const func = this.extractFunctionInfo(node);
-                if (func) {
-                    console.error('[DEBUG] Go: Extracted function:', func.name, 'at line', func.location.start.line);
-                    functions.push(func);
-                }
+        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);
             }
         });
-        console.error('[DEBUG] Go: Total functions extracted:', functions.length);
         return functions;
     }
-    extractFunctionInfo(node) {
-        if (!this.isFunction(node) || !node.raw?.name)
-            return null;
-        return {
-            name: node.raw.name,
-            parameters: [], // TODO: Parse parameters from function signature
-            returnType: 'unknown', // TODO: Parse return type
-            location: node.location,
-            isAsync: false, // Go doesn't have async/await like JS
-            isExported: this.isExportedFunction(node.raw.name),
-            isMethod: false, // TODO: Detect if this is a method (has receiver)
-            className: undefined, // TODO: Extract receiver type for methods
-            jsDoc: undefined // Go uses different comment format
-        };
-    }
-    isExportedFunction(name) {
-        // In Go, exported functions start with uppercase letter
-        return name.length > 0 && name[0] === name[0].toUpperCase();
-    }
     extractClasses(ast) {
-        console.error('[DEBUG] Go: extractClasses called (Note: Go uses structs, not classes)');
-        const structs = [];
-        this.walkAST(ast.root, node => {
-            if (this.isStruct(node)) {
-                const struct = this.extractStructInfo(node);
-                if (struct) {
-                    structs.push(struct);
+        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);
                 }
             }
         });
-        console.error('[DEBUG] Go: Total structs extracted:', structs.length);
-        return structs;
-    }
-    extractStructInfo(node) {
-        if (!this.isStruct(node) || !node.raw?.name)
-            return null;
-        return {
-            name: node.raw.name,
-            location: node.location,
-            methods: [], // TODO: Extract methods associated with this struct
-            properties: [], // TODO: Extract struct fields
-            extends: undefined, // Go doesn't have inheritance
-            implements: [], // TODO: Check if struct implements interfaces
-            isAbstract: false, // Go doesn't have abstract structs
-            isExported: this.isExportedStruct(node.raw.name),
-            jsDoc: undefined
-        };
-    }
-    isExportedStruct(name) {
-        return name.length > 0 && name[0] === name[0].toUpperCase();
+        return classes;
     }
     extractImports(ast) {
-        console.error('[DEBUG] Go: extractImports called');
         const imports = [];
-        // TODO: Parse Go import statements
-        // Go imports look like: import "fmt" or import ( "fmt" "os" )
-        console.error('[DEBUG] Go: Total imports extracted:', imports.length);
+        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) {
-        console.error('[DEBUG] Go: extractExports called');
-        // Go doesn't have explicit exports - exported items are those starting with uppercase
-        return [];
-    }
-    // Optional interface extraction for SOLID analysis
-    extractInterfaces(ast) {
-        console.error('[DEBUG] Go: extractInterfaces called for:', ast.filePath);
-        const interfaces = [];
-        this.walkAST(ast.root, node => {
-            if (this.isInterface(node)) {
-                const iface = this.extractInterfaceInfo(node);
-                if (iface) {
-                    console.error('[DEBUG] Go: Extracted interface:', iface.name, 'with', iface.members?.length, 'members');
-                    interfaces.push(iface);
+        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,
+                    });
                 }
             }
-        });
-        console.error('[DEBUG] Go: Total interfaces extracted:', interfaces.length);
-        return interfaces;
-    }
-    extractInterfaceInfo(node) {
-        if (!this.isInterface(node) || !node.raw?.name)
-            return null;
-        // Create member objects from the parsed methods
-        const members = [];
-        if (node.raw.methods && Array.isArray(node.raw.methods)) {
-            for (let i = 0; i < node.raw.methods.length; i++) {
-                members.push({
-                    name: `method${i + 1}`, // Simple naming since we can't parse method names easily with regex
-                    type: 'method',
-                    location: node.location // Use interface location as approximation
-                });
+            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: node.raw.name,
-            location: node.location,
-            members: members,
-            extends: [], // Go interfaces can embed other interfaces
-            isExported: this.isExportedInterface(node.raw.name)
-        };
-    }
-    isExportedInterface(name) {
-        return name.length > 0 && name[0] === name[0].toUpperCase();
+            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;
     }
-    // Pattern Matching Helpers
+    // -- Pattern Matching Helpers ---------------------------------------------
     isClass(node) {
-        return this.isStruct(node); // In Go, structs are like classes
-    }
-    isStruct(node) {
-        return node.type === 'StructDeclaration';
+        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.type === 'FunctionDeclaration';
+        return node.raw.type === 'function_declaration';
     }
     isMethod(node) {
-        // TODO: Detect methods (functions with receivers)
-        return false;
+        const n = node.raw;
+        if (n.type !== 'function_declaration')
+            return false;
+        return n.childForFieldName?.('receiver') != null;
     }
     isInterface(node) {
-        return node.type === 'InterfaceDeclaration';
+        const n = node.raw;
+        if (n.type === 'type_spec') {
+            const typeNode = n.childForFieldName?.('type');
+            return typeNode?.type === 'interface_type';
+        }
+        return n.type === 'interface_type';
     }
     isImport(node) {
-        return node.type === 'ImportDeclaration';
+        return node.raw.type === 'import_declaration';
     }
     isExport(node) {
-        // Go doesn't have explicit exports
-        return false;
+        return false; // Go has no export keyword
     }
     isLoop(node) {
-        return ['ForStatement', 'RangeStatement'].includes(node.type);
+        return node.raw.type === 'for_statement';
     }
     isConditional(node) {
-        return ['IfStatement', 'SwitchStatement', 'TypeSwitchStatement'].includes(node.type);
+        const t = node.raw.type;
+        return (t === 'if_statement' ||
+            t === 'switch_statement' ||
+            t === 'expression_switch_statement' ||
+            t === 'type_switch_statement');
     }
     isVariableDeclaration(node) {
-        return ['VarDeclaration', 'ConstDeclaration'].includes(node.type);
+        const t = node.raw.type;
+        return (t === 'var_declaration' ||
+            t === 'short_var_declaration' ||
+            t === 'var_spec' ||
+            t === 'const_declaration');
     }
-    // Advanced Features
+    // -- Advanced Features ----------------------------------------------------
     getTypeInfo(node) {
-        // TODO: Extract type information from Go AST
+        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;
     }
     getDocumentation(node) {
-        // TODO: Extract Go comments (// or /* */)
-        return null;
+        return this.extractDocumentation(node.raw);
     }
     getComplexity(node) {
-        // TODO: Calculate complexity based on control flow
-        return 1;
+        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);
+                    }
+                }
+            }
+        });
+        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,
+        }));
+    }
+    // ---------------------------------------------------------------------------
+    // Internal helpers
+    // ---------------------------------------------------------------------------
+    walk(node, visitor) {
+        visitor(node);
+        if (node.children) {
+            for (const child of node.children) {
+                this.walk(child, visitor);
+            }
+        }
+    }
+    walkRaw(node, visitor) {
+        visitor(node);
+        for (const child of node.children) {
+            this.walkRaw(child, visitor);
+        }
+    }
+    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',
+            });
+        }
+        for (const child of node.children) {
+            this.collectErrors(child, errors);
+        }
+    }
+    matchesPattern(node, pattern) {
+        const syntaxNode = node.raw;
+        if (pattern.type !== undefined) {
+            const types = Array.isArray(pattern.type) ? pattern.type : [pattern.type];
+            if (!types.includes(syntaxNode.type))
+                return false;
+        }
+        if (pattern.name !== undefined) {
+            const nodeName = this.extractName(syntaxNode);
+            if (nodeName === null)
+                return false;
+            if (typeof pattern.name === 'string') {
+                if (nodeName !== pattern.name)
+                    return false;
+            }
+            else if (pattern.name instanceof RegExp) {
+                if (!pattern.name.test(nodeName))
+                    return false;
+            }
+        }
+        if (pattern.hasChild !== undefined) {
+            const childNodes = node.children ?? [];
+            if (!childNodes.some((c) => this.matchesPattern(c, pattern.hasChild))) {
+                return false;
+            }
+        }
+        if (pattern.hasParent !== undefined) {
+            if (!node.parent)
+                return false;
+            if (!this.matchesPattern(node.parent, pattern.hasParent))
+                return false;
+        }
+        if (pattern.custom !== undefined) {
+            if (!pattern.custom(node))
+                return false;
+        }
+        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;
+        let myIndex = -1;
+        for (let i = 0; i < siblings.length; i++) {
+            if (siblings[i] === node) {
+                myIndex = i;
+                break;
+            }
+        }
+        if (myIndex === -1)
+            return null;
+        const comments = [];
+        for (let i = myIndex - 1; i >= 0; i--) {
+            const sibling = siblings[i];
+            if (sibling.type === 'comment') {
+                comments.unshift(sibling.text);
+            }
+            else {
+                break;
+            }
+        }
+        if (comments.length === 0)
+            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) => {
+            if (child === node)
+                return;
+            switch (child.type) {
+                case 'if_statement':
+                case 'for_statement':
+                case 'switch_statement':
+                case 'expression_switch_statement':
+                case 'type_switch_statement':
+                case 'select_statement':
+                case 'type_case_clause':
+                case 'expression_case_clause':
+                case 'default_case':
+                case 'communication_case':
+                    complexity++;
+                    break;
+                case 'binary_expression': {
+                    const op = this.getOperator(child);
+                    if (op === '&&' || op === '||')
+                        complexity++;
+                    break;
+                }
+            }
+        });
+        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);
+        const isMethod = node.childForFieldName?.('receiver') != null;
+        const isExported = name ? this.isExportedGo(name) : false;
+        const className = isMethod ? this.getReceiverType(node) : undefined;
+        const returnType = this.getReturnType(node);
+        const jsDoc = this.extractDocumentation(node);
+        const parameters = this.extractParameters(node, sourceCode);
+        return {
+            name: name ?? '<anonymous>',
+            location: toSourceLocation(node),
+            parameters,
+            returnType: returnType ?? undefined,
+            isAsync: false,
+            isExported,
+            isMethod,
+            className,
+            jsDoc: jsDoc ?? undefined,
+        };
+    }
+    buildStructAsClass(_typeSpec, nameNode, typeNode, allFunctions, _sourceCode) {
+        const name = nameNode.text;
+        const isExported = this.isExportedGo(name);
+        const jsDoc = this.extractDocumentation(_typeSpec);
+        // Collect fields as properties
+        const properties = [];
+        for (const field of this.findNamedChildren(typeNode, 'field_declaration')) {
+            const propName = this.extractName(field);
+            const typeNode_ = field.childForFieldName?.('type');
+            if (propName) {
+                properties.push({
+                    name: propName,
+                    type: typeNode_?.text,
+                    visibility: this.isExportedGo(propName) ? 'public' : 'private',
+                    isStatic: false,
+                    isReadonly: false,
+                });
+            }
+        }
+        // Match methods with this receiver type
+        const methods = allFunctions.filter((fn) => fn.className === name || fn.className === `*${name}`);
+        return {
+            name,
+            location: toSourceLocation(nameNode),
+            methods,
+            properties,
+            isAbstract: false,
+            isExported,
+            jsDoc: jsDoc ?? undefined,
+        };
+    }
+    buildImportInfo(spec) {
+        let source = '';
+        let alias;
+        for (const child of spec.namedChildren) {
+            if (child.type === 'interpreted_string_literal' ||
+                child.type === 'raw_string_literal') {
+                source = child.text.slice(1, -1);
+            }
+            else if (child.type === 'package_identifier' ||
+                child.type === 'identifier') {
+                alias = child.text;
+            }
+        }
+        if (!source)
+            return null;
+        return {
+            source,
+            specifiers: [
+                {
+                    name: source,
+                    alias,
+                    isDefault: false,
+                    isNamespace: false,
+                },
+            ],
+            location: toSourceLocation(spec),
+        };
+    }
+    buildInterfaceInfo(nameNode, typeNode) {
+        const name = nameNode.text;
+        const isExported = this.isExportedGo(name);
+        const members = [];
+        for (const member of typeNode.namedChildren) {
+            if (member.type === 'method_spec') {
+                const memberNameNode = member.childForFieldName?.('name');
+                if (memberNameNode) {
+                    members.push({
+                        name: memberNameNode.text,
+                        type: 'method',
+                        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,
+        };
+    }
+    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;
+    }
+    // -- 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;
+            }
+        }
+        return undefined;
+    }
+    getReturnType(node) {
+        if (node.type !== 'function_declaration')
+            return null;
+        const result = node.childForFieldName?.('result');
+        if (result)
+            return result.text.trim();
+        return null;
+    }
+    // -- Tree traversal helpers ------------------------------------------------
+    findNamedChildren(node, type) {
+        return node.namedChildren.filter((c) => c.type === type);
     }
 }
 //# sourceMappingURL=GoAdapter.js.map