@taj-special/dravix-code 1.1.28 → 1.2.1

package/dist/cli/repl.js

@@ -289,7 +289,7 @@ function highlightCode(line, lang) {
 function applyInline(text) {
     return text
         .replace(/\*\*(.+?)\*\*|__(.+?)__/g, (_, a, b) => chalk.bold(a ?? b))
-        .replace(/`([^`\n]+)`/g, (_, c) => chalk.hex('#fbbf24')(c))
+        .replace(/`([^`\n]+)`/g, (_, c) => '`' + chalk.hex('#fbbf24')(c) + '`')
         .replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, (_, t) => chalk.italic(t));
 }
 class MarkdownRenderer {
@@ -409,30 +409,40 @@ class MarkdownRenderer {
         this.tableRows = [];
         if (rows.length === 0)
             return '';
-        const cols = Math.max(...rows.map(r => r.length));
+        // Filter out separator rows (--- | --- | ---)
+        const dataRows = rows.filter(r => !r.every(c => /^:?-+:?$/.test(c.trim())));
+        if (dataRows.length === 0)
+            return '';
+        const cols = Math.max(...dataRows.map(r => r.length));
         const termW = process.stdout.columns ?? 80;
         // max usable width per column (distribute evenly, min 6)
         const maxColW = Math.max(6, Math.floor((termW - 4 - (cols + 1)) / cols));
         const widths = Array(cols).fill(0);
-        for (const row of rows) {
+        for (const row of dataRows) {
             for (let i = 0; i < cols; i++) {
-                const cellLen = Math.min((row[i] ?? '').length, maxColW);
+                // Strip markdown formatting for width calculation
+                const rawCell = (row[i] ?? '').replace(/\*\*/g, '').replace(/`/g, '').trim();
+                const cellLen = Math.min(rawCell.length, maxColW);
                 widths[i] = Math.max(widths[i], cellLen + 2);
             }
         }
         const bar = (l, m, r) => colors.dim('  ' + l + widths.map(w => '─'.repeat(w)).join(m) + r);
         let out = '\n' + bar('┌', '┬', '┐') + '\n';
-        for (let ri = 0; ri < rows.length; ri++) {
-            const row = rows[ri];
+        for (let ri = 0; ri < dataRows.length; ri++) {
+            const row = dataRows[ri];
             const cells = widths.map((w, i) => {
-                const raw = row[i] ?? '';
-                const cell = raw.length > w - 2 ? raw.slice(0, w - 3) + '…' : raw;
+                const raw = (row[i] ?? '').trim();
+                // Strip markdown for display but keep formatting
+                const plain = raw.replace(/\*\*/g, '').replace(/`/g, '');
+                const cell = plain.length > w - 2 ? plain.slice(0, w - 3) + '…' : plain;
                 const pad = w - cell.length - 1;
+                // Apply formatting to the cell content
+                const formatted = applyInline(raw);
                 const text = ri === 0 ? chalk.bold.white(cell) : colors.ai(cell);
                 return ' ' + text + ' '.repeat(Math.max(pad, 0));
             });
             out += colors.dim('  │') + cells.join(colors.dim('│')) + colors.dim('│') + '\n';
-            if (ri === 0 && rows.length > 1)
+            if (ri === 0 && dataRows.length > 1)
                 out += bar('├', '┼', '┤') + '\n';
         }
         out += bar('└', '┴', '┘') + '\n';
@@ -462,14 +472,14 @@ class MarkdownRenderer {
         const capped = Math.min(inner, maxInner);
         const dashAfterLang = Math.max(0, capped - lang.length - 2);
         const top = lang
-            ? colors.dim('  ╭─ ') + chalk.hex('#818cf8')(lang) + colors.dim(' ' + '─'.repeat(dashAfterLang))
+            ? colors.dim('  ╭─ ') + colors.primary(lang) + colors.dim(' ' + '─'.repeat(dashAfterLang))
             : colors.dim('  ╭' + '─'.repeat(capped + 2));
         const bot = colors.dim('  ╰' + '─'.repeat(capped + 2));
         const canHighlight = lang && !['text', 'txt', 'plain', 'output', 'log'].includes(lang.toLowerCase());
         let out = '\n' + top + '\n';
         for (const l of lines) {
             const display = l.length > capped ? l.slice(0, capped - 1) + '…' : l;
-            const colorized = canHighlight ? highlightCode(display, lang) : chalk.hex('#e2e8f0')(display);
+            const colorized = canHighlight ? highlightCode(display, lang) : colors.text(display);
             out += colors.dim('  │ ') + colorized + '\n';
         }
         out += bot + '\n';
@@ -612,15 +622,15 @@ function printDiffPreview(op, cwd) {
         if (adds === 0 && removes === 0)
             return 0;
         const statStr = [
-            removes > 0 ? chalk.hex('#f87171').bold(`-${removes}`) : '',
-            adds > 0 ? chalk.hex('#34d399').bold(`+${adds}`) : '',
+            removes > 0 ? colors.error.bold(`-${removes}`) : '',
+            adds > 0 ? colors.success.bold(`+${adds}`) : '',
         ].filter(Boolean).join('  ');
         const writeLine = (s) => { process.stdout.write(s + '\n'); printed++; };
         process.stdout.write('\n');
         printed++;
-        writeLine(chalk.hex('#fbbf24')('  ~') +
-            chalk.hex('#94a3b8')('  ') +
-            chalk.hex('#e2e8f0')(op.path ?? '') +
+        writeLine(colors.warn('  ~') +
+            colors.subtext('  ') +
+            colors.text(op.path ?? '') +
             (statStr ? '   ' + statStr : ''));
         const CONTEXT = 2;
         const show = new Uint8Array(diff.length);
@@ -633,15 +643,15 @@ function printDiffPreview(op, cwd) {
         const renderLine = (line) => {
             const num = String(line.lineNo).padStart(5, ' ');
             if (line.kind === 'remove') {
-                const content = `  ${num}  ${chalk.hex('#f87171')('-')}  ${clip(line.text)}`;
-                writeLine('  ' + chalk.hex('#7f1d1d')('▌') + chalk.bgHex('#1c0a0a')(content.padEnd(cols - 3)));
+                const content = `  ${num}  ${colors.error('-')}  ${clip(line.text)}`;
+                writeLine('  ' + colors.error('▌') + chalk.bgHex('#1c0a0a')(content.padEnd(cols - 3)));
             }
             else if (line.kind === 'add') {
-                const content = `  ${num}  ${chalk.hex('#34d399')('+')}  ${clip(line.text)}`;
-                writeLine('  ' + chalk.hex('#065f46')('▌') + chalk.bgHex('#021a0e')(content.padEnd(cols - 3)));
+                const content = `  ${num}  ${colors.success('+')}  ${clip(line.text)}`;
+                writeLine('  ' + colors.success('▌') + chalk.bgHex('#021a0e')(content.padEnd(cols - 3)));
             }
             else {
-                writeLine(chalk.hex('#374151')(`       ${num}     ${clip(line.text)}`));
+                writeLine(colors.dim(`       ${num}     ${clip(line.text)}`));
             }
         };
         const hunks = [];
@@ -665,7 +675,7 @@ function printDiffPreview(op, cwd) {
             if (shown >= MAX_LINES)
                 break;
             if (h > 0) {
-                writeLine(chalk.hex('#374151')('        ╌╌╌'));
+                writeLine(colors.dim('        ╌╌╌'));
             }
             const hunk = hunks[h];
             const before = [];
@@ -708,7 +718,7 @@ function printDiffPreview(op, cwd) {
         }
         const total = diff.filter(d => d.kind !== 'context').length;
         if (total > MAX_LINES) {
-            writeLine(chalk.hex('#4b5563')(`        … ${total - MAX_LINES} more lines`));
+            writeLine(colors.muted(`        … ${total - MAX_LINES} more lines`));
         }
     }
     catch { /* ignore */ }
@@ -734,7 +744,6 @@ async function askPermission(label, key, alwaysAllowed, noAlways, diffShown, pre
             drawn = true;
             let lines;
             if (diffShown) {
-                // Diff already shown above — just show options, no redundant box
                 lines = [
                     '',
                     ...optLabels.map((lbl, i) => i === sel
@@ -846,25 +855,22 @@ async function readLine(prompt, cwd) {
         let suffix = '';
         let ctrlCCount = 0;
         let ctrlCTimer = null;
-        // @ file-completion state
         let atMode = false;
         let atQuery = '';
         let atSel = 0;
-        let atBoxLines = 0; // total picker box lines on screen (header + items + footer)
+        let atBoxLines = 0;
         let allFiles = [];
-        // / slash-command picker state
         let slashMode = false;
         let slashQuery = '';
         let slashSel = 0;
         let slashBoxLines = 0;
         let slashDrawn = false;
-        // Tab path-autocomplete state
         let tabMode = false;
         let tabQuery = '';
         let tabSel = 0;
         let tabBoxLines = 0;
         let tabDrawn = false;
-        let tabPreWord = ''; // prefix text before the tab-completed token
+        let tabPreWord = '';
         function onResize() {
             const newCols = process.stdout.columns ?? 80;
             const oldSepRows = Math.ceil(sepVisualLen / newCols);
@@ -979,9 +985,9 @@ async function readLine(prompt, cwd) {
                 atDrawn = true;
             }
             atBoxLines = 0;
-            const inputLine = colors.primary('  › ') + chalk.white(prefix) +
-                (pasteBlock !== null ? colors.muted(`[paste: ${pasteCount} lines]`) + chalk.white(suffix) : '') +
-                chalk.hex('#818cf8')('@') + chalk.white(atQuery);
+            const inputLine = colors.primary('  › ') + colors.text(prefix) +
+                (pasteBlock !== null ? colors.muted(`[paste: ${pasteCount} lines]`) + colors.text(suffix) : '') +
+                colors.primary('@') + colors.text(atQuery);
             process.stdout.write(inputLine + '\r\n' + SEP + '\r\n');
             const DW = Math.min(Math.max((process.stdout.columns ?? 80) - 6, 44), 72);
             const IW = DW - 6;
@@ -1009,8 +1015,8 @@ async function readLine(prompt, cwd) {
                     const pad = ' '.repeat(Math.max(IW - clip.length, 0));
                     const name = sel && isDir ? colors.primary.bold(clip) + pad
                         : sel ? colors.primary.bold(clip) + pad
-                            : isDir ? chalk.hex('#38bdf8')(clip) + pad
-                                : chalk.hex('#94a3b8')(clip + pad);
+                            : isDir ? chalk.hex('#74b9ff')(clip) + pad
+                                : colors.subtext(clip + pad);
                     process.stdout.write(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│') + '\n');
                     atBoxLines++;
                 }
@@ -1048,7 +1054,7 @@ async function readLine(prompt, cwd) {
                 slashDrawn = true;
             }
             slashBoxLines = 0;
-            const inputLine = colors.primary('  › ') + colors.primary('/') + chalk.white(slashQuery);
+            const inputLine = colors.primary('  › ') + colors.primary('/') + colors.text(slashQuery);
             process.stdout.write(inputLine + '\r\n' + SEP + '\r\n');
             const DW = Math.min(Math.max((process.stdout.columns ?? 80) - 6, 44), 72);
             const nameW = 10;
@@ -1074,8 +1080,8 @@ async function readLine(prompt, cwd) {
                     const nameStr = cmd.name.padEnd(nameW);
                     const descStr = cmd.desc.length > descW ? cmd.desc.slice(0, descW - 1) + '…' : cmd.desc;
                     const descPad = ' '.repeat(Math.max(descW - descStr.length, 0));
-                    const namePaint = sel ? colors.primary.bold(nameStr) : chalk.hex('#818cf8')(nameStr);
-                    const descPaint = sel ? colors.muted(descStr) : chalk.hex('#4b5563')(descStr);
+                    const namePaint = sel ? colors.primary.bold(nameStr) : colors.primary(nameStr);
+                    const descPaint = sel ? colors.muted(descStr) : colors.subtext(descStr);
                     process.stdout.write(colors.dim('  │') + `  ${mark} ` + namePaint + '  ' + descPaint + descPad + colors.dim('│') + '\n');
                     slashBoxLines++;
                 }
@@ -1113,8 +1119,8 @@ async function readLine(prompt, cwd) {
                 tabDrawn = true;
             }
             tabBoxLines = 0;
-            const TC = chalk.hex('#34d399');
-            const inputLine = colors.primary('  › ') + chalk.white(tabPreWord) + TC(tabQuery);
+            const TC = colors.success;
+            const inputLine = colors.primary('  › ') + colors.text(tabPreWord) + TC(tabQuery);
             process.stdout.write(inputLine + '\r\n' + SEP + '\r\n');
             const DW = Math.min(Math.max((process.stdout.columns ?? 80) - 6, 44), 72);
             const IW = DW - 6;
@@ -1141,8 +1147,8 @@ async function readLine(prompt, cwd) {
                     const clip = f.length > IW ? f.slice(0, IW - 1) + '…' : f;
                     const pad = ' '.repeat(Math.max(IW - clip.length, 0));
                     const name = sel ? TC.bold(clip) + pad
-                        : isDir ? chalk.hex('#38bdf8')(clip) + pad
-                            : chalk.hex('#94a3b8')(clip + pad);
+                        : isDir ? chalk.hex('#74b9ff')(clip) + pad
+                            : colors.subtext(clip + pad);
                     process.stdout.write(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│') + '\n');
                     tabBoxLines++;
                 }
@@ -1178,11 +1184,11 @@ async function readLine(prompt, cwd) {
                 displayPre = '…' + displayPre.slice(-(maxLen - 1));
             let inp;
             if (pasteBlock !== null) {
-                inp = colors.primary('  › ') + chalk.white(displayPre) +
-                    colors.muted(`[paste: ${pasteCount} lines]`) + chalk.white(suffix);
+                inp = colors.primary('  › ') + colors.text(displayPre) +
+                    colors.muted(`[paste: ${pasteCount} lines]`) + colors.text(suffix);
             }
             else {
-                inp = colors.primary('  › ') + chalk.white(displayPre);
+                inp = colors.primary('  › ') + colors.text(displayPre);
             }
             process.stdout.write('\r\x1b[K' + inp);
             process.stdout.write('\r\n' + SEP + '\x1b[1A\r' + inp);
@@ -2120,12 +2126,63 @@ export async function startRepl(cwd) {
     // Rules appended to every system prompt to enforce safe file-operation behavior
     const SAFE_FILE_RULES = `
 
-## CRITICAL RULES — Follow these on every response
+## CORE RULES
+
+### READ FIRST, THEN ANSWER
+When the user asks about their code:
+1. Find the relevant file(s)
+2. Read them silently
+3. Give a direct, accurate answer based on what you found
+Never guess or fabricate information.
+
+### BE ACCURATE
+- Only report what you actually see in the code
+- If you are unsure, say so — do not fabricate answers
+- Never add features or items that do not exist in the code
+
+### RESPOND IN THE SAME LANGUAGE
+- Respond in the same language the user writes in
+- If user writes in English → respond in English
+- If user writes in Russian → respond in Russian
+- And so on for any language
+
+### FORMAT ANSWERS CLEARLY
+- Use bullet points or numbered lists for multiple items
+- Put each item on its own line
+- Keep answers concise — 3-10 lines maximum
+- Do not dump entire file contents unless asked
+- Do not add unnecessary commentary
+
+### WORK SILENTLY
+- Do not say "I will read the file" — just read it and answer
+- Do not narrate your thought process
+- Do not say "I already answered your question"
+- Give your answer ONCE and STOP
+
+### WHEN CREATING/EDITING FILES
+- write_file = CREATE new files only
+- edit_file = MODIFY existing (read first, then find/replace)
+- Before editing: ALWAYS read_file first
+- Complete the ENTIRE task in ONE response
+- Use tags, NOT code blocks
+
+### WHEN CREATING/EDITING FILES
+- write_file = CREATE new files only
+- edit_file = MODIFY existing (read first, then find/replace)
+- Before editing: ALWAYS read_file first
+- Multiple edits: order from BOTTOM to TOP
+- Complete the ENTIRE task in ONE response
+- Use tags, NOT code blocks
+
+### When the user asks you to do something:
+1. Read the relevant files first
+2. Do the work using <write_file> / <edit_file> tags
+3. Summarize what you did in 1-2 sentences
 
 ### Act decisively
 - Use judgment and execute immediately when intent is clear.
 - Do NOT ask unnecessary clarifying questions — just do the task.
-- Make reasonable assumptions and proceed. State the assumption briefly if needed.
+- Make reasonable assumptions and proceed.
 
 ### Creating files
 - NEVER show code in code blocks when the user asks to create files or a project.
@@ -2139,9 +2196,39 @@ export async function startRepl(cwd) {
 - Before editing any file: use <read_file> to see its current content first.
 - NEVER overwrite an existing file with write_file — it destroys user code.
 
+### How to use edit_file correctly
+1. ALWAYS read_file first to see the current content
+2. Copy the EXACT text from the file into <find> — character by character
+3. The <find> text must match EXACTLY (including whitespace, indentation)
+4. If edit fails, the system will show you the actual content — use it to retry
+5. Do NOT put line numbers in <find> (e.g., "42 │ code" is WRONG)
+6. Do NOT modify the text in <find> — copy it EXACTLY from the file
+
+### Searching and navigating
+- Use <glob_files pattern="**/*.ts" /> to find files by extension
+- Use <search_code pattern="functionName" /> to find code
+- Use <search_code pattern="regex.*pattern" regex="true" /> for regex search
+- Use <search_code pattern="error" include="*.ts" /> to search specific file types
+- Use <search_code pattern="TODO" context="2" /> to show context around matches
+- Read files before editing them — always!
+
+### Multi-file tasks
+- Plan all files FIRST (list them in your response)
+- Create/edit files in LOGICAL ORDER (dependencies first)
+- Use write_file for ALL new files
+- Use edit_file for ALL modifications
+- Run commands LAST (after all files are created)
+
+### Error recovery
+- If an edit_file fails, read the file again and retry with the actual content
+- If a run_command fails, read the error message and fix the issue
+- Never give up — keep trying until the task is complete
+
 ### Scope
 - Only touch files the user explicitly mentioned or that are clearly required by the task.
-- Do NOT restructure, rename, or "improve" anything that wasn't asked.`;
+- Do NOT restructure, rename, or "improve" anything that wasn't asked.
+- When creating a new project, create ALL necessary files (not just some).
+- When fixing a bug, fix the ROOT CAUSE, not just the symptom.`;
     const buildSystemMsg = (dir) => ({
         role: 'system',
         content: SYSTEM_PROMPT + SAFE_FILE_RULES + '\n\nProject context:\n' + buildContext(dir),
@@ -2160,6 +2247,10 @@ export async function startRepl(cwd) {
     let pendingOutputTokens = 0;
     let pendingUserTokens = 0;
     let hasPendingReport = false;
+    // Auto-retry state
+    const MAX_AUTO_RETRIES = 3;
+    let autoRetryCount = 0;
+    let lastFailedOp = null;
     process.stdin.once('end', () => {
         console.log(colors.muted('\n  Goodbye!\n'));
         process.exit(0);
@@ -2312,6 +2403,8 @@ export async function startRepl(cwd) {
             if (!skipInput) {
                 readFileTurnCount = 0; // reset loop counter for each new user message
                 forcedEditMode = false; // reset forced edit mode for each new user message
+                autoRetryCount = 0; // reset auto-retry counter for each new user message
+                lastFailedOp = null;
                 // ── Refresh project context (files may have changed since last turn) ──
                 history[0] = buildSystemMsg(activeCwd);
                 // ── Clear stale operational messages left from previous auto-continue turns ──
@@ -2470,7 +2563,7 @@ export async function startRepl(cwd) {
                             }
                             catch { /* ignore */ }
                         }
-                        const previewLines = (op.type === 'write' || op.type === 'edit') ? printDiffPreview(op, activeCwd) : 0;
+                        const previewLines = (!alwaysAllowed.has(key) && (op.type === 'write' || op.type === 'edit')) ? printDiffPreview(op, activeCwd) : 0;
                         const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run', previewLines > 0, previewLines);
                         executedInlineOps.add(inlineOpFingerprint(op));
                         if (!allowed) {
@@ -2506,8 +2599,7 @@ export async function startRepl(cwd) {
                                             const cur = fs.readFileSync(fp, 'utf-8');
                                             const curLines = cur.split('\n');
                                             const nLines = curLines.length;
-                                            const isDeleteOp = !op.replace || op.replace.trim() === '';
-                                            // Auto-search for what AI was trying to find — inject exact block
+                                            // Smart error recovery: find approximate location and provide fix instructions
                                             const findLines = (op.find ?? '').split('\n').map(l => l.replace(/^\s*\d+\s*[│|:]\s?/, '').trim()).filter(Boolean);
                                             const searchTerm = findLines[0]?.slice(0, 60) ?? '';
                                             let foundAt = -1;
@@ -2520,27 +2612,51 @@ export async function startRepl(cwd) {
                                                 }
                                             }
                                             if (foundAt >= 0) {
-                                                // Found the approximate location — inject surrounding block
-                                                const start = Math.max(0, foundAt - 2);
-                                                const end = Math.min(curLines.length - 1, foundAt + 100);
+                                                // Found approximate location — show surrounding context
+                                                const start = Math.max(0, foundAt - 3);
+                                                const end = Math.min(curLines.length - 1, foundAt + 50);
                                                 const block = curLines.slice(start, end + 1).join('\n');
-                                                errMsg += `\n\n[FOUND near line ${foundAt + 1} in ${op.path}]:\n${block}\n`;
-                                                errMsg += isDeleteOp
-                                                    ? `\nDELETE FIX: Copy the EXACT full container (from its opening <div>/<section> tag through the matching closing tag) from above. Put it in <edit_file path="${op.path}"><find>EXACT_TEXT</find><replace></replace>. Text must match CHARACTER FOR CHARACTER.`
-                                                    : `\nEDIT FIX: Copy the EXACT text you want to change from above. Use <edit_file path="${op.path}"><find>EXACT_TEXT</find><replace>NEW_TEXT</replace>.`;
+                                                errMsg += `\n\n[FILE CONTENT — ${op.path} lines ${start + 1}-${end + 1}]:\n${block}`;
+                                                errMsg += `\n\nFIX: The edit failed. Copy the EXACT text from the file above into <find>. Do NOT include line numbers.`;
                                             }
                                             else if (nLines <= 400) {
-                                                errMsg += `\n\nFull content of ${op.path} (${nLines} lines):\n${cur}\n\nFIX: Copy the EXACT text from above into <find>. Character-for-character, no changes.`;
+                                                // File is small — show full content
+                                                errMsg += `\n\n[FILE CONTENT — ${op.path} (${nLines} lines)]:\n${cur}`;
+                                                errMsg += `\n\nFIX: Copy the EXACT text from the file above into <find>.`;
                                             }
                                             else {
-                                                const safe = searchTerm.replace(/['"<>{}()\[\]]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 35);
-                                                errMsg += `\n\nFIX STEPS:\n1. <search_code pattern="${safe}" path="${op.path}"/>\n2. <read_file path="${op.path}" lines="N-M"/> (use line numbers from search)\n3. Copy EXACT text into <find> — no modifications, no line numbers`;
+                                                // File is large — show first 100 lines and instruct to search
+                                                const preview = curLines.slice(0, 100).join('\n');
+                                                errMsg += `\n\n[FILE CONTENT — ${op.path} (first 100 of ${nLines} lines)]:\n${preview}`;
+                                                errMsg += `\n\nFIX: Use <read_file path="${op.path}" lines="N-M"/> to read the correct section, then copy EXACT text into <find>.`;
                                             }
+                                            // Auto-retry: inject file content and force continuation
+                                            history.push({
+                                                role: 'system',
+                                                content: `[AUTO-RETRY] The edit failed. Here is the current file content:\n\n${nLines <= 200 ? cur : curLines.slice(0, 200).join('\n')}\n\nRetry the edit using the EXACT content above. Copy text CHARACTER FOR CHARACTER into <find>.`,
+                                            });
+                                            readFileContinue = true;
                                         }
                                     }
                                     catch { /* ignore */ }
                                 }
                                 inlineFileOpErrors.push(errMsg);
+                                // Auto-retry logic: if edit_file fails, automatically retry with updated context
+                                if (op.type === 'edit' && autoRetryCount < MAX_AUTO_RETRIES) {
+                                    autoRetryCount++;
+                                    lastFailedOp = op.path ?? null;
+                                }
+                                else if (autoRetryCount >= MAX_AUTO_RETRIES) {
+                                    // Reset retry counter after max retries — prevent infinite loop
+                                    autoRetryCount = 0;
+                                    lastFailedOp = null;
+                                    // Tell AI to stop retrying this specific edit
+                                    history.push({
+                                        role: 'system',
+                                        content: `[STOP] Edit failed ${MAX_AUTO_RETRIES} times. Do NOT retry this specific edit. Move on to other tasks or ask the user for help.`,
+                                    });
+                                    readFileContinue = true;
+                                }
                             }
                             else if ((opResult.type === 'modified' || opResult.type === 'created') && op.path &&
                                 (op.type === 'edit' || op.type === 'write')) {
@@ -2737,9 +2853,11 @@ export async function startRepl(cwd) {
                         return;
                     }
                     const normalized = normalizeResponse(fullResponse);
-                    lastAIResponse = normalized;
-                    if (normalized.trim()) {
-                        history.push({ role: 'assistant', content: normalized });
+                    // Clean up the response — remove trailing newlines
+                    const stripped = normalized.replace(/\n+$/, '').trim();
+                    lastAIResponse = stripped;
+                    if (stripped.trim()) {
+                        history.push({ role: 'assistant', content: stripped });
                     }
                     if (conversationTitle === null) {
                         const _msgs = history.slice(1).filter(m => m.role === 'user' || m.role === 'assistant');
@@ -2777,16 +2895,38 @@ export async function startRepl(cwd) {
                         history.push({ role: 'system', content: inlineFileOpErrors.join('\n\n') + '\n\nFix the above errors and retry the failed operations.' });
                         readFileContinue = true;
                     }
-                    const allOps = parseOps(normalized);
+                    const allOps = parseOps(fullResponse);
                     // ── Detect incomplete plan: AI described steps but didn't output tags ──
                     if (!readFileContinue && !streamCancelled) {
                         const hasAnyReadOp = allOps.some(op => op.type === 'read_file' || op.type === 'read_folder' || op.type === 'search_code');
+                        const hasAnyWriteOp = allOps.some(op => op.type === 'write' || op.type === 'edit' || op.type === 'delete' || op.type === 'mkdir' || op.type === 'run');
                         const writeOps = allOps.filter(op => op.type !== 'read_file' && op.type !== 'read_folder' && op.type !== 'search_code').length;
-                        const plannedSteps = (normalized.match(/^\s*[2-9]\.\s+\S/mg) ?? []).length;
-                        const hasCodeFence = normalized.includes('```');
-                        const hasStepList = (normalized.match(/^\s*\d+[.)]\s+\S/mg) ?? []).length >= 2;
+                        const plannedSteps = (stripped.match(/^\s*[2-9]\.\s+\S/mg) ?? []).length;
+                        const hasCodeFence = stripped.includes('```');
+                        const hasStepList = (stripped.match(/^\s*\d+[.)]\s+\S/mg) ?? []).length >= 2;
+                        // Case 0: AI only output read/search ops with NO substantial text answer — force continuation
+                        // BUT: if AI wrote a substantial answer along with read ops, it already answered
+                        const textLength = stripped.replace(/<[^>]+>/g, '').trim().length;
+                        // Also check if the answer contains useful content (bullet points, lists, specific info)
+                        const hasUsefulContent = /[•\-\*]\s|^\d+\.\s|\b\d+\s+(забон|function|file|language|item)/m.test(stripped);
+                        // Check for loop: if same answer was given before, STOP
+                        const isDuplicate = lastAIResponse && stripped === lastAIResponse;
+                        // Check if answer contains specific info (numbers, names, etc.)
+                        const hasSpecificInfo = /\d+\s+(забон|function|file|language|item|line|row)|`\w+`/i.test(stripped);
+                        // Check if AI already gave a complete answer (more than 3 lines or contains list items)
+                        const hasCompleteAnswer = stripped.split('\n').length > 3 || /\n\s*[-•*]\s/.test(stripped) || /\n\s*\d+\.\s/.test(stripped);
+                        // Check if this is a repeat of recent answers (compare first 50 chars)
+                        const recentAnswerPrefix = lastAIResponse.slice(0, 50);
+                        const currentPrefix = stripped.slice(0, 50);
+                        const isSimilarToRecent = recentAnswerPrefix.length > 10 && currentPrefix === recentAnswerPrefix;
+                        if (hasAnyReadOp && !hasAnyWriteOp && readFileTurnCount < 3 && textLength < 20 && !hasUsefulContent && !isDuplicate && !hasSpecificInfo && !hasCompleteAnswer && !isSimilarToRecent) {
+                            // AI read files but didn't produce any answer — force it to answer
+                            const readPrompt = `[FILE CONTENTS LOADED] The files have been read and their contents are now in your context above.\n\nThe user's question was: "${lastUserLine.slice(0, 300)}"\n\nANSWER THE QUESTION NOW based on what you read. Do NOT say "let me read" — you already read the files. Give a DIRECT, SPECIFIC answer. Do NOT repeat yourself.`;
+                            history.push({ role: 'system', content: readPrompt });
+                            readFileContinue = true;
+                        }
                         // Case 1: AI listed numbered steps (2+) but produced zero file ops
-                        if (plannedSteps >= 1 && writeOps === 0 && !hasAnyReadOp) {
+                        else if (plannedSteps >= 1 && writeOps === 0 && !hasAnyReadOp) {
                             history.push({ role: 'system', content: 'CRITICAL ERROR: You described steps but produced NO file operation tags. You MUST output <write_file> or <edit_file> tags to create/modify actual files. Do NOT show code in ``` blocks — use <write_file path="filename"> tags instead. Output all the tags NOW. No explanation.' });
                             readFileContinue = true;
                             // Case 2: AI showed code blocks + numbered list but no tags — regardless of language
@@ -2849,11 +2989,11 @@ export async function startRepl(cwd) {
                                     return;
                                 }
                                 const cols = process.stdout.columns ?? 80;
-                                const boxW = Math.min(Math.max(cols - 2, 52), 100);
-                                const BC = chalk.hex('#4338ca');
-                                const FC = chalk.hex('#e2e8f0');
-                                const RIGHT_W = 22;
-                                const LABEL_W = Math.max(boxW - 11 - RIGHT_W, 8);
+                                const boxW = Math.min(Math.max(cols - 4, 50), 80);
+                                const BC = colors.dim;
+                                const FC = colors.text;
+                                const RIGHT_W = 10;
+                                const LABEL_W = Math.max(boxW - 11 - RIGHT_W, 10);
                                 const results = [];
                                 for (const op of validOps) {
                                     let spinLabel = '';
@@ -2890,7 +3030,6 @@ export async function startRepl(cwd) {
                                             const lastLine = (res.output ?? '').split('\n').filter(Boolean).pop() ?? '';
                                             rightCol = chalk.hex('#6b7280')(lastLine.startsWith('Total:') ? lastLine.slice(7).trim() : `${ms}ms`);
                                             displayLabel = `"${op.pattern}"`;
-                                            // Auto-read section around first match so AI has exact text without another round-trip
                                             const firstMatchLine = (res.output ?? '').match(/^([^\n:]+):(\d+):/m);
                                             if (firstMatchLine) {
                                                 const matchFile = firstMatchLine[1].trim();
@@ -2919,7 +3058,6 @@ export async function startRepl(cwd) {
                                             ctxLabel = `[File content — ${res.message ?? op.path}]${lineTag}:\n${res.output ?? ''}`;
                                             rightCol = chalk.hex('#6b7280')(op.lines ? `lines ${op.lines}` : `${ms}ms`);
                                             displayLabel = op.lines ? `${op.path ?? ''} :${op.lines}` : (op.path ?? '');
-                                            // Auto-continue paginated reads: if file has more pages, queue next page automatically
                                             const pageMatch = (res.output ?? '').match(/\.\.\. \((\d+) more lines — next page: lines (\d+)-(\d+)\)/);
                                             if (pageMatch && op.path) {
                                                 const [, , nextStart, nextEnd] = pageMatch;
@@ -2927,7 +3065,6 @@ export async function startRepl(cwd) {
                                                     role: 'system',
                                                     content: `[Auto-reading next page of ${op.path}...]`,
                                                 });
-                                                // Queue the next page read by injecting it as a system op
                                                 validOps.push({ type: 'read_file', path: op.path, lines: `${nextStart}-${nextEnd}` });
                                             }
                                         }
@@ -3006,7 +3143,7 @@ export async function startRepl(cwd) {
                                             continue;
                                         }
                                     }
-                                    const previewLines2 = (op.type === 'write' || op.type === 'edit') ? printDiffPreview(op, activeCwd) : 0;
+                                    const previewLines2 = (!alwaysAllowed.has(key) && (op.type === 'write' || op.type === 'edit')) ? printDiffPreview(op, activeCwd) : 0;
                                     const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run', previewLines2 > 0, previewLines2);
                                     if (!allowed) {
                                         if (op.path)
@@ -3024,7 +3161,7 @@ export async function startRepl(cwd) {
                                             stageSpinFrame = 0;
                                             stageSpinInterval = setInterval(() => {
                                                 const f = SPINNER_FRAMES[stageSpinFrame++ % SPINNER_FRAMES.length];
-                                                process.stdout.write(`\r\x1b[K  ${colors.muted(f)}  ${chalk.hex('#94a3b8')(stageSpinMsg)}`);
+                                                process.stdout.write(`\r\x1b[K  ${colors.muted(f)}  ${colors.subtext(stageSpinMsg)}`);
                                             }, 80);
                                         }
                                     });
@@ -3093,6 +3230,19 @@ export async function startRepl(cwd) {
                                         ? `[Command failed — ${r.cmd}]:\n${r.output}`
                                         : `[Command output — ${r.cmd}]:\n${r.output}`).join('\n\n');
                                     history.push({ role: 'system', content });
+                                    // Auto-retry for failed commands
+                                    const failedCmds = runOutputs.filter(r => r.isError);
+                                    if (failedCmds.length > 0 && autoRetryCount < MAX_AUTO_RETRIES) {
+                                        autoRetryCount++;
+                                        const retryHint = `[Auto-retry ${autoRetryCount}/${MAX_AUTO_RETRIES}] ` +
+                                            `Previous command(s) failed. Analyze the error and try again with a fix. ` +
+                                            `Common fixes: check file paths, install missing dependencies, verify syntax.`;
+                                        history.push({ role: 'system', content: retryHint });
+                                        readFileContinue = true;
+                                    }
+                                    else if (autoRetryCount >= MAX_AUTO_RETRIES) {
+                                        autoRetryCount = 0;
+                                    }
                                     // Only auto-continue if there is real output to react to, or an error to explain
                                     const needsReaction = runOutputs.some(r => r.isError || r.output !== NO_OUTPUT_MARKER);
                                     if (needsReaction)