termux-dev 1.4.12 → 1.4.14

package/dist/core/models.js

@@ -1,6 +1,18 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+const FALLBACK_LIMITS = {
+    'claude-3.5-sonnet': 200000,
+    'claude-3-opus': 200000,
+    'gemini-2.5-flash': 1048576,
+    'gemini-2.5-pro': 1048576,
+    'gemini-2.0-flash': 1048576,
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'deepseek-chat': 128000,
+    'deepseek-r1': 128000,
+    'qwen-2.5-coder': 131072,
+};
 let limitsCache = null;
 function loadLimits() {
     if (limitsCache)
@@ -22,7 +34,7 @@ function loadLimits() {
         }
     }
     catch { }
-    limitsCache = {};
+    limitsCache = { ...FALLBACK_LIMITS };
     return limitsCache;
 }
 export function getModelContextLimit(modelName) {

package/dist/core/notify.js

@@ -1,6 +1,20 @@
 import { spawn } from 'child_process';
 export function isTermux() {
-    return !!process.env.PREFIX?.includes('com.termux');
+    return !!process.env.TERMUX_VERSION || !!process.env.PREFIX?.includes('com.termux');
+}
+/**
+ * Acquires a Termux CPU wake lock to prevent Android from putting the process to sleep
+ * when Termux is in the background or the screen is turned off.
+ */
+export function acquireWakeLock() {
+    if (isTermux()) {
+        try {
+            const proc = spawn('termux-wake-lock', [], { stdio: 'ignore', detached: true });
+            proc.on('error', () => { });
+            proc.unref();
+        }
+        catch { }
+    }
 }
 /**
  * Sends a notification and haptic vibration to the device.

package/dist/core/pricing.js

@@ -27,9 +27,10 @@ function loadPricing() {
 }
 export function getModelPricing(modelName) {
     const clean = (modelName || '').trim().toLowerCase();
-    if (clean.includes(':free') ||
+    if (clean.endsWith(':free') ||
         clean.includes('/free') ||
-        clean.includes('free') ||
+        clean === 'free' ||
+        clean.includes('free-models/') ||
         clean.includes('stealth') ||
         clean.includes('local') ||
         clean.includes('ollama') ||

package/dist/mcp/client.js

@@ -63,7 +63,7 @@ export class MCPClient {
                     capabilities: {},
                     clientInfo: {
                         name: 'devx',
-                        version: '1.4.12'
+                        version: '1.4.14'
                     }
                 });
                 if (!initResult) {

package/dist/permissions/guard.js

@@ -149,10 +149,25 @@ export class CLIConsoleGuard {
         else {
             console.log(`  ${pc.dim('Arguments:')} ${JSON.stringify(args, null, 2)}`);
         }
-        const allowed = await p.confirm({
-            message: isDangerous ? pc.red('Confirm executing this dangerous command?') : 'Allow execution?',
-            initialValue: !isDangerous
-        });
+        // Pause raw mode for interactive prompt
+        const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
+        if (wasRaw) {
+            process.stdin.setRawMode(false);
+        }
+        let allowed = false;
+        try {
+            allowed = await p.confirm({
+                message: isDangerous ? pc.red('Confirm executing this dangerous command?') : 'Allow execution?',
+                initialValue: !isDangerous
+            });
+        }
+        finally {
+            // Restore raw mode
+            if (wasRaw && process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+                process.stdin.resume();
+            }
+        }
         return allowed === true;
     }
 }

package/dist/providers/openai.js

@@ -200,6 +200,7 @@ export class OpenAIProvider {
         let accumulatedContent = '';
         let accumulatedReasoning = '';
         let inThinkTag = false;
+        let thinkBuffer = '';
         const toolMap = new Map();
         let usageData = null;
         try {
@@ -243,39 +244,67 @@ export class OpenAIProvider {
                             }
                             // 2. Check content (and handle <think> tags if embedded in content)
                             if (delta.content) {
-                                const text = delta.content;
-                                if (text.includes('<think>')) {
-                                    inThinkTag = true;
-                                    const parts = text.split('<think>');
-                                    if (parts[0]) {
-                                        accumulatedContent += parts[0];
-                                        yield { type: 'content_delta', delta: parts[0] };
-                                    }
-                                    if (parts[1]) {
-                                        accumulatedReasoning += parts[1];
-                                        yield { type: 'reasoning_delta', delta: parts[1] };
-                                    }
-                                }
-                                else if (text.includes('</think>')) {
-                                    inThinkTag = false;
-                                    const parts = text.split('</think>');
-                                    if (parts[0]) {
-                                        accumulatedReasoning += parts[0];
-                                        yield { type: 'reasoning_delta', delta: parts[0] };
+                                thinkBuffer += delta.content;
+                                while (thinkBuffer.length > 0) {
+                                    if (inThinkTag) {
+                                        const closeIdx = thinkBuffer.indexOf('</think>');
+                                        if (closeIdx !== -1) {
+                                            const reasoning = thinkBuffer.slice(0, closeIdx);
+                                            if (reasoning) {
+                                                accumulatedReasoning += reasoning;
+                                                yield { type: 'reasoning_delta', delta: reasoning };
+                                            }
+                                            inThinkTag = false;
+                                            thinkBuffer = thinkBuffer.slice(closeIdx + 8);
+                                        }
+                                        else {
+                                            const partialIdx = thinkBuffer.lastIndexOf('<');
+                                            if (partialIdx !== -1 && thinkBuffer.length - partialIdx < 8) {
+                                                const reasoning = thinkBuffer.slice(0, partialIdx);
+                                                if (reasoning) {
+                                                    accumulatedReasoning += reasoning;
+                                                    yield { type: 'reasoning_delta', delta: reasoning };
+                                                }
+                                                thinkBuffer = thinkBuffer.slice(partialIdx);
+                                                break;
+                                            }
+                                            else {
+                                                accumulatedReasoning += thinkBuffer;
+                                                yield { type: 'reasoning_delta', delta: thinkBuffer };
+                                                thinkBuffer = '';
+                                            }
+                                        }
                                     }
-                                    if (parts[1]) {
-                                        accumulatedContent += parts[1];
-                                        yield { type: 'content_delta', delta: parts[1] };
+                                    else {
+                                        const openIdx = thinkBuffer.indexOf('<think>');
+                                        if (openIdx !== -1) {
+                                            const content = thinkBuffer.slice(0, openIdx);
+                                            if (content) {
+                                                accumulatedContent += content;
+                                                yield { type: 'content_delta', delta: content };
+                                            }
+                                            inThinkTag = true;
+                                            thinkBuffer = thinkBuffer.slice(openIdx + 7);
+                                        }
+                                        else {
+                                            const partialIdx = thinkBuffer.lastIndexOf('<');
+                                            if (partialIdx !== -1 && thinkBuffer.length - partialIdx < 8) {
+                                                const content = thinkBuffer.slice(0, partialIdx);
+                                                if (content) {
+                                                    accumulatedContent += content;
+                                                    yield { type: 'content_delta', delta: content };
+                                                }
+                                                thinkBuffer = thinkBuffer.slice(partialIdx);
+                                                break;
+                                            }
+                                            else {
+                                                accumulatedContent += thinkBuffer;
+                                                yield { type: 'content_delta', delta: thinkBuffer };
+                                                thinkBuffer = '';
+                                            }
+                                        }
                                     }
                                 }
-                                else if (inThinkTag) {
-                                    accumulatedReasoning += text;
-                                    yield { type: 'reasoning_delta', delta: text };
-                                }
-                                else {
-                                    accumulatedContent += text;
-                                    yield { type: 'content_delta', delta: text };
-                                }
                             }
                             // 3. Accumulate tool calls and yield live progress
                             if (delta.tool_calls) {
@@ -331,6 +360,16 @@ export class OpenAIProvider {
         finally {
             reader.releaseLock();
         }
+        if (thinkBuffer.length > 0) {
+            if (inThinkTag) {
+                accumulatedReasoning += thinkBuffer;
+                yield { type: 'reasoning_delta', delta: thinkBuffer };
+            }
+            else {
+                accumulatedContent += thinkBuffer;
+                yield { type: 'content_delta', delta: thinkBuffer };
+            }
+        }
         const toolCalls = Array.from(toolMap.values()).map(tc => {
             let parsedArgs = {};
             try {

package/dist/tools/bash.js

@@ -18,11 +18,23 @@ export const bashTool = {
     },
     async execute(args) {
         return new Promise((resolve, reject) => {
-            const proc = spawn(args.command, { shell: true });
+            const isWin = process.platform === 'win32';
+            const proc = spawn(args.command, { shell: true, detached: !isWin });
             let output = '';
             let isTruncated = false;
+            const killProc = () => {
+                try {
+                    if (!isWin && proc.pid) {
+                        process.kill(-proc.pid, 'SIGTERM');
+                    }
+                    else {
+                        proc.kill();
+                    }
+                }
+                catch { }
+            };
             const timeout = setTimeout(() => {
-                proc.kill();
+                killProc();
                 resolve(output + '\n[Process killed due to timeout]');
             }, 30000);
             proc.stdout.on('data', (data) => {
@@ -32,7 +44,7 @@ export const bashTool = {
                 if (output.length > 20000) {
                     isTruncated = true;
                     output = output.substring(0, 20000) + '\n[Output truncated]';
-                    proc.kill();
+                    killProc();
                 }
             });
             proc.stderr.on('data', (data) => {
@@ -42,7 +54,7 @@ export const bashTool = {
                 if (output.length > 20000) {
                     isTruncated = true;
                     output = output.substring(0, 20000) + '\n[Output truncated]';
-                    proc.kill();
+                    killProc();
                 }
             });
             proc.on('close', (code) => {

package/dist/tools/diagnostics.js

@@ -17,19 +17,20 @@ export const diagnoseCodeTool = {
         return new Promise((resolve) => {
             let cmd = '';
             if (args.file) {
+                const quotedFile = `"${args.file}"`;
                 if (args.file.endsWith('.ts') || args.file.endsWith('.tsx')) {
                     if (fsSync.existsSync('tsconfig.json')) {
                         cmd = 'npx tsc --noEmit';
                     }
                     else {
-                        cmd = `node --check ${args.file}`;
+                        cmd = `echo "node --check does not work for TypeScript. Please use tsc or tsx."`;
                     }
                 }
                 else if (args.file.endsWith('.js') || args.file.endsWith('.mjs') || args.file.endsWith('.cjs')) {
-                    cmd = `node --check ${args.file}`;
+                    cmd = `node --check ${quotedFile}`;
                 }
                 else if (args.file.endsWith('.py')) {
-                    cmd = `python -m py_compile ${args.file}`;
+                    cmd = `python -m py_compile ${quotedFile}`;
                 }
                 else if (args.file.endsWith('.rs')) {
                     cmd = 'cargo check';

package/dist/tools/fs.js

@@ -153,7 +153,14 @@ export const editFileTool = {
             let addCounter = startLine;
             addedArr.forEach((l) => diffLines.push(`${addCounter++} +  ${l}`));
             contextAfter.forEach((l) => diffLines.push(`${addCounter++}    ${l}`));
-            const newContent = content.slice(0, targetIndex) + args.replacement + content.slice(targetIndex + target.length);
+            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');
+            }
+            else {
+                newContent = newContent.replace(/\r\n/g, '\n');
+            }
             await fs.writeFile(args.path, newContent, 'utf8');
             return JSON.stringify({
                 status: 'success',
@@ -191,7 +198,9 @@ export const listDirTool = {
     async execute(args) {
         try {
             const files = await fs.readdir(args.path, { withFileTypes: true });
-            return files.map(f => `${f.isDirectory() ? '[DIR]' : '[FILE]'} ${f.name}`).join('\n');
+            const ignores = ['node_modules', '.git', '.next', '.cache', 'dist'];
+            const filtered = files.filter(f => !ignores.includes(f.name));
+            return filtered.map(f => `${f.isDirectory() ? '[DIR]' : '[FILE]'} ${f.name}`).join('\n');
         }
         catch (err) {
             throw new Error(`Failed to list directory: ${err.message}`);

package/dist/tools/packages.js

@@ -51,7 +51,9 @@ export const installPackageTool = {
             cmd = `pnpm add ${args.dev ? '-D ' : ''}${args.package}`;
         }
         else if (pkgManager === 'pip') {
-            cmd = `pip install ${args.package}`;
+            const isUnix = process.platform !== 'win32';
+            const extraFlag = isUnix ? ' --break-system-packages' : '';
+            cmd = `pip install ${args.package}${extraFlag}`;
         }
         else if (pkgManager === 'cargo') {
             cmd = `cargo add ${args.package}`;

package/dist/tools/questions.js

@@ -36,56 +36,73 @@ export const askQuestionsTool = {
         }
     },
     execute: async (args) => {
+        if (!process.stdin.isTTY) {
+            return JSON.stringify({ note: 'Questions skipped in non-interactive mode', answers: {} });
+        }
         if (!args.questions || !Array.isArray(args.questions) || args.questions.length === 0) {
             return 'No questions provided.';
         }
         const results = [];
         const total = args.questions.length;
         console.log();
-        for (let i = 0; i < total; i++) {
-            const q = args.questions[i];
-            const stepHeader = pc.cyan(`‹ ${i + 1} of ${total} ›`);
-            const messageTitle = `${pc.bold(q.question)}  ${stepHeader}`;
-            const choices = q.options.map((opt, idx) => ({
-                name: `${pc.cyan(String(idx + 1))}  ${opt}`,
-                value: opt
-            }));
-            if (q.allowCustom !== false) {
+        // Pause raw mode for interactive prompt
+        const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
+        if (wasRaw) {
+            process.stdin.setRawMode(false);
+        }
+        try {
+            for (let i = 0; i < total; i++) {
+                const q = args.questions[i];
+                const stepHeader = pc.cyan(`‹ ${i + 1} of ${total} ›`);
+                const messageTitle = `${pc.bold(q.question)}  ${stepHeader}`;
+                const choices = q.options.map((opt, idx) => ({
+                    name: `${pc.cyan(String(idx + 1))}  ${opt}`,
+                    value: opt
+                }));
+                if (q.allowCustom !== false) {
+                    choices.push({
+                        name: `${pc.dim('✏️  Type custom answer...')}`,
+                        value: '__custom__'
+                    });
+                }
                 choices.push({
-                    name: `${pc.dim('✏️  Type custom answer...')}`,
-                    value: '__custom__'
+                    name: `${pc.dim('⏭️  Skip')}`,
+                    value: '__skip__'
                 });
-            }
-            choices.push({
-                name: `${pc.dim('⏭️  Skip')}`,
-                value: '__skip__'
-            });
-            try {
-                let answer = await select({
-                    message: messageTitle,
-                    choices,
-                    pageSize: Math.min(8, choices.length)
-                });
-                if (answer === '__custom__') {
-                    const customAns = await input({
-                        message: pc.cyan('Your custom answer:'),
-                        validate: (v) => v.trim().length > 0 || 'Answer cannot be empty'
+                try {
+                    let answer = await select({
+                        message: messageTitle,
+                        choices,
+                        pageSize: Math.min(8, choices.length)
+                    });
+                    if (answer === '__custom__') {
+                        const customAns = await input({
+                            message: pc.cyan('Your custom answer:'),
+                            validate: (v) => v.trim().length > 0 || 'Answer cannot be empty'
+                        });
+                        answer = customAns.trim();
+                    }
+                    else if (answer === '__skip__') {
+                        answer = '(Skipped)';
+                    }
+                    results.push({
+                        question: q.question,
+                        answer
                     });
-                    answer = customAns.trim();
                 }
-                else if (answer === '__skip__') {
-                    answer = '(Skipped)';
+                catch {
+                    results.push({
+                        question: q.question,
+                        answer: '(Skipped)'
+                    });
                 }
-                results.push({
-                    question: q.question,
-                    answer
-                });
             }
-            catch {
-                results.push({
-                    question: q.question,
-                    answer: '(Skipped)'
-                });
+        }
+        finally {
+            // Restore raw mode
+            if (wasRaw && process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+                process.stdin.resume();
             }
         }
         // Print styled Q&A block in console

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.4.12",
+  "version": "1.4.14",
   "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",
@@ -18,7 +18,7 @@
     "assets"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node ./scripts/copy-assets.js",
     "start": "node ./bin/devx.js",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build"