termux-dev 1.0.2 → 1.1.0

package/README.md

@@ -7,8 +7,9 @@
 **Ultra-fast, autonomous AI pair-programmer & vibe-coding terminal agent.**  
 Built specifically for **Android Termux**, **Windows**, **macOS**, and **Linux**.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![npm version](https://img.shields.io/npm/v/termux-dev.svg?color=blue)](https://www.npmjs.com/package/termux-dev)
 [![CI](https://github.com/apvcode/Termux-Dev/actions/workflows/ci.yml/badge.svg)](https://github.com/apvcode/Termux-Dev/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D20.0.0-brightgreen.svg)](https://nodejs.org)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.4-blue.svg)](https://www.typescriptlang.org)
 [![Platform](https://img.shields.io/badge/Platform-Termux%20%7C%20Windows%20%7C%20macOS%20%7C%20Linux-orange.svg)](#)

package/assets/banner.svg

@@ -25,7 +25,7 @@
 
   <!-- Tagline & Badge -->
   <text x="425" y="142" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" fill="#8b949e" text-anchor="middle" letter-spacing="3">
-    THE TERMINAL-NATIVE AI CODING AGENT <tspan fill="#00f2fe" font-weight="bold">v1.0.2</tspan>
+    THE TERMINAL-NATIVE AI CODING AGENT <tspan fill="#00f2fe" font-weight="bold">v1.1.0</tspan>
   </text>
 
   <!-- Top Accent Line -->

package/dist/cli/index.js

@@ -20,6 +20,7 @@ import { ALL_PROVIDERS } from './providers.js';
 import { getModelContextLimit } from '../core/models.js';
 import { SessionManager } from '../core/session.js';
 import { MarkdownStreamer, renderMarkdown } from './markdown.js';
+import { SmoothStreamer } from './smooth.js';
 import { askPrompt } from './prompt.js';
 import { resolveAtMentions } from './files.js';
 import { runStartupUpdateCheck, checkForUpdates, performSelfUpdate } from './updater.js';
@@ -377,7 +378,7 @@ function drawLogo() {
             pc.cyan('  █▀▀▄ █▀▀▀ █   █ █   █'),
             pc.cyan('  █  █ █▀▀▀  ▀▄▀   ▀▄▀ '),
             pc.cyan('  █▄▄▀ █▄▄▄   ▀    ▀ ▀ '),
-            '  ' + pc.cyan(pc.bold('v1.0.2')),
+            '  ' + pc.cyan(pc.bold('v1.1.0')),
             ''
         ];
         for (const line of logo) {
@@ -392,7 +393,7 @@ function drawLogo() {
             indent + pc.cyan('▀▀▀█▀▀▀ █▀▀▀ █▀▀█ █▄ ▄█ █  █ ▀▄ ▄▀    █▀▀▄ █▀▀▀ █   █'),
             indent + pc.cyan('   █    █▀▀▀ █▄▄▀ █ █ █ █  █   █   ▀▀ █  █ █▀▀▀ █   █'),
             indent + pc.cyan('   █    █▄▄▄ █ ▀▄ █   █ ▀▄▄▀ ▄▀ ▀▄    █▄▄▀ █▄▄▄  ▀▄▀ '),
-            indent + pc.cyan(pc.bold('v1.0.2')),
+            indent + pc.cyan(pc.bold('v1.1.0')),
             ''
         ];
         for (const line of logo) {
@@ -587,7 +588,7 @@ export async function main() {
                         const maxIter = config.maxIterations || 100;
                         const maxIterLabel = maxIter >= 9999 ? 'Unlimited' : `${maxIter} steps`;
                         const choice = await select({
-                            message: `${pc.bold('⚙️  Settings')} ${pc.dim('(devx v1.0.2 • by ApvCode)')}`,
+                            message: `${pc.bold('⚙️  Settings')} ${pc.dim('(devx v1.1.0 • by ApvCode)')}`,
                             choices: [
                                 {
                                     name: `${config.pureBlackTheme !== false ? pc.green('🎨 Pure Black Background: ON') : pc.yellow('🎨 Pure Black Background: OFF')}`,
@@ -623,7 +624,7 @@ export async function main() {
                                     description: 'Limit how many tool steps (file edits, terminal commands) agent can do per request'
                                 },
                                 {
-                                    name: `${pc.cyan('✨ About devx')} ${pc.dim('(v1.0.2 by ApvCode)')}`,
+                                    name: `${pc.cyan('✨ About devx')} ${pc.dim('(v1.1.0 by ApvCode)')}`,
                                     value: 'about',
                                     description: 'Terminal-Native AI Coding Agent created by ApvCode (https://github.com/apvcode/Termux-Dev)'
                                 },
@@ -635,7 +636,7 @@ export async function main() {
                             ]
                         });
                         if (choice === 'about') {
-                            p.note(`⚡ devx v1.0.2 — Terminal-Native AI Coding Agent\n` +
+                            p.note(`⚡ devx v1.1.0 — Terminal-Native AI Coding Agent\n` +
                                 `👤 Author: ApvCode (https://github.com/apvcode)\n` +
                                 `🌟 Repository: https://github.com/apvcode/Termux-Dev\n` +
                                 `📜 License: MIT License (2026)\n` +
@@ -1276,9 +1277,13 @@ export async function main() {
         let thinkingStartTime = 0;
         let textActive = false;
         const streamer = new MarkdownStreamer();
+        const thoughtStreamer = new SmoothStreamer((chunk) => {
+            process.stdout.write(pc.dim(chunk));
+        });
         const finishThinking = (extraNewline = true) => {
             if (!thinkingActive)
                 return;
+            thoughtStreamer.flush();
             const elapsedSec = thinkingStartTime > 0 ? ((Date.now() - thinkingStartTime) / 1000).toFixed(1) : '0.0';
             const width = Math.min(process.stdout.columns || 40, 52);
             const label = `─── Thought for ${elapsedSec}s `;
@@ -1298,6 +1303,7 @@ export async function main() {
                 s.stop();
                 spinnerActive = false;
             }
+            thoughtStreamer.reset();
             finishThinking(true);
             streamer.finish();
             if (textActive) {
@@ -1338,7 +1344,7 @@ export async function main() {
                         process.stdout.write('\n' + pc.bold(pc.white('› Thought:')) + '\n');
                         thinkingActive = true;
                     }
-                    process.stdout.write(pc.dim(event.delta));
+                    thoughtStreamer.push(event.delta);
                 }
                 else if (event.type === 'text_delta') {
                     if (spinnerActive) {
@@ -1384,8 +1390,8 @@ export async function main() {
                         process.stdout.write('\n');
                         textActive = false;
                     }
-                    console.log(pc.cyan(`\n${event.actionDesc}`));
-                    if (event.name !== 'ask_questions') {
+                    console.log('\n' + pc.bold(pc.white(event.actionDesc)));
+                    if (event.name !== 'ask_questions' && event.name !== 'todo_list') {
                         s.start('Executing...');
                         spinnerActive = true;
                     }
@@ -1396,15 +1402,85 @@ export async function main() {
                         spinnerActive = false;
                     }
                     if (event.result) {
-                        const firstLine = event.result.trim().split('\n')[0];
-                        if (firstLine.includes('+') || firstLine.includes('lines') || firstLine.includes('Successfully')) {
-                            console.log(pc.green(`  └─ ${firstLine}`));
+                        try {
+                            const parsed = JSON.parse(event.result);
+                            if (parsed.type === 'todo_list' && parsed.displayCard) {
+                                process.stdout.write(parsed.displayCard);
+                            }
+                            else if (parsed.action === 'edit' && parsed.diffLines) {
+                                const cols = Math.min(process.stdout.columns || 80, 80);
+                                const borderChar = '─';
+                                const boxWidth = Math.max(20, Math.min(cols - 4, 66));
+                                console.log(pc.dim('┌' + borderChar.repeat(boxWidth) + '┐'));
+                                const maxShown = Math.min(parsed.diffLines.length, 12);
+                                for (let i = 0; i < maxShown; i++) {
+                                    const line = parsed.diffLines[i];
+                                    if (line.includes(' -  ')) {
+                                        console.log(pc.dim('│ ') + pc.red(line));
+                                    }
+                                    else if (line.includes(' +  ')) {
+                                        console.log(pc.dim('│ ') + pc.green(line));
+                                    }
+                                    else {
+                                        console.log(pc.dim('│ ') + pc.white(line));
+                                    }
+                                }
+                                if (parsed.diffLines.length > maxShown) {
+                                    console.log(pc.dim(`│ ... +${parsed.diffLines.length - maxShown} more lines`));
+                                }
+                                console.log(pc.dim('└' + borderChar.repeat(boxWidth) + '┘'));
+                                console.log(pc.green(`  └─ ${parsed.summary}`));
+                            }
+                            else if (parsed.summary) {
+                                console.log(pc.green(`  └─ ${parsed.summary}`));
+                            }
+                            else {
+                                const firstLine = event.result.trim().split('\n')[0];
+                                if (firstLine.includes('+') || firstLine.includes('lines') || firstLine.includes('Successfully')) {
+                                    console.log(pc.green(`  └─ ${firstLine}`));
+                                }
+                            }
+                        }
+                        catch {
+                            const firstLine = event.result.trim().split('\n')[0];
+                            if (firstLine.includes('+') || firstLine.includes('lines') || firstLine.includes('Successfully')) {
+                                console.log(pc.green(`  └─ ${firstLine}`));
+                            }
                         }
                     }
                 }
                 else if (event.type === 'usage') {
                     totalSessionCost += event.usage.cost || 0;
                 }
+                else if (event.type === 'reconnecting') {
+                    if (spinnerActive) {
+                        s.stop();
+                        spinnerActive = false;
+                    }
+                    if (thinkingActive) {
+                        finishThinking(false);
+                    }
+                    if (textActive) {
+                        process.stdout.write('\n');
+                        textActive = false;
+                    }
+                    streamer.reset();
+                    console.log();
+                    console.log(pc.bold(pc.yellow(`⚠️  Интернет-соединение нестабильно (${event.reason})`)));
+                    console.log(pc.cyan(`🔄 Попытка переподключения [${event.attempt}/${event.maxAttempts}] (пауза ${(event.delayMs / 1000).toFixed(1)}с)...`));
+                    s.start(pc.cyan(`Ожидание сети [${event.attempt}/${event.maxAttempts}]...`));
+                    spinnerActive = true;
+                }
+                else if (event.type === 'reconnected') {
+                    if (spinnerActive) {
+                        s.stop();
+                        spinnerActive = false;
+                    }
+                    console.log(pc.bold(pc.green(`✔ Соединение восстановлено! Возобновляем генерацию...`)));
+                    console.log();
+                    s.start('Connecting...');
+                    spinnerActive = true;
+                }
                 else if (event.type === 'error') {
                     if (spinnerActive) {
                         s.stop();

package/dist/cli/markdown.js

@@ -28,10 +28,38 @@ export class MarkdownStreamer {
     tableBuffer = [];
     push(chunk) {
         this.buffer += chunk;
-        const lines = this.buffer.split('\n');
-        this.buffer = lines.pop() || '';
-        for (const line of lines) {
-            this.processLine(line);
+        // 1. Process completed lines
+        if (this.buffer.includes('\n')) {
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() || '';
+            for (const line of lines) {
+                this.processLine(line);
+            }
+        }
+        // 2. Stream regular prose words immediately in real-time
+        if (!this.inCodeBlock && !this.inTable && this.buffer.length > 0) {
+            const trimmed = this.buffer.trimStart();
+            const isSpecialLine = trimmed.startsWith('#') ||
+                trimmed.startsWith('|') ||
+                trimmed.startsWith('```') ||
+                trimmed.startsWith('- [') ||
+                trimmed.startsWith('* [') ||
+                trimmed.startsWith('[') ||
+                trimmed.startsWith('→') ||
+                trimmed.startsWith('- ') ||
+                trimmed.startsWith('* ') ||
+                /^\d+\.\s/.test(trimmed) ||
+                trimmed.startsWith('> ') ||
+                trimmed === '---' ||
+                trimmed === '***';
+            if (!isSpecialLine) {
+                const lastSpaceIdx = Math.max(this.buffer.lastIndexOf(' '), this.buffer.lastIndexOf('\t'));
+                if (lastSpaceIdx > 0) {
+                    const wordsToFlush = this.buffer.slice(0, lastSpaceIdx + 1);
+                    this.buffer = this.buffer.slice(lastSpaceIdx + 1);
+                    process.stdout.write(this.formatInline(wordsToFlush));
+                }
+            }
         }
     }
     processLine(line) {
@@ -67,7 +95,28 @@ export class MarkdownStreamer {
             this.flushTable();
             this.inTable = false;
         }
-        // 4. Regular line fast formatting (Headers, Bullets, Bold, Dims)
+        // 4. OpenCode Checklists & Todos ([✓], [ ], [/], [>])
+        const todoMatch = trimmed.match(/^(\s*(?:[-*]\s*)?)\[([ x✓X>/])\]\s*(.*)$/);
+        if (todoMatch) {
+            const mark = todoMatch[2].toLowerCase();
+            const taskText = this.formatInline(todoMatch[3]);
+            if (mark === 'x' || mark === '✓') {
+                process.stdout.write('  ' + pc.green('[✓] ') + pc.dim(taskText) + '\n');
+            }
+            else if (mark === '/' || mark === '>') {
+                process.stdout.write('  ' + pc.bold(pc.green('[ ] ' + taskText)) + '\n');
+            }
+            else {
+                process.stdout.write('  ' + pc.dim('[ ] ') + pc.white(taskText) + '\n');
+            }
+            return;
+        }
+        // 5. OpenCode Action arrows (→ Read ..., → Edit ...)
+        if (trimmed.startsWith('→ ')) {
+            process.stdout.write(pc.bold(pc.cyan('→ ')) + pc.white(this.formatInline(trimmed.slice(2))) + '\n');
+            return;
+        }
+        // 6. Regular line fast formatting (Headers, Bullets, Bold, Dims)
         if (trimmed.startsWith('# ')) {
             process.stdout.write('\n' + pc.bold(pc.cyan(trimmed.slice(2))) + '\n\n');
         }
@@ -123,6 +172,13 @@ export class MarkdownStreamer {
             this.tableBuffer = [];
         }
     }
+    reset() {
+        this.buffer = '';
+        this.inCodeBlock = false;
+        this.codeBlockLang = '';
+        this.inTable = false;
+        this.tableBuffer = [];
+    }
     finish() {
         if (this.buffer) {
             const trimmed = this.buffer.trim();

package/dist/cli/smooth.js

@@ -0,0 +1,77 @@
+/**
+ * High-performance fluid token streamer for terminal vibe-coding.
+ * Turns jerky SSE network chunk bursts into buttery-smooth word-by-word and character-by-character flow.
+ */
+export class SmoothStreamer {
+    queue = [];
+    timer = null;
+    onWrite;
+    constructor(onWrite) {
+        this.onWrite = onWrite;
+    }
+    push(text) {
+        if (!text)
+            return;
+        this.queue.push(text);
+        if (!this.timer) {
+            this.startLoop();
+        }
+    }
+    startLoop() {
+        this.timer = setInterval(() => {
+            this.tick();
+        }, 10);
+    }
+    tick() {
+        if (this.queue.length === 0) {
+            if (this.timer) {
+                clearInterval(this.timer);
+                this.timer = null;
+            }
+            return;
+        }
+        const fullStr = this.queue.join('');
+        this.queue = [];
+        // Adaptive chunk size based on remaining buffer backlog:
+        // Small backlog (< 30 chars) -> 3-6 chars / tick (~60-100 fps typing effect)
+        // Medium backlog (30-100 chars) -> 12-20 chars / tick
+        // Large backlog (> 100 chars) -> flush 50-100 chars / tick (never lags behind fast LLMs)
+        let take = 4;
+        if (fullStr.length > 200) {
+            take = fullStr.length;
+        }
+        else if (fullStr.length > 100) {
+            take = 25;
+        }
+        else if (fullStr.length > 40) {
+            take = 10;
+        }
+        else {
+            take = 4;
+        }
+        const chunk = fullStr.slice(0, take);
+        const rest = fullStr.slice(take);
+        if (rest) {
+            this.queue.unshift(rest);
+        }
+        this.onWrite(chunk);
+    }
+    flush() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.queue.length > 0) {
+            const remaining = this.queue.join('');
+            this.queue = [];
+            this.onWrite(remaining);
+        }
+    }
+    reset() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.queue = [];
+    }
+}

package/dist/core/loop.js

@@ -1,33 +1,40 @@
+import { isNetworkOrRetryableError, getHumanReadableNetworkError, waitDelay } from './network.js';
 function getActionDescription(toolName, args) {
     const t = toolName.toLowerCase();
     if (t === 'read_file' || t === 'view_file' || t === 'read') {
-        return `📖 Reading: ${args.path || args.filePath || args.targetFile || ''}`;
+        return `→ Read ${args.path || args.filePath || args.targetFile || ''}`;
     }
     if (t === 'write_file' || t === 'create_file' || t === 'write_to_file' || t === 'write') {
-        return `📝 Writing: ${args.path || args.filePath || args.targetFile || ''}`;
+        return `→ Write ${args.path || args.filePath || args.targetFile || ''}`;
     }
     if (t === 'edit_file' || t === 'replace_file_content' || t === 'patch') {
-        return `✏️ Editing: ${args.path || args.filePath || args.targetFile || ''}`;
+        return `→ Edit ${args.path || args.filePath || args.targetFile || ''}`;
     }
     if (t === 'delete_file' || t === 'remove_file' || t === 'rm') {
-        return `🗑️ Deleting: ${args.path || args.filePath || ''}`;
+        return `→ Delete ${args.path || args.filePath || ''}`;
     }
     if (t === 'make_dir' || t === 'mkdir') {
-        return `📁 Creating directory: ${args.path || args.dirPath || ''}`;
+        return `→ Mkdir ${args.path || args.dirPath || ''}`;
     }
     if (t === 'list_dir' || t === 'list_files' || t === 'find_files' || t === 'ls') {
-        return `📂 Listing: ${args.path || args.dirPath || '.'}`;
+        return `→ List ${args.path || args.dirPath || '.'}`;
     }
     if (t === 'search' || t === 'grep_search' || t === 'grep') {
-        return `🔍 Searching: "${args.query || args.pattern || ''}" in ${args.dir || args.path || '.'}`;
+        return `→ Search "${args.query || args.pattern || ''}" in ${args.dir || args.path || '.'}`;
     }
     if (t === 'ask_questions' || t === 'questions') {
-        return `📋 Asking clarifying questions...`;
+        return `→ Clarify: Asking questions...`;
     }
     if (t === 'bash' || t === 'execute_command' || t === 'run_command' || t === 'exec') {
-        return `⚡ Running command: ${args.command || args.cmd || ''}`;
+        return `→ Run: ${args.command || args.cmd || ''}`;
     }
-    return `🔧 Executing ${toolName}...`;
+    if (t === 'todo_list' || t === 'update_todos') {
+        return `→ Update Plan & Tasks`;
+    }
+    if (t === 'plan_ready') {
+        return `→ Finalize Plan`;
+    }
+    return `→ Executing ${toolName}...`;
 }
 export class Agent {
     config;
@@ -61,36 +68,68 @@ export class Agent {
                 delete request.tools;
             }
             let response;
-            try {
-                if (this.provider.chatStream) {
-                    for await (const chunk of this.provider.chatStream(request)) {
-                        if (signal?.aborted) {
-                            return;
-                        }
-                        if (chunk.type === 'reasoning_delta') {
-                            yield { type: 'reasoning_delta', delta: chunk.delta };
-                        }
-                        else if (chunk.type === 'content_delta') {
-                            yield { type: 'text_delta', delta: chunk.delta };
-                        }
-                        else if (chunk.type === 'tool_generating') {
-                            yield { type: 'tool_generating', name: chunk.name, bytes: chunk.bytes };
+            let attempt = 0;
+            const maxRetries = 4;
+            while (true) {
+                if (signal?.aborted)
+                    return;
+                try {
+                    if (this.provider.chatStream) {
+                        let receivedAnyChunk = false;
+                        for await (const chunk of this.provider.chatStream(request)) {
+                            if (signal?.aborted) {
+                                return;
+                            }
+                            receivedAnyChunk = true;
+                            if (chunk.type === 'reasoning_delta') {
+                                yield { type: 'reasoning_delta', delta: chunk.delta };
+                            }
+                            else if (chunk.type === 'content_delta') {
+                                yield { type: 'text_delta', delta: chunk.delta };
+                            }
+                            else if (chunk.type === 'tool_generating') {
+                                yield { type: 'tool_generating', name: chunk.name, bytes: chunk.bytes };
+                            }
+                            else if (chunk.type === 'done') {
+                                response = chunk.response;
+                            }
                         }
-                        else if (chunk.type === 'done') {
-                            response = chunk.response;
+                        if (response || receivedAnyChunk) {
+                            break;
                         }
                     }
+                    else {
+                        response = await this.provider.chat(request);
+                        break;
+                    }
                 }
-                else {
-                    response = await this.provider.chat(request);
-                }
-            }
-            catch (err) {
-                if (signal?.aborted || err.name === 'AbortError' || err.message?.includes('aborted')) {
+                catch (err) {
+                    if (signal?.aborted || err.name === 'AbortError' || err.message?.includes('aborted')) {
+                        return;
+                    }
+                    const isNetwork = isNetworkOrRetryableError(err);
+                    if (isNetwork && attempt < maxRetries) {
+                        attempt++;
+                        const delayMs = Math.min(1500 * Math.pow(1.5, attempt - 1), 8000);
+                        yield {
+                            type: 'reconnecting',
+                            attempt,
+                            maxAttempts: maxRetries,
+                            delayMs,
+                            reason: getHumanReadableNetworkError(err)
+                        };
+                        await waitDelay(delayMs, signal);
+                        if (signal?.aborted)
+                            return;
+                        yield { type: 'reconnected', attempt };
+                        continue;
+                    }
+                    const errMsg = isNetwork
+                        ? `Ошибка сети: Не удалось восстановить интернет-соединение после ${attempt} попыток (${err.message}).`
+                        : `API Error: ${err.message}`;
+                    yield { type: 'error', message: errMsg, isFatal: true };
                     return;
                 }
-                yield { type: 'error', message: `API Error: ${err.message}`, isFatal: true };
-                return;
             }
             if (signal?.aborted) {
                 return;

package/dist/core/network.js

@@ -0,0 +1,129 @@
+/**
+ * Network Resilience & Error Utilities for devx
+ */
+export function isNetworkOrRetryableError(err) {
+    if (!err)
+        return false;
+    const msg = (err.message || String(err)).toLowerCase();
+    const code = (err.code || err.cause?.code || '').toLowerCase();
+    const status = err.status || err.statusCode || 0;
+    // HTTP status codes that are retryable (Rate limits, server errors, timeouts)
+    if (status === 429 ||
+        status === 500 ||
+        status === 502 ||
+        status === 503 ||
+        status === 504 ||
+        status === 520 ||
+        status === 521 ||
+        status === 522 ||
+        status === 524) {
+        return true;
+    }
+    // Network / Socket error codes
+    const networkCodes = [
+        'econnreset',
+        'etimedout',
+        'enotfound',
+        'econnrefused',
+        'ehostunreach',
+        'enetunreach',
+        'eai_again',
+        'und_err_socket',
+        'und_err_connect_timeout',
+        'und_err_headers_timeout',
+        'und_err_body_timeout',
+        'und_err_request_timeout',
+        'err_network'
+    ];
+    if (networkCodes.some(c => code.includes(c))) {
+        return true;
+    }
+    // Common network error messages & fragments
+    const networkPatterns = [
+        'fetch failed',
+        'terminated',
+        'socket hang up',
+        'network error',
+        'network timeout',
+        'failed to fetch',
+        'premature close',
+        'other side closed',
+        'connection reset',
+        'connection refused',
+        'timeout',
+        'time out',
+        'econnreset',
+        'etimedout',
+        'enotfound',
+        'dns lookup',
+        'temporary failure',
+        'server error',
+        'bad gateway',
+        'gateway timeout',
+        'overloaded',
+        'service unavailable',
+        'empty stream',
+        'connection closed before receiving response',
+        'rate limit'
+    ];
+    return networkPatterns.some(p => msg.includes(p));
+}
+export function getHumanReadableNetworkError(err) {
+    if (!err)
+        return 'Неизвестная ошибка сети (Network error)';
+    const msg = (err.message || String(err)).toLowerCase();
+    const code = (err.code || err.cause?.code || '').toLowerCase();
+    const status = err.status || err.statusCode || 0;
+    if (status === 429 || msg.includes('429') || msg.includes('rate limit')) {
+        return 'Превышен лимит запросов API (Rate limit / 429)';
+    }
+    if (status === 502 || msg.includes('502') || msg.includes('bad gateway')) {
+        return 'Шлюз провайдера временно недоступен (Bad Gateway / 502)';
+    }
+    if (status === 503 || msg.includes('503') || msg.includes('service unavailable')) {
+        return 'Сервер провайдера перегружен (Service Unavailable / 503)';
+    }
+    if (status === 504 || msg.includes('504') || msg.includes('gateway timeout')) {
+        return 'Таймаут шлюза провайдера (Gateway Timeout / 504)';
+    }
+    if (code.includes('enotfound') || msg.includes('enotfound') || code.includes('eai_again')) {
+        return 'Нет подключения к сети или DNS (Host not found / Offline)';
+    }
+    if (code.includes('econnreset') ||
+        msg.includes('econnreset') ||
+        msg.includes('connection reset') ||
+        msg.includes('socket hang up') ||
+        msg.includes('terminated')) {
+        return 'Обрыв соединения с сервером (Connection reset / Socket closed)';
+    }
+    if (code.includes('etimedout') ||
+        msg.includes('timeout') ||
+        msg.includes('time out') ||
+        code.includes('und_err_connect_timeout')) {
+        return 'Таймаут сетевого соединения (Network timeout)';
+    }
+    if (code.includes('econnrefused') || msg.includes('connection refused')) {
+        return 'Сервер отклонил подключение (Connection refused)';
+    }
+    if (msg.includes('fetch failed')) {
+        return 'Сбой сетевого соединения (Fetch failed / Connection dropped)';
+    }
+    return err.message || 'Сбой интернет-соединения';
+}
+export function waitDelay(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(() => {
+            resolve();
+        }, ms);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                clearTimeout(timer);
+                resolve();
+            }, { once: true });
+        }
+    });
+}

package/dist/prompts/builder.js

@@ -20,17 +20,23 @@ export async function buildSystemPrompt(planMode) {
         prompt += `   - Whenever you want to ask the user ANY question, clarify requirements, or get choices (genre, stack, mechanics, UI, design), you MUST NEVER write questions as plain text in your markdown output!\n`;
         prompt += `   - You MUST call the 'ask_questions' tool function call with the list of questions and options.\n`;
         prompt += `   - Outputting numbered questions in plain markdown text without calling 'ask_questions' is strictly prohibited.\n`;
-        prompt += `5. FORMULATING THE PLAN: Deeply analyze the problem, consider edge cases, and design a solid, clean, step-by-step plan. Present a structured **FINAL PLAN** in your response:\n`;
-        prompt += `   - **🎯 Цель и архитектурный обзор**\n`;
-        prompt += `   - **📁 Пошаговый список изменений по файлам (какие файлы создаём/правим и какую логику реализуем в них, БЕЗ написания полного кода)**\n`;
-        prompt += `   - **🧪 План тестирования и проверки**\n`;
-        prompt += `6. CALL 'plan_ready' TOOL: When your architectural plan is finalized and ready for execution, you MUST call the 'plan_ready' tool with the summary, target files list, and roadmap steps. Do NOT ask the user to type trigger words (like "начинай", "делай", "выполняй") — devx automatically presents the user with an interactive [🚀 Go / ✏️ Other] selection!\n`;
-        prompt += `7. EXECUTION TRIGGER: When the user confirms with [🚀 Go], devx switches to AGENT mode and sends "Go!" to begin implementing the approved plan.\n`;
+        prompt += `5. FORMULATING THE PLAN & TODO LIST:\n`;
+        prompt += `   - For multi-step tasks, formulate a clear, actionable todo checklist using the 'todo_list' tool or markdown checkboxes:\n`;
+        prompt += `     [ ] Step 1 description\n`;
+        prompt += `     [ ] Step 2 description\n`;
+        prompt += `   - Present a structured **FINAL PLAN** in your response:\n`;
+        prompt += `     - **🎯 Цель и архитектурный обзор**\n`;
+        prompt += `     - **📁 Пошаговый список изменений по файлам** (какие файлы создаём/правим и какую логику реализуем в них, БЕЗ полного кода)\n`;
+        prompt += `     - **🧪 План тестирования и проверки**\n`;
+        prompt += `6. CALL 'plan_ready' TOOL: When your architectural plan is finalized and ready for execution, call the 'plan_ready' tool. Do NOT ask the user to type trigger words — devx automatically presents the user with an interactive [🚀 Go / ✏️ Other] prompt!\n`;
+        prompt += `7. EXECUTION TRIGGER: When the user confirms with [🚀 Go], devx switches to AGENT mode to begin implementing the approved plan.\n`;
     }
     else {
         prompt += `MODE: AGENT (CODER / EXECUTOR MODE)\n`;
         prompt += `You are in AGENT mode. You have full access to bash, file creation, editing, package installation, diagnostics, and search tools.\n`;
-        prompt += `Execute tasks and approved plans step by step with high code quality.\n`;
+        prompt += `EXECUTION & TODO PROGRESS TRACKING:\n`;
+        prompt += `- For multi-step tasks, you can use the 'todo_list' tool to update the live task checklist, marking finished steps as 'completed' ([✓]) and the active step as 'in_progress' ([ ]).\n`;
+        prompt += `- Execute tasks and approved plans step by step with high code quality.\n`;
         prompt += `SELF-HEALING & VERIFICATION:\n`;
         prompt += `- Whenever you modify or create files, use the 'diagnose_code' tool to check for any syntax or type errors.\n`;
         prompt += `- If any error is found, automatically fix it with 'edit_file' until all diagnostics pass cleanly.\n`;

package/dist/providers/openai.js

@@ -91,7 +91,9 @@ export class OpenAIProvider {
                 }
             }
             catch { }
-            throw new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
+            const err = new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
+            err.status = res.status;
+            throw err;
         }
         const data = await res.json();
         if (data.error) {
@@ -152,7 +154,9 @@ export class OpenAIProvider {
                 }
             }
             catch { }
-            throw new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
+            const err = new Error(`Provider HTTP Error ${res.status}: ${errMsg}`);
+            err.status = res.status;
+            throw err;
         }
         const reader = res.body?.getReader();
         if (!reader) {

package/dist/tools/fs.js

@@ -65,12 +65,24 @@ export const writeFileTool = {
             await fs.writeFile(args.path, args.content, 'utf8');
             const newLines = args.content.split('\n').length;
             if (!existed) {
-                return `Successfully created ${args.path} (+${newLines} lines)`;
+                return JSON.stringify({
+                    status: 'success',
+                    action: 'create',
+                    path: args.path,
+                    addedCount: newLines,
+                    summary: `Successfully created ${args.path} (+${newLines} lines)`
+                });
             }
             else {
                 const diff = newLines - oldLines;
                 const diffStr = diff >= 0 ? `+${diff}` : `${diff}`;
-                return `Successfully updated ${args.path} (${diffStr} lines, ${newLines} total)`;
+                return JSON.stringify({
+                    status: 'success',
+                    action: 'write',
+                    path: args.path,
+                    addedCount: newLines,
+                    summary: `Successfully updated ${args.path} (${diffStr} lines, ${newLines} total)`
+                });
             }
         }
         catch (err) {
@@ -118,11 +130,29 @@ export const editFileTool = {
                     throw new Error(`Target text to replace was not found in ${args.path}. Ensure exact indentation and characters match.`);
                 }
             }
+            const targetIndex = content.indexOf(target);
+            const startLine = content.slice(0, targetIndex).split('\n').length;
+            const removedArr = target.split('\n');
+            const addedArr = args.replacement.split('\n');
+            const diffLines = [];
+            removedArr.forEach((l, i) => {
+                diffLines.push(`${startLine + i} -  ${l}`);
+            });
+            addedArr.forEach((l, i) => {
+                diffLines.push(`${startLine + i} +  ${l}`);
+            });
             const newContent = content.replace(target, args.replacement);
             await fs.writeFile(args.path, newContent, 'utf8');
-            const removedLines = target.split('\n').length;
-            const addedLines = args.replacement.split('\n').length;
-            return `Successfully edited ${args.path} (+${addedLines} -${removedLines} lines)`;
+            return JSON.stringify({
+                status: 'success',
+                action: 'edit',
+                path: args.path,
+                startLine,
+                removedCount: removedArr.length,
+                addedCount: addedArr.length,
+                diffLines,
+                summary: `Successfully edited ${args.path} (+${addedArr.length} -${removedArr.length} lines)`
+            });
         }
         catch (err) {
             throw new Error(`Failed to edit file: ${err.message}`);

package/dist/tools/index.js

@@ -7,11 +7,12 @@ import { diagnoseCodeTool } from './diagnostics.js';
 import { installPackageTool } from './packages.js';
 import { saveMemoryTool } from '../core/memory.js';
 import { planReadyTool, lastPlanReady, resetPlanReady } from './plan.js';
+import { todoListTool, currentTodoList, resetTodoList } from './todo.js';
 export function getTools(planMode) {
-    const baseTools = [readFileTool, listDirTool, searchTool, askQuestionsTool, webSearchTool, fetchUrlTool, saveMemoryTool, planReadyTool];
+    const baseTools = [readFileTool, listDirTool, searchTool, askQuestionsTool, webSearchTool, fetchUrlTool, saveMemoryTool, planReadyTool, todoListTool];
     if (planMode) {
         return baseTools;
     }
     return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, diagnoseCodeTool, installPackageTool];
 }
-export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady };
+export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady, todoListTool, currentTodoList, resetTodoList };

package/dist/tools/todo.js

@@ -0,0 +1,79 @@
+import pc from 'picocolors';
+export let currentTodoList = [];
+export function resetTodoList() {
+    currentTodoList = [];
+}
+export function formatTodoListCard(tasks) {
+    if (!tasks || tasks.length === 0)
+        return '';
+    const cols = Math.min(process.stdout.columns || 80, 80);
+    const boxWidth = Math.max(30, Math.min(cols - 4, 65));
+    const borderChar = '─';
+    const lines = [];
+    lines.push('\n' + pc.bold(pc.cyan('┌─ 📋 Plan & Tasks ' + borderChar.repeat(Math.max(2, boxWidth - 19)) + '┐')));
+    for (const task of tasks) {
+        let taskLine = '';
+        if (task.status === 'completed') {
+            taskLine = pc.green('[✓] ') + pc.dim(task.text);
+        }
+        else if (task.status === 'in_progress') {
+            taskLine = pc.bold(pc.green('[ ] ' + task.text));
+        }
+        else {
+            taskLine = pc.dim('[ ] ') + pc.white(task.text);
+        }
+        lines.push(pc.cyan('│ ') + taskLine);
+    }
+    lines.push(pc.cyan('└' + borderChar.repeat(boxWidth) + '┘\n'));
+    return lines.join('\n');
+}
+export const todoListTool = {
+    name: 'todo_list',
+    definition: {
+        name: 'todo_list',
+        description: 'Update the live interactive task checklist. Use this to plan multi-step implementations, mark completed steps as "completed", and set the current active step to "in_progress".',
+        parameters: {
+            type: 'object',
+            properties: {
+                tasks: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            text: {
+                                type: 'string',
+                                description: 'Short, clear description of the task step'
+                            },
+                            status: {
+                                type: 'string',
+                                enum: ['pending', 'in_progress', 'completed'],
+                                description: 'Current status of the task'
+                            }
+                        },
+                        required: ['text', 'status']
+                    },
+                    description: 'The updated list of tasks'
+                }
+            },
+            required: ['tasks']
+        }
+    },
+    validateArgs: (args) => {
+        if (!args || !Array.isArray(args.tasks)) {
+            throw new Error('tasks must be an array of task objects');
+        }
+    },
+    execute: async (args) => {
+        currentTodoList = args.tasks;
+        const card = formatTodoListCard(args.tasks);
+        const completedCount = args.tasks.filter(t => t.status === 'completed').length;
+        const totalCount = args.tasks.length;
+        return JSON.stringify({
+            status: 'success',
+            type: 'todo_list',
+            tasks: args.tasks,
+            displayCard: card,
+            summary: `Updated plan progress: ${completedCount}/${totalCount} tasks completed`
+        });
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Ultra-fast, terminal-native AI coding assistant and agent built for Android Termux, Windows, macOS, and Linux.",
   "main": "dist/cli/index.js",
   "type": "module",