@north-light/crouter 0.3.159 → 0.3.161

package/dist/core/runtime/nerd-font.js

@@ -0,0 +1,127 @@
+import { spawnSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** crtr's viewer renders tool calls, command icons, node badges and the
+ *  inspector with Nerd Font private-use-area codepoints (see
+ *  `core/preview-registry.ts` and `clients/attach/render/tool-calls.ts`), so a
+ *  terminal without a Nerd Font shows tofu boxes for every icon. Nothing about
+ *  the font is auto-detectable from inside the process — the terminal emulator
+ *  picks the face — so the best we can do is detect an INSTALLED Nerd Font on
+ *  the system and tell the user to point their terminal profile at it. */
+/** Font-family and filename fragments that only appear in Nerd Font builds.
+ *  `symbols` alone would false-positive on system symbol faces, so the
+ *  symbols-only patch is matched with its full distributed name. */
+const NERD_FONT_PATTERN = /nerd[ _-]?font|symbolsnerdfont|symbols-only/i;
+/** Font directories searched when fontconfig is unavailable (always the case
+ *  on macOS). User-level dirs first: an install crtr suggested lands there. */
+function fontDirs(platform, home) {
+    if (platform === 'darwin') {
+        return [join(home, 'Library', 'Fonts'), '/Library/Fonts', '/System/Library/Fonts'];
+    }
+    return [
+        join(home, '.local', 'share', 'fonts'),
+        join(home, '.fonts'),
+        '/usr/local/share/fonts',
+        '/usr/share/fonts',
+    ];
+}
+/** Shallow recursive filename scan. Font trees nest a couple of levels
+ *  (`/usr/share/fonts/truetype/<family>/`), so depth 3 reaches every real
+ *  install without walking an unbounded tree. */
+function scanForNerdFont(dir, depth) {
+    if (depth < 0)
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null; // absent or unreadable directory is simply not a match
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const nested = scanForNerdFont(join(dir, entry.name), depth - 1);
+            if (nested !== null)
+                return nested;
+            continue;
+        }
+        if (!/\.(ttf|otf|ttc)$/i.test(entry.name))
+            continue;
+        if (NERD_FONT_PATTERN.test(entry.name))
+            return entry.name;
+    }
+    return null;
+}
+/** Ask fontconfig for installed families. Present on Linux, absent on macOS. */
+function queryFontconfig() {
+    const probe = spawnSync('sh', ['-lc', 'command -v fc-list >/dev/null 2>&1'], { stdio: 'ignore' });
+    if (probe.status !== 0)
+        return null;
+    const res = spawnSync('fc-list', [':', 'family'], { encoding: 'utf8', timeout: 5000 });
+    if (res.status !== 0 || typeof res.stdout !== 'string')
+        return null;
+    for (const line of res.stdout.split('\n')) {
+        if (NERD_FONT_PATTERN.test(line))
+            return line.split(',')[0].trim();
+    }
+    return ''; // fontconfig answered and knows of no Nerd Font — authoritative miss
+}
+export function detectNerdFont(platform = process.platform, home = homedir()) {
+    if (platform !== 'darwin') {
+        const family = queryFontconfig();
+        if (family !== null && family !== '')
+            return { installed: true, evidence: family, source: 'fc-list' };
+    }
+    for (const dir of fontDirs(platform, home)) {
+        const file = scanForNerdFont(dir, 3);
+        if (file !== null)
+            return { installed: true, evidence: file, source: 'font-dir' };
+    }
+    return { installed: false, evidence: null, source: null };
+}
+/** Download the upstream symbols-only patch into the user's font dir. Works on
+ *  every Linux regardless of package manager — Debian/Ubuntu and Fedora ship no
+ *  Nerd Font package, so there is nothing native to install there. Needs no
+ *  sudo: it writes to `~/.local/share/fonts`. */
+export const NERD_FONT_MANUAL_LINUX_COMMAND = 'mkdir -p ~/.local/share/fonts && '
+    + 'curl -fsSL -o /tmp/NerdFontsSymbolsOnly.zip '
+    + 'https://github.com/ryanoasis/nerd-fonts/releases/latest/download/NerdFontsSymbolsOnly.zip && '
+    + 'unzip -oq /tmp/NerdFontsSymbolsOnly.zip -d ~/.local/share/fonts && fc-cache -f';
+/** The install command for this platform/package manager. `packageManager`
+ *  matches setup's detection: only brew and pacman have a real Nerd Font
+ *  package, everything else on Linux gets the upstream download. A non-brew
+ *  package manager only ever exists on Linux, so it settles the platform on its
+ *  own and `platform` decides only the `manual` case. */
+export function nerdFontInstallCommand(packageManager, platform = process.platform) {
+    const onLinux = platform !== 'darwin' || packageManager === 'apt-get' || packageManager === 'dnf' || packageManager === 'pacman';
+    if (packageManager === 'brew') {
+        return {
+            command: 'brew install --cask font-symbols-only-nerd-font',
+            hint: 'Homebrew cask',
+            autoInstall: true,
+        };
+    }
+    if (packageManager === 'pacman') {
+        return {
+            command: 'sudo pacman -S --noconfirm ttf-nerd-fonts-symbols',
+            hint: 'pacman install',
+            autoInstall: true,
+        };
+    }
+    if (onLinux) {
+        return {
+            command: NERD_FONT_MANUAL_LINUX_COMMAND,
+            hint: 'download symbols-only patch to ~/.local/share/fonts (needs curl + unzip)',
+            autoInstall: true,
+        };
+    }
+    return {
+        command: null,
+        hint: 'install Homebrew, or download a Nerd Font from https://nerdfonts.com and add it in Font Book',
+        autoInstall: false,
+    };
+}
+/** Every install path ends the same way: the font is on disk but the terminal
+ *  emulator still has to be pointed at it, and crtr cannot do that. */
+export const NERD_FONT_SELECT_HINT = 'then set your terminal profile\'s font to a Nerd Font (e.g. add "Symbols Nerd Font Mono" as the non-ASCII/fallback font) — installing it does not select it';

package/dist/core/runtime/tmux.js

@@ -483,6 +483,8 @@ const MENU_ACTIONS = {
     // M-S-r carries shift+alt and lands as the same chord the keyboard produces.
     'crtr.tmux.menu.file-review': { description: 'review a file', action: { kind: 'raw-keys', keys: 'M-S-r' } },
     'crtr.tmux.menu.metadata': { description: 'metadata', action: { kind: 'keys', keys: '/node-metadata' } },
+    'crtr.tmux.menu.fold-tools': { description: 'fold finished tool calls', action: { kind: 'keys', keys: '/fold-tools' } },
+    'crtr.tmux.menu.view-settings': undefined,
     'crtr.tmux.menu.context': { description: 'context + reports', action: { kind: 'keys', keys: '/context' } },
     'crtr.tmux.menu.providers': { description: 'settings', action: { kind: 'popup', run: 'sys setup' } },
     'crtr.tmux.menu.graph': { description: 'graph view', action: { kind: 'keys', keys: '/graph' } },
@@ -627,6 +629,11 @@ function menuItems(bindings) {
         'crtr.tmux.menu.metadata',
         'crtr.tmux.menu.context',
     ]);
+    // How this viewer PAINTS the transcript, as opposed to what it shows. Each item
+    // is a toggle the viewer applies to its own render state (a `/`-command sent to
+    // the pane); a tmux menu is built once and cannot show live state, so the item
+    // reads as the action and the viewer answers with a notice.
+    const viewSettingsItems = boundItems(['crtr.tmux.menu.fold-tools']);
     const exploreItems = boundItems([
         'crtr.tmux.menu.resume',
         'crtr.tmux.menu.graph',
@@ -641,6 +648,15 @@ function menuItems(bindings) {
             });
         }
     }
+    if (viewSettingsItems.length > 0) {
+        for (const gesture of bindings.gestures('crtr.tmux.menu.view-settings')) {
+            exploreItems.push({
+                description: 'view settings ›',
+                selector: menuSelector(gesture),
+                action: { kind: 'submenu', title: ' view settings ', items: viewSettingsItems },
+            });
+        }
+    }
     // Explore changes what is in view or opens a canvas-level browser. Current
     // node acts on the agent in this pane without changing its lifecycle.
     addGroup('Explore', exploreItems);

package/dist/daemon/api/map.js

@@ -105,6 +105,8 @@ export function toNodeDetailDTO(meta, edges) {
     };
     if (meta.description !== undefined)
         dto.description = meta.description;
+    if (meta.icon !== undefined)
+        dto.icon = meta.icon;
     if (meta.cycles !== undefined)
         dto.cycles = meta.cycles;
     dto.context_tokens = readContextTokens(meta.node_id);

package/dist/pi-extensions/naming-tool.d.ts

@@ -0,0 +1,24 @@
+interface PiLike {
+    registerTool: (definition: Record<string, unknown>) => void;
+}
+/** The naming schema — the ONE definition of what a generated session name is.
+ *  Both fields are required: a name without an icon renders a bare label, and
+ *  an icon without a name is useless, so the model is made to decide both in a
+ *  single constrained emission. */
+export declare const NAME_SESSION_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.";
+        };
+        readonly icon: {
+            readonly type: "string";
+            readonly description: "The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).";
+        };
+    };
+    readonly required: readonly ["name", "icon"];
+    readonly additionalProperties: false;
+};
+export declare function registerNamingTool(pi: PiLike): void;
+export default registerNamingTool;

package/dist/pi-extensions/naming-tool.js

@@ -0,0 +1,67 @@
+// naming-tool.ts — the structured-output seam for session naming.
+//
+// Loaded ONLY by the headless namer subprocess (`runtime/naming.ts` passes it
+// with `-e` alongside `--no-extensions`), never by a canvas node. It registers a
+// single `name_session` tool whose parameters ARE the naming schema, with
+// pi's constrained sampling turned on, so the light model emits a real typed
+// object instead of prose we have to parse out of a text reply.
+//
+// The result travels back to the parent over a file: the parent creates a temp
+// path, passes it as CRTR_NAME_RESULT_FILE, and reads it after the subprocess
+// exits. stdout is unusable for this — pi print-mode writes its own chatter
+// there.
+//
+// Inert (registers nothing) when CRTR_NAME_RESULT_FILE is absent, so an
+// accidental load in any other context is a no-op.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** The naming schema — the ONE definition of what a generated session name is.
+ *  Both fields are required: a name without an icon renders a bare label, and
+ *  an icon without a name is useless, so the model is made to decide both in a
+ *  single constrained emission. */
+export const NAME_SESSION_SCHEMA = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.',
+        },
+        icon: {
+            type: 'string',
+            description: 'The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).',
+        },
+    },
+    required: ['name', 'icon'],
+    additionalProperties: false,
+};
+export function registerNamingTool(pi) {
+    const out = process.env['CRTR_NAME_RESULT_FILE'];
+    if (out === undefined || out.trim() === '')
+        return;
+    pi.registerTool({
+        name: 'name_session',
+        label: 'Name session',
+        description: 'Record the name and icon for this coding session. Call exactly once, then stop.',
+        parameters: NAME_SESSION_SCHEMA,
+        // Ask the provider to constrain sampling to the schema. `prefer` degrades
+        // silently on a model without strict tool support (`require` would fail the
+        // whole request); the parent validates and falls back to a local slug
+        // either way, so this only makes a malformed emission rarer.
+        constrainedSampling: { type: 'json_schema', strict: 'prefer' },
+        execute(_id, params) {
+            try {
+                mkdirSync(dirname(out), { recursive: true });
+                writeFileSync(out, JSON.stringify(params ?? {}), 'utf8');
+            }
+            catch {
+                // The parent falls back to a local slug when the file never lands.
+            }
+            return {
+                content: [{ type: 'text', text: 'Recorded.' }],
+                details: { recorded: true },
+                terminate: true,
+            };
+        },
+    });
+}
+export default registerNamingTool;

package/dist/types.d.ts

@@ -152,6 +152,11 @@ export interface ScopeConfig {
      *  `both` keeps both. Tool calls and results are never kept. Full detail for
      *  every cycle stays in the session file. */
     condensed_history: CondensedHistoryMode;
+    /** Fold every SETTLED tool call in the attach viewer down to its single call
+     *  line (`/fold-tools`, Alt+C → w → f). A tool still running is never folded —
+     *  it folds itself once it settles. Toggling it in a viewer writes back here,
+     *  so the choice carries into later chats and later viewers. Default false. */
+    fold_finished_tools: boolean;
     keybindings: KeybindingOverrides;
     modelLadders: ModelLaddersConfig;
     /** The kind registry (spec §1.5): kind existence + launch knobs, keyed by

package/dist/types.js

@@ -38,6 +38,7 @@ export function defaultScopeConfig() {
         completion_bell: true,
         live_cycles: DEFAULT_LIVE_CYCLES,
         condensed_history: DEFAULT_CONDENSED_HISTORY,
+        fold_finished_tools: false,
         keybindings: {},
         modelLadders: defaultModelLaddersConfig(),
         kinds: defaultKindsConfig(),