miii-cli 0.2.2 → 0.2.4

package/dist/tui/InputBar.js

@@ -6,11 +6,19 @@ 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 } from '../parser/stream-parser.js';
+import { StreamParser, extractBareToolCall } from '../parser/stream-parser.js';
 import { tools, getSystemPrompt } from '../tools/index.js';
 import { readFile } from '../files/ops.js';
+import { resolve } from 'path';
 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 { exec } from 'child_process';
+import { promisify } from 'util';
+const gitRun = promisify(exec);
 const MAX_TOOL_DEPTH = 6;
 const THINKING_PHRASES = [
     'oh wow, a question. let me pretend to care…',
@@ -23,6 +31,21 @@ const THINKING_PHRASES = [
     '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) {
@@ -40,6 +63,60 @@ 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 }) {
     const { stdout } = useStdout();
     const cols = stdout.columns ?? 80;
@@ -47,6 +124,8 @@ export function InputBar({ config, skills, cwd, session }) {
     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);
@@ -56,10 +135,29 @@ export function InputBar({ config, skills, cwd, session }) {
     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
@@ -87,18 +185,22 @@ export function InputBar({ config, skills, cwd, session }) {
             ctx.push(extra);
         return ctx;
     }
-    const runLoop = useCallback(async (contextMsgs, depth = 0) => {
+    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: contextMsgs,
+            messages: msgs,
             signal: abortRef.current.signal,
             async onDone(fullText) {
                 const pendingTools = [];
@@ -107,35 +209,57 @@ export function InputBar({ config, skills, cwd, session }) {
                     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);
-                historyRef.current.push({ role: 'assistant', content: fullText });
-                saveSession(sessionNameRef.current, historyRef.current);
+                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 = [...contextMsgs, { role: 'assistant', content: fullText }];
-                for (const tc of pendingTools) {
-                    const tool = tools.find(t => t.name === 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}` });
+                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 });
+                            }
                         }
-                        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}` });
                         }
                     }
-                    else {
-                        printer.errorMsg(`unknown tool: ${tc.name}`);
-                        next.push({ role: 'user', content: `unknown tool: ${tc.name}` });
-                    }
                 }
-                await runLoop(next, depth + 1);
+                finally {
+                    setCurrentTool(undefined);
+                }
+                await runLoop(next, depth + 1, goal);
             },
             onError(err) {
                 if (err.name !== 'AbortError')
@@ -182,14 +306,234 @@ export function InputBar({ config, skills, cwd, session }) {
             setPickerError(`pull failed: ${e}`);
         }
     }, [config.baseUrl]);
+    // ─── 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 },
+            {
+                role: 'user',
+                content: `Refactor goal: ${goal}\n\nList every file that needs to change. For each file output:\nFILE: <path>\nCHANGE: <one sentence describing the edit>\n\nUse list_files and read_file to discover relevant files first. Only list files that genuinely need changes.`,
+            },
+        ];
+        abortRef.current = new AbortController();
+        let planText = '';
+        await chat({
+            provider: config.provider,
+            model: currentModelRef.current,
+            baseUrl: config.baseUrl,
+            messages: planCtx,
+            signal: abortRef.current.signal,
+            async onDone(text) { planText = text; },
+            onError(err) { printer.errorMsg(err.message); },
+        });
+        if (!planText) {
+            setStatus('idle');
+            setTaskLabel(undefined);
+            return;
+        }
+        printer.assistantMsg(planText);
+        // Parse FILE:/CHANGE: pairs from plan
+        const filePlan = [];
+        const lines = planText.split('\n');
+        let lastPath = '';
+        for (const line of lines) {
+            const fm = line.match(/^FILE:\s*(.+)/);
+            const cm = line.match(/^CHANGE:\s*(.+)/);
+            if (fm)
+                lastPath = fm[1].trim();
+            if (cm && lastPath) {
+                filePlan.push({ path: lastPath, change: cm[1].trim() });
+                lastPath = '';
+            }
+        }
+        if (!filePlan.length) {
+            printer.systemMsg('no files identified in plan — done');
+            setStatus('idle');
+            setTaskLabel(undefined);
+            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);
+        }
+        const macro = {
+            id: generateId(),
+            goal,
+            priority: 0,
+            microtasks: micro.toArray(),
+            status: 'running',
+        };
+        macroQueueRef.current.enqueue(macro);
+        setTaskLabel(`reading ${filePlan.length} file(s)…`);
+        const readResults = await executorRef.current.drain(micro, ({ task, result, 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) {
+            const readId = `read:${fp.path}`;
+            const fileContent = readResults.get(readId) ?? '';
+            if (!fileContent) {
+                printer.systemMsg(`skip (unreadable): ${fp.path}`);
+                continue;
+            }
+            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({
+                provider: config.provider,
+                model: currentModelRef.current,
+                baseUrl: config.baseUrl,
+                messages: editCtx,
+                signal: abortRef.current?.signal,
+                async onDone(text) { editText = text; },
+                onError(err) { printer.errorMsg(`edit LLM error: ${err.message}`); },
+            });
+            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') {
+                    writeMicro.push({ id: generateId(), priority: 2, tool: item.toolName, args: item.toolArgs, deps: [], status: 'pending' });
+                }
+            }
+        }
+        // Execute all writes
+        if (writeMicro.size > 0) {
+            setTaskLabel(`writing ${writeMicro.size} change(s)…`);
+            await executorRef.current.drain(writeMicro, ({ task, result, error }) => {
+                if (error)
+                    printer.errorMsg(`${task.tool} failed: ${error}`);
+                else
+                    printer.toolMsg(task.tool, result ?? '');
+            });
+        }
+        macro.status = 'done';
+        macroQueueRef.current.dequeue();
+        setCurrentTool(undefined);
+        setTaskLabel(undefined);
+        setStatus('idle');
+        printer.systemMsg(`refactor done — ${filePlan.length} file(s) processed`);
+        pushHistory({ role: 'user', content: `[refactor] ${goal}` });
+        pushHistory({ role: 'assistant', content: planText });
+    }, [config]);
+    // ─── git ───────────────────────────────────────────────────────────────────
+    const handleGit = useCallback(async (sub) => {
+        const git = async (args) => {
+            try {
+                const { stdout, stderr } = await gitRun(`git ${args}`, { timeout: 15_000 });
+                return (stdout + stderr).trim();
+            }
+            catch (e) {
+                return e.message ?? String(e);
+            }
+        };
+        // /git  or  /git status
+        if (!sub || sub === 'status') {
+            const out = await git('status');
+            printer.systemMsg(out);
+            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);
+            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)');
+            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');
+            const combined = [diff, staged].filter(Boolean).join('\n').trim();
+            if (!combined || combined === '(no diff)') {
+                printer.systemMsg('no changes to review');
+                return;
+            }
+            const truncated = combined.length > 8000 ? combined.slice(0, 8000) + '\n…[truncated]' : combined;
+            const userMsg = `Review these git changes for bugs, issues, and improvements:\n\n${truncated}`;
+            printer.userMsg('/git review');
+            pushHistory({ role: 'user', content: userMsg });
+            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)');
+            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)') {
+                printer.systemMsg('nothing to commit — working tree clean');
+                return;
+            }
+            printer.systemMsg(`staging and committing:\n${status}`);
+            const stageOut = await git('add -A');
+            if (stageOut)
+                printer.systemMsg(stageOut);
+            const commitOut = await git(`commit -m ${JSON.stringify(msg)}`);
+            printer.systemMsg(commitOut);
+            return;
+        }
+        // fallthrough — run arbitrary git subcommand
+        const out = await git(sub);
+        printer.systemMsg(out || '(done)');
+    }, []);
     // ─── submit ────────────────────────────────────────────────────────────────
     const handleSubmit = useCallback(async (text) => {
         const cmd = text.trim();
+        if (cmd === '/model' || cmd.startsWith('/model ')) {
+            const name = cmd.slice(6).trim();
+            if (!name) {
+                printer.systemMsg(`current model: ${currentModelRef.current}`);
+                return;
+            }
+            setCurrentModel(name);
+            printer.systemMsg(`model → ${name}`);
+            return;
+        }
         if (cmd === '/models') {
             await openPicker();
             return;
         }
         if (cmd === '/new') {
+            if (saveTimerRef.current) {
+                clearTimeout(saveTimerRef.current);
+                saveTimerRef.current = null;
+            }
             saveSession(sessionNameRef.current, historyRef.current);
             const newName = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
             historyRef.current = [];
@@ -210,6 +554,20 @@ export function InputBar({ config, skills, cwd, session }) {
         if (cmd === '/exit') {
             process.exit(0);
         }
+        if (cmd === '/git' || cmd.startsWith('/git ')) {
+            const sub = cmd.slice(4).trim();
+            await handleGit(sub);
+            return;
+        }
+        if (cmd.startsWith('/refactor ') || cmd === '/refactor') {
+            const goal = cmd.slice(9).trim();
+            if (!goal) {
+                printer.systemMsg('usage: /refactor <goal>');
+                return;
+            }
+            await runRefactor(goal);
+            return;
+        }
         if (cmd === '/plan' || cmd.startsWith('/plan ')) {
             const topic = cmd.slice(5).trim();
             setPlanningMode(true);
@@ -218,8 +576,7 @@ export function InputBar({ config, skills, cwd, session }) {
                 ? `I want to plan: ${topic}`
                 : 'I want to start planning. Help me think through my goals step by step.';
             printer.userMsg(msg);
-            historyRef.current.push({ role: 'user', content: msg });
-            saveSession(sessionNameRef.current, historyRef.current);
+            pushHistory({ role: 'user', content: msg });
             await runLoop(buildContext());
             return;
         }
@@ -239,8 +596,7 @@ export function InputBar({ config, skills, cwd, session }) {
             const msg = subPrompts[subCmd];
             if (msg) {
                 printer.userMsg(msg);
-                historyRef.current.push({ role: 'user', content: msg });
-                saveSession(sessionNameRef.current, historyRef.current);
+                pushHistory({ role: 'user', content: msg });
                 await runLoop(buildContext());
                 return;
             }
@@ -260,6 +616,10 @@ export function InputBar({ config, skills, cwd, session }) {
                 printer.systemMsg(`current: ${sessionNameRef.current}`);
                 return;
             }
+            if (saveTimerRef.current) {
+                clearTimeout(saveTimerRef.current);
+                saveTimerRef.current = null;
+            }
             saveSession(sessionNameRef.current, historyRef.current);
             historyRef.current = loadSession(arg);
             setSessionName(arg);
@@ -288,7 +648,7 @@ export function InputBar({ config, skills, cwd, session }) {
                 }
                 if (skill.prompt) {
                     printer.userMsg(skill.prompt);
-                    historyRef.current.push({ role: 'user', content: skill.prompt });
+                    pushHistory({ role: 'user', content: skill.prompt });
                     await runLoop(buildContext());
                     return;
                 }
@@ -297,9 +657,14 @@ export function InputBar({ config, skills, cwd, session }) {
             return;
         }
         const contextPrefix = buildAtContext(text);
+        const shouldInjectGit = config.gitContext !== false && looksCodeRelated(text);
+        const { prefix: gitPrefix, label: gitLabel } = shouldInjectGit
+            ? await buildGitContext(cwd, lastGitStatusRef)
+            : { prefix: '', label: '' };
+        if (gitLabel)
+            printer.systemMsg(gitLabel);
         printer.userMsg(text);
-        historyRef.current.push({ role: 'user', content: contextPrefix + text });
-        saveSession(sessionNameRef.current, historyRef.current);
+        pushHistory({ role: 'user', content: gitPrefix + contextPrefix + text });
         await runLoop(buildContext());
     }, [skills, runLoop, openPicker]);
     const handleAbort = useCallback(() => {
@@ -308,8 +673,7 @@ export function InputBar({ config, skills, cwd, session }) {
     }, []);
     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" }), _jsx(Box, { paddingLeft: 2, 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] })] })
-                                    : _jsx(Text, { color: "yellow", dimColor: true, children: "running tool\u2026" }) })] }), _jsx(Divider, { cols: cols })] })) : null, _jsx(InputArea, { status: status, skills: skillList, cwd: cwd, planningMode: planningMode, onSubmit: handleSubmit, onAbort: handleAbort })] }));
+    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'
+                                            ? _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 })] }));
 }
-//# sourceMappingURL=InputBar.js.map

package/dist/tui/components/AtPicker.js

@@ -16,4 +16,3 @@ export function AtPicker({ files, query, idx }) {
             return (_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: active ? 'cyan' : 'white', bold: active, children: [active ? '▶' : ' ', icon] }), _jsxs(Text, { color: active ? 'cyan' : f.type === 'dir' ? 'blue' : 'white', children: [' ', f.rel] }), f.size !== undefined && (_jsxs(Text, { color: "gray", dimColor: true, children: ['  ', f.size > 1024 ? `${(f.size / 1024).toFixed(0)}k` : `${f.size}b`] }))] }, f.path));
         }) }));
 }
-//# sourceMappingURL=AtPicker.js.map

package/dist/tui/components/CommandPalette.js

@@ -15,11 +15,12 @@ export function CommandPalette({ skills, query, idx }) {
     }
     return (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", marginX: 1, children: filtered.map((s, i) => {
             const active = i === idx;
-            const isBuiltin = s.ns === 'builtin';
+            const isBuiltin = s.ns === 'builtin' || s.ns === 'git';
             const name = (s.ns === 'default' || s.ns === 'builtin')
                 ? `/${s.name}`
-                : `/${s.ns}:${s.name}`;
+                : s.ns === 'git'
+                    ? `/git ${s.name}`
+                    : `/${s.ns}:${s.name}`;
             return (_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: active ? 'cyan' : isBuiltin ? 'white' : 'magenta', bold: active, children: [active ? '▶ ' : '  ', name.padEnd(20)] }), _jsx(Text, { color: "gray", dimColor: true, children: s.description })] }, `${s.ns}:${s.name}`));
         }) }));
 }
-//# sourceMappingURL=CommandPalette.js.map

package/dist/tui/components/InputArea.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useMemo } from 'react';
+import { useState, useMemo, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { listFiles } from '../../files/ops.js';
 import { CommandPalette } from './CommandPalette.js';
@@ -11,8 +11,17 @@ const BUILTIN_COMMANDS = [
     { ns: 'builtin', name: 'sessions', description: 'list all saved sessions' },
     { 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: '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>' },
+    { ns: 'git', name: 'status', description: 'show git working tree status' },
+    { ns: 'git', name: 'diff', description: 'show unstaged diff' },
+    { ns: 'git', name: 'diff --staged', description: 'show staged diff' },
+    { ns: 'git', name: 'log', description: 'show recent commits' },
+    { ns: 'git', name: 'review', description: 'review current changes with AI' },
+    { ns: 'git', name: 'branch', description: 'list branches' },
+    { ns: 'git', name: 'commit', description: 'stage all and commit  /git commit <msg>' },
 ];
 const PLANNING_COMMANDS = [
     { ns: 'plan', name: 'next', description: 'suggest next concrete steps' },
@@ -25,14 +34,8 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
     const [cursor, setCursor] = useState({ row: 0, col: 0 });
     const [overlay, setOverlay] = useState('none');
     const [overlayIdx, setOverlayIdx] = useState(0);
-    const [files] = useState(() => {
-        try {
-            return listFiles(cwd, true);
-        }
-        catch {
-            return [];
-        }
-    });
+    const [files, setFiles] = useState([]);
+    const filesLoadedRef = useRef(false);
     // built-ins first, then loaded skills (deduplicated by name)
     const allCommands = useMemo(() => {
         const builtinNames = new Set(BUILTIN_COMMANDS.map(b => b.name));
@@ -64,9 +67,17 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
     }, [commandQuery, allCommands]);
     const filteredFiles = useMemo(() => {
         if (!atQuery)
-            return files.slice(0, 8);
+            return [];
+        if (!filesLoadedRef.current) {
+            filesLoadedRef.current = true;
+            setTimeout(() => { try {
+                setFiles(listFiles(cwd, true));
+            }
+            catch { } }, 0);
+            return [];
+        }
         return files.filter(f => f.rel.toLowerCase().includes(atQuery.toLowerCase())).slice(0, 8);
-    }, [atQuery, files]);
+    }, [atQuery, files, cwd]);
     const overlayCount = overlay === 'command' ? filteredCommands.length : filteredFiles.length;
     function clearInput() {
         setLines(['']);
@@ -104,7 +115,9 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
     function selectCommand(skill) {
         const name = (skill.ns === 'default' || skill.ns === 'builtin')
             ? `/${skill.name}`
-            : `/${skill.ns}:${skill.name}`;
+            : skill.ns === 'git'
+                ? `/git ${skill.name}`
+                : `/${skill.ns}:${skill.name}`;
         clearInput();
         onSubmit(name);
     }
@@ -275,4 +288,3 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
 function renderLineWithCursor(line, col, showCursor) {
     return line.slice(0, col) + (showCursor ? '█' : '') + line.slice(col);
 }
-//# sourceMappingURL=InputArea.js.map