@customize-agent/knowledge 2.1.2 → 2.2.0

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/qdrant-store.d.ts

@@ -0,0 +1,37 @@
+import type { CollectionClient, VectorCollectionInfo, VectorDocument, VectorSearchQuery, VectorSearchResult, VectorStoreInterface } from './types.js';
+interface QdrantSearchPoint {
+    id: string | number;
+    score?: number;
+    payload?: Record<string, unknown>;
+}
+export interface QdrantClientOptions {
+    baseUrl?: string;
+}
+export declare class QdrantHttpClient implements CollectionClient {
+    readonly baseUrl: string;
+    constructor(options?: QdrantClientOptions);
+    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>;
+    search(collectionName: string, query: VectorSearchQuery): Promise<QdrantSearchPoint[]>;
+    private getCollection;
+    private toFilter;
+    private pointId;
+    private toPayload;
+    private request;
+}
+export declare class QdrantVectorStore implements VectorStoreInterface {
+    private readonly client;
+    readonly collectionName: string;
+    constructor(client: QdrantHttpClient, 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 payloadString;
+    private toMetadata;
+}
+export {};

package/dist/vector/qdrant-store.js

@@ -0,0 +1,172 @@
+import * as crypto from 'node:crypto';
+export class QdrantHttpClient {
+    baseUrl;
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl ?? process.env.QDRANT_URL ?? process.env.QDRANT_BASE_URL ?? 'http://127.0.0.1:6333';
+    }
+    async heartbeat() {
+        try {
+            await this.request('/collections', {}, 3000);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getOrCreateCollection(name, metadata = {}) {
+        const existing = await this.getCollection(name);
+        if (existing)
+            return existing;
+        const size = Number(metadata.embedding_dimension ?? process.env.QDRANT_VECTOR_SIZE ?? 384);
+        await this.request(`/collections/${encodeURIComponent(name)}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                vectors: { size, distance: 'Cosine' },
+                on_disk_payload: true,
+            }),
+        }, 30000);
+        return { name, metadata };
+    }
+    async listCollections() {
+        const response = await this.request('/collections', {}, 10000);
+        return (response.result?.collections ?? []).map(collection => ({ name: collection.name }));
+    }
+    async deleteCollection(name) {
+        await this.request(`/collections/${encodeURIComponent(name)}`, { method: 'DELETE' }, 30000);
+    }
+    async upsert(collectionName, documents) {
+        if (documents.length === 0)
+            return;
+        await this.request(`/collections/${encodeURIComponent(collectionName)}/points?wait=true`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                points: documents.map(document => ({
+                    id: this.pointId(document.id),
+                    vector: document.embedding,
+                    payload: this.toPayload({
+                        ...document.metadata,
+                        id: document.id,
+                        content: document.content,
+                    }),
+                })),
+            }),
+        }, 60000);
+    }
+    async deleteWhere(collectionName, where) {
+        await this.request(`/collections/${encodeURIComponent(collectionName)}/points/delete?wait=true`, {
+            method: 'POST',
+            body: JSON.stringify({
+                filter: this.toFilter(where),
+            }),
+        }, 30000);
+    }
+    async search(collectionName, query) {
+        const response = await this.request(`/collections/${encodeURIComponent(collectionName)}/points/search`, {
+            method: 'POST',
+            body: JSON.stringify({
+                vector: query.queryEmbedding,
+                limit: query.topK,
+                filter: query.where ? this.toFilter(query.where) : undefined,
+                with_payload: true,
+            }),
+        }, 30000);
+        return response.result ?? [];
+    }
+    async getCollection(name) {
+        try {
+            await this.request(`/collections/${encodeURIComponent(name)}`, {}, 10000);
+            return { name };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('404'))
+                return undefined;
+            throw error;
+        }
+    }
+    toFilter(where) {
+        return {
+            must: Object.entries(where).map(([key, value]) => ({ key, match: { value } })),
+        };
+    }
+    pointId(id) {
+        const hash = crypto.createHash('sha256').update(id).digest('hex');
+        return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+    }
+    toPayload(payload) {
+        const result = {};
+        for (const [key, value] of Object.entries(payload)) {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    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) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Qdrant request failed: ${response.status} ${response.statusText} ${body}`.trim());
+        }
+        if (response.status === 204)
+            return undefined;
+        return await response.json();
+    }
+}
+export class QdrantVectorStore {
+    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 points = await this.client.search(this.collectionName, query);
+        return points.map(point => ({
+            collection: this.collectionName,
+            score: Number(point.score ?? 0),
+            document: {
+                id: this.payloadString(point.payload?.id) ?? String(point.id),
+                content: this.payloadString(point.payload?.content) ?? '',
+                metadata: this.toMetadata(point.payload ?? {}),
+            },
+        }));
+    }
+    payloadString(value) {
+        return typeof value === 'string' ? value : undefined;
+    }
+    toMetadata(payload) {
+        const result = {};
+        for (const [key, value] of Object.entries(payload)) {
+            if (key === 'content')
+                continue;
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+}

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.2",
+  "version": "2.2.0",
   "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/"
   }
-}
+}