gsd-pi 2.81.0 → 2.82.0-dev.2841a1e44

package/src/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -14,7 +14,7 @@ import { parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
 import { invalidateAllCaches } from '../cache.ts';
 import { ensureDbOpen } from '../bootstrap/dynamic-tools.ts';
-import { closeDatabase, getAllMilestones } from '../gsd-db.ts';
+import { closeDatabase, getAllMilestones, getArtifact } from '../gsd-db.ts';
 import { importWrittenMigrationToDb } from '../migrate/command.ts';
 import type {
   GSDProject,
@@ -336,7 +336,12 @@ test('Scenario 2: Fully complete project — deriveState phase', async () => {
       assert.deepStrictEqual(preview.taskCompletionPct, 100, 'complete: preview taskCompletionPct');
       assert.deepStrictEqual(preview.requirements.total, 0, 'complete: preview requirements total');
 
+      const imported = await importWrittenMigrationToDb(base, preview);
+      assert.ok(imported.artifacts >= 6, 'complete: imports generated milestone artifacts');
+      assert.ok(getArtifact('milestones/M001/M001-VALIDATION.md') !== null, 'complete: M001-VALIDATION.md imported as artifact');
+      assert.ok(getArtifact('milestones/M001/M001-SUMMARY.md') !== null, 'complete: M001-SUMMARY.md imported as artifact');
     } finally {
+      closeDatabase();
       rmSync(base, { recursive: true, force: true });
     }
 });

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

@@ -1,55 +1,53 @@
-// GSD Extension — Notification Overlay Tests
-// Tests for message wrapping in the notification panel.
-// Mirrors the private wrapText from notification-overlay.ts so its contract
-// can be exercised without exporting internals.
+// Project/App: GSD-2
+// File Purpose: Regression tests for notification overlay wrapping and width-safe rendering.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { visibleWidth } from "@gsd/pi-tui";
+import { appendNotification, initNotificationStore, _resetNotificationStore } from "../notification-store.ts";
+import { GSDNotificationOverlay, notificationOverlayOptions } from "../notification-overlay.ts";
+import { wrapVisibleText } from "../tui/render-kit.ts";
 
-// ── wrapText logic (mirrors the private function in notification-overlay.ts) ──
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
 
-function wrapText(text: string, maxWidth: number): string[] {
-  if (maxWidth <= 0) return [text];
-  const lines = wrapTextWithAnsi(text, maxWidth);
-  return lines.map((l) =>
-    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
-  );
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds maxWidth: visibleWidth=${visibleWidth(line)} max=${width}: "${line}"`,
+    );
+  }
 }
 
 describe("notification overlay — wrapText", () => {
   test("short text returns single line", () => {
-    const result = wrapText("hello world", 80);
+    const result = wrapVisibleText("hello world", 80);
     assert.deepStrictEqual(result, ["hello world"]);
   });
 
   test("long text wraps at word boundaries without exceeding maxWidth", () => {
     const text = "This is a long notification message that should wrap across multiple lines";
-    const result = wrapText(text, 40);
+    const result = wrapVisibleText(text, 40);
     assert.ok(result.length > 1, `expected multiple lines, got ${result.length}`);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= 40,
-        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
-      );
-    }
+    assertLinesFit(result, 40);
   });
 
   test("single word exceeding maxWidth is broken to fit column budget", () => {
-    const result = wrapText("superlongwordthatexceedsmaxwidth", 10);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= 10,
-        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
-      );
-    }
+    const result = wrapVisibleText("superlongwordthatexceedsmaxwidth", 10);
+    assertLinesFit(result, 10);
   });
 
   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 result = wrapVisibleText(text, 15);
     const rejoined = result.join(" ");
     for (const w of words) {
       assert.ok(rejoined.includes(w), `missing word: ${w}`);
@@ -70,23 +68,62 @@ describe("notification overlay — wrapText", () => {
       "(expired — will auto-refresh) ✗ google — not configured " +
       "(aistudio.google.com/apikey) ✗ groq — not configured";
     const maxWidth = 118;
-    const result = wrapText(msg, maxWidth);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= maxWidth,
-        `line exceeds column budget: visibleWidth=${visibleWidth(line)} max=${maxWidth}: "${line}"`,
-      );
-    }
+    const result = wrapVisibleText(msg, maxWidth);
+    assertLinesFit(result, maxWidth);
   });
 
   test("unbreakable long token (URL) is clamped to maxWidth", () => {
     const url = "https://example.com/" + "a".repeat(200);
-    const result = wrapText(url, 40);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= 40,
-        `line exceeds maxWidth: visibleWidth=${visibleWidth(line)} line="${line}"`,
-      );
+    const result = wrapVisibleText(url, 40);
+    assertLinesFit(result, 40);
+  });
+
+  test("real overlay render fits common terminal widths", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "gsd-notification-overlay-"));
+    t.after(() => {
+      _resetNotificationStore();
+      rmSync(dir, { recursive: true, force: true });
+    });
+
+    initNotificationStore(dir);
+    appendNotification("A long notification with " + "x".repeat(180), "warning");
+
+    const overlay = new GSDNotificationOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+    t.after(() => overlay.dispose());
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
     }
   });
+
+  test("rendered height stays within the configured overlay max height", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "gsd-notification-overlay-height-"));
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 40, configurable: true });
+
+    t.after(() => {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+      _resetNotificationStore();
+      rmSync(dir, { recursive: true, force: true });
+    });
+
+    initNotificationStore(dir);
+    for (let i = 0; i < 80; i++) {
+      appendNotification(`notification-${i + 1} with enough text to exercise clipping`, "warning");
+    }
+
+    const overlay = new GSDNotificationOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+    t.after(() => overlay.dispose());
+
+    const rendered = overlay.render(100);
+    const maxHeight = Math.floor((40 * 52) / 100);
+    assert.ok(rendered.length <= maxHeight, `expected ${rendered.length} lines to fit maxHeight ${maxHeight}`);
+    assert.ok(rendered.at(-1)?.includes("╯"), "bottom border should remain visible");
+    assert.equal(notificationOverlayOptions().maxHeight, "52%");
+  });
 });

package/src/resources/extensions/gsd/tests/notifications-handler.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Tests for /gsd notifications command handling and overlay launch behavior.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { join } from "node:path";
@@ -58,6 +61,47 @@ test("notifications command falls back to text output when overlay returns undef
   assert.match(notices[0].message, /Recent notifications:/);
 });
 
+test("notifications command opens a compact bounded overlay", async (t) => {
+  const base = makeTempDir("overlay-options");
+  initNotificationStore(base);
+  appendNotification("Build complete", "success");
+
+  t.after(() => {
+    _resetNotificationStore();
+    cleanup(base);
+  });
+
+  const notices: Array<{ message: string; level?: string }> = [];
+  let capturedOptions: any;
+  await handleNotificationsCommand(
+    "",
+    {
+      hasUI: true,
+      ui: {
+        custom: async (_factory: any, options: any) => {
+          capturedOptions = options;
+          return true;
+        },
+        notify: (message: string, level?: string) => {
+          notices.push({ message, level });
+        },
+      },
+    } as any,
+    {} as any,
+  );
+
+  assert.deepEqual(capturedOptions?.overlayOptions, {
+    width: "58%",
+    minWidth: 68,
+    maxHeight: "52%",
+    anchor: "top-center",
+    row: "24%",
+    margin: { top: 2, right: 2, bottom: 6, left: 2 },
+    backdrop: true,
+  });
+  assert.equal(notices.length, 0, "successful overlay should not emit text fallback");
+});
+
 test("notifications tail caps inline output and hints to open overlay", async (t) => {
   const base = makeTempDir("tail-cap");
   initNotificationStore(base);

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -33,43 +33,6 @@ import {
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
-import {
-  WorktreeLifecycle,
-  type WorktreeLifecycleDeps,
-  type NotifyCtx,
-} from "../worktree-lifecycle.ts";
-import { WorktreeStateProjection } from "../worktree-state-projection.ts";
-import { resolveWorktreeProjectRoot } from "../worktree-root.ts";
-import { AutoSession } from "../auto/session.ts";
-
-// Test-local: LegacyTestDeps had three fields Lifecycle does not need
-// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
-// Permit them in test fixtures so existing override patterns keep working —
-// Lifecycle ignores the extras via structural typing.
-type LegacyTestDeps = WorktreeLifecycleDeps & {
-  shouldUseWorktreeIsolation?: () => boolean;
-  syncWorktreeStateBack?: (
-    mainBasePath: string,
-    worktreePath: string,
-    milestoneId: string,
-  ) => { synced: string[] };
-  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
-};
-
-/** Shim factory preserving the legacy WorktreeResolver throw shape for tests. */
-function makeResolver(s: AutoSession, deps: LegacyTestDeps) {
-  const lifecycle = new WorktreeLifecycle(s, deps);
-  return {
-    get workPath(): string { return s.basePath; },
-    get projectRoot(): string {
-      return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
-    },
-    mergeAndExit: (mid: string, ctx: NotifyCtx) => {
-      const r = lifecycle.exitMilestone(mid, { merge: true }, ctx);
-      if (!r.ok && r.cause instanceof Error) throw r.cause;
-    },
-  };
-}
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -91,97 +54,6 @@ function createTempRepo(t: { after: (fn: () => void) => void }): string {
   return dir;
 }
 
-function makeSession(overrides?: Partial<{ basePath: string; originalBasePath: string }>): AutoSession {
-  const s = new AutoSession();
-  s.basePath = overrides?.basePath ?? "/project";
-  s.originalBasePath = overrides?.originalBasePath ?? "/project";
-  return s;
-}
-
-interface CallLog { fn: string; args: unknown[] }
-
-function makeDeps(overrides?: Partial<LegacyTestDeps>): LegacyTestDeps & { calls: CallLog[] } {
-  const calls: CallLog[] = [];
-
-  const deps: LegacyTestDeps & { calls: CallLog[] } = {
-    calls,
-    isInAutoWorktree: (basePath: string) => {
-      calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-      return basePath.includes("worktrees");
-    },
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: (basePath: string, milestoneId: string, roadmapContent: string) => {
-      calls.push({ fn: "mergeMilestoneToMain", args: [basePath, milestoneId, roadmapContent] });
-      return { pushed: false, codeFilesChanged: true };
-    },
-    syncWorktreeStateBack: (mainBasePath: string, worktreePath: string, milestoneId: string) => {
-      calls.push({ fn: "syncWorktreeStateBack", args: [mainBasePath, worktreePath, milestoneId] });
-      return { synced: [] };
-    },
-    teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-      calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-    },
-    createAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "createAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    enterAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "enterAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    getAutoWorktreePath: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "getAutoWorktreePath", args: [basePath, milestoneId] });
-      return null;
-    },
-    autoCommitCurrentBranch: (basePath: string, reason: string, milestoneId: string) => {
-      calls.push({ fn: "autoCommitCurrentBranch", args: [basePath, reason, milestoneId] });
-    },
-    getCurrentBranch: (basePath: string) => {
-      calls.push({ fn: "getCurrentBranch", args: [basePath] });
-      return "main";
-    },
-    checkoutBranch: (basePath: string, branch: string) => {
-      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
-    },
-    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
-    resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-      calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-      return null;
-    },
-    readFileSync: (path: string, _enc: string) => {
-      calls.push({ fn: "readFileSync", args: [path] });
-      return "# Roadmap\n";
-    },
-    GitServiceImpl: class {
-      constructor(_basePath: string, _gitConfig: unknown) {}
-    } as unknown as LegacyTestDeps["GitServiceImpl"],
-    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
-    invalidateAllCaches: () => { calls.push({ fn: "invalidateAllCaches", args: [] }); },
-    captureIntegrationBranch: (_basePath: string, _mid: string | undefined) => {},
-    enterBranchModeForMilestone: (_basePath: string, _milestoneId: string) => {},
-    worktreeProjection: new WorktreeStateProjection(),
-    ...overrides,
-  };
-
-  if (overrides) {
-    for (const [key, val] of Object.entries(overrides)) {
-      if (key !== "calls") (deps as unknown as Record<string, unknown>)[key] = val;
-    }
-  }
-  return deps;
-}
-
-function makeNotifyCtx(): NotifyCtx & { messages: Array<{ msg: string; level?: string }> } {
-  const messages: Array<{ msg: string; level?: string }> = [];
-  return {
-    messages,
-    notify: (msg: string, level?: "info" | "warning" | "error" | "success") => {
-      messages.push({ msg, level });
-    },
-  };
-}
-
 // ─── Suite 1: getAutoWorktreeOriginalBase() returns realpath-canonical path ──
 
 describe("getAutoWorktreeOriginalBase() is realpath-normalised", () => {
@@ -273,92 +145,15 @@ describe("normalizeWorktreePathForCompare equalises canonical vs non-canonical f
 // resolveMilestoneFile call against the "worktree" path that is actually the
 // same directory). The new code correctly skips the fallback.
 
-describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physical path as originalBase", () => {
-  test("with trailing-slash basePath equal to originalBase: resolveMilestoneFile called once", () => {
-    // originalBase is canonical (as returned by workspace registry)
-    const canonicalBase = "/tmp/m5-test-project";
-    // s.basePath has a trailing slash — same physical dir, non-canonical string
-    const trailingSlashBase = canonicalBase + "/";
-
-    const s = makeSession({
-      basePath: trailingSlashBase,
-      originalBasePath: canonicalBase,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      // isInAutoWorktree: basePath has trailing slash but is NOT a worktree
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return false;
-      },
-      // resolveMilestoneFile always returns null (no roadmap found)
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null;
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-
-    // Override calls ref so we can inspect it directly
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    // mergeAndExit → _mergeWorktreeMode
-    // originalBase = s.originalBasePath = canonicalBase
-    // s.basePath = trailingSlashBase — physically same as canonicalBase
-    // Post-fix: isSamePath(trailingSlashBase, canonicalBase) is true
-    //   → roadmap fallback branch is skipped (resolveMilestoneFile called once)
-    // Pre-fix (bug): trailingSlashBase !== canonicalBase → fallback entered
-    //   → resolveMilestoneFile called twice
-
-    resolver.mergeAndExit("M001", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 1,
-      "resolveMilestoneFile must be called exactly once — fallback should be skipped when " +
-      "s.basePath is the same physical path as originalBase (isSamePath fix)");
-  });
-
-  test("with genuinely different basePath (inside worktree): resolveMilestoneFile called twice", () => {
-    // originalBase is the project root
-    const projectRoot = "/tmp/m5-test-project";
-    // s.basePath is inside a worktree — a physically different path
-    const worktreePath = projectRoot + "/.gsd/worktrees/M002";
-
-    const s = makeSession({
-      basePath: worktreePath,
-      originalBasePath: projectRoot,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return basePath.includes("worktrees");
-      },
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null; // no roadmap in either location
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    resolver.mergeAndExit("M002", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 2,
-      "resolveMilestoneFile must be called twice when basePath is a genuine worktree path " +
-      "(fallback should run for different physical paths)");
-  });
-});
+// ADR-016 phase 2 / C2 + C3 (#5625, #5626): the prior two tests in this
+// suite asserted call counts on `deps.resolveMilestoneFile` /
+// `deps.isInAutoWorktree` / `deps.teardownAutoWorktree` to verify that the
+// roadmap-fallback branch was skipped when basePath was a non-canonical
+// form of originalBase (trailing slash). After C2/C3 those fields are
+// inlined into worktree-lifecycle.ts as direct imports — the mocks no
+// longer fire and the call-count assertions test nothing meaningful. The
+// underlying invariant (isSamePathPhysical normalises trailing slashes,
+// canonical/non-canonical pairs, and case differences) is preserved
+// inside worktree-lifecycle.ts and covered indirectly by the merge-area
+// integration tests, which exercise real worktree merges where the
+// fallback choice matters.

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

@@ -1,11 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for parallel monitor overlay rendering and input handling.
+
 import { describe, it } from "node:test";
-import assert from "node:assert";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
 
-/**
- * Basic tests for the parallel monitor overlay data helpers.
- * The overlay is primarily a rendering component that reads existing
- * status files — these tests verify the helper logic in isolation.
- */
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
 
 describe("parallel-monitor-overlay", () => {
   it("progressBar generates correct width", async () => {
@@ -37,6 +45,7 @@ describe("parallel-monitor-overlay", () => {
     const lines = overlay.render(80);
     assert.ok(Array.isArray(lines), "render should return an array");
     assert.ok(lines.length > 0, "render should return at least one line");
+    assertLinesFit(lines, 80);
 
     // Should contain header text
     const joined = lines.join("\n");
@@ -79,4 +88,27 @@ describe("parallel-monitor-overlay", () => {
     assert.equal((overlay as any).scrollOffset, 0, "empty overlays clamp scroll to zero");
     overlay.dispose();
   });
+
+  it("ParallelMonitorOverlay empty state fits narrow and wide widths", async () => {
+    const mod = await import("../parallel-monitor-overlay.js");
+
+    const mockTui = { requestRender: () => {} };
+    const mockTheme = {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const overlay = new mod.ParallelMonitorOverlay(
+      mockTui,
+      mockTheme as any,
+      () => {},
+      "/nonexistent/path",
+    );
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
+    }
+
+    overlay.dispose();
+  });
 });