vexi-cli 0.5.5 → 0.9.0

package/dist/cli.js

@@ -17,8 +17,11 @@
  *   vexi learn [--apply]       learn your coding style from past sessions
  */
 import { Command } from 'commander';
+import { confirm } from '@inquirer/prompts';
+import { VERSION } from './version.js';
 import ora from 'ora';
-import { runAgent } from './agent.js';
+import { checkForUpdate, runUpdate, runUninstall } from './update/index.js';
+import { runAgent, runPrint } from './agent.js';
 import { loadConfig, resetConfig, CONFIG_PATH } from './config.js';
 import { loadSkills, addSkill, removeSkill } from './skills/index.js';
 import { listSessions } from './replay/recorder.js';
@@ -28,11 +31,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) {
@@ -53,16 +58,25 @@ export function buildCli() {
         .description('Open-source AI coding agent for your terminal. BYOK, zero config, multilingual.')
         .version(VERSION, '-v, --version')
         .option('-l, --lang <lang>', `UI language (${SUPPORTED_LANGS.join('/')})`)
+        .option('-p, --print <prompt>', 'non-interactive: send one prompt, print the reply, exit (for scripts/CI)')
+        .option('-y, --yes', 'with --print, auto-run any shell commands the model proposes (no confirmation)')
         .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 });
+        if (options.print) {
+            await runPrint({ prompt: options.print, lang, autoYes: !!options.yes });
+            return;
+        }
+        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 +86,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
@@ -112,7 +130,15 @@ export function buildCli() {
         .action(async (source) => {
         const s = getStrings(await resolveLang());
         try {
-            const name = await addSkill(process.cwd(), source);
+            const name = await addSkill(process.cwd(), source, {
+                confirmRemoteContent: async (content, skillName, sourceUrl) => {
+                    console.log(dim(`\nFetched from ${sourceUrl} — this will be added to every prompt as an instruction the AI must follow:\n`));
+                    console.log(dim('─'.repeat(60)));
+                    console.log(content.slice(0, 2000) + (content.length > 2000 ? dim('\n… (truncated)') : ''));
+                    console.log(dim('─'.repeat(60)));
+                    return confirm({ message: `Save as skill "${skillName}"?`, default: false });
+                },
+            });
             console.log(ok(t(s.skillAdded, { name })));
         }
         catch (e) {
@@ -184,7 +210,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 +322,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 +355,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) {

package/dist/endpoint.js

@@ -0,0 +1,174 @@
+/**
+ * URL-based provider identification and model discovery.
+ *
+ * The user pastes an endpoint URL (e.g. https://openrouter.ai/api/v1).
+ * identifyFromUrl() inspects the hostname and path to determine which
+ * provider it is and how to authenticate. discoverModels() then calls
+ * the /models endpoint to get the live model list.
+ */
+const OPERATION_SUFFIXES = [
+    '/chat/completions',
+    '/completions',
+    '/models',
+    '/messages',
+];
+/** Strip trailing slashes and known operation path suffixes so the user can
+ *  paste a full URL (e.g. .../chat/completions) and still get the API root. */
+function normalizeBase(rawUrl) {
+    let url = rawUrl.trim().replace(/\/+$/, '');
+    for (const suffix of OPERATION_SUFFIXES) {
+        if (url.endsWith(suffix)) {
+            url = url.slice(0, url.length - suffix.length);
+            break;
+        }
+    }
+    return url;
+}
+function isPrivateIp(host) {
+    return (host === 'localhost' ||
+        host === '127.0.0.1' ||
+        host.endsWith('.local') ||
+        /^192\.168\.\d{1,3}\.\d{1,3}$/.test(host) ||
+        /^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host));
+}
+/**
+ * Identify the provider from a raw endpoint URL.
+ * Returns a UrlIdentity describing the provider, normalized base URL,
+ * API shape, and where to discover models.
+ */
+export function identifyFromUrl(rawUrl) {
+    const baseUrl = normalizeBase(rawUrl);
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        throw new Error(`Invalid URL: ${rawUrl}`);
+    }
+    const host = parsed.hostname.toLowerCase();
+    const path = parsed.pathname;
+    // OpenRouter
+    if (host === 'openrouter.ai') {
+        return {
+            provider: 'openrouter',
+            displayName: 'OpenRouter',
+            baseUrl,
+            apiShape: 'openai',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // Z.ai
+    if (host.endsWith('z.ai')) {
+        const displayName = path.toLowerCase().includes('/coding/') ? 'Z.ai (Coding Plan)' : 'Z.ai';
+        return {
+            provider: 'zai',
+            displayName,
+            baseUrl,
+            apiShape: 'openai',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // Groq
+    if (host.endsWith('groq.com')) {
+        return {
+            provider: 'groq',
+            displayName: 'Groq',
+            baseUrl,
+            apiShape: 'openai',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // OpenAI
+    if (host === 'api.openai.com') {
+        return {
+            provider: 'openai',
+            displayName: 'OpenAI',
+            baseUrl,
+            apiShape: 'openai',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // Anthropic
+    if (host === 'api.anthropic.com') {
+        return {
+            provider: 'anthropic',
+            displayName: 'Anthropic',
+            baseUrl,
+            apiShape: 'anthropic',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // Google Gemini
+    if (host.endsWith('generativelanguage.googleapis.com')) {
+        return {
+            provider: 'gemini',
+            displayName: 'Google Gemini',
+            baseUrl,
+            apiShape: 'openai',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // Cloudflare Workers AI -- model is embedded in the path after /ai/run/
+    if (host.endsWith('api.cloudflare.com') && path.includes('/ai/run/')) {
+        const aiRunStart = path.indexOf('/ai/run/') + '/ai/run/'.length;
+        let modelFromPath = path.slice(aiRunStart);
+        if (modelFromPath.startsWith('@cf/')) {
+            modelFromPath = modelFromPath.slice('@cf/'.length);
+        }
+        // baseUrl is the account endpoint up to /ai/run (without the model)
+        const cfBase = `${parsed.protocol}//${parsed.host}${path.slice(0, aiRunStart - 1)}`;
+        return {
+            provider: 'cloudflare',
+            displayName: 'Cloudflare Workers AI',
+            baseUrl: cfBase,
+            apiShape: 'openai',
+            modelsUrl: null,
+            modelFromPath: modelFromPath || undefined,
+        };
+    }
+    // Local / private LAN servers (Ollama, LM Studio, vLLM, etc.)
+    if (isPrivateIp(host)) {
+        return {
+            provider: 'local',
+            displayName: 'Local (OpenAI-compatible)',
+            baseUrl,
+            apiShape: 'openai',
+            modelsUrl: `${baseUrl}/models`,
+        };
+    }
+    // Unknown / custom endpoint -- assume OpenAI-compatible
+    return {
+        provider: 'custom',
+        displayName: `Custom (${host})`,
+        baseUrl,
+        apiShape: 'openai',
+        modelsUrl: `${baseUrl}/models`,
+    };
+}
+/**
+ * Discover the available models for a given endpoint.
+ *
+ * If the URL embeds the model (Cloudflare), returns that model directly.
+ * If modelsUrl is null, returns an empty array.
+ * Otherwise calls GET /models and maps the response to a list of id strings.
+ *
+ * Accepts an optional fetchFn for testability (defaults to globalThis.fetch).
+ */
+export async function discoverModels(identity, apiKey, fetchFn = globalThis.fetch) {
+    if (identity.modelFromPath) {
+        return [identity.modelFromPath];
+    }
+    if (!identity.modelsUrl) {
+        return [];
+    }
+    const headers = identity.apiShape === 'anthropic'
+        ? { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' }
+        : { Authorization: `Bearer ${apiKey}` };
+    const res = await fetchFn(identity.modelsUrl, { headers });
+    if (!res.ok) {
+        throw new Error(`Provider identified as "${identity.displayName}" but GET /models returned HTTP ${res.status}. ` +
+            `Enter the model ID manually.`);
+    }
+    const json = (await res.json());
+    return (json.data ?? []).map((m) => m.id).filter(Boolean);
+}

package/dist/endpoint.test.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi } from 'vitest';
+import { identifyFromUrl, discoverModels } from './endpoint.js';
+// ── identifyFromUrl ──────────────────────────────────────────────────────────
+describe('identifyFromUrl', () => {
+    it('identifies OpenRouter', () => {
+        const id = identifyFromUrl('https://openrouter.ai/api/v1');
+        expect(id.provider).toBe('openrouter');
+        expect(id.displayName).toBe('OpenRouter');
+        expect(id.baseUrl).toBe('https://openrouter.ai/api/v1');
+        expect(id.apiShape).toBe('openai');
+        expect(id.modelsUrl).toBe('https://openrouter.ai/api/v1/models');
+    });
+    it('strips /chat/completions suffix', () => {
+        const id = identifyFromUrl('https://openrouter.ai/api/v1/chat/completions');
+        expect(id.baseUrl).toBe('https://openrouter.ai/api/v1');
+    });
+    it('strips trailing slash', () => {
+        const id = identifyFromUrl('https://openrouter.ai/api/v1/');
+        expect(id.baseUrl).toBe('https://openrouter.ai/api/v1');
+    });
+    it('identifies Z.ai coding plan', () => {
+        const id = identifyFromUrl('https://api.z.ai/coding/v1');
+        expect(id.provider).toBe('zai');
+        expect(id.displayName).toBe('Z.ai (Coding Plan)');
+        expect(id.apiShape).toBe('openai');
+    });
+    it('identifies Z.ai generic', () => {
+        const id = identifyFromUrl('https://api.z.ai/v1');
+        expect(id.provider).toBe('zai');
+        expect(id.displayName).toBe('Z.ai');
+    });
+    it('identifies Anthropic', () => {
+        const id = identifyFromUrl('https://api.anthropic.com/v1');
+        expect(id.provider).toBe('anthropic');
+        expect(id.apiShape).toBe('anthropic');
+        expect(id.modelsUrl).toBe('https://api.anthropic.com/v1/models');
+    });
+    it('identifies OpenAI', () => {
+        const id = identifyFromUrl('https://api.openai.com/v1');
+        expect(id.provider).toBe('openai');
+        expect(id.apiShape).toBe('openai');
+    });
+    it('identifies Groq', () => {
+        const id = identifyFromUrl('https://api.groq.com/openai/v1');
+        expect(id.provider).toBe('groq');
+        expect(id.displayName).toBe('Groq');
+    });
+    it('identifies localhost as local', () => {
+        const id = identifyFromUrl('http://localhost:11434/v1');
+        expect(id.provider).toBe('local');
+        expect(id.displayName).toBe('Local (OpenAI-compatible)');
+        expect(id.modelsUrl).toBe('http://localhost:11434/v1/models');
+    });
+    it('identifies 192.168.x.x as local', () => {
+        const id = identifyFromUrl('http://192.168.1.100:8080/v1');
+        expect(id.provider).toBe('local');
+    });
+    it('identifies Cloudflare and extracts model from path', () => {
+        const id = identifyFromUrl('https://api.cloudflare.com/client/v4/accounts/abc123/ai/run/@cf/meta/llama-3.1-8b');
+        expect(id.provider).toBe('cloudflare');
+        expect(id.displayName).toBe('Cloudflare Workers AI');
+        expect(id.modelsUrl).toBeNull();
+        expect(id.modelFromPath).toBe('meta/llama-3.1-8b');
+    });
+    it('classifies unknown public host as custom', () => {
+        const id = identifyFromUrl('https://my-proxy.example.com/v1');
+        expect(id.provider).toBe('custom');
+        expect(id.displayName).toContain('my-proxy.example.com');
+        expect(id.apiShape).toBe('openai');
+    });
+    it('throws on invalid URL', () => {
+        expect(() => identifyFromUrl('not-a-url')).toThrow('Invalid URL');
+    });
+});
+// ── discoverModels ────────────────────────────────────────────────────────────
+describe('discoverModels', () => {
+    it('returns modelFromPath directly without fetching', async () => {
+        const identity = {
+            provider: 'cloudflare',
+            displayName: 'Cloudflare Workers AI',
+            baseUrl: 'https://api.cloudflare.com/client/v4/accounts/abc/ai/run',
+            apiShape: 'openai',
+            modelsUrl: null,
+            modelFromPath: 'meta/llama-3.1-8b',
+        };
+        const fetchFn = vi.fn();
+        const models = await discoverModels(identity, 'key', fetchFn);
+        expect(models).toEqual(['meta/llama-3.1-8b']);
+        expect(fetchFn).not.toHaveBeenCalled();
+    });
+    it('returns empty array when modelsUrl is null and no modelFromPath', async () => {
+        const identity = {
+            provider: 'custom',
+            displayName: 'Custom',
+            baseUrl: 'https://example.com',
+            apiShape: 'openai',
+            modelsUrl: null,
+        };
+        const models = await discoverModels(identity, 'key', vi.fn());
+        expect(models).toEqual([]);
+    });
+    it('fetches /models and maps response data to ids', async () => {
+        const identity = {
+            provider: 'openrouter',
+            displayName: 'OpenRouter',
+            baseUrl: 'https://openrouter.ai/api/v1',
+            apiShape: 'openai',
+            modelsUrl: 'https://openrouter.ai/api/v1/models',
+        };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: [{ id: 'openai/gpt-4o' }, { id: 'anthropic/claude-3.5-sonnet' }] }),
+        });
+        const models = await discoverModels(identity, 'sk-test', mockFetch);
+        expect(models).toEqual(['openai/gpt-4o', 'anthropic/claude-3.5-sonnet']);
+        expect(mockFetch).toHaveBeenCalledWith('https://openrouter.ai/api/v1/models', expect.objectContaining({ headers: expect.objectContaining({ Authorization: 'Bearer sk-test' }) }));
+    });
+    it('uses x-api-key header for Anthropic shape', async () => {
+        const identity = {
+            provider: 'anthropic',
+            displayName: 'Anthropic',
+            baseUrl: 'https://api.anthropic.com/v1',
+            apiShape: 'anthropic',
+            modelsUrl: 'https://api.anthropic.com/v1/models',
+        };
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: [{ id: 'claude-3-5-sonnet-20241022' }] }),
+        });
+        await discoverModels(identity, 'sk-ant-test', mockFetch);
+        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            headers: expect.objectContaining({ 'x-api-key': 'sk-ant-test' }),
+        }));
+    });
+    it('throws when /models returns non-OK status', async () => {
+        const identity = {
+            provider: 'groq',
+            displayName: 'Groq',
+            baseUrl: 'https://api.groq.com/openai/v1',
+            apiShape: 'openai',
+            modelsUrl: 'https://api.groq.com/openai/v1/models',
+        };
+        const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 401 });
+        await expect(discoverModels(identity, 'bad-key', mockFetch)).rejects.toThrow('HTTP 401');
+    });
+});

package/dist/explain/index.js

@@ -12,6 +12,7 @@
  */
 import { promises as fs } from 'node:fs';
 import { basename, join, relative, resolve } from 'node:path';
+import { escapeHtml } from '../utils/html.js';
 /** Limits to keep prompts within context windows. */
 const MAX_FILE_BYTES = 100 * 1024;
 const MAX_TOTAL_BYTES = 120 * 1024;
@@ -229,10 +230,3 @@ function inline(text) {
         .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
         .replace(/`([^`]+)`/g, '<code>$1</code>');
 }
-function escapeHtml(text) {
-    return text
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;');
-}