@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/commands/headless-slash.js

@@ -55,6 +55,18 @@ export async function executeHeadlessSlashToken(token, args, allow, ctx = {}) {
     if (ctx.client)
         handler.setCodeBuddyClient(ctx.client);
     try {
+        if (ctx.goalSessionKey && (token === '__GOAL__' || token === '__SUBGOAL__')) {
+            const { handleGoal, handleSubgoal } = await import('./handlers/goal-handler.js');
+            const result = token === '__GOAL__'
+                ? await handleGoal(args, { sessionKey: ctx.goalSessionKey, client: ctx.client ?? null })
+                : await handleSubgoal(args, { sessionKey: ctx.goalSessionKey });
+            return {
+                handled: result.handled,
+                output: result.entry?.content,
+                prompt: result.prompt,
+                passToAI: result.passToAI,
+            };
+        }
         const result = await handler.handleCommand(token, args, [token, ...args].join(" "));
         return {
             handled: result.handled,

package/dist/commands/llm-provider-resolution.d.ts

@@ -6,9 +6,11 @@
  * provider + the `PROVIDERS` map (paid keys), so a machine running on
  * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
  * exit even though the rest of Code Buddy — including the autonomous
- * daemon — runs fine there. This resolver keeps the legacy path first
- * (backward compatible) and falls back to {@link detectProviderFromEnv}
- * (ollama / chatgpt-oauth / env-detected providers) when either:
+ * daemon — runs fine there. This resolver keeps the legacy path for
+ * ambient paid-key defaults, but honors explicit local / ChatGPT
+ * subscription model choices before a cloud key can hijack them. It
+ * falls back to {@link detectProviderFromEnv} (ollama / chatgpt-oauth /
+ * env-detected providers) when either:
  *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
  *   - the legacy path found no key.
  */

package/dist/commands/llm-provider-resolution.js

@@ -6,58 +6,69 @@
  * provider + the `PROVIDERS` map (paid keys), so a machine running on
  * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
  * exit even though the rest of Code Buddy — including the autonomous
- * daemon — runs fine there. This resolver keeps the legacy path first
- * (backward compatible) and falls back to {@link detectProviderFromEnv}
- * (ollama / chatgpt-oauth / env-detected providers) when either:
+ * daemon — runs fine there. This resolver keeps the legacy path for
+ * ambient paid-key defaults, but honors explicit local / ChatGPT
+ * subscription model choices before a cloud key can hijack them. It
+ * falls back to {@link detectProviderFromEnv} (ollama / chatgpt-oauth /
+ * env-detected providers) when either:
  *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
  *   - the legacy path found no key.
  */
 import { getSettingsManager } from '../utils/settings-manager.js';
 import { detectProviderFromEnv } from '../utils/provider-detector.js';
-import { PROVIDERS } from './provider.js';
+import { inferProvider } from '../config/resolve-model.js';
+import { hasCodexCredentials } from '../providers/codex-oauth.js';
+import { resolveProviderFromCatalog } from '../providers/provider-catalog.js';
+import { PROVIDERS, resolveProviderCommandKey } from './provider.js';
 export function resolveCommandProvider(options = {}) {
+    const settingsManager = getSettingsManager();
+    const settings = settingsManager.loadUserSettings();
+    const configuredModel = options.explicitModel || settingsManager.getCurrentModel();
     const detectFirst = Boolean(process.env.CODEBUDDY_PROVIDER);
     if (detectFirst) {
         const detected = fromEnvDetection(options.explicitModel);
         if (detected)
             return detected;
     }
-    const settingsManager = getSettingsManager();
-    const settings = settingsManager.loadUserSettings();
+    const explicitLocal = resolveExplicitOllamaModel(configuredModel);
+    if (explicitLocal)
+        return explicitLocal;
+    const explicitChatGpt = resolveExplicitChatGptModel(configuredModel);
+    if (explicitChatGpt)
+        return explicitChatGpt;
     const currentProviderKey = settings.provider || 'grok';
-    const providerInfo = PROVIDERS[currentProviderKey];
-    let apiKey = process.env[providerInfo?.envVar || ''] || '';
-    if (!apiKey && currentProviderKey === 'grok')
-        apiKey = process.env.XAI_API_KEY || '';
-    if (!apiKey && currentProviderKey === 'gemini')
-        apiKey = process.env.GOOGLE_API_KEY || '';
-    if (!apiKey) {
-        apiKey =
-            process.env.GROK_API_KEY ||
-                process.env.ANTHROPIC_API_KEY ||
-                process.env.OPENAI_API_KEY ||
-                process.env.GOOGLE_API_KEY ||
-                '';
+    const providerInfoKey = resolveProviderCommandKey(currentProviderKey) || currentProviderKey;
+    const providerInfo = PROVIDERS[providerInfoKey];
+    if (providerInfo) {
+        const configuredProvider = resolveProviderFromCatalog({
+            providerOverride: providerInfo.providerId,
+            hasChatGptOAuth: hasCodexCredentials(),
+            requireConfigured: providerInfo.authMode === 'api-key',
+        });
+        if (configuredProvider) {
+            return {
+                apiKey: configuredProvider.apiKey,
+                baseURL: configuredProvider.baseURL,
+                model: configuredModel || configuredProvider.defaultModel,
+                providerLabel: configuredProvider.provider,
+            };
+        }
     }
-    if (apiKey) {
-        const providerEnvBaseURL = {
-            grok: process.env.GROK_BASE_URL,
-            claude: process.env.ANTHROPIC_BASE_URL,
-            openai: process.env.OPENAI_BASE_URL,
-            gemini: process.env.GEMINI_BASE_URL,
-        };
+    const ambientProvider = resolveProviderFromCatalog({
+        hasChatGptOAuth: hasCodexCredentials(),
+        requireConfigured: true,
+    });
+    if (ambientProvider) {
         return {
-            apiKey,
-            baseURL: providerEnvBaseURL[currentProviderKey] || providerInfo?.baseURL,
-            model: options.explicitModel ||
-                settingsManager.getCurrentModel() ||
-                providerInfo?.defaultModel,
-            providerLabel: providerInfo?.name || currentProviderKey,
+            apiKey: ambientProvider.apiKey,
+            baseURL: ambientProvider.baseURL,
+            model: configuredModel || ambientProvider.defaultModel,
+            providerLabel: ambientProvider.provider,
         };
     }
     // Legacy path found nothing — fall back to env detection (local
     // Ollama, ChatGPT OAuth, …) so a $0 local machine can still run.
-    return fromEnvDetection(options.explicitModel);
+    return fromEnvDetection(configuredModel);
 }
 function fromEnvDetection(explicitModel) {
     const detected = detectProviderFromEnv();
@@ -70,4 +81,47 @@ function fromEnvDetection(explicitModel) {
         providerLabel: detected.provider,
     };
 }
+function resolveExplicitOllamaModel(explicitModel) {
+    const model = explicitModel?.trim();
+    if (!model || !isLocalOllamaModel(model))
+        return null;
+    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 {
+        apiKey: 'ollama',
+        baseURL: host,
+        model,
+        providerLabel: 'ollama',
+    };
+}
+function isLocalOllamaModel(model) {
+    const normalized = model.trim().toLowerCase();
+    return inferProvider(normalized) === 'ollama' || normalized.startsWith('devstral-small-2');
+}
+function resolveExplicitChatGptModel(explicitModel) {
+    const model = explicitModel?.trim();
+    if (!model || !isChatGptSubscriptionModel(model))
+        return null;
+    const detected = detectProviderFromEnv();
+    if (detected?.provider !== 'chatgpt')
+        return null;
+    return {
+        apiKey: detected.apiKey,
+        baseURL: detected.baseURL,
+        model,
+        providerLabel: detected.provider,
+    };
+}
+function isChatGptSubscriptionModel(model) {
+    const m = model.trim().toLowerCase();
+    return (m === 'gpt-5.2' ||
+        m === 'gpt-5.5' ||
+        m.startsWith('gpt-5.5-') ||
+        m.includes('-codex') ||
+        m === 'codex-1' ||
+        m.startsWith('codex-mini'));
+}
 //# sourceMappingURL=llm-provider-resolution.js.map

package/dist/commands/ollama.d.ts

@@ -0,0 +1,25 @@
+export interface OllamaStatus {
+    baseUrl: string;
+    reachable: boolean;
+    version: string | null;
+    models: string[];
+    error: string | null;
+}
+export interface OllamaUpdatePlan {
+    supported: boolean;
+    platform: NodeJS.Platform;
+    repoRoot: string;
+    scriptPath: string;
+    scriptUrl: string;
+    command?: string;
+    args?: string[];
+    message: string;
+}
+export declare function normalizeOllamaBaseUrl(rawUrl?: string): string;
+export declare function fetchOllamaStatus(baseUrl?: string): Promise<OllamaStatus>;
+export declare function buildOllamaUpdatePlan(options: {
+    platform?: NodeJS.Platform;
+    repoRoot: string;
+    scriptUrl?: string;
+}): OllamaUpdatePlan;
+export declare function runOllamaUpdatePlan(plan: OllamaUpdatePlan): Promise<void>;

package/dist/commands/ollama.js

@@ -0,0 +1,100 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+export function normalizeOllamaBaseUrl(rawUrl) {
+    const value = (rawUrl || 'http://localhost:11434').trim();
+    const withoutV1 = value.replace(/\/v1\/?$/, '');
+    return withoutV1.replace(/\/+$/, '');
+}
+export async function fetchOllamaStatus(baseUrl) {
+    const normalizedBaseUrl = normalizeOllamaBaseUrl(baseUrl);
+    const apiBase = `${normalizedBaseUrl}/api`;
+    try {
+        const [versionResponse, tagsResponse] = await Promise.all([
+            fetch(`${apiBase}/version`, { signal: AbortSignal.timeout(5000) }),
+            fetch(`${apiBase}/tags`, { signal: AbortSignal.timeout(5000) }),
+        ]);
+        const versionJson = (await versionResponse.json());
+        const tagsJson = (await tagsResponse.json());
+        return {
+            baseUrl: normalizedBaseUrl,
+            reachable: versionResponse.ok && tagsResponse.ok,
+            version: typeof versionJson.version === 'string' ? versionJson.version : null,
+            models: Array.isArray(tagsJson.models)
+                ? tagsJson.models
+                    .map((model) => (typeof model.name === 'string' ? model.name : null))
+                    .filter((name) => Boolean(name))
+                : [],
+            error: versionResponse.ok && tagsResponse.ok ? null : `HTTP ${versionResponse.status}/${tagsResponse.status}`,
+        };
+    }
+    catch (error) {
+        return {
+            baseUrl: normalizedBaseUrl,
+            reachable: false,
+            version: null,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function buildOllamaUpdatePlan(options) {
+    const platform = options.platform ?? process.platform;
+    const repoRoot = resolve(options.repoRoot);
+    const scriptPath = resolve(repoRoot, 'scripts', 'update-ollama-windows.ps1');
+    const scriptUrl = options.scriptUrl ?? 'https://ollama.com/install.ps1';
+    const supported = platform === 'win32';
+    if (!supported) {
+        return {
+            supported,
+            platform,
+            repoRoot,
+            scriptPath,
+            scriptUrl,
+            message: 'Ollama update automation is implemented for Windows. Use the official install script on this platform.',
+        };
+    }
+    const command = 'powershell';
+    const args = [
+        '-ExecutionPolicy',
+        'Bypass',
+        '-File',
+        scriptPath,
+        '-InstallerScriptUrl',
+        scriptUrl,
+    ];
+    return {
+        supported,
+        platform,
+        repoRoot,
+        scriptPath,
+        scriptUrl,
+        command,
+        args,
+        message: `Windows update script ready: ${scriptPath}`,
+    };
+}
+export async function runOllamaUpdatePlan(plan) {
+    if (!plan.supported || !plan.command || !plan.args) {
+        throw new Error(plan.message);
+    }
+    if (!existsSync(plan.scriptPath)) {
+        throw new Error(`Missing Ollama update script: ${plan.scriptPath}`);
+    }
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(plan.command, plan.args, {
+            stdio: 'inherit',
+            cwd: plan.repoRoot,
+            shell: false,
+        });
+        child.once('error', rejectPromise);
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            rejectPromise(new Error(`Ollama update script exited with code ${code ?? 'unknown'}`));
+        });
+    });
+}
+//# sourceMappingURL=ollama.js.map

package/dist/commands/provider.d.ts

@@ -4,13 +4,18 @@
  * CLI commands for managing AI providers (Claude, ChatGPT, Grok, Gemini)
  */
 import { Command } from 'commander';
+import { type RuntimeProviderCatalogEntry, type RuntimeProviderId } from '../providers/provider-catalog.js';
 interface ProviderInfo {
     name: string;
     envVar: string;
+    envVars: string[];
     models: string[];
     defaultModel: string;
     baseURL?: string;
+    providerId: RuntimeProviderId;
+    authMode: RuntimeProviderCatalogEntry['authMode'];
 }
 export declare const PROVIDERS: Record<string, ProviderInfo>;
 export declare function createProviderCommand(): Command;
+export declare function resolveProviderCommandKey(provider: string): string | null;
 export default createProviderCommand;

package/dist/commands/provider.js

@@ -7,61 +7,85 @@ import { Command } from 'commander';
 import { logger } from "../utils/logger.js";
 import { getSettingsManager } from '../utils/settings-manager.js';
 import { hasCodexCredentials } from '../providers/codex-oauth.js';
-export const PROVIDERS = {
-    grok: {
-        name: 'Grok (xAI)',
-        envVar: 'GROK_API_KEY',
-        models: ['grok-4-1-fast', 'grok-4-latest', 'grok-4-fast', 'grok-code-fast-1', 'grok-3-latest', 'grok-3-fast', 'grok-3-mini'],
-        defaultModel: 'grok-3-fast',
-        baseURL: 'https://api.x.ai/v1',
-    },
-    claude: {
-        name: 'Claude (Anthropic)',
-        envVar: 'ANTHROPIC_API_KEY',
-        models: [
-            'claude-sonnet-4-20250514',
-            'claude-opus-4-20250514',
-            'claude-3-5-sonnet-latest',
-            'claude-3-5-haiku-latest',
-            'claude-3-opus-latest',
-        ],
-        defaultModel: 'claude-sonnet-4-20250514',
-    },
-    openai: {
-        name: 'ChatGPT (OpenAI)',
-        envVar: 'OPENAI_API_KEY',
-        models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1', 'o1-mini', 'o3-mini'],
-        defaultModel: 'gpt-4o',
-        baseURL: 'https://api.openai.com/v1',
-    },
-    chatgpt: {
-        name: 'ChatGPT (OAuth)',
-        envVar: 'CODEBUDDY_CHATGPT_OAUTH',
-        models: ['gpt-5.5'],
-        defaultModel: 'gpt-5.5',
-        baseURL: 'https://chatgpt.com/backend-api/codex',
-    },
-    gemini: {
-        name: 'Gemini (Google)',
-        envVar: 'GOOGLE_API_KEY',
-        models: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
-        defaultModel: 'gemini-2.5-flash',
-        baseURL: 'https://generativelanguage.googleapis.com/v1beta',
-    },
+import { findRuntimeProvider, getPluginNativeRuntimeProviderCatalog, getProviderEnvSummary, getRuntimeProviderCatalog, isProviderConfigured, resolvePluginRuntimeProvider, } from '../providers/provider-catalog.js';
+const PROVIDER_COMMAND_KEYS = {
+    chatgpt: 'chatgpt',
+    ollama: 'ollama',
+    'ollama-cloud': 'ollama-cloud',
+    lmstudio: 'lmstudio',
+    grok: 'grok',
+    gemini: 'gemini',
+    openai: 'openai',
+    anthropic: 'claude',
+    mistral: 'mistral',
+    groq: 'groq',
+    together: 'together',
+    fireworks: 'fireworks',
+    openrouter: 'openrouter',
+    novita: 'novita',
+    zai: 'zai',
+    'kimi-coding': 'kimi-coding',
+    'kimi-coding-cn': 'kimi-coding-cn',
+    arcee: 'arcee',
+    gmi: 'gmi',
+    minimax: 'minimax',
+    'minimax-cn': 'minimax-cn',
+    alibaba: 'alibaba',
+    'alibaba-coding-plan': 'alibaba-coding-plan',
+    kilocode: 'kilocode',
+    xiaomi: 'xiaomi',
+    'tencent-tokenhub': 'tencent-tokenhub',
+    'opencode-zen': 'opencode-zen',
+    'opencode-go': 'opencode-go',
+    deepseek: 'deepseek',
+    huggingface: 'huggingface',
+    nvidia: 'nvidia',
+    stepfun: 'stepfun',
+    vllm: 'vllm',
+    custom: 'custom',
+    azure: 'azure',
+    bedrock: 'bedrock',
+    copilot: 'copilot',
 };
+export const PROVIDERS = Object.fromEntries(getRuntimeProviderCatalog()
+    .filter((entry) => entry.runtimeSupport === 'direct')
+    .map((entry) => {
+    const key = PROVIDER_COMMAND_KEYS[entry.id];
+    return [
+        key,
+        {
+            name: entry.label,
+            envVar: getProviderEnvSummary(entry),
+            envVars: entry.id === 'chatgpt'
+                ? ['CODEBUDDY_CHATGPT_OAUTH']
+                : [...entry.apiKeyEnvKeys, ...entry.baseUrlEnvKeys],
+            models: entry.models,
+            defaultModel: entry.defaultModel,
+            baseURL: entry.defaultBaseURL,
+            providerId: entry.id,
+            authMode: entry.authMode,
+        },
+    ];
+}));
 function getConfiguredProviders() {
     const configured = [];
     for (const [key, info] of Object.entries(PROVIDERS)) {
-        const hasKey = process.env[info.envVar] ||
-            (key === 'grok' && process.env.XAI_API_KEY) ||
-            (key === 'gemini' && process.env.GEMINI_API_KEY) ||
-            (key === 'chatgpt' && hasCodexCredentials());
-        if (hasKey) {
+        const entry = findRuntimeProvider(info.providerId);
+        if (entry && isProviderConfigured(entry, process.env, hasCodexCredentials())) {
             configured.push(key);
         }
     }
     return configured;
 }
+function getConfiguredPluginNativeProviders() {
+    const configured = [];
+    for (const entry of getPluginNativeRuntimeProviderCatalog()) {
+        if (isProviderConfigured(entry, process.env, hasCodexCredentials())) {
+            configured.push(entry.id);
+        }
+    }
+    return configured;
+}
 function getCurrentProvider() {
     const manager = getSettingsManager();
     const settings = manager.loadUserSettings();
@@ -90,7 +114,7 @@ function setCurrentModel(model) {
 }
 export function createProviderCommand() {
     const provider = new Command('provider')
-        .description('Manage AI providers (Claude, ChatGPT, Grok, Gemini)');
+        .description('Manage AI providers');
     // List providers
     provider
         .command('list')
@@ -98,7 +122,8 @@ export function createProviderCommand() {
         .description('List available AI providers')
         .action(() => {
         const configured = getConfiguredProviders();
-        const current = getCurrentProvider();
+        const configuredPluginProviders = getConfiguredPluginNativeProviders();
+        const current = resolveProviderCommandKey(getCurrentProvider()) || getCurrentProvider();
         console.log('\nAvailable AI Providers:\n');
         for (const [key, info] of Object.entries(PROVIDERS)) {
             const isConfigured = configured.includes(key);
@@ -111,7 +136,21 @@ export function createProviderCommand() {
             console.log(`     Models: ${info.models.slice(0, 3).join(', ')}${info.models.length > 3 ? '...' : ''}`);
             console.log('');
         }
-        if (configured.length === 0) {
+        const pluginProviders = getPluginNativeRuntimeProviderCatalog();
+        if (pluginProviders.length > 0) {
+            console.log('Plugin-native providers (available through bundled transports):\n');
+            for (const entry of pluginProviders) {
+                const status = configuredPluginProviders.includes(entry.id) ? '✅' : '❌';
+                const runtime = resolvePluginRuntimeProvider(entry.id);
+                console.log(`  ${status} ${entry.label}`);
+                console.log(`     Key: ${PROVIDER_COMMAND_KEYS[entry.id]}`);
+                console.log(`     Env: ${getProviderEnvSummary(entry)}`);
+                console.log(`     Transport: ${runtime?.pluginId ?? 'bundled plugin'}`);
+                console.log(`     Models: ${entry.models.slice(0, 3).join(', ')}${entry.models.length > 3 ? '...' : ''}`);
+                console.log('');
+            }
+        }
+        if (configured.length === 0 && configuredPluginProviders.length === 0) {
             console.log('⚠️  No providers configured. Set an API key environment variable.');
             console.log('   Example: export ANTHROPIC_API_KEY="your-key"');
         }
@@ -124,11 +163,12 @@ export function createProviderCommand() {
         .action(() => {
         const current = getCurrentProvider();
         const model = getCurrentModel();
-        const info = PROVIDERS[current];
+        const key = resolveProviderCommandKey(current) || current;
+        const info = PROVIDERS[key];
         console.log(`\nActive Provider: ${info?.name || current}`);
         console.log(`Model: ${model || info?.defaultModel || 'default'}`);
         const configured = getConfiguredProviders();
-        if (!configured.includes(current)) {
+        if (!configured.includes(key)) {
             console.log(`\n⚠️  Warning: ${info?.envVar || 'API key'} not set`);
         }
     });
@@ -139,8 +179,8 @@ export function createProviderCommand() {
         .description('Set the active AI provider')
         .option('-m, --model <model>', 'Also set the model')
         .action((providerKey, options) => {
-        const key = providerKey.toLowerCase();
-        if (!PROVIDERS[key]) {
+        const key = resolveProviderCommandKey(providerKey);
+        if (!key || !PROVIDERS[key]) {
             logger.error(`❌ Unknown provider: ${providerKey}`);
             logger.error(`   Available: ${Object.keys(PROVIDERS).join(', ')}`);
             process.exit(1);
@@ -167,8 +207,8 @@ export function createProviderCommand() {
         .command('models [provider]')
         .description('List available models for a provider')
         .action((providerKey) => {
-        const key = (providerKey || getCurrentProvider()).toLowerCase();
-        if (!PROVIDERS[key]) {
+        const key = resolveProviderCommandKey(providerKey || getCurrentProvider());
+        if (!key || !PROVIDERS[key]) {
             logger.error(`❌ Unknown provider: ${providerKey}`);
             process.exit(1);
         }
@@ -197,5 +237,16 @@ export function createProviderCommand() {
     });
     return provider;
 }
+export function resolveProviderCommandKey(provider) {
+    const normalized = provider.toLowerCase();
+    if (PROVIDERS[normalized])
+        return normalized;
+    const entry = findRuntimeProvider(normalized);
+    if (!entry)
+        return null;
+    if (entry.runtimeSupport !== 'direct')
+        return null;
+    return PROVIDER_COMMAND_KEYS[entry.id] ?? null;
+}
 export default createProviderCommand;
 //# sourceMappingURL=provider.js.map