@taj-special/dravix-code 1.4.7 → 1.4.8

package/dist/cli/repl.js

@@ -749,16 +749,6 @@ async function askPermission(label, key, alwaysAllowed, noAlways, diffShown, pre
     if (!noAlways && alwaysAllowed.has(key))
         return true;
     return new Promise((resolve) => {
-        // Auto-resolve after 5 min — prevent hanging process
-        const timeout = setTimeout(() => {
-            cleanup();
-            clearMenu(menuLines);
-            for (let i = 0; i < previewLineCount - 1; i++) {
-                process.stdout.write('\x1b[1A\x1b[2K');
-            }
-            process.stdout.write(`  ${colors.muted('○')}  ${colors.muted('Timeout — skipped: ' + label)}\n`);
-            resolve(false);
-        }, 300_000);
         let sel = 0;
         let drawn = false;
         const ci = label.indexOf(': ');
@@ -812,11 +802,9 @@ async function askPermission(label, key, alwaysAllowed, noAlways, diffShown, pre
         }
         printMenu();
         function cleanup() {
-            clearTimeout(timeout);
             process.stdin.removeListener('data', onData);
         }
         function confirm(idx) {
-            clearTimeout(timeout);
             cleanup();
             clearMenu(menuLines);
             // Clear the diff preview lines (all except the first blank separator)
@@ -877,12 +865,10 @@ async function askPermission(label, key, alwaysAllowed, noAlways, diffShown, pre
     });
 }
 async function readLine(prompt, cwd) {
-    const sepRow = (process.stdout.rows ?? 24) - 2;
-    const inpRow = (process.stdout.rows ?? 24) - 1;
     let SEP = colors.dim('  ' + '─'.repeat(Math.max((process.stdout.columns ?? 80) - 4, 40)));
-    // Draw fixed bottom separator + input
-    process.stdout.write(`\x1b[${sepRow};1H\x1b[2K${SEP}`);
-    process.stdout.write(`\x1b[${inpRow};1H\x1b[2K${prompt}`);
+    let sepVisualLen = 2 + Math.max((process.stdout.columns ?? 80) - 4, 40);
+    process.stdout.write('\n' + SEP + '\n' + prompt);
+    process.stdout.write('\r\n' + SEP + '\x1b[1A\r' + prompt);
     return new Promise((resolve) => {
         let prefix = '';
         let pasteBlock = null;
@@ -910,35 +896,15 @@ async function readLine(prompt, cwd) {
             const newCols = process.stdout.columns ?? 80;
             SEP = colors.dim('  ' + '─'.repeat(Math.max(newCols - 4, 40)));
             if (atMode) {
-                for (let i = 0; i < atBoxLines + 3; i++)
-                    process.stdout.write('\x1b[1A');
-                process.stdout.write('\r\x1b[0J');
-                atDrawn = false;
-                atBoxLines = 0;
                 drawPicker();
             }
             else if (slashMode) {
-                for (let i = 0; i < slashBoxLines + 3; i++)
-                    process.stdout.write('\x1b[1A');
-                process.stdout.write('\r\x1b[0J');
-                slashDrawn = false;
-                slashBoxLines = 0;
                 drawSlashPicker();
             }
             else if (tabMode) {
-                for (let i = 0; i < tabBoxLines + 3; i++)
-                    process.stdout.write('\x1b[1A');
-                process.stdout.write('\r\x1b[0J');
-                tabDrawn = false;
-                tabBoxLines = 0;
                 drawTabPicker();
             }
             else {
-                // No mode active — just redraw the fixed bottom separator + input
-                const sepR = (process.stdout.rows ?? 24) - 2;
-                const inpR = (process.stdout.rows ?? 24) - 1;
-                process.stdout.write(`\x1b[${sepR};1H\x1b[2K${SEP}`);
-                process.stdout.write(`\x1b[${inpR};1H`);
                 redraw();
             }
         }
@@ -1003,233 +969,284 @@ async function readLine(prompt, cwd) {
             const lq = q.toLowerCase();
             return SLASH_COMMANDS.filter(c => c.name.slice(1).toLowerCase().startsWith(lq));
         }
-        // Picker layout:  input (A) | bot-sep (A+1) | box (A+2 .. A+1+atBoxLines)
-        // Clearing box:   atBoxLines × \x1b[1A\x1b[2K → cursor at A+2
-        //                 then \x1b[2A\x1b[2K to skip bot-sep and clear input
         let atDrawn = false;
         function drawPicker() {
-            if (atDrawn) {
-                for (let i = 0; i < atBoxLines; i++)
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                process.stdout.write('\x1b[2A\x1b[2K');
-            }
-            else {
-                process.stdout.write('\r\x1b[K');
-                atDrawn = true;
-            }
-            atBoxLines = 0;
-            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;
+            const cols = process.stdout.columns ?? 80;
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            const iR = rows - 1;
             const filtered = filterFiles(atQuery);
             if (atSel >= filtered.length && filtered.length > 0)
                 atSel = filtered.length - 1;
-            const shown = filtered.slice(0, 10);
+            if (atSel < 0)
+                atSel = 0;
+            const maxVisible = Math.min(8, Math.max(3, rows - 6));
+            const shown = filtered.slice(0, maxVisible);
+            const DW = Math.min(Math.max(cols - 6, 44), 74);
+            const IW = DW - 6;
+            const boxLines = [];
             const qLabel = atQuery ? `@${atQuery}` : 'files';
-            const hDashes = Math.max(DW - 5 - qLabel.length, 1);
-            process.stdout.write(colors.dim('  ╭─ ') + colors.primary(qLabel) + colors.dim(' ' + '─'.repeat(hDashes) + '╮') + '\n');
-            atBoxLines++;
+            const hDashes = Math.max(DW - 4 - qLabel.length, 1);
+            boxLines.push(colors.dim('  ╭─ ') + colors.primary(qLabel) + colors.dim(' ' + '─'.repeat(hDashes) + '╮'));
             if (shown.length === 0) {
                 const msg = 'no matches';
                 const pad = ' '.repeat(Math.max(IW - msg.length, 0));
-                process.stdout.write(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│') + '\n');
-                atBoxLines++;
+                boxLines.push(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│'));
             }
             else {
                 for (let i = 0; i < shown.length; i++) {
                     const f = shown[i];
                     const isDir = f.endsWith('/');
                     const sel = i === atSel;
-                    const mark = sel ? colors.primary('>') : ' ';
+                    const mark = sel ? colors.primary('›') : ' ';
                     const clip = f.length > IW ? f.slice(0, IW - 1) + '…' : f;
                     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('#74b9ff')(clip) + pad
                                 : colors.subtext(clip + pad);
-                    process.stdout.write(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│') + '\n');
-                    atBoxLines++;
+                    boxLines.push(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│'));
                 }
             }
-            const hint = ' ↑↓  Enter  Esc ';
+            const hint = ' ↑↓ Navigate  Enter Select  Esc Close ';
             const fInner = DW - 2 - hint.length;
-            const fLeft = Math.floor(fInner / 2);
-            const fRight = fInner - fLeft;
-            process.stdout.write(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) + colors.muted(hint) + colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯') + '\n');
-            atBoxLines++;
+            const fLeft = Math.max(0, Math.floor(fInner / 2));
+            const fRight = Math.max(0, fInner - fLeft);
+            boxLines.push(colors.dim('  ╰' + '─'.repeat(fLeft)) + colors.muted(hint) + colors.dim('─'.repeat(fRight) + '╯'));
+            const newLinesCount = boxLines.length;
+            // Clear any leftover lines from previous taller popup
+            if (atBoxLines > newLinesCount) {
+                for (let r = sR - atBoxLines; r < sR - newLinesCount; r++) {
+                    if (r >= 1)
+                        process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+                }
+            }
+            // Render popup above separator
+            for (let i = 0; i < newLinesCount; i++) {
+                const targetRow = sR - newLinesCount + i;
+                if (targetRow >= 1) {
+                    process.stdout.write(`\x1b[${targetRow};1H\x1b[2K${boxLines[i]}`);
+                }
+            }
+            // Re-draw separator and input
+            process.stdout.write(`\x1b[${sR};1H\x1b[2K${SEP}`);
+            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(`\x1b[${iR};1H\x1b[2K${inputLine}`);
+            const cursorCol = 5 + prefix.length + (pasteBlock !== null ? `[paste: ${pasteCount} lines]`.length + suffix.length : 0) + 1 + atQuery.length;
+            process.stdout.write(`\x1b[${iR};${cursorCol}H`);
+            atBoxLines = newLinesCount;
+            atDrawn = true;
         }
         function closePicker() {
-            if (atDrawn) {
-                for (let i = 0; i < atBoxLines; i++)
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                process.stdout.write('\x1b[2A\x1b[2K');
-                atDrawn = false;
-            }
-            else {
-                process.stdout.write('\r\x1b[K');
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            if (atDrawn && atBoxLines > 0) {
+                for (let r = sR - atBoxLines; r < sR; r++) {
+                    if (r >= 1)
+                        process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+                }
             }
             atBoxLines = 0;
             atMode = false;
             atQuery = '';
             atSel = 0;
+            atDrawn = false;
         }
         function drawSlashPicker() {
-            if (slashDrawn) {
-                for (let i = 0; i < slashBoxLines; i++)
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                process.stdout.write('\x1b[2A\x1b[2K');
-            }
-            else {
-                process.stdout.write('\r\x1b[K');
-                slashDrawn = true;
-            }
-            slashBoxLines = 0;
-            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;
-            const descW = DW - nameW - 8;
+            const cols = process.stdout.columns ?? 80;
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            const iR = rows - 1;
             const filtered = filterSlash(slashQuery);
             if (slashSel >= filtered.length && filtered.length > 0)
                 slashSel = filtered.length - 1;
+            if (slashSel < 0)
+                slashSel = 0;
+            const maxVisible = Math.min(8, Math.max(3, rows - 6));
+            const shown = filtered.slice(0, maxVisible);
+            const DW = Math.min(Math.max(cols - 6, 44), 74);
+            const nameW = 11;
+            const descW = Math.max(DW - nameW - 9, 10);
+            const boxLines = [];
             const qLabel = slashQuery ? `/${slashQuery}` : 'commands';
-            const hDashes = Math.max(DW - 5 - qLabel.length, 1);
-            process.stdout.write(colors.dim('  ╭─ ') + colors.primary(qLabel) + colors.dim(' ' + '─'.repeat(hDashes) + '╮') + '\n');
-            slashBoxLines++;
+            const hDashes = Math.max(DW - 4 - qLabel.length, 1);
+            boxLines.push(colors.dim('  ╭─ ') + colors.primary(qLabel) + colors.dim(' ' + '─'.repeat(hDashes) + '╮'));
             if (filtered.length === 0) {
                 const msg = 'no matching commands';
-                const pad = ' '.repeat(Math.max(DW - 4 - msg.length, 0));
-                process.stdout.write(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│') + '\n');
-                slashBoxLines++;
+                const pad = ' '.repeat(Math.max(DW - 4 - msg.length - 2, 0));
+                boxLines.push(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│'));
             }
             else {
-                for (let i = 0; i < filtered.length; i++) {
-                    const cmd = filtered[i];
+                for (let i = 0; i < shown.length; i++) {
+                    const cmd = shown[i];
                     const sel = i === slashSel;
-                    const mark = sel ? colors.primary('>') : ' ';
+                    const mark = sel ? colors.primary('›') : ' ';
                     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) : 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++;
+                    const descPaint = sel ? chalk.hex('#f1f5f9')(descStr) : colors.subtext(descStr);
+                    boxLines.push(colors.dim('  │') + `  ${mark} ` + namePaint + '  ' + descPaint + descPad + colors.dim('│'));
                 }
             }
-            const hint = ' ↑↓  Enter  Esc ';
+            const hint = ' ↑↓ Navigate  Tab Complete  ↵ Run  Esc Close ';
             const fInner = DW - 2 - hint.length;
-            const fLeft = Math.floor(fInner / 2);
-            const fRight = fInner - fLeft;
-            process.stdout.write(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) + colors.muted(hint) + colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯') + '\n');
-            slashBoxLines++;
+            const fLeft = Math.max(0, Math.floor(fInner / 2));
+            const fRight = Math.max(0, fInner - fLeft);
+            boxLines.push(colors.dim('  ╰' + '─'.repeat(fLeft)) + colors.muted(hint) + colors.dim('─'.repeat(fRight) + '╯'));
+            const newLinesCount = boxLines.length;
+            // Clear any leftover lines from previous taller popup
+            if (slashBoxLines > newLinesCount) {
+                for (let r = sR - slashBoxLines; r < sR - newLinesCount; r++) {
+                    if (r >= 1)
+                        process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+                }
+            }
+            // Render popup above separator
+            for (let i = 0; i < newLinesCount; i++) {
+                const targetRow = sR - newLinesCount + i;
+                if (targetRow >= 1) {
+                    process.stdout.write(`\x1b[${targetRow};1H\x1b[2K${boxLines[i]}`);
+                }
+            }
+            // Re-draw separator and input line
+            process.stdout.write(`\x1b[${sR};1H\x1b[2K${SEP}`);
+            const inputLine = colors.primary('  › ') + colors.primary('/') + colors.text(slashQuery);
+            process.stdout.write(`\x1b[${iR};1H\x1b[2K${inputLine}`);
+            process.stdout.write(`\x1b[${iR};${5 + 1 + slashQuery.length}H`);
+            slashBoxLines = newLinesCount;
+            slashDrawn = true;
         }
         function closeSlashPicker() {
-            if (slashDrawn) {
-                for (let i = 0; i < slashBoxLines; i++)
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                process.stdout.write('\x1b[2A\x1b[2K');
-                slashDrawn = false;
-            }
-            else {
-                process.stdout.write('\r\x1b[K');
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            if (slashDrawn && slashBoxLines > 0) {
+                for (let r = sR - slashBoxLines; r < sR; r++) {
+                    if (r >= 1)
+                        process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+                }
             }
             slashBoxLines = 0;
             slashMode = false;
             slashQuery = '';
             slashSel = 0;
+            slashDrawn = false;
         }
         function drawTabPicker() {
-            if (tabDrawn) {
-                for (let i = 0; i < tabBoxLines; i++)
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                process.stdout.write('\x1b[2A\x1b[2K');
-            }
-            else {
-                process.stdout.write('\r\x1b[K');
-                tabDrawn = true;
-            }
-            tabBoxLines = 0;
+            const cols = process.stdout.columns ?? 80;
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            const iR = rows - 1;
             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 DW = Math.min(Math.max(cols - 6, 44), 74);
             const IW = DW - 6;
             const filtered = filterFiles(tabQuery);
             if (tabSel >= filtered.length && filtered.length > 0)
                 tabSel = filtered.length - 1;
-            const shown = filtered.slice(0, 10);
+            if (tabSel < 0)
+                tabSel = 0;
+            const maxVisible = Math.min(8, Math.max(3, rows - 6));
+            const shown = filtered.slice(0, maxVisible);
+            const boxLines = [];
             const qLabel = tabQuery || 'tab complete';
-            const hDashes = Math.max(DW - 5 - qLabel.length, 1);
-            process.stdout.write(colors.dim('  ╭─ ') + TC(qLabel) + colors.dim(' ' + '─'.repeat(hDashes) + '╮') + '\n');
-            tabBoxLines++;
+            const hDashes = Math.max(DW - 4 - qLabel.length, 1);
+            boxLines.push(colors.dim('  ╭─ ') + TC(qLabel) + colors.dim(' ' + '─'.repeat(hDashes) + '╮'));
             if (shown.length === 0) {
                 const msg = 'no matches';
                 const pad = ' '.repeat(Math.max(IW - msg.length, 0));
-                process.stdout.write(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│') + '\n');
-                tabBoxLines++;
+                boxLines.push(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│'));
             }
             else {
                 for (let i = 0; i < shown.length; i++) {
                     const f = shown[i];
                     const isDir = f.endsWith('/');
                     const sel = i === tabSel;
-                    const mark = sel ? TC('>') : ' ';
+                    const mark = sel ? TC('›') : ' ';
                     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('#74b9ff')(clip) + pad
                             : colors.subtext(clip + pad);
-                    process.stdout.write(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│') + '\n');
-                    tabBoxLines++;
+                    boxLines.push(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│'));
                 }
             }
-            const hint = ' Tab/↑↓  Enter  Esc ';
+            const hint = ' Tab/↑↓ Navigate  Enter Select  Esc Close ';
             const fInner = DW - 2 - hint.length;
             const fLeft = Math.floor(fInner / 2);
             const fRight = fInner - fLeft;
-            process.stdout.write(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) + colors.muted(hint) + colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯') + '\n');
-            tabBoxLines++;
+            boxLines.push(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) + colors.muted(hint) + colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯'));
+            const newLinesCount = boxLines.length;
+            // Clear any leftover lines from previous taller popup
+            if (tabBoxLines > newLinesCount) {
+                for (let r = sR - tabBoxLines; r < sR - newLinesCount; r++) {
+                    if (r >= 1)
+                        process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+                }
+            }
+            // Render popup above separator
+            for (let i = 0; i < newLinesCount; i++) {
+                const targetRow = sR - newLinesCount + i;
+                if (targetRow >= 1) {
+                    process.stdout.write(`\x1b[${targetRow};1H\x1b[2K${boxLines[i]}`);
+                }
+            }
+            // Re-draw separator and input line
+            process.stdout.write(`\x1b[${sR};1H\x1b[2K${SEP}`);
+            const inputLine = colors.primary('  › ') + colors.text(tabPreWord) + TC(tabQuery);
+            process.stdout.write(`\x1b[${iR};1H\x1b[2K${inputLine}`);
+            const cursorCol = 5 + tabPreWord.length + tabQuery.length;
+            process.stdout.write(`\x1b[${iR};${cursorCol}H`);
+            tabBoxLines = newLinesCount;
+            tabDrawn = true;
         }
         function closeTabPicker() {
-            if (tabDrawn) {
-                for (let i = 0; i < tabBoxLines; i++)
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                process.stdout.write('\x1b[2A\x1b[2K');
-                tabDrawn = false;
-            }
-            else {
-                process.stdout.write('\r\x1b[K');
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            if (tabDrawn && tabBoxLines > 0) {
+                for (let r = sR - tabBoxLines; r < sR; r++) {
+                    if (r >= 1)
+                        process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+                }
             }
             tabBoxLines = 0;
             tabMode = false;
             tabQuery = '';
             tabSel = 0;
             tabPreWord = '';
+            tabDrawn = false;
         }
         function redraw() {
             const cols = process.stdout.columns ?? 80;
-            const inpRow = (process.stdout.rows ?? 24) - 1;
-            const maxLen = Math.max(cols - 6, 10);
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            const iR = rows - 1;
+            const maxLen = Math.max(cols - 8, 10);
             let displayPre = prefix;
             if (displayPre.length > maxLen)
                 displayPre = '…' + displayPre.slice(-(maxLen - 1));
             let inp;
+            let cursorCol = 5 + displayPre.length;
             if (pasteBlock !== null) {
+                const pTag = `[paste: ${pasteCount} lines]`;
                 inp = colors.primary('  › ') + colors.text(displayPre) +
-                    colors.muted(`[paste: ${pasteCount} lines]`) + colors.text(suffix);
+                    colors.muted(pTag) + colors.text(suffix);
+                cursorCol = 5 + displayPre.length + pTag.length + suffix.length;
             }
             else {
-                inp = colors.primary('  › ') + colors.text(displayPre);
+                inp = colors.primary('  › ') + colors.text(displayPre) + colors.text(suffix);
+                cursorCol = 5 + displayPre.length;
             }
-            process.stdout.write(`\x1b[${inpRow};1H\x1b[2K` + inp);
-            process.stdout.write('\r\n' + SEP + '\x1b[1A\r' + inp);
+            process.stdout.write(`\x1b[${sR};1H\x1b[2K${SEP}`);
+            process.stdout.write(`\x1b[${iR};1H\x1b[2K${inp}`);
+            process.stdout.write(`\x1b[${iR};${cursorCol}H`);
         }
         function submit() {
             if (atMode)
                 closePicker();
+            if (slashMode)
+                closeSlashPicker();
             if (tabMode) {
                 prefix = tabPreWord + tabQuery;
                 closeTabPicker();
@@ -1244,12 +1261,12 @@ async function readLine(prompt, cwd) {
             const text = parts.join('\n');
             const lns = parts.length > 0 ? parts : (text ? [text] : []);
             cleanup();
-            process.stdout.write('\r\x1b[K');
-            process.stdout.write('\x1b[1B\x1b[2K');
-            process.stdout.write('\x1b[2A\x1b[2K');
-            // Move cursor to bottom of scroll region for next AI output
-            const scrEnd = (process.stdout.rows ?? 24) - 3;
-            process.stdout.write(`\x1b[${scrEnd};1H`);
+            const rows = process.stdout.rows ?? 24;
+            const sR = rows - 2;
+            const iR = rows - 1;
+            process.stdout.write(`\x1b[${sR};1H\x1b[2K`);
+            process.stdout.write(`\x1b[${iR};1H\x1b[2K`);
+            process.stdout.write(`\x1b[${sR};1H`);
             if (!text) {
                 resolve(null);
                 return;
@@ -1461,7 +1478,22 @@ async function readLine(prompt, cwd) {
                         }
                         return;
                     }
-                    if (data === '\r' || data === '\n' || data === '\t') {
+                    if (data === '\r' || data === '\n') {
+                        const filtered = filterSlash(slashQuery);
+                        if (filtered.length > 0) {
+                            const cmd = filtered[Math.min(slashSel, filtered.length - 1)];
+                            prefix = cmd.name;
+                            closeSlashPicker();
+                            submit();
+                        }
+                        else {
+                            prefix = '/' + slashQuery;
+                            closeSlashPicker();
+                            submit();
+                        }
+                        return;
+                    }
+                    if (data === '\t') {
                         const filtered = filterSlash(slashQuery);
                         if (filtered.length > 0) {
                             const cmd = filtered[Math.min(slashSel, filtered.length - 1)];
@@ -1711,8 +1743,8 @@ function timeAgoShort(iso) {
         return `${d}d`;
     return `${Math.floor(d / 30)}mo`;
 }
-async function showConversationPicker(cwdForList) {
-    const allConvs = listConversations(cwdForList, 100);
+async function showConversationPicker(cwd) {
+    const allConvs = listConversations(cwd, 100);
     if (allConvs.length === 0) {
         printInfo('No saved conversations yet.');
         return null;
@@ -2149,159 +2181,123 @@ async function showDesignModeLoader(skills) {
 }
 export async function startRepl(cwd) {
     const alwaysAllowed = new Set();
-    // ── Terminal title helper ─────────────────────────────────────
-    function setTerminalTitle(title) {
-        process.stdout.write(`\x1b]0;Dravix Code — ${title}\x07`);
-    }
-    setTerminalTitle('AI-powered coding assistant');
     const token = getToken() ?? '';
-    let SYSTEM_PROMPT = `You are Dravix Code, an interactive CLI coding agent powered by DeepSeek that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
-
-You are a proactive, precise, and safe engineering partner. You think before you act, you verify your work, and you communicate clearly.
-
-IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
-
-# Core Principles
-
-- Be correct, helpful, and safe above all else.
-- Think step by step before writing or modifying any code. State the plan in one short sentence before acting.
-- Prefer minimal, surgical changes that preserve the existing codebase structure and conventions.
-- Never guess at APIs, libraries, or configurations. Read the codebase first, or admit uncertainty.
-- Respect the user's time: be concise but never omit crucial details.
-- If a request is genuinely ambiguous and blocks progress, ask one short clarifying question. Otherwise make the reasonable call and continue.
-
-# File Operations
-
-- read_file = read a file (returns numbered lines like "  42 │ code")
-- write_file = CREATE new files only — NEVER overwrite existing files
-- edit_file = MODIFY existing files (use <find>/<replace> with EXACT text from read_file)
-- create_folder = create directories
-- delete_file = delete files
-- run_command = execute shell commands
-- read_folder = list directory contents
-- search_code = search file contents with regex or literal text
-- glob_files = find files by glob pattern like "**/*.ts"
-
-# edit_file rules — CRITICAL
-
-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. Do NOT put line numbers in <find> (e.g., "42 │ code" is WRONG — use only "code")
-5. If edit fails, the system will show you the actual content — use it to retry
-6. Multiple edits on the same file: order from BOTTOM to TOP
-7. NEVER use write_file on an existing file — it destroys user code
-
-# Communication Style
-
-- Output is rendered in a terminal as Markdown. Be short and concise.
-- Reference code with \`file_path:line_number\` so the user can jump to it.
-- Do not start replies with conversational filler ("Got it", "Sure", "Great question"). State the action or result directly.
-- Do not narrate internal deliberation. Give brief updates at key moments.
-- End-of-turn summary: one or two sentences. What changed and what's next.
-- Respond in the same language the user writes in.
-
-# Code Quality
-
-- Keep things in one function unless composable or reusable.
-- Avoid try/catch where possible; avoid the any type.
-- Prefer functional array methods (flatMap/filter/map) over for loops.
-- Prefer const. Use ternaries or early returns instead of reassignment. Avoid else after return.
-- Do not destructure unnecessarily — obj.a over const { a } = obj.
-- Don't add features, refactors, or abstractions beyond what the task requires.
-- Don't add error handling for impossible scenarios.
-- Delete unused code completely rather than leaving _var or comments.
-- Default to writing no comments. Only comment when the WHY is non-obvious.
-
-# Safety
-
-- Never generate malicious, obfuscated, or deceptive code.
-- Do not output secrets, tokens, or private keys.
-- Guard against SQL injection, XSS, path traversal, insecure deserialization, command injection.
-- When you encounter an obstacle, do not use destructive actions as a shortcut.
-
-# Working discipline
-
-- If the user asks to create a file: use write_file, NOT code blocks.
-- Read files before editing them — always!
-- Plan all files first, create them in logical order, run commands last.
-- Only touch files the user explicitly mentioned or clearly required by the task.
-- When fixing a bug, fix the ROOT CAUSE, not just the symptom.
-- If a run_command fails, read the error message and fix the issue.
-- Complete the ENTIRE task in ONE response — do not ask for permission to continue.`;
+    let SYSTEM_PROMPT = 'You are Dravix Code — an elite AI coding assistant. The server is temporarily unreachable. Use your best judgment to help the user.';
     if (token) {
         const { prompt, webDesignerSkill } = await fetchSystemPrompt(token);
         if (prompt) {
-            SYSTEM_PROMPT = prompt + '\n\n' + SYSTEM_PROMPT;
+            SYSTEM_PROMPT = prompt;
             _serverWebDesignerSkill = webDesignerSkill;
         }
     }
     // activeCwd can change when /resume loads a conversation from a different directory
     let activeCwd = cwd;
     // Rules appended to every system prompt to enforce safe file-operation behavior
-    const SAFE_FILE_RULES = `
-
-## XML Tag Format (REQUIRED — use these EXACTLY)
-
-All file operations MUST use these tags — NEVER put them in markdown code blocks:
-
-### <write_file path="relative/path"> ... </write_file>
-Create a NEW file. The path is relative to the project root. The content goes between the tags.
-
-### <edit_file path="relative/path">
-###   <find>EXACT text to find</find>
-###   <replace>replacement text</replace>
-### </edit_file>
-Modify an EXISTING file. The <find> text must match EXACTLY — copy it verbatim from read_file output, WITHOUT the line number prefixes (e.g., if read_file shows "  42 │ code", use just "code" in <find>).
-
-### <read_file path="relative/path" />
-Read a file. Optional: lines="100-200" to read a specific range.
-
-### <read_folder path="relative/path" />
-List directory contents with file sizes.
-
-### <create_folder path="relative/path" />
-Create a new directory (and parents if needed).
-
-### <delete_file path="relative/path" />
-Delete a file or directory.
-
-### <run_command>command here</run_command>
-Execute a shell command. Optional: cwd="subdir" to run in a subdirectory.
-
-### <search_code pattern="text" />
-Search file contents. Options: path="dir", include="*.ts", context="3", regex="true".
-
-### <glob_files pattern="**/*.ts" />
-Find files by glob pattern.
-
-## Critical Reminders
-
-- write_file = NEW files ONLY. For existing files, ALWAYS use edit_file.
-- read_file shows line numbers as "  N │ code" — strip the "N │ " prefix when copying into <find>.
-- Multiple edit_file on the same file: order from BOTTOM to TOP (line numbers shift as you edit).
-- DO NOT output <write_file> / <edit_file> / <run_command> tags inside markdown code blocks — they must be raw in the response.
-- Execute ALL operations in ONE response when possible — do not split work across multiple turns.
-- ⚠️ CRITICAL: If you write "now I will run/start/execute/install X" — you MUST also include the <run_command> tag. Saying it is NOT enough. Always output the actual tag with the command.
-
-## End-of-turn summary — REQUIRED after every task
-
-After you finish ALL operations for the user's request, you MUST write a short, natural summary. This is the most important part of your response.
-
-Write 1-3 sentences in the user's language. No tables. No emoji lists. No rigid formats. Just explain what you did, like a colleague updating a teammate.
-
-Good examples:
-- "I deleted BOT_INFO.md from the project. No other changes were made."
-- "Updated main.ts — changed the port from 8000 to 9000. The API now listens on port 9000."
-- "Created three files: auth.ts, routes.ts, and models.ts. The basic API structure is ready."
-- "Fixed the import path in app.tsx and removed the unused variable in utils.ts."
-
-Bad examples:
-- Outputting operation tags with no human-readable text
-- Saying only "Done" or "Summary:" with a rigid table of emojis
-- Ending with nothing — just silence after the last XML tag
-
-The summary should feel like a natural conversation close — informative, brief, in the user's language.`;
+    const SAFE_FILE_RULES = `
+
+## 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.
+
+### Creating files
+- NEVER show code in code blocks when the user asks to create files or a project.
+- ALWAYS use <write_file path="filename"> tags to create actual files.
+- Code blocks are for short inline explanations only — they do NOT create files.
+- Output ALL required files in ONE response using <write_file> tags.
+
+### File operations
+- **write_file** = CREATE only. Use it ONLY when a file does NOT exist yet.
+- **edit_file** = MODIFY existing files. For ANY change to an existing file, always use edit_file with <find>/<replace>.
+- 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.
+- 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),
@@ -2351,8 +2347,8 @@ The summary should feel like a natural conversation close — informative, brief
     process.on('exit', resetTerminal);
     process.on('SIGINT', () => { resetTerminal(); process.exit(0); });
     process.on('SIGTERM', () => { resetTerminal(); process.exit(0); });
-    process.on('unhandledRejection', (reason) => { logError('unhandledRejection', reason); /* don't kill — let process continue */ });
-    process.on('uncaughtException', (err) => { logError('uncaughtException', err); /* don't kill — let process continue */ });
+    process.on('unhandledRejection', (reason) => { logError('unhandledRejection', reason); resetTerminal(); });
+    process.on('uncaughtException', (err) => { logError('uncaughtException', err); resetTerminal(); });
     // Set raw mode ONCE — never toggle it during the session to avoid CMD getting stuck
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -2373,8 +2369,20 @@ The summary should feel like a natural conversation close — informative, brief
             if (readFileContinue) {
                 readFileContinue = false;
                 readFileTurnCount++;
-                // Keep auto-continue prompt SHORT — large prompts time out DeepSeek reasoning model
-                const taskInstruction = `Continue. All necessary file contents are above in context. Complete the task now — do NOT read more files. Output operations with <edit_file> or <run_command> tags.`;
+                // Remind AI of the original user request — show first + last line so pasted code
+                // doesn't eclipse the actual instruction written at the end.
+                const rawUserMsg = lastUserLine.trim();
+                const msgLines = rawUserMsg.split('\n').map(l => l.trim()).filter(Boolean);
+                let userReminder = '';
+                if (msgLines.length > 0) {
+                    const first = msgLines[0].slice(0, 100);
+                    const last = msgLines[msgLines.length - 1].slice(0, 150);
+                    const display = msgLines.length <= 2 ? msgLines.join(' / ').slice(0, 200) : `${first} [...] ${last}`;
+                    userReminder = `The user's request: "${display}". `;
+                }
+                const taskInstruction = userReminder
+                    ? `The user's exact request was: "${rawUserMsg.slice(0, 300)}"\nNow execute THIS request and ONLY this request — nothing else. Do not invent, add, or change anything the user did not ask for. Use <edit_file> with targeted <find>/<replace> — never use <write_file> on existing files. Use the file content above to find the exact text and apply the change.`
+                    : `Execute the user's request using the file content above. Use <edit_file> for existing files, <write_file> only for new files.`;
                 // Keep using FLASH_MODEL after file reads
                 if (readFileTurnCount > 5 && !forcedEditMode) {
                     forcedEditMode = true;
@@ -2436,7 +2444,6 @@ The summary should feel like a natural conversation close — informative, brief
                         });
                         sessionId = convId;
                         conversationTitle = conv.title;
-                        setTerminalTitle(conv.title);
                         printConversationHistory(conv.messages);
                     }
                 }
@@ -2490,13 +2497,11 @@ The summary should feel like a natural conversation close — informative, brief
                     history.splice(1, history.length - 22);
                 }
                 // ── Auto-inject mentioned file contents ──────────────────────
-                // Reduced from 3000 → keeps prompt small enough for DeepSeek reasoning model
+                // Files ≤ 3000 lines: full raw content injected — AI has exact text for <find>, no reads needed.
                 const FILE_PATTERN = /[\w\-.\/\\]+\.\w{2,5}/g;
                 const mentioned = [...new Set(line.match(FILE_PATTERN) ?? [])];
                 let fileContext = '';
-                const FULL_INJECT_LINES = 400;
-                const MAX_INJECT_CHARS = 25000;
-                let injectedChars = 0;
+                const FULL_INJECT_LINES = 3000;
                 for (const fname of mentioned) {
                     const fullPath = path.resolve(activeCwd, fname);
                     if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
@@ -2504,15 +2509,8 @@ The summary should feel like a natural conversation close — informative, brief
                             const content = fs.readFileSync(fullPath, 'utf-8');
                             const fileLines = content.split('\n');
                             const lineCount = fileLines.length;
-                            if (lineCount <= FULL_INJECT_LINES && injectedChars < MAX_INJECT_CHARS) {
-                                const toAdd = `\n\n[File: ${fname} — ${lineCount} lines — FULL]\n` + content;
-                                if (injectedChars + toAdd.length > MAX_INJECT_CHARS) {
-                                    fileContext += `\n\n[File: ${fname} — ${lineCount} lines — skipped (prompt limit)]`;
-                                }
-                                else {
-                                    fileContext += toAdd;
-                                    injectedChars += toAdd.length;
-                                }
+                            if (lineCount <= FULL_INJECT_LINES) {
+                                fileContext += `\n\n[File: ${fname} — ${lineCount} lines — FULL]\n` + content;
                             }
                             else {
                                 fileContext += `\n\n[File: ${fname} — ${lineCount} lines]\n` +
@@ -2546,7 +2544,6 @@ The summary should feel like a natural conversation close — informative, brief
             }
             // ── Ctrl+C cancel during streaming ──────────────────────────
             let streamCancelled = false;
-            let streamInputBuffer = '';
             const streamAbort = new AbortController();
             const onStreamKey = (data) => {
                 try {
@@ -2554,10 +2551,6 @@ The summary should feel like a natural conversation close — informative, brief
                         streamCancelled = true;
                         streamAbort.abort();
                     }
-                    else {
-                        // Capture user input during stream — will be queued for next turn
-                        streamInputBuffer += data;
-                    }
                 }
                 catch { /* ignore */ }
             };
@@ -2942,7 +2935,6 @@ The summary should feel like a natural conversation close — informative, brief
                         if (_u && _a) {
                             generateAITitle(String(_u.content), String(_a.content), token).then(t => {
                                 conversationTitle = t;
-                                setTerminalTitle(t);
                                 saveConversation(sessionId, t, activeCwd, history.slice(1));
                             }).catch(() => { });
                         }
@@ -3029,8 +3021,6 @@ The summary should feel like a natural conversation close — informative, brief
                     // Trailing newline — skip when read ops follow (they start on current line)
                     if (hasRenderedContent && readOps.length === 0)
                         process.stdout.write('\n');
-                    // Synchronisation flag: ops/else must wait for readOps to finish
-                    let readOpsDone = readOps.length === 0;
                     // ── Handle read_file ops ──────────────────────────────
                     // forcedEditMode: block further reads — AI must use existing context
                     if (readOps.length > 0 && forcedEditMode) {
@@ -3041,7 +3031,6 @@ The summary should feel like a natural conversation close — informative, brief
                         readFileContinue = true;
                     }
                     else if (readOps.length > 0) {
-                        readOpsDone = false;
                         // Absorb blank lines so reading block starts immediately after user message
                         if (hasRenderedContent) {
                             // Ensure cursor is on a new line, then absorb excess trailing blank lines
@@ -3219,22 +3208,18 @@ The summary should feel like a natural conversation close — informative, brief
                                 }
                                 process.stdout.write(`  ` + BC('╰' + '─'.repeat(boxW - 2) + '╯') + `\n`);
                                 readFileContinue = true;
-                                readOpsDone = true;
+                                resolve();
                             }
                             catch (e) {
                                 logError('readOps', e);
-                                readFileContinue = true;
-                                readOpsDone = true;
+                                resolve();
                             }
                         })();
+                        return;
                     } // end else if (readOps.length > 0)
-                    // Process write/run/mkdir/delete ops — waits for readOps to finish first
                     if (ops.length > 0) {
                         (async () => {
                             try {
-                                // Wait for any pending read operations to finish
-                                while (!readOpsDone)
-                                    await new Promise(r => setTimeout(r, 20));
                                 const skippedPaths = new Set();
                                 const runOutputs = [];
                                 const fileOpErrors = [];
@@ -3373,12 +3358,7 @@ The summary should feel like a natural conversation close — informative, brief
                         })();
                     }
                     else {
-                        // No ops — just wait for readOps to finish, then resolve
-                        (async () => {
-                            while (!readOpsDone)
-                                await new Promise(r => setTimeout(r, 20));
-                            resolve();
-                        })();
+                        resolve();
                     }
                 }, (err) => {
                     clearInterval(spinnerInterval);
@@ -3409,12 +3389,6 @@ The summary should feel like a natural conversation close — informative, brief
             });
             // ── Remove streaming key listener ─────────────────────────
             process.stdin.removeListener('data', onStreamKey);
-            // ── Queue captured input for next user turn ─────────────────
-            const captured = streamInputBuffer.trim();
-            if (captured && !queuedResult) {
-                queuedResult = { text: captured, lines: [captured] };
-            }
-            streamInputBuffer = '';
             // ── Accumulate token usage (deferred — report on next user turn) ──
             if (cliTok && fullResponse) {
                 pendingOutputTokens += estimateTokens(normalizeResponse(fullResponse));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taj-special/dravix-code",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "description": "AI-powered coding assistant CLI — Dravix Code",
   "type": "module",
   "bin": {
@@ -10,10 +10,10 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "node node_modules/typescript/lib/tsc.js",
     "start": "node dist/cli/index.js",
-    "dev": "tsc --watch",
-    "prepublishOnly": "tsc"
+    "dev": "node node_modules/typescript/lib/tsc.js --watch",
+    "prepublishOnly": "node node_modules/typescript/lib/tsc.js"
   },
   "dependencies": {
     "chalk": "^5.3.0"