vexi-cli 0.5.5 → 0.9.0

package/dist/agent.js

@@ -21,17 +21,21 @@ import { input, select, confirm } from '@inquirer/prompts';
 import * as nodeRl from 'node:readline';
 import ora from 'ora';
 import { loadConfig, saveConfig, CONFIG_PATH } from './config.js';
-import { createProvider, detectProvider, sanitizeKey, PROVIDER_INFO, ProviderError, } from './providers/index.js';
+import { SnapshotManager } from './snapshots/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;
@@ -42,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 });
         });
     });
 }
@@ -116,8 +133,10 @@ export async function runAgent(opts) {
         config.lang = opts.lang;
         await saveConfig(config);
     }
-    let provider = createProvider(config.provider, config.apiKey, config.model);
+    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;
@@ -143,10 +162,15 @@ export async function runAgent(opts) {
         for (const f of failed)
             console.log(warn(t(s.mcpFailed, { name: f.name })));
     }
+    // ── Snapshot engine: register this session for undo/redo ─────────────
+    const snapshotSessionId = Date.now().toString(36);
+    const snapshots = new SnapshotManager(root, snapshotSessionId);
+    await snapshots.registerAsCurrentSession().catch(() => { });
     // ── Session recording (Vexi Replay) — saved after every turn ─────────
+    const providerLabel = config.displayName ?? PROVIDER_INFO[config.provider]?.label ?? config.provider;
     const recorder = new SessionRecorder(root, {
         project: basename(root),
-        provider: PROVIDER_INFO[config.provider].label,
+        provider: providerLabel,
         model: provider.model,
         lang: opts.lang,
     });
@@ -154,7 +178,7 @@ export async function runAgent(opts) {
         project: project?.stack.length
             ? `${basename(root)} (${project.stack.slice(0, 4).join(', ')})`
             : basename(root),
-        provider: PROVIDER_INFO[config.provider].label,
+        provider: providerLabel,
         model: provider.model,
         lang: opts.lang,
     });
@@ -164,19 +188,32 @@ export async function runAgent(opts) {
     if (skills.length > 0) {
         console.log(dim(t(s.skillsLoaded, { names: skills.map((sk) => sk.name).join(', ') })));
     }
+    // Peek at the update check (only picks up already-resolved results; never blocks)
+    const latestVersion = opts.updateCheckPromise
+        ? await Promise.race([
+            opts.updateCheckPromise,
+            new Promise((r) => setTimeout(() => r(null), 0)),
+        ])
+        : null;
+    if (latestVersion) {
+        console.log(dim(`Update available: ${opts.version} -> ${latestVersion}   run: npm install -g vexi-cli@latest`));
+    }
     console.log(dim(s.chatHint) + '\n');
     // ── Chat loop ────────────────────────────────────────────────────────
     const history = [];
     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
@@ -186,18 +223,59 @@ export async function runAgent(opts) {
     const maybeCompress = () => {
         if (compressing || history.length < KEEP_RECENT + COMPRESS_INTERVAL)
             return;
-        const archived = history.splice(0, history.length - KEEP_RECENT);
+        // Slice (not splice) — do NOT mutate history before we know compression succeeded.
+        const archiveCount = history.length - KEEP_RECENT;
+        const archived = history.slice(0, archiveCount);
         compressing = true;
         compressIntoMemory(provider, memory, archived)
             .then(async (updated) => {
+            // Only remove from history after a successful archive write.
+            history.splice(0, archiveCount);
             memory = updated;
             await saveMemory(root, updated);
         })
-            .catch(() => { }) // compression must never break the chat
+            .catch(() => { }) // history intact on failure — retries next turn
             .finally(() => {
             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 {
@@ -205,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;
         }
@@ -217,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;
@@ -245,7 +330,7 @@ export async function runAgent(opts) {
                     if (model) {
                         config.model = model;
                         await saveConfig(config);
-                        provider = createProvider(config.provider, config.apiKey, model);
+                        provider = createProviderFromConfig(config);
                         console.log(ok(t(s.modelSwitched, { model })) + '\n');
                     }
                     else {
@@ -253,6 +338,56 @@ export async function runAgent(opts) {
                     }
                     continue;
                 }
+                case '/undo': {
+                    const entry = await snapshots.undo().catch(() => null);
+                    if (!entry) {
+                        console.log(dim(s.undoNone) + '\n');
+                    }
+                    else {
+                        console.log(ok(t(s.undoDone, { files: entry.files.join(', ') })) + '\n');
+                    }
+                    continue;
+                }
+                case '/redo': {
+                    const entry = await snapshots.redo().catch(() => null);
+                    if (!entry) {
+                        console.log(dim(s.redoNone) + '\n');
+                    }
+                    else {
+                        console.log(ok(t(s.redoDone, { files: entry.files.join(', ') })) + '\n');
+                    }
+                    continue;
+                }
+                case '/history': {
+                    const entries = await snapshots.list().catch(() => []);
+                    if (entries.length === 0) {
+                        console.log(dim(s.historyNone) + '\n');
+                    }
+                    else {
+                        console.log(dim(s.historyHeader));
+                        for (const e of entries) {
+                            const time = new Date(e.at).toLocaleTimeString();
+                            console.log(accent(`  ${time}`) + dim(`  ${e.files.join(', ')}`) + dim(` — ${e.label.slice(0, 60)}`));
+                        }
+                        console.log();
+                    }
+                    continue;
+                }
+                case '/push': {
+                    const firstArg = rest[0] ?? '';
+                    const pushOnly = firstArg === '--only';
+                    const message = pushOnly || rest.length === 0 ? undefined : rest.join(' ').trim() || undefined;
+                    await gitPush({
+                        cwd: root,
+                        run: runCommand,
+                        confirm: (m) => confirm({ message: m, default: true }).catch(() => false),
+                        provider,
+                        message,
+                        pushOnly,
+                    });
+                    console.log();
+                    continue;
+                }
                 default:
                     console.log(warn(`Unknown command: ${cmd}`) + ' ' + dim('(/help)') + '\n');
                     continue;
@@ -264,45 +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;
-                    }
-                    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;
@@ -338,7 +492,7 @@ export async function runAgent(opts) {
                 const retry = await confirm({ message: s.reenterKey, default: true }).catch(() => false);
                 if (retry) {
                     config = await firstRunSetup(s, opts.lang);
-                    provider = createProvider(config.provider, config.apiKey, config.model);
+                    provider = createProviderFromConfig(config);
                 }
             }
             else {
@@ -348,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));
@@ -385,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',
@@ -415,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');
+    });
+});