@tai-io/codesearch 2026.313.1614

package/dist/vectordb/sqlite.js

@@ -0,0 +1,624 @@
+import Database from 'better-sqlite3';
+import * as sqliteVec from 'sqlite-vec';
+import fs from 'node:fs';
+import path from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { pathToCollectionName, getCodesearchDbPath, getSnapshotDbPath, getSnapshotDir, } from '../paths.js';
+import { VectorDBError } from '../errors.js';
+import { reciprocalRankFusion, rankByTermFrequency, } from './rrf.js';
+const INSERT_BATCH_SIZE = 500;
+let db = null;
+function getDb(dbPath) {
+    if (db)
+        return db;
+    mkdirSync(dirname(dbPath), { recursive: true });
+    db = new Database(dbPath);
+    sqliteVec.load(db);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS collections (
+      name TEXT PRIMARY KEY,
+      dimension INTEGER NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      collection TEXT NOT NULL REFERENCES collections(name) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      relative_path TEXT NOT NULL,
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      file_extension TEXT NOT NULL,
+      language TEXT NOT NULL,
+      file_category TEXT,
+      symbol_name TEXT,
+      symbol_kind TEXT,
+      symbol_signature TEXT,
+      parent_symbol TEXT,
+      indexed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      file_modified_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chunks_collection ON chunks(collection);
+    CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(collection, relative_path);
+    CREATE INDEX IF NOT EXISTS idx_chunks_ext ON chunks(collection, file_extension);
+    CREATE INDEX IF NOT EXISTS idx_chunks_symbol ON chunks(collection, symbol_name)
+      WHERE symbol_name IS NOT NULL;
+    CREATE INDEX IF NOT EXISTS idx_chunks_indexed ON chunks(collection, indexed_at);
+
+    CREATE TABLE IF NOT EXISTS snapshots (
+      collection_name TEXT PRIMARY KEY,
+      data TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+    migrateOldSnapshotsDb(db);
+    process.on('exit', () => {
+        try {
+            db?.close();
+        }
+        catch {
+            // best-effort
+        }
+    });
+    return db;
+}
+function migrateOldSnapshotsDb(database) {
+    try {
+        const oldDbPath = getSnapshotDbPath();
+        if (!fs.existsSync(oldDbPath))
+            return;
+        const oldDb = new Database(oldDbPath, { readonly: true });
+        try {
+            const rows = oldDb.prepare('SELECT collection_name, data, updated_at FROM snapshots').all();
+            if (rows.length > 0) {
+                const insert = database.prepare('INSERT OR IGNORE INTO snapshots (collection_name, data, updated_at) VALUES (?, ?, ?)');
+                const tx = database.transaction(() => {
+                    for (const row of rows) {
+                        insert.run(row.collection_name, row.data, row.updated_at);
+                    }
+                });
+                tx();
+                console.warn(`Migrated ${rows.length} snapshot(s) from old snapshots.db`);
+            }
+        }
+        finally {
+            oldDb.close();
+        }
+        // Also migrate JSON snapshots from the old snapshot directory
+        migrateJsonSnapshots(database);
+        // Remove old DB after successful migration
+        try {
+            fs.unlinkSync(oldDbPath);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    catch {
+        // migration is best-effort
+    }
+}
+function migrateJsonSnapshots(database) {
+    try {
+        const snapshotDir = getSnapshotDir();
+        if (!fs.existsSync(snapshotDir))
+            return;
+        const files = fs.readdirSync(snapshotDir).filter((f) => f.endsWith('.json'));
+        if (files.length === 0)
+            return;
+        const insert = database.prepare('INSERT OR IGNORE INTO snapshots (collection_name, data, updated_at) VALUES (?, ?, ?)');
+        let migrated = 0;
+        for (const file of files) {
+            const collectionName = file.replace(/\.json$/, '');
+            try {
+                const raw = fs.readFileSync(path.join(snapshotDir, file), 'utf-8');
+                JSON.parse(raw); // validate
+                insert.run(collectionName, raw, new Date().toISOString());
+                migrated++;
+            }
+            catch {
+                // skip corrupted files
+            }
+        }
+        if (migrated > 0) {
+            console.warn(`Migrated ${migrated} JSON snapshot(s) to SQLite`);
+        }
+    }
+    catch {
+        // migration is best-effort
+    }
+}
+function sanitizeName(name) {
+    // Collection names are already sanitized by pathToCollectionName,
+    // but double-check to prevent SQL injection in dynamic table names
+    if (!/^[a-z0-9_]+$/.test(name)) {
+        throw new VectorDBError(`Invalid collection name: ${name}`);
+    }
+    return name;
+}
+function vecToBuffer(vec) {
+    return Buffer.from(new Float32Array(vec).buffer);
+}
+export class SqliteVectorDB {
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    get db() {
+        return getDb(this.dbPath);
+    }
+    async createCollection(name, dimension) {
+        const safe = sanitizeName(name);
+        try {
+            const existing = this.db
+                .prepare('SELECT dimension FROM collections WHERE name = ?')
+                .get(safe);
+            if (existing)
+                return;
+            this.db.transaction(() => {
+                this.db
+                    .prepare('INSERT INTO collections (name, dimension) VALUES (?, ?)')
+                    .run(safe, dimension);
+                this.db.exec(`
+          CREATE VIRTUAL TABLE "${safe}_vec" USING vec0(
+            id TEXT PRIMARY KEY,
+            vector float[${dimension}]
+          )
+        `);
+                this.db.exec(`
+          CREATE VIRTUAL TABLE "${safe}_fts" USING fts5(
+            content,
+            content=chunks,
+            content_rowid=rowid
+          )
+        `);
+                this.db.exec(`
+          CREATE TRIGGER "${safe}_fts_insert" AFTER INSERT ON chunks
+            WHEN NEW.collection = '${safe}'
+            BEGIN
+              INSERT INTO "${safe}_fts"(rowid, content) VALUES (NEW.rowid, NEW.content);
+            END
+        `);
+                this.db.exec(`
+          CREATE TRIGGER "${safe}_fts_update" AFTER UPDATE ON chunks
+            WHEN OLD.collection = '${safe}' AND NEW.collection = '${safe}'
+            BEGIN
+              INSERT INTO "${safe}_fts"("${safe}_fts", rowid, content)
+                VALUES ('delete', OLD.rowid, OLD.content);
+              INSERT INTO "${safe}_fts"(rowid, content) VALUES (NEW.rowid, NEW.content);
+            END
+        `);
+                this.db.exec(`
+          CREATE TRIGGER "${safe}_fts_delete" AFTER DELETE ON chunks
+            WHEN OLD.collection = '${safe}'
+            BEGIN
+              INSERT INTO "${safe}_fts"("${safe}_fts", rowid, content)
+                VALUES ('delete', OLD.rowid, OLD.content);
+            END
+        `);
+            })();
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to create collection "${name}"`, err);
+        }
+    }
+    async hasCollection(name) {
+        const safe = sanitizeName(name);
+        const row = this.db
+            .prepare('SELECT 1 FROM collections WHERE name = ?')
+            .get(safe);
+        return row !== undefined;
+    }
+    async dropCollection(name) {
+        const safe = sanitizeName(name);
+        try {
+            this.db.transaction(() => {
+                // Drop triggers first (they reference chunks table)
+                this.db.exec(`DROP TRIGGER IF EXISTS "${safe}_fts_insert"`);
+                this.db.exec(`DROP TRIGGER IF EXISTS "${safe}_fts_update"`);
+                this.db.exec(`DROP TRIGGER IF EXISTS "${safe}_fts_delete"`);
+                // Drop virtual tables
+                this.db.exec(`DROP TABLE IF EXISTS "${safe}_vec"`);
+                this.db.exec(`DROP TABLE IF EXISTS "${safe}_fts"`);
+                // Delete chunk rows (FK cascade won't fire for virtual tables)
+                this.db.prepare('DELETE FROM chunks WHERE collection = ?').run(safe);
+                // Delete collection entry
+                this.db.prepare('DELETE FROM collections WHERE name = ?').run(safe);
+            })();
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to drop collection "${name}"`, err);
+        }
+    }
+    async insert(name, documents) {
+        if (documents.length === 0)
+            return;
+        const safe = sanitizeName(name);
+        try {
+            const insertChunk = this.db.prepare(`
+        INSERT OR REPLACE INTO chunks
+          (id, collection, content, relative_path, start_line, end_line,
+           file_extension, language, file_category, symbol_name, symbol_kind,
+           symbol_signature, parent_symbol, indexed_at, file_modified_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)
+      `);
+            const insertVec = this.db.prepare(`
+        INSERT OR REPLACE INTO "${safe}_vec" (id, vector) VALUES (?, ?)
+      `);
+            for (let i = 0; i < documents.length; i += INSERT_BATCH_SIZE) {
+                const batch = documents.slice(i, i + INSERT_BATCH_SIZE);
+                this.db.transaction(() => {
+                    for (const doc of batch) {
+                        insertChunk.run(doc.id, safe, doc.content, doc.relativePath, doc.startLine, doc.endLine, doc.fileExtension, doc.language, doc.fileCategory ?? null, doc.symbolName ?? null, doc.symbolKind ?? null, doc.symbolSignature ?? null, doc.parentSymbol ?? null, doc.fileModifiedAt ?? null);
+                        insertVec.run(doc.id, vecToBuffer(doc.vector));
+                    }
+                })();
+            }
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to insert ${documents.length} documents into "${name}"`, err);
+        }
+    }
+    async search(name, params) {
+        const safe = sanitizeName(name);
+        try {
+            const fetchLimit = params.limit * 2;
+            // Extension filter clause
+            let extClause = '';
+            let extParams = [];
+            if (params.extensionFilter?.length) {
+                const placeholders = params.extensionFilter.map(() => '?').join(', ');
+                extClause = `AND c.file_extension IN (${placeholders})`;
+                extParams = params.extensionFilter;
+            }
+            // Dense vector search
+            const denseRows = this.db
+                .prepare(`SELECT v.id, v.distance
+           FROM "${safe}_vec" v
+           JOIN chunks c ON c.id = v.id AND c.collection = ?
+           WHERE v.vector MATCH ?
+             AND k = ?
+             ${extClause}
+           ORDER BY v.distance ASC`)
+                .all(safe, vecToBuffer(params.queryVector), fetchLimit, ...extParams);
+            // Convert distance to similarity score (cosine distance → similarity)
+            const denseResults = denseRows.map((row) => ({
+                id: row.id,
+                score: 1 - row.distance,
+                payload: null,
+            }));
+            // FTS search
+            let textResults = [];
+            if (params.queryText) {
+                // Tokenize query for FTS5 — escape special chars, join with OR
+                const ftsQuery = params.queryText
+                    .split(/\s+/)
+                    .filter((t) => t.length > 0)
+                    .map((t) => `"${t.replace(/"/g, '""')}"`)
+                    .join(' OR ');
+                if (ftsQuery) {
+                    const ftsRows = this.db
+                        .prepare(`SELECT c.id, c.content
+               FROM "${safe}_fts" f
+               JOIN chunks c ON c.rowid = f.rowid AND c.collection = ?
+               WHERE "${safe}_fts" MATCH ?
+                 ${extClause}
+               LIMIT ?`)
+                        .all(safe, ftsQuery, fetchLimit, ...extParams);
+                    const pointsForRank = ftsRows.map((r) => ({
+                        id: r.id,
+                        payload: { content: r.content },
+                    }));
+                    textResults = rankByTermFrequency(pointsForRank, params.queryText);
+                }
+            }
+            // If we have both dense and text results, fuse them
+            if (denseResults.length === 0 && textResults.length === 0) {
+                return [];
+            }
+            const fused = reciprocalRankFusion(denseResults, textResults, params.limit * 2);
+            // Fetch full metadata for the fused result IDs
+            const resultIds = fused.map((r) => r.relativePath || '').length
+                ? fused
+                : [];
+            if (fused.length === 0)
+                return [];
+            // Get IDs from fused results — they're in the SearchResult format from RRF
+            // but we need to re-fetch from chunks for full metadata
+            // RRF returns SearchResult[] which has relativePath etc from payload extraction
+            // We need the chunk IDs — let's collect from both dense and text results
+            const allIds = new Set();
+            for (const d of denseResults)
+                allIds.add(String(d.id));
+            for (const t of textResults)
+                allIds.add(String(t.id));
+            if (allIds.size === 0)
+                return [];
+            const idList = [...allIds];
+            const placeholders = idList.map(() => '?').join(', ');
+            const metadataRows = this.db
+                .prepare(`SELECT id, content, relative_path, start_line, end_line,
+                  file_extension, language, file_category, indexed_at
+           FROM chunks
+           WHERE id IN (${placeholders}) AND collection = ?`)
+                .all(...idList, safe);
+            const metaMap = new Map(metadataRows.map((r) => [r.id, r]));
+            // Now rebuild dense and text results with full payloads for RRF
+            const denseWithPayload = denseResults
+                .filter((d) => metaMap.has(String(d.id)))
+                .map((d) => {
+                const m = metaMap.get(String(d.id));
+                return {
+                    id: d.id,
+                    score: d.score,
+                    payload: {
+                        content: m.content,
+                        relativePath: m.relative_path,
+                        startLine: m.start_line,
+                        endLine: m.end_line,
+                        fileExtension: m.file_extension,
+                        language: m.language,
+                        fileCategory: m.file_category ?? '',
+                    },
+                };
+            });
+            const textWithPayload = textResults
+                .filter((t) => metaMap.has(String(t.id)))
+                .map((t) => {
+                const m = metaMap.get(String(t.id));
+                return {
+                    id: t.id,
+                    rawScore: t.rawScore,
+                    payload: {
+                        content: m.content,
+                        relativePath: m.relative_path,
+                        startLine: m.start_line,
+                        endLine: m.end_line,
+                        fileExtension: m.file_extension,
+                        language: m.language,
+                        fileCategory: m.file_category ?? '',
+                    },
+                };
+            });
+            return reciprocalRankFusion(denseWithPayload, textWithPayload, params.limit);
+        }
+        catch (err) {
+            throw new VectorDBError(`Search failed in collection "${name}"`, err);
+        }
+    }
+    async getById(name, id) {
+        const safe = sanitizeName(name);
+        try {
+            const row = this.db
+                .prepare(`SELECT c.*, v.vector
+           FROM chunks c
+           JOIN "${safe}_vec" v ON v.id = c.id
+           WHERE c.id = ? AND c.collection = ?`)
+                .get(id, safe);
+            if (!row)
+                return null;
+            const vectorBuf = row.vector;
+            const vector = [...new Float32Array(vectorBuf.buffer, vectorBuf.byteOffset, vectorBuf.byteLength / 4)];
+            return {
+                payload: {
+                    content: row.content,
+                    relativePath: row.relative_path,
+                    startLine: row.start_line,
+                    endLine: row.end_line,
+                    fileExtension: row.file_extension,
+                    language: row.language,
+                    fileCategory: row.file_category ?? '',
+                    symbolName: row.symbol_name ?? '',
+                    symbolKind: row.symbol_kind ?? '',
+                    symbolSignature: row.symbol_signature ?? '',
+                    parentSymbol: row.parent_symbol ?? '',
+                    indexedAt: row.indexed_at ?? '',
+                    fileModifiedAt: row.file_modified_at ?? '',
+                },
+                vector,
+            };
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to retrieve point "${id}" from "${name}"`, err);
+        }
+    }
+    async updatePoint(name, id, vector, payload) {
+        const safe = sanitizeName(name);
+        try {
+            this.db.transaction(() => {
+                this.db
+                    .prepare(`INSERT OR REPLACE INTO chunks
+              (id, collection, content, relative_path, start_line, end_line,
+               file_extension, language, file_category, symbol_name, symbol_kind,
+               symbol_signature, parent_symbol, indexed_at, file_modified_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)`)
+                    .run(id, safe, String(payload.content ?? ''), String(payload.relativePath ?? ''), Number(payload.startLine ?? 0), Number(payload.endLine ?? 0), String(payload.fileExtension ?? ''), String(payload.language ?? ''), String(payload.fileCategory ?? ''), String(payload.symbolName ?? ''), String(payload.symbolKind ?? ''), String(payload.symbolSignature ?? ''), String(payload.parentSymbol ?? ''), payload.fileModifiedAt != null ? String(payload.fileModifiedAt) : null);
+                this.db
+                    .prepare(`INSERT OR REPLACE INTO "${safe}_vec" (id, vector) VALUES (?, ?)`)
+                    .run(id, vecToBuffer(vector));
+            })();
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to update point "${id}" in "${name}"`, err);
+        }
+    }
+    async deleteByPath(name, relativePath) {
+        const safe = sanitizeName(name);
+        try {
+            const ids = this.db
+                .prepare('SELECT id FROM chunks WHERE collection = ? AND relative_path = ?')
+                .all(safe, relativePath);
+            if (ids.length === 0)
+                return;
+            this.db.transaction(() => {
+                const deleteVec = this.db.prepare(`DELETE FROM "${safe}_vec" WHERE id = ?`);
+                for (const { id } of ids) {
+                    deleteVec.run(id);
+                }
+                this.db
+                    .prepare('DELETE FROM chunks WHERE collection = ? AND relative_path = ?')
+                    .run(safe, relativePath);
+            })();
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to delete documents for path "${relativePath}" from "${name}"`, err);
+        }
+    }
+    async deleteByFilter(name, filter) {
+        const safe = sanitizeName(name);
+        try {
+            // Build WHERE clause from filter
+            const columnMap = {
+                relativePath: 'relative_path',
+                startLine: 'start_line',
+                endLine: 'end_line',
+                fileExtension: 'file_extension',
+                fileCategory: 'file_category',
+                symbolName: 'symbol_name',
+                symbolKind: 'symbol_kind',
+            };
+            const conditions = ['collection = ?'];
+            const params = [safe];
+            for (const [key, value] of Object.entries(filter)) {
+                const col = columnMap[key] ?? key;
+                conditions.push(`"${col}" = ?`);
+                params.push(value);
+            }
+            const where = conditions.join(' AND ');
+            const ids = this.db
+                .prepare(`SELECT id FROM chunks WHERE ${where}`)
+                .all(...params);
+            if (ids.length === 0)
+                return;
+            this.db.transaction(() => {
+                const deleteVec = this.db.prepare(`DELETE FROM "${safe}_vec" WHERE id = ?`);
+                for (const { id } of ids) {
+                    deleteVec.run(id);
+                }
+                this.db
+                    .prepare(`DELETE FROM chunks WHERE ${where}`)
+                    .run(...params);
+            })();
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to delete by filter from "${name}"`, err);
+        }
+    }
+    async listSymbols(name) {
+        const safe = sanitizeName(name);
+        try {
+            const rows = this.db
+                .prepare(`SELECT symbol_name, symbol_kind, relative_path, start_line,
+                  symbol_signature, parent_symbol
+           FROM chunks
+           WHERE collection = ? AND symbol_name IS NOT NULL AND symbol_name != ''`)
+                .all(safe);
+            return rows.map((row) => ({
+                name: row.symbol_name,
+                kind: row.symbol_kind,
+                relativePath: row.relative_path,
+                startLine: row.start_line,
+                ...(row.symbol_signature ? { signature: row.symbol_signature } : {}),
+                ...(row.parent_symbol ? { parentName: row.parent_symbol } : {}),
+            }));
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to list symbols from "${name}"`, err);
+        }
+    }
+    async scrollAll(name) {
+        const safe = sanitizeName(name);
+        try {
+            const rows = this.db
+                .prepare(`SELECT c.*, v.vector
+           FROM chunks c
+           JOIN "${safe}_vec" v ON v.id = c.id
+           WHERE c.collection = ?`)
+                .all(safe);
+            return rows.map((row) => {
+                const vectorBuf = row.vector;
+                const vector = [...new Float32Array(vectorBuf.buffer, vectorBuf.byteOffset, vectorBuf.byteLength / 4)];
+                return {
+                    id: String(row.id),
+                    vector,
+                    payload: {
+                        content: row.content,
+                        relativePath: row.relative_path,
+                        startLine: row.start_line,
+                        endLine: row.end_line,
+                        fileExtension: row.file_extension,
+                        language: row.language,
+                        fileCategory: row.file_category ?? '',
+                        symbolName: row.symbol_name ?? '',
+                        symbolKind: row.symbol_kind ?? '',
+                        symbolSignature: row.symbol_signature ?? '',
+                        parentSymbol: row.parent_symbol ?? '',
+                    },
+                };
+            });
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to scroll all points from "${name}"`, err);
+        }
+    }
+}
+// ── Snapshot functions ─────────────────────────────────────────────────────
+function resolveDbPath(dbPath) {
+    return dbPath ?? getCodesearchDbPath();
+}
+export function loadSnapshot(rootPath, dbPath) {
+    const name = pathToCollectionName(rootPath);
+    const row = getDb(resolveDbPath(dbPath))
+        .prepare('SELECT data FROM snapshots WHERE collection_name = ?')
+        .get(name);
+    if (!row)
+        return null;
+    try {
+        return JSON.parse(row.data);
+    }
+    catch {
+        console.warn(`Corrupted snapshot for ${name}, ignoring`);
+        return null;
+    }
+}
+export function saveSnapshot(rootPath, snapshot, dbPath) {
+    const name = pathToCollectionName(rootPath);
+    getDb(resolveDbPath(dbPath))
+        .prepare('INSERT OR REPLACE INTO snapshots (collection_name, data, updated_at) VALUES (?, ?, ?)')
+        .run(name, JSON.stringify(snapshot), new Date().toISOString());
+}
+export function deleteSnapshot(rootPath, dbPath) {
+    const name = pathToCollectionName(rootPath);
+    getDb(resolveDbPath(dbPath)).prepare('DELETE FROM snapshots WHERE collection_name = ?').run(name);
+}
+export function snapshotExists(rootPath, dbPath) {
+    const name = pathToCollectionName(rootPath);
+    const row = getDb(resolveDbPath(dbPath))
+        .prepare('SELECT 1 FROM snapshots WHERE collection_name = ?')
+        .get(name);
+    return row !== undefined;
+}
+export function listSnapshotCollections(dbPath) {
+    const rows = getDb(resolveDbPath(dbPath)).prepare('SELECT collection_name FROM snapshots').all();
+    return rows.map((r) => r.collection_name);
+}
+export function deleteSnapshotByCollection(collectionName, dbPath) {
+    getDb(resolveDbPath(dbPath)).prepare('DELETE FROM snapshots WHERE collection_name = ?').run(collectionName);
+}
+/** Reset the module-level DB connection (for testing). */
+export function resetForTesting() {
+    if (db) {
+        try {
+            db.close();
+        }
+        catch {
+            // ignore
+        }
+        db = null;
+    }
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/vectordb/types.d.ts

@@ -0,0 +1,63 @@
+import type { EmbeddingVector } from '../embedding/types.js';
+export interface CodeDocument {
+    id: string;
+    content: string;
+    vector: EmbeddingVector;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    fileExtension: string;
+    language: string;
+    fileCategory?: string;
+    symbolName?: string;
+    symbolKind?: string;
+    symbolSignature?: string;
+    parentSymbol?: string;
+    indexedAt?: string;
+    fileModifiedAt?: string;
+}
+export interface SymbolEntry {
+    name: string;
+    kind: string;
+    relativePath: string;
+    startLine: number;
+    signature?: string;
+    parentName?: string;
+}
+export interface HybridSearchParams {
+    queryVector: EmbeddingVector;
+    queryText: string;
+    limit: number;
+    extensionFilter?: string[];
+}
+export interface SearchResult {
+    content: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    fileExtension: string;
+    language: string;
+    score: number;
+    fileCategory?: string;
+}
+export interface VectorDB {
+    createCollection(name: string, dimension: number): Promise<void>;
+    hasCollection(name: string): Promise<boolean>;
+    dropCollection(name: string): Promise<void>;
+    insert(name: string, documents: CodeDocument[]): Promise<void>;
+    search(name: string, params: HybridSearchParams): Promise<SearchResult[]>;
+    deleteByPath(name: string, relativePath: string): Promise<void>;
+    deleteByFilter(name: string, filter: Record<string, unknown>): Promise<void>;
+    getById(name: string, id: string): Promise<{
+        payload: Record<string, unknown>;
+        vector: number[];
+    } | null>;
+    updatePoint(name: string, id: string, vector: number[], payload: Record<string, unknown>): Promise<void>;
+    listSymbols(name: string): Promise<SymbolEntry[]>;
+    scrollAll(name: string): Promise<{
+        id: string | number;
+        vector: number[];
+        payload: Record<string, unknown>;
+    }[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vectordb/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map