gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -36,156 +36,176 @@ function makeTempDir(prefix: string): string {
 
 // ─── appendCapture ────────────────────────────────────────────────────────────
 
-test("captures: appendCapture creates CAPTURES.md on first call", (t) => {
+test("captures: appendCapture creates CAPTURES.md on first call", () => {
   const tmp = makeTempDir("cap-create");
-  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",
-  );
+  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 });
+  }
 });
 
-test("captures: appendCapture appends to existing file", (t) => {
+test("captures: appendCapture appends to existing file", () => {
   const tmp = makeTempDir("cap-append");
-  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",
-  );
+  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 });
+  }
 });
 
 // ─── loadAllCaptures / loadPendingCaptures ────────────────────────────────────
 
-test("captures: loadAllCaptures parses entries correctly", (t) => {
+test("captures: loadAllCaptures parses entries correctly", () => {
   const tmp = makeTempDir("cap-load");
-  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");
+  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 });
+  }
 });
 
-test("captures: loadAllCaptures returns empty array when no file", (t) => {
+test("captures: loadAllCaptures returns empty array when no file", () => {
   const tmp = makeTempDir("cap-nofile");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  const all = loadAllCaptures(tmp);
-  assert.strictEqual(all.length, 0);
+  try {
+    const all = loadAllCaptures(tmp);
+    assert.strictEqual(all.length, 0);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("captures: loadPendingCaptures filters resolved entries", (t) => {
+test("captures: loadPendingCaptures filters resolved entries", () => {
   const tmp = makeTempDir("cap-pending");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  const id1 = appendCapture(tmp, "pending one");
-  appendCapture(tmp, "pending two");
+  try {
+    const id1 = appendCapture(tmp, "pending one");
+    appendCapture(tmp, "pending two");
 
-  markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
+    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");
+    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 });
+  }
 });
 
-test("captures: loadAllCaptures preserves resolved entries", (t) => {
+test("captures: loadAllCaptures preserves resolved entries", () => {
   const tmp = makeTempDir("cap-all-resolved");
-  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");
+  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 });
+  }
 });
 
 // ─── hasPendingCaptures ───────────────────────────────────────────────────────
 
-test("captures: hasPendingCaptures returns false when no file", (t) => {
+test("captures: hasPendingCaptures returns false when no file", () => {
   const tmp = makeTempDir("cap-has-nofile");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  assert.strictEqual(hasPendingCaptures(tmp), false);
+  try {
+    assert.strictEqual(hasPendingCaptures(tmp), false);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("captures: hasPendingCaptures returns true with pending entries", (t) => {
+test("captures: hasPendingCaptures returns true with pending entries", () => {
   const tmp = makeTempDir("cap-has-true");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  appendCapture(tmp, "something");
-  assert.strictEqual(hasPendingCaptures(tmp), true);
+  try {
+    appendCapture(tmp, "something");
+    assert.strictEqual(hasPendingCaptures(tmp), true);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("captures: hasPendingCaptures returns false when all resolved", (t) => {
+test("captures: hasPendingCaptures returns false when all resolved", () => {
   const tmp = makeTempDir("cap-has-false");
-  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);
+  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 });
+  }
 });
 
 // ─── markCaptureResolved ──────────────────────────────────────────────────────
 
-test("captures: markCaptureResolved updates entry in place", (t) => {
+test("captures: markCaptureResolved updates entry in place", () => {
   const tmp = makeTempDir("cap-resolve");
-  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);
+  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 });
+  }
 });
 
 // ─── resolveCapturesPath ──────────────────────────────────────────────────────
@@ -351,50 +371,58 @@ test("triage: parseTriageOutput handles all five classification types", () => {
 
 // ─── Edge Cases ───────────────────────────────────────────────────────────────
 
-test("captures: appendCapture handles special characters in text", (t) => {
+test("captures: appendCapture handles special characters in text", () => {
   const tmp = makeTempDir("cap-special");
-  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");
+  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 });
+  }
 });
 
-test("captures: markCaptureResolved is no-op for non-existent ID", (t) => {
+test("captures: markCaptureResolved is no-op for non-existent ID", () => {
   const tmp = makeTempDir("cap-noop");
-  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");
+  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 });
+  }
 });
 
-test("captures: markCaptureResolved is no-op when no file exists", (t) => {
+test("captures: markCaptureResolved is no-op when no file exists", () => {
   const tmp = makeTempDir("cap-nofile-resolve");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  // Should not throw
-  markCaptureResolved(tmp, "CAP-abc", "note", "test", "test");
+  try {
+    // Should not throw
+    markCaptureResolved(tmp, "CAP-abc", "note", "test", "test");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("captures: re-resolving a capture overwrites previous resolution", (t) => {
+test("captures: re-resolving a capture overwrites previous resolution", () => {
   const tmp = makeTempDir("cap-reresolve");
-  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");
+  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 });
+  }
 });
 
 test("triage: parseTriageOutput preserves affectedFiles and targetSlice", () => {

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

@@ -8,6 +8,7 @@
  * `/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';
@@ -305,45 +306,45 @@ describe(
 				});
 			});
 
-			it('should not persist marketplace agent directories into package sources', async (t) => {
+			it('should not persist marketplace agent directories into package sources', async () => {
 				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;
 
-				t.after(() => {
+				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 {
 					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');
+				}
 			});
 		});
 	}