@bastani/atomic 0.5.34 → 0.6.0-0

package/src/commands/cli/workflow-inputs.test.ts

@@ -12,12 +12,9 @@ import {
   renderInputsText,
   workflowInputsCommand,
   type WorkflowInputsDeps,
+  type ResolvedWorkflowEntry,
 } from "./workflow-inputs.ts";
-import type {
-  WorkflowInput,
-  DiscoveredWorkflow,
-  WorkflowDefinition,
-} from "../../sdk/workflows/index.ts";
+import type { AgentType, WorkflowInput, WorkflowDefinition } from "../../sdk/workflows/index.ts";
 
 let originalNoColor: string | undefined;
 beforeAll(() => {
@@ -153,12 +150,10 @@ function captureOutput(): {
   };
 }
 
-function fakeDiscovered(name: string): DiscoveredWorkflow {
+function fakeDiscovered(name: string): ResolvedWorkflowEntry {
   return {
     name,
     agent: "claude",
-    path: `/fake/path/${name}.ts`,
-    source: "builtin",
   };
 }
 
@@ -166,10 +161,12 @@ function fakeDefinition(
   name: string,
   description: string,
   inputs: WorkflowInput[],
+  agent: AgentType = "claude",
 ): WorkflowDefinition {
   return {
     __brand: "WorkflowDefinition",
     name,
+    agent,
     description,
     inputs,
     minSDKVersion: null,
@@ -181,11 +178,9 @@ function makeDeps(overrides: Partial<WorkflowInputsDeps> = {}): WorkflowInputsDe
   return {
     findWorkflow: mock(async () => fakeDiscovered("gen-spec")) as unknown as
       WorkflowInputsDeps["findWorkflow"],
-    loadWorkflow: mock(async (plan) => ({
+    loadWorkflow: mock(async () => ({
       ok: true,
       value: {
-        ...plan,
-        warnings: [],
         definition: fakeDefinition("gen-spec", "spec generator", [
           { name: "research_doc", type: "string", required: true },
         ]),
@@ -319,4 +314,39 @@ describe("workflowInputsCommand", () => {
       cap.restore();
     }
   });
+
+  test("default deps resolve against the builtin registry on success", async () => {
+    // Omit the deps argument so the module-level `defaultDeps` runs —
+    // this exercises `registryFindWorkflow` + `registryLoadWorkflow`.
+    const cap = captureOutput();
+    try {
+      const code = await workflowInputsCommand({
+        name: "ralph",
+        agent: "claude",
+        format: "json",
+      });
+      expect(code).toBe(0);
+      const parsed = JSON.parse(cap.stdout());
+      expect(parsed.workflow).toBe("ralph");
+      expect(parsed.agent).toBe("claude");
+    } finally {
+      cap.restore();
+    }
+  });
+
+  test("default deps report 'not found' for an unknown workflow", async () => {
+    const cap = captureOutput();
+    try {
+      const code = await workflowInputsCommand({
+        name: "definitely-not-a-real-workflow",
+        agent: "claude",
+        format: "json",
+      });
+      expect(code).toBe(1);
+      const parsed = JSON.parse(cap.stdout());
+      expect(parsed.error).toContain("not found");
+    } finally {
+      cap.restore();
+    }
+  });
 });

package/src/commands/cli/workflow-inputs.ts

@@ -13,12 +13,9 @@
  */
 
 import { COLORS, createPainter } from "../../theme/colors.ts";
-import { AGENT_CONFIG, type AgentKey } from "../../services/config/index.ts";
-import {
-  findWorkflow as _findWorkflow,
-  WorkflowLoader,
-} from "../../sdk/workflows/index.ts";
-import type { WorkflowInput } from "../../sdk/workflows/index.ts";
+import { AGENT_CONFIG } from "../../services/config/index.ts";
+import { createBuiltinRegistry } from "../../sdk/workflows/builtin-registry.ts";
+import type { WorkflowInput, WorkflowDefinition, AgentType } from "../../sdk/workflows/index.ts";
 
 export type WorkflowInputsFormat = "json" | "text";
 
@@ -151,19 +148,57 @@ export interface WorkflowInputsOptions {
   cwd?: string;
 }
 
+/**
+ * A resolved workflow entry — enough information for the inputs command
+ * to load and render the workflow's declared schema.
+ */
+export interface ResolvedWorkflowEntry {
+  name: string;
+  agent: AgentType;
+}
+
+/**
+ * Result of loading a workflow definition — either success with the
+ * definition or a failure with a stage label and message.
+ */
+export type WorkflowLoadResult =
+  | { ok: true; value: { definition: WorkflowDefinition } }
+  | { ok: false; stage: string; error: unknown; message: string };
+
 /**
  * Deps for `workflowInputsCommand`. Injected so tests can drive every
  * branch (unknown agent / missing workflow / load failure / success)
- * without the SDK's real filesystem-dependent discovery.
+ * without touching the real registry or filesystem.
  */
 export interface WorkflowInputsDeps {
-  findWorkflow: typeof _findWorkflow;
-  loadWorkflow: typeof WorkflowLoader.loadWorkflow;
+  findWorkflow: (name: string, agent: AgentType, cwd?: string) => Promise<ResolvedWorkflowEntry | null>;
+  loadWorkflow: (entry: ResolvedWorkflowEntry) => Promise<WorkflowLoadResult>;
+}
+
+function registryFindWorkflow(name: string, agent: AgentType): Promise<ResolvedWorkflowEntry | null> {
+  const registry = createBuiltinRegistry();
+  const wf = registry.resolve(name, agent);
+  if (!wf) return Promise.resolve(null);
+  return Promise.resolve({ name: wf.name, agent: wf.agent });
+}
+
+function registryLoadWorkflow(entry: ResolvedWorkflowEntry): Promise<WorkflowLoadResult> {
+  const registry = createBuiltinRegistry();
+  const wf = registry.resolve(entry.name, entry.agent);
+  if (!wf) {
+    return Promise.resolve({
+      ok: false,
+      stage: "resolve",
+      error: new Error(`Workflow not found: ${entry.agent}/${entry.name}`),
+      message: `Workflow not found: ${entry.agent}/${entry.name}`,
+    });
+  }
+  return Promise.resolve({ ok: true, value: { definition: wf } });
 }
 
 const defaultDeps: WorkflowInputsDeps = {
-  findWorkflow: _findWorkflow,
-  loadWorkflow: WorkflowLoader.loadWorkflow,
+  findWorkflow: registryFindWorkflow,
+  loadWorkflow: registryLoadWorkflow,
 };
 
 /**
@@ -185,7 +220,7 @@ export async function workflowInputsCommand(
       `Unknown agent '${options.agent}'. Valid agents: ${validAgents.join(", ")}`,
     );
   }
-  const agent = options.agent as AgentKey;
+  const agent = options.agent as AgentType;
 
   const discovered = await deps.findWorkflow(options.name, agent, options.cwd);
   if (!discovered) {

package/src/commands/cli/workflow-list.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Unit tests for `atomic workflow list` — the subcommand that replaced
+ * the old dispatcher `-l/--list` flag.
+ *
+ * The command itself is thin; these tests cover the behaviors that
+ * would silently break if the filter logic regressed: agent filtering,
+ * empty results, unknown agent rejection, and the sort order that
+ * keeps output stable across runs.
+ */
+
+import { describe, test, expect, beforeAll, beforeEach, afterAll, afterEach, mock } from "bun:test";
+import { workflowListCommand } from "./workflow-list.ts";
+import type { AgentType, WorkflowDefinition } from "../../sdk/workflows/index.ts";
+
+function def(agent: AgentType, name: string, description = ""): WorkflowDefinition {
+  return {
+    __brand: "WorkflowDefinition",
+    agent,
+    name,
+    description,
+    inputs: [],
+    minSDKVersion: null,
+    run: async () => {},
+  } as unknown as WorkflowDefinition;
+}
+
+let originalNoColor: string | undefined;
+beforeAll(() => {
+  originalNoColor = process.env.NO_COLOR;
+  process.env.NO_COLOR = "1";
+});
+afterAll(() => {
+  if (originalNoColor === undefined) delete process.env.NO_COLOR;
+  else process.env.NO_COLOR = originalNoColor;
+});
+
+interface Captured {
+  stdout: string;
+  stderr: string;
+  restore: () => void;
+}
+
+function captureOutput(): Captured {
+  const captured: Captured = { stdout: "", stderr: "", restore: () => {} };
+  const origStdout = process.stdout.write.bind(process.stdout);
+  const origStderr = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk: string | Uint8Array): boolean => {
+    captured.stdout += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+    return true;
+  }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: string | Uint8Array): boolean => {
+    captured.stderr += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+  captured.restore = () => {
+    process.stdout.write = origStdout;
+    process.stderr.write = origStderr;
+  };
+  return captured;
+}
+
+const fixture = [
+  def("claude", "ralph", "iterative plan/orchestrate/review/debug loop"),
+  def("copilot", "ralph", "iterative plan/orchestrate/review/debug loop"),
+  def("opencode", "ralph", "iterative plan/orchestrate/review/debug loop"),
+  def("claude", "deep-research-codebase", "scout -> explorer fan-out"),
+  def("copilot", "deep-research-codebase", "scout -> explorer fan-out"),
+  def("opencode", "deep-research-codebase", "scout -> explorer fan-out"),
+  def("claude", "open-claude-design", "design system onboarding"),
+  def("copilot", "open-claude-design", "design system onboarding"),
+  def("opencode", "open-claude-design", "design system onboarding"),
+];
+
+let savedNoColor: string | undefined;
+beforeEach(() => {
+  savedNoColor = process.env.NO_COLOR;
+  process.env.NO_COLOR = "1";
+});
+afterEach(() => {
+  if (savedNoColor === undefined) delete process.env.NO_COLOR;
+  else process.env.NO_COLOR = savedNoColor;
+});
+
+describe("workflowListCommand", () => {
+  test("no agent filter: prints every registered workflow, grouped by name", async () => {
+    const cap = captureOutput();
+    let code: number;
+    try {
+      code = await workflowListCommand({}, { list: () => fixture });
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    expect(cap.stdout).toContain("ralph");
+    expect(cap.stdout).toContain("deep-research-codebase");
+    expect(cap.stdout).toContain("open-claude-design");
+    // Grouping deduplicates identical (name, description) pairs, so each
+    // workflow name appears exactly once.
+    expect(cap.stdout.match(/\bralph\b/g)?.length).toBe(1);
+    // Agents are rendered as a badge line under each group.
+    expect(cap.stdout).toContain("claude");
+    expect(cap.stdout).toContain("copilot");
+    expect(cap.stdout).toContain("opencode");
+    expect(cap.stdout).toContain(" · ");
+    // The old `agent=<name>` label is gone — grouping replaces it.
+    expect(cap.stdout).not.toContain("agent=");
+  });
+
+  test("agent filter narrows to the selected agent only", async () => {
+    const cap = captureOutput();
+    let code: number;
+    try {
+      code = await workflowListCommand({ agent: "claude" }, { list: () => fixture });
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    // Every workflow with a claude variant appears.
+    expect(cap.stdout).toContain("ralph");
+    expect(cap.stdout).toContain("deep-research-codebase");
+    expect(cap.stdout).toContain("open-claude-design");
+    // Non-matching agents should not appear in the listing. We check for
+    // the agent-badge separator, not the strings themselves — a workflow
+    // named "open-claude-design" legitimately contains the token
+    // "claude" outside the badge list.
+    expect(cap.stdout).not.toContain("copilot");
+    expect(cap.stdout).not.toContain("opencode");
+    // Filtered output suppresses the agent-badge line entirely, since
+    // the filter itself provides the context.
+    expect(cap.stdout).not.toContain(" · ");
+  });
+
+  test("unknown agent returns non-zero and writes an error message", async () => {
+    const cap = captureOutput();
+    let code: number;
+    try {
+      code = await workflowListCommand({ agent: "bogus" }, { list: () => fixture });
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(1);
+    expect(cap.stderr).toContain("Unknown agent 'bogus'");
+  });
+
+  test("empty registry prints a helpful placeholder", async () => {
+    const cap = captureOutput();
+    let code: number;
+    try {
+      code = await workflowListCommand({}, { list: () => [] });
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    expect(cap.stdout).toContain("No workflows registered.");
+  });
+
+  test("agent filter with zero matches prints the placeholder, not an error", async () => {
+    const cap = captureOutput();
+    let code: number;
+    try {
+      code = await workflowListCommand(
+        { agent: "opencode" },
+        { list: () => [def("claude", "ralph")] },
+      );
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    expect(cap.stdout).toContain("No workflows registered.");
+  });
+
+  test("groups are sorted alphabetically by workflow name", async () => {
+    const shuffled = [
+      def("opencode", "ralph"),
+      def("claude", "deep-research-codebase"),
+      def("claude", "ralph"),
+      def("copilot", "ralph"),
+    ];
+    const cap = captureOutput();
+    try {
+      await workflowListCommand({}, { list: () => shuffled });
+    } finally {
+      cap.restore();
+    }
+    const deepIdx = cap.stdout.indexOf("deep-research-codebase");
+    const ralphIdx = cap.stdout.indexOf("ralph");
+    expect(deepIdx).toBeGreaterThan(-1);
+    expect(ralphIdx).toBeGreaterThan(deepIdx);
+  });
+
+  test("agents within a group are sorted alphabetically", async () => {
+    const shuffled = [
+      def("opencode", "ralph", "plan"),
+      def("claude", "ralph", "plan"),
+      def("copilot", "ralph", "plan"),
+    ];
+    const cap = captureOutput();
+    try {
+      await workflowListCommand({}, { list: () => shuffled });
+    } finally {
+      cap.restore();
+    }
+    const claudeIdx = cap.stdout.indexOf("claude");
+    const copilotIdx = cap.stdout.indexOf("copilot");
+    const opencodeIdx = cap.stdout.indexOf("opencode");
+    expect(claudeIdx).toBeGreaterThan(-1);
+    expect(claudeIdx).toBeLessThan(copilotIdx);
+    expect(copilotIdx).toBeLessThan(opencodeIdx);
+  });
+
+  test("variants with differing descriptions print as separate groups", async () => {
+    // Two variants of `ralph` with different descriptions — the grouping
+    // should keep them separate so no information is lost, instead of
+    // silently collapsing to one arbitrary description.
+    const entries = [
+      def("claude", "ralph", "plan version A"),
+      def("copilot", "ralph", "plan version B"),
+    ];
+    const cap = captureOutput();
+    try {
+      await workflowListCommand({}, { list: () => entries });
+    } finally {
+      cap.restore();
+    }
+    expect(cap.stdout).toContain("plan version A");
+    expect(cap.stdout).toContain("plan version B");
+    // Two separate groups means "ralph" appears as a heading twice.
+    expect(cap.stdout.match(/\bralph\b/g)?.length).toBe(2);
+  });
+});
+
+// mock import kept at module scope to match the lint pattern used by
+// other test files — suppresses an unused-import warning if any.
+void mock;