miii-cli 0.2.4 → 0.2.6

package/dist/tui/hooks/useModelPicker.js

@@ -0,0 +1,63 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { listModels, pullModel } from '../../llm/ollama.js';
+import * as printer from '../printer.js';
+export function useModelPicker(config) {
+    const [currentModel, setCurrentModel] = useState(config.model);
+    const currentModelRef = useRef(config.model);
+    const [pickerOpen, setPickerOpen] = useState(true);
+    const [pickerModels, setPickerModels] = useState([]);
+    const [pickerLoading, setPickerLoading] = useState(false);
+    const [pickerError, setPickerError] = useState();
+    const [pullState, setPullState] = useState();
+    const pullAbortRef = useRef(null);
+    useEffect(() => { currentModelRef.current = currentModel; }, [currentModel]);
+    useEffect(() => {
+        setPickerLoading(true);
+        listModels(config.baseUrl)
+            .then(m => { setPickerModels(m); setPickerLoading(false); })
+            .catch(e => { setPickerError(String(e)); setPickerLoading(false); });
+    }, []);
+    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]);
+    return {
+        currentModel, setCurrentModel, currentModelRef,
+        pickerOpen, setPickerOpen,
+        pickerModels, pickerLoading, pickerError, pullState,
+        openPicker, handleModelSelect, handleModelPull,
+    };
+}

package/dist/tui/hooks/useRunLoop.js

@@ -0,0 +1,146 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { chat } from '../../llm/stream.js';
+import { tools } from '../../tools/index.js';
+import { StreamParser, extractBareToolCall } from '../../parser/stream-parser.js';
+import { shouldCompact, compactContext } from '../../tasks/compactor.js';
+import * as printer from '../printer.js';
+const MAX_TOOL_DEPTH = 6;
+const FILE_EDIT_TOOLS = new Set(['edit_file', 'create_file', 'patch_file', 'delete_file']);
+const SHOW_RESULT_TOOLS = new Set(['run_tests', 'git_commit']);
+export function useRunLoop(config, currentModelRef, pushHistory) {
+    const [status, setStatus] = useState('idle');
+    const [tick, setTick] = useState(0);
+    const [currentTool, setCurrentTool] = useState();
+    const [taskLabel, setTaskLabel] = useState();
+    const abortRef = useRef(null);
+    const thinkingStartRef = useRef(0);
+    const pushHistoryRef = useRef(pushHistory);
+    useEffect(() => { pushHistoryRef.current = pushHistory; }, [pushHistory]);
+    useEffect(() => {
+        if (status === 'idle')
+            return;
+        const t = setInterval(() => setTick(n => n + 1), 80);
+        return () => clearInterval(t);
+    }, [status]);
+    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();
+        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 textParts = [];
+                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 });
+                    else
+                        textParts.push(item.content);
+                }
+                if (!pendingTools.length) {
+                    const bare = extractBareToolCall(fullText);
+                    if (bare)
+                        pendingTools.push({ name: bare.name, args: bare.args });
+                }
+                const displayText = textParts.join('').trim();
+                if (displayText)
+                    printer.assistantMsg(displayText);
+                pushHistoryRef.current({ role: 'assistant', content: fullText });
+                if (!pendingTools.length) {
+                    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.',
+                        };
+                        await runLoop([...msgs, { role: 'assistant', content: fullText }, nudge], 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 {
+                                printer.toolCallStart(tc.name, tc.args);
+                                const result = await tool.execute(tc.args);
+                                if (SHOW_RESULT_TOOLS.has(tc.name))
+                                    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);
+                }
+                // Auto-run tests after file edits
+                const didEditFiles = pendingTools.some(tc => FILE_EDIT_TOOLS.has(tc.name));
+                if (didEditFiles) {
+                    const testTool = tools.find(t => t.name === 'run_tests');
+                    if (testTool) {
+                        setCurrentTool('run_tests');
+                        try {
+                            printer.toolCallStart('run_tests', {});
+                            const testResult = await testTool.execute({});
+                            if (testResult && !testResult.startsWith('(no test script') && !testResult.startsWith('(no package.json')) {
+                                printer.toolMsg('run_tests', testResult);
+                                next.push({ role: 'user', content: `Test results after edits:\n${testResult}` });
+                            }
+                        }
+                        catch (e) {
+                            const err = `run_tests error: ${e}`;
+                            printer.errorMsg(err);
+                            next.push({ role: 'user', content: err });
+                        }
+                        finally {
+                            setCurrentTool(undefined);
+                        }
+                    }
+                }
+                await runLoop(next, depth + 1, goal);
+            },
+            onError(err) {
+                if (err.name !== 'AbortError')
+                    printer.errorMsg(err.message);
+                setStatus('idle');
+            },
+        });
+    }, [config]);
+    const handleAbort = useCallback(() => {
+        abortRef.current?.abort();
+        setStatus('idle');
+    }, []);
+    return {
+        status, setStatus, tick,
+        currentTool, setCurrentTool,
+        taskLabel, setTaskLabel,
+        thinkingStartRef, abortRef,
+        runLoop, handleAbort,
+    };
+}

package/dist/tui/hooks/useSession.js

@@ -0,0 +1,50 @@
+import { useState, useRef, useEffect } from 'react';
+import { loadSession, saveSession } from '../../sessions.js';
+import { getSystemPrompt } from '../../tools/index.js';
+import { getTavilyKey, saveTavilyKey } from '../../tavily/client.js';
+import * as printer from '../printer.js';
+export function useSession(initialSession, cwd, config) {
+    const [sessionName, setSessionName] = useState(initialSession);
+    const sessionNameRef = useRef(initialSession);
+    const historyRef = useRef([]);
+    const saveTimerRef = useRef(null);
+    const systemPromptRef = useRef(getSystemPrompt(`\n- CWD: ${cwd}`));
+    useEffect(() => { sessionNameRef.current = sessionName; }, [sessionName]);
+    useEffect(() => {
+        const history = loadSession(initialSession);
+        historyRef.current = history;
+        if (history.length)
+            printer.systemMsg(`resumed "${initialSession}" — ${history.length} messages`);
+        if (config.tavilyApiKey && !getTavilyKey())
+            saveTavilyKey(config.tavilyApiKey);
+        if (!getTavilyKey()) {
+            printer.systemMsg('Tavily API key not set — web search disabled. Run /tavily-key <key> to enable. Get a free key at https://tavily.com');
+        }
+    }, []);
+    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();
+    }
+    function buildContext(extra) {
+        const ctx = [{ role: 'system', content: systemPromptRef.current }];
+        ctx.push(...historyRef.current);
+        if (extra)
+            ctx.push(extra);
+        return ctx;
+    }
+    return {
+        sessionName, setSessionName, sessionNameRef,
+        historyRef, saveTimerRef, systemPromptRef,
+        pushHistory, buildContext,
+    };
+}

package/dist/tui/printer.js

@@ -24,9 +24,18 @@ function stripMarkdown(s) {
 function formatContent(text) {
     const lines = text.split('\n');
     let inCode = false;
+    let inToolCall = false;
     const out = [];
     for (const line of lines) {
-        if (line.startsWith('<tool_call>') || line.startsWith('</tool_call>'))
+        if (line.startsWith('<tool_call>')) {
+            inToolCall = true;
+            continue;
+        }
+        if (line.startsWith('</tool_call>')) {
+            inToolCall = false;
+            continue;
+        }
+        if (inToolCall)
             continue;
         if (line.startsWith('```')) {
             inCode = !inCode;
@@ -41,7 +50,24 @@ function formatContent(text) {
     }
     return out.join('\n');
 }
-export function welcome(provider, model, cwd) {
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n) + '…' : s;
+}
+function toolArgSummary(args) {
+    if (args.message)
+        return `"${truncate(String(args.message), 60)}"`;
+    if (args.path)
+        return String(args.path);
+    if (args.command)
+        return truncate(String(args.command), 60);
+    if (args.query)
+        return `"${truncate(String(args.query), 60)}"`;
+    if (args.from)
+        return `${args.from} → ${args.to}`;
+    const first = Object.values(args)[0];
+    return first ? truncate(String(first), 60) : '';
+}
+export function welcome(provider, model, cwd, version, updateAvailable, linked) {
     const cols = Math.min(process.stdout.columns ?? 80, 100);
     const innerW = cols - 2;
     const leftW = Math.floor(innerW * 0.44);
@@ -64,11 +90,17 @@ export function welcome(provider, model, cwd) {
     function rcmd(key, desc, keyW = 10) {
         return '  ' + cyan(key) + ' '.repeat(Math.max(1, keyW - key.length)) + gray(desc);
     }
-    const titleStr = '─ MIII - CLI ';
+    const versionStr = version ? ` v${version}` : '';
+    const titleStr = `─ MIII - CLI${versionStr} `;
     const dashCount = Math.max(0, cols - 2 - titleStr.length);
-    const top = gray('╭') + gray('─') + bold(cyan(' MIII - CLI ')) + gray('─'.repeat(dashCount) + '╮');
+    const top = gray('╭') + gray('─') + bold(cyan(` MIII - CLI${versionStr} `)) + gray('─'.repeat(dashCount) + '╮');
     const bottom = gray('╰' + '─'.repeat(innerW) + '╯');
     const shortCwd = cwd.replace(process.env.HOME ?? '', '~');
+    const upgradeCmd = linked ? 'cd <miii-dir> && npm run build' : 'npm install -g miii-cli';
+    const separator = gray('│') + bold(yellow(' ⬆ update available: v' + updateAvailable + ' — run: ' + upgradeCmd)).padEnd(innerW - 1) + gray('│');
+    const updateRow = updateAvailable
+        ? [gray('├' + '─'.repeat(innerW) + '┤'), separator, gray('├' + '─'.repeat(innerW) + '┤')]
+        : [];
     const lines = [
         top,
         blank(),
@@ -82,6 +114,7 @@ export function welcome(provider, model, cwd) {
         row(`  ${gray(provider + '/' + model)}`, `  ${bold(yellow('Tips'))}`),
         row(`  ${gray(shortCwd)}`, rcmd('ctrl+c', 'stop thinking')),
         row('', rcmd('ctrl+c x2', 'exit')),
+        ...updateRow,
         blank(),
         bottom,
     ];
@@ -94,12 +127,17 @@ export function userMsg(text) {
 export function assistantMsg(text) {
     console.log(`\n${bold(green('miii'))}\n${formatContent(text)}`);
 }
+export function toolCallStart(name, args) {
+    const summary = toolArgSummary(args);
+    process.stdout.write(`  ${gray('⎿')} ${cyan(name)}${summary ? gray('(' + summary + ')') : ''}\n`);
+}
 export function toolMsg(name, result) {
     const preview = result.length > 250 ? result.slice(0, 250) + '…' : result;
     const body = preview.trim()
         ? preview.split('\n').map(l => gray('    ' + l)).join('\n')
         : '';
-    console.log(`  ${green('✓')} ${cyan(name)}${body ? '\n' + body : ''}`);
+    if (body)
+        console.log(body);
 }
 export function systemMsg(text) {
     console.log(gray(`─ ${text}`));

package/dist/tui/thinking.js

@@ -0,0 +1,53 @@
+export 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…',
+    'rebooting common sense… this may take a while…',
+    'performing a very convincing impression of thinking…',
+    'searching for wisdom in all the wrong places…',
+    'warming up the neurons (both of them)…',
+    'confidently striding toward the wrong answer…',
+    'consulting my gut. it says maybe…',
+    'loading… just kidding, still loading…',
+    'asking the universe. universe has not replied…',
+    'vigorously nodding while understanding nothing…',
+    'doing math on my fingers (ran out of fingers)…',
+    'the confidence is fake. the effort is real. probably…',
+    'entering a fugue state. for your benefit…',
+    'mining the depths of mediocrity…',
+    'compiling a list of plausible nonsense…',
+    'this would be faster if I knew what I was doing…',
+    'buffering at the speed of thought…',
+    'holding three contradictory opinions simultaneously…',
+    'interpolating between guesses…',
+    'rewinding the context window with a pencil…',
+    'waiting for a sign. any sign…',
+    'tracing the error back to its origin: me…',
+    'the logic checks out if you squint…',
+    'reasoning from first principles I just invented…',
+    'generating tokens and praying for coherence…',
+    'one sec — dropped all my thoughts, picking them up…',
+];
+export const SPARKLE = ['✦', '✧', '✶', '✷', '✸', '✹'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "description": "Claude Code-level terminal workflows powered by your local models.",
   "license": "MIT",
@@ -36,7 +36,8 @@
     "dev": "tsx src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
-    "link": "npm run build && npm link"
+    "link": "npm run build && npm link",
+    "test": "vitest run"
   },
   "dependencies": {
     "ink": "^5.2.0",
@@ -49,6 +50,7 @@
     "@types/node": "^22.10.0",
     "@types/react": "^18.3.1",
     "tsx": "^4.19.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.6"
   }
 }