septum 0.1.5 → 0.1.7

package/src/core/parser/extractors/go.ts

@@ -39,16 +39,46 @@ const GO_STDLIB_PREFIXES = new Set([
   "unsafe",
 ]);
 
+import type Parser from "web-tree-sitter";
+import { blankCommentsAndStrings } from "../boundary-tracker.ts";
+import { calculateAstControlFlowNesting, parseWithTreeSitter } from "../wasm-loader.ts";
+
+const GO_CONTROL_FLOW_NODES = new Set([
+  "if_statement",
+  "for_statement",
+  "expression_switch_statement",
+  "type_switch_statement",
+  "select_statement",
+]);
+
+const GO_FUNCTION_BOUNDARY_NODES = new Set([
+  "function_declaration",
+  "method_declaration",
+  "func_literal",
+]);
+
 export class GoExtractor implements CodeExtractor {
   public canHandle(filePath: string): boolean {
     return /\.go$/i.test(filePath);
   }
 
   public async extract(filePath: string, content: string): Promise<ParsedFileAST> {
+    const astResult = await parseWithTreeSitter("go", content, (rootNode) =>
+      this.extractFromAst(rootNode, filePath, content)
+    );
+    if (astResult) {
+      return { ...astResult, status: "parsed" };
+    }
+
+    return { ...this.extractFallback(filePath, content), status: "degraded" };
+  }
+
+  private extractFallback(filePath: string, content: string): ParsedFileAST {
     const symbols: ExtractedSymbol[] = [];
     const dependencies: ExtractedDependency[] = [];
 
     const lines = content.split("\n");
+    const cleanLines = blankCommentsAndStrings(content).split("\n");
 
     // 1. Extract Go Imports
     let inImportBlock = false;
@@ -56,69 +86,74 @@ export class GoExtractor implements CodeExtractor {
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       const trimmed = line.trim();
+      const cleanTrimmed = cleanLines[i].trim();
       const lineNum = i + 1;
 
-      if (trimmed.startsWith("//")) continue;
+      if (!cleanTrimmed || trimmed.startsWith("//")) continue;
 
-      if (trimmed === "import (") {
+      if (cleanTrimmed.startsWith("import (")) {
         inImportBlock = true;
         continue;
       }
 
       if (inImportBlock) {
-        if (trimmed === ")") {
+        if (cleanTrimmed === ")") {
           inImportBlock = false;
           continue;
         }
 
-        const blockMatch = /^(?:[\w.]+\s+)?["']([^"']+)["']/.exec(trimmed);
+        const blockMatch = /^(?:([\w.]+)\s+)?["'`]([^"'`]+)["'`]/.exec(trimmed);
         if (blockMatch) {
-          const importPath = blockMatch[1];
+          const alias = blockMatch[1];
+          const importPath = blockMatch[2];
           const isExternal = this.isExternalImport(importPath, filePath);
+          const pkgSymbol = alias && alias !== "." && alias !== "_" ? alias : importPath.split("/").pop() || importPath;
           dependencies.push({
             target: importPath,
             statement: trimmed,
             line_number: lineNum,
             is_external: isExternal,
+            imported_symbols: [pkgSymbol],
           });
         }
         continue;
       }
 
-      // Single line import: import "fmt" or import alias "pkg"
-      const singleMatch = /^import\s+(?:[\w.]+\s+)?["']([^"']+)["']/.exec(trimmed);
+      const singleMatch = /^import\s+(?:([\w.]+)\s+)?["'`]([^"'`]+)["'`]/.exec(trimmed);
       if (singleMatch) {
-        const importPath = singleMatch[1];
+        const alias = singleMatch[1];
+        const importPath = singleMatch[2];
         const isExternal = this.isExternalImport(importPath, filePath);
+        const pkgSymbol = alias && alias !== "." && alias !== "_" ? alias : importPath.split("/").pop() || importPath;
         dependencies.push({
           target: importPath,
           statement: trimmed,
           line_number: lineNum,
           is_external: isExternal,
+          imported_symbols: [pkgSymbol],
         });
       }
     }
 
     // 2. Extract Go Types, Structs, Interfaces, and Functions
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
+    for (let i = 0; i < cleanLines.length; i++) {
+      const trimmed = cleanLines[i].trim();
+      const rawTrimmed = lines[i].trim();
       const lineNum = i + 1;
 
-      if (trimmed.startsWith("//")) continue;
+      if (!trimmed) continue;
 
-      // Struct or Interface: type User struct / type Reader interface
       const typeMatch = /^type\s+([A-Za-z0-9_]+)\s+(struct|interface)\b/.exec(trimmed);
       if (typeMatch) {
         const typeName = typeMatch[1];
         const kind = typeMatch[2] === "interface" ? "interface" : "class";
         const visibility: Visibility = /^[A-Z]/.test(typeName) ? "public" : "private";
-        const endLine = findBraceBlockEnd(lines, i);
+        const endLine = findBraceBlockEnd(cleanLines, i);
 
         symbols.push({
           name: typeName,
           kind,
-          signature: trimmed.replace(/\{$/, "").trim(),
+          signature: rawTrimmed.replace(/\{$/, "").trim(),
           visibility,
           line_start: lineNum,
           line_end: endLine,
@@ -127,18 +162,17 @@ export class GoExtractor implements CodeExtractor {
         continue;
       }
 
-      // Method with receiver: func (r *Repo) FindUser(...) (...)
       const methodMatch = /^func\s*\([^)]+\)\s*([A-Za-z0-9_]+)\s*\([^)]*\)/.exec(trimmed);
       if (methodMatch) {
         const methodName = methodMatch[1];
         const visibility: Visibility = /^[A-Z]/.test(methodName) ? "public" : "private";
-        const endLine = findBraceBlockEnd(lines, i);
+        const endLine = findBraceBlockEnd(cleanLines, i);
         const nestingDepth = calculateControlFlowNesting(lines, i, endLine - 1);
 
         symbols.push({
           name: methodName,
           kind: "method",
-          signature: trimmed.replace(/\{$/, "").trim(),
+          signature: rawTrimmed.replace(/\{$/, "").trim(),
           visibility,
           line_start: lineNum,
           line_end: endLine,
@@ -148,18 +182,17 @@ export class GoExtractor implements CodeExtractor {
         continue;
       }
 
-      // Function: func ProcessPayment(...) (...)
       const funcMatch = /^func\s+([A-Za-z0-9_]+)\s*\([^)]*\)/.exec(trimmed);
       if (funcMatch) {
         const funcName = funcMatch[1];
         const visibility: Visibility = /^[A-Z]/.test(funcName) ? "public" : "private";
-        const endLine = findBraceBlockEnd(lines, i);
+        const endLine = findBraceBlockEnd(cleanLines, i);
         const nestingDepth = calculateControlFlowNesting(lines, i, endLine - 1);
 
         symbols.push({
           name: funcName,
           kind: "function",
-          signature: trimmed.replace(/\{$/, "").trim(),
+          signature: rawTrimmed.replace(/\{$/, "").trim(),
           visibility,
           line_start: lineNum,
           line_end: endLine,
@@ -175,6 +208,7 @@ export class GoExtractor implements CodeExtractor {
     };
   }
 
+
   private isExternalImport(importPath: string, filePath?: string): boolean {
     if (this.isGoStdlib(importPath)) {
       return true;
@@ -226,4 +260,149 @@ export class GoExtractor implements CodeExtractor {
     const rootSegment = importPath.split("/")[0];
     return GO_STDLIB_PREFIXES.has(rootSegment) || !importPath.includes(".");
   }
+
+  private extractFromAst(
+    rootNode: Parser.SyntaxNode,
+    filePath: string,
+    content: string
+  ): ParsedFileAST {
+    const symbols: ExtractedSymbol[] = [];
+    const dependencies: ExtractedDependency[] = [];
+    const lines = content.split("\n");
+
+    const addImportSpec = (specNode: Parser.SyntaxNode): void => {
+      const pathNode =
+        specNode.childForFieldName("path") ??
+        specNode.namedChildren.find(
+          (c) => c.type === "interpreted_string_literal" || c.type === "raw_string_literal"
+        );
+      if (!pathNode) return;
+
+      const importPath = pathNode.text.replace(/^["'`]|["'`]$/g, "").trim();
+      if (!importPath) return;
+
+      const nameNode =
+        specNode.childForFieldName("name") ??
+        specNode.namedChildren.find((c) => c.type === "package_identifier" || c.type === "dot" || c.type === "blank_identifier");
+      const alias = nameNode?.text?.trim();
+      const pkgSymbol =
+        alias && alias !== "." && alias !== "_" ? alias : importPath.split("/").pop() || importPath;
+
+      dependencies.push({
+        target: importPath,
+        statement: (lines[specNode.startPosition.row] ?? specNode.text).trim(),
+        line_number: specNode.startPosition.row + 1,
+        is_external: this.isExternalImport(importPath, filePath),
+        imported_symbols: [pkgSymbol],
+      });
+    };
+
+    for (const node of rootNode.namedChildren) {
+      if (node.type === "import_declaration") {
+        for (const child of node.namedChildren) {
+          if (child.type === "import_spec") {
+            addImportSpec(child);
+          } else if (child.type === "import_spec_list") {
+            for (const spec of child.namedChildren) {
+              if (spec.type === "import_spec") {
+                addImportSpec(spec);
+              }
+            }
+          }
+        }
+        continue;
+      }
+
+      if (node.type === "type_declaration") {
+        for (const spec of node.namedChildren) {
+          if (spec.type !== "type_spec" && spec.type !== "type_alias") continue;
+          const nameNode =
+            spec.childForFieldName("name") ??
+            spec.namedChildren.find((c) => c.type === "type_identifier");
+          if (!nameNode) continue;
+
+          const typeName = nameNode.text;
+          const typeVal = spec.childForFieldName("type") ?? spec.namedChildren[1];
+          const kind = typeVal?.type === "interface_type" ? "interface" : "class";
+          const visibility: Visibility = /^[A-Z]/.test(typeName) ? "public" : "private";
+          const lineStart = spec.startPosition.row + 1;
+          const lineEnd = Math.max(lineStart, spec.endPosition.row + 1);
+          const headerLine = (lines[spec.startPosition.row] ?? "").trim().replace(/\{$/, "").trim();
+
+          symbols.push({
+            name: typeName,
+            kind,
+            signature: headerLine || `type ${typeName}`,
+            visibility,
+            line_start: lineStart,
+            line_end: lineEnd,
+            line_count: Math.max(1, lineEnd - lineStart + 1),
+          });
+        }
+        continue;
+      }
+
+      if (node.type === "method_declaration") {
+        const nameNode =
+          node.childForFieldName("name") ??
+          node.namedChildren.find((c) => c.type === "field_identifier" || c.type === "identifier");
+        if (!nameNode) continue;
+
+        const methodName = nameNode.text;
+        const visibility: Visibility = /^[A-Z]/.test(methodName) ? "public" : "private";
+        const lineStart = node.startPosition.row + 1;
+        const lineEnd = Math.max(lineStart, node.endPosition.row + 1);
+        const headerLine = (lines[node.startPosition.row] ?? "").trim().replace(/\{$/, "").trim();
+        const nestingDepth = calculateAstControlFlowNesting(
+          node,
+          GO_CONTROL_FLOW_NODES,
+          GO_FUNCTION_BOUNDARY_NODES
+        );
+
+        symbols.push({
+          name: methodName,
+          kind: "method",
+          signature: headerLine || `func ${methodName}()`,
+          visibility,
+          line_start: lineStart,
+          line_end: lineEnd,
+          line_count: Math.max(1, lineEnd - lineStart + 1),
+          nesting_depth: nestingDepth,
+        });
+        continue;
+      }
+
+      if (node.type === "function_declaration") {
+        const nameNode =
+          node.childForFieldName("name") ??
+          node.namedChildren.find((c) => c.type === "identifier");
+        if (!nameNode) continue;
+
+        const funcName = nameNode.text;
+        const visibility: Visibility = /^[A-Z]/.test(funcName) ? "public" : "private";
+        const lineStart = node.startPosition.row + 1;
+        const lineEnd = Math.max(lineStart, node.endPosition.row + 1);
+        const headerLine = (lines[node.startPosition.row] ?? "").trim().replace(/\{$/, "").trim();
+        const nestingDepth = calculateAstControlFlowNesting(
+          node,
+          GO_CONTROL_FLOW_NODES,
+          GO_FUNCTION_BOUNDARY_NODES
+        );
+
+        symbols.push({
+          name: funcName,
+          kind: "function",
+          signature: headerLine || `func ${funcName}()`,
+          visibility,
+          line_start: lineStart,
+          line_end: lineEnd,
+          line_count: Math.max(1, lineEnd - lineStart + 1),
+          nesting_depth: nestingDepth,
+        });
+      }
+    }
+
+    return { symbols, dependencies };
+  }
 }
+

package/src/core/parser/extractors/laravel-semantic.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExecutionChainNode, VerticalSliceRecord } from "../../../types/index.ts";
 import { BehavioralAnalyzer } from "../behavioral-analyzer.ts";
+import { blankCommentsAndStrings } from "../boundary-tracker.ts";
 import { SchemaProviderRegistry } from "../schema/schema-provider-registry.ts";
 import type {
   SemanticSliceExtractor,
@@ -312,6 +313,7 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
 
     // 2. Parse routes with group context tracking (prefix, controller, name prefix)
     const lines = content.split(/\r?\n/);
+    const cleanLines = blankCommentsAndStrings(content, { hashComments: true }).split(/\r?\n/);
     interface GroupContext {
       prefix: string;
       controller: string;
@@ -326,10 +328,14 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
 
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
+      const cleanLine = cleanLines[i] ?? "";
+      const cleanTrimmed = cleanLine.trim();
       const trimmed = line.trim();
 
+      if (!cleanTrimmed) continue;
+
       // Check group opens: Route::...group(
-      if (trimmed.includes("Route::") && trimmed.includes("group(") && trimmed.includes("function")) {
+      if (cleanTrimmed.includes("Route::") && cleanTrimmed.includes("group(") && cleanTrimmed.includes("function")) {
         const prefixMatch = /prefix\s*\(\s*['"]([^'"]+)['"]\s*\)/.exec(trimmed);
         const controllerMatch = /controller\s*\(\s*([\\A-Za-z0-9_]+)::class\s*\)/.exec(trimmed);
         const nameMatch = /name\s*\(\s*['"]([^'"]+)['"]\s*\)/.exec(trimmed);
@@ -351,8 +357,8 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
         });
       }
 
-      // Track brace depth
-      for (const char of line) {
+      // Track brace depth on string/comment-stripped line so '/orders/{id}' never corrupts braceDepth
+      for (const char of cleanLine) {
         if (char === "{") currentBraceDepth++;
         if (char === "}") {
           currentBraceDepth--;
@@ -366,14 +372,14 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
       }
 
       // Route statement accumulation across lines
-      if (!inStatement && trimmed.startsWith("Route::") && !trimmed.includes("Route::resource") && !trimmed.includes("Route::group")) {
+      if (!inStatement && cleanTrimmed.startsWith("Route::") && !cleanTrimmed.includes("Route::resource") && !cleanTrimmed.includes("Route::group") && !(cleanTrimmed.includes("group(") && cleanTrimmed.includes("function"))) {
         statementBuffer = trimmed;
         inStatement = true;
       } else if (inStatement) {
         statementBuffer += " " + trimmed;
       }
 
-      if (inStatement && statementBuffer.includes(";")) {
+      if (inStatement && cleanLine.includes(";")) {
         inStatement = false;
         const stmt = statementBuffer;
         statementBuffer = "";
@@ -519,16 +525,17 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
   }
 
   private extractActionBody(controllerCode: string, actionName: string): string {
-    const fnRegex = new RegExp(`public\\s+function\\s+${actionName}\\s*\\([^{]*\\)\\s*\\{`, "i");
-    const match = fnRegex.exec(controllerCode);
+    const cleanCode = blankCommentsAndStrings(controllerCode, { hashComments: true });
+    const fnRegex = new RegExp(`(?:public\\s+)?function\\s+${actionName}\\s*\\([^{]*\\)\\s*\\{`, "i");
+    const match = fnRegex.exec(cleanCode);
     if (!match) return "";
 
     const startIndex = match.index + match[0].length;
     let braceDepth = 1;
     let endIndex = startIndex;
 
-    while (braceDepth > 0 && endIndex < controllerCode.length) {
-      const char = controllerCode[endIndex];
+    while (braceDepth > 0 && endIndex < cleanCode.length) {
+      const char = cleanCode[endIndex];
       if (char === "{") braceDepth++;
       else if (char === "}") braceDepth--;
       endIndex++;
@@ -750,10 +757,9 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
 
   private extractValidationRules(requestCode: string): Record<string, string> {
     const rules: Record<string, string> = {};
-    const rulesMatch = requestCode.match(/function\s+rules\s*\(\s*\)[^{]*\{([^}]*)\}/i);
-    if (!rulesMatch) return rules;
+    const body = this.extractActionBody(requestCode, "rules");
+    if (!body) return rules;
 
-    const body = rulesMatch[1];
     // Match 'status' => 'in:pending,paid' or 'status' => ['required', 'string']
     const rulePairRegex = /['"]([A-Za-z0-9_]+)['"]\s*=>\s*(?:['"]([^'"]+)['"]|\[([^\]]+)\])/g;
     let rm;