septum 0.1.0

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

@@ -0,0 +1,194 @@
+import type {
+  ExtractedDependency,
+  ExtractedSymbol,
+  ParsedFileAST,
+} from "../../../types/index.ts";
+import type { CodeExtractor } from "./base.ts";
+
+export class FrontendExtractor implements CodeExtractor {
+  public canHandle(filePath: string): boolean {
+    return /\.(vue|astro|svelte)$/i.test(filePath);
+  }
+
+  public async extract(filePath: string, content: string): Promise<ParsedFileAST> {
+    const symbols: ExtractedSymbol[] = [];
+    const dependencies: ExtractedDependency[] = [];
+
+    const isVue = /\.vue$/i.test(filePath);
+    const isAstro = /\.astro$/i.test(filePath);
+    const isSvelte = /\.svelte$/i.test(filePath);
+
+    if (isVue) {
+      this.extractVue(content, symbols, dependencies);
+    } else if (isAstro) {
+      this.extractAstro(content, symbols, dependencies);
+    } else if (isSvelte) {
+      this.extractSvelte(content, symbols, dependencies);
+    }
+
+    return { symbols, dependencies };
+  }
+
+  private extractVue(
+    content: string,
+    symbols: ExtractedSymbol[],
+    dependencies: ExtractedDependency[]
+  ): void {
+    // Match <script> and <script setup> blocks
+    const scriptRegex = /<script(\s+[^>]*?)?>([\s\S]*?)<\/script>/gi;
+    let match: RegExpExecArray | null;
+
+    while ((match = scriptRegex.exec(content)) !== null) {
+      const fullMatch = match[0];
+      const attributes = match[1] || "";
+      const scriptBody = match[2];
+      const isSetup = /\bsetup\b/i.test(attributes);
+
+      // Calculate start line of the script body
+      const beforeMatch = content.slice(0, match.index);
+      const tagOpenMatch = fullMatch.match(/<script(\s+[^>]*?)?>/i);
+      const tagOpenLen = tagOpenMatch ? tagOpenMatch[0].length : 0;
+      const scriptStartOffset = match.index + tagOpenLen;
+      const startLine = content.slice(0, scriptStartOffset).split("\n").length;
+
+      // Extract symbols and dependencies from this script block
+      this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
+
+      if (isSetup) {
+        symbols.push({
+          name: "<script setup>",
+          kind: "method",
+          signature: "script setup",
+          visibility: "public",
+          line_start: startLine,
+          line_end: startLine + scriptBody.split("\n").length,
+          line_count: scriptBody.split("\n").length,
+        });
+      }
+    }
+
+    // Vue defineProps / defineEmits detection
+    const definePropsMatch = content.match(/defineProps\s*<([^>]+)>/);
+    if (definePropsMatch) {
+      const line = content.slice(0, content.indexOf(definePropsMatch[0])).split("\n").length;
+      symbols.push({
+        name: "Props",
+        kind: "interface",
+        signature: `defineProps<${definePropsMatch[1]}>`,
+        visibility: "public",
+        line_start: line,
+        line_end: line,
+        line_count: 1,
+      });
+    }
+  }
+
+  private extractAstro(
+    content: string,
+    symbols: ExtractedSymbol[],
+    dependencies: ExtractedDependency[]
+  ): void {
+    // Astro frontmatter is between the first --- and the second ---
+    const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (frontmatterMatch) {
+      const scriptBody = frontmatterMatch[1];
+      const startLine = 2; // Line 1 is '---'
+      this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
+    }
+  }
+
+  private extractSvelte(
+    content: string,
+    symbols: ExtractedSymbol[],
+    dependencies: ExtractedDependency[]
+  ): void {
+    const scriptRegex = /<script(\s+[^>]*?)?>([\s\S]*?)<\/script>/gi;
+    let match: RegExpExecArray | null;
+
+    while ((match = scriptRegex.exec(content)) !== null) {
+      const fullMatch = match[0];
+      const scriptBody = match[2];
+      const tagOpenMatch = fullMatch.match(/<script(\s+[^>]*?)?>/i);
+      const tagOpenLen = tagOpenMatch ? tagOpenMatch[0].length : 0;
+      const scriptStartOffset = match.index + tagOpenLen;
+      const startLine = content.slice(0, scriptStartOffset).split("\n").length;
+
+      this.extractScriptContent(scriptBody, startLine, symbols, dependencies);
+    }
+  }
+
+  private extractScriptContent(
+    scriptContent: string,
+    lineOffset: number,
+    symbols: ExtractedSymbol[],
+    dependencies: ExtractedDependency[]
+  ): void {
+    const lines = scriptContent.split("\n");
+
+    // 1. Extract Imports
+    const importRegex = /(?:import\s+(?:(?:[\w*\s{},]+)\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let match: RegExpExecArray | null;
+      while ((match = importRegex.exec(line)) !== null) {
+        const target = match[1] || match[2];
+        if (target) {
+          const isExternal = !target.startsWith(".") && !target.startsWith("/");
+          dependencies.push({
+            target,
+            statement: line.trim(),
+            line_number: lineOffset + i,
+            is_external: isExternal,
+          });
+        }
+      }
+    }
+
+    // 2. Extract Functions / Methods / Classes / Components
+    const funcRegex = /(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([a-zA-Z0-9_]+)/g;
+    const constFuncRegex = /(?:export\s+)?const\s+([a-zA-Z0-9_]+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-zA-Z0-9_]+)\s*=>/g;
+    const classRegex = /(?:export\s+)?class\s+([a-zA-Z0-9_]+)/g;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const currentLineNum = lineOffset + i;
+
+      let m: RegExpExecArray | null;
+      while ((m = funcRegex.exec(line)) !== null) {
+        symbols.push({
+          name: m[1],
+          kind: "function",
+          signature: line.trim(),
+          visibility: line.includes("export") ? "public" : "private",
+          line_start: currentLineNum,
+          line_end: currentLineNum,
+          line_count: 1,
+        });
+      }
+
+      while ((m = constFuncRegex.exec(line)) !== null) {
+        symbols.push({
+          name: m[1],
+          kind: "function",
+          signature: line.trim(),
+          visibility: line.includes("export") ? "public" : "private",
+          line_start: currentLineNum,
+          line_end: currentLineNum,
+          line_count: 1,
+        });
+      }
+
+      while ((m = classRegex.exec(line)) !== null) {
+        symbols.push({
+          name: m[1],
+          kind: "class",
+          signature: line.trim(),
+          visibility: line.includes("export") ? "public" : "private",
+          line_start: currentLineNum,
+          line_end: currentLineNum,
+          line_count: 1,
+        });
+      }
+    }
+  }
+}

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

@@ -0,0 +1,176 @@
+import type { ExtractedDependency, ExtractedSymbol, ParsedFileAST, Visibility } from "../../../types/index.ts";
+import { findBraceBlockEnd } from "../boundary-tracker.ts";
+import type { CodeExtractor } from "./base.ts";
+
+const GO_STDLIB_PREFIXES = new Set([
+  "bufio",
+  "bytes",
+  "context",
+  "crypto",
+  "database",
+  "encoding",
+  "errors",
+  "flag",
+  "fmt",
+  "html",
+  "image",
+  "io",
+  "log",
+  "math",
+  "mime",
+  "net",
+  "os",
+  "path",
+  "plugin",
+  "reflect",
+  "regexp",
+  "runtime",
+  "sort",
+  "strconv",
+  "strings",
+  "sync",
+  "syscall",
+  "testing",
+  "text",
+  "time",
+  "unicode",
+  "unsafe",
+]);
+
+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 symbols: ExtractedSymbol[] = [];
+    const dependencies: ExtractedDependency[] = [];
+
+    const lines = content.split("\n");
+
+    // 1. Extract Go Imports
+    let inImportBlock = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+
+      if (trimmed.startsWith("//")) continue;
+
+      if (trimmed === "import (") {
+        inImportBlock = true;
+        continue;
+      }
+
+      if (inImportBlock) {
+        if (trimmed === ")") {
+          inImportBlock = false;
+          continue;
+        }
+
+        const blockMatch = /^(?:[\w.]+\s+)?["']([^"']+)["']/.exec(trimmed);
+        if (blockMatch) {
+          const importPath = blockMatch[1];
+          const isExternal = this.isGoStdlib(importPath);
+          dependencies.push({
+            target: importPath,
+            statement: trimmed,
+            line_number: lineNum,
+            is_external: isExternal,
+          });
+        }
+        continue;
+      }
+
+      // Single line import: import "fmt" or import alias "pkg"
+      const singleMatch = /^import\s+(?:[\w.]+\s+)?["']([^"']+)["']/.exec(trimmed);
+      if (singleMatch) {
+        const importPath = singleMatch[1];
+        const isExternal = this.isGoStdlib(importPath);
+        dependencies.push({
+          target: importPath,
+          statement: trimmed,
+          line_number: lineNum,
+          is_external: isExternal,
+        });
+      }
+    }
+
+    // 2. Extract Go Types, Structs, Interfaces, and Functions
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+
+      if (trimmed.startsWith("//")) 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);
+
+        symbols.push({
+          name: typeName,
+          kind,
+          signature: trimmed.replace(/\{$/, "").trim(),
+          visibility,
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+        });
+        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);
+
+        symbols.push({
+          name: methodName,
+          kind: "method",
+          signature: trimmed.replace(/\{$/, "").trim(),
+          visibility,
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+        });
+        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);
+
+        symbols.push({
+          name: funcName,
+          kind: "function",
+          signature: trimmed.replace(/\{$/, "").trim(),
+          visibility,
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+        });
+      }
+    }
+
+    return {
+      symbols,
+      dependencies,
+    };
+  }
+
+  private isGoStdlib(importPath: string): boolean {
+    const rootSegment = importPath.split("/")[0];
+    return GO_STDLIB_PREFIXES.has(rootSegment) || !importPath.includes(".");
+  }
+}