@bastani/atomic 0.6.8-0 → 0.7.0-1

package/dist/sdk/providers/claude.d.ts

@@ -1,392 +0,0 @@
-/**
- * Claude Code query abstraction.
- *
- * Sends a prompt to an interactive Claude Code session running in a tmux pane
- * using `tmux send-keys -l --` (literal text) + `C-m` (raw carriage return).
- * Verifies delivery by polling `capture-pane` and retries if needed.
- *
- * This is NOT headless — Claude runs as a full interactive TUI in the pane.
- * We're automating keyboard input and reading pane output.
- *
- * Reliability hardened from oh-my-codex's sendToWorker implementation:
- * - Pre-send readiness wait with exponential backoff
- * - CLI-specific submit plan (Claude: 1 C-m per round)
- * - Per-round capture verification (6 rounds)
- * - Adaptive retry with C-u clear + retype
- * - Post-submit active-task detection
- * - File-based idle detection via session JSONL watching
- */
-import { type SessionMessage, type SDKUserMessage, type Options as SDKOptions } from "@anthropic-ai/claude-agent-sdk";
-/**
- * Remove a pane from the initialized map and signal the currently-blocked
- * Stop hook that the session is over, so Claude stops promptly instead of
- * waiting out the hook's safety timeout.
- *
- * Called by the runtime when a Claude stage is being torn down. Idempotent.
- *
- * After writing the release marker, this waits for the per-session in-flight
- * marker dir (`~/.atomic/claude-inflight/<session_id>/`) to drain. The
- * marker dir is populated by the SubagentStart/Stop and TaskCreated/Completed
- * hooks registered in {@link WORKFLOW_HOOK_SETTINGS}. This wait is the
- * synchronization barrier that prevents the executor from advancing to the
- * next stage while the previous stage's backgrounded subagents/tasks still
- * hold FDs/PTYs on the atomic tmux server — the failure mode that surfaced
- * intermittently as `tmux respawn-pane: fork failed: Device not configured`.
- *
- * The wait has its own bounded timeout (default 30 minutes) so a wedged
- * subagent can't permanently block the workflow; the in-hook stale-sweep
- * (~2 hours TTL) is the ultimate safety net.
- */
-export declare function clearClaudeSession(paneId: string): Promise<void>;
-export interface ClaudeSessionOptions {
-    /** tmux pane ID where Claude should be started */
-    paneId: string;
-    /** CLI flags to pass to the `claude` command (default: ["--allow-dangerously-skip-permissions", "--dangerously-skip-permissions"]) */
-    chatFlags?: string[];
-}
-/**
- * Initialize per-pane Claude state. Does NOT spawn the `claude` CLI — the
- * pane is left as a bare shell. The CLI is spawned lazily on the first
- * `claudeQuery()` call, with the prompt baked into the spawn command:
- *
- *     claude [chatFlags] --session-id <UUID> 'Read the prompt in <tmpfile>'
- *
- * Pre-generating the session UUID here lets the first query pass it to the
- * CLI, so we know the JSONL filename up front and can skip discovery polling.
- *
- * Must be called before any `claudeQuery()` calls targeting the same pane.
- *
- * @example
- * ```typescript
- * import { createClaudeSession, claudeQuery } from "@bastani/atomic/workflows";
- *
- * await createClaudeSession({ paneId: ctx.paneId });
- * await claudeQuery({ paneId: ctx.paneId, prompt: "Describe this project" });
- * ```
- *
- * @example
- * ```typescript
- * // With custom flags
- * await createClaudeSession({
- *   paneId: ctx.paneId,
- *   chatFlags: ["--model", "opus", "--dangerously-skip-permissions"],
- * });
- * ```
- */
-export declare function createClaudeSession(options: ClaudeSessionOptions): Promise<string>;
-/**
- * Returns true when the most recent assistant message in the transcript
- * ended with `stop_reason: "tool_use"` — i.e. the agent stopped the current
- * API response to call a tool but has not yet produced its post-tool answer.
- *
- * Claude Code's Stop hook fires each time Claude "finishes responding",
- * which includes intermediate tool-use responses in a multi-step agent
- * loop (not just the final `end_turn`). If we return from `waitForIdle`
- * on the first Stop event, we capture the transcript mid-loop — the
- * final assistant text block is still being generated and won't be on
- * disk yet, so `inbox.md` drops the actual answer.
- *
- * We keep watching until we see an assistant message with a terminal
- * stop_reason (`end_turn`, `max_tokens`, `stop_sequence`, `refusal`),
- * which is the real end of the turn.
- *
- * Exported as `_isMidAgentLoop` for unit testing.
- */
-export declare function _isMidAgentLoop(messages: SessionMessage[]): boolean;
-/**
- * Watch `~/.atomic/claude-hil/` for this session's marker file and fire
- * `onHIL(true|false)` on create/unlink. Returns when `signal` is aborted.
- *
- * The marker is written by the `_claude-ask-hook enter` subcommand from
- * Claude Code's `PreToolUse` hook (matched on `AskUserQuestion`) and removed
- * by `_claude-ask-hook exit` from `PostToolUse` / `PostToolUseFailure`. That
- * makes the signal deterministic and independent of Claude Code's batched
- * JSONL flush timing, which used to hide the HIL window entirely when
- * tool_use and tool_result landed in the same file write.
- *
- * @internal Exported for tests.
- */
-export declare function watchHILMarker(claudeSessionId: string, onHIL: (waiting: boolean) => void, signal: AbortSignal): Promise<void>;
-/**
- * Path of the directory where the claude-stop-hook writes marker files.
- * Each Claude turn creates `~/.atomic/claude-stop/<session_id>` which
- * triggers the `fs.watch` event in `waitForIdle`.
- *
- * @internal Exported for unit tests.
- */
-export declare function markerDir(): string;
-/**
- * Return the marker file path for a given Claude session ID.
- *
- * @internal Exported for unit tests.
- */
-export declare function markerPath(claudeSessionId: string): string;
-/**
- * Directory where the workflow runtime writes queued follow-up prompts that
- * `atomic _claude-stop-hook` picks up and feeds back to Claude as
- * `{decision:"block", reason:<prompt>}`. @internal Exported for unit tests.
- */
-export declare function queueDir(): string;
-/** Return the queue file path for a given Claude session ID. @internal */
-export declare function queuePath(claudeSessionId: string): string;
-/**
- * Directory where the runtime writes session-release signals. When the Stop
- * hook sees `~/.atomic/claude-release/<session_id>` it exits 0 without
- * emitting a block decision — the signal used by `clearClaudeSession` to
- * tell Claude it's safe to actually stop. @internal Exported for unit tests.
- */
-export declare function releaseDir(): string;
-/** Return the release file path for a given Claude session ID. @internal */
-export declare function releasePath(claudeSessionId: string): string;
-/**
- * Signal the Stop hook's blocking wait that this session is done. Called
- * during session teardown so the final hook invocation exits 0 promptly.
- * Safe to call more than once.
- */
-export declare function releaseClaudeSession(claudeSessionId: string): Promise<void>;
-/**
- * Wait for the Claude session to become idle using `fs.watch` on the
- * `~/.atomic/claude-stop/` marker directory.
- *
- * When Claude finishes a turn, the `atomic _claude-stop-hook` Stop hook writes
- * `~/.atomic/claude-stop/<session_id>`. The write triggers an OS-native
- * `fs.watch` event on the parent directory — far more reliable than polling
- * tmux pane glyphs, which vary between Claude Code versions.
- *
- * This function is strictly about *idle detection*. HIL is detected separately
- * by {@link watchHILMarker}; the Stop hook does not fire while
- * `AskUserQuestion` is pending (the agent loop blocks on deferred tools), so
- * mixing the two would silently miss the HIL window.
- *
- * Algorithm:
- * 1. Attach the directory watcher, then check for the marker file on disk —
- *    this closes the race where the Stop hook fires between prompt submission
- *    and watcher attach.
- * 2. On any event, re-check the marker file on disk (we intentionally do NOT
- *    filter by `event.filename`, because on Linux a write can deliver multiple
- *    events with varying filenames and editor tools may race us).
- * 3. Read the session transcript via `getSessionMessages` and slice messages
- *    from `transcriptBeforeCount`.
- * 4. Clean up the `fs.watch` watcher on any exit path via AbortController.
- *
- * @param claudeSessionId       - Claude's session UUID (used to identify marker file)
- * @param transcriptBeforeCount - number of messages in transcript before this turn
- */
-/**
- * @internal Exported for unit tests.
- */
-export declare function waitForIdle(claudeSessionId: string, transcriptBeforeCount: number): Promise<SessionMessage[]>;
-export interface ClaudeQueryOptions {
-    /** tmux pane ID where Claude is running */
-    paneId: string;
-    /** The prompt to send */
-    prompt: string;
-    /**
-     * Called when the agent's human-in-the-loop state changes.
-     * `waiting=true`  → AskUserQuestion is pending (agent blocked on user input).
-     * `waiting=false` → AskUserQuestion was resolved (agent resumed processing).
-     */
-    onHIL?: (waiting: boolean) => void;
-}
-/**
- * Extract text content from assistant messages in a transcript slice.
- *
- * Walks messages from `afterIndex` forward, pulls `TextBlock.text` from each
- * assistant message's content array, and joins them. The `message` payload is
- * `unknown` in the SDK type so we do runtime narrowing.
- *
- * Exported so workflow authors can extract text from `SessionMessage[]`
- * returned by `s.session.query()`.
- */
-export declare function extractAssistantText(msgs: ReadonlyArray<{
-    type: string;
-    message: unknown;
-}>, afterIndex: number): string;
-/**
- * Send a prompt to a Claude Code interactive session running in a tmux pane.
- *
- * First query and follow-up queries use different delivery channels:
- *
- *   - **First query**: stages the prompt in a tmp file and spawns
- *     `claude --session-id <UUID> 'Read the prompt in <path>'` into the
- *     empty pane. Claude's first action is a Read tool call, which
- *     sidesteps ARG_MAX on the spawn argv.
- *
- *   - **Follow-up query**: writes the prompt to
- *     `~/.atomic/claude-queue/<session_id>`. The Stop hook from the
- *     previous turn is blocked in a poll loop there; it reads the queue
- *     entry and emits `{"decision":"block","reason":<prompt>}` on stdout,
- *     which Claude Code feeds back as the next user message. No tmux
- *     keystrokes, no paste-buffer dance, no pane-state polling — the
- *     whole delivery rides Claude's own continuation API.
- *
- * Both paths converge on `waitForIdle`, which watches the Stop-hook marker
- * file for this session and returns the transcript slice for the turn.
- *
- * @example
- * ```typescript
- * import { claudeQuery } from "@bastani/atomic/workflows";
- *
- * const result = await claudeQuery({
- *   paneId: ctx.paneId,
- *   prompt: "Describe this project",
- * });
- * ctx.log(result.output);
- * ```
- */
-export declare function claudeQuery(options: ClaudeQueryOptions): Promise<SessionMessage[]>;
-/**
- * Merge two `disallowedTools` lists, preserving caller entries and appending
- * any extras that aren't already present. Exported for unit testing.
- */
-export declare function mergeDisallowedTools(existing: string[] | undefined, extras: string[]): string[];
-/**
- * Fold the atomic-managed additional instructions into a caller's
- * `systemPrompt` value. Behavior, in order of precedence:
- *
- *   - **No caller value** → return a `claude_code` preset with our content
- *     in `append`. Preserves the SDK's full Claude Code persona.
- *   - **Caller passed a preset object** → concatenate our content onto the
- *     existing `append` (newline-separated when both are present).
- *   - **Caller passed a custom string or array** → leave it alone. The
- *     caller has explicitly opted into a custom prompt, and silently
- *     prepending the persona-style preset text would break that contract.
- *
- * Exported for unit testing.
- */
-export declare function mergeSystemPromptAppend(existing: SDKOptions["systemPrompt"], extra: string): SDKOptions["systemPrompt"];
-/**
- * Synthetic client wrapper for Claude stages.
- * Auto-starts the Claude CLI in the tmux pane during `start()`.
- */
-export declare class ClaudeClientWrapper {
-    readonly paneId: string;
-    private readonly opts;
-    constructor(paneId: string, opts?: {
-        chatFlags?: string[];
-    });
-    /**
-     * Start the Claude CLI in the tmux pane. Returns the Claude session UUID
-     * so the caller can pass it to `ClaudeSessionWrapper` (and thus expose it
-     * as `s.sessionId` to workflows). This is the UUID used by Claude Code to
-     * name its JSONL transcript file and to key the Stop-hook marker — workflows
-     * pass it to `s.save(s.sessionId)` so the save path reads the correct
-     * transcript even when many Claude sessions run in parallel.
-     */
-    start(): Promise<string>;
-    /** Noop — cleanup is handled by the runtime via `clearClaudeSession`. */
-    stop(): Promise<void>;
-}
-/**
- * Synthetic session wrapper for Claude stages.
- * Wraps `claudeQuery()` so users call `s.session.query(prompt)`.
- */
-export declare class ClaudeSessionWrapper {
-    readonly paneId: string;
-    readonly sessionId: string;
-    private readonly onHIL;
-    constructor(paneId: string, sessionId: string, onHIL?: (waiting: boolean) => void);
-    /**
-     * Send a prompt to Claude and wait for the response.
-     *
-     * The `_options` parameter exists for signature compatibility with
-     * {@link HeadlessClaudeSessionWrapper#query} (which forwards SDK options
-     * like `agent`, `permissionMode`, etc. to the Agent SDK). In the
-     * interactive pane path these options don't apply — we're driving the
-     * `claude` CLI binary, not the SDK — so they are silently ignored.
-     */
-    query(prompt: string, _options?: Partial<SDKOptions>): Promise<SessionMessage[]>;
-    /**
-     * Structured output is only produced by the Agent SDK's `result` message,
-     * which interactive stages don't consume (they drive the `claude` CLI via
-     * tmux, not the SDK). Always `undefined` here — pair `outputFormat` with a
-     * headless stage to read {@link HeadlessClaudeSessionWrapper#lastStructuredOutput}.
-     */
-    get lastStructuredOutput(): unknown;
-    /** Noop — for API symmetry with CopilotSession.disconnect(). */
-    disconnect(): Promise<void>;
-}
-/**
- * Headless client wrapper for Claude stages. No tmux pane — noop start/stop.
- * Used when `options.headless` is true in `ctx.stage()`.
- */
-export declare class HeadlessClaudeClientWrapper {
-    /**
-     * Headless Claude stages don't pre-allocate a session — each `query()` call
-     * to {@link HeadlessClaudeSessionWrapper} spawns a fresh Agent SDK run that
-     * emits its own `session_id`. We still return an empty string here so the
-     * method signature matches {@link ClaudeClientWrapper#start}.
-     */
-    start(): Promise<string>;
-    stop(): Promise<void>;
-}
-/**
- * Resolve the `claude` CLI binary for headless SDK queries.
- *
- * Pins the SDK to the same binary interactive stages already spawn via tmux
- * (`AGENT_CONFIG.claude.cmd` on PATH), bypassing
- * `@anthropic-ai/claude-agent-sdk`'s built-in resolver. That resolver probes
- * optional native packages in a fixed order — on Linux it tries
- * `linux-${arch}-musl` before `linux-${arch}` and returns whichever
- * `require.resolve` finds first — so on a glibc host where both optional
- * packages got installed (Bun installs every optionalDependency by default)
- * it picks the musl binary, which can't exec because its dynamic linker
- * (`/lib/ld-musl-*.so.1`) is absent. The SDK surfaces the resulting ENOENT
- * as a misleading "Claude Code native binary not found" error.
- *
- * `chatCommand` and `workflowCommand` already fail fast when `claude` isn't
- * on PATH (see `isCommandInstalled` in each), so in practice this lookup
- * always succeeds. The throw here is a belt-and-suspenders guard that
- * prefers a clear failure over silently falling back to the SDK's resolver.
- */
-export declare function resolveHeadlessClaudeBin(): string;
-/**
- * Headless session wrapper for Claude stages. Uses the Agent SDK's `query()`
- * directly instead of tmux pane operations. Implements the same `query()`
- * interface as {@link ClaudeSessionWrapper} so workflow callbacks work
- * identically for headless and interactive stages.
- *
- * The `query()` method accepts the full Agent SDK parameter types —
- * `prompt` can be a plain string or an `AsyncIterable<SDKUserMessage>`
- * for multi-turn streaming, and `options` passes through SDK-level
- * configuration (abort controllers, allowed tools, agents, etc.).
- */
-export declare class HeadlessClaudeSessionWrapper {
-    readonly paneId = "";
-    /**
-     * Project root the workflow is operating against. Used to resolve
-     * project-scoped config (e.g. `additional-instructions`) against the
-     * workflow's actual root rather than `process.cwd()`, which can drift
-     * when workflows are invoked programmatically or from a subdirectory.
-     */
-    private readonly _projectRoot;
-    /**
-     * The Claude session UUID of the most recently completed `query()`. Exposed
-     * via `s.sessionId` so workflows can pass it to `s.save(s.sessionId)` and
-     * have the save path read the correct transcript, even when several headless
-     * Claude stages run in parallel (each call gets its own SDK-assigned UUID).
-     */
-    private _lastSessionId;
-    constructor(projectRoot: string);
-    /**
-     * Validated structured output captured from the most recent `query()`'s
-     * `result` message. Populated only when callers pass
-     * `options.outputFormat = { type: "json_schema", schema }` and the SDK
-     * produced a `subtype: "success"` result with `structured_output` attached.
-     * Remains `undefined` on plain text runs or when the SDK fails validation
-     * (`error_max_structured_output_retries`).
-     */
-    private _lastStructuredOutput;
-    get sessionId(): string;
-    get lastStructuredOutput(): unknown;
-    query(prompt: string | AsyncIterable<SDKUserMessage>, options?: Partial<SDKOptions>): Promise<SessionMessage[]>;
-    disconnect(): Promise<void>;
-}
-/**
- * Validate a Claude workflow source file for common mistakes.
- *
- * Warns on direct usage of createClaudeSession/claudeQuery — the runtime
- * now handles init/cleanup automatically via s.client and s.session.
- */
-export declare const validateClaudeWorkflow: (source: string) => import("../types.ts").ValidationWarning[];
-//# sourceMappingURL=claude.d.ts.map

package/dist/sdk/providers/claude.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../../src/sdk/providers/claude.ts"],"names":[],"mappings":"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"}

package/dist/sdk/providers/copilot.d.ts

@@ -1,55 +0,0 @@
-/**
- * Copilot workflow source validation + helpers.
- *
- * Checks that Copilot workflow source files use the runtime-managed
- * `s.client` and `s.session` instead of manual SDK client creation.
- */
-import type { CopilotClientOptions, SessionConfig as CopilotSessionConfig } from "@github/copilot-sdk";
-/**
- * Return `true` when `candidate` is a Node.js / npm-loader JavaScript shim
- * that should not be passed to the Copilot SDK as the CLI executable.
- *
- * Filesystem errors for a given candidate are treated as "not a shim" so
- * that the SDK can surface the real error (e.g. permission denied, ENOENT).
- */
-export declare function isCopilotShim(candidate: string): boolean;
-/**
- * Build the subprocess environment for the Copilot CLI process.
- * Normalises locale to UTF-8 and suppresses Node.js deprecation warnings.
- */
-export declare function copilotSubprocessEnv(baseEnv?: NodeJS.ProcessEnv): Record<string, string | undefined>;
-/**
- * Enumerate every existing `cmd` candidate across PATH order.
- */
-export declare function enumeratePathCandidates(cmd: string, pathEnv: string): string[];
-export type CommandPathResolver = (cmd: string) => string | null;
-export declare function resolveCopilotCliPath(resolveCommandPath?: CommandPathResolver): string | undefined;
-/**
- * Build options suitable for `new CopilotClient(...)`.
- *
- * Includes:
- * - `env` from {@link copilotSubprocessEnv} (UTF-8 locale + `NODE_NO_WARNINGS=1`).
- * - `cliPath` from {@link resolveCopilotCliPath} when resolvable; omitted
- *   otherwise so the SDK falls back to its bundled CLI.
- */
-export declare function copilotSdkLaunchOptions(resolveCommandPath?: CommandPathResolver): CopilotClientOptions;
-/**
- * Fold the atomic-managed additional instructions into a caller's
- * `systemMessage` value on `client.createSession`. Behavior:
- *
- *   - **No caller value** → `{ mode: "append", content: extra }`. The
- *     SDK's default mode is append and preserves the SDK persona.
- *   - **Append/customize mode** → concatenate our content to the existing
- *     `content` field (newline-separated when both are present).
- *   - **Replace mode** → leave alone. The caller has explicitly opted out
- *     of SDK-managed sections; silently re-adding the persona-style append
- *     would violate that contract.
- *
- * Exported for unit testing.
- */
-export declare function mergeCopilotSystemMessage(existing: CopilotSessionConfig["systemMessage"], extra: string): CopilotSessionConfig["systemMessage"];
-/**
- * Validate a Copilot workflow source file for common mistakes.
- */
-export declare const validateCopilotWorkflow: (source: string) => import("../types.ts").ValidationWarning[];
-//# sourceMappingURL=copilot.d.ts.map

package/dist/sdk/providers/copilot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copilot.d.ts","sourceRoot":"","sources":["../../../src/sdk/providers/copilot.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,IAAI,oBAAoB,EACtC,MAAM,qBAAqB,CAAC;AAwC7B;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAYxD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,MAAM,CAAC,UAAwB,GACvC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAEpC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ9E;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAEjE,wBAAgB,qBAAqB,CACnC,kBAAkB,GAAE,mBAAoC,GACvD,MAAM,GAAG,SAAS,CAepB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,kBAAkB,GAAE,mBAAoC,GACvD,oBAAoB,CAStB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,oBAAoB,CAAC,eAAe,CAAC,EAC/C,KAAK,EAAE,MAAM,GACZ,oBAAoB,CAAC,eAAe,CAAC,CASvC;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,+DAelC,CAAC"}

package/dist/sdk/providers/opencode.d.ts

@@ -1,27 +0,0 @@
-/**
- * OpenCode workflow source validation + headless env helper.
- *
- * Checks that OpenCode workflow source files use the runtime-managed
- * `s.client` and `s.session` instead of manual SDK client creation, and
- * exports the `OPENCODE_CLIENT` override used to keep the interactive
- * `question` tool out of headless stages.
- */
-/**
- * Client identifier passed to SDK-spawned OpenCode subprocesses in headless
- * stages.
- *
- * OpenCode only registers its interactive `question` tool when
- * `OPENCODE_CLIENT` is one of `"app" | "cli" | "desktop"` (see
- * `packages/opencode/src/tool/registry.ts` upstream — the `questionEnabled`
- * gate). In unattended runs nobody is attached to answer, so we identify
- * ourselves as `"sdk"` to keep the tool off the registry entirely. This
- * mirrors how the upstream ACP integration excludes the tool by default
- * (`packages/opencode/src/cli/cmd/acp.ts` sets `OPENCODE_CLIENT=acp`).
- */
-export declare const HEADLESS_OPENCODE_CLIENT_ID = "sdk";
-export declare function withHeadlessOpencodeEnv<T>(fn: () => Promise<T>): Promise<T>;
-/**
- * Validate an OpenCode workflow source file for common mistakes.
- */
-export declare const validateOpenCodeWorkflow: (source: string) => import("../types.ts").ValidationWarning[];
-//# sourceMappingURL=opencode.d.ts.map

package/dist/sdk/providers/opencode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../../src/sdk/providers/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,QAAQ,CAAC;AAuBjD,wBAAsB,uBAAuB,CAAC,CAAC,EAC7C,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,+DAenC,CAAC"}

package/dist/sdk/registry.d.ts

@@ -1,27 +0,0 @@
-/**
- * Workflow Registry — immutable, chainable registry of WorkflowDefinition objects.
- *
- * Key scheme: `${agent}/${name}` — each (agent, name) pair is unique.
- * Registering the same key twice throws — no silent overwrites.
- * `register()` is immutable: returns a new Registry, original is unchanged.
- */
-import type { Registry } from "./types.ts";
-import { validateCopilotWorkflow } from "./providers/copilot.ts";
-import { validateOpenCodeWorkflow } from "./providers/opencode.ts";
-import { validateClaudeWorkflow } from "./providers/claude.ts";
-export type { Registry };
-/**
- * Create an empty workflow registry.
- *
- * @example
- * ```typescript
- * import { createRegistry } from "@bastani/atomic/workflows";
- * import { myWorkflow } from "./workflows/my-workflow.workflow";
- *
- * const registry = createRegistry()
- *   .register(myWorkflow);
- * ```
- */
-export declare function createRegistry(): Registry<Record<string, never>>;
-export { validateCopilotWorkflow, validateOpenCodeWorkflow, validateClaudeWorkflow };
-//# sourceMappingURL=registry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/sdk/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAa,QAAQ,EAA2C,MAAM,YAAY,CAAC;AAC/F,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAI/D,YAAY,EAAE,QAAQ,EAAE,CAAC;AAmGzB;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAEhE;AAGD,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/sdk/runtime/attached-footer.d.ts

@@ -1,31 +0,0 @@
-/**
- * Helper for spawning the attached `atomic _footer` pane inside an agent
- * tmux window.
- *
- * Shared between the workflow executor (per-agent windows) and the chat
- * command (single-agent window). Splits the target pane vertically so the
- * top pane keeps running the agent CLI and the bottom pane hosts the
- * React footer.
- *
- * Resolves the CLI entrypoint relative to this module (runtime/ lives at
- * src/sdk/runtime/, so ../../cli.ts is the CLI). `process.argv[1]` points
- * at the worker entrypoint when called from the orchestrator,
- * so it can't be used here.
- */
-import type { AgentType } from "../types.ts";
-export declare function resolveAttachedFooterCliPath(runtimeDir?: string, platform?: NodeJS.Platform): string;
-export declare function buildAttachedFooterCommand({ runtime, cliPath, windowName, agentType, platform, }: {
-    runtime: string;
-    cliPath: string;
-    windowName: string;
-    agentType?: AgentType;
-    platform?: NodeJS.Platform;
-}): string;
-export declare function buildAttachedFooterCloseHooks(agentPaneId: string, footerPaneId: string, options?: {
-    guardAgentPane?: boolean;
-}): Array<{
-    event: string;
-    command: string;
-}>;
-export declare function spawnAttachedFooter(windowName: string, paneId: string, agentType?: AgentType): void;
-//# sourceMappingURL=attached-footer.d.ts.map

package/dist/sdk/runtime/attached-footer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attached-footer.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/attached-footer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AA6B7C,wBAAgB,4BAA4B,CAC1C,UAAU,SAAkB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,MAAM,CAIR;AAED,wBAAgB,0BAA0B,CAAC,EACzC,OAAO,EACP,OAAO,EACP,UAAU,EACV,SAAS,EACT,QAA2B,GAC5B,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,GAAG,MAAM,CAoBT;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GACzC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAU3C;AAOD,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,SAAS,GACpB,IAAI,CAyCN"}

package/dist/sdk/runtime/cc-debounce.d.ts

@@ -1,29 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Ctrl+C debounce helper for Atomic-managed tmux panes.
- *
- * Invoked from `tmux.conf` on every root-table Ctrl+C:
- *
- *   bind -n C-c run-shell -b '"#{@atomic-bun}" "#{@atomic-cc-debounce}" "#{pane_id}"'
- *
- * The binding sits on the shared atomic tmux server, so the debounce
- * applies uniformly to every pane — Claude Code, OpenCode, and Copilot
- * CLI, in both chat and workflow sessions.
- *
- * Rule: forward Ctrl+C only if the previous press is more than QUIET_MS
- * ago. The state file is touched on *every* press (forwarded or
- * swallowed) so sustained spam keeps extending the cooldown instead of
- * letting a press leak through every QUIET_MS interval — which is what
- * would otherwise still trigger an agent CLI's "double-tap to exit"
- * confirmation.
- */
-/** Quiet period (ms) the user must leave between presses for the next
- *  one to be forwarded. Must exceed every integrated agent's exit-confirm
- *  window — Claude Code's is the widest (~1.5 s), so 1200 ms is a safe
- *  margin that still feels responsive for legitimate double-interrupts. */
-export declare const QUIET_MS = 1200;
-/** Pure decision helper — exported so tests can exercise it without
- *  touching the filesystem or spawning tmux. Returns `true` when the
- *  press should be forwarded, `false` when it should be swallowed. */
-export declare function shouldForward(nowMs: number, lastMs: number, quietMs?: number): boolean;
-//# sourceMappingURL=cc-debounce.d.ts.map

package/dist/sdk/runtime/cc-debounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cc-debounce.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/cc-debounce.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;;2EAG2E;AAC3E,eAAO,MAAM,QAAQ,OAAO,CAAC;AAE7B;;sEAEsE;AACtE,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,MAAiB,GACzB,OAAO,CAET"}

package/dist/sdk/runtime/executor-env.d.ts

@@ -1,20 +0,0 @@
-/**
- * Orchestrator environment variable validation — extracted into its own
- * module so test files can import it directly without touching the
- * executor.ts module (which is mocked in worker.test.ts and
- * workflow-command.test.ts). Importing from here bypasses those mocks.
- */
-import type { AgentType } from "../types.ts";
-/**
- * Read and validate the required orchestrator env vars, throwing on the
- * first missing or invalid value.
- *
- * Required vars: ATOMIC_WF_ID, ATOMIC_WF_TMUX, ATOMIC_WF_AGENT, ATOMIC_WF_CWD.
- */
-export declare function validateOrchestratorEnv(): {
-    workflowRunId: string;
-    tmuxSessionName: string;
-    agent: AgentType;
-    cwd: string;
-};
-//# sourceMappingURL=executor-env.d.ts.map

package/dist/sdk/runtime/executor-env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor-env.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/executor-env.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,SAAS,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAuBA"}