@thoughtflow/codebase 0.2.0

package/dist/libs/codebase-index.class.d.ts

@@ -0,0 +1,66 @@
+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;
+}
+export declare class CodebaseIndex {
+    private readonly rootDir;
+    private static readonly shared;
+    static forRoot(rootDir: string): Promise<CodebaseIndex>;
+    private readonly db;
+    private hasFts;
+    private indexedAtMs;
+    private indexed;
+    private constructor();
+    isIndexed(): boolean;
+    rebuild(maxFileBytes?: number): CodebaseIndexStats;
+    getStats(): CodebaseIndexStats;
+    search(options: CodebaseSearchOptions): CodebaseSearchHit[];
+    private searchPaths;
+    private searchContent;
+    private searchSymbols;
+    private queryDocuments;
+    private applyDocumentFilters;
+    private makeMatcher;
+    private makeLineFinder;
+    private pathScore;
+    private applyGlobFilters;
+    private createSchema;
+    private clearIndex;
+    private collectFiles;
+    private isLikelyText;
+    private normalizeRel;
+    private extractSymbols;
+}
+//# sourceMappingURL=codebase-index.class.d.ts.map

package/dist/libs/codebase-index.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-index.class.d.ts","sourceRoot":"","sources":["../../src/libs/codebase-index.class.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAC1E,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,UAAU,GACV,QAAQ,GACR,WAAW,GACX,MAAM,GACN,MAAM,GACN,OAAO,GACP,UAAU,CAAC;AAEf,MAAM,WAAW,qBAAqB;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,qBAAsB,SAAQ,qBAAqB;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,kBAAkB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACnC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAsGD,qBAAa,aAAa;IAkBJ,OAAO,CAAC,QAAQ,CAAC,OAAO;IAjB5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAoC;WAErD,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAU7D,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAM;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;IAQP,SAAS,IAAI,OAAO;IAIpB,OAAO,CAAC,YAAY,SAAc,GAAG,kBAAkB;IA8DvD,QAAQ,IAAI,kBAAkB;IAc9B,MAAM,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,EAAE;IAkC3D,OAAO,CAAC,WAAW;IAqBnB,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,aAAa;IAiDrB,OAAO,CAAC,cAAc;IA0CtB,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,cAAc;IAsCtB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,YAAY;IAuCpB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,YAAY;IA6BpB,OAAO,CAAC,YAAY;IAsBpB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,cAAc;CAiCvB"}

package/dist/libs/codebase-index.class.js

@@ -0,0 +1,595 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodebaseIndex = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+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 = [
+    // 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"] },
+];
+class CodebaseIndex {
+    rootDir;
+    static shared = new Map();
+    static async forRoot(rootDir) {
+        const { default: Database } = await Promise.resolve().then(() => __importStar(require("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;
+    }
+    db;
+    hasFts = false;
+    indexedAtMs = null;
+    indexed = false;
+    constructor(rootDir, Database) {
+        this.rootDir = rootDir;
+        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() {
+        return this.indexed;
+    }
+    rebuild(maxFileBytes = 1024 * 1024) {
+        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) => {
+            for (const absPath of absolutePaths) {
+                let stat;
+                try {
+                    stat = fs.statSync(absPath);
+                }
+                catch {
+                    continue;
+                }
+                if (!stat.isFile())
+                    continue;
+                if (stat.size > maxFileBytes)
+                    continue;
+                if (!this.isLikelyText(absPath))
+                    continue;
+                let content;
+                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() {
+        const fileRow = this.db.prepare("SELECT COUNT(*) AS c FROM files").get();
+        const symbolRow = this.db.prepare("SELECT COUNT(*) AS c FROM symbols").get();
+        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) {
+        const mode = options.mode;
+        const allHits = [];
+        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();
+        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);
+    }
+    searchPaths(options) {
+        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 = [];
+        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;
+    }
+    searchContent(options) {
+        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 = [];
+        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;
+    }
+    searchSymbols(options) {
+        const query = (options.query ?? "").trim();
+        if (!query)
+            return [];
+        const conds = [];
+        const params = [];
+        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);
+        const matchName = this.makeMatcher(query, options.regex === true, options.caseSensitive === true);
+        const hits = [];
+        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;
+    }
+    queryDocuments(filters, contentQuery) {
+        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);
+                    return rows.filter((row) => this.applyDocumentFilters(row.path, row.ext, filters));
+                }
+                catch {
+                    // Fallback below.
+                }
+            }
+        }
+        const conds = [];
+        const params = [];
+        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);
+        return rows.filter((row) => this.applyDocumentFilters(row.path, row.ext, filters));
+    }
+    applyDocumentFilters(filePath, ext, filters) {
+        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);
+    }
+    makeMatcher(query, regex, caseSensitive) {
+        if (!query)
+            return () => true;
+        if (regex) {
+            const flags = caseSensitive ? "" : "i";
+            const re = new RegExp(query, flags);
+            return (value) => re.test(value);
+        }
+        const needle = caseSensitive ? query : query.toLowerCase();
+        return (value) => (caseSensitive ? value : value.toLowerCase()).includes(needle);
+    }
+    makeLineFinder(query, regex, caseSensitive, maxChars) {
+        if (regex) {
+            const flags = caseSensitive ? "" : "i";
+            const re = new RegExp(query, flags);
+            return (content) => {
+                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) => {
+            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;
+        };
+    }
+    pathScore(filePath, query) {
+        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;
+    }
+    applyGlobFilters(filePath, filters) {
+        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;
+    }
+    createSchema() {
+        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;
+        }
+    }
+    clearIndex() {
+        this.db.exec("DELETE FROM symbols;");
+        this.db.exec("DELETE FROM files;");
+        if (this.hasFts)
+            this.db.exec("DELETE FROM files_fts;");
+    }
+    collectFiles(root) {
+        const out = [];
+        const walk = (dir) => {
+            let entries;
+            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;
+    }
+    isLikelyText(absPath) {
+        const ext = path.extname(absPath).toLowerCase();
+        if (DEFAULT_BINARY_EXTS.has(ext))
+            return false;
+        let fd = 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 */ }
+            }
+        }
+    }
+    normalizeRel(p) {
+        const rel = path.isAbsolute(p) ? path.relative(this.rootDir, p) : p;
+        return rel.replace(/\\/g, "/").replace(/^\.\//, "");
+    }
+    extractSymbols(content, ext) {
+        const language = languageFromExt(ext);
+        const rows = content.split("\n");
+        const out = [];
+        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;
+    }
+}
+exports.CodebaseIndex = CodebaseIndex;
+function languageFromExt(ext) {
+    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) {
+    if (!raw)
+        return raw;
+    return raw.startsWith(".") ? raw.toLowerCase() : `.${raw.toLowerCase()}`;
+}
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, "\\$&");
+}
+function trimSnippet(line, maxChars) {
+    const clean = line.trim();
+    if (clean.length <= maxChars)
+        return clean;
+    return `${clean.slice(0, Math.max(20, maxChars - 1))}...`;
+}
+function toFtsQuery(query) {
+    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, filePath) {
+    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);
+    }
+}
+//# sourceMappingURL=codebase-index.class.js.map