termux-dev 1.2.2 → 1.4.0

package/dist/cli/prompt.js

@@ -2,11 +2,15 @@ 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: '/mcp', desc: 'Manage Model Context Protocol (MCP) servers & tools' },
     { 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 +47,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 +97,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.4.0 &bull; Terminal-Native AI Assistant</div>
   </div>
 </body>
 </html>`;

package/dist/cli/updater.js

@@ -85,12 +85,6 @@ export async function checkForUpdates(timeoutMs = 10000) {
             currentVersion,
             latestVersion: latestVersion || currentVersion
         };
-        return {
-            updateAvailable: false,
-            currentVersion,
-            latestVersion: currentVersion,
-            error: `HTTP ${res.status}`
-        };
     }
     catch (err) {
         clearTimeout(timer);

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/history.js

@@ -16,6 +16,16 @@ export class History {
     getMessages() {
         return [...this.messages];
     }
+    popLastTurn() {
+        // Pop assistant and tool messages from the end of history
+        while (this.messages.length > 1 && this.messages[this.messages.length - 1].role !== 'user') {
+            this.messages.pop();
+        }
+        // Pop the triggering user message
+        if (this.messages.length > 1 && this.messages[this.messages.length - 1].role === 'user') {
+            this.messages.pop();
+        }
+    }
     clear() {
         this.messages = [];
     }

package/dist/core/loop.js

@@ -94,9 +94,13 @@ export class Agent {
                                 response = chunk.response;
                             }
                         }
-                        if (response || receivedAnyChunk) {
+                        if (response) {
                             break;
                         }
+                        if (!receivedAnyChunk) {
+                            throw new Error('Provider stream ended unexpectedly without receiving any data.');
+                        }
+                        break;
                     }
                     else {
                         response = await this.provider.chat(request);

package/dist/core/models.js

@@ -33,7 +33,7 @@ export function getModelContextLimit(modelName) {
         return cache[clean];
     if (cache[short])
         return cache[short];
-    const baseName = short.replace(/\-\d {4,8}$/, '').replace(/:latest$/, '');
+    const baseName = short.replace(/-\d{4,8}$/, '').replace(/:latest$/, '');
     if (cache[baseName])
         return cache[baseName];
     if (clean.includes('kimi-k2') || clean.includes('kimi'))

package/dist/core/pricing.js

@@ -42,7 +42,7 @@ export function getModelPricing(modelName) {
         return cache[clean];
     if (cache[short])
         return cache[short];
-    const baseName = short.replace(/\-\d {4,8}$/, '').replace(/:latest$/, '');
+    const baseName = short.replace(/-\d{4,8}$/, '').replace(/:latest$/, '');
     if (cache[baseName])
         return cache[baseName];
     if (clean.includes('gpt-4o-mini'))

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';
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+export class UsageTracker {
+    static instance;
+    bytesSent = 0;
+    bytesReceived = 0;
+    requestsCount = 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(payloadBytes) {
+        this.bytesSent += payloadBytes;
+        this.requestsCount += 1;
+    }
+    recordResponseChunk(chunkBytes) {
+        this.bytesReceived += chunkBytes;
+    }
+    recordTokens(promptTokens, completionTokens, cost) {
+        this.promptTokens += promptTokens;
+        this.completionTokens += completionTokens;
+        this.totalCost += cost;
+    }
+    getSummary() {
+        return {
+            bytesSent: this.bytesSent,
+            bytesReceived: this.bytesReceived,
+            totalBytes: this.bytesSent + this.bytesReceived,
+            requestsCount: this.requestsCount,
+            promptTokens: this.promptTokens,
+            completionTokens: this.completionTokens,
+            totalTokens: this.promptTokens + this.completionTokens,
+            totalCost: this.totalCost,
+            dataSaverLimitMB: this.dataSaverLimitMB
+        };
+    }
+    static formatBytes(bytes) {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+    static formatTokens(n) {
+        if (n >= 1000000)
+            return `${(n / 1000000).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(38, cols - 4);
+        const innerWidth = boxWidth - 6;
+        const padRow = (label, value) => {
+            const visibleValLen = stripAnsi(value).length;
+            const plainLen = label.length + visibleValLen;
+            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;
+    }
+}