termux-dev 1.6.0 → 1.8.1

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

@@ -0,0 +1,241 @@
+import { LiveBlock } from './liveblock.js';
+import { WORD_BACKSPACE, normalizeKey, splitKeys } from './keys.js';
+import { windowItems } from './picker.js';
+import { palette } from './ui.js';
+import { displayWidth, padEndWidth, tailWidth, truncateWidth, wrapWords } from './width.js';
+import { t } from '../core/i18n.js';
+/** Every word typed must be found in the label, the id or the keywords; matches at the start of the label come first. */
+export function filterItems(items, query) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const pinned = items.filter((i) => i.pinned);
+    const rest = items.filter((i) => !i.pinned);
+    if (words.length === 0)
+        return [...pinned, ...rest];
+    const scored = [];
+    for (const item of rest) {
+        const hay = `${item.label} ${item.keywords ?? ''}`.toLowerCase();
+        if (!words.every((w) => hay.includes(w)))
+            continue;
+        const label = item.label.toLowerCase();
+        scored.push({ item, score: label.startsWith(words[0]) ? 0 : label.includes(words[0]) ? 1 : 2 });
+    }
+    scored.sort((a, b) => a.score - b.score); // stable: the original order is kept inside a score
+    return [...pinned, ...scored.map((s) => s.item)];
+}
+function hintLine(width, typing) {
+    const variants = [
+        typing
+            ? [['type', t('finder.hint.filter')], ['↑↓', t('picker.hint.move')], ['enter', t('picker.hint.select')], ['esc', t('picker.hint.cancel')]]
+            : [['enter', t('picker.hint.confirm')], ['esc', t('picker.hint.cancel')]],
+        [['↑↓', ''], ['enter', ''], ['esc', '']],
+        [['enter', ''], ['esc', '']],
+    ];
+    for (const items of variants) {
+        const text = items.map(([k, label]) => palette.text(k) + (label ? ' ' + palette.faint(label) : '')).join(palette.faint(items[0][1] ? ' · ' : ' '));
+        if (displayWidth(text) <= width)
+            return text;
+    }
+    return '';
+}
+/** The card around some content rows; `rows` are already padded to the inner width by the caller's `box`. */
+function frame(title, subtitle, cols, body, footer) {
+    if (cols < 60) {
+        const width = Math.max(20, cols - 1);
+        const head = ' ' + palette.bold(palette.accent(title)) + (subtitle ? palette.faint(' · ' + truncateWidth(subtitle, Math.max(6, width - displayWidth(title) - 6))) : '');
+        const plain = (c, shaded = false) => (shaded ? palette.shade(padEndWidth(' ' + c, width)) : ' ' + c);
+        return [head, ...body(width - 1, plain), ' ' + footer];
+    }
+    const W = Math.min(cols - 1, 76);
+    const iw = W - 4;
+    const rule = palette.rule;
+    const box = (content, shaded = false) => rule('│') + (shaded ? palette.shade(' ' + padEndWidth(content, iw) + ' ') : ' ' + padEndWidth(content, iw) + ' ') + rule('│');
+    const head = ' ' + palette.bold(palette.accent(title)) + ' ';
+    const sub = subtitle ? ' ' + palette.muted(truncateWidth(subtitle, Math.max(6, W - 12 - displayWidth(title)))) + ' ' : '';
+    return [
+        rule('╭─') + head + rule('─'.repeat(Math.max(0, W - 4 - displayWidth(head) - displayWidth(sub)))) + sub + rule('─╮'),
+        box(''),
+        ...body(iw, box),
+        rule('╰' + '─'.repeat(W - 2) + '╯'),
+        ' ' + footer,
+    ];
+}
+/** Where the focus starts: on the first match, not on a pinned row such as "type a name". */
+export function firstMatch(shown) {
+    const i = shown.findIndex((item) => !item.pinned);
+    return i === -1 ? 0 : i;
+}
+export function renderFinder(options, query, shown, focus, cols, termRows = 40) {
+    const maxItems = Math.max(3, termRows - 9 - (options.notes?.length ?? 0));
+    return frame(options.title, options.subtitle ?? `${shown.filter((i) => !i.pinned).length}/${options.items.filter((i) => !i.pinned).length}`, cols, (iw, box) => {
+        const lines = [];
+        const typed = query ? palette.text(tailWidth(query, Math.max(4, iw - 6))) : palette.faint(truncateWidth(options.placeholder ?? t('finder.placeholder'), Math.max(4, iw - 6)));
+        lines.push(box(' ' + palette.accent('/') + ' ' + (query ? typed + palette.accent('█') : palette.accent('█') + typed)));
+        lines.push(box(palette.rule('─'.repeat(Math.max(0, iw - 1)))));
+        if (shown.length === 0) {
+            lines.push(box('  ' + palette.faint(t('finder.empty'))));
+        }
+        else {
+            const labelWidth = Math.min(Math.min(options.labelWidth ?? 24, Math.max(...shown.map((i) => displayWidth(i.label)), 4)) + 2, Math.max(10, iw - 12));
+            const rows = shown.map((item, index) => {
+                const focused = index === focus;
+                const isCurrent = options.current !== undefined && item.value === options.current;
+                const mark = focused ? palette.accent('❯') : ' ';
+                const dot = item.pinned ? palette.accent('+') : isCurrent ? palette.accent('●') : palette.faint('○');
+                const label = focused ? palette.bold(palette.text(truncateWidth(item.label, labelWidth - 1))) : palette.muted(truncateWidth(item.label, labelWidth - 1));
+                const prefix = ` ${mark} ${dot} ${padEndWidth(label, labelWidth)}`;
+                const room = Math.max(0, iw - displayWidth(prefix) - 1);
+                const detail = item.detail && room > 6 ? palette.faint(truncateWidth(item.detail, room)) : '';
+                return { text: prefix + detail, index };
+            });
+            for (const r of windowItems(rows, focus, maxItems, iw))
+                lines.push(box(r.text, r.index === focus));
+        }
+        const notes = (options.notes ?? []).flatMap((n) => wrapWords(n, iw - 3));
+        if (notes.length > 0) {
+            lines.push(box(''));
+            for (const line of notes)
+                lines.push(box('  ' + palette.faint(line)));
+        }
+        return lines;
+    }, hintLine(cols - 2, true));
+}
+/** What a key does to a text that is being typed: `undefined` when the key is not an edit. */
+export function editText(value, key) {
+    if (key === '\x7f' || key === '\b')
+        return Array.from(value).slice(0, -1).join('');
+    if (key === WORD_BACKSPACE)
+        return value.replace(/\s*\S*$/, '');
+    if (key === '\x15')
+        return ''; // Ctrl+U
+    if (/^[^\x00-\x1f\x7f\x1b]+$/.test(key))
+        return value + key; // printable text, also a pasted chunk
+    return undefined;
+}
+function openIO(io) {
+    const { input } = io;
+    const wasRaw = !!input.isRaw;
+    input.setRawMode?.(true);
+    input.resume();
+    return () => { if (!wasRaw)
+        input.setRawMode?.(false); };
+}
+/** The list narrowed by typing. Resolves with the chosen value, or undefined when cancelled. */
+export function runFinder(options, io = { input: process.stdin, output: process.stdout }) {
+    return new Promise((resolve) => {
+        const { input, output } = io;
+        const block = new LiveBlock(output);
+        let query = '';
+        let shown = filterItems(options.items, query);
+        const at = shown.findIndex((i) => options.current !== undefined && i.value === options.current);
+        let focus = at >= 0 ? at : firstMatch(shown);
+        let done = false;
+        const rows = () => output.rows || 40;
+        const draw = () => block.draw(renderFinder(options, query, shown, focus, output.columns || 80, rows()));
+        const restore = openIO(io);
+        const finish = (value) => {
+            done = true;
+            input.off('data', onData);
+            block.erase();
+            restore();
+            resolve(value);
+        };
+        const move = (delta) => {
+            const next = Math.max(0, Math.min(shown.length - 1, focus + delta));
+            if (next !== focus) {
+                focus = next;
+                draw();
+            }
+        };
+        const handleKey = (raw) => {
+            const key = normalizeKey(raw);
+            if (key === '\x1b[A' || key === '\x1bOA')
+                return move(-1);
+            if (key === '\x1b[B' || key === '\x1bOB')
+                return move(1);
+            if (key === '\x1b[5~')
+                return move(-8);
+            if (key === '\x1b[6~')
+                return move(8);
+            if (key === '\r' || key === '\n')
+                return shown.length > 0 ? finish(shown[focus].value) : undefined;
+            if (key === '\x1b' || key === '\x03')
+                return finish(undefined);
+            const edited = editText(query, key);
+            if (edited !== undefined && edited !== query) {
+                query = edited;
+                shown = filterItems(options.items, query);
+                focus = firstMatch(shown);
+                draw();
+            }
+        };
+        const onData = (chunk) => {
+            for (const key of splitKeys(chunk.toString())) {
+                if (done)
+                    return;
+                handleKey(key);
+            }
+        };
+        input.on('data', onData);
+        draw();
+    });
+}
+export function renderTextInput(options, value, cols) {
+    return frame(options.title, options.subtitle, cols, (iw, box) => {
+        const lines = [];
+        for (const line of wrapWords(options.label, iw - 2))
+            lines.push(box(' ' + palette.bold(palette.text(line))));
+        const shownValue = options.secret ? '•'.repeat(Array.from(value).length) : value;
+        const room = Math.max(4, iw - 6);
+        const text = value
+            ? palette.text(tailWidth(shownValue, room)) + palette.accent('█')
+            : palette.accent('█') + palette.faint(truncateWidth(options.placeholder ?? '', room));
+        lines.push(box(''));
+        lines.push(box(' ' + palette.accent('❯') + ' ' + text, true));
+        const notes = (options.notes ?? []).flatMap((n) => wrapWords(n, iw - 3));
+        if (notes.length > 0) {
+            lines.push(box(''));
+            for (const line of notes)
+                lines.push(box('  ' + palette.faint(line)));
+        }
+        return lines;
+    }, hintLine(cols - 2, false));
+}
+/** A one-line input. Resolves with the text (never empty), or undefined when cancelled. */
+export function runTextInput(options, io = { input: process.stdin, output: process.stdout }) {
+    return new Promise((resolve) => {
+        const { input, output } = io;
+        const block = new LiveBlock(output);
+        let value = options.initial ?? '';
+        let done = false;
+        const draw = () => block.draw(renderTextInput(options, value, output.columns || 80));
+        const restore = openIO(io);
+        const finish = (result) => {
+            done = true;
+            input.off('data', onData);
+            block.erase();
+            restore();
+            resolve(result);
+        };
+        const handleKey = (raw) => {
+            const key = normalizeKey(raw);
+            if (key === '\r' || key === '\n')
+                return value.trim() ? finish(value.trim()) : undefined;
+            if (key === '\x1b' || key === '\x03')
+                return finish(undefined);
+            const edited = editText(value, key);
+            if (edited !== undefined && edited !== value) {
+                value = edited;
+                draw();
+            }
+        };
+        const onData = (chunk) => {
+            for (const key of splitKeys(chunk.toString())) {
+                if (done)
+                    return;
+                handleKey(key);
+            }
+        };
+        input.on('data', onData);
+        draw();
+    });
+}

package/dist/cli/headless.js

@@ -4,6 +4,7 @@ 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';
@@ -24,21 +25,27 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
     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();
+        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)) {
@@ -70,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,
@@ -85,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));
         }
@@ -94,22 +104,24 @@ 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();
     }