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

package/_site/_test/launcher-readiness-test.js

@@ -1,80 +1,80 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const net = require('node:net');
-const { spawn } = require('node:child_process');
-const endpoint = require('../lib/runtime-endpoint');
-
-const packageRoot = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../..');
-const bin = path.join(packageRoot, 'bin/project-knowledge.js');
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-launcher-readiness-'));
-const data = path.join(root, '.project-knowledge-v5');
-const record = path.join(data, 'runtime/claude-sessions/project-a/session.json');
-const recordBytes = JSON.stringify({ schema: 'claude-workbench-session/v1', sessionId: 'old-test', projectSlug: 'project-a', state: 'running', metadata: { automation: true } });
-fs.mkdirSync(path.dirname(record), { recursive: true });
-fs.writeFileSync(record, recordBytes);
-const env = { ...process.env, KB_DATA_DIR: data, KB_MODULES_AUTOSTART: '0', AI_CODING_EVENT_BRIDGE_HOME: path.join(root, 'bridge') };
-let serverPid;
-
-function run(args, overrides = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [bin, ...args], { cwd: root, env: { ...env, ...overrides }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
-    let stdout = '', stderr = '';
-    const timer = setTimeout(() => { child.kill(); reject(new Error(`CLI timed out: ${stdout} ${stderr}`)); }, 25000);
-    child.stdout.on('data', chunk => { stdout += chunk; });
-    child.stderr.on('data', chunk => { stderr += chunk; });
-    child.once('error', reject);
-    child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
-  });
-}
-async function freePort() {
-  const server = net.createServer();
-  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
-  const port = server.address().port;
-  await new Promise(resolve => server.close(resolve));
-  return port;
-}
-
-(async () => {
-  const port = await freePort();
-  const launched = await run(['--no-open'], { KB_SITE_PORT: String(port) });
-  serverPid = endpoint.readEndpoint(data)?.pid;
-  assert.equal(launched.code, 0, launched.stderr);
-  assert.match(launched.stdout, new RegExp(`is ready at http://127.0.0.1:${port}`));
-  assert(serverPid && endpoint.isProcessAlive(serverPid));
-  const response = await fetch(`http://127.0.0.1:${port}/api/state`);
-  assert.equal(response.status, 200, 'ready must mean HTTP is usable, not only a PID exists');
-  const state = await response.json();
-  assert.deepEqual(state.projects, [], 'abandoned sessions must not import projects or enqueue analysis');
-  assert.equal(fs.readFileSync(record, 'utf8'), recordBytes);
-  const again = await run(['--no-open']);
-  assert.equal(again.code, 0);
-  assert.match(again.stdout, /Already running/);
-  const stopped = await run(['stop']);
-  assert.equal(stopped.code, 0);
-  for (let attempt = 0; attempt < 50 && endpoint.isProcessAlive(serverPid); attempt++) await new Promise(resolve => setTimeout(resolve, 100));
-  assert.equal(endpoint.isProcessAlive(serverPid), false);
-  serverPid = null;
-
-  const oldData = path.join(root, 'actual-old-data');
-  fs.mkdirSync(oldData);
-  const original = JSON.stringify({ projectOrder: ['old-project'] });
-  fs.writeFileSync(path.join(oldData, 'projects.json'), original);
-  const failed = await run(['--no-open', '--port', String(port)], { KB_DATA_DIR: oldData });
-  assert.equal(failed.code, 1, 'background failures must return nonzero to the invoking terminal');
-  assert.match(failed.stderr, /启动失败/);
-  assert.match(failed.stderr, /projects\.json/);
-  assert(!/is ready|Listening at/.test(failed.stdout));
-  assert.equal(fs.readFileSync(path.join(oldData, 'projects.json'), 'utf8'), original);
-  assert.equal(fs.existsSync(path.join(oldData, 'product-data.json')), false);
-  const log = fs.readFileSync(path.join(oldData, 'launcher.log'), 'utf8');
-  assert.match(log, /startup failed/);
-  assert(!/Listening at/.test(log), 'never advertise a listener before initialization succeeds');
-  console.log('launcher readiness PASS: unrelated cwd, abandoned records, HTTP readiness, stop, terminal failure, legacy preservation');
-})().catch(error => { console.error(error); process.exitCode = 1; }).finally(() => {
-  if (serverPid && endpoint.readEndpoint(data)?.pid === serverPid) {
-    try { process.kill(serverPid); } catch {}
-  }
-});
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const net = require('node:net');
+const { spawn } = require('node:child_process');
+const endpoint = require('../lib/runtime-endpoint');
+
+const packageRoot = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../..');
+const bin = path.join(packageRoot, 'bin/project-knowledge.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-launcher-readiness-'));
+const data = path.join(root, '.project-knowledge-v5');
+const record = path.join(data, 'runtime/claude-sessions/project-a/session.json');
+const recordBytes = JSON.stringify({ schema: 'claude-workbench-session/v1', sessionId: 'old-test', projectSlug: 'project-a', state: 'running', metadata: { automation: true } });
+fs.mkdirSync(path.dirname(record), { recursive: true });
+fs.writeFileSync(record, recordBytes);
+const env = { ...process.env, KB_DATA_DIR: data, KB_MODULES_AUTOSTART: '0', AI_CODING_EVENT_BRIDGE_HOME: path.join(root, 'bridge') };
+let serverPid;
+
+function run(args, overrides = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [bin, ...args], { cwd: root, env: { ...env, ...overrides }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    let stdout = '', stderr = '';
+    const timer = setTimeout(() => { child.kill(); reject(new Error(`CLI timed out: ${stdout} ${stderr}`)); }, 25000);
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
+  });
+}
+async function freePort() {
+  const server = net.createServer();
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  await new Promise(resolve => server.close(resolve));
+  return port;
+}
+
+(async () => {
+  const port = await freePort();
+  const launched = await run(['--no-open'], { KB_SITE_PORT: String(port) });
+  serverPid = endpoint.readEndpoint(data)?.pid;
+  assert.equal(launched.code, 0, launched.stderr);
+  assert.match(launched.stdout, new RegExp(`is ready at http://127.0.0.1:${port}`));
+  assert(serverPid && endpoint.isProcessAlive(serverPid));
+  const response = await fetch(`http://127.0.0.1:${port}/api/state`);
+  assert.equal(response.status, 200, 'ready must mean HTTP is usable, not only a PID exists');
+  const state = await response.json();
+  assert.deepEqual(state.projects, [], 'abandoned sessions must not import projects or enqueue analysis');
+  assert.equal(fs.readFileSync(record, 'utf8'), recordBytes);
+  const again = await run(['--no-open']);
+  assert.equal(again.code, 0);
+  assert.match(again.stdout, /Already running/);
+  const stopped = await run(['stop']);
+  assert.equal(stopped.code, 0);
+  for (let attempt = 0; attempt < 50 && endpoint.isProcessAlive(serverPid); attempt++) await new Promise(resolve => setTimeout(resolve, 100));
+  assert.equal(endpoint.isProcessAlive(serverPid), false);
+  serverPid = null;
+
+  const oldData = path.join(root, 'actual-old-data');
+  fs.mkdirSync(oldData);
+  const original = JSON.stringify({ projectOrder: ['old-project'] });
+  fs.writeFileSync(path.join(oldData, 'projects.json'), original);
+  const failed = await run(['--no-open', '--port', String(port)], { KB_DATA_DIR: oldData });
+  assert.equal(failed.code, 1, 'background failures must return nonzero to the invoking terminal');
+  assert.match(failed.stderr, /启动失败/);
+  assert.match(failed.stderr, /projects\.json/);
+  assert(!/is ready|Listening at/.test(failed.stdout));
+  assert.equal(fs.readFileSync(path.join(oldData, 'projects.json'), 'utf8'), original);
+  assert.equal(fs.existsSync(path.join(oldData, 'product-data.json')), false);
+  const log = fs.readFileSync(path.join(oldData, 'launcher.log'), 'utf8');
+  assert.match(log, /startup failed/);
+  assert(!/Listening at/.test(log), 'never advertise a listener before initialization succeeds');
+  console.log('launcher readiness PASS: unrelated cwd, abandoned records, HTTP readiness, stop, terminal failure, legacy preservation');
+})().catch(error => { console.error(error); process.exitCode = 1; }).finally(() => {
+  if (serverPid && endpoint.readEndpoint(data)?.pid === serverPid) {
+    try { process.kill(serverPid); } catch {}
+  }
+});

package/_site/_test/legacy-claude-session-alias-test.js

@@ -1,106 +1,106 @@
-// Run: node _site/_test/legacy-claude-session-alias-test.js
-
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), `kb-legacy-session-${process.pid}-`));
-const projectId = 'project-stable-id';
-const legacySlug = 'legacy-project-slug';
-const knowledgePath = path.join(dataDir, 'knowledge', legacySlug);
-const metadataPath = path.join(dataDir, 'projects', projectId);
-const now = new Date().toISOString();
-process.env.KB_DATA_DIR = dataDir;
-require('../lib/data-dir')._resetCache();
-
-const { defaultProjectConfig, defaultProjectState } = require('../lib/project-store');
-
-function writeRecord(root, record) {
-  fs.mkdirSync(root, { recursive: true });
-  fs.writeFileSync(path.join(root, `${record.sessionId}.json`), `${JSON.stringify({
-    schema: 'claude-workbench-session/v1',
-    projectPath: dataDir,
-    kbPath: knowledgePath,
-    promptKey: 'post-commit-automation',
-    runner: 'sdk',
-    state: 'idle',
-    model: 'test-model',
-    startedAt: now,
-    endedAt: now,
-    exitCode: 0,
-    turns: 1,
-    pendingPermission: null,
-    updatedAt: now,
-    ...record,
-  }, null, 2)}\n`, 'utf8');
-}
-
-try {
-  fs.mkdirSync(metadataPath, { recursive: true });
-  fs.mkdirSync(knowledgePath, { recursive: true });
-  fs.writeFileSync(path.join(metadataPath, 'config.json'), `${JSON.stringify(defaultProjectConfig(projectId, {
-    displayName: 'Legacy project',
-    storageName: 'legacy-project',
-    repoPath: dataDir,
-    knowledgePath,
-    legacyExtensions: { slug: legacySlug, sourceSchema: 'legacy-v1' },
-  }), null, 2)}\n`, 'utf8');
-  fs.writeFileSync(path.join(metadataPath, 'state.json'), `${JSON.stringify(defaultProjectState(), null, 2)}\n`, 'utf8');
-  fs.writeFileSync(path.join(dataDir, 'projects.json'), `${JSON.stringify({
-    schema: 'project-registry/v2',
-    schemaVersion: 2,
-    projectOrder: [projectId],
-    projects: { [projectId]: { createdAt: now, displayNameSnapshot: 'Legacy project' } },
-    revision: 1,
-    updatedAt: now,
-  }, null, 2)}\n`, 'utf8');
-
-  const legacyRoot = path.join(dataDir, '_ai', legacySlug, 'claude-workbench');
-  const currentRoot = path.join(dataDir, 'runtime', 'claude-sessions', projectId);
-  writeRecord(legacyRoot, {
-    sessionId: 'sess-legacy-only',
-    projectSlug: legacySlug,
-    source: 'git-hook',
-    automation: true,
-    events: [
-      { type: 'claude/user-prompt', text: 'historical hook prompt' },
-      { type: 'claude/result', result: 'historical analysis result' },
-    ],
-  });
-  writeRecord(legacyRoot, {
-    sessionId: 'sess-duplicate',
-    projectSlug: legacySlug,
-    source: 'legacy-copy',
-    events: [{ type: 'claude/result', result: 'legacy duplicate' }],
-  });
-  writeRecord(currentRoot, {
-    sessionId: 'sess-duplicate',
-    projectSlug: projectId,
-    source: 'current-runtime',
-    events: [{ type: 'claude/result', result: 'current duplicate' }],
-  });
-
-  const runner = require('../lib/claude-cli-runner');
-  const listed = runner.listSessions({ projectSlug: projectId });
-  assert.strictEqual(listed.length, 2);
-  const legacy = listed.find(session => session.sessionId === 'sess-legacy-only');
-  assert(legacy, 'legacy alias session must be discoverable under the stable projectId');
-  assert.strictEqual(legacy.projectSlug, projectId);
-  assert.strictEqual(legacy.legacyProjectSlug, legacySlug);
-  assert.strictEqual(legacy.legacySource, true);
-  assert.strictEqual(listed.find(session => session.sessionId === 'sess-duplicate').source, 'current-runtime', 'canonical runtime record must win duplicate IDs');
-
-  const events = [];
-  const unsubscribe = runner.subscribe('sess-legacy-only', event => events.push(event));
-  unsubscribe();
-  assert(events.some(event => event.type === 'claude/user-prompt' && event.text === 'historical hook prompt'));
-  assert(events.some(event => event.type === 'claude/result' && event.result === 'historical analysis result'));
-  assert.strictEqual(runner.getState('sess-legacy-only').projectSlug, projectId);
-  console.log('legacy-claude-session-alias-test PASS');
-} catch (error) {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-} finally {
-  fs.rmSync(dataDir, { recursive: true, force: true });
-}
+// Run: node _site/_test/legacy-claude-session-alias-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), `kb-legacy-session-${process.pid}-`));
+const projectId = 'project-stable-id';
+const legacySlug = 'legacy-project-slug';
+const knowledgePath = path.join(dataDir, 'knowledge', legacySlug);
+const metadataPath = path.join(dataDir, 'projects', projectId);
+const now = new Date().toISOString();
+process.env.KB_DATA_DIR = dataDir;
+require('../lib/data-dir')._resetCache();
+
+const { defaultProjectConfig, defaultProjectState } = require('../lib/project-store');
+
+function writeRecord(root, record) {
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(path.join(root, `${record.sessionId}.json`), `${JSON.stringify({
+    schema: 'claude-workbench-session/v1',
+    projectPath: dataDir,
+    kbPath: knowledgePath,
+    promptKey: 'post-commit-automation',
+    runner: 'sdk',
+    state: 'idle',
+    model: 'test-model',
+    startedAt: now,
+    endedAt: now,
+    exitCode: 0,
+    turns: 1,
+    pendingPermission: null,
+    updatedAt: now,
+    ...record,
+  }, null, 2)}\n`, 'utf8');
+}
+
+try {
+  fs.mkdirSync(metadataPath, { recursive: true });
+  fs.mkdirSync(knowledgePath, { recursive: true });
+  fs.writeFileSync(path.join(metadataPath, 'config.json'), `${JSON.stringify(defaultProjectConfig(projectId, {
+    displayName: 'Legacy project',
+    storageName: 'legacy-project',
+    repoPath: dataDir,
+    knowledgePath,
+    legacyExtensions: { slug: legacySlug, sourceSchema: 'legacy-v1' },
+  }), null, 2)}\n`, 'utf8');
+  fs.writeFileSync(path.join(metadataPath, 'state.json'), `${JSON.stringify(defaultProjectState(), null, 2)}\n`, 'utf8');
+  fs.writeFileSync(path.join(dataDir, 'projects.json'), `${JSON.stringify({
+    schema: 'project-registry/v2',
+    schemaVersion: 2,
+    projectOrder: [projectId],
+    projects: { [projectId]: { createdAt: now, displayNameSnapshot: 'Legacy project' } },
+    revision: 1,
+    updatedAt: now,
+  }, null, 2)}\n`, 'utf8');
+
+  const legacyRoot = path.join(dataDir, '_ai', legacySlug, 'claude-workbench');
+  const currentRoot = path.join(dataDir, 'runtime', 'claude-sessions', projectId);
+  writeRecord(legacyRoot, {
+    sessionId: 'sess-legacy-only',
+    projectSlug: legacySlug,
+    source: 'git-hook',
+    automation: true,
+    events: [
+      { type: 'claude/user-prompt', text: 'historical hook prompt' },
+      { type: 'claude/result', result: 'historical analysis result' },
+    ],
+  });
+  writeRecord(legacyRoot, {
+    sessionId: 'sess-duplicate',
+    projectSlug: legacySlug,
+    source: 'legacy-copy',
+    events: [{ type: 'claude/result', result: 'legacy duplicate' }],
+  });
+  writeRecord(currentRoot, {
+    sessionId: 'sess-duplicate',
+    projectSlug: projectId,
+    source: 'current-runtime',
+    events: [{ type: 'claude/result', result: 'current duplicate' }],
+  });
+
+  const runner = require('../lib/claude-cli-runner');
+  const listed = runner.listSessions({ projectSlug: projectId });
+  assert.strictEqual(listed.length, 2);
+  const legacy = listed.find(session => session.sessionId === 'sess-legacy-only');
+  assert(legacy, 'legacy alias session must be discoverable under the stable projectId');
+  assert.strictEqual(legacy.projectSlug, projectId);
+  assert.strictEqual(legacy.legacyProjectSlug, legacySlug);
+  assert.strictEqual(legacy.legacySource, true);
+  assert.strictEqual(listed.find(session => session.sessionId === 'sess-duplicate').source, 'current-runtime', 'canonical runtime record must win duplicate IDs');
+
+  const events = [];
+  const unsubscribe = runner.subscribe('sess-legacy-only', event => events.push(event));
+  unsubscribe();
+  assert(events.some(event => event.type === 'claude/user-prompt' && event.text === 'historical hook prompt'));
+  assert(events.some(event => event.type === 'claude/result' && event.result === 'historical analysis result'));
+  assert.strictEqual(runner.getState('sess-legacy-only').projectSlug, projectId);
+  console.log('legacy-claude-session-alias-test PASS');
+} catch (error) {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+} finally {
+  fs.rmSync(dataDir, { recursive: true, force: true });
+}

package/_site/_test/legacy-routes-removed-test.js

@@ -1,47 +1,47 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnServer } = require('./helpers/spawn-server');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const PORT = 7833;
-const BASE = `http://127.0.0.1:${PORT}`;
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-routes-v2-'));
-
-async function waitForServer() {
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  throw new Error('server did not start');
-}
-
-(async () => {
-  const source = `${fs.readFileSync(path.join(ROOT, '_site', 'server.js'), 'utf8')}\n${fs.readFileSync(path.join(ROOT, '_site', 'lib', 'server-app.js'), 'utf8')}`;
-  for (const removedSymbol of ['automation/simulate', 'automation/init', 'hook-install', 'hook-uninstall', 'dispatchProjectInit', 'DEFAULT_INIT_PROMPT_TEMPLATE', 'renderProjectInitPrompt', '/api/raw']) {
-    assert(!source.includes(removedSymbol), `removed production symbol remains: ${removedSymbol}`);
-  }
-
-  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'routes-v2', extraEnv: { KB_SKIP_MIGRATION: '1' } });
-  try {
-    await waitForServer();
-    const routes = [
-      ['PUT', '/api/projects'],
-      ['POST', '/api/projects/project-example/init'],
-      ['POST', '/api/projects/project-example/automation/simulate'],
-      ['POST', '/api/projects/project-example/automation/init'],
-      ['GET', '/api/projects/project-example/hook-status'],
-      ['POST', '/api/projects/project-example/hook-install'],
-      ['POST', '/api/projects/project-example/hook-uninstall'],
-      ['GET', '/api/raw?path=README.md'],
-    ];
-    for (const [method, pathname] of routes) {
-      const response = await fetch(`${BASE}${pathname}`, { method });
-      assert.strictEqual(response.status, 404, `${method} ${pathname} should be removed`);
-    }
-    console.log('legacy-routes-removed-test PASS');
-  } finally {
-    await spawned.cleanup();
-  }
-})().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 { spawnServer } = require('./helpers/spawn-server');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const PORT = 7833;
+const BASE = `http://127.0.0.1:${PORT}`;
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-routes-v2-'));
+
+async function waitForServer() {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start');
+}
+
+(async () => {
+  const source = `${fs.readFileSync(path.join(ROOT, '_site', 'server.js'), 'utf8')}\n${fs.readFileSync(path.join(ROOT, '_site', 'lib', 'server-app.js'), 'utf8')}`;
+  for (const removedSymbol of ['automation/simulate', 'automation/init', 'hook-install', 'hook-uninstall', 'dispatchProjectInit', 'DEFAULT_INIT_PROMPT_TEMPLATE', 'renderProjectInitPrompt', '/api/raw']) {
+    assert(!source.includes(removedSymbol), `removed production symbol remains: ${removedSymbol}`);
+  }
+
+  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'routes-v2', extraEnv: { KB_SKIP_MIGRATION: '1' } });
+  try {
+    await waitForServer();
+    const routes = [
+      ['PUT', '/api/projects'],
+      ['POST', '/api/projects/project-example/init'],
+      ['POST', '/api/projects/project-example/automation/simulate'],
+      ['POST', '/api/projects/project-example/automation/init'],
+      ['GET', '/api/projects/project-example/hook-status'],
+      ['POST', '/api/projects/project-example/hook-install'],
+      ['POST', '/api/projects/project-example/hook-uninstall'],
+      ['GET', '/api/raw?path=README.md'],
+    ];
+    for (const [method, pathname] of routes) {
+      const response = await fetch(`${BASE}${pathname}`, { method });
+      assert.strictEqual(response.status, 404, `${method} ${pathname} should be removed`);
+    }
+    console.log('legacy-routes-removed-test PASS');
+  } finally {
+    await spawned.cleanup();
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });