@sanqianx/project-knowledge 5.0.19 → 5.0.20-rc.1

package/_site/_test/integration-status-scan-test.js

@@ -1,29 +1,29 @@
-'use strict';
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const { IntegrationStatusScan } = require('../lib/integration-status-scan');
-async function main() {
-  const scan = new IntegrationStatusScan({ workerFile: path.join(__dirname, 'fixtures/integration-busy-worker.cjs'), timeoutMs: 5000 });
-  try {
-    const before = Date.now();
-    const first = await scan.read({ rootDir: path.resolve(__dirname, '../..') }, { clients: ['claude'] }, { waitMs: 50 });
-    assert.equal(first.scan.state, 'checking'); assert.ok(Date.now() - before < 500);
-    const again = await scan.read({ rootDir: path.resolve(__dirname, '../..') }, { clients: ['claude'] }, { waitMs: 10 });
-    assert.equal(first.scan.generation, again.scan.generation); assert.equal(scan.children.size, 1);
-    let ticked = false; await new Promise(resolve => setTimeout(() => { ticked = true; resolve(); }, 20));
-    assert.equal(ticked, true, 'a blocked probe cannot freeze the HTTP event loop');
-    await new Promise(resolve => setTimeout(resolve, 1500));
-    const ready = await scan.read({ rootDir: path.resolve(__dirname, '../..') }, { clients: ['claude'] });
-    assert.equal(ready.scan.state, 'ready'); assert.equal(ready.clients[0].available, true);
-    console.log('Isolated status scan, coalescing and nonblocking snapshot passed.');
-  } finally { scan.close(); }
-  const logs = [], timed = new IntegrationStatusScan({ workerFile: path.join(__dirname, 'fixtures/integration-busy-worker.cjs'), timeoutMs: 100 });
-  try {
-    const result = await timed.read({ rootDir: path.resolve(__dirname, '../..'), operationId: 'status-timeout-test', logger: { warn: (...args) => logs.push(args) } }, { clients: ['claude'] }, { waitMs: 500 });
-    assert.equal(result.error.code, 'INTEGRATION_STATUS_TIMEOUT');
-    assert.equal(result.clients[0].automaticContext.state, 'check-failed');
-    assert.equal(logs[0][0], 'integration.status.timeout');
-    assert.equal(logs[0][2].operationId, 'status-timeout-test');
-  } finally { timed.close(); }
-}
-main().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { IntegrationStatusScan } = require('../lib/integration-status-scan');
+async function main() {
+  const scan = new IntegrationStatusScan({ workerFile: path.join(__dirname, 'fixtures/integration-busy-worker.cjs'), timeoutMs: 5000 });
+  try {
+    const before = Date.now();
+    const first = await scan.read({ rootDir: path.resolve(__dirname, '../..') }, { clients: ['claude'] }, { waitMs: 50 });
+    assert.equal(first.scan.state, 'checking'); assert.ok(Date.now() - before < 500);
+    const again = await scan.read({ rootDir: path.resolve(__dirname, '../..') }, { clients: ['claude'] }, { waitMs: 10 });
+    assert.equal(first.scan.generation, again.scan.generation); assert.equal(scan.children.size, 1);
+    let ticked = false; await new Promise(resolve => setTimeout(() => { ticked = true; resolve(); }, 20));
+    assert.equal(ticked, true, 'a blocked probe cannot freeze the HTTP event loop');
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    const ready = await scan.read({ rootDir: path.resolve(__dirname, '../..') }, { clients: ['claude'] });
+    assert.equal(ready.scan.state, 'ready'); assert.equal(ready.clients[0].available, true);
+    console.log('Isolated status scan, coalescing and nonblocking snapshot passed.');
+  } finally { scan.close(); }
+  const logs = [], timed = new IntegrationStatusScan({ workerFile: path.join(__dirname, 'fixtures/integration-busy-worker.cjs'), timeoutMs: 100 });
+  try {
+    const result = await timed.read({ rootDir: path.resolve(__dirname, '../..'), operationId: 'status-timeout-test', logger: { warn: (...args) => logs.push(args) } }, { clients: ['claude'] }, { waitMs: 500 });
+    assert.equal(result.error.code, 'INTEGRATION_STATUS_TIMEOUT');
+    assert.equal(result.clients[0].automaticContext.state, 'check-failed');
+    assert.equal(logs[0][0], 'integration.status.timeout');
+    assert.equal(logs[0][2].operationId, 'status-timeout-test');
+  } finally { timed.close(); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/kb-framework-test.js

@@ -1,57 +1,57 @@
-// Run: node _site/_test/kb-framework-test.js
-
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-framework-${process.pid}-`));
-process.env.KB_DATA_DIR = path.join(temp, 'data');
-process.env.KB_SKIP_MIGRATION = '1';
-require('../lib/data-dir')._resetCache();
-const framework = require('../lib/kb-framework');
-
-(() => {
-  try {
-    const fresh = path.join(temp, 'knowledge', 'fresh');
-    const initialized = framework.initProjectDirs('fresh-project', fresh);
-    assert.strictEqual(initialized.lazy, true);
-    assert.deepStrictEqual(initialized.created, []);
-    assert.deepStrictEqual(fs.readdirSync(fresh), [], 'fresh import must not create guessed/TODO Markdown or empty collection indexes');
-    const second = framework.initProjectDirs('fresh-project', fresh);
-    assert.deepStrictEqual(second.created, [], 'lazy directory declaration should be idempotent');
-    assert.strictEqual(fs.existsSync(path.join(process.env.KB_DATA_DIR, '_ai', 'fresh-project')), false, 'unused AI workspace must not be created');
-
-    const legacy = path.join(temp, 'knowledge', 'legacy');
-    fs.mkdirSync(path.join(legacy, '_ai', 'runs'), { recursive: true });
-    fs.mkdirSync(path.join(legacy, 'commits'), { recursive: true });
-    fs.mkdirSync(path.join(legacy, 'features'), { recursive: true });
-    fs.writeFileSync(path.join(legacy, 'README.md'), '# Legacy Project\n\nVerified legacy overview.\n', 'utf8');
-    fs.writeFileSync(path.join(legacy, 'project-goal.md'), '# Legacy Goal\n\nA verified migrated goal.\n', 'utf8');
-    fs.writeFileSync(path.join(legacy, 'project-analysis.md'), '# Legacy Analysis\n\nA verified architecture fact.\n', 'utf8');
-    fs.writeFileSync(path.join(legacy, 'commits', 'old.md'), '# Old Commit\n\nVerified old change.\n', 'utf8');
-    fs.writeFileSync(path.join(legacy, '_ai', 'runs', 'old.json'), '{"runId":"old"}\n', 'utf8');
-    const migrated = framework.migrateToFramework({ slug: 'legacy-project', kbPath: legacy });
-    assert.strictEqual(migrated.ok, true);
-    assert(fs.existsSync(path.join(legacy, 'GOAL.md')));
-    assert(fs.existsSync(path.join(legacy, 'ARCHITECTURE.md')));
-    assert(fs.existsSync(path.join(legacy, 'changes', 'legacy-change-01.md')));
-    assert(fs.existsSync(path.join(legacy, 'changes', '00-index.md')));
-    assert(fs.existsSync(path.join(legacy, 'modules', '00-index.md')));
-    assert.strictEqual(fs.existsSync(path.join(legacy, '_ai')), false, 'internal AI data must be removed from user knowledge root after migration');
-    assert(fs.existsSync(path.join(process.env.KB_DATA_DIR, '_ai', 'legacy-project', 'runs', 'old.json')), 'legacy AI run should be preserved internally');
-    const allMarkdown = [];
-    const walk = current => {
-      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-        const target = path.join(current, entry.name);
-        if (entry.isDirectory()) walk(target);
-        else if (entry.name.endsWith('.md')) allMarkdown.push(fs.readFileSync(target, 'utf8'));
-      }
-    };
-    walk(legacy);
-    assert(!allMarkdown.some(text => /TODO: confirm|TODO: summarize/.test(text)), 'migration must not introduce TODO facts');
-    console.log('kb-framework-test PASS');
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-})();
+// Run: node _site/_test/kb-framework-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-framework-${process.pid}-`));
+process.env.KB_DATA_DIR = path.join(temp, 'data');
+process.env.KB_SKIP_MIGRATION = '1';
+require('../lib/data-dir')._resetCache();
+const framework = require('../lib/kb-framework');
+
+(() => {
+  try {
+    const fresh = path.join(temp, 'knowledge', 'fresh');
+    const initialized = framework.initProjectDirs('fresh-project', fresh);
+    assert.strictEqual(initialized.lazy, true);
+    assert.deepStrictEqual(initialized.created, []);
+    assert.deepStrictEqual(fs.readdirSync(fresh), [], 'fresh import must not create guessed/TODO Markdown or empty collection indexes');
+    const second = framework.initProjectDirs('fresh-project', fresh);
+    assert.deepStrictEqual(second.created, [], 'lazy directory declaration should be idempotent');
+    assert.strictEqual(fs.existsSync(path.join(process.env.KB_DATA_DIR, '_ai', 'fresh-project')), false, 'unused AI workspace must not be created');
+
+    const legacy = path.join(temp, 'knowledge', 'legacy');
+    fs.mkdirSync(path.join(legacy, '_ai', 'runs'), { recursive: true });
+    fs.mkdirSync(path.join(legacy, 'commits'), { recursive: true });
+    fs.mkdirSync(path.join(legacy, 'features'), { recursive: true });
+    fs.writeFileSync(path.join(legacy, 'README.md'), '# Legacy Project\n\nVerified legacy overview.\n', 'utf8');
+    fs.writeFileSync(path.join(legacy, 'project-goal.md'), '# Legacy Goal\n\nA verified migrated goal.\n', 'utf8');
+    fs.writeFileSync(path.join(legacy, 'project-analysis.md'), '# Legacy Analysis\n\nA verified architecture fact.\n', 'utf8');
+    fs.writeFileSync(path.join(legacy, 'commits', 'old.md'), '# Old Commit\n\nVerified old change.\n', 'utf8');
+    fs.writeFileSync(path.join(legacy, '_ai', 'runs', 'old.json'), '{"runId":"old"}\n', 'utf8');
+    const migrated = framework.migrateToFramework({ slug: 'legacy-project', kbPath: legacy });
+    assert.strictEqual(migrated.ok, true);
+    assert(fs.existsSync(path.join(legacy, 'GOAL.md')));
+    assert(fs.existsSync(path.join(legacy, 'ARCHITECTURE.md')));
+    assert(fs.existsSync(path.join(legacy, 'changes', 'legacy-change-01.md')));
+    assert(fs.existsSync(path.join(legacy, 'changes', '00-index.md')));
+    assert(fs.existsSync(path.join(legacy, 'modules', '00-index.md')));
+    assert.strictEqual(fs.existsSync(path.join(legacy, '_ai')), false, 'internal AI data must be removed from user knowledge root after migration');
+    assert(fs.existsSync(path.join(process.env.KB_DATA_DIR, '_ai', 'legacy-project', 'runs', 'old.json')), 'legacy AI run should be preserved internally');
+    const allMarkdown = [];
+    const walk = current => {
+      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+        const target = path.join(current, entry.name);
+        if (entry.isDirectory()) walk(target);
+        else if (entry.name.endsWith('.md')) allMarkdown.push(fs.readFileSync(target, 'utf8'));
+      }
+    };
+    walk(legacy);
+    assert(!allMarkdown.some(text => /TODO: confirm|TODO: summarize/.test(text)), 'migration must not introduce TODO facts');
+    console.log('kb-framework-test PASS');
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+})();

package/_site/_test/kbpath-follow-test.js

@@ -1,63 +1,63 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { StorageLayout } = require('../lib/storage-layout');
-const { SettingsStore } = require('../lib/settings-store');
-const { ProjectRegistryStore } = require('../lib/project-registry-store');
-const { ProjectStore } = require('../lib/project-store');
-
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-kbpath-v2-'));
-const projectId = 'project-kbpath-follow';
-const oldKnowledgePath = path.join(dataDir, 'knowledge-old');
-const newKnowledgePath = path.join(dataDir, 'knowledge-new');
-process.env.KB_DATA_DIR = dataDir;
-require('../lib/data-dir')._resetCache();
-
-(async () => {
-  try {
-    fs.mkdirSync(oldKnowledgePath, { recursive: true });
-    fs.mkdirSync(newKnowledgePath, { recursive: true });
-    const layout = new StorageLayout({ dataDir });
-    const settingsStore = new SettingsStore({ layout });
-    const registryStore = new ProjectRegistryStore({ layout });
-    const projectStore = new ProjectStore({ layout });
-    await settingsStore.initialize({ knowledge: { rootPath: path.join(dataDir, 'future') } });
-    await registryStore.initialize();
-    await projectStore.create(projectId, { displayName: 'KB path follow', storageName: 'kbpath', repoPath: dataDir, knowledgePath: oldKnowledgePath });
-    await registryStore.add(projectId, { displayNameSnapshot: 'KB path follow' });
-
-    const runner = require('../lib/claude-cli-runner');
-    const started = runner.startChatSession({
-      slug: projectId,
-      projectPath: dataDir,
-      kbPath: oldKnowledgePath,
-      aiProfile: { id: 'test', implementation: 'claude-code-agent', model: 'test-model' },
-    });
-    const recordPath = layout.getRuntimePath('claude-sessions', projectId, `${started.sessionId}.json`);
-    const persisted = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
-    persisted.claudeSessionId = 'stale-conversation-id';
-    persisted.events.push({ type: 'claude/user-prompt', text: 'old conversation' });
-    fs.writeFileSync(recordPath, `${JSON.stringify(persisted, null, 2)}\n`, 'utf8');
-
-    await projectStore.updateConfig(projectId, { knowledgePath: newKnowledgePath }, { allowKnowledgePath: true });
-    delete require.cache[require.resolve('../lib/claude-cli-runner')];
-    const restoredRunner = require('../lib/claude-cli-runner');
-    const events = [];
-    restoredRunner.subscribe(started.sessionId, event => events.push(event));
-    const restored = restoredRunner.getSession(started.sessionId);
-    assert.strictEqual(restored.kbPath, newKnowledgePath);
-    assert.strictEqual(restored.claudeSessionId, null);
-    assert.strictEqual(restored.historyCleared, true);
-    assert.strictEqual(restored.turns, 0);
-    assert(events.some(event => event.type === 'claude/kbpath-updated' && event.fromKbPath === oldKnowledgePath && event.toKbPath === newKnowledgePath));
-    assert(!restored.outputBuffer.some(event => event.type === 'claude/user-prompt'), 'stale conversation events must be cleared');
-
-    const persistedAfter = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
-    assert.strictEqual(persistedAfter.kbPath, newKnowledgePath);
-    assert.strictEqual(persistedAfter.claudeSessionId, null);
-    console.log('kbpath-follow-test PASS');
-  } finally {
-    fs.rmSync(dataDir, { recursive: true, force: true });
-  }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { SettingsStore } = require('../lib/settings-store');
+const { ProjectRegistryStore } = require('../lib/project-registry-store');
+const { ProjectStore } = require('../lib/project-store');
+
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-kbpath-v2-'));
+const projectId = 'project-kbpath-follow';
+const oldKnowledgePath = path.join(dataDir, 'knowledge-old');
+const newKnowledgePath = path.join(dataDir, 'knowledge-new');
+process.env.KB_DATA_DIR = dataDir;
+require('../lib/data-dir')._resetCache();
+
+(async () => {
+  try {
+    fs.mkdirSync(oldKnowledgePath, { recursive: true });
+    fs.mkdirSync(newKnowledgePath, { recursive: true });
+    const layout = new StorageLayout({ dataDir });
+    const settingsStore = new SettingsStore({ layout });
+    const registryStore = new ProjectRegistryStore({ layout });
+    const projectStore = new ProjectStore({ layout });
+    await settingsStore.initialize({ knowledge: { rootPath: path.join(dataDir, 'future') } });
+    await registryStore.initialize();
+    await projectStore.create(projectId, { displayName: 'KB path follow', storageName: 'kbpath', repoPath: dataDir, knowledgePath: oldKnowledgePath });
+    await registryStore.add(projectId, { displayNameSnapshot: 'KB path follow' });
+
+    const runner = require('../lib/claude-cli-runner');
+    const started = runner.startChatSession({
+      slug: projectId,
+      projectPath: dataDir,
+      kbPath: oldKnowledgePath,
+      aiProfile: { id: 'test', implementation: 'claude-code-agent', model: 'test-model' },
+    });
+    const recordPath = layout.getRuntimePath('claude-sessions', projectId, `${started.sessionId}.json`);
+    const persisted = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
+    persisted.claudeSessionId = 'stale-conversation-id';
+    persisted.events.push({ type: 'claude/user-prompt', text: 'old conversation' });
+    fs.writeFileSync(recordPath, `${JSON.stringify(persisted, null, 2)}\n`, 'utf8');
+
+    await projectStore.updateConfig(projectId, { knowledgePath: newKnowledgePath }, { allowKnowledgePath: true });
+    delete require.cache[require.resolve('../lib/claude-cli-runner')];
+    const restoredRunner = require('../lib/claude-cli-runner');
+    const events = [];
+    restoredRunner.subscribe(started.sessionId, event => events.push(event));
+    const restored = restoredRunner.getSession(started.sessionId);
+    assert.strictEqual(restored.kbPath, newKnowledgePath);
+    assert.strictEqual(restored.claudeSessionId, null);
+    assert.strictEqual(restored.historyCleared, true);
+    assert.strictEqual(restored.turns, 0);
+    assert(events.some(event => event.type === 'claude/kbpath-updated' && event.fromKbPath === oldKnowledgePath && event.toKbPath === newKnowledgePath));
+    assert(!restored.outputBuffer.some(event => event.type === 'claude/user-prompt'), 'stale conversation events must be cleared');
+
+    const persistedAfter = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
+    assert.strictEqual(persistedAfter.kbPath, newKnowledgePath);
+    assert.strictEqual(persistedAfter.claudeSessionId, null);
+    console.log('kbpath-follow-test PASS');
+  } finally {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/knowledge-db-test.js

@@ -1,144 +1,144 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { KnowledgeDatabase, sqlString, inPredicate } = require('../lib/knowledge-db');
-const { LocalEmbeddingService, QUERY_PREFIX } = require('../lib/embedding-service');
-const { EMBEDDING_DIMENSIONS, sha256 } = require('../lib/knowledge-schema');
-const { MarkdownKnowledgeIndexer, chunkMarkdown } = require('../lib/markdown-knowledge-indexer');
-
-function vectorAt(index) {
-  const vector = new Array(EMBEDDING_DIMENSIONS).fill(0);
-  vector[index] = 1;
-  return vector;
-}
-
-(async () => {
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-db-test-'));
-  const db = new KnowledgeDatabase({ dbPath: path.join(temp, 'knowledge.lancedb') });
-  try {
-    assert.equal(sqlString("space'o"), "'space''o'");
-    assert.equal(inPredicate('space_id', ['a', 'a', 'b']), "space_id IN ('a', 'b')");
-    assert.throws(() => inPredicate('space_id', []), /must not be empty/);
-
-    const created = await db.replaceEntry('personal:alpha', 'modules/auth.md', [
-      {
-        chunkOrder: 0,
-        title: '登录设计',
-        chunkText: '系统使用短期访问令牌和可轮换刷新令牌。',
-        vector: vectorAt(0),
-        tags: ['auth'],
-        sourcePaths: ['src/auth.js'],
-        sourceCommit: 'abc123',
-      },
-      {
-        chunkOrder: 1,
-        title: '登录设计',
-        chunkText: '退出登录会撤销刷新令牌。',
-        vector: vectorAt(1),
-        sourceCommit: 'abc123',
-      },
-    ]);
-    assert.equal(created.action, 'created');
-    assert.equal(await db.count(), 2);
-
-    const same = await db.replaceEntry('personal:alpha', 'modules/auth.md', [
-      { chunkOrder: 0, title: '登录设计', chunkText: '系统使用短期访问令牌和可轮换刷新令牌。', vector: vectorAt(0), tags: ['auth'], sourcePaths: ['src/auth.js'], sourceCommit: 'abc123' },
-      { chunkOrder: 1, title: '登录设计', chunkText: '退出登录会撤销刷新令牌。', vector: vectorAt(1), sourceCommit: 'abc123' },
-    ]);
-    assert.equal(same.action, 'unchanged');
-
-    const updated = await db.replaceEntry('personal:alpha', 'modules/auth.md', [
-      { chunkOrder: 0, title: '登录设计', chunkText: '系统使用短期访问令牌。', vector: vectorAt(0), sourceCommit: 'def456' },
-    ]);
-    assert.equal(updated.action, 'updated');
-    assert.equal(updated.deleted, 1);
-    assert.equal(await db.count(), 1);
-
-    await db.replaceEntry('personal:beta', 'GOAL.md', [
-      { chunkOrder: 0, title: '目标', chunkText: '支付服务负责对账。', vector: vectorAt(1), sourceCommit: '999999' },
-    ]);
-    assert.equal(await db.count(['personal:alpha']), 1);
-    const scoped = await db.vectorSearch(vectorAt(0), { spaceIds: ['personal:alpha'], limit: 5 });
-    assert.equal(scoped.length, 1);
-    assert.equal(scoped[0].space_id, 'personal:alpha');
-    assert.deepEqual(scoped[0].tags, []);
-    assert.equal(scoped[0].content_hash, sha256('系统使用短期访问令牌。'));
-
-    const initialIndexes = await db.ensureSearchIndexes();
-    assert.equal(initialIndexes.ftsSchemaVersion, 2);
-    assert.equal(initialIndexes.ftsUpgradeRequired, false);
-    assert.equal(db.maintenanceState().ftsSchemaVersion, 2);
-    const keyword = await db.fullTextSearch('短期访问令牌', { spaceIds: ['personal:alpha'], limit: 5 });
-    assert.equal(keyword.length, 1);
-    const hybrid = await db.hybridSearch({ text: '短期访问令牌', vector: vectorAt(0), spaceIds: ['personal:alpha'], limit: 5 });
-    assert.equal(hybrid.length, 1);
-    assert.deepEqual(hybrid[0].match_channels.sort(), ['keyword', 'semantic']);
-
-    assert.equal((await db.deleteEntry('personal:alpha', 'modules/auth.md')).deleted, 1);
-    assert.equal((await db.deleteSpace('personal:beta')).deleted, 1);
-    assert.equal(await db.count(), 0);
-
-    let seenInput = null;
-    let seenOptions = null;
-    const embeddings = new LocalEmbeddingService({
-      remoteHost: 'https://models.example.test/',
-      pipelineFactory: async (task, model, options) => {
-        assert.equal(task, 'feature-extraction');
-        assert.equal(model, 'Xenova/bge-small-zh-v1.5');
-        assert.equal(options.dtype, 'fp32');
-        return async (input, embedOptions) => {
-          seenInput = input;
-          seenOptions = embedOptions;
-          return { data: Float32Array.from(vectorAt(2)) };
-        };
-      },
-    });
-    const embedded = await embeddings.embedQuery('登录怎么做');
-    assert.equal(embedded.length, EMBEDDING_DIMENSIONS);
-    assert.equal(seenInput, `${QUERY_PREFIX}登录怎么做`);
-    assert.deepEqual(seenOptions, { pooling: 'cls', normalize: true });
-    assert.equal(embeddings.status().loaded, true);
-    assert.equal(embeddings.status().remoteHost, 'https://models.example.test/');
-
-    const sections = chunkMarkdown('# 标题\n\n第一段。\n\n## 细节\n\n第二段。', { maxChars: 20, overlapChars: 2 });
-    assert.ok(sections.length >= 2);
-    assert.deepEqual(sections.at(-1).headingPath, ['标题', '细节']);
-
-    const markdownRoot = path.join(temp, 'legacy-markdown');
-    fs.mkdirSync(path.join(markdownRoot, 'modules'), { recursive: true });
-    fs.writeFileSync(path.join(markdownRoot, 'GOAL.md'), '# 项目目标\n\n建立可靠的支付知识库。\n', 'utf8');
-    fs.writeFileSync(path.join(markdownRoot, 'modules', 'pay.md'), '# 支付模块\n\n对账任务每天运行。\n', 'utf8');
-    fs.writeFileSync(path.join(markdownRoot, 'modules', '00-index.md'), '# Modules Index\n\nTags: duplicated, derived\n', 'utf8');
-    const deterministicEmbedder = {
-      embedPassage: async text => text.includes('对账') ? vectorAt(3) : vectorAt(4),
-    };
-    const indexer = new MarkdownKnowledgeIndexer({ database: db, embedder: deterministicEmbedder });
-    await db.replaceEntry('personal:migrated', 'modules/00-index.md', [
-      { chunkOrder: 0, title: 'Legacy index', chunkText: 'duplicated derived tags', vector: vectorAt(5) },
-    ]);
-    const firstIndex = await indexer.indexDirectory({ kbPath: markdownRoot, spaceId: 'personal:migrated', sourceProjectId: 'pay' });
-    assert.equal(firstIndex.files, 2);
-    assert.equal(firstIndex.indexed, 2);
-    assert.equal(firstIndex.deletedEntries, 1, 'previously indexed derived files should be removed as stale');
-    assert(!firstIndex.results.some(item => item.entryId.endsWith('00-index.md')), 'derived indexes must not be embedded');
-    assert.equal(firstIndex.maintenance.optimized, false, 'small updates must not optimize on every commit');
-    const secondIndex = await indexer.indexDirectory({ kbPath: markdownRoot, spaceId: 'personal:migrated', sourceProjectId: 'pay' });
-    assert.equal(secondIndex.unchanged, 2);
-    db.optimizeOperationsThreshold = 1;
-    fs.unlinkSync(path.join(markdownRoot, 'GOAL.md'));
-    const thirdIndex = await indexer.indexDirectory({ kbPath: markdownRoot, spaceId: 'personal:migrated', sourceProjectId: 'pay' });
-    assert.equal(thirdIndex.deletedEntries, 1);
-    assert.equal(thirdIndex.maintenance.optimized, true, 'maintenance should run after the configured mutation threshold');
-    assert.equal(db.maintenanceState().pendingOperations, 0);
-    assert.deepEqual(await db.entryIds('personal:migrated'), ['modules/pay.md']);
-
-    console.log('knowledge-db-test: PASS');
-  } finally {
-    await db.close();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-})().catch(error => {
-  console.error(error);
-  process.exit(1);
-});
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { KnowledgeDatabase, sqlString, inPredicate } = require('../lib/knowledge-db');
+const { LocalEmbeddingService, QUERY_PREFIX } = require('../lib/embedding-service');
+const { EMBEDDING_DIMENSIONS, sha256 } = require('../lib/knowledge-schema');
+const { MarkdownKnowledgeIndexer, chunkMarkdown } = require('../lib/markdown-knowledge-indexer');
+
+function vectorAt(index) {
+  const vector = new Array(EMBEDDING_DIMENSIONS).fill(0);
+  vector[index] = 1;
+  return vector;
+}
+
+(async () => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-db-test-'));
+  const db = new KnowledgeDatabase({ dbPath: path.join(temp, 'knowledge.lancedb') });
+  try {
+    assert.equal(sqlString("space'o"), "'space''o'");
+    assert.equal(inPredicate('space_id', ['a', 'a', 'b']), "space_id IN ('a', 'b')");
+    assert.throws(() => inPredicate('space_id', []), /must not be empty/);
+
+    const created = await db.replaceEntry('personal:alpha', 'modules/auth.md', [
+      {
+        chunkOrder: 0,
+        title: '登录设计',
+        chunkText: '系统使用短期访问令牌和可轮换刷新令牌。',
+        vector: vectorAt(0),
+        tags: ['auth'],
+        sourcePaths: ['src/auth.js'],
+        sourceCommit: 'abc123',
+      },
+      {
+        chunkOrder: 1,
+        title: '登录设计',
+        chunkText: '退出登录会撤销刷新令牌。',
+        vector: vectorAt(1),
+        sourceCommit: 'abc123',
+      },
+    ]);
+    assert.equal(created.action, 'created');
+    assert.equal(await db.count(), 2);
+
+    const same = await db.replaceEntry('personal:alpha', 'modules/auth.md', [
+      { chunkOrder: 0, title: '登录设计', chunkText: '系统使用短期访问令牌和可轮换刷新令牌。', vector: vectorAt(0), tags: ['auth'], sourcePaths: ['src/auth.js'], sourceCommit: 'abc123' },
+      { chunkOrder: 1, title: '登录设计', chunkText: '退出登录会撤销刷新令牌。', vector: vectorAt(1), sourceCommit: 'abc123' },
+    ]);
+    assert.equal(same.action, 'unchanged');
+
+    const updated = await db.replaceEntry('personal:alpha', 'modules/auth.md', [
+      { chunkOrder: 0, title: '登录设计', chunkText: '系统使用短期访问令牌。', vector: vectorAt(0), sourceCommit: 'def456' },
+    ]);
+    assert.equal(updated.action, 'updated');
+    assert.equal(updated.deleted, 1);
+    assert.equal(await db.count(), 1);
+
+    await db.replaceEntry('personal:beta', 'GOAL.md', [
+      { chunkOrder: 0, title: '目标', chunkText: '支付服务负责对账。', vector: vectorAt(1), sourceCommit: '999999' },
+    ]);
+    assert.equal(await db.count(['personal:alpha']), 1);
+    const scoped = await db.vectorSearch(vectorAt(0), { spaceIds: ['personal:alpha'], limit: 5 });
+    assert.equal(scoped.length, 1);
+    assert.equal(scoped[0].space_id, 'personal:alpha');
+    assert.deepEqual(scoped[0].tags, []);
+    assert.equal(scoped[0].content_hash, sha256('系统使用短期访问令牌。'));
+
+    const initialIndexes = await db.ensureSearchIndexes();
+    assert.equal(initialIndexes.ftsSchemaVersion, 2);
+    assert.equal(initialIndexes.ftsUpgradeRequired, false);
+    assert.equal(db.maintenanceState().ftsSchemaVersion, 2);
+    const keyword = await db.fullTextSearch('短期访问令牌', { spaceIds: ['personal:alpha'], limit: 5 });
+    assert.equal(keyword.length, 1);
+    const hybrid = await db.hybridSearch({ text: '短期访问令牌', vector: vectorAt(0), spaceIds: ['personal:alpha'], limit: 5 });
+    assert.equal(hybrid.length, 1);
+    assert.deepEqual(hybrid[0].match_channels.sort(), ['keyword', 'semantic']);
+
+    assert.equal((await db.deleteEntry('personal:alpha', 'modules/auth.md')).deleted, 1);
+    assert.equal((await db.deleteSpace('personal:beta')).deleted, 1);
+    assert.equal(await db.count(), 0);
+
+    let seenInput = null;
+    let seenOptions = null;
+    const embeddings = new LocalEmbeddingService({
+      remoteHost: 'https://models.example.test/',
+      pipelineFactory: async (task, model, options) => {
+        assert.equal(task, 'feature-extraction');
+        assert.equal(model, 'Xenova/bge-small-zh-v1.5');
+        assert.equal(options.dtype, 'fp32');
+        return async (input, embedOptions) => {
+          seenInput = input;
+          seenOptions = embedOptions;
+          return { data: Float32Array.from(vectorAt(2)) };
+        };
+      },
+    });
+    const embedded = await embeddings.embedQuery('登录怎么做');
+    assert.equal(embedded.length, EMBEDDING_DIMENSIONS);
+    assert.equal(seenInput, `${QUERY_PREFIX}登录怎么做`);
+    assert.deepEqual(seenOptions, { pooling: 'cls', normalize: true });
+    assert.equal(embeddings.status().loaded, true);
+    assert.equal(embeddings.status().remoteHost, 'https://models.example.test/');
+
+    const sections = chunkMarkdown('# 标题\n\n第一段。\n\n## 细节\n\n第二段。', { maxChars: 20, overlapChars: 2 });
+    assert.ok(sections.length >= 2);
+    assert.deepEqual(sections.at(-1).headingPath, ['标题', '细节']);
+
+    const markdownRoot = path.join(temp, 'legacy-markdown');
+    fs.mkdirSync(path.join(markdownRoot, 'modules'), { recursive: true });
+    fs.writeFileSync(path.join(markdownRoot, 'GOAL.md'), '# 项目目标\n\n建立可靠的支付知识库。\n', 'utf8');
+    fs.writeFileSync(path.join(markdownRoot, 'modules', 'pay.md'), '# 支付模块\n\n对账任务每天运行。\n', 'utf8');
+    fs.writeFileSync(path.join(markdownRoot, 'modules', '00-index.md'), '# Modules Index\n\nTags: duplicated, derived\n', 'utf8');
+    const deterministicEmbedder = {
+      embedPassage: async text => text.includes('对账') ? vectorAt(3) : vectorAt(4),
+    };
+    const indexer = new MarkdownKnowledgeIndexer({ database: db, embedder: deterministicEmbedder });
+    await db.replaceEntry('personal:migrated', 'modules/00-index.md', [
+      { chunkOrder: 0, title: 'Legacy index', chunkText: 'duplicated derived tags', vector: vectorAt(5) },
+    ]);
+    const firstIndex = await indexer.indexDirectory({ kbPath: markdownRoot, spaceId: 'personal:migrated', sourceProjectId: 'pay' });
+    assert.equal(firstIndex.files, 2);
+    assert.equal(firstIndex.indexed, 2);
+    assert.equal(firstIndex.deletedEntries, 1, 'previously indexed derived files should be removed as stale');
+    assert(!firstIndex.results.some(item => item.entryId.endsWith('00-index.md')), 'derived indexes must not be embedded');
+    assert.equal(firstIndex.maintenance.optimized, false, 'small updates must not optimize on every commit');
+    const secondIndex = await indexer.indexDirectory({ kbPath: markdownRoot, spaceId: 'personal:migrated', sourceProjectId: 'pay' });
+    assert.equal(secondIndex.unchanged, 2);
+    db.optimizeOperationsThreshold = 1;
+    fs.unlinkSync(path.join(markdownRoot, 'GOAL.md'));
+    const thirdIndex = await indexer.indexDirectory({ kbPath: markdownRoot, spaceId: 'personal:migrated', sourceProjectId: 'pay' });
+    assert.equal(thirdIndex.deletedEntries, 1);
+    assert.equal(thirdIndex.maintenance.optimized, true, 'maintenance should run after the configured mutation threshold');
+    assert.equal(db.maintenanceState().pendingOperations, 0);
+    assert.deepEqual(await db.entryIds('personal:migrated'), ['modules/pay.md']);
+
+    console.log('knowledge-db-test: PASS');
+  } finally {
+    await db.close();
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+})().catch(error => {
+  console.error(error);
+  process.exit(1);
+});