@crouton-kit/crouter 0.3.17 → 0.3.18

package/dist/core/spawn.js

@@ -13,15 +13,60 @@ export function isInTmux() {
 export function shellQuote(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
 }
-/** Count panes in the current tmux window (0 outside tmux / on error). */
-export function countPanesInCurrentWindow() {
-    const result = spawnSync('tmux', ['list-panes', '-F', '#{pane_id}'], {
-        encoding: 'utf8',
-    });
+/** Count panes in a tmux window (0 outside tmux / on error). With `targetPane`,
+ *  counts the window THAT pane lives in (the placement decision must reflect the
+ *  window the new pane will actually open into, not the caller's backstage one);
+ *  without it, the caller's current window. */
+export function countPanesInWindow(targetPane) {
+    const args = targetPane !== undefined && targetPane !== ''
+        ? ['list-panes', '-t', targetPane, '-F', '#{pane_id}']
+        : ['list-panes', '-F', '#{pane_id}'];
+    const result = spawnSync('tmux', args, { encoding: 'utf8' });
     if (result.status !== 0)
         return 0;
     return result.stdout.split('\n').filter((line) => line.trim() !== '').length;
 }
+/** Back-compat alias: panes in the caller's current window. */
+export function countPanesInCurrentWindow() {
+    return countPanesInWindow();
+}
+/** Does this tmux pane id still exist? `display-message` EXITS 0 with EMPTY
+ *  output on an unresolvable pane, so test for non-empty stdout, not just `.ok`.
+ *  False outside tmux / on error. */
+export function paneAlive(pane) {
+    if (!isInTmux() || !/^%\d+$/.test(pane))
+        return false;
+    const r = spawnSync('tmux', ['display-message', '-p', '-t', pane, '#{pane_id}'], {
+        encoding: 'utf8',
+    });
+    return r.status === 0 && r.stdout.trim() !== '';
+}
+/** The active pane of the user's attached tmux client — where they are looking
+ *  right now. `list-clients` first attached client, then its current pane. Used
+ *  to surface a human prompt in the user's view when nothing in the asking
+ *  node's graph is focused. null outside tmux / no client / on error. */
+export function attachedClientPane() {
+    if (!isInTmux())
+        return null;
+    const clients = spawnSync('tmux', ['list-clients', '-F', '#{client_name}'], {
+        encoding: 'utf8',
+    });
+    if (clients.status !== 0)
+        return null;
+    const name = clients.stdout
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => l !== '');
+    if (name === undefined)
+        return null;
+    const pane = spawnSync('tmux', ['display-message', '-p', '-c', name, '#{pane_id}'], {
+        encoding: 'utf8',
+    });
+    if (pane.status !== 0)
+        return null;
+    const id = pane.stdout.trim();
+    return id !== '' ? id : null;
+}
 /**
  * Schedule a kill-pane on the *current* tmux pane after `delaySeconds`, detached
  * so the caller can return normally before the pane dies. No-op outside tmux,
@@ -53,6 +98,8 @@ export function spawnAndDetach(opts) {
     const splitArgs = [];
     if (opts.placement === 'new-window') {
         splitArgs.push('new-window');
+        if (opts.detached === true)
+            splitArgs.push('-d'); // don't switch the client to it
         if (opts.targetPane !== undefined && opts.targetPane !== '') {
             // -a = insert after target window; -t <pane> resolves to that pane's window.
             splitArgs.push('-a', '-t', opts.targetPane);

package/dist/pi-extensions/canvas-nav.js

@@ -18,9 +18,15 @@
 // alt+c is a tmux display-menu (not a pi key), so prefix chords (m/e/1-9/custom)
 // are tmux menu items that route through `crtr canvas chord`.
 //
-// Two selection signals, both NO_COLOR-safe:
-//   SELF row = reverse video (ESC[7m), full width — an attribute, not a color.
-//   CURSOR   = ▸ + bold on the row. Status stays on the colored dot.
+// Selection / liveness signals:
+//   CURSOR (selected) = reverse-video bar (ESC[7m), full width — an attribute,
+//                       not a colour, so it reads under NO_COLOR. Plus a ▸ caret.
+//   ACTIVE (running)  = a coloured background bar (status 'active'); the dot
+//                       glyph still carries the signal where colour is stripped.
+//   SELF              = bold name — a quiet "you are here" marker.
+//
+// Folding is auto by default: a branch stays COLLAPSED unless its subtree holds
+// a running ('active') agent or self. h/l override that per-node and persist.
 //
 // ⚑K pending-asks is PER-NODE, inline on each waiting node's own row (manager,
 // reports, tree rows; self shows a trailing ⚑ line in BASE). ⤳M direct-children
@@ -45,10 +51,13 @@ let liveTimer;
  *  exactly one key tap exists (mirrors the liveTimer double-guard). */
 let liveUnsub;
 let view = 'base';
-/** Fold state — node ids whose children are hidden in GRAPH. Survives renders
- *  AND BASE↔GRAPH toggles. Keyed by id so a topology change never corrupts it;
- *  stale ids are harmless (ignored when absent). */
-const collapsed = new Set();
+/** Manual fold OVERRIDES in GRAPH, keyed by id (so a topology change can't
+ *  corrupt them; stale ids are ignored). They override the default policy —
+ *  collapsed UNLESS the subtree holds a running ('active') agent or self (see
+ *  computeDefaultExpanded). `h` collapses → userCollapsed; `l` expands →
+ *  userExpanded. Both survive renders AND BASE↔GRAPH toggles. */
+const userCollapsed = new Set();
+const userExpanded = new Set();
 /** GRAPH cursor (a node id, not an index — indices shift as topology changes). */
 let cursorId;
 /** GRAPH viewport scroll offset (row index of the top visible row). */
@@ -69,16 +78,19 @@ const PI_MAX_WIDGET_LINES = 10;
 const VIEWPORT_FALLBACK_ROWS = 30;
 // ---------------------------------------------------------------------------
 // ANSI styling. pi renders embedded escapes in widget lines and measures width
-// ANSI-aware, so raw escapes are safe and need no pi-tui dependency. Selection
-// uses theme-agnostic ATTRIBUTES (reverse / bold), never colour alone, so it
-// reads under NO_COLOR and on any background; status uses the standard 8 colors
-// on the dot only.
+// ANSI-aware, so raw escapes are safe and need no pi-tui dependency. The cursor
+// (selected row) uses a theme-agnostic ATTRIBUTE (reverse), so it reads under
+// NO_COLOR; the active-row tint is a background COLOUR, but the differing dot
+// glyph (●/○/✓/✗) keeps the running signal even where colour is stripped.
 // ---------------------------------------------------------------------------
 const ESC = '\x1b[';
 const RESET = `${ESC}0m`;
 const BOLD = `${ESC}1m`;
 const DIM = `${ESC}2m`;
 const REVERSE = `${ESC}7m`;
+/** Dark-green background bar marking a running ('active') node — distinct from
+ *  the cursor's reverse-video bar; chosen so default-fg text stays readable. */
+const BG_ACTIVE = `${ESC}48;5;22m`;
 const GREEN = `${ESC}32m`;
 const RED = `${ESC}31m`;
 const YELLOW = `${ESC}33m`;
@@ -137,15 +149,16 @@ function truncate(s, max = fillWidth()) {
 function fillWidth() {
     return Math.max(20, Math.min((process.stdout.columns ?? 80) - 2, 180));
 }
-/** Wrap `content` in a full-width reverse-video bar. REVERSE is re-asserted
- *  after every embedded RESET so a colored cell (the status dot) doesn't punch
- *  a hole in the bar; the visible width is padded out to `width`; the line
- *  closes with a real RESET. */
-function reverseFill(content, width) {
+/** Wrap `content` in a full-width background bar opened by `open` (REVERSE for
+ *  the cursor, BG_ACTIVE for a running node). `open` is re-asserted after every
+ *  embedded RESET so a coloured cell (the status dot) can't punch a hole in the
+ *  bar; the visible width is padded out to `width`; the line closes with a real
+ *  RESET so the style never bleeds into the editor below. */
+function fillBar(content, width, open) {
     const clipped = truncate(content, width);
-    const reasserted = clipped.replace(/\x1b\[0m/g, `${RESET}${REVERSE}`);
+    const reasserted = clipped.replace(/\x1b\[0m/g, `${RESET}${open}`);
     const pad = Math.max(0, width - visibleWidth(clipped));
-    return `${REVERSE}${reasserted}${' '.repeat(pad)}${RESET}`;
+    return `${open}${reasserted}${' '.repeat(pad)}${RESET}`;
 }
 function readTelemetry(nodeId) {
     try {
@@ -294,21 +307,48 @@ function statusRank(id) {
 function sortedChildIds(id) {
     return convoChildIds(id).sort((a, b) => statusRank(a) - statusRank(b));
 }
+/** Default fold policy: which nodes auto-EXPAND. A node expands only when one
+ *  of its child subtrees holds a running ('active') agent or self — so the path
+ *  to any live agent (and to you) is revealed while quiescent branches stay
+ *  folded. One bottom-up O(N) pass from the ancestry root; cycle-guarded. */
+function computeDefaultExpanded(root, self) {
+    const expand = new Set();
+    const seen = new Set();
+    // Returns whether subtree(id), INCLUDING id, holds an active node or self.
+    const visit = (id) => {
+        if (seen.has(id))
+            return id === self || getNode(id)?.status === 'active';
+        seen.add(id);
+        let childRevealing = false;
+        for (const c of convoChildIds(id))
+            if (visit(c))
+                childRevealing = true;
+        if (childRevealing)
+            expand.add(id); // a descendant is worth revealing → unfold id
+        return childRevealing || id === self || getNode(id)?.status === 'active';
+    };
+    visit(root);
+    return expand;
+}
 function buildGraphModel(self) {
     const rootId = climbRoot(self);
+    const defaultExpanded = computeDefaultExpanded(rootId, self);
+    // userExpanded / userCollapsed override the auto policy; absent → policy decides.
+    const isFolded = (id) => userExpanded.has(id) ? false : userCollapsed.has(id) ? true : !defaultExpanded.has(id);
     const rows = [];
     const visited = new Set();
     const walk = (id, prefix, isRoot, isLast) => {
         if (visited.has(id)) {
             const connector = isRoot ? '' : isLast ? '└─ ' : '├─ ';
-            rows.push({ id, hasKids: false, isSelf: id === self, branch: prefix + connector, cycle: true });
+            rows.push({ id, hasKids: false, isSelf: id === self, branch: prefix + connector, cycle: true, collapsed: false });
             return;
         }
         visited.add(id);
         const kids = sortedChildIds(id);
+        const folded = isFolded(id);
         const connector = isRoot ? '' : isLast ? '└─ ' : '├─ ';
-        rows.push({ id, hasKids: kids.length > 0, isSelf: id === self, branch: prefix + connector, cycle: false });
-        if (collapsed.has(id))
+        rows.push({ id, hasKids: kids.length > 0, isSelf: id === self, branch: prefix + connector, cycle: false, collapsed: folded });
+        if (folded)
             return; // folded — don't descend
         const childPrefix = isRoot ? '' : prefix + (isLast ? '   ' : '│  ');
         for (let i = 0; i < kids.length; i++)
@@ -317,22 +357,27 @@ function buildGraphModel(self) {
     walk(rootId, '', true, true);
     return rows;
 }
-/** Render one GRAPH row. SELF → reverse fill; CURSOR → ▸ + bold caret/name. */
+/** Render one GRAPH row. CURSOR (selected) → reverse-video bar; an ACTIVE
+ *  (running) node → a coloured background bar; SELF → bold name. The cursor
+ *  outranks the active tint when both land on the same row. */
 function renderGraphRow(r, isCursor) {
+    const wrap = (line, active) => isCursor ? fillBar(line, fillWidth(), REVERSE)
+        : active ? fillBar(line, fillWidth(), BG_ACTIVE)
+            : truncate(line);
     if (r.cycle) {
         const line = `${r.branch}  ${DIM}↺ ${shortId(r.id)}${RESET}`;
-        return r.isSelf ? reverseFill(line, fillWidth()) : truncate(line);
+        return wrap(line, false);
     }
     const node = getNode(r.id);
     const dot = coloredGlyph(node);
     const rawName = node !== null ? fullName(node) : shortId(r.id);
-    const name = isCursor ? `${BOLD}${rawName}${RESET}` : rawName;
+    const name = r.isSelf ? `${BOLD}${rawName}${RESET}` : rawName;
     const kind = `${DIM}${node?.kind ?? ''}${RESET}`;
     const tokens = `${DIM}${tokensCell(r.id)}${RESET}`;
     const caret = isCursor ? `${BOLD}▸${RESET} ` : '  ';
-    const fold = r.hasKids && collapsed.has(r.id) ? ` ${DIM}[+${childCount(r.id)}]${RESET}` : '';
+    const fold = r.hasKids && r.collapsed ? ` ${DIM}[+${childCount(r.id)}]${RESET}` : '';
     const line = `${r.branch}${caret}${dot} ${name} ${kind} ${tokens}${childBadge(node)}${fold}${askBadge(r.id)}`;
-    return r.isSelf ? reverseFill(line, fillWidth()) : truncate(line);
+    return wrap(line, node?.status === 'active');
 }
 /** Total lines the GRAPH widget may emit. pi hard-caps extension widgets at
  *  MAX_WIDGET_LINES — anything past that pi truncates itself, eating our own
@@ -677,8 +722,9 @@ export function registerCanvasNav(pi) {
             return { consume: true };
         }
         if (isPlain(data, 'h')) {
-            if (cur !== undefined && cur.hasKids && !collapsed.has(cur.id)) {
-                collapsed.add(cur.id);
+            if (cur !== undefined && cur.hasKids && !cur.collapsed) {
+                userCollapsed.add(cur.id);
+                userExpanded.delete(cur.id);
             }
             else {
                 const p = managerOf(cursorId ?? nodeId);
@@ -689,8 +735,9 @@ export function registerCanvasNav(pi) {
             return { consume: true };
         }
         if (isPlain(data, 'l')) {
-            if (cur !== undefined && collapsed.has(cur.id)) {
-                collapsed.delete(cur.id);
+            if (cur !== undefined && cur.collapsed && cur.hasKids) {
+                userExpanded.add(cur.id);
+                userCollapsed.delete(cur.id);
             }
             else if (cur !== undefined && cur.hasKids) {
                 const c = sortedChildIds(cur.id)[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/crouter",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "crtr — fast access to skills, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",