clawspec 1.0.16 → 1.0.20

package/test/keywords.test.ts

@@ -1,92 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import {
-  parseClawSpecKeyword,
-  extractEmbeddedClawSpecKeyword,
-  isClawSpecKeywordText,
-} from "../src/control/keywords.ts";
-
-test("parseClawSpecKeyword recognizes all primary commands", () => {
-  const commands = [
-    ["cs-plan", "plan"],
-    ["cs-work", "work"],
-    ["cs-attach", "attach"],
-    ["cs-detach", "detach"],
-    ["cs-deattach", "detach"],
-    ["cs-pause", "pause"],
-    ["cs-continue", "continue"],
-    ["cs-status", "status"],
-    ["cs-cancel", "cancel"],
-  ] as const;
-
-  for (const [input, expectedKind] of commands) {
-    const result = parseClawSpecKeyword(input);
-    assert.equal(result?.kind, expectedKind, `${input} should be kind "${expectedKind}"`);
-    assert.equal(result?.command, input.toLowerCase());
-  }
-});
-
-test("parseClawSpecKeyword handles args", () => {
-  const result = parseClawSpecKeyword("cs-continue now please");
-  assert.equal(result?.kind, "continue");
-  assert.equal(result?.args, "now please");
-  assert.equal(result?.raw, "cs-continue now please");
-});
-
-test("parseClawSpecKeyword returns null for non-cs- prefixed text", () => {
-  assert.equal(parseClawSpecKeyword("hello world"), null);
-  assert.equal(parseClawSpecKeyword("/clawspec proposal"), null);
-  assert.equal(parseClawSpecKeyword(""), null);
-  assert.equal(parseClawSpecKeyword("cs-nonexistent"), null);
-});
-
-test("parseClawSpecKeyword is case-insensitive for command", () => {
-  const result = parseClawSpecKeyword("CS-PLAN");
-  assert.equal(result?.kind, "plan");
-  assert.equal(result?.command, "cs-plan");
-});
-
-test("parseClawSpecKeyword trims input", () => {
-  const result = parseClawSpecKeyword("  cs-work  ");
-  assert.equal(result?.kind, "work");
-});
-
-test("parseClawSpecKeyword accepts slash-prefixed and punctuated control words", () => {
-  assert.equal(parseClawSpecKeyword("/cs-work")?.kind, "work");
-  assert.equal(parseClawSpecKeyword("`cs-plan`")?.kind, "plan");
-  assert.equal(parseClawSpecKeyword("cs-work。")?.kind, "work");
-});
-
-test("isClawSpecKeywordText returns boolean correctly", () => {
-  assert.equal(isClawSpecKeywordText("cs-plan"), true);
-  assert.equal(isClawSpecKeywordText("hello"), false);
-});
-
-test("extractEmbeddedClawSpecKeyword finds keyword in multiline text", () => {
-  const text = "Here is some context\n\ncs-work\n\nMore text after";
-  const result = extractEmbeddedClawSpecKeyword(text);
-  assert.equal(result?.kind, "work");
-});
-
-test("extractEmbeddedClawSpecKeyword finds keyword with args in multiline text", () => {
-  const text = "Please do this:\ncs-continue hello world\nThanks!";
-  const result = extractEmbeddedClawSpecKeyword(text);
-  assert.equal(result?.kind, "continue");
-  assert.equal(result?.args, "hello world");
-});
-
-test("extractEmbeddedClawSpecKeyword finds slash-prefixed keyword in multiline text", () => {
-  const text = "Summary:\n/cs-work\nProceed please.";
-  const result = extractEmbeddedClawSpecKeyword(text);
-  assert.equal(result?.kind, "work");
-});
-
-test("extractEmbeddedClawSpecKeyword returns direct match for single-line input", () => {
-  const result = extractEmbeddedClawSpecKeyword("cs-status");
-  assert.equal(result?.kind, "status");
-});
-
-test("extractEmbeddedClawSpecKeyword returns null when no keyword present", () => {
-  assert.equal(extractEmbeddedClawSpecKeyword("no keywords here"), null);
-  assert.equal(extractEmbeddedClawSpecKeyword("just a normal message\nwith multiple lines"), null);
-});

package/test/notifier.test.ts

@@ -1,29 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { ClawSpecNotifier } from "../src/watchers/notifier.ts";
-import { createLogger } from "./helpers/harness.ts";
-
-test("notifier formats Discord channel target correctly", async () => {
-  const sent: Array<{ to: string; text: string }> = [];
-  const notifier = new ClawSpecNotifier({
-    api: {
-      config: {},
-      runtime: {
-        channel: {
-          discord: {
-            sendMessageDiscord: async (to: string, text: string) => {
-              sent.push({ to, text });
-            },
-          },
-          telegram: {},
-          slack: {},
-          signal: {},
-        },
-      },
-    } as any,
-    logger: createLogger() as any,
-  });
-
-  await notifier.send("discord:1474686041939251210:default:main", "hello");
-  assert.deepEqual(sent, [{ to: "channel:1474686041939251210", text: "hello" }]);
-});

package/test/openspec-dependency.test.ts

@@ -1,68 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { buildOpenSpecInstallMessage, ensureOpenSpecCli } from "../src/dependencies/openspec.ts";
-
-const ROOT_PREFIX = process.platform === "win32" ? "C:\\clawspec-test" : "/tmp/clawspec-test";
-
-const LOCAL_COMMAND = path.join(
-  ROOT_PREFIX,
-  "node_modules",
-  ".bin",
-  process.platform === "win32" ? "openspec.cmd" : "openspec",
-);
-
-test("ensureOpenSpecCli uses the global openspec command when available", async () => {
-  const calls: Array<{ command: string; args: string[] }> = [];
-  const result = await ensureOpenSpecCli({
-    pluginRoot: ROOT_PREFIX,
-    runner: async ({ command, args }) => {
-      calls.push({ command, args });
-      if (command === LOCAL_COMMAND) {
-        return { code: 1, stdout: "", stderr: "not found" };
-      }
-      if (command === "openspec") {
-        return { code: 0, stdout: "1.2.0\n", stderr: "" };
-      }
-      return { code: 1, stdout: "", stderr: "unexpected command" };
-    },
-  });
-
-  assert.equal(result.source, "global");
-  assert.equal(result.version, "1.2.0");
-  assert.equal(calls.some((call) => call.command === "npm"), false);
-});
-
-test("ensureOpenSpecCli installs plugin-local openspec when local and global are unavailable", async () => {
-  const calls: Array<{ command: string; args: string[] }> = [];
-  const result = await ensureOpenSpecCli({
-    pluginRoot: ROOT_PREFIX,
-    runner: async ({ command, args }) => {
-      calls.push({ command, args });
-      if (command === LOCAL_COMMAND) {
-        const versionChecks = calls.filter((call) => call.command === LOCAL_COMMAND && call.args[0] === "--version").length;
-        if (versionChecks >= 2) {
-          return { code: 0, stdout: "1.2.3\n", stderr: "" };
-        }
-        return { code: 1, stdout: "", stderr: "not found" };
-      }
-      if (command === "openspec") {
-        return { code: 1, stdout: "", stderr: "not found" };
-      }
-      if (command === "npm") {
-        return { code: 0, stdout: "installed", stderr: "" };
-      }
-      return { code: 1, stdout: "", stderr: "unexpected command" };
-    },
-  });
-
-  assert.equal(result.source, "local");
-  assert.equal(result.version, "1.2.3");
-  assert.equal(calls.some((call) => call.command === "npm"), true);
-});
-
-test("buildOpenSpecInstallMessage includes install command", () => {
-  const message = buildOpenSpecInstallMessage("not found");
-  assert.match(message, /npm install -g @fission-ai\/openspec/);
-  assert.match(message, /not found/);
-});

package/test/paths-utils.test.ts

@@ -1,30 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-import path from "node:path";
-import { resolveUserPath } from "../src/utils/paths.ts";
-
-test("resolveUserPath expands home directory shorthand", () => {
-  const actual = resolveUserPath("~/Desktop/workspace/ai_workspace", "/tmp/base");
-  const expected = path.join(os.homedir(), "Desktop", "workspace", "ai_workspace");
-  assert.equal(actual, expected);
-});
-
-test("resolveUserPath resolves relative path against base directory", () => {
-  const base = path.join(os.homedir(), "clawspec", "workspace");
-  const actual = resolveUserPath("demo-app", base);
-  assert.equal(actual, path.resolve(base, "demo-app"));
-});
-
-test("resolveUserPath keeps POSIX absolute path absolute", () => {
-  const absolute = "/tmp/clawspec-posix-absolute";
-  const actual = resolveUserPath(absolute, "/tmp/base");
-  assert.equal(actual, path.normalize(absolute));
-});
-
-test("resolveUserPath keeps Windows drive absolute path absolute on all platforms", () => {
-  const absolute = "C:\\Users\\dev\\workspace\\demo";
-  const actual = resolveUserPath(absolute, "/tmp/base");
-  assert.equal(actual, path.normalize(absolute));
-});
-

package/test/pause-cancel.test.ts

@@ -1,55 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createServiceHarness, seedPlanningProject } from "./helpers/harness.ts";
-
-test("pause requests watcher interrupt", async () => {
-  const harness = await createServiceHarness("clawspec-pause-");
-  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
-  const channelKey = "discord:pause:default:main";
-
-  await seedPlanningProject(stateStore, channelKey, {
-    workspacePath,
-    repoPath,
-    projectName: "demo-app",
-    changeName: "pause-change",
-    changeDir,
-    phase: "implementing",
-    status: "running",
-    planningDirty: false,
-    execution: { action: "work", state: "running", mode: "apply" },
-  });
-
-  const result = await service.pauseProject(channelKey);
-  const project = await stateStore.getActiveProject(channelKey);
-
-  assert.match(result.text ?? "", /Pause Requested/);
-  assert.equal(project?.pauseRequested, true);
-  assert.deepEqual(watcherManager.interruptCalls, [{ channelKey, reason: "paused by user" }]);
-  assert.deepEqual(watcherManager.wakeCalls, [channelKey]);
-});
-
-test("cancel requests watcher interrupt", async () => {
-  const harness = await createServiceHarness("clawspec-cancel-");
-  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
-  const channelKey = "discord:cancel:default:main";
-
-  await seedPlanningProject(stateStore, channelKey, {
-    workspacePath,
-    repoPath,
-    projectName: "demo-app",
-    changeName: "cancel-change",
-    changeDir,
-    phase: "implementing",
-    status: "running",
-    planningDirty: false,
-    execution: { action: "work", state: "running", mode: "apply" },
-  });
-
-  const result = await service.cancelProject(channelKey);
-  const project = await stateStore.getActiveProject(channelKey);
-
-  assert.match(result.text ?? "", /Cancellation Requested/);
-  assert.equal(project?.cancelRequested, true);
-  assert.deepEqual(watcherManager.interruptCalls, [{ channelKey, reason: "cancelled by user" }]);
-  assert.deepEqual(watcherManager.wakeCalls, [channelKey]);
-});

package/test/planning-journal.test.ts

@@ -1,155 +0,0 @@
-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 { PlanningJournalStore } from "../src/planning/journal.ts";
-
-test("planning journal reports clean when snapshot matches current content", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-journal-clean-"));
-  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
-  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
-  const store = new PlanningJournalStore(journalPath);
-
-  await store.append({
-    timestamp: "2026-03-23T07:00:00.000Z",
-    changeName: "hello",
-    role: "user",
-    text: "keep the two existing endpoints",
-  });
-  await store.writeSnapshot(snapshotPath, "hello", "2026-03-23T07:05:00.000Z");
-
-  assert.equal(await store.hasUnsyncedChanges("hello", snapshotPath), false);
-});
-
-test("planning journal reports dirty when a new entry is appended after the snapshot", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-journal-dirty-"));
-  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
-  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
-  const store = new PlanningJournalStore(journalPath);
-
-  await store.append({
-    timestamp: "2026-03-23T07:00:00.000Z",
-    changeName: "hello",
-    role: "user",
-    text: "keep the two existing endpoints",
-  });
-  await store.writeSnapshot(snapshotPath, "hello", "2026-03-23T07:05:00.000Z");
-  await store.append({
-    timestamp: "2026-03-23T07:10:00.000Z",
-    changeName: "hello",
-    role: "user",
-    text: "add two new interfaces to the same change",
-  });
-
-  assert.equal(await store.hasUnsyncedChanges("hello", snapshotPath), true);
-});
-
-test("planning journal falls back to lastSyncedAt when no snapshot exists yet", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-journal-fallback-"));
-  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
-  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
-  const store = new PlanningJournalStore(journalPath);
-
-  await store.append({
-    timestamp: "2026-03-23T07:00:00.000Z",
-    changeName: "hello",
-    role: "user",
-    text: "keep the two existing endpoints",
-  });
-
-  assert.equal(
-    await store.hasUnsyncedChanges("hello", snapshotPath, "2026-03-23T07:05:00.000Z"),
-    false,
-  );
-  assert.equal(
-    await store.hasUnsyncedChanges("hello", snapshotPath, "2026-03-23T06:55:00.000Z"),
-    true,
-  );
-});
-
-test("snapshot is always written after planning sync regardless of journal dirty state", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-snapshot-always-"));
-  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
-  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
-  const store = new PlanningJournalStore(journalPath);
-
-  await store.append({
-    timestamp: "2026-03-27T03:00:00.000Z",
-    changeName: "test",
-    role: "user",
-    text: "initial requirement",
-  });
-
-  const snapshot1 = await store.writeSnapshot(snapshotPath, "test", "2026-03-27T03:05:00.000Z");
-  assert.equal(snapshot1.entryCount, 1);
-
-  await store.append({
-    timestamp: "2026-03-27T03:10:00.000Z",
-    changeName: "test",
-    role: "assistant",
-    text: "planning sync response",
-  });
-
-  const snapshot2 = await store.writeSnapshot(snapshotPath, "test", "2026-03-27T03:15:00.000Z");
-  assert.equal(snapshot2.entryCount, 2);
-  assert.equal(await store.hasUnsyncedChanges("test", snapshotPath), false);
-});
-
-test("snapshot correctly captures all journal entries including assistant messages", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-snapshot-complete-"));
-  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
-  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
-  const store = new PlanningJournalStore(journalPath);
-
-  await store.append({
-    timestamp: "2026-03-27T03:00:00.000Z",
-    changeName: "test",
-    role: "user",
-    text: "user requirement",
-  });
-  await store.append({
-    timestamp: "2026-03-27T03:05:00.000Z",
-    changeName: "test",
-    role: "assistant",
-    text: "assistant response",
-  });
-
-  const snapshot = await store.writeSnapshot(snapshotPath, "test");
-  const digest = await store.digest("test");
-
-  assert.equal(snapshot.entryCount, digest.entryCount);
-  assert.equal(snapshot.lastEntryAt, digest.lastEntryAt);
-  assert.equal(snapshot.contentHash, digest.contentHash);
-});
-
-test("snapshot sync after cs-plan, add requirement, cs-plan again", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-replan-"));
-  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
-  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
-  const store = new PlanningJournalStore(journalPath);
-
-  await store.append({
-    timestamp: "2026-03-27T06:00:00.000Z",
-    changeName: "test",
-    role: "user",
-    text: "initial requirement",
-  });
-
-  const snapshot1 = await store.writeSnapshot(snapshotPath, "test", "2026-03-27T06:05:00.000Z");
-  assert.equal(snapshot1.entryCount, 1);
-  assert.equal(await store.hasUnsyncedChanges("test", snapshotPath), false);
-
-  await store.append({
-    timestamp: "2026-03-27T06:10:00.000Z",
-    changeName: "test",
-    role: "user",
-    text: "additional requirement",
-  });
-
-  assert.equal(await store.hasUnsyncedChanges("test", snapshotPath), true);
-
-  const snapshot2 = await store.writeSnapshot(snapshotPath, "test", "2026-03-27T06:15:00.000Z");
-  assert.equal(snapshot2.entryCount, 2);
-  assert.equal(await store.hasUnsyncedChanges("test", snapshotPath), false);
-});

package/test/plugin-registration.test.ts

@@ -1,35 +0,0 @@
-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 plugin from "../src/index.ts";
-
-test("plugin registers the clawspec command", async () => {
-  const stateDir = await mkdtemp(path.join(os.tmpdir(), "clawspec-plugin-register-"));
-  const commandNames: string[] = [];
-
-  plugin.register({
-    pluginConfig: {},
-    config: {},
-    logger: {
-      info() {},
-      warn() {},
-      error() {},
-      debug() {},
-    },
-    runtime: {
-      state: {
-        resolveStateDir: () => stateDir,
-      },
-    },
-    registerService() {},
-    registerCli() {},
-    registerCommand(command: { name: string }) {
-      commandNames.push(command.name);
-    },
-    on() {},
-  } as any);
-
-  assert.deepEqual(commandNames, ["clawspec"]);
-});

package/test/project-memory.test.ts

@@ -1,42 +0,0 @@
-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 {
-  DuplicateRememberedProjectError,
-  ProjectMemoryStore,
-  RememberedProjectPathInvalidError,
-} from "../src/memory/store.ts";
-
-test("project memory store remembers, lists, overwrites, and validates paths", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-memory-"));
-  const memoryFile = path.join(tempRoot, "project-memory.json");
-  const repoA = path.join(tempRoot, "repo-a");
-  const repoB = path.join(tempRoot, "repo-b");
-  await mkdir(repoA, { recursive: true });
-  await mkdir(repoB, { recursive: true });
-
-  const store = new ProjectMemoryStore(memoryFile);
-  await store.initialize();
-
-  const created = await store.remember("demo", repoA);
-  assert.equal(created.created, true);
-  assert.equal(created.overwritten, false);
-
-  const entries = await store.list();
-  assert.equal(entries.length, 1);
-  assert.equal(entries[0].repoPath, repoA);
-
-  await assert.rejects(() => store.remember("demo", repoB), DuplicateRememberedProjectError);
-
-  const overwritten = await store.remember("demo", repoB, { overwrite: true });
-  assert.equal(overwritten.overwritten, true);
-  assert.equal((await store.resolveForUse("demo")).repoPath, repoB);
-
-  const staleFile = path.join(tempRoot, "stale-memory.json");
-  const staleStore = new ProjectMemoryStore(staleFile);
-  await staleStore.initialize();
-  await staleStore.remember("stale", path.join(tempRoot, "missing"));
-  await assert.rejects(() => staleStore.resolveForUse("stale"), RememberedProjectPathInvalidError);
-});

package/test/proposal.test.ts

@@ -1,24 +0,0 @@
-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("proposal creates scaffold and rollback baseline", async () => {
-  const harness = await createServiceHarness("clawspec-proposal-");
-  const { service, stateStore, workspacePath } = harness;
-  const channelKey = "discord:proposal:default:main";
-
-  await service.startProject(channelKey);
-  await service.useProject(channelKey, "demo-app");
-  const result = await service.proposalProject(channelKey, "support-weather Add weather endpoints");
-  const project = await stateStore.getActiveProject(channelKey);
-  const changeDir = path.join(workspacePath, "demo-app", "openspec", "changes", "support-weather");
-
-  assert.match(result.text ?? "", /Proposal Ready/);
-  assert.equal(project?.changeName, "support-weather");
-  assert.equal(project?.status, "ready");
-  assert.equal(project?.phase, "proposal");
-  assert.equal(await pathExists(path.join(changeDir, ".openspec.yaml")), true);
-  assert.equal(await pathExists(project?.rollback?.manifestPath ?? ""), true);
-});