miii-cli 0.2.1 → 0.2.3

package/dist/tasks/executor.js

@@ -0,0 +1,88 @@
+import { MicroQueue } from './queue.js';
+export class TaskExecutor {
+    toolMap;
+    constructor(tools) {
+        this.toolMap = new Map(tools.map(t => [t.name, t]));
+    }
+    async runMacro(macro, onProgress) {
+        const queue = new MicroQueue();
+        for (const t of macro.microtasks) {
+            t.status = 'pending';
+            queue.push(t);
+        }
+        return this.drain(queue, onProgress);
+    }
+    async drain(queue, onProgress) {
+        const results = new Map();
+        const allTasks = queue.toArray();
+        while (queue.size > 0) {
+            const ready = this._ready(allTasks, results);
+            if (!ready.length)
+                break;
+            // Remove ready tasks from queue — rebuild without them
+            const readyIds = new Set(ready.map(t => t.id));
+            const remaining = queue.toArray().filter(t => !readyIds.has(t.id));
+            // Clear and re-push remaining
+            while (queue.pop()) { }
+            for (const t of remaining)
+                queue.push(t);
+            // Execute by priority group
+            const byPri = groupBy(ready, t => t.priority);
+            for (const pri of [0, 1, 2, 3]) {
+                const group = byPri.get(pri) ?? [];
+                if (!group.length)
+                    continue;
+                if (pri === 1) {
+                    // Reads run in parallel
+                    await Promise.all(group.map(t => this._run(t, results, onProgress)));
+                }
+                else {
+                    // Blocking (0), writes (2), verify (3) — sequential
+                    for (const t of group) {
+                        await this._run(t, results, onProgress);
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    _ready(all, results) {
+        return all.filter(t => t.status === 'pending' &&
+            t.deps.every(dep => {
+                const dt = all.find(x => x.id === dep);
+                return !dt || dt.status === 'done' || dt.status === 'skipped';
+            }));
+    }
+    async _run(task, results, onProgress) {
+        task.status = 'running';
+        const tool = this.toolMap.get(task.tool);
+        if (!tool) {
+            task.status = 'failed';
+            task.error = `unknown tool: ${task.tool}`;
+            onProgress({ task, error: task.error });
+            return;
+        }
+        try {
+            const result = await tool.execute(task.args);
+            task.status = 'done';
+            task.result = result;
+            results.set(task.id, result);
+            onProgress({ task, result });
+        }
+        catch (e) {
+            task.status = 'failed';
+            task.error = String(e);
+            onProgress({ task, error: task.error });
+        }
+    }
+}
+function groupBy(arr, key) {
+    const m = new Map();
+    for (const v of arr) {
+        const k = key(v);
+        const g = m.get(k) ?? [];
+        g.push(v);
+        m.set(k, g);
+    }
+    return m;
+}

package/dist/tasks/queue.js

@@ -0,0 +1,72 @@
+// ─── MicroQueue — min-heap by priority, FIFO within same priority ────────────
+export class MicroQueue {
+    heap = [];
+    seq = 0;
+    order = new Map();
+    push(task) {
+        this.order.set(task.id, this.seq++);
+        this.heap.push(task);
+        this._up(this.heap.length - 1);
+    }
+    pop() {
+        if (!this.heap.length)
+            return undefined;
+        const top = this.heap[0];
+        const last = this.heap.pop();
+        if (this.heap.length) {
+            this.heap[0] = last;
+            this._down(0);
+        }
+        return top;
+    }
+    peek() { return this.heap[0]; }
+    get size() { return this.heap.length; }
+    toArray() { return [...this.heap]; }
+    _cmp(a, b) {
+        if (a.priority !== b.priority)
+            return a.priority < b.priority;
+        return (this.order.get(a.id) ?? 0) < (this.order.get(b.id) ?? 0);
+    }
+    _up(i) {
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            if (this._cmp(this.heap[i], this.heap[p])) {
+                ;
+                [this.heap[i], this.heap[p]] = [this.heap[p], this.heap[i]];
+                i = p;
+            }
+            else
+                break;
+        }
+    }
+    _down(i) {
+        const n = this.heap.length;
+        while (true) {
+            let min = i;
+            const l = 2 * i + 1, r = 2 * i + 2;
+            if (l < n && this._cmp(this.heap[l], this.heap[min]))
+                min = l;
+            if (r < n && this._cmp(this.heap[r], this.heap[min]))
+                min = r;
+            if (min === i)
+                break;
+            [this.heap[i], this.heap[min]] = [this.heap[min], this.heap[i]];
+            i = min;
+        }
+    }
+}
+// ─── MacroQueue — priority-sorted list of refactor goals ─────────────────────
+export class MacroQueue {
+    tasks = [];
+    enqueue(task) {
+        const i = this.tasks.findIndex(t => t.priority > task.priority);
+        if (i === -1)
+            this.tasks.push(task);
+        else
+            this.tasks.splice(i, 0, task);
+    }
+    dequeue() { return this.tasks.shift(); }
+    peek() { return this.tasks[0]; }
+    get size() { return this.tasks.length; }
+    list() { return [...this.tasks]; }
+}

package/dist/tools/index.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile, deleteFile, listFiles, createDir, moveFile, guardPath } from '../files/ops.js';
 import { existsSync } from 'fs';
+import { join } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const run = promisify(exec);
@@ -59,10 +60,13 @@ export const tools = [
             const current = readFile(safe);
             if (!current)
                 throw new Error(`file not found or empty: ${path}`);
-            if (!current.includes(oldStr))
+            const old = oldStr;
+            const count = current.split(old).length - 1;
+            if (count === 0)
                 throw new Error(`old text not found in ${path}`);
-            const updated = current.replace(oldStr, newStr);
-            writeFile(safe, updated);
+            if (count > 1)
+                throw new Error(`ambiguous: ${count} matches found in ${path} — add more surrounding context to make unique`);
+            writeFile(safe, current.replace(old, newStr));
             return `patched: ${path}`;
         },
     },
@@ -102,6 +106,101 @@ export const tools = [
             return `moved: ${from} → ${to}`;
         },
     },
+    {
+        name: 'git_status',
+        description: 'Show git working tree status',
+        params: '{}',
+        execute: async () => {
+            try {
+                const { stdout } = await run('git status --short', { timeout: EXEC_TIMEOUT_MS });
+                return stdout.trim() || '(clean — no changes)';
+            }
+            catch (e) {
+                throw new Error(`git_status: ${e}`);
+            }
+        },
+    },
+    {
+        name: 'git_diff',
+        description: 'Show git diff. staged=true for staged changes, path for specific file',
+        params: '{"staged": "boolean (optional)", "path": "string (optional)"}',
+        execute: async ({ staged = false, path = '' }) => {
+            const args = staged ? '--staged' : '';
+            const target = path ? `-- "${path}"` : '';
+            try {
+                const { stdout } = await run(`git diff ${args} ${target}`.trim(), { timeout: EXEC_TIMEOUT_MS });
+                const out = stdout.trim();
+                if (!out)
+                    return '(no diff)';
+                return out.length > 8000 ? out.slice(0, 8000) + '\n…[diff truncated at 8k chars]' : out;
+            }
+            catch (e) {
+                throw new Error(`git_diff: ${e}`);
+            }
+        },
+    },
+    {
+        name: 'git_log',
+        description: 'Show recent git commits',
+        params: '{"n": "number (optional, default 10)"}',
+        execute: async ({ n = 10 }) => {
+            try {
+                const { stdout } = await run(`git log --oneline -${Math.min(Number(n), 50)}`, { timeout: EXEC_TIMEOUT_MS });
+                return stdout.trim() || '(no commits)';
+            }
+            catch (e) {
+                throw new Error(`git_log: ${e}`);
+            }
+        },
+    },
+    {
+        name: 'git_commit',
+        description: 'Stage files and create a git commit. Use files="-A" to stage all.',
+        params: '{"message": "string", "files": "string (optional, default -A)"}',
+        execute: async ({ message, files = '-A' }) => {
+            if (!message)
+                throw new Error('git_commit: message required');
+            try {
+                await run(`git add ${files}`, { timeout: EXEC_TIMEOUT_MS });
+                const { stdout } = await run(`git commit -m ${JSON.stringify(String(message))}`, { timeout: EXEC_TIMEOUT_MS });
+                return stdout.trim();
+            }
+            catch (e) {
+                throw new Error(`git_commit: ${e}`);
+            }
+        },
+    },
+    {
+        name: 'run_tests',
+        description: 'Run the test suite. Detects jest/vitest/mocha from package.json scripts.test. Pass path to run a specific file.',
+        params: '{"path": "string (optional)"}',
+        execute: async ({ path = '' }) => {
+            const pkgPath = join(process.cwd(), 'package.json');
+            if (!existsSync(pkgPath))
+                return '(no package.json found)';
+            let testScript = '';
+            try {
+                const pkg = JSON.parse(readFile(pkgPath));
+                testScript = pkg?.scripts?.test ?? '';
+            }
+            catch {
+                return '(could not parse package.json)';
+            }
+            if (!testScript || testScript === 'echo "Error: no test specified" && exit 1') {
+                return '(no test script configured in package.json)';
+            }
+            const cmd = path ? `npm test -- ${path}` : 'npm test';
+            try {
+                const { stdout, stderr } = await run(cmd, { cwd: process.cwd(), timeout: 60_000 });
+                const out = (stdout + (stderr ? '\nstderr: ' + stderr : '')).trim();
+                return out.length > 4000 ? '…[truncated]\n' + out.slice(-4000) : out;
+            }
+            catch (e) {
+                const out = ((e.stdout ?? '') + (e.stderr ? '\n' + e.stderr : '') || String(e)).trim();
+                return out.length > 4000 ? '…[truncated]\n' + out.slice(-4000) : out;
+            }
+        },
+    },
 ];
 export function getSystemPrompt(extra = '') {
     const toolDocs = tools.map(t => `- ${t.name}(${t.params}): ${t.description}`).join('\n');
@@ -141,10 +240,14 @@ Rules:
 - To create a new file: use edit_file with full content in the <content> block
 - read_file before patch_file so you know the exact text to match
 - Never delete without confirming
+- Use git_status and git_diff before any refactor to understand what has already changed
+- Use git_log to understand recent history before suggesting changes
+- Always call git_status before git_commit to verify what will be staged
 - Be concise
 - Output plain text only — never use markdown formatting in your responses
 - No headers (no #, ##), no bold (**text**), no italic (*text*), no bullet points with *, no horizontal rules (---)
 - No fenced code blocks with backticks in prose
-- Use plain indentation and labels for structure. This is a terminal, not a chat UI${extra}`;
+- Use plain indentation and labels for structure. This is a terminal, not a chat UI
+- After editing files that have tests, call run_tests to verify nothing broke
+- If run_tests fails, read the failing test output and fix the code, then run_tests again (max 3 retries)${extra}`;
 }
-//# sourceMappingURL=index.js.map

package/dist/tui/App.js

@@ -283,4 +283,3 @@ export function App({ config, skills, cwd }) {
     const skillList = skills.list();
     return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(StatusBar, { model: currentModel, provider: config.provider, status: status, tick: tick }), _jsx(Divider, { cols: cols }), pickerOpen ? (_jsx(ModelPicker, { models: pickerModels, current: currentModel, loading: pickerLoading, error: pickerError, pull: pullState, onSelect: handleModelSelect, onPull: handleModelPull, onClose: () => { setPickerOpen(false); setPullState(undefined); } })) : (_jsx(MessageList, { messages: messages, rows: rows - 8, cols: cols, scrollOffset: scrollOffset, streaming: false, thinkingTick: status === 'thinking' ? tick : undefined })), _jsx(Divider, { cols: cols }), pendingApproval && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Allow ", pendingApproval.toolName, "?"] }), _jsxs(Text, { children: ["  path: ", _jsx(Text, { color: "cyan", children: pendingApproval.path })] }), pendingApproval.content && (_jsx(Text, { color: "gray", dimColor: true, children: pendingApproval.content.split('\n').slice(0, 12).join('\n') })), _jsxs(Text, { color: "green", children: ["[y] approve  ", _jsx(Text, { color: "red", children: "[n] cancel" })] })] })), _jsx(InputArea, { status: status, skills: skillList, cwd: cwd, onSubmit: handleSubmit, onAbort: handleAbort })] }));
 }
-//# sourceMappingURL=App.js.map