vexi-cli 0.5.1

package/dist/cli.js

@@ -0,0 +1,333 @@
+/**
+ * CLI definition (commander).
+ *
+ *   vexi                       start a chat session (first run: BYOK setup)
+ *   vexi --lang ar             override the UI/output language
+ *   vexi config                show config location + provider
+ *   vexi config reset          delete the stored API key & settings
+ *   vexi skill list            show active skills
+ *   vexi skill add <src>       add a skill (local .md file or GitHub URL)
+ *   vexi skill remove <name>   remove a skill
+ *   vexi replay                list recorded sessions
+ *   vexi replay --export       export latest session as standalone HTML
+ *   vexi explain <path> --ar   explain a file/folder in your language
+ *   vexi graph [--visual]      interactive dependency graph (d3 HTML)
+ *   vexi mcp list/add/remove   manage external MCP servers (~/.vexi/mcp.json)
+ *   vexi --mcp-server          expose Vexi as an MCP server (stdio)
+ *   vexi learn [--apply]       learn your coding style from past sessions
+ */
+import { Command } from 'commander';
+import ora from 'ora';
+import { runAgent } 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';
+import { exportReplay } from './replay/export.js';
+import { explain } from './explain/index.js';
+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 { openInDefaultApp } from './utils/open.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.0';
+/** Resolve the active language: --lang flag > saved config > system locale. */
+async function resolveLang(flag) {
+    if (flag) {
+        const lang = normalizeLang(flag);
+        if (!lang) {
+            console.error(err(`Unsupported language "${flag}". Supported: ${SUPPORTED_LANGS.join(', ')}`));
+            process.exit(1);
+        }
+        return lang;
+    }
+    const config = await loadConfig();
+    return normalizeLang(config?.lang) ?? detectSystemLang();
+}
+export function buildCli() {
+    const program = new Command();
+    program
+        .name('vexi')
+        .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('--mcp-server', 'run Vexi as an MCP server over stdio (for Claude Desktop, Cursor, etc.)')
+        .action(async (options) => {
+        if (options.mcpServer) {
+            // stdout becomes the JSON-RPC channel — no banner, no prompts.
+            const { runMcpServer } = await import('./mcp/server.js');
+            await runMcpServer();
+            return;
+        }
+        const lang = await resolveLang(options.lang);
+        await runAgent({ lang, version: VERSION });
+    });
+    const config = program.command('config').description('Manage Vexi configuration');
+    config
+        .command('show', { isDefault: true })
+        .description('Show config location and current provider')
+        .action(async () => {
+        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));
+            console.log(dim('lang: ') + accent(cfg.lang ?? 'auto'));
+        }
+        else {
+            console.log(dim('No configuration yet — run `vexi` to set up.'));
+        }
+    });
+    config
+        .command('reset')
+        .description('Delete the stored API key and settings')
+        .action(async () => {
+        const lang = await resolveLang();
+        const s = getStrings(lang);
+        const deleted = await resetConfig();
+        console.log(deleted ? ok(s.configReset) : dim(s.configResetNone));
+    });
+    // ── Custom Skills (Feature 2.5) ──────────────────────────────────────
+    const skill = program.command('skill').description('Manage project skills (.vexi/skills/*.md)');
+    skill
+        .command('list', { isDefault: true })
+        .description('Show active skills')
+        .action(async () => {
+        const s = getStrings(await resolveLang());
+        const skills = await loadSkills(process.cwd());
+        if (skills.length === 0) {
+            console.log(dim(s.skillListEmpty));
+            return;
+        }
+        for (const sk of skills) {
+            const firstLine = sk.content.split('\n')[0].replace(/^#+\s*/, '').slice(0, 80);
+            console.log(accent(sk.name) + dim(` — ${firstLine}`));
+        }
+    });
+    skill
+        .command('add <source>')
+        .description('Add a skill from a local .md file or a GitHub URL')
+        .action(async (source) => {
+        const s = getStrings(await resolveLang());
+        try {
+            const name = await addSkill(process.cwd(), source);
+            console.log(ok(t(s.skillAdded, { name })));
+        }
+        catch (e) {
+            console.error(err(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    skill
+        .command('remove <name>')
+        .description('Remove a skill by name')
+        .action(async (name) => {
+        const s = getStrings(await resolveLang());
+        const removed = await removeSkill(process.cwd(), name);
+        console.log(removed ? ok(t(s.skillRemoved, { name })) : err(t(s.skillNotFound, { name })));
+        if (!removed)
+            process.exitCode = 1;
+    });
+    // ── Vexi Replay (Feature 3) ─────────────────────────────────────────
+    program
+        .command('replay')
+        .description('List recorded sessions, or export one as a standalone HTML replay')
+        .option('-e, --export', 'export a session as HTML')
+        .option('-s, --session <name>', 'session file name (default: most recent)')
+        .option('-o, --out <file>', 'output HTML path')
+        .option('-l, --lang <lang>', `replay language (${SUPPORTED_LANGS.join('/')})`)
+        .action(async (options) => {
+        const lang = await resolveLang(options.lang);
+        const s = getStrings(lang);
+        if (!options.export) {
+            const sessions = await listSessions(process.cwd());
+            if (sessions.length === 0) {
+                console.log(dim(s.replayNone));
+                return;
+            }
+            for (const file of sessions)
+                console.log(accent(file));
+            console.log(dim('\nvexi replay --export [--session <name>] [--lang ar]'));
+            return;
+        }
+        try {
+            const path = await exportReplay(process.cwd(), {
+                lang,
+                session: options.session,
+                out: options.out,
+            });
+            console.log(ok(t(s.replayExported, { path })));
+            openInDefaultApp(path);
+        }
+        catch (e) {
+            console.error(err(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    // ── Multilingual explain (Feature 4) ─────────────────────────────────
+    program
+        .command('explain <path>')
+        .description('Explain a file or folder in your language (Arabic opens as RTL HTML)')
+        .option('-l, --lang <lang>', `output language (${SUPPORTED_LANGS.join('/')})`)
+        .option('--ar', 'Arabic').option('--en', 'English').option('--es', 'Spanish')
+        .option('--pt', 'Portuguese').option('--fr', 'French')
+        .action(async (target, options) => {
+        // Shorthand flags (--ar) win over --lang, which wins over config/system.
+        const short = SUPPORTED_LANGS.find((l) => options[l] === true);
+        const lang = short ?? (await resolveLang(options.lang));
+        const s = getStrings(lang);
+        const cfg = await loadConfig();
+        if (!cfg) {
+            console.error(err('No API key configured — run `vexi` once to set up.'));
+            process.exitCode = 1;
+            return;
+        }
+        const provider = createProvider(cfg.provider, cfg.apiKey, cfg.model);
+        const spinner = ora({ text: dim(s.explaining), spinner: 'dots' }).start();
+        let started = false;
+        try {
+            const result = await explain(provider, target, lang, (chunk) => {
+                if (!started) {
+                    spinner.stop();
+                    started = true;
+                }
+                process.stdout.write(chunk);
+            });
+            spinner.stop();
+            if (result) {
+                // Arabic → written to RTL HTML + markdown, opened in the browser
+                console.log(ok(t(s.explainSavedFile, { path: result.htmlPath })));
+                console.log(dim(result.mdPath));
+                openInDefaultApp(result.htmlPath);
+            }
+            else {
+                process.stdout.write('\n');
+            }
+        }
+        catch (e) {
+            spinner.stop();
+            console.error(err(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    // ── Visual code graph (Feature 5) ─────────────────────────────────────
+    program
+        .command('graph')
+        .description('Generate an interactive dependency graph (single HTML, opens in browser)')
+        .option('--visual', 'open the graph in the browser (default behavior)')
+        .option('-o, --out <file>', 'output HTML path')
+        .option('-l, --lang <lang>', `page language (${SUPPORTED_LANGS.join('/')})`)
+        .action(async (options) => {
+        const lang = await resolveLang(options.lang);
+        const s = getStrings(lang);
+        const spinner = ora({ text: dim(s.graphBuilding), spinner: 'dots' }).start();
+        try {
+            const graph = await buildGraph(process.cwd());
+            const path = await exportGraphHtml(process.cwd(), graph, lang, options.out);
+            spinner.stop();
+            console.log(ok(t(s.graphExported, { path })));
+            console.log(dim(`${graph.nodes.length} modules · ${graph.edges.length} imports`));
+            openInDefaultApp(path);
+        }
+        catch (e) {
+            spinner.stop();
+            console.error(err(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    // ── MCP client config (Feature 6a) ───────────────────────────────────
+    const mcp = program.command('mcp').description('Manage external MCP servers (~/.vexi/mcp.json)');
+    mcp
+        .command('list', { isDefault: true })
+        .description('Show configured MCP servers')
+        .action(async () => {
+        const s = getStrings(await resolveLang());
+        const config = await loadMcpConfig();
+        const entries = Object.entries(config.mcpServers);
+        console.log(dim('config: ') + accent(MCP_CONFIG_PATH));
+        if (entries.length === 0) {
+            console.log(dim(s.mcpListEmpty));
+            return;
+        }
+        for (const [name, server] of entries) {
+            console.log(accent(name) + dim(` — ${server.command} ${(server.args ?? []).join(' ')}`));
+        }
+    });
+    mcp
+        .command('add <name> <command> [args...]')
+        .description('Add an MCP server (e.g. vexi mcp add github npx -y @modelcontextprotocol/server-github)')
+        .action(async (name, command, args) => {
+        const s = getStrings(await resolveLang());
+        const config = await loadMcpConfig();
+        config.mcpServers[name] = { command, ...(args.length ? { args } : {}) };
+        await saveMcpConfig(config);
+        console.log(ok(t(s.mcpAdded, { name })));
+    });
+    mcp
+        .command('remove <name>')
+        .description('Remove an MCP server')
+        .action(async (name) => {
+        const s = getStrings(await resolveLang());
+        const config = await loadMcpConfig();
+        if (!config.mcpServers[name]) {
+            console.error(err(t(s.mcpNotFound, { name })));
+            process.exitCode = 1;
+            return;
+        }
+        delete config.mcpServers[name];
+        await saveMcpConfig(config);
+        console.log(ok(t(s.mcpRemoved, { name })));
+    });
+    // ── Vexi Learn (Feature 7) ──────────────────────────────────────
+    program
+        .command('learn')
+        .description('Learn your personal coding style from past sessions and turn it into a skill')
+        .option('-a, --apply', 'save the result as .vexi/skills/learned-style.md')
+        .option('-n, --sessions <count>', 'number of recent sessions to analyze', String(DEFAULT_MAX_SESSIONS))
+        .option('-l, --lang <lang>', `UI language (${SUPPORTED_LANGS.join('/')})`)
+        .action(async (options) => {
+        const lang = await resolveLang(options.lang);
+        const s = getStrings(lang);
+        const cfg = await loadConfig();
+        if (!cfg) {
+            console.error(err('No API key configured — run `vexi` once to set up.'));
+            process.exitCode = 1;
+            return;
+        }
+        const provider = createProvider(cfg.provider, cfg.apiKey, cfg.model);
+        const maxSessions = Math.max(1, parseInt(options.sessions ?? '', 10) || DEFAULT_MAX_SESSIONS);
+        const spinner = ora({ text: dim(s.learnAnalyzing), spinner: 'dots' }).start();
+        try {
+            const result = await learn(provider, process.cwd(), maxSessions);
+            spinner.stop();
+            if (result.evidence.sessionsAnalyzed === 0) {
+                console.log(dim(s.learnNoSessions));
+                return;
+            }
+            if (!result.markdown) {
+                console.log(dim(s.learnNothing));
+                return;
+            }
+            console.log(ok(t(s.learnPreview, {
+                sessions: String(result.evidence.sessionsAnalyzed),
+                signals: String(result.evidence.signals.length),
+            })));
+            console.log('\n' + result.markdown + '\n');
+            if (options.apply) {
+                const path = await applyLearned(process.cwd(), result.markdown);
+                console.log(ok(t(s.learnApplied, { path })));
+            }
+            else {
+                console.log(dim(s.learnApplyHint));
+            }
+        }
+        catch (e) {
+            spinner.stop();
+            console.error(err(e instanceof Error ? e.message : String(e)));
+            process.exitCode = 1;
+        }
+    });
+    return program;
+}

package/dist/config.js

@@ -0,0 +1,36 @@
+/**
+ * Local configuration: ~/.vexi/config.json
+ *
+ * Stores the API key, provider, model and language preference.
+ * - Written atomically (temp file + rename) to avoid corruption.
+ * - File mode 0o600 so the key is only readable by the current OS user
+ *   (chmod is a no-op on Windows, where the user profile dir is already
+ *   protected by NTFS ACLs).
+ */
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readJson, writeJsonAtomic } from './utils/fs-atomic.js';
+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. */
+export async function loadConfig() {
+    const config = await readJson(CONFIG_PATH);
+    if (!config?.apiKey || !config.provider)
+        return null;
+    return config;
+}
+/** Save the config atomically with owner-only permissions. */
+export async function saveConfig(config) {
+    await writeJsonAtomic(CONFIG_PATH, config, { mode: 0o600, dirMode: 0o700 });
+}
+/** Delete the stored config (used by `vexi config reset`). */
+export async function resetConfig() {
+    try {
+        await fs.unlink(CONFIG_PATH);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/explain/index.js

@@ -0,0 +1,238 @@
+/**
+ * Multilingual code explanation — Feature 4.
+ *
+ *   vexi explain auth.ts --ar    → explains the file in Arabic
+ *   vexi explain src/ --es       → explains a folder in Spanish
+ *
+ * Output strategy (terminal RTL limitation):
+ * - Latin-script languages (en/es/pt/fr): streamed directly to the terminal.
+ * - Arabic: terminals render RTL text broken, so the explanation is written
+ *   to a generated .html file (dir="rtl", renders perfectly) and opened in
+ *   the default browser. The raw markdown is saved alongside as .md.
+ */
+import { promises as fs } from 'node:fs';
+import { basename, join, relative, resolve } from 'node:path';
+/** Limits to keep prompts within context windows. */
+const MAX_FILE_BYTES = 100 * 1024;
+const MAX_TOTAL_BYTES = 120 * 1024;
+const MAX_FILES = 20;
+/** Source-code extensions considered when explaining a folder. */
+const CODE_EXTS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java',
+    '.kt', '.rb', '.php', '.cs', '.cpp', '.c', '.h', '.swift', '.vue', '.svelte',
+    '.sql', '.sh', '.css', '.scss', '.html', '.json', '.yml', '.yaml', '.toml', '.md',
+]);
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.vexi', '.next', 'out']);
+/** Collect source files from a file or directory path, with size caps. */
+export async function gatherSource(target) {
+    const abs = resolve(target);
+    const stat = await fs.stat(abs); // throws a clear ENOENT for bad paths
+    const files = [];
+    let total = 0;
+    let truncated = false;
+    async function addFile(path, rel) {
+        if (files.length >= MAX_FILES || total >= MAX_TOTAL_BYTES) {
+            truncated = true;
+            return;
+        }
+        const s = await fs.stat(path).catch(() => null);
+        if (!s || s.size > MAX_FILE_BYTES) {
+            if (s)
+                truncated = true;
+            return;
+        }
+        const content = await fs.readFile(path, 'utf8').catch(() => null);
+        if (content === null)
+            return;
+        total += content.length;
+        files.push({ rel, content });
+    }
+    if (stat.isFile()) {
+        await addFile(abs, basename(abs));
+    }
+    else {
+        async function walk(dir) {
+            const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                if (files.length >= MAX_FILES || total >= MAX_TOTAL_BYTES) {
+                    truncated = true;
+                    return;
+                }
+                const path = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith('.'))
+                        await walk(path);
+                }
+                else if (entry.isFile()) {
+                    const ext = entry.name.slice(entry.name.lastIndexOf('.'));
+                    if (CODE_EXTS.has(ext)) {
+                        await addFile(path, relative(abs, path).replaceAll('\\', '/'));
+                    }
+                }
+            }
+        }
+        await walk(abs);
+    }
+    if (files.length === 0) {
+        throw new Error(`No readable source files found at: ${target}`);
+    }
+    return { files, truncated };
+}
+const LANG_NAMES = {
+    en: 'English',
+    ar: 'Modern Standard Arabic (العربية الفصحى)',
+    es: 'Spanish',
+    pt: 'Portuguese',
+    fr: 'French',
+};
+/** Build the explanation prompt for the model. */
+export function buildExplainMessages(source, lang) {
+    const code = source.files
+        .map((f) => `### FILE: ${f.rel}\n\`\`\`\n${f.content}\n\`\`\``)
+        .join('\n\n');
+    return [
+        {
+            role: 'system',
+            content: [
+                `You are Vexi, an expert code explainer. Write the entire explanation in fluent ${LANG_NAMES[lang]}.`,
+                'Structure the output as Markdown with exactly these parts:',
+                '1. A heading with the file/project name, then a short purpose summary.',
+                '2. A function-by-function (or section-by-section) breakdown, citing line numbers.',
+                '3. A final note on how the pieces fit together (business logic, not just syntax).',
+                'Keep code identifiers, keywords and file names in English; explain around them.',
+                lang === 'ar' ? 'اكتب الشرح كاملًا بالعربية الفصحى السليمة.' : '',
+            ].filter(Boolean).join('\n'),
+        },
+        {
+            role: 'user',
+            content: `Explain the following code:\n\n${code}${source.truncated ? '\n\n(Note: some files were omitted due to size limits.)' : ''}`,
+        },
+    ];
+}
+/**
+ * Run the explanation.
+ * - Latin-script langs: streams to `onText` (terminal) and returns null.
+ * - Arabic: collects silently, writes .md + .html next to cwd and returns
+ *   the HTML path for the caller to open.
+ */
+export async function explain(provider, target, lang, onText) {
+    const source = await gatherSource(target);
+    const messages = buildExplainMessages(source, lang);
+    if (lang !== 'ar') {
+        await provider.stream(messages, onText);
+        return null;
+    }
+    // Arabic → file output (RTL renders perfectly in the browser)
+    const markdown = await provider.stream(messages, () => { });
+    const base = `vexi-explain-${basename(resolve(target)).replace(/[^a-z0-9_-]+/gi, '-')}`;
+    const mdPath = join(process.cwd(), `${base}.md`);
+    const htmlPath = join(process.cwd(), `${base}.html`);
+    await fs.writeFile(mdPath, markdown, 'utf8');
+    await fs.writeFile(htmlPath, explanationHtml(markdown, basename(resolve(target))), 'utf8');
+    return { htmlPath, mdPath };
+}
+/** Wrap the markdown explanation in a standalone RTL HTML page. */
+export function explanationHtml(markdown, title) {
+    return `<!DOCTYPE html>
+<html lang="ar" dir="rtl">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>شرح ${escapeHtml(title)} — Vexi</title>
+<style>
+  :root { --accent: #2979FF; --bg: #0a0a0f; --panel: #12121a; --text: #e8e8f0; --dim: #8888a0; }
+  body { margin: 0; background: var(--bg); color: var(--text);
+         font: 17px/1.9 "Segoe UI", Tahoma, "Noto Naskh Arabic", sans-serif; }
+  main { max-width: 820px; margin: 0 auto; padding: 32px 20px 80px; }
+  h1, h2, h3 { color: var(--accent); }
+  code, pre { direction: ltr; text-align: left; font: 14px/1.6 ui-monospace, Consolas, monospace; }
+  code { background: var(--panel); border-radius: 6px; padding: 2px 8px; }
+  pre { background: var(--panel); border: 1px solid #1e1e2c; border-inline-start: 3px solid var(--accent);
+        border-radius: 10px; padding: 14px 16px; overflow-x: auto; }
+  pre code { background: none; padding: 0; }
+  blockquote { border-inline-start: 3px solid var(--accent); margin-inline-start: 0;
+               padding-inline-start: 16px; color: var(--dim); }
+  footer { text-align: center; color: var(--dim); padding: 24px; font-size: 13px; }
+  footer code { color: var(--accent); }
+</style>
+</head>
+<body>
+<main>${renderMarkdown(markdown)}</main>
+<footer>Generated by Vexi · <code>npm install -g vexi</code> ·
+<a href="https://github.com/Elomami1976/vexi" style="color:var(--dim)">GitHub</a></footer>
+</body>
+</html>
+`;
+}
+/**
+ * Minimal markdown → HTML renderer (headings, fenced code, inline code,
+ * bold, lists, paragraphs). Everything is HTML-escaped first — no raw
+ * model output ever reaches the DOM unescaped.
+ */
+export function renderMarkdown(md) {
+    const out = [];
+    const lines = md.split(/\r?\n/);
+    let inCode = false;
+    let codeBuffer = [];
+    let inList = false;
+    const closeList = () => {
+        if (inList) {
+            out.push('</ul>');
+            inList = false;
+        }
+    };
+    for (const line of lines) {
+        if (line.trimStart().startsWith('```')) {
+            if (inCode) {
+                out.push(`<pre><code>${codeBuffer.join('\n')}</code></pre>`);
+                codeBuffer = [];
+                inCode = false;
+            }
+            else {
+                closeList();
+                inCode = true;
+            }
+            continue;
+        }
+        if (inCode) {
+            codeBuffer.push(escapeHtml(line));
+            continue;
+        }
+        const heading = line.match(/^(#{1,4})\s+(.*)$/);
+        if (heading) {
+            closeList();
+            const level = heading[1].length;
+            out.push(`<h${level}>${inline(heading[2])}</h${level}>`);
+            continue;
+        }
+        const item = line.match(/^\s*[-*]\s+(.*)$/);
+        if (item) {
+            if (!inList) {
+                out.push('<ul>');
+                inList = true;
+            }
+            out.push(`<li>${inline(item[1])}</li>`);
+            continue;
+        }
+        closeList();
+        if (line.trim())
+            out.push(`<p>${inline(line)}</p>`);
+    }
+    if (inCode)
+        out.push(`<pre><code>${codeBuffer.join('\n')}</code></pre>`);
+    closeList();
+    return out.join('\n');
+}
+/** Inline markdown: escape first, then bold and inline code. */
+function inline(text) {
+    return escapeHtml(text)
+        .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+        .replace(/`([^`]+)`/g, '<code>$1</code>');
+}
+function escapeHtml(text) {
+    return text
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;');
+}