@bastani/atomic 0.6.8-0 → 0.7.0-1

package/src/sdk/runtime/status-writer.test.ts

@@ -1,245 +0,0 @@
-/**
- * Unit tests for the workflow status writer.
- *
- * Covers the pure helpers (overall-status derivation, snapshot
- * construction, tmux-name → run-id parsing) and the file I/O round
- * trip against a real temp directory.
- */
-
-import { describe, test, expect } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  buildSnapshot,
-  deriveOverallStatus,
-  readSnapshot,
-  workflowRunIdFromTmuxName,
-  writeSnapshot,
-  type WorkflowStatusSnapshot,
-} from "./status-writer.ts";
-import type { SessionData } from "../components/orchestrator-panel-types.ts";
-
-function session(
-  name: string,
-  status: SessionData["status"],
-  extra: Partial<SessionData> = {},
-): SessionData {
-  return {
-    name,
-    status,
-    parents: [],
-    startedAt: 1000,
-    endedAt: null,
-    ...extra,
-  };
-}
-
-// ─── deriveOverallStatus ────────────────────────────────────────────
-
-describe("deriveOverallStatus", () => {
-  test("returns 'error' when fatalError is set, even if completion is reached", () => {
-    expect(
-      deriveOverallStatus({
-        sessions: [],
-        fatalError: "boom",
-        completionReached: true,
-      }),
-    ).toBe("error");
-  });
-
-  test("returns 'error' when any session ended in error", () => {
-    expect(
-      deriveOverallStatus({
-        sessions: [session("a", "complete"), session("b", "error")],
-        fatalError: null,
-        completionReached: false,
-      }),
-    ).toBe("error");
-  });
-
-  test("returns 'needs_review' when any session is awaiting_input", () => {
-    expect(
-      deriveOverallStatus({
-        sessions: [session("a", "running"), session("b", "awaiting_input")],
-        fatalError: null,
-        completionReached: false,
-      }),
-    ).toBe("needs_review");
-  });
-
-  test("'needs_review' wins over 'completed' so a HIL pause near the end isn't reported as done", () => {
-    expect(
-      deriveOverallStatus({
-        sessions: [session("a", "complete"), session("b", "awaiting_input")],
-        fatalError: null,
-        completionReached: true,
-      }),
-    ).toBe("needs_review");
-  });
-
-  test("returns 'completed' when completionReached and nothing errored or paused", () => {
-    expect(
-      deriveOverallStatus({
-        sessions: [session("a", "complete"), session("b", "complete")],
-        fatalError: null,
-        completionReached: true,
-      }),
-    ).toBe("completed");
-  });
-
-  test("returns 'in_progress' as the default", () => {
-    expect(
-      deriveOverallStatus({
-        sessions: [session("a", "running")],
-        fatalError: null,
-        completionReached: false,
-      }),
-    ).toBe("in_progress");
-  });
-});
-
-// ─── workflowRunIdFromTmuxName ──────────────────────────────────────
-
-describe("workflowRunIdFromTmuxName", () => {
-  test("extracts the trailing 8-hex segment from a workflow session name", () => {
-    expect(workflowRunIdFromTmuxName("atomic-wf-claude-ralph-a1b2c3d4")).toBe(
-      "a1b2c3d4",
-    );
-  });
-
-  test("handles workflow names containing hyphens", () => {
-    expect(
-      workflowRunIdFromTmuxName("atomic-wf-claude-deep-research-12345678"),
-    ).toBe("12345678");
-  });
-
-  test("returns null for chat sessions", () => {
-    expect(workflowRunIdFromTmuxName("atomic-chat-claude-deadbeef")).toBeNull();
-  });
-
-  test("returns null when the suffix is not 8-char hex", () => {
-    expect(workflowRunIdFromTmuxName("atomic-wf-claude-ralph-not-hex")).toBeNull();
-  });
-
-  test("returns null for an unrelated session name", () => {
-    expect(workflowRunIdFromTmuxName("my-session")).toBeNull();
-  });
-});
-
-// ─── buildSnapshot ──────────────────────────────────────────────────
-
-describe("buildSnapshot", () => {
-  test("populates schemaVersion + identifying fields and clones session arrays", () => {
-    const fixed = new Date("2026-01-01T00:00:00.000Z");
-    const sourceParents = ["orchestrator"];
-    const sourceSession = session("orchestrator", "running", { parents: sourceParents });
-    const snap = buildSnapshot(
-      {
-        workflowRunId: "abcd1234",
-        tmuxSession: "atomic-wf-claude-ralph-abcd1234",
-        workflowName: "ralph",
-        agent: "claude",
-        prompt: "hello",
-        fatalError: null,
-        completionReached: false,
-        sessions: [sourceSession],
-      },
-      () => fixed,
-    );
-
-    expect(snap.schemaVersion).toBe(1);
-    expect(snap.workflowRunId).toBe("abcd1234");
-    expect(snap.tmuxSession).toBe("atomic-wf-claude-ralph-abcd1234");
-    expect(snap.workflowName).toBe("ralph");
-    expect(snap.agent).toBe("claude");
-    expect(snap.prompt).toBe("hello");
-    expect(snap.overall).toBe("in_progress");
-    expect(snap.updatedAt).toBe("2026-01-01T00:00:00.000Z");
-    expect(snap.sessions).toHaveLength(1);
-    expect(snap.sessions[0]!.name).toBe("orchestrator");
-    // parents must be cloned, not aliased to the input array — otherwise
-    // a later panel-store mutation would silently rewrite a snapshot
-    // that we already handed to a consumer.
-    expect(snap.sessions[0]!.parents).not.toBe(sourceParents);
-    expect(snap.sessions[0]!.parents).toEqual(sourceParents);
-  });
-
-  test("propagates the derived overall status from the inputs", () => {
-    const snap = buildSnapshot({
-      workflowRunId: "abcd1234",
-      tmuxSession: "x",
-      workflowName: "ralph",
-      agent: "claude",
-      prompt: "",
-      fatalError: null,
-      completionReached: true,
-      sessions: [session("a", "complete")],
-    });
-    expect(snap.overall).toBe("completed");
-  });
-});
-
-// ─── write/read round trip ──────────────────────────────────────────
-
-describe("writeSnapshot + readSnapshot", () => {
-  test("persists a snapshot and reads it back unchanged", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "atomic-status-"));
-    try {
-      const snap: WorkflowStatusSnapshot = buildSnapshot({
-        workflowRunId: "abcd1234",
-        tmuxSession: "atomic-wf-claude-ralph-abcd1234",
-        workflowName: "ralph",
-        agent: "claude",
-        prompt: "hello",
-        fatalError: null,
-        completionReached: false,
-        sessions: [session("orchestrator", "running")],
-      });
-
-      await writeSnapshot(dir, snap);
-      const back = await readSnapshot(dir);
-      expect(back).not.toBeNull();
-      expect(back!.workflowRunId).toBe("abcd1234");
-      expect(back!.overall).toBe("in_progress");
-      expect(back!.sessions).toHaveLength(1);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("returns null when status.json does not exist", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "atomic-status-"));
-    try {
-      const back = await readSnapshot(dir);
-      expect(back).toBeNull();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("returns null when status.json is malformed JSON", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "atomic-status-"));
-    try {
-      await Bun.write(join(dir, "status.json"), "not-json");
-      const back = await readSnapshot(dir);
-      expect(back).toBeNull();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("returns null when status.json fails the snapshot shape guard", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "atomic-status-"));
-    try {
-      await Bun.write(
-        join(dir, "status.json"),
-        JSON.stringify({ schemaVersion: 99, foo: "bar" }),
-      );
-      const back = await readSnapshot(dir);
-      expect(back).toBeNull();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/sdk/runtime/status-writer.ts

@@ -1,201 +0,0 @@
-/**
- * Workflow status snapshot — bridges the in-process panel state with
- * out-of-process consumers (e.g. `atomic workflow status`).
- *
- * The orchestrator subscribes to its `PanelStore` and writes a fresh
- * snapshot to `~/.atomic/sessions/<workflowRunId>/status.json` every
- * time the store mutates. Consumers read that file to derive the
- * overall workflow state without needing IPC into the orchestrator.
- */
-
-import { join } from "node:path";
-import type { SessionData, SessionStatus } from "../components/orchestrator-panel-types.ts";
-
-/** File name used for the status snapshot inside each workflow's session directory. */
-export const STATUS_FILE_NAME = "status.json";
-
-/** High-level workflow state surfaced to the agent / CLI consumer. */
-export type WorkflowOverallStatus =
-  | "in_progress"
-  | "error"
-  | "completed"
-  | "needs_review";
-
-/** Per-session entry mirrored from the orchestrator's panel store. */
-export interface WorkflowStatusSession {
-  name: string;
-  status: SessionStatus;
-  parents: string[];
-  error?: string;
-  startedAt: number | null;
-  endedAt: number | null;
-}
-
-/**
- * Snapshot persisted to disk for `atomic workflow status` to read.
- * Schema is versioned so future readers can stay backwards-compatible.
- */
-export interface WorkflowStatusSnapshot {
-  schemaVersion: 1;
-  workflowRunId: string;
-  tmuxSession: string;
-  workflowName: string;
-  agent: string;
-  prompt: string;
-  /** Overall state derived from per-session status + completion flags. */
-  overall: WorkflowOverallStatus;
-  /** True when the orchestrator has shown its completion banner. */
-  completionReached: boolean;
-  /** Fatal-error message set via `panel.showFatalError`, if any. */
-  fatalError: string | null;
-  /** Wall-clock time of the snapshot in ISO-8601 format. */
-  updatedAt: string;
-  sessions: WorkflowStatusSession[];
-}
-
-/**
- * Inputs the writer needs to render a snapshot — a strict subset of
- * `PanelStore` so the writer doesn't depend on the renderer module.
- */
-export interface StatusWriterInputs {
-  workflowRunId: string;
-  tmuxSession: string;
-  workflowName: string;
-  agent: string;
-  prompt: string;
-  fatalError: string | null;
-  completionReached: boolean;
-  sessions: readonly SessionData[];
-}
-
-/**
- * Derive the overall workflow state from per-session statuses + the
- * orchestrator-level completion / fatal-error flags.
- *
- * Precedence (highest first):
- *   1. `error`          — fatal error or any session ended in error
- *   2. `needs_review`   — at least one session is awaiting human input (HIL)
- *   3. `completed`      — completion banner reached and nothing errored
- *   4. `in_progress`    — default
- *
- * `needs_review` outranks `completed` so an agent that pauses for HIL
- * right at the end is never reported as done while still waiting.
- */
-export function deriveOverallStatus(input: {
-  sessions: readonly SessionData[];
-  completionReached: boolean;
-  fatalError: string | null;
-}): WorkflowOverallStatus {
-  if (input.fatalError !== null) return "error";
-  if (input.sessions.some((s) => s.status === "error")) return "error";
-  if (input.sessions.some((s) => s.status === "awaiting_input")) {
-    return "needs_review";
-  }
-  if (input.completionReached) return "completed";
-  return "in_progress";
-}
-
-/** Build a snapshot from the writer inputs (pure — exported for tests). */
-export function buildSnapshot(
-  input: StatusWriterInputs,
-  now: () => Date = () => new Date(),
-): WorkflowStatusSnapshot {
-  return {
-    schemaVersion: 1,
-    workflowRunId: input.workflowRunId,
-    tmuxSession: input.tmuxSession,
-    workflowName: input.workflowName,
-    agent: input.agent,
-    prompt: input.prompt,
-    overall: deriveOverallStatus({
-      sessions: input.sessions,
-      completionReached: input.completionReached,
-      fatalError: input.fatalError,
-    }),
-    completionReached: input.completionReached,
-    fatalError: input.fatalError,
-    updatedAt: now().toISOString(),
-    sessions: input.sessions.map((s) => ({
-      name: s.name,
-      status: s.status,
-      parents: [...s.parents],
-      ...(s.error !== undefined ? { error: s.error } : {}),
-      startedAt: s.startedAt,
-      endedAt: s.endedAt,
-    })),
-  };
-}
-
-/** Absolute path of the status file for a given workflow run directory. */
-export function statusFilePath(sessionDir: string): string {
-  return join(sessionDir, STATUS_FILE_NAME);
-}
-
-/**
- * Write a snapshot to `<sessionDir>/status.json`. Uses an atomic
- * write-then-rename so concurrent readers never see partial JSON.
- * Errors are swallowed — the orchestrator must keep running even if
- * the status file can't be persisted.
- */
-export async function writeSnapshot(
-  sessionDir: string,
-  snapshot: WorkflowStatusSnapshot,
-): Promise<void> {
-  const finalPath = statusFilePath(sessionDir);
-  const tmpPath = `${finalPath}.tmp-${process.pid}`;
-  try {
-    await Bun.write(tmpPath, JSON.stringify(snapshot, null, 2));
-    const { rename } = await import("node:fs/promises");
-    await rename(tmpPath, finalPath);
-  } catch {
-    // Best-effort — never fail the workflow because of a status write.
-  }
-}
-
-/**
- * Read a snapshot from disk. Returns `null` when the file doesn't
- * exist or fails to parse — callers fall back to deriving status from
- * the live tmux session list.
- */
-export async function readSnapshot(
-  sessionDir: string,
-): Promise<WorkflowStatusSnapshot | null> {
-  try {
-    const file = Bun.file(statusFilePath(sessionDir));
-    if (!(await file.exists())) return null;
-    const parsed: unknown = JSON.parse(await file.text());
-    if (!isSnapshot(parsed)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-/** Runtime guard for deserialised snapshots — keeps the reader type-safe. */
-function isSnapshot(value: unknown): value is WorkflowStatusSnapshot {
-  if (!value || typeof value !== "object") return false;
-  const v = value as Record<string, unknown>;
-  return (
-    v.schemaVersion === 1 &&
-    typeof v.workflowRunId === "string" &&
-    typeof v.tmuxSession === "string" &&
-    typeof v.overall === "string" &&
-    Array.isArray(v.sessions)
-  );
-}
-
-/**
- * Extract the `workflowRunId` (the trailing 8-hex segment) from a
- * tmux session name shaped `atomic-wf-<agent>-<name>-<id>`. Returns
- * `null` for non-workflow sessions or names that don't end in a
- * UUID-style suffix.
- */
-export function workflowRunIdFromTmuxName(name: string): string | null {
-  if (!name.startsWith("atomic-wf-")) return null;
-  const lastDash = name.lastIndexOf("-");
-  if (lastDash < 0) return null;
-  const candidate = name.slice(lastDash + 1);
-  // generateId() produces an 8-char hex slice from crypto.randomUUID.
-  if (!/^[0-9a-f]{8}$/i.test(candidate)) return null;
-  return candidate;
-}

package/src/sdk/runtime/theme.ts

@@ -1,71 +0,0 @@
-/**
- * Terminal color theme using Catppuccin palettes.
- *
- * Uses OpenTUI's built-in dark/light mode detection (via the renderer's
- * themeMode property) to select the appropriate palette:
- * - Mocha for dark terminals (and as fallback)
- * - Latte for light terminals
- */
-
-import type { ThemeMode } from "@opentui/core";
-import { flavors, type CatppuccinFlavor } from "@catppuccin/palette";
-
-// ---------------------------------------------------------------------------
-// Theme type
-// ---------------------------------------------------------------------------
-
-export interface TerminalTheme {
-  bg: string;
-  backgroundPanel: string;
-  backgroundElement: string;
-  surface: string;
-  selection: string;
-  border: string;
-  borderDim: string;
-  accent: string;
-  text: string;
-  textMuted: string;
-  dim: string;
-  info: string;
-  success: string;
-  error: string;
-  warning: string;
-  mauve: string;
-}
-
-function buildTerminalTheme(flavor: CatppuccinFlavor): TerminalTheme {
-  const { colors } = flavor;
-  return {
-    bg: colors.base.hex,
-    backgroundPanel: colors.mantle.hex,
-    backgroundElement: colors.crust.hex,
-    surface: colors.surface0.hex,
-    selection: colors.surface1.hex,
-    border: colors.overlay0.hex,
-    borderDim: colors.surface2.hex,
-    accent: colors.blue.hex,
-    text: colors.text.hex,
-    textMuted: flavor.dark ? colors.subtext0.hex : colors.subtext1.hex,
-    dim: colors.overlay1.hex,
-    info: colors.sky.hex,
-    success: colors.green.hex,
-    error: colors.red.hex,
-    warning: colors.yellow.hex,
-    mauve: colors.mauve.hex,
-  };
-}
-
-const CATPPUCCIN_MOCHA = buildTerminalTheme(flavors.mocha);
-const CATPPUCCIN_LATTE = buildTerminalTheme(flavors.latte);
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the terminal theme from the renderer's detected theme mode.
- * Returns Catppuccin Latte for light terminals, Mocha for dark or unknown.
- */
-export function resolveTheme(mode: ThemeMode | null): TerminalTheme {
-  return mode === "light" ? CATPPUCCIN_LATTE : CATPPUCCIN_MOCHA;
-}

package/src/sdk/runtime/tmux.conf

@@ -1,112 +0,0 @@
-# Atomic tmux configuration — injected automatically via -f
-# Shared by tmux (macOS/Linux) and psmux (Windows)
-#
-# True color + passthrough for rich TUI rendering
-set-option -sa terminal-overrides ",xterm*:Tc"
-set -g set-clipboard on
-set -g allow-passthrough on
-
-# Mouse mode — scroll works out of the box
-set-option -g mouse on
-
-# Prevent processes from overwriting window titles
-set-option -g allow-rename off
-
-# Sane defaults (inlined from tmux-sensible)
-set -g escape-time 0
-set -g history-limit 50000
-set -g display-time 4000
-set -g status-interval 5
-set -g focus-events on
-setw -g aggressive-resize on
-
-# Status bar — hidden. The React-rendered AttachedStatusline footer
-# (spawned via `atomic _footer`) already shows the provider pill / pane
-# name, so the default tmux status line would visually compete with it.
-set -g status off
-
-# Pane resizing
-bind -r l resize-pane -R 5
-bind -r h resize-pane -L 5
-bind -r k resize-pane -U 5
-bind -r j resize-pane -D 5
-
-# Vi-mode
-set-window-option -g mode-keys vi
-bind-key -T copy-mode-vi v send-keys -X begin-selection
-bind-key -T copy-mode-vi C-v send-keys -X rectangle-toggle
-bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel
-
-# ── Atomic workflow navigation (prefix-free) ──────────────
-# These bindings use `bind -n` (root table) so they work without a prefix key.
-# They only apply inside Atomic's isolated tmux server (-L atomic) and do NOT
-# affect the user's regular tmux or shell sessions.
-#
-# NOTE: Ctrl+\ overrides the default SIGQUIT signal.  Agent CLIs running in
-# these panes will not receive SIGQUIT via Ctrl+\.  Use `kill -QUIT <pid>` if
-# needed.  The integrated agents (Claude Code, OpenCode, Copilot CLI) use
-# Ctrl+C for interrupts and are not affected.
-
-# Ctrl+G: jump straight back to the graph (window 0) from any agent window
-bind -n C-g select-window -t :0
-
-# Ctrl+\: cycle to next agent window from anywhere
-bind -n C-\\ next-window
-
-# Ctrl+C handling — for workflow sessions, debounce bursts so the agent's
-# "double-tap to exit" doesn't trigger on accidental spam. For chat
-# sessions (atomic-chat-*) the user is in direct control of the single
-# agent CLI and a deliberate double-tap exit must reach the agent
-# verbatim, so we forward Ctrl+C unmodified.
-#
-# @atomic-bun and @atomic-cc-debounce are set to absolute paths by
-# tmux.ts on session creation — no PATH lookup needed inside run-shell.
-bind -n C-c if-shell -F '#{m:atomic-chat-*,#{session_name}}' \
-  'send-keys C-c' \
-  'run-shell -b "\"#{@atomic-bun}\" \"#{@atomic-cc-debounce}\" \"#{pane_id}\""'
-
-# Escape exits copy-mode (clear selection first if one exists, otherwise cancel)
-bind-key -T copy-mode-vi Escape if-shell -F "#{selection_present}" "send-keys -X clear-selection" "send-keys -X cancel"
-
-# Copy-mode mouse bindings:
-#   - Drag: begin selection + disable scroll-exit (prevents losing selection if dragged to bottom)
-#   - Drag end: copy to system clipboard (via OSC52) and exit copy-mode
-#   - Click: clear any selection (but stay in copy-mode for continued scrolling)
-bind -T copy-mode-vi MouseDrag1Pane    select-pane \; send-keys -X begin-selection \; send-keys -X scroll-exit-off
-bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel
-bind -T copy-mode-vi MouseDown1Pane    send-keys -X clear-selection \; select-pane
-
-# ── Workflow protection: unbind destructive and layout-changing defaults ──
-# Atomic manages the tmux session lifecycle programmatically. Users should
-# interact with agents and navigate via Ctrl+G / Ctrl+\ / the graph panel.
-# The prefix key (C-b) is kept only for copy-mode entry (C-b [).
-#
-# Note: In practice, C-b is largely unreachable inside Atomic sessions because
-# the agent TUIs (Claude Code, OpenCode, Copilot CLI) run in raw/alternate
-# screen mode and capture keyboard input — including Ctrl+b — before tmux ever
-# sees it. This makes all prefix-based bindings effectively inaccessible during
-# normal agent interaction. The unbinds below are a defense-in-depth measure
-# for the edge case where a user exits an agent back to a bare shell prompt.
-#
-# Bindings intentionally kept (non-destructive or low-risk):
-#   C-b [   copy-mode entry (keyboard fallback for mouse scroll)
-#   C-b :   command prompt (requires typing a full command — low accidental risk)
-#   C-b d   detach (non-destructive; just disconnects the client)
-
-# Prevent window/pane destruction
-unbind &          # kill-window
-unbind x          # kill-pane
-
-# Prevent window/pane creation — Atomic owns the layout. User-initiated
-# splits or new windows would desync the executor's pane registry and
-# leave orphaned shells inside workflow/chat sessions.
-unbind c          # new-window
-unbind '"'        # default split vertical
-unbind %          # default split horizontal
-
-# Prevent renaming
-unbind ,          # rename-window
-unbind '$'        # rename-session
-
-# Prevent automatic window renaming (complements allow-rename off above)
-setw -g automatic-rename off