vexi-cli 0.5.5 → 0.9.0

package/dist/tools/index.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parseBuiltinToolCall, executeBuiltinTool, buildNativeTools, dispatchNativeTool } from './index.js';
+import { SnapshotManager } from '../snapshots/index.js';
+// A snapshot manager that writes into a throwaway session dir under root.
+function makeSnapshots(root) {
+    return new SnapshotManager(root, 'test-session');
+}
+let root;
+beforeEach(async () => {
+    root = await fs.mkdtemp(join(tmpdir(), 'vexi-tools-'));
+});
+afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+});
+// ── parseBuiltinToolCall ──────────────────────────────────────────────────────
+describe('parseBuiltinToolCall', () => {
+    it('parses a read_file call', () => {
+        const call = parseBuiltinToolCall('```vexi-tool\n{"tool": "read_file", "path": "a.ts"}\n```');
+        expect(call).toEqual({ tool: 'read_file', args: { path: 'a.ts' } });
+    });
+    it('ignores MCP calls (those have a server field)', () => {
+        const call = parseBuiltinToolCall('```vexi-tool\n{"server": "github", "tool": "read_file", "arguments": {}}\n```');
+        expect(call).toBeNull();
+    });
+    it('ignores unknown tool names', () => {
+        expect(parseBuiltinToolCall('```vexi-tool\n{"tool": "rm_rf", "path": "/"}\n```')).toBeNull();
+    });
+    it('returns null when no block present', () => {
+        expect(parseBuiltinToolCall('just some prose')).toBeNull();
+    });
+});
+// ── executeBuiltinTool ────────────────────────────────────────────────────────
+describe('executeBuiltinTool: write_file', () => {
+    it('creates a new file', async () => {
+        const r = await executeBuiltinTool({ tool: 'write_file', args: { path: 'x.txt', content: 'hello\nworld' } }, root, makeSnapshots(root));
+        expect(r.result).toContain('created x.txt');
+        expect(await fs.readFile(join(root, 'x.txt'), 'utf-8')).toBe('hello\nworld');
+    });
+    it('rejects paths outside the project root', async () => {
+        const r = await executeBuiltinTool({ tool: 'write_file', args: { path: '../escape.txt', content: 'x' } }, root, makeSnapshots(root));
+        expect(r.result).toContain('outside the project root');
+        expect(r.files).toEqual([]);
+    });
+});
+describe('executeBuiltinTool: edit_file', () => {
+    it('replaces a unique substring', async () => {
+        await fs.writeFile(join(root, 'a.ts'), 'const x = 1;\nconst y = 2;\n');
+        const r = await executeBuiltinTool({ tool: 'edit_file', args: { path: 'a.ts', old: 'const y = 2;', new: 'const y = 3;' } }, root, makeSnapshots(root));
+        expect(r.result).toContain('edited a.ts');
+        expect(await fs.readFile(join(root, 'a.ts'), 'utf-8')).toBe('const x = 1;\nconst y = 3;\n');
+    });
+    it('errors when old string is not found', async () => {
+        await fs.writeFile(join(root, 'a.ts'), 'const x = 1;\n');
+        const r = await executeBuiltinTool({ tool: 'edit_file', args: { path: 'a.ts', old: 'nope', new: 'x' } }, root, makeSnapshots(root));
+        expect(r.result).toContain('not found');
+        expect(await fs.readFile(join(root, 'a.ts'), 'utf-8')).toBe('const x = 1;\n');
+    });
+    it('errors on a non-unique match unless all=true', async () => {
+        await fs.writeFile(join(root, 'a.ts'), 'a\na\na\n');
+        const ambiguous = await executeBuiltinTool({ tool: 'edit_file', args: { path: 'a.ts', old: 'a', new: 'b' } }, root, makeSnapshots(root));
+        expect(ambiguous.result).toContain('matches 3 places');
+        const all = await executeBuiltinTool({ tool: 'edit_file', args: { path: 'a.ts', old: 'a', new: 'b', all: true } }, root, makeSnapshots(root));
+        expect(all.result).toContain('3 replacements');
+        expect(await fs.readFile(join(root, 'a.ts'), 'utf-8')).toBe('b\nb\nb\n');
+    });
+    it('snapshots the pre-edit file so undo restores it exactly', async () => {
+        await fs.writeFile(join(root, 'a.ts'), 'original\n');
+        const snaps = makeSnapshots(root);
+        await executeBuiltinTool({ tool: 'edit_file', args: { path: 'a.ts', old: 'original', new: 'changed' } }, root, snaps);
+        expect(await fs.readFile(join(root, 'a.ts'), 'utf-8')).toBe('changed\n');
+        const entry = await snaps.undo();
+        expect(entry).not.toBeNull();
+        expect(await fs.readFile(join(root, 'a.ts'), 'utf-8')).toBe('original\n');
+    });
+});
+// ── native tool routing (Feature #2) ──────────────────────────────────────────
+describe('buildNativeTools', () => {
+    it('exposes the three built-in tools plus namespaced MCP tools', () => {
+        const mcp = { tools: [{ server: 'github', name: 'search', description: 'Search repos', inputSchema: { type: 'object' } }] };
+        const { defs, route } = buildNativeTools(mcp);
+        const names = defs.map((d) => d.name);
+        expect(names).toContain('read_file');
+        expect(names).toContain('write_file');
+        expect(names).toContain('edit_file');
+        expect(names).toContain('github__search');
+        expect(route.get('read_file')).toEqual({ kind: 'builtin' });
+        expect(route.get('github__search')).toEqual({ kind: 'mcp', server: 'github', tool: 'search' });
+    });
+});
+describe('dispatchNativeTool', () => {
+    it('routes built-in names to the file engine', async () => {
+        await fs.writeFile(join(root, 'a.ts'), 'x');
+        const mcp = { tools: [] };
+        const { route } = buildNativeTools(mcp);
+        const r = await dispatchNativeTool('read_file', { path: 'a.ts' }, route, root, makeSnapshots(root), mcp);
+        expect(r.result).toContain('FILE a.ts');
+    });
+    it('routes namespaced names to the MCP server', async () => {
+        let called = null;
+        const mcp = {
+            tools: [{ server: 'github', name: 'search', description: 'd', inputSchema: {} }],
+            callTool: async (server, tool) => { called = { server, tool }; return 'mcp-result'; },
+        };
+        const { route } = buildNativeTools(mcp);
+        const r = await dispatchNativeTool('github__search', { q: 'x' }, route, root, makeSnapshots(root), mcp);
+        expect(r.result).toBe('mcp-result');
+        expect(called).toEqual({ server: 'github', tool: 'search' });
+    });
+    it('errors on an unknown tool name', async () => {
+        const mcp = { tools: [] };
+        const { route } = buildNativeTools(mcp);
+        const r = await dispatchNativeTool('bogus', {}, route, root, makeSnapshots(root), mcp);
+        expect(r.result).toContain('unknown tool');
+    });
+});
+describe('executeBuiltinTool: read_file', () => {
+    it('returns numbered lines within a range', async () => {
+        await fs.writeFile(join(root, 'a.ts'), 'l1\nl2\nl3\nl4\n');
+        const r = await executeBuiltinTool({ tool: 'read_file', args: { path: 'a.ts', start: 2, end: 3 } }, root, makeSnapshots(root));
+        expect(r.result).toContain('2\tl2');
+        expect(r.result).toContain('3\tl3');
+        expect(r.result).not.toContain('l4');
+    });
+    it('errors on a missing file', async () => {
+        const r = await executeBuiltinTool({ tool: 'read_file', args: { path: 'nope.ts' } }, root, makeSnapshots(root));
+        expect(r.result).toContain('file not found');
+    });
+});

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/usage/index.js

@@ -0,0 +1,95 @@
+/**
+ * Token & cost tracking — Feature #3.
+ *
+ * Vexi is bring-your-own-key, so the user pays the provider directly. This
+ * module accumulates the token usage reported by the provider APIs over a
+ * session and estimates the dollar cost from a small built-in price table.
+ *
+ * Cost is best-effort: when a model isn't in the table (or a provider doesn't
+ * report usage) we still show token counts and simply omit the dollar figure.
+ */
+const PRICES = [
+    // ── Anthropic ──
+    { match: 'claude-opus', price: { in: 15, out: 75 } },
+    { match: 'claude-3-opus', price: { in: 15, out: 75 } },
+    { match: 'claude-sonnet', price: { in: 3, out: 15 } },
+    { match: 'claude-3-5-sonnet', price: { in: 3, out: 15 } },
+    { match: 'claude-3-7-sonnet', price: { in: 3, out: 15 } },
+    { match: 'claude-haiku', price: { in: 0.8, out: 4 } },
+    { match: 'claude-3-5-haiku', price: { in: 0.8, out: 4 } },
+    { match: 'claude-3-haiku', price: { in: 0.25, out: 1.25 } },
+    // ── OpenAI ──
+    { match: 'gpt-4o-mini', price: { in: 0.15, out: 0.6 } },
+    { match: 'gpt-4o', price: { in: 2.5, out: 10 } },
+    { match: 'gpt-4.1-mini', price: { in: 0.4, out: 1.6 } },
+    { match: 'gpt-4.1-nano', price: { in: 0.1, out: 0.4 } },
+    { match: 'gpt-4.1', price: { in: 2, out: 8 } },
+    { match: 'o4-mini', price: { in: 1.1, out: 4.4 } },
+    { match: 'o3-mini', price: { in: 1.1, out: 4.4 } },
+    // ── DeepSeek ──
+    { match: 'deepseek-chat', price: { in: 0.27, out: 1.1 } },
+    { match: 'deepseek-reasoner', price: { in: 0.55, out: 2.19 } },
+    // ── Mistral ──
+    { match: 'mistral-small', price: { in: 0.2, out: 0.6 } },
+    { match: 'mistral-large', price: { in: 2, out: 6 } },
+    // ── Known free tiers (default models) — explicitly zero-cost ──
+    { match: 'llama-3.3-70b', price: { in: 0, out: 0 } },
+    { match: 'gemini-2.5-flash', price: { in: 0, out: 0 } },
+    { match: 'gemini-1.5-flash', price: { in: 0, out: 0 } },
+    { match: 'glm-4-flash', price: { in: 0, out: 0 } },
+    { match: 'qwen-turbo', price: { in: 0, out: 0 } },
+    { match: 'moonshot-v1', price: { in: 0, out: 0 } },
+    { match: 'minimax', price: { in: 0, out: 0 } },
+];
+/** Look up the price for a model id, or null when unknown. */
+export function priceForModel(model) {
+    const id = model.toLowerCase();
+    let best = null;
+    for (const entry of PRICES) {
+        if (id.includes(entry.match) && (!best || entry.match.length > best.match.length)) {
+            best = entry;
+        }
+    }
+    return best?.price ?? null;
+}
+/** Estimate the USD cost of a usage total for a model, or null when unpriced. */
+export function estimateCost(model, usage) {
+    const price = priceForModel(model);
+    if (!price)
+        return null;
+    return (usage.inputTokens * price.in + usage.outputTokens * price.out) / 1_000_000;
+}
+/** Accumulates token usage across a session. */
+export class UsageTracker {
+    input = 0;
+    output = 0;
+    turns = 0;
+    add(usage) {
+        if (usage.inputTokens > 0 || usage.outputTokens > 0) {
+            this.input += usage.inputTokens;
+            this.output += usage.outputTokens;
+            this.turns++;
+        }
+    }
+    get totals() {
+        return { inputTokens: this.input, outputTokens: this.output };
+    }
+    get hasData() {
+        return this.turns > 0;
+    }
+    /** A one-line human summary, e.g. "12,340 tokens (8.1k in / 4.2k out) · ~$0.0123". */
+    summary(model) {
+        if (!this.hasData)
+            return 'No usage reported yet.';
+        const total = this.input + this.output;
+        const cost = estimateCost(model, this.totals);
+        const costPart = cost === null ? '' : ` · ~$${cost.toFixed(4)}`;
+        return `${fmt(total)} tokens (${fmt(this.input)} in / ${fmt(this.output)} out)${costPart}`;
+    }
+}
+/** Compact number formatting: 1234 -> "1,234", 12340 -> "12.3k". */
+function fmt(n) {
+    if (n < 10_000)
+        return n.toLocaleString('en-US');
+    return `${(n / 1000).toFixed(1)}k`;
+}

package/dist/usage/index.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { UsageTracker, priceForModel, estimateCost } from './index.js';
+describe('priceForModel', () => {
+    it('matches the most specific prefix (mini before base)', () => {
+        expect(priceForModel('gpt-4o-mini')).toEqual({ in: 0.15, out: 0.6 });
+        expect(priceForModel('gpt-4o-2024-08-06')).toEqual({ in: 2.5, out: 10 });
+    });
+    it('prices known free-tier models at zero', () => {
+        expect(priceForModel('gemini-2.5-flash')).toEqual({ in: 0, out: 0 });
+        expect(priceForModel('glm-4-flash')).toEqual({ in: 0, out: 0 });
+    });
+    it('returns null for unknown models', () => {
+        expect(priceForModel('some-random-model')).toBeNull();
+    });
+});
+describe('estimateCost', () => {
+    it('computes cost from per-million pricing', () => {
+        // 1M input @ $3, 1M output @ $15 => $18
+        expect(estimateCost('claude-sonnet-5', { inputTokens: 1_000_000, outputTokens: 1_000_000 })).toBeCloseTo(18);
+    });
+    it('returns null when the model is unpriced', () => {
+        expect(estimateCost('mystery', { inputTokens: 100, outputTokens: 100 })).toBeNull();
+    });
+});
+describe('UsageTracker', () => {
+    it('accumulates across turns and ignores empty usage', () => {
+        const t = new UsageTracker();
+        t.add({ inputTokens: 100, outputTokens: 50 });
+        t.add({ inputTokens: 0, outputTokens: 0 }); // ignored
+        t.add({ inputTokens: 200, outputTokens: 80 });
+        expect(t.totals).toEqual({ inputTokens: 300, outputTokens: 130 });
+        expect(t.hasData).toBe(true);
+    });
+    it('summarizes with a cost estimate for priced models', () => {
+        const t = new UsageTracker();
+        t.add({ inputTokens: 1000, outputTokens: 500 });
+        const summary = t.summary('gpt-4o-mini');
+        expect(summary).toContain('1,500 tokens');
+        expect(summary).toContain('~$');
+    });
+    it('omits cost for unpriced models but still shows tokens', () => {
+        const t = new UsageTracker();
+        t.add({ inputTokens: 1000, outputTokens: 500 });
+        const summary = t.summary('mystery-model');
+        expect(summary).toContain('1,500 tokens');
+        expect(summary).not.toContain('$');
+    });
+    it('reports no data before any usage', () => {
+        expect(new UsageTracker().hasData).toBe(false);
+    });
+});

package/dist/utils/html.js

@@ -0,0 +1,8 @@
+/** Escape text for safe interpolation into HTML markup. */
+export function escapeHtml(text) {
+    return text
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;');
+}

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.5",
+  "version": "0.9.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"
   }
 }