gsd-pi 2.28.0-dev.e19bf89 → 2.29.0-dev.23d50d0

package/dist/resources/extensions/gsd/tests/commands-logs.test.ts

@@ -0,0 +1,241 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync, existsSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handleLogs } from "../commands-logs.ts";
+
+// ─── Test helpers ───────────────────────────────────────────────────────────
+
+function createTestDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-logs-test-"));
+  mkdirSync(join(dir, ".gsd", "activity"), { recursive: true });
+  mkdirSync(join(dir, ".gsd", "debug"), { recursive: true });
+  return dir;
+}
+
+function createMockCtx(): { notifications: Array<{ msg: string; level: string }>; ui: any } {
+  const notifications: Array<{ msg: string; level: string }> = [];
+  return {
+    notifications,
+    ui: {
+      notify(msg: string, level: string) { notifications.push({ msg, level }); },
+      setStatus() {},
+      setWidget() {},
+      setFooter() {},
+    },
+  };
+}
+
+function writeActivityLog(dir: string, seq: number, unitType: string, unitId: string, entries: Record<string, unknown>[]): void {
+  const safeId = unitId.replace(/\//g, "-");
+  const filename = `${String(seq).padStart(3, "0")}-${unitType}-${safeId}.jsonl`;
+  const content = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
+  writeFileSync(join(dir, ".gsd", "activity", filename), content);
+}
+
+function writeDebugLog(dir: string, name: string, entries: Record<string, unknown>[]): void {
+  const content = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
+  writeFileSync(join(dir, ".gsd", "debug", name), content);
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+test("logs shows empty state message when no logs exist", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+  try {
+    await handleLogs("", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    assert.ok(ctx.notifications[0].msg.includes("No logs found"));
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs lists activity logs", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: false },
+  ]);
+  writeActivityLog(dir, 2, "complete-slice", "M001/S01", [
+    { role: "assistant", content: "Completing slice S01" },
+  ]);
+
+  try {
+    await handleLogs("", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Activity Logs"), "should show activity logs header");
+    assert.ok(msg.includes("execute-task"), "should show unit type");
+    assert.ok(msg.includes("complete-slice"), "should show second log");
+    assert.ok(msg.includes("/gsd logs <#>"), "should show usage hint");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs <N> shows activity log details", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+    { type: "toolCall", name: "write", arguments: { file_path: "/tmp/test.ts" } },
+    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: false },
+    { role: "toolResult", toolCallId: "2", toolName: "write", isError: true },
+    { role: "assistant", content: "I ran the tests and wrote a file" },
+  ]);
+
+  try {
+    await handleLogs("1", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Activity Log #1"), "should show log number");
+    assert.ok(msg.includes("execute-task"), "should show unit type");
+    assert.ok(msg.includes("Tool calls: 2"), "should count tool calls");
+    assert.ok(msg.includes("Errors: 1"), "should count errors");
+    assert.ok(msg.includes("/tmp/test.ts"), "should show files written");
+    assert.ok(msg.includes("npm test"), "should show commands run");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs <N> shows not found for invalid seq", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  try {
+    await handleLogs("999", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    assert.ok(ctx.notifications[0].msg.includes("not found"));
+    assert.equal(ctx.notifications[0].level, "warning");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs debug lists debug logs", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeDebugLog(dir, "debug-2026-03-18T10-30-00.log", [
+    { ts: "2026-03-18T10:30:00Z", event: "debug-start", platform: "darwin" },
+    { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
+  ]);
+
+  try {
+    await handleLogs("debug", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Debug Logs"), "should show debug logs header");
+    assert.ok(msg.includes("debug-2026-03-18T10-30-00.log"), "should show filename");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs debug <N> shows debug log summary", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeDebugLog(dir, "debug-2026-03-18T10-30-00.log", [
+    { ts: "2026-03-18T10:30:00Z", event: "debug-start", platform: "darwin" },
+    { ts: "2026-03-18T10:30:05Z", event: "dispatch-error", error: "missing plan" },
+    { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
+  ]);
+
+  try {
+    await handleLogs("debug 1", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Debug Log:"), "should show debug log header");
+    assert.ok(msg.includes("Events: 3"), "should count events");
+    assert.ok(msg.includes("Dispatches: 5"), "should show dispatch count");
+    assert.ok(msg.includes("dispatch-error"), "should show errors");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs tail shows recent activity summaries", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+  ]);
+  writeActivityLog(dir, 2, "execute-task", "M001/S01/T02", [
+    { type: "toolCall", name: "bash", arguments: { command: "npm build" } },
+    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: true },
+  ]);
+
+  try {
+    await handleLogs("tail 2", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Last 2 activity log(s)"), "should show count");
+    assert.ok(msg.includes("#1"), "should show first log");
+    assert.ok(msg.includes("#2"), "should show second log");
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("logs clear removes old logs", async () => {
+  const dir = createTestDir();
+  const ctx = createMockCtx();
+  const origCwd = process.cwd();
+  process.chdir(dir);
+
+  // Create an old activity log (modify mtime to 10 days ago)
+  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [{ type: "toolCall" }]);
+  const oldFile = join(dir, ".gsd", "activity", "001-execute-task-M001-S01-T01.jsonl");
+  const oldTime = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000);
+  utimesSync(oldFile, oldTime, oldTime);
+
+  // Create 6 recent activity logs so the old one is outside the "keep 5" window
+  for (let i = 2; i <= 7; i++) {
+    writeActivityLog(dir, i, "execute-task", `M001/S01/T0${i}`, [{ type: "toolCall" }]);
+  }
+
+  try {
+    await handleLogs("clear", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    // Old log should be removed, recent ones kept
+    assert.ok(!existsSync(oldFile), "old log should be removed");
+    assert.ok(
+      existsSync(join(dir, ".gsd", "activity", "007-execute-task-M001-S01-T07.jsonl")),
+      "most recent log should be kept",
+    );
+  } finally {
+    process.chdir(origCwd);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/dist/resources/extensions/gsd/tests/extension-selector-separator.test.ts

@@ -1,4 +1,6 @@
-// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent.
+// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent
+// and the two-step provider→model picker in configureModels.
+//
 // We cannot import the component directly in node:test because its transitive
 // dependency (countdown-timer.ts) uses TypeScript parameter properties which
 // are unsupported under --experimental-strip-types. Instead we duplicate the
@@ -69,16 +71,17 @@ describe("separator detection", () => {
 	});
 });
 
-describe("model grouping", () => {
-	test("groups models by provider with separator headers", () => {
-		// Simulate the grouping logic from configureModels
-		const availableModels = [
-			{ id: "claude-opus-4-6", provider: "anthropic" },
-			{ id: "gpt-4o", provider: "openai" },
-			{ id: "claude-sonnet-4-5", provider: "anthropic" },
-			{ id: "o3-mini", provider: "openai" },
-		];
+describe("two-step provider→model picker", () => {
+	// Simulate the grouping logic from configureModels
+	const availableModels = [
+		{ id: "claude-opus-4-6", provider: "anthropic" },
+		{ id: "gpt-4o", provider: "openai" },
+		{ id: "claude-sonnet-4-5", provider: "anthropic" },
+		{ id: "o3-mini", provider: "openai" },
+		{ id: "claude-haiku-4-5", provider: "anthropic" },
+	];
 
+	function buildProviderGroups() {
 		const byProvider = new Map<string, typeof availableModels>();
 		for (const m of availableModels) {
 			let group = byProvider.get(m.provider);
@@ -89,34 +92,53 @@ describe("model grouping", () => {
 			group.push(m);
 		}
 		const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
-
-		const modelOptions: string[] = [];
-		for (const provider of providers) {
-			const group = byProvider.get(provider)!;
-			modelOptions.push(`${SEPARATOR_PREFIX} ${provider} (${group.length}) ${SEPARATOR_PREFIX}`);
-			for (const m of group) {
-				modelOptions.push(`${m.id} · ${m.provider}`);
-			}
+		for (const group of byProvider.values()) {
+			group.sort((a, b) => a.id.localeCompare(b.id));
 		}
-		modelOptions.push("(keep current)", "(clear)");
-
-		// Verify structure
-		assert.strictEqual(modelOptions[0], `${SEPARATOR_PREFIX} anthropic (2) ${SEPARATOR_PREFIX}`);
-		assert.strictEqual(modelOptions[1], "claude-opus-4-6 · anthropic");
-		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5 · anthropic");
-		assert.strictEqual(modelOptions[3], `${SEPARATOR_PREFIX} openai (2) ${SEPARATOR_PREFIX}`);
-		assert.strictEqual(modelOptions[4], "gpt-4o · openai");
-		assert.strictEqual(modelOptions[5], "o3-mini · openai");
-		assert.strictEqual(modelOptions[6], "(keep current)");
-		assert.strictEqual(modelOptions[7], "(clear)");
-
-		// Verify separators are correctly detected
-		assert.ok(isSeparator(modelOptions, 0));
-		assert.ok(!isSeparator(modelOptions, 1));
-		assert.ok(isSeparator(modelOptions, 3));
-		assert.ok(!isSeparator(modelOptions, 6));
-
-		// Verify first selectable is index 1, not the separator at 0
-		assert.strictEqual(nextSelectable(modelOptions, 0, 1), 1);
+		return { byProvider, providers };
+	}
+
+	test("provider menu lists providers with model counts", () => {
+		const { providers, byProvider } = buildProviderGroups();
+		const providerOptions = providers.map(p => {
+			const count = byProvider.get(p)!.length;
+			return `${p} (${count} models)`;
+		});
+		providerOptions.push("(keep current)", "(clear)", "(type manually)");
+
+		assert.strictEqual(providerOptions[0], "anthropic (3 models)");
+		assert.strictEqual(providerOptions[1], "openai (2 models)");
+		assert.strictEqual(providerOptions[2], "(keep current)");
+		assert.strictEqual(providerOptions[3], "(clear)");
+		assert.strictEqual(providerOptions[4], "(type manually)");
+	});
+
+	test("model menu for a provider is sorted alphabetically", () => {
+		const { byProvider } = buildProviderGroups();
+		const anthropicModels = byProvider.get("anthropic")!;
+		const modelOptions = anthropicModels.map(m => m.id);
+
+		assert.strictEqual(modelOptions[0], "claude-haiku-4-5");
+		assert.strictEqual(modelOptions[1], "claude-opus-4-6");
+		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5");
+	});
+
+	test("provider name is extracted correctly from choice string", () => {
+		const choice = "anthropic (3 models)";
+		const providerName = choice.replace(/ \(\d+ models?\)$/, "");
+		assert.strictEqual(providerName, "anthropic");
+
+		const singleChoice = "ollama (1 model)";
+		const singleProvider = singleChoice.replace(/ \(\d+ models?\)$/, "");
+		assert.strictEqual(singleProvider, "ollama");
+	});
+
+	test("openai models are sorted within their group", () => {
+		const { byProvider } = buildProviderGroups();
+		const openaiModels = byProvider.get("openai")!;
+		const modelOptions = openaiModels.map(m => m.id);
+
+		assert.strictEqual(modelOptions[0], "gpt-4o");
+		assert.strictEqual(modelOptions[1], "o3-mini");
 	});
 });

package/dist/resources/extensions/gsd/tests/gsd-inspect.test.ts

@@ -3,7 +3,7 @@
 // Tests the pure formatInspectOutput function with known data.
 
 import { createTestContext } from './test-helpers.ts';
-import { formatInspectOutput, type InspectData } from '../commands.ts';
+import { formatInspectOutput, type InspectData } from '../commands-inspect.ts';
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();