@united-workforce/cli 0.1.0

package/src/__tests__/store-storage-root.test.ts

@@ -0,0 +1,49 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { getDefaultStorageRoot, getGlobalCasDir, resolveStorageRoot } from "../store.js";
+
+describe("Storage root resolution", () => {
+  const envKeys = ["UWF_HOME", "OCAS_HOME"] as const;
+  const savedEnv: Partial<Record<(typeof envKeys)[number], string | undefined>> = {};
+
+  beforeEach(() => {
+    for (const key of envKeys) {
+      savedEnv[key] = process.env[key];
+      delete process.env[key];
+    }
+  });
+
+  afterEach(() => {
+    for (const key of envKeys) {
+      if (savedEnv[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = savedEnv[key];
+      }
+    }
+  });
+
+  test("getDefaultStorageRoot returns ~/.uwf", () => {
+    expect(getDefaultStorageRoot()).toBe(join(homedir(), ".uwf"));
+  });
+
+  test("resolveStorageRoot uses UWF_HOME", () => {
+    process.env.UWF_HOME = "/tmp/uwf-primary";
+    expect(resolveStorageRoot()).toBe("/tmp/uwf-primary");
+  });
+
+  test("resolveStorageRoot falls back to default when UWF_HOME unset", () => {
+    expect(resolveStorageRoot()).toBe(getDefaultStorageRoot());
+  });
+
+  test("getGlobalCasDir returns ~/.ocas by default", () => {
+    const casDir = getGlobalCasDir();
+    expect(casDir).toBe(join(homedir(), ".ocas"));
+  });
+
+  test("getGlobalCasDir respects OCAS_HOME", () => {
+    process.env.OCAS_HOME = "/tmp/ocas-primary";
+    expect(getGlobalCasDir()).toBe("/tmp/ocas-primary");
+  });
+});

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

@@ -0,0 +1,235 @@
+import { mkdir, mkdtemp } 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 {
+  completeThread,
+  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);
+}
+
+async function seedThreadHead(
+  uwf: Awaited<ReturnType<typeof createUwfStore>>,
+  label: string,
+): Promise<CasRef> {
+  return (await uwf.store.cas.put(uwf.schemas.text, label)) as CasRef;
+}
+
+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;
+    const threadId2 = "01JTEST000000000000ACTIVE2" as ThreadId;
+    const head1 = await seedThreadHead(uwf, "active-head");
+    const head2 = await seedThreadHead(uwf, "completed-head");
+
+    setThread(uwf.varStore, threadId1, {
+      head: head1,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    setThread(uwf.varStore, threadId2, {
+      head: head2,
+      status: "completed",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: Date.now(),
+    });
+
+    const active = loadActiveThreads(uwf.varStore);
+    expect(Object.keys(active)).toHaveLength(1);
+    expect(active[threadId1]).toBeDefined();
+    expect(active[threadId2]).toBeUndefined();
+  });
+
+  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;
+    const threadId2 = "01JTEST000000000000ACTIVE4" as ThreadId;
+    const head1 = await seedThreadHead(uwf, "active-head");
+    const head2 = await seedThreadHead(uwf, "cancelled-head");
+
+    setThread(uwf.varStore, threadId1, {
+      head: head1,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    setThread(uwf.varStore, threadId2, {
+      head: head2,
+      status: "cancelled",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: Date.now(),
+    });
+
+    const active = loadActiveThreads(uwf.varStore);
+    expect(Object.keys(active)).toHaveLength(1);
+    expect(active[threadId1]).toBeDefined();
+    expect(active[threadId2]).toBeUndefined();
+  });
+
+  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;
+    const threadId2 = "01JTEST000000000000HISTOR2" as ThreadId;
+    const threadId3 = "01JTEST000000000000HISTOR3" as ThreadId;
+    const head1 = await seedThreadHead(uwf, "active-head");
+    const head2 = await seedThreadHead(uwf, "completed-head");
+    const head3 = await seedThreadHead(uwf, "cancelled-head");
+
+    setThread(uwf.varStore, threadId1, {
+      head: head1,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    setThread(uwf.varStore, threadId2, {
+      head: head2,
+      status: "completed",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: Date.now(),
+    });
+
+    setThread(uwf.varStore, threadId3, {
+      head: head3,
+      status: "cancelled",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: Date.now(),
+    });
+
+    const history = loadHistoryThreads(uwf.varStore);
+    expect(Object.keys(history)).toHaveLength(2);
+    expect(history[threadId1]).toBeUndefined();
+    expect(history[threadId2]).toBeDefined();
+    expect(history[threadId3]).toBeDefined();
+  });
+
+  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");
+
+    setThread(uwf.varStore, threadId, {
+      head,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    completeThread(uwf.varStore, threadId, "completed");
+
+    const entry = getThread(uwf.varStore, threadId);
+    expect(entry).not.toBeNull();
+    expect(entry?.status).toBe("completed");
+    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");
+
+    setThread(uwf.varStore, threadId, {
+      head,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    completeThread(uwf.varStore, threadId, "cancelled");
+
+    const entry = getThread(uwf.varStore, threadId);
+    expect(entry).not.toBeNull();
+    expect(entry?.status).toBe("cancelled");
+    expect(entry?.completedAt).toBeDefined();
+    expect(entry?.completedAt).toBeGreaterThan(0);
+  });
+
+  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");
+
+    setThread(uwf.varStore, threadId, {
+      head,
+      status: "suspended",
+      suspendedRole: "test-role",
+      suspendMessage: "test message",
+      completedAt: null,
+    });
+
+    completeThread(uwf.varStore, threadId, "completed");
+
+    const entry = getThread(uwf.varStore, threadId);
+    expect(entry).not.toBeNull();
+    expect(entry?.status).toBe("completed");
+    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");
+
+    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");
+    const now = Date.now();
+
+    setThread(uwf.varStore, threadId, {
+      head,
+      status: "completed",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: now,
+    });
+
+    const entry = getThread(uwf.varStore, threadId);
+    expect(entry).not.toBeNull();
+    expect(entry?.status).toBe("completed");
+    expect(entry?.completedAt).toBe(now);
+  });
+});

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

@@ -0,0 +1,138 @@
+import { mkdir, mkdtemp } 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 {
+  completeThread,
+  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);
+}
+
+async function seedHistoryHead(
+  uwf: Awaited<ReturnType<typeof createUwfStore>>,
+  label: string,
+): Promise<CasRef> {
+  return (await uwf.store.cas.put(uwf.schemas.text, label)) as CasRef;
+}
+
+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");
+
+    setThread(uwf.varStore, threadId, {
+      head,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    completeThread(uwf.varStore, threadId, "cancelled");
+
+    const entry = getThread(uwf.varStore, threadId);
+    expect(entry).not.toBeNull();
+    expect(entry?.status).toBe("cancelled");
+  });
+
+  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");
+
+    setThread(uwf.varStore, threadId, {
+      head,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+
+    completeThread(uwf.varStore, threadId, "completed");
+
+    const entry = getThread(uwf.varStore, threadId);
+    expect(entry).not.toBeNull();
+    expect(entry?.status).toBe("completed");
+  });
+
+  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");
+
+    const threadId1 = "01JTEST000000000000CANCEL4" as ThreadId;
+    setThread(uwf.varStore, threadId1, {
+      head: head1,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+    completeThread(uwf.varStore, threadId1, "completed");
+
+    const threadId2 = "01JTEST000000000000CANCEL5" as ThreadId;
+    setThread(uwf.varStore, threadId2, {
+      head: head2,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+    completeThread(uwf.varStore, threadId2, "cancelled");
+
+    const history = loadHistoryThreads(uwf.varStore);
+    expect(Object.keys(history)).toHaveLength(2);
+    const statuses = Object.values(history)
+      .map((entry) => entry.status)
+      .sort();
+    expect(statuses).toEqual(["cancelled", "completed"]);
+  });
+
+  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");
+
+    const threadId1 = "01JTEST000000000000CANCEL6" as ThreadId;
+    setThread(uwf.varStore, threadId1, {
+      head: head1,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+    completeThread(uwf.varStore, threadId1, "completed");
+
+    const threadId2 = "01JTEST000000000000CANCEL7" as ThreadId;
+    setThread(uwf.varStore, threadId2, {
+      head: head2,
+      status: "idle",
+      suspendedRole: null,
+      suspendMessage: null,
+      completedAt: null,
+    });
+    completeThread(uwf.varStore, threadId2, "cancelled");
+
+    const history = loadHistoryThreads(uwf.varStore);
+    expect(Object.keys(history)).toHaveLength(2);
+    const statuses = Object.values(history)
+      .map((entry) => entry.status)
+      .sort();
+    expect(statuses).toEqual(["cancelled", "completed"]);
+  });
+});