@united-workforce/cli 0.3.0 → 0.5.0

package/src/__tests__/store-global-cas.test.ts

@@ -230,11 +230,11 @@ describe("Global CAS directory", () => {
     const { createThreadIndexEntry } = await import("@united-workforce/protocol");
 
     setThread(uwf.varStore, threadId, createThreadIndexEntry(headHash));
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const entry = getThread(uwf.varStore, threadId);
     expect(entry?.head).toBe(headHash);
-    expect(entry?.status).toBe("completed");
+    expect(entry?.status).toBe("end");
 
     const { access } = await import("node:fs/promises");
     await access(join(globalCasDir, "vars"));

package/src/__tests__/store-unified-threads.test.ts

@@ -1,23 +1,17 @@
-import { mkdir, mkdtemp } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
-import { describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import {
   completeThread,
-  createUwfStore,
+  type createUwfStore,
   getThread,
   loadActiveThreads,
   loadHistoryThreads,
   setThread,
 } from "../store.js";
-
-async function makeUwfStore(storageRoot: string) {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
+import { makeUwfStore } from "./thread-test-helpers.js";
 
 async function seedThreadHead(
   uwf: Awaited<ReturnType<typeof createUwfStore>>,
@@ -26,9 +20,25 @@ async function seedThreadHead(
   return (await uwf.store.cas.put(uwf.schemas.text, label)) as CasRef;
 }
 
+let tmpDir: string;
+let savedOcasHome: string | undefined;
+
+beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "uwf-store-test-"));
+});
+
+afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
 describe("unified thread storage", () => {
   test("loadActiveThreads excludes completed threads", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-active-test-"));
     const uwf = await makeUwfStore(tmpDir);
 
     const threadId1 = "01JTEST000000000000ACTIVE1" as ThreadId;
@@ -46,7 +56,7 @@ describe("unified thread storage", () => {
 
     setThread(uwf.varStore, threadId2, {
       head: head2,
-      status: "completed",
+      status: "end",
       suspendedRole: null,
       suspendMessage: null,
       completedAt: Date.now(),
@@ -59,7 +69,6 @@ describe("unified thread storage", () => {
   });
 
   test("loadActiveThreads excludes cancelled threads", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-active-test-"));
     const uwf = await makeUwfStore(tmpDir);
 
     const threadId1 = "01JTEST000000000000ACTIVE3" as ThreadId;
@@ -90,7 +99,6 @@ describe("unified thread storage", () => {
   });
 
   test("loadHistoryThreads only returns completed and cancelled", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-history-test-"));
     const uwf = await makeUwfStore(tmpDir);
 
     const threadId1 = "01JTEST000000000000HISTOR1" as ThreadId;
@@ -110,7 +118,7 @@ describe("unified thread storage", () => {
 
     setThread(uwf.varStore, threadId2, {
       head: head2,
-      status: "completed",
+      status: "end",
       suspendedRole: null,
       suspendMessage: null,
       completedAt: Date.now(),
@@ -132,7 +140,6 @@ describe("unified thread storage", () => {
   });
 
   test("completeThread marks thread as completed", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000COMPLE1" as ThreadId;
     const head = await seedThreadHead(uwf, "active-head");
@@ -145,17 +152,16 @@ describe("unified thread storage", () => {
       completedAt: null,
     });
 
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const entry = getThread(uwf.varStore, threadId);
     expect(entry).not.toBeNull();
-    expect(entry?.status).toBe("completed");
+    expect(entry?.status).toBe("end");
     expect(entry?.completedAt).toBeDefined();
     expect(entry?.completedAt).toBeGreaterThan(0);
   });
 
   test("completeThread marks thread as cancelled", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000COMPLE2" as ThreadId;
     const head = await seedThreadHead(uwf, "active-head");
@@ -178,7 +184,6 @@ describe("unified thread storage", () => {
   });
 
   test("completeThread clears suspend metadata", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000COMPLE3" as ThreadId;
     const head = await seedThreadHead(uwf, "suspended-head");
@@ -191,29 +196,27 @@ describe("unified thread storage", () => {
       completedAt: null,
     });
 
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const entry = getThread(uwf.varStore, threadId);
     expect(entry).not.toBeNull();
-    expect(entry?.status).toBe("completed");
+    expect(entry?.status).toBe("end");
     expect(entry?.suspendedRole).toBeNull();
     expect(entry?.suspendMessage).toBeNull();
   });
 
   test("completeThread handles non-existent thread gracefully", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-complete-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000NOEXIST" as ThreadId;
 
     // Should not throw
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const entry = getThread(uwf.varStore, threadId);
     expect(entry).toBeNull();
   });
 
   test("status and completedAt tags are persisted and loaded", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-tags-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const threadId = "01JTEST000000000000TAGTEST" as ThreadId;
     const head = await seedThreadHead(uwf, "test-head");
@@ -221,7 +224,7 @@ describe("unified thread storage", () => {
 
     setThread(uwf.varStore, threadId, {
       head,
-      status: "completed",
+      status: "end",
       suspendedRole: null,
       suspendMessage: null,
       completedAt: now,
@@ -229,7 +232,7 @@ describe("unified thread storage", () => {
 
     const entry = getThread(uwf.varStore, threadId);
     expect(entry).not.toBeNull();
-    expect(entry?.status).toBe("completed");
+    expect(entry?.status).toBe("end");
     expect(entry?.completedAt).toBe(now);
   });
 });

package/src/__tests__/thread-cancel-status.test.ts

@@ -1,22 +1,16 @@
-import { mkdir, mkdtemp } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CasRef, ThreadId } from "@united-workforce/protocol";
-import { describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import {
   completeThread,
-  createUwfStore,
+  type createUwfStore,
   getThread,
   loadHistoryThreads,
   setThread,
 } from "../store.js";
-
-async function makeUwfStore(storageRoot: string) {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
+import { makeUwfStore } from "./thread-test-helpers.js";
 
 async function seedHistoryHead(
   uwf: Awaited<ReturnType<typeof createUwfStore>>,
@@ -25,9 +19,25 @@ async function seedHistoryHead(
   return (await uwf.store.cas.put(uwf.schemas.text, label)) as CasRef;
 }
 
+let tmpDir: string;
+let savedOcasHome: string | undefined;
+
+beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
+});
+
+afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
 describe("thread cancel status", () => {
   test("cancelled thread has status 'cancelled'", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const threadId = "01JTEST000000000000CANCEL1" as ThreadId;
     const uwf = await makeUwfStore(tmpDir);
     const head = await seedHistoryHead(uwf, "cancelled-head");
@@ -48,7 +58,6 @@ describe("thread cancel status", () => {
   });
 
   test("completed thread has status 'completed'", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const threadId = "01JTEST000000000000CANCEL2" as ThreadId;
     const uwf = await makeUwfStore(tmpDir);
     const head = await seedHistoryHead(uwf, "completed-head");
@@ -61,15 +70,14 @@ describe("thread cancel status", () => {
       completedAt: null,
     });
 
-    completeThread(uwf.varStore, threadId, "completed");
+    completeThread(uwf.varStore, threadId, "end");
 
     const entry = getThread(uwf.varStore, threadId);
     expect(entry).not.toBeNull();
-    expect(entry?.status).toBe("completed");
+    expect(entry?.status).toBe("end");
   });
 
   test("loadHistoryThreads returns completed and cancelled", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const head1 = await seedHistoryHead(uwf, "head1");
     const head2 = await seedHistoryHead(uwf, "head2");
@@ -82,7 +90,7 @@ describe("thread cancel status", () => {
       suspendMessage: null,
       completedAt: null,
     });
-    completeThread(uwf.varStore, threadId1, "completed");
+    completeThread(uwf.varStore, threadId1, "end");
 
     const threadId2 = "01JTEST000000000000CANCEL5" as ThreadId;
     setThread(uwf.varStore, threadId2, {
@@ -99,11 +107,10 @@ describe("thread cancel status", () => {
     const statuses = Object.values(history)
       .map((entry) => entry.status)
       .sort();
-    expect(statuses).toEqual(["cancelled", "completed"]);
+    expect(statuses).toEqual(["cancelled", "end"]);
   });
 
   test("mixed completed and cancelled entries preserve distinct statuses", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
     const uwf = await makeUwfStore(tmpDir);
     const head1 = await seedHistoryHead(uwf, "head1");
     const head2 = await seedHistoryHead(uwf, "head2");
@@ -116,7 +123,7 @@ describe("thread cancel status", () => {
       suspendMessage: null,
       completedAt: null,
     });
-    completeThread(uwf.varStore, threadId1, "completed");
+    completeThread(uwf.varStore, threadId1, "end");
 
     const threadId2 = "01JTEST000000000000CANCEL7" as ThreadId;
     setThread(uwf.varStore, threadId2, {
@@ -133,6 +140,6 @@ describe("thread cancel status", () => {
     const statuses = Object.values(history)
       .map((entry) => entry.status)
       .sort();
-    expect(statuses).toEqual(["cancelled", "completed"]);
+    expect(statuses).toEqual(["cancelled", "end"]);
   });
 });

package/src/__tests__/thread-cancel-text-renderer.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "vitest";
+import { formatOutput, getTextRenderer, TEXT_RENDERERS } from "../format.js";
+import { renderThreadCancel } from "../text-renderers.js";
+
+describe("thread cancel — text renderer registration", () => {
+  test("TEXT_RENDERERS contains 'thread cancel'", () => {
+    expect(getTextRenderer("thread cancel")).toBeDefined();
+    expect(typeof getTextRenderer("thread cancel")).toBe("function");
+  });
+
+  test("TEXT_RENDERERS['thread cancel'] is the same reference as renderThreadCancel", () => {
+    expect(TEXT_RENDERERS["thread cancel"]).toBe(renderThreadCancel);
+  });
+
+  test("renderThreadCancel is exported from text-renderers.ts", () => {
+    expect(typeof renderThreadCancel).toBe("function");
+  });
+});
+
+describe("renderThreadCancel — output shape", () => {
+  test("returns a string for full payload", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    expect(typeof out).toBe("string");
+  });
+
+  test("includes the cancelled thread's ULID", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    expect(out).toContain("01JTEST000000000000CANCEL1");
+  });
+
+  test("indicates cancelled status (Status: cancelled OR Cancelled: yes)", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    // accept either rendering style
+    const lower = out.toLowerCase();
+    const hasCancelMarker = lower.includes("cancelled") || lower.includes("yes");
+    expect(hasCancelMarker).toBe(true);
+  });
+
+  test("does NOT begin with '{' or '[' (not raw JSON)", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    const trimmed = out.trimStart();
+    expect(trimmed.startsWith("{")).toBe(false);
+    expect(trimmed.startsWith("[")).toBe(false);
+  });
+
+  test("does NOT contain literal 'undefined'", () => {
+    const out = renderThreadCancel({
+      thread: "01JTEST000000000000CANCEL1",
+      cancelled: true,
+    });
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("renderThreadCancel — partial / missing data", () => {
+  test("missing 'cancelled' field — returns string, no throw, no 'undefined'", () => {
+    const out = renderThreadCancel({ thread: "01JTEST000000000000CANCEL1" });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("missing 'thread' field — returns string, no throw, no 'undefined'", () => {
+    const out = renderThreadCancel({ cancelled: true });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("empty object — returns string, no throw, no 'undefined'", () => {
+    const out = renderThreadCancel({});
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("null payload — returns string, no throw", () => {
+    expect(() => renderThreadCancel(null)).not.toThrow();
+    const out = renderThreadCancel(null);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("non-object payload (string) — returns string, no throw", () => {
+    expect(() => renderThreadCancel("oops")).not.toThrow();
+    const out = renderThreadCancel("oops");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("formatOutput integration — thread cancel", () => {
+  test("formatOutput(data, 'text', 'thread cancel') uses renderer", () => {
+    const data = { thread: "01JTEST000000000000CANCEL1", cancelled: true };
+    const out = formatOutput(data, "text", "thread cancel");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+    expect(out.trimStart().startsWith("{")).toBe(false);
+    expect(out).toContain("01JTEST000000000000CANCEL1");
+  });
+
+  test("formatOutput(data, 'json', 'thread cancel') still emits parseable JSON", () => {
+    const data = { thread: "01JTEST000000000000CANCEL1", cancelled: true };
+    const out = formatOutput(data, "json", "thread cancel");
+    const parsed = JSON.parse(out);
+    expect(parsed).toEqual(data);
+  });
+
+  test("formatOutput(data, 'yaml', 'thread cancel') still emits YAML", () => {
+    const data = { thread: "01JTEST000000000000CANCEL1", cancelled: true };
+    const out = formatOutput(data, "yaml", "thread cancel");
+    expect(typeof out).toBe("string");
+    expect(out).toContain("thread:");
+    expect(out).toContain("cancelled:");
+  });
+});