termux-dev 1.5.0 → 1.8.0

package/dist/cli/doctor.js

@@ -34,7 +34,7 @@ async function pingUrl(url) {
 }
 export async function runDoctor(config) {
     const theme = getCurrentTheme();
-    console.log('\n' + theme.boldFn('🩺 devx Doctor — System & Environment Health Diagnostics'));
+    console.log('\n' + theme.boldFn('devx Doctor — System & Environment Health Diagnostics'));
     console.log(pc.dim('──────────────────────────────────────────────────────────────────'));
     const envChecks = [];
     const toolChecks = [];
@@ -124,7 +124,7 @@ export async function runDoctor(config) {
     const renderSection = (title, items) => {
         console.log('\n' + theme.colorFn(pc.bold(`• ${title}`)));
         for (const item of items) {
-            let icon = pc.green('✔');
+            let icon = pc.green('✓');
             if (item.status === 'warn')
                 icon = pc.yellow('▲');
             if (item.status === 'fail')
@@ -139,10 +139,10 @@ export async function runDoctor(config) {
     console.log('\n' + pc.dim('──────────────────────────────────────────────────────────────────'));
     const hasFailures = [...envChecks, ...toolChecks, ...keyChecks, ...netChecks].some(i => i.status === 'fail');
     if (hasFailures) {
-        console.log(pc.red(pc.bold('⚠ Doctor found critical issues that might prevent devx from functioning properly.')));
+        console.log(pc.red(pc.bold('Doctor found critical issues that might prevent devx from functioning properly.')));
     }
     else {
-        console.log(theme.boldFn('🎉 Everything looks healthy! devx is fully configured and ready for vibe-coding.'));
+        console.log(theme.boldFn('Everything looks healthy! devx is fully configured and ready for vibe-coding.'));
     }
     console.log();
 }

package/dist/cli/effort.js

@@ -0,0 +1,80 @@
+import { LEVELS, effectiveReasoning, parseEffortArg, withEffort, } from '../core/reasoning.js';
+const modelName = (config) => config.model || 'the current model';
+/** Where the levels in the menu come from. */
+const SOURCE_NOTE = {
+    endpoint: 'Levels reported by the endpoint.',
+    catalog: 'Levels from the models.dev catalogue.',
+    rules: 'Levels inferred from the model name.',
+    profile: '',
+    none: '',
+};
+/** What would actually be sent for a level, in one line. */
+export function sentText(params) {
+    return params ? `sends ${JSON.stringify(params)}` : 'sends nothing (the model default applies)';
+}
+function offered(levels) {
+    return ['auto', ...levels].join(', ');
+}
+/** Sets the level for the current model (or clears it) and describes what happened. */
+export function chooseEffort(config, choice) {
+    const model = modelName(config);
+    if (choice === 'auto') {
+        config.effort = withEffort(config.effort, config.model, null);
+        return { kind: 'ok', text: `effort auto for ${model}`, detail: 'the model default applies, no reasoning setting is sent' };
+    }
+    config.effort = withEffort(config.effort, config.model, choice);
+    const { caps, params } = effectiveReasoning({ ...config, effortOverride: undefined });
+    return { kind: 'ok', text: `effort ${choice} for ${model}`, detail: `${caps.describe(choice)}; ${sentText(params)}` };
+}
+export function buildEffortPicker(config) {
+    const { caps, level } = effectiveReasoning({ ...config, effortOverride: undefined });
+    const missing = LEVELS.filter((l) => !caps.levels.includes(l));
+    const notes = [];
+    if (missing.length > 0)
+        notes.push(`Not offered by this model: ${missing.join(', ')}.`);
+    if (caps.alwaysOn)
+        notes.push('This model cannot switch reasoning off.');
+    const source = SOURCE_NOTE[caps.source];
+    if (source)
+        notes.push(source);
+    if (caps.confidence === 'guess')
+        notes.push('How the setting is sent to this endpoint is inferred. If the endpoint rejects it, devx retries without it.');
+    if (caps.confidence === 'custom')
+        notes.push(caps.note);
+    return {
+        title: 'effort',
+        subtitle: modelName(config),
+        current: level ?? 'auto',
+        items: [
+            { value: 'auto', label: 'auto', detail: 'model default, nothing is sent' },
+            ...caps.levels.map((l) => ({ value: l, label: l, detail: caps.describe(l) })),
+        ],
+        notes,
+    };
+}
+/**
+ * Handles `/effort [argument]`. Without an argument it returns a picker with the levels of
+ * the current model; with one it sets it directly. Everything else is an explanation.
+ */
+export function effortCommand(config, arg) {
+    const model = modelName(config);
+    const { caps } = effectiveReasoning({ ...config, effortOverride: undefined });
+    if (!caps.supported) {
+        const hint = caps.alwaysOn
+            ? ''
+            : ' If you know how this model takes a reasoning setting, describe it in ~/.devxrc.json under "reasoningProfiles" (see the README).';
+        return { type: 'say', say: { kind: 'warn', text: `${model} has no reasoning setting.`, detail: `${caps.note}${hint}` } };
+    }
+    if (!arg.trim())
+        return { type: 'pick', picker: buildEffortPicker(config) };
+    const parsed = parseEffortArg(arg);
+    if (parsed.kind === 'auto')
+        return { type: 'say', say: chooseEffort(config, 'auto') };
+    if (parsed.kind === 'invalid') {
+        return { type: 'say', say: { kind: 'warn', text: `Unknown level "${parsed.text}".`, detail: `${model} offers: ${offered(caps.levels)}.` } };
+    }
+    if (!caps.levels.includes(parsed.level)) {
+        return { type: 'say', say: { kind: 'warn', text: `${model} does not offer "${parsed.level}".`, detail: `It offers: ${offered(caps.levels)}.` } };
+    }
+    return { type: 'say', say: chooseEffort(config, parsed.level) };
+}

package/dist/cli/export.js

@@ -9,7 +9,7 @@ export class SessionExporter {
                 fileName += '.md';
             const filePath = path.resolve(process.cwd(), fileName);
             const lines = [
-                `# 📝 devx Session Transcript`,
+                `# devx Session Transcript`,
                 ``,
                 `- **Date:** ${new Date().toLocaleString()}`,
                 `- **Model:** \`${model}\``,
@@ -23,7 +23,7 @@ export class SessionExporter {
                 if (msg.role === 'system')
                     continue; // Skip raw system prompt
                 if (msg.role === 'user') {
-                    lines.push(`## 👤 User\n`);
+                    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(', ')}*`);
@@ -31,7 +31,7 @@ export class SessionExporter {
                     lines.push(`\n---\n`);
                 }
                 else if (msg.role === 'assistant') {
-                    lines.push(`## 🤖 Assistant\n`);
+                    lines.push(`## Assistant\n`);
                     if (msg.content) {
                         lines.push(msg.content);
                     }

package/dist/cli/files.js

@@ -49,22 +49,28 @@ export async function scanProjectFiles(force = false) {
     lastScanTime = now;
     return results;
 }
+// Formats the image APIs accept (SVG is text, not an image for a model).
 const IMAGE_EXTS = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
     '.jpeg': 'image/jpeg',
     '.webp': 'image/webp',
-    '.gif': 'image/gif',
-    '.svg': 'image/svg+xml'
+    '.gif': 'image/gif'
 };
+/** Above this an API usually refuses the image (Anthropic: 5 MB). */
+export const IMAGE_WARN_BYTES = 5 * 1024 * 1024;
+/** Above this the image is not sent at all. */
+export const IMAGE_MAX_BYTES = 20 * 1024 * 1024;
 export async function resolveAtMentions(text) {
-    const mentionRegex = /@([a-zA-Z0-9_\-./\u0400-\u04FF]+)/g;
+    // @path, or @"path with spaces" for a path that has unusual characters
+    const mentionRegex = /@(?:"([^"\n]+)"|([a-zA-Z0-9_\-./\u0400-\u04FF]+))/g;
     const attachments = [];
     const images = [];
+    const warnings = [];
     const seenPaths = new Set();
     let match;
     while ((match = mentionRegex.exec(text)) !== null) {
-        const rawPath = match[1];
+        const rawPath = match[1] ?? match[2];
         const resolved = path.resolve(process.cwd(), rawPath);
         if (seenPaths.has(resolved))
             continue;
@@ -75,6 +81,14 @@ export async function resolveAtMentions(text) {
                 const ext = path.extname(resolved).toLowerCase();
                 if (stat.isFile()) {
                     if (IMAGE_EXTS[ext]) {
+                        const name = path.basename(rawPath);
+                        if (stat.size > IMAGE_MAX_BYTES) {
+                            warnings.push(`${name} is ${(stat.size / 1048576).toFixed(0)} MB: too large, it was not sent.`);
+                            continue;
+                        }
+                        if (stat.size > IMAGE_WARN_BYTES) {
+                            warnings.push(`${name} is ${(stat.size / 1048576).toFixed(1)} MB: some providers refuse images above 5 MB.`);
+                        }
                         const buf = await fs.readFile(resolved);
                         const b64 = buf.toString('base64');
                         const dataUrl = `data:${IMAGE_EXTS[ext]};base64,${b64}`;
@@ -89,5 +103,5 @@ export async function resolveAtMentions(text) {
             catch { }
         }
     }
-    return { text, attachments, images };
+    return { text, attachments, images, warnings };
 }

package/dist/cli/headless.js

@@ -4,10 +4,12 @@ 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 { refreshFormats } from '../core/formats.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';
+import { MCPManager } from '../mcp/manager.js';
 export async function runHeadlessMode(userPrompt, config, options = {}) {
     const planMode = !!options.planMode;
     const isYolo = !!options.yolo || !!config.autoApprove;
@@ -17,26 +19,33 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
     const sysPrompt = await buildSystemPrompt(planMode);
     history.updateSystemPrompt(sysPrompt);
     history.addMessage({ role: 'user', content: userPrompt });
-    const provider = createProvider(config);
-    const tools = getTools(planMode);
-    const guard = new CLIConsoleGuard(isYolo);
-    const agent = new Agent(config, provider, tools, history, guard);
     let executedTools = [];
     let accumulatedText = '';
     let accumulatedReasoning = '';
     let isFatalError = false;
     let errorMessage = '';
     const abortController = new AbortController();
-    process.on('SIGINT', () => {
+    const onAbort = () => {
+        if (abortController.signal.aborted)
+            return;
         abortController.abort();
         if (!isJson) {
             console.error(pc.yellow('\n[devx headless] Aborted by user (SIGINT)'));
         }
-        process.exit(130);
-    });
+    };
+    process.on('SIGINT', onAbort);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted)
+        onAbort();
     try {
+        await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
+        await refreshFormats(config).catch(() => null);
+        const provider = createProvider(config);
+        const tools = getTools(planMode);
+        const guard = new CLIConsoleGuard(isYolo);
+        const agent = new Agent(config, provider, tools, history, guard);
         if (!isQuiet && !isJson) {
-            console.log(pc.bold(pc.cyan(`⚡ devx v${DEVX_VERSION} (headless) | ${planMode ? 'PLAN' : 'AGENT'} | ${config.model}`)));
+            console.log(pc.bold(pc.cyan(`devx v${DEVX_VERSION} (headless) | ${planMode ? 'PLAN' : 'AGENT'} | ${config.model}`)));
             console.log(pc.dim(`Task: ${userPrompt}\n`));
         }
         for await (const event of agent.run(abortController.signal)) {
@@ -68,10 +77,13 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
                 }
             }
         }
+        const cancelled = abortController.signal.aborted;
+        if (cancelled)
+            errorMessage = 'Operation cancelled by user';
         if (isJson) {
             const summary = UsageTracker.getInstance().getSummary();
             const output = {
-                success: !isFatalError,
+                success: !isFatalError && !cancelled,
                 model: config.model,
                 prompt: userPrompt,
                 result: accumulatedText,
@@ -83,7 +95,7 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
                     cost: summary.totalCost,
                     totalBytes: summary.totalBytes
                 },
-                error: isFatalError ? errorMessage : undefined
+                error: isFatalError || cancelled ? errorMessage : undefined
             };
             console.log(JSON.stringify(output, null, 2));
         }
@@ -92,22 +104,25 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
                 process.stdout.write('\n');
             }
             if (isFatalError) {
-                console.error(pc.red(`\n❌ Error: ${errorMessage}`));
+                console.error(pc.red(`\nError: ${errorMessage}`));
                 return 1;
             }
         }
-        return isFatalError ? 1 : 0;
+        return cancelled ? 130 : 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}`));
+            console.error(pc.red(`\nFatal Headless Execution Error: ${err.message}`));
         }
-        return 1;
+        return abortController.signal.aborted ? 130 : 1;
     }
     finally {
+        process.removeListener('SIGINT', onAbort);
+        options.signal?.removeEventListener('abort', onAbort);
         globalSnapshotManager.finishTurn();
+        MCPManager.getInstance().stopAll();
     }
 }