@customize-agent/knowledge 4.0.1 → 4.0.3

package/dist/extraction/external-extractor.d.ts

@@ -1,9 +1,11 @@
 import type { ClassifiedFile, FileCategory } from '../types.js';
+/** 外部解析器提取结果 */
 export interface ExternalExtractionResult {
     text: string;
     metadata?: Record<string, unknown>;
     warnings?: string[];
 }
+/** 外部解析器接口 */
 export interface ExternalExtractor {
     readonly id: string;
     readonly name: string;
@@ -15,6 +17,7 @@ export interface ExternalExtractor {
     extract(file: ClassifiedFile): ExternalExtractionResult;
     describe(): ExternalExtractorCapability;
 }
+/** 外部解析器能力描述 */
 export interface ExternalExtractorCapability {
     id: string;
     name: string;
@@ -24,6 +27,7 @@ export interface ExternalExtractorCapability {
     available: boolean;
     kind: 'command';
 }
+/** 命令行外部解析器配置选项 */
 export interface CommandExternalExtractorOptions {
     id: string;
     name: string;
@@ -34,6 +38,7 @@ export interface CommandExternalExtractorOptions {
     extensions?: string[];
     timeoutMs?: number;
 }
+/** 命令行外部解析器，通过调用外部命令提取文件内容 */
 export declare class CommandExternalExtractor implements ExternalExtractor {
     readonly id: string;
     readonly name: string;
@@ -51,8 +56,13 @@ export declare class CommandExternalExtractor implements ExternalExtractor {
     private interpolate;
     private checkAvailable;
 }
+/** 外部解析器注册表，管理所有已注册的外部解析器 */
 export declare class ExternalExtractorRegistry {
     private readonly extractors;
+    /**
+     * 根据环境变量自动注册可用解析器
+     * @param env 环境变量（默认 process.env）
+     */
     static fromEnvironment(env?: NodeJS.ProcessEnv): ExternalExtractorRegistry;
     register(extractor: ExternalExtractor): void;
     findAll(file: ClassifiedFile): ExternalExtractor[];

package/dist/extraction/external-extractor.js

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import * as path from 'node:path';
+/** 命令行外部解析器，通过调用外部命令提取文件内容 */
 export class CommandExternalExtractor {
     id;
     name;
@@ -87,8 +88,13 @@ export class CommandExternalExtractor {
         return !result.error;
     }
 }
+/** 外部解析器注册表，管理所有已注册的外部解析器 */
 export class ExternalExtractorRegistry {
     extractors = [];
+    /**
+     * 根据环境变量自动注册可用解析器
+     * @param env 环境变量（默认 process.env）
+     */
     static fromEnvironment(env = process.env) {
         const registry = new ExternalExtractorRegistry();
         registry.registerConfiguredOrAuto('cad-dwg', 'DWG Advanced Parser', env.CUSTOMIZE_AGENT_DWG_PARSER, [{ command: 'dwg-parser' }, { command: 'oda-dwg-parser' }], { category: 'cad', formats: ['autocad'], extensions: ['.dwg', '.dwt'] });

package/dist/extraction/module-resolver.js

@@ -37,7 +37,7 @@ function findInPnpm(packageName) {
                     }
                 }
             }
-            catch { /* continue upward */ }
+            catch { /* 继续向上遍历 */ }
         }
         const parent = path.dirname(dir);
         if (parent === dir)
@@ -54,7 +54,7 @@ export function resolvePackage(specifier) {
     try {
         return localRequire.resolve(specifier);
     }
-    catch { /* fall through */ }
+    catch { /* 继续尝试后续回退方式 */ }
     const parts = specifier.split('/');
     let packageName;
     if (parts[0]?.startsWith('@')) {

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { TextChunker, type ChunkConfig, type TextChunk } from './chunking/text-c
 export { FileClassifier } from './classification/classifier.js';
 export { DedupEngine, type MinHashSignature, type SimilarityMatch } from './dedup/dedup-engine.js';
 export { RelationshipDetector } from './dedup/relationship-detector.js';
-export { HashEmbeddingProvider, OpenAICompatibleEmbeddingProvider, createEmbeddingProviderFromEnvironment, type EmbeddingProvider, type OpenAICompatibleEmbeddingOptions } from './embedding/embedding-provider.js';
+export { HashEmbeddingProvider, LocalTransformersEmbeddingProvider, OpenAICompatibleEmbeddingProvider, createEmbeddingProviderFromEnvironment, type EmbeddingProvider, type LocalTransformersEmbeddingOptions, type OpenAICompatibleEmbeddingOptions } from './embedding/embedding-provider.js';
 export { ContentExtractor, type ExtractionResult } from './extraction/content-extractor.js';
 export { CommandExternalExtractor, ExternalExtractorRegistry, type CommandExternalExtractorOptions, type ExternalExtractionResult, type ExternalExtractor, type ExternalExtractorCapability } from './extraction/external-extractor.js';
 export { ChangeTracker } from './core/change-tracker.js';
@@ -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 { SQLiteVecClient, SQLiteVecVectorStore, type SQLiteVecClientOptions } from './vector/sqlite-vec-store.js';
+export { HNSWVectorStore } from './vector/hnsw-vector-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

@@ -1,10 +1,10 @@
-// Types and constants from types.ts and constants.ts are not exported
-// as they are only used internally within the knowledge package.
+// types.ts 和 constants.ts 中的类型和常量不对外导出
+// 它们仅在 knowledge 包内部使用。
 export { TextChunker } from './chunking/text-chunker.js';
 export { FileClassifier } from './classification/classifier.js';
 export { DedupEngine } from './dedup/dedup-engine.js';
 export { RelationshipDetector } from './dedup/relationship-detector.js';
-export { HashEmbeddingProvider, OpenAICompatibleEmbeddingProvider, createEmbeddingProviderFromEnvironment } from './embedding/embedding-provider.js';
+export { HashEmbeddingProvider, LocalTransformersEmbeddingProvider, OpenAICompatibleEmbeddingProvider, createEmbeddingProviderFromEnvironment } from './embedding/embedding-provider.js';
 export { ContentExtractor } from './extraction/content-extractor.js';
 export { CommandExternalExtractor, ExternalExtractorRegistry } from './extraction/external-extractor.js';
 export { ChangeTracker } from './core/change-tracker.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 { SQLiteVecClient, SQLiteVecVectorStore } from './vector/sqlite-vec-store.js';
+export { HNSWVectorStore } from './vector/hnsw-vector-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/search/federation-search.d.ts

@@ -1,7 +1,10 @@
 import type { VectorStoreInterface } from '../vector/types.js';
+/** 搜索范围：项目级、全局级或全部 */
 export type SearchScope = 'project' | 'global' | 'all';
+/** 联合搜索结果项 */
 export interface FederatedSearchItem {
     id: string;
+    rowid?: number;
     content: string;
     filePath: string;
     scope: 'project' | 'global';
@@ -25,6 +28,7 @@ export interface FederatedSearchItem {
     };
     facets?: Record<string, string | number | string[]>;
 }
+/** 联合搜索结果 */
 export interface FederatedResult {
     results: FederatedSearchItem[];
     scopesSearched: Array<'project' | 'global'>;
@@ -37,16 +41,19 @@ export interface FederatedResult {
         reranker?: string;
     };
 }
+/** 搜索过滤器 */
 export interface SearchFilters {
     category?: string;
     filePath?: string;
 }
+/** 各检索方式权重配置 */
 export interface RetrievalWeights {
     keyword?: number;
     vector?: number;
     rewrite?: number;
     hybridBonus?: number;
 }
+/** 联合搜索查询参数 */
 export interface FederatedQuery {
     query: string;
     queryEmbedding: number[];
@@ -56,6 +63,7 @@ export interface FederatedQuery {
     collections?: string[];
     filters?: SearchFilters;
 }
+/** 联合搜索器，支持跨向量存储的分布式搜索和结果合并 */
 export declare class FederationSearch {
     private readonly vectorStores;
     static readonly SCOPE_WEIGHTS: Record<'project' | 'global', number>;

package/dist/search/federation-search.js

@@ -1,5 +1,6 @@
 import { ALL_CATEGORIES } from '../constants.js';
 import { globalCollectionName, projectCollectionName } from '../vector/collection-manager.js';
+/** 联合搜索器，支持跨向量存储的分布式搜索和结果合并 */
 export class FederationSearch {
     vectorStores;
     static SCOPE_WEIGHTS = {
@@ -73,6 +74,7 @@ export class FederationSearch {
     toFederatedItem(result, scope) {
         return {
             id: result.document.id,
+            rowid: typeof result.document.metadata.sqlite_rowid === 'number' ? result.document.metadata.sqlite_rowid : undefined,
             content: result.document.content,
             filePath: String(result.document.metadata.file_path ?? ''),
             scope,

package/dist/types.d.ts

@@ -1,6 +1,10 @@
+/** 知识库作用域：项目级、全局级或会话级 */
 export type KBScope = 'project' | 'global' | 'session';
+/** 文件分类枚举 */
 export type FileCategory = 'document' | 'spreadsheet' | 'image' | 'cad' | 'code' | 'data' | 'web' | 'diagram' | 'archive' | 'other';
+/** 项目状态：活跃、空闲或错误 */
 export type ProjectStatus = 'active' | 'idle' | 'error';
+/** 项目信息 */
 export interface ProjectInfo {
     projectId: string;
     projectRoot: string;
@@ -13,6 +17,7 @@ export interface ProjectInfo {
     lastOpenedAt: number;
     status: ProjectStatus;
 }
+/** 项目配置 */
 export interface ProjectConfig {
     projectId: string;
     projectName?: string;
@@ -27,6 +32,7 @@ export interface ProjectConfig {
     createdAt: number;
     lastOpenedAt: number;
 }
+/** 已分类的文件信息 */
 export interface ClassifiedFile {
     absolutePath: string;
     relativePath: string;
@@ -36,6 +42,7 @@ export interface ClassifiedFile {
     mtime: number;
     mimeType: string;
 }
+/** 索引状态记录 */
 export interface IndexStateRecord {
     relativePath: string;
     category: FileCategory;
@@ -51,6 +58,7 @@ export interface IndexStateRecord {
     errorMessage?: string;
     metadataJson?: string;
 }
+/** 文件差异对比结果 */
 export interface DiffResult {
     newFiles: ClassifiedFile[];
     modifiedFiles: ClassifiedFile[];
@@ -64,6 +72,7 @@ export interface DiffResult {
     hasChanges: boolean;
     diffTimeMs: number;
 }
+/** 知识库统计信息 */
 export interface KnowledgeBaseStats {
     scope: Exclude<KBScope, 'session'>;
     projectId?: string;
@@ -72,6 +81,7 @@ export interface KnowledgeBaseStats {
     totalSizeBytes: number;
     lastIndexedAt: number;
 }
+/** 跨项目重复文件检测结果 */
 export interface CrossProjectDuplicate {
     contentHash: string;
     files: Array<{

package/dist/vector/collection-manager.d.ts

@@ -1,7 +1,10 @@
 import type { FileCategory } from '../types.js';
 import type { CollectionClient } from './types.js';
+/** 生成项目级 Collection 名称 */
 export declare function projectCollectionName(projectId: string, category: FileCategory): string;
+/** 生成全局 Collection 名称 */
 export declare function globalCollectionName(category: FileCategory): string;
+/** Collection 管理器，负责 Vector Collection 的创建和管理 */
 export declare class CollectionManager {
     private readonly client?;
     constructor(client?: CollectionClient | undefined);

package/dist/vector/collection-manager.js

@@ -1,10 +1,13 @@
 import { ALL_CATEGORIES, COLLECTION_CATEGORY_NAMES } from '../constants.js';
+/** 生成项目级 Collection 名称 */
 export function projectCollectionName(projectId, category) {
     return `proj_${projectId}_kb_${COLLECTION_CATEGORY_NAMES[category]}`;
 }
+/** 生成全局 Collection 名称 */
 export function globalCollectionName(category) {
     return `global_kb_${COLLECTION_CATEGORY_NAMES[category]}`;
 }
+/** Collection 管理器，负责 Vector Collection 的创建和管理 */
 export class CollectionManager {
     client;
     constructor(client) {

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

@@ -0,0 +1,21 @@
+import type { VectorDocument, VectorSearchQuery, VectorSearchResult, VectorStoreInterface } from './types.js';
+/** HNSW（分层可导航小世界图）向量存储，基于 hnswlib-node 实现的高效近似最近邻搜索 */
+export declare class HNSWVectorStore implements VectorStoreInterface {
+    readonly collectionName: string;
+    private readonly indexPath;
+    private readonly dimensions;
+    private readonly maxElements;
+    private index?;
+    private deletedSinceRebuild;
+    private readonly documents;
+    constructor(collectionName: string, indexPath: string, dimensions?: number, maxElements?: number);
+    ensureCollection(): Promise<void>;
+    upsert(documents: VectorDocument[]): Promise<void>;
+    clearCollection(): Promise<void>;
+    deleteByFilePath(filePath: string): Promise<void>;
+    needsRebuild(): boolean;
+    search(query: VectorSearchQuery): Promise<VectorSearchResult[]>;
+    private persist;
+    private loadDocuments;
+    private metadataPath;
+}

package/dist/vector/hnsw-vector-store.js

@@ -0,0 +1,108 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+/** HNSW（分层可导航小世界图）向量存储，基于 hnswlib-node 实现的高效近似最近邻搜索 */
+export class HNSWVectorStore {
+    collectionName;
+    indexPath;
+    dimensions;
+    maxElements;
+    index;
+    deletedSinceRebuild = 0;
+    documents = new Map();
+    constructor(collectionName, indexPath, dimensions = 512, maxElements = 500_000) {
+        this.collectionName = collectionName;
+        this.indexPath = indexPath;
+        this.dimensions = dimensions;
+        this.maxElements = maxElements;
+    }
+    async ensureCollection() {
+        if (this.index)
+            return;
+        fs.mkdirSync(path.dirname(this.indexPath), { recursive: true });
+        this.loadDocuments();
+        const mod = require('hnswlib-node');
+        this.index = new mod.HierarchicalNSW('cosine', this.dimensions);
+        if (fs.existsSync(this.indexPath))
+            this.index.readIndexSync(this.indexPath, true);
+        else
+            this.index.initIndex(this.maxElements, 16, 200, 100, true);
+    }
+    async upsert(documents) {
+        await this.ensureCollection();
+        for (const document of documents) {
+            const rowid = Number(document.metadata.sqlite_rowid);
+            if (!Number.isFinite(rowid) || rowid <= 0)
+                throw new Error(`HNSW 向量写入缺少有效 sqlite_rowid: ${document.id}`);
+            this.index.addPoint(document.embedding, rowid, true);
+            this.documents.set(rowid, document);
+        }
+        this.persist();
+    }
+    async clearCollection() {
+        if (fs.existsSync(this.indexPath))
+            fs.rmSync(this.indexPath, { force: true });
+        if (fs.existsSync(this.metadataPath()))
+            fs.rmSync(this.metadataPath(), { force: true });
+        this.documents.clear();
+        this.deletedSinceRebuild = 0;
+        this.index = undefined;
+        await this.ensureCollection();
+    }
+    async deleteByFilePath(filePath) {
+        await this.ensureCollection();
+        for (const [rowid, document] of this.documents.entries()) {
+            if (document.metadata.file_path === filePath) {
+                try {
+                    this.index.markDelete(rowid);
+                    this.deletedSinceRebuild += 1;
+                }
+                catch { /* 忽略缺失的标签 */ }
+                this.documents.delete(rowid);
+            }
+        }
+        this.persist();
+    }
+    needsRebuild() {
+        const total = this.documents.size + this.deletedSinceRebuild;
+        return total >= 1000 && this.deletedSinceRebuild / total > 0.25;
+    }
+    async search(query) {
+        await this.ensureCollection();
+        const result = this.index.searchKnn(query.queryEmbedding, query.topK);
+        return result.neighbors.flatMap((rowid, index) => {
+            const document = this.documents.get(rowid);
+            if (!document)
+                return [];
+            if (typeof query.where?.file_path === 'string' && document.metadata.file_path !== query.where.file_path)
+                return [];
+            const { embedding: _embedding, ...stored } = document;
+            const distance = result.distances[index] ?? 0;
+            return [{ collection: this.collectionName, document: stored, score: 1 / (1 + distance) }];
+        });
+    }
+    persist() {
+        this.index.writeIndexSync(this.indexPath);
+        fs.writeFileSync(this.metadataPath(), JSON.stringify({ deletedSinceRebuild: this.deletedSinceRebuild, documents: [...this.documents.entries()] }), 'utf8');
+    }
+    loadDocuments() {
+        const file = this.metadataPath();
+        if (!fs.existsSync(file))
+            return;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+            const entries = Array.isArray(parsed) ? parsed : parsed.documents ?? [];
+            this.deletedSinceRebuild = Array.isArray(parsed) ? 0 : Number(parsed.deletedSinceRebuild ?? 0);
+            this.documents.clear();
+            for (const [rowid, document] of entries)
+                this.documents.set(Number(rowid), document);
+        }
+        catch {
+            this.documents.clear();
+        }
+    }
+    metadataPath() {
+        return `${this.indexPath}.documents.json`;
+    }
+}

package/dist/vector/types.d.ts

@@ -1,31 +1,39 @@
+/** 向量文档，包含文本内容、嵌入向量和元数据 */
 export interface VectorDocument {
     id: string;
     content: string;
     embedding: number[];
     metadata: Record<string, string | number | boolean | null>;
 }
+/** 向量搜索查询参数 */
 export interface VectorSearchQuery {
     queryEmbedding: number[];
     topK: number;
     where?: Record<string, string | number | boolean>;
 }
+/** 向量搜索结果 */
 export interface VectorSearchResult {
     document: Omit<VectorDocument, 'embedding'>;
     score: number;
     collection: string;
 }
+/** Vector Collection 信息 */
 export interface VectorCollectionInfo {
     id?: string;
     name: string;
     metadata?: Record<string, unknown>;
 }
+/** 向量存储接口，定义所有向量存储实现必须支持的方法 */
 export interface VectorStoreInterface {
     readonly collectionName: string;
     ensureCollection(metadata?: Record<string, unknown>): Promise<void>;
     upsert(documents: VectorDocument[]): Promise<void>;
     deleteByFilePath(filePath: string): Promise<void>;
+    clearCollection?(): Promise<void>;
+    needsRebuild?(): boolean;
     search(query: VectorSearchQuery): Promise<VectorSearchResult[]>;
 }
+/** Collection Client 接口，用于管理远程 Vector Collection */
 export interface CollectionClient {
     getOrCreateCollection(name: string, metadata?: Record<string, unknown>): Promise<VectorCollectionInfo>;
     listCollections(): Promise<VectorCollectionInfo[]>;

package/dist/vector/vector-indexer.d.ts

@@ -1,18 +1,32 @@
 import type { EmbeddingProvider } from '../embedding/embedding-provider.js';
 import type { StoredChunk } from '../core/index-state-store.js';
 import type { VectorStoreInterface } from './types.js';
+/** 向量索引结果 */
 export interface VectorIndexResult {
     collectionName: string;
     chunkCount: number;
     embeddingModel: string;
     embeddingDimension: number;
 }
+export interface VectorIndexProgress {
+    collectionName: string;
+    processedChunks: number;
+    totalChunks: number;
+    batchSize: number;
+}
+export interface VectorIndexOptions {
+    batchSize?: number;
+    onProgress?: (progress: VectorIndexProgress) => void;
+}
+/** 向量索引器，负责将文本切片生成 Embedding 并写入向量存储 */
 export declare class VectorIndexer {
     private readonly embeddingProvider;
     private readonly vectorStores;
     constructor(embeddingProvider: EmbeddingProvider, vectorStores: Map<string, VectorStoreInterface>);
-    indexChunks(chunks: StoredChunk[]): Promise<VectorIndexResult[]>;
+    indexChunks(chunks: StoredChunk[], options?: VectorIndexOptions): Promise<VectorIndexResult[]>;
     deleteFile(collectionName: string, filePath: string): Promise<void>;
+    private embedDocuments;
+    private isValidEmbeddings;
     private groupByCollection;
     private toVectorDocument;
     private parseMetadata;

package/dist/vector/vector-indexer.js

@@ -1,3 +1,10 @@
+function resolveVectorIndexBatchSize(configured) {
+    const raw = configured ?? Number(process.env.CUSTOMIZE_VECTOR_INDEX_BATCH_SIZE ?? process.env.KB_VECTOR_INDEX_BATCH_SIZE);
+    if (!Number.isFinite(raw) || raw <= 0)
+        return 32;
+    return Math.max(1, Math.min(256, Math.floor(raw)));
+}
+/** 向量索引器，负责将文本切片生成 Embedding 并写入向量存储 */
 export class VectorIndexer {
     embeddingProvider;
     vectorStores;
@@ -5,9 +12,11 @@ export class VectorIndexer {
         this.embeddingProvider = embeddingProvider;
         this.vectorStores = vectorStores;
     }
-    async indexChunks(chunks) {
+    async indexChunks(chunks, options = {}) {
         const byCollection = this.groupByCollection(chunks);
         const results = [];
+        const totalChunks = chunks.length;
+        let processedTotalChunks = 0;
         for (const [collectionName, collectionChunks] of byCollection) {
             const store = this.vectorStores.get(collectionName);
             if (!store)
@@ -16,12 +25,21 @@ export class VectorIndexer {
                 embedding_model: this.embeddingProvider.model,
                 embedding_dimension: this.embeddingProvider.dimensions,
             });
-            const embeddings = await this.embeddingProvider.embedDocuments(collectionChunks.map(chunk => chunk.content));
-            const documents = collectionChunks.map((chunk, index) => this.toVectorDocument(chunk, embeddings[index] ?? []));
-            await store.upsert(documents);
+            const batchSize = resolveVectorIndexBatchSize(options.batchSize);
+            let processedChunks = 0;
+            for (let offset = 0; offset < collectionChunks.length; offset += batchSize) {
+                const batchChunks = collectionChunks.slice(offset, offset + batchSize);
+                const texts = batchChunks.map(chunk => chunk.content);
+                const embeddings = await this.embedDocuments(texts);
+                const documents = batchChunks.map((chunk, index) => this.toVectorDocument(chunk, embeddings[index] ?? []));
+                await store.upsert(documents);
+                processedChunks += documents.length;
+                processedTotalChunks += documents.length;
+                options.onProgress?.({ collectionName, processedChunks: processedTotalChunks, totalChunks, batchSize: documents.length });
+            }
             results.push({
                 collectionName,
-                chunkCount: documents.length,
+                chunkCount: processedChunks,
                 embeddingModel: this.embeddingProvider.model,
                 embeddingDimension: this.embeddingProvider.dimensions,
             });
@@ -34,6 +52,16 @@ export class VectorIndexer {
             return;
         await store.deleteByFilePath(filePath);
     }
+    async embedDocuments(texts) {
+        const embeddings = await this.embeddingProvider.embedDocuments(texts);
+        if (!this.isValidEmbeddings(embeddings, texts.length, this.embeddingProvider.dimensions)) {
+            throw new Error(`Embedding 结果异常：期望 ${texts.length} 条 ${this.embeddingProvider.dimensions} 维向量，实际返回 ${embeddings.length} 条`);
+        }
+        return embeddings;
+    }
+    isValidEmbeddings(embeddings, count, dimensions) {
+        return embeddings.length === count && embeddings.every(vector => vector.length === dimensions && vector.every(value => Number.isFinite(value)));
+    }
     groupByCollection(chunks) {
         const grouped = new Map();
         for (const chunk of chunks) {
@@ -50,6 +78,7 @@ export class VectorIndexer {
             content: chunk.content,
             embedding,
             metadata: {
+                sqlite_rowid: chunk.rowid,
                 file_path: chunk.relativePath,
                 chunk_index: chunk.chunkIndex,
                 category: chunk.category,

package/models/bge-small-zh-v1.5/config.json

@@ -0,0 +1,31 @@
+{
+  "_name_or_path": "BAAI/bge-small-zh-v1.5",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 512,
+  "id2label": {
+    "0": "LABEL_0"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 2048,
+  "label2id": {
+    "LABEL_0": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 4,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "transformers_version": "4.34.0.dev0",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 21128
+}

package/models/bge-small-zh-v1.5/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}