@sanqianx/project-knowledge 4.6.1

package/_site/_test/path-consistency-test.js

@@ -0,0 +1,151 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+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 { ProjectLifecycleService } = require('../lib/project-lifecycle-service');
+const { KnowledgeToolRuntime } = require('../lib/knowledge-tool-runtime');
+const { CommitReconciler } = require('../lib/commit-reconciler');
+const { handlePostCommitEvent } = require('../lib/post-commit-automation');
+const hookManager = require('../lib/hook-manager');
+const { callTool } = require('../../bin/project-knowledge-mcp');
+const { spawnServer } = require('./helpers/spawn-server');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const PORT = 7834;
+const BASE = `http://127.0.0.1:${PORT}`;
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-path-v2-'));
+const dataDir = path.join(temp, 'data');
+const rootA = path.join(temp, 'knowledge-a');
+const rootB = path.join(temp, 'knowledge-b');
+const oldRepo = path.join(temp, 'old-repo');
+const movedRepo = path.join(temp, 'moved-repo');
+const newRepo = path.join(temp, 'new-repo');
+
+function git(cwd, args) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  assert.strictEqual(result.status, 0, result.stderr);
+  return String(result.stdout || '').trim();
+}
+
+function initializeRepo(cwd, title) {
+  fs.mkdirSync(cwd, { recursive: true });
+  git(cwd, ['init', '--initial-branch=main']);
+  git(cwd, ['config', 'user.email', 'path@example.test']);
+  git(cwd, ['config', 'user.name', 'Path Test']);
+  fs.writeFileSync(path.join(cwd, 'README.md'), `# ${title}\n`, 'utf8');
+  git(cwd, ['add', 'README.md']);
+  git(cwd, ['commit', '-m', 'baseline']);
+}
+
+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 () => {
+  let spawned;
+  try {
+    initializeRepo(oldRepo, 'Old');
+    initializeRepo(newRepo, 'New');
+    fs.mkdirSync(rootA, { recursive: true });
+    fs.mkdirSync(rootB, { recursive: true });
+    const oldKnowledge = path.join(rootA, 'old-fixed');
+    fs.mkdirSync(path.join(oldKnowledge, 'modules'), { recursive: true });
+    fs.writeFileSync(path.join(oldKnowledge, 'modules', 'identity.md'), '# Fixed identity\n\nOld project knowledge remains here.\n', 'utf8');
+
+    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: rootA } });
+    await registryStore.initialize();
+    const baseline = git(oldRepo, ['rev-parse', 'HEAD']);
+    const commonDir = git(oldRepo, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    await projectStore.create('project-stable', {
+      displayName: 'Before rename', storageName: 'old-fixed', repoPath: oldRepo, knowledgePath: oldKnowledge,
+      repoIdentity: { commonDir }, legacyExtensions: { slug: 'legacy-old' },
+    }, { trackingStartCommit: baseline, index: { dirty: true, generation: 1 } });
+    await registryStore.add('project-stable', { displayNameSnapshot: 'Before rename' });
+
+    await settingsStore.updatePatch({ knowledge: { rootPath: rootB } });
+    assert.strictEqual(projectStore.readConfig('project-stable').knowledgePath, oldKnowledge, 'global root changes must not move an existing project');
+    await projectStore.updateConfig('project-stable', { displayName: 'After rename' });
+    assert.strictEqual(projectStore.readConfig('project-stable').projectId, 'project-stable');
+
+    const lifecycle = new ProjectLifecycleService({ layout, settingsStore, registryStore, projectStore, hookManager, triggerScriptPath: path.join(ROOT, '_site', 'scripts', 'hook-trigger.js') });
+    const imported = await lifecycle.importProject({ localPath: newRepo, displayName: 'New root project' });
+    assert(layout.isPathInside(rootB, imported.config.knowledgePath, { realpath: true }));
+    assert(!layout.isPathInside(rootA, imported.config.knowledgePath, { realpath: true }));
+    await settingsStore.updatePatch({ ai: { schema: 'ai-profiles/v1', profiles: [{ id: 'secret', apiKey: 'never-print-this-secret' }] } });
+
+    fs.renameSync(oldRepo, movedRepo);
+    const reconciler = new CommitReconciler({ layout, registryStore, projectStore, requireAiProfile: false });
+    reconciler.processCommitEvent = async input => ({ ok: true, projectId: input.projectId, commitSha: input.commitSha, status: 'completed', processed: [] });
+    const moved = await handlePostCommitEvent({ schema: 'hook-event/v2', projectId: 'project-stable', repoRoot: movedRepo, head: baseline, branch: 'main' }, { layout, registryStore, projectStore, reconciler });
+    assert.strictEqual(moved.ok, true);
+    assert.strictEqual(projectStore.readConfig('project-stable').repoPath, path.resolve(movedRepo));
+    assert.strictEqual(projectStore.readConfig('project-stable').projectId, 'project-stable');
+
+    const runtime = new KnowledgeToolRuntime({ layout, settingsStore, registryStore, projectStore, cwd: movedRepo });
+    const resolved = runtime.resolveProject({ repoPath: movedRepo });
+    assert.strictEqual(resolved.projectId, 'project-stable');
+    assert.strictEqual(resolved.knowledgePath, oldKnowledge);
+    assert.strictEqual(resolved.indexPath, layout.getIndexPath());
+    const mcpResolved = await callTool(runtime, 'project_knowledge_resolve', { projectId: 'project-stable' });
+    assert.strictEqual(mcpResolved.knowledgePath, resolved.knowledgePath);
+    assert.strictEqual(mcpResolved.indexPath, resolved.indexPath);
+
+    const protectedFiles = [layout.getSettingsPath(), layout.getProjectRegistryPath(), layout.getProjectConfigPath('project-stable'), layout.getProjectStatePath('project-stable')];
+    const beforeRead = new Map(protectedFiles.map(file => [file, fs.readFileSync(file, 'utf8')]));
+    const entry = await runtime.get({ projectId: 'project-stable', entry: 'modules/identity.md' });
+    assert.match(entry.chunks[0].chunk_text, /Old project knowledge/);
+    const search = await runtime.search({ projectId: 'project-stable', query: 'Old project knowledge' });
+    assert.strictEqual(search.source, 'knowledge-retrieval-service');
+    assert.strictEqual(search.backend, 'markdown-hybrid-fallback');
+    const cli = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'project-knowledge-kb.js'), 'get', '--project', 'project-stable', '--entry', 'modules/identity.md', '--json'], {
+      cwd: movedRepo, encoding: 'utf8', env: { ...process.env, KB_DATA_DIR: dataDir, KB_SKIP_MIGRATION: '1' },
+    });
+    assert.strictEqual(cli.status, 0, cli.stderr);
+    assert.match(JSON.parse(cli.stdout).chunks[0].chunk_text, /Old project knowledge/);
+    const cliError = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'project-knowledge-kb.js'), 'get', '--project', 'missing-project', '--entry', 'README.md', '--json'], {
+      cwd: movedRepo, encoding: 'utf8', env: { ...process.env, KB_DATA_DIR: dataDir, KB_SKIP_MIGRATION: '1' },
+    });
+    assert.notStrictEqual(cliError.status, 0);
+    assert(!cliError.stderr.includes('never-print-this-secret'));
+    assert(!/\bstack\b/i.test(cliError.stderr));
+    for (const file of protectedFiles) assert.strictEqual(fs.readFileSync(file, 'utf8'), beforeRead.get(file), `read query mutated ${file}`);
+    await runtime.close();
+
+    spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'path-v2' });
+    await waitForServer();
+    const response = await fetch(`${BASE}/api/projects`);
+    const body = await response.json();
+    const serverProject = body.projects.find(project => project.projectId === 'project-stable');
+    assert.strictEqual(serverProject.config.knowledgePath, oldKnowledge);
+    assert.strictEqual(layout.getIndexPath(), path.join(dataDir, 'index', 'knowledge.lancedb'));
+    console.log('path-consistency-test PASS');
+  } finally {
+    if (spawned) {
+      try { spawned.child.kill(); } catch {}
+      await Promise.race([
+        new Promise(resolve => spawned.child.once('exit', resolve)),
+        new Promise(resolve => setTimeout(resolve, 2000)),
+      ]);
+    }
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      try { fs.rmSync(temp, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); break; }
+      catch (error) {
+        if (attempt === 4) throw error;
+        await new Promise(resolve => setTimeout(resolve, 150));
+      }
+    }
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/pending-sweep-test.js

@@ -0,0 +1,9 @@
+const assert = require('assert');
+const automation = require('../lib/post-commit-automation');
+
+// Pending repository scans are not a recovery mechanism. A Hook event is the
+// only authority that can request analysis.
+assert.equal(Object.hasOwn(automation, 'dispatchPendingAutomations'), false);
+assert.equal(Object.hasOwn(automation, 'getQueueSize'), false);
+assert.equal(Object.hasOwn(automation, 'drainQueue'), false);
+console.log('pending-sweep-test PASS');

package/_site/_test/post-commit-automation-test.js

@@ -0,0 +1,87 @@
+// Run: node _site/_test/post-commit-automation-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const automationConfig = require('../lib/automation-config');
+const automation = require('../lib/post-commit-automation');
+const { REQUIREMENT_UNAVAILABLE, renderCommitPrompt } = require('../lib/commit-prompt');
+
+(() => {
+  const normalized = automationConfig.normalizeAutomationConfig({
+    enabled: true,
+    hookPromptTemplate: 'Legacy instruction for {{commitHash}}.',
+    initPromptTemplate: 'must be ignored',
+    postCommitEnabled: true,
+    allowReadOnlyBash: true,
+  });
+  assert.strictEqual(normalized.commitPromptTemplate, 'Legacy instruction for {{commitHash}}.', 'legacy Hook prompt should be a read-only compatibility override');
+  assert.strictEqual(normalized.legacyPromptOverride, true);
+  assert(!Object.hasOwn(normalized, 'hookPromptTemplate'));
+  assert(!Object.hasOwn(normalized, 'initPromptTemplate'));
+  assert(!Object.hasOwn(normalized, 'postCommitEnabled'));
+  assert(!Object.hasOwn(normalized, 'allowReadOnlyBash'));
+  assert(!Object.hasOwn(automationConfig, 'DEFAULT_INIT_PROMPT_TEMPLATE'), 'init prompt constant must not be exported');
+  assert(!Object.hasOwn(automation, 'dispatchProjectInit'), 'project init dispatch must not be public');
+  assert(!Object.hasOwn(automation, 'dispatchAutomation'), 'generic automation dispatch must not be public');
+
+  const staging = path.resolve('runtime', 'staging', 'run-test');
+  const evidenceRoot = path.resolve('runtime', 'runs', 'run-test', 'input', 'evidence');
+  const policy = automationConfig.buildAutomationToolPolicy({ stagingPath: staging, evidenceRoot });
+  assert.strictEqual(policy.canWriteKb, false, 'AI must never write final knowledge directly');
+  assert.strictEqual(policy.canWriteStaging, true);
+  assert(!policy.allowedTools.includes('Bash'), 'generic Bash must not be available to analysis');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.join(staging, 'manifest.json') }).behavior, 'allow');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.resolve('source.js') }).behavior, 'deny');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Read', { file_path: path.join(evidenceRoot, 'patch-manifest.json') }).behavior, 'allow');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.join(evidenceRoot, 'patches', '000001.patch') }).behavior, 'deny');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Read', { file_path: path.resolve('repo', 'source.js') }).behavior, 'deny');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Bash', { command: 'git show' }).behavior, 'deny');
+
+  const evidence = {
+    commitSha: 'a'.repeat(40),
+    parents: ['b'.repeat(40)],
+    author: 'Test Author',
+    date: '2026-08-17T00:00:00Z',
+    subject: 'feat: exact evidence',
+    branch: 'main',
+    patchMode: 'parent',
+    patchHash: 'sha256:patch',
+    patchBytes: 42,
+    patchOmitted: false,
+    patch: 'diff --git a/a.js b/a.js\n+implemented\n',
+    files: [{ status: 'M', path: 'a.js', oldPath: null, binary: false, added: 1, deleted: 0 }],
+  };
+  const config = {
+    projectId: 'project-test',
+    displayName: 'Prompt Test',
+    repoPath: path.resolve('repo'),
+    knowledgePath: path.resolve('knowledge'),
+    automation: { commitPromptTemplate: automationConfig.DEFAULT_COMMIT_PROMPT_TEMPLATE },
+  };
+  const missing = renderCommitPrompt({ config, evidence, requirements: [], existingKnowledge: { entries: [], omitted: [] } });
+  assert(missing.prompt.includes(REQUIREMENT_UNAVAILABLE), 'unavailable requirement must use the fixed non-guessing text');
+  assert(missing.prompt.includes(evidence.patch), 'prompt must contain the actual patch');
+  assert(missing.prompt.includes('现有相关知识'), 'prompt must contain existing knowledge section');
+  assert(missing.prompt.includes('新增、更新或删除'), 'prompt must ask for add/update/delete decisions');
+  assert(!missing.prompt.includes('git-hook') && !missing.prompt.includes('startup'), 'trigger must not affect prompt content');
+
+  const requirement = { id: 'req-1', client: 'codex', sessionId: 'session-1', ts: '2026-08-17T00:00:00Z', requirement: 'Implement the exact feature.' };
+  const fromHook = renderCommitPrompt({ config, evidence, requirements: [requirement], existingKnowledge: { entries: [] } });
+  const fromStartup = renderCommitPrompt({ config, evidence, requirements: [requirement], existingKnowledge: { entries: [] } });
+  assert.strictEqual(fromHook.promptHash, fromStartup.promptHash, 'Hook and startup must render the identical prompt hash');
+  assert(fromHook.prompt.includes('Implement the exact feature.'), 'recorded user requirement must be present');
+
+  const legacy = renderCommitPrompt({
+    config: { ...config, automation: { hookPromptTemplate: 'Legacy {{commitHash}}' } },
+    evidence,
+    requirements: [],
+    existingKnowledge: { entries: [] },
+  });
+  assert(legacy.prompt.includes('Legacy ' + evidence.commitSha), 'legacy Hook prompt override should still render');
+  assert(legacy.prompt.includes(REQUIREMENT_UNAVAILABLE) && legacy.prompt.includes(evidence.patch), 'mandatory evidence sections must be appended to incomplete legacy templates');
+
+  const source = fs.readFileSync(path.join(__dirname, '..', 'lib', 'post-commit-automation.js'), 'utf8');
+  assert(!/dispatchProjectInit|renderProjectInitPrompt|project-init|startup-recovery/.test(source), 'automation source must not retain init or a third trigger name');
+  console.log('post-commit-automation-test PASS');
+})();

package/_site/_test/pr-consumer-contract-test.js

@@ -0,0 +1,55 @@
+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 { KnowledgeToolRuntime } = require('../lib/knowledge-tool-runtime');
+const { validateKb, buildPrContextPack } = require('../lib/kb-validator');
+const { regenerateIndexes } = require('../lib/index-builder');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-pr-v2-'));
+const knowledgePath = path.join(temp, 'knowledge');
+
+function writeKnowledge() {
+  fs.mkdirSync(path.join(knowledgePath, 'modules'), { recursive: true });
+  fs.mkdirSync(path.join(knowledgePath, 'changes'), { recursive: true });
+  fs.writeFileSync(path.join(knowledgePath, 'README.md'), '# Test KB\n');
+  fs.writeFileSync(path.join(knowledgePath, 'GOAL.md'), '# Goal\n');
+  fs.writeFileSync(path.join(knowledgePath, 'ARCHITECTURE.md'), '# Architecture\n');
+  fs.writeFileSync(path.join(knowledgePath, 'modules', 'api.md'), '---\ntags: [api]\nsourcePaths: [src/api.js]\n---\n# API\n');
+  fs.writeFileSync(path.join(knowledgePath, 'changes', 'api-change.md'), '---\ntags: [api]\naffectedModules: [api]\ndevelopmentIntent: Add API memory.\n---\n# API change\n\n## Development Intent\nAdd API memory.\n\n## Implementation Result\nDone.\n\n## Evidence\n- src/api.js\n');
+  regenerateIndexes(knowledgePath);
+}
+
+(async () => {
+  try {
+    writeKnowledge();
+    const validation = validateKb(knowledgePath);
+    assert(validation.ok, JSON.stringify(validation.errors));
+    const pack = buildPrContextPack(knowledgePath);
+    assert(pack.ok);
+    assert.strictEqual(pack.pack.schema, 'pr-context-pack/v1');
+    assert(pack.pack.trustedKnowledge.some(item => item.path === 'modules/api.md'));
+    assert(!JSON.stringify(pack.pack).includes('_ai/'));
+
+    const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });
+    const settingsStore = new SettingsStore({ layout });
+    const registryStore = new ProjectRegistryStore({ layout });
+    const projectStore = new ProjectStore({ layout });
+    await settingsStore.initialize({ knowledge: { rootPath: path.join(temp, 'future') } });
+    await registryStore.initialize();
+    await projectStore.create('project-consumer', { displayName: 'Consumer', storageName: 'consumer', repoPath: temp, knowledgePath }, { index: { dirty: true, generation: 1 } });
+    await registryStore.add('project-consumer', { displayNameSnapshot: 'Consumer' });
+    const runtime = new KnowledgeToolRuntime({ layout, settingsStore, registryStore, projectStore, cwd: temp });
+    const entry = await runtime.get({ projectId: 'project-consumer', entry: 'modules/api.md' });
+    assert.match(entry.chunks[0].chunk_text, /# API/);
+    await assert.rejects(runtime.get({ projectId: 'project-consumer', entry: '../settings.json' }), error => error.code === 'PATH_OUTSIDE_ROOT');
+    await runtime.close();
+    console.log('pr-consumer-contract-test PASS');
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/project-control-panel-task14-test.js

@@ -0,0 +1,63 @@
+const assert = require('assert');
+const os = require('os');
+const path = require('path');
+const { spawnServer } = require('./helpers/spawn-server');
+const { findChrome } = require('./helpers/find-chrome');
+const { launchCdpBrowser, requestJson, waitFor } = require('./helpers/cdp-browser');
+const { createLoggingUiFixture } = require('./helpers/logging-ui-fixture');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const sitePort = 8500 + (process.pid % 200);
+const profileDir = path.join(os.tmpdir(), 'pk-project-status-profile-' + process.pid);
+
+(async () => {
+  const fixture = await createLoggingUiFixture({ totalLogs: 8 });
+  const server = spawnServer({ root: ROOT, port: sitePort, dataDir: fixture.dataDir, tag: 'project-status-v13', stdio: 'ignore' });
+  let browser;
+  try {
+    await waitFor(() => requestJson(`http://127.0.0.1:${sitePort}/api/projects`).then(body => body.projects.length === 1), 'project API', 20000);
+    browser = await launchCdpBrowser({ chrome: findChrome(), profileDir, url: `http://127.0.0.1:${sitePort}/`, width: 1200, height: 860 });
+    await waitFor(() => browser.evaluate('window.__PK_APP__ && window.__PK_APP__.getState().projects === 1'), 'project shell');
+
+    const shell = await browser.evaluate(`(() => ({
+      projectButtons: document.querySelectorAll('#project-list .project-card').length,
+      selected: document.querySelector('#project-list .project-card.active')?.dataset.projectId,
+      name: document.querySelector('#project-list .project-card.active .project-name')?.textContent,
+      badges: document.querySelectorAll('#project-list .mbadge').length,
+      path: document.querySelector('#project-list .project-card.active .project-path')?.textContent,
+      terminalView: document.getElementById('view-terminal').classList.contains('active'),
+      manualControls: document.querySelectorAll('[data-install-hook], [data-uninstall-hook], [data-analyze], [data-simulate]').length,
+      mainConversationLinks: [...document.querySelectorAll('.sidebar-nav .nav-btn, .mobile-strip button')].filter(node => /开发对话|运行记录|系统日志/.test(node.textContent)).length
+    }))()`);
+    assert.strictEqual(shell.projectButtons, 1);
+    assert.strictEqual(shell.selected, fixture.projectId);
+    assert.strictEqual(shell.name, '视觉检测知识库');
+    // 三个模块徽章：端（Agent 终端）、检（vector-hub）、桥（会话浏览）
+    assert.strictEqual(shell.badges, 3);
+    assert(shell.path.includes(fixture.repo.path));
+    assert.strictEqual(shell.terminalView, true);
+    assert.strictEqual(shell.manualControls, 0);
+    assert.strictEqual(shell.mainConversationLinks, 0);
+
+    // 删除入口：右键项目卡 → 管理菜单 → 移除项目（原"知识库存储"设置节已按终版移除）
+    await browser.evaluate(`(() => {
+      const card = document.querySelector('#project-list .project-card');
+      card.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 300, clientY: 200 }));
+    })()`);
+    await waitFor(() => browser.evaluate("document.getElementById('context-menu').classList.contains('show')"), 'context menu');
+    await browser.evaluate("document.getElementById('remove-project').click()");
+    await waitFor(() => browser.evaluate("document.getElementById('delete-dialog').open"), 'delete modal');
+    assert((await browser.evaluate("document.getElementById('delete-copy').textContent")).includes('视觉检测知识库'));
+    await browser.evaluate("document.getElementById('delete-knowledge').click()");
+    assert.strictEqual(await browser.evaluate("document.getElementById('delete-confirm-field').hidden"), false, 'knowledge deletion needs explicit project-id confirmation');
+    assert.strictEqual(browser.exceptions.length, 0, 'browser runtime exceptions: ' + JSON.stringify(browser.exceptions));
+    console.log('project control panel task14 test PASS');
+  } finally {
+    if (browser) await browser.close();
+    await server.cleanup();
+    fixture.cleanup();
+  }
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/project-delete-recovery-test.js

@@ -0,0 +1,64 @@
+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 { ProjectLifecycleService } = require('../lib/project-lifecycle-service');
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-delete-recovery-'));
+  const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
+  const registry = new ProjectRegistryStore({ layout });
+  const projects = new ProjectStore({ layout });
+  await registry.initialize();
+  const faultPoints = [
+    'delete-tombstoned',
+    'delete-before-hook', 'delete-after-hook',
+    'delete-before-registry', 'delete-after-registry',
+    'delete-before-metadata', 'delete-after-metadata',
+    'delete-before-knowledge', 'delete-after-knowledge',
+    'delete-before-completed',
+  ];
+  const hooks = {
+    uninstallHook({ projectId }) { return { ok: true, removed: true, projectId }; },
+  };
+  for (let index = 0; index < faultPoints.length; index += 1) {
+    const projectId = `project-delete-${String(index).padStart(2, '0')}`;
+    const repoPath = path.join(root, 'repos', projectId);
+    const knowledgePath = path.join(root, 'knowledge', projectId);
+    fs.mkdirSync(repoPath, { recursive: true });
+    fs.mkdirSync(knowledgePath, { recursive: true });
+    fs.writeFileSync(path.join(knowledgePath, 'README.md'), '# User knowledge\n', 'utf8');
+    await projects.create(projectId, { displayName: projectId, storageName: projectId, repoPath, knowledgePath });
+    await registry.add(projectId, { displayNameSnapshot: projectId });
+    let injected = false;
+    const failing = new ProjectLifecycleService({
+      layout, registryStore: registry, projectStore: projects, hookManager: hooks,
+      fault(point) {
+        if (!injected && point === faultPoints[index]) { injected = true; throw new Error(`fault:${point}`); }
+      },
+    });
+    await assert.rejects(
+      failing.deleteProject(projectId, { deleteKnowledge: true, confirmationToken: projectId }),
+      error => /fault:|can be retried/.test(error.message),
+      `fault ${faultPoints[index]} must stop the first attempt`,
+    );
+    assert(fs.existsSync(failing.deleteTransactionPath(projectId)), 'a durable tombstone must exist before any externally visible mutation');
+
+    const recovery = new ProjectLifecycleService({ layout, registryStore: registry, projectStore: projects, hookManager: hooks });
+    const recovered = await recovery.deleteProject(projectId, { deleteKnowledge: true, confirmationToken: projectId });
+    assert.strictEqual(recovered.ok, true, `fault ${faultPoints[index]} must recover on retry`);
+    assert(!registry.listIds().includes(projectId));
+    assert(!fs.existsSync(layout.getProjectMetadataDir(projectId)));
+    assert(!fs.existsSync(knowledgePath));
+    const journal = recovery.readDeleteJournal(projectId);
+    assert.strictEqual(journal.phase, 'completed');
+    assert(Object.values(journal.steps).every(step => step.completed), 'every delete step must be durably terminal');
+  }
+  console.log('project-delete-recovery-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/project-goal-editor-test.js

@@ -0,0 +1,145 @@
+// _site/_test/project-goal-editor-test.js
+//
+// T13: Project Goal editor.
+//   GET /api/projects/:id/goal  -> read GOAL.md from project knowledge path
+//   PUT /api/projects/:id/goal  -> atomic write GOAL.md
+// Verifies:
+//   - missing GOAL.md returns exists=false;
+//   - PUT creates the file atomically;
+//   - subsequent GET returns the persisted content;
+//   - empty content allowed (no auto-template);
+//   - the file is scoped to the project's own knowledgePath (no
+//     cross-project writes);
+//   - 413 when content exceeds 256KB.
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { spawnServer } = require('./helpers/spawn-server');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const sitePort = 8000 + (process.pid % 200);
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-goal-' + process.pid + '-'));
+const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-goal-repo-' + process.pid + '-'));
+
+function git(args) {
+  const result = spawnSync('git', ['-C', repo, ...args], {
+    encoding: 'utf8', windowsHide: true,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+  });
+  if (result.status !== 0) throw new Error(result.stderr || `git ${args.join(' ')} failed: ${result.status}`);
+  return String(result.stdout || '').trim();
+}
+
+async function serverFetch(url, init, timeoutMs = 10000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    const text = await response.text();
+    return { status: response.status, body: text ? JSON.parse(text) : {} };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+(async () => {
+  git(['init', '-q', '-b', 'main']);
+  git(['config', 'user.email', 'goal@example.local']);
+  git(['config', 'user.name', 'Goal']);
+  fs.writeFileSync(path.join(repo, 'README.md'), '# goal\n');
+  git(['add', 'README.md']);
+  git(['commit', '-q', '-m', 'baseline']);
+  const knowledgeRoot = path.join(dataDir, 'knowledge');
+  fs.mkdirSync(knowledgeRoot, { recursive: true });
+  const server = spawnServer({
+    root: ROOT, port: sitePort, dataDir, tag: 'goal',
+    extraEnv: { KB_AUTOMATION_FAKE_CLAUDE: '1', KB_EMBEDDING_FAKE: '1', KB_SKIP_MIGRATION: '1' },
+  });
+  try {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+      try { const r = await serverFetch(`http://127.0.0.1:${sitePort}/api/health`); if (r.body.ok) break; } catch {}
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    await serverFetch(`http://127.0.0.1:${sitePort}/api/settings`, {
+      method: 'PATCH', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ knowledge: { rootPath: knowledgeRoot } }),
+    });
+    await serverFetch(`http://127.0.0.1:${sitePort}/api/ai-profiles`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        schema: 'ai-profiles/v1', defaultProfileId: 'fake',
+        profiles: [{ id: 'fake', name: 'Fake', enabled: true, vendor: 'anthropic', model: 'fake', apiKeyUpdate: { mode: 'replace', value: 'k' } }],
+      }),
+    });
+    const importR = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/import`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ localPath: repo, aiProfileId: 'fake' }),
+    });
+    assert.strictEqual(importR.status, 201, JSON.stringify(importR.body));
+    const projectId = importR.body.projectId;
+    const knowledgePath = importR.body.config.knowledgePath;
+
+    // Case 1: GET on missing GOAL.md returns exists=false
+    let r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, undefined);
+    assert.strictEqual(r.status, 200);
+    assert.strictEqual(r.body.exists, false);
+    assert.strictEqual(r.body.content, '');
+
+    // Case 2: PUT creates the file atomically with the supplied content
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: '# Project Goal\n\nBuild a knowledge base for v4.1.22 -> main recovery.\n' }),
+    });
+    assert.strictEqual(r.status, 200, JSON.stringify(r.body));
+    const goalPath = path.join(knowledgePath, 'GOAL.md');
+    assert(fs.existsSync(goalPath), 'GOAL.md must be created');
+    assert(fs.readFileSync(goalPath, 'utf8').includes('v4.1.22'), 'goal content must include the user-supplied text');
+
+    // Case 3: GET now returns the persisted content
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, undefined);
+    assert.strictEqual(r.status, 200);
+    assert.strictEqual(r.body.exists, true);
+    assert(r.body.content.includes('v4.1.22'));
+
+    // Case 4: empty content is allowed (no auto-template)
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: '' }),
+    });
+    assert.strictEqual(r.status, 200);
+    assert.strictEqual(fs.readFileSync(goalPath, 'utf8'), '', 'empty content must clear the file');
+
+    // Case 5: writes are scoped to the project's own knowledgePath
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: 'real content\n' }),
+    });
+    assert.strictEqual(r.status, 200);
+    const otherFiles = fs.readdirSync(knowledgePath).filter(name => name !== 'GOAL.md');
+    assert.deepStrictEqual(otherFiles, [], 'only GOAL.md must be created in the project knowledge path');
+
+    // Case 6: 413 when content exceeds 256KB
+    const huge = 'x'.repeat(257 * 1024);
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: huge }),
+    });
+    assert.strictEqual(r.status, 413);
+
+    // Case 7: GET on a non-existent project returns 404
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/does-not-exist/goal`, undefined);
+    assert.strictEqual(r.status, 404);
+  } finally {
+    server.child.kill();
+    await new Promise(resolve => server.child.once('exit', resolve));
+    fs.rmSync(dataDir, { recursive: true, force: true });
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+  console.log('project-goal-editor-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});