@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/commands/skills-cli/index.js

@@ -688,6 +688,129 @@ export function registerSkillsCommands(program) {
             console.log(`  ! ${error}`);
         }
     });
+    // ── Import external skills (Hermes / a repository), firewall-gated ──────────
+    skills
+        .command('import')
+        .description('Import external skills from a directory or a named source (firewall-gated)')
+        .option('--dir <path>', 'import from a local directory')
+        .option('--source <name>', 'import from a named source (see `skills sources`)')
+        .option('--apply', 'install (default is a dry run)')
+        .option('--include-review', "also import skills the firewall flags as 'review'")
+        .option('--overwrite', 'overwrite an already-imported skill')
+        .option('--category <c>', 'only import skills whose path contains this')
+        .option('--json', 'output JSON')
+        .action(async (opts) => {
+        const { importSkills } = await import('../../skills/skill-importer.js');
+        const { getSource, resolveSourceDir } = await import('../../skills/skill-sources.js');
+        let dir;
+        let label = 'import';
+        if (opts.dir) {
+            dir = opts.dir.startsWith('~') ? path.join(os.homedir(), opts.dir.slice(1)) : opts.dir;
+            label = path.basename(dir);
+        }
+        else if (opts.source) {
+            const src = getSource(opts.source);
+            if (!src) {
+                console.log(`Unknown source: ${opts.source} (see \`buddy skills sources list\`)`);
+                return;
+            }
+            dir = resolveSourceDir(src);
+            label = src.name;
+        }
+        else {
+            console.log('Specify --dir <path> or --source <name>.');
+            return;
+        }
+        const fs = await import('fs');
+        if (!fs.existsSync(dir)) {
+            console.log(`Directory not found: ${dir}`);
+            return;
+        }
+        const report = importSkills(dir, {
+            source: label,
+            dryRun: opts.apply !== true,
+            includeReview: opts.includeReview === true,
+            overwrite: opts.overwrite === true,
+            ...(opts.category ? { category: opts.category } : {}),
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ source: label, report }, null, 2));
+            return;
+        }
+        console.log(report.dryRun ? `Dry run (use --apply to install) — "${label}"` : `Imported from "${label}"`);
+        console.log(`  ${report.dryRun ? 'would import' : 'imported'}: ${report.imported.length} · quarantined: ${report.quarantined.length} · review: ${report.review.length} · skipped: ${report.skipped.length}`);
+        if (report.quarantined.length) {
+            console.log('  ⚠️  quarantined by firewall:');
+            for (const q of report.quarantined.slice(0, 15))
+                console.log(`     - ${q.sourcePath}`);
+        }
+        if (report.imported.length) {
+            console.log(`  ✓ ${report.dryRun ? 'would import' : 'imported'}:`);
+            for (const s of report.imported.slice(0, 30))
+                console.log(`     - ${s.name}`);
+        }
+    });
+    skills
+        .command('imported')
+        .description('List imported skills (with provenance + pinned status)')
+        .option('--json', 'output JSON')
+        .action(async (opts) => {
+        const fs = await import('fs');
+        const { parseSkillFile } = await import('../../skills/parser.js');
+        const root = path.join(os.homedir(), '.codebuddy', 'skills', 'managed');
+        const items = [];
+        if (fs.existsSync(root)) {
+            for (const e of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!e.isDirectory() || !e.name.startsWith('imported-'))
+                    continue;
+                const md = path.join(root, e.name, 'SKILL.md');
+                if (!fs.existsSync(md))
+                    continue;
+                let pinned = false;
+                let source;
+                try {
+                    const sk = parseSkillFile(fs.readFileSync(md, 'utf-8'), md, 'managed');
+                    pinned = sk.metadata.pinned === true;
+                    source = sk.metadata.source;
+                }
+                catch { /* ignore */ }
+                items.push({ name: e.name, pinned, ...(source ? { source } : {}) });
+            }
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ imported: items }, null, 2));
+            return;
+        }
+        console.log(items.length ? items.map((s) => `  ${s.pinned ? '📌' : '  '} ${s.name}${s.source ? ` (source: ${s.source})` : ''}`).join('\n') : 'No imported skills');
+    });
+    const sources = skills.command('sources').description('Manage skill sources (the import referential)');
+    sources
+        .command('list')
+        .option('--json', 'output JSON')
+        .action(async (opts) => {
+        const { listSources } = await import('../../skills/skill-sources.js');
+        const list = listSources();
+        if (opts.json) {
+            console.log(JSON.stringify({ sources: list }, null, 2));
+            return;
+        }
+        console.log(list.length ? list.map((s) => `  ${s.name}  [${s.type}]  ${s.location}`).join('\n') : 'No skill sources configured');
+    });
+    sources
+        .command('add <name> <location>')
+        .description('Register a skill source (a local dir or a git url)')
+        .option('--type <type>', "'dir' or 'git'")
+        .action(async (name, location, opts) => {
+        const { addSource } = await import('../../skills/skill-sources.js');
+        const src = addSource(name, location, opts.type);
+        console.log(`Added source ${src.name} [${src.type}] → ${src.location}`);
+    });
+    sources
+        .command('remove <name>')
+        .action(async (name) => {
+        const { removeSource } = await import('../../skills/skill-sources.js');
+        console.log(removeSource(name) ? `Removed source ${name}` : `No such source: ${name}`);
+    });
 }
 async function toggleSkill(name, enabled, opts) {
     const { getSkillsHub } = await import('../../skills/hub.js');

package/dist/commands/slash/builtin-commands.js

@@ -42,7 +42,7 @@ const coreCommands = [
     },
     {
         name: 'init',
-        description: 'Initialize .codebuddy directory with templates',
+        description: 'Scaffold .codebuddy, then analyze the repo and write a tailored AGENTS.md (use `--fast` for the deterministic template only)',
         prompt: '__INIT_GROK__',
         filePath: '',
         isBuiltin: true

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/companion/percepts.js

@@ -1,4 +1,4 @@
-import { appendFile, mkdir, readFile, stat } from 'fs/promises';
+import { appendFile, mkdir, readFile, rename, stat } from 'fs/promises';
 import * as crypto from 'crypto';
 import * as path from 'path';
 const DEFAULT_RECENT_LIMIT = 10;
@@ -138,6 +138,16 @@ export async function recordCompanionPercept(input, options = {}) {
         }
         : percept;
     await mkdir(path.dirname(storePath), { recursive: true });
+    // Rotate when large (the disk-guard lesson, mirroring dreams.jsonl): a long-running
+    // companion appends a percept per event, so cap growth + keep one backup.
+    try {
+        const info = await stat(storePath);
+        if (info.size > 1024 * 1024)
+            await rename(storePath, `${storePath}.1`);
+    }
+    catch {
+        /* no file yet */
+    }
     await appendFile(storePath, `${JSON.stringify(storedPercept)}\n`, 'utf8');
     return percept;
 }

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' },
 };