@united-workforce/cli 0.2.1-rc.9 → 0.4.0

package/src/__tests__/workflow-list-recursive.test.ts

@@ -0,0 +1,370 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CasRef, WorkflowPayload } from "@united-workforce/protocol";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { stringify } from "yaml";
+import { cmdThreadStart } from "../commands/thread.js";
+import { cmdWorkflowList } from "../commands/workflow.js";
+import type { UwfStore } from "../store.js";
+import { createUwfStore, discoverProjectWorkflows } from "../store.js";
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+async function makeUwfStore(storageRoot: string): Promise<UwfStore> {
+  const casDir = join(storageRoot, "cas");
+  await mkdir(casDir, { recursive: true });
+  process.env.OCAS_HOME = casDir;
+  return createUwfStore(storageRoot);
+}
+
+function makeMinimalPayload(name: string, description: string): WorkflowPayload {
+  return {
+    version: 1,
+    name,
+    description,
+    roles: {
+      worker: {
+        description: "worker role",
+        goal: "do work",
+        capabilities: [],
+        procedure: "",
+        output: "",
+        frontmatter: {
+          type: "object",
+          properties: {
+            $status: { const: "done" },
+          },
+          required: ["$status"],
+        } as unknown as CasRef,
+      },
+    },
+    graph: {
+      $START: {
+        new: { role: "worker", prompt: "start working", location: null },
+        resume: { role: "worker", prompt: "resume working", location: null },
+      },
+      worker: { done: { role: "$END", prompt: "done", location: null } },
+    },
+  };
+}
+
+async function createWorkflowYaml(name: string, version: string | null = null): Promise<string> {
+  const payload = makeMinimalPayload(
+    name,
+    version !== null ? `Test workflow (${version})` : "Test workflow",
+  );
+  return stringify(payload);
+}
+
+// ── fixture ───────────────────────────────────────────────────────────────────
+
+let tmpDir: string;
+let storageRoot: string;
+let projectRoot: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), "uwf-wf-list-recursive-"));
+  storageRoot = join(tmpDir, "storage");
+  projectRoot = join(tmpDir, "project");
+  await mkdir(storageRoot, { recursive: true });
+  await mkdir(projectRoot, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+// ── discoverProjectWorkflows — parent traversal ───────────────────────────────
+
+describe("discoverProjectWorkflows — parent traversal", () => {
+  test("T1: finds workflows in cwd's .workflows/", async () => {
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+
+    expect(entries.map((e) => e.name)).toContain("solve-issue");
+  });
+
+  test("T2: finds workflows in ancestor's .workflows/ when called from subdirectory", async () => {
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const subdir = join(projectRoot, "packages", "cli", "src");
+    await mkdir(subdir, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(subdir);
+
+    expect(entries.map((e) => e.name)).toContain("solve-issue");
+  });
+
+  test("T3: returns [] when no .workflows/ or .workflow/ exists in any ancestor", async () => {
+    // Use a deep path under tmpDir that has no .workflows/ or .workflow/ on the way up.
+    // (Traversal will stop at filesystem root and find nothing.)
+    const deepPath = join(tmpDir, "isolated", "no", "workflow", "here");
+    await mkdir(deepPath, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(deepPath);
+
+    expect(entries).toEqual([]);
+  });
+
+  test("T4: .workflows/ entries win over .workflow/ within the same directory", async () => {
+    const primaryDir = join(projectRoot, ".workflows");
+    const legacyDir = join(projectRoot, ".workflow");
+    await mkdir(primaryDir, { recursive: true });
+    await mkdir(legacyDir, { recursive: true });
+
+    await writeFile(
+      join(primaryDir, "solve-issue.yaml"),
+      await createWorkflowYaml("solve-issue", "new"),
+    );
+    await writeFile(
+      join(legacyDir, "solve-issue.yaml"),
+      await createWorkflowYaml("solve-issue", "legacy"),
+    );
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+
+    const match = entries.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(primaryDir, "solve-issue.yaml"));
+  });
+
+  test("T5: nearest .workflows/ wins over ancestor's .workflows/", async () => {
+    const ancestorWf = join(projectRoot, ".workflows");
+    await mkdir(ancestorWf, { recursive: true });
+    await writeFile(join(ancestorWf, "foo.yaml"), await createWorkflowYaml("foo", "ancestor"));
+
+    const nearDir = join(projectRoot, "pkg");
+    const nearWf = join(nearDir, ".workflows");
+    await mkdir(nearWf, { recursive: true });
+    await writeFile(join(nearWf, "foo.yaml"), await createWorkflowYaml("foo", "near"));
+
+    const entries = await discoverProjectWorkflows(nearDir);
+
+    const match = entries.find((e) => e.name === "foo");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(nearWf, "foo.yaml"));
+    // Should not include duplicates from ancestor
+    expect(entries.filter((e) => e.name === "foo")).toHaveLength(1);
+  });
+
+  test("T6: returns all entries from the nearest .workflows/ when called from a deep subdir", async () => {
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+    await writeFile(join(wfDir, "review-code.yaml"), await createWorkflowYaml("review-code"));
+
+    const deep = join(projectRoot, "a", "b", "c", "d");
+    await mkdir(deep, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(deep);
+
+    const names = entries.map((e) => e.name).sort();
+    expect(names).toEqual(["review-code", "solve-issue"]);
+  });
+
+  test("T7: discovers folder-based layout (name/index.yaml) via parent traversal under .workflows/", async () => {
+    const folderDir = join(projectRoot, ".workflows", "solve-issue");
+    await mkdir(folderDir, { recursive: true });
+    await writeFile(join(folderDir, "index.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const subdir = join(projectRoot, "deep", "sub");
+    await mkdir(subdir, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(subdir);
+
+    const match = entries.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(folderDir, "index.yaml"));
+  });
+
+  test("T8: .workflow/ (legacy) is still discovered when .workflows/ does not exist", async () => {
+    const legacyDir = join(projectRoot, ".workflow");
+    await mkdir(legacyDir, { recursive: true });
+    await writeFile(join(legacyDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+
+    const match = entries.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.filePath).toBe(join(legacyDir, "solve-issue.yaml"));
+  });
+
+  test("T9: nearest directory with EITHER variant stops traversal", async () => {
+    // Setup: ancestor .workflows/ + near .workflow/ only — near wins, ancestor not merged.
+    const ancestorWf = join(tmpDir, ".workflows");
+    await mkdir(ancestorWf, { recursive: true });
+    await writeFile(join(ancestorWf, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const nearLegacyDir = join(projectRoot, ".workflow");
+    await mkdir(nearLegacyDir, { recursive: true });
+    await writeFile(join(nearLegacyDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const entries = await discoverProjectWorkflows(projectRoot);
+    const names = entries.map((e) => e.name);
+    expect(names).toContain("local");
+    expect(names).not.toContain("leak");
+  });
+});
+
+// ── discoverProjectWorkflows — .git boundary ─────────────────────────────────
+
+describe("discoverProjectWorkflows — .git boundary", () => {
+  test("G1: .git directory stops traversal", async () => {
+    // Setup: tmpDir/repo/.git/ (dir), tmpDir/.workflows/leak.yaml, start from tmpDir/repo/sub/deep/
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    // Workflow above repo root — should NOT be reachable
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "sub", "deep");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries).toEqual([]);
+  });
+
+  test("G2: .git file (worktree) stops traversal", async () => {
+    // Setup: tmpDir/repo/.git as a FILE, tmpDir/.workflows/leak.yaml, start from tmpDir/repo/pkg/
+    const repoDir = join(tmpDir, "repo");
+    await mkdir(repoDir, { recursive: true });
+    await writeFile(join(repoDir, ".git"), "gitdir: /some/other/path/.git/worktrees/repo");
+
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "pkg");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries).toEqual([]);
+  });
+
+  test("G3: workflow at .git boundary IS found (primary .workflows/)", async () => {
+    // Setup: tmpDir/repo/.git/ (dir), tmpDir/repo/.workflows/local.yaml, start from tmpDir/repo/sub/
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    const wfDir = join(repoDir, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries.map((e) => e.name)).toContain("local");
+  });
+
+  test("G4: workflow below .git is found, above is not", async () => {
+    // Setup: tmpDir/repo/.git/ + tmpDir/repo/.workflows/local.yaml + tmpDir/.workflows/leak.yaml
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    const localWfDir = join(repoDir, ".workflows");
+    await mkdir(localWfDir, { recursive: true });
+    await writeFile(join(localWfDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    const entries = await discoverProjectWorkflows(startFrom);
+    expect(entries.map((e) => e.name)).toEqual(["local"]);
+  });
+});
+
+// ── findWorkflowInParents (via cmdThreadStart) — .git boundary ───────────────
+
+describe("findWorkflowInParents via cmdThreadStart — .git boundary", () => {
+  test("G5: .git stops traversal — workflow above boundary is not found", async () => {
+    await makeUwfStore(storageRoot);
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    // Workflow above .git boundary
+    const leakDir = join(tmpDir, ".workflows");
+    await mkdir(leakDir, { recursive: true });
+    await writeFile(join(leakDir, "leak.yaml"), await createWorkflowYaml("leak"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    // cmdThreadStart should fail — "leak" is above the .git boundary
+    await expect(cmdThreadStart(storageRoot, "leak", "prompt", startFrom)).rejects.toThrow();
+  });
+
+  test("G6: workflow at .git boundary IS found via cmdThreadStart", async () => {
+    await makeUwfStore(storageRoot);
+    const repoDir = join(tmpDir, "repo");
+    const gitDir = join(repoDir, ".git");
+    await mkdir(gitDir, { recursive: true });
+
+    const wfDir = join(repoDir, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "local.yaml"), await createWorkflowYaml("local"));
+
+    const startFrom = join(repoDir, "sub");
+    await mkdir(startFrom, { recursive: true });
+
+    const result = await cmdThreadStart(storageRoot, "local", "prompt", startFrom);
+    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+  });
+});
+
+// ── cmdWorkflowList — parent traversal ───────────────────────────────────────
+
+describe("cmdWorkflowList — parent traversal", () => {
+  test("B9: lists local workflows discovered from a subdirectory", async () => {
+    await makeUwfStore(storageRoot);
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const subdir = join(projectRoot, "packages", "foo", "src");
+    await mkdir(subdir, { recursive: true });
+
+    const result = await cmdWorkflowList(storageRoot, subdir);
+
+    const match = result.find((e) => e.name === "solve-issue");
+    expect(match).toBeDefined();
+    expect(match?.hash).toBe("(local)");
+    expect(match?.origin).toBe("local");
+  });
+
+  test("aligns with cmdThreadStart discovery from same subdirectory", async () => {
+    await makeUwfStore(storageRoot);
+    const wfDir = join(projectRoot, ".workflows");
+    await mkdir(wfDir, { recursive: true });
+    await writeFile(join(wfDir, "foo.yaml"), await createWorkflowYaml("foo"));
+
+    const subdir = join(projectRoot, "packages", "foo", "src");
+    await mkdir(subdir, { recursive: true });
+
+    // cmdThreadStart already resolves foo successfully from subdir (existing behavior)
+    const startResult = await cmdThreadStart(storageRoot, "foo", "prompt", subdir);
+    expect(startResult.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+
+    // cmdWorkflowList must ALSO include foo (newly aligned behavior)
+    const listResult = await cmdWorkflowList(storageRoot, subdir);
+    const match = listResult.find((e) => e.name === "foo");
+    expect(match).toBeDefined();
+    expect(match?.origin).toBe("local");
+  });
+});

package/src/__tests__/workflow-resolution.test.ts

@@ -19,6 +19,7 @@ async function makeUwfStore(storageRoot: string): Promise<UwfStore> {
 
 function makeMinimalPayload(name: string, description: string): WorkflowPayload {
   return {
+    version: 1,
     name,
     description,
     roles: {
@@ -180,9 +181,9 @@ describe("Strategy 2: File Path Resolution", () => {
 // ── Strategy 3: Local Discovery (Parent Traversal) ────────────────────────────
 
 describe("Strategy 3: Local Discovery", () => {
-  test("should find workflow in current directory .workflow/", async () => {
+  test("should find workflow in current directory .workflows/", async () => {
     await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
+    const workflowDir = join(projectRoot, ".workflows");
     await mkdir(workflowDir, { recursive: true });
     await writeFile(join(workflowDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
 
@@ -197,9 +198,9 @@ describe("Strategy 3: Local Discovery", () => {
     }
   });
 
-  test("should find workflow in parent directory .workflow/", async () => {
+  test("should find workflow in parent directory .workflows/", async () => {
     await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
+    const workflowDir = join(projectRoot, ".workflows");
     await mkdir(workflowDir, { recursive: true });
     await writeFile(join(workflowDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
 
@@ -219,19 +220,19 @@ describe("Strategy 3: Local Discovery", () => {
     await expect(cmdThreadStart(storageRoot, "nonexistent", "prompt", deepPath)).rejects.toThrow();
   });
 
-  test("should prefer .workflow/ over .workflows/ directory", async () => {
+  test("should prefer .workflows/ over .workflow/ directory", async () => {
     await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
-    const workflowsDir = join(projectRoot, ".workflows");
-    await mkdir(workflowDir, { recursive: true });
-    await mkdir(workflowsDir, { recursive: true });
+    const primaryDir = join(projectRoot, ".workflows");
+    const legacyDir = join(projectRoot, ".workflow");
+    await mkdir(primaryDir, { recursive: true });
+    await mkdir(legacyDir, { recursive: true });
 
     await writeFile(
-      join(workflowDir, "solve-issue.yaml"),
+      join(primaryDir, "solve-issue.yaml"),
       await createWorkflowYaml("solve-issue", "1"),
     );
     await writeFile(
-      join(workflowsDir, "solve-issue.yaml"),
+      join(legacyDir, "solve-issue.yaml"),
       await createWorkflowYaml("solve-issue", "2"),
     );
 
@@ -245,9 +246,9 @@ describe("Strategy 3: Local Discovery", () => {
     }
   });
 
-  test("should support .yml extension in local discovery", async () => {
+  test("should support .yml extension in local discovery under .workflows/", async () => {
     await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
+    const workflowDir = join(projectRoot, ".workflows");
     await mkdir(workflowDir, { recursive: true });
     await writeFile(join(workflowDir, "solve-issue.yml"), await createWorkflowYaml("solve-issue"));
 
@@ -256,9 +257,9 @@ describe("Strategy 3: Local Discovery", () => {
     expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
   });
 
-  test("should find workflow in folder-based layout (name/index.yaml)", async () => {
+  test("should find workflow in folder-based layout (.workflows/<name>/index.yaml)", async () => {
     await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow", "solve-issue");
+    const workflowDir = join(projectRoot, ".workflows", "solve-issue");
     await mkdir(workflowDir, { recursive: true });
     await writeFile(join(workflowDir, "index.yaml"), await createWorkflowYaml("solve-issue"));
 
@@ -273,9 +274,9 @@ describe("Strategy 3: Local Discovery", () => {
     }
   });
 
-  test("should prefer flat file over folder-based layout", async () => {
+  test("should prefer flat file over folder-based layout under .workflows/", async () => {
     await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
+    const workflowDir = join(projectRoot, ".workflows");
     await mkdir(workflowDir, { recursive: true });
     await writeFile(
       join(workflowDir, "solve-issue.yaml"),
@@ -298,6 +299,23 @@ describe("Strategy 3: Local Discovery", () => {
       expect((node.payload as WorkflowPayload).description).toBe("Test workflow (flat)");
     }
   });
+
+  test("should resolve from legacy .workflow/ when .workflows/ is absent", async () => {
+    await makeUwfStore(storageRoot);
+    const legacyDir = join(projectRoot, ".workflow");
+    await mkdir(legacyDir, { recursive: true });
+    await writeFile(join(legacyDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
+
+    const result = await cmdThreadStart(storageRoot, "solve-issue", "prompt", projectRoot);
+
+    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
+    const uwf = await makeUwfStore(storageRoot);
+    const node = uwf.store.cas.get(result.workflow);
+    expect(node).not.toBeNull();
+    if (node !== null) {
+      expect((node.payload as WorkflowPayload).name).toBe("solve-issue");
+    }
+  });
 });
 
 // ── Strategy 4: Global Registry Fallback ──────────────────────────────────────
@@ -329,8 +347,8 @@ describe("Resolution Priority", () => {
   test("should use explicit file path over local discovery", async () => {
     await makeUwfStore(storageRoot);
 
-    // Setup: Create workflow in .workflow/ AND as explicit file
-    const workflowDir = join(projectRoot, ".workflow");
+    // Setup: Create workflow in .workflows/ AND as explicit file
+    const workflowDir = join(projectRoot, ".workflows");
     await mkdir(workflowDir, { recursive: true });
     await writeFile(
       join(workflowDir, "solve-issue.yaml"),
@@ -358,8 +376,8 @@ describe("Resolution Priority", () => {
     const globalHash = await storeWorkflow(uwf, "solve-issue");
     saveWorkflowRegistry(uwf.varStore, "solve-issue", globalHash);
 
-    // Setup: Create local .workflow/
-    const workflowDir = join(projectRoot, ".workflow");
+    // Setup: Create local .workflows/
+    const workflowDir = join(projectRoot, ".workflows");
     await mkdir(workflowDir, { recursive: true });
     const localYaml = await createWorkflowYaml("solve-issue", "local");
     await writeFile(join(workflowDir, "solve-issue.yaml"), localYaml);