@bastani/atomic 0.5.5 → 0.5.6-0

package/src/completions/powershell.ts

@@ -0,0 +1,184 @@
+/**
+ * PowerShell completion script for the atomic CLI (Windows / cross-platform).
+ *
+ * Install: atomic completions powershell | Invoke-Expression
+ *   or add to $PROFILE for persistence.
+ */
+export const powershellCompletionScript = `
+Register-ArgumentCompleter -Native -CommandName atomic -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $tokens = $commandAst.ToString().Substring(0, $cursorPosition) -split '\\s+' |
+        Where-Object { $_ -ne '' }
+
+    $agents  = @('claude', 'opencode', 'copilot')
+    $scms    = @('github', 'sapling')
+    $shells  = @('bash', 'zsh', 'fish', 'powershell')
+
+    # Parse command chain, skipping flags and their values
+    $cmds = @()
+    $skipNext = $false
+    $prevToken = ''
+    for ($i = 1; $i -lt $tokens.Count; $i++) {
+        $t = $tokens[$i]
+        if ($skipNext) { $skipNext = $false; continue }
+        if ($t -match '^-') {
+            if ($t -match '^(-a|--agent|-s|--scm|-n|--name)$') { $skipNext = $true }
+            $prevToken = $t
+            continue
+        }
+        $cmds += $t
+    }
+
+    # Check if the previous non-word token is a value-expecting flag
+    $lastToken = if ($tokens.Count -gt 1) { $tokens[-1] } else { '' }
+    $prevFullToken = if ($tokens.Count -gt 2) { $tokens[-2] } else { '' }
+
+    # Complete flag values
+    if ($prevFullToken -match '^(-a|--agent)$' -or $lastToken -match '^(-a|--agent)$') {
+        if ($lastToken -match '^(-a|--agent)$') {
+            $agents | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+            return
+        }
+        $agents | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+    if ($prevFullToken -match '^(-s|--scm)$' -or $lastToken -match '^(-s|--scm)$') {
+        if ($lastToken -match '^(-s|--scm)$') {
+            $scms | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+            return
+        }
+        $scms | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    $completions = @()
+
+    switch ($cmds.Count) {
+        0 {
+            # Top-level commands
+            $completions = @(
+                @{ text = 'init';        tip = 'Interactive setup with agent selection' }
+                @{ text = 'chat';        tip = 'Start an interactive chat session' }
+                @{ text = 'workflow';    tip = 'Run a multi-session agent workflow' }
+                @{ text = 'session';     tip = 'Manage running tmux sessions' }
+                @{ text = 'config';      tip = 'Manage atomic configuration' }
+                @{ text = 'completions'; tip = 'Output shell completion script' }
+            )
+        }
+        default {
+            switch ($cmds[0]) {
+                'init' {
+                    $completions = @(
+                        @{ text = '-a';      tip = 'Agent to configure' }
+                        @{ text = '--agent'; tip = 'Agent to configure' }
+                        @{ text = '-s';      tip = 'Source control system' }
+                        @{ text = '--scm';   tip = 'Source control system' }
+                    )
+                }
+                'chat' {
+                    if ($cmds.Count -eq 1) {
+                        $completions = @(
+                            @{ text = 'session'; tip = 'Manage running chat sessions' }
+                            @{ text = '-a';      tip = 'Agent to chat with' }
+                            @{ text = '--agent'; tip = 'Agent to chat with' }
+                        )
+                    } elseif ($cmds[1] -eq 'session') {
+                        if ($cmds.Count -eq 2) {
+                            $completions = @(
+                                @{ text = 'list';    tip = 'List running sessions' }
+                                @{ text = 'connect'; tip = 'Attach to a running session' }
+                            )
+                        } else {
+                            $completions = @(
+                                @{ text = '-a';      tip = 'Filter by agent' }
+                                @{ text = '--agent'; tip = 'Filter by agent' }
+                            )
+                        }
+                    }
+                }
+                'workflow' {
+                    if ($cmds.Count -eq 1) {
+                        $completions = @(
+                            @{ text = 'list';    tip = 'List available workflows' }
+                            @{ text = 'session'; tip = 'Manage running workflow sessions' }
+                            @{ text = '-n';      tip = 'Workflow name' }
+                            @{ text = '--name';  tip = 'Workflow name' }
+                            @{ text = '-a';      tip = 'Agent to use' }
+                            @{ text = '--agent'; tip = 'Agent to use' }
+                        )
+                    } elseif ($cmds[1] -eq 'list') {
+                        $completions = @(
+                            @{ text = '-a';      tip = 'Filter by agent' }
+                            @{ text = '--agent'; tip = 'Filter by agent' }
+                        )
+                    } elseif ($cmds[1] -eq 'session') {
+                        if ($cmds.Count -eq 2) {
+                            $completions = @(
+                                @{ text = 'list';    tip = 'List running sessions' }
+                                @{ text = 'connect'; tip = 'Attach to a running session' }
+                            )
+                        } else {
+                            $completions = @(
+                                @{ text = '-a';      tip = 'Filter by agent' }
+                                @{ text = '--agent'; tip = 'Filter by agent' }
+                            )
+                        }
+                    }
+                }
+                'session' {
+                    if ($cmds.Count -eq 1) {
+                        $completions = @(
+                            @{ text = 'list';    tip = 'List running sessions' }
+                            @{ text = 'connect'; tip = 'Attach to a running session' }
+                        )
+                    } else {
+                        $completions = @(
+                            @{ text = '-a';      tip = 'Filter by agent' }
+                            @{ text = '--agent'; tip = 'Filter by agent' }
+                        )
+                    }
+                }
+                'config' {
+                    if ($cmds.Count -eq 1) {
+                        $completions = @(
+                            @{ text = 'set'; tip = 'Set a configuration value' }
+                        )
+                    } elseif ($cmds[1] -eq 'set') {
+                        if ($cmds.Count -eq 2) {
+                            $completions = @(
+                                @{ text = 'telemetry'; tip = 'Telemetry setting' }
+                            )
+                        } elseif ($cmds[2] -eq 'telemetry') {
+                            $completions = @(
+                                @{ text = 'true';  tip = 'Enable telemetry' }
+                                @{ text = 'false'; tip = 'Disable telemetry' }
+                            )
+                        }
+                    }
+                }
+                'completions' {
+                    $completions = @(
+                        @{ text = 'bash';       tip = 'Bash completion script' }
+                        @{ text = 'zsh';        tip = 'Zsh completion script' }
+                        @{ text = 'fish';       tip = 'Fish completion script' }
+                        @{ text = 'powershell'; tip = 'PowerShell completion script' }
+                    )
+                }
+            }
+        }
+    }
+
+    $completions | Where-Object { $_.text -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_.text, $_.text, 'ParameterValue', $_.tip)
+    }
+}
+`;

package/src/completions/zsh.ts

@@ -0,0 +1,144 @@
+/**
+ * Zsh completion script for the atomic CLI.
+ *
+ * Install: eval "$(atomic completions zsh)"
+ */
+export const zshCompletionScript = `
+#compdef atomic
+
+_atomic() {
+    local -a agents=('claude' 'opencode' 'copilot')
+    local -a scms=('github' 'sapling')
+
+    _arguments -C \\
+        '(-y --yes)'{-y,--yes}'[Auto-confirm all prompts]' \\
+        '--no-banner[Skip ASCII banner display]' \\
+        '(-v --version)'{-v,--version}'[Show version number]' \\
+        '(-h --help)'{-h,--help}'[Show help]' \\
+        '1:command:->cmds' \\
+        '*::arg:->args'
+
+    case "$state" in
+        cmds)
+            local -a commands=(
+                'init:Interactive setup with agent selection'
+                'chat:Start an interactive chat session'
+                'workflow:Run a multi-session agent workflow'
+                'session:Manage running tmux sessions'
+                'config:Manage atomic configuration'
+                'completions:Output shell completion script'
+            )
+            _describe 'command' commands
+            ;;
+        args)
+            case "\${words[1]}" in
+                init)
+                    _arguments \\
+                        '(-a --agent)'{-a,--agent}'[Agent to configure]:agent:(claude opencode copilot)' \\
+                        '(-s --scm)'{-s,--scm}'[Source control system]:scm:(github sapling)' \\
+                        '(-h --help)'{-h,--help}'[Show help]'
+                    ;;
+                chat)
+                    _arguments -C \\
+                        '(-a --agent)'{-a,--agent}'[Agent to chat with]:agent:(claude opencode copilot)' \\
+                        '(-h --help)'{-h,--help}'[Show help]' \\
+                        '1:subcommand:->sub' \\
+                        '*::subarg:->subargs'
+                    case "$state" in
+                        sub)
+                            local -a subs=('session:Manage running chat sessions')
+                            _describe 'subcommand' subs
+                            ;;
+                        subargs)
+                            case "\${words[1]}" in
+                                session) _atomic_session ;;
+                            esac
+                            ;;
+                    esac
+                    ;;
+                workflow)
+                    _arguments -C \\
+                        '(-n --name)'{-n,--name}'[Workflow name]:name:' \\
+                        '(-a --agent)'{-a,--agent}'[Agent to use]:agent:(claude opencode copilot)' \\
+                        '(-h --help)'{-h,--help}'[Show help]' \\
+                        '1:subcommand:->sub' \\
+                        '*::subarg:->subargs'
+                    case "$state" in
+                        sub)
+                            local -a subs=(
+                                'list:List available workflows'
+                                'session:Manage running workflow sessions'
+                            )
+                            _describe 'subcommand' subs
+                            ;;
+                        subargs)
+                            case "\${words[1]}" in
+                                list)
+                                    _arguments \\
+                                        '(-a --agent)'{-a,--agent}'[Filter by agent]:agent:(claude opencode copilot)' \\
+                                        '(-h --help)'{-h,--help}'[Show help]'
+                                    ;;
+                                session) _atomic_session ;;
+                            esac
+                            ;;
+                    esac
+                    ;;
+                session)
+                    _atomic_session
+                    ;;
+                config)
+                    _arguments -C \\
+                        '(-h --help)'{-h,--help}'[Show help]' \\
+                        '1:subcommand:->sub' \\
+                        '*::subarg:->subargs'
+                    case "$state" in
+                        sub)
+                            local -a subs=('set:Set a configuration value')
+                            _describe 'subcommand' subs
+                            ;;
+                        subargs)
+                            case "\${words[1]}" in
+                                set)
+                                    _arguments \\
+                                        '1:key:(telemetry)' \\
+                                        '2:value:(true false)'
+                                    ;;
+                            esac
+                            ;;
+                    esac
+                    ;;
+                completions)
+                    _arguments '1:shell:(bash zsh fish powershell)'
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_atomic_session() {
+    _arguments -C \\
+        '(-h --help)'{-h,--help}'[Show help]' \\
+        '1:subcommand:->sub' \\
+        '*::subarg:->subargs'
+    case "$state" in
+        sub)
+            local -a subs=(
+                'list:List running sessions'
+                'connect:Attach to a running session'
+            )
+            _describe 'subcommand' subs
+            ;;
+        subargs)
+            case "\${words[1]}" in
+                list|connect)
+                    _arguments \\
+                        '*'{-a,--agent}'[Filter by agent]:agent:(claude opencode copilot)' \\
+                        '(-h --help)'{-h,--help}'[Show help]'
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_atomic "$@"
+`;

package/src/sdk/components/compact-switcher.tsx

@@ -0,0 +1,73 @@
+/** @jsxImportSource @opentui/react */
+/**
+ * CompactSwitcher — a lightweight popup that lists all agents for quick
+ * direct-jump navigation. Opened with "/" from any view mode.
+ */
+
+import { useStore, useGraphTheme, useStoreVersion } from "./orchestrator-panel-contexts.ts";
+import { statusIcon, statusColor, fmtDuration } from "./status-helpers.ts";
+import { lerpColor } from "./color-utils.ts";
+
+export interface CompactSwitcherProps {
+  selectedIndex: number;
+}
+
+export function CompactSwitcher({ selectedIndex }: CompactSwitcherProps) {
+  const store = useStore();
+  const theme = useGraphTheme();
+  useStoreVersion(store);
+
+  const agents = store.sessions;
+  const headerHint = "\u2191\u2193 select \u00B7 \u21B5 jump \u00B7 Esc close";
+
+  return (
+    <box
+      position="absolute"
+      bottom={1}
+      left={0}
+      width={44}
+      border
+      borderStyle="rounded"
+      borderColor={theme.borderActive}
+      backgroundColor={theme.backgroundElement}
+      flexDirection="column"
+    >
+      {/* Header */}
+      <box height={1} flexDirection="row" paddingLeft={1} paddingRight={1}>
+        <text fg={theme.textDim}>agents</text>
+        <box flexGrow={1} />
+        <text fg={theme.textDim}>{headerHint}</text>
+      </box>
+
+      {/* Agent list */}
+      {agents.map((agent, i) => {
+        const isSelected = i === selectedIndex;
+        const icon = statusIcon(agent.status);
+        const iconColor = statusColor(agent.status, theme);
+        const duration =
+          agent.startedAt !== null
+            ? fmtDuration((agent.endedAt ?? Date.now()) - agent.startedAt)
+            : "\u2014";
+
+        return (
+          <box
+            key={agent.name}
+            height={1}
+            flexDirection="row"
+            paddingLeft={1}
+            paddingRight={1}
+            backgroundColor={isSelected ? lerpColor(theme.backgroundElement, theme.primary, 0.12) : theme.backgroundElement}
+          >
+            <text>
+              <span fg={theme.textDim}>{String(i + 1).padStart(2)} </span>
+              <span fg={iconColor}>{icon} </span>
+              <span fg={isSelected ? theme.text : theme.textMuted}>{agent.name}</span>
+            </text>
+            <box flexGrow={1} />
+            <text fg={theme.textDim}>{duration}</text>
+          </box>
+        );
+      })}
+    </box>
+  );
+}

package/src/sdk/components/orchestrator-panel-store.test.ts

@@ -714,4 +714,128 @@ describe("PanelStore", () => {
       expect(store.sessions.find((s) => s.name === "s3")!.parents).toEqual(["s2"]);
     });
   });
+
+  // ── setViewMode ────────────────────────────────────────────────────────────
+
+  describe("setViewMode", () => {
+    test("defaults to graph mode with empty active agent", () => {
+      expect(store.viewMode).toBe("graph");
+      expect(store.activeAgentId).toBe("");
+    });
+
+    test("switches to attached mode with agent ID", () => {
+      store.setViewMode("attached", "worker-1");
+      expect(store.viewMode).toBe("attached");
+      expect(store.activeAgentId).toBe("worker-1");
+    });
+
+    test("switches back to graph mode and clears active agent", () => {
+      store.setViewMode("attached", "worker-1");
+      store.setViewMode("graph");
+      expect(store.viewMode).toBe("graph");
+      expect(store.activeAgentId).toBe("");
+    });
+
+    test("increments version by exactly 1", () => {
+      const before = store.version;
+      store.setViewMode("attached", "worker-1");
+      expect(store.version).toBe(before + 1);
+    });
+
+    test("notifies subscribers", () => {
+      const listener = mock(() => {});
+      store.subscribe(listener);
+      store.setViewMode("attached", "worker-1");
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    test("attached without agent ID clears active agent", () => {
+      store.setViewMode("attached");
+      expect(store.viewMode).toBe("attached");
+      expect(store.activeAgentId).toBe("");
+    });
+  });
+
+  // ── getSubagents ───────────────────────────────────────────────────────────
+
+  describe("getSubagents", () => {
+    beforeEach(() => {
+      store.setWorkflowInfo("wf", "claude", [
+        { name: "planner", parents: [] },
+        { name: "writer", parents: ["planner"] },
+        { name: "reviewer", parents: ["writer"] },
+      ], "prompt");
+    });
+
+    test("returns empty when all non-orchestrator sessions are pending", () => {
+      expect(store.getSubagents()).toEqual([]);
+    });
+
+    test("excludes orchestrator from subagent list", () => {
+      store.startSession("planner");
+      const subs = store.getSubagents();
+      expect(subs.every((s) => s.name !== "orchestrator")).toBe(true);
+    });
+
+    test("includes running and completed sessions", () => {
+      store.startSession("planner");
+      store.completeSession("planner");
+      store.startSession("writer");
+      const subs = store.getSubagents();
+      expect(subs.map((s) => s.name)).toEqual(["planner", "writer"]);
+    });
+
+    test("includes errored sessions", () => {
+      store.startSession("planner");
+      store.failSession("planner", "timeout");
+      const subs = store.getSubagents();
+      expect(subs.map((s) => s.name)).toEqual(["planner"]);
+    });
+
+    test("excludes pending sessions", () => {
+      store.startSession("planner");
+      const subs = store.getSubagents();
+      expect(subs.map((s) => s.name)).toEqual(["planner"]);
+      expect(subs.some((s) => s.name === "writer")).toBe(false);
+      expect(subs.some((s) => s.name === "reviewer")).toBe(false);
+    });
+  });
+
+  // ── getActiveAgentIndex ────────────────────────────────────────────────────
+
+  describe("getActiveAgentIndex", () => {
+    beforeEach(() => {
+      store.setWorkflowInfo("wf", "claude", [
+        { name: "planner", parents: [] },
+        { name: "writer", parents: ["planner"] },
+        { name: "reviewer", parents: ["writer"] },
+      ], "prompt");
+      store.startSession("planner");
+      store.startSession("writer");
+    });
+
+    test("returns -1 when no agent is active", () => {
+      expect(store.getActiveAgentIndex()).toBe(-1);
+    });
+
+    test("returns correct index for first subagent", () => {
+      store.setViewMode("attached", "planner");
+      expect(store.getActiveAgentIndex()).toBe(0);
+    });
+
+    test("returns correct index for second subagent", () => {
+      store.setViewMode("attached", "writer");
+      expect(store.getActiveAgentIndex()).toBe(1);
+    });
+
+    test("returns -1 for orchestrator (not a subagent)", () => {
+      store.setViewMode("attached", "orchestrator");
+      expect(store.getActiveAgentIndex()).toBe(-1);
+    });
+
+    test("returns -1 for non-existent agent", () => {
+      store.setViewMode("attached", "nonexistent");
+      expect(store.getActiveAgentIndex()).toBe(-1);
+    });
+  });
 });

package/src/sdk/components/orchestrator-panel-store.ts

@@ -1,7 +1,7 @@
 // ─── State Store ──────────────────────────────────
 // Bridges the imperative OrchestratorPanel API with the React component tree.
 
-import type { SessionData, SessionStatus, PanelSession } from "./orchestrator-panel-types.ts";
+import type { SessionData, SessionStatus, PanelSession, ViewMode } from "./orchestrator-panel-types.ts";
 
 type Listener = () => void;
 
@@ -17,6 +17,11 @@ export class PanelStore {
   exitResolve: (() => void) | null = null;
   abortResolve: (() => void) | null = null;
 
+  /** Current view mode — graph overview or attached to a specific agent. */
+  viewMode: ViewMode = "graph";
+  /** ID of the agent currently attached to (only meaningful when viewMode === "attached"). */
+  activeAgentId = "";
+
   private listeners = new Set<Listener>();
 
   subscribe = (fn: Listener): (() => void) => {
@@ -108,6 +113,36 @@ export class PanelStore {
     this.emit();
   }
 
+  /**
+   * Switch between graph and attached view modes.
+   * When switching to "attached", provide the agent ID to attach to.
+   * Switching to "graph" clears the active agent.
+   */
+  setViewMode(mode: ViewMode, agentId?: string): void {
+    this.viewMode = mode;
+    this.activeAgentId = mode === "attached" && agentId ? agentId : "";
+    this.emit();
+  }
+
+  /**
+   * Return non-orchestrator agents that have started (not pending).
+   * Used for the tmux status bar agent count and active-agent index.
+   */
+  getSubagents(): SessionData[] {
+    return this.sessions.filter(
+      (s) => s.name !== "orchestrator" && s.status !== "pending",
+    );
+  }
+
+  /**
+   * Return the 0-based index of the active agent within the subagent list,
+   * or -1 if not found.
+   */
+  getActiveAgentIndex(): number {
+    const subs = this.getSubagents();
+    return subs.findIndex((s) => s.name === this.activeAgentId);
+  }
+
   /** Safely invoke exitResolve at most once, guarding against rapid repeated calls. */
   resolveExit(): void {
     if (this.exitResolve) {

package/src/sdk/components/orchestrator-panel-types.ts

@@ -2,6 +2,8 @@
 
 export type SessionStatus = "pending" | "running" | "complete" | "error";
 
+export type ViewMode = "graph" | "attached";
+
 export interface PanelSession {
   name: string;
   parents: string[];