@customize-agent/knowledge 4.0.1 → 4.0.2

package/dist/embedding/embedding-provider.js

@@ -2,6 +2,7 @@ import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 export class HashEmbeddingProvider {
     dimensions;
     model = 'hash-embedding-local';
@@ -79,6 +80,114 @@ export class OpenAICompatibleEmbeddingProvider {
         return (payload.data ?? []).map(item => item.embedding ?? []);
     }
 }
+function resolveBundledBgeModelPath() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        process.env.CUSTOMIZE_BGE_MODEL_PATH,
+        process.env.KB_BGE_MODEL_PATH,
+        path.resolve(process.cwd(), 'models', 'bge-small-zh-v1.5'),
+        path.resolve(process.cwd(), 'packages', 'knowledge', 'models', 'bge-small-zh-v1.5'),
+        path.resolve(currentDir, '..', '..', 'models', 'bge-small-zh-v1.5'),
+    ].filter(Boolean);
+    return candidates.find(candidate => fs.existsSync(path.join(candidate, 'config.json')) && fs.existsSync(path.join(candidate, 'tokenizer.json')));
+}
+export class LocalTransformersEmbeddingProvider {
+    model;
+    dimensions;
+    modelPath;
+    static pipelines = new Map();
+    constructor(options = {}) {
+        this.model = options.model?.trim() || 'BAAI/bge-small-zh-v1.5';
+        this.dimensions = options.dimensions ?? 512;
+        this.modelPath = options.modelPath || resolveBundledBgeModelPath();
+    }
+    async embedDocuments(texts) {
+        return this.embed(texts);
+    }
+    async embedQuery(text) {
+        return (await this.embed([text]))[0] ?? [];
+    }
+    async embed(input) {
+        const extractor = await this.getPipeline();
+        const output = await extractor(input, { pooling: 'mean', normalize: true });
+        const vectors = this.parseVectors(output, input.length);
+        return vectors.map(vector => this.resizeVector(vector));
+    }
+    getPipeline() {
+        const existing = LocalTransformersEmbeddingProvider.pipelines.get(this.model);
+        if (existing)
+            return existing;
+        const created = this.createPipeline();
+        LocalTransformersEmbeddingProvider.pipelines.set(this.model, created);
+        return created;
+    }
+    async createPipeline() {
+        const modelPath = this.modelPath;
+        if (!modelPath) {
+            throw new Error('本地 bge-small-zh-v1.5 模型资源缺失：请将模型文件放到 packages/knowledge/models/bge-small-zh-v1.5，或通过 CUSTOMIZE_BGE_MODEL_PATH 指定本地模型目录。');
+        }
+        const dynamicImport = new Function('specifier', 'return import(specifier)');
+        const mod = await dynamicImport('@huggingface/transformers').catch(error => {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`本地语义模型运行依赖 @huggingface/transformers 未安装或无法解析：${message}`);
+        });
+        if (!mod.pipeline)
+            throw new Error('Transformers.js pipeline is unavailable');
+        if (mod.env) {
+            mod.env.allowRemoteModels = false;
+            mod.env.allowLocalModels = true;
+            mod.env.localModelPath = path.dirname(modelPath);
+        }
+        return mod.pipeline('feature-extraction', modelPath, { dtype: 'q8' });
+    }
+    parseVectors(output, count) {
+        if (this.isTensorLike(output)) {
+            const dims = output.dims;
+            const data = Array.from(output.data, Number);
+            if (dims.length === 2)
+                return this.splitFlatVectors(data, dims[0] ?? count, dims[1] ?? this.dimensions);
+            if (dims.length === 3) {
+                const batch = dims[0] ?? count;
+                const tokens = dims[1] ?? 1;
+                const width = dims[2] ?? this.dimensions;
+                return Array.from({ length: batch }, (_, batchIndex) => {
+                    const vector = Array.from({ length: width }, () => 0);
+                    for (let tokenIndex = 0; tokenIndex < tokens; tokenIndex++) {
+                        const offset = batchIndex * tokens * width + tokenIndex * width;
+                        for (let i = 0; i < width; i++)
+                            vector[i] = (vector[i] ?? 0) + (data[offset + i] ?? 0);
+                    }
+                    return this.normalize(vector.map(value => value / Math.max(1, tokens)));
+                });
+            }
+        }
+        if (Array.isArray(output)) {
+            const first = output[0];
+            if (Array.isArray(first) && typeof first[0] === 'number')
+                return output;
+            if (typeof first === 'number')
+                return [output];
+        }
+        throw new Error('Unsupported Transformers embedding output');
+    }
+    isTensorLike(value) {
+        return typeof value === 'object' && value !== null && 'data' in value && 'dims' in value && Array.isArray(value.dims);
+    }
+    splitFlatVectors(data, count, width) {
+        return Array.from({ length: count }, (_, index) => this.normalize(data.slice(index * width, (index + 1) * width)));
+    }
+    resizeVector(vector) {
+        if (vector.length === this.dimensions)
+            return vector;
+        if (vector.length > this.dimensions)
+            return this.normalize(vector.slice(0, this.dimensions));
+        return this.normalize([...vector, ...Array.from({ length: this.dimensions - vector.length }, () => 0)]);
+    }
+    normalize(vector) {
+        const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+        return norm > 0 ? vector.map(value => value / norm) : vector;
+    }
+}
 function readStoredEmbeddingConfig() {
     try {
         const configPath = path.join(os.homedir(), '.customize-agent', 'config.json');
@@ -93,7 +202,7 @@ function readStoredEmbeddingConfig() {
 }
 export function createEmbeddingProviderFromEnvironment() {
     const stored = readStoredEmbeddingConfig();
-    const provider = process.env.CUSTOMIZE_EMBEDDING_PROVIDER ?? process.env.KB_EMBEDDING_PROVIDER ?? stored?.provider;
+    const provider = process.env.CUSTOMIZE_EMBEDDING_PROVIDER ?? process.env.KB_EMBEDDING_PROVIDER ?? stored?.provider ?? 'transformers-local';
     if (provider === 'openai-compatible') {
         const baseUrl = process.env.CUSTOMIZE_EMBEDDING_BASE_URL ?? process.env.KB_EMBEDDING_BASE_URL ?? stored?.baseUrl;
         const model = process.env.CUSTOMIZE_EMBEDDING_MODEL ?? process.env.KB_EMBEDDING_MODEL ?? stored?.model;
@@ -108,5 +217,10 @@ export function createEmbeddingProviderFromEnvironment() {
             });
         }
     }
-    return new HashEmbeddingProvider();
+    const rawDimensions = process.env.CUSTOMIZE_EMBEDDING_DIMENSIONS ?? process.env.KB_EMBEDDING_DIMENSIONS;
+    const dimensions = Number(rawDimensions ?? (stored?.provider === 'transformers-local' ? stored.dimensions : undefined) ?? 512);
+    return new LocalTransformersEmbeddingProvider({
+        model: process.env.CUSTOMIZE_EMBEDDING_MODEL ?? process.env.KB_EMBEDDING_MODEL ?? (stored?.provider === 'transformers-local' ? stored.model : undefined) ?? 'BAAI/bge-small-zh-v1.5',
+        dimensions: Number.isFinite(dimensions) ? dimensions : 512,
+    });
 }

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

@@ -17,6 +17,10 @@ export declare class ContentExtractor {
     private textScore;
     private extractCad;
     private extractDxf;
+    private buildCadSemanticNodes;
+    private extractDxfTextAnnotations;
+    private findNearestCadAnnotation;
+    private inferCadEntityType;
     private tryConvertDwgWithBundledWasm;
     private tryConvertDwgToDxf;
     private extractCadMesh;
@@ -25,26 +29,50 @@ export declare class ContentExtractor {
     private extractBinaryStrings;
     private extractData;
     private extractDiagram;
+    private extractDrawioGraph;
+    private extractExcalidrawGraph;
+    private isPointInside;
+    private parseXmlAttributes;
     private parseDelimitedLine;
+    private toMarkdownTable;
     private extractDelimitedText;
     private extractOfficeDocument;
     private extractRtf;
     private extractLegacyWordDocument;
     private extractLegacyOfficeBinary;
+    private findMergedCellValue;
     private extractSpreadsheet;
+    private extractDocxStyleTreeMarkdown;
+    private docxHeadingLevel;
     private extractOfficeZip;
-    private extractArchive;
     private extractRasterImage;
+    private tryPaddleOcrLayout;
+    private parseOcrJson;
+    private formatOcrRegions;
+    private classifyOcrRegion;
+    private formatBoundingBox;
     private validateRasterImage;
     private extractPdf;
-    private pdfOcrPageLimit;
     private extractScannedPdfOcr;
     private extractPdfText;
+    private toPdfTextItem;
+    private layoutPdfTextItems;
+    private groupPdfItemsIntoRows;
+    private detectPdfColumnSplit;
+    private rowsToPdfMarkdownWithTables;
+    private splitLikelyTableRow;
+    private pdfRowToMarkdown;
+    private toMarkdownDocument;
+    private normalizeMarkdownHeadings;
     private extractSvg;
+    private extractSvgSemanticNodes;
     private isTextReadable;
     private looksTextFile;
     private matchAll;
     private stripXml;
     private flattenJson;
+    private atomicJsonObjects;
+    private flattenYamlByIndent;
+    private flattenXmlPaths;
     private metadataOnlyText;
 }