@customize-agent/knowledge 2.1.3 → 2.2.1

package/dist/core/knowledge-base-manager.d.ts

@@ -34,7 +34,7 @@ export declare class KnowledgeBaseManager {
     readonly projectId?: string;
     readonly kbPath: string;
     readonly store: IndexStateStore;
-    private readonly chromaClient;
+    private readonly sqliteVecClient;
     private readonly classifier;
     private readonly scanner;
     private readonly collections;

package/dist/core/knowledge-base-manager.js

@@ -10,7 +10,7 @@ import { HashEmbeddingProvider } from '../embedding/embedding-provider.js';
 import { ContentExtractor } from '../extraction/content-extractor.js';
 import { FederationSearch } from '../search/federation-search.js';
 import { CollectionManager } from '../vector/collection-manager.js';
-import { ChromaHttpClient, ChromaVectorStore } from '../vector/chroma-store.js';
+import { SQLiteVecClient, SQLiteVecVectorStore } from '../vector/sqlite-vec-store.js';
 import { VectorIndexer } from '../vector/vector-indexer.js';
 import { ChangeTracker } from './change-tracker.js';
 import { KnowledgeFileScanner } from './file-scanner.js';
@@ -22,7 +22,7 @@ export class KnowledgeBaseManager {
     projectId;
     kbPath;
     store;
-    chromaClient = new ChromaHttpClient();
+    sqliteVecClient;
     classifier = new FileClassifier();
     scanner = new KnowledgeFileScanner();
     collections = new CollectionManager();
@@ -47,17 +47,20 @@ export class KnowledgeBaseManager {
         this.llmProvider = options.llmProvider;
         this.onProgress = options.onProgress;
         const storageRoot = options.storageRoot ?? path.join(os.homedir(), USER_DATA_DIR);
+        let dbPath;
         if (this.scope === 'global') {
             this.kbPath = options.kbPath ?? path.join(storageRoot, GLOBAL_KNOWLEDGE_DIR);
-            this.store = new IndexStateStore(path.join(storageRoot, 'global-knowledge.db'));
+            dbPath = path.join(storageRoot, 'global-knowledge.db');
         }
         else {
             if (!options.projectRoot || !options.projectId) {
                 throw new Error('project knowledge base requires projectRoot and projectId');
             }
             this.kbPath = options.kbPath ?? getProjectKbPath(options.projectRoot);
-            this.store = new IndexStateStore(path.join(storageRoot, 'projects', options.projectId, 'kb.db'));
+            dbPath = path.join(storageRoot, 'projects', options.projectId, 'kb.db');
         }
+        this.store = new IndexStateStore(dbPath);
+        this.sqliteVecClient = new SQLiteVecClient({ dbPath });
     }
     initialize() {
         if (this.scope === 'project' && this.projectRoot) {
@@ -228,7 +231,7 @@ export class KnowledgeBaseManager {
                 message: vectorDeferred
                     ? '解析、切片和 SQLite 入库已完成，向量入库后台执行'
                     : vectorStatus.status === 'error'
-                        ? '解析和切片已完成，ChromaDB 未连接，向量待入库'
+                        ? '解析和切片已完成，sqlite-vec 向量待入库'
                         : '知识库索引完成',
                 chunkCount: stats.chunkCount,
                 vectorStatus,
@@ -380,7 +383,7 @@ export class KnowledgeBaseManager {
         const targetPath = this.resolveKbRelativePath(normalized);
         if (fs.existsSync(targetPath))
             fs.unlinkSync(targetPath);
-        // 同步删除 ChromaDB 向量数据，避免孤儿向量污染搜索结果
+        // 同步删除 sqlite-vec 向量数据，避免孤儿向量污染搜索结果
         const record = this.store.listRecords().find(r => r.relativePath === normalized);
         if (record) {
             await this.deleteVectorFile(record.collectionName, normalized);
@@ -409,7 +412,7 @@ export class KnowledgeBaseManager {
         const chunks = this.store.listChunks(options);
         for (const collectionName of new Set(chunks.map(chunk => chunk.collectionName)))
             this.ensureVectorStore(collectionName);
-        this.reportProgress({ stage: 'vectorizing', percent: 85, message: `正在写入 ChromaDB 向量库，共 ${chunks.length} 个切片`, chunkCount: chunks.length });
+        this.reportProgress({ stage: 'vectorizing', percent: 85, message: `正在写入 sqlite-vec 向量库，共 ${chunks.length} 个切片`, chunkCount: chunks.length });
         const indexer = new VectorIndexer(this.embeddingProvider, this.vectorStores);
         try {
             const results = await indexer.indexChunks(chunks);
@@ -426,7 +429,7 @@ export class KnowledgeBaseManager {
             this.store.setMetadata('vector_index_status', 'error');
             this.store.setMetadata('vector_index_error', message);
             this.store.setMetadata('last_vector_index_at', String(Date.now()));
-            this.reportProgress({ stage: 'error', percent: 85, message: 'ChromaDB 向量入库失败', chunkCount: chunks.length, vectorStatus: this.getVectorStatus() });
+            this.reportProgress({ stage: 'error', percent: 85, message: 'sqlite-vec 向量入库失败', chunkCount: chunks.length, vectorStatus: this.getVectorStatus() });
             return [];
         }
     }
@@ -450,7 +453,7 @@ export class KnowledgeBaseManager {
             error: this.store.getMetadata('vector_index_error') || undefined,
             indexedChunks: Number(this.store.getMetadata('vector_indexed_chunks') ?? 0),
             lastIndexedAt: Number(this.store.getMetadata('last_vector_index_at') ?? 0),
-            backend: `ChromaDB (${this.chromaClient.baseUrl})`,
+            backend: `SQLite + sqlite-vec (${this.sqliteVecClient.dbPath})`,
         };
     }
     async rewriteQueries(query) {
@@ -673,7 +676,7 @@ ${resultsText}
     ensureVectorStore(collectionName) {
         if (this.vectorStores.has(collectionName))
             return;
-        this.vectorStores.set(collectionName, new ChromaVectorStore(this.chromaClient, collectionName));
+        this.vectorStores.set(collectionName, new SQLiteVecVectorStore(this.sqliteVecClient, collectionName));
     }
     async deleteVectorFile(collectionName, relativePath) {
         this.ensureVectorStore(collectionName);

package/dist/extraction/content-extractor.js

@@ -492,6 +492,11 @@ export class ContentExtractor {
     }
     async extractRasterImage(file) {
         const metadata = { extractionMode: 'builtin_tesseract_ocr_isolated', vectorizable: true };
+        if (process.env.CUSTOMIZE_AGENT_DISABLE_OCR === '1') {
+            metadata.extractionMode = 'raster_image_metadata';
+            metadata.contentCoverage = 'metadata_filename';
+            return { text: this.metadataOnlyText(file), metadata, warnings: ['OCR disabled; indexed image metadata only'] };
+        }
         const validationError = this.validateRasterImage(file.absolutePath);
         if (validationError) {
             metadata.contentCoverage = 'invalid_image';

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { MultiProjectManager } from './core/multi-project-manager.js';
 export { computeProjectId } from './core/project-id.js';
 export { ensureProjectCustomizeFile, getProjectConfigPath, getProjectKbPath, ProjectConfigManager } from './core/project-config.js';
 export { ProjectRegistry } from './core/project-registry.js';
-export { ChromaHttpClient, ChromaVectorStore, type ChromaClientOptions } from './vector/chroma-store.js';
+export { SQLiteVecClient, SQLiteVecVectorStore, type SQLiteVecClientOptions } from './vector/sqlite-vec-store.js';
 export { CollectionManager, globalCollectionName, projectCollectionName } from './vector/collection-manager.js';
 export type { CollectionClient, VectorCollectionInfo, VectorDocument, VectorSearchQuery, VectorSearchResult, VectorStoreInterface } from './vector/types.js';
 export { VectorIndexer, type VectorIndexResult } from './vector/vector-indexer.js';

package/dist/index.js

@@ -15,7 +15,7 @@ export { MultiProjectManager } from './core/multi-project-manager.js';
 export { computeProjectId } from './core/project-id.js';
 export { ensureProjectCustomizeFile, getProjectConfigPath, getProjectKbPath, ProjectConfigManager } from './core/project-config.js';
 export { ProjectRegistry } from './core/project-registry.js';
-export { ChromaHttpClient, ChromaVectorStore } from './vector/chroma-store.js';
+export { SQLiteVecClient, SQLiteVecVectorStore } from './vector/sqlite-vec-store.js';
 export { CollectionManager, globalCollectionName, projectCollectionName } from './vector/collection-manager.js';
 export { VectorIndexer } from './vector/vector-indexer.js';
 export { FederationSearch } from './search/federation-search.js';

package/dist/vector/sqlite-vec-store.d.ts

@@ -0,0 +1,38 @@
+import type { CollectionClient, VectorCollectionInfo, VectorDocument, VectorSearchQuery, VectorSearchResult, VectorStoreInterface } from './types.js';
+interface SearchRow {
+    id: string;
+    content: string;
+    metadata_json: string | null;
+    distance: number;
+}
+export interface SQLiteVecClientOptions {
+    dbPath: string;
+}
+export declare class SQLiteVecClient implements CollectionClient {
+    readonly dbPath: string;
+    private readonly db;
+    constructor(options: SQLiteVecClientOptions);
+    getOrCreateCollection(name: string, metadata?: Record<string, unknown>): Promise<VectorCollectionInfo>;
+    listCollections(): Promise<VectorCollectionInfo[]>;
+    deleteCollection(name: string): Promise<void>;
+    upsert(collectionName: string, documents: VectorDocument[]): void;
+    deleteWhere(collectionName: string, where: Record<string, string | number | boolean>): void;
+    deleteByFilePath(collectionName: string, filePath: string): void;
+    search(collectionName: string, query: VectorSearchQuery): SearchRow[];
+    private getCollection;
+    private requireCollection;
+    private tableName;
+    private parseMetadata;
+    private metadataString;
+}
+export declare class SQLiteVecVectorStore implements VectorStoreInterface {
+    private readonly client;
+    readonly collectionName: string;
+    constructor(client: SQLiteVecClient, collectionName: string);
+    ensureCollection(metadata?: Record<string, unknown>): Promise<void>;
+    upsert(documents: VectorDocument[]): Promise<void>;
+    deleteByFilePath(filePath: string): Promise<void>;
+    search(query: VectorSearchQuery): Promise<VectorSearchResult[]>;
+    private parseDocumentMetadata;
+}
+export {};

package/dist/vector/sqlite-vec-store.js

@@ -0,0 +1,203 @@
+import Database from 'better-sqlite3';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as sqliteVec from 'sqlite-vec';
+export class SQLiteVecClient {
+    dbPath;
+    db;
+    constructor(options) {
+        this.dbPath = options.dbPath;
+        fs.mkdirSync(path.dirname(options.dbPath), { recursive: true });
+        this.db = new Database(options.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        sqliteVec.load(this.db);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS vector_collections (
+        name TEXT PRIMARY KEY,
+        table_name TEXT NOT NULL UNIQUE,
+        dimension INTEGER NOT NULL,
+        metadata_json TEXT,
+        created_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS vector_documents (
+        rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+        collection_name TEXT NOT NULL,
+        id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        metadata_json TEXT,
+                file_path TEXT,
+                vector_rowid INTEGER,
+                created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(collection_name, id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_vector_documents_collection_file ON vector_documents(collection_name, file_path);
+    `);
+        try {
+            this.db.exec('ALTER TABLE vector_documents ADD COLUMN vector_rowid INTEGER');
+        }
+        catch { /* column already exists */ }
+    }
+    async getOrCreateCollection(name, metadata = {}) {
+        const existing = this.getCollection(name);
+        if (existing)
+            return { name: existing.name, metadata: this.parseMetadata(existing.metadata_json) };
+        const dimension = Number(metadata.embedding_dimension ?? 384);
+        const tableName = this.tableName(name);
+        this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName} USING vec0(embedding float[${dimension}])`);
+        this.db.prepare(`
+      INSERT INTO vector_collections (name, table_name, dimension, metadata_json, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(name, tableName, dimension, JSON.stringify(metadata), Date.now());
+        return { name, metadata };
+    }
+    async listCollections() {
+        return this.db.prepare('SELECT name, metadata_json FROM vector_collections ORDER BY name').all()
+            .map(row => {
+            const record = row;
+            return { name: record.name, metadata: this.parseMetadata(record.metadata_json) };
+        });
+    }
+    async deleteCollection(name) {
+        const collection = this.getCollection(name);
+        if (!collection)
+            return;
+        this.db.exec(`DROP TABLE IF EXISTS ${collection.table_name}`);
+        this.db.prepare('DELETE FROM vector_documents WHERE collection_name = ?').run(name);
+        this.db.prepare('DELETE FROM vector_collections WHERE name = ?').run(name);
+    }
+    upsert(collectionName, documents) {
+        if (documents.length === 0)
+            return;
+        const collection = this.requireCollection(collectionName);
+        const deleteVec = this.db.prepare(`DELETE FROM ${collection.table_name} WHERE rowid = ?`);
+        const deleteDoc = this.db.prepare('DELETE FROM vector_documents WHERE collection_name = ? AND id = ?');
+        const insertDoc = this.db.prepare(`
+      INSERT INTO vector_documents (collection_name, id, content, metadata_json, file_path, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        const updateVectorRowid = this.db.prepare('UPDATE vector_documents SET vector_rowid = ? WHERE rowid = ?');
+        const insertVec = this.db.prepare(`INSERT INTO ${collection.table_name} (embedding) VALUES (vec_f32(?))`);
+        const existingRow = this.db.prepare('SELECT rowid, vector_rowid FROM vector_documents WHERE collection_name = ? AND id = ?');
+        const transaction = this.db.transaction((items) => {
+            for (const document of items) {
+                const existing = existingRow.get(collectionName, document.id);
+                if (existing?.vector_rowid)
+                    deleteVec.run(existing.vector_rowid);
+                deleteDoc.run(collectionName, document.id);
+                const now = Date.now();
+                const metadataJson = JSON.stringify(document.metadata);
+                const filePath = this.metadataString(document.metadata.file_path);
+                const documentResult = insertDoc.run(collectionName, document.id, document.content, metadataJson, filePath, now, now);
+                const vectorResult = insertVec.run(JSON.stringify(document.embedding));
+                updateVectorRowid.run(Number(vectorResult.lastInsertRowid), Number(documentResult.lastInsertRowid));
+            }
+        });
+        transaction(documents);
+    }
+    deleteWhere(collectionName, where) {
+        if (typeof where.file_path !== 'string')
+            return;
+        this.deleteByFilePath(collectionName, where.file_path);
+    }
+    deleteByFilePath(collectionName, filePath) {
+        const collection = this.getCollection(collectionName);
+        if (!collection)
+            return;
+        const rows = this.db.prepare('SELECT vector_rowid FROM vector_documents WHERE collection_name = ? AND file_path = ?').all(collectionName, filePath);
+        const deleteVec = this.db.prepare(`DELETE FROM ${collection.table_name} WHERE rowid = ?`);
+        const deleteDocs = this.db.prepare('DELETE FROM vector_documents WHERE collection_name = ? AND file_path = ?');
+        const transaction = this.db.transaction(() => {
+            for (const row of rows) {
+                if (row.vector_rowid)
+                    deleteVec.run(row.vector_rowid);
+            }
+            deleteDocs.run(collectionName, filePath);
+        });
+        transaction();
+    }
+    search(collectionName, query) {
+        const collection = this.getCollection(collectionName);
+        if (!collection)
+            return [];
+        const filePath = query.where?.file_path;
+        if (typeof filePath === 'string') {
+            return this.db.prepare(`
+        SELECT d.id, d.content, d.metadata_json, v.distance
+        FROM (
+          SELECT rowid, distance
+          FROM ${collection.table_name}
+          WHERE embedding MATCH vec_f32(?) AND k = ?
+        ) v
+        JOIN vector_documents d ON d.vector_rowid = v.rowid
+        WHERE d.file_path = ?
+        ORDER BY v.distance
+      `).all(JSON.stringify(query.queryEmbedding), query.topK, filePath);
+        }
+        return this.db.prepare(`
+      SELECT d.id, d.content, d.metadata_json, v.distance
+      FROM (
+        SELECT rowid, distance
+        FROM ${collection.table_name}
+        WHERE embedding MATCH vec_f32(?) AND k = ?
+      ) v
+      JOIN vector_documents d ON d.vector_rowid = v.rowid
+      ORDER BY v.distance
+    `).all(JSON.stringify(query.queryEmbedding), query.topK);
+    }
+    getCollection(name) {
+        return this.db.prepare('SELECT name, table_name, dimension, metadata_json FROM vector_collections WHERE name = ?').get(name);
+    }
+    requireCollection(name) {
+        const collection = this.getCollection(name);
+        if (!collection)
+            throw new Error(`SQLite vec collection not found: ${name}`);
+        return collection;
+    }
+    tableName(collectionName) {
+        const hash = crypto.createHash('sha256').update(collectionName).digest('hex').slice(0, 16);
+        return `vec_${hash}`;
+    }
+    parseMetadata(metadataJson) {
+        if (!metadataJson)
+            return undefined;
+        return JSON.parse(metadataJson);
+    }
+    metadataString(value) {
+        return typeof value === 'string' ? value : null;
+    }
+}
+export class SQLiteVecVectorStore {
+    client;
+    collectionName;
+    constructor(client, collectionName) {
+        this.client = client;
+        this.collectionName = collectionName;
+    }
+    async ensureCollection(metadata) {
+        await this.client.getOrCreateCollection(this.collectionName, metadata);
+    }
+    async upsert(documents) {
+        this.client.upsert(this.collectionName, documents);
+    }
+    async deleteByFilePath(filePath) {
+        this.client.deleteByFilePath(this.collectionName, filePath);
+    }
+    async search(query) {
+        return this.client.search(this.collectionName, query).map(row => ({
+            collection: this.collectionName,
+            score: 1 / (1 + Number(row.distance ?? 0)),
+            document: {
+                id: row.id,
+                content: row.content,
+                metadata: this.parseDocumentMetadata(row.metadata_json),
+            },
+        }));
+    }
+    parseDocumentMetadata(metadataJson) {
+        if (!metadataJson)
+            return {};
+        return JSON.parse(metadataJson);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@customize-agent/knowledge",
-  "version": "2.1.3",
+  "version": "2.2.1",
   "description": "Local knowledge base infrastructure for customize-agent",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,9 +8,15 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/"
+  },
   "license": "MIT",
   "author": "Pan-jijian",
   "repository": {
@@ -32,6 +38,7 @@
   ],
   "dependencies": {
     "better-sqlite3": "^12.10.0",
+    "sqlite-vec": "^0.1.9",
     "fast-glob": "^3.3.3",
     "jszip": "^3.10.1",
     "@napi-rs/canvas": "^0.1.82",
@@ -44,10 +51,5 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.9.3"
-  },
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src/"
   }
-}
+}

package/dist/vector/chroma-store.d.ts

@@ -1,41 +0,0 @@
-import type { CollectionClient, VectorCollectionInfo, VectorDocument, VectorSearchQuery, VectorSearchResult, VectorStoreInterface } from './types.js';
-interface ChromaQueryResponse {
-    ids?: string[][];
-    documents?: string[][];
-    metadatas?: Array<Array<Record<string, unknown>>>;
-    distances?: number[][];
-}
-export interface ChromaClientOptions {
-    baseUrl?: string;
-    tenant?: string;
-    database?: string;
-}
-export declare class ChromaHttpClient implements CollectionClient {
-    readonly baseUrl: string;
-    readonly tenant: string;
-    readonly database: string;
-    private readonly collectionIds;
-    constructor(options?: ChromaClientOptions);
-    heartbeat(): Promise<boolean>;
-    getOrCreateCollection(name: string, metadata?: Record<string, unknown>): Promise<VectorCollectionInfo>;
-    listCollections(): Promise<VectorCollectionInfo[]>;
-    deleteCollection(name: string): Promise<void>;
-    upsert(collectionName: string, documents: VectorDocument[]): Promise<void>;
-    deleteWhere(collectionName: string, where: Record<string, string | number | boolean>): Promise<void>;
-    query(collectionName: string, query: VectorSearchQuery): Promise<ChromaQueryResponse>;
-    private getCollectionId;
-    private collectionsPath;
-    private request;
-    private toCollectionInfo;
-}
-export declare class ChromaVectorStore implements VectorStoreInterface {
-    private readonly client;
-    readonly collectionName: string;
-    constructor(client: ChromaHttpClient, collectionName: string);
-    ensureCollection(metadata?: Record<string, unknown>): Promise<void>;
-    upsert(documents: VectorDocument[]): Promise<void>;
-    deleteByFilePath(filePath: string): Promise<void>;
-    search(query: VectorSearchQuery): Promise<VectorSearchResult[]>;
-    private toMetadata;
-}
-export {};

package/dist/vector/chroma-store.js

@@ -1,162 +0,0 @@
-export class ChromaHttpClient {
-    baseUrl;
-    tenant;
-    database;
-    collectionIds = new Map();
-    constructor(options = {}) {
-        this.baseUrl = options.baseUrl ?? process.env.CHROMA_URL ?? process.env.CHROMA_BASE_URL ?? 'http://localhost:17322';
-        this.tenant = options.tenant ?? 'default_tenant';
-        this.database = options.database ?? 'default_database';
-    }
-    async heartbeat() {
-        try {
-            await this.request('/api/v2/heartbeat');
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async getOrCreateCollection(name, metadata = {}) {
-        const body = { name, get_or_create: true };
-        if (Object.keys(metadata).length > 0)
-            body.metadata = metadata;
-        const response = await this.request(this.collectionsPath(), {
-            method: 'POST',
-            body: JSON.stringify(body),
-        }, 10000);
-        if (response.id)
-            this.collectionIds.set(name, response.id);
-        return this.toCollectionInfo(response);
-    }
-    async listCollections() {
-        const response = await this.request(this.collectionsPath(), {}, 10000);
-        for (const collection of response)
-            if (collection.id)
-                this.collectionIds.set(collection.name, collection.id);
-        return response.map(collection => this.toCollectionInfo(collection));
-    }
-    async deleteCollection(name) {
-        await this.request(`${this.collectionsPath()}/${encodeURIComponent(name)}`, { method: 'DELETE' });
-        this.collectionIds.delete(name);
-    }
-    async upsert(collectionName, documents) {
-        if (documents.length === 0)
-            return;
-        const collectionId = await this.getCollectionId(collectionName);
-        await this.request(`${this.collectionsPath()}/${encodeURIComponent(collectionId)}/upsert`, {
-            method: 'POST',
-            body: JSON.stringify({
-                ids: documents.map(document => document.id),
-                embeddings: documents.map(document => document.embedding),
-                documents: documents.map(document => document.content),
-                metadatas: documents.map(document => document.metadata),
-            }),
-        }, 30000);
-    }
-    async deleteWhere(collectionName, where) {
-        const collectionId = await this.getCollectionId(collectionName);
-        await this.request(`${this.collectionsPath()}/${encodeURIComponent(collectionId)}/delete`, {
-            method: 'POST',
-            body: JSON.stringify({ where }),
-        }, 10000);
-    }
-    async query(collectionName, query) {
-        const collectionId = await this.getCollectionId(collectionName);
-        return this.request(`${this.collectionsPath()}/${encodeURIComponent(collectionId)}/query`, {
-            method: 'POST',
-            body: JSON.stringify({
-                query_embeddings: [query.queryEmbedding],
-                n_results: query.topK,
-                where: query.where,
-                include: ['documents', 'metadatas', 'distances'],
-            }),
-        }, 10000);
-    }
-    async getCollectionId(name) {
-        const cached = this.collectionIds.get(name);
-        if (cached)
-            return cached;
-        const collection = await this.getOrCreateCollection(name);
-        if (!collection.id)
-            throw new Error(`ChromaDB collection has no id: ${name}`);
-        this.collectionIds.set(name, collection.id);
-        return collection.id;
-    }
-    collectionsPath() {
-        return `/api/v2/tenants/${encodeURIComponent(this.tenant)}/databases/${encodeURIComponent(this.database)}/collections`;
-    }
-    async request(path, init = {}, timeoutMs = 3000) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        let response;
-        try {
-            response = await fetch(`${this.baseUrl}${path}`, {
-                ...init,
-                signal: controller.signal,
-                headers: {
-                    'content-type': 'application/json',
-                    ...(init.headers ?? {}),
-                },
-            });
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        if (!response.ok) {
-            throw new Error(`ChromaDB request failed: ${response.status} ${response.statusText}`);
-        }
-        if (response.status === 204)
-            return undefined;
-        return await response.json();
-    }
-    toCollectionInfo(collection) {
-        return {
-            id: collection.id,
-            name: collection.name,
-            metadata: collection.metadata,
-        };
-    }
-}
-export class ChromaVectorStore {
-    client;
-    collectionName;
-    constructor(client, collectionName) {
-        this.client = client;
-        this.collectionName = collectionName;
-    }
-    async ensureCollection(metadata) {
-        await this.client.getOrCreateCollection(this.collectionName, metadata);
-    }
-    async upsert(documents) {
-        await this.client.upsert(this.collectionName, documents);
-    }
-    async deleteByFilePath(filePath) {
-        await this.client.deleteWhere(this.collectionName, { file_path: filePath });
-    }
-    async search(query) {
-        const response = await this.client.query(this.collectionName, query);
-        const ids = response.ids?.[0] ?? [];
-        const documents = response.documents?.[0] ?? [];
-        const metadatas = response.metadatas?.[0] ?? [];
-        const distances = response.distances?.[0] ?? [];
-        return ids.map((id, index) => ({
-            collection: this.collectionName,
-            score: 1 - Number(distances[index] ?? 1),
-            document: {
-                id,
-                content: documents[index] ?? '',
-                metadata: this.toMetadata(metadatas[index] ?? {}),
-            },
-        }));
-    }
-    toMetadata(metadata) {
-        const result = {};
-        for (const [key, value] of Object.entries(metadata)) {
-            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) {
-                result[key] = value;
-            }
-        }
-        return result;
-    }
-}