project-knowledge 0.1.0 → 1.0.1

package/_site/_test/task15-20-integration-test.js

@@ -0,0 +1,194 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo } = require('./fixtures/make-git-repos');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const KNOWLEDGE_STORE_JSON = path.join(ROOT, 'knowledge-store.json');
+const LOGGING_JSON = path.join(ROOT, 'logging.json');
+const PORT = process.env.KB_TASK_15_20_PORT || '7820';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_ROOT = path.join(ROOT, '.tmp-task-15-20');
+const SLUG = 'task-015-020-temp';
+const LEGACY_SLUG = 'task-020-legacy-temp';
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+function backup(file) { return fs.existsSync(file) ? fs.readFileSync(file, 'utf-8') : null; }
+function restore(file, content) {
+  if (content == null) fs.rmSync(file, { force: true });
+  else fs.writeFileSync(file, content, 'utf-8');
+}
+async function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+async function rmWithRetry(target) {
+  for (let i = 0; i < 8; i++) {
+    try { fs.rmSync(target, { recursive: true, force: true }); return; }
+    catch (e) { if (i === 7) throw e; await sleep(250); }
+  }
+}
+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 sleep(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 () => {
+  const projectsBackup = backup(PROJECTS_JSON);
+  const storeBackup = backup(KNOWLEDGE_STORE_JSON);
+  const loggingBackup = backup(LOGGING_JSON);
+  fs.rmSync(TEMP_ROOT, { recursive: true, force: true });
+  fs.mkdirSync(TEMP_ROOT, { recursive: true });
+  const kbRoot = path.join(TEMP_ROOT, 'knowledge');
+  const logsRoot = path.join(TEMP_ROOT, 'logs');
+  const aiRoot = path.join(ROOT, '_site', '_ai');
+  fs.rmSync(path.join(aiRoot, SLUG), { recursive: true, force: true });
+  fs.rmSync(path.join(aiRoot, LEGACY_SLUG), { recursive: true, force: true });
+
+  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(); });
+
+  let repo = null;
+  try {
+    await waitForServer();
+    let r = await json('PUT', '/api/knowledge-store/config', { rootPath: kbRoot, git: { enabled: false } });
+    assert(r.res.ok, 'knowledge-store config should save');
+    r = await json('PUT', '/api/logging/config', { rootPath: logsRoot, retentionDays: 14 });
+    assert(r.res.ok, 'logging config should save');
+
+    repo = makeRepo({ kind: 'feature-commit' });
+    r = await json('PUT', '/api/projects', {
+      slug: SLUG,
+      config: {
+        displayName: 'TASK 015-020 Temp',
+        localPath: repo.path,
+        gitPath: repo.path,
+        aiProfileId: 'mock-agent',
+        goalStatus: 'accepted',
+        kbSchemaVersion: 'v3',
+      },
+    });
+    assert(r.res.ok, 'project import should succeed');
+
+    r = await json('POST', `/api/projects/${SLUG}/init`);
+    assert(r.res.ok && r.data.kbSchemaVersion === 'v3', 'init should create v3 KB');
+    const projects = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+    const kbPath = projects[SLUG].kbPath;
+    const top = fs.readdirSync(kbPath).filter(name => !name.startsWith('.')).sort();
+    assert(JSON.stringify(top) === JSON.stringify(['ARCHITECTURE.md', 'GOAL.md', 'README.md', 'changes', 'modules']), `unexpected v3 top-level: ${top.join(', ')}`);
+    assert(!fs.existsSync(path.join(kbPath, '_ai')), 'v3 KB must not contain _ai');
+    assert(!fs.existsSync(path.join(kbPath, 'kb-manifest.json')), 'v3 KB must not contain manifest');
+
+    r = await json('POST', `/api/projects/${SLUG}/validate-kb`);
+    assert(r.res.ok && r.data.ok, `v3 validate should pass: ${JSON.stringify(r.data)}`);
+    r = await json('GET', `/api/projects/${SLUG}/pr-context`);
+    assert(r.res.ok && r.data.pack && r.data.pack.goal.path === 'GOAL.md', 'PR context should read V3 GOAL');
+
+    r = await json('POST', `/api/projects/${SLUG}/analyze/commits`);
+    assert(r.res.ok, `commit analysis should pass: ${JSON.stringify(r.data)}`);
+    const runId = r.data.runId;
+    assert(r.data.run.sourceBranch !== undefined, 'run should include sourceBranch key');
+    assert(r.data.run.sourceDefaultBranch !== undefined, 'run should include sourceDefaultBranch key');
+    assert(r.data.run.sourceRemote !== undefined, 'run should include sourceRemote key');
+    assert(fs.existsSync(path.join(aiRoot, SLUG, 'runs', `${runId}.json`)), 'run should live in _site/_ai/<slug>');
+    assert(fs.existsSync(path.join(aiRoot, SLUG, 'context-packs', runId, 'context-pack.json')), 'context pack should live in _site/_ai/<slug>');
+
+    const branch = r.data.run.sourceBranch || 'unknown (pre-TASK-016)';
+    r = await json('GET', `/api/projects/${SLUG}/drafts-by-branch?branch=${encodeURIComponent(branch)}`);
+    assert(r.res.ok && r.data.drafts.length > 0, 'drafts-by-branch should return branch drafts');
+    assert(r.data.drafts.every(d => d.sourceBranch === branch), 'drafts-by-branch should filter by branch');
+
+    const payloads = [];
+    for (const d of r.data.drafts.filter(d => d.path.startsWith('changes/'))) {
+      const raw = await json('GET', `/api/projects/${SLUG}/drafts/${d.runId}/raw?path=${encodeURIComponent(d.path)}`);
+      assert(raw.res.ok, `raw draft should load: ${d.path}`);
+      payloads.push({ path: d.path, content: raw.data.content, sourceBranch: d.sourceBranch, sourceHeadCommit: d.sourceHeadCommit });
+    }
+    assert(payloads.length > 0, 'should have changes draft payloads');
+    r = await json('POST', `/api/projects/${SLUG}/drafts/${runId}/apply`, { drafts: payloads, allowGoalEdit: false });
+    assert(r.res.ok && r.data.applied.length === payloads.length, 'V3 changes drafts should auto-apply');
+    const applied = fs.readFileSync(path.join(kbPath, payloads[0].path), 'utf-8');
+    assert(applied.includes('sourceBranch:'), 'applied V3 doc should include sourceBranch');
+    assert(fs.existsSync(path.join(kbPath, 'changes', '00-index.md')), 'changes index should regenerate');
+
+    r = await json('POST', `/api/projects/${SLUG}/drafts/${runId}/apply`, {
+      drafts: [{ path: 'GOAL.md', content: '# bad silent goal edit' }],
+      allowGoalEdit: false,
+    });
+    assert(!r.res.ok && r.res.status === 409, 'GOAL.md apply should require review');
+
+    const legacyKb = path.join(kbRoot, LEGACY_SLUG);
+    fs.mkdirSync(path.join(legacyKb, '_ai', 'runs'), { recursive: true });
+    fs.mkdirSync(path.join(legacyKb, 'commits'), { recursive: true });
+    fs.writeFileSync(path.join(legacyKb, 'README.md'), '# legacy\n');
+    fs.writeFileSync(path.join(legacyKb, 'project-goal.md'), '# legacy goal\n');
+    fs.writeFileSync(path.join(legacyKb, '_ai', 'runs', 'old.json'), '{"schema":"ai-run/v1"}\n');
+    for (let i = 0; i < 6; i++) fs.writeFileSync(path.join(legacyKb, 'commits', `2026-01-0${i + 1}_aaaaaa${i}_test.md`), `# commit ${i}\n`);
+    r = await json('PUT', '/api/projects', { slug: LEGACY_SLUG, config: { displayName: 'legacy', localPath: repo.path, gitPath: repo.path, kbPath: legacyKb, kbSchemaVersion: 'v2' } });
+    assert(r.res.ok, 'legacy project import should succeed');
+    r = await json('POST', `/api/projects/${LEGACY_SLUG}/migrate-v3`);
+    assert(r.res.ok, `migrate-v3 should pass: ${JSON.stringify(r.data)}`);
+    assert(!fs.existsSync(path.join(legacyKb, '_ai')), 'migrate-v3 should remove KB-local _ai');
+    assert(!fs.existsSync(path.join(legacyKb, 'commits')), 'migrate-v3 should remove legacy commits dir');
+    assert(fs.existsSync(path.join(aiRoot, LEGACY_SLUG, 'legacy-commits')), 'legacy commits should be backed up to app AI workspace');
+    assert(fs.readdirSync(path.join(legacyKb, 'changes')).some(name => /^legacy-change-/.test(name)), 'legacy commits should consolidate into changes');
+
+    r = await json('GET', `/api/projects/${SLUG}/remove-preview`);
+    assert(r.res.ok && r.data.preview.fileCount > 0, 'remove preview should include file count');
+    r = await json('POST', `/api/projects/${SLUG}/remove`, { deleteKb: false, reason: 'integration soft remove' });
+    assert(r.res.ok && r.data.removedKb === false, 'soft remove should not delete KB');
+    assert(fs.existsSync(kbPath), 'soft remove should keep KB on disk');
+    r = await json('PUT', '/api/projects', { slug: SLUG, config: { displayName: 'reimport', localPath: repo.path, gitPath: repo.path, kbPath, kbSchemaVersion: 'v3' } });
+    assert(r.res.ok, 'reimport after soft remove should work');
+    r = await json('POST', `/api/projects/${SLUG}/remove`, { deleteKb: true, reason: 'integration hard remove' });
+    assert(r.res.ok && r.data.removedKb === true, 'hard remove should delete KB');
+    assert(!fs.existsSync(kbPath), 'hard remove should remove KB path');
+
+    const logFiles = fs.readdirSync(logsRoot).filter(name => name.endsWith('.log'));
+    assert(logFiles.length > 0, 'structured log should be written');
+    const logText = logFiles.map(file => fs.readFileSync(path.join(logsRoot, file), 'utf-8')).join('\n');
+    assert(logText.includes('project_removed'), 'project removal should be logged');
+
+    console.log('TASK-015..020 integration test passed');
+  } catch (e) {
+    console.error('TASK-015..020 integration test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    child.kill();
+    await sleep(500);
+    try { if (repo && repo.cleanup) repo.cleanup(); } catch {}
+    restore(PROJECTS_JSON, projectsBackup);
+    restore(KNOWLEDGE_STORE_JSON, storeBackup);
+    restore(LOGGING_JSON, loggingBackup);
+    fs.rmSync(path.join(aiRoot, SLUG), { recursive: true, force: true });
+    fs.rmSync(path.join(aiRoot, LEGACY_SLUG), { recursive: true, force: true });
+    await rmWithRetry(TEMP_ROOT).catch(() => {});
+  }
+})();

package/_site/_test/task15-20-ui-flow-test.js

@@ -0,0 +1,144 @@
+// UI flow coverage for TASK-015..020.
+// Uses a real Chromium via CDP and writes screenshots to _site/_test/ui-screenshots.
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const WebSocket = require('ws');
+
+const CHROME = 'C:\\Users\\SanQian\\AppData\\Local\\ms-playwright\\chromium-1223\\chrome-win64\\chrome.exe';
+const TARGET_URL = process.argv[2] || 'http://127.0.0.1:7777/';
+const OUT_DIR = path.join(__dirname, 'ui-screenshots');
+const PROFILE = path.join(OUT_DIR, 'task15-20-profile');
+const PORT = 9341;
+
+fs.mkdirSync(OUT_DIR, { recursive: true });
+fs.rmSync(PROFILE, { recursive: true, force: true });
+fs.mkdirSync(PROFILE, { recursive: true });
+
+function assert(cond, msg) { if (!cond) throw new Error('ASSERT: ' + msg); }
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, res => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(body)); } catch (e) { reject(e); }
+      });
+    }).on('error', reject);
+  });
+}
+async function waitFor(fn, label, ms = 15000) {
+  const deadline = Date.now() + ms;
+  let last;
+  while (Date.now() < deadline) {
+    try {
+      const got = await fn();
+      if (got) return got;
+    } catch (e) { last = e; }
+    await new Promise(resolve => setTimeout(resolve, 250));
+  }
+  throw new Error(`timeout: ${label}${last ? ` :: ${last.message}` : ''}`);
+}
+
+(async () => {
+  const child = spawn(CHROME, [
+    '--headless=new',
+    '--disable-gpu',
+    '--no-sandbox',
+    '--disable-dev-shm-usage',
+    `--remote-debugging-port=${PORT}`,
+    `--user-data-dir=${PROFILE}`,
+    '--window-size=1440,980',
+    'about:blank',
+  ], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+
+  const errors = [];
+  try {
+    const pages = await waitFor(() => fetchJson(`http://127.0.0.1:${PORT}/json/list`), 'chrome page list');
+    const page = pages.find(p => p.type === 'page') || pages[0];
+    const ws = new WebSocket(page.webSocketDebuggerUrl);
+    await new Promise((resolve, reject) => { ws.on('open', resolve); ws.on('error', reject); });
+
+    let nextId = 1;
+    const pending = new Map();
+    ws.on('message', m => {
+      const msg = JSON.parse(m.toString());
+      if (msg.id && pending.has(msg.id)) {
+        const { resolve, reject } = pending.get(msg.id);
+        pending.delete(msg.id);
+        if (msg.error) reject(new Error(msg.error.message));
+        else resolve(msg.result);
+      } else if (msg.method === 'Runtime.consoleAPICalled' && msg.params.type === 'error') {
+        errors.push((msg.params.args || []).map(arg => arg.value || arg.description || '').join(' '));
+      }
+    });
+    function send(method, params = {}) {
+      const id = nextId++;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        ws.send(JSON.stringify({ id, method, params }));
+      });
+    }
+    async function evalJs(expression) {
+      const r = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true });
+      return r.result.value;
+    }
+    async function screenshot(name) {
+      const r = await send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true });
+      const file = path.join(OUT_DIR, name);
+      fs.writeFileSync(file, Buffer.from(r.data, 'base64'));
+      return file;
+    }
+
+    await send('Runtime.enable');
+    await send('Page.enable');
+    await send('Network.enable');
+    await send('Page.navigate', { url: TARGET_URL });
+    await waitFor(() => evalJs('document.readyState === "complete"'), 'document ready');
+    await evalJs('localStorage.setItem("kb-ui-language", "en"); location.reload()');
+    await waitFor(() => evalJs('document.querySelector("#app") && document.querySelector("#app").innerText.includes("Project Supervision")'), 'app english dashboard');
+    await new Promise(resolve => setTimeout(resolve, 800));
+    const dashboardShot = await screenshot('task15-20-dashboard.png');
+
+    await evalJs(`[...document.querySelectorAll('button')].find(b => b.innerText.includes('Pending'))?.click()`);
+    await waitFor(() => evalJs('document.body.innerText.includes("Pending commit details")'), 'pending panel open');
+    const pendingItems = await evalJs('document.querySelectorAll("section details").length');
+    if (pendingItems > 0) assert(pendingItems > 0, 'pending panel should render collapsible details when it has items');
+    assert(!(await evalJs('document.body.innerText.includes("Project Operations")')), 'project detail should be hidden while summary panel is open');
+    const pendingShot = await screenshot('task15-20-pending-panel.png');
+
+    await evalJs(`[...document.querySelectorAll('button')].find(b => b.innerText.includes('Pending'))?.click()`);
+    await evalJs(`[...document.querySelectorAll('button')].find(b => b.innerText.includes('Recent issues') || b.innerText.includes('Issues'))?.click()`);
+    await waitFor(() => evalJs('document.body.innerText.includes("Issue center")'), 'issues panel open');
+    const issueGroups = await evalJs('document.querySelectorAll("section details").length');
+    if (await evalJs('!document.body.innerText.includes("No blocking issue detected.")')) {
+      assert(issueGroups > 0, 'issues panel should render per-project collapsible details when issues exist');
+    }
+
+    await evalJs(`document.querySelector('aside .min-h-0 button')?.click()`);
+    await waitFor(() => evalJs('!document.body.innerText.includes("Pending commit details") && !document.body.innerText.includes("Issue center")'), 'summary panel closes on project switch');
+
+    await evalJs(`[...document.querySelectorAll('button')].find(b => b.innerText.includes('Remove Project'))?.click()`);
+    await waitFor(() => evalJs('document.body.innerText.includes("Also delete KB files")'), 'remove modal open');
+    await waitFor(() => evalJs('document.body.innerText.includes("D:\\\\SanQian.Xu\\\\knowledge") && !document.body.innerText.includes("Not found")'), 'remove preview loaded');
+    assert(await evalJs('document.body.innerText.includes("KB path")'), 'remove modal should show KB path');
+    const removeShot = await screenshot('task15-20-remove-modal.png');
+    await evalJs(`[...document.querySelectorAll('button')].find(b => b.innerText.trim() === '×')?.click()`);
+
+    await evalJs(`[...document.querySelectorAll('button')].find(b => b.innerText.includes('Runs / Drafts'))?.click()`);
+    await waitFor(() => evalJs('document.body.innerText.includes("Runs and Drafts")'), 'runs view');
+    assert(await evalJs('document.body.innerText.includes("All branches") || document.querySelector("select")'), 'runs view should expose branch filtering controls when a run is selected or controls area exists');
+    const runsShot = await screenshot('task15-20-runs-view.png');
+
+    assert(errors.length === 0, `console errors: ${errors.join('\\n')}`);
+    console.log('TASK-015..020 UI flow test passed');
+    console.log(`screenshots:\n${dashboardShot}\n${pendingShot}\n${removeShot}\n${runsShot}`);
+  } catch (e) {
+    console.error('TASK-015..020 UI flow test failed:', e.message);
+    process.exitCode = 1;
+  } finally {
+    child.kill();
+  }
+})();

package/_site/_test/ui-smoke-test.js

@@ -210,10 +210,10 @@ function assert(cond, msg) {
     });
     await new Promise(resolve => setTimeout(resolve, 1000));
     r = await send('Runtime.evaluate', {
-      expression: '/Knowledge output language|知识库输出语言/.test(document.body.innerText)',
+      expression: '/Knowledge output language|知识库输出语言/.test(document.body.innerText) && /Test model|测试模型/.test(document.body.innerText) && /Base URL|Base 地址/.test(document.body.innerText)',
       returnByValue: true,
     });
-    assert(r.result.value, 'AI language setting did not render');
+    assert(r.result.value, 'AI model settings did not render');
 
     const shot = await send('Page.captureScreenshot', { format: 'png', fullPage: true });
     fs.writeFileSync(path.join(OUT_DIR, 'smoke-final.png'), Buffer.from(shot.data, 'base64'));