mod8-cli 0.2.0

package/dist/input/files.js

@@ -0,0 +1,49 @@
+import { promises as fs } from 'fs';
+import { resolve, isAbsolute } from 'path';
+import { homedir } from 'os';
+const MAX_FILE_BYTES = 100_000;
+/**
+ * Find @<path> references in a prompt and load the matching files.
+ * - Strips trailing punctuation (.,;:!?)
+ * - Expands ~ and resolves relative paths against cwd
+ * - Refuses files larger than 100KB
+ * - Returns one entry per reference (with content or error message)
+ */
+export async function resolveFileRefs(prompt) {
+    const matches = [...prompt.matchAll(/@([^\s]+)/g)];
+    const seen = new Set();
+    const results = [];
+    for (const m of matches) {
+        let pathSpec = m[1].replace(/[.,;:!?]+$/, '');
+        if (!pathSpec || seen.has(pathSpec))
+            continue;
+        seen.add(pathSpec);
+        let resolved = pathSpec;
+        if (resolved.startsWith('~/')) {
+            resolved = homedir() + resolved.slice(1);
+        }
+        else if (!isAbsolute(resolved)) {
+            resolved = resolve(process.cwd(), resolved);
+        }
+        try {
+            const stat = await fs.stat(resolved);
+            if (!stat.isFile()) {
+                results.push({ path: pathSpec, error: 'not a regular file' });
+                continue;
+            }
+            if (stat.size > MAX_FILE_BYTES) {
+                results.push({
+                    path: pathSpec,
+                    error: `too large (${stat.size} bytes; limit ${MAX_FILE_BYTES})`,
+                });
+                continue;
+            }
+            const content = await fs.readFile(resolved, 'utf8');
+            results.push({ path: pathSpec, content });
+        }
+        catch {
+            results.push({ path: pathSpec, error: 'not found' });
+        }
+    }
+    return results;
+}

package/dist/input/stdin.js

@@ -0,0 +1,14 @@
+/**
+ * Read all stdin into a string. Returns undefined when stdin is a TTY (no piped input).
+ */
+export async function readStdin() {
+    if (process.stdin.isTTY)
+        return undefined;
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    if (chunks.length === 0)
+        return undefined;
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,115 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { getKey } from '../storage/keys.js';
+import { priceFor } from './pricing.js';
+// Per decision 6: use latest stable. Current Sonnet is 4.6 (was 4.5 in original spec).
+const DEFAULT_MODEL = 'claude-sonnet-4-6';
+async function buildClient() {
+    // Env var wins (standard CLI convention). Fall back to keys.json.
+    const apiKey = process.env.ANTHROPIC_API_KEY ?? (await getKey('anthropic'));
+    if (!apiKey) {
+        throw new Error('No Anthropic key configured. Run: mod8 keys set anthropic, or set ANTHROPIC_API_KEY.');
+    }
+    return { client: new Anthropic({ apiKey }), model: DEFAULT_MODEL };
+}
+export const anthropicProvider = {
+    id: 'anthropic',
+    defaultModel: DEFAULT_MODEL,
+    async call(prompt, opts = {}) {
+        const { client } = await buildClient();
+        const model = opts.model ?? process.env.MOD8_ANTHROPIC_MODEL ?? DEFAULT_MODEL;
+        const start = Date.now();
+        const res = await client.messages.create({
+            model,
+            max_tokens: opts.maxTokens ?? 1024,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const latencyMs = Date.now() - start;
+        const text = res.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
+        const inputTokens = res.usage?.input_tokens ?? 0;
+        const outputTokens = res.usage?.output_tokens ?? 0;
+        const actualModel = res.model ?? model;
+        return {
+            text,
+            inputTokens,
+            outputTokens,
+            costUsd: priceFor(actualModel, inputTokens, outputTokens),
+            latencyMs,
+            model: actualModel,
+        };
+    },
+    async *stream(prompt, opts = {}) {
+        const { client } = await buildClient();
+        const model = opts.model ?? process.env.MOD8_ANTHROPIC_MODEL ?? DEFAULT_MODEL;
+        const start = Date.now();
+        const ms = client.messages.stream({
+            model,
+            max_tokens: opts.maxTokens ?? 1024,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        for await (const event of ms) {
+            if (event.type === 'content_block_delta' &&
+                event.delta.type === 'text_delta') {
+                yield { type: 'text', delta: event.delta.text };
+            }
+        }
+        const final = await ms.finalMessage();
+        const latencyMs = Date.now() - start;
+        const inputTokens = final.usage.input_tokens;
+        const outputTokens = final.usage.output_tokens;
+        const actualModel = final.model ?? model;
+        yield {
+            type: 'done',
+            usage: {
+                inputTokens,
+                outputTokens,
+                latencyMs,
+                model: actualModel,
+                costUsd: priceFor(actualModel, inputTokens, outputTokens),
+            },
+        };
+    },
+};
+/**
+ * Multi-turn streaming chat against Anthropic with a system prompt and full
+ * message history. Used by the chat REPL (host + work modes).
+ *
+ * Throws on abort (signal aborted) so the caller can detect cancellation.
+ */
+export async function* streamAnthropicChat(opts) {
+    const apiKey = process.env.ANTHROPIC_API_KEY ?? (await getKey('anthropic'));
+    if (!apiKey) {
+        throw new Error('No Anthropic key configured. Run: mod8 keys set anthropic, or set ANTHROPIC_API_KEY.');
+    }
+    const client = new Anthropic({ apiKey });
+    const start = Date.now();
+    const ms = client.messages.stream({
+        model: opts.model,
+        max_tokens: opts.maxTokens ?? 4096,
+        system: opts.system,
+        messages: opts.messages,
+    }, { signal: opts.signal });
+    for await (const event of ms) {
+        if (event.type === 'content_block_delta' &&
+            event.delta.type === 'text_delta') {
+            yield { type: 'text', delta: event.delta.text };
+        }
+    }
+    const final = await ms.finalMessage();
+    const latencyMs = Date.now() - start;
+    const inputTokens = final.usage.input_tokens;
+    const outputTokens = final.usage.output_tokens;
+    const actualModel = final.model ?? opts.model;
+    yield {
+        type: 'done',
+        usage: {
+            inputTokens,
+            outputTokens,
+            latencyMs,
+            model: actualModel,
+            costUsd: priceFor(actualModel, inputTokens, outputTokens),
+        },
+    };
+}

package/dist/providers/displayName.js

@@ -0,0 +1,25 @@
+/**
+ * Resolve the short display name shown in chat banners and the work-mode
+ * system prompt's "you are X" line.  Single source of truth so that the
+ * host system prompt, the chat speaker block, and the work system prompt
+ * all agree on what to call a provider.
+ *
+ * Rules:
+ *   - Anthropic always renders as "claude" — that's the canonical brand.
+ *   - For everything else: prefer the user's configured display name when
+ *     it's short and clean (no parens), otherwise fall back to the id.
+ *
+ * Examples:
+ *   anthropic + "Anthropic (Claude)"     → "claude"
+ *   openai    + "OpenAI (GPT)"           → "openai"     (parens → id)
+ *   openai    + "codex"                  → "codex"      (custom name kept)
+ *   deepseek  + "DeepSeek"               → "DeepSeek"   (no parens, kept)
+ */
+export function workerNameFor(id, configuredName) {
+    if (id === 'anthropic')
+        return 'claude';
+    if (configuredName && !/[()]/.test(configuredName) && configuredName.length <= 32) {
+        return configuredName;
+    }
+    return id;
+}

package/dist/providers/errorHints.js

@@ -0,0 +1,175 @@
+/**
+ * Per-error-kind diagnostic explainer.
+ *
+ * Old design: one generic provider hint regardless of error.  Result was
+ * misleading guidance — a 403 "project denied" for Google was followed by
+ * the generic "free-tier quota / billing / regions" tip, which doesn't
+ * match what's actually wrong.
+ *
+ * New design: combine the structured ErrorKind from `diagnose()` with the
+ * provider's id to produce three pieces:
+ *
+ *   - short      — single-line summary used as the error transcript entry
+ *                  (always quotes the raw provider message + HTTP code)
+ *   - long       — explanation + provider-specific fix bullets
+ *   - suggestion — short tip used by the warn / auto-fallback banners
+ *
+ * The raw provider message is ALWAYS preserved so the user can search for
+ * it if our diagnosis is wrong.  We never replace a structured message
+ * with a generic blanket — generic only fires for kind='other' (truly
+ * unknown errors).
+ */
+import { diagnose } from '../util/errors.js';
+const PROVIDER_URLS = {
+    anthropic: {
+        billing: 'https://console.anthropic.com/settings/billing',
+        keys: 'https://console.anthropic.com/settings/keys',
+    },
+    openai: {
+        billing: 'https://platform.openai.com/billing',
+        keys: 'https://platform.openai.com/api-keys',
+    },
+    google: {
+        billing: 'https://console.cloud.google.com/billing',
+        keys: 'https://aistudio.google.com/app/apikey',
+    },
+    groq: {
+        billing: 'https://console.groq.com/settings/billing',
+        keys: 'https://console.groq.com/keys',
+    },
+    xai: {
+        billing: 'https://console.x.ai/team/default',
+        keys: 'https://console.x.ai/team/default/api-keys',
+    },
+    deepseek: {
+        billing: 'https://platform.deepseek.com/usage',
+        keys: 'https://platform.deepseek.com/api_keys',
+    },
+    mistral: {
+        billing: 'https://console.mistral.ai/billing',
+        keys: 'https://console.mistral.ai/api-keys',
+    },
+    openrouter: {
+        billing: 'https://openrouter.ai/credits',
+        keys: 'https://openrouter.ai/keys',
+    },
+    together: {
+        billing: 'https://api.together.ai/settings/billing',
+        keys: 'https://api.together.ai/settings/api-keys',
+    },
+};
+function urlsFor(providerId) {
+    return PROVIDER_URLS[providerId] ?? { billing: '(provider dashboard)', keys: '(provider dashboard)' };
+}
+function quote(text) {
+    return text ? `'${text}'` : '';
+}
+function rejectionLine(providerId, diag, verb) {
+    const code = diag.code ? ` (HTTP ${diag.code})` : '';
+    const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+    return `${providerId} ${verb}${code}${tail}`;
+}
+export function explainError(err, providerId) {
+    const diag = diagnose(err);
+    const urls = urlsFor(providerId);
+    switch (diag.kind) {
+        case 'auth': {
+            const code = diag.code ?? 401;
+            const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+            return {
+                kind: diag.kind,
+                short: `${providerId} rejected the API key (HTTP ${code})${tail}`,
+                long: `API key rejected. Verify the key is correct, not revoked, and not for the wrong product (e.g. a ChatGPT subscription is NOT an OpenAI API key).\n` +
+                    `Possible fixes:\n` +
+                    `- Paste a new key right here ("add a key") and mod8 will save it inline\n` +
+                    `- Or rotate at ${urls.keys}`,
+                suggestion: `Type 'mod8' to switch back, or paste a new key to replace this one.`,
+            };
+        }
+        case 'forbidden': {
+            return {
+                kind: diag.kind,
+                short: rejectionLine(providerId, diag, 'rejected the request'),
+                long: `${providerId} blocked the request at the project / account level — common after rapid key creation, region restrictions, or unusual activity.\n` +
+                    `Possible fixes:\n` +
+                    `- Wait 24h for auto-review\n` +
+                    `- Create a new project in your provider console and a new key in it (${urls.keys})\n` +
+                    `- Contact ${providerId} support`,
+                suggestion: `This is a project-level block, not a key issue. Switch back to mod8 with 'mod8'.`,
+            };
+        }
+        case 'rate-limit': {
+            const code = diag.code ?? 429;
+            const delay = diag.retryDelaySeconds;
+            const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+            const delayHint = delay ? ` (retry in ${delay}s)` : '';
+            return {
+                kind: diag.kind,
+                short: `${providerId} rate-limited the request (HTTP ${code})${delayHint}${tail}`,
+                long: delay
+                    ? `Rate limited. The provider asked us to wait ${delay} seconds before retrying. ` +
+                        `If this persists, you may be on a low-tier limit — see ${urls.billing}.`
+                    : `Rate limited. Wait a few seconds and retry. ` +
+                        `If this persists, you may be on a free or low-tier plan with tight limits — see ${urls.billing}.`,
+                suggestion: delay
+                    ? `Type 'mod8' to switch back, or wait ${delay}s and retry.`
+                    : `Type 'mod8' to switch back, or wait a few seconds and retry.`,
+            };
+        }
+        case 'no-credit': {
+            return {
+                kind: diag.kind,
+                short: rejectionLine(providerId, diag, 'reports insufficient credit'),
+                long: `Out of credit / billing not active. Top up at ${urls.billing}.\n` +
+                    `Note: free-tier quotas can take ~10 minutes to activate after a new key is created — if you JUST created the key, wait and retry.`,
+                suggestion: `Type 'mod8' to switch back, or top up at ${urls.billing}.`,
+            };
+        }
+        case 'server': {
+            return {
+                kind: diag.kind,
+                short: rejectionLine(providerId, diag, 'returned a server error'),
+                long: `${providerId} is having issues right now. Try again in a few minutes; if it persists, check the provider's status page.`,
+                suggestion: `Type 'mod8' to switch back, or retry shortly.`,
+            };
+        }
+        case 'network': {
+            const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+            return {
+                kind: diag.kind,
+                short: `couldn't reach ${providerId}${tail}`,
+                long: `Network error. Check your internet connection — DNS, VPN, or firewall.`,
+                suggestion: `Type 'mod8' to switch back. Check your connection and retry.`,
+            };
+        }
+        case 'timeout': {
+            const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+            return {
+                kind: diag.kind,
+                short: `request to ${providerId} timed out${tail}`,
+                long: `The request took too long. The provider may be overloaded or your network is slow.`,
+                suggestion: `Type 'mod8' to switch back, or retry shortly.`,
+            };
+        }
+        case 'model': {
+            const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+            return {
+                kind: diag.kind,
+                short: `${providerId} model not available${tail}`,
+                long: `The configured model isn't available for this account. Set \`MOD8_${providerId.toUpperCase()}_MODEL\` to override, or pick a different provider.`,
+                suggestion: `Type 'mod8' to switch back, or switch to a different model.`,
+            };
+        }
+        default: {
+            // 'other' — generic fallback.  We do NOT pretend to diagnose; just
+            // surface the raw message and give a minimal escape suggestion.
+            const tail = diag.rawMessage ? `: ${quote(diag.rawMessage)}` : '';
+            return {
+                kind: diag.kind,
+                short: `${providerId} failed${tail}`,
+                long: '',
+                suggestion: `Type 'mod8' to switch back.`,
+            };
+        }
+    }
+}