termux-dev 1.1.2 → 1.2.0

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.1.2</tspan>
+    THE TERMINAL-NATIVE AI CODING AGENT <tspan fill="#00f2fe" font-weight="bold">v1.2.0</tspan>
   </text>
 
   <!-- Top Accent Line -->

package/dist/cli/doctor.js

@@ -0,0 +1,141 @@
+import os from 'os';
+import { execSync } from 'child_process';
+import https from 'https';
+import pc from 'picocolors';
+import { getCurrentTheme } from './theme.js';
+import { isTermux } from '../core/notify.js';
+function checkCmd(cmd) {
+    try {
+        const out = execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' }).trim();
+        return out.split('\n')[0];
+    }
+    catch {
+        return null;
+    }
+}
+async function pingUrl(url) {
+    return new Promise((resolve) => {
+        const req = https.get(url, { timeout: 3000 }, (res) => {
+            resolve(res.statusCode !== undefined);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+export async function runDoctor(config) {
+    const theme = getCurrentTheme();
+    console.log('\n' + theme.boldFn('🩺 devx Doctor — System & Environment Health Diagnostics'));
+    console.log(pc.dim('──────────────────────────────────────────────────────────────────'));
+    const envChecks = [];
+    const toolChecks = [];
+    const keyChecks = [];
+    const netChecks = [];
+    // 1. Environment Checks
+    const nodeVer = process.version;
+    const nodeMajor = parseInt(nodeVer.replace(/^v/, '').split('.')[0], 10);
+    envChecks.push({
+        name: 'Node.js Runtime',
+        status: nodeMajor >= 20 ? 'ok' : 'warn',
+        details: `${nodeVer} (Recommended: >= 20.0)`
+    });
+    const termux = isTermux();
+    envChecks.push({
+        name: 'Platform / Environment',
+        status: 'ok',
+        details: termux ? 'Android (Termux ARM64)' : `${os.platform()} ${os.arch()} (${os.release()})`
+    });
+    const cwd = process.cwd();
+    envChecks.push({
+        name: 'Working Directory',
+        status: 'ok',
+        details: cwd
+    });
+    // 2. Essential Tools
+    const gitVer = checkCmd('git --version');
+    toolChecks.push({
+        name: 'Git VCS',
+        status: gitVer ? 'ok' : 'warn',
+        details: gitVer || 'Not installed (some git features disabled)'
+    });
+    const npmVer = checkCmd('npm --version');
+    toolChecks.push({
+        name: 'NPM Package Manager',
+        status: npmVer ? 'ok' : 'warn',
+        details: npmVer ? `v${npmVer}` : 'Not installed'
+    });
+    const pythonVer = checkCmd('python --version') || checkCmd('python3 --version');
+    toolChecks.push({
+        name: 'Python Runtime',
+        status: pythonVer ? 'ok' : 'warn',
+        details: pythonVer || 'Optional (not found)'
+    });
+    const cCompiler = checkCmd('clang --version') || checkCmd('gcc --version');
+    toolChecks.push({
+        name: 'C/C++ Compiler',
+        status: cCompiler ? 'ok' : 'warn',
+        details: cCompiler ? cCompiler.split(' ')[0] : 'Optional (not found)'
+    });
+    // 3. AI Providers & Keys
+    const activeProvider = config.provider || 'openrouter';
+    const hasActiveKey = !!config.apiKey;
+    keyChecks.push({
+        name: `Active Provider (${activeProvider})`,
+        status: hasActiveKey ? 'ok' : 'fail',
+        details: hasActiveKey ? `Configured (Model: ${config.model})` : 'Missing API Key! Set via /provider or ~/.devxrc.json'
+    });
+    const envOpenRouter = !!process.env.OPENROUTER_API_KEY;
+    const envOpenAI = !!process.env.OPENAI_API_KEY;
+    const envAnthropic = !!process.env.ANTHROPIC_API_KEY;
+    const envGoogle = !!process.env.GEMINI_API_KEY;
+    keyChecks.push({
+        name: 'OpenRouter Key',
+        status: envOpenRouter || config.provider === 'openrouter' && hasActiveKey ? 'ok' : 'warn',
+        details: envOpenRouter || (config.provider === 'openrouter' && hasActiveKey) ? 'Configured' : 'Not set'
+    });
+    keyChecks.push({
+        name: 'OpenAI / Gemini / Anthropic Keys',
+        status: envOpenAI || envAnthropic || envGoogle ? 'ok' : 'warn',
+        details: [envOpenAI && 'OpenAI', envAnthropic && 'Anthropic', envGoogle && 'Gemini'].filter(Boolean).join(', ') || 'Not set in env (using default provider)'
+    });
+    // 4. Network Connectivity
+    const openRouterOnline = await pingUrl('https://openrouter.ai');
+    netChecks.push({
+        name: 'OpenRouter API Connectivity',
+        status: openRouterOnline ? 'ok' : 'warn',
+        details: openRouterOnline ? 'Online (HTTP 200/reachable)' : 'Unreachable (check VPN/DNS/WiFi)'
+    });
+    const githubOnline = await pingUrl('https://api.github.com');
+    netChecks.push({
+        name: 'GitHub API (for updater)',
+        status: githubOnline ? 'ok' : 'warn',
+        details: githubOnline ? 'Online (reachable)' : 'Unreachable'
+    });
+    // Helper to render section
+    const renderSection = (title, items) => {
+        console.log('\n' + theme.colorFn(pc.bold(`• ${title}`)));
+        for (const item of items) {
+            let icon = pc.green('✔');
+            if (item.status === 'warn')
+                icon = pc.yellow('▲');
+            if (item.status === 'fail')
+                icon = pc.red('✖');
+            console.log(`  ${icon} ${pc.bold(item.name)}: ${pc.dim(item.details)}`);
+        }
+    };
+    renderSection('Environment & OS', envChecks);
+    renderSection('Developer Tools', toolChecks);
+    renderSection('AI Configuration & Keys', keyChecks);
+    renderSection('Network Connectivity', netChecks);
+    console.log('\n' + pc.dim('──────────────────────────────────────────────────────────────────'));
+    const hasFailures = [...envChecks, ...toolChecks, ...keyChecks, ...netChecks].some(i => i.status === 'fail');
+    if (hasFailures) {
+        console.log(pc.red(pc.bold('⚠ Doctor found critical issues that might prevent devx from functioning properly.')));
+    }
+    else {
+        console.log(theme.boldFn('🎉 Everything looks healthy! devx is fully configured and ready for vibe-coding.'));
+    }
+    console.log();
+}

package/dist/cli/index.js

@@ -6,7 +6,7 @@ import os from 'os';
 import path from 'path';
 import fs from 'fs/promises';
 import fsSync from 'fs';
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import { History } from '../core/history.js';
 import { Agent } from '../core/loop.js';
 import { buildSystemPrompt } from '../prompts/builder.js';
@@ -15,7 +15,9 @@ import { getTools, lastPlanReady, resetPlanReady } from '../tools/index.js';
 import { CLIConsoleGuard } from '../permissions/guard.js';
 import { globalSnapshotManager } from '../core/snapshot.js';
 import { MemoryManager } from '../core/memory.js';
-import { startServer, stopServer } from './server.js';
+import { startServer, stopServer, displayServerBanner } from './server.js';
+import { notifyDevice } from '../core/notify.js';
+import { runDoctor } from './doctor.js';
 import { ALL_PROVIDERS } from './providers.js';
 import { getModelContextLimit } from '../core/models.js';
 import { SessionManager } from '../core/session.js';
@@ -24,6 +26,7 @@ import { SmoothStreamer } from './smooth.js';
 import { askPrompt } from './prompt.js';
 import { resolveAtMentions } from './files.js';
 import { runStartupUpdateCheck, checkForUpdates, performSelfUpdate } from './updater.js';
+import { setActiveTheme, getCurrentTheme, listThemes, findTheme } from './theme.js';
 const CONFIG_PATH = path.join(os.homedir(), '.devxrc.json');
 function maskApiKey(key) {
     if (!key)
@@ -371,14 +374,15 @@ function clearTerminalScreen() {
 function drawLogo() {
     const cols = process.stdout.columns || 80;
     clearTerminalScreen();
+    const theme = getCurrentTheme();
     if (cols < 56) {
         // Ultra-clean compact ASCII for small mobile screens (width: ~26 chars)
         const logo = [
             '',
-            pc.cyan('  █▀▀▄ █▀▀▀ █   █ █   █'),
-            pc.cyan('  █  █ █▀▀▀  ▀▄▀   ▀▄▀ '),
-            pc.cyan('  █▄▄▀ █▄▄▄   ▀    ▀ ▀ '),
-            '  ' + pc.cyan(pc.bold('v1.1.2')),
+            theme.colorFn('  █▀▀▄ █▀▀▀ █   █ █   █'),
+            theme.colorFn('  █  █ █▀▀▀  ▀▄▀   ▀▄▀ '),
+            theme.colorFn('  █▄▄▀ █▄▄▄   ▀    ▀ ▀ '),
+            '  ' + theme.boldFn('v1.2.0'),
             ''
         ];
         for (const line of logo) {
@@ -390,10 +394,10 @@ function drawLogo() {
         const indent = cols < 68 ? ' ' : '   ';
         const logo = [
             '',
-            indent + pc.cyan('▀▀▀█▀▀▀ █▀▀▀ █▀▀█ █▄ ▄█ █  █ ▀▄ ▄▀    █▀▀▄ █▀▀▀ █   █'),
-            indent + pc.cyan('   █    █▀▀▀ █▄▄▀ █ █ █ █  █   █   ▀▀ █  █ █▀▀▀ █   █'),
-            indent + pc.cyan('   █    █▄▄▄ █ ▀▄ █   █ ▀▄▄▀ ▄▀ ▀▄    █▄▄▀ █▄▄▄  ▀▄▀ '),
-            indent + pc.cyan(pc.bold('v1.1.2')),
+            indent + theme.colorFn('▀▀▀█▀▀▀ █▀▀▀ █▀▀█ █▄ ▄█ █  █ ▀▄ ▄▀    █▀▀▄ █▀▀▀ █   █'),
+            indent + theme.colorFn('   █    █▀▀▀ █▄▄▀ █ █ █ █  █   █   ▀▀ █  █ █▀▀▀ █   █'),
+            indent + theme.colorFn('   █    █▄▄▄ █ ▀▄ █   █ ▀▄▄▀ ▄▀ ▀▄    █▄▄▀ █▄▄▄  ▀▄▀ '),
+            indent + theme.boldFn('v1.2.0'),
             ''
         ];
         for (const line of logo) {
@@ -520,6 +524,39 @@ export async function main() {
     const options = program.opts();
     let planMode = !!options.plan;
     let config = await loadConfig();
+    if (!config.onboarded) {
+        const cols = Math.min(process.stdout.columns || 40, 42);
+        const fill = Math.max(2, cols - 16);
+        const topBorder = '┌─ preview.ts ' + '─'.repeat(fill) + '┐';
+        const bottomBorder = '└' + '─'.repeat(cols - 2) + '┘';
+        const themeChoices = listThemes().map(t => {
+            const addLine = t.diffAddBg(` + 1 | const theme = "${t.id}";`.padEnd(cols - 2));
+            const remLine = t.diffRemoveBg(` - 2 | const theme = "none";`.padEnd(cols - 2));
+            const preview = `${t.colorFn(topBorder)}\n${addLine}\n${remLine}\n${t.colorFn(bottomBorder)}\n\n${pc.dim('💡 You can change this anytime with /theme')}`;
+            return {
+                name: `${t.emoji} ${t.boldFn(t.name.padEnd(18))} ${pc.dim(t.desc)}`,
+                value: t.id,
+                description: preview
+            };
+        });
+        try {
+            console.clear();
+            const selected = await select({
+                message: `${pc.bold('🎨 Pick a theme to personalize your workspace:')}`,
+                choices: themeChoices,
+                pageSize: 10
+            });
+            if (selected) {
+                config.theme = selected;
+            }
+        }
+        catch { }
+        config.onboarded = true;
+        await saveConfig(config);
+    }
+    if (config.theme) {
+        setActiveTheme(config.theme);
+    }
     enableDarkTheme(config.pureBlackTheme !== false);
     let history = new History();
     const sysPrompt = await buildSystemPrompt(planMode);
@@ -546,6 +583,7 @@ export async function main() {
         const tokenStats = `Context: ${formatTokens(currentTokens)} / ${formatTokens(maxTokens)} (${usagePercent}%) • ${costStr}`;
         const cols = process.stdout.columns || 80;
         const modeName = planMode ? 'PLAN' : 'AGENT';
+        const theme = getCurrentTheme();
         // Shorten model name if too long on narrow mobile screens
         let displayModel = config.model;
         if (cols < 75 && displayModel.length > 20) {
@@ -555,7 +593,7 @@ export async function main() {
                 displayModel = displayModel.slice(0, 17) + '...';
             }
         }
-        const badge = pc.bgCyan(pc.black(` devx | ${modeName} | ${displayModel} `));
+        const badge = theme.badgeFn(`devx | ${modeName} | ${displayModel}`);
         if (cols < 75) {
             // 2-line layout for mobile screens: perfectly aligned with clack box borders
             p.intro(`${badge}\n${pc.dim('│')}  ${pc.dim(tokenStats)}`);
@@ -568,7 +606,7 @@ export async function main() {
         if (autoTriggerPrompt) {
             answer = autoTriggerPrompt;
             autoTriggerPrompt = '';
-            console.log(pc.cyan('◆') + '  ' + pc.bold(pc.white(answer)));
+            console.log(theme.colorFn('◆') + '  ' + pc.bold(pc.white(answer)));
         }
         else {
             const inputStr = await askPrompt({
@@ -609,16 +647,44 @@ export async function main() {
         if (answer.startsWith('/')) {
             const parts = answer.split(' ');
             let cmd = parts[0];
+            async function handleThemeSelect(config) {
+                const currentTh = getCurrentTheme();
+                const themeChoices = listThemes().map(t => ({
+                    name: `${t.emoji} ${t.boldFn(t.name.padEnd(18))} ${pc.dim(t.desc)} ${t.id === currentTh.id ? pc.green('(Active)') : ''}`,
+                    value: t.id,
+                    description: `Apply ${t.name} color palette (${t.hex}) to banners, prompts, and actions`
+                }));
+                try {
+                    const selected = await select({
+                        message: `${pc.bold('🎨 Select UI Theme / Выберите цветовую тему:')}`,
+                        choices: themeChoices
+                    });
+                    if (selected) {
+                        config.theme = selected;
+                        await saveConfig(config);
+                        const th = setActiveTheme(selected);
+                        drawLogo();
+                        p.log.success(th.boldFn(`🎨 Theme switched to ${th.emoji} ${th.name}!`));
+                    }
+                }
+                catch { }
+            }
             async function handleSettings(config) {
                 while (true) {
                     try {
                         const maxIter = config.maxIterations || 100;
                         const maxIterLabel = maxIter >= 9999 ? 'Unlimited' : `${maxIter} steps`;
+                        const currentTh = getCurrentTheme();
                         const choice = await select({
-                            message: `${pc.bold('⚙️  Settings')} ${pc.dim('(devx v1.1.2 • by ApvCode)')}`,
+                            message: `${pc.bold('⚙️  Settings')} ${pc.dim(`(devx v1.2.0 • theme: ${currentTh.name})`)}`,
                             choices: [
                                 {
-                                    name: `${config.pureBlackTheme !== false ? pc.green('🎨 Pure Black Background: ON') : pc.yellow('🎨 Pure Black Background: OFF')}`,
+                                    name: `🎨 Color Theme: ${currentTh.emoji} ${currentTh.name}`,
+                                    value: 'change_theme',
+                                    description: `Switch UI accent colors (${currentTh.desc})`
+                                },
+                                {
+                                    name: `${config.pureBlackTheme !== false ? pc.green('🖤 Pure Black Background: ON') : pc.yellow('🖤 Pure Black Background: OFF')}`,
                                     value: 'toggle_black_theme',
                                     description: config.pureBlackTheme !== false
                                         ? 'Apply deep OLED obsidian black background (#0a0a0c) like OpenCode'
@@ -646,12 +712,12 @@ export async function main() {
                                         : 'Disable update checking on startup (run /update manually instead)'
                                 },
                                 {
-                                    name: `🔄 Max Agent Iterations: ${pc.cyan(maxIterLabel)}`,
+                                    name: `🔄 Max Agent Iterations: ${currentTh.colorFn(maxIterLabel)}`,
                                     value: 'change_max_iterations',
                                     description: 'Limit how many tool steps (file edits, terminal commands) agent can do per request'
                                 },
                                 {
-                                    name: `${pc.cyan('✨ About devx')} ${pc.dim('(v1.1.2 by ApvCode)')}`,
+                                    name: `${currentTh.colorFn('✨ About devx')} ${pc.dim('(v1.2.0 by ApvCode)')}`,
                                     value: 'about',
                                     description: 'Terminal-Native AI Coding Agent created by ApvCode (https://github.com/apvcode/Termux-Dev)'
                                 },
@@ -662,8 +728,13 @@ export async function main() {
                                 }
                             ]
                         });
+                        if (choice === 'change_theme') {
+                            await handleThemeSelect(config);
+                            continue;
+                        }
                         if (choice === 'about') {
-                            p.note(`⚡ devx v1.1.2 — Terminal-Native AI Coding Agent\n` +
+                            p.note(`⚡ devx v1.2.0 — Terminal-Native AI Coding Agent\n` +
+                                `🎨 Theme: ${currentTh.emoji} ${currentTh.name}\n` +
                                 `👤 Author: ApvCode (https://github.com/apvcode)\n` +
                                 `🌟 Repository: https://github.com/apvcode/Termux-Dev\n` +
                                 `📜 License: MIT License (2026)\n` +
@@ -692,13 +763,13 @@ export async function main() {
                         if (choice === 'toggle_memory') {
                             config.enableMemory = config.enableMemory === false ? true : false;
                             await saveConfig(config);
-                            p.log.success(`Project memory: ${config.enableMemory ? pc.bold(pc.green('ON (Enabled)')) : pc.bold(pc.yellow('OFF (Disabled)'))}`);
+                            p.log.success(`Project memory bank: ${config.enableMemory !== false ? pc.bold(pc.green('ON (Persistent .devx/memory.md)')) : pc.bold(pc.yellow('OFF'))}`);
                             continue;
                         }
                         if (choice === 'toggle_check_updates') {
                             config.checkUpdates = config.checkUpdates === false ? true : false;
                             await saveConfig(config);
-                            p.log.success(`Check for updates on startup: ${config.checkUpdates ? pc.bold(pc.green('ON (Enabled)')) : pc.bold(pc.yellow('OFF (Disabled)'))}`);
+                            p.log.success(`Check for updates: ${config.checkUpdates !== false ? pc.bold(pc.green('ON (Checked on startup)')) : pc.bold(pc.yellow('OFF (Manual only)'))}`);
                             continue;
                         }
                         if (choice === 'change_max_iterations') {
@@ -726,18 +797,34 @@ export async function main() {
                 process.stdin.resume();
                 return config;
             }
-            const VALID_COMMANDS = ['/new', '/reset', '/resume', '/session', '/sessions', '/history', '/settings', '/update', '/model', '/provider', '/providers', '/plan', '/agent', '/config', '/clear', '/exit', '/help'];
+            const VALID_COMMANDS = [
+                '/new', '/reset', '/resume', '/session', '/sessions', '/history',
+                '/theme', '/themes',
+                '/settings', '/update', '/model', '/provider', '/providers',
+                '/plan', '/agent', '/image', '/serve', '/memory', '/undo',
+                '/diff', '/commit', '/status', '/compact', '/init', '/doctor',
+                '/config', '/clear', '/exit', '/quit', '/help'
+            ];
             if (!VALID_COMMANDS.includes(cmd)) {
                 const SLASH_COMMANDS = [
                     { name: '/new          - Start a new clean chat session', value: '/new' },
                     { name: '/resume       - Resume a previous chat session', value: '/resume' },
                     { name: '/session del  - Select and delete saved sessions', value: '/session del' },
+                    { name: '/theme        - Switch UI color theme', value: '/theme' },
+                    { name: '/doctor       - Run system & environment health diagnostics', value: '/doctor' },
                     { name: '/settings     - Configure permissions & auto-approval', value: '/settings' },
                     { name: '/update       - Check and install updates from GitHub', value: '/update' },
                     { name: '/model        - Switch model for current provider', value: '/model' },
                     { name: '/provider     - Change AI provider (Google, OpenRouter...)', value: '/provider' },
                     { name: '/plan         - Switch to PLAN mode (architect)', value: '/plan' },
                     { name: '/agent        - Switch to AGENT mode (coder)', value: '/agent' },
+                    { name: '/serve        - Start local web server for web preview', value: '/serve' },
+                    { name: '/memory       - View or edit project memory bank', value: '/memory' },
+                    { name: '/undo         - Revert last file changes made by AI', value: '/undo' },
+                    { name: '/diff         - Show git diff of modified files', value: '/diff' },
+                    { name: '/commit       - AI-generated git commit message', value: '/commit' },
+                    { name: '/status       - Show git repository status', value: '/status' },
+                    { name: '/compact      - Compact conversation context', value: '/compact' },
                     { name: '/config       - View current configuration', value: '/config' },
                     { name: '/clear        - Clear message history', value: '/clear' },
                     { name: '/help         - Show commands overview', value: '/help' },
@@ -1070,8 +1157,8 @@ export async function main() {
                         initialValue: true
                     });
                     if (!p.isCancel(confirmed) && confirmed) {
-                        execSync('git add -A', { stdio: 'ignore' });
-                        execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { stdio: 'ignore' });
+                        execFileSync('git', ['add', '-A'], { stdio: 'ignore' });
+                        execFileSync('git', ['commit', '-m', commitMsg], { stdio: 'ignore' });
                         p.log.success(pc.bold(pc.green(`✅ Committed: ${commitMsg}`)));
                     }
                     else {
@@ -1151,6 +1238,10 @@ export async function main() {
                 }
                 continue;
             }
+            if (cmd === '/doctor') {
+                await runDoctor(config);
+                continue;
+            }
             if (cmd === '/serve') {
                 const sub = parts[1]?.toLowerCase();
                 if (sub === 'stop') {
@@ -1165,10 +1256,7 @@ export async function main() {
                     const customPort = parseInt(parts[1], 10) || 3000;
                     try {
                         const { port, localUrl, networkUrl } = await startServer(customPort);
-                        p.log.success(pc.bold(pc.green(`🌐 Web Server running on port ${port}!`)));
-                        console.log(pc.cyan(`  • Local:   ${localUrl}`));
-                        console.log(pc.cyan(`  • Network: ${networkUrl}`));
-                        console.log(pc.dim('  (Use /serve stop to stop the server)\n'));
+                        await displayServerBanner(localUrl, networkUrl);
                     }
                     catch (err) {
                         p.log.error(`Failed to start web server: ${err.message}`);
@@ -1176,6 +1264,27 @@ export async function main() {
                 }
                 continue;
             }
+            if (cmd === '/theme' || cmd === '/themes') {
+                const themeArg = answer.replace(/^\/(?:theme|themes)\s*/i, '').trim();
+                if (themeArg) {
+                    const matched = findTheme(themeArg);
+                    if (matched) {
+                        config.theme = matched.id;
+                        await saveConfig(config);
+                        const th = setActiveTheme(matched.id);
+                        drawLogo();
+                        p.log.success(th.boldFn(`🎨 Theme switched to ${th.emoji} ${th.name}!`));
+                    }
+                    else {
+                        const themes = listThemes();
+                        p.log.warn(`Unknown theme: "${themeArg}". Available themes: ${themes.map(t => `${t.emoji} ${t.id}`).join(', ')}`);
+                    }
+                }
+                else {
+                    await handleThemeSelect(config);
+                }
+                continue;
+            }
             if (cmd === '/memory') {
                 const sub = parts[1]?.toLowerCase();
                 if (sub === 'clear') {
@@ -1357,6 +1466,8 @@ export async function main() {
             }
             catch { }
         }
+        const turnStartTime = Date.now();
+        let toolsExecutedCount = 0;
         try {
             for await (const event of agent.run(abortController.signal)) {
                 if (aborted)
@@ -1395,15 +1506,16 @@ export async function main() {
                     }
                 }
                 else if (event.type === 'tool_generating') {
+                    const theme = getCurrentTheme();
                     const label = formatToolGeneratingLabel(event.name, event.targetHint);
                     if (!spinnerActive) {
                         streamer.finish();
                         finishThinking(false);
-                        s.start(pc.bold(pc.cyan(label)));
+                        s.start(theme.boldFn(label));
                         spinnerActive = true;
                     }
                     else {
-                        s.message(pc.bold(pc.cyan(label)));
+                        s.message(theme.boldFn(label));
                     }
                 }
                 else if (event.type === 'tool_start') {
@@ -1424,6 +1536,7 @@ export async function main() {
                     }
                 }
                 else if (event.type === 'tool_end') {
+                    toolsExecutedCount++;
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
@@ -1435,28 +1548,50 @@ export async function main() {
                                 process.stdout.write(parsed.displayCard);
                             }
                             else if (parsed.action === 'edit' && parsed.diffLines) {
+                                const theme = getCurrentTheme();
                                 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);
+                                const boxWidth = Math.max(30, Math.min(cols - 4, 76));
+                                const fileName = typeof parsed.path === 'string' ? parsed.path.split(/[\/\\]/).pop() || 'file' : 'file';
+                                const fillCount = Math.max(2, boxWidth - 5 - fileName.length);
+                                console.log(theme.colorFn('┌─ ') + pc.bold(fileName) + ' ' + theme.colorFn('─'.repeat(fillCount) + '┐'));
+                                const maxShown = Math.min(parsed.diffLines.length, 30);
                                 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));
+                                    const match = line.match(/^(\d+)(\s+[+\- ]\s+)(.*)$/);
+                                    if (match) {
+                                        const lineNum = match[1].padStart(4, ' ');
+                                        const symbol = match[2];
+                                        const contentStr = match[3] || '';
+                                        const prefix = symbol.includes('-') ? '-' : symbol.includes('+') ? '+' : ' ';
+                                        const maxCodeLen = Math.max(10, boxWidth - 11);
+                                        const paddedCode = contentStr.length > maxCodeLen
+                                            ? contentStr.substring(0, maxCodeLen - 1) + '…'
+                                            : contentStr.padEnd(maxCodeLen, ' ');
+                                        const innerRow = ` ${lineNum} ${prefix} ${paddedCode} `;
+                                        if (prefix === '-') {
+                                            console.log(theme.colorFn('│') + theme.diffRemoveBg(innerRow) + theme.colorFn('│'));
+                                        }
+                                        else if (prefix === '+') {
+                                            console.log(theme.colorFn('│') + theme.diffAddBg(innerRow) + theme.colorFn('│'));
+                                        }
+                                        else {
+                                            console.log(theme.colorFn('│') + pc.dim(innerRow) + theme.colorFn('│'));
+                                        }
                                     }
                                     else {
-                                        console.log(pc.dim('│ ') + pc.white(line));
+                                        const maxLen = Math.max(10, boxWidth - 4);
+                                        const padded = line.length > maxLen ? line.substring(0, maxLen - 1) + '…' : line.padEnd(maxLen, ' ');
+                                        console.log(theme.colorFn('│ ') + pc.white(padded) + theme.colorFn(' │'));
                                     }
                                 }
                                 if (parsed.diffLines.length > maxShown) {
-                                    console.log(pc.dim(`│ ... +${parsed.diffLines.length - maxShown} more lines`));
+                                    const dots = `... +${parsed.diffLines.length - maxShown} more lines`;
+                                    const maxLen = Math.max(10, boxWidth - 4);
+                                    const paddedDots = dots.length > maxLen ? dots.substring(0, maxLen - 1) + '…' : dots.padEnd(maxLen, ' ');
+                                    console.log(theme.colorFn('│ ') + pc.dim(paddedDots) + theme.colorFn(' │'));
                                 }
-                                console.log(pc.dim('└' + borderChar.repeat(boxWidth) + '┘'));
-                                console.log(pc.green(`  └─ ${parsed.summary}`));
+                                console.log(theme.colorFn('└' + '─'.repeat(boxWidth - 2) + '┘'));
+                                console.log(theme.boldFn(`  └─ ${parsed.summary}`));
                             }
                             else if (parsed.summary) {
                                 console.log(pc.green(`  └─ ${parsed.summary}`));
@@ -1535,6 +1670,12 @@ export async function main() {
                 process.stdout.write('\n');
             }
             globalSnapshotManager.finishTurn();
+            const turnElapsedMs = Date.now() - turnStartTime;
+            const shouldNotify = (turnElapsedMs >= 15000) || (toolsExecutedCount > 0) || (planMode && lastPlanReady !== null);
+            if (shouldNotify && !aborted) {
+                const secs = Math.round(turnElapsedMs / 1000);
+                notifyDevice('devx', `Task completed in ${secs}s!`);
+            }
             // Auto-save session
             await sessionManager.save(history.getMessages(), totalSessionCost, config.model, planMode);
             // Check if plan was finalized in PLAN mode

package/dist/cli/prompt.js

@@ -1,11 +1,14 @@
 import pc from 'picocolors';
 import { scanProjectFiles } from './files.js';
 import { saveClipboardImage, processPastedFilePath } from './clipboard.js';
+import { getCurrentTheme, listThemes } from './theme.js';
 export const SLASH_COMMANDS = [
     { cmd: '/new', desc: 'Start a new clean chat session' },
     { cmd: '/resume', desc: 'Resume a previous chat session' },
     { cmd: '/session', desc: 'Show active session ID, stats, and info' },
     { cmd: '/session del', desc: 'Select and delete saved sessions' },
+    { cmd: '/theme', desc: 'Switch UI theme (Cyan, Purple, Matrix, Amber, etc.)' },
+    { cmd: '/doctor', desc: 'Run system & environment health diagnostics' },
     { cmd: '/settings', desc: 'Configure permissions & auto-approval' },
     { cmd: '/update', desc: 'Check and install updates from GitHub' },
     { cmd: '/model', desc: 'Switch model for current provider' },
@@ -47,8 +50,9 @@ export function askPrompt(opts = {}) {
         const pastes = [];
         const imageAttachments = [];
         const usedImageNames = new Set();
+        const theme = getCurrentTheme();
         // Header printed once
-        console.log(pc.cyan('◆') + '  ' + pc.bold(msg));
+        console.log(theme.colorFn('◆') + '  ' + pc.bold(msg));
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
         }
@@ -56,6 +60,33 @@ export function askPrompt(opts = {}) {
             process.stdout.write('\x1b[?2004h');
         }
         function getDropdownItems() {
+            if (input.startsWith('/theme ') || input.startsWith('/themes ') || input === '/theme') {
+                const afterCmd = input.replace(/^\/(?:theme|themes)\s*/i, '').trim().toLowerCase();
+                const themes = listThemes();
+                const matched = themes.filter(t => !afterCmd ||
+                    t.id.toLowerCase().startsWith(afterCmd) ||
+                    t.name.toLowerCase().includes(afterCmd));
+                const list = [];
+                if (!afterCmd || '/theme'.startsWith(input.trim().toLowerCase())) {
+                    list.push({
+                        label: '/theme',
+                        desc: 'Interactive UI theme picker menu',
+                        replacement: '/theme',
+                        replaceStart: 0,
+                        replaceLen: input.length
+                    });
+                }
+                for (const t of matched) {
+                    list.push({
+                        label: `/theme ${t.id}`,
+                        desc: `${t.emoji} ${t.name} (${t.desc})`,
+                        replacement: `/theme ${t.id}`,
+                        replaceStart: 0,
+                        replaceLen: input.length
+                    });
+                }
+                return list;
+            }
             if (input.startsWith('/')) {
                 const q = input.trim().toLowerCase();
                 const filtered = SLASH_COMMANDS.filter(c => c.cmd.toLowerCase().startsWith(q) || q === '/');
@@ -146,9 +177,9 @@ export function askPrompt(opts = {}) {
                     const labelStr = item.label.length > 20 ? item.label.slice(0, 19) + '…' : item.label.padEnd(20);
                     const maxDescLen = Math.max(6, boxWidth - 25);
                     const descStr = item.desc.length > maxDescLen ? item.desc.slice(0, maxDescLen - 3) + '...' : item.desc.padEnd(maxDescLen);
-                    let row = ` ${isSelected ? pc.cyan('›') : ' '} ${isSelected ? pc.bold(pc.cyan(labelStr)) : pc.white(labelStr)} ${pc.gray(descStr)} `;
+                    let row = ` ${isSelected ? theme.colorFn('›') : ' '} ${isSelected ? theme.boldFn(labelStr) : pc.white(labelStr)} ${pc.gray(descStr)} `;
                     if (isSelected) {
-                        row = pc.bgCyan(pc.black(` › ${labelStr} ${descStr} `));
+                        row = theme.badgeFn(`› ${labelStr} ${descStr}`);
                     }
                     dropdownLines.push(pc.dim('│') + '  ' + pc.dim('│') + row + pc.dim('│'));
                 }

package/dist/cli/server.js

@@ -4,6 +4,9 @@ import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
 import { spawn } from 'child_process';
+import pc from 'picocolors';
+import qrcode from 'qrcode-terminal';
+import { getTheme } from './theme.js';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
     '.htm': 'text/html; charset=utf-8',
@@ -136,7 +139,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.1.2 &bull; Terminal-Native AI Assistant</div>
+    <div class="footer">devx v1.2.0 &bull; Terminal-Native AI Assistant</div>
   </div>
 </body>
 </html>`;
@@ -160,6 +163,13 @@ export async function startServer(preferredPort = 3000) {
                     res.end('Forbidden');
                     return;
                 }
+                // Security check: block dotfiles, hidden directories (.env, .git, etc.) and node_modules
+                const segments = reqPath.split(/[\/\\]/).filter(Boolean);
+                if (segments.some(seg => (seg.startsWith('.') && seg !== '.') || seg === 'node_modules')) {
+                    res.writeHead(403, { 'Content-Type': 'text/plain' });
+                    res.end('Forbidden');
+                    return;
+                }
                 // 1. Root / Directory Request Handling
                 if (fsSync.existsSync(targetPath)) {
                     const stat = await fs.stat(targetPath);
@@ -232,8 +242,14 @@ export async function startServer(preferredPort = 3000) {
                 res.end(`Internal Server Error: ${err.message}`);
             }
         });
+        let retryCount = 0;
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {
+                retryCount++;
+                if (retryCount > 20) {
+                    reject(new Error(`Could not find an open port after 20 attempts (started at ${preferredPort})`));
+                    return;
+                }
                 activePort++;
                 server.listen(activePort, '0.0.0.0');
             }
@@ -250,6 +266,7 @@ export async function startServer(preferredPort = 3000) {
             if (process.env.PREFIX?.includes('com.termux')) {
                 try {
                     const opener = spawn('termux-open-url', [localUrl], { stdio: 'ignore', detached: true });
+                    opener.on('error', () => { });
                     opener.unref();
                 }
                 catch { }
@@ -258,3 +275,41 @@ export async function startServer(preferredPort = 3000) {
         });
     });
 }
+export function getQrCodeString(text) {
+    return new Promise((resolve) => {
+        try {
+            qrcode.generate(text, { small: true }, (qr) => {
+                resolve(qr);
+            });
+        }
+        catch {
+            resolve('');
+        }
+    });
+}
+export async function displayServerBanner(localUrl, networkUrl) {
+    const th = getTheme();
+    const qr = await getQrCodeString(networkUrl);
+    const cols = Math.min(process.stdout.columns || 80, 80);
+    const cardWidth = Math.max(36, Math.min(cols - 4, 66));
+    const innerWidth = cardWidth - 2;
+    const title = ' 🌐 Live Web Preview ';
+    const topFill = Math.max(2, cardWidth - 3 - title.length);
+    console.log('\n' + th.colorFn('┌─') + pc.bold(title) + th.colorFn('─'.repeat(topFill) + '┐'));
+    const printRow = (content) => {
+        const visibleLength = content.replace(/\u001b\[[0-9;]*m/g, '').length;
+        const padding = Math.max(0, innerWidth - visibleLength);
+        console.log(th.colorFn('│') + content + ' '.repeat(padding) + th.colorFn('│'));
+    };
+    printRow(`  ${pc.bold('Local:')}   ${pc.cyan(localUrl)}`);
+    printRow(`  ${pc.bold('Network:')} ${pc.green(networkUrl)}`);
+    printRow(' ');
+    printRow(`  ${pc.bold('📱 Mobile QR:')}`);
+    if (qr) {
+        const qrLines = qr.trim().split('\n');
+        for (const ql of qrLines) {
+            printRow(`  ${ql}`);
+        }
+    }
+    console.log(th.colorFn('└' + '─'.repeat(innerWidth) + '┘\n'));
+}

package/dist/cli/theme.js

@@ -0,0 +1,140 @@
+import pc from 'picocolors';
+export const THEMES = {
+    cyan: {
+        id: 'cyan',
+        name: 'Cyan Cyber',
+        desc: 'Electric neon cyan & obsidian (Default)',
+        emoji: '⚡',
+        colorFn: (s) => pc.cyan(s),
+        boldFn: (s) => pc.bold(pc.cyan(s)),
+        accentFn: (s) => pc.blue(s),
+        badgeFn: (s) => pc.bgCyan(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgCyan(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgBlue(pc.white(s)),
+        hex: '#00f2fe'
+    },
+    purple: {
+        id: 'purple',
+        name: 'Synthwave Purple',
+        desc: 'Vibrant neon magenta & violet retro',
+        emoji: '🟣',
+        colorFn: (s) => pc.magenta(s),
+        boldFn: (s) => pc.bold(pc.magenta(s)),
+        accentFn: (s) => pc.blue(s),
+        badgeFn: (s) => pc.bgMagenta(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgMagenta(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgBlue(pc.white(s)),
+        hex: '#d946ef'
+    },
+    matrix: {
+        id: 'matrix',
+        name: 'Matrix Hacker',
+        desc: 'Classic bright phosphor green terminal',
+        emoji: '🟢',
+        colorFn: (s) => pc.green(s),
+        boldFn: (s) => pc.bold(pc.green(s)),
+        accentFn: (s) => pc.cyan(s),
+        badgeFn: (s) => pc.bgGreen(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgGreen(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgRed(pc.white(s)),
+        hex: '#22c55e'
+    },
+    amber: {
+        id: 'amber',
+        name: 'Solar Amber',
+        desc: 'Warm vintage CRT amber gold',
+        emoji: '🟡',
+        colorFn: (s) => pc.yellow(s),
+        boldFn: (s) => pc.bold(pc.yellow(s)),
+        accentFn: (s) => pc.red(s),
+        badgeFn: (s) => pc.bgYellow(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgYellow(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgRed(pc.white(s)),
+        hex: '#f59e0b'
+    },
+    crimson: {
+        id: 'crimson',
+        name: 'Ruby Crimson',
+        desc: 'Aggressive cyberpunk scarlet red',
+        emoji: '🔴',
+        colorFn: (s) => pc.red(s),
+        boldFn: (s) => pc.bold(pc.red(s)),
+        accentFn: (s) => pc.magenta(s),
+        badgeFn: (s) => pc.bgRed(pc.white(` ${s} `)),
+        diffAddBg: (s) => pc.bgRed(pc.white(s)),
+        diffRemoveBg: (s) => pc.bgMagenta(pc.white(s)),
+        hex: '#ef4444'
+    },
+    monochrome: {
+        id: 'monochrome',
+        name: 'Pure Monochrome',
+        desc: 'Crisp minimal pure white & gray',
+        emoji: '⚪',
+        colorFn: (s) => pc.white(s),
+        boldFn: (s) => pc.bold(pc.white(s)),
+        accentFn: (s) => pc.dim(s),
+        badgeFn: (s) => pc.bgWhite(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgWhite(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgBlack(pc.white(s)),
+        hex: '#ffffff'
+    }
+};
+const THEME_ALIASES = {
+    '1': 'cyan',
+    '2': 'purple',
+    '3': 'matrix',
+    '4': 'amber',
+    '5': 'crimson',
+    '6': 'monochrome',
+    'blue': 'cyan',
+    'neon': 'cyan',
+    'cyber': 'cyan',
+    'magenta': 'purple',
+    'violet': 'purple',
+    'pink': 'purple',
+    'synthwave': 'purple',
+    'green': 'matrix',
+    'hacker': 'matrix',
+    'terminal': 'matrix',
+    'yellow': 'amber',
+    'gold': 'amber',
+    'solar': 'amber',
+    'orange': 'amber',
+    'red': 'crimson',
+    'ruby': 'crimson',
+    'cyberpunk': 'crimson',
+    'white': 'monochrome',
+    'mono': 'monochrome',
+    'gray': 'monochrome',
+    'grey': 'monochrome'
+};
+let activeThemeId = 'cyan';
+export function getTheme(themeId) {
+    const id = (themeId || activeThemeId).toLowerCase().trim();
+    return THEMES[id] || (THEME_ALIASES[id] && THEMES[THEME_ALIASES[id]]) || THEMES.cyan;
+}
+export function findTheme(query) {
+    const q = (query || '').toLowerCase().trim();
+    if (!q)
+        return null;
+    if (THEMES[q])
+        return THEMES[q];
+    if (THEME_ALIASES[q] && THEMES[THEME_ALIASES[q]])
+        return THEMES[THEME_ALIASES[q]];
+    const all = listThemes();
+    const found = all.find(t => t.id.toLowerCase() === q ||
+        t.id.toLowerCase().startsWith(q) ||
+        t.name.toLowerCase().includes(q));
+    return found || null;
+}
+export function setActiveTheme(themeId) {
+    const theme = getTheme(themeId);
+    activeThemeId = theme.id;
+    return theme;
+}
+export function getCurrentTheme() {
+    return THEMES[activeThemeId] || THEMES.cyan;
+}
+export function listThemes() {
+    return Object.values(THEMES);
+}

package/dist/core/notify.js

@@ -0,0 +1,40 @@
+import { spawn } from 'child_process';
+export function isTermux() {
+    return !!process.env.PREFIX?.includes('com.termux');
+}
+/**
+ * Sends a notification and haptic vibration to the device.
+ * On Termux: uses termux-notification and termux-vibrate via termux-api.
+ * On Desktop: emits terminal bell \u0007.
+ */
+export function notifyDevice(title, message, options = { vibrate: true, sound: true }) {
+    if (isTermux()) {
+        try {
+            // 1. Android notification via Termux API
+            const notif = spawn('termux-notification', [
+                '--title', title,
+                '--content', message,
+                '--id', 'devx_task_notif',
+                '--priority', 'high'
+            ], { stdio: 'ignore', detached: true });
+            notif.on('error', () => { });
+            notif.unref();
+            // 2. Haptic vibration (150ms)
+            if (options.vibrate !== false) {
+                const vib = spawn('termux-vibrate', ['-d', '150'], { stdio: 'ignore', detached: true });
+                vib.on('error', () => { });
+                vib.unref();
+            }
+        }
+        catch { }
+    }
+    else {
+        // Desktop terminal bell
+        if (options.sound !== false) {
+            try {
+                process.stdout.write('\u0007');
+            }
+            catch { }
+        }
+    }
+}

package/dist/core/snapshot.js

@@ -36,12 +36,8 @@ export class SnapshotManager {
                 });
             }
         }
-        catch {
-            this.currentTurn.files.set(resolved, {
-                filePath: resolved,
-                existed: false,
-                content: null
-            });
+        catch (err) {
+            throw new Error(`Cannot safely snapshot file ${resolved} before edit: ${err.message}`);
         }
     }
     finishTurn() {

package/dist/prompts/builder.js

@@ -41,8 +41,9 @@ export async function buildSystemPrompt(planMode) {
         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`;
         prompt += `- If you need dependencies, use 'install_package' to install them cleanly.\n`;
+        prompt += `- Whenever you create or modify web applications, sites, HTML/CSS/JS, canvas games, or React/Vite frontend apps, automatically call the 'serve_preview' tool with action='start' to start the local preview server and display the mobile QR-code for the user!\n`;
         prompt += `- Use 'save_memory' to remember important architectural decisions, user preferences, or project rules.\n`;
-        prompt += `Always explain your actions briefly before using tools.\n`;
+        prompt += `- Always explain your actions briefly before using tools.\n`;
     }
     // Load Project Memory Bank
     try {

package/dist/tools/fs.js

@@ -63,13 +63,20 @@ export const writeFileTool = {
             }
             catch { }
             await fs.writeFile(args.path, args.content, 'utf8');
-            const newLines = args.content.split('\n').length;
+            const contentLines = args.content.split('\n');
+            const newLines = contentLines.length;
+            const diffLines = [];
+            const showLines = Math.min(contentLines.length, 6);
+            for (let i = 0; i < showLines; i++) {
+                diffLines.push(`${i + 1} +  ${contentLines[i]}`);
+            }
             if (!existed) {
                 return JSON.stringify({
                     status: 'success',
-                    action: 'create',
+                    action: 'edit',
                     path: args.path,
                     addedCount: newLines,
+                    diffLines,
                     summary: `Successfully created ${args.path} (+${newLines} lines)`
                 });
             }
@@ -78,9 +85,10 @@ export const writeFileTool = {
                 const diffStr = diff >= 0 ? `+${diff}` : `${diff}`;
                 return JSON.stringify({
                     status: 'success',
-                    action: 'write',
+                    action: 'edit',
                     path: args.path,
                     addedCount: newLines,
+                    diffLines,
                     summary: `Successfully updated ${args.path} (${diffStr} lines, ${newLines} total)`
                 });
             }
@@ -131,16 +139,20 @@ export const editFileTool = {
                 }
             }
             const targetIndex = content.indexOf(target);
+            const allLines = content.split('\n');
             const startLine = content.slice(0, targetIndex).split('\n').length;
             const removedArr = target.split('\n');
+            const endLine = startLine + removedArr.length - 1;
+            const contextBefore = allLines.slice(Math.max(0, startLine - 3), startLine - 1);
+            const contextAfter = allLines.slice(endLine, Math.min(allLines.length, endLine + 2));
             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}`);
-            });
+            let lineCounter = startLine - contextBefore.length;
+            contextBefore.forEach((l) => diffLines.push(`${lineCounter++}    ${l}`));
+            removedArr.forEach((l) => diffLines.push(`${lineCounter++} -  ${l}`));
+            let addCounter = startLine;
+            addedArr.forEach((l) => diffLines.push(`${addCounter++} +  ${l}`));
+            contextAfter.forEach((l) => diffLines.push(`${addCounter++}    ${l}`));
             const newContent = content.replace(target, args.replacement);
             await fs.writeFile(args.path, newContent, 'utf8');
             return JSON.stringify({

package/dist/tools/index.js

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

package/dist/tools/server.js

@@ -1,9 +1,9 @@
-import { startServer, stopServer, isServerRunning, getServerPort } from '../cli/server.js';
+import { startServer, stopServer, isServerRunning, getServerPort, displayServerBanner } from '../cli/server.js';
 export const servePreviewTool = {
     name: 'serve_preview',
     definition: {
         name: 'serve_preview',
-        description: 'Start or stop the built-in local live web preview server to view HTML/web apps in the browser.',
+        description: 'Start or stop the built-in local live web preview server to view HTML/web apps in the browser with instant QR-code.',
         parameters: {
             type: 'object',
             properties: {
@@ -37,7 +37,8 @@ export const servePreviewTool = {
         const preferredPort = args.port || 3000;
         try {
             const { port, localUrl, networkUrl } = await startServer(preferredPort);
-            return `Web Server is now live!\n• Local URL: ${localUrl}\n• Network URL: ${networkUrl}\nOpened in browser automatically.`;
+            await displayServerBanner(localUrl, networkUrl);
+            return `Web Server is now live!\n• Local URL: ${localUrl}\n• Network URL: ${networkUrl}\nOpened in browser automatically with mobile QR-code displayed in terminal.`;
         }
         catch (err) {
             throw new Error(`Failed to start web server: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.1.2",
+  "version": "1.2.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",
@@ -54,11 +54,13 @@
     "commander": "^12.0.0",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {
     "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
     "typescript": "^5.4.0"
   }
 }