miii-cli 1.2.4 → 1.3.1

package/dist/tui/hooks/useRefactor.js

@@ -20,14 +20,15 @@ export function useRefactor(deps) {
                 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();
+        const controller = new AbortController();
+        abortRef.current = controller;
         let planText = '';
         await chat({
             provider: config.provider,
             model: currentModelRef.current,
             baseUrl: config.baseUrl,
             messages: planCtx,
-            signal: abortRef.current.signal,
+            signal: controller.signal,
             async onDone(text) { planText = text; },
             onError(err) { printer.errorMsg(err.message); },
         });
@@ -95,7 +96,7 @@ export function useRefactor(deps) {
                 model: currentModelRef.current,
                 baseUrl: config.baseUrl,
                 messages: editCtx,
-                signal: abortRef.current?.signal,
+                signal: controller.signal,
                 async onDone(text) { editText = text; },
                 onError(err) { printer.errorMsg(`edit LLM error: ${err.message}`); },
             });

package/dist/tui/hooks/useRunLoop.js

@@ -1,5 +1,8 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
 import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const runCmd = promisify(exec);
 import { chat } from '../../llm/stream.js';
 import { tools as staticTools } from '../../tools/index.js';
 import { StreamParser, extractBareToolCall } from '../../parser/stream-parser.js';
@@ -10,6 +13,7 @@ const FILE_EDIT_TOOLS = new Set(['edit_file', 'create_file', 'update_file', 'del
 const SHOW_RESULT_TOOLS = new Set(['run_tests', 'git_commit']);
 const PERMISSION_TOOLS = new Set(['edit_file', 'update_file', 'delete_file', 'create_file', 'move_file', 'run_command', 'git_commit']);
 const CHECKPOINT_TOOLS = new Set(['edit_file', 'update_file', 'create_file', 'delete_file']);
+const PARALLEL_SAFE = new Set(['read_file', 'list_files', 'git_status', 'git_log', 'git_diff', 'web_search', 'web_extract']);
 // Tool result messages that are ephemeral — never worth storing in memory or compact summaries
 const EPHEMERAL_PATTERN = /^Tool (read_file|list_files|run_tests) result:|^\[current state of|^\[Context compacted|^\[file updated:/;
 export function stripEphemeral(messages) {
@@ -23,6 +27,7 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
     const [permissionRequest, setPermissionRequest] = useState(null);
     const permissionResolveRef = useRef(null);
     const checkpointRef = useRef(new Map());
+    const autoBranchedRef = useRef(null);
     const sessionApprovedRef = useRef(new Set());
     const thinkingStartRef = useRef(0);
     const extraToolsRef = useRef(extraTools);
@@ -42,7 +47,7 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
         const t = setInterval(() => setTick(n => n + 1), 80);
         return () => clearInterval(t);
     }, [status]);
-    const runLoop = useCallback(async (contextMsgs, depth = 0, goal) => {
+    const runLoop = useCallback(async (contextMsgs, depth = 0, goal, options) => {
         if (depth >= MAX_TOOL_DEPTH) {
             abortRef.current = null;
             setStatus('idle');
@@ -52,7 +57,9 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
         if (depth === 0) {
             thinkingStartRef.current = Date.now();
             checkpointRef.current.clear();
+            autoBranchedRef.current = null;
         }
+        abortRef.current = new AbortController();
         let msgs = contextMsgs;
         if (shouldCompact(contextMsgs)) {
             printer.systemMsg('compacting context…');
@@ -62,17 +69,31 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                 model: currentModelRef.current,
                 baseUrl: config.baseUrl,
                 apiKey: config.apiKey,
-            }, goal);
+            }, goal, abortRef.current.signal);
+            if (abortRef.current.signal.aborted) {
+                setStatus('idle');
+                return;
+            }
             printer.systemMsg(`compacted: ${contextMsgs.length} → ${msgs.length} messages`);
             replaceHistoryRef.current?.(msgs.filter(m => m.role !== 'system'));
         }
-        abortRef.current = new AbortController();
+        let didStream = false;
         await chat({
             provider: config.provider,
             model: currentModelRef.current,
             baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
             messages: msgs,
+            tools: config.provider !== 'ollama' && !(options?.noTools && depth === 0) ? [...staticTools, ...extraToolsRef.current] : undefined,
+            toolChoice: (options?.noTools && depth === 0) ? 'none' : undefined,
             signal: abortRef.current.signal,
+            onChunk: config.streaming ? (chunk) => {
+                if (!didStream) {
+                    printer.streamStart();
+                    didStream = true;
+                }
+                printer.streamChunk(chunk);
+            } : undefined,
             onRetry(attempt, max, delayMs) {
                 printer.systemMsg(`retry ${attempt}/${max} — waiting ${Math.round(delayMs / 1000)}s`);
             },
@@ -91,8 +112,10 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                     if (bare)
                         pendingTools.push({ name: bare.name, args: bare.args });
                 }
+                if (didStream)
+                    printer.streamEnd();
                 const displayText = textParts.join('').trim();
-                if (displayText)
+                if (displayText && !didStream)
                     printer.assistantMsg(displayText);
                 pushHistoryRef.current({ role: 'assistant', content: fullText });
                 if (pendingTools.length)
@@ -107,108 +130,161 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                         await runLoop([...msgs, { role: 'assistant', content: fullText }, nudge], depth + 1, goal);
                         return;
                     }
+                    if (autoBranchedRef.current)
+                        printer.systemMsg(`branch: ${autoBranchedRef.current}  (git checkout main when done)`);
                     printer.systemMsg(`done in ${printer.formatElapsed(Date.now() - thinkingStartRef.current)}`);
                     setStatus('idle');
                     return;
                 }
                 setStatus('tool');
                 const next = [...msgs, { role: 'assistant', content: fullText }];
-                try {
-                    for (const tc of pendingTools) {
+                const allParallelSafe = pendingTools.every(tc => PARALLEL_SAFE.has(tc.name));
+                if (allParallelSafe && pendingTools.length > 1) {
+                    try {
+                        setCurrentTool(pendingTools[0].name);
                         const allTools = [...staticTools, ...extraToolsRef.current];
-                        const tool = allTools.find(t => t.name === tc.name);
-                        setCurrentTool(tc.name);
-                        if (PERMISSION_TOOLS.has(tc.name)) {
-                            const sessionKey = tc.name;
-                            let decision;
-                            if (sessionApprovedRef.current.has(sessionKey)) {
-                                decision = 'yes';
+                        const settled = await Promise.allSettled(pendingTools.map(async (tc) => {
+                            const tool = allTools.find(t => t.name === tc.name);
+                            printer.toolCallStart(tc.name, tc.args);
+                            if (!tool)
+                                throw new Error(`unknown tool: ${tc.name}`);
+                            const result = await tool.execute(tc.args);
+                            printer.toolResultSummary(tc.name, tc.args, result);
+                            if (SHOW_RESULT_TOOLS.has(tc.name))
+                                printer.toolMsg(tc.name, result);
+                            return { tc, result };
+                        }));
+                        for (const r of settled) {
+                            if (r.status === 'fulfilled') {
+                                next.push({ role: 'user', content: `Tool ${r.value.tc.name} result:\n${r.value.result}` });
                             }
                             else {
-                                decision = await new Promise(resolve => {
-                                    permissionResolveRef.current = resolve;
-                                    setPermissionRequest({ toolName: tc.name, args: tc.args });
-                                });
-                            }
-                            if (decision === 'session')
-                                sessionApprovedRef.current.add(sessionKey);
-                            if (decision === 'no') {
-                                printer.systemMsg(`denied: ${tc.name}`);
-                                next.push({ role: 'user', content: `Tool ${tc.name} was denied by the user` });
-                                break;
+                                const err = `Tool error: ${r.reason}`;
+                                printer.errorMsg(err);
+                                next.push({ role: 'user', content: err });
                             }
-                            // Checkpoint: store pre-execution file state
-                            if (CHECKPOINT_TOOLS.has(tc.name)) {
-                                const path = tc.args.path;
-                                if (path && !checkpointRef.current.has(path)) {
-                                    try {
-                                        checkpointRef.current.set(path, readFileSync(path, 'utf-8'));
+                        }
+                    }
+                    finally {
+                        setCurrentTool(undefined);
+                    }
+                }
+                else {
+                    try {
+                        for (const tc of pendingTools) {
+                            const allTools = [...staticTools, ...extraToolsRef.current];
+                            const tool = allTools.find(t => t.name === tc.name);
+                            setCurrentTool(tc.name);
+                            if (PERMISSION_TOOLS.has(tc.name)) {
+                                const sessionKey = tc.name;
+                                let decision;
+                                if (sessionApprovedRef.current.has(sessionKey)) {
+                                    decision = 'yes';
+                                }
+                                else {
+                                    decision = await new Promise(resolve => {
+                                        permissionResolveRef.current = resolve;
+                                        setPermissionRequest({ toolName: tc.name, args: tc.args });
+                                    });
+                                }
+                                if (decision === 'session')
+                                    sessionApprovedRef.current.add(sessionKey);
+                                if (decision === 'no') {
+                                    printer.systemMsg(`denied: ${tc.name}`);
+                                    const remaining = pendingTools.slice(pendingTools.indexOf(tc) + 1).map(t => t.name);
+                                    const skippedNote = remaining.length ? ` The following tools were also skipped: ${remaining.join(', ')}.` : '';
+                                    next.push({ role: 'user', content: `Tool ${tc.name} was denied by the user.${skippedNote} Do not retry these tools unless the user explicitly asks.` });
+                                    break;
+                                }
+                                // Checkpoint: store pre-execution file state + auto-branch on first edit
+                                if (CHECKPOINT_TOOLS.has(tc.name)) {
+                                    const path = tc.args.path;
+                                    if (path && !checkpointRef.current.has(path)) {
+                                        try {
+                                            checkpointRef.current.set(path, readFileSync(path, 'utf-8'));
+                                        }
+                                        catch {
+                                            checkpointRef.current.set(path, null);
+                                        }
                                     }
-                                    catch {
-                                        checkpointRef.current.set(path, null);
+                                    if (!autoBranchedRef.current) {
+                                        try {
+                                            const { stdout } = await runCmd('git rev-parse --abbrev-ref HEAD', { timeout: 3000 });
+                                            const branch = stdout.trim();
+                                            if (branch === 'main' || branch === 'master') {
+                                                const ts = new Date().toISOString().slice(0, 16).replace(/[T:]/g, '-');
+                                                const newBranch = `miii/task-${ts}`;
+                                                await runCmd(`git checkout -b ${newBranch}`, { timeout: 5000 });
+                                                autoBranchedRef.current = newBranch;
+                                                printer.systemMsg(`auto-branched: ${newBranch}`);
+                                            }
+                                        }
+                                        catch { }
                                     }
                                 }
                             }
-                        }
-                        if (tool) {
-                            try {
-                                // Guard: for update_file, verify old text still matches before executing.
-                                // If stale, inject fresh file content and skip — model will retry.
-                                if (tc.name === 'update_file') {
-                                    const filePath = tc.args.path;
-                                    const oldText = tc.args.old;
-                                    if (filePath && oldText && existsSync(filePath)) {
-                                        const current = readFileSync(filePath, 'utf-8');
-                                        const occurrences = current.split(oldText).length - 1;
-                                        if (occurrences === 0) {
-                                            printer.errorMsg(`patch stale: old text not found in ${filePath} — injecting fresh content`);
-                                            next.push({ role: 'user', content: `Tool read_file result:\n${current}` });
-                                            next.push({ role: 'user', content: `update_file failed: the <old> text you used does not exist in ${filePath}. The CURRENT file content is shown above. Re-read it carefully, find the exact text you want to replace, and retry update_file using text that exactly matches what is in the file now.` });
-                                            continue;
+                            if (tool) {
+                                try {
+                                    // Guard: for update_file, verify old text still matches before executing.
+                                    // If stale, inject fresh file content and skip — model will retry.
+                                    if (tc.name === 'update_file') {
+                                        const filePath = tc.args.path;
+                                        const oldText = tc.args.old;
+                                        if (filePath && oldText && existsSync(filePath)) {
+                                            const norm = (s) => s.replace(/\r\n/g, '\n');
+                                            const current = readFileSync(filePath, 'utf-8');
+                                            const occurrences = norm(current).split(norm(oldText)).length - 1;
+                                            if (occurrences === 0) {
+                                                printer.errorMsg(`patch stale: old text not found in ${filePath} — injecting fresh content`);
+                                                next.push({ role: 'user', content: `Tool read_file result:\n${current}` });
+                                                next.push({ role: 'user', content: `update_file failed: the <old> text you used does not exist in ${filePath}. The CURRENT file content is shown above. Re-read it carefully, find the exact text you want to replace, and retry update_file using text that exactly matches what is in the file now.` });
+                                                continue;
+                                            }
+                                            if (occurrences > 1) {
+                                                printer.errorMsg(`patch ambiguous: old text matches ${occurrences} locations in ${filePath} — injecting fresh content`);
+                                                next.push({ role: 'user', content: `Tool read_file result:\n${current}` });
+                                                next.push({ role: 'user', content: `update_file failed: the <old> text matches ${occurrences} locations in ${filePath}. Add more surrounding lines to the <old> block to make it unique, then retry.` });
+                                                continue;
+                                            }
                                         }
-                                        if (occurrences > 1) {
-                                            printer.errorMsg(`patch ambiguous: old text matches ${occurrences} locations in ${filePath} — injecting fresh content`);
-                                            next.push({ role: 'user', content: `Tool read_file result:\n${current}` });
-                                            next.push({ role: 'user', content: `update_file failed: the <old> text matches ${occurrences} locations in ${filePath}. Add more surrounding lines to the <old> block to make it unique, then retry.` });
-                                            continue;
+                                    }
+                                    printer.toolCallStart(tc.name, tc.args);
+                                    const result = await tool.execute(tc.args);
+                                    printer.toolResultSummary(tc.name, tc.args, result);
+                                    if (SHOW_RESULT_TOOLS.has(tc.name))
+                                        printer.toolMsg(tc.name, result);
+                                    next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` });
+                                    if (FILE_EDIT_TOOLS.has(tc.name)) {
+                                        const filePath = tc.args.path;
+                                        if (filePath && existsSync(filePath)) {
+                                            const lineCount = readFileSync(filePath, 'utf-8').split('\n').length;
+                                            next.push({ role: 'user', content: `[file updated: ${filePath} — ${lineCount} lines]` });
                                         }
                                     }
                                 }
-                                printer.toolCallStart(tc.name, tc.args);
-                                const result = await tool.execute(tc.args);
-                                printer.toolResultSummary(tc.name, tc.args, result);
-                                if (SHOW_RESULT_TOOLS.has(tc.name))
-                                    printer.toolMsg(tc.name, result);
-                                next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` });
-                                if (FILE_EDIT_TOOLS.has(tc.name)) {
-                                    const filePath = tc.args.path;
-                                    if (filePath && existsSync(filePath)) {
-                                        const lineCount = readFileSync(filePath, 'utf-8').split('\n').length;
-                                        next.push({ role: 'user', content: `[file updated: ${filePath} — ${lineCount} lines]` });
-                                    }
+                                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}` });
-                        }
                     }
-                }
-                finally {
-                    setCurrentTool(undefined);
-                }
+                    finally {
+                        setCurrentTool(undefined);
+                    }
+                } // end sequential else
                 // For file-edit turns: slim context (system + goal + fresh file states + recent results)
                 // For non-edit turns: full next (model needs full conversational context)
                 const didEditFiles = pendingTools.some(tc => FILE_EDIT_TOOLS.has(tc.name));
                 if (didEditFiles) {
                     const systemMsg = msgs.find(m => m.role === 'system');
-                    const goalMsg = msgs.find(m => m.role === 'user' && !m.content.startsWith('[') && !m.content.startsWith('Tool '));
+                    const goalMsg = msgs.find(m => m.role === 'user' && !m.content.startsWith('[') && !m.content.startsWith('Tool '))
+                        ?? (goal ? { role: 'user', content: goal } : undefined);
                     const batchStart = msgs.length; // include assistant message so model sees its own tool call on retry
                     const batchMsgs = next.slice(batchStart);
                     const slimCtx = [
@@ -257,6 +333,10 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
             if (restored > 0)
                 printer.systemMsg(`restored ${restored} file(s) to pre-session state`);
         }
+        if (autoBranchedRef.current) {
+            printer.systemMsg(`task branch preserved: ${autoBranchedRef.current}`);
+            autoBranchedRef.current = null;
+        }
         setStatus('idle');
     }, []);
     return {

package/dist/tui/hooks/useSession.js

@@ -9,7 +9,7 @@ const SHORT_MEMORY_SIZE = 50;
 function buildSystemPrompt(cwd, facts, extraTools = []) {
     return getSystemPrompt(`\n- CWD: ${cwd}`, extraTools) + formatMemoryBlock(facts);
 }
-export function useSession(initialSession, cwd, config, extraTools = []) {
+export function useSession(initialSession, cwd, config, extraTools = [], currentModelRef) {
     const projectDir = getProjectDir(cwd);
     const [sessionName, setSessionName] = useState(initialSession);
     const sessionNameRef = useRef(initialSession);
@@ -49,7 +49,7 @@ export function useSession(initialSession, cwd, config, extraTools = []) {
         if (historyRef.current.length > SHORT_MEMORY_SIZE && !extractingRef.current) {
             const dropped = historyRef.current.splice(0, historyRef.current.length - SHORT_MEMORY_SIZE);
             extractingRef.current = true;
-            extractFacts(dropped, config, config.model).then(newFacts => {
+            extractFacts(dropped, config, currentModelRef?.current ?? config.model).then(newFacts => {
                 if (newFacts.length) {
                     const updated = mergeFacts(longMemoryRef.current, newFacts);
                     longMemoryRef.current = updated;

package/dist/tui/hooks/useSubmit.js

@@ -326,6 +326,18 @@ Analyze what exists, then implement the design. Use the design system above if a
             }
             return;
         }
+        if (cmd.startsWith('/plan exec ')) {
+            const task = cmd.slice(11).trim();
+            if (!task) {
+                printer.systemMsg('usage: /plan exec <task>');
+                return;
+            }
+            const planPrompt = `PLANNING TURN — output a numbered plan of exactly what you will do to accomplish this task. List which files to read, which to edit, and what changes to make. Do NOT call any tools in this response. After I review the plan and respond "go", you will execute.\n\nTask: ${task}`;
+            printer.userMsg(`/plan exec ${task}`);
+            pushHistory({ role: 'user', content: planPrompt });
+            await runLoop(buildContext(), 0, task, { noTools: true });
+            return;
+        }
         if (cmd === '/plan' || cmd.startsWith('/plan ')) {
             const topic = cmd.slice(5).trim();
             setPlanningMode(true);

package/dist/tui/printer.js

@@ -81,7 +81,7 @@ export function toolArgSummary(args) {
     const first = Object.values(args)[0];
     return first ? truncate(String(first), 60) : '';
 }
-export function welcome(provider, model, cwd, version, updateAvailable, linked) {
+export function welcome(cwd, version, updateAvailable, linked) {
     const cols = Math.min(process.stdout.columns ?? 80, 100);
     const innerW = cols - 2;
     const leftW = Math.floor(innerW * 0.44);
@@ -114,7 +114,6 @@ export function welcome(provider, model, cwd, version, updateAvailable, linked)
         '',
         ...miniArt,
         '',
-        `  ${gray(model + ' · ' + provider)}`,
         `  ${gray(shortCwd)}`,
         '',
     ];
@@ -162,8 +161,11 @@ export function assistantMsg(text) {
     const tail = lines.slice(idx + 1).join('\n');
     write(`\n${blue('●')} ${head}${tail ? '\n' + tail : ''}\n`);
 }
-export const EDIT_TOOLS = new Set(['edit_file', 'update_file', 'create_file', 'write_file']);
-export const DELETE_TOOLS = new Set(['delete_file', 'remove_file']);
+export function streamStart() { write(`\n${blue('●')} `); }
+export function streamChunk(s) { write(s); }
+export function streamEnd() { write('\n'); }
+export const EDIT_TOOLS = new Set(['edit_file', 'update_file', 'create_file']);
+export const DELETE_TOOLS = new Set(['delete_file']);
 const PERM_DESC = {
     delete_file: 'delete this file',
     update_file: 'edit this file',
@@ -292,8 +294,7 @@ export function toolResultSummary(name, args, result) {
     const lines = result.trim().split('\n').filter(Boolean);
     let summary = '';
     switch (name) {
-        case 'edit_file':
-        case 'write_file': {
+        case 'edit_file': {
             const n = (a.content ?? '').split('\n').length;
             summary = `Wrote ${n} line${n === 1 ? '' : 's'}`;
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-cli",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "type": "module",
   "description": "The high-performance local AI coding agent for your terminal. Automate complex workflows with local LLMs.",
   "license": "MIT",