vexi-cli 0.8.0 → 0.9.0

package/dist/agent.js

@@ -22,18 +22,20 @@ import * as nodeRl from 'node:readline';
 import ora from 'ora';
 import { loadConfig, saveConfig, CONFIG_PATH } from './config.js';
 import { SnapshotManager } from './snapshots/index.js';
-import { createProviderFromConfig, detectProvider, sanitizeKey, PROVIDER_INFO, ProviderError, } from './providers/index.js';
+import { createProviderFromConfig, detectProvider, sanitizeKey, refreshManifest, PROVIDER_INFO, ProviderError, } from './providers/index.js';
 import { scanProject, projectSummary } from './scanner/index.js';
 import { loadMemory, saveMemory, memoryBlock, compressIntoMemory, KEEP_RECENT, COMPRESS_INTERVAL, } from './memory/index.js';
 import { loadSkills, skillsBlock } from './skills/index.js';
 import { SessionRecorder } from './replay/recorder.js';
 import { McpManager, parseToolCall } from './mcp/client.js';
 import { loadMcpConfig } from './mcp/config.js';
+import { parseBuiltinToolCall, executeBuiltinTool, builtinToolsBlock, buildNativeTools, dispatchNativeTool } from './tools/index.js';
+import { UsageTracker } from './usage/index.js';
 import { ARABIC_RTL_NOTE, getStrings, t } from './i18n/index.js';
 import { gitPush } from './git/index.js';
 import { accent, dim, err, ok, printBanner, printStatusLine, userPrompt, vexiLabel, warn } from './ui/index.js';
 /** Extract shell commands from fenced code blocks in an AI reply. */
-function extractShellBlocks(reply) {
+export function extractShellBlocks(reply) {
     const blocks = [];
     const re = /```(?:bash|sh|shell|cmd|powershell|ps1)\n([\s\S]*?)```/gi;
     let m;
@@ -44,11 +46,24 @@ function extractShellBlocks(reply) {
     }
     return blocks;
 }
+/** Hard cap on how long an AI-suggested command may run before it's killed. */
+export const COMMAND_TIMEOUT_MS = 2 * 60 * 1000;
 /** Run a shell command and return { stdout, stderr, code }. */
-function runCommand(cmd, cwd) {
+export function runCommand(cmd, cwd, timeoutMs = COMMAND_TIMEOUT_MS) {
     return new Promise((resolve) => {
-        cpExec(cmd, { cwd, shell: process.platform === 'win32' ? 'powershell.exe' : '/bin/sh', maxBuffer: 1024 * 1024 * 4 }, (err, stdout, stderr) => {
-            resolve({ stdout: stdout ?? '', stderr: stderr ?? '', code: err?.code ?? 0 });
+        cpExec(cmd, {
+            cwd,
+            shell: process.platform === 'win32' ? 'powershell.exe' : '/bin/sh',
+            maxBuffer: 1024 * 1024 * 4,
+            timeout: timeoutMs,
+            killSignal: 'SIGKILL',
+        }, (err, stdout, stderr) => {
+            const timedOut = Boolean(err?.killed && err.signal === 'SIGKILL');
+            const extraNote = timedOut ? `\n[vexi] command killed after exceeding ${timeoutMs / 1000}s timeout` : '';
+            // A killed process has no real exit code (err.code is undefined) — falling back to
+            // 0 would look like success to callers, so use the conventional timeout code (124).
+            const code = timedOut ? 124 : (err?.code ?? 0);
+            resolve({ stdout: stdout ?? '', stderr: (stderr ?? '') + extraNote, code });
         });
     });
 }
@@ -120,6 +135,8 @@ export async function runAgent(opts) {
     }
     let provider = createProviderFromConfig(config);
     const root = process.cwd();
+    // Best-effort: refresh the remote model-default manifest for the next run.
+    void refreshManifest();
     // ── Full project understanding: scan + load memory + load skills ──────
     const scanSpinner = ora({ text: dim(s.scanning), spinner: 'dots' }).start();
     let project = null;
@@ -187,13 +204,16 @@ export async function runAgent(opts) {
     const projectBlock = project ? projectSummary(project) : '';
     const skillsText = skillsBlock(skills);
     let compressing = false;
+    const usage = new UsageTracker();
+    const trackUsage = (u) => usage.add(u);
     /**
      * The system prompt is rebuilt every turn because the memory block
      * changes as the Context Compression Engine folds in old messages.
      */
+    const nativeToolsEnabled = Boolean(provider.supportsTools && provider.streamTools);
     const buildSystem = () => ({
         role: 'system',
-        content: buildSystemPrompt(opts.lang, projectBlock, skillsText, memoryBlock(memory), mcp.promptBlock()),
+        content: buildSystemPrompt(opts.lang, projectBlock, skillsText, memoryBlock(memory), mcp.promptBlock(), nativeToolsEnabled),
     });
     /**
      * Running-summary compression: when enough messages have accumulated
@@ -219,6 +239,43 @@ export async function runAgent(opts) {
             compressing = false;
         });
     };
+    // Native function-calling: used when the provider reliably supports it,
+    // otherwise the text-based `vexi-tool` protocol below is used instead.
+    const nativeTools = provider.supportsTools && provider.streamTools ? buildNativeTools(mcp) : null;
+    /**
+     * Run any ```bash``` shell blocks in an AI reply (confirm → snapshot → run
+     * → feed output back). Shared by the native and text tool paths, since shell
+     * commands are proposed as fenced blocks regardless of tool mode.
+     */
+    const runShellBlocks = async (reply) => {
+        for (const cmd of extractShellBlocks(reply)) {
+            console.log(accent('▶ run? ') + dim(cmd.slice(0, 120) + (cmd.length > 120 ? '…' : '')));
+            const yes = await confirm({ message: 'Execute', default: true }).catch(() => false);
+            if (!yes) {
+                history.push({ role: 'user', content: `COMMAND SKIPPED: ${cmd}` });
+                continue;
+            }
+            const filesToSnap = SnapshotManager.extractFilePaths(cmd, root);
+            if (filesToSnap.length > 0) {
+                await snapshots.takeSnapshot(filesToSnap, cmd.slice(0, 80)).catch(() => { });
+            }
+            const runSpinner = ora({ text: dim('running…'), spinner: 'dots' }).start();
+            const { stdout, stderr, code } = await runCommand(cmd, root);
+            runSpinner.stop();
+            const output = [
+                stdout.trim() ? `STDOUT:\n${stdout.trim()}` : '',
+                stderr.trim() ? `STDERR:\n${stderr.trim()}` : '',
+                `EXIT CODE: ${code}`,
+            ].filter(Boolean).join('\n');
+            console.log(code === 0 ? ok('✓ done') : err(`✗ exit ${code}`));
+            if (stdout.trim())
+                console.log(dim(stdout.trim().slice(0, 800)));
+            if (stderr.trim())
+                console.log(warn(stderr.trim().slice(0, 400)));
+            history.push({ role: 'user', content: `COMMAND RESULT (${cmd.slice(0, 60)}):\n${output.slice(0, 6000)}` });
+            recorder.add('user', `COMMAND RESULT:\n${output.slice(0, 6000)}`);
+        }
+    };
     while (true) {
         let line;
         try {
@@ -226,6 +283,8 @@ export async function runAgent(opts) {
         }
         catch {
             // Ctrl+C / closed stdin
+            if (usage.hasData)
+                console.log('\n' + dim(`session usage: ${usage.summary(provider.model)}`));
             console.log('\n' + ok(s.goodbye));
             return;
         }
@@ -238,9 +297,14 @@ export async function runAgent(opts) {
             switch (cmd) {
                 case '/exit':
                 case '/quit':
+                    if (usage.hasData)
+                        console.log(dim(`session usage: ${usage.summary(provider.model)}`));
                     console.log(ok(s.goodbye));
                     await mcp.close();
                     return;
+                case '/usage':
+                    console.log(dim(usage.summary(provider.model)) + '\n');
+                    continue;
                 case '/help':
                     console.log(dim(s.helpText) + '\n');
                     continue;
@@ -335,50 +399,64 @@ export async function runAgent(opts) {
         const spinner = ora({ text: dim(s.thinking), spinner: 'dots' }).start();
         let started = false;
         try {
-            // Up to 5 tool-call rounds per user turn, then a final plain answer.
+            // Up to 5 tool-call rounds per user turn (round < 5 below), plus one
+            // extra final round where a ```vexi-tool``` reply is no longer honored
+            // — so the model is forced to give a plain answer. 6 stream() calls total.
             for (let round = 0; round < 6; round++) {
-                const reply = await provider.stream([buildSystem(), ...history], (chunk) => {
+                const onChunk = (chunk) => {
                     if (!started) {
                         spinner.stop();
                         process.stdout.write(vexiLabel + ' ');
                         started = true;
                     }
                     process.stdout.write(chunk);
-                });
+                };
+                // ── Native function-calling path ─────────────────────────────
+                if (nativeTools) {
+                    const { text: reply, toolCalls } = await provider.streamTools([buildSystem(), ...history], nativeTools.defs, onChunk, trackUsage);
+                    if (!started)
+                        spinner.stop();
+                    process.stdout.write('\n\n');
+                    history.push({
+                        role: 'assistant',
+                        content: reply,
+                        toolCalls: toolCalls.length ? toolCalls : undefined,
+                    });
+                    recorder.add('assistant', reply);
+                    await runShellBlocks(reply);
+                    if (toolCalls.length === 0 || round === 5)
+                        break;
+                    for (const tc of toolCalls) {
+                        const toolSpinner = ora({ text: dim(`${tc.name}…`), spinner: 'dots' }).start();
+                        const { result } = await dispatchNativeTool(tc.name, tc.arguments, nativeTools.route, root, snapshots, mcp);
+                        toolSpinner.stop();
+                        console.log(result.startsWith('TOOL ERROR') ? err(`${tc.name}: ${result}`) : ok(`✓ ${tc.name}`));
+                        history.push({ role: 'tool', content: result.slice(0, 8000), toolCallId: tc.id, toolName: tc.name });
+                        recorder.add('user', `TOOL RESULT (${tc.name}):\n${result.slice(0, 8000)}`);
+                    }
+                    started = false; // next round streams with a fresh label
+                    continue;
+                }
+                // ── Text-based `vexi-tool` path (providers without native tools) ─
+                const reply = await provider.stream([buildSystem(), ...history], onChunk, trackUsage);
                 if (!started)
                     spinner.stop(); // empty reply edge case
                 process.stdout.write('\n\n');
                 history.push({ role: 'assistant', content: reply });
                 recorder.add('assistant', reply);
-                // ── Auto-run shell commands suggested by the AI ──────────────
-                const shellBlocks = extractShellBlocks(reply);
-                for (const cmd of shellBlocks) {
-                    console.log(accent('▶ run? ') + dim(cmd.slice(0, 120) + (cmd.length > 120 ? '…' : '')));
-                    const yes = await confirm({ message: 'Execute', default: true }).catch(() => false);
-                    if (!yes) {
-                        history.push({ role: 'user', content: `COMMAND SKIPPED: ${cmd}` });
-                        continue;
-                    }
-                    // Silent snapshot of any files the command is about to modify
-                    const filesToSnap = SnapshotManager.extractFilePaths(cmd, root);
-                    if (filesToSnap.length > 0) {
-                        await snapshots.takeSnapshot(filesToSnap, cmd.slice(0, 80)).catch(() => { });
-                    }
-                    const runSpinner = ora({ text: dim('running…'), spinner: 'dots' }).start();
-                    const { stdout, stderr, code } = await runCommand(cmd, root);
-                    runSpinner.stop();
-                    const output = [
-                        stdout.trim() ? `STDOUT:\n${stdout.trim()}` : '',
-                        stderr.trim() ? `STDERR:\n${stderr.trim()}` : '',
-                        `EXIT CODE: ${code}`,
-                    ].filter(Boolean).join('\n');
-                    console.log(code === 0 ? ok('✓ done') : err(`✗ exit ${code}`));
-                    if (stdout.trim())
-                        console.log(dim(stdout.trim().slice(0, 800)));
-                    if (stderr.trim())
-                        console.log(warn(stderr.trim().slice(0, 400)));
-                    history.push({ role: 'user', content: `COMMAND RESULT (${cmd.slice(0, 60)}):\n${output.slice(0, 6000)}` });
-                    recorder.add('user', `COMMAND RESULT:\n${output.slice(0, 6000)}`);
+                await runShellBlocks(reply);
+                // Built-in file tool requested by the model? (read/write/edit)
+                const builtinCall = round < 5 ? parseBuiltinToolCall(reply) : null;
+                if (builtinCall) {
+                    const fileSpinner = ora({ text: dim(`${builtinCall.tool}…`), spinner: 'dots' }).start();
+                    const { result } = await executeBuiltinTool(builtinCall, root, snapshots);
+                    fileSpinner.stop();
+                    console.log(result.startsWith('TOOL ERROR') ? err(result) : ok(result));
+                    const toolMessage = `TOOL RESULT (${builtinCall.tool}):\n${result.slice(0, 8000)}`;
+                    history.push({ role: 'user', content: toolMessage });
+                    recorder.add('user', toolMessage);
+                    started = false; // next round streams with a fresh label
+                    continue;
                 }
                 // MCP tool call requested by the model?
                 const call = mcp.tools.length > 0 && round < 5 ? parseToolCall(reply) : null;
@@ -424,6 +502,130 @@ export async function runAgent(opts) {
         }
     }
 }
+/**
+ * Non-interactive, single-turn mode for scripting/CI (`vexi -p "<prompt>"`).
+ * Same system prompt (project scan + memory + skills + MCP tools) and the
+ * same tool-call loop as the interactive session, but no readline, no
+ * spinners, and no session recording. Requires an existing config — it
+ * never runs the interactive BYOK onboarding.
+ */
+export async function runPrint(opts) {
+    const config = await loadConfig();
+    if (!config) {
+        console.error(err('No API key configured yet. Run `vexi` once interactively to set one up, then retry with -p.'));
+        process.exitCode = 1;
+        return;
+    }
+    const provider = createProviderFromConfig(config);
+    const root = process.cwd();
+    let project = null;
+    try {
+        project = await scanProject(root);
+    }
+    catch {
+        // scanning is best-effort — the prompt still works without it
+    }
+    const memory = await loadMemory(root);
+    const skills = await loadSkills(root);
+    const mcp = new McpManager();
+    const mcpConfig = await loadMcpConfig();
+    if (Object.keys(mcpConfig.mcpServers).length > 0) {
+        await mcp.connect().catch(() => { });
+    }
+    const snapshots = new SnapshotManager(root, Date.now().toString(36));
+    await snapshots.registerAsCurrentSession().catch(() => { });
+    const projectBlock = project ? projectSummary(project) : '';
+    const skillsText = skillsBlock(skills);
+    const nativeToolsEnabled = Boolean(provider.supportsTools && provider.streamTools);
+    const buildSystem = () => ({
+        role: 'system',
+        content: buildSystemPrompt(opts.lang, projectBlock, skillsText, memoryBlock(memory), mcp.promptBlock(), nativeToolsEnabled),
+    });
+    const history = [{ role: 'user', content: opts.prompt }];
+    const usage = new UsageTracker();
+    const trackUsage = (u) => usage.add(u);
+    const nativeTools = provider.supportsTools && provider.streamTools ? buildNativeTools(mcp) : null;
+    const runShellBlocks = async (reply) => {
+        for (const cmd of extractShellBlocks(reply)) {
+            if (!opts.autoYes) {
+                console.error(dim(`[skipped — pass --yes to auto-run] $ ${cmd.slice(0, 120)}`));
+                history.push({ role: 'user', content: `COMMAND SKIPPED (non-interactive, no --yes flag): ${cmd}` });
+                continue;
+            }
+            console.error(accent('$ ') + cmd.slice(0, 120));
+            const filesToSnap = SnapshotManager.extractFilePaths(cmd, root);
+            if (filesToSnap.length > 0) {
+                await snapshots.takeSnapshot(filesToSnap, cmd.slice(0, 80)).catch(() => { });
+            }
+            const { stdout, stderr, code } = await runCommand(cmd, root);
+            console.error(code === 0 ? ok('✓ done') : err(`✗ exit ${code}`));
+            const output = [
+                stdout.trim() ? `STDOUT:\n${stdout.trim()}` : '',
+                stderr.trim() ? `STDERR:\n${stderr.trim()}` : '',
+                `EXIT CODE: ${code}`,
+            ].filter(Boolean).join('\n');
+            history.push({ role: 'user', content: `COMMAND RESULT (${cmd.slice(0, 60)}):\n${output.slice(0, 6000)}` });
+        }
+    };
+    try {
+        for (let round = 0; round < 6; round++) {
+            // ── Native function-calling path ─────────────────────────────
+            if (nativeTools) {
+                const { text: reply, toolCalls } = await provider.streamTools([buildSystem(), ...history], nativeTools.defs, (chunk) => process.stdout.write(chunk), trackUsage);
+                process.stdout.write('\n');
+                history.push({
+                    role: 'assistant',
+                    content: reply,
+                    toolCalls: toolCalls.length ? toolCalls : undefined,
+                });
+                await runShellBlocks(reply);
+                if (toolCalls.length === 0 || round === 5)
+                    break;
+                for (const tc of toolCalls) {
+                    const { result } = await dispatchNativeTool(tc.name, tc.arguments, nativeTools.route, root, snapshots, mcp);
+                    console.error(result.startsWith('TOOL ERROR') ? err(`${tc.name}: ${result}`) : ok(`✓ ${tc.name}`));
+                    history.push({ role: 'tool', content: result.slice(0, 8000), toolCallId: tc.id, toolName: tc.name });
+                }
+                continue;
+            }
+            // ── Text-based `vexi-tool` path ──────────────────────────────
+            const reply = await provider.stream([buildSystem(), ...history], (chunk) => {
+                process.stdout.write(chunk);
+            }, trackUsage);
+            process.stdout.write('\n');
+            history.push({ role: 'assistant', content: reply });
+            await runShellBlocks(reply);
+            const builtinCall = round < 5 ? parseBuiltinToolCall(reply) : null;
+            if (builtinCall) {
+                const { result } = await executeBuiltinTool(builtinCall, root, snapshots);
+                console.error(result.startsWith('TOOL ERROR') ? err(result) : ok(result));
+                history.push({ role: 'user', content: `TOOL RESULT (${builtinCall.tool}):\n${result.slice(0, 8000)}` });
+                continue;
+            }
+            const call = mcp.tools.length > 0 && round < 5 ? parseToolCall(reply) : null;
+            if (!call)
+                break;
+            let result;
+            try {
+                result = await mcp.callTool(call.server, call.tool, call.arguments);
+            }
+            catch (e) {
+                result = `TOOL ERROR: ${e instanceof Error ? e.message : String(e)}`;
+            }
+            history.push({ role: 'user', content: `TOOL RESULT (${call.server}/${call.tool}):\n${result.slice(0, 8000)}` });
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        console.error(err(message));
+        process.exitCode = 1;
+    }
+    finally {
+        if (usage.hasData)
+            console.error(dim(`usage: ${usage.summary(provider.model)}`));
+        await mcp.close();
+    }
+}
 /** Ask for the API key, auto-detect the provider, save the config. */
 async function firstRunSetup(s, lang) {
     console.log(accent(s.welcome));
@@ -461,7 +663,7 @@ async function firstRunSetup(s, lang) {
     return config;
 }
 /** System prompt for the chat session. */
-function buildSystemPrompt(lang, projectBlock, skillsText, memoryText, mcpText) {
+function buildSystemPrompt(lang, projectBlock, skillsText, memoryText, mcpText, nativeTools = false) {
     const langNames = {
         en: 'English',
         ar: 'Arabic',
@@ -491,13 +693,23 @@ function buildSystemPrompt(lang, projectBlock, skillsText, memoryText, mcpText)
         'Always use `bash` as the code block language tag for commands — never `python`, `java`, etc.',
         'After seeing the output, continue helping based on the result.',
     ];
+    if (nativeTools) {
+        // Native function-calling: file tools (and MCP tools) are advertised
+        // through the API's tools parameter, so only a short pointer is needed.
+        parts.push('', '## File tools', 'You have native tools to read and edit files (read_file, write_file, edit_file). '
+            + 'Use them to inspect and change files instead of shell cat/sed. Read a file before editing it.');
+    }
+    else {
+        parts.push('', builtinToolsBlock());
+    }
     if (projectBlock)
         parts.push('', '## Project map', projectBlock);
     if (memoryText)
         parts.push('', memoryText);
     if (skillsText)
         parts.push('', skillsText);
-    if (mcpText)
+    // In native mode, MCP tools are sent via the API — skip the text protocol block.
+    if (mcpText && !nativeTools)
         parts.push('', mcpText);
     return parts.join('\n');
 }

package/dist/agent.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { tmpdir } from 'node:os';
+import { extractShellBlocks, runCommand } from './agent.js';
+describe('extractShellBlocks', () => {
+    it('extracts a single bash block', () => {
+        const reply = 'Run this:\n```bash\nnpm install\n```\nThen restart.';
+        expect(extractShellBlocks(reply)).toEqual(['npm install']);
+    });
+    it('extracts multiple blocks across different fence languages', () => {
+        const reply = [
+            '```sh\necho one\n```',
+            'some text in between',
+            '```powershell\nWrite-Output "two"\n```',
+            '```cmd\necho three\n```',
+        ].join('\n');
+        expect(extractShellBlocks(reply)).toEqual(['echo one', 'Write-Output "two"', 'echo three']);
+    });
+    it('is case-insensitive on the fence language tag', () => {
+        const reply = '```BASH\nls -la\n```';
+        expect(extractShellBlocks(reply)).toEqual(['ls -la']);
+    });
+    it('trims whitespace inside the block', () => {
+        const reply = '```bash\n\n  npm test  \n\n```';
+        expect(extractShellBlocks(reply)).toEqual(['npm test']);
+    });
+    it('skips empty blocks', () => {
+        const reply = '```bash\n\n\n```\nSome text\n```sh\necho hi\n```';
+        expect(extractShellBlocks(reply)).toEqual(['echo hi']);
+    });
+    it('ignores non-shell fenced blocks (e.g. ```ts, ```json)', () => {
+        const reply = '```ts\nconst x = 1;\n```\n```json\n{"a": 1}\n```';
+        expect(extractShellBlocks(reply)).toEqual([]);
+    });
+    it('returns an empty array when the reply has no code fences', () => {
+        expect(extractShellBlocks('just a plain text answer, no commands here')).toEqual([]);
+    });
+    it('handles multiple blocks of the same language', () => {
+        const reply = '```bash\necho a\n```\n```bash\necho b\n```';
+        expect(extractShellBlocks(reply)).toEqual(['echo a', 'echo b']);
+    });
+});
+// Shell-specific commands: runCommand picks powershell.exe on win32, /bin/sh elsewhere.
+const isWin = process.platform === 'win32';
+const echoCmd = (text) => (isWin ? `Write-Output '${text}'` : `echo '${text}'`);
+const sleepCmd = (seconds) => (isWin ? `Start-Sleep -Seconds ${seconds}` : `sleep ${seconds}`);
+describe('runCommand', () => {
+    it('captures stdout and a zero exit code on success', async () => {
+        const { stdout, code } = await runCommand(echoCmd('hello-vexi'), tmpdir());
+        expect(stdout).toContain('hello-vexi');
+        expect(code).toBe(0);
+    });
+    it('captures a non-zero exit code on failure', async () => {
+        const { code } = await runCommand('exit 3', tmpdir());
+        expect(code).toBe(3);
+    });
+    it('kills the process and reports a timeout note once the deadline passes', async () => {
+        const { stderr, code } = await runCommand(sleepCmd(5), tmpdir(), 300);
+        expect(stderr).toContain('timeout');
+        expect(code).not.toBe(0);
+    }, 10_000);
+    it('does not time out when the command finishes well within the deadline', async () => {
+        const { stdout, stderr } = await runCommand(echoCmd('fast'), tmpdir(), 10_000);
+        expect(stdout).toContain('fast');
+        expect(stderr).not.toContain('timeout');
+    });
+});

package/dist/cli.js

@@ -17,10 +17,11 @@
  *   vexi learn [--apply]       learn your coding style from past sessions
  */
 import { Command } from 'commander';
+import { confirm } from '@inquirer/prompts';
 import { VERSION } from './version.js';
 import ora from 'ora';
 import { checkForUpdate, runUpdate, runUninstall } from './update/index.js';
-import { runAgent } from './agent.js';
+import { runAgent, runPrint } from './agent.js';
 import { loadConfig, resetConfig, CONFIG_PATH } from './config.js';
 import { loadSkills, addSkill, removeSkill } from './skills/index.js';
 import { listSessions } from './replay/recorder.js';
@@ -57,6 +58,8 @@ export function buildCli() {
         .description('Open-source AI coding agent for your terminal. BYOK, zero config, multilingual.')
         .version(VERSION, '-v, --version')
         .option('-l, --lang <lang>', `UI language (${SUPPORTED_LANGS.join('/')})`)
+        .option('-p, --print <prompt>', 'non-interactive: send one prompt, print the reply, exit (for scripts/CI)')
+        .option('-y, --yes', 'with --print, auto-run any shell commands the model proposes (no confirmation)')
         .option('--mcp-server', 'run Vexi as an MCP server over stdio (for Claude Desktop, Cursor, etc.)')
         .option('--no-update-check', 'skip the daily background update check')
         .action(async (options) => {
@@ -67,6 +70,10 @@ export function buildCli() {
             return;
         }
         const lang = await resolveLang(options.lang);
+        if (options.print) {
+            await runPrint({ prompt: options.print, lang, autoYes: !!options.yes });
+            return;
+        }
         const noUpdateCheck = !options.updateCheck || !!process.env['VEXI_NO_UPDATE_CHECK'];
         const updateCheckPromise = noUpdateCheck ? Promise.resolve(null) : checkForUpdate();
         await runAgent({ lang, version: VERSION, updateCheckPromise });
@@ -123,7 +130,15 @@ export function buildCli() {
         .action(async (source) => {
         const s = getStrings(await resolveLang());
         try {
-            const name = await addSkill(process.cwd(), source);
+            const name = await addSkill(process.cwd(), source, {
+                confirmRemoteContent: async (content, skillName, sourceUrl) => {
+                    console.log(dim(`\nFetched from ${sourceUrl} — this will be added to every prompt as an instruction the AI must follow:\n`));
+                    console.log(dim('─'.repeat(60)));
+                    console.log(content.slice(0, 2000) + (content.length > 2000 ? dim('\n… (truncated)') : ''));
+                    console.log(dim('─'.repeat(60)));
+                    return confirm({ message: `Save as skill "${skillName}"?`, default: false });
+                },
+            });
             console.log(ok(t(s.skillAdded, { name })));
         }
         catch (e) {

package/dist/explain/index.js

@@ -12,6 +12,7 @@
  */
 import { promises as fs } from 'node:fs';
 import { basename, join, relative, resolve } from 'node:path';
+import { escapeHtml } from '../utils/html.js';
 /** Limits to keep prompts within context windows. */
 const MAX_FILE_BYTES = 100 * 1024;
 const MAX_TOTAL_BYTES = 120 * 1024;
@@ -229,10 +230,3 @@ function inline(text) {
         .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
         .replace(/`([^`]+)`/g, '<code>$1</code>');
 }
-function escapeHtml(text) {
-    return text
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;');
-}

package/dist/git/index.js

@@ -10,6 +10,18 @@
 function shellQuote(s) {
     return "'" + s.replace(/'/g, "'\\''") + "'";
 }
+/** Max length for a model-drafted commit message (well above conventional-commit norms). */
+const MAX_COMMIT_MSG_LEN = 200;
+/**
+ * Take the model's raw reply and turn it into a safe single-line commit message:
+ * first line only, control/escape characters stripped (so a malicious or broken
+ * reply can't inject terminal escape sequences when echoed back), length-capped.
+ */
+function sanitizeCommitMessage(raw) {
+    const firstLine = raw.replace(/`/g, '').split('\n')[0] ?? '';
+    const noControlChars = firstLine.replace(/[\x00-\x1f\x7f]/g, '');
+    return noControlChars.trim().slice(0, MAX_COMMIT_MSG_LEN);
+}
 const AUTH_SIGNATURES = [
     'could not read',
     'authentication failed',
@@ -78,7 +90,7 @@ export async function gitPush(opts) {
                 ];
                 try {
                     const raw = await provider.stream(messages, () => { });
-                    commitMsg = raw.replace(/`/g, '').split('\n')[0]?.trim() ?? '';
+                    commitMsg = sanitizeCommitMessage(raw);
                 }
                 catch {
                     // fall through to default below

package/dist/graph/html.js

@@ -12,6 +12,7 @@
  */
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
+import { escapeHtml } from '../utils/html.js';
 const LABELS = {
     en: {
         title: 'Vexi code graph',
@@ -85,7 +86,7 @@ export function buildGraphHtml(graph, lang) {
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>${L.title} — ${escapeHtml(graph.project)}</title>
-<script src="https://cdn.jsdelivr.net/npm/d3@7"></script>
+<script src="https://cdn.jsdelivr.net/npm/d3@7.9.0/dist/d3.min.js" integrity="sha384-CjloA8y00+1SDAUkjs099PVfnY2KmDC2BZnws9kh8D/lX1s46w6EPhpXdqMfjK6i" crossorigin="anonymous"></script>
 <style>
   :root { --accent: #2979FF; --bg: #0a0a0f; --panel: #12121a; --text: #e8e8f0; --dim: #8888a0; }
   * { box-sizing: border-box; }
@@ -216,10 +217,3 @@ document.getElementById('search').addEventListener('input', (ev) => {
 </html>
 `;
 }
-function escapeHtml(text) {
-    return text
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;');
-}

package/dist/i18n/index.js

@@ -26,7 +26,7 @@ const en = {
     apiError: 'API error: {message}',
     emptyKey: 'No key entered.',
     historyCleared: 'Conversation history cleared.',
-    helpText: '/help     show this help\n/model    switch model (e.g. /model gpt-4o)\n/memory   show compressed project memory\n/clear    clear conversation history\n/undo     revert last AI file edit\n/redo     re-apply last undone edit\n/history  list recent AI file edits\n/push     stage, commit and push to git (/push --only to skip commit)\n/exit     quit Vexi',
+    helpText: '/help     show this help\n/model    switch model (e.g. /model gpt-4o)\n/memory   show compressed project memory\n/clear    clear conversation history\n/undo     revert last AI file edit\n/redo     re-apply last undone edit\n/history  list recent AI file edits\n/push     stage, commit and push to git (/push --only to skip commit)\n/usage    token & cost estimate this session\n/exit     quit Vexi',
     modelSwitched: 'Model switched to {model}',
     configReset: 'Configuration deleted. Run `vexi` to set up again.',
     configResetNone: 'No configuration found.',
@@ -84,7 +84,7 @@ const es = {
     apiError: 'Error de API: {message}',
     emptyKey: 'No se introdujo ninguna clave.',
     historyCleared: 'Historial de conversación borrado.',
-    helpText: '/help    mostrar esta ayuda\n/model   cambiar modelo (p. ej. /model gpt-4o)\n/memory  ver la memoria comprimida del proyecto\n/clear   borrar historial de conversación\n/push    confirmar y enviar cambios a git\n/exit    salir de Vexi',
+    helpText: '/help    mostrar esta ayuda\n/model   cambiar modelo (p. ej. /model gpt-4o)\n/memory  ver la memoria comprimida del proyecto\n/clear   borrar historial de conversación\n/push    confirmar y enviar cambios a git\n/usage   tokens y coste estimado de la sesión\n/exit    salir de Vexi',
     modelSwitched: 'Modelo cambiado a {model}',
     configReset: 'Configuración eliminada. Ejecuta `vexi` para configurar de nuevo.',
     configResetNone: 'No se encontró configuración.',
@@ -142,7 +142,7 @@ const pt = {
     apiError: 'Erro de API: {message}',
     emptyKey: 'Nenhuma chave inserida.',
     historyCleared: 'Histórico de conversa apagado.',
-    helpText: '/help    mostrar esta ajuda\n/model   trocar modelo (ex.: /model gpt-4o)\n/memory  ver a memória comprimida do projeto\n/clear   apagar histórico de conversa\n/push    confirmar e enviar mudanças ao git\n/exit    sair do Vexi',
+    helpText: '/help    mostrar esta ajuda\n/model   trocar modelo (ex.: /model gpt-4o)\n/memory  ver a memória comprimida do projeto\n/clear   apagar histórico de conversa\n/push    confirmar e enviar mudanças ao git\n/usage   tokens e custo estimado da sessão\n/exit    sair do Vexi',
     modelSwitched: 'Modelo alterado para {model}',
     configReset: 'Configuração excluída. Execute `vexi` para configurar novamente.',
     configResetNone: 'Nenhuma configuração encontrada.',
@@ -200,7 +200,7 @@ const fr = {
     apiError: 'Erreur API : {message}',
     emptyKey: 'Aucune clé saisie.',
     historyCleared: 'Historique de conversation effacé.',
-    helpText: '/help    afficher cette aide\n/model   changer de modèle (ex. /model gpt-4o)\n/memory  voir la mémoire compressée du projet\n/clear   effacer l\'historique de conversation\n/push    valider et pousser les modifications git\n/exit    quitter Vexi',
+    helpText: '/help    afficher cette aide\n/model   changer de modèle (ex. /model gpt-4o)\n/memory  voir la mémoire compressée du projet\n/clear   effacer l\'historique de conversation\n/push    valider et pousser les modifications git\n/usage   tokens et coût estimé de la session\n/exit    quitter Vexi',
     modelSwitched: 'Modèle changé pour {model}',
     configReset: 'Configuration supprimée. Lancez `vexi` pour reconfigurer.',
     configResetNone: 'Aucune configuration trouvée.',

package/dist/mcp/client.js

@@ -57,7 +57,11 @@ export class McpManager {
         const parsed = McpManager.ArgsSchema.safeParse(args);
         if (!parsed.success)
             throw new Error(`Invalid tool arguments: ${parsed.error.message}`);
-        const result = await connection.client.callTool({ name: tool, arguments: parsed.data });
+        // Explicit timeout (matches the SDK default) so a hung MCP server can
+        // never freeze the chat loop, regardless of future SDK default changes.
+        const result = await connection.client.callTool({ name: tool, arguments: parsed.data }, undefined, {
+            timeout: 60_000,
+        });
         const content = Array.isArray(result.content) ? result.content : [];
         const text = content
             .map((c) => (c.type === 'text' ? (c.text ?? '') : `[${c.type}]`))