gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/windows-path-normalization.test.ts

@@ -6,9 +6,9 @@
  * strips backslashes (escape characters), producing `C:Usersuserproject`.
  */
 
-import { createTestContext } from "./test-helpers.ts";
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── shellEscape + path normalization ──────────────────────────────────────
 
@@ -25,42 +25,42 @@ function bashPath(p: string): string {
 console.log("\n=== Windows backslash path normalization (#1436) ===");
 
 // Backslash paths are converted to forward slashes
-assertEq(
+assert.deepStrictEqual(
   bashPath("C:\\Users\\user\\project"),
   "'C:/Users/user/project'",
   "backslash path normalised to forward slashes in shell-escaped string",
 );
 
 // Unix paths pass through unchanged
-assertEq(
+assert.deepStrictEqual(
   bashPath("/home/user/project"),
   "'/home/user/project'",
   "Unix path unchanged",
 );
 
 // Mixed separators are normalised
-assertEq(
+assert.deepStrictEqual(
   bashPath("C:\\Users/user\\project/src"),
   "'C:/Users/user/project/src'",
   "mixed separators normalised",
 );
 
 // Paths with single quotes are still properly escaped
-assertEq(
+assert.deepStrictEqual(
   bashPath("C:\\Users\\o'brien\\project"),
   "'C:/Users/o'\\''brien/project'",
   "single quote in path is escaped after normalisation",
 );
 
 // UNC paths
-assertEq(
+assert.deepStrictEqual(
   bashPath("\\\\server\\share\\dir"),
   "'//server/share/dir'",
   "UNC path normalised",
 );
 
 // Empty string
-assertEq(
+assert.deepStrictEqual(
   bashPath(""),
   "''",
   "empty string handled",
@@ -72,14 +72,14 @@ console.log("\n=== cd command construction with normalised paths ===");
 
 const windowsCwd = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
 const cdCommand = `cd ${bashPath(windowsCwd)}`;
-assertEq(
+assert.deepStrictEqual(
   cdCommand,
   "cd 'C:/Users/user/project/.gsd/worktrees/M001'",
   "cd command uses forward slashes for Windows worktree path",
 );
 
 // Verify the mangled form from #1436 is NOT produced
-assertTrue(
+assert.ok(
   !cdCommand.includes("C:Users"),
   "mangled path C:Usersuserproject must not appear",
 );
@@ -90,10 +90,8 @@ console.log("\n=== teardown orphan warning path formatting ===");
 
 const windowsWtDir = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
 const helpCommand = `rm -rf "${windowsWtDir.replaceAll("\\", "/")}"`;
-assertEq(
+assert.deepStrictEqual(
   helpCommand,
   'rm -rf "C:/Users/user/project/.gsd/worktrees/M001"',
   "orphan cleanup help command uses forward slashes",
 );
-
-report();

package/src/resources/extensions/gsd/tests/worker-registry.test.ts

@@ -5,7 +5,8 @@
  * and the hasActiveWorkers() status check.
  */
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   registerWorker,
   updateWorker,
@@ -15,7 +16,6 @@ import {
   resetWorkerRegistry,
 } from '../../subagent/worker-registry.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Setup ────────────────────────────────────────────────────────────────────
 
@@ -28,15 +28,15 @@ console.log("\n=== Worker Registration ===");
 {
   resetWorkerRegistry();
   const id = registerWorker("scout", "Explore codebase", 0, 3, "batch-1");
-  assertTrue(id.startsWith("worker-"), "worker ID has correct prefix");
+  assert.ok(id.startsWith("worker-"), "worker ID has correct prefix");
   const workers = getActiveWorkers();
-  assertEq(workers.length, 1, "one worker registered");
-  assertEq(workers[0].agent, "scout", "worker agent name correct");
-  assertEq(workers[0].task, "Explore codebase", "worker task correct");
-  assertEq(workers[0].status, "running", "worker starts as running");
-  assertEq(workers[0].index, 0, "worker index correct");
-  assertEq(workers[0].batchSize, 3, "worker batch size correct");
-  assertEq(workers[0].batchId, "batch-1", "worker batch ID correct");
+  assert.deepStrictEqual(workers.length, 1, "one worker registered");
+  assert.deepStrictEqual(workers[0].agent, "scout", "worker agent name correct");
+  assert.deepStrictEqual(workers[0].task, "Explore codebase", "worker task correct");
+  assert.deepStrictEqual(workers[0].status, "running", "worker starts as running");
+  assert.deepStrictEqual(workers[0].index, 0, "worker index correct");
+  assert.deepStrictEqual(workers[0].batchSize, 3, "worker batch size correct");
+  assert.deepStrictEqual(workers[0].batchId, "batch-1", "worker batch ID correct");
 }
 
 // ─── Multiple workers in a batch ──────────────────────────────────────────────
@@ -50,14 +50,14 @@ console.log("\n=== Multiple Workers in a Batch ===");
   const id3 = registerWorker("worker", "Task C", 2, 3, "batch-2");
 
   const workers = getActiveWorkers();
-  assertEq(workers.length, 3, "three workers registered");
-  assertTrue(hasActiveWorkers(), "has active workers");
+  assert.deepStrictEqual(workers.length, 3, "three workers registered");
+  assert.ok(hasActiveWorkers(), "has active workers");
 
   const batches = getWorkerBatches();
-  assertEq(batches.size, 1, "one batch");
+  assert.deepStrictEqual(batches.size, 1, "one batch");
   const batch = batches.get("batch-2");
-  assertTrue(batch !== undefined, "batch-2 exists");
-  assertEq(batch!.length, 3, "batch has 3 workers");
+  assert.ok(batch !== undefined, "batch-2 exists");
+  assert.deepStrictEqual(batch!.length, 3, "batch has 3 workers");
 }
 
 // ─── Worker status updates ────────────────────────────────────────────────────
@@ -72,11 +72,11 @@ console.log("\n=== Worker Status Updates ===");
   updateWorker(id1, "completed");
   const workers = getActiveWorkers();
   const w1 = workers.find(w => w.id === id1);
-  assertEq(w1?.status, "completed", "worker 1 marked completed");
+  assert.deepStrictEqual(w1?.status, "completed", "worker 1 marked completed");
 
   const w2 = workers.find(w => w.id === id2);
-  assertEq(w2?.status, "running", "worker 2 still running");
-  assertTrue(hasActiveWorkers(), "still has active workers (worker 2 running)");
+  assert.deepStrictEqual(w2?.status, "running", "worker 2 still running");
+  assert.ok(hasActiveWorkers(), "still has active workers (worker 2 running)");
 }
 
 // ─── Failed worker ────────────────────────────────────────────────────────────
@@ -88,7 +88,7 @@ console.log("\n=== Failed Worker ===");
   const id = registerWorker("scout", "Task A", 0, 1, "batch-4");
   updateWorker(id, "failed");
   const workers = getActiveWorkers();
-  assertEq(workers[0].status, "failed", "worker marked failed");
+  assert.deepStrictEqual(workers[0].status, "failed", "worker marked failed");
 }
 
 // ─── Multiple batches ─────────────────────────────────────────────────────────
@@ -102,9 +102,9 @@ console.log("\n=== Multiple Batches ===");
   registerWorker("researcher", "Task C", 0, 1, "batch-6");
 
   const batches = getWorkerBatches();
-  assertEq(batches.size, 2, "two batches");
-  assertEq(batches.get("batch-5")!.length, 2, "batch-5 has 2 workers");
-  assertEq(batches.get("batch-6")!.length, 1, "batch-6 has 1 worker");
+  assert.deepStrictEqual(batches.size, 2, "two batches");
+  assert.deepStrictEqual(batches.get("batch-5")!.length, 2, "batch-5 has 2 workers");
+  assert.deepStrictEqual(batches.get("batch-6")!.length, 1, "batch-6 has 1 worker");
 }
 
 // ─── hasActiveWorkers with all completed ──────────────────────────────────────
@@ -117,7 +117,7 @@ console.log("\n=== hasActiveWorkers — all completed ===");
   const id2 = registerWorker("worker", "Task B", 1, 2, "batch-7");
   updateWorker(id1, "completed");
   updateWorker(id2, "completed");
-  assertTrue(!hasActiveWorkers(), "no active workers when all completed");
+  assert.ok(!hasActiveWorkers(), "no active workers when all completed");
 }
 
 // ─── Reset clears everything ─────────────────────────────────────────────────
@@ -126,10 +126,10 @@ console.log("\n=== Reset ===");
 
 {
   registerWorker("scout", "Task", 0, 1, "batch-8");
-  assertTrue(getActiveWorkers().length > 0, "workers exist before reset");
+  assert.ok(getActiveWorkers().length > 0, "workers exist before reset");
   resetWorkerRegistry();
-  assertEq(getActiveWorkers().length, 0, "no workers after reset");
-  assertTrue(!hasActiveWorkers(), "hasActiveWorkers false after reset");
+  assert.deepStrictEqual(getActiveWorkers().length, 0, "no workers after reset");
+  assert.ok(!hasActiveWorkers(), "hasActiveWorkers false after reset");
 }
 
 // ─── Update non-existent worker is no-op ──────────────────────────────────────
@@ -140,9 +140,7 @@ console.log("\n=== Update non-existent worker ===");
   resetWorkerRegistry();
   // Should not throw
   updateWorker("nonexistent-id", "completed");
-  assertEq(getActiveWorkers().length, 0, "no workers created by updating nonexistent");
+  assert.deepStrictEqual(getActiveWorkers().length, 0, "no workers created by updating nonexistent");
 }
 
 // ─── Summary ──────────────────────────────────────────────────────────────────
-
-report();

package/src/resources/extensions/gsd/tests/workflow-events.test.ts

@@ -0,0 +1,205 @@
+// GSD Extension — workflow-events unit tests
+// Tests appendEvent, readEvents, findForkPoint, compactMilestoneEvents.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  appendEvent,
+  readEvents,
+  findForkPoint,
+  compactMilestoneEvents,
+  type WorkflowEvent,
+} from '../workflow-events.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-events-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+function makeEvent(cmd: string, params: Record<string, unknown> = {}): Omit<WorkflowEvent, 'hash' | 'session_id'> {
+  return { cmd, params, ts: new Date().toISOString(), actor: 'agent' };
+}
+
+// ─── appendEvent ─────────────────────────────────────────────────────────
+
+test('workflow-events: appendEvent creates .gsd dir and event-log.jsonl', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    assert.ok(fs.existsSync(path.join(base, '.gsd', 'event-log.jsonl')));
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: appendEvent writes valid JSON line', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    const content = fs.readFileSync(path.join(base, '.gsd', 'event-log.jsonl'), 'utf-8');
+    const lines = content.trim().split('\n');
+    assert.strictEqual(lines.length, 1);
+    const parsed = JSON.parse(lines[0]!) as WorkflowEvent;
+    assert.strictEqual(parsed.cmd, 'complete-task');
+    assert.strictEqual(parsed.actor, 'agent');
+    assert.strictEqual(typeof parsed.hash, 'string');
+    assert.strictEqual(parsed.hash.length, 16);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: appendEvent appends multiple events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-slice', { sliceId: 'S01' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(events.length, 2);
+    assert.strictEqual(events[0]!.cmd, 'complete-task');
+    assert.strictEqual(events[1]!.cmd, 'complete-slice');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: same cmd+params → same hash (deterministic)', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('plan-task', { milestoneId: 'M001', sliceId: 'S01' }));
+    appendEvent(base, makeEvent('plan-task', { milestoneId: 'M001', sliceId: 'S01' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(events[0]!.hash, events[1]!.hash, 'identical cmd+params produce identical hash');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: different params → different hash', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T02' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.notStrictEqual(events[0]!.hash, events[1]!.hash, 'different params produce different hash');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── readEvents ──────────────────────────────────────────────────────────
+
+test('workflow-events: readEvents returns [] for non-existent file', () => {
+  const result = readEvents('/nonexistent/path/event-log.jsonl');
+  assert.deepStrictEqual(result, []);
+});
+
+test('workflow-events: readEvents skips corrupted lines', () => {
+  const base = tempDir();
+  try {
+    fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    // Write a valid line, a corrupted line, and another valid line
+    fs.writeFileSync(logPath,
+      '{"cmd":"complete-task","params":{},"ts":"2026-01-01T00:00:00Z","hash":"abcd1234abcd1234","actor":"agent"}\n' +
+      'NOT VALID JSON {{{{\n' +
+      '{"cmd":"plan-task","params":{},"ts":"2026-01-01T00:00:01Z","hash":"1234abcd1234abcd","actor":"system"}\n',
+    );
+    const events = readEvents(logPath);
+    assert.strictEqual(events.length, 2, 'should return 2 valid events, skipping the corrupted line');
+    assert.strictEqual(events[0]!.cmd, 'complete-task');
+    assert.strictEqual(events[1]!.cmd, 'plan-task');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── findForkPoint ───────────────────────────────────────────────────────
+
+test('workflow-events: findForkPoint returns -1 for two empty logs', () => {
+  assert.strictEqual(findForkPoint([], []), -1);
+});
+
+test('workflow-events: findForkPoint returns -1 when first events differ', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'hash1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'hash2', actor: 'agent' } as WorkflowEvent;
+  assert.strictEqual(findForkPoint([e1], [e2]), -1);
+});
+
+test('workflow-events: findForkPoint returns 0 when only first event is common', () => {
+  const common = { cmd: 'a', params: {}, ts: '', hash: 'hash1', actor: 'agent' } as WorkflowEvent;
+  const eA = { cmd: 'b', params: {}, ts: '', hash: 'hash2', actor: 'agent' } as WorkflowEvent;
+  const eB = { cmd: 'c', params: {}, ts: '', hash: 'hash3', actor: 'agent' } as WorkflowEvent;
+  // logA: [common, eA], logB: [common, eB]
+  assert.strictEqual(findForkPoint([common, eA], [common, eB]), 0);
+});
+
+test('workflow-events: findForkPoint returns last common index for prefix relationship', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'h1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'h2', actor: 'agent' } as WorkflowEvent;
+  const e3 = { cmd: 'c', params: {}, ts: '', hash: 'h3', actor: 'agent' } as WorkflowEvent;
+  // logA is a prefix of logB → fork point is last index of logA
+  assert.strictEqual(findForkPoint([e1, e2], [e1, e2, e3]), 1);
+});
+
+test('workflow-events: findForkPoint handles equal logs', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'h1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'h2', actor: 'agent' } as WorkflowEvent;
+  assert.strictEqual(findForkPoint([e1, e2], [e1, e2]), 1);
+});
+
+// ─── compactMilestoneEvents ──────────────────────────────────────────────
+
+test('workflow-events: compactMilestoneEvents returns { archived: 0 } when no matching events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M002', taskId: 'T01' }));
+    const result = compactMilestoneEvents(base, 'M001');
+    assert.strictEqual(result.archived, 0);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: compactMilestoneEvents archives milestone events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T02' }));
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M002', taskId: 'T03' }));
+
+    const result = compactMilestoneEvents(base, 'M001');
+    assert.strictEqual(result.archived, 2, 'should archive 2 M001 events');
+
+    // Archive file should exist
+    const archivePath = path.join(base, '.gsd', 'event-log-M001.jsonl.archived');
+    assert.ok(fs.existsSync(archivePath), 'archive file should exist');
+    const archived = readEvents(archivePath);
+    assert.strictEqual(archived.length, 2, 'archive file should have 2 events');
+
+    // Active log should retain only M002 event
+    const active = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(active.length, 1, 'active log should have 1 remaining event');
+    assert.strictEqual((active[0]!.params as { milestoneId?: string }).milestoneId, 'M002');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: compactMilestoneEvents empties active log when all events are from milestone', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    compactMilestoneEvents(base, 'M001');
+    const active = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(active.length, 0, 'active log should be empty after full compact');
+  } finally {
+    cleanupDir(base);
+  }
+});