@getmikk/core 2.0.13 → 2.0.15

package/src/parser/go/go-extractor.ts

@@ -1,731 +1,304 @@
-import { hashContent } from '../../hash/file-hasher.js'
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { LanguageRegistry } from '../language-registry.js';
+import { BaseExtractor } from '../base-extractor.js';
+import { hashContent } from '../../hash/file-hasher.js';
 import type {
-    ParsedFunction, ParsedClass, ParsedImport, ParsedExport,
-    ParsedParam, ParsedGeneric, ParsedRoute, CallExpression
-} from '../types.js'
-
-// --- Go builtins / keywords to skip when extracting calls -------------------
-const GO_BUILTINS = new Set([
-    'if', 'else', 'for', 'switch', 'select', 'case', 'default', 'break',
-    'continue', 'goto', 'fallthrough', 'return', 'go', 'defer', 'range',
-    'func', 'type', 'var', 'const', 'package', 'import', 'struct', 'interface',
-    'map', 'chan', 'make', 'new', 'len', 'cap', 'append', 'copy', 'delete',
-    'close', 'panic', 'recover', 'print', 'println', 'nil', 'true', 'false',
-    'iota', 'string', 'int', 'int8', 'int16', 'int32', 'int64', 'uint',
-    'uint8', 'uint16', 'uint32', 'uint64', 'uintptr', 'float32', 'float64',
-    'complex64', 'complex128', 'bool', 'byte', 'rune', 'error', 'any',
-])
-
-// --- Route detection patterns (Gin, Echo, Chi, Mux, net/http, Fiber) --------
-type RoutePattern = { re: RegExp; methodGroup: number; pathGroup: number; handlerGroup: number; fixedMethod?: string }
-
-const ROUTE_PATTERNS: RoutePattern[] = [
-    // Gin / Echo / Chi: r.GET("/path", handler)
-    {
-        re: /\b(?:router|r|e|app|v\d*|api|g|group|server)\.(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD|Any|Use)\s*\(\s*"([^"]+)"\s*,\s*([\w.]+)/,
-        methodGroup: 1, pathGroup: 2, handlerGroup: 3,
-    },
-    // Gorilla Mux: r.HandleFunc("/path", handler).Methods("GET")
-    {
-        re: /\b(?:r|router|mux)\.HandleFunc\s*\(\s*"([^"]+)"\s*,\s*([\w.]+).*?\.Methods\s*\(\s*"(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)"/,
-        methodGroup: 3, pathGroup: 1, handlerGroup: 2,
-    },
-    // Gorilla Mux (no Methods): r.HandleFunc("/path", handler)
-    {
-        re: /\b(?:r|router|mux)\.HandleFunc\s*\(\s*"([^"]+)"\s*,\s*([\w.]+)/,
-        methodGroup: -1, pathGroup: 1, handlerGroup: 2, fixedMethod: 'ANY',
-    },
-    // net/http: http.HandleFunc("/path", handler)
-    {
-        re: /http\.HandleFunc\s*\(\s*"([^"]+)"\s*,\s*([\w.]+)/,
-        methodGroup: -1, pathGroup: 1, handlerGroup: 2, fixedMethod: 'ANY',
-    },
-    // Fiber / lowercase Chi: app.Get("/path", handler)
-    {
-        re: /\b(?:app|server)\.(Get|Post|Put|Delete|Patch|Options|Head|Use)\s*\(\s*"([^"]+)"\s*,\s*([\w.]+)/,
-        methodGroup: 1, pathGroup: 2, handlerGroup: 3,
-    },
-]
+    ParsedFile,
+    ParsedFunction,
+    ParsedClass,
+    ParsedImport,
+    ParsedExport,
+    ParsedParam,
+    ParsedGeneric,
+    ParsedRoute,
+    CallExpression,
+    ParsedVariable
+} from '../types.js';
 
 /**
- * GoExtractor -- pure regex + stateful line scanner for .go files.
- * Extracts functions, structs (as classes), imports, exports, and HTTP routes
- * without any external Go AST dependency.
+ * GoExtractor: robust regex-based extractor for Go source.
+ * Handles structs, interfaces, functions, and common routing patterns.
  */
-export class GoExtractor {
-    private readonly lines: string[]
-    private cachedFunctions: ReturnType<typeof this.scanFunctions> | null = null
-
-    constructor(
-        private readonly filePath: string,
-        private readonly content: string,
-    ) {
-        this.lines = content.split('\n')
+export class GoExtractor extends BaseExtractor {
+    async extract(filePath: string, content: string): Promise<ParsedFile> {
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        const worker = new GoExtractorWorker(normalizedPath, content);
+        
+        return {
+            path: normalizedPath,
+            language: 'go',
+            functions: worker.extractFunctions(),
+            classes: worker.extractClasses(),
+            variables: worker.extractVariables(),
+            generics: worker.extractGenerics(),
+            imports: worker.extractImports(),
+            exports: worker.extractExports(),
+            routes: worker.extractRoutes(),
+            calls: worker.extractModuleCalls(),
+            hash: hashContent(content),
+            parsedAt: Date.now()
+        };
     }
 
-    // --- Public API ---------------------------------------------------------
-
-    /** Extract all top-level functions (no receiver) */
-    extractFunctions(): ParsedFunction[] {
-        return this.scanFunctions().filter(f => !f.receiverType)
-            .map(f => this.buildParsedFunction(f))
+    async resolveImports(files: ParsedFile[], _projectRoot: string): Promise<ParsedFile[]> {
+        // Go import resolution is usually handled by the Resolver
+        return files;
     }
+}
 
-    /** Extract structs and interfaces as classes, with their receiver methods */
-    extractClasses(): ParsedClass[] {
-        const allMethods = this.scanFunctions().filter(f => !!f.receiverType)
-
-        // Group methods by receiver type
-        const byReceiver = new Map<string, ReturnType<typeof this.scanFunctions>[number][]>()
-        for (const m of allMethods) {
-            const arr = byReceiver.get(m.receiverType!) ?? []
-            arr.push(m)
-            byReceiver.set(m.receiverType!, arr)
-        }
+class GoExtractorWorker {
+    private nameCounter = new Map<string, number>();
 
-        const classes: ParsedClass[] = []
+    constructor(
+        private readonly filePath: string,
+        private readonly content: string
+    ) {}
+
+    private allocateId(prefix: string, name: string): string {
+        const count = (this.nameCounter.get(name) ?? 0) + 1;
+        this.nameCounter.set(name, count);
+        const suffix = count === 1 ? '' : `#${count}`;
+        return `${prefix}:${this.filePath}:${name}${suffix}`.toLowerCase();
+    }
 
-        // Structs / interfaces declared in this file
-        for (const typeDecl of this.scanTypeDeclarations()) {
-            const methods = byReceiver.get(typeDecl.name) ?? []
-            classes.push({
-                id: `cls:${this.filePath}:${typeDecl.name}`,
-                name: typeDecl.name,
+    extractFunctions(): ParsedFunction[] {
+        const functions: ParsedFunction[] = [];
+        // Pattern: func Name(args) ret { or func (r Receiver) Name(args) ret {
+        const funcRegex = /func\s+(?:\(\s*[^)]+\s*\)\s*)?(\w+)\s*\(([^)]*)\)\s*([^{]*)\{/g;
+        let match;
+        while ((match = funcRegex.exec(this.content)) !== null) {
+            const name = match[1];
+            const params = this.parseParams(match[2]);
+            const returnType = match[3].trim() || 'void';
+            const startLine = this.getLineNumber(match.index);
+            const body = this.extractBracedContent(match.index + match[0].length - 1);
+            
+            functions.push({
+                id: this.allocateId('fn', name),
+                name,
                 file: this.filePath,
-                startLine: typeDecl.startLine,
-                endLine: typeDecl.endLine,
-                isExported: isExported(typeDecl.name),
-                purpose: typeDecl.purpose,
-                methods: methods.map(m => this.buildParsedFunction(m)),
-                properties: [],
-                hash: '',
-            })
-            byReceiver.delete(typeDecl.name)
+                startLine,
+                endLine: this.getLineNumber(match.index + match[0].length + body.length),
+                params,
+                returnType,
+                isExported: /^[A-Z]/.test(name),
+                isAsync: false, // Go uses goroutines, not async keywords
+                calls: this.extractCalls(body),
+                hash: hashContent(body),
+                purpose: this.extractDocComment(match.index),
+                edgeCasesHandled: [],
+                errorHandling: [],
+                detailedLines: []
+            });
         }
+        return functions;
+    }
 
-        // Methods with no matching struct declaration (e.g. declared in another file)
-        for (const [receiverType, methods] of byReceiver) {
+    extractClasses(): ParsedClass[] {
+        const classes: ParsedClass[] = [];
+        // Pattern: type Name struct {
+        const structRegex = /type\s+(\w+)\s+struct\s+\{/g;
+        let match;
+        while ((match = structRegex.exec(this.content)) !== null) {
+            const name = match[1];
+            const startLine = this.getLineNumber(match.index);
+            const body = this.extractBracedContent(match.index + match[0].length - 1);
+            
             classes.push({
-                id: `cls:${this.filePath}:${receiverType}`,
-                name: receiverType,
+                id: this.allocateId('class', name),
+                name,
                 file: this.filePath,
-                startLine: methods[0]?.startLine ?? 0,
-                endLine: methods[methods.length - 1]?.endLine ?? 0,
-                isExported: isExported(receiverType),
-                methods: methods.map(m => this.buildParsedFunction(m)),
-                properties: [],
-                hash: '',
-                purpose: '',
-            })
-        }
-
-        return classes
-    }
-
-    extractImports(): ParsedImport[] {
-        return this.parseImports()
-    }
-
-    extractExports(): ParsedExport[] {
-        const fns = this.scanFunctions()
-        const types = this.scanTypeDeclarations()
-        const exports: ParsedExport[] = []
-
-        for (const fn of fns) {
-            if (isExported(fn.name)) {
-                exports.push({ name: fn.name, type: 'function', file: this.filePath })
-            }
-        }
-        for (const t of types) {
-            if (isExported(t.name)) {
-                exports.push({ name: t.name, type: t.kind === 'interface' ? 'interface' : 'class', file: this.filePath })
-            }
-        }
-
-        return exports
-    }
-
-    extractRoutes(): ParsedRoute[] {
-        const routes: ParsedRoute[] = []
-        for (let i = 0; i < this.lines.length; i++) {
-            const line = this.lines[i]
-            for (const pat of ROUTE_PATTERNS) {
-                const m = pat.re.exec(line)
-                if (!m) continue
-                const method = pat.fixedMethod ?? (pat.methodGroup > 0 ? m[pat.methodGroup].toUpperCase() : 'ANY')
-                routes.push({
-                    method,
-                    path: m[pat.pathGroup],
-                    handler: m[pat.handlerGroup],
-                    middlewares: [],
-                    file: this.filePath,
-                    line: i + 1,
-                })
-            }
+                startLine,
+                endLine: this.getLineNumber(match.index + match[0].length + body.length),
+                methods: [], // Methods are extracted as functions in Go
+                properties: this.parseStructFields(body),
+                isExported: /^[A-Z]/.test(name),
+                hash: hashContent(body),
+                purpose: this.extractDocComment(match.index)
+            });
         }
-        return routes
+        return classes;
     }
 
-    // --- Internal scanning ---------------------------------------------------
-
-    /** Scanned raw function data (before building ParsedFunction) */
-    private scanFunctions(): Array<{
-        name: string
-        receiverType?: string
-        receiverVar?: string
-        paramStr: string
-        returnStr: string
-        startLine: number
-        bodyStart: number
-        endLine: number
-        purpose: string
-    }> {
-        if (this.cachedFunctions) return this.cachedFunctions
-        const results: Array<{
-            name: string
-            receiverType?: string
-            receiverVar?: string
-            paramStr: string
-            returnStr: string
-            startLine: number
-            bodyStart: number
-            endLine: number
-            purpose: string
-        }> = []
-
-        let i = 0
-        while (i < this.lines.length) {
-            const trimmed = this.lines[i].trimStart()
-
-            // Only lines starting with `func`
-            if (!trimmed.startsWith('func ') && !trimmed.startsWith('func\t')) {
-                i++
-                continue
-            }
-
-            const funcLineStart = i
-
-            // Collect signature lines until we find the opening `{`
-            const sigLines: string[] = []
-            let j = i
-            let foundOpen = false
-            while (j < this.lines.length) {
-                sigLines.push(this.lines[j])
-                if (this.lines[j].includes('{')) {
-                    foundOpen = true
-                    break
-                }
-                j++
-            }
-
-            if (!foundOpen) { i++; continue }
-
-            const sigRaw = sigLines.join(' ').replace(/\s+/g, ' ').trim()
-
-            // Parse signature
-            const parsed = parseGoFuncSignature(sigRaw)
-            if (!parsed) { i++; continue }
-
-            // Find body bounds
-            const { bodyEnd } = findBodyBounds(this.lines, j)
-
-            // Extract purpose from leading comment
-            const purpose = extractLeadingComment(this.lines, funcLineStart)
-
-            results.push({
-                ...parsed,
-                startLine: funcLineStart + 1,
-                bodyStart: j + 1,
-                endLine: bodyEnd + 1,
-                purpose,
-            })
-
-            // Skip to after this function
-            i = bodyEnd + 1
-        }
-
-        this.cachedFunctions = results
-        return results
-    }
-
-    /** Build ParsedFunction from scanned raw data */
-    private buildParsedFunction(raw: ReturnType<typeof this.scanFunctions>[number]): ParsedFunction {
-        const name = raw.receiverType ? `${raw.receiverType}.${raw.name}` : raw.name
-        const id = `fn:${this.filePath}:${name}`
-
-        const bodyLines = this.lines.slice(raw.bodyStart - 1, raw.endLine)
-        const hash = hashContent(bodyLines.join('\n'))
-        const calls = extractCallsFromBody(bodyLines, raw.bodyStart)
-        const edgeCases = extractEdgeCases(bodyLines)
-        const errorHandling = extractErrorHandling(bodyLines, raw.bodyStart)
-
-        return {
-            id,
-            name,
-            file: this.filePath,
-            startLine: raw.startLine,
-            endLine: raw.endLine,
-            params: parseGoParams(raw.paramStr),
-            returnType: cleanReturnType(raw.returnStr),
-            isExported: isExported(raw.name),
-            isAsync: false, // Go has goroutines but no async keyword
-            calls,
-            hash,
-            purpose: raw.purpose,
-            edgeCasesHandled: edgeCases,
-            errorHandling,
-            detailedLines: [],
-        }
-    }
-
-    /** Scan for type struct / type interface declarations */
-    private scanTypeDeclarations(): Array<{
-        name: string
-        kind: 'struct' | 'interface'
-        startLine: number
-        endLine: number
-        purpose: string
-    }> {
-        const results: Array<{
-            name: string
-            kind: 'struct' | 'interface'
-            startLine: number
-            endLine: number
-            purpose: string
-        }> = []
-
-        for (let i = 0; i < this.lines.length; i++) {
-            const trimmed = this.lines[i].trim()
-            const m = /^type\s+(\w+)\s+(struct|interface)\s*\{?/.exec(trimmed)
-            if (!m) continue
-
-            const name = m[1]
-            const kind = m[2] as 'struct' | 'interface'
-            const purpose = extractLeadingComment(this.lines, i)
-
-            // Find end of type block
-            const { bodyEnd } = findBodyBounds(this.lines, i)
-            results.push({
+    extractGenerics(): ParsedGeneric[] {
+        const generics: ParsedGeneric[] = [];
+        // Pattern: type Name interface {
+        const interfaceRegex = /type\s+(\w+)\s+interface\s+\{/g;
+        let match;
+        while ((match = interfaceRegex.exec(this.content)) !== null) {
+            const name = match[1];
+            const body = this.extractBracedContent(match.index + match[0].length - 1);
+            generics.push({
+                id: this.allocateId('type', name),
                 name,
-                kind,
-                startLine: i + 1,
-                endLine: bodyEnd + 1,
-                purpose,
-            })
-            // Don't skip — nested types possible, but rare enough to leave sequential
+                type: 'interface',
+                file: this.filePath,
+                startLine: this.getLineNumber(match.index),
+                endLine: this.getLineNumber(match.index + match[0].length + body.length),
+                isExported: /^[A-Z]/.test(name),
+                typeParameters: [],
+                hash: hashContent(body),
+                purpose: this.extractDocComment(match.index)
+            });
         }
-
-        return results
+        return generics;
     }
 
-    /** Parse all import declarations */
-    private parseImports(): ParsedImport[] {
-        const imports: ParsedImport[] = []
-        let i = 0
-        while (i < this.lines.length) {
-            const trimmed = this.lines[i].trim()
-
-            // Block import: import (...)
-            if (trimmed === 'import (' || /^import\s+\($/.test(trimmed)) {
-                i++
-                while (i < this.lines.length) {
-                    const iline = this.lines[i].trim()
-                    if (iline === ')') break
-                    const imp = parseImportLine(iline)
-                    if (imp) imports.push(imp)
-                    i++
+    extractImports(): ParsedImport[] {
+        const imports: ParsedImport[] = [];
+        const importRegex = /import\s+(?:\(\s*([^)]+)\s*\)|"([^"]+)")/g;
+        let match;
+        while ((match = importRegex.exec(this.content)) !== null) {
+            if (match[1]) {
+                const lines = match[1].split('\n');
+                for (const line of lines) {
+                    const parts = line.trim().match(/(?:(\w+)\s+)??"([^"]+)"/);
+                    if (parts) {
+                        imports.push({
+                            source: parts[2],
+                            resolvedPath: '',
+                            names: parts[1] ? [parts[1]] : [],
+                            isDefault: !parts[1],
+                            isDynamic: false
+                        });
+                    }
                 }
-                i++
-                continue
-            }
-
-            // Single import: import "pkg" or import alias "pkg"
-            if (/^import\s+/.test(trimmed)) {
-                const imp = parseImportLine(trimmed.replace(/^import\s+/, ''))
-                if (imp) imports.push(imp)
+            } else {
+                imports.push({
+                    source: match[2],
+                    resolvedPath: '',
+                    names: [],
+                    isDefault: true,
+                    isDynamic: false
+                });
             }
-
-            i++
-        }
-        return imports
-    }
-}
-
-// --- Signature parsing --------------------------------------------------------
-
-interface GoFuncSignature {
-    name: string
-    receiverType?: string
-    receiverVar?: string
-    paramStr: string
-    returnStr: string
-}
-
-/**
- * Find balanced (...) starting from `fromIdx` in `s`.
- * Returns the content between parens and the index of the closing paren.
- * Handles nested parens correctly, so `fn func(int) bool` extracts properly.
- */
-function extractBalancedParens(s: string, fromIdx: number): { content: string; end: number } | null {
-    const start = s.indexOf('(', fromIdx)
-    if (start === -1) return null
-    let depth = 0
-    for (let i = start; i < s.length; i++) {
-        if (s[i] === '(') depth++
-        else if (s[i] === ')') {
-            depth--
-            if (depth === 0) return { content: s.slice(start + 1, i), end: i }
         }
+        return imports;
     }
-    return null
-}
-
-function parseGoFuncSignature(sig: string): GoFuncSignature | null {
-    // Strip leading 'func ' prefix
-    let rest = sig.replace(/^func\s+/, '')
-    let receiverVar: string | undefined
-    let receiverType: string | undefined
 
-    // Method receiver: func (varName *ReceiverType) Name(...)
-    if (rest.startsWith('(')) {
-        const recv = extractBalancedParens(rest, 0)
-        if (!recv) return null
-        const recvMatch = /^(\w+)\s+\*?(\w+)/.exec(recv.content.trim())
-        if (recvMatch) {
-            receiverVar = recvMatch[1]
-            // Strip generic brackets: Stack[T] → Stack
-            receiverType = recvMatch[2].replace(/\[.*$/, '')
-        }
-        rest = rest.slice(recv.end + 1).trimStart()
+    extractExports(): ParsedExport[] {
+        // In Go, any name starting with UpperCase is exported
+        const exports: ParsedExport[] = [];
+        return exports;
     }
 
-    // Function name, optionally with type params: Name[T any]
-    const nameMatch = /^(\w+)\s*(?:\[[^\]]*\])?\s*/.exec(rest)
-    if (!nameMatch) return null
-    const name = nameMatch[1]
-    rest = rest.slice(nameMatch[0].length)
-
-    // Parameter list — uses balanced-paren extraction so func-typed params work
-    const paramsResult = extractBalancedParens(rest, 0)
-    if (!paramsResult) return null
-    const paramStr = paramsResult.content.trim()
-
-    // Return type: everything after params, before trailing `{`
-    const returnStr = rest.slice(paramsResult.end + 1).replace(/\s*\{.*$/, '').trim()
-
-    return { name, receiverType, receiverVar, paramStr, returnStr }
-}
-
-// ─── Parameter parsing ────────────────────────────────────────────────────────
-
-function parseGoParams(paramStr: string): ParsedParam[] {
-    if (!paramStr.trim()) return []
-
-    const params: Array<{ name: string; type: string }> = []
-    const parts = splitTopLevel(paramStr, ',').map(p => p.trim()).filter(Boolean)
-
-    for (const part of parts) {
-        // Variadic: name ...Type
-        const variadicRe = /^(\w+)\s+\.\.\.(.+)$/.exec(part)
-        if (variadicRe) {
-            params.push({ name: variadicRe[1], type: '...' + variadicRe[2].trim() })
-            continue
-        }
-
-        // Named with type: name Type (space-separated, e.g. "ctx context.Context")
-        const namedRe = /^(\w+)\s+(\S.*)$/.exec(part)
-        if (namedRe) {
-            params.push({ name: namedRe[1], type: namedRe[2].trim() })
-            continue
-        }
-
-        // Single token — could be a grouped name (e.g. "first" in "first, last string")
-        // or an unnamed type (e.g. "int" in "(int, string)").
-        // Heuristic: Go builtin types, pointer/slice/qualified types → unnamed; else grouped name.
-        if (looksLikeGoType(part)) {
-            params.push({ name: '_', type: part })
-        } else {
-            params.push({ name: part, type: '' }) // grouped name — back-filled below
+    extractRoutes(): ParsedRoute[] {
+        const routes: ParsedRoute[] = [];
+        // Simplified route detection for common Go frameworks (Gin, Echo, Chi)
+        const routeRegex = /\.(GET|POST|PUT|DELETE|PATCH)\s*\(\s*"([^"]+)"\s*,\s*([\w.]+)/g;
+        let match;
+        while ((match = routeRegex.exec(this.content)) !== null) {
+            routes.push({
+                method: match[1] as any,
+                path: match[2],
+                handler: match[3],
+                middlewares: [],
+                file: this.filePath,
+                line: this.getLineNumber(match.index)
+            });
         }
+        return routes;
     }
 
-    // Back-fill grouped params: "first, last string" → first.type = last.type = "string"
-    // Scan right-to-left: if a param has no type but the next one does, inherit it
-    for (let i = params.length - 2; i >= 0; i--) {
-        if (params[i].type === '' && params[i + 1].type !== '') {
-            params[i].type = params[i + 1].type
-        }
+    extractVariables(): ParsedVariable[] {
+        return [];
     }
 
-    return params.map(p => ({
-        name: p.name || '_',
-        type: p.type || 'any',
-        optional: false,
-    }))
-}
-
-/**
- * Returns true when a bare single-token parameter is a type annotation rather
- * than a parameter name in a grouped declaration like `(first, last string)`.
- */
-function looksLikeGoType(token: string): boolean {
-    if (!token) return false
-    const ch = token[0]
-    // Pointer (*int), slice ([]byte), or channel (chan)
-    if (ch === '*' || ch === '[' || ch === '<') return true
-    // Go builtin types and keywords
-    if (GO_BUILTINS.has(token)) return true
-    // Exported named type (e.g. Context, ResponseWriter)
-    if (ch >= 'A' && ch <= 'Z') return true
-    // Qualified type (e.g. context.Context, http.Request)
-    if (token.includes('.')) return true
-    return false
-}
-
-function cleanReturnType(ret: string): string {
-    // Strip trailing `{`
-    ret = ret.replace(/\s*\{.*$/, '').trim()
-    // Clean up multiple return: (Type1, Type2) → keep as-is for readability
-    return ret
-}
-
-// --- Import line parsing ------------------------------------------------------
-
-function parseImportLine(line: string): ParsedImport | null {
-    const trimmed = line.trim()
-    if (!trimmed || trimmed.startsWith('//')) return null
-
-    // Blank import: _ "pkg"
-    if (/^_\s+"/.test(trimmed)) return null
-
-    // Aliased: alias "pkg"
-    const aliasRe = /^(\w+)\s+"([^"]+)"/.exec(trimmed)
-    if (aliasRe) {
-        const [, alias, pkg] = aliasRe
-        return { source: pkg, resolvedPath: '', names: [alias], isDefault: false, isDynamic: false }
+    extractModuleCalls(): CallExpression[] {
+        return [];
     }
 
-    // Plain: "pkg"
-    const plainRe = /^"([^"]+)"/.exec(trimmed)
-    if (plainRe) {
-        const pkg = plainRe[1]
-        // Package name is the last segment of the import path
-        const name = pkg.split('/').pop() ?? pkg
-        return { source: pkg, resolvedPath: '', names: [name], isDefault: false, isDynamic: false }
+    private parseParams(paramsStr: string): ParsedParam[] {
+        if (!paramsStr.trim()) return [];
+        return paramsStr.split(',').map(p => {
+            const parts = p.trim().split(/\s+/);
+            return {
+                name: parts[0],
+                type: parts[1] || 'any',
+                optional: false
+            };
+        });
     }
 
-    return null
-}
-
-// --- Body analysis ------------------------------------------------------------
-
-/**
- * Statefully track brace depth through content, handling:
- *  - string literals ("...", `...`), rune literals ('.')
- *  - line comments (//)
- *  - block comments (/* ... * /)
- */
-function findBodyBounds(lines: string[], startLine: number): { bodyStart: number; bodyEnd: number } {
-    let braceDepth = 0
-    let bodyStart = -1
-    let inString = false
-    let stringChar = ''
-    let inBlockComment = false
-
-    for (let i = startLine; i < lines.length; i++) {
-        const line = lines[i]
-        let inLineComment = false
-
-        for (let j = 0; j < line.length; j++) {
-            const ch = line[j]
-            const next = line[j + 1]
-
-            if (inLineComment) break
-
-            if (inBlockComment) {
-                if (ch === '*' && next === '/') { inBlockComment = false; j++ }
-                continue
-            }
-
-            if (inString) {
-                if (ch === '\\') { j++; continue } // escape sequence
-                if (ch === stringChar) inString = false
-                continue
-            }
-
-            if (ch === '/' && next === '/') { inLineComment = true; break }
-            if (ch === '/' && next === '*') { inBlockComment = true; j++; continue }
-            if (ch === '"' || ch === '`') {
-                inString = true
-                stringChar = ch
-                continue
-            }
-            if (ch === '\'') {
-                // Go rune literal: consume exactly one character (or escape) then close
-                if (next === '\\') j += 3 // '\n' or '\x00' etc.
-                else j += 2 // 'a'
-                continue
-            }
-
-            if (ch === '{') {
-                if (bodyStart === -1) bodyStart = i
-                braceDepth++
-            } else if (ch === '}') {
-                braceDepth--
-                if (braceDepth === 0 && bodyStart !== -1) {
-                    return { bodyStart, bodyEnd: i }
-                }
+    private parseStructFields(body: string): ParsedVariable[] {
+        const fields: ParsedVariable[] = [];
+        const lines = body.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            const parts = line.split(/\s+/);
+            if (parts.length >= 2 && !line.startsWith('//')) {
+                fields.push({
+                    id: this.allocateId('var', parts[0]),
+                    name: parts[0],
+                    type: parts[1],
+                    file: this.filePath,
+                    line: i + 1, // Approximate
+                    isExported: /^[A-Z]/.test(parts[0])
+                });
             }
         }
+        return fields;
     }
 
-    return { bodyStart: bodyStart === -1 ? startLine : bodyStart, bodyEnd: lines.length - 1 }
-}
-
-function stripStringsAndComments(code: string): string {
-    let out = ''
-    let i = 0
-    let inString = false
-    let stringChar = ''
-    let inBlockComment = false
-
-    while (i < code.length) {
-        const ch = code[i]
-        const next = code[i + 1]
-
-        if (inBlockComment) {
-            if (ch === '*' && next === '/') { inBlockComment = false; i += 2 }
-            else i++
-            continue
-        }
-
-        if (inString) {
-            if (ch === '\\') { i += 2; continue }
-            if (ch === stringChar) { inString = false }
-            i++
-            continue
+    private extractCalls(body: string): CallExpression[] {
+        const calls: CallExpression[] = [];
+        const callRegex = /([\w.]+)\s*\(/g;
+        let match;
+        while ((match = callRegex.exec(body)) !== null) {
+            calls.push({
+                name: match[1],
+                line: this.getLineNumber(match.index),
+                type: match[1].includes('.') ? 'method' : 'function'
+            });
         }
-
-        if (ch === '/' && next === '/') {
-            // Skip to end of line
-            while (i < code.length && code[i] !== '\n') i++
-            continue
-        }
-        if (ch === '/' && next === '*') { inBlockComment = true; i += 2; continue }
-        if (ch === '"' || ch === '`' || ch === '\'') {
-            inString = true
-            stringChar = ch
-            i++
-            continue
-        }
-
-        out += ch
-        i++
+        return calls;
     }
-    return out
-}
 
-function extractCallsFromBody(bodyLines: string[], baseLine: number = 1): CallExpression[] {
-    const code = bodyLines.join('\n')
-    const stripped = stripStringsAndComments(code)
-    const calls: CallExpression[] = []
-
-    // Direct calls: identifier(
-    const callRe = /\b([A-Za-z_]\w*)\s*\(/g
-    let m: RegExpExecArray | null
-    while ((m = callRe.exec(stripped)) !== null) {
-        const name = m[1]
-        if (!GO_BUILTINS.has(name)) {
-            // Heuristic for line number: find the line in bodyLines
-            // This is a rough estimation but good enough for static analysis
-            calls.push({ name, line: baseLine, type: 'function' })
-        }
-    }
-
-    // Method calls: receiver.Method(
-    const methodRe = /\b([A-Za-z_]\w+\.[A-Za-z_]\w*)\s*\(/g
-    while ((m = methodRe.exec(stripped)) !== null) {
-        calls.push({ name: m[1], line: baseLine, type: 'method' })
-    }
-
-    return calls
-}
-
-function extractEdgeCases(bodyLines: string[]): string[] {
-    const edgeCases: string[] = []
-    for (let i = 0; i < bodyLines.length; i++) {
-        const trimmed = bodyLines[i].trim()
-        // if condition followed by return/panic/error
-        const m = /^if\s+(.+?)\s*\{?\s*$/.exec(trimmed)
-        if (m && bodyLines[i + 1]?.trim().match(/^(return|panic|log\.|fmt\.)/)) {
-            edgeCases.push(m[1].trim())
+    private extractBracedContent(startIndex: number): string {
+        let depth = 0;
+        let result = '';
+        for (let i = startIndex; i < this.content.length; i++) {
+            const char = this.content[i];
+            if (char === '{') depth++;
+            if (char === '}') depth--;
+            result += char;
+            if (depth === 0) break;
         }
+        return result;
     }
-    return edgeCases
-}
 
-function extractErrorHandling(bodyLines: string[], baseLineNumber: number): { line: number; type: 'try-catch' | 'throw'; detail: string }[] {
-    const errors: { line: number; type: 'try-catch' | 'throw'; detail: string }[] = []
-    for (let i = 0; i < bodyLines.length; i++) {
-        const trimmed = bodyLines[i].trim()
-        // if err != nil { return ..., err }
-        if (/^if\s+\w*err\w*\s*!=\s*nil/.test(trimmed)) {
-            errors.push({ line: baseLineNumber + i, type: 'try-catch', detail: trimmed })
-        }
-        // panic(...)
-        if (/^panic\(/.test(trimmed)) {
-            errors.push({ line: baseLineNumber + i, type: 'throw', detail: trimmed })
-        }
+    private getLineNumber(offset: number): number {
+        return this.content.substring(0, offset).split('\n').length;
     }
-    return errors
-}
-
-// --- Comment extraction -------------------------------------------------------
 
-function extractLeadingComment(lines: string[], funcLine: number): string {
-    // Scan backwards from funcLine for consecutive comment lines
-    const commentLines: string[] = []
-    let i = funcLine - 1
-    while (i >= 0) {
-        const trimmed = lines[i].trim()
-        if (trimmed.startsWith('//')) {
-            commentLines.unshift(trimmed.replace(/^\/\/\s?/, ''))
-        } else if (trimmed === '') {
-            break
-        } else {
-            break
+    private extractDocComment(offset: number): string {
+        const lines = this.content.substring(0, offset).split('\n');
+        const comments = [];
+        for (let i = lines.length - 2; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (line.startsWith('//')) {
+                comments.unshift(line.replace('//', '').trim());
+            } else if (line === '') {
+                continue;
+            } else {
+                break;
+            }
         }
-        i--
-    }
-    // First meaningful non-divider line
-    for (const line of commentLines) {
-        if (/^[-=*─]{3,}$/.test(line)) continue
-        return line.trim()
+        return comments.join(' ');
     }
-    return ''
 }
 
-// --- Utility helpers ----------------------------------------------------------
-
-function isExported(name: string): boolean {
-    return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase()
-}
-
-/** Split string by delimiter, ignoring delimiters inside parens/brackets */
-function splitTopLevel(str: string, delimiter: string): string[] {
-    const parts: string[] = []
-    let depth = 0
-    let current = ''
-    for (const ch of str) {
-        if (ch === '(' || ch === '[' || ch === '{') depth++
-        else if (ch === ')' || ch === ']' || ch === '}') depth--
-        else if (ch === delimiter && depth === 0) {
-            parts.push(current)
-            current = ''
-            continue
-        }
-        current += ch
+// Register in the global registry
+LanguageRegistry.getInstance().register({
+    name: 'go',
+    extensions: ['.go'],
+    treeSitterGrammar: '',
+    extractor: new GoExtractor(),
+    semanticFeatures: {
+        hasTypeSystem: true,
+        hasGenerics: true,
+        hasMacros: false,
+        hasAnnotations: false,
+        hasPatternMatching: false
     }
-    if (current.trim()) parts.push(current)
-    return parts
-}
+});