vexi-cli 0.5.1

package/dist/learn/index.js

@@ -0,0 +1,131 @@
+/**
+ * Vexi Learn — Feature 7 (Phase 5).
+ *
+ * Vexi adapts to your personal coding style by mining your own recorded
+ * sessions (`.vexi/sessions/*.json`, written by the replay recorder).
+ * Your corrections to the AI are the strongest signal: "use tabs",
+ * "don't use classes", "always answer in Arabic", "prefer fetch over
+ * axios" — durable preferences hidden inside everyday messages.
+ *
+ *   vexi learn           analyze recent sessions, preview the learned style
+ *   vexi learn --apply   save it as .vexi/skills/learned-style.md
+ *
+ * The saved skill is a normal markdown skill file, so it is automatically
+ * injected into the system prompt of every future session (Feature 2.5) —
+ * the agent literally gets more "you" over time. Everything stays local;
+ * the only network call is the one to your own model provider.
+ */
+import { join } from 'node:path';
+import { promises as fs } from 'node:fs';
+import { listSessions, loadSession } from '../replay/recorder.js';
+/** The skill file Vexi Learn owns (re-running learn overwrites it). */
+export const LEARNED_SKILL_NAME = 'learned-style';
+/** How many recent sessions to analyze by default. */
+export const DEFAULT_MAX_SESSIONS = 10;
+/** Per-message and total caps keep the prompt well under context limits. */
+const MAX_MSG_LEN = 600;
+const MAX_TOTAL_CHARS = 24_000;
+/**
+ * Heuristics for "correction / preference" messages — the user pushing
+ * back or stating a durable rule. Multilingual on purpose (en/es/pt/fr/ar).
+ */
+const SIGNAL_RE = new RegExp([
+    // English
+    String.raw `\b(don'?t|do not|stop|never|always|instead( of)?|prefer|rather than|please use|use\s+\S+\s+(not|instead)|no,|actually|wrong|rename|i (like|want|prefer))\b`,
+    // Spanish / Portuguese
+    String.raw `\b(no uses|en lugar de|prefiero|siempre|nunca|mejor usa|não use|em vez de|prefiro|sempre)\b`,
+    // French
+    String.raw `\b(n'utilise pas|au lieu de|je préfère|toujours|jamais|plutôt)\b`,
+    // Arabic
+    String.raw `(لا تستخدم|بدلًا من|بدلا من|أفضّل|افضل|دائمًا|دائما|أبدًا|استخدم)`,
+].join('|'), 'iu');
+/** True when a user message looks like a correction or stated preference. */
+export function isPreferenceSignal(message) {
+    return SIGNAL_RE.test(message);
+}
+/**
+ * Collect evidence from recent sessions: every user message, with
+ * correction-style messages separated out. Newest sessions first.
+ */
+export async function gatherEvidence(root, maxSessions = DEFAULT_MAX_SESSIONS) {
+    const names = (await listSessions(root)).slice(0, maxSessions);
+    const signals = [];
+    const other = [];
+    let total = 0;
+    let sessionsAnalyzed = 0;
+    for (const name of names) {
+        const loaded = await loadSession(root, name);
+        if (!loaded)
+            continue;
+        sessionsAnalyzed++;
+        for (const event of loaded.session.events) {
+            if (event.role !== 'user')
+                continue;
+            const text = event.content.trim().slice(0, MAX_MSG_LEN);
+            if (!text || text.startsWith('/'))
+                continue; // skip slash commands
+            if (total + text.length > MAX_TOTAL_CHARS)
+                break;
+            total += text.length;
+            (isPreferenceSignal(text) ? signals : other).push(text);
+        }
+    }
+    return { sessionsAnalyzed, signals, other };
+}
+const LEARN_PROMPT = `You are a coding-style analyst. Below are real messages a developer
+sent to their AI coding agent across past sessions. CORRECTIONS are messages where they
+pushed back or stated a rule — these are the strongest evidence of durable preferences.
+
+Extract the developer's PERSONAL CODING STYLE as a markdown skill file that a coding
+agent will follow in every future session.
+
+Rules:
+- Only include DURABLE preferences (style, naming, libraries, language, formatting,
+  testing habits, communication preferences). Ignore one-off task instructions.
+- Each preference must be backed by evidence in the messages. Never invent.
+- Write in English (the file is consumed by an AI model). Be concise: short bullet
+  points grouped under a few ## headings, max ~300 words.
+- Start the file with the line: # Learned coding style
+- If the messages contain NO durable preferences at all, respond with exactly: NOTHING`;
+/** Build the chat messages for the learn call (exported for tests). */
+export function buildLearnMessages(evidence) {
+    const sections = [];
+    if (evidence.signals.length > 0) {
+        sections.push('CORRECTIONS / STATED PREFERENCES:\n' + evidence.signals.map((m) => `- ${m}`).join('\n'));
+    }
+    if (evidence.other.length > 0) {
+        sections.push('OTHER MESSAGES (context):\n' + evidence.other.map((m) => `- ${m}`).join('\n'));
+    }
+    return [
+        { role: 'system', content: LEARN_PROMPT },
+        { role: 'user', content: sections.join('\n\n') },
+    ];
+}
+/**
+ * Analyze recent sessions and distill the user's coding style.
+ * Returns `markdown: null` when there are no sessions or no durable signal.
+ */
+export async function learn(provider, root, maxSessions = DEFAULT_MAX_SESSIONS) {
+    const evidence = await gatherEvidence(root, maxSessions);
+    if (evidence.signals.length === 0 && evidence.other.length === 0) {
+        return { markdown: null, evidence };
+    }
+    const raw = (await provider.stream(buildLearnMessages(evidence), () => { })).trim();
+    if (!raw || /^NOTHING\b/i.test(raw)) {
+        return { markdown: null, evidence };
+    }
+    // Strip accidental markdown fences around the whole reply.
+    const markdown = raw.replace(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/m, '$1').trim();
+    return { markdown, evidence };
+}
+/**
+ * Save the learned style as a regular skill file so it is injected into
+ * every future session. Returns the absolute file path.
+ */
+export async function applyLearned(root, markdown) {
+    const dir = join(root, '.vexi', 'skills');
+    await fs.mkdir(dir, { recursive: true });
+    const path = join(dir, `${LEARNED_SKILL_NAME}.md`);
+    await fs.writeFile(path, markdown.trim() + '\n', 'utf8');
+    return path;
+}

package/dist/mcp/client.js

@@ -0,0 +1,99 @@
+/**
+ * MCP client — Feature 6a (Vexi as MCP client).
+ *
+ * Connects to the stdio MCP servers configured in ~/.vexi/mcp.json and
+ * exposes their tools to the chat agent. Because Vexi is provider-agnostic
+ * (no native function-calling API), tool use is text-based: the model is
+ * shown the available tools in the system prompt and replies with a fenced
+ * ```vexi-tool``` JSON block, which the agent parses and executes here.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { loadMcpConfig } from './config.js';
+export class McpManager {
+    connections = [];
+    tools = [];
+    /** Connect to every configured server (errors are collected, not thrown). */
+    async connect() {
+        const config = await loadMcpConfig();
+        const connected = [];
+        const failed = [];
+        for (const [name, server] of Object.entries(config.mcpServers)) {
+            try {
+                const transport = new StdioClientTransport({
+                    command: server.command,
+                    args: server.args ?? [],
+                    env: { ...process.env, ...server.env },
+                    stderr: 'ignore',
+                });
+                const client = new Client({ name: 'vexi', version: '0.5.0' });
+                await client.connect(transport);
+                const { tools } = await client.listTools();
+                for (const tool of tools) {
+                    this.tools.push({
+                        server: name,
+                        name: tool.name,
+                        description: tool.description ?? '',
+                        inputSchema: tool.inputSchema,
+                    });
+                }
+                this.connections.push({ name, client });
+                connected.push(name);
+            }
+            catch (e) {
+                failed.push({ name, error: e instanceof Error ? e.message : String(e) });
+            }
+        }
+        return { connected, failed };
+    }
+    /** Call a tool on a connected server; returns the text result. */
+    async callTool(server, tool, args) {
+        const connection = this.connections.find((c) => c.name === server);
+        if (!connection)
+            throw new Error(`MCP server "${server}" is not connected.`);
+        const result = await connection.client.callTool({ name: tool, arguments: args });
+        const content = Array.isArray(result.content) ? result.content : [];
+        const text = content
+            .map((c) => (c.type === 'text' ? (c.text ?? '') : `[${c.type}]`))
+            .join('\n');
+        return result.isError ? `TOOL ERROR: ${text}` : text;
+    }
+    /** System-prompt block describing the available tools ('' when none). */
+    promptBlock() {
+        if (this.tools.length === 0)
+            return '';
+        const list = this.tools
+            .map((t) => `- ${t.server}/${t.name}: ${t.description.split('\n')[0]}\n  input schema: ${JSON.stringify(t.inputSchema)}`)
+            .join('\n');
+        return [
+            '## External tools (MCP)',
+            'You can call these tools. To call one, reply with ONLY a fenced block:',
+            '```vexi-tool',
+            '{"server": "<server>", "tool": "<name>", "arguments": { ... }}',
+            '```',
+            'You will receive the tool result in the next message; then continue.',
+            'Available tools:',
+            list,
+        ].join('\n');
+    }
+    async close() {
+        await Promise.allSettled(this.connections.map((c) => c.client.close()));
+        this.connections = [];
+    }
+}
+/** Parse a ```vexi-tool``` call from a model reply, or null. */
+export function parseToolCall(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' && typeof json.tool === 'string') {
+            return { server: json.server, tool: json.tool, arguments: json.arguments ?? {} };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}

package/dist/mcp/config.js

@@ -0,0 +1,27 @@
+/**
+ * MCP client configuration — Feature 6a.
+ *
+ * External MCP servers are declared in ~/.vexi/mcp.json using the same
+ * shape as Claude Desktop's config, so users can copy entries verbatim:
+ *
+ * {
+ *   "mcpServers": {
+ *     "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] }
+ *   }
+ * }
+ */
+import { join } from 'node:path';
+import { VEXI_DIR } from '../config.js';
+import { readJson, writeJsonAtomic } from '../utils/fs-atomic.js';
+export const MCP_CONFIG_PATH = join(VEXI_DIR, 'mcp.json');
+export async function loadMcpConfig() {
+    const config = await readJson(MCP_CONFIG_PATH);
+    if (!config || typeof config.mcpServers !== 'object' || config.mcpServers === null) {
+        return { mcpServers: {} };
+    }
+    return config;
+}
+export async function saveMcpConfig(config) {
+    // mode 600: server entries may carry env secrets (API tokens)
+    await writeJsonAtomic(MCP_CONFIG_PATH, config, { mode: 0o600, dirMode: 0o700 });
+}

package/dist/mcp/server.js

@@ -0,0 +1,110 @@
+/**
+ * MCP server mode — Feature 6b (Vexi as MCP server, unique differentiator).
+ *
+ * `vexi --mcp-server` exposes Vexi's capabilities to OTHER AI agents
+ * (Claude Desktop, Claude Code, Cursor, any MCP client) over stdio:
+ *
+ * Resources:
+ *   vexi://project   project structure map (.vexi/project.json, rescanned)
+ *   vexi://memory    compressed project memory — decisions & summary
+ *   vexi://sessions  list of recorded sessions
+ *
+ * Tools:
+ *   scan_project     rescan the project and return the map
+ *   explain_code     explain any file/folder in en/ar/es/pt/fr
+ *   project_memory   read the running summary + key decisions
+ *
+ * Example client config (Claude Desktop):
+ *   { "mcpServers": { "vexi": { "command": "vexi", "args": ["--mcp-server"] } } }
+ *
+ * IMPORTANT: stdout is the JSON-RPC channel — never console.log here
+ * (diagnostics go to stderr).
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { loadConfig } from '../config.js';
+import { createProvider } from '../providers/index.js';
+import { scanProject, projectSummary } from '../scanner/index.js';
+import { loadMemory, memoryBlock } from '../memory/index.js';
+import { listSessions } from '../replay/recorder.js';
+import { gatherSource, buildExplainMessages } from '../explain/index.js';
+import { SUPPORTED_LANGS } from '../i18n/index.js';
+export async function runMcpServer() {
+    const root = process.cwd();
+    const server = new McpServer({ name: 'vexi', version: '0.5.0' });
+    // ── Resources ──────────────────────────────────────────────────────────
+    server.registerResource('project-map', 'vexi://project', {
+        title: 'Project map',
+        description: 'Languages, stack, architecture layers and file list of the current project.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const map = await scanProject(root);
+        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(map, null, 2) }] };
+    });
+    server.registerResource('project-memory', 'vexi://memory', {
+        title: 'Project memory',
+        description: 'Compressed running summary and key decisions from past Vexi sessions.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const memory = await loadMemory(root);
+        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(memory, null, 2) }] };
+    });
+    server.registerResource('sessions', 'vexi://sessions', {
+        title: 'Recorded sessions',
+        description: 'List of recorded Vexi chat sessions (.vexi/sessions/).',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const sessions = await listSessions(root);
+        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(sessions, null, 2) }] };
+    });
+    // ── Tools ──────────────────────────────────────────────────────────────
+    server.registerTool('scan_project', {
+        title: 'Scan project',
+        description: 'Scan the current project and return a compact structure summary (languages, stack, architecture layers).',
+        inputSchema: {},
+    }, async () => {
+        const map = await scanProject(root);
+        return { content: [{ type: 'text', text: projectSummary(map) }] };
+    });
+    server.registerTool('project_memory', {
+        title: 'Project memory',
+        description: 'Return the compressed project memory: running summary + key decisions from past sessions.',
+        inputSchema: {},
+    }, async () => {
+        const memory = await loadMemory(root);
+        const text = memoryBlock(memory) || 'No project memory recorded yet.';
+        return { content: [{ type: 'text', text }] };
+    });
+    server.registerTool('explain_code', {
+        title: 'Explain code',
+        description: `Explain a file or folder in any supported language (${SUPPORTED_LANGS.join('/')}). Returns a structured Markdown explanation.`,
+        inputSchema: {
+            path: z.string().describe('File or folder path, relative to the project root or absolute'),
+            language: z.enum(SUPPORTED_LANGS).default('en').describe('Output language'),
+        },
+    }, async ({ path, language }) => {
+        const config = await loadConfig();
+        if (!config) {
+            return {
+                content: [{ type: 'text', text: 'No API key configured. Run `vexi` once in a terminal to set up.' }],
+                isError: true,
+            };
+        }
+        try {
+            const provider = createProvider(config.provider, config.apiKey, config.model);
+            const source = await gatherSource(path);
+            const markdown = await provider.stream(buildExplainMessages(source, language), () => { });
+            return { content: [{ type: 'text', text: markdown }] };
+        }
+        catch (e) {
+            return {
+                content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Vexi MCP server running on stdio (project: ' + root + ')');
+}

package/dist/memory/index.js

@@ -0,0 +1,127 @@
+/**
+ * Context Compression Engine — Feature 1 (Running Summary approach).
+ *
+ * Problem: in long sessions the conversation outgrows the context window.
+ * Naively deleting old messages makes the model forget earlier decisions.
+ *
+ * Strategy:
+ * - Recent messages always stay in full (KEEP_RECENT).
+ * - Every COMPRESS_INTERVAL messages, older messages are folded into a
+ *   "running summary" + a list of key decision points, produced by the
+ *   model itself (e.g. "User chose JWT for authentication").
+ * - The summary is persisted per-project in .vexi/memory.json (atomic
+ *   writes) and loaded automatically on every session start, so Vexi
+ *   never forgets previous decisions — even across sessions.
+ */
+import { join } from 'node:path';
+import { readJson, writeJsonAtomic } from '../utils/fs-atomic.js';
+/** Messages that always stay in the context verbatim. */
+export const KEEP_RECENT = 10;
+/** Compress after this many new messages accumulate beyond KEEP_RECENT. */
+export const COMPRESS_INTERVAL = 6;
+const EMPTY_MEMORY = {
+    version: 1,
+    summary: '',
+    decisions: [],
+    updatedAt: '',
+    compressedCount: 0,
+};
+function memoryPath(root) {
+    return join(root, '.vexi', 'memory.json');
+}
+/** Load this project's memory (or an empty one). */
+export async function loadMemory(root) {
+    const memory = await readJson(memoryPath(root));
+    return memory && memory.version === 1 ? memory : { ...EMPTY_MEMORY };
+}
+/** Persist memory atomically. */
+export async function saveMemory(root, memory) {
+    await writeJsonAtomic(memoryPath(root), memory);
+}
+/**
+ * Render the memory as a system-prompt block.
+ * Returns '' when there is nothing remembered yet.
+ */
+export function memoryBlock(memory) {
+    if (!memory.summary && memory.decisions.length === 0)
+        return '';
+    const parts = ['## Project memory (earlier context, compressed)'];
+    if (memory.summary)
+        parts.push(memory.summary);
+    if (memory.decisions.length > 0) {
+        parts.push('Key decisions:\n' + memory.decisions.map((d) => `- ${d}`).join('\n'));
+    }
+    return parts.join('\n');
+}
+/** Prompt used to fold old messages into the running summary. */
+const COMPRESS_PROMPT = `You maintain the long-term memory of a coding session.
+Merge the EXISTING MEMORY and the NEW MESSAGES below into an updated memory.
+
+Rules:
+- Keep it dense and factual; max ~200 words for the summary.
+- "decisions" lists durable decision points worth remembering forever
+  (e.g. "User chose JWT for authentication", "Database switched to PostgreSQL").
+  Carry over old decisions unless they were explicitly reversed; max 20 items.
+- Never invent information.
+
+Respond with ONLY valid JSON, no markdown fences:
+{"summary": "...", "decisions": ["...", "..."]}`;
+/**
+ * Fold `oldMessages` into the running summary using the model itself.
+ *
+ * On any failure the previous memory is returned unchanged — compression
+ * is an optimization and must never break the chat loop.
+ */
+export async function compressIntoMemory(provider, memory, oldMessages) {
+    if (oldMessages.length === 0)
+        return memory;
+    const transcript = oldMessages
+        .map((m) => `${m.role.toUpperCase()}: ${truncate(m.content, 1500)}`)
+        .join('\n\n');
+    const existing = memory.summary || memory.decisions.length
+        ? `Summary: ${memory.summary || '(none)'}\nDecisions:\n${memory.decisions.map((d) => `- ${d}`).join('\n') || '(none)'}`
+        : '(empty)';
+    try {
+        const raw = await provider.stream([
+            { role: 'system', content: COMPRESS_PROMPT },
+            {
+                role: 'user',
+                content: `EXISTING MEMORY:\n${existing}\n\nNEW MESSAGES:\n${transcript}`,
+            },
+        ], () => { });
+        const parsed = extractJson(raw);
+        if (!parsed || typeof parsed.summary !== 'string' || !Array.isArray(parsed.decisions)) {
+            return memory;
+        }
+        return {
+            version: 1,
+            summary: parsed.summary.trim(),
+            decisions: parsed.decisions
+                .filter((d) => typeof d === 'string')
+                .map((d) => d.trim())
+                .filter(Boolean)
+                .slice(0, 20),
+            updatedAt: new Date().toISOString(),
+            compressedCount: memory.compressedCount + oldMessages.length,
+        };
+    }
+    catch {
+        return memory; // never let compression break the session
+    }
+}
+/** Extract the first JSON object from a model reply (tolerates fences/prose). */
+function extractJson(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end <= start)
+        return null;
+    try {
+        return JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+}
+function truncate(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,59 @@
+/**
+ * Streaming client for the native Anthropic Messages API.
+ * Anthropic separates the system prompt from the messages array,
+ * so it gets its own small client instead of the OpenAI-compatible one.
+ */
+import { ProviderError } from './types.js';
+import { sseEvents, truncate } from './openai-compat.js';
+const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+export function createAnthropicProvider(apiKey, model) {
+    return {
+        id: 'anthropic',
+        model,
+        async stream(messages, onText) {
+            // Anthropic takes the system prompt as a top-level field
+            const system = messages
+                .filter((m) => m.role === 'system')
+                .map((m) => m.content)
+                .join('\n\n');
+            const chat = messages.filter((m) => m.role !== 'system');
+            const res = await fetch(ANTHROPIC_API, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': ANTHROPIC_VERSION,
+                },
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 8192,
+                    ...(system ? { system } : {}),
+                    messages: chat,
+                    stream: true,
+                }),
+            }).catch((err) => {
+                throw new ProviderError(`Network error: ${err.message}`);
+            });
+            if (!res.ok || !res.body) {
+                const body = await res.text().catch(() => '');
+                throw new ProviderError(`anthropic API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
+            }
+            let full = '';
+            for await (const data of sseEvents(res.body)) {
+                try {
+                    const json = JSON.parse(data);
+                    if (json.type === 'content_block_delta' && json.delta?.type === 'text_delta') {
+                        const text = json.delta.text;
+                        full += text;
+                        onText(text);
+                    }
+                }
+                catch {
+                    // Ignore malformed/keep-alive chunks
+                }
+            }
+            return full;
+        },
+    };
+}

package/dist/providers/detect.js

@@ -0,0 +1,47 @@
+/**
+ * API key → provider auto-detection.
+ *
+ * Key formats change over time, so all patterns live in this single file
+ * and are intentionally loose (prefix-based). To support a new key format,
+ * just add/update an entry in PROVIDER_PATTERNS below.
+ */
+/**
+ * Ordered list of detection patterns.
+ *
+ * Patterns are written to be mutually exclusive (the generic OpenAI `sk-`
+ * pattern uses a negative lookahead for `sk-ant-` / `sk-or-`), so a key
+ * matching more than one pattern is a genuine ambiguity and triggers the
+ * interactive fallback.
+ */
+export const PROVIDER_PATTERNS = [
+    { provider: 'anthropic', pattern: /^sk-ant-/ },
+    { provider: 'openrouter', pattern: /^sk-or-/ },
+    { provider: 'groq', pattern: /^gsk_/ },
+    { provider: 'gemini', pattern: /^AIza/ },
+    // OpenAI: classic `sk-...` and new project keys `sk-proj-...`,
+    // excluding the Anthropic / OpenRouter prefixes above.
+    { provider: 'openai', pattern: /^sk-(?!ant-|or-)/ },
+];
+/**
+ * Sanitize a pasted API key: trim whitespace/newlines and strip
+ * surrounding quotes (users often paste keys with extra characters).
+ */
+export function sanitizeKey(raw) {
+    let key = raw.trim();
+    // Strip matching surrounding quotes ("key", 'key', `key`)
+    while (key.length >= 2 && `"'\``.includes(key[0]) && key[0] === key[key.length - 1]) {
+        key = key.slice(1, -1).trim();
+    }
+    return key;
+}
+/**
+ * Detect the provider for a (sanitized) API key.
+ *
+ * Returns the provider id when exactly one pattern matches.
+ * Returns `null` when zero or multiple patterns match — callers should
+ * fall back to asking the user to pick the provider manually.
+ */
+export function detectProvider(key) {
+    const matches = PROVIDER_PATTERNS.filter(({ pattern }) => pattern.test(key));
+    return matches.length === 1 ? matches[0].provider : null;
+}

package/dist/providers/index.js

@@ -0,0 +1,37 @@
+/**
+ * Provider factory: builds the right streaming client for a given
+ * provider id + API key.
+ */
+import { PROVIDER_INFO } from './types.js';
+import { createAnthropicProvider } from './anthropic.js';
+import { createOpenAICompatProvider } from './openai-compat.js';
+export { detectProvider, sanitizeKey, PROVIDER_PATTERNS } from './detect.js';
+export { PROVIDER_INFO, ProviderError } from './types.js';
+/** Base URLs for the OpenAI-compatible providers. */
+const BASE_URLS = {
+    openai: 'https://api.openai.com/v1',
+    openrouter: 'https://openrouter.ai/api/v1',
+    groq: 'https://api.groq.com/openai/v1',
+    // Gemini's OpenAI-compatibility endpoint
+    gemini: 'https://generativelanguage.googleapis.com/v1beta/openai',
+};
+export function createProvider(id, apiKey, model) {
+    const resolvedModel = model ?? PROVIDER_INFO[id].defaultModel;
+    if (id === 'anthropic') {
+        return createAnthropicProvider(apiKey, resolvedModel);
+    }
+    const extraHeaders = id === 'openrouter'
+        ? {
+            // OpenRouter attribution headers (optional but recommended)
+            'HTTP-Referer': 'https://github.com/Elomami1976/vexi',
+            'X-Title': 'Vexi',
+        }
+        : undefined;
+    return createOpenAICompatProvider({
+        id,
+        baseUrl: BASE_URLS[id],
+        apiKey,
+        model: resolvedModel,
+        extraHeaders,
+    });
+}