@united-workforce/cli 0.3.0 → 0.5.0

package/src/__tests__/log-text-renderer.test.ts

@@ -0,0 +1,294 @@
+import { describe, expect, test } from "vitest";
+import { formatOutput, getTextRenderer, TEXT_RENDERERS } from "../format.js";
+import { renderLogList, renderLogShow } from "../text-renderers.js";
+
+describe("log list — text renderer registration", () => {
+  test("TEXT_RENDERERS contains 'log list'", () => {
+    expect(getTextRenderer("log list")).toBeDefined();
+    expect(typeof getTextRenderer("log list")).toBe("function");
+  });
+
+  test("TEXT_RENDERERS['log list'] is the same reference as renderLogList", () => {
+    expect(TEXT_RENDERERS["log list"]).toBe(renderLogList);
+  });
+
+  test("renderLogList is exported from text-renderers.ts", () => {
+    expect(typeof renderLogList).toBe("function");
+  });
+});
+
+describe("log show — text renderer registration", () => {
+  test("TEXT_RENDERERS contains 'log show'", () => {
+    expect(getTextRenderer("log show")).toBeDefined();
+    expect(typeof getTextRenderer("log show")).toBe("function");
+  });
+
+  test("TEXT_RENDERERS['log show'] is the same reference as renderLogShow", () => {
+    expect(TEXT_RENDERERS["log show"]).toBe(renderLogShow);
+  });
+
+  test("renderLogShow is exported from text-renderers.ts", () => {
+    expect(typeof renderLogShow).toBe("function");
+  });
+});
+
+describe("renderLogList — output shape", () => {
+  test("returns a string for full payload", () => {
+    const out = renderLogList([
+      { name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" },
+      { name: "2026-06-11.jsonl", size: 8192, date: "2026-06-11" },
+    ]);
+    expect(typeof out).toBe("string");
+  });
+
+  test("includes file names, dates, and sizes for each row", () => {
+    const out = renderLogList([
+      { name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" },
+      { name: "2026-06-11.jsonl", size: 8192, date: "2026-06-11" },
+    ]);
+    expect(out).toContain("2026-06-10.jsonl");
+    expect(out).toContain("2026-06-10");
+    expect(out).toContain("2026-06-11.jsonl");
+    expect(out).toContain("2026-06-11");
+  });
+
+  test("includes a header line", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }]);
+    const lines = out.split("\n");
+    expect(lines.length).toBeGreaterThanOrEqual(2);
+    // header should mention NAME or DATE or SIZE
+    const header = lines[0]?.toUpperCase() ?? "";
+    const hasHeader = header.includes("NAME") || header.includes("DATE") || header.includes("SIZE");
+    expect(hasHeader).toBe(true);
+  });
+
+  test("does NOT begin with '{' or '[' (not raw JSON)", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }]);
+    const trimmed = out.trimStart();
+    expect(trimmed.startsWith("{")).toBe(false);
+    expect(trimmed.startsWith("[")).toBe(false);
+  });
+
+  test("does NOT contain literal 'undefined'", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }]);
+    expect(out).not.toContain("undefined");
+  });
+
+  test("empty array — returns string, no 'undefined'", () => {
+    const out = renderLogList([]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("null payload — returns string, does not throw", () => {
+    expect(() => renderLogList(null)).not.toThrow();
+    const out = renderLogList(null);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("non-array payload — returns string, does not throw", () => {
+    expect(() => renderLogList({ name: "x" })).not.toThrow();
+    const out = renderLogList({ name: "x" });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("partial item (missing size) — returns string, no 'undefined'", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", date: "2026-06-10" }]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("renderLogShow — output shape", () => {
+  test("returns a string for full payload", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: "01JTEST000000000000THREAD1",
+        workflow: "WF1234567890A",
+      },
+    ]);
+    expect(typeof out).toBe("string");
+  });
+
+  test("includes ts, pid, tag, and msg for each entry", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: null,
+        workflow: null,
+      },
+    ]);
+    expect(out).toContain("2026-06-12T10:00:00.000Z");
+    expect(out).toContain("12345");
+    expect(out).toContain("4KNMR2PX");
+    expect(out).toContain("Loading workflow...");
+  });
+
+  test("includes thread id when present", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: "01JTEST000000000000THREAD1",
+        workflow: null,
+      },
+    ]);
+    expect(out).toContain("01JTEST000000000000THREAD1");
+  });
+
+  test("does NOT begin with '{' or '[' (not raw JSON)", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: null,
+        workflow: null,
+      },
+    ]);
+    const trimmed = out.trimStart();
+    expect(trimmed.startsWith("{")).toBe(false);
+    expect(trimmed.startsWith("[")).toBe(false);
+  });
+
+  test("does NOT contain literal 'undefined'", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: null,
+        workflow: null,
+      },
+    ]);
+    expect(out).not.toContain("undefined");
+  });
+
+  test("empty array — returns string, no 'undefined'", () => {
+    const out = renderLogShow([]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("null payload — returns string, does not throw", () => {
+    expect(() => renderLogShow(null)).not.toThrow();
+    const out = renderLogShow(null);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("non-array payload — returns string, does not throw", () => {
+    expect(() => renderLogShow({ ts: "x" })).not.toThrow();
+    const out = renderLogShow({ ts: "x" });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("partial entry (missing thread) — returns string, no 'undefined'", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+      },
+    ]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("formatOutput integration — log list", () => {
+  test("formatOutput(data, 'text', 'log list') uses renderer", () => {
+    const data = [{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }];
+    const out = formatOutput(data, "text", "log list");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+    expect(out.trimStart().startsWith("{")).toBe(false);
+    expect(out.trimStart().startsWith("[")).toBe(false);
+    expect(out).toContain("2026-06-10.jsonl");
+  });
+
+  test("formatOutput(data, 'json', 'log list') still emits parseable JSON", () => {
+    const data = [{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }];
+    const out = formatOutput(data, "json", "log list");
+    const parsed = JSON.parse(out);
+    expect(parsed).toEqual(data);
+  });
+
+  test("formatOutput(data, 'yaml', 'log list') still emits YAML", () => {
+    const data = [{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }];
+    const out = formatOutput(data, "yaml", "log list");
+    expect(typeof out).toBe("string");
+    expect(out).toContain("name:");
+    expect(out).toContain("2026-06-10.jsonl");
+  });
+});
+
+describe("formatOutput integration — log show", () => {
+  test("formatOutput(data, 'text', 'log show') uses renderer", () => {
+    const data = [
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+        thread: null,
+        workflow: null,
+      },
+    ];
+    const out = formatOutput(data, "text", "log show");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+    expect(out.trimStart().startsWith("{")).toBe(false);
+    expect(out.trimStart().startsWith("[")).toBe(false);
+    expect(out).toContain("4KNMR2PX");
+    expect(out).toContain("hello");
+  });
+
+  test("formatOutput(data, 'json', 'log show') still emits parseable JSON", () => {
+    const data = [
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+        thread: null,
+        workflow: null,
+      },
+    ];
+    const out = formatOutput(data, "json", "log show");
+    const parsed = JSON.parse(out);
+    expect(parsed).toEqual(data);
+  });
+
+  test("formatOutput(data, 'yaml', 'log show') still emits YAML", () => {
+    const data = [
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+        thread: null,
+        workflow: null,
+      },
+    ];
+    const out = formatOutput(data, "yaml", "log show");
+    expect(typeof out).toBe("string");
+    expect(out).toContain("ts:");
+    expect(out).toContain("pid:");
+  });
+});

package/src/__tests__/moderator-evaluate.test.ts

@@ -13,14 +13,14 @@ const solveIssueGraph: WorkflowPayload["graph"] = {
     },
   },
   planner: {
-    planned: { role: "developer", prompt: "Implement the plan: {{plan}}", location: null },
+    planned: { role: "developer", prompt: "Implement the plan: {{ plan }}", location: null },
   },
   developer: {
-    implemented: { role: "reviewer", prompt: "Review the changes: {{summary}}", location: null },
+    implemented: { role: "reviewer", prompt: "Review the changes: {{ summary }}", location: null },
   },
   reviewer: {
     approved: { role: "$END", prompt: "Done.", location: null },
-    rejected: { role: "developer", prompt: "Fix: {{comments}}", location: null },
+    rejected: { role: "developer", prompt: "Fix: {{ comments }}", location: null },
   },
 };
 
@@ -68,49 +68,6 @@ describe("evaluate", () => {
     });
   });
 
-  test("status-based routing (needs input → $SUSPEND)", () => {
-    const graph: Record<string, Record<string, Target>> = {
-      ...solveIssueGraph,
-      reviewer: {
-        ...solveIssueGraph.reviewer,
-        needs_input: { role: "$SUSPEND", prompt: "Waiting for user input.", location: null },
-      },
-    };
-    const result = evaluate(graph, "reviewer", { $status: "needs_input" });
-    expect(result).toEqual({
-      ok: true,
-      value: {
-        action: "suspend",
-        suspendedRole: "reviewer",
-        prompt: "Waiting for user input.",
-      },
-    });
-  });
-
-  test("$SUSPEND prompt template renders mustache variables", () => {
-    const graph: Record<string, Record<string, Target>> = {
-      reviewer: {
-        needs_input: {
-          role: "$SUSPEND",
-          prompt: "Please clarify: {{{question}}}",
-          location: null,
-        },
-      },
-    };
-    const result = evaluate(graph, "reviewer", {
-      $status: "needs_input",
-      question: "Which API endpoint?",
-    });
-    expect(result).toEqual({
-      ok: true,
-      value: {
-        action: "suspend",
-        suspendedRole: "reviewer",
-        prompt: "Please clarify: Which API endpoint?",
-      },
-    });
-  });
-
   test("missing role in graph → error", () => {
     const result = evaluate(solveIssueGraph, "unknown-role", { $status: "new" });
     expect(result.ok).toBe(false);
@@ -127,7 +84,7 @@ describe("evaluate", () => {
     }
   });
 
-  test("mustache template rendering with simple fields", () => {
+  test("liquid template rendering with simple fields", () => {
     const result = evaluate(solveIssueGraph, "planner", {
       $status: "planned",
       plan: "Add auth middleware",
@@ -142,7 +99,7 @@ describe("evaluate", () => {
     });
   });
 
-  test("mustache does not HTML-escape prompt content", () => {
+  test("liquid does not HTML-escape prompt content", () => {
     const result = evaluate(solveIssueGraph, "reviewer", {
       $status: "rejected",
       comments: 'use <T> & "Result<T, E>" types',
@@ -153,10 +110,10 @@ describe("evaluate", () => {
     });
   });
 
-  test("triple mustache also works for unescaped output", () => {
+  test("liquid renders HTML content without escaping", () => {
     const graph: Record<string, Record<string, Target>> = {
       reviewer: {
-        rejected: { role: "developer", prompt: "Fix: {{{comments}}}", location: null },
+        rejected: { role: "developer", prompt: "Fix: {{ comments }}", location: null },
       },
     };
     const result = evaluate(graph, "reviewer", {
@@ -181,12 +138,12 @@ describe("evaluate", () => {
     }
   });
 
-  test("mustache template with nested object paths", () => {
+  test("liquid template with nested object paths", () => {
     const graph: Record<string, Record<string, Target>> = {
       reviewer: {
         rejected: {
           role: "developer",
-          prompt: "Address: {{review.comments}}",
+          prompt: "Address: {{ review.comments }}",
           location: null,
         },
       },

package/src/__tests__/output-mapper-thread-list-startedat.test.ts

@@ -0,0 +1,124 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import type { CasRef, ThreadId } from "@united-workforce/protocol";
+import { generateUlid } from "@united-workforce/util";
+import { describe, expect, test } from "vitest";
+import type { ThreadListItemWithStatus } from "../commands/thread.js";
+import { toThreadListPayload } from "../output-mappers.js";
+
+const OUTPUT_MAPPERS_PATH = fileURLToPath(new URL("../output-mappers.ts", import.meta.url));
+
+function makeItem(threadId: string): ThreadListItemWithStatus {
+  return {
+    thread: threadId as ThreadId,
+    workflow: "WORKFLOWHASH1" as CasRef,
+    head: "HEADHASH00001" as CasRef,
+    status: "idle",
+    currentRole: null,
+    statusDisplay: "idle",
+    workflowName: "test-workflow",
+  };
+}
+
+describe("toThreadListPayload — issue #343 (ULID timestamp decoded with padding stripped)", () => {
+  test("startedAt equals the millisecond timestamp originally passed to generateUlid", () => {
+    const ts = 1781219097830; // 2026-06-11T23:04:57.830Z
+    const ulid = generateUlid(ts);
+
+    const payload = toThreadListPayload([makeItem(ulid)]);
+
+    expect(payload.items).toHaveLength(1);
+    expect(payload.items[0]!.startedAt).toBe(ts);
+  });
+
+  test("startedAt is NOT the raw 50-bit value (i.e. NOT timestamp << 2)", () => {
+    const ts = 1781219097830;
+    const ulid = generateUlid(ts);
+
+    const payload = toThreadListPayload([makeItem(ulid)]);
+
+    // The buggy decoder produced ts * 4 = 7124876391323, pushing year to 2195.
+    expect(payload.items[0]!.startedAt).not.toBe(ts * 4);
+    expect(payload.items[0]!.startedAt).not.toBe(7124876391323);
+  });
+
+  test("startedAt decodes to year 2026 for the issue-reported ULID timestamp", () => {
+    const ts = 1781219097830;
+    const ulid = generateUlid(ts);
+
+    const payload = toThreadListPayload([makeItem(ulid)]);
+
+    const startedAt = payload.items[0]!.startedAt;
+    expect(startedAt).not.toBeNull();
+    if (startedAt === null) return;
+    const isoDate = new Date(startedAt).toISOString().slice(0, 10);
+    expect(isoDate).toBe("2026-06-11");
+  });
+
+  test("round-trips correctly across several timestamps", () => {
+    const timestamps = [
+      0,
+      Date.UTC(2020, 0, 1, 0, 0, 0),
+      Date.UTC(2023, 5, 15, 12, 30, 45),
+      Date.UTC(2026, 4, 20, 0, 0, 0),
+      Date.UTC(2030, 11, 31, 23, 59, 59),
+    ];
+    const items = timestamps.map((t) => makeItem(generateUlid(t)));
+
+    const payload = toThreadListPayload(items);
+
+    for (let i = 0; i < timestamps.length; i++) {
+      expect(payload.items[i]!.startedAt).toBe(timestamps[i]);
+    }
+  });
+
+  test("startedAt is null for thread ids that are not valid 26-char Crockford Base32 ULIDs", () => {
+    const cases = ["", "TOOSHORT", "TOOLONGAAAAAAAAAAAAAAAAAA", "INVALID!@#$%^&CHARACTERS"];
+    const items = cases.map((id) => makeItem(id));
+
+    const payload = toThreadListPayload(items);
+
+    for (const item of payload.items) {
+      expect(item.startedAt).toBeNull();
+    }
+  });
+
+  test("preserves other thread-list item fields verbatim", () => {
+    const ts = 1781219097830;
+    const ulid = generateUlid(ts);
+    const item: ThreadListItemWithStatus = {
+      thread: ulid as ThreadId,
+      workflow: "WORKFLOWHASH9" as CasRef,
+      head: "HEADHASH99999" as CasRef,
+      status: "running",
+      currentRole: "developer",
+      statusDisplay: "running",
+      workflowName: "solve-issue",
+    };
+
+    const payload = toThreadListPayload([item]);
+
+    expect(payload.items[0]).toEqual({
+      threadId: ulid,
+      workflowHash: "WORKFLOWHASH9",
+      workflowName: "solve-issue",
+      status: "running",
+      currentRole: "developer",
+      startedAt: ts,
+      completedAt: null,
+    });
+  });
+});
+
+describe("output-mappers.ts source — issue #343 refactor", () => {
+  test("does NOT contain a local extractUlidTime function (removed in favor of util)", async () => {
+    const source = await readFile(OUTPUT_MAPPERS_PATH, "utf8");
+    expect(source).not.toMatch(/function\s+extractUlidTime\b/);
+  });
+
+  test("imports extractUlidTimestamp from @united-workforce/util", async () => {
+    const source = await readFile(OUTPUT_MAPPERS_PATH, "utf8");
+    expect(source).toMatch(/extractUlidTimestamp/);
+    expect(source).toMatch(/@united-workforce\/util/);
+  });
+});

package/src/__tests__/output-mapper-workflow-add.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+import { toWorkflowAddPayload, type WorkflowAddPayload } from "../output-mappers.js";
+
+describe("toWorkflowAddPayload — issue #334", () => {
+  test("maps WorkflowAddOutput { name, hash } to plain payload shape", () => {
+    const out = toWorkflowAddPayload({ name: "review-pr", hash: "2TBP6T37TZAJZ" });
+    expect(out).toEqual({ name: "review-pr", hash: "2TBP6T37TZAJZ" });
+  });
+
+  test("returns a WorkflowAddPayload type with exactly two fields", () => {
+    const out: WorkflowAddPayload = toWorkflowAddPayload({
+      name: "solve-issue",
+      hash: "76C98RVXA5E4F",
+    });
+    expect(Object.keys(out).sort()).toEqual(["hash", "name"]);
+  });
+
+  test("performs no I/O — pure data mapping", () => {
+    // Repeated calls produce equal results
+    const a = toWorkflowAddPayload({ name: "a", hash: "AAA1234567890" });
+    const b = toWorkflowAddPayload({ name: "a", hash: "AAA1234567890" });
+    expect(a).toEqual(b);
+  });
+});