@nahisaho/musubix-security 3.0.11 → 3.0.15

package/dist/extractors/go-extractor.js

@@ -1,159 +1,263 @@
 /**
  * @fileoverview Go Language Extractor
  * @module @nahisaho/musubix-security/extractors/go-extractor
- * @trace TSK-005, TSK-006, TSK-007, TSK-008
- * @trace REQ-SEC-LANG-002, REQ-SEC-CFG-001, REQ-SEC-DFG-001
+ * @trace TSK-GO-001, TSK-GO-002, TSK-GO-003, TSK-GO-004, TSK-GO-005
+ * @trace REQ-SEC-GO-001, REQ-SEC-GO-002, REQ-SEC-GO-003, REQ-SEC-GO-004
+ * @trace REQ-SEC-GO-005, REQ-SEC-GO-006, REQ-SEC-GO-007, REQ-SEC-GO-008
  */
 import { BaseExtractor, } from './base-extractor.js';
 /**
- * Go framework patterns
+ * Go framework models with proper FrameworkModel interface
+ * @trace REQ-SEC-GO-004
  */
-const GO_FRAMEWORK_PATTERNS = [
-    // net/http
+const GO_FRAMEWORK_MODELS = [
+    // net/http (Standard Library HTTP Server)
     {
-        id: 'go-net-http',
         name: 'net/http',
-        language: 'go',
-        sourcePatterns: [
-            { pattern: 'r.URL.Query', type: 'user_input' },
-            { pattern: 'r.FormValue', type: 'user_input' },
-            { pattern: 'r.PostFormValue', type: 'user_input' },
-            { pattern: 'r.Header.Get', type: 'user_input' },
-            { pattern: 'r.Body', type: 'user_input' },
-            { pattern: 'r.Cookie', type: 'user_input' },
+        languages: ['go'],
+        sources: [
+            { pattern: /r\.URL\.Query\(\)/, type: 'user_input', description: 'URL query parameters', taintLabel: 'user_input' },
+            { pattern: /r\.FormValue\(/, type: 'user_input', description: 'Form value access', taintLabel: 'user_input' },
+            { pattern: /r\.PostFormValue\(/, type: 'user_input', description: 'POST form value', taintLabel: 'user_input' },
+            { pattern: /r\.Header\.Get\(/, type: 'user_input', description: 'HTTP header access', taintLabel: 'user_input' },
+            { pattern: /r\.Body/, type: 'user_input', description: 'Request body', taintLabel: 'user_input' },
+            { pattern: /r\.Cookies\(\)/, type: 'user_input', description: 'Cookie access', taintLabel: 'user_input' },
         ],
-        sinkPatterns: [
-            { pattern: 'w.Write', type: 'xss' },
-            { pattern: 'fmt.Fprintf(w,', type: 'xss' },
-            { pattern: 'template.Execute', type: 'xss' },
-            { pattern: 'http.Redirect', type: 'open_redirect' },
+        sinks: [
+            { pattern: /fmt\.Fprintf\(w,/, type: 'xss', vulnerabilityType: 'xss', severity: 'high' },
+            { pattern: /w\.Write\(/, type: 'xss', vulnerabilityType: 'xss', severity: 'high' },
+            { pattern: /http\.Redirect\(/, type: 'redirect', vulnerabilityType: 'open_redirect', severity: 'medium' },
         ],
-        sanitizerPatterns: [
-            { pattern: 'html.EscapeString', type: 'xss' },
-            { pattern: 'template.HTMLEscapeString', type: 'xss' },
-            { pattern: 'url.PathEscape', type: 'path_traversal' },
+        sanitizers: [
+            { pattern: /html\.EscapeString\(/, sanitizes: ['xss'] },
+            { pattern: /template\.HTMLEscapeString\(/, sanitizes: ['xss'] },
         ],
     },
-    // Gin framework
+    // database/sql (Standard Library Database)
+    {
+        name: 'database/sql',
+        languages: ['go'],
+        sources: [],
+        sinks: [
+            { pattern: /db\.Query\([^,)]*\+/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+            { pattern: /db\.QueryRow\([^,)]*\+/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+            { pattern: /db\.Exec\([^,)]*\+/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+            { pattern: /db\.Prepare\([^)]*\+/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+            { pattern: /fmt\.Sprintf\([^)]*SELECT/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+        ],
+        sanitizers: [
+            { pattern: /db\.Query\([^,]+,\s*\w+\)/, sanitizes: ['sql_injection'] },
+            { pattern: /db\.QueryRow\([^,]+,\s*\w+\)/, sanitizes: ['sql_injection'] },
+        ],
+    },
+    // os/exec (Command Execution)
+    {
+        name: 'os/exec',
+        languages: ['go'],
+        sources: [
+            { pattern: /os\.Args/, type: 'user_input', description: 'Command line arguments', taintLabel: 'user_input' },
+            { pattern: /os\.Getenv\(/, type: 'user_input', description: 'Environment variable', taintLabel: 'env_input' },
+        ],
+        sinks: [
+            { pattern: /exec\.Command\(/, type: 'command', vulnerabilityType: 'command_injection', severity: 'critical' },
+            { pattern: /exec\.CommandContext\(/, type: 'command', vulnerabilityType: 'command_injection', severity: 'critical' },
+        ],
+        sanitizers: [],
+    },
+    // os (File Operations)
+    {
+        name: 'os',
+        languages: ['go'],
+        sources: [],
+        sinks: [
+            { pattern: /os\.Open\(/, type: 'file', vulnerabilityType: 'path_traversal', severity: 'high' },
+            { pattern: /os\.OpenFile\(/, type: 'file', vulnerabilityType: 'path_traversal', severity: 'high' },
+            { pattern: /os\.Create\(/, type: 'file', vulnerabilityType: 'path_traversal', severity: 'high' },
+            { pattern: /os\.ReadFile\(/, type: 'file', vulnerabilityType: 'path_traversal', severity: 'high' },
+            { pattern: /os\.WriteFile\(/, type: 'file', vulnerabilityType: 'path_traversal', severity: 'high' },
+            { pattern: /ioutil\.ReadFile\(/, type: 'file', vulnerabilityType: 'path_traversal', severity: 'high' },
+        ],
+        sanitizers: [
+            { pattern: /filepath\.Clean\(/, sanitizes: ['path_traversal'] },
+            { pattern: /filepath\.Base\(/, sanitizes: ['path_traversal'] },
+        ],
+    },
+    // encoding/xml (XML Processing)
+    {
+        name: 'encoding/xml',
+        languages: ['go'],
+        sources: [],
+        sinks: [
+            { pattern: /xml\.Unmarshal\(/, type: 'xml', vulnerabilityType: 'xxe', severity: 'high' },
+            { pattern: /xml\.NewDecoder\(/, type: 'xml', vulnerabilityType: 'xxe', severity: 'high' },
+        ],
+        sanitizers: [],
+    },
+    // Gin Framework
     {
-        id: 'go-gin',
         name: 'Gin',
-        language: 'go',
-        sourcePatterns: [
-            { pattern: 'c.Query', type: 'user_input' },
-            { pattern: 'c.Param', type: 'user_input' },
-            { pattern: 'c.PostForm', type: 'user_input' },
-            { pattern: 'c.GetHeader', type: 'user_input' },
-            { pattern: 'c.ShouldBind', type: 'user_input' },
-            { pattern: 'c.BindJSON', type: 'user_input' },
+        languages: ['go'],
+        sources: [
+            { pattern: /c\.Query\(/, type: 'user_input', description: 'Gin query parameter', taintLabel: 'user_input' },
+            { pattern: /c\.Param\(/, type: 'user_input', description: 'Gin path parameter', taintLabel: 'user_input' },
+            { pattern: /c\.PostForm\(/, type: 'user_input', description: 'Gin POST form', taintLabel: 'user_input' },
+            { pattern: /c\.ShouldBindJSON\(/, type: 'user_input', description: 'Gin JSON binding', taintLabel: 'user_input' },
+            { pattern: /c\.GetHeader\(/, type: 'user_input', description: 'Gin header access', taintLabel: 'user_input' },
+            { pattern: /c\.Cookie\(/, type: 'user_input', description: 'Gin cookie access', taintLabel: 'user_input' },
         ],
-        sinkPatterns: [
-            { pattern: 'c.String', type: 'xss' },
-            { pattern: 'c.HTML', type: 'xss' },
-            { pattern: 'c.Redirect', type: 'open_redirect' },
+        sinks: [
+            { pattern: /c\.HTML\(/, type: 'xss', vulnerabilityType: 'xss', severity: 'high' },
+            { pattern: /c\.String\(/, type: 'xss', vulnerabilityType: 'xss', severity: 'medium' },
+            { pattern: /c\.Redirect\(/, type: 'redirect', vulnerabilityType: 'open_redirect', severity: 'medium' },
         ],
-        sanitizerPatterns: [],
+        sanitizers: [],
     },
-    // database/sql
+    // Echo Framework
     {
-        id: 'go-database-sql',
-        name: 'database/sql',
-        language: 'go',
-        sourcePatterns: [],
-        sinkPatterns: [
-            { pattern: 'db.Query', type: 'sql_injection' },
-            { pattern: 'db.Exec', type: 'sql_injection' },
-            { pattern: 'db.QueryRow', type: 'sql_injection' },
-            { pattern: 'tx.Query', type: 'sql_injection' },
-            { pattern: 'tx.Exec', type: 'sql_injection' },
+        name: 'Echo',
+        languages: ['go'],
+        sources: [
+            { pattern: /c\.QueryParam\(/, type: 'user_input', description: 'Echo query parameter', taintLabel: 'user_input' },
+            { pattern: /c\.Param\(/, type: 'user_input', description: 'Echo path parameter', taintLabel: 'user_input' },
+            { pattern: /c\.FormValue\(/, type: 'user_input', description: 'Echo form value', taintLabel: 'user_input' },
+            { pattern: /c\.Bind\(/, type: 'user_input', description: 'Echo request binding', taintLabel: 'user_input' },
+            { pattern: /c\.Request\(\)\.Header\.Get\(/, type: 'user_input', description: 'Echo header access', taintLabel: 'user_input' },
         ],
-        sanitizerPatterns: [
-            { pattern: 'db.Prepare', type: 'sql_injection' },
+        sinks: [
+            { pattern: /c\.HTML\(/, type: 'xss', vulnerabilityType: 'xss', severity: 'high' },
+            { pattern: /c\.String\(/, type: 'xss', vulnerabilityType: 'xss', severity: 'medium' },
+            { pattern: /c\.Redirect\(/, type: 'redirect', vulnerabilityType: 'open_redirect', severity: 'medium' },
         ],
+        sanitizers: [],
     },
-    // os/exec
+    // Fiber Framework
     {
-        id: 'go-os-exec',
-        name: 'os/exec',
-        language: 'go',
-        sourcePatterns: [],
-        sinkPatterns: [
-            { pattern: 'exec.Command', type: 'command_injection' },
-            { pattern: 'exec.CommandContext', type: 'command_injection' },
+        name: 'Fiber',
+        languages: ['go'],
+        sources: [
+            { pattern: /c\.Query\(/, type: 'user_input', description: 'Fiber query parameter', taintLabel: 'user_input' },
+            { pattern: /c\.Params\(/, type: 'user_input', description: 'Fiber path parameter', taintLabel: 'user_input' },
+            { pattern: /c\.FormValue\(/, type: 'user_input', description: 'Fiber form value', taintLabel: 'user_input' },
+            { pattern: /c\.BodyParser\(/, type: 'user_input', description: 'Fiber body parser', taintLabel: 'user_input' },
+            { pattern: /c\.Get\(/, type: 'user_input', description: 'Fiber header access', taintLabel: 'user_input' },
+        ],
+        sinks: [
+            { pattern: /c\.SendString\(/, type: 'xss', vulnerabilityType: 'xss', severity: 'medium' },
+            { pattern: /c\.Redirect\(/, type: 'redirect', vulnerabilityType: 'open_redirect', severity: 'medium' },
         ],
-        sanitizerPatterns: [],
+        sanitizers: [],
     },
-    // io/ioutil & os
+    // GORM ORM
     {
-        id: 'go-file-io',
-        name: 'file-io',
-        language: 'go',
-        sourcePatterns: [],
-        sinkPatterns: [
-            { pattern: 'os.Open', type: 'path_traversal' },
-            { pattern: 'os.Create', type: 'path_traversal' },
-            { pattern: 'os.ReadFile', type: 'path_traversal' },
-            { pattern: 'os.WriteFile', type: 'path_traversal' },
-            { pattern: 'ioutil.ReadFile', type: 'path_traversal' },
-            { pattern: 'ioutil.WriteFile', type: 'path_traversal' },
+        name: 'GORM',
+        languages: ['go'],
+        sources: [],
+        sinks: [
+            { pattern: /db\.Raw\(/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+            { pattern: /db\.Exec\(/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
+            { pattern: /db\.Where\([^,)]*\+/, type: 'sql', vulnerabilityType: 'sql_injection', severity: 'critical' },
         ],
-        sanitizerPatterns: [
-            { pattern: 'filepath.Clean', type: 'path_traversal' },
-            { pattern: 'filepath.Abs', type: 'path_traversal' },
+        sanitizers: [
+            { pattern: /db\.Where\([^,]+,\s*\w+\)/, sanitizes: ['sql_injection'] },
+        ],
+    },
+    // Go SSRF vulnerabilities
+    {
+        name: 'Go SSRF',
+        languages: ['go'],
+        sources: [],
+        sinks: [
+            { pattern: /http\.Get\(/, type: 'ssrf', vulnerabilityType: 'ssrf', severity: 'high' },
+            { pattern: /http\.Post\(/, type: 'ssrf', vulnerabilityType: 'ssrf', severity: 'high' },
+            { pattern: /http\.NewRequest\(/, type: 'ssrf', vulnerabilityType: 'ssrf', severity: 'high' },
+            { pattern: /client\.Do\(/, type: 'ssrf', vulnerabilityType: 'ssrf', severity: 'high' },
+        ],
+        sanitizers: [
+            { pattern: /url\.Parse\(/, sanitizes: ['ssrf'] },
         ],
     },
 ];
 /**
- * Go language extractor implementation
+ * Check if a Go identifier is exported (starts with uppercase)
+ * @param name The identifier name to check
+ * @returns true if exported, false otherwise
+ */
+function isExported(name) {
+    if (!name || name.length === 0)
+        return false;
+    const firstChar = name.charAt(0);
+    return firstChar >= 'A' && firstChar <= 'Z';
+}
+/**
+ * Go Language Extractor
+ * @trace TSK-GO-001, REQ-SEC-GO-001
  */
 export class GoExtractor extends BaseExtractor {
+    language = 'go';
+    extensions = ['.go'];
     parser = null;
     tree = null;
     nodeIdCounter = 0;
     blockIdCounter = 0;
     /**
-     * Create a new Go extractor
+     * Get framework models for Go
+     * @trace REQ-SEC-GO-004
      */
-    constructor(options) {
-        super('go', options);
-        this.frameworkModels = GO_FRAMEWORK_PATTERNS;
+    getFrameworkModels() {
+        return GO_FRAMEWORK_MODELS;
     }
     /**
      * Initialize tree-sitter parser
+     * @trace REQ-SEC-GO-002
      */
     async initParser() {
         if (this.parser)
             return;
         try {
-            // Dynamic import for tree-sitter
             const Parser = (await import('tree-sitter')).default;
             const Go = (await import('tree-sitter-go')).default;
             this.parser = new Parser();
             this.parser.setLanguage(Go);
         }
         catch {
-            // Tree-sitter not available, will use fallback parsing
+            // tree-sitter-go not available, use fallback
             this.parser = null;
         }
     }
     /**
-     * Parse Go source code into AST
+     * Build AST from source code
+     * @trace TSK-GO-002, REQ-SEC-GO-002
      */
-    async parseAST(code, filePath) {
+    async buildAST(source, filePath) {
         await this.initParser();
+        this.nodeIdCounter = 0;
+        const astNodes = new Map();
+        const astEdges = [];
+        let ast;
         if (this.parser) {
-            this.tree = this.parser.parse(code);
-            return this.convertTreeSitterNode(this.tree.rootNode, filePath);
+            this.tree = this.parser.parse(source);
+            ast = this.convertTreeSitterNode(this.tree.rootNode, filePath, astNodes, astEdges);
+        }
+        else {
+            ast = this.createFallbackAST(source, filePath, astNodes);
         }
-        // Fallback: minimal AST structure
-        return this.createFallbackAST(code, filePath);
+        return { ast, astNodes, astEdges };
     }
     /**
-     * Convert tree-sitter node to our AST format
+     * Convert tree-sitter node to AST format
      */
-    convertTreeSitterNode(node, filePath) {
+    convertTreeSitterNode(node, filePath, astNodes, astEdges) {
         const id = `${filePath}#${this.nodeIdCounter++}`;
-        const children = node.namedChildren.map((child) => this.convertTreeSitterNode(child, filePath));
+        const childIds = [];
+        for (const child of node.namedChildren) {
+            const childNode = this.convertTreeSitterNode(child, filePath, astNodes, astEdges);
+            childIds.push(childNode.id);
+            astEdges.push({
+                from: id,
+                to: childNode.id,
+                label: 'child',
+            });
+        }
         const astNode = {
             id,
             type: node.type,
@@ -165,641 +269,485 @@ export class GoExtractor extends BaseExtractor {
                 startColumn: node.startPosition.column,
                 endColumn: node.endPosition.column,
             },
-            children,
-            metadata: this.extractNodeMetadata(node),
+            properties: this.extractNodeProperties(node),
+            children: childIds,
+            metadata: {},
         };
-        // Set parent references
-        for (const child of children) {
-            child.parent = astNode;
-        }
+        astNodes.set(id, astNode);
         return astNode;
     }
     /**
-     * Extract metadata from tree-sitter node
+     * Extract properties from node
+     * @trace REQ-SEC-GO-003
      */
-    extractNodeMetadata(node) {
-        const metadata = {};
+    extractNodeProperties(node) {
+        const props = {};
         switch (node.type) {
-            case 'function_declaration':
+            case 'function_declaration': {
+                const nameNode = node.childForFieldName('name');
+                const paramsNode = node.childForFieldName('parameters');
+                const resultNode = node.childForFieldName('result');
+                const name = nameNode?.text;
+                props.name = name;
+                props.parameters = paramsNode?.namedChildren.map((p) => p.text) ?? [];
+                props.returnType = resultNode?.text;
+                props.isExported = name ? isExported(name) : false;
+                break;
+            }
             case 'method_declaration': {
                 const nameNode = node.childForFieldName('name');
+                const receiverNode = node.childForFieldName('receiver');
                 const paramsNode = node.childForFieldName('parameters');
                 const resultNode = node.childForFieldName('result');
-                metadata.name = nameNode?.text;
-                metadata.parameters = this.extractParameters(paramsNode);
-                metadata.returnType = resultNode?.text;
-                if (node.type === 'method_declaration') {
-                    const receiverNode = node.childForFieldName('receiver');
-                    metadata.receiver = receiverNode?.text;
-                }
+                const name = nameNode?.text;
+                props.name = name;
+                props.receiver = receiverNode?.text;
+                props.parameters = paramsNode?.namedChildren.map((p) => p.text) ?? [];
+                props.returnType = resultNode?.text;
+                props.isExported = name ? isExported(name) : false;
                 break;
             }
             case 'type_declaration': {
-                const specs = node.namedChildren.filter((c) => c.type === 'type_spec');
-                metadata.types = specs.map((spec) => ({
-                    name: spec.childForFieldName('name')?.text,
-                    kind: spec.childForFieldName('type')?.type,
-                }));
+                const specNode = node.namedChildren[0];
+                if (specNode?.type === 'type_spec') {
+                    const nameNode = specNode.childForFieldName('name');
+                    const typeNode = specNode.childForFieldName('type');
+                    const name = nameNode?.text;
+                    props.name = name;
+                    props.underlyingType = typeNode?.type;
+                    props.isExported = name ? isExported(name) : false;
+                }
                 break;
             }
-            case 'import_declaration': {
-                const specs = node.namedChildren.filter((c) => c.type === 'import_spec' || c.type === 'import_spec_list');
-                metadata.imports = this.extractImports(specs);
+            case 'struct_type': {
+                const fields = [];
+                for (const fieldDecl of node.namedChildren) {
+                    if (fieldDecl.type === 'field_declaration') {
+                        const fieldNameNode = fieldDecl.childForFieldName('name');
+                        const fieldTypeNode = fieldDecl.childForFieldName('type');
+                        const tagNode = fieldDecl.namedChildren.find((n) => n.type === 'raw_string_literal');
+                        fields.push({
+                            name: fieldNameNode?.text ?? '',
+                            type: fieldTypeNode?.text ?? '',
+                            tag: tagNode?.text,
+                        });
+                    }
+                }
+                props.fields = fields;
+                break;
+            }
+            case 'interface_type': {
+                const methods = [];
+                for (const methodSpec of node.namedChildren) {
+                    if (methodSpec.type === 'method_spec') {
+                        const methodNameNode = methodSpec.childForFieldName('name');
+                        if (methodNameNode) {
+                            methods.push(methodNameNode.text);
+                        }
+                    }
+                }
+                props.methods = methods;
                 break;
             }
             case 'call_expression': {
-                const funcNode = node.childForFieldName('function');
+                const functionNode = node.childForFieldName('function');
                 const argsNode = node.childForFieldName('arguments');
-                metadata.callee = funcNode?.text;
-                metadata.argumentCount = argsNode?.namedChildCount ?? 0;
+                props.functionName = functionNode?.text;
+                props.argumentCount = argsNode?.namedChildCount ?? 0;
+                break;
+            }
+            case 'selector_expression': {
+                const operandNode = node.childForFieldName('operand');
+                const fieldNode = node.childForFieldName('field');
+                props.operand = operandNode?.text;
+                props.field = fieldNode?.text;
+                break;
+            }
+            case 'short_var_declaration':
+            case 'var_declaration':
+            case 'assignment_statement': {
+                const leftNode = node.childForFieldName('left');
+                const rightNode = node.childForFieldName('right');
+                props.left = leftNode?.text;
+                props.right = rightNode?.text;
+                break;
+            }
+            case 'package_clause': {
+                const pkgNameNode = node.childForFieldName('name');
+                props.packageName = pkgNameNode?.text;
+                break;
+            }
+            case 'import_declaration': {
+                const specs = [];
+                for (const child of node.namedChildren) {
+                    if (child.type === 'import_spec' || child.type === 'import_spec_list') {
+                        const pathNode = child.childForFieldName('path') ?? child;
+                        specs.push(pathNode.text.replace(/"/g, ''));
+                    }
+                }
+                props.imports = specs;
                 break;
             }
             case 'if_statement':
+                props.hasElse = node.namedChildren.some((n) => n.type === 'block' && n !== node.namedChildren[0]);
+                break;
             case 'for_statement':
+                props.hasRange = node.text.includes('range');
+                break;
             case 'switch_statement':
-                metadata.isControlFlow = true;
+            case 'type_switch_statement':
+                props.caseCount = node.namedChildren.filter((n) => n.type === 'expression_case' || n.type === 'type_case').length;
                 break;
             case 'go_statement':
-                metadata.isConcurrent = true;
+                props.isGoroutine = true;
                 break;
             case 'defer_statement':
-                metadata.isDeferred = true;
+                props.isDeferred = true;
+                break;
+            case 'select_statement':
+                props.caseCount = node.namedChildren.filter((n) => n.type === 'communication_case').length;
                 break;
         }
-        return metadata;
-    }
-    /**
-     * Extract function parameters
-     */
-    extractParameters(paramsNode) {
-        if (!paramsNode)
-            return [];
-        const params = [];
-        const paramDecls = paramsNode.namedChildren.filter((c) => c.type === 'parameter_declaration');
-        for (const decl of paramDecls) {
-            const names = decl.childrenForFieldName('name');
-            const typeNode = decl.childForFieldName('type');
-            const typeName = typeNode?.text ?? 'unknown';
-            for (const nameNode of names) {
-                params.push({ name: nameNode.text, type: typeName });
-            }
-        }
-        return params;
-    }
-    /**
-     * Extract import specifications
-     */
-    extractImports(specs) {
-        const imports = [];
-        for (const spec of specs) {
-            if (spec.type === 'import_spec') {
-                const pathNode = spec.childForFieldName('path');
-                const aliasNode = spec.childForFieldName('name');
-                imports.push({
-                    path: pathNode?.text?.replace(/"/g, '') ?? '',
-                    alias: aliasNode?.text,
-                });
-            }
-            else if (spec.type === 'import_spec_list') {
-                imports.push(...this.extractImports(spec.namedChildren));
-            }
-        }
-        return imports;
+        return props;
     }
     /**
-     * Build control flow graph
+     * Create fallback AST when tree-sitter is unavailable
      */
-    async buildCFG(ast) {
-        const blocks = [];
-        const edges = [];
-        // Find all functions
-        const functions = this.findNodesByType(ast, [
-            'function_declaration',
-            'method_declaration',
-            'func_literal',
-        ]);
-        for (const func of functions) {
-            const funcCFG = this.buildFunctionCFG(func);
-            blocks.push(...funcCFG.blocks);
-            edges.push(...funcCFG.edges);
-        }
-        // Create entry and exit blocks
-        const entry = {
-            id: `${ast.location.file}#entry`,
-            statements: [],
-            predecessors: [],
-            successors: blocks.filter((b) => b.predecessors.length === 0).map((b) => b.id),
-        };
-        const exit = {
-            id: `${ast.location.file}#exit`,
-            statements: [],
-            predecessors: blocks.filter((b) => b.successors.length === 0).map((b) => b.id),
-            successors: [],
-        };
-        return {
-            entry: entry.id,
-            exit: exit.id,
-            blocks: [entry, ...blocks, exit],
-            edges,
+    createFallbackAST(source, filePath, astNodes) {
+        const lines = source.split('\n');
+        const id = `${filePath}#root`;
+        const ast = {
+            id,
+            type: 'source_file',
+            text: source,
+            location: {
+                file: filePath,
+                startLine: 1,
+                endLine: lines.length,
+                startColumn: 0,
+                endColumn: lines[lines.length - 1]?.length ?? 0,
+            },
+            properties: { fallback: true, lineCount: lines.length },
+            children: [],
+            metadata: {},
         };
+        astNodes.set(id, ast);
+        return ast;
     }
     /**
-     * Build CFG for a single function
-     */
-    buildFunctionCFG(func) {
-        const blocks = [];
-        const edges = [];
-        const bodyNode = func.children.find((c) => c.type === 'block');
-        if (!bodyNode) {
-            return { blocks, edges };
-        }
-        // Process function body
-        const { blocks: bodyBlocks, edges: bodyEdges } = this.processBlock(bodyNode);
-        blocks.push(...bodyBlocks);
-        edges.push(...bodyEdges);
-        return { blocks, edges };
-    }
-    /**
-     * Process a block of statements
+     * Build Data Flow Graph
+     * @trace TSK-GO-003, REQ-SEC-GO-005
      */
-    processBlock(block) {
-        const blocks = [];
+    async buildDFG(astNodes, _astEdges, frameworkModels) {
+        const nodes = new Map();
         const edges = [];
-        let currentBlock = null;
-        for (const stmt of block.children) {
-            if (this.isControlFlowStatement(stmt)) {
-                // End current block
-                if (currentBlock && currentBlock.statements.length > 0) {
-                    blocks.push(currentBlock);
-                }
-                // Process control flow statement
-                const cfResult = this.processControlFlow(stmt);
-                blocks.push(...cfResult.blocks);
-                edges.push(...cfResult.edges);
-                // Start new block
-                currentBlock = null;
-            }
-            else {
-                // Add to current block
-                if (!currentBlock) {
-                    currentBlock = {
-                        id: `${block.location.file}#block_${this.blockIdCounter++}`,
-                        statements: [],
-                        predecessors: [],
-                        successors: [],
-                    };
-                }
-                currentBlock.statements.push(stmt.id);
-            }
-        }
-        // Add final block
-        if (currentBlock && currentBlock.statements.length > 0) {
-            blocks.push(currentBlock);
-        }
-        // Connect sequential blocks
-        for (let i = 0; i < blocks.length - 1; i++) {
-            if (blocks[i].successors.length === 0) {
-                blocks[i].successors.push(blocks[i + 1].id);
-                blocks[i + 1].predecessors.push(blocks[i].id);
-                edges.push({
-                    from: blocks[i].id,
-                    to: blocks[i + 1].id,
-                    type: 'sequential',
-                });
-            }
-        }
-        return { blocks, edges };
-    }
-    /**
-     * Check if statement is control flow
-     */
-    isControlFlowStatement(stmt) {
-        return [
-            'if_statement',
-            'for_statement',
-            'switch_statement',
-            'select_statement',
-            'return_statement',
-            'go_statement',
-            'defer_statement',
-        ].includes(stmt.type);
-    }
-    /**
-     * Process control flow statement
-     */
-    processControlFlow(stmt) {
-        const blocks = [];
-        const edges = [];
-        switch (stmt.type) {
-            case 'if_statement': {
-                // Create condition block
-                const condBlock = {
-                    id: `${stmt.location.file}#if_cond_${this.blockIdCounter++}`,
-                    statements: [stmt.id],
-                    predecessors: [],
-                    successors: [],
-                };
-                blocks.push(condBlock);
-                // Process then branch
-                const thenBlock = stmt.children.find((c) => c.type === 'block');
-                if (thenBlock) {
-                    const { blocks: thenBlocks, edges: thenEdges } = this.processBlock(thenBlock);
-                    blocks.push(...thenBlocks);
-                    edges.push(...thenEdges);
-                    if (thenBlocks.length > 0) {
-                        condBlock.successors.push(thenBlocks[0].id);
-                        thenBlocks[0].predecessors.push(condBlock.id);
-                        edges.push({
-                            from: condBlock.id,
-                            to: thenBlocks[0].id,
-                            type: 'conditional',
-                            condition: 'true',
+        const sources = [];
+        const sinks = [];
+        const models = frameworkModels.length > 0 ? frameworkModels : GO_FRAMEWORK_MODELS;
+        for (const [_nodeId, astNode] of astNodes) {
+            if (!astNode.text)
+                continue;
+            // Check for sources
+            for (const model of models) {
+                for (const source of model.sources) {
+                    if (source.pattern.test(astNode.text)) {
+                        const dfgId = `dfg_source_${astNode.id}`;
+                        nodes.set(dfgId, {
+                            id: dfgId,
+                            astNodeId: astNode.id,
+                            nodeType: 'source',
+                            taintLabel: source.taintLabel,
+                            expression: astNode.text,
+                            location: astNode.location,
+                            properties: { sourceType: source.type, framework: model.name },
                         });
+                        sources.push(dfgId);
                     }
                 }
-                // Process else branch
-                const elseClause = stmt.children.find((c) => c.type === 'block' && c !== thenBlock);
-                if (elseClause) {
-                    const { blocks: elseBlocks, edges: elseEdges } = this.processBlock(elseClause);
-                    blocks.push(...elseBlocks);
-                    edges.push(...elseEdges);
-                    if (elseBlocks.length > 0) {
-                        condBlock.successors.push(elseBlocks[0].id);
-                        elseBlocks[0].predecessors.push(condBlock.id);
-                        edges.push({
-                            from: condBlock.id,
-                            to: elseBlocks[0].id,
-                            type: 'conditional',
-                            condition: 'false',
+                // Check for sinks
+                for (const sink of model.sinks) {
+                    if (sink.pattern.test(astNode.text)) {
+                        const dfgId = `dfg_sink_${astNode.id}`;
+                        nodes.set(dfgId, {
+                            id: dfgId,
+                            astNodeId: astNode.id,
+                            nodeType: 'sink',
+                            expression: astNode.text,
+                            location: astNode.location,
+                            properties: {
+                                sinkType: sink.type,
+                                vulnerabilityType: sink.vulnerabilityType,
+                                severity: sink.severity,
+                                framework: model.name,
+                            },
                         });
+                        sinks.push(dfgId);
                     }
                 }
-                break;
-            }
-            case 'for_statement': {
-                // Create loop header block
-                const headerBlock = {
-                    id: `${stmt.location.file}#for_header_${this.blockIdCounter++}`,
-                    statements: [stmt.id],
-                    predecessors: [],
-                    successors: [],
-                };
-                blocks.push(headerBlock);
-                // Process loop body
-                const bodyBlock = stmt.children.find((c) => c.type === 'block');
-                if (bodyBlock) {
-                    const { blocks: bodyBlocks, edges: bodyEdges } = this.processBlock(bodyBlock);
-                    blocks.push(...bodyBlocks);
-                    edges.push(...bodyEdges);
-                    if (bodyBlocks.length > 0) {
-                        // Entry to body
-                        headerBlock.successors.push(bodyBlocks[0].id);
-                        bodyBlocks[0].predecessors.push(headerBlock.id);
-                        edges.push({
-                            from: headerBlock.id,
-                            to: bodyBlocks[0].id,
-                            type: 'conditional',
-                            condition: 'true',
-                        });
-                        // Back edge
-                        const lastBody = bodyBlocks[bodyBlocks.length - 1];
-                        lastBody.successors.push(headerBlock.id);
-                        headerBlock.predecessors.push(lastBody.id);
-                        edges.push({
-                            from: lastBody.id,
-                            to: headerBlock.id,
-                            type: 'back',
+                // Check for sanitizers
+                for (const sanitizer of model.sanitizers) {
+                    if (sanitizer.pattern.test(astNode.text)) {
+                        const dfgId = `dfg_sanitizer_${astNode.id}`;
+                        nodes.set(dfgId, {
+                            id: dfgId,
+                            astNodeId: astNode.id,
+                            nodeType: 'sanitizer',
+                            expression: astNode.text,
+                            location: astNode.location,
+                            properties: { sanitizes: sanitizer.sanitizes, framework: model.name },
                         });
                     }
                 }
-                break;
             }
-            case 'return_statement': {
-                const returnBlock = {
-                    id: `${stmt.location.file}#return_${this.blockIdCounter++}`,
-                    statements: [stmt.id],
-                    predecessors: [],
-                    successors: [], // Will connect to exit
-                };
-                blocks.push(returnBlock);
-                break;
-            }
-            default: {
-                const block = {
-                    id: `${stmt.location.file}#stmt_${this.blockIdCounter++}`,
-                    statements: [stmt.id],
-                    predecessors: [],
-                    successors: [],
-                };
-                blocks.push(block);
-            }
-        }
-        return { blocks, edges };
-    }
-    /**
-     * Build data flow graph
-     */
-    async buildDFG(ast, cfg) {
-        const nodes = [];
-        const edges = [];
-        const nodeMap = new Map();
-        // Process all assignments and declarations
-        const assignments = this.findNodesByType(ast, [
-            'short_var_declaration',
-            'var_declaration',
-            'const_declaration',
-            'assignment_statement',
-        ]);
-        for (const assign of assignments) {
-            const dfgNodes = this.createDFGNodesForAssignment(assign, nodeMap);
-            nodes.push(...dfgNodes);
-        }
-        // Process function parameters as sources
-        const functions = this.findNodesByType(ast, [
-            'function_declaration',
-            'method_declaration',
-        ]);
-        for (const func of functions) {
-            const paramNodes = this.createDFGNodesForParameters(func, nodeMap);
-            nodes.push(...paramNodes);
-        }
-        // Build edges based on data dependencies
-        edges.push(...this.buildDFGEdges(nodes, nodeMap));
-        return {
-            nodes,
-            edges,
-        };
-    }
-    /**
-     * Create DFG nodes for assignment
-     */
-    createDFGNodesForAssignment(assign, nodeMap) {
-        const nodes = [];
-        // Get left-hand side (defined variables)
-        const lhs = assign.children.filter((c) => ['identifier', 'expression_list'].includes(c.type));
-        for (const target of lhs) {
-            if (target.type === 'identifier') {
-                const node = {
-                    id: `dfg_${target.id}`,
-                    astNodeId: target.id,
-                    variable: target.text,
+            // Handle variable declarations and assignments
+            if (astNode.type === 'short_var_declaration' ||
+                astNode.type === 'var_declaration' ||
+                astNode.type === 'assignment_statement') {
+                const dfgId = `dfg_assign_${astNode.id}`;
+                nodes.set(dfgId, {
+                    id: dfgId,
+                    astNodeId: astNode.id,
+                    nodeType: 'propagator',
+                    variable: astNode.properties.left,
                     operation: 'write',
-                    location: target.location,
-                    predecessors: [],
-                    successors: [],
-                };
-                nodes.push(node);
-                nodeMap.set(target.text, node);
+                    expression: astNode.text,
+                    location: astNode.location,
+                    properties: {},
+                });
             }
         }
-        return nodes;
+        return { nodes, edges, sources, sinks };
     }
     /**
-     * Create DFG nodes for function parameters
+     * Build Control Flow Graph
+     * @trace TSK-GO-004, REQ-SEC-GO-006
      */
-    createDFGNodesForParameters(func, nodeMap) {
-        const nodes = [];
-        const params = func.metadata?.parameters;
-        if (params) {
-            for (const param of params) {
-                const node = {
-                    id: `dfg_param_${func.id}_${param.name}`,
-                    astNodeId: func.id,
-                    variable: param.name,
-                    operation: 'param',
-                    location: func.location,
+    async buildCFG(astNodes, _astEdges) {
+        const blocks = new Map();
+        const edges = [];
+        const entryBlocks = [];
+        const exitBlocks = [];
+        // Find functions and build CFG for each
+        for (const [_nodeId, astNode] of astNodes) {
+            if (astNode.type === 'function_declaration' || astNode.type === 'method_declaration') {
+                const blockId = `block_${this.blockIdCounter++}`;
+                blocks.set(blockId, {
+                    id: blockId,
+                    statements: [astNode.id],
                     predecessors: [],
                     successors: [],
-                    taintLabel: this.inferTaintLabel(param.name, param.type),
-                };
-                nodes.push(node);
-                nodeMap.set(param.name, node);
-            }
-        }
-        return nodes;
-    }
-    /**
-     * Infer taint label from parameter
-     */
-    inferTaintLabel(name, type) {
-        // HTTP request parameters
-        if (name === 'r' && type.includes('Request'))
-            return 'user_input';
-        if (name === 'req' && type.includes('Request'))
-            return 'user_input';
-        if (name === 'c' && type.includes('Context'))
-            return 'user_input'; // Gin context
-        return undefined;
-    }
-    /**
-     * Build DFG edges
-     */
-    buildDFGEdges(nodes, nodeMap) {
-        const edges = [];
-        // Connect reads to their definitions
-        for (const node of nodes) {
-            if (node.operation === 'read') {
-                const def = nodeMap.get(node.variable);
-                if (def && def !== node) {
-                    edges.push({
-                        from: def.id,
-                        to: node.id,
-                        type: 'data',
-                        variable: node.variable,
-                    });
-                    def.successors.push(node.id);
-                    node.predecessors.push(def.id);
-                }
-            }
-        }
-        return edges;
-    }
-    /**
-     * Build symbol table
-     */
-    async buildSymbolTable(ast) {
-        const global = new Map();
-        const scopes = [];
-        // Extract package name
-        const packageNode = this.findNodesByType(ast, ['package_clause'])[0];
-        const packageName = packageNode?.children[0]?.text ?? 'main';
-        // Process imports
-        const importNodes = this.findNodesByType(ast, ['import_declaration']);
-        for (const importDecl of importNodes) {
-            const imports = importDecl.metadata?.imports;
-            if (imports) {
-                for (const imp of imports) {
-                    const alias = imp.alias ?? imp.path.split('/').pop() ?? imp.path;
-                    global.set(alias, {
-                        name: alias,
-                        kind: 'import',
-                        type: imp.path,
-                        location: importDecl.location,
-                        scope: 'global',
-                    });
-                }
-            }
-        }
-        // Process type declarations
-        const typeDecls = this.findNodesByType(ast, ['type_declaration']);
-        for (const typeDecl of typeDecls) {
-            const types = typeDecl.metadata?.types;
-            if (types) {
-                for (const t of types) {
-                    global.set(t.name, {
-                        name: t.name,
-                        kind: 'type',
-                        type: t.kind,
-                        location: typeDecl.location,
-                        scope: 'global',
-                        exported: this.isExported(t.name),
-                    });
-                }
-            }
-        }
-        // Process function declarations
-        const funcDecls = this.findNodesByType(ast, [
-            'function_declaration',
-            'method_declaration',
-        ]);
-        for (const funcDecl of funcDecls) {
-            const name = funcDecl.metadata?.name;
-            const params = funcDecl.metadata?.parameters;
-            const returnType = funcDecl.metadata?.returnType;
-            const receiver = funcDecl.metadata?.receiver;
-            if (name) {
-                const fullName = receiver ? `${receiver}.${name}` : name;
-                global.set(fullName, {
-                    name: fullName,
-                    kind: 'function',
-                    type: `func(${params?.map((p) => p.type).join(', ') ?? ''}) ${returnType ?? ''}`,
-                    location: funcDecl.location,
-                    scope: 'global',
-                    exported: this.isExported(name),
                 });
-                // Create function scope
-                const funcScope = new Map();
-                if (params) {
-                    for (const param of params) {
-                        funcScope.set(param.name, {
-                            name: param.name,
-                            kind: 'parameter',
-                            type: param.type,
-                            location: funcDecl.location,
-                            scope: fullName,
-                        });
-                    }
-                }
-                scopes.push({ scopeId: fullName, symbols: funcScope });
+                entryBlocks.push(blockId);
+                exitBlocks.push(blockId);
             }
         }
-        // Process var/const declarations
-        const varDecls = this.findNodesByType(ast, ['var_declaration', 'const_declaration']);
-        for (const varDecl of varDecls) {
-            const specs = varDecl.children.filter((c) => c.type === 'var_spec' || c.type === 'const_spec');
-            for (const spec of specs) {
-                const nameNode = spec.children.find((c) => c.type === 'identifier');
-                const typeNode = spec.children.find((c) => c.type.includes('type'));
-                if (nameNode) {
-                    global.set(nameNode.text, {
-                        name: nameNode.text,
-                        kind: varDecl.type === 'var_declaration' ? 'variable' : 'constant',
-                        type: typeNode?.text ?? 'unknown',
-                        location: varDecl.location,
-                        scope: 'global',
-                        exported: this.isExported(nameNode.text),
-                    });
-                }
-            }
+        // Add entry and exit blocks if none found
+        if (entryBlocks.length === 0) {
+            const entryId = 'entry_block';
+            const exitId = 'exit_block';
+            blocks.set(entryId, {
+                id: entryId,
+                statements: [],
+                predecessors: [],
+                successors: [exitId],
+                isEntry: true,
+            });
+            blocks.set(exitId, {
+                id: exitId,
+                statements: [],
+                predecessors: [entryId],
+                successors: [],
+                isExit: true,
+            });
+            entryBlocks.push(entryId);
+            exitBlocks.push(exitId);
+            edges.push({
+                from: entryId,
+                to: exitId,
+                edgeType: 'normal',
+            });
         }
         return {
-            global,
-            scopes,
-            packageName,
+            blocks,
+            edges,
+            entryBlocks,
+            exitBlocks,
+            entry: entryBlocks[0],
+            exit: exitBlocks[exitBlocks.length - 1],
         };
     }
     /**
-     * Check if Go identifier is exported (starts with uppercase)
-     */
-    isExported(name) {
-        return /^[A-Z]/.test(name);
-    }
-    /**
-     * Detect framework usage
+     * Extract symbols from AST
+     * @trace TSK-GO-005, REQ-SEC-GO-007
      */
-    async detectFrameworks(ast, symbols) {
-        const detected = [];
-        const imports = new Set();
-        // Collect all imports
-        for (const [, entry] of symbols.global) {
-            if (entry.kind === 'import' && entry.type) {
-                imports.add(entry.type);
+    async extractSymbols(astNodes) {
+        const symbols = new Map();
+        const functions = new Map();
+        const classes = new Map();
+        const scopes = new Map();
+        // Package scope
+        let packageName = 'main';
+        for (const [, astNode] of astNodes) {
+            if (astNode.type === 'package_clause' && astNode.properties.packageName) {
+                packageName = astNode.properties.packageName;
+                break;
             }
         }
-        // Check against framework patterns
-        for (const framework of this.frameworkModels) {
-            let matched = false;
-            switch (framework.id) {
-                case 'go-net-http':
-                    matched = imports.has('net/http');
-                    break;
-                case 'go-gin':
-                    matched = imports.has('github.com/gin-gonic/gin');
+        const packageScope = {
+            id: packageName,
+            symbols: [],
+            kind: 'global',
+        };
+        scopes.set(packageName, packageScope);
+        for (const [_nodeId, astNode] of astNodes) {
+            switch (astNode.type) {
+                case 'function_declaration': {
+                    const funcId = `func_${astNode.id}`;
+                    const name = astNode.properties.name ?? 'anonymous';
+                    const params = astNode.properties.parameters ?? [];
+                    const isExp = astNode.properties.isExported ?? false;
+                    const funcSymbol = {
+                        name,
+                        kind: 'function',
+                        location: astNode.location,
+                        scopeId: packageName,
+                        properties: {
+                            isExported: isExp,
+                        },
+                        parameters: params.map((p, i) => ({
+                            name: p,
+                            index: i,
+                        })),
+                        returnType: astNode.properties.returnType,
+                    };
+                    functions.set(funcId, funcSymbol);
+                    symbols.set(funcId, funcSymbol);
+                    packageScope.symbols.push(funcId);
                     break;
-                case 'go-database-sql':
-                    matched = imports.has('database/sql');
+                }
+                case 'method_declaration': {
+                    const methodId = `method_${astNode.id}`;
+                    const name = astNode.properties.name ?? 'anonymous';
+                    const params = astNode.properties.parameters ?? [];
+                    const receiver = astNode.properties.receiver;
+                    const isExp = astNode.properties.isExported ?? false;
+                    const methodSymbol = {
+                        name,
+                        kind: 'method',
+                        location: astNode.location,
+                        scopeId: packageName,
+                        properties: {
+                            receiver,
+                            isExported: isExp,
+                        },
+                        parameters: params.map((p, i) => ({
+                            name: p,
+                            index: i,
+                        })),
+                        returnType: astNode.properties.returnType,
+                    };
+                    functions.set(methodId, methodSymbol);
+                    symbols.set(methodId, methodSymbol);
+                    packageScope.symbols.push(methodId);
                     break;
-                case 'go-os-exec':
-                    matched = imports.has('os/exec');
+                }
+                case 'type_declaration': {
+                    const typeId = `type_${astNode.id}`;
+                    const name = astNode.properties.name ?? 'Anonymous';
+                    const underlyingType = astNode.properties.underlyingType;
+                    const isExp = astNode.properties.isExported ?? false;
+                    if (underlyingType === 'struct_type') {
+                        const structSymbol = {
+                            name,
+                            kind: 'class',
+                            location: astNode.location,
+                            scopeId: packageName,
+                            methods: [],
+                            properties: [],
+                        };
+                        classes.set(typeId, structSymbol);
+                        const structAsSymbol = {
+                            name,
+                            kind: 'class',
+                            location: astNode.location,
+                            scopeId: packageName,
+                            properties: {
+                                structType: true,
+                                isExported: isExp,
+                            },
+                        };
+                        symbols.set(typeId, structAsSymbol);
+                    }
+                    else if (underlyingType === 'interface_type') {
+                        const interfaceSymbol = {
+                            name,
+                            kind: 'interface',
+                            location: astNode.location,
+                            scopeId: packageName,
+                            properties: {
+                                isExported: isExp,
+                            },
+                        };
+                        symbols.set(typeId, interfaceSymbol);
+                    }
+                    else {
+                        // Type alias
+                        const typeSymbol = {
+                            name,
+                            kind: 'type',
+                            location: astNode.location,
+                            scopeId: packageName,
+                            properties: {
+                                underlyingType,
+                                isExported: isExp,
+                            },
+                        };
+                        symbols.set(typeId, typeSymbol);
+                    }
+                    packageScope.symbols.push(typeId);
                     break;
-                case 'go-file-io':
-                    matched = imports.has('os') || imports.has('io/ioutil');
+                }
+                case 'const_declaration':
+                case 'var_declaration': {
+                    const varId = `var_${astNode.id}`;
+                    const name = astNode.properties.left ?? 'anonymous';
+                    const isConst = astNode.type === 'const_declaration';
+                    const varSymbol = {
+                        name,
+                        kind: isConst ? 'constant' : 'variable',
+                        location: astNode.location,
+                        scopeId: packageName,
+                        properties: {
+                            isExported: isExported(name),
+                        },
+                    };
+                    symbols.set(varId, varSymbol);
+                    packageScope.symbols.push(varId);
                     break;
-            }
-            if (matched) {
-                detected.push(framework);
+                }
             }
         }
-        return detected;
-    }
-    /**
-     * Create fallback AST for when tree-sitter is unavailable
-     */
-    createFallbackAST(code, filePath) {
-        const lines = code.split('\n');
         return {
-            id: `${filePath}#root`,
-            type: 'source_file',
-            text: code,
-            location: {
-                file: filePath,
-                startLine: 1,
-                endLine: lines.length,
-                startColumn: 0,
-                endColumn: lines[lines.length - 1]?.length ?? 0,
-            },
-            children: [],
-            metadata: {
-                fallback: true,
-                lineCount: lines.length,
-            },
+            symbols,
+            functions,
+            classes,
+            scopes,
+            global: symbols,
         };
     }
     /**
-     * Find nodes by type(s) in AST
+     * Check if identifier is exported (public)
+     * Go exports identifiers starting with uppercase
      */
-    findNodesByType(ast, types) {
-        const results = [];
-        const visit = (node) => {
-            if (types.includes(node.type)) {
-                results.push(node);
-            }
-            for (const child of node.children) {
-                visit(child);
-            }
-        };
-        visit(ast);
-        return results;
+    isExported(name) {
+        return isExported(name);
     }
 }
+/**
+ * Create Go extractor instance
+ * @trace REQ-SEC-GO-001
+ */
+export function createGoExtractor() {
+    return new GoExtractor();
+}
 //# sourceMappingURL=go-extractor.js.map