@taj-special/dravix-code 1.1.28 → 1.2.0

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';
@@ -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
@@ -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)

package/dist/services/ai.js

@@ -2,6 +2,36 @@ const AI_PROXY = 'https://dravix.app/ai-proxy.php';
 const PROMPT_URL = 'https://dravix.app/cli-prompt.php';
 export const FLASH_MODEL = 'deepseek/deepseek-v4-flash'; // fast, cheap — default for all tasks
 export const PRO_MODEL = 'deepseek/deepseek-r1'; // high-reasoning — used after errors/retries
+export const CLAUDE_MODEL = 'anthropic/claude-sonnet-4'; // high-quality — for complex tasks
+// Model routing: decide which model to use based on task complexity
+export function selectModel(userMessage, retryCount = 0) {
+    // Always use PRO_MODEL for retries (better at fixing errors)
+    if (retryCount > 0)
+        return PRO_MODEL;
+    const msg = userMessage.toLowerCase();
+    // Complex task indicators
+    const COMPLEX_INDICATORS = [
+        'refactor', 'architecture', 'complex', 'redesign', 'migrate',
+        'debug', 'fix error', 'error handling', 'optimization', 'performance',
+        'security', 'authentication', 'database', 'deploy', 'infrastructure',
+        'test', 'testing', 'integration', 'api', 'microservice',
+        'typescript', 'type safety', 'interface', 'generic',
+    ];
+    // Long messages are usually more complex
+    if (userMessage.length > 500)
+        return PRO_MODEL;
+    // Check for complex indicators
+    for (const indicator of COMPLEX_INDICATORS) {
+        if (msg.includes(indicator))
+            return PRO_MODEL;
+    }
+    // Multi-file tasks (mentions multiple files)
+    const fileMentions = (userMessage.match(/\.\w{2,5}/g) ?? []).length;
+    if (fileMentions > 5)
+        return PRO_MODEL;
+    // Default: use flash for speed
+    return FLASH_MODEL;
+}
 export async function fetchSystemPrompt(token) {
     try {
         const res = await fetch(`${PROMPT_URL}?token=${encodeURIComponent(token)}`, {
@@ -24,20 +54,68 @@ const TIMEOUT_MS = 300_000; // 5 min — AI may generate large responses
 const CHUNK_TIMEOUT_MS = 60_000; // 1 min without any chunk = abort
 const MAX_CONTINUATIONS = 5; // auto-continue up to 5 times on length cutoff
 const MAX_429_RETRIES = 3; // retry on rate-limit with exponential backoff
-// Convert history to OpenAI-compatible format:
-// Only the first message can be role:system — everything else must alternate user/assistant.
-// Mid-conversation system messages (file contents, /add files) become role:user.
-// Consecutive user/system-as-user messages are merged to maintain proper alternation.
+// Smart context management: priority-based trimming with summarization
 function prepareMessages(messages) {
-    // Trim context: if total chars exceed ~180k (~45k tokens), drop oldest non-system messages
-    const MAX_CHARS = 150_000;
+    const MAX_CHARS = 150_000; // ~45k tokens
+    const MIN_KEEP = 6; // Always keep at least last 6 messages (3 user + 3 assistant)
     let totalChars = messages.reduce((s, m) => s + String(m.content).length, 0);
-    const trimmed = [...messages];
-    while (totalChars > MAX_CHARS && trimmed.length > 4) {
-        const removed = trimmed.splice(1, 1)[0];
-        totalChars -= String(removed.content).length;
+    // If under limit, just convert and return
+    if (totalChars <= MAX_CHARS) {
+        return convertAndMerge(messages);
+    }
+    // Smart trimming strategy:
+    // 1. Keep system prompt (index 0)
+    // 2. Keep last MIN_KEEP messages
+    // 3. Summarize middle messages
+    // 4. Drop oldest middle messages if still over limit
+    const systemMsg = messages[0];
+    const recentMessages = messages.slice(-MIN_KEEP);
+    const middleMessages = messages.slice(1, messages.length - MIN_KEEP);
+    // Calculate chars for system + recent
+    const systemChars = String(systemMsg.content).length;
+    const recentChars = recentMessages.reduce((s, m) => s + String(m.content).length, 0);
+    const availableForMiddle = MAX_CHARS - systemChars - recentChars;
+    if (availableForMiddle <= 0 || middleMessages.length === 0) {
+        // No room for middle messages — just use system + recent
+        return convertAndMerge([systemMsg, ...recentMessages]);
     }
-    const converted = trimmed.map((msg, i) => {
+    // Summarize middle messages into a compact summary
+    const summary = summarizeMessages(middleMessages, availableForMiddle);
+    const summarizedMessages = [
+        systemMsg,
+        { role: 'system', content: `[Previous conversation summary]\n${summary}` },
+        ...recentMessages,
+    ];
+    return convertAndMerge(summarizedMessages);
+}
+// Summarize messages into a compact format
+function summarizeMessages(messages, maxChars) {
+    const parts = [];
+    let totalChars = 0;
+    for (const msg of messages) {
+        const content = String(msg.content);
+        const role = msg.role === 'user' ? 'User' : 'AI';
+        // For short messages, include them fully
+        if (content.length < 200) {
+            const line = `${role}: ${content.slice(0, 200)}`;
+            if (totalChars + line.length < maxChars) {
+                parts.push(line);
+                totalChars += line.length;
+            }
+            continue;
+        }
+        // For long messages, include first 100 chars + "... [truncated]"
+        const truncated = `${role}: ${content.slice(0, 100)}... [${content.length} chars total]`;
+        if (totalChars + truncated.length < maxChars) {
+            parts.push(truncated);
+            totalChars += truncated.length;
+        }
+    }
+    return parts.join('\n') || '[No previous context available]';
+}
+// Convert messages to OpenAI format and merge consecutive user messages
+function convertAndMerge(messages) {
+    const converted = messages.map((msg, i) => {
         if (msg.role === 'system' && i > 0)
             return { role: 'user', content: msg.content };
         return msg;