abmux 0.0.8 → 0.0.9

package/README.md

@@ -1,14 +1,8 @@
 # abmux
 
-AI Board on tmux — A terminal UI for managing Claude Code sessions on tmux.
+AI Board on tmux — A TUI for managing multiple Claude Code sessions from a single terminal screen.
 
-## Features
-
-- Manage tmux sessions grouped by project
-- Detect Claude session status: waiting for input, thinking, running tools, idle
-- Launch new Claude Code sessions with prompts via your `$EDITOR`
-- Fuzzy search directories to add new sessions
-- CLI commands for scripting: `new`, `open`, `kill`, `list`
+Monitor, create, switch between, and delete Claude Code sessions running on tmux, all in one place.
 
 ## Requirements
 
@@ -19,34 +13,116 @@ AI Board on tmux — A terminal UI for managing Claude Code sessions on tmux.
 ## Install
 
 ```sh
-npm install -g abmux
-# or
-yarn global add abmux
-# or
 pnpm add -g abmux
 ```
 
-## Usage
+## Getting Started
 
 ```sh
-abmux                              # Start TUI
-abmux new <prompt> [--dir <path>]  # Create session and launch Claude
-abmux open [session]               # Attach to session
-abmux kill [session]               # Kill session
+abmux
+```
+
+Run without arguments to launch the TUI.
+
+CLI commands are also available for scripting:
+
+```sh
+abmux new <prompt> [--dir <path>]  # Create a session
+abmux open [session]               # Attach to a session
+abmux kill [session]               # Kill a session
 abmux list                         # List sessions
-abmux --help                       # Show help
 ```
 
+## Screen Layout
+
+The main screen is split into three panels:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ abmux - v0.0.x                                                  │
+├───────────────────────┬─────────────────────────────────────────┤
+│                       │                                         │
+│  Session List         │  Pane List                              │
+│  (Left Panel)         │  (Right Panel)                          │
+│                       │                                         │
+│  > my-project (cwd)   │    ⠋ [thinking] Refactoring...  %5     │
+│    other-project      │    ✳ [running]  Fixing tests    %8     │
+│                       │    ○ [idle]     Waiting         %12    │
+│                       │    ● vim                        %3     │
+│                       │                                         │
+├───────────────────────┴─────────────────────────────────────────┤
+│                                                                  │
+│  Session Overview (Bottom Panel)                                 │
+│  Summaries of what Claude is working on in each session          │
+│                                                                  │
+├──────────────────────────────────────────────────────────────────┤
+│ ↑/↓ move  Enter select  Tab next  n add  q quit    ● 2 thinking │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+Press `Tab` to cycle focus: Left → Right → Bottom. The focused panel is highlighted with a green border.
+
+## Panels
+
+### Left Panel: Session List
+
+Lists tmux sessions grouped by project directory. The session matching your current directory is marked with `(cwd)`.
+
+| Key           | Action                              |
+| ------------- | ----------------------------------- |
+| `↑` / `↓`     | Move cursor                         |
+| `Enter` / `→` | Select session, move to right panel |
+| `n`           | Add session via directory search    |
+| `d`           | Delete session                      |
+| `q`           | Quit                                |
+
+### Right Panel: Pane List
+
+Shows all panes in the selected session. Claude Code panes display their status; other panes (editors, shells) are also listed.
+
+| Key         | Action                          |
+| ----------- | ------------------------------- |
+| `↑` / `↓`   | Move cursor                     |
+| `Enter`     | Attach to pane (switch to tmux) |
+| `n`         | Create a new Claude session     |
+| `v`         | Open session in `$EDITOR`       |
+| `d`         | Kill pane                       |
+| `Esc` / `←` | Back to left panel              |
+
+### Bottom Panel: Session Overview
+
+Displays AI-generated summaries of what Claude is doing in each session. Auto-refreshes every 60 seconds.
+
+| Key         | Action             |
+| ----------- | ------------------ |
+| `↑` / `↓`   | Scroll             |
+| `Tab`       | Next panel         |
+| `Esc` / `←` | Back to left panel |
+
+## Status Icons
+
+The right panel and the status bar show Claude session states with these icons:
+
+| Icon          | Status   | Meaning                   |
+| ------------- | -------- | ------------------------- |
+| `⠋` (braille) | thinking | Claude is reasoning       |
+| `✳`           | running  | Executing a tool          |
+| `❓`          | confirm  | Waiting for user approval |
+| `❯`           | waiting  | Ready for input           |
+| `○`           | idle     | Idle                      |
+
+Non-Claude panes show `●` (busy) or `○` (available).
+
 ## Development
 
 ```sh
 pnpm install
-pnpm start        # Run in development mode (tsx)
-pnpm test         # Run tests with Vitest
-pnpm typecheck    # Type check without emitting
-pnpm lint:check   # Lint with oxlint
-pnpm format:check # Check formatting with oxfmt
-pnpm build        # Bundle with esbuild
+pnpm start        # Run in dev mode
+pnpm test         # Run tests
+pnpm typecheck    # Type check
+pnpm lint:check   # Lint
+pnpm format:check # Format check
+pnpm build        # Bundle
 ```
 
 ## License

package/dist/cli/index.js

@@ -603,7 +603,7 @@ var createUsecases = (context) => ({
 // package.json
 var package_default = {
   name: "abmux",
-  version: "0.0.8",
+  version: "0.0.9",
   repository: {
     type: "git",
     url: "https://github.com/cut0/abmux.git"
@@ -673,8 +673,8 @@ import { createElement } from "react";
 
 // src/components/ManagerView.tsx
 import { basename as basename2 } from "node:path";
-import { Box as Box11, useInput as useInput7 } from "ink";
-import { useCallback as useCallback5, useMemo as useMemo7, useRef as useRef3, useState as useState7 } from "react";
+import { Box as Box12, useInput as useInput8 } from "ink";
+import { useCallback as useCallback5, useMemo as useMemo7, useRef as useRef4, useState as useState8 } from "react";
 
 // src/components/shared/Header.tsx
 import { Box, Text } from "ink";
@@ -776,11 +776,10 @@ var SessionListPanel = ({
   onCursorChange,
   onDeleteSession,
   onAddSession,
-  initialCursor,
   cursorRef
 }) => {
   const { exit } = useApp();
-  const [cursor, setCursor] = useState(initialCursor ?? 0);
+  const [cursor, setCursor] = useState(cursorRef?.current ?? 0);
   const sortedSessions = useMemo3(
     () => sortSessions(sessions, currentSession),
     [sessions, currentSession]
@@ -864,6 +863,7 @@ var SessionListPanel = ({
 
 // src/components/PaneListPanel.tsx
 import { Box as Box6, Text as Text6 } from "ink";
+import { useRef as useRef2 } from "react";
 
 // src/components/PaneListView.tsx
 import { Box as Box5, Text as Text5, useApp as useApp2, useInput as useInput2 } from "ink";
@@ -911,12 +911,12 @@ var PaneListView = ({
   onUnhighlight,
   onBack,
   onNewSession,
+  onOpenEditor,
   onKillPane,
-  initialCursor,
   cursorRef
 }) => {
   const { exit } = useApp2();
-  const [cursor, setCursor] = useState2(initialCursor ?? 0);
+  const [cursor, setCursor] = useState2(cursorRef?.current ?? 0);
   const highlightedRef = useRef(void 0);
   const panes = useMemo4(() => group.tabs.flatMap((t) => t.panes), [group]);
   const clampedCursor = cursor >= panes.length ? Math.max(0, panes.length - 1) : cursor;
@@ -992,6 +992,10 @@ var PaneListView = ({
         onNewSession(selectedSession);
         return;
       }
+      if (input === "v") {
+        onOpenEditor(selectedSession);
+        return;
+      }
       if (key.return) {
         const pane = panes[clampedCursor];
         if (pane) onNavigate(pane);
@@ -1012,7 +1016,7 @@ var PaneListView = ({
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: panes.length === 0 ? /* @__PURE__ */ jsx5(Box5, { paddingLeft: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "No panes. Press n to create." }) }) : visiblePanes.map((up, i) => /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: panes.length === 0 ? /* @__PURE__ */ jsx5(Box5, { paddingLeft: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "No panes. Press n or v to create." }) }) : visiblePanes.map((up, i) => /* @__PURE__ */ jsx5(
       PaneItem,
       {
         unifiedPane: up,
@@ -1035,10 +1039,15 @@ var PaneListPanel = ({
   onUnhighlight,
   onBack,
   onNewSession,
+  onOpenEditor,
   onKillPane,
-  initialCursor,
   cursorRef
 }) => {
+  const prevSessionRef = useRef2(selectedSession);
+  if (prevSessionRef.current !== selectedSession) {
+    prevSessionRef.current = selectedSession;
+    if (cursorRef) cursorRef.current = 0;
+  }
   if (!selectedSession) {
     return /* @__PURE__ */ jsx6(Box6, { paddingLeft: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No session selected" }) });
   }
@@ -1054,8 +1063,8 @@ var PaneListPanel = ({
       onUnhighlight,
       onBack,
       onNewSession,
+      onOpenEditor,
       onKillPane,
-      initialCursor,
       cursorRef
     },
     selectedSession
@@ -1075,11 +1084,10 @@ var SessionOverviewPanel = ({
   isFocused,
   availableRows,
   onBack,
-  initialCursor,
   cursorRef
 }) => {
   const { exit } = useApp3();
-  const [cursor, setCursor] = useState3(initialCursor ?? 0);
+  const [cursor, setCursor] = useState3(cursorRef?.current ?? 0);
   const lines = useMemo5(() => {
     const summaryLines = overallSummary ? [
       { key: "summary", type: "summary", text: overallSummary },
@@ -1390,10 +1398,53 @@ var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
   ] });
 };
 
+// src/components/PromptInputView.tsx
+import { Box as Box11, Text as Text11, useInput as useInput7 } from "ink";
+import { useState as useState7 } from "react";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var PromptInputView = ({ selectedDir, onSubmit, onCancel }) => {
+  const { rows } = useTerminalSize();
+  const [value, setValue] = useState7("");
+  useInput7((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      const trimmed = value.trim();
+      if (trimmed) onSubmit(trimmed);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setValue((prev) => prev.slice(0, -1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setValue((prev) => prev + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} \u2014 ${selectedDir}` }),
+    /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { bold: true, children: "New prompt:" }) }),
+    /* @__PURE__ */ jsxs9(Box11, { paddingLeft: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs9(Text11, { color: "green", children: [
+        ">",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { children: value }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: value ? "" : "type your prompt..." })
+    ] }),
+    /* @__PURE__ */ jsxs9(Box11, { gap: 2, children: [
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Enter submit" }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Esc cancel" })
+    ] })
+  ] });
+};
+
 // src/hooks/use-interval.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useEffect as useEffect2, useRef as useRef3 } from "react";
 var useInterval = (fn, intervalMs, enabled = true) => {
-  const fnRef = useRef2(fn);
+  const fnRef = useRef3(fn);
   fnRef.current = fn;
   useEffect2(() => {
     if (!enabled) return;
@@ -1416,13 +1467,7 @@ var swallow = async (fn) => {
 };
 
 // src/components/ManagerView.tsx
-import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
-var MODE = {
-  split: "split",
-  confirm: "confirm",
-  deleteSession: "deleteSession",
-  addSession: "addSession"
-};
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var FOCUS = {
   left: "left",
   right: "right",
@@ -1430,95 +1475,91 @@ var FOCUS = {
 };
 var POLL_INTERVAL = 3e3;
 var OVERVIEW_POLL_INTERVAL = 6e4;
+var FIXED_ROWS = 3;
+var TOP_HEIGHT_RATIO = 1 / 2;
+var LEFT_WIDTH_RATIO = 1 / 3;
+var initState = (remountState) => {
+  const snapshot = remountState?.snapshot;
+  return {
+    view: remountState?.prompt ? { mode: "confirm", prompt: remountState.prompt, cwd: remountState.cwd ?? "" } : { mode: "split" },
+    focus: snapshot?.focus ?? FOCUS.left,
+    selectedSession: remountState?.session ?? snapshot?.selectedSession,
+    sessions: [],
+    sessionsLoading: true,
+    overviewResult: snapshot?.overviewResult
+  };
+};
 var ManagerView = ({
   actions,
   currentSession,
   directories,
-  restoredPrompt,
-  restoredSession,
-  restoredCwd,
-  snapshotRef,
-  restoredState
+  remountState,
+  snapshotRef
 }) => {
   const { rows, columns } = useTerminalSize();
-  const [sessionsState, setSessionsState] = useState7({
-    sessions: [],
-    isLoading: true
+  const [state, setState] = useState8(() => initState(remountState));
+  const overviewInFlightRef = useRef4(false);
+  const snapshot = remountState?.snapshot;
+  const cursorsRef = useRef4({
+    session: { current: snapshot?.sessionListCursor ?? 0 },
+    pane: { current: snapshot?.paneListCursor ?? 0 },
+    overview: { current: snapshot?.overviewCursor ?? 0 }
   });
-  const [mode, setMode] = useState7(restoredPrompt ? MODE.confirm : MODE.split);
-  const [focus, setFocus] = useState7(restoredState?.focus ?? FOCUS.left);
-  const [selectedSession, setSelectedSession] = useState7(
-    restoredSession ?? restoredState?.selectedSession
-  );
-  const [pendingPrompt, setPendingPrompt] = useState7(restoredPrompt ?? "");
-  const [pendingDeleteSession, setPendingDeleteSession] = useState7(void 0);
-  const [overviewResult, setOverviewResult] = useState7(
-    restoredState?.overviewResult ?? { overallSummary: "", sessions: [] }
-  );
-  const [overviewLoading, setOverviewLoading] = useState7(
-    restoredState?.overviewResult ? false : true
-  );
-  const overviewInFlightRef = useRef3(false);
-  const sessionCursorRef = useRef3(restoredState?.sessionListCursor ?? 0);
-  const paneCursorRef = useRef3(restoredState?.paneListCursor ?? 0);
-  const overviewCursorRef = useRef3(restoredState?.overviewCursor ?? 0);
-  const paneRestoredRef = useRef3(false);
+  const patch = useCallback5((partial) => {
+    setState((prev) => ({ ...prev, ...partial }));
+  }, []);
   const refresh = useCallback5(async () => {
     try {
       const fetched = await actions.fetchSessions();
-      setSessionsState((prev) => {
+      setState((prev) => {
         const fetchedNames = new Set(fetched.map((s) => s.name));
         const userOnly = prev.sessions.filter(
           (s) => !fetchedNames.has(s.name) && s.groups.length === 0
         );
-        return { sessions: [...userOnly, ...fetched], isLoading: false };
+        return { ...prev, sessions: [...userOnly, ...fetched], sessionsLoading: false };
       });
     } catch {
-      setSessionsState((prev) => ({ ...prev, isLoading: false }));
+      patch({ sessionsLoading: false });
     }
-  }, [actions]);
+  }, [actions, patch]);
   useInterval(() => void refresh(), POLL_INTERVAL);
   useInterval(
     () => {
       if (overviewInFlightRef.current) return;
       overviewInFlightRef.current = true;
-      void actions.fetchOverview(sessionsState.sessions).then((result) => {
-        setOverviewResult(result);
+      void actions.fetchOverview(state.sessions).then((result) => {
+        patch({ overviewResult: result });
       }).catch(() => {
       }).finally(() => {
-        setOverviewLoading(false);
         overviewInFlightRef.current = false;
       });
     },
     OVERVIEW_POLL_INTERVAL,
-    !sessionsState.isLoading
+    !state.sessionsLoading
   );
-  useInput7(
+  useInput8(
     (_input, key) => {
       if (key.tab) {
-        setFocus((prev) => {
-          if (prev === FOCUS.left) return FOCUS.right;
-          if (prev === FOCUS.right) return FOCUS.bottom;
-          return FOCUS.left;
+        setState((prev) => {
+          const next = prev.focus === FOCUS.left ? FOCUS.right : prev.focus === FOCUS.right ? FOCUS.bottom : FOCUS.left;
+          return { ...prev, focus: next };
         });
       }
     },
-    { isActive: mode === MODE.split }
+    { isActive: state.view.mode === "split" }
   );
-  const resolvedSession = selectedSession ?? sessionsState.sessions[0]?.name;
-  const paneInitialCursor = !paneRestoredRef.current && restoredState?.selectedSession === resolvedSession ? restoredState?.paneListCursor : void 0;
-  if (paneInitialCursor !== void 0) paneRestoredRef.current = true;
+  const resolvedSession = state.selectedSession ?? state.sessions[0]?.name;
   snapshotRef.current = {
-    focus,
+    focus: state.focus,
     selectedSession: resolvedSession,
-    sessionListCursor: sessionCursorRef.current,
-    paneListCursor: paneCursorRef.current,
-    overviewCursor: overviewCursorRef.current,
-    overviewResult
+    sessionListCursor: cursorsRef.current.session.current,
+    paneListCursor: cursorsRef.current.pane.current,
+    overviewCursor: cursorsRef.current.overview.current,
+    overviewResult: state.overviewResult ?? { overallSummary: "", sessions: [] }
   };
   const selectedManagedSession = useMemo7(
-    () => sessionsState.sessions.find((s) => s.name === resolvedSession),
-    [sessionsState.sessions, resolvedSession]
+    () => state.sessions.find((s) => s.name === resolvedSession),
+    [state.sessions, resolvedSession]
   );
   const selectedGroup = useMemo7(() => {
     if (!selectedManagedSession) return void 0;
@@ -1527,10 +1568,7 @@ var ManagerView = ({
       tabs: selectedManagedSession.groups.flatMap((g) => g.tabs)
     };
   }, [selectedManagedSession]);
-  const allGroups = useMemo7(
-    () => sessionsState.sessions.flatMap((s) => s.groups),
-    [sessionsState.sessions]
-  );
+  const allGroups = useMemo7(() => state.sessions.flatMap((s) => s.groups), [state.sessions]);
   const statusCounts = useMemo7(
     () => allGroups.flatMap((g) => g.tabs).flatMap((t) => t.panes).filter((p) => p.kind === "claude" && p.claudeStatus).reduce((acc, p) => {
       const s = p.claudeStatus;
@@ -1541,52 +1579,53 @@ var ManagerView = ({
     [allGroups]
   );
   const handleOpenAddSession = useCallback5(() => {
-    setMode(MODE.addSession);
-  }, []);
+    patch({ view: { mode: "addSession" } });
+  }, [patch]);
   const handleAddSessionSelect = useCallback5((path) => {
     const name = basename2(path);
-    setSessionsState((prev) => {
+    setState((prev) => {
       const exists2 = prev.sessions.some((s) => s.name === name);
-      if (exists2) return prev;
       return {
         ...prev,
-        sessions: [{ name, path, groups: [] }, ...prev.sessions]
+        view: { mode: "split" },
+        selectedSession: name,
+        sessions: exists2 ? prev.sessions : [{ name, path, groups: [] }, ...prev.sessions]
       };
     });
-    setSelectedSession(name);
-    setMode(MODE.split);
   }, []);
   const handleCancelAddSession = useCallback5(() => {
-    setMode(MODE.split);
-  }, []);
-  const handleDeleteSession = useCallback5((name) => {
-    setPendingDeleteSession(name);
-    setMode(MODE.deleteSession);
-  }, []);
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleDeleteSession = useCallback5(
+    (name) => {
+      patch({ view: { mode: "deleteSession", sessionName: name } });
+    },
+    [patch]
+  );
   const handleConfirmDelete = useCallback5(() => {
-    if (!pendingDeleteSession) return;
-    const session = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
-    setSessionsState((prev) => ({
+    if (state.view.mode !== "deleteSession") return;
+    const { sessionName } = state.view;
+    const session = state.sessions.find((s) => s.name === sessionName);
+    setState((prev) => ({
       ...prev,
-      sessions: prev.sessions.filter((s) => s.name !== pendingDeleteSession)
+      view: { mode: "split" },
+      sessions: prev.sessions.filter((s) => s.name !== sessionName),
+      selectedSession: prev.selectedSession === sessionName ? void 0 : prev.selectedSession
     }));
-    if (resolvedSession === pendingDeleteSession) {
-      setSelectedSession(void 0);
-    }
     if (session) {
       const killAll = Promise.all(
         session.groups.map((g) => swallow(() => actions.killSession(g.sessionName)))
       );
       void killAll.then(() => void refresh());
     }
-    setPendingDeleteSession(void 0);
-    setMode(MODE.split);
-  }, [pendingDeleteSession, resolvedSession, sessionsState.sessions, actions, refresh]);
+  }, [state.view, state.sessions, actions, refresh]);
   const handleCancelDelete = useCallback5(() => {
-    setPendingDeleteSession(void 0);
-    setMode(MODE.split);
-  }, []);
-  const handleNewSession = useCallback5(
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleNewSession = useCallback5(() => {
+    patch({ view: { mode: "promptInput" } });
+  }, [patch]);
+  const handleOpenEditor = useCallback5(
     (sessionName) => {
       const cwd = selectedManagedSession?.path;
       if (!cwd) return;
@@ -1594,28 +1633,41 @@ var ManagerView = ({
     },
     [actions, selectedManagedSession]
   );
+  const handlePromptInputSubmit = useCallback5(
+    (prompt) => {
+      const cwd = selectedManagedSession?.path;
+      if (!cwd) return;
+      patch({ view: { mode: "confirm", prompt, cwd } });
+    },
+    [patch, selectedManagedSession]
+  );
+  const handlePromptInputCancel = useCallback5(() => {
+    patch({ view: { mode: "split" } });
+  }, [patch]);
   const handleConfirmNew = useCallback5(
     ({ worktree }) => {
+      if (state.view.mode !== "confirm") return;
       if (!resolvedSession) return;
-      const cwd = restoredCwd ?? selectedManagedSession?.path;
-      if (!cwd) return;
-      void actions.createSession(resolvedSession, cwd, pendingPrompt, worktree).then(() => void refresh());
-      setPendingPrompt("");
-      setMode(MODE.split);
+      void actions.createSession(resolvedSession, state.view.cwd, state.view.prompt, worktree).then(() => void refresh());
+      patch({ view: { mode: "split" } });
     },
-    [resolvedSession, restoredCwd, selectedManagedSession, pendingPrompt, actions, refresh]
+    [state.view, resolvedSession, actions, refresh, patch]
   );
   const handleCancelConfirm = useCallback5(() => {
-    setPendingPrompt("");
-    setMode(MODE.split);
-  }, []);
-  const handleSessionSelect = useCallback5((name) => {
-    setSelectedSession(name);
-    setFocus(FOCUS.right);
-  }, []);
-  const handleSessionCursorChange = useCallback5((name) => {
-    setSelectedSession(name);
-  }, []);
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleSessionSelect = useCallback5(
+    (name) => {
+      patch({ selectedSession: name, focus: FOCUS.right });
+    },
+    [patch]
+  );
+  const handleSessionCursorChange = useCallback5(
+    (name) => {
+      patch({ selectedSession: name });
+    },
+    [patch]
+  );
   const handleNavigate = useCallback5(
     (up) => {
       void actions.navigateToPane(up);
@@ -1623,8 +1675,8 @@ var ManagerView = ({
     [actions]
   );
   const handleBack = useCallback5(() => {
-    setFocus(FOCUS.left);
-  }, []);
+    patch({ focus: FOCUS.left });
+  }, [patch]);
   const handleKillPane = useCallback5(
     async (paneId) => {
       await swallow(() => actions.killPane(paneId));
@@ -1644,14 +1696,14 @@ var ManagerView = ({
     },
     [actions]
   );
-  if (sessionsState.isLoading) {
-    return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
-      /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
-      /* @__PURE__ */ jsx11(StatusBar, { message: "Loading...", type: "info" })
+  if (state.sessionsLoading) {
+    return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsx12(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
+      /* @__PURE__ */ jsx12(StatusBar, { message: "Loading...", type: "info" })
     ] });
   }
-  if (mode === MODE.addSession) {
-    return /* @__PURE__ */ jsx11(
+  if (state.view.mode === "addSession") {
+    return /* @__PURE__ */ jsx12(
       DirectorySearchView,
       {
         directories,
@@ -1660,111 +1712,119 @@ var ManagerView = ({
       }
     );
   }
-  if (mode === MODE.deleteSession && pendingDeleteSession) {
-    const deleteSession = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
+  if (state.view.mode === "deleteSession") {
+    const { sessionName } = state.view;
+    const deleteSession = state.sessions.find((s) => s.name === sessionName);
     const paneCount = deleteSession?.groups.reduce(
       (sum, g) => sum + g.tabs.reduce((s, t) => s + t.panes.length, 0),
       0
     ) ?? 0;
-    return /* @__PURE__ */ jsx11(
+    return /* @__PURE__ */ jsx12(
       DeleteSessionView,
       {
-        sessionName: pendingDeleteSession,
+        sessionName,
         paneCount,
         onConfirm: handleConfirmDelete,
         onCancel: handleCancelDelete
       }
     );
   }
-  if (mode === MODE.confirm && pendingPrompt) {
-    return /* @__PURE__ */ jsx11(
+  if (state.view.mode === "promptInput") {
+    return /* @__PURE__ */ jsx12(
+      PromptInputView,
+      {
+        selectedDir: resolvedSession ?? "",
+        onSubmit: handlePromptInputSubmit,
+        onCancel: handlePromptInputCancel
+      }
+    );
+  }
+  if (state.view.mode === "confirm") {
+    return /* @__PURE__ */ jsx12(
       ConfirmView,
       {
         selectedDir: resolvedSession ?? "",
-        prompt: pendingPrompt,
+        prompt: state.view.prompt,
         onConfirm: handleConfirmNew,
         onCancel: handleCancelConfirm
       }
     );
   }
-  const fixedRows = 3;
-  const contentHeight = rows - fixedRows;
-  const topHeight = Math.floor(contentHeight / 2);
+  const contentHeight = rows - FIXED_ROWS;
+  const topHeight = Math.floor(contentHeight * TOP_HEIGHT_RATIO);
   const bottomHeight = contentHeight - topHeight;
-  const leftWidth = Math.floor(columns / 3);
+  const leftWidth = Math.floor(columns * LEFT_WIDTH_RATIO);
   const rightWidth = columns - leftWidth;
-  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
-    /* @__PURE__ */ jsxs9(Box11, { flexDirection: "row", height: topHeight, children: [
-      /* @__PURE__ */ jsx11(
-        Box11,
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx12(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
+    /* @__PURE__ */ jsxs10(Box12, { flexDirection: "row", height: topHeight, children: [
+      /* @__PURE__ */ jsx12(
+        Box12,
         {
           flexDirection: "column",
           width: leftWidth,
           borderStyle: "round",
-          borderColor: focus === FOCUS.left ? "green" : "gray",
-          children: /* @__PURE__ */ jsx11(
+          borderColor: state.focus === FOCUS.left ? "green" : "gray",
+          children: /* @__PURE__ */ jsx12(
             SessionListPanel,
             {
-              sessions: sessionsState.sessions,
+              sessions: state.sessions,
               currentSession,
-              isFocused: focus === FOCUS.left,
+              isFocused: state.focus === FOCUS.left,
               availableRows: topHeight - 2,
               onSelect: handleSessionSelect,
               onCursorChange: handleSessionCursorChange,
               onDeleteSession: handleDeleteSession,
               onAddSession: handleOpenAddSession,
-              initialCursor: restoredState?.sessionListCursor,
-              cursorRef: sessionCursorRef
+              cursorRef: cursorsRef.current.session
             }
           )
         }
       ),
-      /* @__PURE__ */ jsx11(
-        Box11,
+      /* @__PURE__ */ jsx12(
+        Box12,
         {
           flexDirection: "column",
           width: rightWidth,
           borderStyle: "round",
-          borderColor: focus === FOCUS.right ? "green" : "gray",
-          children: /* @__PURE__ */ jsx11(
+          borderColor: state.focus === FOCUS.right ? "green" : "gray",
+          children: /* @__PURE__ */ jsx12(
             PaneListPanel,
             {
               selectedSession: resolvedSession,
               group: selectedGroup,
-              isFocused: focus === FOCUS.right,
+              isFocused: state.focus === FOCUS.right,
               availableRows: topHeight - 2,
               onNavigate: handleNavigate,
               onHighlight: handleHighlight,
               onUnhighlight: handleUnhighlight,
               onBack: handleBack,
               onNewSession: handleNewSession,
+              onOpenEditor: handleOpenEditor,
               onKillPane: handleKillPane,
-              initialCursor: paneInitialCursor,
-              cursorRef: paneCursorRef
+              cursorRef: cursorsRef.current.pane
             }
           )
         }
       )
     ] }),
-    /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(
       SessionOverviewPanel,
       {
-        overallSummary: overviewResult.overallSummary,
-        items: overviewResult.sessions,
+        overallSummary: state.overviewResult?.overallSummary ?? "",
+        items: state.overviewResult?.sessions ?? [],
         groups: allGroups,
-        isLoading: overviewLoading,
-        isFocused: focus === FOCUS.bottom,
+        isLoading: !state.overviewResult,
+        isFocused: state.focus === FOCUS.bottom,
         availableRows: bottomHeight,
         onBack: handleBack,
-        initialCursor: restoredState?.overviewCursor,
-        cursorRef: overviewCursorRef
+        cursorRef: cursorsRef.current.overview
       }
     ),
-    /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(
       StatusBar,
       {
-        message: focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  Tab next  n add  d delete  q quit" : focus === FOCUS.right ? "\u2191/\u2193 move  Enter focus  Tab next  n new  d kill  Esc/\u2190 back  q quit" : "\u2191/\u2193 scroll  Tab next  Esc/\u2190 back  q quit",
+        message: state.focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  Tab next  n add  d delete  q quit" : state.focus === FOCUS.right ? "\u2191/\u2193 move  Enter focus  Tab next  n new  v vim  d kill  Esc/\u2190 back  q quit" : "\u2191/\u2193 scroll  Tab next  Esc/\u2190 back  q quit",
         statusCounts
       }
     )
@@ -1775,11 +1835,8 @@ var ManagerView = ({
 var createTuiCommand = ({ usecases, services, infra }) => async () => {
   const directories = await services.directoryScan.scan();
   let instance;
-  let pendingPrompt;
-  let pendingSession;
-  let pendingCwd;
   const snapshotRef = { current: void 0 };
-  let restoredState;
+  let remountState;
   const actions = {
     fetchSessions: async () => {
       const result = await usecases.manager.list();
@@ -1829,12 +1886,10 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
       await usecases.manager.unhighlightWindow(up);
     },
     openEditor: (sessionName, cwd) => {
-      restoredState = snapshotRef.current;
+      const snapshot = snapshotRef.current;
       instance.unmount();
       const prompt = infra.editor.open();
-      pendingPrompt = prompt;
-      pendingSession = sessionName;
-      pendingCwd = cwd;
+      remountState = { prompt, session: sessionName, cwd, snapshot };
       instance = renderApp();
       return prompt;
     },
@@ -1842,21 +1897,16 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
       const target = `${up.pane.sessionName}:${String(up.pane.windowIndex)}`;
       await infra.tmuxCli.selectWindow(target);
       await infra.tmuxCli.selectPane(up.pane.paneId);
-      restoredState = snapshotRef.current;
+      const snapshot = snapshotRef.current;
       instance.unmount();
       await infra.tmuxCli.attachSession(up.pane.sessionName);
+      remountState = { snapshot };
       instance = renderApp();
     }
   };
   const renderApp = () => {
-    const prompt = pendingPrompt;
-    const session = pendingSession;
-    const cwd = pendingCwd;
-    const snapshot = restoredState;
-    pendingPrompt = void 0;
-    pendingSession = void 0;
-    pendingCwd = void 0;
-    restoredState = void 0;
+    const state = remountState;
+    remountState = void 0;
     snapshotRef.current = void 0;
     const rawCwd = process.cwd();
     const currentSession = basename3(findMatchingDirectory(rawCwd, directories) ?? rawCwd);
@@ -1865,11 +1915,8 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
         actions,
         currentSession,
         directories,
-        restoredPrompt: prompt,
-        restoredSession: session,
-        restoredCwd: cwd,
-        snapshotRef,
-        restoredState: snapshot
+        remountState: state,
+        snapshotRef
       }),
       { concurrent: true }
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmux",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/cut0/abmux.git"