vexi-cli 0.5.5 → 0.8.0

package/README.md

@@ -15,6 +15,7 @@ Bring your own key · Zero config · Multilingual · 100% local
 [![npm](https://img.shields.io/npm/v/vexi-cli?color=2979FF)](https://www.npmjs.com/package/vexi-cli)
 [![license](https://img.shields.io/badge/license-MIT-2979FF)](LICENSE)
 [![node](https://img.shields.io/badge/node-%E2%89%A518-2979FF)](package.json)
+[![website](https://img.shields.io/badge/website-vexi.pro-2979FF)](https://vexi.pro)
 
 **English** · [العربية](#-العربية) · [Español](#-español) · [Português](#-português) · [Français](#-français)
 
@@ -31,19 +32,89 @@ vexi
 
 That's it. No login, no signup, no server, no database. Everything runs locally.
 
+## Update
+
+```bash
+vexi update
+# or directly:
+npm install -g vexi-cli@latest
+```
+
+Vexi checks once a day whether a newer version is published on npm and prints a
+one-line notice at startup if one is available. To disable the check:
+
+```bash
+vexi --no-update-check          # skip for this run
+VEXI_NO_UPDATE_CHECK=1 vexi     # skip via environment variable
+```
+
+## Uninstall
+
+```bash
+vexi uninstall           # removes Vexi, keeps your ~/.vexi config
+vexi uninstall --purge   # also deletes ~/.vexi (config, keys, memory)
+```
+
+Or directly, without running Vexi:
+
+```bash
+npm uninstall -g vexi-cli
+rm -rf ~/.vexi           # optional -- removes config, keys, and memory
+```
+
+On Windows:
+
+```cmd
+npm uninstall -g vexi-cli
+rmdir /s /q %USERPROFILE%\.vexi
+```
+
 ## BYOK — Bring Your Own Key
 
 On first run, paste any API key. Vexi **auto-detects the provider** from the key format:
 
-| Key prefix          | Provider          |
-| ------------------- | ----------------- |
-| `sk-ant-...`        | Anthropic (Claude)|
-| `sk-or-...`         | OpenRouter        |
-| `gsk_...`           | Groq              |
-| `AIza...`           | Google Gemini     |
-| `sk-...` / `sk-proj-...` | OpenAI       |
+| Key prefix | Provider | Auto-detect? | Free tier? |
+| ---------- | -------- | ------------ | ---------- |
+| `sk-ant-...` | Anthropic (Claude) | ✅ | — |
+| `sk-or-...` | OpenRouter | ✅ | ✅ free models |
+| `gsk_...` | Groq | ✅ | ✅ free |
+| `AIza...` | Google Gemini | ✅ | ✅ free |
+| `csk-...` | Cerebras | ✅ | ✅ free |
+| `<32-hex>.<secret>` | Zhipu AI — GLM | ✅ | ✅ free |
+| `sk-proj-...` | OpenAI | ✅ | — |
+| `sk-...` *(classic)* | OpenAI / DeepSeek / Kimi — pick manually | manual select | DeepSeek ✅ / Kimi ✅ |
+| *(any)* | Qwen · Mistral · MiniMax | manual select | ✅ free |
 
-If detection is ambiguous, Vexi simply asks you to pick the provider. Your key is stored **locally** in `~/.vexi/config.json` with owner-only file permissions (`chmod 600`).
+> **Tip:** If Vexi guesses the wrong provider, run `vexi config reset`, paste your key again, and pick from the list.
+
+Your key is stored **locally** in `~/.vexi/config.json` with owner-only file permissions (`chmod 600`).
+
+### 🆓 Start for free — no credit card needed
+
+**International:**
+
+| Provider | Sign-up | Free model | Speed |
+| -------- | ------- | ---------- | ----- |
+| **Groq** | [console.groq.com](https://console.groq.com) | Llama 3.3 70B | ⚡⚡ very fast |
+| **Google Gemini** | [aistudio.google.com](https://aistudio.google.com) | Gemini 2.5 Flash | ⚡ fast |
+| **Cerebras** | [cloud.cerebras.ai](https://cloud.cerebras.ai) | Llama 3.3 70B | ⚡⚡⚡ fastest |
+| **OpenRouter** | [openrouter.ai](https://openrouter.ai) | many free models | varies |
+
+**Chinese AI (all free tier, great quality):**
+
+| Provider | Sign-up | Free model | Notes |
+| -------- | ------- | ---------- | ----- |
+| **DeepSeek** | [platform.deepseek.com](https://platform.deepseek.com) | deepseek-chat (V3) | excellent coder |
+| **Zhipu AI — GLM** | [bigmodel.cn](https://bigmodel.cn) | glm-4-flash | auto-detected |
+| **Alibaba Qwen** | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) | qwen-turbo | manual select |
+| **Kimi (Moonshot)** | [platform.moonshot.cn](https://platform.moonshot.cn) | moonshot-v1-8k | manual select |
+| **MiniMax** | [platform.minimaxi.com](https://platform.minimaxi.com) | MiniMax-Text-01 | manual select |
+
+To switch provider at any time:
+```bash
+vexi config reset   # wipe the stored key
+vexi                # restart — prompts for a new key
+```
 
 ## Multilingual
 
@@ -78,16 +149,23 @@ vexi mcp list               # manage external MCP servers
 vexi --mcp-server           # expose Vexi as an MCP server (stdio)
 vexi learn                  # learn your coding style from past sessions
 vexi learn --apply          # save it as a skill (injected in every session)
+vexi undo                   # revert the last AI file edit
+vexi redo                   # re-apply a reverted edit
+vexi history                # list recent AI file edits with timestamps
+vexi clean                  # clear old snapshots (.vexi/snapshots/)
 ```
 
 Inside the chat:
 
 ```
-/help    show available commands
-/model   switch model (e.g. /model gpt-4o)
-/memory  show compressed project memory
-/clear   clear conversation history
-/exit    quit
+/help     show available commands
+/model    switch model (e.g. /model gpt-4o)
+/memory   show compressed project memory
+/clear    clear conversation history
+/undo     revert last AI file edit
+/redo     re-apply last undone edit
+/history  list recent AI file edits
+/exit     quit
 ```
 
 ## ⚙️ Multi-language build support
@@ -241,6 +319,29 @@ session, so you stop repeating yourself. Everything stays local — the only
 network call is to your own model provider, and you always preview before
 saving.
 
+## ↩️ Undo / Redo — instant rescue from any AI edit
+
+> Approve a change, see it break things, type `vexi undo`. Done.
+
+```bash
+vexi undo      # revert the last AI-applied file change
+vexi redo      # re-apply a reverted change
+vexi history   # list every file edit this session, with timestamps
+vexi clean     # remove old snapshot sessions to free disk space
+```
+
+Or use the in-chat shortcuts without leaving the session: `/undo`, `/redo`, `/history`.
+
+**How it works (lightweight snapshot design):**
+
+- Before executing any confirmed shell command, Vexi inspects it for file-write patterns (`cat >`, `sed -i`, `mv`, `cp`, `tee`, `writeFileSync`, PowerShell `Set-Content`, and bare source-file tokens) and saves a copy of **only the affected files** into `.vexi/snapshots/<session>/`.
+- `undo` restores the pre-command copy and saves the current state as a redo point — so you can bounce back and forth freely.
+- Each session keeps a maximum of 50 snapshots; the oldest are pruned automatically.
+- Snapshots are **per-file, not per-project** — no full-tree indexing, no slow startup, no huge disk usage (the approach OpenCode's whole-tree snapshot system suffers from).
+- `vexi clean` wipes all previous sessions' snapshots while keeping the current one active.
+
+This pairs naturally with the confirmation prompt: even if you approve a change that turns out to be wrong, one command gets you back.
+
 ## Roadmap
 
 | Phase | Feature | Status |
@@ -250,19 +351,23 @@ saving.
 | 3 | **Vexi Replay** (export sessions as animated HTML) · multilingual code explanation | ✅ done |
 | 4 | Visual code graph · MCP support (client **and** server mode) | ✅ done |
 | 5 | **Vexi Learn** — adapts to your personal coding style | ✅ done |
+| 6 | **Multi-language builds** — auto-executes pip, gcc, javac, cargo, gradle from chat | ✅ done |
+| 7 | **Undo / Redo** — instant one-command revert of any AI file edit, without touching git | ✅ done |
 
 ## Why Vexi?
 
 | | Vexi | OpenCode | Claude Code | Cursor |
 | --- | --- | --- | --- | --- |
 | Install | `npm i -g vexi-cli` | binary/script | `npm i -g` | desktop app |
-| BYOK (any provider) | ✅ 5 providers, auto-detect | ✅ | ❌ Anthropic only | partial |
+| BYOK (any provider) | ✅ 12 providers incl. Chinese AI | ✅ | ❌ Anthropic only | partial |
 | Works fully offline/local | ✅ no server, no account | ✅ | ❌ account | ❌ account |
 | Native-language code explanations | ✅ ar/es/pt/fr | ❌ | ❌ | ❌ |
 | Session replay export | ✅ | ❌ | ❌ | ❌ |
 | Persistent project memory | ✅ | partial | partial | ✅ |
 | Learns your personal coding style | ✅ from your own sessions | ❌ | ❌ | partial |
 | MCP server mode (be a tool for other agents) | ✅ | ❌ | ❌ | ❌ |
+| Builds any language (Python, Java, C, Rust, Go) | ✅ | ❌ | ✅ | ✅ |
+| Instant undo/redo of AI edits (no git required) | ✅ per-file snapshots | ❌ | ❌ | ❌ |
 | License | MIT | MIT | proprietary | proprietary |
 
 Vexi **complements** tools like Claude Code instead of competing: its project memory and multilingual explanations will be exposed over MCP so any agent can use them.
@@ -292,6 +397,7 @@ src/
 ├── graph/          dependency graph + interactive d3 visualization
 ├── mcp/            MCP client (tools in chat) + server mode
 ├── learn/          Vexi Learn — style mining from your own sessions
+├── snapshots/      undo/redo engine — per-file backups before AI edits
 ├── i18n/           5-language UI strings + RTL strategy
 ├── ui/             terminal branding (chalk, ora)
 └── utils/          atomic JSON writes, cross-platform open

package/dist/agent.js

@@ -21,7 +21,8 @@ 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, 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';
@@ -29,6 +30,7 @@ import { SessionRecorder } from './replay/recorder.js';
 import { McpManager, parseToolCall } from './mcp/client.js';
 import { loadMcpConfig } from './mcp/config.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) {
@@ -116,7 +118,7 @@ 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();
     // ── Full project understanding: scan + load memory + load skills ──────
     const scanSpinner = ora({ text: dim(s.scanning), spinner: 'dots' }).start();
@@ -143,10 +145,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 +161,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,6 +171,16 @@ 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 = [];
@@ -186,14 +203,18 @@ 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;
         });
@@ -245,7 +266,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 +274,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;
@@ -288,6 +359,11 @@ export async function runAgent(opts) {
                         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();
@@ -338,7 +414,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 {

package/dist/cli.js

@@ -17,7 +17,9 @@
  *   vexi learn [--apply]       learn your coding style from past sessions
  */
 import { Command } from 'commander';
+import { VERSION } from './version.js';
 import ora from 'ora';
+import { checkForUpdate, runUpdate, runUninstall } from './update/index.js';
 import { runAgent } from './agent.js';
 import { loadConfig, resetConfig, CONFIG_PATH } from './config.js';
 import { loadSkills, addSkill, removeSkill } from './skills/index.js';
@@ -28,11 +30,13 @@ import { buildGraph } from './graph/index.js';
 import { exportGraphHtml } from './graph/html.js';
 import { loadMcpConfig, saveMcpConfig, MCP_CONFIG_PATH } from './mcp/config.js';
 import { learn, applyLearned, DEFAULT_MAX_SESSIONS } from './learn/index.js';
-import { createProvider, PROVIDER_INFO } from './providers/index.js';
+import { createProviderFromConfig, PROVIDER_INFO } from './providers/index.js';
+import { runOnboarding } from './onboarding.js';
+import * as nodeRlPromises from 'node:readline/promises';
 import { openInDefaultApp } from './utils/open.js';
+import { SnapshotManager } from './snapshots/index.js';
 import { detectSystemLang, getStrings, normalizeLang, t, SUPPORTED_LANGS } from './i18n/index.js';
 import { accent, dim, err, ok } from './ui/index.js';
-export const VERSION = '0.5.5';
 /** Resolve the active language: --lang flag > saved config > system locale. */
 async function resolveLang(flag) {
     if (flag) {
@@ -54,15 +58,18 @@ export function buildCli() {
         .version(VERSION, '-v, --version')
         .option('-l, --lang <lang>', `UI language (${SUPPORTED_LANGS.join('/')})`)
         .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) => {
         if (options.mcpServer) {
-            // stdout becomes the JSON-RPC channel — no banner, no prompts.
+            // stdout becomes the JSON-RPC channel -- no banner, no prompts.
             const { runMcpServer } = await import('./mcp/server.js');
             await runMcpServer();
             return;
         }
         const lang = await resolveLang(options.lang);
-        await runAgent({ lang, version: VERSION });
+        const noUpdateCheck = !options.updateCheck || !!process.env['VEXI_NO_UPDATE_CHECK'];
+        const updateCheckPromise = noUpdateCheck ? Promise.resolve(null) : checkForUpdate();
+        await runAgent({ lang, version: VERSION, updateCheckPromise });
     });
     const config = program.command('config').description('Manage Vexi configuration');
     config
@@ -72,12 +79,16 @@ export function buildCli() {
         const cfg = await loadConfig();
         console.log(dim('config: ') + accent(CONFIG_PATH));
         if (cfg) {
-            console.log(dim('provider: ') + accent(PROVIDER_INFO[cfg.provider].label));
-            console.log(dim('model: ') + accent(cfg.model ?? PROVIDER_INFO[cfg.provider].defaultModel));
+            const providerLabel = cfg.displayName ?? PROVIDER_INFO[cfg.provider]?.label ?? cfg.provider;
+            console.log(dim('provider: ') + accent(providerLabel));
+            const defaultModel = PROVIDER_INFO[cfg.provider]?.defaultModel ?? 'unknown';
+            console.log(dim('model: ') + accent(cfg.model ?? defaultModel));
+            if (cfg.baseUrl)
+                console.log(dim('baseUrl: ') + accent(cfg.baseUrl));
             console.log(dim('lang: ') + accent(cfg.lang ?? 'auto'));
         }
         else {
-            console.log(dim('No configuration yet — run `vexi` to set up.'));
+            console.log(dim('No configuration yet — run `vexi` or `vexi setup` to configure.'));
         }
     });
     config
@@ -184,7 +195,7 @@ export function buildCli() {
             process.exitCode = 1;
             return;
         }
-        const provider = createProvider(cfg.provider, cfg.apiKey, cfg.model);
+        const provider = createProviderFromConfig(cfg);
         const spinner = ora({ text: dim(s.explaining), spinner: 'dots' }).start();
         let started = false;
         try {
@@ -296,7 +307,7 @@ export function buildCli() {
             process.exitCode = 1;
             return;
         }
-        const provider = createProvider(cfg.provider, cfg.apiKey, cfg.model);
+        const provider = createProviderFromConfig(cfg);
         const maxSessions = Math.max(1, parseInt(options.sessions ?? '', 10) || DEFAULT_MAX_SESSIONS);
         const spinner = ora({ text: dim(s.learnAnalyzing), spinner: 'dots' }).start();
         try {
@@ -329,5 +340,115 @@ export function buildCli() {
             process.exitCode = 1;
         }
     });
+    // ── Undo / Redo / History / Clean (Feature 8) ────────────────────────
+    program
+        .command('undo')
+        .description('Revert the last AI file edit in the current session')
+        .action(async () => {
+        const s = getStrings(await resolveLang());
+        const mgr = await SnapshotManager.forCurrentSession(process.cwd());
+        if (!mgr) {
+            console.log(dim(s.snapshotNoSession));
+            return;
+        }
+        const entry = await mgr.undo().catch(() => null);
+        if (!entry) {
+            console.log(dim(s.undoNone));
+        }
+        else {
+            console.log(ok(t(s.undoDone, { files: entry.files.join(', ') })));
+        }
+    });
+    program
+        .command('redo')
+        .description('Re-apply the last undone AI file edit')
+        .action(async () => {
+        const s = getStrings(await resolveLang());
+        const mgr = await SnapshotManager.forCurrentSession(process.cwd());
+        if (!mgr) {
+            console.log(dim(s.snapshotNoSession));
+            return;
+        }
+        const entry = await mgr.redo().catch(() => null);
+        if (!entry) {
+            console.log(dim(s.redoNone));
+        }
+        else {
+            console.log(ok(t(s.redoDone, { files: entry.files.join(', ') })));
+        }
+    });
+    program
+        .command('history')
+        .description('List recent AI file edits in this session (with timestamps)')
+        .action(async () => {
+        const s = getStrings(await resolveLang());
+        const mgr = await SnapshotManager.forCurrentSession(process.cwd());
+        if (!mgr) {
+            console.log(dim(s.snapshotNoSession));
+            return;
+        }
+        const entries = await mgr.list().catch(() => []);
+        if (entries.length === 0) {
+            console.log(dim(s.historyNone));
+            return;
+        }
+        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)}`));
+        }
+    });
+    program
+        .command('clean')
+        .description('Clear old snapshot sessions to free disk space (.vexi/snapshots/)')
+        .action(async () => {
+        const s = getStrings(await resolveLang());
+        const mgr = await SnapshotManager.forCurrentSession(process.cwd());
+        const count = await SnapshotManager.cleanAll(process.cwd(), mgr?.sessionId);
+        console.log(ok(t(s.cleanDone, { count: String(count) })));
+    });
+    // ── URL-based provider setup (vexi setup) ────────────────────────────
+    program
+        .command('setup')
+        .description('Configure your API provider by pasting an endpoint URL')
+        .action(async () => {
+        const io = {
+            prompt: async (question) => {
+                const iface = nodeRlPromises.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                try {
+                    return await iface.question(question);
+                }
+                finally {
+                    iface.close();
+                }
+            },
+            write: (line) => console.log(line),
+        };
+        try {
+            await runOnboarding(io);
+        }
+        catch (e) {
+            console.error(err(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    // ── Self-update (vexi update) ─────────────────────────────────────────
+    program
+        .command('update')
+        .description('Update Vexi to the latest version (npm install -g vexi-cli@latest)')
+        .action(async () => {
+        await runUpdate();
+    });
+    // ── Self-uninstall (vexi uninstall) ──────────────────────────────────
+    program
+        .command('uninstall')
+        .description('Uninstall Vexi. Keeps ~/.vexi unless --purge is passed.')
+        .option('--purge', 'also delete ~/.vexi (config, keys, memory, sessions)')
+        .action(async (options) => {
+        await runUninstall(!!options.purge);
+    });
     return program;
 }

package/dist/config.js

@@ -10,15 +10,29 @@
 import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { z } from 'zod';
 import { readJson, writeJsonAtomic } from './utils/fs-atomic.js';
+const VexiConfigSchema = z.object({
+    provider: z.string().min(1),
+    displayName: z.string().optional(),
+    apiKey: z.string().min(1),
+    baseUrl: z.string().optional(),
+    model: z.string().optional(),
+    lang: z.string().optional(),
+});
 export const VEXI_DIR = join(homedir(), '.vexi');
 export const CONFIG_PATH = join(VEXI_DIR, 'config.json');
-/** Load the config, or `null` if it doesn't exist / is unreadable. */
+/** Load the config, or `null` if it doesn't exist / is unreadable / fails validation. */
 export async function loadConfig() {
-    const config = await readJson(CONFIG_PATH);
-    if (!config?.apiKey || !config.provider)
+    const raw = await readJson(CONFIG_PATH);
+    if (!raw)
         return null;
-    return config;
+    const result = VexiConfigSchema.safeParse(raw);
+    if (!result.success) {
+        process.stderr.write(`[vexi] config validation failed: ${result.error.message}\n`);
+        return null;
+    }
+    return result.data;
 }
 /** Save the config atomically with owner-only permissions. */
 export async function saveConfig(config) {