beercan 0.6.12 → 0.6.14

package/dist/cli.js

@@ -77,34 +77,72 @@ async function runSetup() {
     }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     try {
-        // Required
         const mask = (v) => v ? v.slice(0, 12) + "..." : "";
-        console.log(chalk.bold("1. Anthropic API Key") + chalk.red(" (required)"));
-        console.log(chalk.dim("   Get one at: https://console.anthropic.com/\n"));
-        const apiKey = (await prompt(rl, chalk.cyan(`   ANTHROPIC_API_KEY [${mask(existing.ANTHROPIC_API_KEY)}]: `))).trim()
-            || existing.ANTHROPIC_API_KEY || "";
-        if (!apiKey) {
-            console.log(chalk.red("\n   API key is required. Aborting setup."));
-            return;
+        // Provider selection
+        console.log(chalk.bold("1. LLM Provider"));
+        console.log(chalk.dim("   Options: anthropic, openai, openai-compatible (LM Studio, Ollama, OpenRouter)\n"));
+        const llmProvider = (await prompt(rl, chalk.cyan(`   BEERCAN_LLM_PROVIDER [${existing.BEERCAN_LLM_PROVIDER || "anthropic"}]: `))).trim()
+            || existing.BEERCAN_LLM_PROVIDER || "anthropic";
+        // API key(s) based on provider
+        let apiKey = "";
+        let openaiApiKey = "";
+        let llmApiKey = "";
+        let llmBaseUrl = "";
+        if (llmProvider === "anthropic") {
+            console.log(chalk.bold("\n2. Anthropic API Key") + chalk.red(" (required)"));
+            console.log(chalk.dim("   Get one at: https://console.anthropic.com/\n"));
+            apiKey = (await prompt(rl, chalk.cyan(`   ANTHROPIC_API_KEY [${mask(existing.ANTHROPIC_API_KEY)}]: `))).trim()
+                || existing.ANTHROPIC_API_KEY || "";
+            if (!apiKey) {
+                console.log(chalk.red("\n   API key is required. Aborting setup."));
+                return;
+            }
+        }
+        else if (llmProvider === "openai") {
+            console.log(chalk.bold("\n2. OpenAI API Key") + chalk.red(" (required)"));
+            console.log(chalk.dim("   Get one at: https://platform.openai.com/\n"));
+            openaiApiKey = (await prompt(rl, chalk.cyan(`   OPENAI_API_KEY [${mask(existing.OPENAI_API_KEY)}]: `))).trim()
+                || existing.OPENAI_API_KEY || "";
+            if (!openaiApiKey) {
+                console.log(chalk.red("\n   API key is required. Aborting setup."));
+                return;
+            }
         }
-        // Optional — Models
-        console.log(chalk.bold("\n2. Models") + chalk.dim(" (press Enter for defaults)"));
-        const defaultModel = (await prompt(rl, chalk.cyan(`   Default model [${existing.BEERCAN_DEFAULT_MODEL || "claude-sonnet-4-6"}]: `))).trim()
+        else {
+            console.log(chalk.bold("\n2. OpenAI-Compatible Endpoint") + chalk.red(" (required)"));
+            console.log(chalk.dim("   e.g., http://localhost:1234/v1 (LM Studio), http://localhost:11434/v1 (Ollama)\n"));
+            llmBaseUrl = (await prompt(rl, chalk.cyan(`   BEERCAN_LLM_BASE_URL [${existing.BEERCAN_LLM_BASE_URL || ""}]: `))).trim()
+                || existing.BEERCAN_LLM_BASE_URL || "";
+            if (!llmBaseUrl) {
+                console.log(chalk.red("\n   Base URL is required for openai-compatible. Aborting setup."));
+                return;
+            }
+            llmApiKey = (await prompt(rl, chalk.cyan(`   BEERCAN_LLM_API_KEY [${mask(existing.BEERCAN_LLM_API_KEY) || "not-needed"}]: `))).trim()
+                || existing.BEERCAN_LLM_API_KEY || "";
+        }
+        // Models — show provider-appropriate defaults
+        const modelDefaults = llmProvider === "anthropic"
+            ? { default: "claude-sonnet-4-6", heavy: "claude-opus-4-6" }
+            : llmProvider === "openai"
+                ? { default: "gpt-4o", heavy: "gpt-4o" }
+                : { default: "default", heavy: "default" };
+        console.log(chalk.bold("\n3. Models") + chalk.dim(" (press Enter for defaults)"));
+        const defaultModel = (await prompt(rl, chalk.cyan(`   Default model [${existing.BEERCAN_DEFAULT_MODEL || modelDefaults.default}]: `))).trim()
             || existing.BEERCAN_DEFAULT_MODEL || "";
-        const heavyModel = (await prompt(rl, chalk.cyan(`   Heavy model [${existing.BEERCAN_HEAVY_MODEL || "claude-opus-4-6"}]: `))).trim()
+        const heavyModel = (await prompt(rl, chalk.cyan(`   Heavy model [${existing.BEERCAN_HEAVY_MODEL || modelDefaults.heavy}]: `))).trim()
             || existing.BEERCAN_HEAVY_MODEL || "";
         // Optional — Cloudflare
-        console.log(chalk.bold("\n3. Cloudflare Browser Rendering") + chalk.dim(" (optional, for web_fetch)"));
+        console.log(chalk.bold("\n4. Cloudflare Browser Rendering") + chalk.dim(" (optional, for web_fetch)"));
         const cfToken = (await prompt(rl, chalk.cyan(`   CLOUDFLARE_API_TOKEN [${mask(existing.CLOUDFLARE_API_TOKEN)}]: `))).trim()
             || existing.CLOUDFLARE_API_TOKEN || "";
         const cfAccount = (await prompt(rl, chalk.cyan(`   CLOUDFLARE_ACCOUNT_ID [${mask(existing.CLOUDFLARE_ACCOUNT_ID)}]: `))).trim()
             || existing.CLOUDFLARE_ACCOUNT_ID || "";
         // Optional — Security
-        console.log(chalk.bold("\n4. API Security") + chalk.dim(" (optional, for REST API auth)"));
+        console.log(chalk.bold("\n5. API Security") + chalk.dim(" (optional, for REST API auth)"));
         const beercanApiKey = (await prompt(rl, chalk.cyan(`   BEERCAN_API_KEY [${mask(existing.BEERCAN_API_KEY)}]: `))).trim()
             || existing.BEERCAN_API_KEY || "";
         // Optional — Chat
-        console.log(chalk.bold("\n5. Chat Providers") + chalk.dim(" (optional, for Telegram/Slack bots)"));
+        console.log(chalk.bold("\n6. Chat Providers") + chalk.dim(" (optional, for Telegram/Slack bots)"));
         const telegramToken = (await prompt(rl, chalk.cyan(`   BEERCAN_TELEGRAM_TOKEN [${mask(existing.BEERCAN_TELEGRAM_TOKEN)}]: `))).trim()
             || existing.BEERCAN_TELEGRAM_TOKEN || "";
         const slackToken = (await prompt(rl, chalk.cyan(`   BEERCAN_SLACK_TOKEN [${mask(existing.BEERCAN_SLACK_TOKEN)}]: `))).trim()
@@ -112,7 +150,7 @@ async function runSetup() {
         const slackSecret = (await prompt(rl, chalk.cyan(`   BEERCAN_SLACK_SIGNING_SECRET [${mask(existing.BEERCAN_SLACK_SIGNING_SECRET)}]: `))).trim()
             || existing.BEERCAN_SLACK_SIGNING_SECRET || "";
         // Optional — Notifications
-        console.log(chalk.bold("\n6. Notifications") + chalk.dim(" (optional)"));
+        console.log(chalk.bold("\n7. Notifications") + chalk.dim(" (optional)"));
         const webhookUrl = (await prompt(rl, chalk.cyan(`   BEERCAN_NOTIFY_WEBHOOK_URL [${existing.BEERCAN_NOTIFY_WEBHOOK_URL || ""}]: `))).trim()
             || existing.BEERCAN_NOTIFY_WEBHOOK_URL || "";
         // Build .env content
@@ -120,10 +158,19 @@ async function runSetup() {
             `# BeerCan Configuration`,
             `# Generated by: beercan setup`,
             ``,
-            `ANTHROPIC_API_KEY=${apiKey}`,
+            `# LLM Provider: anthropic, openai, openai-compatible`,
+            `BEERCAN_LLM_PROVIDER=${llmProvider}`,
         ];
+        if (apiKey)
+            lines.push(`ANTHROPIC_API_KEY=${apiKey}`);
+        if (openaiApiKey)
+            lines.push(`OPENAI_API_KEY=${openaiApiKey}`);
+        if (llmApiKey)
+            lines.push(`BEERCAN_LLM_API_KEY=${llmApiKey}`);
+        if (llmBaseUrl)
+            lines.push(`BEERCAN_LLM_BASE_URL=${llmBaseUrl}`);
         if (defaultModel)
-            lines.push(`BEERCAN_DEFAULT_MODEL=${defaultModel}`);
+            lines.push(``, `# Models`, `BEERCAN_DEFAULT_MODEL=${defaultModel}`);
         if (heavyModel)
             lines.push(`BEERCAN_HEAVY_MODEL=${heavyModel}`);
         if (cfToken)
@@ -921,11 +968,11 @@ Do NOT rewrite everything — make focused, incremental changes.`,
             // ── Chat Mode ───────────────────────────────────────────
             case "chat": {
                 const chatProject = args[1];
-                const { createAnthropicClient } = await import("./client.js");
+                const { createLLMProvider } = await import("./providers/factory.js");
                 const { ChatBridge } = await import("./chat/index.js");
                 const { TerminalProvider } = await import("./chat/providers/terminal.js");
-                const client = await createAnthropicClient();
-                const bridge = new ChatBridge(engine, client);
+                const provider = await createLLMProvider();
+                const bridge = new ChatBridge(engine, provider);
                 const terminal = new TerminalProvider();
                 bridge.addProvider(terminal);
                 if (chatProject) {
@@ -1255,6 +1302,197 @@ Do NOT rewrite everything — make focused, incremental changes.`,
                 rl.close();
                 break;
             }
+            // ── Training Commands ───────────────────────────────────
+            case "training:create": {
+                const traineeName = args[1];
+                if (!traineeName) {
+                    console.log(chalk.red("Usage: beercan training:create <name> [--work-dir <path>]"));
+                    console.log(chalk.dim("Creates a new training sandbox project for an agent."));
+                    break;
+                }
+                const wdIdx = args.indexOf("--work-dir");
+                const workDir = wdIdx >= 0 ? args[wdIdx + 1] : undefined;
+                try {
+                    const project = await engine.createTrainee(traineeName, workDir);
+                    console.log(chalk.green(`✓ Created training project: ${project.name}`));
+                    console.log(chalk.dim(`  Slug:  ${project.slug}`));
+                    console.log(chalk.dim(`  ID:    ${project.id}`));
+                    if (workDir)
+                        console.log(chalk.dim(`  Work dir: ${workDir}`));
+                    console.log(chalk.dim(`\nNext: beercan training:run ${project.slug}`));
+                }
+                catch (err) {
+                    console.log(chalk.red(`Failed to create trainee: ${err.message}`));
+                }
+                break;
+            }
+            case "training:run": {
+                const trainingProject = args[1];
+                if (!trainingProject) {
+                    console.log(chalk.red("Usage: beercan training:run <project> [--scenario <id>]"));
+                    console.log(chalk.dim("Runs the next (or a specific) training scenario."));
+                    break;
+                }
+                const scenarioIdx = args.indexOf("--scenario");
+                const scenarioId = scenarioIdx >= 0 ? args[scenarioIdx + 1] : undefined;
+                try {
+                    const status = await engine.getTrainingStatus(trainingProject);
+                    if (scenarioId) {
+                        console.log(chalk.bold(`\nRunning scenario: ${scenarioId}`));
+                    }
+                    else if (status.nextScenario) {
+                        console.log(chalk.bold(`\nRunning next scenario: ${status.nextScenario.name}`));
+                        console.log(chalk.dim(`  Difficulty: ${status.nextScenario.difficulty}`));
+                        console.log(chalk.dim(`  Category:   ${status.nextScenario.category}`));
+                        console.log(chalk.dim(`  Goal:       ${status.nextScenario.goal.slice(0, 80)}...`));
+                    }
+                    else {
+                        console.log(chalk.yellow("No scenarios available. Check status with: beercan training:status " + trainingProject));
+                        break;
+                    }
+                    console.log();
+                    const attempt = await engine.runTrainingScenario(trainingProject, scenarioId);
+                    const statusColor = attempt.status === "pass"
+                        ? chalk.green
+                        : attempt.status === "fail"
+                            ? chalk.yellow
+                            : chalk.red;
+                    console.log(statusColor(`\n${attempt.status === "pass" ? "✓ PASSED" : attempt.status === "fail" ? "✗ FAILED" : "! ERROR"}`));
+                    console.log(`  Score:    ${(attempt.score * 100).toFixed(0)}%`);
+                    console.log(`  Feedback: ${attempt.feedback}`);
+                    console.log(chalk.dim(`  Tokens:   ${attempt.tokensUsed.toLocaleString()}`));
+                    console.log(chalk.dim(`  Duration: ${(attempt.durationMs / 1000).toFixed(1)}s`));
+                    // Show updated status
+                    const newStatus = await engine.getTrainingStatus(trainingProject);
+                    if (newStatus.progress.graduationStatus === "graduated") {
+                        console.log(chalk.bold.green("\nCongratulations! Agent has graduated!"));
+                    }
+                    else if (newStatus.nextScenario) {
+                        console.log(chalk.dim(`\nNext scenario: ${newStatus.nextScenario.name} — run again to continue`));
+                    }
+                }
+                catch (err) {
+                    console.log(chalk.red(`Training run failed: ${err.message}`));
+                }
+                break;
+            }
+            case "training:status": {
+                const statusProject = args[1];
+                if (!statusProject) {
+                    console.log(chalk.red("Usage: beercan training:status <project>"));
+                    break;
+                }
+                try {
+                    const { progress, nextScenario, summary } = await engine.getTrainingStatus(statusProject);
+                    const gradColor = progress.graduationStatus === "graduated"
+                        ? chalk.bold.green
+                        : progress.graduationStatus === "failed"
+                            ? chalk.red
+                            : chalk.yellow;
+                    console.log(chalk.bold(`\nTraining Status: ${statusProject}\n`));
+                    console.log(`  Graduation: ${gradColor(progress.graduationStatus)}`);
+                    console.log(`  Level:      ${progress.currentLevel}`);
+                    console.log(`  Passed:     ${progress.passedScenarios.length} scenarios`);
+                    console.log(`  Bloops:     ${progress.totalBloops}`);
+                    console.log(`  Tokens:     ${progress.totalTokensUsed.toLocaleString()}`);
+                    if (progress.startedAt) {
+                        console.log(chalk.dim(`  Started:    ${progress.startedAt.slice(0, 19)}`));
+                    }
+                    if (progress.graduatedAt) {
+                        console.log(chalk.dim(`  Graduated:  ${progress.graduatedAt.slice(0, 19)}`));
+                    }
+                    if (nextScenario) {
+                        console.log(chalk.bold(`\nNext Scenario:`));
+                        console.log(`  ${chalk.cyan(nextScenario.name)} (${nextScenario.difficulty})`);
+                        console.log(chalk.dim(`  Category: ${nextScenario.category}`));
+                        console.log(chalk.dim(`  Tests: ${nextScenario.teaches.slice(0, 3).join(", ")}`));
+                    }
+                    if (progress.passedScenarios.length > 0) {
+                        console.log(chalk.bold(`\nPassed Scenarios:`));
+                        for (const id of progress.passedScenarios) {
+                            console.log(chalk.green(`  ✓ ${id}`));
+                        }
+                    }
+                    if (progress.failedScenarios.length > 0) {
+                        console.log(chalk.bold(`\nFailed Scenarios:`));
+                        for (const f of progress.failedScenarios) {
+                            console.log(chalk.red(`  ✗ ${f.id} (${f.attempts} attempt${f.attempts !== 1 ? "s" : ""})`));
+                        }
+                    }
+                }
+                catch (err) {
+                    console.log(chalk.red(`Failed to get training status: ${err.message}`));
+                }
+                break;
+            }
+            case "training:export": {
+                const exportProject = args[1];
+                if (!exportProject) {
+                    console.log(chalk.red("Usage: beercan training:export <project> [--output <path>]"));
+                    break;
+                }
+                const outIdx = args.indexOf("--output");
+                const outputPath = outIdx >= 0
+                    ? args[outIdx + 1]
+                    : `./${exportProject}-agent-package.json`;
+                try {
+                    console.log(chalk.dim(`Exporting agent: ${exportProject} → ${outputPath}`));
+                    await engine.exportAgent(exportProject, outputPath);
+                    console.log(chalk.green(`✓ Agent exported: ${outputPath}`));
+                    console.log(chalk.dim(`  Import with: beercan training:import ${outputPath}`));
+                }
+                catch (err) {
+                    console.log(chalk.red(`Export failed: ${err.message}`));
+                }
+                break;
+            }
+            case "training:import": {
+                const importPath = args[1];
+                if (!importPath) {
+                    console.log(chalk.red("Usage: beercan training:import <package-path> [--name <slug>] [--global] [--project <slug>]"));
+                    console.log(chalk.dim("  --global           Import only skills & tools globally (no project created)"));
+                    console.log(chalk.dim("  --project <slug>   Import into an existing project"));
+                    console.log(chalk.dim("  --name <slug>      Create a new project with this slug (default: from package)"));
+                    break;
+                }
+                const isGlobal = args.includes("--global");
+                const projectIdx = args.indexOf("--project");
+                const targetProject = projectIdx >= 0 ? args[projectIdx + 1] : undefined;
+                const nameIdx = args.indexOf("--name");
+                const targetSlug = nameIdx >= 0 ? args[nameIdx + 1] : undefined;
+                try {
+                    if (isGlobal) {
+                        // Global import: skills + tools only, no project
+                        console.log(chalk.dim(`Importing skills & tools globally from: ${importPath}`));
+                        const { skills, tools } = await engine.importAgentGlobal(importPath);
+                        console.log(chalk.green(`✓ Global import complete`));
+                        console.log(chalk.dim(`  Skills imported: ${skills}`));
+                        console.log(chalk.dim(`  Tools imported:  ${tools}`));
+                    }
+                    else if (targetProject) {
+                        // Import into existing project
+                        console.log(chalk.dim(`Importing agent into project: ${targetProject}`));
+                        const project = await engine.importAgentIntoProject(importPath, targetProject);
+                        console.log(chalk.green(`✓ Agent imported into: ${project.name}`));
+                        console.log(chalk.dim(`  Slug: ${project.slug}`));
+                    }
+                    else {
+                        // Default: create new project from package
+                        console.log(chalk.dim(`Importing agent package: ${importPath}`));
+                        const project = await engine.importAgent(importPath, targetSlug);
+                        console.log(chalk.green(`✓ Agent imported: ${project.name}`));
+                        console.log(chalk.dim(`  Slug: ${project.slug}`));
+                        console.log(chalk.dim(`  ID:   ${project.id}`));
+                        if (targetSlug && targetSlug !== project.slug) {
+                            console.log(chalk.dim(`  Note: imported as ${project.slug}`));
+                        }
+                    }
+                }
+                catch (err) {
+                    console.log(chalk.red(`Import failed: ${err.message}`));
+                }
+                break;
+            }
             // ── Help ────────────────────────────────────────────────
             default:
                 console.log(chalk.bold("BeerCan") + chalk.dim(" — Autonomous agent system\n"));
@@ -1286,6 +1524,14 @@ Do NOT rewrite everything — make focused, incremental changes.`,
                 console.log(chalk.cyan("  mcp:add <project> <name> <cmd> [args]") + chalk.dim("  Add MCP server"));
                 console.log(chalk.cyan("  mcp:list <project>") + chalk.dim("                    List MCP servers"));
                 console.log();
+                console.log(chalk.bold("Training:"));
+                console.log(chalk.cyan("  training:create <name> [--work-dir <path>]") + chalk.dim("  Create a training sandbox project"));
+                console.log(chalk.cyan("  training:run <project> [--scenario <id>]") + chalk.dim("   Run next (or specific) scenario"));
+                console.log(chalk.cyan("  training:status <project>") + chalk.dim("               Show training progress"));
+                console.log(chalk.cyan("  training:export <project> [--output <path>]") + chalk.dim(" Export agent package"));
+                console.log(chalk.cyan("  training:import <package> [options]") + chalk.dim("        Import agent package"));
+                console.log(chalk.dim("    --name <slug>     Create new project with slug  |  --global  Skills & tools only  |  --project <slug>  Into existing"));
+                console.log();
                 console.log(chalk.bold("Encryption:"));
                 console.log(chalk.cyan("  crypto:setup") + chalk.dim("                          Configure encryption (passphrase or keyfile)"));
                 console.log(chalk.cyan("  crypto:status") + chalk.dim("                         Show encryption status"));
@@ -1311,8 +1557,8 @@ Do NOT rewrite everything — make focused, incremental changes.`,
 }
 main().catch((err) => {
     const msg = String(err?.message ?? err);
-    if (msg.includes("anthropicApiKey") || msg.includes("ANTHROPIC_API_KEY") || msg.includes("Required")) {
-        console.error(chalk.red("\nMissing API key.") + " Run " + chalk.cyan("beercan setup") + " to configure BeerCan.\n");
+    if (msg.includes("API_KEY") || msg.includes("api key") || msg.includes("Api key") || msg.includes("not set") || msg.includes("Required")) {
+        console.error(chalk.red("\nMissing API key or provider config.") + " Run " + chalk.cyan("beercan setup") + " to configure BeerCan.\n");
     }
     else {
         console.error(chalk.red("Fatal:"), msg);