@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/providers/gemini-oauth.js

@@ -8,6 +8,7 @@ import * as os from 'node:os';
 import * as fs from 'node:fs/promises';
 import open from 'open';
 import { logger } from '../utils/logger.js';
+import { readJsonAtomic, writeJsonAtomic } from '../utils/atomic-write.js';
 // Cloud Code First-Party Client ID & Secret
 const OAUTH_CLIENT_ID = process.env.GEMINI_OAUTH_CLIENT_ID || '';
 const OAUTH_CLIENT_SECRET = process.env.GEMINI_OAUTH_CLIENT_SECRET || '';
@@ -52,18 +53,19 @@ export async function getGeminiOauthTokens(forceLogin = false) {
     const credsPath = getCredentialsPath();
     if (!forceLogin) {
         try {
-            const credsRaw = await fs.readFile(credsPath, 'utf-8');
-            const creds = JSON.parse(credsRaw);
+            const creds = await readJsonAtomic(credsPath, null);
+            if (!creds)
+                throw new Error('Gemini credentials are unavailable');
             client.setCredentials(creds);
             // Attempt to get access token to see if it's still valid or can be refreshed
             const { token } = await client.getAccessToken();
             if (token) {
                 // Save the updated credentials if they were refreshed
-                await fs.writeFile(credsPath, JSON.stringify(client.credentials, null, 2));
+                await writeJsonAtomic(credsPath, client.credentials, { mode: 0o600 });
                 return client.credentials;
             }
         }
-        catch (e) {
+        catch (_e) {
             // Ignore read errors or invalid JSON
         }
     }
@@ -104,8 +106,7 @@ export async function getGeminiOauthTokens(forceLogin = false) {
                     });
                     client.setCredentials(tokens);
                     // Save credentials to disk
-                    await fs.mkdir(path.dirname(credsPath), { recursive: true });
-                    await fs.writeFile(credsPath, JSON.stringify(tokens, null, 2), { mode: 0o600 });
+                    await writeJsonAtomic(credsPath, tokens, { mode: 0o600 });
                     res.writeHead(301, { Location: SIGN_IN_SUCCESS_URL });
                     res.end();
                     resolve(tokens);

package/dist/providers/grok-provider.js

@@ -129,7 +129,7 @@ export class GrokProvider extends BaseProvider {
         }
     }
     async getModels() {
-        return ['grok-4-1-fast', 'grok-4-latest', 'grok-4-fast', 'grok-code-fast-1', 'grok-3-latest', 'grok-3-fast', 'grok-3-mini'];
+        return ['grok-4.6', 'grok-4-1-fast', 'grok-4-latest', 'grok-4-fast', 'grok-code-fast-1', 'grok-3-latest', 'grok-3-fast', 'grok-3-mini'];
     }
     getPricing() {
         // Grok pricing per 1M tokens

package/dist/providers/index.d.ts

@@ -18,6 +18,9 @@ export { ADDITIONAL_PROVIDERS, getAdditionalProvider, getProviderForModel, listA
 export type { ProviderConfig as AdditionalProviderConfig } from './additional-providers.js';
 export * from './provider-catalog.js';
 export * from './provider-fallback.js';
+export * from './provider-health.js';
+export * from './provider-failover-policy.js';
+export * from './provider-failover-notify.js';
 export * from './auxiliary-provider.js';
 export { ProviderFallbackChain, getFallbackChain, resetFallbackChain, } from './fallback-chain.js';
 export type { FallbackConfig, ProviderHealth, FallbackChainEvents, } from './fallback-chain.js';

package/dist/providers/index.js

@@ -22,6 +22,9 @@ export { ADDITIONAL_PROVIDERS, getAdditionalProvider, getProviderForModel, listA
 // Hermes-style runtime provider catalog and auxiliary provider routing
 export * from './provider-catalog.js';
 export * from './provider-fallback.js';
+export * from './provider-health.js';
+export * from './provider-failover-policy.js';
+export * from './provider-failover-notify.js';
 export * from './auxiliary-provider.js';
 // Fallback chain
 export { ProviderFallbackChain, getFallbackChain, resetFallbackChain, } from './fallback-chain.js';

package/dist/providers/local-model-resolver.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Local-model resolution for Ollama.
+ *
+ * Fixes the "$0 local" onboarding trap: `CODEBUDDY_PROVIDER=ollama buddy`
+ * used to detect Ollama correctly but then send a stale cloud model id
+ * (`grok-code-fast-1`) as the request model, producing a cryptic
+ * `404 model 'grok-code-fast-1' not found`.
+ *
+ * The resolver probes the tags actually installed on the local Ollama
+ * server and picks a real one (preferring a coding model). If the server
+ * is reachable but empty, or unreachable, callers get a clear, actionable
+ * signal (`ollama pull <model>`) instead of a 404.
+ *
+ * Pure functions (probe is injectable) so the whole thing is unit-testable
+ * without a live Ollama.
+ */
+/** Default coding model advertised during onboarding — the pull hint target. */
+export declare const DEFAULT_OLLAMA_MODEL = "qwen2.5-coder:7b";
+/**
+ * Choose an installed Ollama model without assuming an exact tag.
+ *
+ * Order: an exact match for `requested` → a coding-oriented model
+ * (qwen coder, devstral, codestral, anything "coder"/"code") → the first
+ * installed model. Returns `null` when nothing is installed.
+ */
+export declare function chooseInstalledOllamaModel(models: readonly string[], requested?: string): string | null;
+/** Turn an Ollama base URL (with or without a trailing `/v1`) into its `/api/tags` endpoint. */
+export declare function ollamaTagsUrl(baseURL: string): string;
+/**
+ * Fetch the installed model tags from a local Ollama server.
+ *
+ * Returns `null` when the server can't be reached or returns junk (so the
+ * caller can distinguish "Ollama is down" from "no models installed"), or a
+ * (possibly empty) list of tag names when it responds.
+ */
+export declare function fetchOllamaTags(baseURL: string, options?: {
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<string[] | null>;
+export interface OllamaModelResolution {
+    /** The chosen installed model, or `null` when none is usable. */
+    model: string | null;
+    /** Whether the server was reachable (null tags ⇒ unreachable). */
+    reachable: boolean;
+    /** Number of installed models seen (0 when unreachable). */
+    installedCount: number;
+}
+/**
+ * Resolve the model to send to a local Ollama provider: probe the server,
+ * then pick an installed tag (preferring `requested`, then a coder model).
+ */
+export declare function resolveInstalledOllamaModel(options: {
+    baseURL: string;
+    requested?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<OllamaModelResolution>;
+/**
+ * Build the clear, actionable message shown when no local model can be
+ * resolved — the honest replacement for the cryptic Grok 404.
+ */
+export declare function buildOllamaPullHint(options: {
+    baseURL: string;
+    reachable: boolean;
+    requested?: string;
+}): string;

package/dist/providers/local-model-resolver.js

@@ -0,0 +1,128 @@
+/**
+ * Local-model resolution for Ollama.
+ *
+ * Fixes the "$0 local" onboarding trap: `CODEBUDDY_PROVIDER=ollama buddy`
+ * used to detect Ollama correctly but then send a stale cloud model id
+ * (`grok-code-fast-1`) as the request model, producing a cryptic
+ * `404 model 'grok-code-fast-1' not found`.
+ *
+ * The resolver probes the tags actually installed on the local Ollama
+ * server and picks a real one (preferring a coding model). If the server
+ * is reachable but empty, or unreachable, callers get a clear, actionable
+ * signal (`ollama pull <model>`) instead of a 404.
+ *
+ * Pure functions (probe is injectable) so the whole thing is unit-testable
+ * without a live Ollama.
+ */
+const OLLAMA_TAGS_TIMEOUT_MS = 2_000;
+/** Default coding model advertised during onboarding — the pull hint target. */
+export const DEFAULT_OLLAMA_MODEL = 'qwen2.5-coder:7b';
+/**
+ * Choose an installed Ollama model without assuming an exact tag.
+ *
+ * Order: an exact match for `requested` → a coding-oriented model
+ * (qwen coder, devstral, codestral, anything "coder"/"code") → the first
+ * installed model. Returns `null` when nothing is installed.
+ */
+export function chooseInstalledOllamaModel(models, requested) {
+    const usable = models.map((model) => model.trim()).filter(Boolean);
+    const requestedModel = requested?.trim();
+    if (requestedModel) {
+        const exact = usable.find((model) => model.toLowerCase() === requestedModel.toLowerCase());
+        if (exact)
+            return exact;
+    }
+    for (const pattern of [/qwen.*coder/i, /devstral/i, /codestral/i, /coder/i, /code/i]) {
+        const match = usable.find((model) => pattern.test(model));
+        if (match)
+            return match;
+    }
+    return usable[0] ?? null;
+}
+/** Turn an Ollama base URL (with or without a trailing `/v1`) into its `/api/tags` endpoint. */
+export function ollamaTagsUrl(baseURL) {
+    let host = (baseURL || 'http://localhost:11434').trim();
+    if (!/^https?:\/\//i.test(host))
+        host = `http://${host}`;
+    host = host.replace(/\/+$/, '').replace(/\/v1$/i, '');
+    return `${host}/api/tags`;
+}
+function parseOllamaModels(value) {
+    if (!value || typeof value !== 'object')
+        return [];
+    const models = value.models;
+    if (!Array.isArray(models))
+        return [];
+    return models
+        .map((entry) => {
+        const candidate = entry.name ?? entry.model;
+        return typeof candidate === 'string' ? candidate : null;
+    })
+        .filter((model) => Boolean(model));
+}
+/**
+ * Fetch the installed model tags from a local Ollama server.
+ *
+ * Returns `null` when the server can't be reached or returns junk (so the
+ * caller can distinguish "Ollama is down" from "no models installed"), or a
+ * (possibly empty) list of tag names when it responds.
+ */
+export async function fetchOllamaTags(baseURL, options = {}) {
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== 'function')
+        return null;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? OLLAMA_TAGS_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(ollamaTagsUrl(baseURL), { signal: controller.signal });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        return parseOllamaModels(body);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Resolve the model to send to a local Ollama provider: probe the server,
+ * then pick an installed tag (preferring `requested`, then a coder model).
+ */
+export async function resolveInstalledOllamaModel(options) {
+    const tags = await fetchOllamaTags(options.baseURL, {
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+    });
+    if (tags === null) {
+        return { model: null, reachable: false, installedCount: 0 };
+    }
+    return {
+        model: chooseInstalledOllamaModel(tags, options.requested),
+        reachable: true,
+        installedCount: tags.length,
+    };
+}
+/**
+ * Build the clear, actionable message shown when no local model can be
+ * resolved — the honest replacement for the cryptic Grok 404.
+ */
+export function buildOllamaPullHint(options) {
+    const model = options.requested?.trim() || DEFAULT_OLLAMA_MODEL;
+    if (!options.reachable) {
+        return [
+            `Ollama not reachable at ${options.baseURL}.`,
+            'Start it, then install a model:',
+            '  ollama serve            # if it is not already running',
+            `  ollama pull ${model}`,
+        ].join('\n');
+    }
+    return [
+        'No Ollama model is installed for the local ($0) path.',
+        'Install one, then re-run:',
+        `  ollama pull ${model}`,
+    ].join('\n');
+}
+//# sourceMappingURL=local-model-resolver.js.map

package/dist/providers/model-egress.d.ts

@@ -0,0 +1,8 @@
+export type ModelEgress = 'local' | 'lan' | 'cloud';
+/**
+ * Classify the real inference destination. A cloud subscription CLI remains
+ * cloud even though its child process runs on the local machine.
+ */
+export declare function classifyModelEgress(baseURL: string | undefined, providerIsLocal: boolean): ModelEgress;
+/** Provider-aware guard for CLIs whose process is local but inference is not. */
+export declare function classifyProviderModelEgress(provider: string | undefined, baseURL: string | undefined, providerIsLocal: boolean): ModelEgress;

package/dist/providers/model-egress.js

@@ -0,0 +1,62 @@
+/**
+ * Providers whose PROCESS/endpoint is local but whose inference is not: the
+ * subscription CLIs (child process on the box, model in the cloud) and the
+ * OmniRoute gateway (loopback proxy that fans out to cloud free tiers).
+ */
+const CLOUD_SUBPROCESS_PROVIDERS = new Set([
+    'agy-cli',
+    'gemini-cli',
+    'chatgpt',
+    'chatgpt-oauth',
+    'grok-oauth',
+    'omniroute',
+]);
+function isPrivateIpv4(hostname) {
+    const parts = hostname.split('.').map(Number);
+    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+        return false;
+    }
+    const [a, b] = parts;
+    return a === 10 ||
+        a === 127 ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 168) ||
+        (a === 169 && b === 254);
+}
+/**
+ * Classify the real inference destination. A cloud subscription CLI remains
+ * cloud even though its child process runs on the local machine.
+ */
+export function classifyModelEgress(baseURL, providerIsLocal) {
+    if (!providerIsLocal)
+        return 'cloud';
+    if (!baseURL)
+        return 'local';
+    try {
+        const hostname = new URL(baseURL).hostname.toLowerCase().replace(/^\[|\]$/g, '');
+        if (hostname === 'localhost' || hostname === '::1' || hostname === '127.0.0.1') {
+            return 'local';
+        }
+        if (isPrivateIpv4(hostname) ||
+            hostname.startsWith('fc') ||
+            hostname.startsWith('fd') ||
+            hostname.startsWith('fe80') ||
+            hostname.endsWith('.local') ||
+            hostname === 'host.docker.internal' ||
+            !hostname.includes('.')) {
+            return 'lan';
+        }
+        return 'cloud';
+    }
+    catch {
+        return 'cloud';
+    }
+}
+/** Provider-aware guard for CLIs whose process is local but inference is not. */
+export function classifyProviderModelEgress(provider, baseURL, providerIsLocal) {
+    const normalized = provider?.trim().toLowerCase().replace(/_/g, '-');
+    if (normalized && CLOUD_SUBPROCESS_PROVIDERS.has(normalized))
+        return 'cloud';
+    return classifyModelEgress(baseURL, providerIsLocal);
+}
+//# sourceMappingURL=model-egress.js.map

package/dist/providers/model-provider-compat.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Model ↔ provider compatibility for the CLI model resolver (`loadModel`).
+ *
+ * A model saved in settings (or left over from a previous provider) must never
+ * be sent to a backend that cannot serve it: the result is a cryptic 404 on the
+ * very first turn. Gateways (OpenRouter, OmniRoute, Bedrock, Azure, Copilot,
+ * Together, …) legitimately re-serve first-party families, so they keep the
+ * permissive default; only first-party backends are strict.
+ */
+export declare const LOCAL_RUNTIME_PROVIDERS: ReadonlySet<string>;
+/** A model id that only makes sense on a hosted cloud backend (never a local Ollama tag). */
+export declare function looksLikeCloudModel(model: string): boolean;
+export declare function isModelCompatibleWithProvider(model: string, provider?: string): boolean;

package/dist/providers/model-provider-compat.js

@@ -0,0 +1,49 @@
+import { isChatGptSubscriptionModel } from './chatgpt-models.js';
+/**
+ * Model ↔ provider compatibility for the CLI model resolver (`loadModel`).
+ *
+ * A model saved in settings (or left over from a previous provider) must never
+ * be sent to a backend that cannot serve it: the result is a cryptic 404 on the
+ * very first turn. Gateways (OpenRouter, OmniRoute, Bedrock, Azure, Copilot,
+ * Together, …) legitimately re-serve first-party families, so they keep the
+ * permissive default; only first-party backends are strict.
+ */
+export const LOCAL_RUNTIME_PROVIDERS = new Set(['ollama', 'lmstudio', 'vllm']);
+/** A model id that only makes sense on a hosted cloud backend (never a local Ollama tag). */
+export function looksLikeCloudModel(model) {
+    return /grok|^gpt-|^o[1-9]|codex|claude|gemini/i.test(model);
+}
+/**
+ * First-party model families and the only first-party provider that serves
+ * them directly. A slug from one family sent to ANOTHER first-party backend
+ * (e.g. a stale `grok-code-fast-1` default against NVIDIA NIM, Anthropic or
+ * Gemini) can only 404.
+ */
+const FIRST_PARTY_MODEL_FAMILIES = [
+    [/grok/i, 'grok'],
+    [/^claude-/i, 'anthropic'],
+    [/^gemini-/i, 'gemini'],
+    [/^(?:gpt-|o[1-9]\b|codex)/i, 'openai'],
+];
+/** Backends that serve exactly one vendor's catalog (never a cross-vendor gateway). */
+const FIRST_PARTY_PROVIDERS = new Set([
+    'grok', 'anthropic', 'gemini', 'openai', 'chatgpt', 'nvidia', 'mistral', 'groq', 'cerebras', 'deepseek',
+]);
+export function isModelCompatibleWithProvider(model, provider) {
+    if (!provider)
+        return true;
+    const looksGrok = /grok/i.test(model);
+    if (provider === 'grok')
+        return looksGrok;
+    if (provider === 'chatgpt')
+        return isChatGptSubscriptionModel(model) && !looksGrok;
+    if (LOCAL_RUNTIME_PROVIDERS.has(provider))
+        return !looksLikeCloudModel(model);
+    if (FIRST_PARTY_PROVIDERS.has(provider)) {
+        const family = FIRST_PARTY_MODEL_FAMILIES.find(([pattern]) => pattern.test(model));
+        if (family && family[1] !== provider)
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=model-provider-compat.js.map

package/dist/providers/provider-catalog.d.ts

@@ -8,12 +8,13 @@
  */
 export type ProviderApiMode = 'openai-compatible' | 'gemini-native' | 'chatgpt-responses' | 'azure-openai' | 'aws-bedrock' | 'copilot-chat';
 export type ProviderAuthMode = 'api-key' | 'oauth' | 'local' | 'none';
-export type RuntimeProviderId = 'chatgpt' | 'ollama' | 'ollama-cloud' | 'lmstudio' | 'grok' | 'gemini' | 'openai' | 'anthropic' | 'mistral' | 'groq' | 'together' | 'fireworks' | 'openrouter' | 'novita' | 'zai' | 'kimi-coding' | 'kimi-coding-cn' | 'arcee' | 'gmi' | 'minimax' | 'minimax-cn' | 'alibaba' | 'alibaba-coding-plan' | 'kilocode' | 'xiaomi' | 'tencent-tokenhub' | 'opencode-zen' | 'opencode-go' | 'deepseek' | 'huggingface' | 'nvidia' | 'stepfun' | 'vllm' | 'custom' | 'azure' | 'bedrock' | 'copilot';
+export type RuntimeProviderId = 'chatgpt' | 'agy-cli' | 'ollama' | 'lemonade' | 'ollama-cloud' | 'lmstudio' | 'grok' | 'gemini' | 'openai' | 'anthropic' | 'mistral' | 'groq' | 'together' | 'fireworks' | 'openrouter' | 'novita' | 'zai' | 'kimi-coding' | 'kimi-coding-cn' | 'arcee' | 'gmi' | 'minimax' | 'minimax-cn' | 'alibaba' | 'alibaba-coding-plan' | 'kilocode' | 'xiaomi' | 'tencent-tokenhub' | 'opencode-zen' | 'opencode-go' | 'deepseek' | 'huggingface' | 'nvidia' | 'omniroute' | 'ai21' | 'ant-ling' | 'cerebras' | 'cohere' | 'deepinfra' | 'featherless-ai' | 'friendliai' | 'hyperbolic' | 'inception' | 'inference-net' | 'internlm' | 'liquid' | 'longcat' | 'modelscope' | 'nscale' | 'openadapter' | 'pioneer' | 'reka' | 'sambanova' | 'sarvam' | 'scaleway' | 'tokenrouter' | 'typhoon' | 'zenmux' | 'stepfun' | 'vllm' | 'custom' | 'azure' | 'bedrock' | 'copilot';
 export type ProviderRuntimeSupport = 'direct' | 'plugin-native';
 export interface RuntimeProviderCatalogEntry {
     id: RuntimeProviderId;
     aliases?: string[];
     label: string;
+    freeTier?: string;
     authMode: ProviderAuthMode;
     apiMode: ProviderApiMode;
     runtimeSupport: ProviderRuntimeSupport;
@@ -67,4 +68,6 @@ export declare function resolveProviderFromCatalog(options?: ProviderCatalogReso
 export declare function resolvePluginRuntimeProvider(idOrAlias: string, env?: EnvLike): ResolvedPluginRuntimeProvider | null;
 export declare function getProviderEnvSummary(entry: RuntimeProviderCatalogEntry): string;
 export declare function isProviderConfigured(entry: RuntimeProviderCatalogEntry, env?: EnvLike, hasChatGptOAuth?: boolean): boolean;
+/** Entries at or above this priority (imported free tiers) are opt-in only: excluded from env auto-detection. */
+export declare const AUTO_DETECT_PRIORITY_CEILING = 300;
 export {};