berget 2.2.5 → 2.2.7

package/dist/src/commands/code/setup.js

@@ -0,0 +1,533 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetupCommand = exports.runSetup = void 0;
+const errors_1 = require("./errors");
+const jsonc_parser_1 = require("jsonc-parser");
+const auth_sync_js_1 = require("./auth-sync.js");
+const clack_prompter_js_1 = require("./adapters/clack-prompter.js");
+const fs_file_store_js_1 = require("./adapters/fs-file-store.js");
+const spawn_command_runner_js_1 = require("./adapters/spawn-command-runner.js");
+const auth_service_js_1 = require("../../services/auth-service.js");
+const api_key_service_js_1 = require("../../services/api-key-service.js");
+const index_js_1 = require("../../agents/index.js");
+const os = __importStar(require("os"));
+const OPENCODE_PLUGIN = "@bergetai/opencode-auth@1.0.16";
+const PI_PROVIDER = "npm:@bergetai/pi-provider";
+const OPENCODE_PLUGIN_NAME = "@bergetai/opencode-auth";
+const PI_PROVIDER_NAME = "@bergetai/pi-provider";
+function runSetup(deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompter, files, commands, authService, apiKeyService, homeDir, cwd } = deps;
+        prompter.intro("\uD83D\uDD27 Berget Code Setup");
+        const ocState = yield getOpencodeState(files, homeDir, cwd);
+        const piState = yield getPiState(files, homeDir, cwd);
+        const tool = yield prompter.select({
+            message: "How do you want to use Berget AI?",
+            options: [
+                {
+                    value: "opencode",
+                    label: `OpenCode${getOpencodeLabel(ocState)}`,
+                    hint: "Open source AI coding agent",
+                },
+                {
+                    value: "pi",
+                    label: `Pi${getPiLabel(piState)}`,
+                    hint: "Minimal terminal coding harness",
+                },
+            ],
+        });
+        const scope = yield prompter.select({
+            message: "Where should the configuration apply?",
+            options: [
+                {
+                    value: "project",
+                    label: "This project only",
+                    hint: tool === "opencode"
+                        ? ocState.project
+                            ? "Already configured"
+                            : "opencode.json in current directory"
+                        : piState.project
+                            ? "Already configured"
+                            : ".pi/settings.json in current directory",
+                },
+                {
+                    value: "global",
+                    label: "Globally for all projects",
+                    hint: tool === "opencode"
+                        ? ocState.global
+                            ? "Already configured"
+                            : "~/.config/opencode/opencode.json"
+                        : piState.global
+                            ? "Already configured"
+                            : "~/.pi/agent/settings.json",
+                },
+            ],
+        });
+        const authResult = yield (0, auth_sync_js_1.configureAuth)({ prompter, files, authService, apiKeyService, homeDir }, tool);
+        if (tool === "opencode") {
+            yield setupOpenCode({ prompter, files, commands, homeDir, cwd, scope });
+            yield setupOpenCodeAgents({ prompter, files, homeDir, cwd, scope });
+            if (authResult.authenticated) {
+                prompter.note(`You're all set!\n\n1. Run: opencode\n2. Select model: /models\n\nFor more information, see official docs:\n\nhttps://github.com/berget-ai/opencode-berget-auth`, "Successfully configured Berget AI for OpenCode");
+            }
+            else {
+                prompter.note(`Next steps:\n\n1. Run: opencode\n2. Type: /connect\n3. Choose your auth method:\n   • "Login with Berget" — Berget Code plan\n   • "Enter Berget API Key manually"\n   • (or set BERGET_API_KEY env var)\n4. Select model: /models\n\nFor more information, see official docs:\n\nhttps://github.com/berget-ai/opencode-berget-auth`, "Successfully configured Berget AI for OpenCode");
+            }
+        }
+        else {
+            yield setupPi({ prompter, files, commands, homeDir, cwd, scope });
+            yield setupPiAgent({ prompter, files, homeDir, cwd, scope });
+            if (authResult.authenticated) {
+                prompter.note(`You're all set!\n\n1. Restart Pi or run /reload\n2. Select model: /model\n\nFor more information, see official docs:\n\nhttps://github.com/berget-ai/pi-provider`, "Successfully configured Berget AI for Pi");
+            }
+            else {
+                prompter.note(`Next steps:\n\n1. Restart Pi or run /reload\n2. Type: /login\n3. Choose your auth method:\n   • "Use a subscription" → Berget AI\n   • (or set BERGET_API_KEY env var)\n4. Select model: /model\n\nFor more information, see official docs:\n\nhttps://github.com/berget-ai/pi-provider`, "Successfully configured Berget AI for Pi");
+            }
+        }
+        prompter.outro("Setup complete!");
+    });
+}
+exports.runSetup = runSetup;
+// ─── OpenCode ────────────────────────────────────────────────────────────────
+function setupOpenCode(deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompter, files, commands, homeDir, cwd, scope } = deps;
+        const installed = yield commands.checkInstalled("opencode");
+        if (!installed) {
+            throw new errors_1.PrerequisiteError("opencode");
+        }
+        const configPath = yield resolveOpencodeConfigPath(files, homeDir, cwd, scope);
+        const existingContent = yield files.readFile(configPath);
+        const newContent = generateModifiedContent(existingContent, configPath);
+        if (existingContent && existingContent === newContent) {
+            return;
+        }
+        if (existingContent) {
+            prompter.note(generateDiff(existingContent, newContent, configPath), "Changes to be written");
+        }
+        else {
+            prompter.note(`New config at ${configPath}:\n\n${newContent}`, "Config preview");
+        }
+        const shouldWrite = yield prompter.confirm({
+            message: existingContent ? `Write these changes to ${configPath}?` : `Create ${configPath}?`,
+            initialValue: true,
+        });
+        if (!shouldWrite)
+            throw new errors_1.CancelledError();
+        const s = prompter.spinner();
+        s.start("Writing OpenCode configuration...");
+        yield files.writeFile(configPath, newContent);
+        s.stop(`Wrote configuration to ${configPath}.`);
+    });
+}
+// ─── Pi ────────────────────────────────────────────────────────────────────────
+function setupPi(deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompter, files, commands, homeDir, cwd, scope } = deps;
+        const s = prompter.spinner();
+        const installed = yield commands.checkInstalled("pi");
+        if (!installed) {
+            throw new errors_1.PrerequisiteError("pi");
+        }
+        const installArgs = scope === "project" ? ["install", "-l", PI_PROVIDER] : ["install", PI_PROVIDER];
+        s.start(`Installing Berget AI provider for Pi...`);
+        try {
+            yield commands.run("pi", installArgs);
+            s.stop("Installed Pi provider.");
+        }
+        catch (_a) {
+            s.stop("Pi provider installation failed. Please try again or install manually.");
+            throw new errors_1.CommandFailedError(`pi ${installArgs.join(" ")}`, 1);
+        }
+        const settingsPath = scope === "project"
+            ? pathJoin(cwd, ".pi", "settings.json")
+            : pathJoin(homeDir, ".pi", "agent", "settings.json");
+        let settings = (yield readJsonMaybe(files, settingsPath)) || {};
+        if (settings.defaultProvider === "berget") {
+            prompter.note("Berget AI is already set as your default provider.", "Default provider already set");
+        }
+        else {
+            if (settings.defaultProvider) {
+                const makeDefault = yield prompter.confirm({
+                    message: `Your default provider is ${settings.defaultProvider}. Switch to Berget AI instead?`,
+                    initialValue: false,
+                });
+                if (makeDefault) {
+                    settings.defaultProvider = "berget";
+                    yield writeJsonFile(files, settingsPath, settings);
+                    prompter.note("Berget AI is now your default provider.", "Updated default provider");
+                }
+            }
+            else {
+                settings.defaultProvider = "berget";
+                yield writeJsonFile(files, settingsPath, settings);
+                prompter.note("Berget AI is now your default provider.", "Updated default provider");
+            }
+        }
+    });
+}
+function setupOpenCodeAgents(deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompter, files, homeDir, cwd, scope } = deps;
+        const agents = (0, index_js_1.getAllAgents)().filter(a => a.config.mode === "primary");
+        if (agents.length === 0) {
+            return;
+        }
+        const selectedAgents = yield prompter.multiselect({
+            message: "Select agents to set up (optional - press enter to skip):",
+            options: agents.map(agent => ({
+                value: agent.config.name,
+                label: agent.config.name,
+                hint: agent.config.description,
+            })),
+        });
+        if (selectedAgents.length === 0) {
+            return;
+        }
+        const agentsDir = scope === "project"
+            ? pathJoin(cwd, ".opencode", "agents")
+            : pathJoin(homeDir, ".config", "opencode", "agents");
+        yield files.mkdir(agentsDir);
+        const hasChanges = yield Promise.all(selectedAgents.map((agentName) => __awaiter(this, void 0, void 0, function* () {
+            const agent = agents.find(a => a.config.name === agentName);
+            if (!agent)
+                return false;
+            const agentPath = pathJoin(agentsDir, `${agentName}.md`);
+            const existing = yield files.readFile(agentPath);
+            const newContent = (0, index_js_1.toMarkdown)(agent);
+            if (existing === newContent) {
+                return false;
+            }
+            if (existing) {
+                prompter.note(generateDiff(existing, newContent, agentPath), `Changes to ${agentName} agent`);
+            }
+            return true;
+        })));
+        if (!hasChanges.some(Boolean)) {
+            prompter.note("Agent files are already up to date.", "No changes needed");
+            return;
+        }
+        const shouldWrite = yield prompter.confirm({
+            message: "Write agent configuration files?",
+            initialValue: true,
+        });
+        if (!shouldWrite) {
+            throw new errors_1.CancelledError();
+        }
+        const s = prompter.spinner();
+        s.start("Writing agent configurations...");
+        for (const agentName of selectedAgents) {
+            const agent = agents.find(a => a.config.name === agentName);
+            if (!agent)
+                continue;
+            const agentPath = pathJoin(agentsDir, `${agentName}.md`);
+            const content = (0, index_js_1.toMarkdown)(agent);
+            yield files.writeFile(agentPath, content);
+        }
+        s.stop(`Wrote ${selectedAgents.length} agent(s) to ${agentsDir}`);
+    });
+}
+function setupPiAgent(deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompter, files, homeDir, cwd, scope } = deps;
+        const agents = (0, index_js_1.getAllAgents)().filter(a => a.config.mode === "primary");
+        if (agents.length === 0) {
+            return;
+        }
+        const selectedAgentName = yield prompter.select({
+            message: "Select an agent (optional - press enter to skip):",
+            options: [
+                { value: "__skip__", label: "Skip agent setup" },
+                ...agents.map(agent => ({
+                    value: agent.config.name,
+                    label: agent.config.name,
+                    hint: agent.config.description,
+                })),
+            ],
+        });
+        if (selectedAgentName === "__skip__") {
+            return;
+        }
+        const agent = agents.find(a => a.config.name === selectedAgentName);
+        if (!agent)
+            return;
+        const systemPath = scope === "project"
+            ? pathJoin(cwd, ".pi", "SYSTEM.md")
+            : pathJoin(homeDir, ".pi", "agent", "SYSTEM.md");
+        const existing = yield files.readFile(systemPath);
+        const newContent = (0, index_js_1.toPiPrompt)(agent);
+        if (existing === newContent) {
+            prompter.note("Agent configuration is already up to date.", "No changes needed");
+            return;
+        }
+        if (existing) {
+            prompter.note(generateDiff(existing, newContent, systemPath), "Changes to agent configuration");
+        }
+        else {
+            prompter.note(newContent, "New agent configuration");
+        }
+        const shouldWrite = yield prompter.confirm({
+            message: existing ? "Overwrite existing agent configuration?" : "Create agent configuration?",
+            initialValue: true,
+        });
+        if (!shouldWrite) {
+            throw new errors_1.CancelledError();
+        }
+        const s = prompter.spinner();
+        s.start("Writing agent configuration...");
+        const systemDir = scope === "project" ? pathJoin(cwd, ".pi") : pathJoin(homeDir, ".pi", "agent");
+        yield files.mkdir(systemDir);
+        yield files.writeFile(systemPath, newContent);
+        s.stop(`Wrote agent configuration to ${systemPath}`);
+    });
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function pathJoin(...parts) {
+    // Simple path join that avoids importing 'path' module
+    // This is good enough for cross-platform testing since tests control the path format
+    return parts.join("/");
+}
+function stripJsoncComments(content) {
+    content = content.replace(/\/\/.*$/gm, "");
+    content = content.replace(/\/\*[\s\S]*?\*\//g, "");
+    return content;
+}
+function generateDiff(oldText, newText, filePath) {
+    const oldLines = oldText.split("\n");
+    const newLines = newText.split("\n");
+    let result = `--- ${filePath}\n+++ ${filePath}\n`;
+    const maxLen = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLen; i++) {
+        const oldLine = oldLines[i];
+        const newLine = newLines[i];
+        if (oldLine !== newLine) {
+            if (oldLine !== undefined)
+                result += `- ${oldLine}\n`;
+            if (newLine !== undefined)
+                result += `+ ${newLine}\n`;
+        }
+    }
+    return result.trimEnd();
+}
+function readJsonMaybe(files, filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const content = yield files.readFile(filePath);
+        if (!content)
+            return null;
+        try {
+            return JSON.parse(content);
+        }
+        catch (_a) {
+            try {
+                return JSON.parse(stripJsoncComments(content));
+            }
+            catch (_b) {
+                return null;
+            }
+        }
+    });
+}
+function writeJsonFile(files, filePath, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield files.writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    });
+}
+function hasPluginInConfig(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!config)
+            return false;
+        const plugins = config.plugin || config.plugins || [];
+        return plugins.some((p) => p.includes(OPENCODE_PLUGIN_NAME));
+    });
+}
+function hasPiProviderInSettings(settings) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!settings)
+            return false;
+        const packages = settings.packages || [];
+        return packages.some((p) => {
+            if (typeof p === "string")
+                return p.includes(PI_PROVIDER_NAME);
+            if (typeof p === "object" && p.source)
+                return p.source.includes(PI_PROVIDER_NAME);
+            return false;
+        });
+    });
+}
+function getOpencodeState(files, homeDir, cwd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const projectJsonc = yield readJsonMaybe(files, pathJoin(cwd, "opencode.jsonc"));
+        const projectJson = yield readJsonMaybe(files, pathJoin(cwd, "opencode.json"));
+        const globalJsonc = yield readJsonMaybe(files, pathJoin(homeDir, ".config", "opencode", "opencode.jsonc"));
+        const globalJson = yield readJsonMaybe(files, pathJoin(homeDir, ".config", "opencode", "opencode.json"));
+        return {
+            project: (yield hasPluginInConfig(projectJsonc)) || (yield hasPluginInConfig(projectJson)),
+            global: (yield hasPluginInConfig(globalJsonc)) || (yield hasPluginInConfig(globalJson)),
+        };
+    });
+}
+function getPiState(files, homeDir, cwd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const projectSettings = yield readJsonMaybe(files, pathJoin(cwd, ".pi", "settings.json"));
+        const globalSettings = yield readJsonMaybe(files, pathJoin(homeDir, ".pi", "agent", "settings.json"));
+        return {
+            project: yield hasPiProviderInSettings(projectSettings),
+            global: yield hasPiProviderInSettings(globalSettings),
+        };
+    });
+}
+function getOpencodeLabel(state) {
+    if (state.project || state.global)
+        return " (already configured)";
+    return "";
+}
+function getPiLabel(state) {
+    if (state.project || state.global)
+        return " (already configured)";
+    return "";
+}
+function resolveOpencodeConfigPath(files, homeDir, cwd, scope) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (scope === "project") {
+            const jsoncPath = pathJoin(cwd, "opencode.jsonc");
+            const jsonPath = pathJoin(cwd, "opencode.json");
+            if (yield files.exists(jsoncPath))
+                return jsoncPath;
+            if (yield files.exists(jsonPath))
+                return jsonPath;
+            return jsonPath;
+        }
+        else {
+            const globalDir = pathJoin(homeDir, ".config", "opencode");
+            const jsoncPath = pathJoin(globalDir, "opencode.jsonc");
+            const jsonPath = pathJoin(globalDir, "opencode.json");
+            if (yield files.exists(jsoncPath))
+                return jsoncPath;
+            if (yield files.exists(jsonPath))
+                return jsonPath;
+            return jsonPath;
+        }
+    });
+}
+function generateModifiedContent(existingContent, configPath) {
+    if (configPath.endsWith(".jsonc")) {
+        const content = existingContent || "{}";
+        const parseErrors = [];
+        const parsed = (0, jsonc_parser_1.parse)(content, parseErrors, {
+            allowTrailingComma: true,
+            disallowComments: false,
+        });
+        let jsConfig = {};
+        const canModifyText = parsed !== undefined &&
+            typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed);
+        if (canModifyText) {
+            jsConfig = parsed;
+        }
+        const pluginsKey = jsConfig.plugins !== undefined ? "plugins" : "plugin";
+        const existing = jsConfig[pluginsKey] || [];
+        const filtered = existing.filter((p) => !p.includes(OPENCODE_PLUGIN_NAME));
+        filtered.push(OPENCODE_PLUGIN);
+        if (canModifyText) {
+            let modifiedContent = content;
+            const pluginEdits = (0, jsonc_parser_1.modify)(modifiedContent, [pluginsKey], filtered, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            });
+            modifiedContent = (0, jsonc_parser_1.applyEdits)(modifiedContent, pluginEdits);
+            if (!jsConfig.$schema) {
+                const schemaEdits = (0, jsonc_parser_1.modify)(modifiedContent, ["$schema"], "https://opencode.ai/config.json", {
+                    formattingOptions: { insertSpaces: true, tabSize: 2 },
+                });
+                modifiedContent = (0, jsonc_parser_1.applyEdits)(modifiedContent, schemaEdits);
+            }
+            return modifiedContent;
+        }
+        // Malformed, empty, or non-object JSONC — write a clean config
+        const config = {
+            [pluginsKey]: filtered,
+            $schema: "https://opencode.ai/config.json",
+        };
+        return JSON.stringify(config, null, 2) + "\n";
+    }
+    // Plain JSON
+    let config = {};
+    if (existingContent) {
+        try {
+            config = JSON.parse(existingContent);
+        }
+        catch (_a) {
+            // ignore malformed, overwrite
+        }
+    }
+    const pluginsKey = config.plugins !== undefined ? "plugins" : "plugin";
+    const existing = config[pluginsKey] || [];
+    const filtered = existing.filter((p) => !p.includes(OPENCODE_PLUGIN_NAME));
+    filtered.push(OPENCODE_PLUGIN);
+    config[pluginsKey] = filtered;
+    config.$schema = config.$schema || "https://opencode.ai/config.json";
+    return JSON.stringify(config, null, 2) + "\n";
+}
+function runSetupCommand() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield runSetup({
+                prompter: new clack_prompter_js_1.ClackPrompter(),
+                files: new fs_file_store_js_1.FsFileStore(),
+                commands: new spawn_command_runner_js_1.SpawnCommandRunner(),
+                authService: auth_service_js_1.AuthService.getInstance(),
+                apiKeyService: api_key_service_js_1.ApiKeyService.getInstance(),
+                homeDir: os.homedir(),
+                cwd: process.cwd(),
+            });
+            process.exit(0);
+        }
+        catch (err) {
+            if (err instanceof errors_1.CancelledError) {
+                process.exit(130);
+            }
+            if (err instanceof errors_1.PrerequisiteError) {
+                console.error(`Missing required binary: ${err.binary}`);
+                process.exit(2);
+            }
+            if (err instanceof errors_1.CommandFailedError) {
+                console.error(err.message);
+                process.exit(5);
+            }
+            throw err;
+        }
+    });
+}
+exports.runSetupCommand = runSetupCommand;