termux-dev 1.2.2 → 1.3.0

package/README.md

@@ -85,6 +85,20 @@ npm install
 npm link
 ```
 
+### 🗑️ Complete Uninstallation
+
+To completely remove `devx` along with all configuration, saved sessions, and data:
+
+```bash
+# 1. Uninstall the global npm package
+npm uninstall -g termux-dev
+
+# 2. Remove configuration and session history (Linux / macOS / Termux)
+rm -rf ~/.devx ~/.devxrc.json
+
+# (Windows PowerShell)
+Remove-Item -Recurse -Force "$HOME\.devx", "$HOME\.devxrc.json" -ErrorAction SilentlyContinue
+```
 
 ---
 
@@ -101,6 +115,11 @@ devx
   ```bash
   devx --plan
   ```
+* Run in **Headless One-Shot Mode** (scripts, CI/CD, Termux:Widget):
+  ```bash
+  devx -p "review latest git diff and find security bugs"
+  devx -p "fix build errors" --yolo
+  ```
 
 ---
 
@@ -112,6 +131,10 @@ Type `/` in the prompt to open the autocomplete command palette:
 | :--- | :--- |
 | **`/plan`** | Switch to **PLAN** mode (architect & requirements planner) |
 | **`/agent`** | Switch to **AGENT** mode (coder & autonomous executor) |
+| **`/usage`** | View live network bandwidth (KB/MB), token costs, and API request counts |
+| **`/export`** | Export session conversation to a clean GitHub-Flavored Markdown transcript |
+| **`/theme`** | Switch UI color theme (Cyan, Purple, Matrix, Amber, Crimson, Monochrome) |
+| **`/doctor`** | Run environment health diagnostics (Node, Termux, Compilers, API keys) |
 | **`/image`** | Paste image from clipboard as `[1.png 203kb]` |
 | **`/serve [port]`** | Start local HTTP server for web/game preview (`/serve stop` to halt) |
 | **`/memory`** | View, add (`/memory add <fact>`), or clear project memory bank |
@@ -213,6 +236,20 @@ npm install
 npm link
 ```
 
+### 🗑️ Полное удаление
+
+Чтобы полностью удалить `devx` вместе с конфигурацией, историей сессий и сохранёнными данными:
+
+```bash
+# 1. Удаляем глобальный npm-пакет
+npm uninstall -g termux-dev
+
+# 2. Удаляем конфиг и историю сессий (Linux / macOS / Termux)
+rm -rf ~/.devx ~/.devxrc.json
+
+# (Windows PowerShell)
+Remove-Item -Recurse -Force "$HOME\.devx", "$HOME\.devxrc.json" -ErrorAction SilentlyContinue
+```
 
 ---
 
@@ -229,6 +266,11 @@ devx
   ```bash
   devx --plan
   ```
+* Запуск в **Headless One-Shot режиме** (скрипты, CI/CD, Termux:Widget):
+  ```bash
+  devx -p "проверь последний git diff и найди баги"
+  devx -p "исправь ошибки сборки" --yolo
+  ```
 
 ---
 
@@ -240,6 +282,10 @@ devx
 | :--- | :--- |
 | **`/plan`** | Переключиться в режим архитектора (**PLAN**) |
 | **`/agent`** | Переключиться в режим исполнителя (**AGENT**) |
+| **`/usage`** | Показать сетевой трафик (КБ/МБ), токены, число запросов и расходы ($) |
+| **`/export`** | Экспортировать сессию диалога в чистый GitHub Markdown файл |
+| **`/theme`** | Сменить цветовую тему (Cyan, Purple, Matrix, Amber, Crimson, Monochrome) |
+| **`/doctor`** | Запустить системную диагностику (Node, Termux, Компиляторы, Ключи) |
 | **`/image`** | Вставить картинку из буфера обмена как `[1.png 203kb]` |
 | **`/serve [порт]`** | Запустить локальный веб-сервер (`/serve stop` для остановки) |
 | **`/memory`** | Посмотреть, добавить (`/memory add <факт>`) или очистить банк памяти |

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

package/dist/cli/export.js

@@ -0,0 +1,62 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class SessionExporter {
+    static async exportToMarkdown(messages, model, targetFilename) {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            let fileName = targetFilename?.trim() || `devx-session-${timestamp.slice(0, 19)}.md`;
+            if (!fileName.endsWith('.md'))
+                fileName += '.md';
+            const filePath = path.resolve(process.cwd(), fileName);
+            const lines = [
+                `# 📝 devx Session Transcript`,
+                ``,
+                `- **Date:** ${new Date().toLocaleString()}`,
+                `- **Model:** \`${model}\``,
+                `- **Total Messages:** ${messages.length}`,
+                `- **Working Directory:** \`${process.cwd()}\``,
+                ``,
+                `---`,
+                ``
+            ];
+            for (const msg of messages) {
+                if (msg.role === 'system')
+                    continue; // Skip raw system prompt
+                if (msg.role === 'user') {
+                    lines.push(`## 👤 User\n`);
+                    lines.push(msg.content || '');
+                    if (msg.images && msg.images.length > 0) {
+                        lines.push(`\n*Attached Images: ${msg.images.map(i => i.path).join(', ')}*`);
+                    }
+                    lines.push(`\n---\n`);
+                }
+                else if (msg.role === 'assistant') {
+                    lines.push(`## 🤖 Assistant\n`);
+                    if (msg.content) {
+                        lines.push(msg.content);
+                    }
+                    if (msg.tool_calls && msg.tool_calls.length > 0) {
+                        lines.push(`\n**Executed Tools:**`);
+                        for (const tc of msg.tool_calls) {
+                            lines.push(`- \`${tc.name}\`: \`\`\`json\n${JSON.stringify(tc.arguments, null, 2)}\n\`\`\``);
+                        }
+                    }
+                    lines.push(`\n---\n`);
+                }
+                else if (msg.role === 'tool') {
+                    lines.push(`> **Tool Result (${msg.name || 'tool'}):**\n`);
+                    let displayContent = msg.content || '';
+                    if (displayContent.length > 2000) {
+                        displayContent = displayContent.slice(0, 2000) + '\n... [truncated]';
+                    }
+                    lines.push('```\n' + displayContent + '\n```\n');
+                }
+            }
+            await fs.writeFile(filePath, lines.join('\n'), 'utf8');
+            return { success: true, filePath };
+        }
+        catch (err) {
+            return { success: false, filePath: '', error: err.message };
+        }
+    }
+}

package/dist/cli/headless.js

@@ -0,0 +1,110 @@
+import pc from 'picocolors';
+import { History } from '../core/history.js';
+import { Agent } from '../core/loop.js';
+import { buildSystemPrompt } from '../prompts/builder.js';
+import { createProvider } from '../providers/index.js';
+import { getTools } from '../tools/index.js';
+import { CLIConsoleGuard } from '../permissions/guard.js';
+import { globalSnapshotManager } from '../core/snapshot.js';
+import { UsageTracker } from '../core/usage.js';
+export async function runHeadlessMode(userPrompt, config, options = {}) {
+    const planMode = !!options.planMode;
+    const isYolo = !!options.yolo || !!config.autoApprove;
+    const isQuiet = !!options.quiet;
+    const isJson = !!options.json;
+    let history = new History();
+    const sysPrompt = await buildSystemPrompt(planMode);
+    history.addMessage({ role: 'system', content: sysPrompt });
+    history.addMessage({ role: 'user', content: userPrompt });
+    const provider = createProvider(config);
+    const tools = getTools(planMode);
+    const guard = new CLIConsoleGuard(isYolo, config.bashAllowlist || []);
+    const agent = new Agent(config, provider, tools, history, guard);
+    const executedTools = [];
+    let accumulatedText = '';
+    let accumulatedReasoning = '';
+    let isFatalError = false;
+    let errorMessage = '';
+    const abortController = new AbortController();
+    process.on('SIGINT', () => {
+        abortController.abort();
+        if (!isJson) {
+            console.error(pc.yellow('\n[devx headless] Aborted by user (SIGINT)'));
+        }
+        process.exit(130);
+    });
+    try {
+        if (!isQuiet && !isJson) {
+            console.log(pc.bold(pc.cyan(`⚡ devx v1.3.0 (headless) | ${planMode ? 'PLAN' : 'AGENT'} | ${config.model}`)));
+            console.log(pc.dim(`Task: ${userPrompt}\n`));
+        }
+        for await (const event of agent.run(abortController.signal)) {
+            if (event.type === 'reasoning_delta') {
+                accumulatedReasoning += event.delta;
+                if (!isQuiet && !isJson) {
+                    process.stdout.write(pc.dim(event.delta));
+                }
+            }
+            else if (event.type === 'text_delta') {
+                accumulatedText += event.delta;
+                if (!isJson) {
+                    process.stdout.write(event.delta);
+                }
+            }
+            else if (event.type === 'tool_start') {
+                if (!isQuiet && !isJson) {
+                    console.log('\n' + pc.bold(pc.white(`› ${event.actionDesc}`)));
+                }
+            }
+            else if (event.type === 'tool_end') {
+                executedTools.push({ id: event.id, name: event.name, result: event.result });
+            }
+            else if (event.type === 'error') {
+                errorMessage = event.message;
+                if (event.isFatal) {
+                    isFatalError = true;
+                    break;
+                }
+            }
+        }
+        globalSnapshotManager.finishTurn();
+        if (isJson) {
+            const summary = UsageTracker.getInstance().getSummary();
+            const output = {
+                success: !isFatalError,
+                model: config.model,
+                prompt: userPrompt,
+                result: accumulatedText,
+                reasoning: accumulatedReasoning || undefined,
+                executedTools,
+                usage: {
+                    requests: summary.requestsCount,
+                    totalTokens: summary.totalTokens,
+                    cost: summary.totalCost,
+                    totalBytes: summary.totalBytes
+                },
+                error: isFatalError ? errorMessage : undefined
+            };
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            if (accumulatedText && !accumulatedText.endsWith('\n')) {
+                process.stdout.write('\n');
+            }
+            if (isFatalError) {
+                console.error(pc.red(`\n❌ Error: ${errorMessage}`));
+                return 1;
+            }
+        }
+        return isFatalError ? 1 : 0;
+    }
+    catch (err) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: err.message }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n❌ Fatal Headless Execution Error: ${err.message}`));
+        }
+        return 1;
+    }
+}

package/dist/cli/index.js

@@ -27,6 +27,10 @@ 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';
+import { runHeadlessMode } from './headless.js';
+import { CustomCommandManager } from '../core/commands.js';
+import { UsageTracker } from '../core/usage.js';
+import { SessionExporter } from './export.js';
 const CONFIG_PATH = path.join(os.homedir(), '.devxrc.json');
 function maskApiKey(key) {
     if (!key)
@@ -316,23 +320,110 @@ async function runOnboarding() {
     p.outro(pc.green('Setup complete! Configuration saved to ~/.devxrc.json'));
     return res;
 }
-async function loadConfig() {
+async function loadConfig(interactive = true) {
+    let globalConfig = {};
     try {
         const data = await fs.readFile(CONFIG_PATH, 'utf8');
-        const parsed = JSON.parse(data);
-        if (!parsed.model || !parsed.baseUrl)
+        globalConfig = JSON.parse(data);
+        if (!globalConfig.model || !globalConfig.baseUrl)
             throw new Error('Invalid config');
-        parsed.maxContextTokens = parsed.maxContextTokens || getModelContextLimit(parsed.model);
-        parsed.apiKeys = parsed.apiKeys || {};
-        parsed.baseUrls = parsed.baseUrls || {};
-        if (parsed.provider && parsed.apiKey) {
-            parsed.apiKeys[parsed.provider] = parsed.apiKey;
+        globalConfig.maxContextTokens = globalConfig.maxContextTokens || getModelContextLimit(globalConfig.model);
+        globalConfig.apiKeys = globalConfig.apiKeys || {};
+        globalConfig.baseUrls = globalConfig.baseUrls || {};
+        globalConfig.trustedProjects = globalConfig.trustedProjects || {};
+        if (globalConfig.provider && globalConfig.apiKey) {
+            globalConfig.apiKeys[globalConfig.provider] = globalConfig.apiKey;
         }
-        return parsed;
     }
     catch {
-        return await runOnboarding();
+        if (interactive) {
+            globalConfig = await runOnboarding();
+        }
+        else {
+            throw new Error('No configuration found in ~/.devxrc.json. Please run devx interactively first to set up your AI provider.');
+        }
+    }
+    // Check for local project config (.devx.json or .devxrc.json)
+    const localConfigPaths = [
+        path.join(process.cwd(), '.devx.json'),
+        path.join(process.cwd(), '.devxrc.json')
+    ];
+    let localConfig = null;
+    for (const lp of localConfigPaths) {
+        try {
+            if (fsSync.existsSync(lp)) {
+                const raw = await fs.readFile(lp, 'utf8');
+                localConfig = JSON.parse(raw);
+                break;
+            }
+        }
+        catch { }
+    }
+    const effectiveConfig = { ...globalConfig };
+    if (localConfig && typeof localConfig === 'object') {
+        const cwd = process.cwd();
+        const hasElevatedPermissions = localConfig.autoApprove === true || (Array.isArray(localConfig.bashAllowlist) && localConfig.bashAllowlist.length > 0);
+        let isTrusted = globalConfig.trustedProjects?.[cwd];
+        if (hasElevatedPermissions && isTrusted === undefined) {
+            if (interactive) {
+                console.log('');
+                p.log.warn(pc.bold(pc.yellow(`🛡️  [PROJECT TRUST] Local configuration (.devx.json) requests elevated permissions:`)));
+                if (localConfig.autoApprove === true) {
+                    console.log(pc.yellow(`   • Auto-approval (YOLO mode): enabled`));
+                }
+                if (localConfig.bashAllowlist) {
+                    console.log(pc.yellow(`   • Bash allowlist: ${localConfig.bashAllowlist.join(', ')}`));
+                }
+                console.log(pc.dim(`   Repository: ${cwd}`));
+                const answer = await p.confirm({
+                    message: 'Do you trust this repository and allow its elevated permissions?',
+                    initialValue: false
+                });
+                isTrusted = answer === true;
+                globalConfig.trustedProjects = globalConfig.trustedProjects || {};
+                globalConfig.trustedProjects[cwd] = isTrusted;
+                await saveConfig(globalConfig);
+                if (isTrusted) {
+                    p.log.success(pc.green('Repository marked as trusted. Elevated permissions applied.'));
+                }
+                else {
+                    p.log.info(pc.cyan('Repository not trusted. Elevated permissions ignored.'));
+                }
+            }
+            else {
+                isTrusted = false; // Never auto-trust in non-interactive headless mode
+            }
+        }
+        // Apply safe configuration overrides
+        if (localConfig.model)
+            effectiveConfig.model = localConfig.model;
+        if (localConfig.provider)
+            effectiveConfig.provider = localConfig.provider;
+        if (localConfig.apiKey)
+            effectiveConfig.apiKey = localConfig.apiKey;
+        if (localConfig.baseUrl)
+            effectiveConfig.baseUrl = localConfig.baseUrl;
+        if (localConfig.maxIterations)
+            effectiveConfig.maxIterations = localConfig.maxIterations;
+        if (localConfig.maxContextTokens)
+            effectiveConfig.maxContextTokens = localConfig.maxContextTokens;
+        if (localConfig.dataSaverLimitMB)
+            effectiveConfig.dataSaverLimitMB = localConfig.dataSaverLimitMB;
+        if (localConfig.pureBlackTheme !== undefined)
+            effectiveConfig.pureBlackTheme = localConfig.pureBlackTheme;
+        // Apply elevated permissions only if explicitly trusted
+        if (isTrusted) {
+            if (localConfig.autoApprove !== undefined)
+                effectiveConfig.autoApprove = localConfig.autoApprove;
+            if (Array.isArray(localConfig.bashAllowlist))
+                effectiveConfig.bashAllowlist = localConfig.bashAllowlist;
+        }
+    }
+    // Configure Data Saver threshold
+    if (effectiveConfig.dataSaverLimitMB) {
+        UsageTracker.getInstance().setLimit(effectiveConfig.dataSaverLimitMB);
     }
+    return effectiveConfig;
 }
 function enableDarkTheme(enabled = true) {
     if (!enabled)
@@ -391,7 +482,7 @@ function drawLogo() {
             theme.colorFn('  █▀▀▄ █▀▀▀ █   █ █   █'),
             theme.colorFn('  █  █ █▀▀▀  ▀▄▀   ▀▄▀ '),
             theme.colorFn('  █▄▄▀ █▄▄▄   ▀    ▀ ▀ '),
-            '  ' + theme.boldFn('v1.2.2'),
+            '  ' + theme.boldFn('v1.3.0'),
             ''
         ];
         for (const line of logo) {
@@ -406,7 +497,7 @@ function drawLogo() {
             indent + theme.colorFn('▀▀▀█▀▀▀ █▀▀▀ █▀▀█ █▄ ▄█ █  █ ▀▄ ▄▀    █▀▀▄ █▀▀▀ █   █'),
             indent + theme.colorFn('   █    █▀▀▀ █▄▄▀ █ █ █ █  █   █   ▀▀ █  █ █▀▀▀ █   █'),
             indent + theme.colorFn('   █    █▄▄▄ █ ▀▄ █   █ ▀▄▄▀ ▄▀ ▀▄    █▄▄▀ █▄▄▄  ▀▄▀ '),
-            indent + theme.boldFn('v1.2.2'),
+            indent + theme.boldFn('v1.3.0'),
             ''
         ];
         for (const line of logo) {
@@ -527,12 +618,37 @@ export async function main() {
     const program = new Command();
     program
         .name('devx')
-        .description('CLI tool for vibe-coding')
-        .option('--plan', 'Start in plan mode')
+        .description('Terminal-native AI coding assistant and vibe-coding agent')
+        .version('1.3.0')
+        .option('-p, --prompt <task>', 'Run one-shot task non-interactively (headless mode)')
+        .option('-y, --yolo', 'Automatically approve all tool executions without confirmation')
+        .option('-m, --model <model>', 'Specify AI model to use for this execution')
+        .option('-q, --quiet', 'Quiet output in headless mode (suppress banners and tool logs)')
+        .option('--json', 'Output structured JSON in headless mode')
+        .option('--plan', 'Start in plan mode (architect & planner)')
         .parse(process.argv);
     const options = program.opts();
-    let planMode = !!options.plan;
-    let config = await loadConfig();
+    const planModeInitial = !!options.plan;
+    const isHeadless = !!options.prompt;
+    let config = await loadConfig(!isHeadless);
+    if (options.model) {
+        config.model = options.model;
+        config.maxContextTokens = getModelContextLimit(options.model);
+    }
+    if (options.yolo) {
+        config.autoApprove = true;
+    }
+    // If -p / --prompt is provided, execute one-shot headless mode and exit!
+    if (isHeadless) {
+        const exitCode = await runHeadlessMode(options.prompt, config, {
+            planMode: planModeInitial,
+            yolo: !!options.yolo,
+            quiet: !!options.quiet,
+            json: !!options.json
+        });
+        process.exit(exitCode);
+    }
+    let planMode = planModeInitial;
     if (!config.onboarded) {
         const cols = Math.min(process.stdout.columns || 40, 42);
         const fill = Math.max(2, cols - 16);
@@ -685,7 +801,7 @@ export async function main() {
                         const maxIterLabel = maxIter >= 9999 ? 'Unlimited' : `${maxIter} steps`;
                         const currentTh = getCurrentTheme();
                         const choice = await select({
-                            message: `${pc.bold('⚙️  Settings')} ${pc.dim(`(devx v1.2.2 • theme: ${currentTh.name})`)}`,
+                            message: `${pc.bold('⚙️  Settings')} ${pc.dim(`(devx v1.3.0 • theme: ${currentTh.name})`)}`,
                             choices: [
                                 {
                                     name: `🎨 Color Theme: ${currentTh.emoji} ${currentTh.name}`,
@@ -726,7 +842,7 @@ export async function main() {
                                     description: 'Limit how many tool steps (file edits, terminal commands) agent can do per request'
                                 },
                                 {
-                                    name: `${currentTh.colorFn('✨ About devx')} ${pc.dim('(v1.2.2 by ApvCode)')}`,
+                                    name: `${currentTh.colorFn('✨ About devx')} ${pc.dim('(v1.3.0 by ApvCode)')}`,
                                     value: 'about',
                                     description: 'Terminal-Native AI Coding Agent created by ApvCode (https://github.com/apvcode/Termux-Dev)'
                                 },
@@ -742,7 +858,7 @@ export async function main() {
                             continue;
                         }
                         if (choice === 'about') {
-                            p.note(`⚡ devx v1.2.2 — Terminal-Native AI Coding Agent\n` +
+                            p.note(`⚡ devx v1.3.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` +
@@ -806,65 +922,83 @@ export async function main() {
                 process.stdin.resume();
                 return config;
             }
-            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' },
-                    { name: '/exit         - Exit devx', value: '/exit' },
+            // 1. Check for custom slash commands (.devx/commands/*.md)
+            const customCmd = await CustomCommandManager.findCommand(cmd);
+            if (customCmd) {
+                const cmdArgs = answer.slice(cmd.length).trim();
+                const expandedPrompt = CustomCommandManager.expandTemplate(customCmd.promptTemplate, cmdArgs);
+                answer = expandedPrompt;
+                p.log.info(pc.cyan(`⚡ Executing custom command: ${pc.bold(customCmd.cmd)} (${customCmd.desc})`));
+            }
+            else {
+                const VALID_COMMANDS = [
+                    '/new', '/reset', '/resume', '/session', '/sessions', '/history',
+                    '/theme', '/themes', '/usage', '/export',
+                    '/settings', '/update', '/model', '/provider', '/providers',
+                    '/plan', '/agent', '/image', '/serve', '/memory', '/undo',
+                    '/diff', '/commit', '/status', '/compact', '/init', '/doctor',
+                    '/config', '/clear', '/exit', '/quit', '/help'
                 ];
-                try {
-                    const picked = await search({
-                        message: 'Commands (type to search or select):',
-                        source: async (term) => {
-                            const q = (term || '').trim().toLowerCase();
-                            const list = [
-                                { name: pc.yellow('⬅️  Cancel'), value: '__cancel__' },
-                                ...SLASH_COMMANDS
-                            ];
-                            if (!q)
-                                return list;
-                            return list.filter(item => item.name.toLowerCase().includes(q) || item.value.toLowerCase().includes(q));
-                        },
-                        pageSize: 12
-                    });
-                    if (!picked || picked === '__cancel__') {
-                        continue;
+                if (!VALID_COMMANDS.includes(cmd)) {
+                    const customList = await CustomCommandManager.listCommands();
+                    const customSlashItems = customList.map(c => ({
+                        name: `${c.cmd.padEnd(14)} - ${c.desc}`,
+                        value: c.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: '/usage        - Show network bandwidth, data saver & token cost', value: '/usage' },
+                        { name: '/export       - Export session conversation to Markdown', value: '/export' },
+                        { 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' },
+                        { name: '/exit         - Exit devx', value: '/exit' },
+                        ...customSlashItems
+                    ];
+                    try {
+                        const picked = await search({
+                            message: 'Commands (type to search or select):',
+                            source: async (term) => {
+                                const q = (term || '').trim().toLowerCase();
+                                const list = [
+                                    { name: pc.yellow('⬅️  Cancel'), value: '__cancel__' },
+                                    ...SLASH_COMMANDS
+                                ];
+                                if (!q)
+                                    return list;
+                                return list.filter(item => item.name.toLowerCase().includes(q) || item.value.toLowerCase().includes(q));
+                            },
+                            pageSize: 12
+                        });
+                        if (!picked || picked === '__cancel__') {
+                            continue;
+                        }
+                        if (picked === '/session del') {
+                            await handleSessionDelete();
+                            continue;
+                        }
+                        cmd = picked;
                     }
-                    if (picked === '/session del') {
-                        await handleSessionDelete();
+                    catch {
                         continue;
                     }
-                    cmd = picked;
-                }
-                catch {
-                    continue;
                 }
             }
             if (cmd === '/settings') {
@@ -1322,8 +1456,33 @@ export async function main() {
                 }
                 continue;
             }
+            if (cmd === '/usage') {
+                const card = UsageTracker.getInstance().renderUsageCard();
+                console.log('\n' + card);
+                continue;
+            }
+            if (cmd === '/export') {
+                const targetName = parts.slice(1).join(' ').trim();
+                const res = await SessionExporter.exportToMarkdown(history.getMessages(), config.model, targetName || undefined);
+                if (res.success) {
+                    p.log.success(pc.bold(pc.green(`📄 Session exported to: ${res.filePath}`)));
+                }
+                else {
+                    p.log.error(`Failed to export session: ${res.error}`);
+                }
+                continue;
+            }
             if (cmd === '/config') {
-                p.note(JSON.stringify(config, null, 2), 'Configuration');
+                const masked = { ...config };
+                if (masked.apiKey)
+                    masked.apiKey = maskApiKey(masked.apiKey);
+                if (masked.apiKeys) {
+                    masked.apiKeys = { ...masked.apiKeys };
+                    for (const k of Object.keys(masked.apiKeys)) {
+                        masked.apiKeys[k] = maskApiKey(masked.apiKeys[k]);
+                    }
+                }
+                p.note(JSON.stringify(masked, null, 2), 'Configuration (Secrets Masked)');
                 continue;
             }
             if (cmd === '/model') {
@@ -1408,10 +1567,12 @@ export async function main() {
         });
         const provider = createProvider(config);
         const tools = getTools(planMode);
-        const guard = new CLIConsoleGuard(config.autoApprove);
+        const guard = new CLIConsoleGuard(config.autoApprove, config.bashAllowlist || []);
         const agentConfig = {
             maxContextTokens: config.maxContextTokens || 100000,
-            maxIterations: config.maxIterations || 100
+            maxIterations: config.maxIterations || 100,
+            autoApprove: config.autoApprove,
+            bashAllowlist: config.bashAllowlist
         };
         const agent = new Agent(agentConfig, provider, tools, history, guard);
         const taskStartTime = Date.now();

package/dist/cli/prompt.js

@@ -2,11 +2,14 @@ import pc from 'picocolors';
 import { scanProjectFiles } from './files.js';
 import { saveClipboardImage, processPastedFilePath } from './clipboard.js';
 import { getCurrentTheme, listThemes } from './theme.js';
+import { CustomCommandManager } from '../core/commands.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: '/usage', desc: 'Show network bandwidth, data saver & token cost' },
+    { cmd: '/export', desc: 'Export session conversation to Markdown' },
     { 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' },
@@ -43,10 +46,14 @@ export function askPrompt(opts = {}) {
         let historyIndex = GLOBAL_PROMPT_HISTORY.length;
         let tempDraft = '';
         let availableFiles = [];
-        // Preload project files for fast @ autocomplete
+        let customCommandsList = [];
+        // Preload project files and custom slash commands
         scanProjectFiles().then(files => {
             availableFiles = files;
         }).catch(() => { });
+        CustomCommandManager.listCommands().then(cmds => {
+            customCommandsList = cmds.map(c => ({ cmd: c.cmd, desc: c.desc }));
+        }).catch(() => { });
         const pastes = [];
         const imageAttachments = [];
         const usedImageNames = new Set();
@@ -89,7 +96,13 @@ export function askPrompt(opts = {}) {
             }
             if (input.startsWith('/')) {
                 const q = input.trim().toLowerCase();
-                const filtered = SLASH_COMMANDS.filter(c => c.cmd.toLowerCase().startsWith(q) || q === '/');
+                const baseList = [...SLASH_COMMANDS];
+                for (const cc of customCommandsList) {
+                    if (!baseList.some(b => b.cmd === cc.cmd)) {
+                        baseList.push({ cmd: cc.cmd, desc: cc.desc });
+                    }
+                }
+                const filtered = baseList.filter(c => c.cmd.toLowerCase().startsWith(q) || q === '/');
                 return filtered.map(c => ({
                     label: c.cmd,
                     desc: c.desc,

package/dist/cli/server.js

@@ -139,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.2.2 &bull; Terminal-Native AI Assistant</div>
+    <div class="footer">devx v1.3.0 &bull; Terminal-Native AI Assistant</div>
   </div>
 </body>
 </html>`;

package/dist/core/commands.js

@@ -0,0 +1,100 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+export class CustomCommandManager {
+    static cachedCommands = null;
+    static lastScanTime = 0;
+    /**
+     * Scans for custom commands in project and global directories
+     */
+    static async listCommands(forceRefresh = false) {
+        const now = Date.now();
+        if (!forceRefresh && this.cachedCommands && now - this.lastScanTime < 5000) {
+            return this.cachedCommands;
+        }
+        const commandMap = new Map();
+        // 1. Search directories (higher priority overrides lower priority)
+        const searchDirs = [
+            path.join(os.homedir(), '.devx', 'commands'),
+            path.join(process.cwd(), '.claude', 'commands'),
+            path.join(process.cwd(), '.devx', 'commands')
+        ];
+        for (const dir of searchDirs) {
+            try {
+                if (!fsSync.existsSync(dir))
+                    continue;
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.prompt'))) {
+                        const rawName = entry.name.replace(/\.(md|prompt)$/i, '').toLowerCase();
+                        const filePath = path.join(dir, entry.name);
+                        const content = await fs.readFile(filePath, 'utf8');
+                        const { description, template } = this.parseCommandFile(content, rawName);
+                        commandMap.set(rawName, {
+                            name: rawName,
+                            cmd: `/${rawName}`,
+                            desc: description || `Custom command (${path.basename(dir)}/${entry.name})`,
+                            promptTemplate: template,
+                            sourcePath: filePath
+                        });
+                    }
+                }
+            }
+            catch { }
+        }
+        this.cachedCommands = Array.from(commandMap.values());
+        this.lastScanTime = now;
+        return this.cachedCommands;
+    }
+    /**
+     * Finds a custom command by slash name (e.g. "/deploy" or "deploy")
+     */
+    static async findCommand(cmdName) {
+        const clean = cmdName.replace(/^\//, '').toLowerCase().trim();
+        const list = await this.listCommands();
+        return list.find(c => c.name === clean) || null;
+    }
+    /**
+     * Expands arguments into the prompt template
+     */
+    static expandTemplate(template, args) {
+        const trimmedArgs = args.trim();
+        if (!template.includes('$ARG') && !template.includes('$*') && !template.includes('$1')) {
+            return trimmedArgs ? `${template}\n\nUser Arguments: ${trimmedArgs}` : template;
+        }
+        let expanded = template;
+        expanded = expanded.replace(/\$ARG/g, trimmedArgs);
+        expanded = expanded.replace(/\$\*/g, trimmedArgs);
+        // Support positional parameters: $1, $2, etc.
+        const parts = trimmedArgs.split(/\s+/);
+        for (let i = 0; i < parts.length; i++) {
+            expanded = expanded.replace(new RegExp(`\\$${i + 1}`, 'g'), parts[i]);
+        }
+        return expanded;
+    }
+    /**
+     * Parses frontmatter (YAML description) and template content
+     */
+    static parseCommandFile(rawContent, defaultName) {
+        let description = '';
+        let template = rawContent;
+        const frontmatterMatch = rawContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+        if (frontmatterMatch) {
+            const frontmatter = frontmatterMatch[1];
+            template = frontmatterMatch[2].trim();
+            const descMatch = frontmatter.match(/description:\s*([^\r\n]+)/i);
+            if (descMatch) {
+                description = descMatch[1].trim().replace(/^["']|["']$/g, '');
+            }
+        }
+        else {
+            // Check for first-line Markdown heading or comment: # Description
+            const firstLine = rawContent.split('\n')[0].trim();
+            if (firstLine.startsWith('# ')) {
+                description = firstLine.replace(/^#\s*/, '').trim();
+            }
+        }
+        return { description, template };
+    }
+}

package/dist/core/repomap.js

@@ -0,0 +1,135 @@
+import fs from 'fs/promises';
+import path from 'path';
+const IGNORED_DIRS = new Set([
+    '.git', 'node_modules', 'dist', 'build', 'out', 'coverage',
+    '.next', '.nuxt', '.cache', '.gemini', '.antigravity', '.vscode', '.idea'
+]);
+const EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.mjs', '.cjs', '.rs', '.go', '.c', '.cpp', '.h', '.java']);
+export class RepoMapGenerator {
+    /**
+     * Generates a compact, compressed tree representation of project files and key symbols
+     */
+    static async generate(rootDir = process.cwd(), maxFiles = 60) {
+        try {
+            const files = await this.scanFiles(rootDir, maxFiles);
+            if (files.length === 0)
+                return '';
+            const lines = ['Project Structure & Key Symbols (Repo Map):'];
+            for (const file of files) {
+                const symbolStr = file.symbols.length > 0 ? ` (${file.symbols.slice(0, 5).join(', ')}${file.symbols.length > 5 ? ', ...' : ''})` : '';
+                lines.push(`• ${file.relPath}${symbolStr}`);
+            }
+            return lines.join('\n');
+        }
+        catch {
+            return '';
+        }
+    }
+    static async scanFiles(dir, maxFiles) {
+        const results = [];
+        async function walk(currentDir) {
+            if (results.length >= maxFiles)
+                return;
+            try {
+                const entries = await fs.readdir(currentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (results.length >= maxFiles)
+                        break;
+                    if (entry.isDirectory()) {
+                        if (!IGNORED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+                            await walk(path.join(currentDir, entry.name));
+                        }
+                    }
+                    else if (entry.isFile()) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (EXTENSIONS.has(ext)) {
+                            const fullPath = path.join(currentDir, entry.name);
+                            const relPath = path.relative(dir, fullPath).replace(/\\/g, '/');
+                            const symbols = await RepoMapGenerator.extractSymbols(fullPath, ext);
+                            results.push({ relPath, symbols });
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        await walk(dir);
+        return results;
+    }
+    static async extractSymbols(filePath, ext) {
+        const symbols = [];
+        try {
+            // Read at most 16KB of each file for super-fast symbol extraction
+            const stat = await fs.stat(filePath);
+            if (stat.size > 256 * 1024)
+                return []; // Skip giant generated files
+            const content = await fs.readFile(filePath, 'utf8');
+            const lines = content.split('\n').slice(0, 300); // Only examine top 300 lines
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' || ext === '.mjs') {
+                    // JS/TS exports: function, class, interface, type, const
+                    const fnMatch = trimmed.match(/^export\s+(?:async\s+)?function\s+([a-zA-Z0-9_$]+)/);
+                    if (fnMatch) {
+                        symbols.push(`fn ${fnMatch[1]}`);
+                        continue;
+                    }
+                    const classMatch = trimmed.match(/^export\s+(?:abstract\s+)?class\s+([a-zA-Z0-9_$]+)/);
+                    if (classMatch) {
+                        symbols.push(`class ${classMatch[1]}`);
+                        continue;
+                    }
+                    const ifaceMatch = trimmed.match(/^export\s+interface\s+([a-zA-Z0-9_$]+)/);
+                    if (ifaceMatch) {
+                        symbols.push(`interface ${ifaceMatch[1]}`);
+                        continue;
+                    }
+                    const typeMatch = trimmed.match(/^export\s+type\s+([a-zA-Z0-9_$]+)/);
+                    if (typeMatch) {
+                        symbols.push(`type ${typeMatch[1]}`);
+                        continue;
+                    }
+                    const constMatch = trimmed.match(/^export\s+const\s+([a-zA-Z0-9_$]+)/);
+                    if (constMatch && !constMatch[1].startsWith('_')) {
+                        symbols.push(constMatch[1]);
+                        continue;
+                    }
+                }
+                else if (ext === '.py') {
+                    // Python classes and functions
+                    const pyClass = trimmed.match(/^class\s+([a-zA-Z0-9_]+)/);
+                    if (pyClass) {
+                        symbols.push(`class ${pyClass[1]}`);
+                        continue;
+                    }
+                    const pyFn = trimmed.match(/^(?:async\s+)?def\s+([a-zA-Z0-9_]+)/);
+                    if (pyFn && !pyFn[1].startsWith('__')) {
+                        symbols.push(`def ${pyFn[1]}`);
+                        continue;
+                    }
+                }
+                else if (ext === '.rs') {
+                    const rsFn = trimmed.match(/^pub\s+(?:async\s+)?fn\s+([a-zA-Z0-9_]+)/);
+                    if (rsFn) {
+                        symbols.push(`fn ${rsFn[1]}`);
+                        continue;
+                    }
+                    const rsStruct = trimmed.match(/^pub\s+struct\s+([a-zA-Z0-9_]+)/);
+                    if (rsStruct) {
+                        symbols.push(`struct ${rsStruct[1]}`);
+                        continue;
+                    }
+                }
+                else if (ext === '.go') {
+                    const goFn = trimmed.match(/^func\s+(?:\([^\)]+\)\s+)?([a-zA-Z0-9_]+)/);
+                    if (goFn) {
+                        symbols.push(`func ${goFn[1]}`);
+                        continue;
+                    }
+                }
+            }
+        }
+        catch { }
+        return symbols.slice(0, 8);
+    }
+}

package/dist/core/usage.js

@@ -0,0 +1,119 @@
+import pc from 'picocolors';
+import { getCurrentTheme } from '../cli/theme.js';
+export class UsageTracker {
+    static instance;
+    requestsCount = 0;
+    bytesSent = 0;
+    bytesReceived = 0;
+    promptTokens = 0;
+    completionTokens = 0;
+    totalCost = 0;
+    dataSaverLimitMB;
+    warnedThreshold = false;
+    constructor() { }
+    static getInstance() {
+        if (!UsageTracker.instance) {
+            UsageTracker.instance = new UsageTracker();
+        }
+        return UsageTracker.instance;
+    }
+    setLimit(limitMB) {
+        this.dataSaverLimitMB = limitMB;
+    }
+    recordRequest(bytes) {
+        this.requestsCount++;
+        this.bytesSent += Math.max(0, bytes);
+    }
+    recordResponseChunk(bytes) {
+        this.bytesReceived += Math.max(0, bytes);
+    }
+    recordTokens(prompt, completion, cost = 0) {
+        this.promptTokens += Math.max(0, prompt);
+        this.completionTokens += Math.max(0, completion);
+        this.totalCost += Math.max(0, cost);
+    }
+    getSummary() {
+        return {
+            requestsCount: this.requestsCount,
+            bytesSent: this.bytesSent,
+            bytesReceived: this.bytesReceived,
+            totalBytes: this.bytesSent + this.bytesReceived,
+            promptTokens: this.promptTokens,
+            completionTokens: this.completionTokens,
+            totalTokens: this.promptTokens + this.completionTokens,
+            totalCost: this.totalCost,
+            dataSaverLimitMB: this.dataSaverLimitMB
+        };
+    }
+    static formatBytes(bytes) {
+        if (bytes <= 0)
+            return '0 B';
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        if (bytes < 1024 * 1024 * 1024)
+            return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+    }
+    static formatTokens(n) {
+        if (n >= 1_000_000)
+            return `${(n / 1_000_000).toFixed(2)}M`;
+        if (n >= 1000)
+            return `${(n / 1000).toFixed(1)}k`;
+        return `${n}`;
+    }
+    renderUsageCard() {
+        const theme = getCurrentTheme();
+        const summary = this.getSummary();
+        const cols = Math.min(process.stdout.columns || 80, 75);
+        const boxWidth = Math.max(34, cols - 4);
+        const innerWidth = boxWidth - 4;
+        const padRow = (label, value) => {
+            const plainLen = label.length + value.length;
+            const spaces = Math.max(1, innerWidth - plainLen);
+            return `│  ${pc.bold(label)}${' '.repeat(spaces)}${value}  │`;
+        };
+        const header = theme.colorFn('┌─ ') + pc.bold('📊 Session Bandwidth & Usage Monitor') + ' ' + theme.colorFn('─'.repeat(Math.max(2, boxWidth - 41)) + '┐');
+        const divider = theme.colorFn('├' + '─'.repeat(boxWidth - 2) + '┤');
+        const footer = theme.colorFn('└' + '─'.repeat(boxWidth - 2) + '┘');
+        const totalBandwidthStr = pc.cyan(UsageTracker.formatBytes(summary.totalBytes));
+        const sentStr = pc.dim(UsageTracker.formatBytes(summary.bytesSent));
+        const recvStr = pc.dim(UsageTracker.formatBytes(summary.bytesReceived));
+        const reqStr = pc.yellow(`${summary.requestsCount}`);
+        const tokenStr = pc.magenta(`${UsageTracker.formatTokens(summary.totalTokens)} tokens`);
+        const promptTokenStr = pc.dim(`${UsageTracker.formatTokens(summary.promptTokens)} in`);
+        const compTokenStr = pc.dim(`${UsageTracker.formatTokens(summary.completionTokens)} out`);
+        const costStr = pc.green(`$${summary.totalCost.toFixed(4)}`);
+        const lines = [
+            header,
+            padRow('Total Network Traffic:', totalBandwidthStr),
+            padRow('  • Upload (Sent):', sentStr),
+            padRow('  • Download (Recv):', recvStr),
+            padRow('API Requests Count:', reqStr),
+            divider,
+            padRow('Tokens Consumed:', tokenStr),
+            padRow('  • Breakdown:', `${promptTokenStr} / ${compTokenStr}`),
+            padRow('Session Cost:', costStr)
+        ];
+        if (summary.dataSaverLimitMB) {
+            const usedMB = summary.totalBytes / (1024 * 1024);
+            const pct = Math.min(100, Math.round((usedMB / summary.dataSaverLimitMB) * 100));
+            const limitStr = pct >= 90 ? pc.red(`${usedMB.toFixed(1)} / ${summary.dataSaverLimitMB} MB (${pct}%)`) : pc.cyan(`${usedMB.toFixed(1)} / ${summary.dataSaverLimitMB} MB (${pct}%)`);
+            lines.push(divider);
+            lines.push(padRow('Data Saver Limit:', limitStr));
+        }
+        lines.push(footer);
+        return lines.join('\n') + '\n';
+    }
+    checkThresholdWarning() {
+        if (!this.dataSaverLimitMB || this.warnedThreshold)
+            return null;
+        const usedMB = (this.bytesSent + this.bytesReceived) / (1024 * 1024);
+        if (usedMB >= this.dataSaverLimitMB) {
+            this.warnedThreshold = true;
+            return `⚠️  [DATA SAVER WARNING] Session network traffic has reached ${usedMB.toFixed(1)} MB (Limit: ${this.dataSaverLimitMB} MB)!`;
+        }
+        return null;
+    }
+}

package/dist/permissions/guard.js

@@ -34,14 +34,34 @@ function isDangerousBashCommand(commandStr) {
         lower.includes('> /dev/sda') ||
         lower.includes('format c:'));
 }
+/**
+ * Checks if a command contains chaining, redirection, or subshell operators.
+ * Allowlist matches MUST be clean, single commands without hidden side-effects.
+ */
+function hasComplexChainingOrRedirection(commandStr) {
+    if (!commandStr)
+        return false;
+    return (commandStr.includes('&&') ||
+        commandStr.includes('||') ||
+        commandStr.includes(';') ||
+        commandStr.includes('|') ||
+        commandStr.includes('>') ||
+        commandStr.includes('<') ||
+        commandStr.includes('`') ||
+        commandStr.includes('$(') ||
+        commandStr.includes('\n') ||
+        commandStr.includes('\r'));
+}
 export class CLIConsoleGuard {
     autoApprove;
-    constructor(autoApprove = false) {
+    bashAllowlist;
+    constructor(autoApprove = false, bashAllowlist = []) {
         this.autoApprove = autoApprove;
+        this.bashAllowlist = bashAllowlist;
     }
     check(toolName, args) {
         const t = (toolName || '').toLowerCase();
-        const cmd = args?.command || args?.cmd || '';
+        const cmd = (args?.command || args?.cmd || '').trim();
         // Critical safety net: even in YOLO mode, warn and confirm destructive system commands
         if (this.autoApprove) {
             if (t === 'bash' && isDangerousBashCommand(cmd)) {
@@ -49,9 +69,19 @@ export class CLIConsoleGuard {
             }
             return false;
         }
-        // 1. Shell commands always require confirmation in safe mode
-        if (t === 'bash' || t === 'exec' || t === 'run_command') {
-            return true;
+        // Check Bash Allowlist: only allow if command is NOT dangerous AND does not use chaining/redirection
+        if ((t === 'bash' || t === 'exec' || t === 'run_command') && cmd) {
+            if (!isDangerousBashCommand(cmd) && !hasComplexChainingOrRedirection(cmd)) {
+                const isAllowed = this.bashAllowlist.some(pattern => {
+                    const p = pattern.trim().toLowerCase();
+                    const lowerCmd = cmd.toLowerCase();
+                    return lowerCmd === p || lowerCmd.startsWith(p + ' ');
+                });
+                if (isAllowed) {
+                    return false; // Automatically allowed!
+                }
+            }
+            return true; // Requires user confirmation
         }
         // 2. Package installations require confirmation
         if (t === 'install_package' || t === 'packages') {

package/dist/prompts/builder.js

@@ -72,5 +72,14 @@ export async function buildSystemPrompt(planMode) {
     }
     catch (e) {
     }
+    // Load Compact Repo Map (AST structure & exported symbols)
+    try {
+        const { RepoMapGenerator } = await import('../core/repomap.js');
+        const repoMap = await RepoMapGenerator.generate(process.cwd(), 50);
+        if (repoMap.trim()) {
+            prompt += `\n--- Codebase Map & Exported Symbols ---\n${repoMap}\n----------------------------------------\n`;
+        }
+    }
+    catch { }
     return prompt;
 }

package/dist/providers/openai.js

@@ -1,4 +1,5 @@
 import { calculateCost } from '../core/pricing.js';
+import { UsageTracker } from '../core/usage.js';
 export class OpenAIProvider {
     baseUrl;
     apiKey;
@@ -66,20 +67,23 @@ export class OpenAIProvider {
     async chat(request) {
         const url = `${this.baseUrl}/chat/completions`;
         const payload = this.buildPayload(request, false);
+        const bodyStr = JSON.stringify(payload);
         const headers = {
             'Content-Type': 'application/json',
         };
         if (this.apiKey) {
             headers['Authorization'] = `Bearer ${this.apiKey}`;
         }
+        UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
         const res = await fetch(url, {
             method: 'POST',
             headers,
-            body: JSON.stringify(payload),
+            body: bodyStr,
             signal: request.signal
         });
         if (!res.ok) {
             const errText = await res.text();
+            UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(errText, 'utf8'));
             let errMsg = errText;
             try {
                 const parsed = JSON.parse(errText);
@@ -95,7 +99,15 @@ export class OpenAIProvider {
             err.status = res.status;
             throw err;
         }
-        const data = await res.json();
+        const rawResText = await res.text();
+        UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(rawResText, 'utf8'));
+        let data = {};
+        try {
+            data = JSON.parse(rawResText);
+        }
+        catch {
+            throw new Error(`Invalid JSON response from provider`);
+        }
         if (data.error) {
             const msg = data.error.message || data.error.code || JSON.stringify(data.error);
             throw new Error(`Provider Error: ${msg}`);
@@ -115,6 +127,7 @@ export class OpenAIProvider {
                 totalTokens,
                 cost
             };
+            UsageTracker.getInstance().recordTokens(promptTokens, completionTokens, cost);
         }
         return {
             content: choice.content || null,
@@ -129,20 +142,23 @@ export class OpenAIProvider {
     async *chatStream(request) {
         const url = `${this.baseUrl}/chat/completions`;
         const payload = this.buildPayload(request, true);
+        const bodyStr = JSON.stringify(payload);
         const headers = {
             'Content-Type': 'application/json',
         };
         if (this.apiKey) {
             headers['Authorization'] = `Bearer ${this.apiKey}`;
         }
+        UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
         const res = await fetch(url, {
             method: 'POST',
             headers,
-            body: JSON.stringify(payload),
+            body: bodyStr,
             signal: request.signal
         });
         if (!res.ok) {
             const errText = await res.text();
+            UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(errText, 'utf8'));
             let errMsg = errText;
             try {
                 const parsed = JSON.parse(errText);
@@ -184,6 +200,9 @@ export class OpenAIProvider {
                 const { done, value } = await reader.read();
                 if (done || request.signal?.aborted)
                     break;
+                if (value) {
+                    UsageTracker.getInstance().recordResponseChunk(value.byteLength);
+                }
                 buffer += decoder.decode(value, { stream: true });
                 const lines = buffer.split('\n');
                 buffer = lines.pop() || '';
@@ -333,6 +352,7 @@ export class OpenAIProvider {
             totalTokens,
             cost
         };
+        UsageTracker.getInstance().recordTokens(promptTokens, completionTokens, cost);
         const finalResponse = {
             content: accumulatedContent || null,
             toolCalls: toolCalls.length > 0 ? toolCalls : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.2.2",
+  "version": "1.3.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",