project-knowledge 0.1.0

package/_site/_test/commit-analysis-test.js

@@ -0,0 +1,184 @@
+// TASK-008: Incremental commit analysis test
+// Run: node _site/_test/commit-analysis-test.js
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo, git } = require('./fixtures/make-git-repos');
+const { runCommitAnalysis, readRun, listDrafts } = require('../lib/analysis-orchestrator');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const PORT = process.env.KB_COMMIT_TEST_PORT || '7798';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_SLUG = 'task-008-temp';
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+
+async function waitForServer() {
+  const deadline = Date.now() + 15000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${BASE_URL}/api/state`);
+      if (res.ok) return;
+      lastError = new Error(`HTTP ${res.status}`);
+    } catch (e) { lastError = e; }
+    await new Promise(r => setTimeout(r, 250));
+  }
+  throw lastError || new Error('server did not start');
+}
+
+async function json(method, url, body) {
+  const res = await fetch(`${BASE_URL}${url}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let data = {};
+  if (text) { try { data = JSON.parse(text); } catch { data = { raw: text }; } }
+  return { res, data };
+}
+
+async function cleanup() {
+  const base = path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.rmSync(base, { recursive: true, force: true });
+  const cur = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+  if (cur[TEMP_SLUG]) {
+    delete cur[TEMP_SLUG];
+    fs.writeFileSync(PROJECTS_JSON, JSON.stringify(cur, null, 2) + '\n', 'utf-8');
+  }
+}
+
+(async () => {
+  // Unit: feature commit creates feature + change drafts
+  const repo = makeRepo({ kind: 'feature-commit' });
+  const kbBase = path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.mkdirSync(kbBase, { recursive: true });
+  fs.writeFileSync(path.join(kbBase, 'project-goal.md'), '# Goal — preserve\n');
+  fs.mkdirSync(path.join(kbBase, 'features'), { recursive: true });
+
+  const project = {
+    slug: TEMP_SLUG,
+    kbPath: kbBase,
+    gitPath: repo.path,
+    localPath: repo.path,
+    aiProfileId: 'mock-agent',
+  };
+
+  let r = await runCommitAnalysis(project);
+  assert(r.ok, `commit analysis should succeed: ${r.error || ''}`);
+  assert(r.runRecord.commitCount === 2, 'fixture has 2 commits, run should see 2');
+  assert(r.runRecord.status === 'succeeded', 'run should be succeeded');
+
+  // 1. New-feature commit (the second of the two) should produce a feature draft
+  const drafts = listDrafts(kbBase, r.runId);
+  const changeDrafts = drafts.filter(d => d.path.startsWith('changes/'));
+  const featureDrafts = drafts.filter(d => d.path.startsWith('features/'));
+  assert(changeDrafts.length === 2, `expected 2 change drafts, got ${changeDrafts.length}`);
+  assert(featureDrafts.length >= 1, `expected at least 1 feature draft, got ${featureDrafts.length}`);
+
+  // 2. Existing pre-existing project-goal.md is preserved
+  const goalText = fs.readFileSync(path.join(kbBase, 'project-goal.md'), 'utf-8');
+  assert(goalText.includes('preserve'), 'pre-existing project-goal.md must not be overwritten');
+
+  // 3. lastAnalyzedCommit is unchanged in the project input
+  assert(r.runRecord.lastAnalyzedCommitBefore === null, 'before-state was null');
+
+  // 4. Refactor commit explains architecture impact
+  const repo2 = makeRepo({ kind: 'refactor-commit' });
+  const kbBase2 = path.join(ROOT, 'projects', TEMP_SLUG + '-refactor');
+  fs.mkdirSync(kbBase2, { recursive: true });
+  fs.writeFileSync(path.join(kbBase2, 'project-goal.md'), '# Goal\n');
+  const project2 = { ...project, slug: TEMP_SLUG + '-refactor', kbPath: kbBase2, gitPath: repo2.path, localPath: repo2.path };
+  r = await runCommitAnalysis(project2);
+  assert(r.ok, 'refactor analysis should succeed');
+  const refactorChanges = (r.runRecord.drafts || []).filter(d => d.path.startsWith('changes/'));
+  assert(refactorChanges.length === 2, 'should draft both refactor commits');
+  // The refactor's change draft should reference architecture or modules
+  const changePath = path.join(kbBase2, '_ai', 'drafts', r.runId, 'changes', `${(repo2.commits[0].short || repo2.commits[0].hash).slice(0, 7)}.md`);
+  if (fs.existsSync(changePath)) {
+    const txt = fs.readFileSync(changePath, 'utf-8');
+    assert(txt.includes('classification') || txt.includes('refactor') || txt.includes('AI Proposal'),
+      'refactor change draft should reference classification');
+  }
+  repo2.cleanup();
+  fs.rmSync(kbBase2, { recursive: true, force: true });
+
+  // 5. Test-only commit does NOT invent a user feature
+  const repo3 = makeRepo({ kind: 'pure-test-only' });
+  const kbBase3 = path.join(ROOT, 'projects', TEMP_SLUG + '-test');
+  fs.mkdirSync(kbBase3, { recursive: true });
+  fs.writeFileSync(path.join(kbBase3, 'project-goal.md'), '# Goal\n');
+  const project3 = { ...project, slug: TEMP_SLUG + '-test', kbPath: kbBase3, gitPath: repo3.path, localPath: repo3.path };
+  r = await runCommitAnalysis(project3);
+  assert(r.ok, 'test analysis should succeed');
+  const testFeatureDrafts = listDrafts(kbBase3, r.runId).filter(d => d.path.startsWith('features/'));
+  assert(testFeatureDrafts.length === 0, `test-only commit must NOT produce a feature draft, got ${testFeatureDrafts.length}`);
+  repo3.cleanup();
+  fs.rmSync(kbBase3, { recursive: true, force: true });
+
+  // 6. Failed analysis leaves lastAnalyzedCommit unchanged
+  // We can't easily make the mock fail; simulate by giving an invalid project path.
+  const badProject = { ...project, gitPath: 'D:\\__no_such_repo__' };
+  r = await runCommitAnalysis(badProject);
+  assert(!r.ok, 'bad git path should fail');
+  // The bad project's projects.json is untouched.
+
+  repo.cleanup();
+  fs.rmSync(kbBase, { recursive: true, force: true });
+
+  // 7. Server tests
+  const child = spawn(process.execPath, [SERVER], {
+    cwd: ROOT,
+    env: { ...process.env, KB_SITE_PORT: PORT, KB_SITE_HOST: '127.0.0.1' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+  let serverOutput = '';
+  child.stdout.on('data', d => { serverOutput += d.toString(); });
+  child.stderr.on('data', d => { serverOutput += d.toString(); });
+
+  try {
+    await cleanup();
+    await waitForServer();
+
+    const repo4 = makeRepo({ kind: 'multi-commit' });
+    const slug = TEMP_SLUG;
+    const kbPath = path.join(ROOT, 'projects', slug);
+    fs.mkdirSync(kbPath, { recursive: true });
+    fs.writeFileSync(path.join(kbPath, 'project-goal.md'), '# Goal — server\n');
+
+    r = await json('PUT', '/api/projects', {
+      slug,
+      config: { displayName: 'TASK-008', localPath: repo4.path, gitPath: repo4.path, kbPath },
+    });
+    assert(r.res.ok, 'upsert should succeed');
+
+    r = await json('POST', `/api/projects/${slug}/analyze/commits`, {});
+    assert(r.res.ok, `analyze commits should succeed: ${JSON.stringify(r.data)}`);
+    assert(r.data.runId, 'should return runId');
+    assert(r.data.run && r.data.run.status === 'succeeded', 'run should succeed');
+    const serverRunId = r.data.runId;
+
+    // Drafts should be on disk
+    r = await json('GET', `/api/projects/${slug}/drafts/${serverRunId}`);
+    assert(r.res.ok, 'list drafts should succeed');
+    assert(r.data.drafts.length >= 3, `expected 3+ drafts (2 changes + 1 feature), got ${r.data.drafts.length}`);
+
+    // 8. Bad slug
+    r = await json('POST', '/api/projects/INVALID../analyze/commits', {});
+    assert(!r.res.ok && r.res.status === 400, 'bad slug should 400');
+
+    repo4.cleanup();
+    console.log('TASK-008 commit analysis test passed');
+  } catch (e) {
+    console.error('TASK-008 commit analysis test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    await cleanup().catch(() => {});
+    child.kill();
+  }
+})();

package/_site/_test/context-pack-test.js

@@ -0,0 +1,199 @@
+// TASK-006: Context pack builder test
+// Run: node _site/_test/context-pack-test.js
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo, git } = require('./fixtures/make-git-repos');
+const { buildContextPack, isSafePath, PACKAGE_CONFIG_FILES } = require('../lib/context-pack-builder');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const PORT = process.env.KB_CTX_TEST_PORT || '7796';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_SLUG = 'task-006-temp';
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+
+async function waitForServer() {
+  const deadline = Date.now() + 15000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${BASE_URL}/api/state`);
+      if (res.ok) return;
+      lastError = new Error(`HTTP ${res.status}`);
+    } catch (e) { lastError = e; }
+    await new Promise(r => setTimeout(r, 250));
+  }
+  throw lastError || new Error('server did not start');
+}
+
+async function json(method, url, body) {
+  const res = await fetch(`${BASE_URL}${url}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let data = {};
+  if (text) { try { data = JSON.parse(text); } catch { data = { raw: text }; } }
+  return { res, data };
+}
+
+async function cleanup() {
+  const base = path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.rmSync(base, { recursive: true, force: true });
+  const cur = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+  if (cur[TEMP_SLUG]) {
+    delete cur[TEMP_SLUG];
+    fs.writeFileSync(PROJECTS_JSON, JSON.stringify(cur, null, 2) + '\n', 'utf-8');
+  }
+}
+
+(async () => {
+  // 1. Path safety
+  assert(isSafePath('/tmp/proj', 'a/b.md'), 'safe path should pass');
+  assert(!isSafePath('/tmp/proj', '../escape.md'), 'parent traversal should fail');
+  assert(!isSafePath('/tmp/proj', '/etc/passwd'), 'absolute outside should fail');
+  // Sibling that is not a sub-path: resolve it relative to the project root and check.
+  const siblingResolved = require('path').resolve('/tmp/proj', '../proj-other/x.md');
+  assert(!siblingResolved.startsWith('/tmp/proj/') && siblingResolved !== '/tmp/proj',
+    'sibling-of-project should not pass when constructed as a traversal');
+  assert(Array.isArray(PACKAGE_CONFIG_FILES) && PACKAGE_CONFIG_FILES.includes('package.json'), 'package config list ok');
+
+  // 2. Unit test: build a context pack for a feature-commit fixture
+  const repo = makeRepo({ kind: 'feature-commit' });
+  const kbBase = path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.mkdirSync(kbBase, { recursive: true });
+  // Lay down v2 structure with project-goal.md and a feature doc that references a changed file
+  fs.mkdirSync(path.join(kbBase, 'features'), { recursive: true });
+  fs.mkdirSync(path.join(kbBase, 'modules'), { recursive: true });
+  fs.writeFileSync(path.join(kbBase, 'project-goal.md'), '# Goal — test\n\nGoal text for tests.\n');
+  fs.writeFileSync(path.join(kbBase, 'project-analysis.md'), '# Analysis — test\n');
+  fs.writeFileSync(path.join(kbBase, 'features', 'feature.md'), 'See `src/feature.ts` for the implementation.\n');
+  fs.writeFileSync(path.join(kbBase, 'README.md'), '# Project — test\n');
+  // package.json lives in the source repo (the fixture already has a src/, but no package.json)
+  fs.writeFileSync(path.join(repo.path, 'package.json'), '{"name":"fixture"}');
+
+  const commits = repo.commits.slice().reverse(); // chronological
+  const pack = await buildContextPack({
+    project: {
+      slug: TEMP_SLUG,
+      kbPath: kbBase,
+      gitPath: repo.path,
+      localPath: repo.path,
+    },
+    runId: 'run-unit-1',
+    trigger: 'commits',
+    commits,
+  });
+
+  assert(pack.schema === 'context-pack/v1', 'pack schema should be v1');
+  assert(pack.runId === 'run-unit-1', 'runId should be honored');
+  assert(pack.trigger === 'commits', 'trigger should be commits');
+  assert(pack.commitCount === commits.length, 'commitCount should match');
+  assert(pack.range, 'range should be set');
+
+  // Required entries
+  const goalEntry = pack.entries.find(e => e.path === 'project-goal.md');
+  assert(goalEntry, 'pack should include project-goal.md');
+  assert(goalEntry.kind === 'goal', 'goal entry kind should be goal');
+  assert(goalEntry.reason, 'goal entry should have a reason');
+  const pkg = pack.entries.find(e => e.path === 'package.json');
+  assert(pkg && pkg.kind === 'package-config', 'pack should include package.json as package-config');
+  const changed = pack.entries.find(e => e.path === 'src/feature.ts');
+  assert(changed && changed.kind === 'git-changed', 'pack should include changed file src/feature.ts');
+  const related = pack.entries.find(e => e.path === 'features/feature.md');
+  assert(related && related.kind === 'feature-doc', 'pack should include related feature doc');
+  // Every entry must have a reason
+  for (const e of pack.entries) {
+    assert(typeof e.reason === 'string' && e.reason.length > 0, `entry ${e.path} missing reason`);
+  }
+
+  // Disk artifacts
+  const onDisk = JSON.parse(fs.readFileSync(path.join(kbBase, '_ai', 'context-packs', 'run-unit-1', 'context-pack.json'), 'utf-8'));
+  assert(onDisk.runId === 'run-unit-1', 'on-disk runId should match');
+
+  // 3. Large / binary file is summarized or skipped
+  const repo2 = makeRepo({ kind: 'binary-commit' });
+  const kbBase2 = path.join(ROOT, 'projects', TEMP_SLUG + '-2');
+  fs.mkdirSync(kbBase2, { recursive: true });
+  fs.writeFileSync(path.join(kbBase2, 'project-goal.md'), '# Goal\n');
+  const commits2 = repo2.commits.slice().reverse();
+  const pack2 = await buildContextPack({
+    project: { slug: TEMP_SLUG + '-2', kbPath: kbBase2, gitPath: repo2.path, localPath: repo2.path },
+    runId: 'run-binary-1',
+    trigger: 'commits',
+    commits: commits2,
+  });
+  const big = pack2.entries.find(e => e.path === 'big.bin');
+  if (big) {
+    assert(big.binary || big.skipped === 'too-large' || big.truncated, 'big file should be marked binary/skipped/truncated');
+  }
+  fs.rmSync(kbBase2, { recursive: true, force: true });
+  repo2.cleanup();
+
+  // 4. Path-traversal attempt is rejected
+  const ok = isSafePath(kbBase, '..\\..\\escape.md');
+  // On Windows, ..\\ becomes normalized. The resolved path should still be inside kbBase.
+  // Test the explicit scenario:
+  assert(!isSafePath(kbBase, '..\\..\\..\\..\\Windows\\evil.txt') || path.resolve(kbBase, '..\\..\\..\\..\\Windows\\evil.txt').startsWith(path.resolve(kbBase)),
+    'path traversal must be rejected');
+
+  repo.cleanup();
+
+  // 5. Server tests
+  assert(fs.existsSync(SERVER), 'server.js missing');
+  JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+  const child = spawn(process.execPath, [SERVER], {
+    cwd: ROOT,
+    env: { ...process.env, KB_SITE_PORT: PORT, KB_SITE_HOST: '127.0.0.1' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+  let serverOutput = '';
+  child.stdout.on('data', d => { serverOutput += d.toString(); });
+  child.stderr.on('data', d => { serverOutput += d.toString(); });
+
+  try {
+    await cleanup();
+    await waitForServer();
+
+    // 6. POST /api/projects/:slug/context-pack for an initial pack
+    const initRepo = makeRepo({ kind: 'one-commit' });
+    const slug = TEMP_SLUG;
+    const kbPath = path.join(ROOT, 'projects', slug);
+    fs.mkdirSync(kbPath, { recursive: true });
+    fs.writeFileSync(path.join(kbPath, 'project-goal.md'), '# Goal — server test\n');
+
+    r = await json('PUT', '/api/projects', {
+      slug,
+      config: { displayName: 'TASK-006', localPath: initRepo.path, gitPath: initRepo.path, kbPath },
+    });
+    assert(r.res.ok, 'upsert should succeed');
+
+    r = await json('POST', `/api/projects/${slug}/context-pack`, { trigger: 'initial' });
+    assert(r.res.ok, 'context-pack initial should succeed');
+    assert(r.data.contextPack.entries.length > 0, 'context pack should have entries');
+    assert(r.data.contextPack.entries.find(e => e.path === 'project-goal.md'), 'goal should be in pack');
+
+    r = await json('POST', `/api/projects/${slug}/context-pack`, { trigger: 'commits' });
+    assert(r.res.ok, 'context-pack commits should succeed');
+    assert(r.data.contextPack.commitCount > 0, 'commits trigger should report commits');
+
+    // 7. Bad slug
+    r = await json('POST', '/api/projects/INVALID../context-pack', {});
+    assert(!r.res.ok && r.res.status === 400, 'bad slug should 400');
+
+    initRepo.cleanup();
+    console.log('TASK-006 context pack test passed');
+  } catch (e) {
+    console.error('TASK-006 context pack test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    await cleanup().catch(() => {});
+    child.kill();
+  }
+})();