@customize-agent/knowledge 4.0.33 → 4.0.34

package/dist/core/index-state-store.d.ts

@@ -130,11 +130,21 @@ export declare class IndexStateStore {
         format: string;
         collectionName: string;
     }): void;
+    private chunkQueryParts;
     listChunks(options?: {
         collectionName?: string;
         relativePath?: string;
         limit?: number;
     }): StoredChunk[];
+    countChunks(options?: {
+        collectionName?: string;
+        relativePath?: string;
+    }): number;
+    listChunksByContentBudget(options?: {
+        collectionName?: string;
+        relativePath?: string;
+        maxContentChars?: number;
+    }): StoredChunk[];
     getChunkByRowid(rowid: number): StoredChunk | undefined;
     getChunksByRowids(rowids: number[]): StoredChunk[];
     getContextChunks(relativePath: string, chunkIndex: number, window?: number): StoredChunk[];
@@ -152,6 +162,7 @@ export declare class IndexStateStore {
         filePaths?: string[];
     }): ChunkSearchResult[];
     private filePathFilterClause;
+    private resolveChunkSearchLimit;
     private searchChunksFts;
     private searchChunksLike;
     findExactDuplicate(contentHash: string, excludePath?: string): FileHashRecord | undefined;

package/dist/core/index-state-store.js

@@ -182,7 +182,7 @@ export class IndexStateStore {
         });
         transaction();
     }
-    listChunks(options = {}) {
+    chunkQueryParts(options = {}) {
         const conditions = [];
         const params = [];
         if (options.collectionName) {
@@ -194,17 +194,47 @@ export class IndexStateStore {
             params.push(options.relativePath);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        return { where, params };
+    }
+    listChunks(options = {}) {
+        const { where, params } = this.chunkQueryParts(options);
         const limit = options.limit ? 'LIMIT ?' : '';
-        if (options.limit)
-            params.push(options.limit);
+        const queryParams = options.limit ? [...params, options.limit] : params;
         const rows = this.db.prepare(`
       SELECT rowid, * FROM kb_chunks
       ${where}
       ORDER BY relative_path, chunk_index
       ${limit}
-    `).all(...params);
+    `).all(...queryParams);
         return rows.map(row => this.rowToChunk(row, 0));
     }
+    countChunks(options = {}) {
+        const { where, params } = this.chunkQueryParts(options);
+        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM kb_chunks ${where}`).get(...params);
+        return Number(row?.count || 0);
+    }
+    listChunksByContentBudget(options = {}) {
+        const maxContentChars = Number(options.maxContentChars);
+        if (!Number.isFinite(maxContentChars) || maxContentChars <= 0)
+            return this.listChunks(options);
+        const { where, params } = this.chunkQueryParts(options);
+        const rows = this.db.prepare(`
+      SELECT rowid, * FROM kb_chunks
+      ${where}
+      ORDER BY relative_path, chunk_index
+    `).iterate(...params);
+        const chunks = [];
+        let usedChars = 0;
+        for (const row of rows) {
+            const chunk = this.rowToChunk(row, 0);
+            const length = chunk.content?.length || 0;
+            if (chunks.length > 0 && usedChars + length > maxContentChars)
+                break;
+            chunks.push(chunk);
+            usedChars += length;
+        }
+        return chunks;
+    }
     getChunkByRowid(rowid) {
         const row = this.db.prepare('SELECT rowid, * FROM kb_chunks WHERE rowid = ?').get(rowid);
         return row ? this.rowToChunk(row, 0) : undefined;
@@ -264,20 +294,28 @@ export class IndexStateStore {
      * @param limit 返回结果数量上限
      * @returns 搜索结果列表（按相关性得分排序）
      */
-    searchChunks(query, limit = 10, filters = {}) {
+    searchChunks(query, limit, filters = {}) {
         const terms = this.expandSearchTerms(query);
         if (terms.length === 0)
             return [];
         const filePaths = [...new Set((filters.filePaths ?? []).filter(Boolean))];
+        const effectiveLimit = this.resolveChunkSearchLimit(limit, filePaths);
         const results = [
-            ...(this.ftsEnabled ? this.searchChunksFts(terms, limit, filePaths) : []),
-            ...this.searchChunksLike(terms, limit, filePaths),
+            ...(this.ftsEnabled ? this.searchChunksFts(terms, effectiveLimit, filePaths) : []),
+            ...this.searchChunksLike(terms, effectiveLimit, filePaths),
         ];
-        return this.mergeKeywordResults(results, limit);
+        return this.mergeKeywordResults(results, effectiveLimit);
     }
     filePathFilterClause(filePaths, column = 'relative_path') {
         return filePaths.length > 0 ? ` AND ${column} IN (${filePaths.map(() => '?').join(', ')})` : '';
     }
+    resolveChunkSearchLimit(limit, filePaths) {
+        if (Number.isFinite(limit) && limit > 0)
+            return Math.ceil(limit);
+        const row = this.db.prepare(`SELECT COUNT(*) as count FROM kb_chunks WHERE 1 = 1${this.filePathFilterClause(filePaths)}`)
+            .get(...filePaths);
+        return Math.max(1, Math.ceil(Number(row?.count) || 0));
+    }
     searchChunksFts(terms, limit, filePaths) {
         try {
             const matchQuery = this.toFtsQuery(terms);

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

@@ -66,6 +66,8 @@ export declare class KnowledgeBaseManager {
     }): Promise<DiffResult>;
     search(query: string, limit?: number, filters?: SearchFilters): ChunkSearchResult[];
     keywordSearchItems(query: string, limit?: number, filters?: SearchFilters): FederatedSearchItem[];
+    private resolveSearchLimit;
+    private searchCorpusSize;
     expandContext(item: FederatedSearchItem): FederatedSearchItem;
     hybridSearch(query: string, options?: {
         limit?: number;
@@ -81,11 +83,14 @@ export declare class KnowledgeBaseManager {
     }): Promise<FederatedResult>;
     listRelationships(filePath?: string): FileRelationship[];
     listFiles(): IndexStateRecord[];
-    getFileDetail(relativePath: string): {
+    getFileDetail(relativePath: string, options?: {
+        maxChunkContentChars?: number;
+    }): {
         file: IndexStateRecord;
         absolutePath: string;
         directory: string;
         chunks: import("./index-state-store.js").StoredChunk[];
+        totalChunkCount: number;
         parents: import("./index-state-store.js").StoredParentChunk[];
         relationships: FileRelationship[];
         tags: {

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

@@ -326,11 +326,24 @@ export class KnowledgeBaseManager {
             this.onProgress = previousOnProgress;
         }
     }
-    search(query, limit = 10, filters) {
-        return this.store.searchChunks(query, limit, { filePaths: filters?.filePaths ?? (filters?.filePath ? [filters.filePath] : undefined) });
+    search(query, limit, filters) {
+        return this.store.searchChunks(query, this.resolveSearchLimit(limit, filters), { filePaths: filters?.filePaths ?? (filters?.filePath ? [filters.filePath] : undefined) });
     }
-    keywordSearchItems(query, limit = 10, filters) {
-        return this.store.searchChunks(query, limit, { filePaths: filters?.filePaths ?? (filters?.filePath ? [filters.filePath] : undefined) }).map(result => this.toFederatedItem(result, 'keyword'));
+    keywordSearchItems(query, limit, filters) {
+        return this.store.searchChunks(query, this.resolveSearchLimit(limit, filters), { filePaths: filters?.filePaths ?? (filters?.filePath ? [filters.filePath] : undefined) }).map(result => this.toFederatedItem(result, 'keyword'));
+    }
+    resolveSearchLimit(limit, filters) {
+        if (Number.isFinite(limit) && limit > 0)
+            return Math.ceil(limit);
+        return this.searchCorpusSize(filters);
+    }
+    searchCorpusSize(filters) {
+        const paths = filters?.filePaths ?? (filters?.filePath ? [filters.filePath] : undefined);
+        const pathSet = new Set(paths?.filter(Boolean));
+        const total = this.store.listRecords()
+            .filter(record => pathSet.size === 0 || pathSet.has(record.relativePath))
+            .reduce((sum, record) => sum + Math.max(0, Math.ceil(Number(record.chunkCount) || 0)), 0);
+        return Math.max(1, total);
     }
     expandContext(item) {
         const chunkIndex = item.chunkIndex ?? this.parseChunkIndex(item.id);
@@ -361,7 +374,9 @@ export class KnowledgeBaseManager {
         };
     }
     async hybridSearch(query, options = {}) {
-        const limit = options.limit ?? 10;
+        const requestedLimit = Number.isFinite(options.limit) && options.limit > 0 ? Math.ceil(options.limit) : undefined;
+        const corpusSize = this.searchCorpusSize(options.filters);
+        const effectiveLimit = requestedLimit ?? corpusSize;
         const start = Date.now();
         const weights = this.retrievalWeights(options.weights);
         const rewrittenQueries = options.generationMode ? [query.trim()].filter(Boolean) : await this.rewriteQueries(query);
@@ -370,10 +385,12 @@ export class KnowledgeBaseManager {
         const vectorMultiplier = options.generationMode ? 3 : 6;
         const vectorQueryLimit = options.generationMode ? 1 : 3;
         for (const [queryIndex, rewritten] of rewrittenQueries.entries()) {
-            rankedLists.push({ source: 'keyword', items: this.keywordSearchItems(rewritten, limit * keywordMultiplier, options.filters), queryIndex });
+            rankedLists.push({ source: 'keyword', items: this.keywordSearchItems(rewritten, effectiveLimit * keywordMultiplier, options.filters), queryIndex });
             if (queryIndex < vectorQueryLimit) {
                 try {
-                    rankedLists.push({ source: 'vector', items: (await this.semanticSearch(rewritten, { ...options, limit: limit * vectorMultiplier })).results.slice(0, limit * keywordMultiplier), queryIndex });
+                    const vectorLimit = effectiveLimit * vectorMultiplier;
+                    const keywordLimit = effectiveLimit * keywordMultiplier;
+                    rankedLists.push({ source: 'vector', items: (await this.semanticSearch(rewritten, { ...options, limit: vectorLimit })).results.slice(0, keywordLimit), queryIndex });
                 }
                 catch { /* 向量搜索在混合搜索中是可选的 */ }
             }
@@ -381,12 +398,14 @@ export class KnowledgeBaseManager {
         const keywordItems = rankedLists.filter(list => list.source === 'keyword').flatMap(list => list.items);
         const vectorItems = rankedLists.filter(list => list.source === 'vector').flatMap(list => list.items);
         // 1. 先进行初筛合并，合并相同的子块并计算混合初始分（不获取大片段，保留子块自身用于精确打分）
-        const mergedChildChunks = this.mergeContexts(this.mergeHybridRankedLists(rankedLists, limit * 4, weights), limit * 4);
+        const mergeLimit = effectiveLimit * 4;
+        const mergedChildChunks = this.mergeContexts(this.mergeHybridRankedLists(rankedLists, mergeLimit, weights), mergeLimit);
         // 2. 对这些子块进行交叉编码器重排（Cross-Encoder Rerank）
         let reranked = mergedChildChunks;
         let rerankerName = 'local-heuristic-fallback';
         if (mergedChildChunks.length > 0) {
-            const candidates = mergedChildChunks.slice(0, Math.min(30, limit * 4));
+            const rerankLimit = requestedLimit ? Math.min(30, mergeLimit) : mergedChildChunks.length;
+            const candidates = mergedChildChunks.slice(0, rerankLimit);
             // 这里使用的是子块自身内容，通常在 500 tokens 左右，不仅相关性判断最准，而且不会超出 Reranker 的 max_length
             const textsToRerank = candidates.map(item => `${item.titlePath ?? item.sectionTitle ?? ''}\n${item.content}`);
             try {
@@ -409,8 +428,8 @@ export class KnowledgeBaseManager {
                 reranked = this.heuristicRerank(query, mergedChildChunks);
             }
         }
-        // 3. 拿到精确打分后的 Top 结果，此时再进行 expandContext 向上追溯到完整的父块大片段
-        const finalExpandedResults = this.mergeExpandedContexts(reranked.map(item => this.expandContext(item)), limit);
+        // 3. 拿到精确打分后的结果，此时再进行 expandContext 向上追溯到完整的父块大片段
+        const finalExpandedResults = this.mergeExpandedContexts(reranked.map(item => this.expandContext(item)), effectiveLimit);
         return {
             results: finalExpandedResults,
             scopesSearched: this.scope === 'global' ? ['global'] : ['project'],
@@ -433,7 +452,7 @@ export class KnowledgeBaseManager {
             const result = await search.search({
                 query,
                 queryEmbedding,
-                topK: options.limit ?? 10,
+                topK: this.resolveSearchLimit(options.limit, options.filters),
                 scope: this.scope,
                 projectId: this.projectId,
                 collections: options.collections,
@@ -451,17 +470,21 @@ export class KnowledgeBaseManager {
     listFiles() {
         return this.store.listRecords();
     }
-    getFileDetail(relativePath) {
+    getFileDetail(relativePath, options = {}) {
         const normalized = this.normalizeRelativePath(relativePath);
         const file = this.store.listRecords().find(record => record.relativePath === normalized);
         if (!file)
             return undefined;
         const absolutePath = this.resolveKbRelativePath(normalized);
+        const chunks = options.maxChunkContentChars
+            ? this.store.listChunksByContentBudget({ relativePath: normalized, maxContentChars: options.maxChunkContentChars })
+            : this.store.listChunks({ relativePath: normalized });
         return {
             file,
             absolutePath,
             directory: path.dirname(absolutePath),
-            chunks: this.store.listChunks({ relativePath: normalized, limit: 500 }),
+            chunks,
+            totalChunkCount: this.store.countChunks({ relativePath: normalized }),
             parents: this.store.listParentChunks(normalized),
             relationships: this.store.listRelationships(normalized),
             tags: this.store.listTags(normalized),

package/dist/core/multi-project-manager.js

@@ -59,7 +59,7 @@ export class MultiProjectManager {
         return this.registry.list();
     }
     async search(projectRoot, query, options = {}) {
-        const limit = options.limit ?? 10;
+        const limit = Number.isFinite(options.limit) && options.limit > 0 ? Math.ceil(options.limit) : undefined;
         const scope = options.scope ?? 'project';
         const project = await this.getProject(projectRoot);
         if (scope === 'project')
@@ -73,7 +73,8 @@ export class MultiProjectManager {
         }
         const global = await this.getGlobalKB();
         const globalResults = await global.hybridSearch(query, { limit, filters: options.filters, weights: options.weights, generationMode: options.generationMode });
-        const merged = new FederationSearch().merge([...projectResults.results, ...globalResults.results], limit, 'all');
+        const mergeLimit = limit ?? (projectResults.results.length + globalResults.results.length);
+        const merged = new FederationSearch().merge([...projectResults.results, ...globalResults.results], mergeLimit, 'all');
         return {
             ...merged,
             debug: this.mergeDebug(projectResults.debug, globalResults.debug),
@@ -94,7 +95,8 @@ export class MultiProjectManager {
         }
         const global = await this.getGlobalKB();
         const globalResults = await global.semanticSearch(query, options);
-        return new FederationSearch().merge([...projectResults.results, ...globalResults.results], options.limit ?? 10, 'all');
+        const mergeLimit = Number.isFinite(options.limit) && options.limit > 0 ? Math.ceil(options.limit) : projectResults.results.length + globalResults.results.length;
+        return new FederationSearch().merge([...projectResults.results, ...globalResults.results], mergeLimit, 'all');
     }
     async findCrossProjectDuplicates() {
         const projects = this.registry.list();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@customize-agent/knowledge",
-  "version": "4.0.33",
+  "version": "4.0.34",
   "description": "Local knowledge base infrastructure for customize-agent",
   "type": "module",
   "main": "./dist/index.js",