@thoughtflow/codebase 0.2.0

package/src/libs/codebase-index.class.ts

@@ -0,0 +1,715 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type CodebaseSearchMode = "hybrid" | "content" | "path" | "symbol";
+export type CodebaseSymbolKind =
+  | "class"
+  | "function"
+  | "method"
+  | "interface"
+  | "type"
+  | "enum"
+  | "const"
+  | "variable";
+
+export interface CodebaseSearchFilters {
+  pathPrefix?: string;
+  extensions?: string[];
+  includeGlobs?: string[];
+  excludeGlobs?: string[];
+  includeHidden?: boolean;
+}
+
+export interface CodebaseSearchOptions extends CodebaseSearchFilters {
+  query?: string;
+  mode: CodebaseSearchMode;
+  limit: number;
+  offset: number;
+  regex?: boolean;
+  caseSensitive?: boolean;
+  symbolKinds?: CodebaseSymbolKind[];
+  maxSnippetChars?: number;
+}
+
+export interface CodebaseSearchHit {
+  path: string;
+  line?: number;
+  column?: number;
+  snippet?: string;
+  symbol?: string;
+  kind?: CodebaseSymbolKind;
+  source: "path" | "content" | "symbol";
+  score: number;
+}
+
+export interface CodebaseIndexStats {
+  rootDir: string;
+  fileCount: number;
+  symbolCount: number;
+  hasFts: boolean;
+  indexedAt: string | null;
+}
+
+interface IndexedFileRow {
+  id: number;
+  path: string;
+  ext: string;
+  content: string;
+}
+
+interface SymbolRow {
+  path: string;
+  name: string;
+  kind: CodebaseSymbolKind;
+  line: number;
+  column: number;
+  signature: string | null;
+}
+
+type SourceLanguage =
+  | "ts"
+  | "js"
+  | "python"
+  | "php"
+  | "go"
+  | "java"
+  | "csharp"
+  | "rust"
+  | "ruby"
+  | "other";
+
+interface SymbolPattern {
+  kind: CodebaseSymbolKind;
+  regex: RegExp;
+  languages: SourceLanguage[];
+}
+
+const DEFAULT_SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  "out",
+  ".next",
+  ".turbo",
+  ".cache",
+  "vendor",
+]);
+
+const DEFAULT_BINARY_EXTS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tar", ".tgz",
+  ".bz2", ".7z", ".rar", ".mp4", ".mov", ".avi", ".mp3", ".wav", ".woff", ".woff2", ".ttf",
+  ".eot", ".class", ".jar", ".exe", ".dll", ".so", ".dylib", ".bin", ".wasm", ".map",
+]);
+
+const SYMBOL_PATTERNS: SymbolPattern[] = [
+  // TS/JS
+  { kind: "class", regex: /\bclass\s+([A-Za-z_$][\w$]*)/g, languages: ["ts", "js"] },
+  { kind: "interface", regex: /\binterface\s+([A-Za-z_$][\w$]*)/g, languages: ["ts"] },
+  { kind: "type", regex: /\btype\s+([A-Za-z_$][\w$]*)\s*=/g, languages: ["ts"] },
+  { kind: "enum", regex: /\benum\s+([A-Za-z_$][\w$]*)/g, languages: ["ts", "js"] },
+  { kind: "function", regex: /\bfunction\s+([A-Za-z_$][\w$]*)\s*\(/g, languages: ["ts", "js"] },
+  { kind: "const", regex: /\bconst\s+([A-Za-z_$][\w$]*)\s*=/g, languages: ["ts", "js"] },
+  { kind: "variable", regex: /\b(?:let|var)\s+([A-Za-z_$][\w$]*)\s*=/g, languages: ["ts", "js"] },
+  { kind: "method", regex: /^\s*(?:public|private|protected|async|static|readonly\s+)*([A-Za-z_$][\w$]*)\s*\([^\n)]*\)\s*\{/g, languages: ["ts", "js"] },
+
+  // Python
+  { kind: "class", regex: /^\s*class\s+([A-Za-z_][\w]*)\s*(?:\(|:)/g, languages: ["python"] },
+  { kind: "function", regex: /^\s*def\s+([A-Za-z_][\w]*)\s*\(/g, languages: ["python"] },
+
+  // PHP
+  { kind: "class", regex: /\bclass\s+([A-Za-z_][\w]*)/g, languages: ["php"] },
+  { kind: "interface", regex: /\binterface\s+([A-Za-z_][\w]*)/g, languages: ["php"] },
+  { kind: "enum", regex: /\benum\s+([A-Za-z_][\w]*)/g, languages: ["php"] },
+  { kind: "function", regex: /\bfunction\s+([A-Za-z_][\w]*)\s*\(/g, languages: ["php"] },
+
+  // Go
+  { kind: "type", regex: /^\s*type\s+([A-Za-z_][\w]*)\s+(?:struct|interface|\w+)/g, languages: ["go"] },
+  { kind: "function", regex: /^\s*func\s+(?:\([^)]+\)\s*)?([A-Za-z_][\w]*)\s*\(/g, languages: ["go"] },
+
+  // Java
+  { kind: "class", regex: /\bclass\s+([A-Za-z_][\w]*)/g, languages: ["java"] },
+  { kind: "interface", regex: /\binterface\s+([A-Za-z_][\w]*)/g, languages: ["java"] },
+  { kind: "enum", regex: /\benum\s+([A-Za-z_][\w]*)/g, languages: ["java"] },
+  { kind: "method", regex: /^\s*(?:public|private|protected|static|final|synchronized|native|abstract)\s+[A-Za-z_<>,\[\]\s]+\s+([A-Za-z_][\w]*)\s*\(/g, languages: ["java"] },
+
+  // C#
+  { kind: "class", regex: /\bclass\s+([A-Za-z_][\w]*)/g, languages: ["csharp"] },
+  { kind: "interface", regex: /\binterface\s+([A-Za-z_][\w]*)/g, languages: ["csharp"] },
+  { kind: "enum", regex: /\benum\s+([A-Za-z_][\w]*)/g, languages: ["csharp"] },
+  { kind: "method", regex: /^\s*(?:public|private|protected|internal|static|virtual|override|async)\s+[A-Za-z_<>,\[\]\?\s]+\s+([A-Za-z_][\w]*)\s*\(/g, languages: ["csharp"] },
+
+  // Rust
+  { kind: "type", regex: /^\s*(?:pub\s+)?(?:struct|trait|type)\s+([A-Za-z_][\w]*)/g, languages: ["rust"] },
+  { kind: "enum", regex: /^\s*(?:pub\s+)?enum\s+([A-Za-z_][\w]*)/g, languages: ["rust"] },
+  { kind: "function", regex: /^\s*(?:pub\s+)?fn\s+([A-Za-z_][\w]*)\s*\(/g, languages: ["rust"] },
+
+  // Ruby
+  { kind: "class", regex: /^\s*class\s+([A-Za-z_][\w:]*)/g, languages: ["ruby"] },
+  { kind: "function", regex: /^\s*def\s+([A-Za-z_][\w!?=]*)/g, languages: ["ruby"] },
+];
+
+export class CodebaseIndex {
+  private static readonly shared = new Map<string, CodebaseIndex>();
+
+  static async forRoot(rootDir: string): Promise<CodebaseIndex> {
+    const { default: Database } = await import("better-sqlite3");
+    const key = path.resolve(rootDir);
+    const existing = this.shared.get(key);
+    if (existing) return existing;
+    const created = new CodebaseIndex(key, Database);
+    this.shared.set(key, created);
+    return created;
+  }
+
+  private readonly db: any;
+  private hasFts = false;
+  private indexedAtMs: number | null = null;
+  private indexed = false;
+
+  private constructor(private readonly rootDir: string, Database: any) {
+    this.db = new Database(":memory:");
+    this.db.pragma("journal_mode = OFF");
+    this.db.pragma("synchronous = OFF");
+    this.db.pragma("temp_store = MEMORY");
+    this.createSchema();
+  }
+
+  isIndexed(): boolean {
+    return this.indexed;
+  }
+
+  rebuild(maxFileBytes = 1024 * 1024): CodebaseIndexStats {
+    this.clearIndex();
+
+    const files = this.collectFiles(this.rootDir);
+
+    const insertFile = this.db.prepare(
+      "INSERT INTO files (rel_path, ext, mtime_ms, size_bytes, content) VALUES (?, ?, ?, ?, ?)"
+    );
+    const insertFts = this.hasFts
+      ? this.db.prepare("INSERT INTO files_fts (rowid, rel_path, content) VALUES (?, ?, ?)")
+      : null;
+    const insertSymbol = this.db.prepare(
+      "INSERT INTO symbols (file_id, name, kind, line, column, signature) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+
+    const tx = this.db.transaction((absolutePaths: string[]) => {
+      for (const absPath of absolutePaths) {
+        let stat: fs.Stats;
+        try {
+          stat = fs.statSync(absPath);
+        } catch {
+          continue;
+        }
+        if (!stat.isFile()) continue;
+        if (stat.size > maxFileBytes) continue;
+        if (!this.isLikelyText(absPath)) continue;
+
+        let content: string;
+        try {
+          content = fs.readFileSync(absPath, "utf8");
+        } catch {
+          continue;
+        }
+
+        const relPath = this.normalizeRel(absPath);
+        const ext = path.extname(absPath).toLowerCase();
+        const inserted = insertFile.run(relPath, ext, Math.floor(stat.mtimeMs), stat.size, content);
+        const fileId = Number(inserted.lastInsertRowid);
+
+        if (insertFts) {
+          insertFts.run(fileId, relPath, content);
+        }
+
+        for (const symbol of this.extractSymbols(content, ext)) {
+          insertSymbol.run(
+            fileId,
+            symbol.name,
+            symbol.kind,
+            symbol.line,
+            symbol.column,
+            symbol.signature
+          );
+        }
+      }
+    });
+
+    tx(files);
+    this.indexedAtMs = Date.now();
+    this.indexed = true;
+    return this.getStats();
+  }
+
+  getStats(): CodebaseIndexStats {
+    const fileRow = this.db.prepare("SELECT COUNT(*) AS c FROM files").get() as { c?: number } | undefined;
+    const symbolRow = this.db.prepare("SELECT COUNT(*) AS c FROM symbols").get() as { c?: number } | undefined;
+    const fileCount = Number(fileRow?.c ?? 0);
+    const symbolCount = Number(symbolRow?.c ?? 0);
+    return {
+      rootDir: this.rootDir,
+      fileCount,
+      symbolCount,
+      hasFts: this.hasFts,
+      indexedAt: this.indexedAtMs ? new Date(this.indexedAtMs).toISOString() : null,
+    };
+  }
+
+  search(options: CodebaseSearchOptions): CodebaseSearchHit[] {
+    const mode = options.mode;
+    const allHits: CodebaseSearchHit[] = [];
+
+    if (mode === "path" || mode === "hybrid") {
+      allHits.push(...this.searchPaths(options));
+    }
+
+    if (mode === "content" || mode === "hybrid") {
+      allHits.push(...this.searchContent(options));
+    }
+
+    if (mode === "symbol" || mode === "hybrid") {
+      allHits.push(...this.searchSymbols(options));
+    }
+
+    const dedup = new Map<string, CodebaseSearchHit>();
+    for (const hit of allHits) {
+      const key = `${hit.source}|${hit.path}|${hit.line ?? 0}|${hit.column ?? 0}|${hit.symbol ?? ""}`;
+      const existing = dedup.get(key);
+      if (!existing || hit.score > existing.score) dedup.set(key, hit);
+    }
+
+    const sorted = Array.from(dedup.values()).sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      if (a.path !== b.path) return a.path.localeCompare(b.path);
+      return (a.line ?? 0) - (b.line ?? 0);
+    });
+
+    const offset = Math.max(0, options.offset);
+    const limit = Math.max(1, options.limit);
+    return sorted.slice(offset, offset + limit);
+  }
+
+  private searchPaths(options: CodebaseSearchOptions): CodebaseSearchHit[] {
+    const docs = this.queryDocuments(options);
+    const query = (options.query ?? "").trim();
+    if (!query && !options.pathPrefix && !options.includeGlobs?.length) return [];
+
+    const matcher = this.makeMatcher(query, options.regex === true, options.caseSensitive === true);
+    const hits: CodebaseSearchHit[] = [];
+
+    for (const doc of docs) {
+      if (!query || matcher(doc.path)) {
+        hits.push({
+          path: doc.path,
+          source: "path",
+          score: this.pathScore(doc.path, query),
+        });
+      }
+    }
+
+    return hits;
+  }
+
+  private searchContent(options: CodebaseSearchOptions): CodebaseSearchHit[] {
+    const query = (options.query ?? "").trim();
+    if (!query) return [];
+
+    const docs = this.queryDocuments(options, { forContent: true, query, regex: options.regex === true });
+    const matchLine = this.makeLineFinder(
+      query,
+      options.regex === true,
+      options.caseSensitive === true,
+      options.maxSnippetChars ?? 220
+    );
+
+    const hits: CodebaseSearchHit[] = [];
+    for (const doc of docs) {
+      const lineHit = matchLine(doc.content);
+      if (!lineHit) continue;
+      hits.push({
+        path: doc.path,
+        line: lineHit.line,
+        column: lineHit.column,
+        snippet: lineHit.snippet,
+        source: "content",
+        score: lineHit.exact ? 95 : 78,
+      });
+    }
+
+    return hits;
+  }
+
+  private searchSymbols(options: CodebaseSearchOptions): CodebaseSearchHit[] {
+    const query = (options.query ?? "").trim();
+    if (!query) return [];
+
+    const conds: string[] = [];
+    const params: unknown[] = [];
+
+    if (options.pathPrefix) {
+      conds.push("f.rel_path LIKE ? ESCAPE '\\\\'");
+      params.push(`${escapeLike(this.normalizeRel(options.pathPrefix))}%`);
+    }
+
+    if (options.extensions && options.extensions.length > 0) {
+      conds.push(`f.ext IN (${options.extensions.map(() => "?").join(",")})`);
+      params.push(...options.extensions.map((ext) => normalizeExt(ext)));
+    }
+
+    if (options.symbolKinds && options.symbolKinds.length > 0) {
+      conds.push(`s.kind IN (${options.symbolKinds.map(() => "?").join(",")})`);
+      params.push(...options.symbolKinds);
+    }
+
+    let sql =
+      "SELECT f.rel_path AS path, s.name AS name, s.kind AS kind, s.line AS line, s.column AS column, s.signature AS signature " +
+      "FROM symbols s JOIN files f ON f.id = s.file_id";
+    if (conds.length > 0) sql += ` WHERE ${conds.join(" AND ")}`;
+
+    const rows = this.db.prepare(sql).all(...params) as SymbolRow[];
+    const matchName = this.makeMatcher(query, options.regex === true, options.caseSensitive === true);
+
+    const hits: CodebaseSearchHit[] = [];
+    for (const row of rows) {
+      if (!this.applyGlobFilters(row.path, options)) continue;
+      if (!matchName(row.name)) continue;
+      hits.push({
+        path: row.path,
+        line: row.line,
+        column: row.column,
+        snippet: row.signature ?? undefined,
+        symbol: row.name,
+        kind: row.kind,
+        source: "symbol",
+        score: row.name === query ? 100 : 86,
+      });
+    }
+
+    return hits;
+  }
+
+  private queryDocuments(
+    filters: CodebaseSearchFilters,
+    contentQuery?: { forContent: boolean; query: string; regex: boolean }
+  ): IndexedFileRow[] {
+    if (contentQuery && this.hasFts && !contentQuery.regex) {
+      const ftsQuery = toFtsQuery(contentQuery.query);
+      if (ftsQuery) {
+        try {
+          const rows = this.db
+            .prepare(
+              "SELECT f.id AS id, f.rel_path AS path, f.ext AS ext, f.content AS content " +
+              "FROM files_fts ft JOIN files f ON f.id = ft.rowid " +
+              "WHERE files_fts MATCH ? LIMIT 500"
+            )
+            .all(ftsQuery) as IndexedFileRow[];
+          return rows.filter((row) => this.applyDocumentFilters(row.path, row.ext, filters));
+        } catch {
+          // Fallback below.
+        }
+      }
+    }
+
+    const conds: string[] = [];
+    const params: unknown[] = [];
+
+    if (filters.pathPrefix) {
+      conds.push("rel_path LIKE ? ESCAPE '\\\\'");
+      params.push(`${escapeLike(this.normalizeRel(filters.pathPrefix))}%`);
+    }
+
+    if (filters.extensions && filters.extensions.length > 0) {
+      conds.push(`ext IN (${filters.extensions.map(() => "?").join(",")})`);
+      params.push(...filters.extensions.map((ext) => normalizeExt(ext)));
+    }
+
+    let sql = "SELECT id, rel_path AS path, ext, content FROM files";
+    if (conds.length > 0) sql += ` WHERE ${conds.join(" AND ")}`;
+
+    const rows = this.db.prepare(sql).all(...params) as IndexedFileRow[];
+    return rows.filter((row) => this.applyDocumentFilters(row.path, row.ext, filters));
+  }
+
+  private applyDocumentFilters(filePath: string, ext: string, filters: CodebaseSearchFilters): boolean {
+    if (filters.pathPrefix) {
+      const prefix = this.normalizeRel(filters.pathPrefix);
+      if (prefix && !filePath.startsWith(prefix)) return false;
+    }
+
+    if (filters.extensions && filters.extensions.length > 0) {
+      const normalized = new Set(filters.extensions.map((value) => normalizeExt(value)));
+      if (!normalized.has(ext)) return false;
+    }
+
+    return this.applyGlobFilters(filePath, filters);
+  }
+
+  private makeMatcher(query: string, regex: boolean, caseSensitive: boolean): (value: string) => boolean {
+    if (!query) return () => true;
+
+    if (regex) {
+      const flags = caseSensitive ? "" : "i";
+      const re = new RegExp(query, flags);
+      return (value: string) => re.test(value);
+    }
+
+    const needle = caseSensitive ? query : query.toLowerCase();
+    return (value: string) => (caseSensitive ? value : value.toLowerCase()).includes(needle);
+  }
+
+  private makeLineFinder(query: string, regex: boolean, caseSensitive: boolean, maxChars: number): (content: string) => {
+    line: number;
+    column: number;
+    snippet: string;
+    exact: boolean;
+  } | null {
+    if (regex) {
+      const flags = caseSensitive ? "" : "i";
+      const re = new RegExp(query, flags);
+      return (content: string) => {
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          re.lastIndex = 0;
+          const match = re.exec(line);
+          if (!match) continue;
+          const snippet = trimSnippet(line, maxChars);
+          return { line: i + 1, column: (match.index ?? 0) + 1, snippet, exact: false };
+        }
+        return null;
+      };
+    }
+
+    const needle = caseSensitive ? query : query.toLowerCase();
+    return (content: string) => {
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const hay = caseSensitive ? line : line.toLowerCase();
+        const idx = hay.indexOf(needle);
+        if (idx === -1) continue;
+        const snippet = trimSnippet(line, maxChars);
+        return { line: i + 1, column: idx + 1, snippet, exact: line.includes(query) };
+      }
+      return null;
+    };
+  }
+
+  private pathScore(filePath: string, query: string): number {
+    if (!query) return 55;
+    const lowerPath = filePath.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    if (lowerPath === lowerQuery) return 98;
+    if (lowerPath.endsWith(`/${lowerQuery}`)) return 90;
+    if (lowerPath.includes(lowerQuery)) return 80;
+    return 60;
+  }
+
+  private applyGlobFilters(filePath: string, filters: CodebaseSearchFilters): boolean {
+    if (filters.includeHidden !== true) {
+      const segments = filePath.split("/");
+      if (segments.some((segment) => segment.startsWith("."))) return false;
+    }
+
+    const includeGlobs = filters.includeGlobs ?? [];
+    if (includeGlobs.length > 0 && !includeGlobs.some((glob) => globMatch(glob, filePath))) {
+      return false;
+    }
+
+    const excludeGlobs = filters.excludeGlobs ?? [];
+    if (excludeGlobs.some((glob) => globMatch(glob, filePath))) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private createSchema(): void {
+    this.db.exec(
+      "CREATE TABLE IF NOT EXISTS files (" +
+      "id INTEGER PRIMARY KEY, " +
+      "rel_path TEXT NOT NULL UNIQUE, " +
+      "ext TEXT NOT NULL, " +
+      "mtime_ms INTEGER NOT NULL, " +
+      "size_bytes INTEGER NOT NULL, " +
+      "content TEXT NOT NULL" +
+      ");"
+    );
+
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_files_ext ON files(ext);");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_files_path ON files(rel_path);");
+
+    this.db.exec(
+      "CREATE TABLE IF NOT EXISTS symbols (" +
+      "id INTEGER PRIMARY KEY, " +
+      "file_id INTEGER NOT NULL, " +
+      "name TEXT NOT NULL, " +
+      "kind TEXT NOT NULL, " +
+      "line INTEGER NOT NULL, " +
+      "column INTEGER NOT NULL, " +
+      "signature TEXT, " +
+      "FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE" +
+      ");"
+    );
+
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);");
+
+    try {
+      this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS files_fts USING fts5(rel_path, content, tokenize='unicode61');");
+      this.hasFts = true;
+    } catch {
+      this.hasFts = false;
+    }
+  }
+
+  private clearIndex(): void {
+    this.db.exec("DELETE FROM symbols;");
+    this.db.exec("DELETE FROM files;");
+    if (this.hasFts) this.db.exec("DELETE FROM files_fts;");
+  }
+
+  private collectFiles(root: string): string[] {
+    const out: string[] = [];
+
+    const walk = (dir: string) => {
+      let entries: fs.Dirent[];
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+
+      for (const entry of entries) {
+        const abs = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          if (DEFAULT_SKIP_DIRS.has(entry.name)) continue;
+          walk(abs);
+          continue;
+        }
+
+        if (!entry.isFile()) continue;
+        out.push(abs);
+      }
+    };
+
+    walk(root);
+    return out;
+  }
+
+  private isLikelyText(absPath: string): boolean {
+    const ext = path.extname(absPath).toLowerCase();
+    if (DEFAULT_BINARY_EXTS.has(ext)) return false;
+
+    let fd: number | null = null;
+    try {
+      fd = fs.openSync(absPath, "r");
+      const sample = Buffer.allocUnsafe(1024);
+      const read = fs.readSync(fd, sample, 0, sample.length, 0);
+      for (let i = 0; i < read; i++) {
+        if (sample[i] === 0) return false;
+      }
+      return true;
+    } catch {
+      return false;
+    } finally {
+      if (fd !== null) {
+        try { fs.closeSync(fd); } catch { /* noop */ }
+      }
+    }
+  }
+
+  private normalizeRel(p: string): string {
+    const rel = path.isAbsolute(p) ? path.relative(this.rootDir, p) : p;
+    return rel.replace(/\\/g, "/").replace(/^\.\//, "");
+  }
+
+  private extractSymbols(content: string, ext: string): Array<{
+    name: string;
+    kind: CodebaseSymbolKind;
+    line: number;
+    column: number;
+    signature: string;
+  }> {
+    const language = languageFromExt(ext);
+    const rows = content.split("\n");
+    const out: Array<{ name: string; kind: CodebaseSymbolKind; line: number; column: number; signature: string }> = [];
+
+    for (let i = 0; i < rows.length; i++) {
+      const line = rows[i] ?? "";
+      for (const pattern of SYMBOL_PATTERNS) {
+        if (!pattern.languages.includes(language)) continue;
+        pattern.regex.lastIndex = 0;
+        const match = pattern.regex.exec(line);
+        if (!match || !match[1]) continue;
+
+        const name = String(match[1]);
+        const column = (match.index ?? 0) + 1;
+        out.push({
+          name,
+          kind: pattern.kind,
+          line: i + 1,
+          column,
+          signature: line.trim().slice(0, 240),
+        });
+      }
+    }
+
+    return out;
+  }
+}
+
+function languageFromExt(ext: string): SourceLanguage {
+  const normalized = ext.toLowerCase();
+  if (normalized === ".ts" || normalized === ".tsx" || normalized === ".mts" || normalized === ".cts") return "ts";
+  if (normalized === ".js" || normalized === ".jsx" || normalized === ".mjs" || normalized === ".cjs") return "js";
+  if (normalized === ".py") return "python";
+  if (normalized === ".php" || normalized === ".phtml") return "php";
+  if (normalized === ".go") return "go";
+  if (normalized === ".java") return "java";
+  if (normalized === ".cs") return "csharp";
+  if (normalized === ".rs") return "rust";
+  if (normalized === ".rb") return "ruby";
+  return "other";
+}
+
+function normalizeExt(raw: string): string {
+  if (!raw) return raw;
+  return raw.startsWith(".") ? raw.toLowerCase() : `.${raw.toLowerCase()}`;
+}
+
+function escapeLike(value: string): string {
+  return value.replace(/[\\%_]/g, "\\$&");
+}
+
+function trimSnippet(line: string, maxChars: number): string {
+  const clean = line.trim();
+  if (clean.length <= maxChars) return clean;
+  return `${clean.slice(0, Math.max(20, maxChars - 1))}...`;
+}
+
+function toFtsQuery(query: string): string | null {
+  const tokens = query.toLowerCase().match(/[a-z0-9_]+/g);
+  if (!tokens || tokens.length === 0) return null;
+  return tokens.map((token) => `${token}*`).join(" AND ");
+}
+
+function globMatch(glob: string, filePath: string): boolean {
+  const normGlob = glob.replace(/\\/g, "/");
+  const normPath = filePath.replace(/\\/g, "/");
+
+  const escaped = normGlob
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*/g, "@@DOUBLESTAR@@")
+    .replace(/\*/g, "[^/]*")
+    .replace(/@@DOUBLESTAR@@/g, ".*")
+    .replace(/\?/g, "[^/]");
+
+  try {
+    return new RegExp(`^${escaped}$`).test(normPath);
+  } catch {
+    return normPath.includes(normGlob);
+  }
+}