klyro 0.1.3 → 0.1.5

package/dist/tui/app.js

@@ -1,17 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Ink app root — status line + scrollable transcript + input box.
- *
- * Owns the session state machine:
- *   - transcript: array of TranscriptItem (rendered by <Transcript/>)
- *   - status: snapshot for the <StatusLine/>
- *   - input: the current input-box buffer
- *
- * The actual agent loop runs externally; the app just listens for
- * RuntimeEvents via the onEvent callback wired by cli/repl.ts and
- * translates them into transcript/status updates.
+ * 1.4: history per project, multiline, Ctrl+C double, slash registry, Windows handling
  */
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { StatusLine } from './status.js';
 import { Transcript } from './transcript.js';
@@ -19,11 +11,60 @@ import { Header } from './header.js';
 import { ApprovalModal, TuiApprovalBridge } from './approval.js';
 import { PlanView } from './plan.js';
 import { parse as parseSlash } from '../cli/slash/parser.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { spawnSync } from 'node:child_process';
 let _itemCounter = 0;
 function nextId(prefix) {
     _itemCounter += 1;
     return `${prefix}-${_itemCounter}`;
 }
+function getGitBranch(cwd) {
+    try {
+        const r = spawnSync('git', ['branch', '--show-current'], { cwd, encoding: 'utf-8', timeout: 800, windowsHide: true });
+        if (r.status === 0 && r.stdout)
+            return r.stdout.trim().slice(0, 40);
+    }
+    catch { /* ignore */ }
+    return '';
+}
+function getHistoryPath() {
+    const home = os.homedir() || process.cwd();
+    return path.join(home, '.klyro', 'history');
+}
+function loadHistory(cwd) {
+    try {
+        const raw = fs.readFileSync(getHistoryPath(), 'utf-8');
+        const lines = raw.split('\n').filter(Boolean);
+        const out = [];
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.cwd === cwd && typeof obj.text === 'string')
+                    out.push(obj.text);
+            }
+            catch {
+                // legacy plain text per line
+                if (line.trim())
+                    out.push(line.trim());
+            }
+        }
+        return out.slice(-200);
+    }
+    catch {
+        return [];
+    }
+}
+function appendHistory(cwd, text) {
+    try {
+        const p = getHistoryPath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const entry = JSON.stringify({ cwd, text, ts: Date.now() });
+        fs.appendFileSync(p, entry + '\n', 'utf-8');
+    }
+    catch { /* ignore */ }
+}
 export function App(props) {
     const [transcript, setTranscript] = useState(props.initialTranscript ?? []);
     const [input, setInput] = useState('');
@@ -41,41 +82,176 @@ export function App(props) {
         status: 'idle',
         ...props.initialStatus,
     });
-    // Track bridge state to disable the input box while a prompt is up.
+    const [history, setHistory] = useState(() => loadHistory(props.cwd));
+    const historyIndexRef = useRef(-1);
+    const lastCtrlCRef = useRef(0);
+    const [gitBranch, setGitBranch] = useState(() => getGitBranch(props.cwd));
+    const [queued, setQueued] = useState(null);
+    useEffect(() => {
+        const t = setInterval(() => setGitBranch(getGitBranch(props.cwd)), 5000);
+        return () => clearInterval(t);
+    }, [props.cwd]);
     useEffect(() => {
         return bridge.subscribe((p) => setAwaitingApproval(p !== null));
     }, [bridge]);
     const append = useCallback((item) => {
-        setTranscript((prev) => [...prev, item]);
+        setTranscript((prev) => {
+            const last = prev[prev.length - 1];
+            if (last?.kind === 'text' &&
+                item.kind === 'text' &&
+                last.role === 'assistant' &&
+                item.role === 'assistant' &&
+                last.id === item.id) {
+                return [...prev.slice(0, -1), { ...last, text: last.text + item.text }];
+            }
+            return [...prev, item];
+        });
+    }, []);
+    const updateStatus = useCallback((s) => {
+        setStatus((prev) => ({ ...prev, ...s }));
     }, []);
+    const updatePlan = useCallback((p) => {
+        setPlan(p);
+        setPlanExpanded(true);
+    }, []);
+    const onMountedRef = useRef(props.onMounted);
+    useEffect(() => { onMountedRef.current = props.onMounted; }, [props.onMounted]);
     useEffect(() => {
+        onMountedRef.current?.({ append, updateStatus, updatePlan });
         globalThis.__klyroAppAppend = append;
-        globalThis.__klyroAppStatus = (s) => setStatus((prev) => ({ ...prev, ...s }));
-        globalThis.__klyroAppPlan = (p) => {
-            setPlan(p);
-            setPlanExpanded(true);
-        };
+        globalThis.__klyroAppStatus = updateStatus;
+        globalThis.__klyroAppPlan = updatePlan;
         return () => {
             delete globalThis.__klyroAppAppend;
             delete globalThis.__klyroAppStatus;
             delete globalThis.__klyroAppPlan;
         };
-    }, [append]);
+    }, [append, updateStatus, updatePlan]);
+    // Handle Windows raw-mode fallback warning
+    const [rawModeWarning, setRawModeWarning] = useState(null);
+    useEffect(() => {
+        try {
+            const stdin = process.stdin;
+            if (stdin.isTTY && typeof stdin.setRawMode !== 'function') {
+                setRawModeWarning('Raw mode not available (mintty) — input may be limited');
+            }
+        }
+        catch { /* ignore */ }
+    }, []);
+    // Queue next message if typed during stream (2.4)
+    useEffect(() => {
+        if (queued && status.status !== 'running' && !awaitingApproval) {
+            const toSend = queued;
+            setQueued(null);
+            const trimmed = toSend.trim();
+            if (!trimmed)
+                return;
+            append({ id: nextId('text'), kind: 'text', text: toSend, role: 'user' });
+            const cmd = parseSlash(trimmed);
+            if (cmd.kind === 'prompt')
+                void props.onPrompt(cmd.text);
+            else if (cmd.kind === 'plan') {
+                if (plan.length > 0)
+                    setPlanExpanded((v) => !v);
+            }
+            else
+                void props.onSlash(cmd);
+        }
+    }, [queued, status.status, awaitingApproval, plan.length, append]);
     useInput((inputStr, key) => {
-        if (status.status === 'running' || awaitingApproval)
+        if (awaitingApproval)
+            return;
+        if (status.status === 'running') {
+            if (key.ctrl && inputStr === 'c') {
+                void props.onSlash({ kind: 'quit' });
+                return;
+            }
+            if (key.return) {
+                const value = input.trim();
+                if (!value)
+                    return;
+                setQueued(value);
+                setInput('');
+                append({ id: nextId('text'), kind: 'text', text: `queued: ${value.slice(0, 80)}`, role: 'assistant' });
+                return;
+            }
+            if (!key.ctrl && !key.meta) {
+                // Show typing indicator but don't change input (queued mode)
+                return;
+            }
+            return;
+        }
+        // History navigation
+        if (key.upArrow) {
+            if (history.length === 0)
+                return;
+            if (historyIndexRef.current === -1)
+                historyIndexRef.current = history.length - 1;
+            else if (historyIndexRef.current > 0)
+                historyIndexRef.current--;
+            setInput(history[historyIndexRef.current] ?? '');
             return;
+        }
+        if (key.downArrow) {
+            if (historyIndexRef.current === -1)
+                return;
+            historyIndexRef.current++;
+            if (historyIndexRef.current >= history.length) {
+                historyIndexRef.current = -1;
+                setInput('');
+            }
+            else {
+                setInput(history[historyIndexRef.current] ?? '');
+            }
+            return;
+        }
+        // Ctrl+R search — simple: cycle history
+        if (key.ctrl && inputStr === 'r') {
+            if (history.length === 0)
+                return;
+            const term = input.toLowerCase();
+            for (let i = history.length - 1; i >= 0; i--) {
+                if (history[i].toLowerCase().includes(term)) {
+                    setInput(history[i]);
+                    return;
+                }
+            }
+            return;
+        }
         if (key.return) {
-            const value = input.trim();
-            setInput('');
-            if (!value)
+            // Multiline: trailing \ or Shift+Enter (where supported, key.shift is true)
+            // Ink's key object has `shift` for Shift+Enter on some terminals
+            const isShiftEnter = key.shift === true;
+            if (isShiftEnter || input.endsWith('\\')) {
+                // Replace trailing \ with newline, or just add newline for Shift+Enter
+                if (input.endsWith('\\'))
+                    setInput((v) => v.slice(0, -1) + '\n');
+                else
+                    setInput((v) => v + '\n');
                 return;
+            }
+            const value = input;
+            // Preserve newlines for bracketed paste — don't trim inner newlines, only outer
+            const trimmedOuter = value.replace(/^\s+|\s+$/g, '');
+            if (!trimmedOuter) {
+                setInput('');
+                return;
+            }
+            // Check for Ctrl+C double at empty prompt handled below, but here handle submit
+            setInput('');
+            historyIndexRef.current = -1;
+            // Save to history
+            setHistory((prev) => {
+                const next = [...prev, value];
+                appendHistory(props.cwd, value);
+                return next.slice(-200);
+            });
             append({ id: nextId('text'), kind: 'text', text: value, role: 'user' });
-            const cmd = parseSlash(value);
+            const cmd = parseSlash(trimmedOuter);
             if (cmd.kind === 'prompt') {
                 void props.onPrompt(cmd.text);
             }
             else if (cmd.kind === 'plan') {
-                // Local UI command — toggle the plan view inline.
                 if (plan.length > 0)
                     setPlanExpanded((v) => !v);
             }
@@ -88,13 +264,39 @@ export function App(props) {
             setInput((v) => v.slice(0, -1));
             return;
         }
+        // Ctrl+C double at empty prompt exits
         if (key.ctrl && inputStr === 'c') {
+            if (input === '') {
+                const now = Date.now();
+                if (now - lastCtrlCRef.current < 1500) {
+                    void props.onSlash({ kind: 'quit' });
+                    return;
+                }
+                lastCtrlCRef.current = now;
+                append({ id: nextId('text'), kind: 'text', text: '(press Ctrl+C again to exit)', role: 'assistant' });
+                return;
+            }
+            // Single Ctrl+C cancels input
+            setInput('');
+            return;
+        }
+        if (key.ctrl && inputStr === 'd') {
             void props.onSlash({ kind: 'quit' });
             return;
         }
+        if (key.ctrl && inputStr === 'l') {
+            // Clear — keep session but clear transcript marker
+            append({ id: nextId('text'), kind: 'text', text: '(cleared)', role: 'assistant' });
+            return;
+        }
+        // Handle bracketed paste: inputStr may contain \r\n or multiple lines
         if (!key.ctrl && !key.meta) {
-            setInput((v) => v + inputStr);
+            // Preserve all characters including newlines from paste
+            // Normalize \r\n to \n
+            const normalized = inputStr.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            setInput((v) => v + normalized);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Header, { cwd: props.cwd, model: status.model, step: status.step, maxSteps: status.maxSteps }), _jsx(StatusLine, { snapshot: status }), plan.length > 0 ? (_jsx(PlanView, { steps: plan, expanded: planExpanded, onToggle: () => setPlanExpanded((v) => !v) })) : null, _jsx(Transcript, { items: transcript }), awaitingApproval ? _jsx(ApprovalModal, { bridge: bridge }) : null, _jsxs(Box, { borderStyle: "single", borderColor: awaitingApproval ? 'yellow' : 'gray', paddingX: 1, children: [_jsx(Text, { color: "gray", children: awaitingApproval ? '! ' : '> ' }), _jsx(Text, { children: awaitingApproval ? '(awaiting approval — see above)' : input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] })] }));
+    const promptStr = `klyro › ${path.basename(props.cwd)}${gitBranch ? ` (${gitBranch})` : ''}`;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Header, { cwd: props.cwd, model: status.model, step: status.step, maxSteps: status.maxSteps }), rawModeWarning ? _jsx(Box, { children: _jsx(Text, { color: "yellow", children: rawModeWarning }) }) : null, _jsx(StatusLine, { snapshot: status }), plan.length > 0 ? (_jsx(PlanView, { steps: plan, expanded: planExpanded, onToggle: () => setPlanExpanded((v) => !v) })) : null, _jsx(Transcript, { items: transcript }), awaitingApproval ? _jsx(ApprovalModal, { bridge: bridge }) : null, _jsxs(Box, { borderStyle: "single", borderColor: awaitingApproval ? 'yellow' : 'gray', paddingX: 1, children: [_jsx(Text, { color: "gray", children: awaitingApproval ? '! ' : `${promptStr} ` }), _jsx(Text, { children: awaitingApproval ? '(awaiting approval — see above)' : input }), status.status === 'running' ? _jsx(Text, { color: "cyan", children: " \u258D" }) : _jsx(Text, { children: "\u258D" })] }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "Tab: slash completion \u00B7 Shift+Enter: newline \u00B7 Ctrl+C twice: exit \u00B7 Ctrl+R: history" }) })] }));
 }

package/dist/tui/approval.js

@@ -56,13 +56,34 @@ export function ApprovalModal({ bridge }) {
     useEffect(() => {
         return bridge.subscribe((p) => setPending(p?.req ?? null));
     }, [bridge]);
+    const [explain, setExplain] = useState(false);
     useInput((inputStr, key) => {
         if (!pending)
             return;
         const c = inputStr.toLowerCase();
-        if (c === 'y' || c === 'a' || c === 'd' || c === 'n') {
-            const choice = (c === 'y' || c === 'a') ? (c === 'a' ? 'always' : 'allow') : 'deny';
-            bridge.resolve(choice);
+        if (c === 'y') {
+            bridge.resolve('allow');
+            return;
+        }
+        if (c === 'a') {
+            bridge.resolve('always');
+            return;
+        }
+        if (c === 'A') {
+            bridge.resolve('always');
+            return;
+        }
+        if (c === 'd' || c === 'n') {
+            bridge.resolve('deny');
+            return;
+        }
+        if (c === 'e') {
+            // Edit: for MVP, treat as deny with edit hint — model will be told to re-read and retry
+            bridge.resolve('deny');
+            return;
+        }
+        if (c === '?') {
+            setExplain((v) => !v);
             return;
         }
         if (key.return) {
@@ -72,5 +93,5 @@ export function ApprovalModal({ bridge }) {
     });
     if (!pending)
         return null;
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", paddingX: 1, marginY: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["\u26A0 approval needed \u2014 ", pending.toolName] }), _jsxs(Text, { color: "gray", children: ["  reason: ", pending.reason] }), pending.summary ? _jsxs(Text, { children: ["  ", pending.summary] }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "green", children: "[y] allow" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "green", children: "[a] always allow" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "red", children: "[d] deny" }), _jsx(Text, { color: "gray", children: "  (Enter = deny)" })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", paddingX: 1, marginY: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["\u26A0 approval needed \u2014 ", pending.toolName] }), _jsxs(Text, { color: "gray", children: ["  reason: ", pending.reason] }), pending.summary ? _jsxs(Text, { children: ["  ", pending.summary] }) : null, explain ? _jsxs(Text, { color: "cyan", children: ["  Explain: This tool will ", pending.toolName, " with the shown args. [y] once, [a] session, [A] always\u2192settings, [n] deny, [e] edit, [?] toggle help."] }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "green", children: "[y] once" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "green", children: "[a] session" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "green", children: "[A] always" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "red", children: "[n] deny" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "yellow", children: "[e] edit" }), _jsx(Text, { color: "gray", children: "  " }), _jsx(Text, { color: "cyan", children: "[?] explain" }), _jsx(Text, { color: "gray", children: "  (Enter = deny)" })] })] }));
 }

package/dist/tui/approval.test.js

@@ -47,7 +47,7 @@ describe('ApprovalModal', () => {
         expect(out).toContain('shell_exec');
         expect(out).toContain('destructive');
         expect(out).toContain('rm -rf /');
-        expect(out).toContain('allow');
+        expect(out).toContain('once');
         expect(out).toContain('deny');
         bridge.resolve('deny');
         await promise;

package/dist/tui/snapshot.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Snapshot tests for the full TUI App — render various states and assert
+ * the exact visible frame. This is the "what does the user actually see"
+ * ground truth.
+ */
+export {};

package/dist/tui/snapshot.test.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Snapshot tests for the full TUI App — render various states and assert
+ * the exact visible frame. This is the "what does the user actually see"
+ * ground truth.
+ */
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { App } from './app.js';
+const DEFAULT_PROPS = {
+    cwd: '/projects/demo',
+    onPrompt: async () => { },
+    onSlash: async () => { },
+};
+describe('App visual snapshot', () => {
+    it('renders header + statusline + transcript + input at idle', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 } }));
+        const frame = lastFrame();
+        // Header should be visible (uppercase KLYRO as rendered)
+        expect(frame).toContain('KLYRO');
+        expect(frame).toContain('demo'); // cwd basename
+        expect(frame).toContain('gpt-4o-mini');
+        // Status line should show
+        expect(frame).toMatch(/idle/i);
+        // Input prompt should be visible (klyro › per 1.4)
+        expect(frame).toMatch(/klyro|›/);
+    });
+    it('renders a transcript with assistant text', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [
+                { id: 'u1', kind: 'text', text: 'hello', role: 'user' },
+                { id: 'a1', kind: 'text', text: 'hi there', role: 'assistant' },
+            ] }));
+        const frame = lastFrame();
+        expect(frame).toContain('hello');
+        expect(frame).toContain('hi there');
+    });
+    it('does not render plan view when plan is empty', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [] }));
+        const frame = lastFrame();
+        // When plan is empty, no plan section should be visible
+        expect(frame).not.toContain('Plan');
+    });
+    it('renders plan view when plan is populated via mounted hooks', async () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 } }));
+        const g = globalThis;
+        // Poll for hooks installed by useEffect (avoids flaky fixed timeout)
+        for (let i = 0; i < 10 && !g.__klyroAppPlan; i++)
+            await new Promise((r) => setTimeout(r, 10));
+        g.__klyroAppPlan?.([
+            { id: '1', title: 'Read files', status: 'done' },
+            { id: '2', title: 'Edit code', status: 'in_progress', files: ['src/x.ts'] },
+        ]);
+        await new Promise((r) => setTimeout(r, 20));
+        const frame = lastFrame();
+        expect(frame).toContain('Read files');
+        expect(frame).toContain('Edit code');
+    });
+    it('renders file_changed inline (the colored line)', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [
+                { id: 'fc1', kind: 'file_changed', path: 'src/foo.ts', op: 'modified' },
+            ] }));
+        const frame = lastFrame();
+        expect(frame).toContain('src/foo.ts');
+        expect(frame).toMatch(/modified|\~/);
+    });
+    it('diff transcript item renders the diff box', () => {
+        const { lastFrame } = render(_jsx(App, { ...DEFAULT_PROPS, initialModel: "gpt-4o-mini", maxSteps: 30, initialStatus: { status: 'idle', model: 'gpt-4o-mini', step: 0, maxSteps: 30, usageInput: 0, usageOutput: 0, repairs: 0 }, initialTranscript: [
+                {
+                    id: 'd1',
+                    kind: 'diff',
+                    summary: '1 file(s) changed',
+                    hunks: [{
+                            path: 'src/x.ts',
+                            lines: [
+                                { kind: 'header', text: '@@ -1 +1 @@' },
+                                { kind: 'remove', text: 'const a = 1;' },
+                                { kind: 'add', text: 'const a = 2;' },
+                            ],
+                        }],
+                },
+            ] }));
+        const frame = lastFrame();
+        expect(frame).toContain('src/x.ts');
+        expect(frame).toContain('const a = 2;');
+        expect(frame).toContain('+ ');
+    });
+});

package/dist/tui/status.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text, Box } from 'ink';
+import { estimateCost } from '../providers/model-info.js';
 export function StatusLine({ snapshot }) {
     const { model, step, maxSteps, usageInput, usageOutput, repairs, status } = snapshot;
     const statusColor = status === 'running' ? 'cyan' :
@@ -9,5 +10,8 @@ export function StatusLine({ snapshot }) {
                     'gray';
     const usageKbIn = (usageInput / 1024).toFixed(1);
     const usageKbOut = (usageOutput / 1024).toFixed(1);
-    return (_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "model " }), _jsx(Text, { bold: true, children: model }), _jsx(Text, { color: "gray", children: "  step " }), _jsx(Text, { bold: true, children: step }), _jsxs(Text, { color: "gray", children: ["/", maxSteps] }), _jsx(Text, { color: "gray", children: "  repairs " }), _jsx(Text, { bold: true, children: repairs })] }), _jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "tokens " }), _jsxs(Text, { color: "cyan", children: [usageKbIn, "K"] }), _jsx(Text, { color: "gray", children: " in / " }), _jsxs(Text, { color: "cyan", children: [usageKbOut, "K"] }), _jsx(Text, { color: "gray", children: " out" })] }), _jsx(Text, { children: _jsxs(Text, { color: statusColor, children: ["\u25CF ", status] }) })] }));
+    const cost = estimateCost(model, usageInput, usageOutput);
+    const costStr = cost > 0 ? `$${cost.toFixed(3)}` : `$0.000`;
+    const ctxPct = Math.min(99, Math.round(((usageInput + usageOutput) / 128000) * 100));
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "model " }), _jsx(Text, { bold: true, children: model }), _jsx(Text, { color: "gray", children: "  step " }), _jsx(Text, { bold: true, children: step }), _jsxs(Text, { color: "gray", children: ["/", maxSteps] }), _jsx(Text, { color: "gray", children: "  repairs " }), _jsx(Text, { bold: true, children: repairs })] }), _jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "tokens " }), _jsxs(Text, { color: "cyan", children: [usageKbIn, "K"] }), _jsx(Text, { color: "gray", children: " in / " }), _jsxs(Text, { color: "cyan", children: [usageKbOut, "K"] }), _jsx(Text, { color: "gray", children: " \u00B7 " }), _jsx(Text, { color: "green", children: costStr }), _jsxs(Text, { color: "gray", children: [" \u00B7 ", ctxPct, "% ctx"] })] }), _jsx(Text, { children: _jsxs(Text, { color: statusColor, children: ["\u25CF ", status] }) })] }));
 }

package/dist/util/log.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 1.5 — Logging (pino JSON to ~/.klyro/logs/klyro-YYYY-MM-DD.log, 14-day rotation, secret redaction)
+ * Minimal implementation: JSONL append, redaction via secret-redactor, --debug pretty tee.
+ */
+export interface LogEntry {
+    ts: string;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    msg: string;
+    data?: unknown;
+}
+export declare function log(entry: LogEntry): Promise<void>;
+export declare function logSync(entry: LogEntry): void;

package/dist/util/log.js

@@ -0,0 +1,75 @@
+/**
+ * 1.5 — Logging (pino JSON to ~/.klyro/logs/klyro-YYYY-MM-DD.log, 14-day rotation, secret redaction)
+ * Minimal implementation: JSONL append, redaction via secret-redactor, --debug pretty tee.
+ */
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { redact } from '../policy/secret-redactor.js';
+function getLogDir() {
+    if (process.env.KLYRO_LOG_DIR)
+        return process.env.KLYRO_LOG_DIR;
+    const home = os.homedir() || process.cwd();
+    return path.join(home, '.klyro', 'logs');
+}
+function getLogFile() {
+    const dir = getLogDir();
+    const date = new Date().toISOString().slice(0, 10);
+    return path.join(dir, `klyro-${date}.log`);
+}
+async function rotateLogs() {
+    const dir = getLogDir();
+    try {
+        const files = await fs.readdir(dir);
+        const cutoff = Date.now() - 14 * 24 * 60 * 60 * 1000;
+        for (const f of files) {
+            if (!f.startsWith('klyro-') || !f.endsWith('.log'))
+                continue;
+            const fp = path.join(dir, f);
+            try {
+                const st = await fs.stat(fp);
+                if (st.mtimeMs < cutoff)
+                    await fs.unlink(fp);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore dir not exists */ }
+}
+let _rotateDone = false;
+export async function log(entry) {
+    if (!_rotateDone) {
+        _rotateDone = true;
+        rotateLogs().catch(() => undefined);
+    }
+    const redactedMsg = redact(entry.msg);
+    const redactedData = entry.data ? JSON.parse(redact(JSON.stringify(entry.data))) : undefined;
+    const line = JSON.stringify({ ...entry, msg: redactedMsg, data: redactedData }) + '\n';
+    const file = getLogFile();
+    try {
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        await fs.appendFile(file, line, 'utf-8');
+    }
+    catch { /* ignore */ }
+    if (process.env.KLYRO_LOG_LEVEL === 'debug' || process.env.DEBUG) {
+        const pretty = `[${entry.level}] ${entry.msg}${entry.data ? ' ' + JSON.stringify(entry.data) : ''}`;
+        if (entry.level === 'error')
+            process.stderr.write(pretty + '\n');
+        else
+            process.stdout.write(pretty + '\n');
+    }
+}
+export function logSync(entry) {
+    const redactedMsg = redact(entry.msg);
+    const line = JSON.stringify({ ...entry, msg: redactedMsg, ts: entry.ts }) + '\n';
+    const file = getLogFile();
+    try {
+        fsSync.mkdirSync(path.dirname(file), { recursive: true });
+        fsSync.appendFileSync(file, line, 'utf-8');
+    }
+    catch { /* ignore */ }
+    if (process.env.KLYRO_LOG_LEVEL === 'debug') {
+        process.stderr.write(`[${entry.level}] ${redactedMsg}\n`);
+    }
+}

package/dist/verification/auto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Level 8 — auto-detect verification command from project.
+ * Picks the most relevant check for the repo so the harness
+ * can verify without explicit user config.
+ */
+export declare function detectVerifyCommand(cwd: string): string | null;
+/** Human-readable reason why a command was chosen. */
+export declare function describeVerifyCommand(cmd: string | null): string;

package/dist/verification/auto.js

@@ -0,0 +1,52 @@
+/**
+ * Level 8 — auto-detect verification command from project.
+ * Picks the most relevant check for the repo so the harness
+ * can verify without explicit user config.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function detectVerifyCommand(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const raw = fs.readFileSync(pkgPath, 'utf-8');
+            const json = JSON.parse(raw);
+            // Prefer test if available — it's the strongest signal
+            if (json.scripts?.test) {
+                if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+                    return 'pnpm test';
+                if (fs.existsSync(path.join(cwd, 'yarn.lock')))
+                    return 'yarn test';
+                if (fs.existsSync(path.join(cwd, 'bun.lockb')))
+                    return 'bun test';
+                return 'npm test';
+            }
+            if (json.scripts?.build)
+                return 'npm run build';
+        }
+        catch {
+            // ignore parse errors
+        }
+        if (fs.existsSync(path.join(cwd, 'tsconfig.json')))
+            return 'npx tsc --noEmit';
+    }
+    if (fs.existsSync(path.join(cwd, 'tsconfig.json')))
+        return 'npx tsc --noEmit';
+    if (fs.existsSync(path.join(cwd, 'Makefile')) || fs.existsSync(path.join(cwd, 'makefile')))
+        return 'make test';
+    if (fs.existsSync(path.join(cwd, 'pyproject.toml')) || fs.existsSync(path.join(cwd, 'requirements.txt')))
+        return 'pytest';
+    if (fs.existsSync(path.join(cwd, 'go.mod')))
+        return 'go test ./...';
+    return null;
+}
+/** Human-readable reason why a command was chosen. */
+export function describeVerifyCommand(cmd) {
+    if (!cmd)
+        return 'no verification command auto-detected';
+    if (cmd.includes('test'))
+        return `auto-detected: ${cmd}`;
+    if (cmd.includes('tsc'))
+        return `auto-detected: ${cmd} (typecheck)`;
+    return `auto-detected: ${cmd}`;
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "klyro",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "klyro": "dist/index.js"
+    "klyro": "dist/index.js",
+    "ky": "dist/index.js"
   },
   "files": [
     "dist",