gsd-pi 2.24.0 → 2.25.0

package/dist/resources/extensions/gsd/tests/auto-worktree.test.ts

@@ -153,6 +153,64 @@ async function main(): Promise<void> {
     // After teardown, originalBase should be null
     assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
 
+    // ─── #778: reconcile plan checkboxes on re-attach ─────────────────
+    console.log("\n=== #778: reconcile plan checkboxes on re-attach ===");
+    {
+      // Simulate: T01 [x] was committed to milestone branch, T02 [x] was
+      // written to project root by syncStateToProjectRoot() but the
+      // auto-commit crashed before it fired. On restart the worktree is
+      // re-created from the milestone branch HEAD (T02 still [ ]).
+      // reconcilePlanCheckboxes should forward-apply T02 [x] from the root.
+
+      const planRelPath = join(".gsd", "milestones", "M004", "slices", "S01", "S01-PLAN.md");
+      const planDir = join(tempDir, ".gsd", "milestones", "M004", "slices", "S01");
+      const { mkdirSync: mkdir, writeFileSync: write, readFileSync: read } = await import("node:fs");
+
+      // Plan on integration branch (project root): T01 [x], T02 [x]
+      mkdir(planDir, { recursive: true });
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+
+      // Write integration-branch plan to git so milestone branch starts from it
+      run(`git add .`, tempDir);
+      run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
+
+      // Create milestone branch with only T01 [x] (simulating crash before T02 commit)
+      const milestoneBranch = "milestone/M004";
+      run(`git checkout -b ${milestoneBranch}`, tempDir);
+      mkdir(planDir, { recursive: true });
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [ ] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+      run(`git add .`, tempDir);
+      run(`git commit -m "milestone: only T01 checked"`, tempDir);
+      run(`git checkout main`, tempDir);
+
+      // Restore project root plan (T01+T02 [x]) — simulates syncStateToProjectRoot
+      write(
+        join(tempDir, planRelPath),
+        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
+      );
+
+      // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
+      const wtPath = createAutoWorktree(tempDir, "M004");
+
+      try {
+        const wtPlanPath = join(wtPath, planRelPath);
+        assertTrue(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
+
+        const wtPlan = read(wtPlanPath, "utf-8");
+        assertTrue(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
+        assertTrue(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
+        assertTrue(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
+      } finally {
+        teardownAutoWorktree(tempDir, "M004");
+      }
+    }
+
   } finally {
     // Always restore cwd and clean up
     process.chdir(savedCwd);

package/dist/resources/extensions/gsd/tests/git-service.test.ts

@@ -5,6 +5,7 @@ import { execSync } from "node:child_process";
 
 import {
   inferCommitType,
+  buildTaskCommitMessage,
   GitServiceImpl,
   RUNTIME_EXCLUSION_PATHS,
   VALID_BRANCH_NAME,
@@ -14,6 +15,7 @@ import {
   type GitPreferences,
   type CommitOptions,
   type PreMergeCheckResult,
+  type TaskCommitContext,
 } from "../git-service.ts";
 import { createTestContext } from './test-helpers.ts';
 
@@ -188,6 +190,58 @@ async function main(): Promise<void> {
     "'prefix' does not match 'fix' — word boundary prevents partial match"
   );
 
+  // ─── inferCommitType with oneLiner ──────────────────────────────────────
+
+  console.log("\n=== inferCommitType with oneLiner ===");
+
+  assertEq(
+    inferCommitType("implement dashboard", "Fixed rendering bug in sidebar"),
+    "fix",
+    "one-liner with 'fixed' overrides generic title → fix"
+  );
+
+  assertEq(
+    inferCommitType("add search", "Optimized query performance with caching"),
+    "perf",
+    "one-liner with 'performance' and 'caching' → perf"
+  );
+
+  // ─── buildTaskCommitMessage ─────────────────────────────────────────────
+
+  console.log("\n=== buildTaskCommitMessage ===");
+
+  {
+    const msg = buildTaskCommitMessage({
+      taskId: "S01/T02",
+      taskTitle: "implement user authentication",
+      oneLiner: "Added JWT-based auth with refresh token rotation",
+      keyFiles: ["src/auth.ts", "src/middleware/jwt.ts"],
+    });
+    assertTrue(msg.startsWith("feat(S01/T02):"), "message starts with type(scope)");
+    assertTrue(msg.includes("JWT-based auth"), "message includes one-liner content");
+    assertTrue(msg.includes("- src/auth.ts"), "message body includes key files");
+    assertTrue(msg.includes("- src/middleware/jwt.ts"), "message body includes second key file");
+  }
+
+  {
+    const msg = buildTaskCommitMessage({
+      taskId: "S02/T01",
+      taskTitle: "fix login redirect bug",
+    });
+    assertTrue(msg.startsWith("fix(S02/T01):"), "infers fix type from title");
+    assertTrue(msg.includes("fix login redirect bug"), "uses task title when no one-liner");
+    assertTrue(!msg.includes("\n"), "no body when no key files");
+  }
+
+  {
+    const msg = buildTaskCommitMessage({
+      taskId: "S01/T03",
+      taskTitle: "add tests",
+      oneLiner: "Unit tests for auth module with coverage",
+    });
+    assertTrue(msg.startsWith("test(S01/T03):"), "infers test type");
+  }
+
   // ─── RUNTIME_EXCLUSION_PATHS ───────────────────────────────────────────
 
   console.log("\n=== RUNTIME_EXCLUSION_PATHS ===");
@@ -430,13 +484,25 @@ async function main(): Promise<void> {
     const svc = new GitServiceImpl(repo);
 
     createFile(repo, "src/new-feature.ts", "export const x = 1;");
-    const msg = svc.autoCommit("task", "T01");
 
-    assertEq(msg, "chore(T01): auto-commit after task", "autoCommit returns correct message format");
+    // Without task context, autoCommit uses generic chore message
+    const msg = svc.autoCommit("task", "T01");
+    assertEq(msg, "chore(T01): auto-commit after task", "autoCommit returns generic format without task context");
 
-    // Verify the commit exists
     const log = run("git log --oneline -1", repo);
-    assertTrue(log.includes("chore(T01): auto-commit after task"), "commit message is in git log");
+    assertTrue(log.includes("chore(T01): auto-commit after task"), "generic commit message is in git log");
+
+    // With task context, autoCommit uses meaningful message
+    createFile(repo, "src/auth.ts", "export function login() {}");
+    const msg2 = svc.autoCommit("task", "S01/T02", [], {
+      taskId: "S01/T02",
+      taskTitle: "implement user authentication endpoint",
+      oneLiner: "Added JWT-based auth with refresh token rotation",
+      keyFiles: ["src/auth.ts"],
+    });
+    assertTrue(msg2 !== null, "autoCommit with task context returns a message");
+    assertTrue(msg2!.startsWith("feat(S01/T02):"), "meaningful commit uses feat type and scope");
+    assertTrue(msg2!.includes("JWT-based auth"), "meaningful commit includes one-liner content");
 
     rmSync(repo, { recursive: true, force: true });
   }

package/dist/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -65,8 +65,8 @@ console.log('\n=== gsd-db: fresh DB schema init (memory) ===');
 
   // Check schema_version table
   const adapter = _getAdapter()!;
-  const version = adapter.prepare('SELECT version FROM schema_version').get();
-  assertEq(version?.['version'], 2, 'schema version should be 2');
+  const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
+  assertEq(version?.['version'], 3, 'schema version should be 3');
 
   // Check tables exist by querying them
   const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/dist/resources/extensions/gsd/tests/md-importer.test.ts

@@ -350,12 +350,11 @@ console.log('=== md-importer: missing file handling ===');
 console.log('=== md-importer: schema v1→v2 migration ===');
 
 {
-  // This test verifies that opening a v1 DB auto-migrates to v2
-  // (The actual migration is tested via the gsd-db.test.ts schema version assertion = 2)
+  // This test verifies that opening a fresh DB auto-migrates to current schema version
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.v, 2, 'new DB should be at schema version 2');
+  assertEq(version?.v, 3, 'new DB should be at schema version 3');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/dist/resources/extensions/gsd/tests/memory-extractor.test.ts

@@ -0,0 +1,180 @@
+import { createTestContext } from './test-helpers.ts';
+import { parseMemoryResponse, _resetExtractionState } from '../memory-extractor.ts';
+import {
+  openDatabase,
+  closeDatabase,
+} from '../gsd-db.ts';
+import {
+  getActiveMemories,
+  applyMemoryActions,
+  getActiveMemoriesRanked,
+} from '../memory-store.ts';
+import type { MemoryAction } from '../memory-store.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse valid JSON response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: parse valid JSON ===');
+{
+  const response = JSON.stringify([
+    { action: 'CREATE', category: 'gotcha', content: 'esbuild drops binaries', confidence: 0.85 },
+    { action: 'REINFORCE', id: 'MEM001' },
+    { action: 'UPDATE', id: 'MEM002', content: 'revised content' },
+    { action: 'SUPERSEDE', id: 'MEM003', superseded_by: 'MEM004' },
+  ]);
+
+  const actions = parseMemoryResponse(response);
+  assertEq(actions.length, 4, 'should parse 4 actions');
+  assertEq(actions[0].action, 'CREATE', 'first action should be CREATE');
+  assertEq((actions[0] as any).category, 'gotcha', 'CREATE category');
+  assertEq((actions[0] as any).confidence, 0.85, 'CREATE confidence');
+  assertEq(actions[1].action, 'REINFORCE', 'second action should be REINFORCE');
+  assertEq(actions[2].action, 'UPDATE', 'third action should be UPDATE');
+  assertEq(actions[3].action, 'SUPERSEDE', 'fourth action should be SUPERSEDE');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse fenced JSON response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: parse fenced JSON ===');
+{
+  const response = '```json\n[\n  {"action": "CREATE", "category": "convention", "content": "test memory"}\n]\n```';
+
+  const actions = parseMemoryResponse(response);
+  assertEq(actions.length, 1, 'should parse 1 action from fenced JSON');
+  assertEq(actions[0].action, 'CREATE', 'action should be CREATE');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse empty array response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: parse empty array ===');
+{
+  const actions = parseMemoryResponse('[]');
+  assertEq(actions.length, 0, 'empty array should parse to empty actions');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: parse malformed response
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: malformed responses ===');
+{
+  assertEq(parseMemoryResponse('not json at all'), [], 'garbage text should return []');
+  assertEq(parseMemoryResponse('{"action": "CREATE"}'), [], 'non-array should return []');
+  assertEq(parseMemoryResponse(''), [], 'empty string should return []');
+  assertEq(parseMemoryResponse('```\nbroken\n```'), [], 'fenced non-JSON should return []');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: validation of required fields
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: field validation ===');
+{
+  const response = JSON.stringify([
+    // Valid CREATE
+    { action: 'CREATE', category: 'gotcha', content: 'valid' },
+    // Invalid CREATE — missing content
+    { action: 'CREATE', category: 'gotcha' },
+    // Invalid CREATE — missing category
+    { action: 'CREATE', content: 'no category' },
+    // Valid REINFORCE
+    { action: 'REINFORCE', id: 'MEM001' },
+    // Invalid REINFORCE — missing id
+    { action: 'REINFORCE' },
+    // Valid UPDATE
+    { action: 'UPDATE', id: 'MEM002', content: 'new content' },
+    // Invalid UPDATE — missing content
+    { action: 'UPDATE', id: 'MEM002' },
+    // Valid SUPERSEDE
+    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM002' },
+    // Invalid SUPERSEDE — missing superseded_by
+    { action: 'SUPERSEDE', id: 'MEM001' },
+    // Unknown action
+    { action: 'DELETE', id: 'MEM001' },
+    // Null entry
+    null,
+  ]);
+
+  const actions = parseMemoryResponse(response);
+  assertEq(actions.length, 4, 'should only accept 4 valid actions');
+  assertEq(actions[0].action, 'CREATE', 'first valid is CREATE');
+  assertEq(actions[1].action, 'REINFORCE', 'second valid is REINFORCE');
+  assertEq(actions[2].action, 'UPDATE', 'third valid is UPDATE');
+  assertEq(actions[3].action, 'SUPERSEDE', 'fourth valid is SUPERSEDE');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Integration: applyMemoryActions with mixed actions
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== integration: mixed action lifecycle ===');
+{
+  openDatabase(':memory:');
+
+  // Phase 1: Create initial memories
+  applyMemoryActions([
+    { action: 'CREATE', category: 'gotcha', content: 'npm run build needs tsc first', confidence: 0.7 },
+    { action: 'CREATE', category: 'convention', content: 'all DB queries use named params', confidence: 0.8 },
+    { action: 'CREATE', category: 'architecture', content: 'extensions loaded from two paths', confidence: 0.85 },
+  ], 'plan-slice', 'M001/S01');
+
+  let active = getActiveMemoriesRanked(30);
+  assertEq(active.length, 3, 'phase 1: 3 active memories');
+
+  // Phase 2: Reinforce one, update another, create new
+  applyMemoryActions([
+    { action: 'REINFORCE', id: 'MEM002' },
+    { action: 'UPDATE', id: 'MEM001', content: 'npm run build requires tsc --noEmit first' },
+    { action: 'CREATE', category: 'pattern', content: 'use INSERT OR IGNORE for idempotency', confidence: 0.75 },
+  ], 'execute-task', 'M001/S01/T01');
+
+  active = getActiveMemoriesRanked(30);
+  assertEq(active.length, 4, 'phase 2: 4 active memories');
+  assertEq(
+    active.find(m => m.id === 'MEM001')?.content,
+    'npm run build requires tsc --noEmit first',
+    'MEM001 content should be updated',
+  );
+  assertEq(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
+
+  // Phase 3: Supersede MEM001 with MEM005
+  applyMemoryActions([
+    { action: 'CREATE', category: 'gotcha', content: 'build script handles tsc automatically now', confidence: 0.9 },
+    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM005' },
+  ], 'execute-task', 'M001/S01/T02');
+
+  active = getActiveMemoriesRanked(30);
+  assertEq(active.length, 4, 'phase 3: 4 active (1 superseded, 1 created)');
+  assertTrue(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
+  assertTrue(!!active.find(m => m.id === 'MEM005'), 'MEM005 should be active');
+
+  // Verify ranking: MEM003 (0.85) > MEM005 (0.9) but MEM002 has 1 hit
+  // MEM002: 0.8 * (1 + 1*0.1) = 0.88
+  // MEM003: 0.85 * 1.0 = 0.85
+  // MEM005: 0.9 * 1.0 = 0.9
+  // MEM004: 0.75 * 1.0 = 0.75
+  assertEq(active[0].id, 'MEM005', 'MEM005 should rank first (0.9)');
+  assertEq(active[1].id, 'MEM002', 'MEM002 should rank second (0.88)');
+
+  closeDatabase();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-extractor: _resetExtractionState
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== memory-extractor: reset extraction state ===');
+{
+  // Just verify it doesn't throw
+  _resetExtractionState();
+  assertTrue(true, '_resetExtractionState should not throw');
+}
+
+report();