gsd-pi 2.82.0 → 3.0.0-dev.8b8d129d7

package/src/resources/extensions/gsd/tests/knowledge-capture.test.ts

@@ -0,0 +1,242 @@
+// ADR-013 Stage 2c — /gsd knowledge write-side redirect tests.
+//
+// Locks in four properties of captureKnowledgeEntry / nextKnowledgeId:
+//   1. Pattern entries write a memory row with category="pattern" and a
+//      sourceKnowledgeId marker — but do NOT touch KNOWLEDGE.md.
+//   2. Lesson entries write a memory row with category="gotcha" — same
+//      file-vs-memory split.
+//   3. Next-ID is monotonic across both surfaces: a P004 in the file plus a
+//      P007 in memories yields P008 next.
+//   4. The legacy appendKnowledge stays the canonical path for Rules
+//      (covered indirectly via no-memory side effect on type="rule").
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _getAdapter,
+  closeDatabase,
+  openDatabase,
+} from "../gsd-db.ts";
+import { captureKnowledgeEntry, nextKnowledgeId } from "../knowledge-capture.ts";
+import { knowledgeMdPath } from "../knowledge-parser.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-knowledge-capture-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function readMemoriesWithMarker(prefix: "P" | "L"): Array<{ category: string; sf: Record<string, unknown> }> {
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+  const rows = adapter
+    .prepare(
+      "SELECT category, structured_fields FROM memories WHERE structured_fields LIKE :pattern ORDER BY seq",
+    )
+    .all({ ":pattern": `%"sourceKnowledgeId":"${prefix}%` }) as Array<{
+    category: string;
+    structured_fields: string;
+  }>;
+  return rows.map((r) => ({ category: r.category, sf: JSON.parse(r.structured_fields) }));
+}
+
+// ─── Pattern path ───────────────────────────────────────────────────────────
+
+test("pattern entry creates a memory and assigns the next P### id", () => {
+  const base = makeTmpBase();
+  try {
+    const result = captureKnowledgeEntry(base, "pattern", "Repository pattern at the seam", "M001");
+    assert.equal(result.id, "P001", "first pattern on a fresh project should be P001");
+    assert.equal(result.written, true);
+
+    const memories = readMemoriesWithMarker("P");
+    assert.equal(memories.length, 1);
+    assert.equal(memories[0]?.category, "pattern");
+    assert.equal(memories[0]?.sf.sourceKnowledgeId, "P001");
+    assert.equal(memories[0]?.sf.pattern, "Repository pattern at the seam");
+    assert.equal(memories[0]?.sf.where, "");
+    assert.equal(memories[0]?.sf.notes, "");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("pattern entry does NOT write to KNOWLEDGE.md (memory-only)", () => {
+  const base = makeTmpBase();
+  try {
+    captureKnowledgeEntry(base, "pattern", "Adapter at the seam", "project");
+    assert.equal(
+      existsSync(knowledgeMdPath(base)),
+      false,
+      "KNOWLEDGE.md should remain untouched — projection re-renders on next session start",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("repeated pattern captures advance the ID monotonically", () => {
+  const base = makeTmpBase();
+  try {
+    const a = captureKnowledgeEntry(base, "pattern", "First", "project");
+    const b = captureKnowledgeEntry(base, "pattern", "Second", "project");
+    const c = captureKnowledgeEntry(base, "pattern", "Third", "project");
+    assert.deepEqual([a.id, b.id, c.id], ["P001", "P002", "P003"]);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Lesson path ────────────────────────────────────────────────────────────
+
+test("lesson entry creates a memory with category=gotcha and L### id", () => {
+  const base = makeTmpBase();
+  try {
+    const result = captureKnowledgeEntry(base, "lesson", "Cache poisoning via reused key", "M001/S01");
+    assert.equal(result.id, "L001");
+    assert.equal(result.written, true);
+
+    const memories = readMemoriesWithMarker("L");
+    assert.equal(memories.length, 1);
+    assert.equal(memories[0]?.category, "gotcha");
+    assert.equal(memories[0]?.sf.sourceKnowledgeId, "L001");
+    assert.equal(memories[0]?.sf.whatHappened, "Cache poisoning via reused key");
+    assert.equal(memories[0]?.sf.scopeText, "M001/S01");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Empty input ────────────────────────────────────────────────────────────
+
+test("empty entry text does NOT create a memory but still assigns an id", () => {
+  const base = makeTmpBase();
+  try {
+    const result = captureKnowledgeEntry(base, "pattern", "   ", "project");
+    assert.equal(result.written, false);
+    assert.equal(readMemoriesWithMarker("P").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── nextKnowledgeId — cross-surface monotonicity ───────────────────────────
+
+test("nextKnowledgeId takes max of file and memory surfaces", () => {
+  const base = makeTmpBase();
+  try {
+    // Pre-existing patterns in KNOWLEDGE.md and one new pattern in memories.
+    // The legacy appendKnowledge format starts P at 001 — we simulate higher
+    // existing IDs to verify the take-max-then-+1 rule.
+    writeFileSync(
+      knowledgeMdPath(base),
+      `## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P004 | Legacy pattern | services/ | preserved |
+`,
+      "utf-8",
+    );
+
+    // Capture jumps the memory ID forward.
+    captureKnowledgeEntry(base, "pattern", "Memory-only pattern", "project");
+    captureKnowledgeEntry(base, "pattern", "Another memory-only pattern", "project");
+    captureKnowledgeEntry(base, "pattern", "And another", "project");
+
+    // After: file has P004 (max=4); memories have P005, P006, P007 (max=7).
+    // Next must be P008.
+    assert.equal(nextKnowledgeId(base, "P"), "P008");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("nextKnowledgeId works per-prefix without cross-talk", () => {
+  const base = makeTmpBase();
+  try {
+    captureKnowledgeEntry(base, "pattern", "P entry", "project");
+    captureKnowledgeEntry(base, "pattern", "P entry 2", "project");
+    captureKnowledgeEntry(base, "lesson", "L entry", "project");
+
+    assert.equal(nextKnowledgeId(base, "P"), "P003");
+    assert.equal(nextKnowledgeId(base, "L"), "L002");
+    // K has no entries on this project — first one should be K001.
+    assert.equal(nextKnowledgeId(base, "K"), "K001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("nextKnowledgeId pads to three digits even at the rollover", () => {
+  const base = makeTmpBase();
+  try {
+    writeFileSync(
+      knowledgeMdPath(base),
+      `## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P099 | high water mark | — | — |
+`,
+      "utf-8",
+    );
+    assert.equal(nextKnowledgeId(base, "P"), "P100");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Sanity: file-side reads still see existing rows after capture ─────────
+
+test("after pattern capture, KNOWLEDGE.md untouched but next id reflects memory state", () => {
+  const base = makeTmpBase();
+  try {
+    captureKnowledgeEntry(base, "pattern", "First", "project");
+    // KNOWLEDGE.md still absent.
+    assert.equal(existsSync(knowledgeMdPath(base)), false);
+    // Next-ID logic sees the new memory.
+    assert.equal(nextKnowledgeId(base, "P"), "P002");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("rule writes still flow through appendKnowledge (file-canonical) — memory unchanged", async () => {
+  const base = makeTmpBase();
+  try {
+    // We invoke the legacy file path directly here; the command handler
+    // dispatch is verified separately at the integration level. The point
+    // of this test is to lock in that captureKnowledgeEntry is NOT the
+    // rule path — rules must go through appendKnowledge.
+    const { appendKnowledge } = await import("../files.ts");
+    await appendKnowledge(base, "rule", "Always pin SQLite version", "project");
+
+    const md = readFileSync(knowledgeMdPath(base), "utf-8");
+    assert.match(md, /\| K001 \| project \| Always pin SQLite version /);
+
+    // No pattern/lesson memories should exist as a side effect.
+    assert.equal(readMemoriesWithMarker("P").length, 0);
+    assert.equal(readMemoriesWithMarker("L").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/knowledge.test.ts

@@ -187,7 +187,7 @@ test('loadKnowledgeBlock: uses project knowledge alone when no global file', ()
   writeFileSync(join(cwd, '.gsd', 'KNOWLEDGE.md'), 'K001: Use real DB');
 
   const result = loadKnowledgeBlock(gsdHome, cwd);
-  assert.ok(result.block.includes('[KNOWLEDGE — Rules, patterns, and lessons learned]'));
+  assert.ok(result.block.includes('[KNOWLEDGE — Rules from KNOWLEDGE.md'));
   assert.ok(result.block.includes('## Project Knowledge'));
   assert.ok(result.block.includes('K001: Use real DB'));
   assert.ok(!result.block.includes('## Global Knowledge'));
@@ -205,7 +205,7 @@ test('loadKnowledgeBlock: uses global knowledge alone when no project file', ()
   writeFileSync(join(gsdHome, 'agent', 'KNOWLEDGE.md'), 'G001: Respond in English');
 
   const result = loadKnowledgeBlock(gsdHome, cwd);
-  assert.ok(result.block.includes('[KNOWLEDGE — Rules, patterns, and lessons learned]'));
+  assert.ok(result.block.includes('[KNOWLEDGE — Rules from KNOWLEDGE.md'));
   assert.ok(result.block.includes('## Global Knowledge'));
   assert.ok(result.block.includes('G001: Respond in English'));
   assert.ok(!result.block.includes('## Project Knowledge'));
@@ -234,6 +234,51 @@ test('loadKnowledgeBlock: merges global before project when both exist', () => {
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('loadKnowledgeBlock: strips patterns and lessons from project knowledge', () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-kb-strip-')));
+  const gsdHome = join(tmp, 'home');
+  const cwd = join(tmp, 'project');
+  mkdirSync(join(cwd, '.gsd'), { recursive: true });
+  mkdirSync(join(gsdHome, 'agent'), { recursive: true });
+  writeFileSync(
+    join(cwd, '.gsd', 'KNOWLEDGE.md'),
+    [
+      '# Project Knowledge',
+      '',
+      'Intro note that should stay with manual rules.',
+      '',
+      '## Rules',
+      '',
+      '| ID | Rule | Notes |',
+      '|---|---|---|',
+      '| K001 | Use real DB | - |',
+      '',
+      '## Patterns',
+      '',
+      '| ID | Pattern | Where | Notes |',
+      '|---|---|---|---|',
+      '| P001 | Prefer async | server | - |',
+      '',
+      '## Lessons Learned',
+      '',
+      '| ID | What Happened | Root Cause | Fix | Scope |',
+      '|---|---|---|---|---|',
+      '| L001 | Missed cache | N/A | Add TTL | project |',
+    ].join('\n'),
+  );
+
+  const result = loadKnowledgeBlock(gsdHome, cwd);
+  assert.ok(result.block.includes('[KNOWLEDGE — Rules from KNOWLEDGE.md'));
+  assert.ok(result.block.includes('Intro note that should stay with manual rules.'));
+  assert.ok(result.block.includes('K001'), 'rules entry should be present');
+  assert.ok(!result.block.includes('P001'), 'patterns should be stripped and injected via memories');
+  assert.ok(!result.block.includes('L001'), 'lessons should be stripped and injected via memories');
+  assert.ok(!result.block.includes('## Patterns'), 'Patterns heading should not appear');
+  assert.ok(!result.block.includes('## Lessons Learned'), 'Lessons heading should not appear');
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
 test('loadKnowledgeBlock: reports globalSizeKb above 4KB threshold', () => {
   const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-kb-')));
   const gsdHome = join(tmp, 'home');

package/src/resources/extensions/gsd/tests/load-knowledge-block-rules-only.test.ts

@@ -0,0 +1,209 @@
+// ADR-013 follow-up — loadKnowledgeBlock injects only Rules from project
+// KNOWLEDGE.md to avoid duplicating Patterns + Lessons content already
+// injected via loadMemoryBlock (Stage 2b cutover).
+//
+// Global KNOWLEDGE.md (~/.gsd/agent/KNOWLEDGE.md) is NOT memory-projected
+// and still passes through with all three sections intact.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadKnowledgeBlock } from "../bootstrap/system-context.ts";
+import { extractIntroAndRules } from "../knowledge-parser.ts";
+
+function makeTmpProject(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-knowledge-rules-only-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function makeTmpHome(): string {
+  const home = mkdtempSync(join(tmpdir(), "gsd-knowledge-home-"));
+  mkdirSync(join(home, "agent"), { recursive: true });
+  return home;
+}
+
+function cleanup(...dirs: string[]): void {
+  for (const dir of dirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* noop */
+    }
+  }
+}
+
+const FULL_KNOWLEDGE = `# Project Knowledge
+
+Append-only register of project-specific rules, patterns, and lessons learned.
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | All timestamps in UTC | clarity | 2026-01-01 |
+| K002 | M001 | Never trust user input | safety | 2026-01-02 |
+
+## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Repository pattern | services/ | guards |
+
+## Lessons Learned
+
+| # | What Happened | Root Cause | Fix | Scope |
+|---|--------------|------------|-----|-------|
+| L001 | Cache poisoning | reused key | versioned key | project |
+`;
+
+// ─── extractIntroAndRules unit tests ───────────────────────────────────────
+
+test("extractIntroAndRules keeps intro + Rules, drops Patterns + Lessons", () => {
+  const out = extractIntroAndRules(FULL_KNOWLEDGE);
+  assert.match(out, /# Project Knowledge/);
+  assert.match(out, /## Rules/);
+  assert.match(out, /\| K001 \| project \| All timestamps in UTC/);
+  assert.match(out, /\| K002 \| M001 \| Never trust user input/);
+
+  assert.equal(out.includes("## Patterns"), false, "Patterns heading must be dropped");
+  assert.equal(out.includes("P001"), false, "Pattern rows must be dropped");
+  assert.equal(out.includes("## Lessons Learned"), false, "Lessons heading must be dropped");
+  assert.equal(out.includes("L001"), false, "Lesson rows must be dropped");
+});
+
+test("extractIntroAndRules returns content unchanged when no `## Rules` heading", () => {
+  const content = "# Notes\n\nfreeform content without standard sections\n";
+  assert.equal(extractIntroAndRules(content), content);
+});
+
+test("extractIntroAndRules returns empty for empty input", () => {
+  assert.equal(extractIntroAndRules(""), "");
+  assert.equal(extractIntroAndRules("   \n\n"), "");
+});
+
+test("extractIntroAndRules handles Rules as the only section (no Patterns/Lessons to drop)", () => {
+  const content = `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | only rule | reason | 2026-01-01 |
+`;
+  const out = extractIntroAndRules(content);
+  assert.match(out, /K001/);
+  assert.match(out, /## Rules/);
+});
+
+// ─── loadKnowledgeBlock integration ────────────────────────────────────────
+
+test("loadKnowledgeBlock trims project KNOWLEDGE.md to intro + Rules", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(join(base, ".gsd", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    const { block } = loadKnowledgeBlock(home, base);
+
+    assert.match(block, /## Project Knowledge/);
+    assert.match(block, /K001/);
+    assert.match(block, /K002/);
+    assert.equal(block.includes("P001"), false, "project Patterns must not appear in the block");
+    assert.equal(block.includes("L001"), false, "project Lessons must not appear in the block");
+    assert.equal(block.includes("## Patterns"), false);
+    assert.equal(block.includes("## Lessons Learned"), false);
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock leaves global KNOWLEDGE.md intact (no memory projection there)", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(join(home, "agent", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    const { block, globalSizeKb } = loadKnowledgeBlock(home, base);
+
+    assert.match(block, /## Global Knowledge/);
+    // Global is full-fidelity: all three sections intact.
+    assert.match(block, /K001/);
+    assert.match(block, /P001/);
+    assert.match(block, /L001/);
+    assert.match(block, /## Patterns/);
+    assert.match(block, /## Lessons Learned/);
+    assert.ok(globalSizeKb > 0, "globalSizeKb should report the global file size");
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock with both global and project: global keeps full content, project trimmed", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(join(home, "agent", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    writeFileSync(join(base, ".gsd", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    const { block } = loadKnowledgeBlock(home, base);
+
+    // Both sections present.
+    assert.match(block, /## Global Knowledge/);
+    assert.match(block, /## Project Knowledge/);
+
+    // Project's Patterns/Lessons headings must be gone. But global keeps
+    // them, so a substring count of e.g. "## Patterns" should equal 1.
+    const patternsCount = (block.match(/## Patterns/g) ?? []).length;
+    const lessonsCount = (block.match(/## Lessons Learned/g) ?? []).length;
+    assert.equal(patternsCount, 1, "Patterns heading appears exactly once (in global)");
+    assert.equal(lessonsCount, 1, "Lessons heading appears exactly once (in global)");
+
+    // K/P/L rows: K appears twice (global + project), P/L appear once (global).
+    const k001Count = (block.match(/K001/g) ?? []).length;
+    const p001Count = (block.match(/P001/g) ?? []).length;
+    const l001Count = (block.match(/L001/g) ?? []).length;
+    assert.equal(k001Count, 2, "K001 in both global and project");
+    assert.equal(p001Count, 1, "P001 only in global");
+    assert.equal(l001Count, 1, "L001 only in global");
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock returns empty block when neither file exists", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    const result = loadKnowledgeBlock(home, base);
+    assert.equal(result.block, "");
+    assert.equal(result.globalSizeKb, 0);
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock injects only Rules when project KNOWLEDGE.md has no Patterns/Lessons", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(
+      join(base, ".gsd", "KNOWLEDGE.md"),
+      `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | rule one | reason | 2026-01-01 |
+`,
+      "utf-8",
+    );
+    const { block } = loadKnowledgeBlock(home, base);
+    assert.match(block, /K001/);
+    // Block heading reflects the new contract.
+    assert.match(block, /Rules from KNOWLEDGE\.md/);
+  } finally {
+    cleanup(base, home);
+  }
+});