gsd-pi 2.64.0 → 2.65.0-dev.16e10d7

package/src/resources/extensions/gsd/tests/notification-overlay.test.ts

@@ -0,0 +1,73 @@
+// GSD Extension — Notification Overlay Tests
+// Tests for message wrapping and content-fit sizing in the notification panel.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+// The wrapText function is private to the module, so we test the overlay's
+// render output indirectly. We also extract and test wrapText logic directly.
+
+// ── wrapText logic (mirrors the private function) ───────────────────────────
+
+function wrapText(text: string, maxWidth: number): string[] {
+  if (text.length <= maxWidth) return [text];
+  const words = text.split(/\s+/);
+  const lines: string[] = [];
+  let current = "";
+  for (const word of words) {
+    if (current.length === 0) {
+      current = word;
+    } else if (current.length + 1 + word.length <= maxWidth) {
+      current += " " + word;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+  }
+  if (current.length > 0) lines.push(current);
+  return lines.map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + "…" : l);
+}
+
+describe("notification overlay — wrapText", () => {
+  test("short text returns single line", () => {
+    const result = wrapText("hello world", 80);
+    assert.deepStrictEqual(result, ["hello world"]);
+  });
+
+  test("long text wraps at word boundaries", () => {
+    const text = "This is a long notification message that should wrap across multiple lines";
+    const result = wrapText(text, 40);
+    assert.ok(result.length > 1, `expected multiple lines, got ${result.length}`);
+    for (const line of result) {
+      assert.ok(line.length <= 40, `line exceeds maxWidth: "${line}" (${line.length})`);
+    }
+  });
+
+  test("single word exceeding maxWidth is truncated", () => {
+    const result = wrapText("superlongwordthatexceedsmaxwidth", 10);
+    assert.equal(result.length, 1);
+    assert.equal(result[0]!.length, 10);
+    assert.ok(result[0]!.endsWith("…"));
+  });
+
+  test("empty string returns single empty line", () => {
+    const result = wrapText("", 80);
+    assert.deepStrictEqual(result, [""]);
+  });
+
+  test("exact-fit text returns single line", () => {
+    const text = "exactly twenty chars";
+    const result = wrapText(text, 20);
+    assert.deepStrictEqual(result, [text]);
+  });
+
+  test("preserves all words across wrapped lines", () => {
+    const words = ["alpha", "bravo", "charlie", "delta", "echo", "foxtrot"];
+    const text = words.join(" ");
+    const result = wrapText(text, 15);
+    const rejoined = result.join(" ");
+    for (const w of words) {
+      assert.ok(rejoined.includes(w), `missing word: ${w}`);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -0,0 +1,282 @@
+// GSD Extension — Notification Store Tests
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  initNotificationStore,
+  appendNotification,
+  readNotifications,
+  markAllRead,
+  clearNotifications,
+  getUnreadCount,
+  getLineCount,
+  suppressPersistence,
+  unsuppressPersistence,
+  _resetNotificationStore,
+} from "../notification-store.js";
+
+describe("notification-store", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "gsd-notif-test-"));
+    mkdirSync(join(tmp, ".gsd"), { recursive: true });
+    _resetNotificationStore();
+  });
+
+  afterEach(() => {
+    _resetNotificationStore();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("appendNotification creates file and writes entry", () => {
+    initNotificationStore(tmp);
+    appendNotification("test message", "info");
+
+    const filePath = join(tmp, ".gsd", "notifications.jsonl");
+    assert.ok(existsSync(filePath));
+
+    const content = readFileSync(filePath, "utf-8").trim();
+    const entry = JSON.parse(content);
+    assert.equal(entry.message, "test message");
+    assert.equal(entry.severity, "info");
+    assert.equal(entry.source, "notify");
+    assert.equal(entry.read, false);
+    assert.ok(entry.id);
+    assert.ok(entry.ts);
+  });
+
+  test("readNotifications returns newest-first", () => {
+    initNotificationStore(tmp);
+    appendNotification("first", "info");
+    appendNotification("second", "warning");
+    appendNotification("third", "error");
+
+    const entries = readNotifications();
+    assert.equal(entries.length, 3);
+    assert.equal(entries[0].message, "third");
+    assert.equal(entries[1].message, "second");
+    assert.equal(entries[2].message, "first");
+  });
+
+  test("getUnreadCount tracks appends", () => {
+    initNotificationStore(tmp);
+    assert.equal(getUnreadCount(), 0);
+
+    appendNotification("msg1", "info");
+    assert.equal(getUnreadCount(), 1);
+
+    appendNotification("msg2", "warning");
+    assert.equal(getUnreadCount(), 2);
+  });
+
+  test("markAllRead sets all entries to read", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+    appendNotification("msg2", "warning");
+
+    assert.equal(getUnreadCount(), 2);
+
+    markAllRead();
+
+    assert.equal(getUnreadCount(), 0);
+
+    const entries = readNotifications();
+    assert.ok(entries.every((e) => e.read === true));
+  });
+
+  test("clearNotifications empties the file", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+    appendNotification("msg2", "error");
+
+    assert.equal(getLineCount(), 2);
+
+    clearNotifications();
+
+    assert.equal(getLineCount(), 0);
+    assert.equal(getUnreadCount(), 0);
+    assert.equal(readNotifications().length, 0);
+  });
+
+  test("rotation keeps only 500 entries", () => {
+    initNotificationStore(tmp);
+
+    for (let i = 0; i < 510; i++) {
+      appendNotification(`msg-${i}`, "info");
+    }
+
+    const entries = readNotifications();
+    assert.ok(entries.length <= 500, `Expected <= 500 entries, got ${entries.length}`);
+    // Most recent should be msg-509
+    assert.equal(entries[0].message, "msg-509");
+  });
+
+  test("source field is preserved", () => {
+    initNotificationStore(tmp);
+    appendNotification("from notify", "info", "notify");
+    appendNotification("from logger", "warning", "workflow-logger");
+
+    const entries = readNotifications();
+    assert.equal(entries[0].source, "workflow-logger");
+    assert.equal(entries[1].source, "notify");
+  });
+
+  test("messages are truncated at 500 chars", () => {
+    initNotificationStore(tmp);
+    const longMsg = "x".repeat(600);
+    appendNotification(longMsg, "info");
+
+    const entries = readNotifications();
+    assert.ok(entries[0].message.length <= 501); // 500 + "…"
+    assert.ok(entries[0].message.endsWith("…"));
+  });
+
+  test("readNotifications with explicit basePath works", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    // Read with explicit basePath
+    _resetNotificationStore();
+    const entries = readNotifications(tmp);
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].message, "msg1");
+  });
+
+  test("init seeds counters from existing file", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+    appendNotification("msg2", "warning");
+
+    // Reset and re-init — should seed from disk
+    _resetNotificationStore();
+    initNotificationStore(tmp);
+
+    assert.equal(getLineCount(), 2);
+    assert.equal(getUnreadCount(), 2);
+  });
+
+  test("no-op when store not initialized", () => {
+    // Should not throw
+    appendNotification("msg", "info");
+    assert.equal(readNotifications().length, 0);
+    assert.equal(getUnreadCount(), 0);
+  });
+
+  test("suppressPersistence prevents writes", () => {
+    initNotificationStore(tmp);
+    appendNotification("before", "info");
+    assert.equal(getLineCount(), 1);
+
+    suppressPersistence();
+    appendNotification("suppressed", "info");
+    assert.equal(getLineCount(), 1); // still 1
+
+    unsuppressPersistence();
+    appendNotification("after", "info");
+    assert.equal(getLineCount(), 2); // now 2
+
+    const entries = readNotifications();
+    assert.equal(entries[0].message, "after");
+    assert.equal(entries[1].message, "before");
+    // "suppressed" should not appear
+    assert.ok(!entries.some((e) => e.message === "suppressed"));
+  });
+
+  test("suppressPersistence is ref-counted", () => {
+    initNotificationStore(tmp);
+    suppressPersistence();
+    suppressPersistence();
+    unsuppressPersistence();
+    // Still suppressed (one suppress remaining)
+    appendNotification("still suppressed", "info");
+    assert.equal(getLineCount(), 0);
+
+    unsuppressPersistence();
+    appendNotification("now works", "info");
+    assert.equal(getLineCount(), 1);
+  });
+
+  test("reinit switches to new project path", () => {
+    const tmp2 = mkdtempSync(join(tmpdir(), "gsd-notif-test2-"));
+    mkdirSync(join(tmp2, ".gsd"), { recursive: true });
+
+    initNotificationStore(tmp);
+    appendNotification("project1", "info");
+
+    // Switch to new project
+    initNotificationStore(tmp2);
+    appendNotification("project2", "info");
+
+    // project2 should only have its own entry
+    const entries = readNotifications();
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].message, "project2");
+
+    // project1 should still have its entry
+    const p1Entries = readNotifications(tmp);
+    assert.equal(p1Entries.length, 1);
+    assert.equal(p1Entries[0].message, "project1");
+
+    rmSync(tmp2, { recursive: true, force: true });
+  });
+
+  test("counters resync from disk after markAllRead", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+    appendNotification("msg2", "info");
+    assert.equal(getUnreadCount(), 2);
+    assert.equal(getLineCount(), 2);
+
+    markAllRead();
+    assert.equal(getUnreadCount(), 0);
+    assert.equal(getLineCount(), 2); // entries still exist, just marked read
+  });
+
+  test("counters resync from disk after clearNotifications", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+    appendNotification("msg2", "info");
+
+    clearNotifications();
+    assert.equal(getUnreadCount(), 0);
+    assert.equal(getLineCount(), 0);
+  });
+
+  test("markAllRead does not delete a foreign lock file", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    // Simulate another process holding the lock
+    const lockPath = join(tmp, ".gsd", "notifications.lock");
+    writeFileSync(lockPath, String(Date.now()), "utf-8");
+
+    // markAllRead should still work (best-effort) but not delete the foreign lock
+    markAllRead();
+
+    assert.ok(existsSync(lockPath), "foreign lock file should not be deleted");
+
+    // Clean up the lock so afterEach doesn't leave artifacts
+    rmSync(lockPath, { force: true });
+  });
+
+  test("clearNotifications does not delete a foreign lock file", () => {
+    initNotificationStore(tmp);
+    appendNotification("msg1", "info");
+
+    // Simulate another process holding the lock
+    const lockPath = join(tmp, ".gsd", "notifications.lock");
+    writeFileSync(lockPath, String(Date.now()), "utf-8");
+
+    // clearNotifications should still work but not delete the foreign lock
+    clearNotifications();
+
+    assert.ok(existsSync(lockPath), "foreign lock file should not be deleted");
+
+    rmSync(lockPath, { force: true });
+  });
+});

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Parallel research slices dispatch — structural tests.
+ *
+ * Verifies the dispatch rule and prompt builder exist with correct structure.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
+const templatePath = join(__dirname, "..", "prompts", "parallel-research-slices.md");
+const templateSrc = readFileSync(templatePath, "utf-8");
+
+// ─── Dispatch rule ────────────────────────────────────────────────────────
+
+test("dispatch: parallel-research-slices rule exists", () => {
+  assert.ok(
+    dispatchSrc.includes("parallel-research-slices"),
+    "dispatch table should have parallel-research-slices rule",
+  );
+});
+
+test("dispatch: parallel-research-slices requires 2+ slices", () => {
+  assert.ok(
+    dispatchSrc.includes("researchReadySlices.length < 2"),
+    "rule should require at least 2 slices for parallel dispatch",
+  );
+});
+
+test("dispatch: parallel-research-slices respects skip_research", () => {
+  const ruleIdx = dispatchSrc.indexOf("parallel-research-slices");
+  const ruleBlock = dispatchSrc.slice(ruleIdx, ruleIdx + 500);
+  assert.ok(
+    ruleBlock.includes("skip_research") || dispatchSrc.slice(ruleIdx - 300, ruleIdx).includes("skip_research"),
+    "rule should check skip_research preference",
+  );
+});
+
+// ─── Prompt builder ───────────────────────────────────────────────────────
+
+test("prompt: buildParallelResearchSlicesPrompt exported", () => {
+  assert.ok(
+    promptsSrc.includes("export async function buildParallelResearchSlicesPrompt"),
+    "buildParallelResearchSlicesPrompt should be exported",
+  );
+});
+
+test("prompt: builds per-slice subagent prompts", () => {
+  assert.ok(
+    promptsSrc.includes("buildResearchSlicePrompt"),
+    "parallel prompt builder should delegate to per-slice research prompts",
+  );
+});
+
+// ─── Template ─────────────────────────────────────────────────────────────
+
+test("template: parallel-research-slices.md has required variables", () => {
+  assert.ok(templateSrc.includes("{{sliceCount}}"), "template should use sliceCount");
+  assert.ok(templateSrc.includes("{{mid}}"), "template should use mid");
+  assert.ok(templateSrc.includes("{{subagentPrompts}}"), "template should use subagentPrompts");
+});
+
+// ─── Validate milestone prompt ────────────────────────────────────────────
+
+test("template: validate-milestone uses parallel reviewers", () => {
+  const validateSrc = readFileSync(join(__dirname, "..", "prompts", "validate-milestone.md"), "utf-8");
+  assert.ok(
+    validateSrc.includes("Reviewer A") && validateSrc.includes("Reviewer B") && validateSrc.includes("Reviewer C"),
+    "validate-milestone should dispatch 3 parallel reviewers",
+  );
+});

package/src/resources/extensions/gsd/tests/phantom-ghost-detection.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Regression test for #3671 — isGhostMilestone detects phantom queued rows
+ *
+ * gsd_milestone_generate_id inserts a DB row with status "queued" as a side
+ * effect. If the milestone is never planned, isGhostMilestone previously
+ * returned false for any milestone with a DB row, blocking the state machine.
+ *
+ * The fix makes isGhostMilestone treat a "queued" DB row with no disk
+ * artifacts (CONTEXT, ROADMAP, SUMMARY) as a ghost.
+ *
+ * This structural test verifies the dbRow.status === 'queued' guard exists.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'state.ts'), 'utf-8');
+
+describe('isGhostMilestone phantom queued detection (#3671)', () => {
+  test('isGhostMilestone function exists', () => {
+    assert.match(source, /export function isGhostMilestone\(/,
+      'isGhostMilestone should be exported');
+  });
+
+  test('checks dbRow.status === queued', () => {
+    assert.match(source, /dbRow\.status\s*===\s*['"]queued['"]/,
+      'isGhostMilestone should check dbRow.status === "queued"');
+  });
+
+  test('checks for CONTEXT disk artifact', () => {
+    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']CONTEXT["']\)/,
+      'should check for CONTEXT file');
+  });
+
+  test('checks for ROADMAP disk artifact', () => {
+    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']ROADMAP["']\)/,
+      'should check for ROADMAP file');
+  });
+
+  test('checks for SUMMARY disk artifact', () => {
+    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']SUMMARY["']\)/,
+      'should check for SUMMARY file');
+  });
+
+  test('returns !hasContent for queued rows (ghost if no artifacts)', () => {
+    assert.match(source, /return !hasContent/,
+      'should return !hasContent for queued phantom milestones');
+  });
+});

package/src/resources/extensions/gsd/tests/phantom-milestone-default-queued.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Regression test for #3695 — insertMilestone defaults status to "queued"
+ *
+ * Milestones were being auto-created with status "active", causing phantom
+ * milestones to appear as active work.  The fix defaults to "queued" so
+ * new milestones must be explicitly activated.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const dbSrc = readFileSync(
+  join(__dirname, '..', 'gsd-db.ts'),
+  'utf-8',
+);
+
+describe('insertMilestone defaults status to queued (#3695)', () => {
+  test('insertMilestone function exists', () => {
+    assert.match(dbSrc, /export function insertMilestone\(/,
+      'insertMilestone should be exported from gsd-db.ts');
+  });
+
+  test('default status is "queued" not "active"', () => {
+    // The status parameter should default to "queued" via nullish coalescing
+    assert.match(dbSrc, /m\.status\s*\?\?\s*"queued"/,
+      'insertMilestone should default status to "queued"');
+  });
+
+  test('comment explains the rationale', () => {
+    assert.match(dbSrc, /never auto-create milestones as "active"/i,
+      'should have a comment explaining why default is queued');
+  });
+});