vexi-cli 0.5.4 → 0.8.0

package/dist/providers/types.js

@@ -16,9 +16,18 @@ export class ProviderError extends Error {
 }
 /** Human-friendly provider metadata. */
 export const PROVIDER_INFO = {
+    // ── International providers ───────────────────────────────────────────
     anthropic: { label: 'Anthropic (Claude)', defaultModel: 'claude-sonnet-4-5' },
     openai: { label: 'OpenAI (GPT)', defaultModel: 'gpt-4o-mini' },
     openrouter: { label: 'OpenRouter', defaultModel: 'openrouter/auto' },
-    groq: { label: 'Groq', defaultModel: 'llama-3.3-70b-versatile' },
-    gemini: { label: 'Google Gemini', defaultModel: 'gemini-2.5-flash' },
+    groq: { label: 'Groq (free tier)', defaultModel: 'llama-3.3-70b-versatile', free: true },
+    gemini: { label: 'Google Gemini (free tier)', defaultModel: 'gemini-2.5-flash', free: true },
+    mistral: { label: 'Mistral AI', defaultModel: 'mistral-small-latest' },
+    cerebras: { label: 'Cerebras (free tier)', defaultModel: 'llama-3.3-70b', free: true },
+    // ── Chinese AI providers ──────────────────────────────────────────────
+    glm: { label: 'Zhipu AI — GLM (free tier)', defaultModel: 'glm-4-flash', free: true },
+    deepseek: { label: 'DeepSeek (free tier)', defaultModel: 'deepseek-chat', free: true },
+    qwen: { label: 'Alibaba Qwen (free tier)', defaultModel: 'qwen-turbo', free: true },
+    moonshot: { label: 'Kimi — Moonshot AI (free tier)', defaultModel: 'moonshot-v1-8k', free: true },
+    minimax: { label: 'MiniMax (free tier)', defaultModel: 'MiniMax-Text-01', free: true },
 };

package/dist/snapshots/index.js

@@ -0,0 +1,261 @@
+/**
+ * Snapshot engine for undo/redo of AI file edits.
+ *
+ * Before executing any shell command that looks like a file write, Vexi
+ * saves a copy of only the affected files into:
+ *
+ *   .vexi/snapshots/<session-id>/<entry-id>/files/<encoded-path>
+ *
+ * State (undo/redo stacks) is persisted in:
+ *   .vexi/snapshots/<session-id>/state.json
+ *
+ * The active session is tracked in:
+ *   .vexi/snapshots/current-session
+ *
+ * Design choices:
+ * - Only snapshots files it is about to change (NOT the whole project tree).
+ * - Max 50 snapshots per session; oldest pruned automatically.
+ * - Undo restores the pre-command file state; redo re-applies the reverted state.
+ * - New files created by a command are not deleted on undo (limitation v1).
+ */
+import { promises as fs } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { join, isAbsolute, relative, dirname } from 'node:path';
+import { writeJsonAtomic, readJson } from '../utils/fs-atomic.js';
+const MAX_SNAPSHOTS = 50;
+function makeId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+}
+function encodeRelPath(relPath) {
+    return relPath.replace(/[\\/]/g, '__').replace(/:/g, '_C_');
+}
+export class SnapshotManager {
+    root;
+    sessionId;
+    sessionDir;
+    statePath;
+    _state = null;
+    constructor(root, sessionId) {
+        this.root = root;
+        this.sessionId = sessionId;
+        this.sessionDir = join(root, '.vexi', 'snapshots', sessionId);
+        this.statePath = join(this.sessionDir, 'state.json');
+    }
+    /** Create a manager pointing at the most-recently registered session. */
+    static async forCurrentSession(root) {
+        const markerPath = join(root, '.vexi', 'snapshots', 'current-session');
+        try {
+            const id = (await fs.readFile(markerPath, 'utf-8')).trim();
+            if (id)
+                return new SnapshotManager(root, id);
+        }
+        catch { }
+        return null;
+    }
+    /** Write the "current-session" marker so CLI commands can find this session. */
+    async registerAsCurrentSession() {
+        const markerPath = join(this.root, '.vexi', 'snapshots', 'current-session');
+        await fs.mkdir(dirname(markerPath), { recursive: true });
+        await fs.writeFile(markerPath, this.sessionId, 'utf-8');
+    }
+    async getState() {
+        if (this._state)
+            return this._state;
+        const loaded = await readJson(this.statePath);
+        this._state = loaded ?? {
+            sessionId: this.sessionId,
+            undoStack: [],
+            redoStack: [],
+            entries: {},
+        };
+        return this._state;
+    }
+    async persistState() {
+        if (this._state)
+            await writeJsonAtomic(this.statePath, this._state);
+    }
+    async saveFiles(id, relPaths) {
+        const dir = join(this.sessionDir, id, 'files');
+        await fs.mkdir(dir, { recursive: true });
+        const saved = [];
+        for (const rel of relPaths) {
+            const abs = isAbsolute(rel) ? rel : join(this.root, rel);
+            if (!existsSync(abs))
+                continue;
+            await fs.copyFile(abs, join(dir, encodeRelPath(rel)));
+            saved.push(rel);
+        }
+        return saved;
+    }
+    async restoreFiles(id, relPaths) {
+        const dir = join(this.sessionDir, id, 'files');
+        for (const rel of relPaths) {
+            const dest = isAbsolute(rel) ? rel : join(this.root, rel);
+            try {
+                await fs.copyFile(join(dir, encodeRelPath(rel)), dest);
+            }
+            catch { }
+        }
+    }
+    async deleteEntry(state, id) {
+        delete state.entries[id];
+        await fs.rm(join(this.sessionDir, id), { recursive: true, force: true }).catch(() => { });
+    }
+    /**
+     * Save the current state of `files` before applying an edit.
+     * Call this right before running the shell command.
+     * Returns true if at least one file was snapshotted.
+     */
+    async takeSnapshot(files, label) {
+        if (files.length === 0)
+            return false;
+        const state = await this.getState();
+        const id = makeId();
+        const saved = await this.saveFiles(id, files);
+        if (saved.length === 0)
+            return false;
+        state.entries[id] = { id, at: Date.now(), label, files: saved };
+        state.undoStack.push(id);
+        state.redoStack = []; // new edit invalidates redo history
+        while (state.undoStack.length > MAX_SNAPSHOTS) {
+            await this.deleteEntry(state, state.undoStack.shift());
+        }
+        await this.persistState();
+        return true;
+    }
+    /** Restore the last snapshotted file state. Returns the reverted entry, or null if nothing to undo. */
+    async undo() {
+        const state = await this.getState();
+        if (state.undoStack.length === 0)
+            return null;
+        const id = state.undoStack[state.undoStack.length - 1];
+        const entry = state.entries[id];
+        if (!entry)
+            return null;
+        // Save current (post-edit) state as a redo point covering the same files
+        const redoId = makeId();
+        const redoSaved = await this.saveFiles(redoId, entry.files);
+        if (redoSaved.length > 0) {
+            state.entries[redoId] = { id: redoId, at: Date.now(), label: entry.label, files: redoSaved };
+            state.redoStack.push(redoId);
+        }
+        await this.restoreFiles(id, entry.files);
+        state.undoStack.pop();
+        await this.deleteEntry(state, id);
+        await this.persistState();
+        return entry;
+    }
+    /** Re-apply the last undone change. Returns the re-applied entry, or null if nothing to redo. */
+    async redo() {
+        const state = await this.getState();
+        if (state.redoStack.length === 0)
+            return null;
+        const id = state.redoStack[state.redoStack.length - 1];
+        const entry = state.entries[id];
+        if (!entry)
+            return null;
+        // Save current (post-undo) state back onto the undo stack
+        const undoId = makeId();
+        const undoSaved = await this.saveFiles(undoId, entry.files);
+        if (undoSaved.length > 0) {
+            state.entries[undoId] = { id: undoId, at: Date.now(), label: entry.label, files: undoSaved };
+            state.undoStack.push(undoId);
+        }
+        await this.restoreFiles(id, entry.files);
+        state.redoStack.pop();
+        await this.deleteEntry(state, id);
+        await this.persistState();
+        return entry;
+    }
+    /** List all available undo entries, newest first. */
+    async list() {
+        const state = await this.getState();
+        return [...state.undoStack]
+            .reverse()
+            .map((id) => state.entries[id])
+            .filter(Boolean);
+    }
+    /** Remove all snapshot sessions except this one (and the current-session marker). */
+    async clean() {
+        return SnapshotManager.cleanAll(this.root, this.sessionId);
+    }
+    /** Remove all snapshot session directories, optionally keeping one by ID. */
+    static async cleanAll(root, keepSessionId) {
+        const snapshotsDir = join(root, '.vexi', 'snapshots');
+        let count = 0;
+        try {
+            const entries = await fs.readdir(snapshotsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (keepSessionId && entry.name === keepSessionId)
+                    continue;
+                try {
+                    await fs.rm(join(snapshotsDir, entry.name), { recursive: true, force: true });
+                    count++;
+                }
+                catch { }
+            }
+        }
+        catch { }
+        return count;
+    }
+    /**
+     * Extract file paths that a shell command is likely to write.
+     * Returns relative paths (relative to cwd) for files that currently exist on disk.
+     * This is best-effort: covers common patterns (cat >, sed -i, mv, cp, tee, etc.)
+     * and files with known extensions that appear as bare tokens in the command.
+     */
+    static extractFilePaths(command, cwd) {
+        const found = new Set();
+        const tryAdd = (raw) => {
+            if (!raw)
+                return;
+            const p = raw.trim().replace(/^["']|["']$/g, '');
+            if (!p || p.startsWith('-') || p.startsWith('http') || p === '/dev/null')
+                return;
+            const abs = isAbsolute(p) ? p : join(cwd, p);
+            if (existsSync(abs)) {
+                found.add(relative(cwd, abs).replace(/\\/g, '/'));
+            }
+        };
+        // cat > file  /  cat >> file
+        for (const m of command.matchAll(/\bcat\s+>>?\s+(\S+)/gi))
+            tryAdd(m[1]);
+        // echo ... > file  /  >> file
+        for (const m of command.matchAll(/\becho\b.*?>>?\s+(\S+)/gi))
+            tryAdd(m[1]);
+        // sed -i[suffix] 'expr' file
+        for (const m of command.matchAll(/\bsed\b.*?-i\S*\s+(?:'[^']*'|"[^"]*"|\S+)\s+(\S+)/gi))
+            tryAdd(m[1]);
+        // patch [options] file
+        for (const m of command.matchAll(/\bpatch\b(?:\s+-[a-zA-Z0-9]+)*\s+(\S+)/gi))
+            tryAdd(m[1]);
+        // tee file
+        for (const m of command.matchAll(/\btee\s+(\S+)/gi))
+            tryAdd(m[1]);
+        // cp src dst
+        for (const m of command.matchAll(/\bcp\b(?:\s+-[a-zA-Z]+)*\s+(\S+)\s+(\S+)/gi)) {
+            tryAdd(m[1]);
+            tryAdd(m[2]);
+        }
+        // mv src dst
+        for (const m of command.matchAll(/\bmv\b(?:\s+-[a-zA-Z]+)*\s+(\S+)\s+(\S+)/gi)) {
+            tryAdd(m[1]);
+            tryAdd(m[2]);
+        }
+        // node/deno: fs.writeFileSync('file', ...)
+        for (const m of command.matchAll(/writeFileSync\s*\(\s*["']([^"']+)["']/gi))
+            tryAdd(m[1]);
+        // python: open('file', 'w') or open('file', 'a')
+        for (const m of command.matchAll(/\bopen\s*\(\s*["']([^"']+)["']\s*,\s*["'][wa]/gi))
+            tryAdd(m[1]);
+        // PowerShell: Set-Content / Out-File / Add-Content
+        for (const m of command.matchAll(/\b(?:Set-Content|Out-File|Add-Content)\b.*?-(?:Path|Value|FilePath)\s+["']?(\S+?)["']?(?:\s|$)/gi))
+            tryAdd(m[1]);
+        // Generic: bare token with a known source-file extension
+        for (const m of command.matchAll(/(?:^|[\s;|&>])["']?([\w./\\-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|py|rs|go|java|c|cpp|h|hpp|css|scss|html|yaml|yml|toml|sh|env|txt|xml|sql|graphql|vue|svelte|rb|php|swift|kt|cs))["']?(?=\s|$|[;|&])/gim))
+            tryAdd(m[1]);
+        return [...found];
+    }
+}

package/dist/snapshots/index.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { SnapshotManager } from './index.js';
+async function mkTmp() {
+    return fs.mkdtemp(join(tmpdir(), 'vexi-snap-test-'));
+}
+async function writeFile(dir, name, content) {
+    const p = join(dir, name);
+    await fs.writeFile(p, content, 'utf8');
+    return p;
+}
+describe('SnapshotManager', () => {
+    let root;
+    let manager;
+    beforeEach(async () => {
+        root = await mkTmp();
+        manager = new SnapshotManager(root, 'test-session');
+    });
+    afterEach(async () => {
+        await fs.rm(root, { recursive: true, force: true });
+    });
+    it('round-trip: takeSnapshot → undo restores file content', async () => {
+        const filePath = await writeFile(root, 'hello.txt', 'original');
+        const snapped = await manager.takeSnapshot([filePath], 'initial write');
+        expect(snapped).toBe(true);
+        await fs.writeFile(filePath, 'modified', 'utf8');
+        const entry = await manager.undo();
+        expect(entry).not.toBeNull();
+        expect(entry.files.some((f) => f.endsWith('hello.txt') || f === filePath)).toBe(true);
+        const restored = await fs.readFile(filePath, 'utf8');
+        expect(restored).toBe('original');
+    });
+    it('round-trip: undo → redo restores modified content', async () => {
+        const filePath = await writeFile(root, 'hello.txt', 'original');
+        await manager.takeSnapshot([filePath], 'initial write');
+        await fs.writeFile(filePath, 'modified', 'utf8');
+        await manager.undo();
+        const afterUndo = await fs.readFile(filePath, 'utf8');
+        expect(afterUndo).toBe('original');
+        const redoEntry = await manager.redo();
+        expect(redoEntry).not.toBeNull();
+        const afterRedo = await fs.readFile(filePath, 'utf8');
+        expect(afterRedo).toBe('modified');
+    });
+    it('list() returns newest snapshot first', async () => {
+        const filePath = await writeFile(root, 'a.txt', 'v1');
+        await manager.takeSnapshot([filePath], 'first');
+        await fs.writeFile(filePath, 'v2', 'utf8');
+        await manager.takeSnapshot([filePath], 'second');
+        const list = await manager.list();
+        expect(list.length).toBe(2);
+        expect(list[0].label).toBe('second');
+        expect(list[1].label).toBe('first');
+    });
+    it('undo() returns null when stack is empty', async () => {
+        const result = await manager.undo();
+        expect(result).toBeNull();
+    });
+    it('redo() returns null when stack is empty', async () => {
+        const result = await manager.redo();
+        expect(result).toBeNull();
+    });
+    it('takeSnapshot clears redo stack', async () => {
+        const filePath = await writeFile(root, 'b.txt', 'v1');
+        await manager.takeSnapshot([filePath], 'snap1');
+        await fs.writeFile(filePath, 'v2', 'utf8');
+        await manager.undo();
+        // new snapshot after undo — redo stack should be cleared
+        await manager.takeSnapshot([filePath], 'snap2');
+        const redo = await manager.redo();
+        expect(redo).toBeNull();
+    });
+    it('takeSnapshot returns false when no files exist', async () => {
+        const result = await manager.takeSnapshot([join(root, 'ghost.txt')], 'missing');
+        expect(result).toBe(false);
+    });
+});
+describe('SnapshotManager.extractFilePaths', () => {
+    let cwd;
+    beforeEach(async () => {
+        cwd = await fs.mkdtemp(join(tmpdir(), 'vexi-ext-test-'));
+        // create the files so existsSync passes
+        await fs.mkdir(join(cwd, 'src'), { recursive: true });
+        await fs.writeFile(join(cwd, 'src', 'app.ts'), '', 'utf8');
+        await fs.writeFile(join(cwd, 'src', 'utils.js'), '', 'utf8');
+    });
+    afterEach(async () => {
+        await fs.rm(cwd, { recursive: true, force: true });
+    });
+    it('extracts path from cat > redirect', () => {
+        const paths = SnapshotManager.extractFilePaths('cat > src/app.ts', cwd);
+        expect(paths.length).toBeGreaterThan(0);
+        expect(paths.some((p) => p.endsWith('app.ts'))).toBe(true);
+    });
+    it('extracts path from sed -i command', () => {
+        const paths = SnapshotManager.extractFilePaths("sed -i 's/foo/bar/' src/utils.js", cwd);
+        expect(paths.some((p) => p.endsWith('utils.js'))).toBe(true);
+    });
+    it('returns empty array for non-file commands', () => {
+        const paths = SnapshotManager.extractFilePaths('npm install', cwd);
+        expect(paths).toEqual([]);
+    });
+});

package/dist/update/index.js

@@ -0,0 +1,190 @@
+/**
+ * Update management: check, install, and uninstall.
+ *
+ * checkForUpdate - non-blocking; returns cached result fast, fires network
+ *   check in the background and caches it for the next run.
+ * runUpdate      - npm install -g vexi-cli@latest with streamed output.
+ * runUninstall   - npm uninstall -g vexi-cli with optional ~/.vexi purge.
+ */
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { confirm } from '@inquirer/prompts';
+import { VEXI_DIR } from '../config.js';
+import { VERSION } from '../version.js';
+import { dim, err, ok, warn, accent } from '../ui/index.js';
+const UPDATE_CACHE_PATH = join(VEXI_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 1500;
+const NPM_REGISTRY = 'https://registry.npmjs.org/vexi-cli/latest';
+/** Returns true if version string `a` is strictly greater than `b`. */
+function semverGt(a, b) {
+    const parts = (v) => v.replace(/[^0-9.]/g, '').split('.').map((n) => parseInt(n, 10) || 0);
+    const [aMaj = 0, aMin = 0, aPat = 0] = parts(a);
+    const [bMaj = 0, bMin = 0, bPat = 0] = parts(b);
+    if (aMaj !== bMaj)
+        return aMaj > bMaj;
+    if (aMin !== bMin)
+        return aMin > bMin;
+    return aPat > bPat;
+}
+/**
+ * Check whether a newer version of vexi-cli is published on npm.
+ *
+ * - Returns the newer version string, or null (no update / check failed).
+ * - Reads a local cache first; only hits the network when the cache is
+ *   older than 24 hours.
+ * - When the cache is stale, fires a background fetch (max 1500 ms) and
+ *   updates the cache when done. Returns null for this run so startup is
+ *   never blocked by the network.
+ * - All errors are swallowed silently.
+ */
+export async function checkForUpdate() {
+    try {
+        const cacheRaw = await fs.readFile(UPDATE_CACHE_PATH, 'utf8').catch(() => null);
+        if (cacheRaw) {
+            const cache = JSON.parse(cacheRaw);
+            const age = Date.now() - new Date(cache.lastCheck).getTime();
+            if (age < CHECK_INTERVAL_MS) {
+                // Cache is fresh: return immediately
+                return semverGt(cache.latest, VERSION) ? cache.latest : null;
+            }
+        }
+        // Cache is stale or missing: fire a background fetch and return null now
+        void (async () => {
+            try {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+                const res = await fetch(NPM_REGISTRY, { signal: controller.signal });
+                clearTimeout(timer);
+                if (!res.ok)
+                    return;
+                const json = (await res.json());
+                const latest = json.version;
+                if (!latest)
+                    return;
+                await fs.mkdir(VEXI_DIR, { recursive: true }).catch(() => { });
+                await fs.writeFile(UPDATE_CACHE_PATH, JSON.stringify({ lastCheck: new Date().toISOString(), latest }), 'utf8').catch(() => { });
+            }
+            catch {
+                // network error or timeout -- silently ignored
+            }
+        })();
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Spawn npm with inherited stdio and return whether it exited successfully. */
+async function runNpm(args) {
+    return new Promise((resolve) => {
+        const cmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const child = spawn(cmd, args, { stdio: 'inherit' });
+        child.on('error', (e) => {
+            if (e.code === 'ENOENT') {
+                console.error(err('\nnpm not found. Install Node.js (which includes npm) from https://nodejs.org'));
+            }
+            else {
+                console.error(err(`\nFailed to run npm: ${e.message}`));
+            }
+            resolve(false);
+        });
+        child.on('close', (code) => resolve(code === 0));
+    });
+}
+/**
+ * Run `npm install -g vexi-cli@latest`, streaming npm output to the terminal.
+ * Prints the manual command and exits non-zero on any failure.
+ */
+export async function runUpdate() {
+    console.log(dim('Running: npm install -g vexi-cli@latest\n'));
+    const ok_ = await runNpm(['install', '-g', 'vexi-cli@latest']);
+    if (ok_) {
+        console.log('\n' + ok('Vexi updated successfully.'));
+        console.log(dim('Restart your terminal or run `vexi --version` to confirm.'));
+    }
+    else {
+        console.log('\n' + warn('If the error above is a permissions problem, try one of:'));
+        console.log(dim('  sudo npm install -g vexi-cli@latest'));
+        console.log(dim('  # Windows: run your terminal as Administrator'));
+        console.log(dim('  # or use a Node version manager (nvm, fnm, volta)'));
+        console.log(dim('\nManual command:  npm install -g vexi-cli@latest'));
+        process.exitCode = 1;
+    }
+}
+/**
+ * Uninstall vexi-cli.
+ *
+ * 1. Describes what will happen and asks for confirmation.
+ * 2. Runs `npm uninstall -g vexi-cli`, streaming output.
+ * 3. If --purge: asks for a SECOND confirmation, then deletes ~/.vexi.
+ *
+ * Always prints the manual command, because on some platforms (Windows,
+ * certain npm prefixes) a running binary cannot delete itself in-process.
+ */
+export async function runUninstall(purge) {
+    // Step 1: Describe what will happen
+    console.log();
+    console.log(accent('What will happen:'));
+    console.log(dim('  - Remove:  vexi-cli global npm package'));
+    if (purge) {
+        console.log(warn(`  - Delete:  ${VEXI_DIR}`));
+        console.log(warn('             (config, API keys, memory, snapshots -- permanent!)'));
+    }
+    else {
+        console.log(dim(`  - Keep:    ${VEXI_DIR} (your config, keys, and memory are preserved)`));
+        console.log(dim('             Use --purge to also delete this directory.'));
+    }
+    console.log();
+    // Step 2: First confirmation
+    const proceed = await confirm({ message: 'Remove vexi-cli?', default: false }).catch(() => false);
+    if (!proceed) {
+        console.log(dim('\nCancelled. Nothing was changed.'));
+        return;
+    }
+    console.log(dim('\nRunning: npm uninstall -g vexi-cli\n'));
+    const uninstallOk = await runNpm(['uninstall', '-g', 'vexi-cli']);
+    if (!uninstallOk) {
+        console.log('\n' + warn('Uninstall may have failed. Run this manually if needed:'));
+        console.log(dim('  npm uninstall -g vexi-cli'));
+        if (purge) {
+            console.log(dim('  rm -rf ~/.vexi                               # macOS / Linux'));
+            console.log(dim('  rmdir /s /q %USERPROFILE%\\.vexi             # Windows'));
+        }
+        process.exitCode = 1;
+        return;
+    }
+    console.log('\n' + ok('vexi-cli uninstalled.'));
+    console.log(dim('Manual command for reference:  npm uninstall -g vexi-cli'));
+    console.log(dim('To reinstall:                  npm install -g vexi-cli'));
+    // Step 3: Purge ~/.vexi if requested
+    if (purge) {
+        console.log();
+        console.log(warn(`About to permanently delete ${VEXI_DIR}`));
+        console.log(warn('This removes config, API keys, memory, and sessions. This cannot be undone.'));
+        console.log();
+        const confirmPurge = await confirm({
+            message: `Delete ${VEXI_DIR} permanently?`,
+            default: false,
+        }).catch(() => false);
+        if (!confirmPurge) {
+            console.log(dim(`\n${VEXI_DIR} was not deleted.`));
+            console.log(dim(`To remove it manually:`));
+            console.log(dim(`  rm -rf ~/.vexi                               # macOS / Linux`));
+            console.log(dim(`  rmdir /s /q %USERPROFILE%\\.vexi             # Windows`));
+            return;
+        }
+        try {
+            await fs.rm(VEXI_DIR, { recursive: true, force: true });
+            console.log(ok(`Deleted ${VEXI_DIR}`));
+        }
+        catch (e) {
+            console.error(err(`Could not delete ${VEXI_DIR}: ${e instanceof Error ? e.message : String(e)}`));
+            console.log(dim('Remove it manually:'));
+            console.log(dim(`  rm -rf ~/.vexi                               # macOS / Linux`));
+            console.log(dim(`  rmdir /s /q %USERPROFILE%\\.vexi             # Windows`));
+            process.exitCode = 1;
+        }
+    }
+}

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+export const VERSION = pkg.version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vexi-cli",
-  "version": "0.5.4",
+  "version": "0.8.0",
   "description": "Open-source AI coding agent for your terminal. Bring your own key, zero config, multilingual.",
   "type": "module",
   "bin": {
@@ -19,6 +19,8 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
+    "test": "vitest run",
+    "lint": "eslint src",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -33,6 +35,9 @@
     "gemini",
     "groq",
     "openrouter",
+    "glm",
+    "mistral",
+    "cerebras",
     "multilingual"
   ],
   "author": "Elomami1976",
@@ -55,6 +60,10 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
-    "typescript": "^5.7.0"
+    "@typescript-eslint/eslint-plugin": "^8.61.1",
+    "@typescript-eslint/parser": "^8.61.1",
+    "eslint": "^9.39.4",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.9"
   }
 }