koneck 2.25.16 → 2.25.18

package/dist/ink-chat.js

@@ -6,7 +6,7 @@ import { createAgentSession, buildClient, resolveAgentConcurrency } from './engi
 import { estimateCost, formatCost } from './pricing.js';
 import { generateSessionId, saveSession, listSessions, loadSession } from './session.js';
 import { loadMemory } from './memory.js';
-import { loadKoneckConfig, saveKoneckConfig, setConfigKey, configKeyDescriptions, CONFIG_FILE } from './config-store.js';
+import { loadKoneckConfig, saveKoneckConfig, setConfigKey, configKeyDescriptions, CONFIG_FILE, CONFIG_SCHEMA, stepValue, displayValue } from './config-store.js';
 import { PROVIDERS, resolveProvider, getApiKey, addUserProvider, userProvidersPath } from './providers.js';
 import { listCheckpoints, revertCheckpoint, snapshotTree, filesTouchedBy } from './checkpoint.js';
 import { fileDiff, diffSummary } from './diff-view.js';
@@ -418,7 +418,7 @@ const MAX_DIFF_BYTES = 512 * 1024;
 /** One tool rarely touches more; the cap stops a bulk move from flooding scrollback. */
 const MAX_DIFF_FILES = 4;
 /** The tabs of the usage pane, in the order they are shown. */
-const USAGE_TABS = ['session', 'context', 'models', 'limits'];
+const USAGE_TABS = ['settings', 'session', 'context', 'models', 'limits'];
 const MIN_REPLY_WIDTH = 24; // below this a table cannot render legibly anyway
 const PICKER_ROWS = 9; // visible rows; the list scrolls within this window
 /**
@@ -508,6 +508,8 @@ function App({ config: initialConfig }) {
      * token — the animation tick is what paints it, not a re-render per delta.
      */
     const thinkingRef = useRef({ chars: 0, at: 0 });
+    /** Why the current turn stopped short, when it did. Cleared at the start of each turn. */
+    const incompleteRef = useRef(null);
     /**
      * Text pasted into the composer, held aside so the prompt stays readable.
      *
@@ -665,6 +667,7 @@ function App({ config: initialConfig }) {
                 liveToolRef.current.output = line;
         },
         onStreamActivity: (frames) => setProviderFrames(frames),
+        onIncomplete: (reason) => { incompleteRef.current = reason; },
         onThinking: (_text, totalChars) => {
             thinkingRef.current = { chars: totalChars, at: Date.now() };
             lastActivityRef.current = Date.now();
@@ -702,6 +705,12 @@ function App({ config: initialConfig }) {
     /** Tree hash captured at startup, so "code changes" is a diff rather than a running tally. */
     const baseTreeRef = useRef(null);
     const [usagePane, setUsagePane] = useState(null);
+    /** Which setting is highlighted on the Settings tab. */
+    const [settingRow, setSettingRow] = useState(0);
+    /** Stored config as the editor sees it — read when the pane opens, written as it is edited. */
+    const [stored, setStored] = useState({});
+    /** Non-null while a value is being typed rather than stepped. */
+    const [editing, setEditing] = useState(null);
     // undefined while the diff is still being computed, null once git has said there is nothing to
     // compare against. Collapsing the two would flash "not a git repo" at every open.
     const [usageDiff, setUsageDiff] = useState(undefined);
@@ -1013,10 +1022,48 @@ function App({ config: initialConfig }) {
      */
     async function openUsagePane(tab) {
         setUsagePane(tab);
+        setEditing(null);
+        void loadKoneckConfig().then(c => setStored(c));
         void diffStatSince(cfg.cwd, baseTreeRef.current).then(setUsageDiff);
         if (modelCatalog.length === 0)
             void loadModelCatalog();
     }
+    /**
+     * Writes one setting and makes it live.
+     *
+     * Persisting alone would leave the running session on the old value until restart, which is the
+     * behaviour that made the old `/config` feel inert even when it had worked.
+     */
+    async function applySetting(field, value) {
+        const next = { ...stored, [field.key]: value };
+        if (value === undefined)
+            delete next[field.key];
+        setStored(next);
+        await saveKoneckConfig(next);
+        switch (field.key) {
+            case 'effort':
+                setEffort((typeof value === 'string' ? value : 'medium'));
+                break;
+            case 'maxWidth':
+                setConfigMaxWidth(typeof value === 'number' && value >= 40 ? value : undefined);
+                break;
+            case 'model':
+            case 'provider':
+            case 'baseURL':
+            case 'maxTurns':
+            case 'requireApproval':
+            case 'agentConcurrency':
+            case 'budget': {
+                // These shape the session itself, so it is rebuilt on the new values.
+                const merged = { ...cfg, [field.key]: value };
+                setCfg(merged);
+                await resetSession(merged);
+                break;
+            }
+            default:
+                break;
+        }
+    }
     /** The provider's own model listing, kept so the models tab and picker agree on the facts. */
     async function loadModelCatalog() {
         try {
@@ -1464,6 +1511,12 @@ function App({ config: initialConfig }) {
             }
             case '/config': {
                 const parts = arg.split(/\s+/).filter(Boolean);
+                // Bare `/config` opens the editor. The `key value` form still works, because it is what
+                // scripts and muscle memory use — printing a table was never the useful half.
+                if (parts.length === 0) {
+                    await openUsagePane('settings');
+                    return;
+                }
                 const key = parts[0];
                 const val = parts.slice(1).join(' ');
                 if (key === 'reset') {
@@ -1924,6 +1977,49 @@ function App({ config: initialConfig }) {
         // Inside the usage pane: the arrows walk the tabs and escape closes it. This sits ahead of
         // the composer's own arrow handling, which would otherwise move the caret behind the pane.
         if (usagePane) {
+            // Typing a value owns the keyboard entirely, so a stray arrow cannot change tabs midway
+            // through an edit and lose what was typed.
+            if (editing) {
+                const field = CONFIG_SCHEMA.find(f => f.key === editing.key);
+                if (key.escape) {
+                    setEditing(null);
+                    return;
+                }
+                if (key.return) {
+                    const raw = editing.value.trim();
+                    setEditing(null);
+                    if (!field)
+                        return;
+                    if (raw === '') {
+                        if (field.clearable)
+                            void applySetting(field, undefined);
+                        return;
+                    }
+                    if (field.type.kind === 'number') {
+                        const n = Number(raw);
+                        if (!Number.isFinite(n))
+                            return; // ignore rather than store junk
+                        const { min, max } = field.type;
+                        const clamped = Math.min(max ?? Infinity, Math.max(min ?? -Infinity, n));
+                        void applySetting(field, clamped);
+                    }
+                    else {
+                        void applySetting(field, raw);
+                    }
+                    return;
+                }
+                if (key.backspace || key.delete) {
+                    setEditing(e => (e ? { ...e, value: e.value.slice(0, -1) } : e));
+                    return;
+                }
+                if (!key.ctrl && !key.meta && input) {
+                    // eslint-disable-next-line no-control-regex
+                    const text = input.replace(/[\u0000-\u001f\u007f]/g, '');
+                    if (text)
+                        setEditing(e => (e ? { ...e, value: e.value + text } : e));
+                }
+                return;
+            }
             if (key.escape) {
                 setUsagePane(null);
                 return;
@@ -1931,9 +2027,43 @@ function App({ config: initialConfig }) {
             if (key.leftArrow || key.rightArrow) {
                 const at = USAGE_TABS.indexOf(usagePane);
                 const next = (at + (key.rightArrow ? 1 : USAGE_TABS.length - 1)) % USAGE_TABS.length;
+                setSettingRow(0);
                 void openUsagePane(USAGE_TABS[next]);
                 return;
             }
+            if (usagePane === 'settings') {
+                const field = CONFIG_SCHEMA[settingRow];
+                if (key.downArrow) {
+                    setSettingRow(r => Math.min(r + 1, CONFIG_SCHEMA.length - 1));
+                    return;
+                }
+                if (key.upArrow) {
+                    setSettingRow(r => Math.max(r - 1, 0));
+                    return;
+                }
+                if (!field)
+                    return;
+                // Enter acts: a boolean flips, a choice advances, anything typed opens for typing.
+                if (key.return || input === ' ') {
+                    if (field.type.kind === 'boolean' || field.type.kind === 'choice') {
+                        void applySetting(field, stepValue(field, stored[field.key], 1));
+                    }
+                    else {
+                        setEditing({ key: String(field.key), value: '' });
+                    }
+                    return;
+                }
+                // A digit starts typing a number straight away, without a separate "edit" gesture.
+                if (field.type.kind === 'number' && /^[0-9]$/.test(input)) {
+                    setEditing({ key: String(field.key), value: input });
+                    return;
+                }
+                if (input === 'x' && field.clearable) {
+                    void applySetting(field, undefined);
+                    return;
+                }
+                return;
+            }
         }
         // Shift+U → the update and guide panel.
         if (key.shift && (input === 'U' || input === 'u')) {
@@ -2142,6 +2272,7 @@ function App({ config: initialConfig }) {
             streamedRef.current = '';
             replyStartedRef.current = false;
             thinkingRef.current = { chars: 0, at: 0 };
+            incompleteRef.current = null;
             lastActivityRef.current = Date.now();
             setProviderFrames(0);
             liveToolRef.current = null;
@@ -2212,6 +2343,11 @@ function App({ config: initialConfig }) {
                                 recovered: turnRecoveredRef.current,
                             }, turnWordRef.current)[1] },
                     ]);
+                    // A run that stopped short says so, rather than letting the footer imply it finished.
+                    if (incompleteRef.current) {
+                        addSystem(incompleteRef.current);
+                        incompleteRef.current = null;
+                    }
                     setAgentState('completed');
                     setTimeout(() => setAgentState('ready'), 700);
                 }
@@ -2359,13 +2495,48 @@ function App({ config: initialConfig }) {
                                                         : 'starting', thinkingRef.current.chars > 0 && Date.now() - thinkingRef.current.at < 2_000
                                                 ? ` | thinking, ${fmtTokens(Math.round(thinkingRef.current.chars / 4))} reasoning tokens`
                                                 : '', ")"] })] }) }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: DIM, children: "esc to cancel and keep your input \u00B7 ctrl+c to exit" }) })] })) }), usagePane && (() => {
-                const width = Math.min(barWidth, 66);
+                const width = Math.min(barWidth, usagePane === 'settings' ? 96 : 66);
                 const inner = width - 4;
                 const BAR_W = Math.max(12, inner - 14);
                 const tabs = USAGE_TABS.map(t => t === usagePane ? `**${t[0].toUpperCase() + t.slice(1)}**` : t[0].toUpperCase() + t.slice(1)).join('   ');
                 /** A labelled bar with its percentage, the shape used for every proportion here. */
                 const meter = (fraction, label) => [`${bar(fraction, BAR_W)} ${Math.round(fraction * 100)}%`, `${label}`, ''];
                 const lines = [tabs, '---'];
+                if (usagePane === 'settings') {
+                    lines.push('**Settings**  — written to disk and applied now', '');
+                    // What is actually in force, not just what this file happens to hold. provider and
+                    // baseURL commonly come from ~/.koneckrc, and showing those as "(not set)" made a
+                    // configured session look unconfigured.
+                    const live = {
+                        provider: cfg.provider, model: cfg.model, baseURL: cfg.baseURL,
+                        effort, requireApproval: cfg.requireApproval, maxTurns: cfg.maxTurns,
+                        agentConcurrency: cfg.agentConcurrency, maxWidth: configMaxWidth, budget: cfg.budget,
+                    };
+                    const labelW = Math.max(...CONFIG_SCHEMA.map(f => f.label.length));
+                    for (const [i, f] of CONFIG_SCHEMA.entries()) {
+                        const selected = i === settingRow;
+                        const beingTyped = editing?.key === String(f.key);
+                        const here = stored[f.key] !== undefined;
+                        const value = here ? stored[f.key] : live[f.key];
+                        const shown = beingTyped
+                            ? `${editing.value}_`
+                            : displayValue(value) + (here || value === undefined ? '' : ' (inherited)');
+                        // The marker is what makes the selection legible without colour, which a panel line
+                        // drawn as one string cannot carry per-segment.
+                        const mark = selected ? '>' : ' ';
+                        const hint = !selected ? ''
+                            : f.type.kind === 'boolean' ? '   enter toggles'
+                                : f.type.kind === 'choice' ? `   enter cycles: ${f.type.choices.join(' / ')}`
+                                    : f.type.kind === 'number' ? `   type a number, enter to save${f.clearable ? ', x clears' : ''}`
+                                        : `   enter to type a value${f.clearable ? ', x clears' : ''}`;
+                        lines.push(`${mark} ${f.label.padEnd(labelW)}  ${selected ? '**' + shown + '**' : shown}${hint}`);
+                    }
+                    lines.push('');
+                    lines.push(editing
+                        ? 'Typing. **enter** saves, **esc** abandons.'
+                        : 'Up/down choose · enter change · x clear · left/right tabs');
+                    lines.push(`Saved to ${CONFIG_FILE}`);
+                }
                 if (usagePane === 'session') {
                     const wall = Date.now() - sessionStartRef.current;
                     const cost = estimateCost(cfg.model, stats.promptTokens, stats.completionTokens);