vexi-cli 0.8.0 → 0.9.1

package/dist/tools/index.js

@@ -0,0 +1,280 @@
+/**
+ * Built-in file tools — Feature #1 (structured, deterministic file editing).
+ *
+ * The original design edited files by asking the model to emit shell commands
+ * (`cat >`, `sed -i`, `tee`…) which Vexi then ran, and the snapshot engine
+ * *regex-guessed* which files were touched. That is fragile: a mis-escaped
+ * `sed` corrupts files, and a missed write leaves nothing to undo.
+ *
+ * These built-in tools replace that path for editing. They use the same
+ * provider-agnostic text protocol as MCP (a fenced ```vexi-tool``` JSON block,
+ * WITHOUT a `server` field), so they work with every provider — no native
+ * function-calling API required. Because each write goes through here, the
+ * snapshot is taken on the *exact* file about to change, making undo precise.
+ */
+import { promises as fs } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve, relative, sep, dirname } from 'node:path';
+/** Names of the built-in tools the model may call. */
+export const BUILTIN_TOOL_NAMES = ['read_file', 'write_file', 'edit_file'];
+/** Cap on how much file content is returned to the model in one read. */
+const MAX_READ_BYTES = 64 * 1024;
+/**
+ * Parse a built-in file-tool call from a model reply, or null.
+ * Matches a ```vexi-tool``` block whose `tool` is a known built-in name and
+ * which has NO `server` field (that is how MCP tool calls are told apart).
+ */
+export function parseBuiltinToolCall(reply) {
+    const match = reply.match(/```vexi-tool\s*\n([\s\S]*?)```/);
+    if (!match)
+        return null;
+    try {
+        const json = JSON.parse(match[1]);
+        if (typeof json.server === 'string')
+            return null; // that's an MCP call
+        if (typeof json.tool !== 'string')
+            return null;
+        if (!BUILTIN_TOOL_NAMES.includes(json.tool))
+            return null;
+        const { tool, ...args } = json;
+        return { tool, args };
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve `rel` against `root`, rejecting paths that escape the project root. */
+function resolveWithinRoot(root, rel) {
+    const absRoot = resolve(root);
+    const abs = isAbsolute(rel) ? resolve(rel) : resolve(absRoot, rel);
+    if (abs !== absRoot && !abs.startsWith(absRoot + sep))
+        return null;
+    return abs;
+}
+function asString(v) {
+    return typeof v === 'string' ? v : null;
+}
+/** Count non-overlapping occurrences of `needle` in `haystack`. */
+function countOccurrences(haystack, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let i = haystack.indexOf(needle);
+    while (i !== -1) {
+        count++;
+        i = haystack.indexOf(needle, i + needle.length);
+    }
+    return count;
+}
+/**
+ * Execute a built-in file tool. Snapshots any file about to be written
+ * (via the provided SnapshotManager) so the edit is undoable exactly.
+ */
+export async function executeBuiltinTool(call, root, snapshots) {
+    const rawPath = asString(call.args.path);
+    if (!rawPath)
+        return { result: 'TOOL ERROR: missing "path".', files: [] };
+    const abs = resolveWithinRoot(root, rawPath);
+    if (!abs)
+        return { result: `TOOL ERROR: path "${rawPath}" is outside the project root.`, files: [] };
+    const rel = relative(root, abs).replace(/\\/g, '/');
+    switch (call.tool) {
+        // ── read_file {path, [start], [end]} ────────────────────────────────
+        case 'read_file': {
+            if (!existsSync(abs))
+                return { result: `TOOL ERROR: file not found: ${rel}`, files: [] };
+            let content;
+            try {
+                content = await fs.readFile(abs, 'utf-8');
+            }
+            catch (e) {
+                return { result: `TOOL ERROR: cannot read ${rel}: ${e instanceof Error ? e.message : String(e)}`, files: [] };
+            }
+            const lines = content.split('\n');
+            const start = Number.isInteger(call.args.start) ? Math.max(1, call.args.start) : 1;
+            const end = Number.isInteger(call.args.end) ? Math.min(lines.length, call.args.end) : lines.length;
+            const slice = lines.slice(start - 1, end);
+            let numbered = slice.map((l, i) => `${start + i}\t${l}`).join('\n');
+            if (numbered.length > MAX_READ_BYTES) {
+                numbered = numbered.slice(0, MAX_READ_BYTES) + '\n… [truncated — read a smaller line range]';
+            }
+            return { result: `FILE ${rel} (lines ${start}-${end} of ${lines.length}):\n${numbered}`, files: [] };
+        }
+        // ── write_file {path, content} — create or overwrite ────────────────
+        case 'write_file': {
+            const content = asString(call.args.content);
+            if (content === null)
+                return { result: 'TOOL ERROR: missing "content".', files: [] };
+            const existed = existsSync(abs);
+            if (existed) {
+                // Snapshot the current version BEFORE overwriting so undo restores it.
+                await snapshots.takeSnapshot([rel], `write_file ${rel}`).catch(() => { });
+            }
+            try {
+                await fs.mkdir(dirname(abs), { recursive: true });
+                await fs.writeFile(abs, content, 'utf-8');
+            }
+            catch (e) {
+                return { result: `TOOL ERROR: cannot write ${rel}: ${e instanceof Error ? e.message : String(e)}`, files: [] };
+            }
+            const lineCount = content.split('\n').length;
+            return {
+                result: `OK: ${existed ? 'overwrote' : 'created'} ${rel} (${lineCount} lines).`,
+                files: [rel],
+            };
+        }
+        // ── edit_file {path, old, new, [all]} — exact substring replace ──────
+        case 'edit_file': {
+            const oldStr = asString(call.args.old);
+            const newStr = asString(call.args.new);
+            if (oldStr === null || newStr === null) {
+                return { result: 'TOOL ERROR: edit_file requires string "old" and "new".', files: [] };
+            }
+            if (oldStr === newStr) {
+                return { result: 'TOOL ERROR: "old" and "new" are identical — nothing to change.', files: [] };
+            }
+            if (!existsSync(abs))
+                return { result: `TOOL ERROR: file not found: ${rel}`, files: [] };
+            let content;
+            try {
+                content = await fs.readFile(abs, 'utf-8');
+            }
+            catch (e) {
+                return { result: `TOOL ERROR: cannot read ${rel}: ${e instanceof Error ? e.message : String(e)}`, files: [] };
+            }
+            const occurrences = countOccurrences(content, oldStr);
+            if (occurrences === 0) {
+                return { result: `TOOL ERROR: "old" string not found in ${rel}. Read the file and copy the exact text (including whitespace).`, files: [] };
+            }
+            const all = call.args.all === true;
+            if (occurrences > 1 && !all) {
+                return {
+                    result: `TOOL ERROR: "old" matches ${occurrences} places in ${rel}. Add surrounding context to make it unique, or set "all": true to replace every occurrence.`,
+                    files: [],
+                };
+            }
+            // Snapshot BEFORE editing so undo restores the pre-edit version exactly.
+            await snapshots.takeSnapshot([rel], `edit_file ${rel}`).catch(() => { });
+            const updated = all
+                ? content.split(oldStr).join(newStr)
+                : content.replace(oldStr, newStr);
+            try {
+                await fs.writeFile(abs, updated, 'utf-8');
+            }
+            catch (e) {
+                return { result: `TOOL ERROR: cannot write ${rel}: ${e instanceof Error ? e.message : String(e)}`, files: [] };
+            }
+            return {
+                result: `OK: edited ${rel} (${all ? occurrences : 1} replacement${all && occurrences > 1 ? 's' : ''}).`,
+                files: [rel],
+            };
+        }
+        default:
+            return { result: `TOOL ERROR: unknown built-in tool "${call.tool}".`, files: [] };
+    }
+}
+// ── Native function-calling support ───────────────────────────────────────────
+/** JSON-Schema definitions of the built-in file tools, for native tool calling. */
+export const BUILTIN_TOOL_DEFS = [
+    {
+        name: 'read_file',
+        description: 'Read a file from the project, optionally a 1-based line range. Read before editing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative file path.' },
+                start: { type: 'integer', description: 'First line to read (1-based).' },
+                end: { type: 'integer', description: 'Last line to read (inclusive).' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'write_file',
+        description: 'Create a new file or fully overwrite an existing one with exact content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative file path.' },
+                content: { type: 'string', description: 'Full file content to write.' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    {
+        name: 'edit_file',
+        description: 'Replace the exact substring "old" with "new" in a file. "old" must appear verbatim and be unique unless "all" is true.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative file path.' },
+                old: { type: 'string', description: 'Exact existing text to replace (include surrounding context to be unique).' },
+                new: { type: 'string', description: 'Replacement text.' },
+                all: { type: 'boolean', description: 'Replace every occurrence instead of requiring uniqueness.' },
+            },
+            required: ['path', 'old', 'new'],
+        },
+    },
+];
+/** Separator between an MCP server name and tool name in a native tool call. */
+const MCP_SEP = '__';
+/**
+ * Build the full native tool list (built-in file tools + connected MCP tools)
+ * and a router that maps each tool name back to how it should be executed.
+ */
+export function buildNativeTools(mcp) {
+    const route = new Map();
+    const defs = [];
+    for (const def of BUILTIN_TOOL_DEFS) {
+        defs.push(def);
+        route.set(def.name, { kind: 'builtin' });
+    }
+    for (const t of mcp.tools) {
+        // Function names must match ^[a-zA-Z0-9_-]+$ — encode "server/tool" safely.
+        const name = `${t.server}${MCP_SEP}${t.name}`.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const schema = (t.inputSchema && typeof t.inputSchema === 'object')
+            ? t.inputSchema
+            : { type: 'object', properties: {} };
+        defs.push({ name, description: t.description.split('\n')[0], inputSchema: schema });
+        route.set(name, { kind: 'mcp', server: t.server, tool: t.name });
+    }
+    return { defs, route };
+}
+/**
+ * Execute a native tool call by name, routing to a built-in file tool or an
+ * MCP server. Returns the text result plus any project files that changed.
+ */
+export async function dispatchNativeTool(name, args, route, root, snapshots, mcp) {
+    const target = route.get(name);
+    if (!target)
+        return { result: `TOOL ERROR: unknown tool "${name}".`, files: [] };
+    if (target.kind === 'builtin') {
+        return executeBuiltinTool({ tool: name, args }, root, snapshots);
+    }
+    try {
+        const result = await mcp.callTool(target.server, target.tool, args);
+        return { result, files: [] };
+    }
+    catch (e) {
+        return { result: `TOOL ERROR: ${e instanceof Error ? e.message : String(e)}`, files: [] };
+    }
+}
+/** System-prompt block describing the built-in file tools. */
+export function builtinToolsBlock() {
+    return [
+        '## File tools (built-in — prefer these over shell for reading/editing files)',
+        'Read and edit files directly and reliably with these tools instead of shell commands',
+        '(cat/sed/tee). To call one, reply with ONLY a fenced block and nothing else:',
+        '```vexi-tool',
+        '{"tool": "edit_file", "path": "src/foo.ts", "old": "<exact text>", "new": "<replacement>"}',
+        '```',
+        'Available tools:',
+        '- read_file {path, [start], [end]} — return file contents, optionally a 1-based line range. Read before editing.',
+        '- write_file {path, content} — create a new file or fully overwrite an existing one with exact content.',
+        '- edit_file {path, old, new, [all]} — replace the exact substring "old" with "new". "old" must appear verbatim '
+            + 'and be unique unless you set "all": true. Include enough surrounding context to make "old" unique.',
+        'The JSON must be valid: escape newlines as \\n and quotes as \\" inside string values. Do NOT include a "server" field '
+            + '(that is reserved for MCP tools). You will receive the tool result in the next message; then continue.',
+        'Still use `bash` shell blocks for non-editing work: installing deps, building, running tests, starting servers.',
+    ].join('\n');
+}

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vexi-cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Open-source AI coding agent for your terminal. Bring your own key, zero config, multilingual.",
   "type": "module",
   "bin": {