abmux 0.0.3 → 0.0.5

package/dist/cli/index.js

@@ -228,13 +228,6 @@ var detectStatusFromText = (paneText) => {
   }
   return SESSION_STATUS.idle;
 };
-var formatCwd = (cwd) => {
-  const home = process.env["HOME"] ?? "";
-  if (home && cwd.startsWith(home)) {
-    return `~${cwd.slice(home.length)}`;
-  }
-  return cwd;
-};
 var toUnifiedPane = (pane) => {
   const kind = classifyPane(pane);
   if (kind === PANE_KIND.claude) {
@@ -250,66 +243,44 @@ var toUnifiedPane = (pane) => {
 var createSessionDetectionService = () => ({
   groupBySession: ({ panes }) => {
     const windowKey = (pane) => `${pane.sessionName}:${String(pane.windowIndex)}`;
-    const windowMap = /* @__PURE__ */ new Map();
-    for (const pane of panes) {
-      const key = windowKey(pane);
-      const unified = toUnifiedPane(pane);
-      const existing = windowMap.get(key);
-      if (existing) {
-        existing.panes = [...existing.panes, unified];
-        if (pane.isActive) {
-          existing.activePaneTitle = pane.title;
-        }
-      } else {
-        windowMap.set(key, {
-          sessionName: pane.sessionName,
-          windowIndex: pane.windowIndex,
-          cwd: formatCwd(pane.cwd),
-          windowName: pane.windowName,
-          activePaneTitle: pane.isActive ? pane.title : "",
-          panes: [unified]
-        });
+    const panesByWindow = Map.groupBy(panes, windowKey);
+    const sortPanes = (items) => items.toSorted((a, b) => {
+      const kindOrder = { claude: 0, available: 1, busy: 2 };
+      const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
+      if (kindDiff !== 0) return kindDiff;
+      if (a.kind === "claude" && b.kind === "claude") {
+        const statusOrder = {
+          "waiting-confirm": 0,
+          "waiting-input": 1,
+          thinking: 2,
+          "tool-running": 3,
+          idle: 4
+        };
+        const sa = statusOrder[a.claudeStatus ?? "idle"] ?? 4;
+        const sb = statusOrder[b.claudeStatus ?? "idle"] ?? 4;
+        if (sa !== sb) return sa - sb;
       }
-    }
-    const windowGroups = [...windowMap.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([, group]) => ({
-      windowIndex: group.windowIndex,
-      windowName: group.windowName || group.activePaneTitle || `Window ${String(group.windowIndex)}`,
-      sessionName: group.sessionName,
-      panes: group.panes.toSorted((a, b) => {
-        const kindOrder = { claude: 0, available: 1, busy: 2 };
-        const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
-        if (kindDiff !== 0) return kindDiff;
-        if (a.kind === "claude" && b.kind === "claude") {
-          const statusOrder = {
-            "waiting-confirm": 0,
-            "waiting-input": 1,
-            thinking: 2,
-            "tool-running": 3,
-            idle: 4
-          };
-          const sa = statusOrder[a.claudeStatus ?? "idle"] ?? 4;
-          const sb = statusOrder[b.claudeStatus ?? "idle"] ?? 4;
-          if (sa !== sb) return sa - sb;
-        }
-        return a.pane.paneIndex - b.pane.paneIndex;
-      })
+      return a.pane.paneIndex - b.pane.paneIndex;
+    });
+    const windowGroups = [...panesByWindow.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([, group]) => {
+      const first = group[0];
+      const activePaneTitle = group.find((p) => p.isActive)?.title ?? "";
+      return {
+        windowIndex: first.windowIndex,
+        windowName: first.windowName || activePaneTitle || `Window ${String(first.windowIndex)}`,
+        sessionName: first.sessionName,
+        panes: sortPanes(group.map(toUnifiedPane))
+      };
+    });
+    const sessionGroups = Map.groupBy(windowGroups, (win) => win.sessionName);
+    return [...sessionGroups.entries()].map(([sessionName, wins]) => ({
+      sessionName,
+      tabs: wins.map(({ windowIndex, windowName, panes: p }) => ({
+        windowIndex,
+        windowName,
+        panes: p
+      }))
     }));
-    const sessionMap = /* @__PURE__ */ new Map();
-    for (const win of windowGroups) {
-      const existing = sessionMap.get(win.sessionName);
-      if (existing) {
-        existing.push({
-          windowIndex: win.windowIndex,
-          windowName: win.windowName,
-          panes: win.panes
-        });
-      } else {
-        sessionMap.set(win.sessionName, [
-          { windowIndex: win.windowIndex, windowName: win.windowName, panes: win.panes }
-        ]);
-      }
-    }
-    return [...sessionMap.entries()].map(([sessionName, tabs]) => ({ sessionName, tabs }));
   },
   detectStatusFromText
 });
@@ -394,24 +365,15 @@ var findProjects = async (dir, depth) => {
     const dirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP_DIRS.has(e.name)
     );
-    const results = [];
-    const childScans = [];
-    for (const entry of dirs) {
+    const childScans = dirs.map((entry) => {
       const fullPath = join2(dir, entry.name);
-      childScans.push(
-        exists(join2(fullPath, ".git")).then(async (isProject) => {
-          if (isProject) return [fullPath];
-          return await findProjects(fullPath, depth + 1);
-        })
-      );
-    }
+      return exists(join2(fullPath, ".git")).then(async (isProject) => {
+        if (isProject) return [fullPath];
+        return await findProjects(fullPath, depth + 1);
+      });
+    });
     const nested = await Promise.all(childScans);
-    for (const paths of nested) {
-      for (const p of paths) {
-        results.push(p);
-      }
-    }
-    return results;
+    return nested.flat();
   } catch {
     return [];
   }
@@ -505,7 +467,7 @@ var createUsecases = (context) => ({
 // package.json
 var package_default = {
   name: "abmux",
-  version: "0.0.3",
+  version: "0.0.5",
   repository: {
     type: "git",
     url: "https://github.com/cut0/abmux.git"
@@ -576,7 +538,7 @@ import { createElement } from "react";
 // src/components/ManagerView.tsx
 import { basename as basename2 } from "node:path";
 import { Box as Box10, Text as Text10 } from "ink";
-import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo5, useRef as useRef2, useState as useState5 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo5, useState as useState5 } from "react";
 
 // src/components/shared/Header.tsx
 import { Box, Text } from "ink";
@@ -616,15 +578,28 @@ var useScroll = (cursor, totalItems, availableRows) => {
   }, [cursor, totalItems, availableRows]);
 };
 
+// src/utils/PathUtils.ts
+var formatCwd = (cwd) => {
+  const home = process.env["HOME"] ?? "";
+  if (home && cwd.startsWith(home)) {
+    return `~${cwd.slice(home.length)}`;
+  }
+  return cwd;
+};
+var findMatchingDirectory = (path, directories) => directories.filter((dir) => path === dir || path.startsWith(dir + "/")).reduce(
+  (best, dir) => !best || dir.length > best.length ? dir : best,
+  void 0
+);
+
 // src/components/shared/DirectorySelect.tsx
 import { jsx as jsx3, jsxs } from "react/jsx-runtime";
-var sortSessionGroups = (groups, currentSession) => {
-  const current = groups.filter((g) => g.sessionName === currentSession);
-  const rest = groups.filter((g) => g.sessionName !== currentSession);
+var sortSessions = (sessions, currentSession) => {
+  const current = sessions.filter((s) => s.name === currentSession);
+  const rest = sessions.filter((s) => s.name !== currentSession);
   return [...current, ...rest];
 };
 var SessionListPanel = ({
-  sessionGroups,
+  sessions,
   currentSession,
   isFocused,
   availableRows,
@@ -635,30 +610,30 @@ var SessionListPanel = ({
 }) => {
   const { exit } = useApp();
   const [cursor, setCursor] = useState(0);
-  const sortedGroups = useMemo2(
-    () => sortSessionGroups(sessionGroups, currentSession),
-    [sessionGroups, currentSession]
+  const sortedSessions = useMemo2(
+    () => sortSessions(sessions, currentSession),
+    [sessions, currentSession]
   );
-  const sessions = useMemo2(() => sortedGroups.map((g) => g.sessionName), [sortedGroups]);
-  const clampedCursor = cursor >= sessions.length ? Math.max(0, sessions.length - 1) : cursor;
+  const names = useMemo2(() => sortedSessions.map((s) => s.name), [sortedSessions]);
+  const clampedCursor = cursor >= names.length ? Math.max(0, names.length - 1) : cursor;
   if (clampedCursor !== cursor) {
     setCursor(clampedCursor);
   }
   const reservedLines = 1;
   const { scrollOffset, visibleCount } = useScroll(
     clampedCursor,
-    sessions.length,
+    names.length,
     availableRows - reservedLines
   );
-  const visibleSessions = sessions.slice(scrollOffset, scrollOffset + visibleCount);
+  const visibleSessions = sortedSessions.slice(scrollOffset, scrollOffset + visibleCount);
   const moveCursor = useCallback(
     (next) => {
-      const clamped = Math.max(0, Math.min(sessions.length - 1, next));
+      const clamped = Math.max(0, Math.min(names.length - 1, next));
       setCursor(clamped);
-      const name = sessions[clamped];
+      const name = names[clamped];
       if (name) onCursorChange(name);
     },
-    [sessions, onCursorChange]
+    [names, onCursorChange]
   );
   useInput(
     (input, key) => {
@@ -675,12 +650,12 @@ var SessionListPanel = ({
         return;
       }
       if (key.return || key.rightArrow) {
-        const name = sessions[clampedCursor];
+        const name = names[clampedCursor];
         if (name) onSelect(name);
         return;
       }
       if (input === "d" && onDeleteSession) {
-        const name = sessions[clampedCursor];
+        const name = names[clampedCursor];
         if (name) onDeleteSession(name);
         return;
       }
@@ -698,19 +673,19 @@ var SessionListPanel = ({
         "(",
         clampedCursor + 1,
         "/",
-        sessions.length,
+        names.length,
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleSessions.map((name, i) => {
+    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleSessions.map((session, i) => {
       const globalIndex = scrollOffset + i;
       const isHighlighted = globalIndex === clampedCursor;
-      const isCurrent = name === currentSession;
+      const isCurrent = session.name === currentSession;
       return /* @__PURE__ */ jsxs(Box3, { paddingLeft: 1, gap: 1, children: [
         /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
-        /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : "cyan", bold: isHighlighted, wrap: "truncate", children: name }),
+        /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : "cyan", bold: isHighlighted, wrap: "truncate", children: session.path ? formatCwd(session.path) : session.name }),
         isCurrent && /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "(cwd)" })
-      ] }, name);
+      ] }, session.name);
     }) })
   ] });
 };
@@ -1118,32 +1093,33 @@ var POLL_INTERVAL = 3e3;
 var ManagerView = ({
   actions,
   currentSession,
-  currentCwd,
   directories,
   restoredPrompt,
-  restoredSession
+  restoredSession,
+  restoredCwd
 }) => {
   const { rows, columns } = useTerminalSize();
-  const [fetchState, setFetchState] = useState5({ data: [], isLoading: true });
+  const [sessionsState, setSessionsState] = useState5({
+    sessions: [],
+    isLoading: true
+  });
   const [mode, setMode] = useState5(restoredPrompt ? MODE.confirm : MODE.split);
   const [focus, setFocus] = useState5(FOCUS.left);
   const [selectedSession, setSelectedSession] = useState5(restoredSession);
   const [pendingPrompt, setPendingPrompt] = useState5(restoredPrompt ?? "");
   const [pendingDeleteSession, setPendingDeleteSession] = useState5(void 0);
-  const sessionCwdMap = useRef2(/* @__PURE__ */ new Map());
   const refresh = useCallback3(async () => {
     try {
-      const groups = await actions.fetchSessions();
-      const knownNames = new Set(groups.map((g) => g.sessionName));
-      const missing = [];
-      for (const name of sessionCwdMap.current.keys()) {
-        if (!knownNames.has(name)) {
-          missing.push({ sessionName: name, tabs: [] });
-        }
-      }
-      setFetchState({ data: [...missing, ...groups], isLoading: false });
+      const fetched = await actions.fetchSessions();
+      setSessionsState((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 };
+      });
     } catch {
-      setFetchState((prev) => ({ ...prev, isLoading: false }));
+      setSessionsState((prev) => ({ ...prev, isLoading: false }));
     }
   }, [actions]);
   useEffect2(() => {
@@ -1155,30 +1131,34 @@ var ManagerView = ({
       clearInterval(timer);
     };
   }, [refresh]);
-  const resolvedSession = selectedSession ?? fetchState.data[0]?.sessionName;
-  const selectedGroup = useMemo5(
-    () => fetchState.data.find((g) => g.sessionName === resolvedSession),
-    [fetchState.data, resolvedSession]
+  const resolvedSession = selectedSession ?? sessionsState.sessions[0]?.name;
+  const selectedManagedSession = useMemo5(
+    () => sessionsState.sessions.find((s) => s.name === resolvedSession),
+    [sessionsState.sessions, resolvedSession]
   );
+  const selectedGroup = useMemo5(() => {
+    if (!selectedManagedSession) return void 0;
+    return {
+      sessionName: selectedManagedSession.name,
+      tabs: selectedManagedSession.groups.flatMap((g) => g.tabs)
+    };
+  }, [selectedManagedSession]);
   const handleOpenAddSession = useCallback3(() => {
     setMode(MODE.addSession);
   }, []);
-  const handleAddSessionSelect = useCallback3(
-    (path) => {
-      const name = basename2(path);
-      sessionCwdMap.current.set(name, path);
-      const exists2 = fetchState.data.some((g) => g.sessionName === name);
-      if (!exists2) {
-        setFetchState((prev) => ({
-          ...prev,
-          data: [{ sessionName: name, tabs: [] }, ...prev.data]
-        }));
-      }
-      setSelectedSession(name);
-      setMode(MODE.split);
-    },
-    [fetchState.data]
-  );
+  const handleAddSessionSelect = useCallback3((path) => {
+    const name = basename2(path);
+    setSessionsState((prev) => {
+      const exists2 = prev.sessions.some((s) => s.name === name);
+      if (exists2) return prev;
+      return {
+        ...prev,
+        sessions: [{ name, path, groups: [] }, ...prev.sessions]
+      };
+    });
+    setSelectedSession(name);
+    setMode(MODE.split);
+  }, []);
   const handleCancelAddSession = useCallback3(() => {
     setMode(MODE.split);
   }, []);
@@ -1188,31 +1168,43 @@ var ManagerView = ({
   }, []);
   const handleConfirmDelete = useCallback3(() => {
     if (!pendingDeleteSession) return;
-    sessionCwdMap.current.delete(pendingDeleteSession);
+    const session = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
+    setSessionsState((prev) => ({
+      ...prev,
+      sessions: prev.sessions.filter((s) => s.name !== pendingDeleteSession)
+    }));
     if (resolvedSession === pendingDeleteSession) {
       setSelectedSession(void 0);
     }
-    void swallow(() => actions.killSession(pendingDeleteSession)).then(() => void refresh());
+    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, actions, refresh]);
+  }, [pendingDeleteSession, resolvedSession, sessionsState.sessions, actions, refresh]);
   const handleCancelDelete = useCallback3(() => {
     setPendingDeleteSession(void 0);
     setMode(MODE.split);
   }, []);
   const handleNewSession = useCallback3(
     (sessionName) => {
-      actions.openEditor(sessionName);
+      const cwd = selectedManagedSession?.path;
+      if (!cwd) return;
+      actions.openEditor(sessionName, cwd);
     },
-    [actions]
+    [actions, selectedManagedSession]
   );
   const handleConfirmNew = useCallback3(() => {
     if (!resolvedSession) return;
-    const cwd = sessionCwdMap.current.get(resolvedSession) ?? currentCwd;
+    const cwd = restoredCwd ?? selectedManagedSession?.path;
+    if (!cwd) return;
     void actions.createSession(resolvedSession, cwd, pendingPrompt).then(() => void refresh());
     setPendingPrompt("");
     setMode(MODE.split);
-  }, [resolvedSession, currentCwd, pendingPrompt, actions, refresh]);
+  }, [resolvedSession, restoredCwd, selectedManagedSession, pendingPrompt, actions, refresh]);
   const handleCancelConfirm = useCallback3(() => {
     setPendingPrompt("");
     setMode(MODE.split);
@@ -1226,7 +1218,7 @@ var ManagerView = ({
   }, []);
   const handleNavigate = useCallback3(
     (up) => {
-      actions.attachSession(up.pane.sessionName);
+      void actions.navigateToPane(up);
     },
     [actions]
   );
@@ -1252,7 +1244,7 @@ var ManagerView = ({
     },
     [actions]
   );
-  if (fetchState.isLoading) {
+  if (sessionsState.isLoading) {
     return /* @__PURE__ */ jsxs7(Box10, { flexDirection: "column", height: rows, children: [
       /* @__PURE__ */ jsx10(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
       /* @__PURE__ */ jsx10(StatusBar, { message: "Loading...", type: "info" })
@@ -1269,8 +1261,11 @@ var ManagerView = ({
     );
   }
   if (mode === MODE.deleteSession && pendingDeleteSession) {
-    const deleteGroup = fetchState.data.find((g) => g.sessionName === pendingDeleteSession);
-    const paneCount = deleteGroup?.tabs.reduce((sum, t) => sum + t.panes.length, 0) ?? 0;
+    const deleteSession = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
+    const paneCount = deleteSession?.groups.reduce(
+      (sum, g) => sum + g.tabs.reduce((s, t) => s + t.panes.length, 0),
+      0
+    ) ?? 0;
     return /* @__PURE__ */ jsx10(
       DeleteSessionView,
       {
@@ -1308,7 +1303,7 @@ var ManagerView = ({
           children: /* @__PURE__ */ jsx10(
             SessionListPanel,
             {
-              sessionGroups: fetchState.data,
+              sessions: sessionsState.sessions,
               currentSession,
               isFocused: focus === FOCUS.left,
               availableRows: panelHeight,
@@ -1355,21 +1350,35 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
   let instance;
   let pendingPrompt;
   let pendingSession;
+  let pendingCwd;
   const actions = {
     fetchSessions: async () => {
       const result = await usecases.manager.list();
-      return await Promise.all(
-        result.sessionGroups.map(async (group) => ({
-          sessionName: group.sessionName,
-          tabs: await Promise.all(
-            group.tabs.map(async (tab) => ({
-              windowIndex: tab.windowIndex,
-              windowName: tab.windowName,
-              panes: await Promise.all(tab.panes.map((up) => usecases.manager.enrichStatus(up)))
-            }))
-          )
-        }))
+      const resolved = await Promise.all(
+        result.sessionGroups.map(async (group) => {
+          const enrichedGroup = {
+            sessionName: group.sessionName,
+            tabs: await Promise.all(
+              group.tabs.map(async (tab) => ({
+                windowIndex: tab.windowIndex,
+                windowName: tab.windowName,
+                panes: await Promise.all(
+                  tab.panes.map((up) => usecases.manager.enrichStatus(up))
+                )
+              }))
+            )
+          };
+          const paneCwd = group.tabs[0]?.panes[0]?.pane.cwd ?? "";
+          const path = findMatchingDirectory(paneCwd, directories) ?? paneCwd;
+          return { path, group: enrichedGroup };
+        })
       );
+      const grouped = Map.groupBy(resolved, (item) => item.path || item.group.sessionName);
+      return [...grouped.entries()].map(([key, items]) => ({
+        name: basename3(key) || items[0].group.sessionName,
+        path: items[0].path,
+        groups: items.map((item) => item.group)
+      }));
     },
     createSession: async (sessionName, cwd, prompt) => {
       await usecases.manager.createSession({ sessionName, cwd, prompt });
@@ -1386,33 +1395,41 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
     unhighlightWindow: async (up) => {
       await usecases.manager.unhighlightWindow(up);
     },
-    openEditor: (sessionName) => {
+    openEditor: (sessionName, cwd) => {
       instance.unmount();
       const prompt = infra.editor.open();
       pendingPrompt = prompt;
       pendingSession = sessionName;
+      pendingCwd = cwd;
       instance = renderApp();
       return prompt;
     },
-    attachSession: (sessionName) => {
+    navigateToPane: async (up) => {
+      const target = `${up.pane.sessionName}:${String(up.pane.windowIndex)}`;
+      await infra.tmuxCli.selectWindow(target);
+      await infra.tmuxCli.selectPane(up.pane.paneId);
       instance.unmount();
-      void infra.tmuxCli.attachSession(sessionName);
+      await infra.tmuxCli.attachSession(up.pane.sessionName);
       instance = renderApp();
     }
   };
   const renderApp = () => {
     const prompt = pendingPrompt;
     const session = pendingSession;
+    const cwd = pendingCwd;
     pendingPrompt = void 0;
     pendingSession = void 0;
+    pendingCwd = void 0;
+    const rawCwd = process.cwd();
+    const currentSession = basename3(findMatchingDirectory(rawCwd, directories) ?? rawCwd);
     return render(
       createElement(ManagerView, {
         actions,
-        currentSession: basename3(process.cwd()),
-        currentCwd: process.cwd(),
+        currentSession,
         directories,
         restoredPrompt: prompt,
-        restoredSession: session
+        restoredSession: session,
+        restoredCwd: cwd
       }),
       { concurrent: true }
     );
@@ -1470,10 +1487,11 @@ var createListCommand = ({ usecases }) => async () => {
     console.log("No sessions found.");
     return;
   }
-  for (const group of result.sessionGroups) {
+  const lines = result.sessionGroups.map((group) => {
     const paneCount = group.tabs.reduce((sum, t) => sum + t.panes.length, 0);
-    console.log(`${group.sessionName} (${String(paneCount)} panes)`);
-  }
+    return `${group.sessionName} (${String(paneCount)} panes)`;
+  });
+  console.log(lines.join("\n"));
 };
 
 // src/cli/index.ts

package/package.json

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