miii-cli 1.1.0 → 1.1.2

package/dist/tools/index.js

@@ -34,7 +34,7 @@ export const tools = [
     },
     {
         name: 'create_file',
-        description: 'Create a new file — fails if file already exists',
+        description: 'Create a new file with content — fails if file already exists. Prefer edit_file for new files.',
         params: '{"path": "string", "content": "string"}',
         execute: async ({ path, content }) => {
             const safe = guardPath(path);
@@ -46,16 +46,24 @@ export const tools = [
     },
     {
         name: 'edit_file',
-        description: 'Overwrite entire file — use only for new files or full rewrites',
+        description: 'Write a new file — only for files that do not exist yet. Use patch_file to modify existing files.',
         params: '{"path": "string", "content": "string"}',
         execute: async ({ path, content }) => {
-            writeFile(guardPath(path), content);
-            return `written: ${path}`;
+            const safe = guardPath(path);
+            if (existsSync(safe)) {
+                throw new Error(`edit_file cannot overwrite existing file: ${path}\n` +
+                    `Use patch_file with <old> and <new> blocks to make targeted edits.\n` +
+                    `Call read_file first to get the exact current text.`);
+            }
+            const text = content;
+            writeFile(safe, text);
+            const lines = text.split('\n').length;
+            return `created: ${path} (${lines} line${lines === 1 ? '' : 's'})`;
         },
     },
     {
         name: 'patch_file',
-        description: 'Replace an exact string in a file — use for targeted edits to existing files',
+        description: 'Replace an exact unique string in an existing file. Always call read_file first to get the exact text.',
         params: '{"path": "string", "old": "string", "new": "string"}',
         execute: async ({ path, old: oldStr, new: newStr }) => {
             const safe = guardPath(path);
@@ -64,12 +72,29 @@ export const tools = [
                 throw new Error(`file not found or empty: ${path}`);
             const old = oldStr;
             const count = current.split(old).length - 1;
-            if (count === 0)
-                throw new Error(`old text not found in ${path}`);
-            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}`;
+            if (count === 0) {
+                throw new Error(`old text not found in ${path} — file may have changed since last read.\n` +
+                    `Call read_file again to get current content, then retry with exact matching text.`);
+            }
+            if (count > 1) {
+                throw new Error(`ambiguous: ${count} matches found in ${path} — extend <old> block with more surrounding lines to make it unique`);
+            }
+            const updated = current.replace(old, newStr);
+            writeFile(safe, updated);
+            // Compute affected line range for the snippet
+            const startLine = current.slice(0, current.indexOf(old)).split('\n').length;
+            const oldLines = old.split('\n').length;
+            const newLines = newStr.split('\n').length;
+            const updatedArr = updated.split('\n');
+            const snippetStart = Math.max(0, startLine - 3);
+            const snippetEnd = Math.min(updatedArr.length, startLine + newLines + 2);
+            const snippet = updatedArr
+                .slice(snippetStart, snippetEnd)
+                .map((l, i) => `${String(snippetStart + i + 1).padStart(4)} │ ${l}`)
+                .join('\n');
+            const delta = newLines - oldLines;
+            const deltaStr = delta === 0 ? '' : delta > 0 ? ` (+${delta} line${delta === 1 ? '' : 's'})` : ` (${delta} line${Math.abs(delta) === 1 ? '' : 's'})`;
+            return `patched: ${path}${deltaStr}\n\nLines ${snippetStart + 1}–${snippetEnd}:\n${snippet}`;
         },
     },
     {
@@ -284,9 +309,10 @@ ${toolDocs}
 ${deepThinkDoc}
 
 Rules:
-- To modify an existing file: use patch_file with the exact old text and new replacement — do NOT rewrite the whole file
-- 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
+- edit_file only works on NEW files — it throws an error if the file exists. Never call it on existing files
+- To modify any existing file: call read_file first, then patch_file with the exact text from that read as the <old> block
+- Never guess or reuse old text from earlier in the conversation — always re-read immediately before patching
+- If patch_file reports "old text not found", call read_file again and retry with the exact current text
 - 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

package/dist/tui/hooks/useRunLoop.js

@@ -155,12 +155,35 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                         }
                         if (tool) {
                             try {
+                                // Guard: for patch_file, verify old text still matches before executing.
+                                // If stale, inject fresh file content and skip — model will retry.
+                                if (tc.name === 'patch_file') {
+                                    const filePath = tc.args.path;
+                                    const oldText = tc.args.old;
+                                    if (filePath && oldText && existsSync(filePath)) {
+                                        const current = readFileSync(filePath, 'utf-8');
+                                        if (!current.includes(oldText)) {
+                                            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: `patch_file failed: old text not found in ${filePath}. The file content above is the current state. Retry patch_file with the correct exact text.` });
+                                            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}` });
+                                // After any file edit, inject fresh file state so next tool sees actual content
+                                if (FILE_EDIT_TOOLS.has(tc.name)) {
+                                    const filePath = tc.args.path;
+                                    if (filePath && existsSync(filePath)) {
+                                        const fresh = readFileSync(filePath, 'utf-8');
+                                        next.push({ role: 'user', content: `[current state of ${filePath} after edit]\n${fresh}` });
+                                    }
+                                }
                             }
                             catch (e) {
                                 const err = `Tool ${tc.name} error: ${e}`;
@@ -202,7 +225,23 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                         }
                     }
                 }
-                await runLoop(next, depth + 1, goal);
+                // For file-edit turns: slim context (system + goal + fresh file states + recent results)
+                // For non-edit turns: full next (model needs full conversational context)
+                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 batchStart = msgs.length + 1; // index in next where this batch's messages start
+                    const batchMsgs = next.slice(batchStart);
+                    const slimCtx = [
+                        ...(systemMsg ? [systemMsg] : []),
+                        ...(goalMsg ? [goalMsg] : []),
+                        ...batchMsgs,
+                    ];
+                    await runLoop(slimCtx, depth + 1, goal);
+                }
+                else {
+                    await runLoop(next, depth + 1, goal);
+                }
             },
             onError(err) {
                 if (err.name !== 'AbortError')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-cli",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "description": "The high-performance local AI coding agent for your terminal. Automate complex workflows with local LLMs.",
   "license": "MIT",
@@ -12,6 +12,7 @@
     "url": "https://github.com/maruakshay/miii-cli.git"
   },
   "homepage": "https://www.miii.in",
+  "readme": "README.md",
   "bugs": {
     "url": "https://github.com/maruakshay/miii-cli/issues"
   },