koneck 2.26.0 → 2.27.0

package/dist/ink-chat.js

@@ -41,6 +41,10 @@ import { describeActivity } from './activity.js';
 import { redactSecrets, containsSecret } from './redact.js';
 import { renderTrajectory } from './trajectory.js';
 import { describeSandbox, resolveSandbox } from './sandbox.js';
+import { doctorChecks, doctorReport } from './doctor.js';
+import { runQualityGate } from './quality-gate.js';
+import { listAuditEvents } from './audit.js';
+import { initializePolicy, loadPolicy, POLICY_FILE } from './policy.js';
 const CYAN = '#54D7E7';
 const GREEN = '#9BCB8F';
 const CRIMSON = '#E8878D';
@@ -506,6 +510,7 @@ const COMMANDS = [
     { cmd: '/model', desc: 'Show or set the model by name' },
     { cmd: '/provider', desc: 'Show or switch provider' },
     { cmd: '/status', desc: 'Provider, model, mode, tokens, cost, workspace' },
+    { cmd: '/doctor', desc: 'Check the active provider, workspace, and developer tools' },
     { cmd: '/revert', desc: 'Undo file edits KONECK made' },
     { cmd: '/sessions', desc: 'List running KONECK sessions and their state' },
     { cmd: '/send', desc: 'Hand work to another session: /send <repo> <instruction>' },
@@ -532,6 +537,9 @@ const COMMANDS = [
     { cmd: '/fork', desc: 'Copy this session and continue on the copy' },
     { cmd: '/archive', desc: 'Keep a session but hide it from /resume' },
     { cmd: '/diff', desc: 'Show uncommitted git changes' },
+    { cmd: '/quality', desc: 'Run the detected lint and test checks' },
+    { cmd: '/audit', desc: 'Show recent redacted tool activity' },
+    { cmd: '/policy', desc: 'Show or initialize workspace safety rules' },
     { cmd: '/verify', desc: 'Run the project test command' },
     { cmd: '/rewind', desc: 'Drop the last exchange from history' },
     { cmd: '/copy', desc: 'Copy the last response to the clipboard' },
@@ -580,19 +588,20 @@ const MAX_DIFF_FILES = 4;
 const USAGE_TABS = ['settings', 'session', 'context', 'models', 'limits'];
 const MIN_REPLY_WIDTH = 24; // below this a table cannot render legibly anyway
 const PICKER_MIN_ROWS = 6;
-const PICKER_MAX_ROWS = 14;
-const PROVIDER_PICKER_MAX_ROWS = 16;
+const PICKER_MAX_ROWS = 16;
 /**
  * Number of choices to keep visible in a palette.
  *
- * Provider choice is deliberately roomier than the other palettes: it is a small, finite set
- * and seeing every connection at once makes comparing and choosing it feel immediate. Larger
- * lists still leave room for the composer in a short terminal and can be paged through.
+ * A picker should feel like a real menu, not a letterbox. Sixteen rows keeps commands, models,
+ * files, sessions, and providers equally easy to scan; on short terminals it yields space to
+ * the composer and the rest remains available through search and paging.
  */
 export function pickerRowLimit(kind, itemCount, terminalRows) {
     const terminalBudget = Math.max(PICKER_MIN_ROWS, terminalRows - 8);
-    const ideal = kind === 'provider' ? PROVIDER_PICKER_MAX_ROWS : PICKER_MAX_ROWS;
-    return Math.min(itemCount, ideal, terminalBudget);
+    // Keep kind in the signature: it documents that this is the common policy for *every* picker
+    // and lets a future picker opt into a different policy without duplicating this calculation.
+    void kind;
+    return Math.min(itemCount, PICKER_MAX_ROWS, terminalBudget);
 }
 /**
  * Filters picker entries. Prefix matches rank above substring matches so typing "mo" offers
@@ -754,6 +763,7 @@ Slash commands:
                         /endpoint http://192.168.1.50:11434/v1
   /key                  Enter an API key for the current provider
   /status               Provider, model, mode, tokens, cost, CWD
+  /doctor               Diagnose the active provider, workspace, and developer tools
   /clear /reset /new    Clear conversation history
   /model [name]         Show or switch model
   /provider [name]      Show or switch provider
@@ -766,6 +776,9 @@ Slash commands:
   /cost                 Show session cost
   /memory               Show .koneck/MEMORY.md
   /diff                 Show uncommitted git changes
+  /quality              Run the detected lint and test checks
+  /audit [count]        Show recent redacted tool activity
+  /policy [init]        Show or create workspace safety rules
   /verify               Run project test command
   /agents               How parallel sub-agents are configured
   /subtask <task>       Run a task in an isolated sub-agent
@@ -810,8 +823,14 @@ function App({ config: initialConfig, clearFrame }) {
     const streamedRef = useRef('');
     /** When the live region last had something new to show, used to pick the repaint rate. */
     const lastActivityRef = useRef(Date.now());
-    /** Frames received before any content — proof the provider has the request and is working. */
-    const [providerFrames, setProviderFrames] = useState(0);
+    /**
+     * Frames received before any content — proof the provider has the request and is working.
+     *
+     * Gateways can emit hundreds of these while routing. This must not be React state: doing so
+     * repainted the complete terminal for each network frame, which is the primary source of the
+     * visible flashing during a response. The already-throttled live refresh reads this ref.
+     */
+    const providerFramesRef = useRef(0);
     /**
      * Reasoning characters this turn, and when the last one arrived.
      *
@@ -1040,7 +1059,7 @@ function App({ config: initialConfig, clearFrame }) {
             if (liveToolRef.current)
                 liveToolRef.current.output = line;
         },
-        onStreamActivity: (frames) => setProviderFrames(frames),
+        onStreamActivity: (frames) => { providerFramesRef.current = frames; },
         onIncomplete: (reason) => { incompleteRef.current = reason; },
         onToolsUnsupported: (model) => {
             // Said once per session, not once per turn — it is a property of the model, not an event.
@@ -1496,16 +1515,23 @@ function App({ config: initialConfig, clearFrame }) {
         }
         busyStart.current = Date.now();
         wordTimer.current = 0;
-        // The frame rate is the flicker rate. Every tick makes Ink erase and rewrite the whole live
-        // region — measured at 188 line-erases a second, which on a modest terminal reads as the
-        // bottom of the screen flashing. So the rate follows how much is actually happening: quick
-        // while output is arriving, and much slower once a single long command is all that is left,
-        // where a spinner turning four times a second says as much as one turning seven.
+        // The frame rate is the flicker rate. Every tick makes Ink update the live region, so network
+        // activity must be sampled for a human reader rather than mirrored frame-for-frame. A third
+        // of a second keeps streamed prose feeling live; an idle tool only needs a once-a-second
+        // heartbeat. This is particularly important in terminals that repaint an ANSI line update as
+        // a flash.
         let timer;
         const tick = () => {
             const elapsed = Date.now() - busyStart.current;
             const delay = currentDelay();
-            setAnim(a => ({ spin: (a.spin + 1) % SPINNER.length, shimmer: a.shimmer + 1, elapsed }));
+            // Do not animate several cells for every content refresh. The spinner moves once a second
+            // and the shimmer once every two seconds; the intervening refreshes are solely to reveal
+            // new streamed text.
+            setAnim({
+                spin: Math.floor(elapsed / 1_000) % SPINNER.length,
+                shimmer: Math.floor(elapsed / 2_000),
+                elapsed,
+            });
             wordTimer.current += 1;
             // Roughly every 60 seconds, whatever the current rate. Twenty-five felt churned on a long
             // run — the word is there to be read and enjoyed, not to reassure by moving.
@@ -1516,13 +1542,9 @@ function App({ config: initialConfig, clearFrame }) {
         };
         const currentDelay = () => {
             const idleFor = Date.now() - lastActivityRef.current;
-            // Two complaints pull against each other here: a fast repaint flickers, a slow one looks
-            // like the app has seized. 500ms was too far — at two frames a second the spinner visibly
-            // steps and reads as lag. These are the slowest rates at which the animation still reads
-            // as motion, which is the property that matters more than the byte count.
-            return idleFor < 2_000 ? 120 : idleFor > 15_000 ? 220 : 170;
+            return idleFor < 2_000 ? 350 : 1_000;
         };
-        timer = setTimeout(tick, 150);
+        timer = setTimeout(tick, 350);
         return () => clearTimeout(timer);
     }, [busy]);
     // A queued prompt runs the moment the agent is free again. Keyed on `busy` rather than done
@@ -1618,7 +1640,9 @@ function App({ config: initialConfig, clearFrame }) {
             id, task, provider: cfg.provider, model: cfg.model,
             cwd: cfg.cwd, startedAt: startedAtRef.current,
             turns: live.turns, totalTokens: live.totalTokens,
-        }, s?.messages ?? []);
+            // Timings persisted alongside the conversation: the messages say what was said, only this
+            // says where the time went.
+        }, s?.messages ?? [], s?.trajectory);
     }
     /**
      * Compresses this session's state into something worth sending. One small model call, capped
@@ -2119,6 +2143,22 @@ function App({ config: initialConfig, clearFrame }) {
                     `Cost       : ${costStr}`);
                 return;
             }
+            case '/doctor': {
+                // A session can change provider, endpoint, or workspace after startup. Running the same
+                // checks here, against the *active* provider, means a diagnosis describes this session
+                // rather than a stale global default.
+                addSystem(`**KONECK Doctor** — checking ${cfg.provider} and this workspace…`);
+                try {
+                    const checks = await doctorChecks(cfg.cwd, cfg.provider);
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(`**KONECK Doctor**\n\n${doctorReport(checks)}`);
+                }
+                catch (e) {
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(`Doctor could not finish: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                return;
+            }
             case '/clear':
             case '/reset':
             case '/new': {
@@ -2381,6 +2421,75 @@ function App({ config: initialConfig, clearFrame }) {
                 }
                 return;
             }
+            case '/quality': {
+                // The engine uses this exact gate after a coding turn. Exposing it in chat gives the user
+                // the same independent proof on demand, without the legacy TUI writing over Ink's frame.
+                addSystem('**Quality gate** — running detected lint and test checks…');
+                try {
+                    const result = await runQualityGate(cfg.cwd, { report: false });
+                    setRows(prev => prev.slice(0, -1));
+                    if (result.checks.length === 0) {
+                        addSystem('**Quality gate**\n\nNo lint or test command was detected for this workspace.');
+                        return;
+                    }
+                    const lines = result.checks.flatMap(check => {
+                        const state = check.passed ? 'PASS' : 'FAIL';
+                        const detail = check.output?.trim();
+                        const tail = !check.passed && detail
+                            ? `\n\n\`\`\`\n${detail.slice(-2_000)}\n\`\`\``
+                            : '';
+                        return [`**${state}**  ${check.label} — \`${check.command}\` (${fmtElapsed(check.durationMs)})${tail}`];
+                    });
+                    addSystem(`**Quality gate ${result.passed ? 'passed' : 'needs attention'}**\n\n` +
+                        lines.join('\n\n'));
+                }
+                catch (e) {
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(`Quality gate could not finish: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                return;
+            }
+            case '/audit': {
+                const requested = Number.parseInt(arg, 10);
+                const limit = Number.isFinite(requested) ? Math.max(1, Math.min(requested, 100)) : 20;
+                const events = await listAuditEvents(cfg.cwd, limit);
+                if (events.length === 0) {
+                    addSystem('No recorded tool activity yet. KONECK records redacted actions in `.koneck/audit/`.');
+                    return;
+                }
+                const lines = events.map(event => {
+                    const when = new Date(event.timestamp).toLocaleString();
+                    const state = event.outcome === 'success' ? 'OK' : 'FAIL';
+                    const action = Object.entries(event.action)
+                        .map(([key, value]) => `${key}=${String(value)}`)
+                        .join(' · ');
+                    return `${state.padEnd(4)} ${when}  ${event.tool}  ${action}  (${fmtElapsed(event.durationMs)})`;
+                });
+                addSystem(`**Recent tool activity** — ${events.length} event${events.length === 1 ? '' : 's'}\n\n${lines.join('\n')}`);
+                return;
+            }
+            case '/policy': {
+                if (arg.trim().toLowerCase() === 'init') {
+                    try {
+                        addSystem(await initializePolicy(cfg.cwd));
+                    }
+                    catch (e) {
+                        addSystem(`Could not create ${POLICY_FILE}: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                    return;
+                }
+                const policy = await loadPolicy(cfg.cwd);
+                if (!policy) {
+                    addSystem(`No workspace policy is active. Run \`/policy init\` to create \`${POLICY_FILE}\`.`);
+                    return;
+                }
+                addSystem(`**KONECK policy** — \`${POLICY_FILE}\`\n\n` +
+                    `Protected paths : ${policy.protectedPaths?.length ?? 0}\n` +
+                    `Write scopes    : ${policy.allowedWritePaths?.length ? policy.allowedWritePaths.join(', ') : 'unrestricted'}\n` +
+                    `Blocked commands: ${policy.blockedCommands?.length ?? 0}\n` +
+                    `Approval rules  : ${policy.requireApprovalFor?.join(', ') || 'none'}`);
+                return;
+            }
             case '/verify': {
                 const { detectProject } = await import('./project.js');
                 const project = await detectProject(cfg.cwd);
@@ -3403,7 +3512,7 @@ function App({ config: initialConfig, clearFrame }) {
             thinkingTextRef.current = '';
             incompleteRef.current = null;
             lastActivityRef.current = Date.now();
-            setProviderFrames(0);
+            providerFramesRef.current = 0;
             liveToolRef.current = null;
             charsRef.current = 0;
             realTokRef.current = 0;
@@ -3685,7 +3794,7 @@ function App({ config: initialConfig, clearFrame }) {
                                                 // A gateway routing to several backends sends content-free frames while it
                                                 // finds one. Saying "waiting for the first token" through that reads as a
                                                 // hang, when in fact the request was accepted and is being worked on.
-                                                : providerFrames > 0 ? `${cfg.provider} is holding the line, no output yet`
+                                                : providerFramesRef.current > 0 ? `${cfg.provider} is holding the line, no output yet`
                                                     : elapsedMs > 8_000 ? `no response from ${cfg.provider} yet`
                                                         : 'starting', thinkingRef.current.chars > 0 && Date.now() - thinkingRef.current.at < 2_000
                                                 ? ` | thinking, ${fmtTokens(Math.round(thinkingRef.current.chars / 4))} reasoning tokens`