@north-light/crouter 0.3.163 → 0.3.165

package/dist/clients/attach/session/bindings.js

@@ -5,24 +5,18 @@
 // tmux installer binds from (`core/keybindings`), never from ad-hoc key
 // literals, so a user's rebind is honored by the viewer and tmux alike.
 import { matchesKey } from '@earendil-works/pi-tui';
-import { formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
+import { ATTACH_CONTROL_BINDINGS, formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export function matchesAttachBinding(bindings, id, data) {
     return matchesPiTuiInput(bindings, id, data, (input, gesture) => matchesKey(input, gesture));
 }
+export function dispatchAttachAction(id, actions) {
+    actions[id]();
+}
 export function dispatchAttachBinding(bindings, data, actions) {
-    for (const id of [
-        'crtr.attach.detach',
-        'crtr.attach.clear-or-detach',
-        'crtr.mode.cycle',
-        'crtr.attach.graph.toggle',
-        'crtr.attach.model-ladder.next',
-        'crtr.attach.model-ladder.previous',
-        'crtr.attach.command.inspect',
-        'crtr.attach.file-review',
-    ]) {
-        if (matchesAttachBinding(bindings, id, data)) {
-            actions[id]();
+    for (const { actionId } of ATTACH_CONTROL_BINDINGS) {
+        if (matchesAttachBinding(bindings, actionId, data)) {
+            dispatchAttachAction(actionId, actions);
             return true;
         }
     }

package/dist/clients/attach/session/keys.d.ts

@@ -17,6 +17,8 @@ export interface KeyHooks {
     inspectLoadedCommand: () => void;
     /** The file-review chord — open the transcript-file picker + review surface. */
     openFileReview: () => void;
+    /** Search the current node's local profile project files. */
+    openProfileFiles: () => void;
 }
 /** Install the listener; returns the remover, which teardown MUST call. */
 export declare function installGlobalKeys(ctx: Pick<AttachSession, 'tui' | 'editor'>, hooks: KeyHooks): () => void;

package/dist/clients/attach/session/keys.js

@@ -3,10 +3,11 @@
 // A TUI input listener fires BEFORE the focused component and before any dialog
 // overlay, so the configured attach actions work regardless of what has focus.
 // That privilege is also the hazard: anything consumed here never reaches the
-// editor. Only three things may claim a chunk — terminal focus reports, the
-// roster while it holds the cursor, and a configured crtr binding — and each
-// returns to the editor untouched when it does not apply.
-import { dispatchAttachBinding } from './bindings.js';
+// editor. Only terminal focus reports, a private crouter control input, the
+// roster while it holds the cursor, and a configured crtr binding may claim a
+// chunk; each returns ordinary editor input untouched when it does not apply.
+import { extractAttachControlInput } from '../../../core/keybindings/index.js';
+import { dispatchAttachAction, dispatchAttachBinding } from './bindings.js';
 import { FOCUS_IN, FOCUS_OUT } from './focus-events.js';
 /** Press the clear-or-detach binding twice inside this window to detach. */
 const CLEAR_OR_DETACH_MS = 1000;
@@ -14,47 +15,45 @@ const CLEAR_OR_DETACH_MS = 1000;
 export function installGlobalKeys(ctx, hooks) {
     const { tui, editor } = ctx;
     let lastClearOrDetachAt = 0;
+    const actions = {
+        'crtr.attach.detach': hooks.detach,
+        'crtr.attach.clear-or-detach': () => {
+            const now = Date.now();
+            if (now - lastClearOrDetachAt < CLEAR_OR_DETACH_MS) {
+                lastClearOrDetachAt = 0;
+                hooks.detach();
+                return;
+            }
+            lastClearOrDetachAt = now;
+            editor.setText('');
+            hooks.setNotice(`Editor cleared — press ${hooks.detachHint()} again to detach`);
+            tui.requestRender();
+        },
+        'crtr.mode.cycle': hooks.cycleMode,
+        'crtr.attach.graph.toggle': hooks.toggleGraph,
+        // A plain broker frame, so this works locally and remotely alike; the broker gates observers on controller role.
+        'crtr.attach.model-ladder.next': () => hooks.cycleModelLadder('forward'),
+        'crtr.attach.model-ladder.previous': () => hooks.cycleModelLadder('backward'),
+        'crtr.attach.command.inspect': hooks.inspectLoadedCommand,
+        'crtr.attach.file-review': hooks.openFileReview,
+        'crtr.attach.profile-files': hooks.openProfileFiles,
+    };
     return tui.addInputListener((data) => {
-        // Terminal focus reporting (DECSET 1004, enabled after tui.start; tmux
-        // forwards it per-pane with `focus-events on`). Pane focus drives the
-        // editor's fake cursor — solid block focused, hollow outline blurred — so a
-        // wall of attach panes shows exactly which one keys go to. The events are
-        // stripped rather than blanket-consumed in case the chunk coalesced them
-        // with real keystrokes.
+        // Terminal focus reporting (DECSET 1004, enabled after tui.start; tmux forwards it per-pane with `focus-events on`). Pane focus drives the editor's fake cursor — solid block focused, hollow outline blurred — so a wall of attach panes shows exactly which one keys go to. The events are stripped rather than blanket-consumed in case the chunk coalesced them with real keystrokes.
         if (data.includes(FOCUS_IN) || data.includes(FOCUS_OUT)) {
             hooks.setPaneFocused(data.lastIndexOf(FOCUS_IN) > data.lastIndexOf(FOCUS_OUT));
             tui.requestRender();
             const rest = data.replaceAll(FOCUS_IN, '').replaceAll(FOCUS_OUT, '');
             return rest.length > 0 ? { data: rest } : { consume: true };
         }
-        // Inline subagent scroll+swap: once the editor hands off at its ↓ boundary,
-        // ↑/↓ move over the manager/report roster and Enter dives into a node. An
-        // inactive roster never intercepts editor input.
+        const control = extractAttachControlInput(data);
+        if (control !== undefined) {
+            dispatchAttachAction(control.actionId, actions);
+            return control.remaining.length > 0 ? { data: control.remaining } : { consume: true };
+        }
+        // Inline subagent scroll+swap: once the editor hands off at its ↓ boundary, ↑/↓ move over the manager/report roster and Enter dives into a node. An inactive roster never intercepts editor input.
         if (hooks.rosterHandleKey(data))
             return { consume: true };
-        const dispatched = dispatchAttachBinding(hooks.bindings(), data, {
-            'crtr.attach.detach': hooks.detach,
-            'crtr.attach.clear-or-detach': () => {
-                const now = Date.now();
-                if (now - lastClearOrDetachAt < CLEAR_OR_DETACH_MS) {
-                    lastClearOrDetachAt = 0;
-                    hooks.detach();
-                    return;
-                }
-                lastClearOrDetachAt = now;
-                editor.setText('');
-                hooks.setNotice(`Editor cleared — press ${hooks.detachHint()} again to detach`);
-                tui.requestRender();
-            },
-            'crtr.mode.cycle': hooks.cycleMode,
-            'crtr.attach.graph.toggle': hooks.toggleGraph,
-            // A plain broker frame, so this works locally and remotely alike; the
-            // broker gates observers on controller role.
-            'crtr.attach.model-ladder.next': () => hooks.cycleModelLadder('forward'),
-            'crtr.attach.model-ladder.previous': () => hooks.cycleModelLadder('backward'),
-            'crtr.attach.command.inspect': hooks.inspectLoadedCommand,
-            'crtr.attach.file-review': hooks.openFileReview,
-        });
-        return dispatched ? { consume: true } : undefined;
+        return dispatchAttachBinding(hooks.bindings(), data, actions) ? { consume: true } : undefined;
     });
 }

package/dist/clients/attach/session/profile-files.d.ts

@@ -0,0 +1,8 @@
+interface ProfileFileSearchOptions {
+    cwd: string;
+    profileId: string | null;
+    fdPath: string | null;
+    onNotice: (message: string) => void;
+}
+export declare function launchProfileFileSearch(opts: ProfileFileSearchOptions): void;
+export {};

package/dist/clients/attach/session/profile-files.js

@@ -0,0 +1,157 @@
+// session/profile-files.ts — fuzzy file search across a node's local profile.
+//
+// The popup searches the current workspace plus every project named by the
+// node's profile manifest. Ancestor `.crouter/memory/` stores are added with
+// ignore rules disabled, so project memory remains findable even when a parent
+// ignore file hides `.crouter/`. fzf owns selection and nvim owns viewing; the
+// attach viewer only resolves the relevant roots and wires the two popups.
+import { constants, accessSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, dirname, join, resolve, sep } from 'node:path';
+import { execFile, spawnSync } from 'node:child_process';
+import { loadProfileManifest } from '../../../core/profiles/manifest.js';
+import { shellQuote } from '../../../core/runtime/placement-tmux.js';
+import { surfaceTmuxStyleArgs } from '../../../core/runtime/surface-bg.js';
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function executableCandidates(name, preferred) {
+    const candidates = [
+        ...(preferred === undefined || preferred === null ? [] : [preferred]),
+        ...(process.env['PATH'] ?? '').split(delimiter).filter(Boolean).map((dir) => join(dir, name)),
+    ];
+    return [...new Set(candidates)];
+}
+/** Return the first PATH candidate that can actually execute. Checking only
+ *  X_OK is insufficient when a managed tool cache contains a binary for a
+ *  different host platform. This runs only when the user opens the search. */
+function workingExecutable(name, preferred) {
+    for (const candidate of executableCandidates(name, preferred)) {
+        try {
+            accessSync(candidate, constants.X_OK);
+        }
+        catch {
+            continue;
+        }
+        const probe = spawnSync(candidate, ['--version'], { stdio: 'ignore' });
+        if (probe.status === 0)
+            return candidate;
+    }
+    return null;
+}
+function profileProjectDirs(profileId) {
+    if (profileId === null || profileId === '')
+        return [];
+    try {
+        return loadProfileManifest(profileId).manifest.projects;
+    }
+    catch {
+        return [];
+    }
+}
+function dedupeExistingDirs(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const path of paths) {
+        const absolute = resolve(path);
+        if (seen.has(absolute) || !isDirectory(absolute))
+            continue;
+        seen.add(absolute);
+        out.push(absolute);
+    }
+    return out;
+}
+/** Keep only the outermost search roots. An outer profile project already
+ *  covers a cwd or another project nested beneath it, and avoiding the second
+ *  fd walk keeps every candidate unique without a separate dedupe process. */
+function outermostDirs(paths) {
+    return paths.filter((path) => !paths.some((other) => other !== path && path.startsWith(other + sep)));
+}
+/** Every existing `<ancestor>/.crouter/memory/` from each pointer through the
+ *  filesystem root. A dedicated no-ignore fd pass guarantees these files are
+ *  present even when the wider project scan respects an ignore rule. */
+function ancestorMemoryDirs(pointers) {
+    const found = [];
+    for (const pointer of pointers) {
+        let cursor = resolve(pointer);
+        for (;;) {
+            const memory = join(cursor, '.crouter', 'memory');
+            if (isDirectory(memory))
+                found.push(memory);
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                break;
+            cursor = parent;
+        }
+    }
+    return dedupeExistingDirs(found);
+}
+function selectionPath(path) {
+    try {
+        const bytes = readFileSync(path);
+        if (bytes.length === 0)
+            return null;
+        const end = bytes[bytes.length - 1] === 0 ? bytes.length - 1 : bytes.length;
+        return bytes.subarray(0, end).toString('utf8') || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function launchProfileFileSearch(opts) {
+    const fd = workingExecutable('fd', opts.fdPath);
+    if (fd === null) {
+        opts.onNotice('fd is required for profile file search');
+        return;
+    }
+    const fzf = workingExecutable('fzf');
+    if (fzf === null) {
+        opts.onNotice('fzf is required for profile file search');
+        return;
+    }
+    const nvim = workingExecutable('nvim');
+    if (nvim === null) {
+        opts.onNotice('Neovim is required for profile file search');
+        return;
+    }
+    const pointers = dedupeExistingDirs([opts.cwd, ...profileProjectDirs(opts.profileId)]);
+    if (pointers.length === 0) {
+        opts.onNotice('No profile file-search directories exist');
+        return;
+    }
+    const roots = outermostDirs(pointers);
+    const memoryDirs = ancestorMemoryDirs(pointers);
+    const tempDir = mkdtempSync(join(tmpdir(), 'crtr-profile-files-'));
+    const selected = join(tempDir, 'selection');
+    const scans = [
+        ...roots.map((root) => `${shellQuote(fd)} --type f --hidden --exclude .git --exclude ${shellQuote('**/.crouter/memory/**')} --print0 . ${shellQuote(root)}`),
+        ...memoryDirs.map((memory) => `${shellQuote(fd)} --type f --hidden --exclude .git --no-ignore --print0 . ${shellQuote(memory)}`),
+    ];
+    const command = `{ ${scans.map((scan) => `${scan} &`).join(' ')} wait; } | ${shellQuote(fzf)} --read0 --print0 --preview ${shellQuote('head -100 -- {}')} > ${shellQuote(selected)}`;
+    try {
+        execFile('tmux', ['display-popup', '-E', '-T', ' profile files ', '-w', '80%', '-h', '60%', ...surfaceTmuxStyleArgs(), command], () => {
+            const file = selectionPath(selected);
+            if (file === null || !existsSync(file)) {
+                rmSync(tempDir, { recursive: true, force: true });
+                return;
+            }
+            const open = `exec ${shellQuote(nvim)} -- ${shellQuote(file)}`;
+            try {
+                execFile('tmux', ['display-popup', '-E', '-T', ' profile file ', '-w', '90%', '-h', '90%', ...surfaceTmuxStyleArgs(), open], () => rmSync(tempDir, { recursive: true, force: true }));
+            }
+            catch (err) {
+                rmSync(tempDir, { recursive: true, force: true });
+                opts.onNotice(`Could not open profile file: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+    }
+    catch (err) {
+        rmSync(tempDir, { recursive: true, force: true });
+        opts.onNotice(`Could not open profile file search: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}