vexi-cli 0.5.5 → 0.9.0

package/dist/git/index.js

@@ -0,0 +1,154 @@
+/**
+ * Git push workflow for the /push slash command.
+ *
+ * Design: fully injected — run, confirm, and provider are passed in so the
+ * module is testable without touching real git, the filesystem, or the network.
+ * All user-facing output goes through the injected log function.
+ * Every mutating git command is gated behind an explicit confirm call.
+ */
+/** Wrap a string in single quotes, escaping embedded single quotes. */
+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',
+    'permission denied',
+    'terminal prompts disabled',
+    'host key verification',
+    'batch mode',
+];
+function isAuthError(combined) {
+    const lower = combined.toLowerCase();
+    return AUTH_SIGNATURES.some((sig) => lower.includes(sig));
+}
+export async function gitPush(opts) {
+    const log = opts.log ?? ((l) => console.log(l));
+    const { cwd, run, confirm, provider } = opts;
+    // ── 1. Repo check ────────────────────────────────────────────────────────
+    const repoCheck = await run('git rev-parse --is-inside-work-tree', cwd);
+    if (repoCheck.code !== 0) {
+        log('Not a git repository. Initialize one with:');
+        log('  git init && git remote add origin <your-repo-url>');
+        return { ok: false, reason: 'not-a-repo' };
+    }
+    // ── 2. Remote check ──────────────────────────────────────────────────────
+    const remoteResult = await run('git remote', cwd);
+    if (!remoteResult.stdout.trim()) {
+        log('No git remote configured. Add one with:');
+        log('  git remote add origin <your-repo-url>');
+        return { ok: false, reason: 'no-remote' };
+    }
+    // ── 3. Resolve branch ────────────────────────────────────────────────────
+    const branch = opts.branch ?? (await run('git rev-parse --abbrev-ref HEAD', cwd)).stdout.trim();
+    if (!branch || branch === 'HEAD') {
+        log('Cannot determine current branch (detached HEAD?). Checkout a named branch first.');
+        return { ok: false, reason: 'aborted', detail: 'detached HEAD' };
+    }
+    // ── 4. Inspect working state ─────────────────────────────────────────────
+    const statusResult = await run('git status --porcelain', cwd);
+    // Preserve leading chars (XY status columns) — do NOT trim() the full output.
+    const statusLines = statusResult.stdout.split('\n').filter((l) => l.trim().length > 0);
+    const diffStat = (await run('git diff --stat HEAD', cwd)).stdout.trim();
+    if (diffStat)
+        log(diffStat);
+    // ── 5. Stage + commit (skipped when pushOnly) ─────────────────────────────
+    if (!opts.pushOnly) {
+        if (statusLines.length > 0) {
+            // Porcelain format: XY<space>filename — Y != ' ' means unstaged/untracked
+            const needsAdd = statusLines.some((l) => l.length >= 2 && l[1] !== ' ');
+            if (needsAdd) {
+                const addOk = await confirm('Stage all changes? (git add -A)');
+                if (!addOk)
+                    return { ok: false, reason: 'aborted' };
+                await run('git add -A', cwd);
+            }
+            // Draft or use the provided commit message
+            let commitMsg = opts.message ?? '';
+            if (!commitMsg) {
+                const stagedDiff = (await run('git diff --staged', cwd)).stdout;
+                const trimmedDiff = stagedDiff.slice(0, 6000);
+                const userContent = 'Write a single-line Conventional Commits message (type(scope): description) ' +
+                    'for the following diff. Reply with ONLY the commit message — no explanation, ' +
+                    'no markdown fences, no backticks.\n\n' +
+                    (trimmedDiff || '(no staged diff available)');
+                const messages = [
+                    { role: 'system', content: 'You draft git commit messages. Reply with only the message.' },
+                    { role: 'user', content: userContent },
+                ];
+                try {
+                    const raw = await provider.stream(messages, () => { });
+                    commitMsg = sanitizeCommitMessage(raw);
+                }
+                catch {
+                    // fall through to default below
+                }
+                if (!commitMsg)
+                    commitMsg = 'chore: update files';
+            }
+            log(`Proposed commit message: ${commitMsg}`);
+            const commitOk = await confirm(`Commit with: "${commitMsg}"?`);
+            if (!commitOk)
+                return { ok: false, reason: 'aborted' };
+            const commitResult = await run(`git commit -m ${shellQuote(commitMsg)}`, cwd);
+            if (commitResult.code !== 0) {
+                log(`Commit failed:\n${commitResult.stderr.trim()}`);
+                return { ok: false, reason: 'push-failed', detail: commitResult.stderr };
+            }
+        }
+        else {
+            // Nothing staged or unstaged — check for already-committed unpushed work
+            const logResult = await run('git log @{u}..HEAD --oneline', cwd);
+            if (logResult.code === 0 && !logResult.stdout.trim()) {
+                log('Nothing to commit and already up to date with remote.');
+                return { ok: false, reason: 'nothing-to-do' };
+            }
+            if (logResult.stdout.trim()) {
+                log(`Unpushed commits:\n${logResult.stdout.trim()}`);
+            }
+            // code !== 0 means no upstream yet — proceed, the push step will set -u
+        }
+    }
+    // ── 6. Auth pre-flight ───────────────────────────────────────────────────
+    const safeBranch = shellQuote(branch);
+    // Disable terminal prompts so git never hangs waiting for input.
+    // On Windows, Git for Windows respects GIT_TERMINAL_PROMPT via its own env.
+    const dryRunCmd = process.platform === 'win32'
+        ? `git -c core.askPass= push --dry-run origin ${safeBranch}`
+        : `GIT_TERMINAL_PROMPT=0 GIT_SSH_COMMAND='ssh -o BatchMode=yes' git -c core.askPass= push --dry-run origin ${safeBranch}`;
+    const dryResult = await run(dryRunCmd, cwd);
+    if (dryResult.code !== 0 && isAuthError(dryResult.stderr + dryResult.stdout)) {
+        log('Authentication failed. Set up git credentials:');
+        log('  • SSH key: https://docs.github.com/authentication/connecting-to-github-with-ssh');
+        log('  • HTTPS token: personal access token or git credential helper.');
+        return { ok: false, reason: 'auth-failed', detail: dryResult.stderr };
+    }
+    // ── 7. Push ──────────────────────────────────────────────────────────────
+    const upstreamResult = await run(`git rev-parse --abbrev-ref --symbolic-full-name ${shellQuote(`${branch}@{upstream}`)}`, cwd);
+    const hasUpstream = upstreamResult.code === 0 && upstreamResult.stdout.trim().length > 0;
+    const pushCmd = hasUpstream
+        ? `git push origin ${safeBranch}`
+        : `git push -u origin ${safeBranch}`;
+    const pushOk = await confirm(`Run: ${pushCmd}?`);
+    if (!pushOk)
+        return { ok: false, reason: 'aborted' };
+    const pushResult = await run(pushCmd, cwd);
+    if (pushResult.code !== 0) {
+        log(`Push failed:\n${pushResult.stderr.trim()}`);
+        return { ok: false, reason: 'push-failed', detail: pushResult.stderr };
+    }
+    log(`Pushed ${branch} to origin.`);
+    return { ok: true };
+}

package/dist/git/index.test.js

@@ -0,0 +1,178 @@
+import { describe, it, expect } from 'vitest';
+import { gitPush } from './index.js';
+/** Build a mock `run` that returns canned results matched by command substring. */
+function makeRun(specs = []) {
+    const calls = [];
+    const run = async (cmd, _cwd) => {
+        calls.push(cmd);
+        for (const spec of specs) {
+            if (cmd.includes(spec.match))
+                return spec.out;
+        }
+        return { stdout: '', stderr: '', code: 0 };
+    };
+    return { run, calls };
+}
+/** Build a mock `confirm` that returns scripted booleans in sequence. */
+function makeConfirm(answers = []) {
+    const calls = [];
+    let i = 0;
+    const confirm = async (msg) => {
+        calls.push(msg);
+        return answers[i++] ?? true;
+    };
+    return { confirm, calls };
+}
+const MOCK_PROVIDER = {
+    id: 'openai',
+    model: 'gpt-4o',
+    stream: async () => 'feat: add new feature',
+};
+const OK = { stdout: '', stderr: '', code: 0 };
+/** Specs shared by all happy-path scenarios. */
+function happySpecs(branch = 'main', opts = {}) {
+    return [
+        { match: '--is-inside-work-tree', out: { stdout: 'true\n', stderr: '', code: 0 } },
+        { match: 'git remote', out: { stdout: 'origin\n', stderr: '', code: 0 } },
+        { match: '--abbrev-ref HEAD', out: { stdout: `${branch}\n`, stderr: '', code: 0 } },
+        { match: 'status --porcelain', out: OK },
+        { match: 'diff --stat HEAD', out: OK },
+        { match: 'push --dry-run', out: OK }, // must come before 'push origin'
+        {
+            match: '--symbolic-full-name',
+            out: opts.upstreamExists === false
+                ? { stdout: '', stderr: 'fatal: no upstream configured', code: 128 }
+                : { stdout: `origin/${branch}\n`, stderr: '', code: 0 },
+        },
+        { match: 'push origin', out: OK },
+        { match: 'push -u', out: OK },
+    ];
+}
+// ── Test cases ────────────────────────────────────────────────────────────────
+describe('gitPush', () => {
+    // 1. Not a git repo
+    it('returns not-a-repo and runs no mutating commands', async () => {
+        const { run, calls } = makeRun([
+            { match: '--is-inside-work-tree', out: { stdout: '', stderr: '', code: 128 } },
+        ]);
+        const { confirm } = makeConfirm();
+        const logs = [];
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER,
+            log: (l) => logs.push(l),
+        });
+        expect(result).toEqual({ ok: false, reason: 'not-a-repo' });
+        expect(calls.some((c) => c.includes('git add'))).toBe(false);
+        expect(calls.some((c) => c.includes('git commit'))).toBe(false);
+        expect(calls.some((c) => c.includes('git push'))).toBe(false);
+        expect(logs.some((l) => l.includes('git init'))).toBe(true);
+    });
+    // 2. No remote configured
+    it('returns no-remote and nothing is pushed', async () => {
+        const { run, calls } = makeRun([
+            { match: '--is-inside-work-tree', out: { stdout: 'true\n', stderr: '', code: 0 } },
+            { match: 'git remote', out: { stdout: '', stderr: '', code: 0 } },
+        ]);
+        const { confirm } = makeConfirm();
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER,
+        });
+        expect(result).toEqual({ ok: false, reason: 'no-remote' });
+        expect(calls.some((c) => c.includes('git push'))).toBe(false);
+    });
+    // 3. Auth pre-flight fails → real push is NEVER run
+    it('returns auth-failed when dry-run shows an auth-signature error', async () => {
+        const { run, calls } = makeRun([
+            { match: '--is-inside-work-tree', out: { stdout: 'true\n', stderr: '', code: 0 } },
+            { match: 'git remote', out: { stdout: 'origin\n', stderr: '', code: 0 } },
+            { match: '--abbrev-ref HEAD', out: { stdout: 'main\n', stderr: '', code: 0 } },
+            { match: 'status --porcelain', out: OK },
+            { match: 'diff --stat HEAD', out: OK },
+            // dry-run fails with auth-signature stderr
+            {
+                match: 'push --dry-run',
+                out: { stdout: '', stderr: 'could not read Username for remote: terminal prompts disabled', code: 1 },
+            },
+        ]);
+        const { confirm } = makeConfirm([true]); // any confirms before push would be true
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER, pushOnly: true,
+        });
+        expect(result.ok).toBe(false);
+        expect(result.reason).toBe('auth-failed');
+        // The real (non-dry-run) push must NOT have been called
+        expect(calls.some((c) => c.includes('push') && !c.includes('--dry-run'))).toBe(false);
+    });
+    // 4. Happy path: unstaged changes, no message → add, AI-draft commit, push
+    it('stages, AI-drafts commit message, and pushes; returns ok: true', async () => {
+        const { run, calls } = makeRun([
+            { match: '--is-inside-work-tree', out: { stdout: 'true\n', stderr: '', code: 0 } },
+            { match: 'git remote', out: { stdout: 'origin\n', stderr: '', code: 0 } },
+            { match: '--abbrev-ref HEAD', out: { stdout: 'main\n', stderr: '', code: 0 } },
+            // ' M' → Y='M' → unstaged modification → needsAdd = true
+            { match: 'status --porcelain', out: { stdout: ' M src/foo.ts\n', stderr: '', code: 0 } },
+            { match: 'diff --stat HEAD', out: { stdout: '1 file changed, 2 insertions(+)\n', stderr: '', code: 0 } },
+            { match: 'add -A', out: OK },
+            { match: 'diff --staged', out: { stdout: '+added a line\n', stderr: '', code: 0 } },
+            { match: 'commit -m', out: OK },
+            { match: 'push --dry-run', out: OK },
+            { match: '--symbolic-full-name', out: { stdout: 'origin/main\n', stderr: '', code: 0 } },
+            { match: 'push origin', out: OK },
+        ]);
+        // all confirms: add, commit, push
+        const { confirm } = makeConfirm([true, true, true]);
+        const logs = [];
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER,
+            log: (l) => logs.push(l),
+        });
+        expect(result).toEqual({ ok: true });
+        expect(calls.some((c) => c.includes('add -A'))).toBe(true);
+        expect(calls.some((c) => c.includes('commit -m'))).toBe(true);
+        // Real push (non-dry-run) was called
+        expect(calls.some((c) => c.includes('push origin') && !c.includes('--dry-run'))).toBe(true);
+        // AI-drafted message appears in the log
+        expect(logs.some((l) => l.includes('feat: add new feature'))).toBe(true);
+        // Final success message
+        expect(logs.some((l) => l.includes('Pushed main to origin'))).toBe(true);
+    });
+    // 5. pushOnly: true → no git add or git commit
+    it('pushOnly skips staging and committing, only pushes', async () => {
+        const { run, calls } = makeRun(happySpecs());
+        const { confirm } = makeConfirm([true]); // only the push confirm
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER, pushOnly: true,
+        });
+        expect(result).toEqual({ ok: true });
+        expect(calls.some((c) => c.includes('add -A'))).toBe(false);
+        expect(calls.some((c) => c.includes('commit -m'))).toBe(false);
+        expect(calls.some((c) => c.includes('push origin') && !c.includes('--dry-run'))).toBe(true);
+    });
+    // 6. User declines push confirm → aborted, no real push runs
+    it('returns aborted when user declines the push confirm', async () => {
+        const { run, calls } = makeRun(happySpecs());
+        // pushOnly so there are no add/commit confirms; only one confirm: the push
+        const { confirm } = makeConfirm([false]);
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER, pushOnly: true,
+        });
+        expect(result).toEqual({ ok: false, reason: 'aborted' });
+        // No real push was issued after the decline
+        expect(calls.some((c) => c.includes('push origin') && !c.includes('--dry-run'))).toBe(false);
+        expect(calls.some((c) => c.includes('push -u'))).toBe(false);
+    });
+    // 7. New branch with no upstream → git push -u origin <branch>
+    it('uses git push -u when no upstream is configured', async () => {
+        const branch = 'feature/new-thing';
+        const { run, calls } = makeRun(happySpecs(branch, { upstreamExists: false }));
+        const { confirm } = makeConfirm([true]);
+        const result = await gitPush({
+            cwd: '/proj', run, confirm, provider: MOCK_PROVIDER,
+            pushOnly: true, branch,
+        });
+        expect(result).toEqual({ ok: true });
+        // Must use -u form, not the plain push
+        expect(calls.some((c) => c.includes('push -u'))).toBe(true);
+        expect(calls.some((c) => c.includes('push origin') && !c.includes('push -u') && !c.includes('--dry-run'))).toBe(false);
+    });
+});

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

@@ -12,13 +12,13 @@
 export const SUPPORTED_LANGS = ['en', 'ar', 'es', 'pt', 'fr'];
 const en = {
     welcome: 'Welcome to Vexi — your AI coding agent in the terminal.',
-    firstRunIntro: 'First run: Vexi needs an API key (Anthropic, OpenAI, OpenRouter, Groq or Gemini).\nIt is stored locally in ~/.vexi/config.json — no login, no server, no telemetry.',
+    firstRunIntro: 'First run: Vexi needs an API key.\nSupported: Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras · DeepSeek · Qwen · Kimi · MiniMax\nIf auto-detection picks the wrong provider, just re-enter your key and select from the list.\nStored locally in ~/.vexi/config.json — no login, no server, no telemetry.',
     enterApiKey: 'Paste your API key',
     detectedProvider: 'Provider detected: {provider}',
     detectFailed: 'Could not auto-detect the provider for this key.',
     selectProvider: 'Select your provider',
     configSaved: 'Saved to {path} (readable only by your OS user).',
-    chatHint: 'Type your message. Commands: /help /model /clear /exit',
+    chatHint: 'Type your message. Commands: /help /model /clear /undo /redo /history /push /exit',
     thinking: 'Thinking…',
     goodbye: 'Goodbye! 👋',
     invalidKey: 'The API key was rejected by the provider (unauthorized).',
@@ -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/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.',
@@ -59,16 +59,24 @@ const en = {
     learnPreview: 'Learned from {sessions} sessions ({signals} corrections found):',
     learnApplyHint: 'Looks right? Save it with: vexi learn --apply',
     learnApplied: 'Learned style saved: {path} — now injected into every session.',
+    undoNone: 'Nothing to undo — no file snapshots in this session.',
+    undoDone: 'Reverted: {files}',
+    redoNone: 'Nothing to redo.',
+    redoDone: 'Re-applied: {files}',
+    historyNone: 'No file snapshots yet — make some AI edits first.',
+    historyHeader: 'Recent AI file edits (newest first):',
+    cleanDone: 'Cleaned {count} old snapshot session(s).',
+    snapshotNoSession: 'No active Vexi session found. Run `vexi` first to start a session.',
 };
 const es = {
     welcome: 'Bienvenido a Vexi — tu agente de programación con IA en la terminal.',
-    firstRunIntro: 'Primer uso: Vexi necesita una clave API (Anthropic, OpenAI, OpenRouter, Groq o Gemini).\nSe guarda localmente en ~/.vexi/config.json — sin registro, sin servidor, sin telemetría.',
+    firstRunIntro: 'Primer uso: Vexi necesita una clave API.\nCompatibles (varios son gratuitos): Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras\nGuardada en ~/.vexi/config.json — sin registro, sin servidor, sin telemetría.',
     enterApiKey: 'Pega tu clave API',
     detectedProvider: 'Proveedor detectado: {provider}',
     detectFailed: 'No se pudo detectar automáticamente el proveedor de esta clave.',
     selectProvider: 'Selecciona tu proveedor',
     configSaved: 'Guardado en {path} (solo legible por tu usuario del sistema).',
-    chatHint: 'Escribe tu mensaje. Comandos: /help /model /clear /exit',
+    chatHint: 'Escribe tu mensaje. Comandos: /help /model /clear /push /exit',
     thinking: 'Pensando…',
     goodbye: '¡Hasta luego! 👋',
     invalidKey: 'El proveedor rechazó la clave API (no autorizada).',
@@ -76,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/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.',
@@ -109,16 +117,24 @@ const es = {
     learnPreview: 'Aprendido de {sessions} sesiones ({signals} correcciones encontradas):',
     learnApplyHint: '¿Se ve bien? Guárdalo con: vexi learn --apply',
     learnApplied: 'Estilo aprendido guardado: {path} — ahora se inyecta en cada sesión.',
+    undoNone: 'Nada que deshacer — no hay instantáneas de archivos en esta sesión.',
+    undoDone: 'Revertido: {files}',
+    redoNone: 'Nada que rehacer.',
+    redoDone: 'Reaplicado: {files}',
+    historyNone: 'Aún no hay instantáneas de archivos — haz ediciones con IA primero.',
+    historyHeader: 'Ediciones de archivos recientes de la IA (más recientes primero):',
+    cleanDone: 'Se eliminaron {count} sesión(es) de instantáneas antiguas.',
+    snapshotNoSession: 'No se encontró ninguna sesión activa de Vexi. Ejecuta `vexi` primero.',
 };
 const pt = {
     welcome: 'Bem-vindo ao Vexi — seu agente de programação com IA no terminal.',
-    firstRunIntro: 'Primeira execução: o Vexi precisa de uma chave de API (Anthropic, OpenAI, OpenRouter, Groq ou Gemini).\nEla é guardada localmente em ~/.vexi/config.json — sem login, sem servidor, sem telemetria.',
+    firstRunIntro: 'Primeira execução: o Vexi precisa de uma chave de API.\nCompatíveis (vários gratuitos): Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras\nGuardada em ~/.vexi/config.json — sem login, sem servidor, sem telemetria.',
     enterApiKey: 'Cole sua chave de API',
     detectedProvider: 'Provedor detectado: {provider}',
     detectFailed: 'Não foi possível detectar automaticamente o provedor desta chave.',
     selectProvider: 'Selecione seu provedor',
     configSaved: 'Salvo em {path} (legível apenas pelo seu usuário do sistema).',
-    chatHint: 'Digite sua mensagem. Comandos: /help /model /clear /exit',
+    chatHint: 'Digite sua mensagem. Comandos: /help /model /clear /push /exit',
     thinking: 'Pensando…',
     goodbye: 'Até logo! 👋',
     invalidKey: 'O provedor rejeitou a chave de API (não autorizada).',
@@ -126,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/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.',
@@ -159,16 +175,24 @@ const pt = {
     learnPreview: 'Aprendido de {sessions} sessões ({signals} correções encontradas):',
     learnApplyHint: 'Parece certo? Salve com: vexi learn --apply',
     learnApplied: 'Estilo aprendido salvo: {path} — agora é injetado em cada sessão.',
+    undoNone: 'Nada a desfazer — sem instantâneos de arquivos nesta sessão.',
+    undoDone: 'Revertido: {files}',
+    redoNone: 'Nada a refazer.',
+    redoDone: 'Reaplicado: {files}',
+    historyNone: 'Ainda não há instantâneos de arquivos — faça edições com IA primeiro.',
+    historyHeader: 'Edições de arquivos recentes da IA (mais recentes primeiro):',
+    cleanDone: 'Foram removidas {count} sessão(ões) de instantâneos antigas.',
+    snapshotNoSession: 'Nenhuma sessão ativa do Vexi encontrada. Execute `vexi` primeiro.',
 };
 const fr = {
     welcome: 'Bienvenue dans Vexi — votre agent de codage IA dans le terminal.',
-    firstRunIntro: 'Première utilisation : Vexi a besoin d\'une clé API (Anthropic, OpenAI, OpenRouter, Groq ou Gemini).\nElle est stockée localement dans ~/.vexi/config.json — sans compte, sans serveur, sans télémétrie.',
+    firstRunIntro: 'Première utilisation : Vexi a besoin d\'une clé API.\nCompatibles (plusieurs gratuits) : Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras\nStockée dans ~/.vexi/config.json — sans compte, sans serveur, sans télémétrie.',
     enterApiKey: 'Collez votre clé API',
     detectedProvider: 'Fournisseur détecté : {provider}',
     detectFailed: 'Impossible de détecter automatiquement le fournisseur de cette clé.',
     selectProvider: 'Sélectionnez votre fournisseur',
     configSaved: 'Enregistré dans {path} (lisible uniquement par votre utilisateur système).',
-    chatHint: 'Tapez votre message. Commandes : /help /model /clear /exit',
+    chatHint: 'Tapez votre message. Commandes : /help /model /clear /push /exit',
     thinking: 'Réflexion…',
     goodbye: 'À bientôt ! 👋',
     invalidKey: 'La clé API a été rejetée par le fournisseur (non autorisée).',
@@ -176,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/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.',
@@ -209,6 +233,14 @@ const fr = {
     learnPreview: 'Appris de {sessions} sessions ({signals} corrections trouvées) :',
     learnApplyHint: 'Ça vous convient ? Enregistrez avec : vexi learn --apply',
     learnApplied: 'Style appris enregistré : {path} — désormais injecté dans chaque session.',
+    undoNone: 'Rien à annuler — aucun instantané de fichier dans cette session.',
+    undoDone: 'Rétabli : {files}',
+    redoNone: 'Rien à rétablir.',
+    redoDone: 'Réappliqué : {files}',
+    historyNone: 'Pas encore d\'instantanés de fichiers — effectuez d\'abord des modifications avec l\'IA.',
+    historyHeader: 'Modifications de fichiers récentes de l\'IA (plus récentes en premier) :',
+    cleanDone: '{count} session(s) d\'instantanés ancienne(s) supprimée(s).',
+    snapshotNoSession: 'Aucune session Vexi active trouvée. Exécutez `vexi` d\'abord.',
 };
 const STRINGS = {
     en,

package/dist/mcp/client.js

@@ -9,6 +9,8 @@
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { z } from 'zod';
+import { VERSION } from '../version.js';
 import { loadMcpConfig } from './config.js';
 export class McpManager {
     connections = [];
@@ -26,7 +28,7 @@ export class McpManager {
                     env: { ...process.env, ...server.env },
                     stderr: 'ignore',
                 });
-                const client = new Client({ name: 'vexi', version: '0.5.0' });
+                const client = new Client({ name: 'vexi', version: VERSION });
                 await client.connect(transport);
                 const { tools } = await client.listTools();
                 for (const tool of tools) {
@@ -46,12 +48,20 @@ export class McpManager {
         }
         return { connected, failed };
     }
+    static ArgsSchema = z.record(z.string(), z.unknown());
     /** Call a tool on a connected server; returns the text result. */
     async callTool(server, tool, args) {
         const connection = this.connections.find((c) => c.name === server);
         if (!connection)
             throw new Error(`MCP server "${server}" is not connected.`);
-        const result = await connection.client.callTool({ name: tool, arguments: args });
+        const parsed = McpManager.ArgsSchema.safeParse(args);
+        if (!parsed.success)
+            throw new Error(`Invalid tool arguments: ${parsed.error.message}`);
+        // 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}]`))

package/dist/mcp/server.js

@@ -23,8 +23,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { VERSION } from '../version.js';
 import { loadConfig } from '../config.js';
-import { createProvider } from '../providers/index.js';
+import { createProviderFromConfig } from '../providers/index.js';
 import { scanProject, projectSummary } from '../scanner/index.js';
 import { loadMemory, memoryBlock } from '../memory/index.js';
 import { listSessions } from '../replay/recorder.js';
@@ -32,7 +33,7 @@ import { gatherSource, buildExplainMessages } from '../explain/index.js';
 import { SUPPORTED_LANGS } from '../i18n/index.js';
 export async function runMcpServer() {
     const root = process.cwd();
-    const server = new McpServer({ name: 'vexi', version: '0.5.0' });
+    const server = new McpServer({ name: 'vexi', version: VERSION });
     // ── Resources ──────────────────────────────────────────────────────────
     server.registerResource('project-map', 'vexi://project', {
         title: 'Project map',
@@ -92,7 +93,7 @@ export async function runMcpServer() {
             };
         }
         try {
-            const provider = createProvider(config.provider, config.apiKey, config.model);
+            const provider = createProviderFromConfig(config);
             const source = await gatherSource(path);
             const markdown = await provider.stream(buildExplainMessages(source, language), () => { });
             return { content: [{ type: 'text', text: markdown }] };

package/dist/memory/compress.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { compressIntoMemory, KEEP_RECENT, COMPRESS_INTERVAL } from './index.js';
+function makeMessages(n) {
+    return Array.from({ length: n }, (_, i) => ({
+        role: (i % 2 === 0 ? 'user' : 'assistant'),
+        content: `message ${i}`,
+    }));
+}
+const failingProvider = {
+    id: 'openai',
+    model: 'gpt-4o',
+    stream: async () => { throw new Error('provider failure'); },
+};
+const emptyMemory = {
+    version: 1,
+    summary: '',
+    decisions: [],
+    updatedAt: '',
+    compressedCount: 0,
+};
+describe('Fix 1: maybeCompress data-loss guard', () => {
+    it('returns original memory unchanged when provider.stream throws', async () => {
+        const messages = makeMessages(KEEP_RECENT + COMPRESS_INTERVAL + 2);
+        const original = { ...emptyMemory, summary: 'prior summary' };
+        const result = await compressIntoMemory(failingProvider, original, messages);
+        expect(result).toBe(original); // same reference — not mutated, not replaced
+        expect(result.summary).toBe('prior summary');
+    });
+    it('returns original memory when provider returns malformed JSON', async () => {
+        const badProvider = {
+            id: 'openai',
+            model: 'gpt-4o',
+            stream: async () => 'this is not json at all',
+        };
+        const original = { ...emptyMemory, decisions: ['keep this'] };
+        const result = await compressIntoMemory(badProvider, original, makeMessages(4));
+        expect(result).toBe(original);
+        expect(result.decisions).toEqual(['keep this']);
+    });
+    it('returns updated memory when provider returns valid JSON', async () => {
+        const goodProvider = {
+            id: 'openai',
+            model: 'gpt-4o',
+            stream: async () => '{"summary":"new summary","decisions":["decision A"]}',
+        };
+        const original = { ...emptyMemory };
+        const result = await compressIntoMemory(goodProvider, original, makeMessages(4));
+        expect(result).not.toBe(original);
+        expect(result.summary).toBe('new summary');
+        expect(result.decisions).toEqual(['decision A']);
+    });
+});