gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

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

@@ -36,176 +36,156 @@ function makeTempDir(prefix: string): string {
 
 // ─── appendCapture ────────────────────────────────────────────────────────────
 
-test("captures: appendCapture creates CAPTURES.md on first call", () => {
+test("captures: appendCapture creates CAPTURES.md on first call", (t) => {
   const tmp = makeTempDir("cap-create");
-  try {
-    const id = appendCapture(tmp, "first thought");
-    assert.ok(id.startsWith("CAP-"), "ID should start with CAP-");
-    assert.ok(
-      existsSync(join(tmp, ".gsd", "CAPTURES.md")),
-      "CAPTURES.md should exist",
-    );
-    const content = readFileSync(join(tmp, ".gsd", "CAPTURES.md"), "utf-8");
-    assert.ok(content.includes("# Captures"), "should have header");
-    assert.ok(content.includes(`### ${id}`), "should have entry heading");
-    assert.ok(
-      content.includes("**Text:** first thought"),
-      "should have text field",
-    );
-    assert.ok(
-      content.includes("**Status:** pending"),
-      "should have pending status",
-    );
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id = appendCapture(tmp, "first thought");
+  assert.ok(id.startsWith("CAP-"), "ID should start with CAP-");
+  assert.ok(
+    existsSync(join(tmp, ".gsd", "CAPTURES.md")),
+    "CAPTURES.md should exist",
+  );
+  const content = readFileSync(join(tmp, ".gsd", "CAPTURES.md"), "utf-8");
+  assert.ok(content.includes("# Captures"), "should have header");
+  assert.ok(content.includes(`### ${id}`), "should have entry heading");
+  assert.ok(
+    content.includes("**Text:** first thought"),
+    "should have text field",
+  );
+  assert.ok(
+    content.includes("**Status:** pending"),
+    "should have pending status",
+  );
 });
 
-test("captures: appendCapture appends to existing file", () => {
+test("captures: appendCapture appends to existing file", (t) => {
   const tmp = makeTempDir("cap-append");
-  try {
-    const id1 = appendCapture(tmp, "thought one");
-    const id2 = appendCapture(tmp, "thought two");
-    assert.notStrictEqual(id1, id2, "IDs should be unique");
-
-    const content = readFileSync(join(tmp, ".gsd", "CAPTURES.md"), "utf-8");
-    assert.ok(content.includes(`### ${id1}`), "should have first entry");
-    assert.ok(content.includes(`### ${id2}`), "should have second entry");
-    assert.ok(
-      content.includes("**Text:** thought one"),
-      "should have first text",
-    );
-    assert.ok(
-      content.includes("**Text:** thought two"),
-      "should have second text",
-    );
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id1 = appendCapture(tmp, "thought one");
+  const id2 = appendCapture(tmp, "thought two");
+  assert.notStrictEqual(id1, id2, "IDs should be unique");
+
+  const content = readFileSync(join(tmp, ".gsd", "CAPTURES.md"), "utf-8");
+  assert.ok(content.includes(`### ${id1}`), "should have first entry");
+  assert.ok(content.includes(`### ${id2}`), "should have second entry");
+  assert.ok(
+    content.includes("**Text:** thought one"),
+    "should have first text",
+  );
+  assert.ok(
+    content.includes("**Text:** thought two"),
+    "should have second text",
+  );
 });
 
 // ─── loadAllCaptures / loadPendingCaptures ────────────────────────────────────
 
-test("captures: loadAllCaptures parses entries correctly", () => {
+test("captures: loadAllCaptures parses entries correctly", (t) => {
   const tmp = makeTempDir("cap-load");
-  try {
-    appendCapture(tmp, "alpha");
-    appendCapture(tmp, "beta");
-
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 2, "should have 2 entries");
-    assert.strictEqual(all[0].text, "alpha");
-    assert.strictEqual(all[1].text, "beta");
-    assert.strictEqual(all[0].status, "pending");
-    assert.strictEqual(all[1].status, "pending");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  appendCapture(tmp, "alpha");
+  appendCapture(tmp, "beta");
+
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 2, "should have 2 entries");
+  assert.strictEqual(all[0].text, "alpha");
+  assert.strictEqual(all[1].text, "beta");
+  assert.strictEqual(all[0].status, "pending");
+  assert.strictEqual(all[1].status, "pending");
 });
 
-test("captures: loadAllCaptures returns empty array when no file", () => {
+test("captures: loadAllCaptures returns empty array when no file", (t) => {
   const tmp = makeTempDir("cap-nofile");
-  try {
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 0);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 0);
 });
 
-test("captures: loadPendingCaptures filters resolved entries", () => {
+test("captures: loadPendingCaptures filters resolved entries", (t) => {
   const tmp = makeTempDir("cap-pending");
-  try {
-    const id1 = appendCapture(tmp, "pending one");
-    appendCapture(tmp, "pending two");
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-    markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
+  const id1 = appendCapture(tmp, "pending one");
+  appendCapture(tmp, "pending two");
 
-    const pending = loadPendingCaptures(tmp);
-    assert.strictEqual(pending.length, 1, "should have 1 pending");
-    assert.strictEqual(pending[0].text, "pending two");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
+
+  const pending = loadPendingCaptures(tmp);
+  assert.strictEqual(pending.length, 1, "should have 1 pending");
+  assert.strictEqual(pending[0].text, "pending two");
 });
 
-test("captures: loadAllCaptures preserves resolved entries", () => {
+test("captures: loadAllCaptures preserves resolved entries", (t) => {
   const tmp = makeTempDir("cap-all-resolved");
-  try {
-    const id1 = appendCapture(tmp, "pending one");
-    appendCapture(tmp, "pending two");
-
-    markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
-
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 2, "all should still have 2");
-    assert.strictEqual(all[0].status, "resolved");
-    assert.strictEqual(all[1].status, "pending");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id1 = appendCapture(tmp, "pending one");
+  appendCapture(tmp, "pending two");
+
+  markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
+
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 2, "all should still have 2");
+  assert.strictEqual(all[0].status, "resolved");
+  assert.strictEqual(all[1].status, "pending");
 });
 
 // ─── hasPendingCaptures ───────────────────────────────────────────────────────
 
-test("captures: hasPendingCaptures returns false when no file", () => {
+test("captures: hasPendingCaptures returns false when no file", (t) => {
   const tmp = makeTempDir("cap-has-nofile");
-  try {
-    assert.strictEqual(hasPendingCaptures(tmp), false);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  assert.strictEqual(hasPendingCaptures(tmp), false);
 });
 
-test("captures: hasPendingCaptures returns true with pending entries", () => {
+test("captures: hasPendingCaptures returns true with pending entries", (t) => {
   const tmp = makeTempDir("cap-has-true");
-  try {
-    appendCapture(tmp, "something");
-    assert.strictEqual(hasPendingCaptures(tmp), true);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  appendCapture(tmp, "something");
+  assert.strictEqual(hasPendingCaptures(tmp), true);
 });
 
-test("captures: hasPendingCaptures returns false when all resolved", () => {
+test("captures: hasPendingCaptures returns false when all resolved", (t) => {
   const tmp = makeTempDir("cap-has-false");
-  try {
-    const id = appendCapture(tmp, "will resolve");
-    markCaptureResolved(tmp, id, "note", "done", "resolved it");
-    assert.strictEqual(hasPendingCaptures(tmp), false);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id = appendCapture(tmp, "will resolve");
+  markCaptureResolved(tmp, id, "note", "done", "resolved it");
+  assert.strictEqual(hasPendingCaptures(tmp), false);
 });
 
 // ─── markCaptureResolved ──────────────────────────────────────────────────────
 
-test("captures: markCaptureResolved updates entry in place", () => {
+test("captures: markCaptureResolved updates entry in place", (t) => {
   const tmp = makeTempDir("cap-resolve");
-  try {
-    const id1 = appendCapture(tmp, "keep pending");
-    const id2 = appendCapture(tmp, "will resolve");
-    appendCapture(tmp, "also pending");
-
-    markCaptureResolved(tmp, id2, "quick-task", "executed inline", "small fix");
-
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 3, "should still have 3 entries");
-
-    const resolved = all.find((c) => c.id === id2)!;
-    assert.strictEqual(resolved.status, "resolved");
-    assert.strictEqual(resolved.classification, "quick-task");
-    assert.strictEqual(resolved.resolution, "executed inline");
-    assert.strictEqual(resolved.rationale, "small fix");
-    assert.ok(resolved.resolvedAt, "should have resolved timestamp");
-
-    // Others should be unaffected
-    const kept = all.find((c) => c.id === id1)!;
-    assert.strictEqual(kept.status, "pending");
-    assert.strictEqual(kept.classification, undefined);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id1 = appendCapture(tmp, "keep pending");
+  const id2 = appendCapture(tmp, "will resolve");
+  appendCapture(tmp, "also pending");
+
+  markCaptureResolved(tmp, id2, "quick-task", "executed inline", "small fix");
+
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 3, "should still have 3 entries");
+
+  const resolved = all.find((c) => c.id === id2)!;
+  assert.strictEqual(resolved.status, "resolved");
+  assert.strictEqual(resolved.classification, "quick-task");
+  assert.strictEqual(resolved.resolution, "executed inline");
+  assert.strictEqual(resolved.rationale, "small fix");
+  assert.ok(resolved.resolvedAt, "should have resolved timestamp");
+
+  // Others should be unaffected
+  const kept = all.find((c) => c.id === id1)!;
+  assert.strictEqual(kept.status, "pending");
+  assert.strictEqual(kept.classification, undefined);
 });
 
 // ─── resolveCapturesPath ──────────────────────────────────────────────────────
@@ -371,58 +351,50 @@ test("triage: parseTriageOutput handles all five classification types", () => {
 
 // ─── Edge Cases ───────────────────────────────────────────────────────────────
 
-test("captures: appendCapture handles special characters in text", () => {
+test("captures: appendCapture handles special characters in text", (t) => {
   const tmp = makeTempDir("cap-special");
-  try {
-    const id = appendCapture(tmp, 'text with "quotes" and **bold** and `code`');
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 1);
-    assert.ok(all[0].text.includes('"quotes"'), "should preserve quotes");
-    assert.ok(all[0].text.includes("**bold**"), "should preserve bold");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id = appendCapture(tmp, 'text with "quotes" and **bold** and `code`');
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 1);
+  assert.ok(all[0].text.includes('"quotes"'), "should preserve quotes");
+  assert.ok(all[0].text.includes("**bold**"), "should preserve bold");
 });
 
-test("captures: markCaptureResolved is no-op for non-existent ID", () => {
+test("captures: markCaptureResolved is no-op for non-existent ID", (t) => {
   const tmp = makeTempDir("cap-noop");
-  try {
-    appendCapture(tmp, "real capture");
-    // Should not throw
-    markCaptureResolved(tmp, "CAP-nonexistent", "note", "test", "test");
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 1);
-    assert.strictEqual(all[0].status, "pending", "original should be unchanged");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  appendCapture(tmp, "real capture");
+  // Should not throw
+  markCaptureResolved(tmp, "CAP-nonexistent", "note", "test", "test");
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 1);
+  assert.strictEqual(all[0].status, "pending", "original should be unchanged");
 });
 
-test("captures: markCaptureResolved is no-op when no file exists", () => {
+test("captures: markCaptureResolved is no-op when no file exists", (t) => {
   const tmp = makeTempDir("cap-nofile-resolve");
-  try {
-    // Should not throw
-    markCaptureResolved(tmp, "CAP-abc", "note", "test", "test");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // Should not throw
+  markCaptureResolved(tmp, "CAP-abc", "note", "test", "test");
 });
 
-test("captures: re-resolving a capture overwrites previous resolution", () => {
+test("captures: re-resolving a capture overwrites previous resolution", (t) => {
   const tmp = makeTempDir("cap-reresolve");
-  try {
-    const id = appendCapture(tmp, "will re-resolve");
-    markCaptureResolved(tmp, id, "note", "first resolution", "first rationale");
-    markCaptureResolved(tmp, id, "inject", "second resolution", "second rationale");
-
-    const all = loadAllCaptures(tmp);
-    assert.strictEqual(all.length, 1);
-    assert.strictEqual(all[0].classification, "inject", "should have updated classification");
-    assert.strictEqual(all[0].resolution, "second resolution");
-    assert.strictEqual(all[0].rationale, "second rationale");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const id = appendCapture(tmp, "will re-resolve");
+  markCaptureResolved(tmp, id, "note", "first resolution", "first rationale");
+  markCaptureResolved(tmp, id, "inject", "second resolution", "second rationale");
+
+  const all = loadAllCaptures(tmp);
+  assert.strictEqual(all.length, 1);
+  assert.strictEqual(all[0].classification, "inject", "should have updated classification");
+  assert.strictEqual(all[0].resolution, "second resolution");
+  assert.strictEqual(all[0].rationale, "second rationale");
 });
 
 test("triage: parseTriageOutput preserves affectedFiles and targetSlice", () => {

package/src/resources/extensions/gsd/tests/claude-import-tui.test.ts

@@ -8,7 +8,6 @@
  * `/plugin marketplace add ...` source model.
  */
 
-
 import { describe, it, before, after, mock } from 'node:test';
 import assert from 'node:assert';
 import { existsSync, mkdtempSync, rmSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
@@ -306,45 +305,45 @@ describe(
 				});
 			});
 
-			it('should not persist marketplace agent directories into package sources', async () => {
+			it('should not persist marketplace agent directories into package sources', async (t) => {
 				const isolatedAgentDir = join(tempDir, '.gsd', 'agent');
 				const settingsPath = join(isolatedAgentDir, 'settings.json');
 				rmSync(isolatedAgentDir, { recursive: true, force: true });
 				process.env.GSD_CODING_AGENT_DIR = isolatedAgentDir;
 
-				try {
-					mkdirSync(isolatedAgentDir, { recursive: true });
-					const tempSettings: Record<string, unknown> = { packages: [] };
-					writeFileSync(settingsPath, JSON.stringify(tempSettings, null, 2));
-
-					const { ctx } = createMockContext([
-						'Plugins only',
-						'Yes - discover plugins and select components',
-						'Import all components',
-						'Yes, continue',
-					]);
-
-					const readPrefs = () => ({ ...prefs });
-					const writePrefs = async (p: Record<string, unknown>) => {
-						Object.assign(prefs, p);
-					};
-
-					await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
-
-					const settings = JSON.parse(readFileSync(settingsPath, 'utf8')) as { packages?: unknown[] };
-					const packageEntries = Array.isArray(settings.packages) ? settings.packages : [];
-					const hasAgentsDirPackage = packageEntries.some((entry) => {
-						const source = typeof entry === 'string'
-							? entry
-							: (entry && typeof entry === 'object' ? (entry as { source?: unknown }).source : undefined);
-						return typeof source === 'string' && source.endsWith('/agents');
-					});
-
-					assert.strictEqual(hasAgentsDirPackage, false, 'Marketplace agent directories should not be persisted as package sources');
-				} finally {
+				t.after(() => {
 					delete process.env.GSD_CODING_AGENT_DIR;
 					rmSync(isolatedAgentDir, { recursive: true, force: true });
-				}
+				});
+
+				mkdirSync(isolatedAgentDir, { recursive: true });
+				const tempSettings: Record<string, unknown> = { packages: [] };
+				writeFileSync(settingsPath, JSON.stringify(tempSettings, null, 2));
+
+				const { ctx } = createMockContext([
+					'Plugins only',
+					'Yes - discover plugins and select components',
+					'Import all components',
+					'Yes, continue',
+				]);
+
+				const readPrefs = () => ({ ...prefs });
+				const writePrefs = async (p: Record<string, unknown>) => {
+					Object.assign(prefs, p);
+				};
+
+				await runClaudeImportFlow(ctx, 'global', readPrefs, writePrefs);
+
+				const settings = JSON.parse(readFileSync(settingsPath, 'utf8')) as { packages?: unknown[] };
+				const packageEntries = Array.isArray(settings.packages) ? settings.packages : [];
+				const hasAgentsDirPackage = packageEntries.some((entry) => {
+					const source = typeof entry === 'string'
+						? entry
+						: (entry && typeof entry === 'object' ? (entry as { source?: unknown }).source : undefined);
+					return typeof source === 'string' && source.endsWith('/agents');
+				});
+
+				assert.strictEqual(hasAgentsDirPackage, false, 'Marketplace agent directories should not be persisted as package sources');
 			});
 		});
 	}