gsd-pi 2.34.0-dev.ed0bfbf → 2.35.0-dev.55dcc60

package/src/resources/extensions/gsd/tests/commands-inspect-open-db.test.ts

@@ -0,0 +1,46 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+
+import { handleInspect } from "../commands-inspect.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+
+test("/gsd inspect opens existing database when it was not yet opened in session", async () => {
+  closeDatabase();
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-inspect-db-"));
+  const prevCwd = process.cwd();
+
+  try {
+    const gsdDir = path.join(tmp, ".gsd");
+    fs.mkdirSync(gsdDir, { recursive: true });
+    const dbPath = path.join(gsdDir, "gsd.db");
+
+    assert.equal(openDatabase(dbPath), true);
+    closeDatabase();
+
+    process.chdir(tmp);
+
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: {
+        notify(message: string, level: string) {
+          notifications.push({ message, level });
+        },
+      },
+    } as any;
+
+    await handleInspect(ctx);
+
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0].level, "info");
+    assert.match(notifications[0].message, /=== GSD Database Inspect ===/);
+    assert.doesNotMatch(notifications[0].message, /No GSD database available/);
+  } finally {
+    process.chdir(prevCwd);
+    closeDatabase();
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/doctor-git.test.ts

@@ -2,9 +2,10 @@
  * doctor-git.test.ts — Integration tests for doctor git health checks.
  *
  * Creates real temp git repos with deliberate broken state, runs runGSDDoctor,
- * and asserts correct detection and fixing of all 4 git issue codes:
+ * and asserts correct detection and fixing of git issue codes:
  *   orphaned_auto_worktree, stale_milestone_branch,
- *   corrupt_merge_state, tracked_runtime_files
+ *   corrupt_merge_state, tracked_runtime_files,
+ *   integration_branch_missing, worktree_directory_orphaned
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
@@ -299,6 +300,101 @@ async function main(): Promise<void> {
       console.log("\n=== none-mode skips stale branch (skipped on Windows) ===");
     }
 
+    // ─── Test: Integration branch missing ──────────────────────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== integration_branch_missing ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Write integration branch metadata for M001 pointing to a non-existent branch
+      const metaPath = join(dir, ".gsd", "milestones", "M001", "M001-META.json");
+      writeFileSync(metaPath, JSON.stringify({ integrationBranch: "feat/does-not-exist" }, null, 2));
+
+      const detect = await runGSDDoctor(dir);
+      const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
+      assertTrue(missingBranchIssues.length > 0, "detects missing integration branch");
+      assertTrue(
+        missingBranchIssues[0]?.message.includes("feat/does-not-exist"),
+        "message includes the missing branch name",
+      );
+      assertEq(missingBranchIssues[0]?.fixable, false, "integration_branch_missing is not auto-fixable");
+      assertEq(missingBranchIssues[0]?.severity, "error", "severity is error");
+    }
+    } else {
+      console.log("\n=== integration_branch_missing (skipped on Windows) ===");
+    }
+
+    // ─── Test: Integration branch present — no false positive ──────────
+    if (process.platform !== "win32") {
+    console.log("\n=== integration_branch_missing (no false positive) ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Write integration branch metadata for M001 pointing to "main" (which exists)
+      const metaPath = join(dir, ".gsd", "milestones", "M001", "M001-META.json");
+      writeFileSync(metaPath, JSON.stringify({ integrationBranch: "main" }, null, 2));
+
+      const detect = await runGSDDoctor(dir);
+      const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
+      assertEq(missingBranchIssues.length, 0, "existing integration branch NOT flagged");
+    }
+    } else {
+      console.log("\n=== integration_branch_missing (no false positive — skipped on Windows) ===");
+    }
+
+    // ─── Test: Orphaned worktree directory ─────────────────────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== worktree_directory_orphaned ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create a worktrees/ dir with an entry that is NOT in git worktree list
+      const orphanDir = join(dir, ".gsd", "worktrees", "orphan-feature");
+      mkdirSync(orphanDir, { recursive: true });
+      writeFileSync(join(orphanDir, "some-file.txt"), "leftover content\n");
+
+      const detect = await runGSDDoctor(dir);
+      const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
+      assertTrue(orphanDirIssues.length > 0, "detects orphaned worktree directory");
+      assertTrue(
+        orphanDirIssues[0]?.message.includes("orphan-feature"),
+        "message includes the orphaned directory name",
+      );
+      assertTrue(orphanDirIssues[0]?.fixable === true, "worktree_directory_orphaned is fixable");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(
+        fixed.fixesApplied.some(f => f.includes("removed orphaned worktree directory")),
+        "fix removes orphaned worktree directory",
+      );
+      assertTrue(!existsSync(orphanDir), "orphaned directory removed after fix");
+    }
+    } else {
+      console.log("\n=== worktree_directory_orphaned (skipped on Windows) ===");
+    }
+
+    // ─── Test: Registered worktree NOT flagged as orphaned ─────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== worktree_directory_orphaned (registered worktree not flagged) ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create a real registered worktree under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b worktree/feature-1 .gsd/worktrees/feature-1", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
+      assertEq(orphanDirIssues.length, 0, "registered worktree NOT flagged as orphaned");
+    }
+    } else {
+      console.log("\n=== worktree_directory_orphaned (registered worktree not flagged — skipped on Windows) ===");
+    }
+
     // ─── Test 9: none-mode still detects corrupt merge state ───────────
     console.log("\n=== none-mode keeps corrupt merge state ===");
     {

package/src/resources/extensions/gsd/tests/doctor-runtime.test.ts

@@ -2,9 +2,9 @@
  * doctor-runtime.test.ts — Tests for doctor runtime health checks.
  *
  * Tests detection and auto-fix of:
- *   stale_crash_lock, orphaned_completed_units, stale_hook_state,
- *   activity_log_bloat, state_file_missing, state_file_stale,
- *   gitignore_missing_patterns
+ *   stale_crash_lock, stranded_lock_directory, orphaned_completed_units,
+ *   stale_hook_state, activity_log_bloat, state_file_missing,
+ *   state_file_stale, gitignore_missing_patterns
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, realpathSync } from "node:fs";
@@ -290,6 +290,62 @@ node_modules/
       assertEq(content.length, 0, "all orphaned keys removed");
     }
 
+    // ─── Test: Stranded lock directory detection & fix ────────────────
+    // Skip on Windows: proper-lockfile uses advisory file locking on Windows,
+    // not the directory-based mechanism. The .gsd.lock/ directory pattern is
+    // a POSIX-specific lockfile implementation detail.
+    if (process.platform !== "win32") {
+    console.log("\n=== stranded_lock_directory ===");
+    {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      // Create the proper-lockfile lock directory without a live lock holder.
+      // The lock dir sits at <parent of .gsd>/.gsd.lock (i.e., <basePath>/.gsd.lock).
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+
+      const detect = await runGSDDoctor(dir);
+      const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+      assertTrue(strandedIssues.length > 0, "detects stranded lock directory");
+      assertTrue(strandedIssues[0]?.message.includes("lock directory"), "message describes stranded lock directory");
+      assertTrue(strandedIssues[0]?.fixable === true, "stranded lock dir is fixable");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(
+        fixed.fixesApplied.some(f => f.includes("removed stranded lock directory")),
+        "fix removes stranded lock directory",
+      );
+      assertTrue(!existsSync(lockDir), "lock directory removed after fix");
+    }
+
+    // ─── Test: Stranded lock dir with live lock holder — NOT flagged ───
+    console.log("\n=== stranded_lock_directory (live holder not flagged) ===");
+    {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      // Create lock dir + auto.lock with PID 1 (init/launchd — always alive, never our own PID)
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+      const liveLockData = {
+        pid: 1,
+        startedAt: new Date().toISOString(),
+        unitType: "execute-task",
+        unitId: "M001/S01/T01",
+        unitStartedAt: new Date().toISOString(),
+        completedUnits: 1,
+      };
+      writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(liveLockData, null, 2));
+
+      const detect = await runGSDDoctor(dir);
+      const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+      assertEq(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
+    }
+    } else {
+      console.log("\n=== stranded_lock_directory (skipped on Windows) ===");
+    }
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -175,6 +175,34 @@ test("git fields comprehensive validation", () => {
   assert.equal(preferences.git?.isolation, "branch");
 });
 
+test("auto_visualize, auto_report, compression_strategy, context_selection validate correctly", () => {
+  const { preferences, errors } = validatePreferences({
+    auto_visualize: true,
+    auto_report: false,
+    compression_strategy: "compress",
+    context_selection: "smart",
+  });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.auto_visualize, true);
+  assert.equal(preferences.auto_report, false);
+  assert.equal(preferences.compression_strategy, "compress");
+  assert.equal(preferences.context_selection, "smart");
+});
+
+test("auto_visualize, auto_report, compression_strategy, context_selection reject invalid values", () => {
+  const { errors: e1 } = validatePreferences({ auto_visualize: "yes" as never });
+  assert.ok(e1.some(e => e.includes("auto_visualize")));
+
+  const { errors: e2 } = validatePreferences({ auto_report: 1 as never });
+  assert.ok(e2.some(e => e.includes("auto_report")));
+
+  const { errors: e3 } = validatePreferences({ compression_strategy: "shrink" as never });
+  assert.ok(e3.some(e => e.includes("compression_strategy")));
+
+  const { errors: e4 } = validatePreferences({ context_selection: "partial" as never });
+  assert.ok(e4.some(e => e.includes("context_selection")));
+});
+
 test("all wizard fields together produce no errors", () => {
   const { errors, warnings } = validatePreferences({
     version: 1,

package/src/resources/skills/create-gsd-extension/references/events-reference.md

@@ -61,10 +61,10 @@ pi.on("tool_call", async (event, ctx) => {
 
 **tool_result** — Fired after tool executes. Can modify result. Handlers chain like middleware.
 ```typescript
-import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 pi.on("tool_result", async (event, ctx) => {
-  if (isBashToolResult(event)) {
+  if (isToolResultEventType("bash", event)) {
     // event.details is typed as BashToolDetails
   }
   // Return partial patch: { content, details, isError }
@@ -105,7 +105,7 @@ pi.on("model_select", async (event, ctx) => {
 Built-in type guards for tool events:
 
 ```typescript
-import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 // Tool calls — narrows event.input type
 if (isToolCallEventType("bash", event)) { /* event.input: { command, timeout? } */ }
@@ -114,7 +114,7 @@ if (isToolCallEventType("write", event)) { /* event.input: { path, content } */
 if (isToolCallEventType("edit", event)) { /* event.input: { path, oldText, newText } */ }
 
 // Tool results — narrows event.details type
-if (isBashToolResult(event)) { /* event.details: BashToolDetails */ }
+if (isToolResultEventType("bash", event)) { /* event.details: BashToolDetails */ }
 ```
 
 For custom tools, export your input type and use explicit type params:

package/packages/pi-coding-agent/dist/modes/interactive/theme/dark.json

@@ -1,85 +0,0 @@
-{
-	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
-	"name": "dark",
-	"vars": {
-		"cyan": "#00d7ff",
-		"blue": "#5f87ff",
-		"green": "#b5bd68",
-		"red": "#cc6666",
-		"yellow": "#ffff00",
-		"gray": "#808080",
-		"dimGray": "#666666",
-		"darkGray": "#505050",
-		"accent": "#8abeb7",
-		"selectedBg": "#3a3a4a",
-		"userMsgBg": "#343541",
-		"toolPendingBg": "#282832",
-		"toolSuccessBg": "#283228",
-		"toolErrorBg": "#3c2828",
-		"customMsgBg": "#2d2838"
-	},
-	"colors": {
-		"accent": "accent",
-		"border": "blue",
-		"borderAccent": "cyan",
-		"borderMuted": "darkGray",
-		"success": "green",
-		"error": "red",
-		"warning": "yellow",
-		"muted": "gray",
-		"dim": "dimGray",
-		"text": "",
-		"thinkingText": "gray",
-
-		"selectedBg": "selectedBg",
-		"userMessageBg": "userMsgBg",
-		"userMessageText": "",
-		"customMessageBg": "customMsgBg",
-		"customMessageText": "",
-		"customMessageLabel": "#9575cd",
-		"toolPendingBg": "toolPendingBg",
-		"toolSuccessBg": "toolSuccessBg",
-		"toolErrorBg": "toolErrorBg",
-		"toolTitle": "",
-		"toolOutput": "gray",
-
-		"mdHeading": "#f0c674",
-		"mdLink": "#81a2be",
-		"mdLinkUrl": "dimGray",
-		"mdCode": "accent",
-		"mdCodeBlock": "green",
-		"mdCodeBlockBorder": "gray",
-		"mdQuote": "gray",
-		"mdQuoteBorder": "gray",
-		"mdHr": "gray",
-		"mdListBullet": "accent",
-
-		"toolDiffAdded": "green",
-		"toolDiffRemoved": "red",
-		"toolDiffContext": "gray",
-
-		"syntaxComment": "#6A9955",
-		"syntaxKeyword": "#569CD6",
-		"syntaxFunction": "#DCDCAA",
-		"syntaxVariable": "#9CDCFE",
-		"syntaxString": "#CE9178",
-		"syntaxNumber": "#B5CEA8",
-		"syntaxType": "#4EC9B0",
-		"syntaxOperator": "#D4D4D4",
-		"syntaxPunctuation": "#D4D4D4",
-
-		"thinkingOff": "darkGray",
-		"thinkingMinimal": "#6e6e6e",
-		"thinkingLow": "#5f87af",
-		"thinkingMedium": "#81a2be",
-		"thinkingHigh": "#b294bb",
-		"thinkingXhigh": "#d183e8",
-
-		"bashMode": "green"
-	},
-	"export": {
-		"pageBg": "#18181e",
-		"cardBg": "#1e1e24",
-		"infoBg": "#3c3728"
-	}
-}

package/packages/pi-coding-agent/dist/modes/interactive/theme/light.json

@@ -1,84 +0,0 @@
-{
-	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
-	"name": "light",
-	"vars": {
-		"teal": "#5a8080",
-		"blue": "#547da7",
-		"green": "#588458",
-		"red": "#aa5555",
-		"yellow": "#9a7326",
-		"mediumGray": "#6c6c6c",
-		"dimGray": "#767676",
-		"lightGray": "#b0b0b0",
-		"selectedBg": "#d0d0e0",
-		"userMsgBg": "#e8e8e8",
-		"toolPendingBg": "#e8e8f0",
-		"toolSuccessBg": "#e8f0e8",
-		"toolErrorBg": "#f0e8e8",
-		"customMsgBg": "#ede7f6"
-	},
-	"colors": {
-		"accent": "teal",
-		"border": "blue",
-		"borderAccent": "teal",
-		"borderMuted": "lightGray",
-		"success": "green",
-		"error": "red",
-		"warning": "yellow",
-		"muted": "mediumGray",
-		"dim": "dimGray",
-		"text": "",
-		"thinkingText": "mediumGray",
-
-		"selectedBg": "selectedBg",
-		"userMessageBg": "userMsgBg",
-		"userMessageText": "",
-		"customMessageBg": "customMsgBg",
-		"customMessageText": "",
-		"customMessageLabel": "#7e57c2",
-		"toolPendingBg": "toolPendingBg",
-		"toolSuccessBg": "toolSuccessBg",
-		"toolErrorBg": "toolErrorBg",
-		"toolTitle": "",
-		"toolOutput": "mediumGray",
-
-		"mdHeading": "yellow",
-		"mdLink": "blue",
-		"mdLinkUrl": "dimGray",
-		"mdCode": "teal",
-		"mdCodeBlock": "green",
-		"mdCodeBlockBorder": "mediumGray",
-		"mdQuote": "mediumGray",
-		"mdQuoteBorder": "mediumGray",
-		"mdHr": "mediumGray",
-		"mdListBullet": "green",
-
-		"toolDiffAdded": "green",
-		"toolDiffRemoved": "red",
-		"toolDiffContext": "mediumGray",
-
-		"syntaxComment": "#008000",
-		"syntaxKeyword": "#0000FF",
-		"syntaxFunction": "#795E26",
-		"syntaxVariable": "#001080",
-		"syntaxString": "#A31515",
-		"syntaxNumber": "#098658",
-		"syntaxType": "#267F99",
-		"syntaxOperator": "#000000",
-		"syntaxPunctuation": "#000000",
-
-		"thinkingOff": "lightGray",
-		"thinkingMinimal": "#767676",
-		"thinkingLow": "blue",
-		"thinkingMedium": "teal",
-		"thinkingHigh": "#875f87",
-		"thinkingXhigh": "#8b008b",
-
-		"bashMode": "green"
-	},
-	"export": {
-		"pageBg": "#f8f8f8",
-		"cardBg": "#ffffff",
-		"infoBg": "#fffae6"
-	}
-}