termux-dev 1.4.19 → 1.5.0

package/dist/cli/statusline.js

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

package/dist/cli/telemetry.js

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

package/dist/core/types.js

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

package/dist/mcp/client.js

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

package/dist/permissions/guard.js

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

package/dist/providers/openai.js

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

package/dist/tools/fs.js

@@ -108,7 +108,8 @@ export const editFileTool = {
             properties: {
                 path: { type: 'string', description: 'Path to the file to edit' },
                 target: { type: 'string', description: 'Exact string or block of code to replace' },
-                replacement: { type: 'string', description: 'New string or block of code to replace with' }
+                replacement: { type: 'string', description: 'New string or block of code to replace with' },
+                replaceAll: { type: 'boolean', description: 'If true, replaces all occurrences of target in the file. Default is false.' }
             },
             required: ['path', 'target', 'replacement']
         }
@@ -138,14 +139,48 @@ export const editFileTool = {
                     throw new Error(`Target text to replace was not found in ${args.path}. Ensure exact indentation and characters match.`);
                 }
             }
-            const targetIndex = content.indexOf(target);
-            const allLines = content.split('\n');
-            const startLine = content.slice(0, targetIndex).split('\n').length;
-            const removedArr = target.split('\n');
+            // Find all matching occurrences
+            const matches = [];
+            let searchPos = 0;
+            while (searchPos < content.length) {
+                const idx = content.indexOf(target, searchPos);
+                if (idx === -1)
+                    break;
+                matches.push(idx);
+                searchPos = idx + Math.max(1, target.length);
+            }
+            const isReplaceAll = args.replaceAll === true || args.replaceAll === 'true';
+            if (matches.length > 1 && !isReplaceAll) {
+                const lineNumbers = matches.map(idx => content.slice(0, idx).split(/\r?\n/).length);
+                throw new Error(`Target text matches ${matches.length} occurrences in ${args.path} at lines: [${lineNumbers.join(', ')}]. ` +
+                    `Please provide more surrounding lines/context to make the target block unique, or set replaceAll: true to replace all instances.`);
+            }
+            const hasCRLF = oldContent.includes('\r\n');
+            const removedArr = target.split(/\r?\n/);
+            const addedArr = args.replacement.split(/\r?\n/);
+            if (isReplaceAll && matches.length > 1) {
+                let newContent = content.split(target).join(args.replacement);
+                if (hasCRLF) {
+                    newContent = newContent.replace(/\r?\n/g, '\r\n');
+                }
+                else {
+                    newContent = newContent.replace(/\r\n/g, '\n');
+                }
+                await fs.writeFile(args.path, newContent, 'utf8');
+                return JSON.stringify({
+                    status: 'success',
+                    action: 'edit',
+                    path: args.path,
+                    occurrencesReplaced: matches.length,
+                    summary: `Successfully replaced all ${matches.length} occurrences in ${args.path}`
+                });
+            }
+            const targetIndex = matches[0];
+            const allLines = content.split(/\r?\n/);
+            const startLine = content.slice(0, targetIndex).split(/\r?\n/).length;
             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 = [];
             let lineCounter = startLine - contextBefore.length;
             contextBefore.forEach((l) => diffLines.push(`${lineCounter++}    ${l}`));
@@ -153,7 +188,6 @@ export const editFileTool = {
             let addCounter = startLine;
             addedArr.forEach((l) => diffLines.push(`${addCounter++} +  ${l}`));
             contextAfter.forEach((l) => diffLines.push(`${addCounter++}    ${l}`));
-            const hasCRLF = oldContent.includes('\r\n');
             let newContent = content.slice(0, targetIndex) + args.replacement + content.slice(targetIndex + target.length);
             if (hasCRLF) {
                 newContent = newContent.replace(/\r?\n/g, '\r\n');

package/dist/tools/packages.js

@@ -18,6 +18,10 @@ export const installPackageTool = {
     validateArgs(args) {
         if (!args.package || typeof args.package !== 'string')
             throw new Error('package is required');
+        const sanitized = args.package.trim();
+        if (!/^[@a-zA-Z0-9_\-./=><^~+:[\] ]+$/.test(sanitized) || /[;&|`$\n\r()]/.test(sanitized)) {
+            throw new Error(`Invalid package name: "${args.package}". Invalid characters or potential command injection detected.`);
+        }
     },
     async execute(args) {
         let pkgManager = args.manager;
@@ -40,29 +44,49 @@ export const installPackageTool = {
                 pkgManager = 'npm';
             }
         }
-        let cmd = '';
+        let executable = 'npm';
+        let cmdArgs = [];
+        const pkgs = args.package.trim().split(/\s+/);
         if (pkgManager === 'npm') {
-            cmd = `npm install ${args.dev ? '-D ' : ''}${args.package}`;
+            executable = 'npm';
+            cmdArgs = ['install'];
+            if (args.dev)
+                cmdArgs.push('-D');
+            cmdArgs.push(...pkgs);
         }
         else if (pkgManager === 'yarn') {
-            cmd = `yarn add ${args.dev ? '-D ' : ''}${args.package}`;
+            executable = 'yarn';
+            cmdArgs = ['add'];
+            if (args.dev)
+                cmdArgs.push('-D');
+            cmdArgs.push(...pkgs);
         }
         else if (pkgManager === 'pnpm') {
-            cmd = `pnpm add ${args.dev ? '-D ' : ''}${args.package}`;
+            executable = 'pnpm';
+            cmdArgs = ['add'];
+            if (args.dev)
+                cmdArgs.push('-D');
+            cmdArgs.push(...pkgs);
         }
         else if (pkgManager === 'pip') {
-            const isUnix = process.platform !== 'win32';
-            const extraFlag = isUnix ? ' --break-system-packages' : '';
-            cmd = `pip install ${args.package}${extraFlag}`;
+            executable = 'pip';
+            cmdArgs = ['install'];
+            if (process.platform !== 'win32') {
+                cmdArgs.push('--break-system-packages');
+            }
+            cmdArgs.push(...pkgs);
         }
         else if (pkgManager === 'cargo') {
-            cmd = `cargo add ${args.package}`;
+            executable = 'cargo';
+            cmdArgs = ['add', ...pkgs];
         }
         else {
-            cmd = `npm install ${args.package}`;
+            executable = 'npm';
+            cmdArgs = ['install', ...pkgs];
         }
+        const isWin = process.platform === 'win32';
         return new Promise((resolve) => {
-            const proc = spawn(cmd, { shell: true });
+            const proc = spawn(executable, cmdArgs, { shell: isWin });
             let output = '';
             proc.stdout.on('data', (d) => { output += d.toString(); });
             proc.stderr.on('data', (d) => { output += d.toString(); });
@@ -75,7 +99,7 @@ export const installPackageTool = {
                 }
             });
             proc.on('error', (err) => {
-                resolve(`Failed to run ${cmd}: ${err.message}`);
+                resolve(`Failed to run ${executable} ${cmdArgs.join(' ')}: ${err.message}`);
             });
         });
     }

package/dist/tools/search.js

@@ -11,9 +11,20 @@ const IGNORED_DIRS = new Set([
     '.cache',
     'vendor'
 ]);
-async function searchFiles(dir, query, results, maxResults = 50) {
-    if (results.length >= maxResults)
+const MAX_FILE_SIZE = 512 * 1024; // 512 KB
+async function searchFiles(dir, query, results, maxResults = 50, visitedDirs = new Set(), depth = 0) {
+    if (results.length >= maxResults || depth > 15)
         return;
+    let realDir;
+    try {
+        realDir = await fs.realpath(dir);
+        if (visitedDirs.has(realDir))
+            return;
+        visitedDirs.add(realDir);
+    }
+    catch {
+        return;
+    }
     let entries;
     try {
         entries = await fs.readdir(dir, { withFileTypes: true });
@@ -28,19 +39,27 @@ async function searchFiles(dir, query, results, maxResults = 50) {
         const relPath = path.relative(process.cwd(), fullPath) || fullPath;
         if (entry.isDirectory()) {
             if (!IGNORED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
-                await searchFiles(fullPath, query, results, maxResults);
+                await searchFiles(fullPath, query, results, maxResults, visitedDirs, depth + 1);
             }
         }
         else if (entry.isFile()) {
             // Skip large binary extensions
             const ext = path.extname(entry.name).toLowerCase();
-            if (['.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip', '.tar', '.gz', '.exe', '.dll', '.so', '.wasm'].includes(ext)) {
+            if (['.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip', '.tar', '.gz', '.exe', '.dll', '.so', '.wasm', '.bin', '.db', '.sqlite'].includes(ext)) {
                 continue;
             }
             try {
+                const stat = await fs.stat(fullPath);
+                if (stat.size > MAX_FILE_SIZE) {
+                    continue;
+                }
                 const content = await fs.readFile(fullPath, 'utf8');
+                // Skip binary files (e.g. compiled executables without extension) containing null bytes
+                if (content.includes('\0')) {
+                    continue;
+                }
                 if (content.toLowerCase().includes(query.toLowerCase())) {
-                    const lines = content.split('\n');
+                    const lines = content.split(/\r?\n/);
                     for (let i = 0; i < lines.length; i++) {
                         if (results.length >= maxResults)
                             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.4.19",
+  "version": "1.5.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",
@@ -21,6 +21,8 @@
     "build": "tsc && node ./scripts/copy-assets.js",
     "start": "node ./bin/devx.js",
     "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "engines": {
@@ -61,6 +63,7 @@
     "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.0.0",
     "@types/qrcode-terminal": "^0.12.2",
-    "typescript": "^5.4.0"
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.11"
   }
 }