miii-cli 0.2.4 → 0.2.5

package/dist/tui/InputBar.js

@@ -1,53 +1,29 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useCallback, useRef, useEffect } from 'react';
+import { useState, useCallback, useRef } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import { InputArea } from './components/InputArea.js';
 import { ModelPicker } from './components/ModelPicker.js';
 import { Divider } from './components/StatusBar.js';
-import { chat } from '../llm/stream.js';
-import { listModels, pullModel } from '../llm/ollama.js';
-import { StreamParser, extractBareToolCall } from '../parser/stream-parser.js';
-import { tools, getSystemPrompt } from '../tools/index.js';
+import { tools } from '../tools/index.js';
 import { readFile } from '../files/ops.js';
-import { resolve } from 'path';
+import { generateId } from '../types.js';
 import * as printer from './printer.js';
 import { loadSession, saveSession, listSessions } from '../sessions.js';
-import { shouldCompact, compactContext, fileEditContext } from '../tasks/compactor.js';
 import { MacroQueue, MicroQueue } from '../tasks/queue.js';
 import { TaskExecutor } from '../tasks/executor.js';
-import { generateId } from '../types.js';
+import { fileEditContext } from '../tasks/compactor.js';
+import { StreamParser } from '../parser/stream-parser.js';
+import { chat } from '../llm/stream.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { getTavilyKey, saveTavilyKey } from '../tavily/client.js';
+import { getSystemPrompt } from '../tools/index.js';
+import { THINKING_PHRASES, SPARKLE } from './thinking.js';
+import { buildGitContext, looksCodeRelated } from './git-context.js';
+import { useSession } from './hooks/useSession.js';
+import { useModelPicker } from './hooks/useModelPicker.js';
+import { useRunLoop } from './hooks/useRunLoop.js';
 const gitRun = promisify(exec);
-const MAX_TOOL_DEPTH = 6;
-const THINKING_PHRASES = [
-    'oh wow, a question. let me pretend to care…',
-    'consulting the void…',
-    'making something up, just a sec…',
-    'definitely not hallucinating right now…',
-    'running 47 mental tabs…',
-    'staring into the abyss (it blinked)…',
-    'calculating your fate, no pressure…',
-    'doing the thinking you pay me for…',
-    'processing your questionable life choices…',
-    'summoning coherent thoughts, rarely works…',
-    'asking my imaginary friend for help…',
-    'pretending this is a hard problem…',
-    'yes, yes, very interesting. anyway…',
-    'googling it (not really, I can\'t)…',
-    'simulating intelligence… please wait…',
-    'having a brief existential crisis…',
-    'cross-referencing vibes…',
-    'totally not making this up…',
-    'the answer is 42. now finding the question…',
-    'my other tab is loading…',
-    'channelling the spirit of stack overflow…',
-    'trying not to confidently be wrong…',
-    'applying artificial to the intelligence…',
-    'phoning a friend who also doesn\'t know…',
-    'checking if this is even my problem to solve…',
-];
-const SPARKLE = ['✦', '✧', '✶', '✷', '✸', '✹'];
 function buildAtContext(text) {
     const refs = [...text.matchAll(/@([\w./\-]+)/g)];
     if (!refs.length)
@@ -63,255 +39,21 @@ function buildAtContext(text) {
     }
     return parts.length ? parts.join('\n\n') + '\n\n' : '';
 }
-const CODE_PATTERN = /\.(ts|js|tsx|jsx|py|go|rs|java|rb|sh|css|html|json|yaml|yml)\b|function|class|import|export|const|let|var|def |async|await|error|bug|fix|refactor|implement|`[^`]+`/i;
-function looksCodeRelated(text) {
-    return text.length >= 10 && CODE_PATTERN.test(text);
-}
-async function buildGitContext(cwd, lastStatusRef) {
-    try {
-        const { stdout } = await gitRun('git status --short', { cwd, timeout: 5000 });
-        const status = stdout.trim();
-        if (!status || status === lastStatusRef.current)
-            return { prefix: '', label: '' };
-        lastStatusRef.current = status;
-        const MAX_TOTAL = 40_000;
-        const MAX_FILE = 15_000;
-        let total = 0;
-        const parts = [];
-        const skipped = [];
-        for (const line of status.split('\n')) {
-            const code = line.slice(0, 2);
-            if (code.includes('D'))
-                continue;
-            const raw = line.slice(3).trim().replace(/^"|"$/g, '');
-            const rel = raw.includes(' -> ') ? raw.split(' -> ')[1] : raw;
-            if (!rel)
-                continue;
-            try {
-                const content = readFile(resolve(cwd, rel));
-                if (!content || content.length > MAX_FILE) {
-                    skipped.push(rel);
-                    continue;
-                }
-                total += content.length;
-                if (total > MAX_TOTAL) {
-                    skipped.push(rel);
-                    continue;
-                }
-                parts.push(`<file path="${rel}">\n${content}\n</file>`);
-            }
-            catch {
-                skipped.push(rel);
-            }
-        }
-        if (!parts.length && !skipped.length)
-            return { prefix: '', label: '' };
-        let prefix = '[Auto-context: git-changed files]\n' + parts.join('\n') + '\n';
-        if (skipped.length)
-            prefix += `Files changed but too large to auto-load: ${skipped.join(', ')}\n`;
-        prefix += '\n';
-        const label = `auto-loaded ${parts.length} changed file(s)${skipped.length ? `, skipped ${skipped.length} (too large)` : ''}`;
-        return { prefix, label };
-    }
-    catch {
-        return { prefix: '', label: '' };
-    }
-}
-export function InputBar({ config, skills, cwd, session }) {
+export function InputBar({ config, skills, cwd, session, version }) {
     const { stdout } = useStdout();
     const cols = stdout.columns ?? 80;
-    const [status, setStatus] = useState('idle');
-    const [tick, setTick] = useState(0);
-    const [currentModel, setCurrentModel] = useState(config.model);
-    const [sessionName, setSessionName] = useState(session);
-    const [currentTool, setCurrentTool] = useState();
-    const [taskLabel, setTaskLabel] = useState();
     const [planningMode, setPlanningMode] = useState(false);
-    // picker opens on mount — force model selection every launch
-    const [pickerOpen, setPickerOpen] = useState(true);
-    const [pickerModels, setPickerModels] = useState([]);
-    const [pickerLoading, setPickerLoading] = useState(false);
-    const [pickerError, setPickerError] = useState();
-    const [pullState, setPullState] = useState();
-    const abortRef = useRef(null);
-    const pullAbortRef = useRef(null);
-    const thinkingStartRef = useRef(0);
     const macroQueueRef = useRef(new MacroQueue());
     const executorRef = useRef(new TaskExecutor(tools));
-    const systemPromptRef = useRef(getSystemPrompt(`\n- CWD: ${cwd}`));
-    const currentModelRef = useRef(currentModel);
-    const sessionNameRef = useRef(sessionName);
-    const historyRef = useRef([]);
-    const saveTimerRef = useRef(null);
     const lastGitStatusRef = useRef('');
-    function scheduleSave() {
-        if (saveTimerRef.current)
-            clearTimeout(saveTimerRef.current);
-        saveTimerRef.current = setTimeout(() => {
-            saveSession(sessionNameRef.current, historyRef.current);
-            saveTimerRef.current = null;
-        }, 2000);
-    }
-    function pushHistory(msg) {
-        historyRef.current.push(msg);
-        if (historyRef.current.length > 100)
-            historyRef.current.splice(0, historyRef.current.length - 100);
-        scheduleSave();
-    }
-    useEffect(() => { currentModelRef.current = currentModel; }, [currentModel]);
-    useEffect(() => { sessionNameRef.current = sessionName; }, [sessionName]);
-    // mount: load session history + fetch models for initial picker
-    useEffect(() => {
-        const history = loadSession(session);
-        historyRef.current = history;
-        if (history.length) {
-            printer.systemMsg(`resumed "${session}" — ${history.length} messages`);
-        }
-        setPickerLoading(true);
-        listModels(config.baseUrl)
-            .then(m => { setPickerModels(m); setPickerLoading(false); })
-            .catch(e => { setPickerError(String(e)); setPickerLoading(false); });
-    }, []);
-    useEffect(() => {
-        if (status === 'idle')
-            return;
-        const t = setInterval(() => setTick(n => n + 1), 80);
-        return () => clearInterval(t);
-    }, [status]);
-    function buildContext(extra) {
-        const ctx = [{ role: 'system', content: systemPromptRef.current }];
-        ctx.push(...historyRef.current);
-        if (extra)
-            ctx.push(extra);
-        return ctx;
-    }
-    const runLoop = useCallback(async (contextMsgs, depth = 0, goal) => {
-        if (depth >= MAX_TOOL_DEPTH) {
-            setStatus('idle');
-            return;
-        }
-        setStatus('thinking');
-        if (depth === 0)
-            thinkingStartRef.current = Date.now();
-        // Auto-compact context when local model starts losing the thread
-        const msgs = shouldCompact(contextMsgs) ? compactContext(contextMsgs, goal) : contextMsgs;
-        abortRef.current = new AbortController();
-        await chat({
-            provider: config.provider,
-            model: currentModelRef.current,
-            baseUrl: config.baseUrl,
-            messages: msgs,
-            signal: abortRef.current.signal,
-            async onDone(fullText) {
-                const pendingTools = [];
-                const parser = new StreamParser();
-                for (const item of [...parser.feed(fullText), ...parser.flush()]) {
-                    if (item.type === 'tool_call')
-                        pendingTools.push({ name: item.toolName, args: item.toolArgs });
-                }
-                // Fallback: bare JSON tool call without <tool_call> wrapper
-                if (!pendingTools.length) {
-                    const bare = extractBareToolCall(fullText);
-                    if (bare)
-                        pendingTools.push({ name: bare.name, args: bare.args });
-                }
-                printer.assistantMsg(fullText);
-                pushHistory({ role: 'assistant', content: fullText });
-                if (!pendingTools.length) {
-                    // Model printed code as text instead of using tools — nudge it
-                    const hasFencedCode = /```[\w]*\n[\s\S]{50,}?\n```/.test(fullText);
-                    if (hasFencedCode && depth < MAX_TOOL_DEPTH - 1) {
-                        const nudge = {
-                            role: 'user',
-                            content: 'You showed code in your response but did not use any file tools. Use edit_file or patch_file to actually write the changes to disk.',
-                        };
-                        const next = [...msgs, { role: 'assistant', content: fullText }, nudge];
-                        await runLoop(next, depth + 1, goal);
-                        return;
-                    }
-                    setStatus('idle');
-                    return;
-                }
-                setStatus('tool');
-                const next = [...msgs, { role: 'assistant', content: fullText }];
-                try {
-                    for (const tc of pendingTools) {
-                        const tool = tools.find(t => t.name === tc.name);
-                        setCurrentTool(tc.name);
-                        if (tool) {
-                            try {
-                                const result = await tool.execute(tc.args);
-                                printer.toolMsg(tc.name, result);
-                                next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` });
-                            }
-                            catch (e) {
-                                const err = `Tool ${tc.name} error: ${e}`;
-                                printer.errorMsg(err);
-                                next.push({ role: 'user', content: err });
-                            }
-                        }
-                        else {
-                            printer.errorMsg(`unknown tool: ${tc.name}`);
-                            next.push({ role: 'user', content: `unknown tool: ${tc.name}` });
-                        }
-                    }
-                }
-                finally {
-                    setCurrentTool(undefined);
-                }
-                await runLoop(next, depth + 1, goal);
-            },
-            onError(err) {
-                if (err.name !== 'AbortError')
-                    printer.errorMsg(err.message);
-                setStatus('idle');
-            },
-        });
-    }, [config]);
-    // ─── model picker ──────────────────────────────────────────────────────────
-    const openPicker = useCallback(async () => {
-        setPickerOpen(true);
-        setPickerLoading(true);
-        setPickerError(undefined);
-        try {
-            setPickerModels(await listModels(config.baseUrl));
-        }
-        catch (e) {
-            setPickerError(String(e));
-        }
-        finally {
-            setPickerLoading(false);
-        }
-    }, [config.baseUrl]);
-    const handleModelSelect = useCallback((name) => {
-        setCurrentModel(name);
-        currentModelRef.current = name;
-        setPickerOpen(false);
-        printer.systemMsg(`model → ${name}`);
-    }, []);
-    const handleModelPull = useCallback(async (name) => {
-        setPullState({ name, status: 'starting...', pct: undefined });
-        pullAbortRef.current = new AbortController();
-        try {
-            await pullModel(config.baseUrl, name, (s, p) => setPullState({ name, status: s, pct: p }), pullAbortRef.current.signal);
-            setPickerModels(await listModels(config.baseUrl));
-            setPullState(undefined);
-            setCurrentModel(name);
-            currentModelRef.current = name;
-            setPickerOpen(false);
-            printer.systemMsg(`pulled ${name} → active`);
-        }
-        catch (e) {
-            setPullState(undefined);
-            setPickerError(`pull failed: ${e}`);
-        }
-    }, [config.baseUrl]);
+    const { setSessionName, sessionNameRef, historyRef, saveTimerRef, systemPromptRef, pushHistory, buildContext, } = useSession(session, cwd, config);
+    const { currentModel, setCurrentModel, currentModelRef, pickerOpen, setPickerOpen, pickerModels, pickerLoading, pickerError, pullState, openPicker, handleModelSelect, handleModelPull, } = useModelPicker(config);
+    const { status, setStatus, tick, currentTool, setCurrentTool, taskLabel, setTaskLabel, thinkingStartRef, abortRef, runLoop, handleAbort, } = useRunLoop(config, currentModelRef, pushHistory);
     // ─── refactor ─────────────────────────────────────────────────────────────
     const runRefactor = useCallback(async (goal) => {
         printer.systemMsg(`refactor: ${goal}`);
         setTaskLabel(`planning: ${goal}`);
         setStatus('thinking');
-        // Phase 1 — planning: ask model to list files and describe changes
         const planCtx = [
             { role: 'system', content: systemPromptRef.current },
             {
@@ -336,7 +78,6 @@ export function InputBar({ config, skills, cwd, session }) {
             return;
         }
         printer.assistantMsg(planText);
-        // Parse FILE:/CHANGE: pairs from plan
         const filePlan = [];
         const lines = planText.split('\n');
         let lastPath = '';
@@ -357,9 +98,7 @@ export function InputBar({ config, skills, cwd, session }) {
             return;
         }
         printer.systemMsg(`plan: ${filePlan.length} file(s) to change`);
-        // Phase 2 — execute via macro/micro queue
         const micro = new MicroQueue();
-        // P1: read all files in parallel
         for (const fp of filePlan) {
             const t = { id: `read:${fp.path}`, priority: 1, tool: 'read_file', args: { path: fp.path }, deps: [], status: 'pending' };
             micro.push(t);
@@ -373,13 +112,12 @@ export function InputBar({ config, skills, cwd, session }) {
         };
         macroQueueRef.current.enqueue(macro);
         setTaskLabel(`reading ${filePlan.length} file(s)…`);
-        const readResults = await executorRef.current.drain(micro, ({ task, result, error }) => {
+        const readResults = await executorRef.current.drain(micro, ({ task, error }) => {
             if (error)
                 printer.errorMsg(`read failed: ${task.args.path} — ${error}`);
             else
                 printer.systemMsg(`read: ${task.args.path}`);
         });
-        // Phase 3 — per-file LLM call with isolated context → patch
         setTaskLabel(`applying changes…`);
         const writeMicro = new MicroQueue();
         for (const fp of filePlan) {
@@ -391,7 +129,6 @@ export function InputBar({ config, skills, cwd, session }) {
             }
             setCurrentTool(`edit ${fp.path}`);
             setTaskLabel(`editing: ${fp.path}`);
-            // Isolated context per file keeps model focused
             const editCtx = fileEditContext(systemPromptRef.current, goal, fp.path, fileContent, fp.change);
             let editText = '';
             await chat({
@@ -406,7 +143,6 @@ export function InputBar({ config, skills, cwd, session }) {
             if (!editText)
                 continue;
             printer.assistantMsg(editText);
-            // Queue write tasks from LLM's tool calls (P2)
             const parser = new StreamParser();
             for (const item of [...parser.feed(editText), ...parser.flush()]) {
                 if (item.type === 'tool_call') {
@@ -414,7 +150,6 @@ export function InputBar({ config, skills, cwd, session }) {
                 }
             }
         }
-        // Execute all writes
         if (writeMicro.size > 0) {
             setTaskLabel(`writing ${writeMicro.size} change(s)…`);
             await executorRef.current.drain(writeMicro, ({ task, result, error }) => {
@@ -444,28 +179,21 @@ export function InputBar({ config, skills, cwd, session }) {
                 return e.message ?? String(e);
             }
         };
-        // /git  or  /git status
         if (!sub || sub === 'status') {
-            const out = await git('status');
-            printer.systemMsg(out);
+            printer.systemMsg(await git('status'));
             return;
         }
-        // /git log [n]
         if (sub === 'log' || sub.startsWith('log ')) {
             const n = parseInt(sub.split(' ')[1] ?? '10', 10) || 10;
-            const out = await git(`log --oneline --decorate -${Math.min(n, 50)}`);
-            printer.systemMsg(out);
+            printer.systemMsg(await git(`log --oneline --decorate -${Math.min(n, 50)}`));
             return;
         }
-        // /git diff [--staged] [file]
         if (sub === 'diff' || sub.startsWith('diff ')) {
             const args = sub.slice(4).trim();
             const out = await git(`diff ${args}`.trim());
-            const display = out.length > 6000 ? out.slice(0, 6000) + '\n…[truncated]' : out;
-            printer.systemMsg(display || '(no diff)');
+            printer.systemMsg(out.length > 6000 ? out.slice(0, 6000) + '\n…[truncated]' : out || '(no diff)');
             return;
         }
-        // /git review  — inject diff into context, ask model to review
         if (sub === 'review') {
             const diff = await git('diff HEAD');
             const staged = await git('diff --staged');
@@ -481,40 +209,91 @@ export function InputBar({ config, skills, cwd, session }) {
             await runLoop(buildContext());
             return;
         }
-        // /git branch
         if (sub === 'branch' || sub.startsWith('branch ')) {
-            const args = sub.slice(6).trim();
-            const out = await git(`branch ${args}`.trim());
-            printer.systemMsg(out || '(done)');
+            printer.systemMsg(await git(`branch ${sub.slice(6).trim()}`.trim()) || '(done)');
             return;
         }
-        // /git commit <msg>
         if (sub.startsWith('commit ')) {
             const msg = sub.slice(7).trim();
             if (!msg) {
                 printer.systemMsg('usage: /git commit <message>');
                 return;
             }
-            const status = await git('status --short');
-            if (!status || status === '(clean — no changes)') {
+            const gitStatus = await git('status --short');
+            if (!gitStatus || gitStatus === '(clean — no changes)') {
                 printer.systemMsg('nothing to commit — working tree clean');
                 return;
             }
-            printer.systemMsg(`staging and committing:\n${status}`);
+            printer.systemMsg(`staging and committing:\n${gitStatus}`);
             const stageOut = await git('add -A');
             if (stageOut)
                 printer.systemMsg(stageOut);
-            const commitOut = await git(`commit -m ${JSON.stringify(msg)}`);
-            printer.systemMsg(commitOut);
+            printer.systemMsg(await git(`commit -m ${JSON.stringify(msg)}`));
             return;
         }
-        // fallthrough — run arbitrary git subcommand
-        const out = await git(sub);
-        printer.systemMsg(out || '(done)');
+        printer.systemMsg(await git(sub) || '(done)');
     }, []);
     // ─── submit ────────────────────────────────────────────────────────────────
     const handleSubmit = useCallback(async (text) => {
         const cmd = text.trim();
+        if (cmd === '/version') {
+            printer.systemMsg(`miii v${version ?? 'unknown'}`);
+            return;
+        }
+        if (cmd === '/tavily-key' || cmd.startsWith('/tavily-key ')) {
+            const key = cmd.slice(11).trim();
+            if (!key) {
+                const existing = getTavilyKey();
+                printer.systemMsg(existing ? 'Tavily key set (use /tavily-key <key> to update)' : 'No Tavily key set. Usage: /tavily-key tvly-...');
+                return;
+            }
+            if (!key.startsWith('tvly-')) {
+                printer.systemMsg('Key should start with tvly-. Get yours at https://tavily.com');
+                return;
+            }
+            saveTavilyKey(key);
+            printer.systemMsg('Tavily API key saved to ~/.config/miii/tavily.key (mode 600)');
+            return;
+        }
+        if (cmd === '/skills' || cmd.startsWith('/skills ')) {
+            const sub = cmd.slice(7).trim();
+            if (!sub || sub === 'list') {
+                const pkgs = skills.listNpmSkills();
+                printer.systemMsg(pkgs.length ? `installed npm skills:\n${pkgs.map(p => `  ${p}`).join('\n')}` : 'no npm skills installed — try /skills install <name>');
+                return;
+            }
+            if (sub.startsWith('install ')) {
+                const pkg = sub.slice(8).trim();
+                if (!pkg) {
+                    printer.systemMsg('usage: /skills install <name>  (e.g. /skills install git-summary)');
+                    return;
+                }
+                printer.systemMsg(`installing miii-skill-${pkg}…`);
+                try {
+                    printer.systemMsg(await skills.installSkill(pkg));
+                }
+                catch (e) {
+                    printer.errorMsg(String(e));
+                }
+                return;
+            }
+            if (sub.startsWith('uninstall ')) {
+                const pkg = sub.slice(10).trim();
+                if (!pkg) {
+                    printer.systemMsg('usage: /skills uninstall <name>');
+                    return;
+                }
+                try {
+                    printer.systemMsg(await skills.uninstallSkill(pkg));
+                }
+                catch (e) {
+                    printer.errorMsg(String(e));
+                }
+                return;
+            }
+            printer.systemMsg('usage: /skills install <name> | /skills uninstall <name> | /skills list');
+            return;
+        }
         if (cmd === '/model' || cmd.startsWith('/model ')) {
             const name = cmd.slice(6).trim();
             if (!name) {
@@ -522,6 +301,7 @@ export function InputBar({ config, skills, cwd, session }) {
                 return;
             }
             setCurrentModel(name);
+            currentModelRef.current = name;
             printer.systemMsg(`model → ${name}`);
             return;
         }
@@ -555,8 +335,7 @@ export function InputBar({ config, skills, cwd, session }) {
             process.exit(0);
         }
         if (cmd === '/git' || cmd.startsWith('/git ')) {
-            const sub = cmd.slice(4).trim();
-            await handleGit(sub);
+            await handleGit(cmd.slice(4).trim());
             return;
         }
         if (cmd.startsWith('/refactor ') || cmd === '/refactor') {
@@ -572,9 +351,7 @@ export function InputBar({ config, skills, cwd, session }) {
             const topic = cmd.slice(5).trim();
             setPlanningMode(true);
             systemPromptRef.current = getSystemPrompt(`\n- CWD: ${cwd}\n- MODE: Planning assistant. Help the user plan step by step. Ask clarifying questions. Suggest concrete next steps. Use plain text only — no markdown, no headers, no bold, no bullets with asterisks, no backtick blocks. Use numbered lists and plain indentation for structure.`);
-            const msg = topic
-                ? `I want to plan: ${topic}`
-                : 'I want to start planning. Help me think through my goals step by step.';
+            const msg = topic ? `I want to plan: ${topic}` : 'I want to start planning. Help me think through my goals step by step.';
             printer.userMsg(msg);
             pushHistory({ role: 'user', content: msg });
             await runLoop(buildContext());
@@ -667,13 +444,9 @@ export function InputBar({ config, skills, cwd, session }) {
         pushHistory({ role: 'user', content: gitPrefix + contextPrefix + text });
         await runLoop(buildContext());
     }, [skills, runLoop, openPicker]);
-    const handleAbort = useCallback(() => {
-        abortRef.current?.abort();
-        setStatus('idle');
-    }, []);
     const skillList = skills.list();
     // ─── render ────────────────────────────────────────────────────────────────
-    return (_jsxs(Box, { flexDirection: "column", children: [pickerOpen ? (_jsxs(_Fragment, { children: [_jsx(ModelPicker, { models: pickerModels, current: currentModel, loading: pickerLoading, error: pickerError, pull: pullState, onSelect: handleModelSelect, onPull: handleModelPull, onClose: () => { setPickerOpen(false); setPullState(undefined); } }), _jsx(Divider, { cols: cols })] })) : (status === 'thinking' || status === 'tool') ? (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "miii" }), _jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [_jsx(Box, { children: status === 'thinking'
+    return (_jsxs(Box, { flexDirection: "column", children: [pickerOpen ? (_jsxs(_Fragment, { children: [_jsx(ModelPicker, { models: pickerModels, current: currentModel, loading: pickerLoading, error: pickerError, pull: pullState, onSelect: handleModelSelect, onPull: handleModelPull, onClose: () => { setPickerOpen(false); } }), _jsx(Divider, { cols: cols })] })) : (status === 'thinking' || status === 'tool') ? (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "miii" }), _jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [_jsx(Box, { children: status === 'thinking'
                                             ? _jsxs(_Fragment, { children: [_jsxs(Text, { color: "yellow", children: [SPARKLE[tick % SPARKLE.length], " "] }), _jsx(Text, { color: "gray", dimColor: true, italic: true, children: THINKING_PHRASES[Math.floor(tick / 62) % THINKING_PHRASES.length] })] })
                                             : _jsxs(Text, { color: "yellow", dimColor: true, children: ["\u2699 running ", currentTool ?? 'tool', "\u2026"] }) }), _jsxs(Box, { gap: 2, children: [_jsxs(Text, { color: "gray", dimColor: true, children: [Math.floor((Date.now() - thinkingStartRef.current) / 1000), "s"] }), taskLabel && _jsx(Text, { color: "cyan", dimColor: true, children: taskLabel })] })] })] }), _jsx(Divider, { cols: cols })] })) : null, _jsx(InputArea, { status: status, skills: skillList, cwd: cwd, planningMode: planningMode, onSubmit: handleSubmit, onAbort: handleAbort })] }));
 }

package/dist/tui/components/InputArea.js

@@ -12,6 +12,9 @@ const BUILTIN_COMMANDS = [
     { ns: 'builtin', name: 'session', description: 'switch session  /session <name>' },
     { ns: 'builtin', name: 'exit', description: 'exit miii' },
     { ns: 'builtin', name: 'model', description: 'switch model mid-session  /model <name>' },
+    { ns: 'builtin', name: 'version', description: 'show current miii version' },
+    { ns: 'builtin', name: 'tavily-key', description: 'set Tavily API key for web search  /tavily-key tvly-...' },
+    { ns: 'builtin', name: 'skills', description: 'install/uninstall/list npm skills  /skills install <name>' },
     { ns: 'builtin', name: 'list', description: 'list all loaded skills' },
     { ns: 'builtin', name: 'plan', description: 'start planning mode  /plan [topic]' },
     { ns: 'builtin', name: 'refactor', description: 'multi-file AI refactor  /refactor <goal>' },

package/dist/tui/git-context.js

@@ -0,0 +1,59 @@
+import { readFile } from '../files/ops.js';
+import { resolve } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const gitRun = promisify(exec);
+const CODE_PATTERN = /\.(ts|js|tsx|jsx|py|go|rs|java|rb|sh|css|html|json|yaml|yml)\b|function|class|import|export|const|let|var|def |async|await|error|bug|fix|refactor|implement|`[^`]+`/i;
+export function looksCodeRelated(text) {
+    return text.length >= 10 && CODE_PATTERN.test(text);
+}
+export async function buildGitContext(cwd, lastStatusRef) {
+    try {
+        const { stdout } = await gitRun('git status --short', { cwd, timeout: 5000 });
+        const status = stdout.trim();
+        if (!status || status === lastStatusRef.current)
+            return { prefix: '', label: '' };
+        lastStatusRef.current = status;
+        const MAX_TOTAL = 40_000;
+        const MAX_FILE = 15_000;
+        let total = 0;
+        const parts = [];
+        const skipped = [];
+        for (const line of status.split('\n')) {
+            const code = line.slice(0, 2);
+            if (code.includes('D'))
+                continue;
+            const raw = line.slice(3).trim().replace(/^"|"$/g, '');
+            const rel = raw.includes(' -> ') ? raw.split(' -> ')[1] : raw;
+            if (!rel)
+                continue;
+            try {
+                const content = readFile(resolve(cwd, rel));
+                if (!content || content.length > MAX_FILE) {
+                    skipped.push(rel);
+                    continue;
+                }
+                total += content.length;
+                if (total > MAX_TOTAL) {
+                    skipped.push(rel);
+                    continue;
+                }
+                parts.push(`<file path="${rel}">\n${content}\n</file>`);
+            }
+            catch {
+                skipped.push(rel);
+            }
+        }
+        if (!parts.length && !skipped.length)
+            return { prefix: '', label: '' };
+        let prefix = '[Auto-context: git-changed files]\n' + parts.join('\n') + '\n';
+        if (skipped.length)
+            prefix += `Files changed but too large to auto-load: ${skipped.join(', ')}\n`;
+        prefix += '\n';
+        const label = `auto-loaded ${parts.length} changed file(s)${skipped.length ? `, skipped ${skipped.length} (too large)` : ''}`;
+        return { prefix, label };
+    }
+    catch {
+        return { prefix: '', label: '' };
+    }
+}