@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/utils/provider-detector.js

@@ -5,93 +5,35 @@
  * a Code Buddy session. Pure function (no side effects beyond stat/read
  * on the OAuth file) so it's unit-testable.
  *
- * Priority order:
+ * Priority order is defined in `src/providers/provider-catalog.ts`:
  *   0. CODEBUDDY_PROVIDER override (always wins when set + valid)
  *   1. ChatGPT OAuth credentials present (~/.codebuddy/codex-auth.json)
  *      → explicit "I logged in" act beats ambient env vars
- *   2. OLLAMA_HOST    → ollama (local, free, unlimited)
- *   3. GROK_API_KEY   → grok / OpenAI-compat (incl. xAI)
- *   4. GEMINI/GOOGLE  → gemini
- *   5. OPENAI         → openai
- *   6. ANTHROPIC      → anthropic
+ *   2. Local providers (Ollama / LM Studio / vLLM)
+ *   3. Cloud providers in catalog priority order
  *   else null (no provider available)
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { resolveProviderFromCatalog, } from '../providers/provider-catalog.js';
 export function detectProviderFromEnv() {
-    const override = process.env.CODEBUDDY_PROVIDER?.toLowerCase();
-    // ChatGPT subscription auth — explicit login wins over ambient
-    // env-detected providers. User who ran `buddy login chatgpt` recently
-    // expects subsequent calls to route through their ChatGPT plan, not
-    // get hijacked by an OLLAMA_HOST set in their shell rc weeks ago.
-    if (override === 'chatgpt' || !override) {
-        try {
-            const authPath = path.join(os.homedir(), '.codebuddy', 'codex-auth.json');
-            if (fs.existsSync(authPath)) {
-                const raw = fs.readFileSync(authPath, 'utf-8').trim();
-                const parsed = raw ? JSON.parse(raw) : null;
-                if (parsed?.tokens?.access_token) {
-                    return {
-                        provider: 'chatgpt',
-                        apiKey: 'oauth-chatgpt',
-                        baseURL: 'https://chatgpt.com/backend-api/codex',
-                        defaultModel: process.env.CHATGPT_MODEL || 'gpt-5.5',
-                    };
-                }
-            }
-        }
-        catch {
-            // Malformed auth file or unexpected — fall through.
-        }
-    }
-    if (override === 'ollama' || (!override && process.env.OLLAMA_HOST)) {
-        let host = process.env.OLLAMA_HOST || 'http://localhost:11434';
-        if (!/^https?:\/\//i.test(host))
-            host = `http://${host}`;
-        if (!host.endsWith('/v1'))
-            host = host.replace(/\/+$/, '') + '/v1';
-        return {
-            provider: 'ollama',
-            apiKey: 'ollama',
-            baseURL: host,
-            defaultModel: process.env.GROK_MODEL || process.env.OLLAMA_MODEL || 'qwen2.5-coder:7b',
-        };
-    }
-    if ((override === 'grok' || override === 'xai') ||
-        (!override && (process.env.GROK_API_KEY || process.env.XAI_API_KEY))) {
-        return {
-            provider: 'grok',
-            apiKey: process.env.GROK_API_KEY || process.env.XAI_API_KEY || '',
-            baseURL: process.env.GROK_BASE_URL || 'https://api.x.ai/v1',
-            defaultModel: process.env.GROK_MODEL || 'grok-3-fast',
-        };
-    }
-    if ((override === 'gemini' || override === 'google') ||
-        (!override && (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY))) {
-        return {
-            provider: 'gemini',
-            apiKey: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || '',
-            baseURL: 'https://generativelanguage.googleapis.com/v1beta',
-            defaultModel: process.env.GEMINI_MODEL || 'gemini-2.5-flash',
-        };
-    }
-    if (override === 'openai' || (!override && process.env.OPENAI_API_KEY)) {
-        return {
-            provider: 'openai',
-            apiKey: process.env.OPENAI_API_KEY || '',
-            baseURL: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
-            defaultModel: process.env.OPENAI_MODEL || 'gpt-4o',
-        };
+    return resolveProviderFromCatalog({
+        hasChatGptOAuth: hasChatGptOAuthCredentials(),
+    });
+}
+function hasChatGptOAuthCredentials() {
+    try {
+        const authPath = path.join(os.homedir(), '.codebuddy', 'codex-auth.json');
+        if (!fs.existsSync(authPath))
+            return false;
+        const raw = fs.readFileSync(authPath, 'utf-8').trim();
+        const parsed = raw ? JSON.parse(raw) : null;
+        return Boolean(parsed?.tokens?.access_token);
     }
-    if (override === 'anthropic' || (!override && process.env.ANTHROPIC_API_KEY)) {
-        return {
-            provider: 'anthropic',
-            apiKey: process.env.ANTHROPIC_API_KEY || '',
-            baseURL: 'https://api.anthropic.com/v1',
-            defaultModel: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-20250514',
-        };
+    catch {
+        // Malformed auth file or unexpected — fall through to env providers.
+        return false;
     }
-    return null;
 }
 //# sourceMappingURL=provider-detector.js.map

package/dist/utils/settings-manager.d.ts

@@ -20,6 +20,25 @@ export interface ProjectSettings {
     model?: string;
     mcpServers?: Record<string, unknown>;
     thinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high';
+    goals?: {
+        maxTurns?: number;
+        judgeModel?: string;
+        plannerModel?: string;
+        judgeMaxTokens?: number;
+        judgeTimeoutMs?: number;
+    };
+    /**
+     * Project-instruction context-file loading (the AGENTS.md/CLAUDE.md/GEMINI.md
+     * hierarchy). All fields optional; omitted keys fall back to defaults in
+     * `src/context/instruction-excludes.ts` (`loadContextConfig`).
+     */
+    context?: {
+        fileNames?: string[];
+        maxBytes?: number;
+        jitMaxBytes?: number;
+        importMaxBytes?: number;
+        importMaxDepth?: number;
+    };
 }
 /**
  * Unified settings manager that handles both user-level and project-level settings

package/dist/utils/token-display.d.ts

@@ -22,8 +22,8 @@ export declare function formatTokenUsage(usage: TokenUsageInfo): string;
  * Uses a simple heuristic; for accurate cost tracking use CostTracker.
  *
  * Special-case: returns 0 when `model` indicates a ChatGPT subscription
- * call (`gpt-5.2`, `gpt-5.5*`, `*-codex*`, `codex-1`). Those are billed against
- * the user's flat-fee Plus/Pro plan, NOT per token, so reporting USD
- * spend would be misleading. See `cost-tracker.ts:isChatGptSubscriptionModel`.
+ * call (`gpt-5.2`, `gpt-5.5*`, `*-codex*`, `codex-1`) or a local Ollama /
+ * LM Studio model. Those are not billed per token through Code Buddy, so
+ * reporting USD spend would be misleading.
  */
 export declare function estimateCost(inputTokens: number, outputTokens: number, inputPricePer1k?: number, outputPricePer1k?: number, model?: string): number;

package/dist/utils/token-display.js

@@ -42,12 +42,12 @@ function formatCost(cost) {
  * Uses a simple heuristic; for accurate cost tracking use CostTracker.
  *
  * Special-case: returns 0 when `model` indicates a ChatGPT subscription
- * call (`gpt-5.2`, `gpt-5.5*`, `*-codex*`, `codex-1`). Those are billed against
- * the user's flat-fee Plus/Pro plan, NOT per token, so reporting USD
- * spend would be misleading. See `cost-tracker.ts:isChatGptSubscriptionModel`.
+ * call (`gpt-5.2`, `gpt-5.5*`, `*-codex*`, `codex-1`) or a local Ollama /
+ * LM Studio model. Those are not billed per token through Code Buddy, so
+ * reporting USD spend would be misleading.
  */
 export function estimateCost(inputTokens, outputTokens, inputPricePer1k = 0.003, outputPricePer1k = 0.015, model) {
-    if (model && isChatGptSubscriptionModel(model))
+    if (model && (isChatGptSubscriptionModel(model) || isLocalNoCostModel(model)))
         return 0;
     return (inputTokens / 1000) * inputPricePer1k + (outputTokens / 1000) * outputPricePer1k;
 }
@@ -60,4 +60,22 @@ function isChatGptSubscriptionModel(model) {
         m === 'codex-1' ||
         m.startsWith('codex-mini'));
 }
+function isLocalNoCostModel(model) {
+    const m = model.toLowerCase();
+    return (m === 'ollama' ||
+        m.startsWith('ollama/') ||
+        m === 'lmstudio' ||
+        m === 'local-model' ||
+        m.startsWith('llama') ||
+        m.startsWith('qwen') ||
+        m.startsWith('gemma') ||
+        m.startsWith('phi') ||
+        m.startsWith('codellama') ||
+        m.startsWith('deepseek') ||
+        m.startsWith('command-r') ||
+        m === 'mistral' ||
+        m.startsWith('mistral:') ||
+        m === 'mixtral' ||
+        m.startsWith('mixtral:'));
+}
 //# sourceMappingURL=token-display.js.map

package/dist/wizard/onboarding.d.ts

@@ -4,8 +4,47 @@ export interface OnboardingResult {
     model: string;
     ttsEnabled: boolean;
     ttsProvider?: string;
+    authMode?: OnboardingAuthMode;
+    recommendedNextCommands?: string[];
+}
+export type OnboardingAuthMode = 'oauth' | 'api-key' | 'local';
+export interface OnboardingProviderGuide {
+    id: string;
+    label: string;
+    authMode: OnboardingAuthMode;
+    envVar: string;
+    defaultModel: string;
+    /** Inference base URL — persisted so the chosen provider resolves on the
+     *  next run (the provider strategy in client.ts is picked from baseURL). */
+    baseURL?: string;
+    setupCommand?: string;
+    verifyCommand: string;
+    help: string;
+}
+export interface OnboardingPhase {
+    id: string;
+    title: string;
+    hermesPhase: string;
+    codeBuddyAction: string;
+    successCheck: string;
 }
 export declare const PROVIDER_ENV_MAP: Record<string, string>;
 export declare const PROVIDER_DEFAULT_MODEL: Record<string, string>;
+export declare const PROVIDER_AUTH_MODE: Record<string, OnboardingAuthMode>;
+export declare const PROVIDER_GUIDES: OnboardingProviderGuide[];
+export declare const ONBOARDING_PHASES: OnboardingPhase[];
+/**
+ * Persist the chosen provider so the session works now AND on the next run:
+ *   - provider + baseURL + model → `~/.codebuddy/user-settings.json`
+ *     (loadBaseURL/loadModel read it; the provider strategy is picked from baseURL).
+ *   - an entered API key → encrypted credential store (never plaintext in settings),
+ *     plus `process.env[envVar]` so the current process resolves immediately.
+ *   - ollama → default `OLLAMA_HOST` so auto-detection picks it up.
+ * All writes are best-effort; the wizard summary still prints on failure.
+ */
+export declare function persistProviderSelection(guide: OnboardingProviderGuide, model: string, apiKey: string): Promise<void>;
 export declare function writeConfig(configDir: string, result: OnboardingResult): void;
+export declare function getProviderGuide(provider: string): OnboardingProviderGuide;
+export declare function buildRecommendedNextCommands(result: Pick<OnboardingResult, 'provider' | 'model' | 'apiKey'>): string[];
+export declare function renderOnboardingRoadmap(result?: Pick<OnboardingResult, 'provider' | 'model' | 'apiKey'>): string;
 export declare function runOnboarding(): Promise<OnboardingResult>;