@kolisachint/hoocode-agent 0.5.29 → 0.5.31

package/dist/modes/interactive/components/settings-selector.js

@@ -1,4 +1,5 @@
 import { Container, getCapabilities, Input, SelectList, SettingsList, Spacer, Text, } from "@kolisachint/hoocode-tui";
+import { buildRowGates, statusLabel } from "../../../core/external-tools.js";
 import { getSelectListTheme, getSettingsListTheme, getThemeDescription, theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyDisplayText } from "./keybinding-hints.js";
@@ -164,6 +165,34 @@ class PlatformSubmenu extends Container {
         this.settingsList.handleInput(data);
     }
 }
+/**
+ * Trailing sentence for a row whose setting is inert until an external binary
+ * shows up. The row is annotated rather than hidden: the binaries were invisible
+ * precisely because nothing ever mentioned them, and a row that disappears when
+ * its dependency is missing teaches the user nothing at all.
+ */
+function gateNote(gate) {
+    if (!gate || gate.installed)
+        return "";
+    return gate.downloadable
+        ? ` Needs the ${gate.tool} binary, which hoocode fetches the first time this is used. Until then: ${gate.fallback}`
+        : ` Needs the ${gate.tool} binary, and this environment will not fetch it. Until then: ${gate.fallback}`;
+}
+/** "3 of 5 installed" - the one number that says whether this category needs attention. */
+function externalCount(statuses) {
+    const installed = statuses.filter((status) => status.installed).length;
+    return `${installed} of ${statuses.length} installed`;
+}
+/** The capability words, so the category row says what the binaries are for. */
+function externalSummary(statuses) {
+    return statuses.map((status) => status.tool).join(", ");
+}
+/** Value-column marker for a gated row, so the list shows it without selecting. */
+function gateSuffix(gate) {
+    if (!gate || gate.installed)
+        return undefined;
+    return `needs ${gate.tool}`;
+}
 /**
  * Submenu for tool availability. The first rows are group switches (web,
  * semantic search) that decide whether a group's tools
@@ -180,16 +209,26 @@ class ToolsSubmenu extends Container {
     enabled;
     static CORE = new Set(["read", "bash", "edit", "write"]);
     static GROUP_PREFIX = "group:";
-    constructor(tools, groups, onChange, onGroupChange, onCancel) {
+    constructor(tools, groups, 
+    /** Rows gated on an external binary, keyed by row id. See buildRowGates. */
+    gates, onChange, onGroupChange, onCancel) {
         super();
         this.enabled = new Map(tools.map((t) => [t.name, t.enabled]));
-        const groupItems = groups.map((group) => ({
-            id: `${ToolsSubmenu.GROUP_PREFIX}${group.id}`,
-            label: `[group] ${group.label}`,
-            description: `${group.description} Governs whether these tools exist; applies on the next session.`,
-            currentValue: group.enabled ? "on" : "off",
-            values: ["on", "off"],
-        }));
+        const groupItems = groups.map((group) => {
+            const id = `${ToolsSubmenu.GROUP_PREFIX}${group.id}`;
+            const gate = gates.get(id);
+            return {
+                id,
+                label: `[group] ${group.label}`,
+                description: `${group.description} Governs whether these tools exist; applies on the next session.${gateNote(gate)}`,
+                currentValue: group.enabled ? "on" : "off",
+                // The switch stays settable with the binary missing: the setting is
+                // what makes hoocode fetch it, so refusing the toggle would make the
+                // group unreachable forever.
+                valueSuffix: gateSuffix(gate),
+                values: ["on", "off"],
+            };
+        });
         const toolItems = tools.map((tool) => ({
             id: tool.name,
             label: tool.name,
@@ -197,6 +236,10 @@ class ToolsSubmenu extends Container {
                 ? "Core tool. Disabling leaves the agent unable to perform this action in every session."
                 : "Disable to remove this tool from the agent this session and every future session.",
             currentValue: tool.enabled ? "on" : "off",
+            // What the schema costs on every request, whether the tool is on or off:
+            // off, it is the price of turning it back on. This is the number that
+            // makes a tool worth disabling, so it belongs beside the switch.
+            valueSuffix: tool.tokens !== undefined ? `${tokenCount(tool.tokens)} tok/turn` : undefined,
             values: ["on", "off"],
         }));
         const items = [...groupItems, ...toolItems];
@@ -223,6 +266,88 @@ class ToolsSubmenu extends Container {
         this.settingsList.handleInput(data);
     }
 }
+/**
+ * Read-only detail for one external binary: what it is, whether it is here, what
+ * it turns on, and what hoocode does without it.
+ *
+ * A submenu rather than a long `description` because the useful answer is five
+ * or six lines and the pane shows descriptions on one. Nothing here is settable
+ * - the binary is either on the machine or it is not - so the rows carry no
+ * `values` and Enter does nothing but close.
+ */
+class ExternalToolDetailSubmenu extends Container {
+    settingsList;
+    constructor(status, onCancel) {
+        super();
+        const acquisition = status.acquisition === "startup"
+            ? "Downloaded in the background at startup."
+            : status.acquisition === "on-demand"
+                ? "Downloaded the first time the feature is used."
+                : "Never downloaded automatically; install it yourself.";
+        const location = status.installed
+            ? status.source === "path"
+                ? `found on PATH as \`${status.path}\``
+                : status.source === "override"
+                    ? `${status.overrideEnv} points at ${status.path}`
+                    : `hoocode's own copy at ${status.path}`
+            : status.downloadable
+                ? `${acquisition} Not on this machine yet.`
+                : "Not installed, and this environment will not download it (offline mode, or no published build for this platform).";
+        const rows = [
+            ["Status", statusLabel(status), location],
+            [
+                "Enables",
+                `${status.enables.length} feature${status.enables.length === 1 ? "" : "s"}`,
+                status.enables.join("; "),
+            ],
+            ["Without it", "fallback", status.fallback],
+            ["Source", status.repo || "-", `Release archives come from github.com/${status.repo}. ${acquisition}`],
+            ["Env", String(status.env.length), status.env.join("  |  ")],
+        ];
+        const items = rows.map(([label, value, description], index) => ({
+            id: `detail-${index}`,
+            label,
+            currentValue: value,
+            description,
+        }));
+        this.settingsList = new SettingsList(items, items.length, getSettingsListTheme(), () => { }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
+/**
+ * The external-binary category: one row per managed Rust binary.
+ *
+ * These binaries were entirely invisible before this pane existed. hoocode works
+ * without every one of them, which is the whole reason nobody found them: search
+ * silently got slower, semantic ranking silently never happened, and web/voice
+ * were simply features nobody knew were there. The row states presence; the
+ * submenu states what presence buys.
+ */
+class ExternalToolsSubmenu extends Container {
+    settingsList;
+    constructor(statuses, onCancel) {
+        super();
+        const items = statuses.map((status) => ({
+            id: `ext-${status.tool}`,
+            label: status.label,
+            description: `${status.summary} Without it: ${status.fallback}`,
+            currentValue: statusLabel(status),
+            // The value column says whether it is here; the suffix says what it is
+            // for, so the list reads without opening every row.
+            valueSuffix: status.installed ? undefined : status.downloadable ? "auto-fetch" : "manual",
+            keywords: [status.tool, status.repo, ...status.settingsKeys, ...status.enables].join(" "),
+            submenu: (_currentValue, done) => new ExternalToolDetailSubmenu(status, () => done()),
+        }));
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), () => { }, onCancel, { enableSearch: true });
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
 /** Byte-cap presets shown as human labels; mapped back to raw byte counts. */
 const TOOL_OUTPUT_BYTE_PRESETS = [
     ["8 KB", 8 * 1024],
@@ -243,39 +368,45 @@ function byteLabels(current) {
     return all.sort((a, b) => a[1] - b[1]).map(([label]) => label);
 }
 /**
- * Submenu for per-tool runtime settings. These feed the tool runtime the next
- * time it is built (next session / rebuild), so changes apply to future tool
- * calls rather than retroactively.
+ * Submenu for what a tool result looks like: how much of it is rendered, and
+ * where it is truncated. The display level applies to the transcript at once;
+ * the caps feed the tool runtime, so they bind on future tool calls.
+ *
+ * Context GC is deliberately not here. It is not about a tool's output but about
+ * what stays in the outgoing context, which is the Context category's subject.
  */
 class ToolSettingsSubmenu extends Container {
     settingsList;
     constructor(config, callbacks, onCancel) {
         super();
         const items = [
+            {
+                id: "tool-output-display",
+                label: "Display",
+                description: "How tool results render. 'standard': shown (expandable). 'collapsed': hidden. 'peek': hidden with a ▸ reveal caret (press the expand key to reveal).",
+                currentValue: config.toolOutputDisplay,
+                values: ["standard", "collapsed", "peek"],
+            },
             {
                 id: "output-max-bytes",
-                label: "Output max bytes",
+                label: "Max bytes",
                 description: "Byte cap on a single read/bash result before truncation. Applies to future tool calls.",
                 currentValue: bytesToLabel(config.toolOutputMaxBytes),
                 values: byteLabels(config.toolOutputMaxBytes),
             },
             {
                 id: "output-max-lines",
-                label: "Output max lines",
+                label: "Max lines",
                 description: "Line cap on a single read/bash result before truncation. Applies to future tool calls.",
                 currentValue: String(config.toolOutputMaxLines),
                 values: presetValues([200, 400, 800, 1600, 3200], config.toolOutputMaxLines),
             },
-            {
-                id: "context-gc",
-                label: "Context GC",
-                description: "Stub superseded read results (files later edited/re-read) out of the outgoing context.",
-                currentValue: config.contextGc ? "true" : "false",
-                values: ["true", "false"],
-            },
         ];
         this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
             switch (id) {
+                case "tool-output-display":
+                    callbacks.onToolOutputDisplayChange(newValue);
+                    break;
                 case "output-max-bytes": {
                     const preset = TOOL_OUTPUT_BYTE_PRESETS.find(([label]) => label === newValue);
                     // A hand-set cap has no preset entry; its label is "<n> KB" by
@@ -288,9 +419,6 @@ class ToolSettingsSubmenu extends Container {
                 case "output-max-lines":
                     callbacks.onToolOutputMaxLinesChange(parseInt(newValue, 10));
                     break;
-                case "context-gc":
-                    callbacks.onContextGcChange(newValue === "true");
-                    break;
             }
         }, onCancel);
         this.addChild(this.settingsList);
@@ -420,13 +548,41 @@ class SelectSubmenu extends Container {
         this.selectList.handleInput(data);
     }
 }
+/**
+ * Token counts, grouped and exact.
+ *
+ * `formatTokens` (2.7k) exists for the fixed-width chrome, where a count must
+ * never grow the box it sits in. This pane is the opposite case: the point of
+ * showing a number here is to compare it with another one, and "2.7k" hides the
+ * difference between the tool that costs 2,710 and the one that costs 2,749.
+ */
+function tokenCount(tokens) {
+    return tokens.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+/**
+ * The fixed per-turn cost, as one line under the pane.
+ *
+ * Every byte of system prompt and active tool schema is re-sent on every
+ * request, and the pane is where that number is decided - so the pane is where
+ * it should be visible. It reports the *live* session: a tool toggle applies at
+ * once and moves it, while a setting that only takes effect next session (a tool
+ * group, the light preset) leaves it alone until then.
+ */
+function formatSurfaceLine(surface) {
+    const tools = `${surface.tools.length} tool${surface.tools.length === 1 ? "" : "s"}`;
+    return (`  Per-turn surface: ${tokenCount(surface.totalTokens)} tokens  ` +
+        `${theme.fg("dim", `(${tokenCount(surface.systemPromptTokens)} system prompt + ${tokenCount(surface.toolSchemaTokens)} schemas, ${tools})`)}`);
+}
 /**
  * Main settings selector component.
  */
 export class SettingsSelectorComponent extends Container {
     settingsList;
+    surfaceLine;
+    measureTokenSurface;
     constructor(config, callbacks) {
         super();
+        this.measureTokenSurface = config.measureTokenSurface;
         const supportsImages = getCapabilities().images;
         const followUpKey = keyDisplayText("app.message.followUp");
         let currentWarnings = { ...config.warnings };
@@ -437,6 +593,10 @@ export class SettingsSelectorComponent extends Container {
         const pinnedNote = (key) => projectPinned.has(key)
             ? ` This repo's .hoocode/settings.json sets ${key}, which overrides this row from the next session on.`
             : "";
+        // Which rows are gated on an external binary that is not on this machine.
+        // Built once so every row that needs it reads the same answer.
+        const rowGates = buildRowGates(config.externalTools);
+        const initialSurface = config.measureTokenSurface?.();
         const toolsOn = config.tools.filter((t) => t.enabled).length;
         const toolsOff = config.tools.length - toolsOn;
         const items = [
@@ -591,8 +751,26 @@ export class SettingsSelectorComponent extends Container {
             currentValue: config.blockImages ? "true" : "false",
             values: ["true", "false"],
         });
-        // Skill commands toggle (insert after block-images)
-        const blockImagesIndex = items.findIndex((item) => item.id === "block-images");
+        // Context GC (insert after block-images), a leaf the Context category picks up.
+        items.splice(items.findIndex((item) => item.id === "block-images") + 1, 0, {
+            id: "context-gc",
+            label: "Context GC",
+            description: "Stub superseded read results (files later edited or re-read) out of the outgoing context.",
+            currentValue: config.contextGc ? "true" : "false",
+            values: ["true", "false"],
+        });
+        // The light preset (insert after context GC). Read at startup to pick the
+        // tool set and the system prompt, so it lands on the next session.
+        const blockImagesIdx = items.findIndex((item) => item.id === "context-gc");
+        items.splice(blockImagesIdx + 1, 0, {
+            id: "light",
+            label: "Light preset",
+            description: "Low-token preset for small or local models: read/write/edit/bash only with stripped schemas, a terse system prompt, and no subagents/TodoWrite/skills/context files. Applies on the next session.",
+            currentValue: config.light ? "true" : "false",
+            values: ["true", "false"],
+        });
+        // Skill commands toggle (insert after the light preset)
+        const blockImagesIndex = items.findIndex((item) => item.id === "light");
         items.splice(blockImagesIndex + 1, 0, {
             id: "skill-commands",
             label: "Skill commands",
@@ -694,8 +872,9 @@ export class SettingsSelectorComponent extends Container {
         items.splice(terminalProgressIndex + 1, 0, {
             id: "voice-silence-ms",
             label: "Voice silence window",
-            description: "Trailing-silence (ms) before voice capture auto-stops (300-10000). Env: VOICETOOLS_SILENCE_MS.",
+            description: `Trailing-silence (ms) before voice capture auto-stops (300-10000). Env: VOICETOOLS_SILENCE_MS.${gateNote(rowGates.get("voice-silence-ms"))}`,
             currentValue: String(config.voiceSilenceMs),
+            valueSuffix: gateSuffix(rowGates.get("voice-silence-ms")),
             values: presetValues([300, 500, 800, 1200, 2000, 3000, 5000, 8000, 10000], config.voiceSilenceMs),
         });
         // Webtools request timeout (insert after voice-silence-ms)
@@ -703,8 +882,9 @@ export class SettingsSelectorComponent extends Container {
         items.splice(voiceSilenceIndex + 1, 0, {
             id: "webtools-timeout-secs",
             label: "Web tools timeout",
-            description: "Per-request timeout (secs) for webfetch/websearch (1-120). Env: HOOCODE_WEBTOOLS_TIMEOUT.",
+            description: `Per-request timeout (secs) for webfetch/websearch (1-120). Env: HOOCODE_WEBTOOLS_TIMEOUT.${gateNote(rowGates.get("webtools-timeout-secs"))}`,
             currentValue: String(config.webtoolsTimeoutSecs),
+            valueSuffix: gateSuffix(rowGates.get("webtools-timeout-secs")),
             values: presetValues([5, 10, 15, 30, 60, 120], config.webtoolsTimeoutSecs),
         });
         // The /learn thresholds, appended as leaf rows and gathered into their own
@@ -724,30 +904,28 @@ export class SettingsSelectorComponent extends Container {
             {
                 id: "tools",
                 label: "Tools",
-                description: "Enable/disable tools and tool groups (web, semantic search). Changes persist across sessions.",
+                description: "Enable/disable tools and tool groups (web, semantic search), each priced by what its schema costs per turn. Changes persist across sessions.",
                 currentValue: toolsOff > 0 ? `${toolsOn} on · ${toolsOff} off` : `${toolsOn} on`,
-                submenu: (_currentValue, done) => new ToolsSubmenu(config.tools, config.toolGroups, (name, enabled) => callbacks.onToolEnabledChange(name, enabled), (id, enabled) => callbacks.onToolGroupChange(id, enabled), () => done()),
+                valueSuffix: initialSurface ? `${tokenCount(initialSurface.toolSchemaTokens)} tok/turn` : undefined,
+                submenu: (_currentValue, done) => new ToolsSubmenu(config.tools, config.toolGroups, rowGates, (name, enabled) => {
+                    callbacks.onToolEnabledChange(name, enabled);
+                    // Applied live by the host, so the surface below is already stale.
+                    this.refreshTokenSurface();
+                }, (id, enabled) => callbacks.onToolGroupChange(id, enabled), () => done()),
             },
             {
-                id: "tool-output-display",
-                label: "Tool output display",
-                description: "How tool results render. 'standard': shown (expandable). 'collapsed': hidden. 'peek': hidden with a ▸ reveal caret (press the expand key to reveal).",
+                id: "tool-output",
+                label: "Tool output",
+                description: "How much of a tool result is rendered, and where it is truncated.",
                 currentValue: config.toolOutputDisplay,
-                values: ["standard", "collapsed", "peek"],
-            },
-            {
-                id: "tool-settings",
-                label: "Tool settings",
-                description: "Per-tool runtime settings: output truncation caps and context garbage collection.",
-                currentValue: "configure",
                 submenu: (_currentValue, done) => new ToolSettingsSubmenu({
+                    toolOutputDisplay: config.toolOutputDisplay,
                     toolOutputMaxBytes: config.toolOutputMaxBytes,
                     toolOutputMaxLines: config.toolOutputMaxLines,
-                    contextGc: config.contextGc,
                 }, {
+                    onToolOutputDisplayChange: callbacks.onToolOutputDisplayChange,
                     onToolOutputMaxBytesChange: callbacks.onToolOutputMaxBytesChange,
                     onToolOutputMaxLinesChange: callbacks.onToolOutputMaxLinesChange,
-                    onContextGcChange: callbacks.onContextGcChange,
                 }, () => done()),
             },
         ];
@@ -769,9 +947,6 @@ export class SettingsSelectorComponent extends Container {
                 case "autocompact":
                     callbacks.onAutoCompactChange(newValue === "true");
                     break;
-                case "tool-output-display":
-                    callbacks.onToolOutputDisplayChange(newValue);
-                    break;
                 case "show-images":
                     callbacks.onShowImagesChange(newValue === "true");
                     break;
@@ -787,6 +962,9 @@ export class SettingsSelectorComponent extends Container {
                 case "skill-commands":
                     callbacks.onEnableSkillCommandsChange(newValue === "true");
                     break;
+                case "light":
+                    callbacks.onLightChange(newValue === "true");
+                    break;
                 case "plugin-tools":
                     callbacks.onEnablePluginToolsChange(newValue === "true");
                     break;
@@ -855,6 +1033,10 @@ export class SettingsSelectorComponent extends Container {
                         callbacks.onLearnSettingChange(id, parseInt(newValue, 10));
                     break;
             }
+            // Most rows leave the per-turn surface alone; the ones that do not (a tool
+            // toggle, anything that rebuilds the system prompt) move it immediately.
+            // Re-measuring after every change is cheaper than knowing which is which.
+            this.refreshTokenSurface();
         };
         // Partition the flat leaf settings into named category submenus so the
         // top level stays short. `items` holds autocompact + every leaf setting.
@@ -876,8 +1058,12 @@ export class SettingsSelectorComponent extends Container {
             };
         };
         const topItems = [
-            ...(byId.has("autocompact") ? [byId.get("autocompact")] : []),
             ...toolFlagGroup,
+            // What the model is sent, and how much of it. Auto-compact used to sit
+            // alone at the top level and context GC was filed under tool settings,
+            // which left the three settings that decide the token budget in three
+            // different places - with the light preset in none of them.
+            categoryRow("cat-context", "Context", "What the model is sent and how much of it: compaction, superseded reads, and the low-token preset.", ["autocompact", "context-gc", "light"]),
             categoryRow("cat-behavior", "Behavior", "Agent and session behavior: steering, follow-up, thinking, escape, tree filter, transport.", ["steering-mode", "follow-up-mode", "thinking", "double-escape-action", "tree-filter-mode", "transport"]),
             categoryRow("cat-interface", "Interface", "Appearance and editor: theme, thinking visibility, cursor, border, padding, autocomplete, terminal.", [
                 "theme",
@@ -902,6 +1088,21 @@ export class SettingsSelectorComponent extends Container {
             // that decide whether /learn finds anything, and burying them is what
             // made them undiscoverable in the first place.
             categoryRow("cat-learn", "Learning", "Thresholds /learn mines sessions with: how far back to look, and how often something must repeat.", LEARN_SETTINGS.map((setting) => setting.key)),
+            // The external binaries. Top level, not folded into Advanced: their whole
+            // problem was that nothing in the product ever said they existed, and a
+            // row two levels down would have been the same silence with extra steps.
+            // This is the only category built from live machine state rather than
+            // settings, so it is assembled here instead of going through categoryRow.
+            {
+                id: "cat-external",
+                label: "External tools",
+                description: `Optional Rust binaries that expand what hoocode can do: ${externalSummary(config.externalTools)}. hoocode runs without every one of them - each row says what it adds and what happens without it.`,
+                currentValue: externalCount(config.externalTools),
+                keywords: config.externalTools
+                    .flatMap((status) => [status.tool, status.label, ...status.settingsKeys])
+                    .join(" "),
+                submenu: (_currentValue, done) => new ExternalToolsSubmenu(config.externalTools, () => done()),
+            },
             categoryRow("cat-advanced", "Advanced", "Startup, telemetry, skills, warnings, voice, and web tools.", [
                 "quiet-startup",
                 "collapse-changelog",
@@ -916,8 +1117,18 @@ export class SettingsSelectorComponent extends Container {
             enableSearch: true,
         });
         this.addChild(this.settingsList);
+        if (initialSurface) {
+            this.surfaceLine = new Text(formatSurfaceLine(initialSurface), 0, 0);
+            this.addChild(this.surfaceLine);
+        }
         this.addChild(new DynamicBorder());
     }
+    /** Re-price the pane after a change that may have altered what each turn sends. */
+    refreshTokenSurface() {
+        if (!this.surfaceLine || !this.measureTokenSurface)
+            return;
+        this.surfaceLine.setText(formatSurfaceLine(this.measureTokenSurface()));
+    }
     getSettingsList() {
         return this.settingsList;
     }