clawspec 1.0.15 → 1.0.19

package/test/doctor.test.ts

@@ -0,0 +1,142 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir } from "node:fs/promises";
+import { runDoctorCommand } from "../src/orchestrator/service.ts";
+import { writeJsonFile, readJsonFile } from "../src/utils/fs.ts";
+
+test("doctor reports no issues when config file does not exist", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configPath = path.join(tempRoot, ".acpx", "config.json");
+
+  const result = await runDoctorCommand(configPath);
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /No issues found/);
+});
+
+test("doctor reports no issues when agents is empty", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  await writeJsonFile(configPath, {
+    defaultAgent: "codex",
+    agents: {},
+  });
+
+  const result = await runDoctorCommand(configPath);
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /No issues found/);
+});
+
+test("doctor detects custom agent entries", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  await writeJsonFile(configPath, {
+    defaultAgent: "codex",
+    agents: {
+      codex: { command: "/usr/local/bin/codex" },
+    },
+  });
+
+  const result = await runDoctorCommand(configPath);
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /custom agent entries/);
+  assert.match(result.text ?? "", /`codex`/);
+  assert.match(result.text ?? "", /doctor fix/);
+});
+
+test("doctor reports no issues when config file is empty", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  const { writeUtf8 } = await import("../src/utils/fs.ts");
+  await writeUtf8(configPath, "");
+
+  const result = await runDoctorCommand(configPath);
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /No issues found/);
+});
+
+test("doctor detects invalid JSON", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  const { writeUtf8 } = await import("../src/utils/fs.ts");
+  await writeUtf8(configPath, '{ "agents": { broken }');
+
+  const result = await runDoctorCommand(configPath);
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /invalid JSON/);
+});
+
+test("doctor fix clears custom agent entries", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  await writeJsonFile(configPath, {
+    defaultAgent: "codex",
+    authPolicy: "skip",
+    agents: {
+      codex: { command: "/usr/local/bin/codex" },
+    },
+  });
+
+  const result = await runDoctorCommand(configPath, "fix");
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /Doctor Fix Applied/);
+
+  const updated = await readJsonFile<Record<string, unknown>>(configPath, {});
+  assert.deepEqual(updated.agents, {});
+  assert.equal(updated.defaultAgent, "codex");
+  assert.equal(updated.authPolicy, "skip");
+});
+
+test("doctor fix reports nothing to fix when agents is already empty", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  await writeJsonFile(configPath, {
+    defaultAgent: "codex",
+    agents: {},
+  });
+
+  const result = await runDoctorCommand(configPath, "fix");
+
+  assert.equal(result.isError, undefined);
+  assert.match(result.text ?? "", /Nothing to fix/);
+});
+
+test("doctor fix reports error when config has invalid JSON", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-doctor-"));
+  const configDir = path.join(tempRoot, ".acpx");
+  await mkdir(configDir, { recursive: true });
+  const configPath = path.join(configDir, "config.json");
+
+  const { writeUtf8 } = await import("../src/utils/fs.ts");
+  await writeUtf8(configPath, '{ broken json');
+
+  const result = await runDoctorCommand(configPath, "fix");
+
+  assert.equal(result.isError, true);
+  assert.match(result.text ?? "", /Cannot auto-fix/);
+});

package/test/helpers/harness.ts

@@ -55,13 +55,17 @@ export function createLogger() {
   };
 }
 
-export async function waitFor(check: () => Promise<boolean>, timeoutMs = 4_000): Promise<void> {
+export async function waitFor(
+  check: () => Promise<boolean>,
+  timeoutMs = 4_000,
+  pollIntervalMs = 250,
+): Promise<void> {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
     if (await check()) {
       return;
     }
-    await new Promise((resolve) => setTimeout(resolve, 25));
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
   }
   throw new Error("Timed out waiting for test condition.");
 }

package/test/recovery.test.ts

@@ -1,15 +1,18 @@
-import test from "node:test";
+import test, { type TestContext } from "node:test";
 import assert from "node:assert/strict";
 import os from "node:os";
 import path from "node:path";
 import { mkdtemp, mkdir } from "node:fs/promises";
-import { pathExists, readUtf8, writeJsonFile, writeUtf8 } from "../src/utils/fs.ts";
+import { pathExists, readJsonFile, readUtf8, writeJsonFile, writeUtf8 } from "../src/utils/fs.ts";
 import { getRepoStatePaths } from "../src/utils/paths.ts";
 import { RollbackStore } from "../src/rollback/store.ts";
 import { ProjectStateStore } from "../src/state/store.ts";
 import { WatcherManager } from "../src/watchers/manager.ts";
 import { createLogger, waitFor } from "./helpers/harness.ts";
 
+const TEST_WATCHER_POLL_INTERVAL_MS = 250;
+const TEST_WAIT_TIMEOUT_MS = 15_000;
+
 function createWorkOpenSpec(changeDir: string, tasksPath: string) {
   return {
     instructionsApply: async (cwd: string, cn: string) => {
@@ -39,7 +42,25 @@ function createWorkOpenSpec(changeDir: string, tasksPath: string) {
   } as any;
 }
 
-test("recovery from orphaned state (armed, no execution field)", async () => {
+function registerManagerCleanup(t: TestContext, manager: WatcherManager): () => Promise<void> {
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    await manager.stop();
+  };
+  t.after(stop);
+  return stop;
+}
+
+async function waitForProjectStatus(repoPath: string, status: "done", timeoutMs = TEST_WAIT_TIMEOUT_MS): Promise<void> {
+  const stateFile = getRepoStatePaths(repoPath, "archives").stateFile;
+  await waitFor(async () => (await readJsonFile<any>(stateFile, null))?.status === status, timeoutMs);
+}
+
+test("recovery from orphaned state (armed, no execution field)", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-recovery-orphan-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -105,12 +126,13 @@ test("recovery from orphaned state (armed, no execution field)", async () => {
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   await manager.start();
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "done");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "done");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "done");
@@ -120,7 +142,7 @@ test("recovery from orphaned state (armed, no execution field)", async () => {
   assert.equal(await pathExists(path.join(clawspecDir, "state.json.12345.999999.tmp")), false);
 });
 
-test("recovery from mid-crash running state", async () => {
+test("recovery from mid-crash running state", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-recovery-midcrash-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -178,19 +200,20 @@ test("recovery from mid-crash running state", async () => {
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   await manager.start();
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "done");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "done");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "done");
   assert.equal(notifierMessages.some((m) => m.includes("Gateway restarted")), true);
 });
 
-test("startup recovery adopts a live implementation session instead of spawning a new worker", async () => {
+test("startup recovery adopts a live implementation session instead of spawning a new worker", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-recovery-adopt-live-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -274,8 +297,9 @@ test("startup recovery adopts a live implementation session instead of spawning
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   setTimeout(() => {
     void (async () => {
@@ -308,8 +332,8 @@ test("startup recovery adopts a live implementation session instead of spawning
   }, 120);
 
   await manager.start();
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "done");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "done");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "done");
@@ -328,7 +352,7 @@ test("startup recovery adopts a live implementation session instead of spawning
   assert.equal(notifierMessages.some((m) => m.includes("Watcher active. Starting codex worker")), false);
 });
 
-test("recovery from recoverable blocked implementation state", async () => {
+test("recovery from recoverable blocked implementation state", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-recovery-blocked-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -421,12 +445,13 @@ test("recovery from recoverable blocked implementation state", async () => {
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   await manager.start();
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "done");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "done");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "done");
@@ -435,7 +460,7 @@ test("recovery from recoverable blocked implementation state", async () => {
   assert.equal(notifierMessages.some((m) => m.includes("All tasks complete")), true);
 });
 
-test("rearm never drops execution field (batch mode)", async () => {
+test("rearm never drops execution field (batch mode)", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-rearm-safe-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -497,13 +522,14 @@ test("rearm never drops execution field (batch mode)", async () => {
     logger: createLogger(),
     notifier: { send: async () => undefined } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   await manager.start();
   await manager.wake(channelKey);
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "done");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "done");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "done");
@@ -511,7 +537,7 @@ test("rearm never drops execution field (batch mode)", async () => {
   assert.equal(turnCount, 1);
 });
 
-test("startup recovery does not spawn a worker for visible chat planning", async () => {
+test("startup recovery does not spawn a worker for visible chat planning", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-recovery-visible-plan-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -561,12 +587,13 @@ test("startup recovery does not spawn a worker for visible chat planning", async
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   await manager.start();
   await new Promise((resolve) => setTimeout(resolve, 150));
-  await manager.stop();
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(runCount, 0);

package/test/watcher-planning.test.ts

@@ -1,15 +1,18 @@
-import test from "node:test";
+import test, { type TestContext } from "node:test";
 import assert from "node:assert/strict";
 import os from "node:os";
 import path from "node:path";
 import { mkdtemp, mkdir } from "node:fs/promises";
-import { pathExists, writeJsonFile, writeUtf8 } from "../src/utils/fs.ts";
+import { pathExists, readJsonFile, writeJsonFile, writeUtf8 } from "../src/utils/fs.ts";
 import { PlanningJournalStore } from "../src/planning/journal.ts";
 import { getRepoStatePaths } from "../src/utils/paths.ts";
 import { ProjectStateStore } from "../src/state/store.ts";
 import { WatcherManager } from "../src/watchers/manager.ts";
 import { createLogger, waitFor } from "./helpers/harness.ts";
 
+const TEST_WATCHER_POLL_INTERVAL_MS = 1_000;
+const TEST_WAIT_TIMEOUT_MS = 35_000;
+
 function createPlanningOpenSpec(changeDir: string, proposalPath: string) {
   return {
     status: async (cwd: string, changeName: string) => ({
@@ -71,7 +74,29 @@ function createPlanningOpenSpec(changeDir: string, proposalPath: string) {
   } as any;
 }
 
-test("watcher planning flow completes", async () => {
+function registerManagerCleanup(t: TestContext, manager: WatcherManager): () => Promise<void> {
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    await manager.stop();
+  };
+  t.after(stop);
+  return stop;
+}
+
+async function waitForProjectStatus(
+  repoPath: string,
+  status: "ready" | "done" | "blocked" | "planning" | "armed" | "running",
+  timeoutMs = TEST_WAIT_TIMEOUT_MS,
+): Promise<void> {
+  const stateFile = getRepoStatePaths(repoPath, "archives").stateFile;
+  await waitFor(async () => (await readJsonFile<any>(stateFile, null))?.status === status, timeoutMs);
+}
+
+test("watcher planning flow completes", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-watcher-plan-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -113,8 +138,9 @@ test("watcher planning flow completes", async () => {
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   const channelKey = "discord:watch-plan:default:main";
   await stateStore.createProject(channelKey);
@@ -143,8 +169,8 @@ test("watcher planning flow completes", async () => {
 
   await manager.start();
   await manager.wake(channelKey);
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "ready");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "ready");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "ready");
@@ -155,7 +181,7 @@ test("watcher planning flow completes", async () => {
   assert.equal(notifierMessages.some((m) => m.includes("Planning ready") && m.includes("Next: run `cs-work` to start implementation")), true);
 });
 
-test("planning fallback normalizes artifact path", async () => {
+test("planning fallback normalizes artifact path", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-watcher-plan-fallback-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -215,8 +241,9 @@ test("planning fallback normalizes artifact path", async () => {
       cancelSession: async () => undefined,
       closeSession: async () => undefined,
     } as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   const channelKey = "discord:watch-plan-fallback:default:main";
   await stateStore.createProject(channelKey);
@@ -230,14 +257,14 @@ test("planning fallback normalizes artifact path", async () => {
 
   await manager.start();
   await manager.wake(channelKey);
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "ready");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "ready");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.deepEqual(project?.lastExecution?.changedFiles, ["openspec/changes/watch-plan-fallback/proposal.md"]);
 });
 
-test("watcher force-refreshes planning artifacts when journal is dirty and OpenSpec reports all artifacts done", async () => {
+test("watcher force-refreshes planning artifacts when journal is dirty and OpenSpec reports all artifacts done", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-watcher-plan-forced-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -358,8 +385,9 @@ test("watcher force-refreshes planning artifacts when journal is dirty and OpenS
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   const channelKey = "discord:watch-plan-forced:default:main";
   await stateStore.createProject(channelKey);
@@ -398,8 +426,8 @@ test("watcher force-refreshes planning artifacts when journal is dirty and OpenS
 
   await manager.start();
   await manager.wake(channelKey);
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "ready");
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "ready");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.deepEqual(runOrder, ["proposal", "specs", "design", "tasks"]);
@@ -412,7 +440,7 @@ test("watcher force-refreshes planning artifacts when journal is dirty and OpenS
   );
 });
 
-test("watcher restarts planning worker after ACP runtime exit", async () => {
+test("watcher restarts planning worker after ACP runtime exit", async (t) => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-watcher-plan-restart-"));
   const workspacePath = path.join(tempRoot, "workspace");
   const repoPath = path.join(workspacePath, "demo-app");
@@ -460,8 +488,9 @@ test("watcher restarts planning worker after ACP runtime exit", async () => {
     logger: createLogger(),
     notifier: { send: async (_: string, text: string) => { notifierMessages.push(text); } } as any,
     acpClient: fakeAcpClient as any,
-    pollIntervalMs: 25,
+    pollIntervalMs: TEST_WATCHER_POLL_INTERVAL_MS,
   });
+  const stopManager = registerManagerCleanup(t, manager);
 
   const channelKey = "discord:watch-plan-restart:default:main";
   await stateStore.createProject(channelKey);
@@ -490,8 +519,8 @@ test("watcher restarts planning worker after ACP runtime exit", async () => {
 
   await manager.start();
   await manager.wake(channelKey);
-  await waitFor(async () => (await stateStore.getActiveProject(channelKey))?.status === "ready", 8_000);
-  await manager.stop();
+  await waitForProjectStatus(repoPath, "ready");
+  await stopManager();
 
   const project = await stateStore.getActiveProject(channelKey);
   assert.equal(project?.status, "ready");