clawspec 1.0.0

package/test/service-archive.test.ts

@@ -0,0 +1,82 @@
+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 { ProjectMemoryStore } from "../src/memory/store.ts";
+import { ClawSpecService } from "../src/orchestrator/service.ts";
+import { ProjectStateStore } from "../src/state/store.ts";
+import { pathExists, writeUtf8 } from "../src/utils/fs.ts";
+import { WorkspaceStore } from "../src/workspace/store.ts";
+
+test("service writes archive bundles from visible-execution state", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-service-"));
+  const repoPath = path.join(tempRoot, "repo");
+  const workspacePath = path.join(tempRoot, "workspace");
+  const changeName = "demo-change";
+  await mkdir(path.join(repoPath, "openspec", "changes", changeName), { recursive: true });
+  await mkdir(workspacePath, { recursive: true });
+
+  await writeUtf8(
+    path.join(repoPath, "openspec", "changes", changeName, "tasks.md"),
+    [
+      "## 1. Setup",
+      "",
+      "- [x] 1.1 Create plugin",
+      "- [ ] 1.2 Add lifecycle store",
+      "",
+    ].join("\n"),
+  );
+
+  const stateStore = new ProjectStateStore(tempRoot, "archives");
+  const memoryStore = new ProjectMemoryStore(path.join(tempRoot, "memory.json"));
+  const workspaceStore = new WorkspaceStore(path.join(tempRoot, "workspace-state.json"), workspacePath);
+  await stateStore.initialize();
+  await memoryStore.initialize();
+  await workspaceStore.initialize();
+
+  let project = await stateStore.createProject("channel:demo");
+  project = await stateStore.updateProject("channel:demo", (current) => ({
+    ...current,
+    workspacePath,
+    repoPath,
+    projectName: "repo",
+    changeName,
+    changeDir: path.join(repoPath, "openspec", "changes", changeName),
+    latestSummary: "Latest summary text",
+  }));
+
+  const fakeApi = {
+    logger: {
+      info: () => undefined,
+      warn: () => undefined,
+      error: () => undefined,
+      debug: () => undefined,
+    },
+  } as any;
+
+  const service = new ClawSpecService({
+    api: fakeApi,
+    config: {} as any,
+    logger: fakeApi.logger,
+    stateStore,
+    memoryStore,
+    openSpec: {} as any,
+    archiveDirName: "archives",
+    defaultWorkspace: workspacePath,
+    defaultWorkerAgentId: "codex",
+    workspaceStore,
+  });
+
+  await (service as any).ensureProjectSupportFiles(project);
+  const counts = await (service as any).loadTaskCounts(project);
+  assert.equal(counts.complete, 1);
+  assert.equal(counts.remaining, 1);
+
+  const archivePath = await (service as any).writeArchiveBundle(project, counts);
+  assert.equal(await pathExists(path.join(archivePath, "resume-context.md")), true);
+  assert.equal(await pathExists(path.join(archivePath, "session-summary.md")), true);
+  assert.equal(await pathExists(path.join(archivePath, "changed-files.md")), true);
+  assert.equal(await pathExists(path.join(archivePath, "decision-log.md")), true);
+  assert.equal(await pathExists(path.join(archivePath, "run-metadata.json")), true);
+});

package/test/shell-command.test.ts

@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { runShellCommand } from "../src/utils/shell-command.ts";
+
+test("runShellCommand handles cwd and script paths that contain spaces", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-shell-"));
+  const spaceDir = path.join(tempRoot, "space dir");
+  const scriptPath = path.join(spaceDir, "echo script.js");
+  await mkdir(spaceDir, { recursive: true });
+  await writeFile(scriptPath, `
+console.log(process.cwd());
+console.log(process.argv[2]);
+`, "utf8");
+
+  const result = await runShellCommand({
+    command: process.execPath,
+    args: [scriptPath, "hello world"],
+    cwd: spaceDir,
+    timeoutMs: 2_000,
+  });
+
+  assert.equal(result.error, undefined);
+  assert.equal(result.code, 0);
+  assert.match(result.stdout, /space dir/);
+  assert.match(result.stdout, /hello world/);
+});
+
+test("runShellCommand surfaces timeout errors", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-shell-timeout-"));
+  const scriptPath = path.join(tempRoot, "sleep.js");
+  await writeFile(scriptPath, `
+setTimeout(() => {
+  console.log("finished");
+}, 5_000);
+`, "utf8");
+
+  const result = await runShellCommand({
+    command: process.execPath,
+    args: [scriptPath],
+    cwd: tempRoot,
+    timeoutMs: 100,
+  });
+
+  assert.match(result.error?.message ?? "", /timed out/i);
+});

package/test/state-store.test.ts

@@ -0,0 +1,74 @@
+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 { ActiveProjectConflictError, ProjectStateStore } from "../src/state/store.ts";
+import { readJsonFile, removeIfExists, writeJsonFile } from "../src/utils/fs.ts";
+import { getActiveProjectMapPath, getPluginStateRoot } from "../src/utils/paths.ts";
+import { withFileLock } from "../src/state/locks.ts";
+
+test("state store enforces one active project per channel and migrates to repo-local state", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-state-"));
+  const repoPath = path.join(tempRoot, "repo");
+  await mkdir(repoPath, { recursive: true });
+
+  const store = new ProjectStateStore(tempRoot, "archives");
+  await store.initialize();
+
+  const project = await store.createProject("channel:demo");
+  assert.equal(project.status, "idle");
+
+  await assert.rejects(() => store.createProject("channel:demo"), ActiveProjectConflictError);
+
+  const updated = await store.setRepoPath("channel:demo", repoPath, "demo");
+  assert.equal(updated.repoPath, repoPath);
+  assert.match(updated.storagePath, /\.openclaw[\\\/]clawspec[\\\/]state\.json$/);
+
+  const described = await store.setDescription(
+    "channel:demo",
+    "Build the project orchestrator",
+    "Build the project orchestrator",
+    "build-project-orchestrator",
+  );
+  assert.equal(described.changeName, "build-project-orchestrator");
+  assert.equal((await store.getActiveProject("channel:demo"))?.repoPath, repoPath);
+  assert.equal((await store.listActiveProjects()).length, 1);
+});
+
+test("updateProject waits for the active map lock instead of failing on a transiently missing map file", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-state-lock-"));
+  const store = new ProjectStateStore(tempRoot, "archives");
+  await store.initialize();
+  await store.createProject("channel:demo");
+
+  const activeMapPath = getActiveProjectMapPath(tempRoot);
+  const activeMapLockPath = path.join(getPluginStateRoot(tempRoot), "locks", "active-projects.lock");
+  const originalMap = await readJsonFile(activeMapPath, { version: 1, channels: {} as Record<string, unknown> });
+
+  let settled = false;
+  let updatePromise: Promise<unknown> | undefined;
+
+  await withFileLock(activeMapLockPath, async () => {
+    await removeIfExists(activeMapPath);
+    updatePromise = store.updateProject("channel:demo", (current) => ({
+      ...current,
+      latestSummary: "updated after lock release",
+    }));
+    updatePromise.finally(() => {
+      settled = true;
+    });
+
+    await delay(50);
+    assert.equal(settled, false);
+
+    await writeJsonFile(activeMapPath, originalMap);
+  });
+
+  const updated = await updatePromise;
+  assert.equal((updated as { latestSummary?: string }).latestSummary, "updated after lock release");
+});
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/test/tasks-and-checkpoint.test.ts

@@ -0,0 +1,60 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp } from "node:fs/promises";
+import { getNextIncompleteTask, parseTasksMarkdown } from "../src/openspec/tasks.ts";
+import { readExecutionControl, readExecutionResult, isExecutionTriggerText } from "../src/execution/state.ts";
+import { writeJsonFile } from "../src/utils/fs.ts";
+
+test("tasks parser keeps checkbox order and selects the next unchecked task", () => {
+  const taskList = parseTasksMarkdown(`
+## 1. Setup
+
+- [x] 1.1 Create package
+- [ ] 1.2 Add state store
+- [ ] 1.3 Add docs
+`);
+
+  assert.equal(taskList.counts.total, 3);
+  assert.equal(taskList.counts.complete, 1);
+  assert.equal(taskList.counts.remaining, 2);
+  assert.equal(getNextIncompleteTask(taskList)?.taskId, "1.2");
+});
+
+test("execution helpers read structured control and result files", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-execution-"));
+  const controlPath = path.join(tempRoot, "execution-control.json");
+  const resultPath = path.join(tempRoot, "execution-result.json");
+
+  await writeJsonFile(controlPath, {
+    version: 1,
+    changeName: "demo-change",
+    mode: "apply",
+    state: "armed",
+    armedAt: new Date().toISOString(),
+    pauseRequested: false,
+    cancelRequested: false,
+  });
+  await writeJsonFile(resultPath, {
+    version: 1,
+    changeName: "demo-change",
+    mode: "apply",
+    status: "paused",
+    timestamp: new Date().toISOString(),
+    summary: "Paused cleanly.",
+    progressMade: true,
+    changedFiles: ["src/index.ts"],
+    notes: ["wrote execution result"],
+  });
+
+  const control = await readExecutionControl(controlPath);
+  const result = await readExecutionResult(resultPath);
+
+  assert.equal(control?.changeName, "demo-change");
+  assert.equal(control?.state, "armed");
+  assert.equal(result?.status, "paused");
+  assert.deepEqual(result?.changedFiles, ["src/index.ts"]);
+  assert.equal(isExecutionTriggerText("continue"), true);
+  assert.equal(isExecutionTriggerText("Need one more requirement"), false);
+});

package/test/use-project.test.ts

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { pathExists } from "../src/utils/fs.ts";
+import { createServiceHarness } from "./helpers/harness.ts";
+
+test("useProject initializes repo and selects project", async () => {
+  const harness = await createServiceHarness("clawspec-use-project-");
+  const { service, stateStore, workspacePath } = harness;
+  const channelKey = "discord:use-project:default:main";
+
+  await service.startProject(channelKey);
+  const result = await service.useProject(channelKey, "demo-app");
+  const project = await stateStore.getActiveProject(channelKey);
+
+  assert.match(result.text ?? "", /Project Selected/);
+  assert.equal(project?.repoPath, path.join(workspacePath, "demo-app"));
+  assert.equal(await pathExists(path.join(workspacePath, "demo-app", "openspec", "config.yaml")), true);
+});