mod8-cli 0.2.0

package/dist/commands/addProvider.js

@@ -0,0 +1,105 @@
+/**
+ * `mod8 add-provider` — interactive flow:
+ *   1. Paste API key.
+ *   2. mod8 detects format from prefix → suggests built-in template if it knows.
+ *   3. User confirms / edits id, display name, base URL, default model.
+ *   4. Provider is saved to providers.json with an auto-assigned palette color.
+ *
+ * Mostly used for non-built-in providers, but also works as a faster path for
+ * registering a known one (no need to remember the exact id).
+ */
+import chalk from 'chalk';
+import { readSecret, readLine, maskKey } from '../util/prompt.js';
+import { detectFromKey, isValidProviderId } from '../providers/registry.js';
+import { setProvider, nextPaletteColor, PROVIDERS_FILE_PATH, } from '../storage/providers.js';
+const API_TYPES = ['anthropic', 'openai-compat', 'gemini'];
+function isApiType(s) {
+    return API_TYPES.includes(s);
+}
+export async function addProviderCommand() {
+    console.log();
+    console.log(chalk.bold('mod8 add-provider'));
+    console.log(chalk.dim('  Paste an API key. mod8 will detect the format and ask anything it can\'t guess.'));
+    console.log();
+    const key = (await readSecret('paste key: ')).trim();
+    if (!key) {
+        console.error(chalk.red('No key entered. Aborted.'));
+        process.exit(1);
+    }
+    const tpl = detectFromKey(key);
+    if (tpl) {
+        console.log();
+        console.log(chalk.green('✓') +
+            ` Looks like ${chalk.bold(tpl.name)} (${tpl.id}, ${tpl.apiType}).`);
+    }
+    else {
+        console.log();
+        console.log(chalk.yellow('?') + ` Haven\'t seen this key format before. Tell me about the provider.`);
+    }
+    const id = await promptId(tpl?.id);
+    const name = await readLine(`display name [${tpl?.name ?? id}]: `, tpl?.name ?? id);
+    const apiType = await promptApiType(tpl?.apiType);
+    const baseUrl = await promptBaseUrl(apiType, tpl?.baseUrl);
+    const defaultModel = await readLine(`default model [${tpl?.defaultModel ?? ''}]: `, tpl?.defaultModel ?? '');
+    if (!defaultModel) {
+        console.error(chalk.red('A default model is required (e.g. "deepseek-chat").'));
+        process.exit(1);
+    }
+    const color = tpl?.color ?? (await nextPaletteColor());
+    const entry = {
+        apiKey: key,
+        apiType,
+        name,
+        defaultModel,
+        color,
+        custom: !tpl,
+    };
+    if (baseUrl)
+        entry.baseUrl = baseUrl;
+    await setProvider(id, entry);
+    console.log();
+    console.log(chalk.green('✓') +
+        ` Saved ${chalk.bold(name)} (${id}) — key ${chalk.dim(maskKey(key))}, color ${chalk.hex(color)('●')}`);
+    console.log(chalk.dim(`  Stored at ${PROVIDERS_FILE_PATH} (mode 0600)`));
+    console.log();
+    console.log(chalk.dim(`  Use it: mod8 -c (or any flag) → not yet; in chat: "ask ${id}" / "use ${id}"`));
+}
+async function promptId(suggested) {
+    while (true) {
+        const id = await readLine(`provider id [${suggested ?? 'lowercase, e.g. "deepseek"'}]: `, suggested ?? '');
+        if (!id) {
+            console.error(chalk.red('  id required (lowercase, letters/digits/dash/underscore).'));
+            continue;
+        }
+        if (!isValidProviderId(id)) {
+            console.error(chalk.red('  invalid id — use lowercase letters, digits, dash, underscore (max 30 chars).'));
+            continue;
+        }
+        return id;
+    }
+}
+async function promptApiType(suggested) {
+    const fallback = suggested ?? 'openai-compat';
+    while (true) {
+        const v = await readLine(`api type (anthropic | openai-compat | gemini) [${fallback}]: `, fallback);
+        if (isApiType(v))
+            return v;
+        console.error(chalk.red(`  must be one of: ${API_TYPES.join(', ')}.`));
+    }
+}
+async function promptBaseUrl(apiType, suggested) {
+    if (apiType === 'anthropic' || apiType === 'gemini')
+        return undefined;
+    while (true) {
+        const v = await readLine(`base URL [${suggested ?? 'https://api.example.com/v1'}]: `, suggested ?? '');
+        if (!v) {
+            console.error(chalk.red('  base URL is required for openai-compat providers.'));
+            continue;
+        }
+        if (!/^https?:\/\//.test(v)) {
+            console.error(chalk.red('  must be http(s):// URL.'));
+            continue;
+        }
+        return v;
+    }
+}

package/dist/commands/all.js

@@ -0,0 +1,158 @@
+import chalk from 'chalk';
+import { getProviderClient } from '../providers/index.js';
+import { formatCost } from '../providers/pricing.js';
+import { getConfig, updateConfig } from '../storage/config.js';
+import { confirm } from '../util/prompt.js';
+import { classifyError } from '../util/errors.js';
+import { configuredProviderIds, resolveConfigured, } from '../storage/providers.js';
+import { templateById } from '../providers/registry.js';
+/**
+ * Resolve which providers `--all` should fan out to.  Order:
+ *   1. Every provider currently configured in providers.json (post-migration)
+ *   2. Plus any of the legacy three (anthropic/openai/google) that have an
+ *      env-var key set, so out-of-the-box `--all` still works for users who
+ *      only export ANTHROPIC_API_KEY etc.
+ *   3. In MOD8_MOCK mode with no configured providers, fall back to the
+ *      original three so existing mock-driven tests keep working.
+ */
+async function resolveAllProviders() {
+    // In MOD8_MOCK mode we always run the legacy three side-by-side, regardless
+    // of which env keys happen to be set, so the mock-driven --all tests are
+    // deterministic and so demos always show three blocks even with an empty
+    // sandbox.
+    if (process.env.MOD8_MOCK === '1') {
+        const ids = ['anthropic', 'openai', 'google'];
+        const out = [];
+        for (const id of ids) {
+            const tpl = templateById(id);
+            out.push({
+                id,
+                entry: {
+                    apiKey: 'mock',
+                    apiType: tpl?.apiType ?? 'openai-compat',
+                    name: tpl?.name ?? id,
+                    defaultModel: tpl?.defaultModel ?? `${id}-mock-1`,
+                    color: tpl?.color ?? '#888888',
+                },
+            });
+        }
+        return out;
+    }
+    const ids = await configuredProviderIds();
+    // Add legacy ids whose env keys are set but who aren't yet stored.
+    for (const legacy of ['anthropic', 'openai', 'google']) {
+        if (!ids.includes(legacy)) {
+            const env = await resolveConfigured(legacy);
+            if (env)
+                ids.push(legacy);
+        }
+    }
+    const out = [];
+    for (const id of ids) {
+        const entry = await resolveConfigured(id);
+        if (entry)
+            out.push({ id, entry });
+        else if (process.env.MOD8_MOCK === '1') {
+            // Synthesize a placeholder so the mock dispatcher still gets called.
+            out.push({
+                id,
+                entry: {
+                    apiKey: 'mock',
+                    apiType: 'openai-compat',
+                    name: id,
+                    defaultModel: `${id}-mock-1`,
+                    color: '#888888',
+                },
+            });
+        }
+    }
+    return out;
+}
+export async function runAll(prompt) {
+    const targets = await resolveAllProviders();
+    if (targets.length === 0) {
+        console.error(chalk.red('mod8: --all has no configured providers.\n') +
+            chalk.dim('  Run mod8 keys set <provider> or mod8 add-provider, then retry.'));
+        process.exit(1);
+    }
+    console.log(chalk.dim(`Running against ${targets.length} providers in parallel…`));
+    const settled = await Promise.allSettled(targets.map(async ({ id }) => {
+        const client = await getProviderClient(id);
+        return client.call(prompt);
+    }));
+    const results = targets.map(({ id, entry }, i) => {
+        const s = settled[i];
+        if (s.status === 'fulfilled') {
+            return { id, label: entry.name, color: entry.color, ok: true, response: s.value };
+        }
+        return {
+            id,
+            label: entry.name,
+            color: entry.color,
+            ok: false,
+            error: classifyError(s.reason, id),
+        };
+    });
+    let totalTokens = 0;
+    let totalCost = 0;
+    let totalLatencyMs = 0;
+    let okCount = 0;
+    for (const r of results) {
+        renderBlock(r);
+        if (r.ok && r.response) {
+            totalTokens += r.response.inputTokens + r.response.outputTokens;
+            totalCost += r.response.costUsd;
+            totalLatencyMs = Math.max(totalLatencyMs, r.response.latencyMs);
+            okCount++;
+        }
+    }
+    console.log();
+    console.log(chalk.dim('─'.repeat(60)));
+    const seconds = (totalLatencyMs / 1000).toFixed(2);
+    const summary = `${okCount}/${results.length} ok · ${totalTokens.toLocaleString()} tok · ${seconds}s · ${formatCost(totalCost)}`;
+    console.log(`${chalk.bold('Total:')}  ${chalk.dim(summary)}`);
+}
+function renderBlock(result) {
+    const color = chalk.hex(result.color);
+    console.log();
+    if (result.ok && result.response) {
+        const r = result.response;
+        const seconds = (r.latencyMs / 1000).toFixed(2);
+        const tokens = (r.inputTokens + r.outputTokens).toLocaleString();
+        console.log(`${color('▎')} ${chalk.bold(result.label)}  ${chalk.dim(r.model)}  ${chalk.dim(`${tokens} tok · ${seconds}s · ${formatCost(r.costUsd)}`)}`);
+        console.log(r.text.trimEnd());
+    }
+    else {
+        console.log(`${color('▎')} ${chalk.bold(result.label)}  ${chalk.red('✗ failed')}`);
+        console.log(chalk.red(`  ${result.error ?? 'Unknown error'}`));
+    }
+}
+/**
+ * Gate first --all use behind explicit consent.
+ * Must be called BEFORE stdin is consumed (the prompt needs the TTY/pipe to be readable).
+ */
+export async function ensureAllConsent({ stdinPiped }) {
+    if (process.env.MOD8_AUTO_CONFIRM === '1')
+        return;
+    const config = await getConfig();
+    if (config.allConsent)
+        return;
+    if (stdinPiped) {
+        console.error(chalk.red('mod8: --all needs first-run confirmation, but stdin is piped.'));
+        console.error(chalk.dim('  Run mod8 --all interactively once, or set MOD8_AUTO_CONFIRM=1 to accept non-interactively.'));
+        process.exit(1);
+    }
+    console.log();
+    console.log(chalk.yellow('First time using --all:'));
+    console.log(chalk.dim(`  This sends your prompt to every configured provider in parallel.\n` +
+        `  Cost depends on prompt length and the providers' rates.\n` +
+        '  This confirmation only appears once.'));
+    console.log();
+    const ok = await confirm(chalk.bold('Continue? [y/N]: '));
+    if (!ok) {
+        console.log(chalk.dim('Cancelled.'));
+        process.exit(0);
+    }
+    await updateConfig({ allConsent: true });
+    console.log();
+}