@sanqianx/project-knowledge 4.6.1

package/_site/_test/module-bridge-eventbridge-test.js

@@ -0,0 +1,193 @@
+// Module bridge: ai-coding-event-bridge console leg.
+//
+// Exercises the third embedded module end to end against a stub console
+// server (same surface as packages/console/src/server.js): proxy mapping,
+// idempotent registration by Git work tree path, removal (404-tolerant),
+// aggregated projection, health, and the supervised-spawn spec (vendored
+// runtime, command override, bridge-home passthrough). Real module services
+// are never contacted — terminal/vector-hub point at a reserved loopback
+// port that refuses instantly.
+
+const assert = require('assert');
+const http = require('http');
+const { PassThrough } = require('stream');
+const { ModuleBridge, defaultEventBridgeUrl } = require('../lib/module-bridge');
+
+const DEAD_URL = 'http://127.0.0.1:1'; // reserved port: connection refused, never a real service
+
+function makeStoreStub() {
+  const store = {
+    state: { modules: {} },
+    readConfig: () => ({ displayName: 'demo', repoPath: 'D:/work/demo', knowledgePath: 'D:/kb/demo' }),
+    readState: () => store.state,
+    updateState: async (_id, mutator) => { mutator(store.state); },
+  };
+  return store;
+}
+
+function fakeRes() {
+  return {
+    statusCode: 0, headers: {}, body: '',
+    writeHead(code, headers) { this.statusCode = code; this.headers = headers || {}; },
+    end(buf) { this.body = buf ? Buffer.from(buf).toString('utf8') : ''; },
+  };
+}
+
+function fakeReq(body) {
+  const req = new PassThrough();
+  req.method = 'GET';
+  req.headers = {};
+  req.end(body || undefined);
+  return req;
+}
+
+async function main() {
+  assert.strictEqual(defaultEventBridgeUrl(), 'http://127.0.0.1:8790', 'loopback default URL');
+
+  // ---- stub console server (same API surface the shell integrates against) ----
+  const hits = [];
+  const registered = [];
+  const stub = http.createServer((req, res) => {
+    const url = new URL(req.url, 'http://localhost');
+    hits.push(`${req.method} ${url.pathname}${url.search}`);
+    if (url.pathname === '/api/echo') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ echo: `${req.method} ${url.pathname}`, query: Object.fromEntries(url.searchParams) }));
+      return;
+    }
+    if (url.pathname === '/api/projects' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ projects: registered }));
+      return;
+    }
+    if (url.pathname === '/api/projects' && req.method === 'POST') {
+      let body = '';
+      req.on('data', c => { body += c; });
+      req.on('end', () => {
+        const parsed = JSON.parse(body || '{}');
+        if (registered.some(p => p.path === parsed.path)) {
+          res.writeHead(409, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { code: 'PROJECT_DUPLICATE', message: 'duplicate' } }));
+          return;
+        }
+        const project = { id: `sha256:${registered.length + 1}`, name: 'demo', path: parsed.path, store: parsed.store || 'global', auto: false, turns: 3 };
+        registered.push(project);
+        res.writeHead(201, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ project }));
+      });
+      return;
+    }
+    if (url.pathname === '/api/projects' && req.method === 'DELETE') {
+      const id = url.searchParams.get('id');
+      const index = registered.findIndex(p => p.id === id);
+      if (index === -1) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { code: 'PROJECT_NOT_FOUND', message: 'unknown' } }));
+        return;
+      }
+      registered.splice(index, 1);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ removed: true }));
+      return;
+    }
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: { code: 'NOT_FOUND', message: req.url } }));
+  });
+  await new Promise(resolve => stub.listen(0, '127.0.0.1', resolve));
+  const stubUrl = `http://127.0.0.1:${stub.address().port}`;
+
+  const savedEnv = { ...process.env };
+  delete process.env.KB_MODULES_REGISTER;
+  delete process.env.AI_CODING_EVENT_BRIDGE_HOME;
+  delete process.env.KB_EVENTBRIDGE_COMMAND;
+
+  try {
+    const bridge = new ModuleBridge({
+      terminalUrl: DEAD_URL,
+      vectorHubUrl: DEAD_URL,
+      eventBridgeUrl: stubUrl,
+      registryStore: { listIds: () => ['demo-proj'] },
+      projectStore: makeStoreStub(),
+    });
+
+    // ---- proxy mapping: /api/eventbridge/<rest> -> <console>/api/<rest> ----
+    assert.strictEqual(bridge._eventBridgeApi('/api/eventbridge/projects'), `${stubUrl}/api/projects`, 'api prefix mapping');
+    const pres = fakeRes();
+    await bridge.proxyEventBridge(fakeReq(), pres, '/api/eventbridge/echo', '?x=1');
+    assert.strictEqual(pres.statusCode, 200, 'proxy reaches the console');
+    assert.deepStrictEqual(JSON.parse(pres.body).query, { x: '1' }, 'proxy forwards query string');
+
+    // ---- registration: POST { path, store: <knowledge>/dev-conversations } ----
+    const wiringStore = bridge.projectStore;
+    const first = await bridge.registerProjectLinks({ projectId: 'demo-proj', name: 'demo', workspacePath: 'D:/work/demo', knowledgePath: 'D:/kb/demo' });
+    assert.strictEqual(first.eventBridge.ok, true, 'event-bridge leg registers');
+    assert.strictEqual(first.eventBridge.status, 'registered', 'first registration is not a reuse');
+    assert.ok(first.eventBridge.projectId, 'registration returns the console project id');
+    const postHits = hits.filter(h => h.startsWith('POST /api/projects'));
+    assert.strictEqual(postHits.length, 1, 'exactly one POST issued');
+    assert.ok(wiringStore.state.modules.eventBridge, 'wiring persisted');
+    assert.ok(wiringStore.state.modules.eventBridge.store.endsWith('dev-conversations'), 'store follows the recommended layout');
+
+    // ---- idempotent registration: same path is reused, no second POST ----
+    const second = await bridge.registerProjectLinks({ projectId: 'demo-proj', name: 'demo', workspacePath: 'D:/work/demo', knowledgePath: 'D:/kb/demo' });
+    assert.strictEqual(second.eventBridge.ok, true, 're-registration succeeds');
+    assert.strictEqual(second.eventBridge.reused, true, 're-registration reuses by path');
+    assert.strictEqual(hits.filter(h => h.startsWith('POST /api/projects')).length, 1, 'no duplicate POST on re-registration');
+
+    // ---- aggregated projection ----
+    const aggregate = await bridge.aggregatedProjects();
+    assert.strictEqual(aggregate.eventBridgeAvailable, true, 'event-bridge available flag');
+    const projected = aggregate.projects.find(p => p.projectId === 'demo-proj');
+    assert.strictEqual(projected.modules.eventBridge.registered, true, 'sidebar projection marks event-bridge registered');
+    assert.strictEqual(projected.modules.eventBridge.turns, 3, 'sidebar projection carries turn count');
+
+    // ---- health ----
+    const health = await bridge.modulesHealth();
+    assert.strictEqual(health.modules.eventBridge.up, true, 'health reports event-bridge up');
+    assert.strictEqual(health.modules.terminal.up, false, 'health keeps terminal leg honest');
+
+    // ---- removal: DELETE ?id=..., wiring cleared ----
+    const removal = await bridge.removeProjectLinks({ projectId: 'demo-proj' });
+    assert.strictEqual(removal.eventBridge.ok, true, 'removal succeeds');
+    assert.ok(hits.some(h => h.startsWith(`DELETE /api/projects?id=${encodeURIComponent(first.eventBridge.projectId)}`)), 'DELETE carries the console project id');
+    assert.strictEqual(wiringStore.state.modules.eventBridge.status, 'removed', 'wiring marked removed');
+
+    // ---- removal when the console no longer knows the project: 404 tolerated ----
+    const removalAgain = await bridge.removeProjectLinks({ projectId: 'demo-proj' });
+    assert.strictEqual(removalAgain.eventBridge.ok, true, '404 on removal counts as removed');
+
+    // ---- supervised spawn spec ----
+    const specs = bridge._supervisedSpecs();
+    const ebSpec = specs.find(s => s.name === 'event-bridge');
+    assert.ok(ebSpec, 'supervisor specs include event-bridge');
+    assert.ok(ebSpec.command.includes('serve'), 'spec serves the console');
+    // Windows 路径分隔符无关:命令里的绝对路径在 win32 上是反斜杠
+    assert.ok(ebSpec.command.replace(new RegExp("\\\\+", 'g'), '/').includes('@sanqianx/ai-coding-event-bridge-console'), 'spec spawns the packaged console runtime; actual=' + ebSpec.command);
+    assert.ok(ebSpec.url === stubUrl, 'spec binds the configured URL');
+
+    process.env.KB_EVENTBRIDGE_COMMAND = 'node C:/explicit/console-bin.js serve --port 9001';
+    const overridden = bridge._supervisedSpecs().find(s => s.name === 'event-bridge');
+    assert.ok(overridden.command.includes('C:/explicit/console-bin.js'), 'KB_EVENTBRIDGE_COMMAND override wins');
+
+    process.env.AI_CODING_EVENT_BRIDGE_HOME = 'D:/bridge-home';
+    delete process.env.KB_EVENTBRIDGE_COMMAND;
+    const withHome = bridge._supervisedSpecs().find(s => s.name === 'event-bridge');
+    assert.ok(withHome.command.includes('--home'), 'bridge home is passed through to the console');
+    assert.ok(withHome.command.includes('D:\\bridge-home') || withHome.command.includes('D:/bridge-home'), 'bridge home path is quoted into the command line');
+
+    // ---- KB_MODULES_REGISTER=0 keeps the fan-out off ----
+    process.env.KB_MODULES_REGISTER = '0';
+    const disabled = await bridge.registerProjectLinks({ projectId: 'demo-proj', name: 'demo', workspacePath: 'D:/work/demo', knowledgePath: 'D:/kb/demo' });
+    assert.strictEqual(disabled.eventBridge.status, 'disabled', 'registration honors KB_MODULES_REGISTER=0');
+  } finally {
+    process.env = savedEnv;
+    stub.close();
+  }
+
+  console.log('module-bridge-eventbridge-test PASS');
+}
+
+main().catch(error => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});

package/_site/_test/non-release-ci-test.js

@@ -0,0 +1,34 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const workflowPath = path.join(ROOT, '.github', 'workflows', 'ci.yml');
+const workflow = fs.readFileSync(workflowPath, 'utf8');
+
+assert.match(workflow, /^\s*push:/m, 'non-release CI must run for branch pushes');
+assert.match(workflow, /^\s*pull_request:/m, 'non-release CI must run for pull requests');
+assert.match(workflow, /node:\s*\['18\.x', '24\.x'\]/, 'Linux CI must cover Node 18 and 24');
+assert.match(workflow, /runs-on:\s*windows-latest/, 'CI must include a Windows job');
+assert.match(workflow, /npm test -- --no-report/, 'CI must run the core regression suite');
+assert.match(workflow, /npm pack --dry-run --json/, 'CI must audit the npm package contents');
+
+// Desktop development is paused by product decision (2026-08-18): the
+// non-release CI validates the web runtime only. Desktop packaging validation
+// must be restored together with desktop development; until then it must not
+// run silently under this workflow.
+assert.doesNotMatch(workflow, /npm test --prefix desktop/, 'desktop validation is paused and must not run here');
+assert.doesNotMatch(workflow, /test:packaged/, 'packaged desktop smoke is paused and must not run here');
+assert.doesNotMatch(workflow, /electron-forge|npm run make/, 'desktop packaging is paused and must not run here');
+
+for (const forbidden of [
+  /workflow_dispatch:/,
+  /^\s*tags:/m,
+  /npm\s+publish/,
+  /gh\s+release/,
+  /git\s+tag/,
+]) {
+  assert(!forbidden.test(workflow), `non-release CI contains forbidden release behavior: ${forbidden}`);
+}
+
+console.log('non-release-ci-test PASS');

package/_site/_test/offline-boundary-isolation-test.js

@@ -0,0 +1,32 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ProjectStore } = require('../lib/project-store');
+const { ConversationStore } = require('../lib/conversation-store');
+const { CommitConversationBinder } = require('../lib/commit-conversation-binder');
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-offline-boundaries-'));
+  try {
+    const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
+    const projects = new ProjectStore({ layout });
+    const projectId = 'project-offline-boundary';
+    const identity = { commonDir: path.join(root, 'repo', '.git') };
+    await projects.create(projectId, { storageName: 'offline-boundary', displayName: 'Offline Boundary', repoPath: path.join(root, 'repo'), knowledgePath: path.join(root, 'knowledge'), repoIdentity: identity }, { conversationBaselineCursor: 0 });
+    const store = new ConversationStore({ layout, projectStore: projects });
+    const binder = new CommitConversationBinder({ layout, projectStore: projects, conversationStore: store });
+    const add = (sequence, eventId, content) => store.appendEvent(projectId, { eventId, sequence, source: 'codex', eventType: 'user_prompt', role: 'user', content, turnId: eventId, repoIdentity: identity, capturedAt: '2026-08-24T00:00:00.000Z', identityConfidence: 'exact', captureStatus: 'captured' });
+    const boundary = (sha, cursor) => store.writeBoundary(projectId, { commitSha: sha, repoIdentity: identity, parentShas: [], branch: 'main', committedAt: '2026-08-24T00:00:00.000Z', bridgeCursorAtCommit: cursor, journalSequence: cursor, openTurnIdsAtCommit: [], operationId: `op-${cursor}` });
+    const b = 'b'.repeat(40); const c = 'c'.repeat(40); const d = 'd'.repeat(40);
+    await add(1, 'prompt-b', 'offline B'); boundary(b, 2);
+    await add(3, 'prompt-c', 'offline C'); boundary(c, 4);
+    await add(5, 'prompt-d', 'online D'); boundary(d, 6);
+    const snapshot = await binder.bind({ projectId, commitSha: d });
+    assert.deepEqual(snapshot.turns.map(turn => turn.turnId), ['prompt-d']);
+    assert.equal(JSON.stringify(snapshot).includes('offline B'), false);
+    assert.equal(JSON.stringify(snapshot).includes('offline C'), false);
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+  console.log('offline-boundary-isolation-test PASS');
+})().catch(error => { console.error(error.stack || error.message); process.exit(1); });

package/_site/_test/orphaned-claim-recovery-test.js

@@ -0,0 +1,80 @@
+// Run: node _site/_test/orphaned-claim-recovery-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ProjectRegistryStore } = require('../lib/project-registry-store');
+const { ProjectStore } = require('../lib/project-store');
+const { recoverOrphanedClaims } = require('../lib/post-commit-automation');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-orphaned-claim-${process.pid}-`));
+const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });
+const registryStore = new ProjectRegistryStore({ layout });
+const projectStore = new ProjectStore({ layout });
+const projectId = 'project-orphaned-claim';
+const oldCommit = 'a'.repeat(40);
+const lastAnalyzedCommit = 'b'.repeat(40);
+let warnings = 0;
+let analyzerCalls = 0;
+
+(async () => {
+  await registryStore.initialize();
+  await registryStore.add(projectId);
+  await projectStore.create(projectId, {
+    repoPath: temp,
+    knowledgePath: path.join(temp, 'knowledge'),
+  }, {
+    trackingStartCommit: lastAnalyzedCommit,
+    lastAnalyzedCommit,
+    analysis: {
+      status: 'evidence.prepared',
+      activeClaim: {
+        schema: 'commit-claim/v1',
+        projectId,
+        commitSha: oldCommit,
+        runId: 'run-before-restart',
+        operationId: 'operation-before-restart',
+        fingerprint: 'frozen-claim',
+        phase: 'evidence.prepared',
+      },
+    },
+  });
+
+  const recovered = await recoverOrphanedClaims({
+    layout,
+    registryStore,
+    projectStore,
+    claimProcessor: { processClaim: async () => { analyzerCalls += 1; } },
+    now: () => '2026-08-25T00:00:00.000Z',
+    logger: { warn: async () => { warnings += 1; } },
+  });
+
+  assert.deepStrictEqual(recovered, [{
+    projectId,
+    commitSha: oldCommit,
+    runId: 'run-before-restart',
+    previousPhase: 'evidence.prepared',
+  }]);
+  const state = projectStore.readState(projectId);
+  assert.strictEqual(state.lastAnalyzedCommit, lastAnalyzedCommit, 'startup recovery must not advance commit state');
+  assert.strictEqual(state.analysis.status, 'failed');
+  assert.strictEqual(state.analysis.activeClaim.commitSha, oldCommit);
+  assert.strictEqual(state.analysis.activeClaim.phase, 'failed');
+  assert.strictEqual(state.analysis.activeClaim.error.code, 'ORPHANED_CLAIM');
+  assert.strictEqual(state.analysis.activeClaim.error.retryable, false);
+  assert.strictEqual(state.analysis.lastError.code, 'ORPHANED_CLAIM');
+  assert.strictEqual(analyzerCalls, 0, 'startup recovery must never invoke analysis');
+  assert.strictEqual(warnings, 1);
+
+  const secondPass = await recoverOrphanedClaims({ layout, registryStore, projectStore });
+  assert.strictEqual(secondPass.length, 0, 'recovery is idempotent while the terminal claim remains visible');
+  assert.strictEqual(projectStore.readState(projectId).analysis.activeClaim.error.code, 'ORPHANED_CLAIM');
+  console.log('orphaned-claim-recovery-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => {
+  fs.rmSync(temp, { recursive: true, force: true });
+});

package/_site/_test/p0-data-migration-characterization-test.js

@@ -0,0 +1,37 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { MigrationService } = require('../lib/migration-service');
+
+function fixture() {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-p0-migration-'));
+  fs.writeFileSync(path.join(dataDir, 'projects.json'), JSON.stringify({ old: { repoPath: 'C:/legacy', kbPath: 'C:/knowledge/old' } }));
+  fs.writeFileSync(path.join(dataDir, 'knowledge-store.json'), JSON.stringify({ rootPath: 'C:/knowledge' }));
+  fs.writeFileSync(path.join(dataDir, 'ai-profiles.json'), JSON.stringify({ profiles: [{ id: 'p', apiKey: 'test-secret' }] }));
+  fs.writeFileSync(path.join(dataDir, 'embedding-config.json'), JSON.stringify({ modelId: 'legacy-model', localModelPath: 'C:/models', localFilesOnly: true }));
+  fs.mkdirSync(path.join(dataDir, 'models', 'nested'), { recursive: true });
+  fs.writeFileSync(path.join(dataDir, 'models', 'nested', 'model.onnx'), 'model-fixture');
+  return dataDir;
+}
+
+(async () => {
+  const dataDir = fixture();
+  try {
+    const layout = new StorageLayout({ dataDir });
+    const migration = new MigrationService({ layout, legacyDataDir: dataDir });
+    const result = await migration.migrateIfNeeded({ migrationRunId: 'p0-characterization' });
+    assert.equal(result.ok, true);
+    assert.equal(result.marker.schema, 'layout-migration-completion/v2');
+    assert.equal(result.marker.projectCount, 1);
+    assert.equal(result.marker.aiProfileCount, 1);
+    assert.equal(result.marker.knowledgeRootConfigured, true);
+    assert.equal(result.marker.embeddingConfigured, true);
+    assert.equal(fs.readFileSync(path.join(dataDir, 'cache', 'models', 'nested', 'model.onnx'), 'utf8'), 'model-fixture');
+    const settings = JSON.parse(fs.readFileSync(layout.getSettingsPath(), 'utf8'));
+    assert.equal(settings.embedding.modelId, 'legacy-model');
+    assert.equal(settings.ai.profiles.length, 1);
+  } finally { fs.rmSync(dataDir, { recursive: true, force: true }); }
+  console.log('p0-data-migration-characterization-test PASS');
+})().catch(error => { console.error(error.stack || error.message); process.exit(1); });