@phuetz/code-buddy 1.1.0 → 1.2.0

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

package/dist/commands/spec-next.js

@@ -163,7 +163,8 @@ function pickStory(store, projectId, explicitId) {
         }
         return story;
     }
-    const approved = store.listStories(projectId, 'approved'); // oldest first (createdAt)
+    const approved = store.listStories(projectId, 'approved')
+        .sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
     const first = approved[0];
     if (!first) {
         console.log('No approved stories. Approve one with: buddy spec story approve <id> --by <name>');

package/dist/commands/spec-plan.js

@@ -18,7 +18,7 @@ import { Command } from 'commander';
 import { getSpecStore } from '../spec/spec-store.js';
 import { startSpecPlan, advanceSpecPlan, runSpecPlanToCompletion, } from '../spec/spec-plan-runner.js';
 import { getSettingsManager } from '../utils/settings-manager.js';
-import { PROVIDERS } from './provider.js';
+import { resolveCommandProvider } from './llm-provider-resolution.js';
 /**
  * Build the `plan` sub-command group.
  * @param llmProvider override for tests; defaults to a real CodeBuddyClient.
@@ -150,23 +150,12 @@ function printAdvanceResult(store, projectId, result) {
 // ============================================================================
 async function defaultLlmProvider() {
     const settingsManager = getSettingsManager();
-    const userSettings = settingsManager.loadUserSettings();
-    const providerKey = userSettings.provider || 'grok';
-    const providerInfo = PROVIDERS[providerKey];
-    let apiKey = process.env[providerInfo?.envVar || ''] || '';
-    if (!apiKey) {
-        apiKey =
-            process.env.GROK_API_KEY ||
-                process.env.ANTHROPIC_API_KEY ||
-                process.env.OPENAI_API_KEY ||
-                process.env.GEMINI_API_KEY ||
-                '';
-    }
-    if (!apiKey)
+    const resolved = resolveCommandProvider();
+    if (!resolved)
         throw new Error('No API key configured. Run: buddy onboard');
     const { CodeBuddyClient } = await import('../codebuddy/client.js');
-    const model = settingsManager.getCurrentModel() || providerInfo?.defaultModel;
-    const client = new CodeBuddyClient(apiKey, model, providerInfo?.baseURL);
+    const model = settingsManager.getCurrentModel() || resolved.model;
+    const client = new CodeBuddyClient(resolved.apiKey, model, resolved.baseURL);
     return async (system, user) => {
         const response = await client.chat([
             { role: 'system', content: system },

package/dist/commands/tunnel.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createTunnelCommand(): Command;

package/dist/commands/tunnel.js

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import { TunnelManager } from '../server/tunnel-manager.js';
+import { logger } from '../utils/logger.js';
+export function createTunnelCommand() {
+    const cmd = new Command('tunnel')
+        .description('Manage ngrok tunnels for the Code Buddy remote gateway');
+    cmd.command('start')
+        .description('Start an ngrok tunnel')
+        .option('-p, --port <number>', 'Port to tunnel to', '3000')
+        .option('--domain <string>', 'Custom ngrok domain')
+        .option('--authtoken <string>', 'ngrok authtoken (or set NGROK_AUTHTOKEN env var)')
+        .option('--server', 'Start the local HTTP server along with the tunnel')
+        .action(async (opts) => {
+        const port = parseInt(opts.port, 10);
+        if (opts.server) {
+            // dynamically import server to start it
+            try {
+                const { startServer } = await import('../server/index.js');
+                await startServer({ port });
+                logger.info(`Local server started on port ${port}`);
+            }
+            catch (error) {
+                logger.error('Failed to start local server', { error });
+                process.exit(1);
+            }
+        }
+        try {
+            const url = await TunnelManager.startTunnel({
+                port,
+                domain: opts.domain,
+                authtoken: opts.authtoken,
+            });
+            console.log(`\nTunnel started successfully!`);
+            console.log(`Forwarding: ${url} -> http://localhost:${port}\n`);
+            // Keep process alive if just tunneling
+            process.on('SIGINT', async () => {
+                await TunnelManager.stopTunnel();
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            console.error('Failed to start tunnel:', error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=tunnel.js.map

package/dist/config/config-resolver.d.ts

@@ -44,9 +44,10 @@ export declare class ConfigResolver extends EventEmitter {
     private resolveFromProfile;
     /**
      * Resolve from environment variables
-     * Priority: Gemini > Grok > OpenAI > Anthropic
+     * Priority comes from the runtime provider catalog.
      */
     private resolveFromEnv;
+    private normalizeDetectedProvider;
     /**
      * Get built-in default configuration
      */

package/dist/config/config-resolver.js

@@ -11,6 +11,7 @@
  */
 import { EventEmitter } from 'events';
 import { logger } from '../utils/logger.js';
+import { detectProviderFromEnv } from '../utils/provider-detector.js';
 import { DEFAULT_PROFILES, DEFAULT_CONNECTION_CONFIG, } from './types.js';
 // ============================================================================
 // Config Resolver
@@ -121,49 +122,16 @@ export class ConfigResolver extends EventEmitter {
     }
     /**
      * Resolve from environment variables
-     * Priority: Gemini > Grok > OpenAI > Anthropic
+     * Priority comes from the runtime provider catalog.
      */
     resolveFromEnv() {
-        // Check Gemini first (preferred)
-        const geminiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
-        if (geminiKey) {
+        const detected = detectProviderFromEnv();
+        if (detected) {
             return {
-                baseURL: 'https://generativelanguage.googleapis.com/v1beta',
-                apiKey: geminiKey,
-                model: process.env.GEMINI_MODEL || 'gemini-2.5-flash',
-                provider: 'gemini',
-                source: 'environment',
-            };
-        }
-        // Check Grok
-        const grokKey = process.env.GROK_API_KEY || process.env.XAI_API_KEY;
-        if (grokKey) {
-            const baseURL = process.env.GROK_BASE_URL || 'https://api.x.ai/v1';
-            return {
-                baseURL,
-                apiKey: grokKey,
-                model: process.env.GROK_MODEL || 'grok-code-fast-1',
-                provider: 'grok',
-                source: 'environment',
-            };
-        }
-        // Check OpenAI
-        if (process.env.OPENAI_API_KEY) {
-            return {
-                baseURL: 'https://api.openai.com/v1',
-                apiKey: process.env.OPENAI_API_KEY,
-                model: process.env.OPENAI_MODEL || 'gpt-4o',
-                provider: 'openai',
-                source: 'environment',
-            };
-        }
-        // Check Anthropic
-        if (process.env.ANTHROPIC_API_KEY) {
-            return {
-                baseURL: 'https://api.anthropic.com/v1',
-                apiKey: process.env.ANTHROPIC_API_KEY,
-                model: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-20250514',
-                provider: 'claude',
+                baseURL: detected.baseURL,
+                apiKey: detected.apiKey,
+                model: detected.defaultModel,
+                provider: this.normalizeDetectedProvider(detected.provider),
                 source: 'environment',
             };
         }
@@ -177,6 +145,13 @@ export class ConfigResolver extends EventEmitter {
             source: 'environment',
         };
     }
+    normalizeDetectedProvider(provider) {
+        if (provider === 'anthropic')
+            return 'claude';
+        if (provider === 'unknown')
+            return 'grok';
+        return provider;
+    }
     /**
      * Get built-in default configuration
      */
@@ -215,6 +190,44 @@ export class ConfigResolver extends EventEmitter {
             return 'together';
         if (urlLower.includes('fireworks.ai'))
             return 'fireworks';
+        if (urlLower.includes('openrouter.ai'))
+            return 'openrouter';
+        if (urlLower.includes('novita.ai'))
+            return 'novita';
+        if (urlLower.includes('z.ai') || urlLower.includes('bigmodel'))
+            return 'zai';
+        if (urlLower.includes('moonshot.ai'))
+            return 'kimi-coding';
+        if (urlLower.includes('moonshot.cn'))
+            return 'kimi-coding-cn';
+        if (urlLower.includes('arcee.ai'))
+            return 'arcee';
+        if (urlLower.includes('gmi-serving.com'))
+            return 'gmi';
+        if (urlLower.includes('minimax.io'))
+            return 'minimax';
+        if (urlLower.includes('minimaxi.com'))
+            return 'minimax-cn';
+        if (urlLower.includes('dashscope') || urlLower.includes('aliyuncs.com'))
+            return 'alibaba';
+        if (urlLower.includes('kilo.ai'))
+            return 'kilocode';
+        if (urlLower.includes('xiaomimimo.com'))
+            return 'xiaomi';
+        if (urlLower.includes('tencentmaas.com'))
+            return 'tencent-tokenhub';
+        if (urlLower.includes('opencode.ai/zen/go'))
+            return 'opencode-go';
+        if (urlLower.includes('opencode.ai/zen'))
+            return 'opencode-zen';
+        if (urlLower.includes('router.huggingface.co') || urlLower.includes('huggingface.co'))
+            return 'huggingface';
+        if (urlLower.includes('api.nvidia.com'))
+            return 'nvidia';
+        if (urlLower.includes('ollama.com'))
+            return 'ollama-cloud';
+        if (urlLower.includes('stepfun.ai'))
+            return 'stepfun';
         // Local providers (by port)
         if (urlLower.includes(':1234'))
             return 'lmstudio';
@@ -393,7 +406,7 @@ export class ConfigResolver extends EventEmitter {
                     };
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // Server not available on this port, try next
                 continue;
             }

package/dist/config/constants.d.ts

@@ -282,10 +282,38 @@ export declare const SUPPORTED_MODELS: {
         readonly maxTokens: 32768;
         readonly provider: "ollama";
     };
+    readonly 'qwen3.5-ctx32k': {
+        readonly maxTokens: 32768;
+        readonly provider: "ollama";
+    };
+    readonly 'qwen3.5:35b': {
+        readonly maxTokens: 32768;
+        readonly provider: "ollama";
+    };
+    readonly 'qwen3.6:27b': {
+        readonly maxTokens: 32768;
+        readonly provider: "ollama";
+    };
+    readonly 'qwen3.6:35b-a3b-q4_K_M': {
+        readonly maxTokens: 32768;
+        readonly provider: "ollama";
+    };
+    readonly 'devstral-small-2': {
+        readonly maxTokens: 131072;
+        readonly provider: "ollama";
+    };
+    readonly 'devstral-small-2:24b-instruct-2512-q4_K_M': {
+        readonly maxTokens: 131072;
+        readonly provider: "ollama";
+    };
     readonly phi3: {
         readonly maxTokens: 4096;
         readonly provider: "ollama";
     };
+    readonly 'gemma4:12b': {
+        readonly maxTokens: 8192;
+        readonly provider: "ollama";
+    };
     readonly gemma2: {
         readonly maxTokens: 8192;
         readonly provider: "ollama";

package/dist/config/constants.js

@@ -149,7 +149,14 @@ export const SUPPORTED_MODELS = {
     'deepseek-coder-v2': { maxTokens: 131072, provider: 'ollama' },
     'qwen2.5': { maxTokens: 32768, provider: 'ollama' },
     'qwen2.5-coder:7b': { maxTokens: 32768, provider: 'ollama' },
+    'qwen3.5-ctx32k': { maxTokens: 32768, provider: 'ollama' },
+    'qwen3.5:35b': { maxTokens: 32768, provider: 'ollama' },
+    'qwen3.6:27b': { maxTokens: 32768, provider: 'ollama' },
+    'qwen3.6:35b-a3b-q4_K_M': { maxTokens: 32768, provider: 'ollama' },
+    'devstral-small-2': { maxTokens: 131072, provider: 'ollama' },
+    'devstral-small-2:24b-instruct-2512-q4_K_M': { maxTokens: 131072, provider: 'ollama' },
     'phi3': { maxTokens: 4096, provider: 'ollama' },
+    'gemma4:12b': { maxTokens: 8192, provider: 'ollama' },
     'gemma2': { maxTokens: 8192, provider: 'ollama' },
     'command-r': { maxTokens: 131072, provider: 'ollama' },
 };