termux-dev 1.4.18 → 1.5.0

package/dist/cli/prompt.js

@@ -3,6 +3,9 @@ import { scanProjectFiles } from './files.js';
 import { saveClipboardImage, processPastedFilePath } from './clipboard.js';
 import { getCurrentTheme } from './theme.js';
 import { CustomCommandManager } from '../core/commands.js';
+import { formatPromptHeader } from './modeborder.js';
+import { filterCommandPalette, estimatePromptTokens, formatPromptTokenBadge } from './prompt_palette.js';
+import { PromptHistoryNavigator } from './history_search.js';
 export const SLASH_COMMANDS = [
     { cmd: '/new', desc: 'Start a new clean chat session' },
     { cmd: '/resume', desc: 'Resume a previous chat session' },
@@ -39,11 +42,17 @@ function stripAnsi(str) {
 }
 export function askPrompt(opts = {}) {
     return new Promise((resolve) => {
-        const msg = opts.message
-            ? `${opts.message} ${pc.dim(`(Tab = ${opts.planMode ? 'AGENT' : 'PLAN'})`)}`
-            : `Ask anything... ${pc.dim(`(Tab = ${opts.planMode ? 'AGENT' : 'PLAN'})`)}`;
         const theme = getCurrentTheme();
-        console.log(theme.colorFn('◆') + '  ' + pc.bold(msg));
+        if (opts.ui?.modeBorder) {
+            const header = formatPromptHeader(!!opts.planMode, !!opts.isYolo, opts.message);
+            console.log(header);
+        }
+        else {
+            const msg = opts.message
+                ? `${opts.message} ${pc.dim(`(Tab = ${opts.planMode ? 'AGENT' : 'PLAN'})`)}`
+                : `Ask anything... ${pc.dim(`(Tab = ${opts.planMode ? 'AGENT' : 'PLAN'})`)}`;
+            console.log(theme.colorFn('◆') + '  ' + pc.bold(msg));
+        }
         let availableFiles = [];
         let customCommandsList = [];
         scanProjectFiles().then((f) => (availableFiles = f)).catch(() => { });
@@ -54,8 +63,14 @@ export function askPrompt(opts = {}) {
         let cursorPos = input.length;
         let selectedIndex = 0;
         let lastRenderedDropdownLines = 0;
-        let historyIndex = GLOBAL_PROMPT_HISTORY.length;
-        let tempDraft = '';
+        const historyNav = new PromptHistoryNavigator(GLOBAL_PROMPT_HISTORY, !!opts.ui?.promptHistoryFuzzy);
+        PromptHistoryNavigator.loadPersistent().then((persisted) => {
+            for (const p of persisted) {
+                if (!GLOBAL_PROMPT_HISTORY.includes(p)) {
+                    GLOBAL_PROMPT_HISTORY.push(p);
+                }
+            }
+        }).catch(() => { });
         const imageAttachments = [];
         const usedImageNames = new Set();
         const pastedBlocks = [];
@@ -133,18 +148,34 @@ export function askPrompt(opts = {}) {
         function getDropdownItems() {
             if (input.startsWith('/')) {
                 const q = input.trim().toLowerCase();
-                const baseList = [
-                    ...SLASH_COMMANDS.map((c) => ({ label: c.cmd, desc: c.desc, replacement: c.cmd })),
-                    ...customCommandsList.map((c) => ({ label: c.cmd, desc: `(custom) ${c.desc}`, replacement: c.cmd }))
-                ];
-                const filtered = baseList.filter((c) => c.label.toLowerCase().startsWith(q) || q === '/');
-                return filtered.map((item) => ({
-                    label: item.label,
-                    desc: item.desc,
-                    replacement: item.replacement,
-                    replaceStart: 0,
-                    replaceLen: input.length
-                }));
+                if (opts.ui?.commandPalette) {
+                    const baseList = [
+                        ...SLASH_COMMANDS.map((c) => ({ cmd: c.cmd, desc: c.desc })),
+                        ...customCommandsList.map((c) => ({ cmd: c.cmd, desc: `(custom) ${c.desc}` }))
+                    ];
+                    const filtered = filterCommandPalette(input, baseList).slice(0, 15);
+                    return filtered.map((item) => ({
+                        label: item.cmd,
+                        desc: item.desc,
+                        replacement: `${item.cmd} `,
+                        replaceStart: 0,
+                        replaceLen: input.length
+                    }));
+                }
+                else {
+                    const baseList = [
+                        ...SLASH_COMMANDS.map((c) => ({ label: c.cmd, desc: c.desc, replacement: c.cmd })),
+                        ...customCommandsList.map((c) => ({ label: c.cmd, desc: `(custom) ${c.desc}`, replacement: c.cmd }))
+                    ];
+                    const filtered = baseList.filter((c) => c.label.toLowerCase().startsWith(q) || q === '/');
+                    return filtered.map((item) => ({
+                        label: item.label,
+                        desc: item.desc,
+                        replacement: item.replacement,
+                        replaceStart: 0,
+                        replaceLen: input.length
+                    }));
+                }
             }
             const beforeCursor = input.slice(0, cursorPos);
             const atMatch = beforeCursor.match(/@([a-zA-Z0-9_\-./\u0400-\u04FF]*)$/);
@@ -178,9 +209,12 @@ export function askPrompt(opts = {}) {
                 if (selectedIndex < 0)
                     selectedIndex = 0;
                 // Limit dropdown height gracefully so it always fits comfortably
-                const maxDropdownRows = Math.max(2, Math.min(rows - 3, 6));
+                const maxDropdownRows = Math.max(2, Math.min(rows - 3, 5));
                 const pageSize = Math.min(4, Math.max(2, Math.min(maxDropdownRows - 2, Math.floor(rows / 4))));
-                const innerBoxWidth = Math.max(10, Math.min(cols - 8, 48));
+                // Strict boundary: left margin (2) + box borders (2) + inner width <= cols - 4
+                // This mathematically prevents terminal auto-wrapping on narrow mobile screens
+                const boxWidth = Math.max(12, Math.min(cols - 6, 46));
+                const innerWidth = Math.max(8, boxWidth - 2);
                 const total = items.length;
                 let startIndex = 0;
                 if (total > pageSize) {
@@ -191,52 +225,53 @@ export function askPrompt(opts = {}) {
                 const endIndex = Math.min(startIndex + pageSize, total);
                 const hasMoreUp = startIndex > 0;
                 const hasMoreDown = endIndex < total;
-                let topBorderStr = '─'.repeat(innerBoxWidth);
+                let topBorderStr = '─'.repeat(innerWidth);
                 if (hasMoreUp) {
-                    const mid = Math.max(0, Math.floor(innerBoxWidth / 2) - 2);
-                    topBorderStr = '─'.repeat(mid) + ' ▲ ' + '─'.repeat(Math.max(0, innerBoxWidth - mid - 3));
+                    const mid = Math.max(0, Math.floor(innerWidth / 2) - 2);
+                    topBorderStr = '─'.repeat(mid) + ' ▲ ' + '─'.repeat(Math.max(0, innerWidth - mid - 3));
                 }
-                let botBorderStr = '─'.repeat(innerBoxWidth);
+                let botBorderStr = '─'.repeat(innerWidth);
                 if (hasMoreDown) {
-                    const mid = Math.max(0, Math.floor(innerBoxWidth / 2) - 2);
-                    botBorderStr = '─'.repeat(mid) + ' ▼ ' + '─'.repeat(Math.max(0, innerBoxWidth - mid - 3));
+                    const mid = Math.max(0, Math.floor(innerWidth / 2) - 2);
+                    botBorderStr = '─'.repeat(mid) + ' ▼ ' + '─'.repeat(Math.max(0, innerWidth - mid - 3));
                 }
-                dropdownLines.push(pc.dim('│') + '  ' + pc.dim('╭' + topBorderStr + '╮') + '\x1b[0m');
+                dropdownLines.push(pc.dim('│ ') + pc.dim('╭' + topBorderStr + '╮') + '\x1b[0m');
                 for (let i = startIndex; i < endIndex; i++) {
                     const item = items[i];
                     const isSelected = i === selectedIndex;
                     const pointer = isSelected ? '› ' : '  ';
-                    const availWidth = innerBoxWidth;
-                    let row = '';
-                    if (availWidth < 20) {
-                        const labelStr = item.label.length > availWidth - 2
-                            ? item.label.slice(0, availWidth - 3) + '…'
-                            : item.label.padEnd(availWidth - 2, ' ');
-                        const plain = (pointer + labelStr).padEnd(availWidth, ' ').slice(0, availWidth);
-                        row = isSelected
-                            ? theme.badgeFn(plain) + '\x1b[0m'
-                            : pointer + theme.boldFn(labelStr) + '\x1b[0m';
+                    const avail = Math.max(4, innerWidth - pointer.length);
+                    let rowText = '';
+                    if (avail < 16) {
+                        const labelStr = item.label.length > avail
+                            ? item.label.slice(0, avail - 1) + '…'
+                            : item.label.padEnd(avail, ' ');
+                        rowText = pointer + (isSelected ? theme.boldFn(labelStr) : labelStr);
                     }
                     else {
-                        const labelMax = Math.min(13, Math.max(6, Math.floor(availWidth * 0.35)));
+                        const labelMax = Math.min(12, Math.max(6, Math.floor(avail * 0.38)));
                         const labelStr = item.label.length > labelMax
                             ? item.label.slice(0, labelMax - 1) + '…'
                             : item.label.padEnd(labelMax, ' ');
-                        const descMax = Math.max(4, availWidth - labelMax - pointer.length - 1);
+                        const descMax = Math.max(3, avail - labelMax - 1);
                         const descStr = item.desc.length > descMax
                             ? item.desc.slice(0, descMax - 1) + '…'
                             : item.desc.padEnd(descMax, ' ');
-                        const plain = (pointer + labelStr + ' ' + descStr).padEnd(availWidth, ' ').slice(0, availWidth);
-                        if (isSelected) {
-                            row = theme.badgeFn(plain) + '\x1b[0m';
-                        }
-                        else {
-                            row = `${pointer}${theme.boldFn(labelStr)} ${pc.gray(descStr)}\x1b[0m`;
-                        }
+                        rowText = pointer + (isSelected ? theme.boldFn(labelStr) : labelStr) + ' ' + pc.gray(descStr);
+                    }
+                    // Calculate visible plain length without ANSI
+                    const plainLen = rowText.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').length;
+                    const padCount = Math.max(0, innerWidth - plainLen);
+                    const fullRow = rowText + ' '.repeat(padCount);
+                    if (isSelected) {
+                        const cleanFull = fullRow.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+                        dropdownLines.push(pc.dim('│ ') + pc.dim('│') + theme.badgeFn(cleanFull) + pc.dim('│') + '\x1b[0m');
+                    }
+                    else {
+                        dropdownLines.push(pc.dim('│ ') + pc.dim('│') + fullRow + pc.dim('│') + '\x1b[0m');
                     }
-                    dropdownLines.push(pc.dim('│') + '  ' + pc.dim('│') + row + pc.dim('│') + '\x1b[0m');
                 }
-                dropdownLines.push(pc.dim('│') + '  ' + pc.dim('╰' + botBorderStr + '╯') + '\x1b[0m');
+                dropdownLines.push(pc.dim('│ ') + pc.dim('╰' + botBorderStr + '╯') + '\x1b[0m');
             }
             // 1. Format and write the Prompt line safely
             let inputDisplay = pc.dim('│') + '  ';
@@ -248,9 +283,11 @@ export function askPrompt(opts = {}) {
                 renderCursorCol = 3;
             }
             else {
-                const maxInputLen = Math.max(10, cols - 6);
+                const tokenBadge = opts.ui?.inputTokenCounter ? formatPromptTokenBadge(estimatePromptTokens(input), 40) : '';
+                const badgeSuffix = tokenBadge ? ` ${tokenBadge}` : '';
+                const maxInputLen = Math.max(10, cols - 6 - (tokenBadge ? 12 : 0));
                 if (input.length <= maxInputLen) {
-                    inputDisplay += formatInputWithBadges(input) + '\x1b[0m';
+                    inputDisplay += formatInputWithBadges(input) + badgeSuffix + '\x1b[0m';
                     renderCursorCol = 3 + cursorPos;
                 }
                 else {
@@ -259,7 +296,7 @@ export function askPrompt(opts = {}) {
                     const visibleChunk = input.slice(start, start + maxInputLen);
                     const prefix = start > 0 ? '…' : '';
                     const suffix = start + maxInputLen < input.length ? '…' : '';
-                    inputDisplay += pc.dim(prefix) + formatInputWithBadges(visibleChunk) + pc.dim(suffix) + '\x1b[0m';
+                    inputDisplay += pc.dim(prefix) + formatInputWithBadges(visibleChunk) + pc.dim(suffix) + badgeSuffix + '\x1b[0m';
                     renderCursorCol = 3 + (prefix ? 1 : 0) + (cursorPos - start);
                 }
             }
@@ -361,6 +398,10 @@ export function askPrompt(opts = {}) {
                 handlePaste(str);
                 return;
             }
+            // Ignore EOF / Ctrl+D (\x04)
+            if (str === '\x04') {
+                return;
+            }
             // Ctrl+C / SIGINT
             if (str === '\x03') {
                 if (lastRenderedDropdownLines > 0) {
@@ -465,14 +506,13 @@ export function askPrompt(opts = {}) {
                     selectedIndex = (selectedIndex - 1 + items.length) % items.length;
                     render();
                 }
-                else if (GLOBAL_PROMPT_HISTORY.length > 0 && historyIndex > 0) {
-                    if (historyIndex === GLOBAL_PROMPT_HISTORY.length) {
-                        tempDraft = input;
+                else {
+                    const prev = historyNav.navigateUp(input);
+                    if (prev !== null) {
+                        input = prev;
+                        cursorPos = input.length;
+                        render();
                     }
-                    historyIndex--;
-                    input = GLOBAL_PROMPT_HISTORY[historyIndex];
-                    cursorPos = input.length;
-                    render();
                 }
                 return;
             }
@@ -482,16 +522,13 @@ export function askPrompt(opts = {}) {
                     selectedIndex = (selectedIndex + 1) % items.length;
                     render();
                 }
-                else if (historyIndex < GLOBAL_PROMPT_HISTORY.length) {
-                    historyIndex++;
-                    if (historyIndex === GLOBAL_PROMPT_HISTORY.length) {
-                        input = tempDraft;
-                    }
-                    else {
-                        input = GLOBAL_PROMPT_HISTORY[historyIndex];
+                else {
+                    const next = historyNav.navigateDown();
+                    if (next !== null) {
+                        input = next;
+                        cursorPos = input.length;
+                        render();
                     }
-                    cursorPos = input.length;
-                    render();
                 }
                 return;
             }

package/dist/cli/prompt_palette.js

@@ -0,0 +1,37 @@
+import pc from 'picocolors';
+export function filterCommandPalette(query, commands) {
+    if (!query || query === '/') {
+        return [...commands];
+    }
+    const q = query.toLowerCase().replace(/^\//, '');
+    return commands.filter((c) => {
+        const name = c.cmd.toLowerCase().replace(/^\//, '');
+        return name.includes(q) || c.desc.toLowerCase().includes(q);
+    });
+}
+export function estimatePromptTokens(text) {
+    if (!text)
+        return 0;
+    let tokens = 0;
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if (code >= 0x0400 && code <= 0x04ff) {
+            tokens += 0.8;
+        }
+        else if (code > 0x07ff) {
+            tokens += 1.2;
+        }
+        else {
+            tokens += 0.25;
+        }
+    }
+    return Math.max(1, Math.round(tokens));
+}
+export function formatPromptTokenBadge(tokens, threshold = 30) {
+    if (tokens < threshold)
+        return '';
+    if (tokens >= 1000) {
+        return pc.dim(`(~${(tokens / 1000).toFixed(1)}k tok)`);
+    }
+    return pc.dim(`(~${tokens} tok)`);
+}

package/dist/cli/server.js

@@ -7,6 +7,7 @@ import { spawn } from 'child_process';
 import pc from 'picocolors';
 import qrcode from 'qrcode-terminal';
 import { getTheme } from './theme.js';
+import { DEVX_VERSION } from '../core/types.js';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
     '.htm': 'text/html; charset=utf-8',
@@ -139,7 +140,7 @@ function renderDirectoryHtml(dirPath, relPath, files, port) {
       ${parentLink}
       ${items || '<li style="padding: 20px; text-align: center; color: #6e7681;">No visible files in this directory</li>'}
     </ul>
-    <div class="footer">devx v1.4.18 &bull; Terminal-Native AI Assistant</div>
+    <div class="footer">devx v${DEVX_VERSION} &bull; Terminal-Native AI Assistant</div>
   </div>
 </body>
 </html>`;

package/dist/cli/statusline.js

@@ -0,0 +1,107 @@
+import { execSync } from 'child_process';
+import pc from 'picocolors';
+import { getCurrentTheme } from './theme.js';
+export class GitStatusCache {
+    static cachedInfo = undefined;
+    static lastCheckTime = 0;
+    static TTL_MS = 10000; // 10s fallback TTL
+    static getStatus(forceRefresh = false) {
+        const now = Date.now();
+        if (!forceRefresh && GitStatusCache.cachedInfo !== undefined && (now - GitStatusCache.lastCheckTime < GitStatusCache.TTL_MS)) {
+            return GitStatusCache.cachedInfo;
+        }
+        GitStatusCache.lastCheckTime = now;
+        try {
+            const branch = execSync('git branch --show-current', {
+                stdio: ['ignore', 'pipe', 'ignore'],
+                encoding: 'utf8',
+                timeout: 1000
+            }).trim();
+            if (!branch) {
+                GitStatusCache.cachedInfo = null;
+                return null;
+            }
+            const status = execSync('git status --porcelain', {
+                stdio: ['ignore', 'pipe', 'ignore'],
+                encoding: 'utf8',
+                timeout: 1000
+            }).trim();
+            const isDirty = status.length > 0;
+            GitStatusCache.cachedInfo = { branch, isDirty };
+            return GitStatusCache.cachedInfo;
+        }
+        catch {
+            GitStatusCache.cachedInfo = null;
+            return null;
+        }
+    }
+    static invalidate() {
+        GitStatusCache.cachedInfo = undefined;
+        GitStatusCache.lastCheckTime = 0;
+    }
+}
+export function renderProgressBar(percent, barWidth = 10) {
+    const clamped = Math.max(0, Math.min(100, percent));
+    const filledCount = Math.round((clamped / 100) * barWidth);
+    const emptyCount = Math.max(0, barWidth - filledCount);
+    const bar = '█'.repeat(filledCount) + '░'.repeat(emptyCount);
+    if (clamped >= 90)
+        return pc.red(`[${bar}] ${clamped}%`);
+    if (clamped >= 75)
+        return pc.yellow(`[${bar}] ${clamped}%`);
+    return pc.cyan(`[${bar}] ${clamped}%`);
+}
+export function formatCostBadge(cost, maxCostUSD) {
+    const costFormatted = `$${cost.toFixed(4)}`;
+    if (!maxCostUSD || maxCostUSD <= 0) {
+        return pc.green(costFormatted);
+    }
+    const ratio = cost / maxCostUSD;
+    if (ratio >= 1.0) {
+        return pc.red(costFormatted);
+    }
+    if (ratio >= 0.8) {
+        return pc.yellow(costFormatted);
+    }
+    return pc.green(costFormatted);
+}
+export function renderPowerlineStatus(opts) {
+    const cols = opts.cols || process.stdout.columns || 80;
+    const theme = getCurrentTheme();
+    // Mode badge
+    let modeBadge = '';
+    if (opts.isYolo) {
+        modeBadge = pc.bgRed(pc.bold(pc.white(' YOLO ')));
+    }
+    else if (opts.mode === 'PLAN') {
+        modeBadge = pc.bgCyan(pc.bold(pc.black(' PLAN ')));
+    }
+    else {
+        modeBadge = pc.bgGreen(pc.bold(pc.black(' AGENT ')));
+    }
+    // Model shortening for narrow screens
+    let displayModel = opts.model;
+    if (cols < 75 && displayModel.length > 18) {
+        const parts = displayModel.split('/');
+        displayModel = parts.length > 1 ? parts.slice(1).join('/') : displayModel;
+        if (displayModel.length > 18) {
+            displayModel = displayModel.slice(0, 15) + '…';
+        }
+    }
+    // Git info
+    const git = GitStatusCache.getStatus();
+    const gitStr = git ? ` · ${pc.magenta(git.branch)}${git.isDirty ? pc.yellow('✱') : ''}` : '';
+    // Context progress
+    const usagePercent = Math.min(100, Math.round((opts.currentTokens / Math.max(1, opts.maxTokens)) * 100));
+    const barWidth = cols < 60 ? 6 : 10;
+    const progressStr = renderProgressBar(usagePercent, barWidth);
+    const costStr = formatCostBadge(opts.cost, opts.maxCostUSD);
+    if (cols < 65) {
+        // 2-line layout for mobile Termux
+        const line1 = `${modeBadge} ${pc.bold(displayModel)}${gitStr}`;
+        const line2 = `${pc.dim('│')}  Context ${progressStr} · ${costStr}`;
+        return `${line1}\n${line2}`;
+    }
+    // 1-line powerline layout for desktop
+    return `${modeBadge} ${pc.bold(displayModel)}${gitStr} · Context ${progressStr} · ${costStr}`;
+}

package/dist/cli/telemetry.js

@@ -0,0 +1,105 @@
+import pc from 'picocolors';
+export class LiveTelemetryTracker {
+    startTime = 0;
+    phase = 'connecting';
+    totalTokens = 0;
+    samples = [];
+    windowMs = 2000;
+    constructor(windowMs = 2000) {
+        this.windowMs = windowMs;
+    }
+    start(phase = 'connecting') {
+        this.startTime = Date.now();
+        this.phase = phase;
+        this.totalTokens = 0;
+        this.samples = [];
+    }
+    setPhase(phase) {
+        this.phase = phase;
+    }
+    recordTokens(count) {
+        if (count <= 0)
+            return;
+        const now = Date.now();
+        this.totalTokens += count;
+        this.samples.push({ timestamp: now, tokens: count });
+        this.pruneOldSamples(now);
+    }
+    estimateTokensFromText(text) {
+        if (!text)
+            return 0;
+        // Fast token estimation: ~0.8 tokens per Cyrillic char, ~0.25 per ASCII
+        let tokens = 0;
+        for (let i = 0; i < text.length; i++) {
+            const code = text.charCodeAt(i);
+            if (code >= 0x0400 && code <= 0x04ff) {
+                tokens += 0.8;
+            }
+            else if (code > 0x07ff) {
+                tokens += 1.2;
+            }
+            else {
+                tokens += 0.25;
+            }
+        }
+        return Math.max(1, Math.round(tokens));
+    }
+    pruneOldSamples(now) {
+        const threshold = now - this.windowMs;
+        while (this.samples.length > 0 && this.samples[0].timestamp < threshold) {
+            this.samples.shift();
+        }
+    }
+    getTokensPerSecond() {
+        const now = Date.now();
+        this.pruneOldSamples(now);
+        if (this.samples.length === 0)
+            return 0;
+        const windowTokens = this.samples.reduce((acc, s) => acc + s.tokens, 0);
+        const earliest = this.samples[0].timestamp;
+        const durationSec = Math.max(0.2, (now - earliest) / 1000);
+        return Math.round(windowTokens / durationSec);
+    }
+    getElapsedSeconds() {
+        if (this.startTime === 0)
+            return 0;
+        return Math.max(0, Math.round((Date.now() - this.startTime) / 1000));
+    }
+    getTotalTokens() {
+        return this.totalTokens;
+    }
+    static formatTokenCount(n) {
+        if (n >= 1_000_000)
+            return `${(n / 1_000_000).toFixed(1)}M`;
+        if (n >= 1_000)
+            return `${(n / 1_000).toFixed(1)}k`;
+        return `${Math.round(n)}`;
+    }
+    formatLabel() {
+        const secs = `${this.getElapsedSeconds()}s`;
+        const tokens = LiveTelemetryTracker.formatTokenCount(this.totalTokens);
+        const tps = this.getTokensPerSecond();
+        if (this.phase === 'connecting') {
+            return `connecting… ${pc.dim(secs)}`;
+        }
+        if (this.phase === 'thinking') {
+            if (this.totalTokens > 0) {
+                return `thinking… ${pc.dim(`${secs} · ${tokens} tok · ${tps} tok/s`)}`;
+            }
+            return `thinking… ${pc.dim(secs)}`;
+        }
+        if (this.phase === 'generating') {
+            if (this.totalTokens > 0) {
+                return `generating… ${pc.dim(`${secs} · ${tokens} tok · ${tps} tok/s`)}`;
+            }
+            return `generating… ${pc.dim(secs)}`;
+        }
+        return `executing… ${pc.dim(secs)}`;
+    }
+    reset() {
+        this.startTime = 0;
+        this.phase = 'connecting';
+        this.totalTokens = 0;
+        this.samples = [];
+    }
+}

package/dist/core/types.js

@@ -1 +1 @@
-export {};
+export const DEVX_VERSION = '1.5.0';

package/dist/mcp/client.js

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { DEVX_VERSION } from '../core/types.js';
 export class MCPClient {
     name;
     config;
@@ -63,7 +64,7 @@ export class MCPClient {
                     capabilities: {},
                     clientInfo: {
                         name: 'devx',
-                        version: '1.4.18'
+                        version: DEVX_VERSION
                     }
                 });
                 if (!initResult) {

package/dist/permissions/guard.js

@@ -25,14 +25,19 @@ function isDangerousBashCommand(commandStr) {
         return false;
     // Normalize whitespace: collapse multiple spaces/tabs into single space
     const norm = commandStr.toLowerCase().replace(/\s+/g, ' ').trim();
-    // Pattern matching rm with combined flags (-rf, -fr, -r -f, etc.) targeting root, home, termux prefix, or glob
-    const isDangerousRm = /rm\s+-(?:[a-z]*r[a-z]*f|[a-z]*f[a-z]*r)\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
-        /rm\s+-[a-z]*r[a-z]*\s+-[a-z]*f[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
-        /rm\s+-[a-z]*f[a-z]*\s+-[a-z]*r[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm);
+    // Pattern matching rm with combined flags (-rf, -fr, -r -f, etc.) targeting root, home, termux prefix, glob, or current/parent dir
+    const isDangerousRm = /rm\s+-(?:[a-z]*r[a-z]*f|[a-z]*f[a-z]*r)\s+(?:\/|\/\*|~|~\/|\*|\.|\.\/|\.\.\/?.*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
+        /rm\s+-[a-z]*r[a-z]*\s+-[a-z]*f[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\.|\.\/|\.\.\/?.*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
+        /rm\s+-[a-z]*f[a-z]*\s+-[a-z]*r[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\.|\.\/|\.\.\/?.*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm);
     return (isDangerousRm ||
         norm.includes('rm -rf /') ||
         norm.includes('rm -rf ~') ||
         norm.includes('rm -rf *') ||
+        norm.includes('rm -rf .') ||
+        norm.includes('rm -rf ./') ||
+        norm.includes('rm -rf ..') ||
+        norm.includes('rm -fr .') ||
+        norm.includes('rm -fr ./') ||
         norm.includes('rm -rf $prefix') ||
         norm.includes('rm -rf $home') ||
         norm.includes('rm -rf /data/data/com.termux') ||

package/dist/providers/openai.js

@@ -220,11 +220,12 @@ export class OpenAIProvider {
                     const trimmed = line.trim();
                     if (!trimmed || trimmed.startsWith(':'))
                         continue;
-                    if (trimmed === 'data: [DONE]')
-                        continue;
-                    if (trimmed.startsWith('data: ')) {
+                    if (trimmed.startsWith('data:')) {
+                        const dataPayload = trimmed.replace(/^data:\s*/, '');
+                        if (dataPayload === '[DONE]')
+                            continue;
                         try {
-                            const json = JSON.parse(trimmed.slice(6));
+                            const json = JSON.parse(dataPayload);
                             if (json.error) {
                                 const errMsg = json.error.message || json.error.code || JSON.stringify(json.error);
                                 throw new Error(`Provider Stream Error: ${errMsg}`);