gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

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-logger.test.ts

@@ -0,0 +1,275 @@
+// GSD Extension — Workflow Logger Tests
+// Tests for the centralized warning/error accumulator.
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  logWarning,
+  logError,
+  drainLogs,
+  drainAndSummarize,
+  peekLogs,
+  hasErrors,
+  hasWarnings,
+  hasAnyIssues,
+  summarizeLogs,
+  formatForNotification,
+  _resetLogs,
+} from "../workflow-logger.ts";
+
+const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+describe("workflow-logger", () => {
+  beforeEach(() => {
+    _resetLogs();
+  });
+
+  describe("accumulation", () => {
+    test("logWarning adds an entry with severity warn", () => {
+      logWarning("engine", "test warning");
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "warn");
+      assert.equal(entries[0].component, "engine");
+      assert.equal(entries[0].message, "test warning");
+      assert.match(entries[0].ts, ISO_RE);
+    });
+
+    test("logError adds an entry with severity error", () => {
+      logError("intercept", "blocked write", { path: "/foo/STATE.md" });
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "error");
+      assert.equal(entries[0].component, "intercept");
+      assert.deepEqual(entries[0].context, { path: "/foo/STATE.md" });
+    });
+
+    test("accumulates multiple entries in order", () => {
+      logWarning("projection", "render failed");
+      logError("intercept", "blocked write");
+      logWarning("manifest", "write failed");
+      assert.equal(peekLogs().length, 3);
+      assert.equal(peekLogs()[0].component, "projection");
+      assert.equal(peekLogs()[1].component, "intercept");
+      assert.equal(peekLogs()[2].component, "manifest");
+    });
+
+    test("omits context field when not provided", () => {
+      logWarning("engine", "no context");
+      assert.equal("context" in peekLogs()[0], false);
+    });
+
+    test("omits context field when undefined is passed", () => {
+      logWarning("engine", "no context", undefined);
+      assert.equal("context" in peekLogs()[0], false);
+    });
+
+    test("context with special characters is stored as-is", () => {
+      logError("tool", "failed", { path: '/foo/"quoted".md', msg: "line1\nline2" });
+      assert.deepEqual(peekLogs()[0].context, {
+        path: '/foo/"quoted".md',
+        msg: "line1\nline2",
+      });
+    });
+
+    test("ts field is a valid ISO 8601 timestamp", () => {
+      logWarning("engine", "ts check");
+      assert.match(peekLogs()[0].ts, ISO_RE);
+    });
+  });
+
+  describe("drain", () => {
+    test("returns all entries and clears buffer", () => {
+      logWarning("engine", "w1");
+      logError("engine", "e1");
+      const drained = drainLogs();
+      assert.equal(drained.length, 2);
+      assert.equal(peekLogs().length, 0);
+    });
+
+    test("returns empty array when no entries", () => {
+      assert.deepEqual(drainLogs(), []);
+    });
+
+    test("second drain returns empty array", () => {
+      logWarning("engine", "w1");
+      drainLogs();
+      assert.deepEqual(drainLogs(), []);
+    });
+  });
+
+  describe("drainAndSummarize", () => {
+    test("returns summary and clears buffer atomically", () => {
+      logError("intercept", "blocked");
+      logWarning("projection", "render failed");
+      const { logs, summary } = drainAndSummarize();
+      assert.equal(logs.length, 2);
+      assert.equal(peekLogs().length, 0);
+      assert.ok(summary?.includes("1 error(s)"));
+      assert.ok(summary?.includes("1 warning(s)"));
+    });
+
+    test("returns null summary when buffer is empty", () => {
+      const { logs, summary } = drainAndSummarize();
+      assert.deepEqual(logs, []);
+      assert.equal(summary, null);
+    });
+  });
+
+  describe("hasErrors / hasWarnings / hasAnyIssues", () => {
+    test("hasErrors returns false when only warnings", () => {
+      logWarning("engine", "just a warning");
+      assert.equal(hasErrors(), false);
+      assert.equal(hasWarnings(), true);
+    });
+
+    test("hasErrors returns true when errors present", () => {
+      logWarning("engine", "warning");
+      logError("intercept", "error");
+      assert.equal(hasErrors(), true);
+    });
+
+    test("hasWarnings returns false when buffer empty", () => {
+      assert.equal(hasWarnings(), false);
+    });
+
+    test("hasWarnings returns false when buffer contains only errors", () => {
+      logError("intercept", "only an error");
+      assert.equal(hasWarnings(), false);
+      assert.equal(hasErrors(), true);
+    });
+
+    test("hasAnyIssues returns true for warnings only", () => {
+      logWarning("engine", "warn");
+      assert.equal(hasAnyIssues(), true);
+    });
+
+    test("hasAnyIssues returns true for errors only", () => {
+      logError("engine", "err");
+      assert.equal(hasAnyIssues(), true);
+    });
+
+    test("hasAnyIssues returns false when buffer empty", () => {
+      assert.equal(hasAnyIssues(), false);
+    });
+  });
+
+  describe("summarizeLogs", () => {
+    test("returns null when empty", () => {
+      assert.equal(summarizeLogs(), null);
+    });
+
+    test("summarizes errors and warnings separately", () => {
+      logError("intercept", "blocked STATE.md");
+      logWarning("projection", "render failed");
+      logWarning("manifest", "write failed");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(summary.includes("blocked STATE.md"));
+      assert.ok(summary.includes("2 warning(s)"));
+    });
+
+    test("only shows errors section when no warnings", () => {
+      logError("intercept", "blocked");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(!summary.includes("warning"));
+    });
+
+    test("only shows warnings section when no errors", () => {
+      logWarning("projection", "render degraded");
+      logWarning("manifest", "write slow");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("2 warning(s)"));
+      assert.ok(!summary.includes("error"));
+    });
+
+    test("does not clear buffer", () => {
+      logError("intercept", "blocked");
+      summarizeLogs();
+      assert.equal(peekLogs().length, 1);
+    });
+  });
+
+  describe("formatForNotification", () => {
+    test("returns empty string for empty array", () => {
+      assert.equal(formatForNotification([]), "");
+    });
+
+    test("formats single entry without line breaks", () => {
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[intercept] blocked write");
+    });
+
+    test("formats multiple entries with line breaks", () => {
+      logWarning("projection", "render failed");
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.ok(formatted.includes("[projection] render failed"));
+      assert.ok(formatted.includes("[intercept] blocked write"));
+      assert.ok(formatted.includes("\n"));
+    });
+
+    test("does not include context in formatted output", () => {
+      logError("tool", "failed", { cmd: "complete_task" });
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[tool] failed");
+      assert.ok(!formatted.includes("complete_task"));
+    });
+  });
+
+  describe("buffer limit", () => {
+    test("caps at MAX_BUFFER entries, dropping oldest", () => {
+      const OVER = 110;
+      const MAX = 100;
+      for (let i = 0; i < OVER; i++) {
+        logWarning("engine", `msg-${i}`);
+      }
+      const entries = peekLogs();
+      assert.equal(entries.length, MAX);
+      // First MAX entries dropped; oldest surviving = msg-(OVER-MAX)
+      assert.equal(entries[0].message, `msg-${OVER - MAX}`);
+      assert.equal(entries[MAX - 1].message, `msg-${OVER - 1}`);
+    });
+  });
+
+  describe("stderr output", () => {
+    test("writes WARN prefix to stderr for warnings", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logWarning("engine", "test warn");
+      assert.equal(written.length, 1);
+      assert.ok(written[0].includes("[gsd:engine] WARN: test warn"));
+    });
+
+    test("writes ERROR prefix to stderr for errors", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logError("intercept", "blocked");
+      assert.ok(written[0].includes("[gsd:intercept] ERROR: blocked"));
+    });
+
+    test("includes serialized context in stderr output", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logError("tool", "failed", { cmd: "complete_task" });
+      assert.ok(written[0].includes('"cmd":"complete_task"'));
+    });
+  });
+});