@bastani/atomic 0.6.4 → 0.6.5-0

package/dist/commands/cli/session.d.ts

@@ -1,67 +0,0 @@
-/**
- * Session CLI commands — shared between `atomic chat session` and
- * `atomic workflow session`, and the top-level `atomic session` picker.
- *
- * Wraps tmux -L atomic list-sessions / attach-session so users can
- * inspect and reconnect to running atomic sessions without touching
- * tmux directly.
- */
-import { select, confirm, isCancel } from "@clack/prompts";
-import type { TmuxSession } from "../../sdk/runtime/tmux.ts";
-import type { Subprocess } from "bun";
-/** Scope controls which session types a command shows. */
-export type SessionScope = "chat" | "workflow" | "all";
-/** Injectable tmux dependencies for command functions. */
-export interface SessionDeps {
-    isTmuxInstalled: () => boolean;
-    sessionExists: (name: string) => boolean;
-    listSessions: () => TmuxSession[];
-    isInsideAtomicSocket: () => boolean;
-    isInsideTmux: () => boolean;
-    switchClient: (name: string) => void;
-    spawnMuxAttach: (name: string) => Subprocess;
-    detachAndAttachAtomic: (name: string) => void;
-    killSession: (name: string) => void;
-    /** Prompt function for the session picker — defaults to @clack/prompts select. */
-    select: typeof select;
-    /** Prompt function for yes/no confirmations — defaults to @clack/prompts confirm. */
-    confirm: typeof confirm;
-    isCancel: typeof isCancel;
-}
-/**
- * Render the session list as a printable string.
- *
- * Layout mirrors the workflow list style — data-first count header,
- * session rows with metadata, dim footer hint.
- */
-export declare function renderSessionList(sessions: TmuxSession[]): string;
-/** Filter sessions by scope (chat-only, workflow-only, or all). */
-export declare function filterByScope(sessions: TmuxSession[], scope: SessionScope): TmuxSession[];
-/** Filter sessions to only those matching at least one of the given agents. */
-export declare function filterByAgent(sessions: TmuxSession[], agents: string[]): TmuxSession[];
-export declare function sessionListCommand(agents?: string[], scope?: SessionScope, deps?: SessionDeps): Promise<number>;
-/**
- * Connect to a named session. Handles the three tmux contexts:
- * already on atomic socket → switch-client, inside other tmux → detach+attach,
- * outside tmux → spawn attach.
- */
-export declare function sessionConnectCommand(sessionName: string, deps?: SessionDeps): Promise<number>;
-/**
- * Show an fzf-style interactive picker for all running atomic sessions.
- * Used by `atomic session connect` (no args).
- */
-export declare function sessionPickerCommand(agents?: string[], scope?: SessionScope, deps?: SessionDeps): Promise<number>;
-/**
- * Kill a named session or all sessions matching the given scope and agents.
- *
- * - If `sessionId` is provided: confirm and kill that one session.
- * - If `sessionId` is omitted: confirm and kill all sessions in scope.
- *
- * Pass `yes: true` (the `-y/--yes` flag on the CLI) to skip the
- * confirmation prompt — useful for orchestrating agents that need to
- * tear down a workflow session non-interactively.
- */
-export declare function sessionKillCommand(sessionId: string | undefined, agents?: string[], scope?: SessionScope, deps?: SessionDeps, options?: {
-    yes?: boolean;
-}): Promise<number>;
-//# sourceMappingURL=session.d.ts.map

package/dist/commands/cli/session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/commands/cli/session.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAU,MAAM,gBAAgB,CAAC;AAcnE,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,0DAA0D;AAC1D,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;AAEvD,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,eAAe,EAAE,MAAM,OAAO,CAAC;IAC/B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,YAAY,EAAE,MAAM,WAAW,EAAE,CAAC;IAClC,oBAAoB,EAAE,MAAM,OAAO,CAAC;IACpC,YAAY,EAAE,MAAM,OAAO,CAAC;IAC5B,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC;IAC7C,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,kFAAkF;IAClF,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,qFAAqF;IACrF,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,QAAQ,EAAE,OAAO,QAAQ,CAAC;CAC3B;AAoBD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,CA6CjE;AA+BD,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,YAAY,GAAG,WAAW,EAAE,CAIzF;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,CAItF;AAID,wBAAsB,kBAAkB,CAAC,MAAM,GAAE,MAAM,EAAO,EAAE,KAAK,GAAE,YAAoB,EAAE,IAAI,GAAE,WAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAa7I;AAID;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,GAAE,WAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAyCjH;AAID;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,GAAE,MAAM,EAAO,EAAE,KAAK,GAAE,YAAoB,EAAE,IAAI,GAAE,WAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoC/I;AAID;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,GAAE,MAAM,EAAO,EACrB,KAAK,GAAE,YAAoB,EAC3B,IAAI,GAAE,WAAyB,EAC/B,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B,OAAO,CAAC,MAAM,CAAC,CAoGjB"}

package/dist/commands/cli/workflow-status.d.ts

@@ -1,63 +0,0 @@
-/**
- * `atomic workflow status [<id>]` — query the current state of one or
- * all running workflows so an orchestrating agent can decide whether
- * to keep waiting, surface a HIL prompt to the user, or move on.
- *
- * Status sources, in priority order:
- *   1. <sessionDir>/status.json — written by the orchestrator on every
- *      panel-store mutation. Provides per-stage detail and the
- *      derived overall state (in_progress | error | completed |
- *      needs_review).
- *   2. tmux liveness fallback — when status.json is missing or stale
- *      we still report whether the tmux session is alive so
- *      script-driven workflows aren't blind during the brief window
- *      before the orchestrator first writes its snapshot.
- */
-import { readSnapshot, type WorkflowOverallStatus, type WorkflowStatusSnapshot } from "../../sdk/runtime/status-writer.ts";
-import type { TmuxSession } from "../../sdk/runtime/tmux.ts";
-export type StatusFormat = "json" | "text";
-/** A single workflow's resolved status, as returned to the caller. */
-export interface WorkflowStatusReport {
-    /** Tmux session name (e.g. `atomic-wf-claude-ralph-a1b2c3d4`). */
-    id: string;
-    /** Workflow run id (the trailing 8-hex segment of the tmux name). */
-    workflowRunId: string;
-    /** Workflow name pulled from the snapshot. Empty when no snapshot exists. */
-    workflowName: string;
-    /** Agent backend (claude / copilot / opencode). */
-    agent: string;
-    overall: WorkflowOverallStatus;
-    /** True when the tmux session is currently alive on the atomic socket. */
-    alive: boolean;
-    /** ISO timestamp of the last snapshot, or null when none exists. */
-    updatedAt: string | null;
-    /** Sessions/stages, mirrored from the snapshot. Empty when no snapshot exists. */
-    sessions: WorkflowStatusSnapshot["sessions"];
-    /** Fatal-error message, if any. */
-    fatalError: string | null;
-}
-export interface StatusDeps {
-    isTmuxInstalled: () => boolean;
-    sessionExists: (name: string) => boolean;
-    listSessions: () => TmuxSession[];
-    /**
-     * Read a snapshot from disk. Defaults to the real reader; tests
-     * inject a fake to control the snapshot data without touching the
-     * filesystem.
-     */
-    readSnapshot: typeof readSnapshot;
-    /** Base directory for session dirs. Defaults to `~/.atomic/sessions`. */
-    sessionsBaseDir: string;
-}
-export interface WorkflowStatusOptions {
-    /** Filter to a specific workflow by tmux session name. */
-    id?: string;
-    format?: StatusFormat;
-}
-/**
- * Top-level command. Prints either a single report (when `id` is
- * provided) or the list of all workflow sessions on the atomic
- * socket. Returns 1 when a requested id can't be found, 0 otherwise.
- */
-export declare function workflowStatusCommand(options: WorkflowStatusOptions, deps?: StatusDeps): Promise<number>;
-//# sourceMappingURL=workflow-status.d.ts.map

package/dist/commands/cli/workflow-status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-status.d.ts","sourceRoot":"","sources":["../../../src/commands/cli/workflow-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,OAAO,EACL,YAAY,EAEZ,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3C,sEAAsE;AACtE,MAAM,WAAW,oBAAoB;IACnC,kEAAkE;IAClE,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,qBAAqB,CAAC;IAC/B,0EAA0E;IAC1E,KAAK,EAAE,OAAO,CAAC;IACf,oEAAoE;IACpE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,kFAAkF;IAClF,QAAQ,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC7C,mCAAmC;IACnC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,eAAe,EAAE,MAAM,OAAO,CAAC;IAC/B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,YAAY,EAAE,MAAM,WAAW,EAAE,CAAC;IAClC;;;;OAIG;IACH,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,yEAAyE;IACzE,eAAe,EAAE,MAAM,CAAC;CACzB;AAiED,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,qBAAqB,EAC9B,IAAI,GAAE,UAAwB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAiDjB"}

package/dist/sdk/commander.d.ts

@@ -1,74 +0,0 @@
-/**
- * Commander adapter for embedding a WorkflowCli under a parent Commander CLI.
- *
- * ```ts
- * import { createWorkflowCli } from "@bastani/atomic/workflows";
- * import { toCommand, runCli } from "@bastani/atomic/workflows/commander";
- *
- * const cli = createWorkflowCli(workflow);
- * const program = new Command("my-app");
- * program.addCommand(toCommand(cli, "workflow"));
- *
- * await runCli(cli, () => program.parseAsync());
- * ```
- *
- * `WorkflowCli` itself is framework-agnostic — this module is the only place
- * that imports Commander on the adapter side of the API. A future
- * yargs/citty adapter would be a sibling module with the same shape.
- *
- * `runCli` handles orchestrator re-entry transparently — parent CLIs never
- * see env vars or guards. PyTorch-distributed style: the framework owns
- * rank-zero dispatch; the developer writes one line.
- */
-import type { Command } from "@commander-js/extra-typings";
-import type { WorkflowCli, WorkflowDefinition } from "./types.ts";
-/**
- * Build a Commander `Command` bound to a WorkflowCli for embedding under
- * a parent CLI. The returned Command declares `-n/--name`, `-a/--agent`,
- * `-d/--detach`, plus the per-input union across the registry. Picker
- * behaviour (agent without name in a TTY) is preserved.
- *
- * @param cli - WorkflowCli returned by `createWorkflowCli()`.
- * @param name - Mount name (default: `"workflow"`).
- */
-export declare function toCommand<T extends Record<string, WorkflowDefinition>>(cli: WorkflowCli<T>, name?: string): Command;
-/**
- * Bootstrap an embedded Commander CLI. Use this in place of
- * `program.parseAsync()` when you've mounted an atomic WorkflowCli under
- * a parent program.
- *
- * Inspired by PyTorch's `init_process_group()`: the framework handles
- * rank-zero dispatch (here: orchestrator vs CLI) transparently, so the
- * developer writes the same code whether this process is a fresh CLI
- * invocation or a tmux-spawned orchestrator re-exec.
- *
- * - On a fresh invocation, invokes `cliFn()` (your `program.parseAsync()`
- *   call, plus any bootstrap you want before it).
- * - When the process is a detached orchestrator re-exec
- *   (`ATOMIC_ORCHESTRATOR_MODE=1` is set by the runtime), resolves the
- *   workflow identified by `ATOMIC_WF_KEY` against the supplied CLI
- *   (or the first match across CLIs) and drives it via
- *   `runOrchestrator`. `cliFn` is not called.
- *
- * Accepts a single WorkflowCli or an array — use an array when your
- * parent CLI embeds multiple atomic WorkflowClis (rare, but supported).
- *
- * @example
- * ```ts
- * const program = new Command("my-app");
- * program.addCommand(toCommand(cli));
- *
- * await runCli(cli, () => program.parseAsync());
- * ```
- *
- * @example With pre-parse bootstrap:
- * ```ts
- * await runCli(builtinCli, async () => {
- *   await ensureGlobalAtomicSettings();
- *   await autoSyncIfStale();
- *   await program.parseAsync();
- * });
- * ```
- */
-export declare function runCli(target: WorkflowCli | ReadonlyArray<WorkflowCli>, cliFn: () => void | Promise<void>): Promise<void>;
-//# sourceMappingURL=commander.d.ts.map

package/dist/sdk/commander.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commander.d.ts","sourceRoot":"","sources":["../../src/sdk/commander.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAEV,WAAW,EACX,kBAAkB,EACnB,MAAM,YAAY,CAAC;AASpB;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACpE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EACnB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAyCT;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,MAAM,CAC1B,MAAM,EAAE,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC,EAChD,KAAK,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/sdk/management-commands.d.ts

@@ -1,42 +0,0 @@
-/**
- * Session + status management subcommands for workflow CLIs.
- *
- * Shared by the atomic CLI root (`atomic session *`, `atomic workflow status`)
- * and by SDK-built CLIs (`createWorkflowCli(...)`). Factoring this out means a
- * user running `bun run src/claude-worker.ts session list` gets the identical
- * command surface as `atomic session list`, without the SDK embedding its own
- * diverging implementation. All queries go through the shared atomic tmux
- * socket, so sessions spawned by SDK-built CLIs and by `atomic workflow -n …`
- * show up interchangeably.
- *
- * Commander options are declared with the same names, descriptions, and
- * behaviour as the atomic root CLI — keep them in sync when the root CLI
- * grows a new option.
- */
-import type { Command } from "@commander-js/extra-typings";
-import type { SessionScope } from "../commands/cli/session.ts";
-/**
- * Attach the `session` subcommand group (`list` / `connect` / `kill`) to a
- * parent Commander command. Returns the created `session` group so callers
- * can attach additional children if they need to.
- *
- * @param parent The Commander command to mount `session` under.
- * @param scope  Which session set the list/kill commands operate on. SDK CLIs
- *               typically pass `"workflow"` to scope the picker to
- *               `atomic-wf-*` sessions only; the atomic root uses `"all"`.
- */
-export declare function addSessionSubcommand(parent: Command, scope?: SessionScope): Command;
-/**
- * Attach a top-level `status` subcommand for querying workflow status.
- * Mirrors `atomic workflow status` — same overall-state contract
- * (`in_progress` / `error` / `completed` / `needs_review`) and same JSON
- * shape. Omit the id to list every running workflow on the socket.
- */
-export declare function addStatusSubcommand(parent: Command): void;
-/**
- * Convenience: attach both `session` and `status` subcommands in the order
- * the SDK defaults use. Called by `createWorkflowCli` when
- * `includeManagementCommands` is `true` (the default).
- */
-export declare function addManagementCommands(parent: Command, scope?: SessionScope): void;
-//# sourceMappingURL=management-commands.d.ts.map

package/dist/sdk/management-commands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"management-commands.d.ts","sourceRoot":"","sources":["../../src/sdk/management-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAO/D;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,EACf,KAAK,GAAE,YAAoB,GAC1B,OAAO,CA0ET;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAkBzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EACf,KAAK,GAAE,YAAyB,GAC/B,IAAI,CAGN"}

package/dist/sdk/workflow-cli.d.ts

@@ -1,103 +0,0 @@
-/**
- * WorkflowCli — the single entry-point factory for workflow CLIs.
- *
- * Parses `-n/--name` + `-a/--agent` from argv, exposes a union of flags
- * across every workflow in the registry, opens an interactive picker when
- * agent is given without a name in a TTY, and handles orchestrator
- * re-entry from detached runs.
- *
- * Framework-agnostic: the returned `WorkflowCli` type has no direct
- * Commander dependency. To embed under a parent Commander CLI, use
- * `toCommand(cli)` from `@bastani/atomic/workflows/commander`.
- *
- * Used by the internal `atomic workflow` command. Per-workflow CLI
- * files call `createWorkflowCli(workflow)` — the same factory supports
- * a lone workflow, an array, or a full `Registry`.
- */
-import { Command } from "@commander-js/extra-typings";
-import type { AgentType, Registry, RegistrableWorkflow, WorkflowCli, WorkflowDefinition, WorkflowInput, CreateWorkflowCliOptions } from "./types.ts";
-/**
- * Resolve the workflow definition, merge inputs (with precedence), validate,
- * and hand off to the executor.
- *
- * Input precedence (highest → lowest):
- *   cliInputs > runInputs > dispatcherInputs > defineWorkflow defaults
- *
- * Exported for `./commander.ts` — not part of the public API.
- */
-export declare function resolveAndStart(registry: Registry, name: string, agent: AgentType, opts: {
-    cliInputs?: Record<string, string>;
-    runInputs?: Record<string, string>;
-    dispatcherInputs?: Record<string, string>;
-    detach?: boolean;
-    entry: string;
-}): Promise<void>;
-/**
- * Build the Commander Command that drives the workflow CLI. Used by both
- * the standalone `run()` path and the `toCommand` adapter.
- *
- * Exported for `./commander.ts` — not part of the public API.
- */
-export declare function buildCliCommand(registry: Registry, unionInputs: Map<string, WorkflowInput>, onAction: (params: {
-    name: string | undefined;
-    agent: AgentType | undefined;
-    cliInputs: Record<string, string>;
-    detach: boolean;
-}) => Promise<void>, mountName?: string): Command;
-/**
- * Interactive-picker path used by both `run()` and the Commander adapter.
- * Depends on `process.stdout.isTTY`; returns without side effects when
- * the user cancels or no terminal is attached.
- *
- * Exported for `./commander.ts` — not part of the public API.
- */
-export declare function runPicker(registry: Registry, agent: AgentType, detach: boolean, entry: string, dispatcherInputs: Record<string, string> | undefined): Promise<void>;
-/**
- * Create a workflow CLI that resolves `--name` + `--agent` from argv and
- * runs the matching workflow from the registry.
- *
- * Accepts three input shapes — pick whichever is cleanest:
- *
- * - **A single workflow.** `createWorkflowCli(workflow).run()`.
- * - **An array of workflows.** `createWorkflowCli([claude, copilot]).run()`.
- * - **A `Registry`.** For programmatic/dynamic composition, or sharing a
- *   registry across multiple CLIs. Build with `createRegistry().register(...)`.
- *
- * @example
- * ```ts
- * // Single workflow — ~70% of use cases
- * const cli = createWorkflowCli(workflow);
- * await cli.run();
- *
- * // Multi-workflow, multi-agent — by far the most common multi-case
- * await createWorkflowCli([claude, copilot, opencode]).run();
- *
- * // Dynamic composition
- * const registry = workflowFiles.reduce(
- *   (r, wf) => r.register(wf),
- *   createRegistry(),
- * );
- * await createWorkflowCli(registry).run();
- * ```
- *
- * To embed under a parent Commander CLI:
- *
- * ```ts
- * import { toCommand, runCli } from "@bastani/atomic/workflows/commander";
- * parent.addCommand(toCommand(cli));
- * await runCli(cli, () => parent.parseAsync());
- * ```
- *
- * The single/array overloads use generic constraints (`W extends
- * RegistrableWorkflow`) rather than a plain parameter type. This matters
- * under `--strictFunctionTypes`: a `WorkflowDefinition<"claude", ...>`
- * will not assign to a property-typed parameter because its narrow
- * `run(ctx: WorkflowContext<"claude">)` is contravariant against the
- * broader target. Routing through a generic `W` lets TS check bivariantly
- * via `extends`, which matches how `Registry.register` already accepts
- * the same inputs.
- */
-export declare function createWorkflowCli<W extends RegistrableWorkflow>(target: W, options?: CreateWorkflowCliOptions): WorkflowCli;
-export declare function createWorkflowCli<W extends RegistrableWorkflow>(target: readonly W[], options?: CreateWorkflowCliOptions): WorkflowCli;
-export declare function createWorkflowCli<T extends Record<string, WorkflowDefinition>>(target: Registry<T>, options?: CreateWorkflowCliOptions): WorkflowCli<T>;
-//# sourceMappingURL=workflow-cli.d.ts.map

package/dist/sdk/workflow-cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-cli.d.ts","sourceRoot":"","sources":["../../src/sdk/workflow-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EACR,mBAAmB,EACnB,WAAW,EACX,kBAAkB,EAClB,aAAa,EACb,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAsDpB;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE;IACJ,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GACA,OAAO,CAAC,IAAI,CAAC,CAmCf;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EACvC,QAAQ,EAAE,CAAC,MAAM,EAAE;IACjB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC;CACjB,KAAK,OAAO,CAAC,IAAI,CAAC,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAwET;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACnD,OAAO,CAAC,IAAI,CAAC,CAef;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,EAC7D,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,wBAAwB,GACjC,WAAW,CAAC;AACf,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,EAC7D,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACjC,WAAW,CAAC;AACf,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC5E,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EACnB,OAAO,CAAC,EAAE,wBAAwB,GACjC,WAAW,CAAC,CAAC,CAAC,CAAC"}

package/dist/sdk/workflows/builtin-registry.d.ts

@@ -1,113 +0,0 @@
-export declare function createBuiltinRegistry(): import(".").Registry<Record<string, never> & Record<`claude/${string}`, import(".").WorkflowDefinition<"claude", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "task prompt";
-}, {
-    readonly name: "max_loops";
-    readonly type: "integer";
-    readonly description: "maximum number of plan/orchestrate/review iterations";
-    readonly default: 10;
-}]>> & Record<`copilot/${string}`, import(".").WorkflowDefinition<"copilot", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "task prompt";
-}, {
-    readonly name: "max_loops";
-    readonly type: "integer";
-    readonly description: "maximum number of plan/orchestrate/review iterations";
-    readonly default: 10;
-}]>> & Record<`opencode/${string}`, import(".").WorkflowDefinition<"opencode", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "task prompt";
-}, {
-    readonly name: "max_loops";
-    readonly type: "integer";
-    readonly description: "maximum number of plan/orchestrate/review iterations";
-    readonly default: 10;
-}]>> & Record<`claude/${string}`, import(".").WorkflowDefinition<"claude", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "research question";
-}]>> & Record<`copilot/${string}`, import(".").WorkflowDefinition<"copilot", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "research question";
-}]>> & Record<`opencode/${string}`, import(".").WorkflowDefinition<"opencode", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "research question";
-}]>> & Record<`claude/${string}`, import(".").WorkflowDefinition<"claude", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "What to design (e.g., 'a dashboard for monitoring API latency')";
-}, {
-    readonly name: "reference";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "URL, file path, or codebase path to import as design reference";
-}, {
-    readonly name: "output-type";
-    readonly type: "enum";
-    readonly required: false;
-    readonly values: readonly ["prototype", "wireframe", "page", "component"];
-    readonly default: "prototype";
-    readonly description: "Type of design output to generate";
-}, {
-    readonly name: "design-system";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "Path to existing Design.md (skips onboarding if provided)";
-}]>> & Record<`copilot/${string}`, import(".").WorkflowDefinition<"copilot", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "What to design (e.g., 'a dashboard for monitoring API latency')";
-}, {
-    readonly name: "reference";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "URL, file path, or codebase path to import as design reference";
-}, {
-    readonly name: "output-type";
-    readonly type: "enum";
-    readonly required: false;
-    readonly values: readonly ["prototype", "wireframe", "page", "component"];
-    readonly default: "prototype";
-    readonly description: "Type of design output to generate";
-}, {
-    readonly name: "design-system";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "Path to existing Design.md (skips onboarding if provided)";
-}]>> & Record<`opencode/${string}`, import(".").WorkflowDefinition<"opencode", readonly [{
-    readonly name: "prompt";
-    readonly type: "text";
-    readonly required: true;
-    readonly description: "What to design (e.g., 'a dashboard for monitoring API latency')";
-}, {
-    readonly name: "reference";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "URL, file path, or codebase path to import as design reference";
-}, {
-    readonly name: "output-type";
-    readonly type: "enum";
-    readonly required: false;
-    readonly values: readonly ["prototype", "wireframe", "page", "component"];
-    readonly default: "prototype";
-    readonly description: "Type of design output to generate";
-}, {
-    readonly name: "design-system";
-    readonly type: "text";
-    readonly required: false;
-    readonly description: "Path to existing Design.md (skips onboarding if provided)";
-}]>>>;
-//# sourceMappingURL=builtin-registry.d.ts.map

package/dist/sdk/workflows/builtin-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtin-registry.d.ts","sourceRoot":"","sources":["../../../src/sdk/workflows/builtin-registry.ts"],"names":[],"mappings":"AAiBA,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKpC"}

package/src/sdk/commander.ts

@@ -1,161 +0,0 @@
-/**
- * Commander adapter for embedding a WorkflowCli under a parent Commander CLI.
- *
- * ```ts
- * import { createWorkflowCli } from "@bastani/atomic/workflows";
- * import { toCommand, runCli } from "@bastani/atomic/workflows/commander";
- *
- * const cli = createWorkflowCli(workflow);
- * const program = new Command("my-app");
- * program.addCommand(toCommand(cli, "workflow"));
- *
- * await runCli(cli, () => program.parseAsync());
- * ```
- *
- * `WorkflowCli` itself is framework-agnostic — this module is the only place
- * that imports Commander on the adapter side of the API. A future
- * yargs/citty adapter would be a sibling module with the same shape.
- *
- * `runCli` handles orchestrator re-entry transparently — parent CLIs never
- * see env vars or guards. PyTorch-distributed style: the framework owns
- * rank-zero dispatch; the developer writes one line.
- */
-
-import type { Command } from "@commander-js/extra-typings";
-import type {
-  AgentType,
-  WorkflowCli,
-  WorkflowDefinition,
-} from "./types.ts";
-import {
-  buildCliCommand,
-  resolveAndStart,
-  runPicker,
-} from "./workflow-cli.ts";
-import { buildInputUnion } from "./worker-shared.ts";
-import { runOrchestrator } from "./runtime/executor.ts";
-
-/**
- * Build a Commander `Command` bound to a WorkflowCli for embedding under
- * a parent CLI. The returned Command declares `-n/--name`, `-a/--agent`,
- * `-d/--detach`, plus the per-input union across the registry. Picker
- * behaviour (agent without name in a TTY) is preserved.
- *
- * @param cli - WorkflowCli returned by `createWorkflowCli()`.
- * @param name - Mount name (default: `"workflow"`).
- */
-export function toCommand<T extends Record<string, WorkflowDefinition>>(
-  cli: WorkflowCli<T>,
-  name?: string,
-): Command {
-  const registry = cli.registry;
-  const entry = cli.entry;
-  const defaultInputs = cli.defaults;
-
-  const unionInputs = buildInputUnion(registry.list());
-
-  let cmd!: Command;
-  cmd = buildCliCommand(
-    registry,
-    unionInputs,
-    async (params) => {
-      const { name: parsedName, agent: parsedAgent, cliInputs, detach } = params;
-
-      // Interactive picker: agent given, name omitted, running in a TTY.
-      if (!parsedName && parsedAgent && process.stdout.isTTY) {
-        await runPicker(registry, parsedAgent, detach, entry, defaultInputs);
-        return;
-      }
-
-      if (!parsedName || !parsedAgent) {
-        // Commander's `help()` calls `process.exit()` and is typed `never`.
-        cmd.help();
-      }
-
-      await resolveAndStart(
-        registry,
-        parsedName,
-        parsedAgent as AgentType,
-        {
-          cliInputs,
-          dispatcherInputs: defaultInputs,
-          detach,
-          entry,
-        },
-      );
-    },
-    name ?? "workflow",
-  );
-
-  return cmd;
-}
-
-// ─── runCli — embed bootstrap ──────────────────────────────────────────────
-
-/**
- * Bootstrap an embedded Commander CLI. Use this in place of
- * `program.parseAsync()` when you've mounted an atomic WorkflowCli under
- * a parent program.
- *
- * Inspired by PyTorch's `init_process_group()`: the framework handles
- * rank-zero dispatch (here: orchestrator vs CLI) transparently, so the
- * developer writes the same code whether this process is a fresh CLI
- * invocation or a tmux-spawned orchestrator re-exec.
- *
- * - On a fresh invocation, invokes `cliFn()` (your `program.parseAsync()`
- *   call, plus any bootstrap you want before it).
- * - When the process is a detached orchestrator re-exec
- *   (`ATOMIC_ORCHESTRATOR_MODE=1` is set by the runtime), resolves the
- *   workflow identified by `ATOMIC_WF_KEY` against the supplied CLI
- *   (or the first match across CLIs) and drives it via
- *   `runOrchestrator`. `cliFn` is not called.
- *
- * Accepts a single WorkflowCli or an array — use an array when your
- * parent CLI embeds multiple atomic WorkflowClis (rare, but supported).
- *
- * @example
- * ```ts
- * const program = new Command("my-app");
- * program.addCommand(toCommand(cli));
- *
- * await runCli(cli, () => program.parseAsync());
- * ```
- *
- * @example With pre-parse bootstrap:
- * ```ts
- * await runCli(builtinCli, async () => {
- *   await ensureGlobalAtomicSettings();
- *   await autoSyncIfStale();
- *   await program.parseAsync();
- * });
- * ```
- */
-export async function runCli(
-  target: WorkflowCli | ReadonlyArray<WorkflowCli>,
-  cliFn: () => void | Promise<void>,
-): Promise<void> {
-  if (process.env.ATOMIC_ORCHESTRATOR_MODE === "1") {
-    const key = process.env.ATOMIC_WF_KEY ?? "";
-    const slashIdx = key.indexOf("/");
-    if (slashIdx < 0) {
-      throw new Error(
-        `ATOMIC_ORCHESTRATOR_MODE=1 but ATOMIC_WF_KEY "${key}" is malformed — expected "<agent>/<name>"`,
-      );
-    }
-    const agent = key.slice(0, slashIdx) as AgentType;
-    const name = key.slice(slashIdx + 1);
-
-    const clis = Array.isArray(target) ? target : [target];
-    for (const cli of clis) {
-      const def = cli.registry.resolve(name, agent);
-      if (def) {
-        await runOrchestrator(def);
-        return;
-      }
-    }
-
-    throw new Error(`ATOMIC_WF_KEY "${key}" not found in any provided WorkflowCli`);
-  }
-
-  await cliFn();
-}