@customize-agent/knowledge 3.0.10 → 3.0.12

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

@@ -494,7 +494,13 @@ export class IndexStateStore {
       );
     `);
         this.initFts();
-        this.setMetadata('schema_version', '2');
+        try {
+            if (this.getMetadata('schema_version') !== '2')
+                this.setMetadata('schema_version', '2');
+        }
+        catch {
+            // 受限环境中已有索引库可能以只读方式挂载；运行时元数据不是必需项。
+        }
     }
     initFts() {
         try {

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

@@ -32,7 +32,7 @@ export class KnowledgeBaseManager {
     relationshipDetector = new RelationshipDetector();
     embeddingProvider;
     vectorStores;
-    configManager = new ProjectConfigManager();
+    configManager;
     projectConfig;
     lastSkippedFiles = [];
     llmProvider;
@@ -47,6 +47,7 @@ export class KnowledgeBaseManager {
         this.llmProvider = options.llmProvider;
         this.onProgress = options.onProgress;
         const storageRoot = options.storageRoot ?? path.join(os.homedir(), USER_DATA_DIR);
+        this.configManager = new ProjectConfigManager(storageRoot);
         let dbPath;
         if (this.scope === 'global') {
             this.kbPath = options.kbPath ?? path.join(storageRoot, GLOBAL_KNOWLEDGE_DIR);
@@ -366,18 +367,26 @@ export class KnowledgeBaseManager {
         return this.incrementalIndex();
     }
     getUploadRelativePath(fileName, targetRelativePath) {
-        return targetRelativePath ?? this.defaultUploadRelativePath(fileName);
+        return targetRelativePath ? this.normalizeRelativePath(targetRelativePath) : this.defaultUploadRelativePath(fileName);
     }
     async uploadFile(fileName, content, targetRelativePath, onProgress, options = {}) {
         return this.uploadFiles([{ fileName, content, targetRelativePath }], onProgress, options);
     }
     async uploadFiles(files, onProgress, options = {}) {
         this.initialize();
+        const uploadedPaths = [];
         for (const file of files) {
             const relativePath = this.getUploadRelativePath(file.fileName, file.targetRelativePath);
             const targetPath = this.resolveKbRelativePath(relativePath);
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
             fs.writeFileSync(targetPath, file.content);
+            uploadedPaths.push(relativePath);
+        }
+        for (const relativePath of uploadedPaths) {
+            const record = this.store.listRecords().find(item => item.relativePath === relativePath);
+            if (record)
+                await this.deleteVectorFile(record.collectionName, relativePath);
+            this.store.deleteRecord(relativePath);
         }
         return this.incrementalIndex({ onProgress, vectorMode: options.vectorMode });
     }

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

@@ -10,13 +10,14 @@ export class MultiProjectManager {
     storageRoot;
     llmProvider;
     registry;
-    configManager = new ProjectConfigManager();
+    configManager;
     projects = new Map();
     globalKB;
     constructor(storageRoot = path.join(os.homedir(), USER_DATA_DIR), llmProvider) {
         this.storageRoot = storageRoot;
         this.llmProvider = llmProvider;
         this.registry = new ProjectRegistry(path.join(storageRoot, 'projects', 'registry.db'));
+        this.configManager = new ProjectConfigManager(storageRoot);
     }
     async getProject(projectRoot) {
         const resolvedRoot = path.resolve(projectRoot);

package/dist/core/project-config.d.ts

@@ -1,8 +1,10 @@
 import type { ProjectConfig } from '../types.js';
-export declare function getProjectConfigPath(projectRoot: string): string;
+export declare function getProjectConfigPath(projectRoot: string, storageRoot?: string): string;
 export declare function getProjectKbPath(projectRoot: string): string;
 export declare function ensureProjectCustomizeFile(projectRoot: string): void;
 export declare class ProjectConfigManager {
+    private readonly storageRoot;
+    constructor(storageRoot?: string);
     loadOrCreate(projectRoot: string): ProjectConfig;
     save(projectRoot: string, config: ProjectConfig): void;
     private withDefaults;

package/dist/core/project-config.js

@@ -1,11 +1,11 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { DEFAULT_CATEGORY_DIRS, KNOWLEDGE_BASE_DIR, PROJECT_CONFIG_PATH, USER_DATA_DIR } from '../constants.js';
+import { DEFAULT_CATEGORY_DIRS, KNOWLEDGE_BASE_DIR, USER_DATA_DIR } from '../constants.js';
 import { computeProjectId } from './project-id.js';
-export function getProjectConfigPath(projectRoot) {
+export function getProjectConfigPath(projectRoot, storageRoot = path.join(os.homedir(), USER_DATA_DIR)) {
     const projectId = computeProjectId(projectRoot);
-    return path.join(os.homedir(), USER_DATA_DIR, 'projects', projectId, ...PROJECT_CONFIG_PATH.slice(1));
+    return path.join(storageRoot, 'projects', projectId, 'project.json');
 }
 export function getProjectKbPath(projectRoot) {
     return path.join(projectRoot, KNOWLEDGE_BASE_DIR);
@@ -35,22 +35,24 @@ export function ensureProjectCustomizeFile(projectRoot) {
     }
 }
 export class ProjectConfigManager {
+    storageRoot;
+    constructor(storageRoot = path.join(os.homedir(), USER_DATA_DIR)) {
+        this.storageRoot = storageRoot;
+    }
     loadOrCreate(projectRoot) {
         ensureProjectCustomizeFile(projectRoot);
-        const configPath = getProjectConfigPath(projectRoot);
+        const configPath = getProjectConfigPath(projectRoot, this.storageRoot);
         const now = Date.now();
         if (fs.existsSync(configPath)) {
             const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-            const config = this.withDefaults(projectRoot, raw, now);
-            this.save(projectRoot, { ...config, lastOpenedAt: now });
-            return { ...config, lastOpenedAt: now };
+            return this.withDefaults(projectRoot, raw, now);
         }
         const config = this.withDefaults(projectRoot, {}, now);
         this.save(projectRoot, config);
         return config;
     }
     save(projectRoot, config) {
-        const configPath = getProjectConfigPath(projectRoot);
+        const configPath = getProjectConfigPath(projectRoot, this.storageRoot);
         fs.mkdirSync(path.dirname(configPath), { recursive: true });
         fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
     }

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

@@ -17,6 +17,7 @@ export declare class ContentExtractor {
     private textScore;
     private extractCad;
     private extractDxf;
+    private tryConvertDwgWithBundledWasm;
     private tryConvertDwgToDxf;
     private extractCadMesh;
     private getTempRoot;

package/dist/extraction/content-extractor.js

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { tmpdir } from 'node:os';
+import { pathToFileURL } from 'node:url';
 import { ExternalExtractorRegistry } from './external-extractor.js';
 import { resolveAndImport, resolvePackage, getNodeModulesRoot } from './module-resolver.js';
 export class ContentExtractor {
@@ -333,10 +334,31 @@ export class ContentExtractor {
             warnings,
         };
     }
+    async tryConvertDwgWithBundledWasm(filePath) {
+        try {
+            const mod = await resolveAndImport('dwgdxf');
+            if (!mod.convertDwgToDxf)
+                return { tool: 'dwgdxf_wasm', warnings: ['内置 dwgdxf WASM 转换器未导出 convertDwgToDxf'] };
+            const wasmBase = pathToFileURL(path.join(path.dirname(resolvePackage('dwgdxf')), 'wasm')).href;
+            const dxfBytes = await mod.convertDwgToDxf(fs.readFileSync(filePath), { wasmBase });
+            const dxfText = Buffer.from(dxfBytes).toString('utf8');
+            return dxfText.trim()
+                ? { dxfText, tool: 'dwgdxf_wasm', warnings: [] }
+                : { tool: 'dwgdxf_wasm', warnings: ['内置 dwgdxf WASM 转换器未输出 DXF 文本'] };
+        }
+        catch (error) {
+            return { tool: 'dwgdxf_wasm', warnings: [`内置 dwgdxf WASM 转换失败: ${error instanceof Error ? error.message : String(error)}`] };
+        }
+    }
     async tryConvertDwgToDxf(filePath) {
         const tmpDir = fs.mkdtempSync(path.join(this.getTempRoot(), 'customize-dwg-'));
         const outputPath = path.join(tmpDir, `${path.basename(filePath, path.extname(filePath))}.dxf`);
         try {
+            const failures = [];
+            const bundled = await this.tryConvertDwgWithBundledWasm(filePath);
+            if (bundled.dxfText)
+                return bundled;
+            failures.push(...bundled.warnings);
             const customCmd = process.env.CUSTOMIZE_DWG_TO_DXF_CMD;
             if (customCmd) {
                 if (/\s/u.test(customCmd))
@@ -357,7 +379,6 @@ export class ContentExtractor {
                     return { dxfText: fs.readFileSync(outputPath, 'utf8'), tool: 'external_dwg_to_dxf', warnings: [] };
                 return { tool: 'external_dwg_to_dxf', warnings: [`CUSTOMIZE_DWG_TO_DXF_CMD 转换失败: ${result.stderr || result.stdout || result.error?.message || 'unknown error'}`] };
             }
-            const failures = [];
             for (const bin of ['dwgread', 'dwg2dxf']) {
                 const result = spawnSync(bin, bin === 'dwgread' ? ['-O', 'DXF', '-o', outputPath, filePath] : [filePath, outputPath], { encoding: 'utf8', timeout: 120_000 });
                 if (result.status === 0 && fs.existsSync(outputPath))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@customize-agent/knowledge",
-  "version": "3.0.10",
+  "version": "3.0.12",
   "description": "Local knowledge base infrastructure for customize-agent",
   "type": "module",
   "main": "./dist/index.js",
@@ -37,6 +37,7 @@
   "dependencies": {
     "@napi-rs/canvas": "^0.1.82",
     "better-sqlite3": "^12.10.0",
+    "dwgdxf": "^2.0.1",
     "dxf-parser": "^1.1.2",
     "fast-glob": "^3.3.3",
     "jszip": "^3.10.1",