berget 2.2.5 → 2.2.6

package/dist/src/commands/code/adapters/spawn-command-runner.js

@@ -0,0 +1,49 @@
+"use strict";
+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.SpawnCommandRunner = void 0;
+const node_child_process_1 = require("node:child_process");
+class SpawnCommandRunner {
+    checkInstalled(binary) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const child = (0, node_child_process_1.spawn)('which', [binary], { stdio: 'pipe' });
+                child.on('close', (code) => resolve(code === 0));
+                child.on('error', () => resolve(false));
+            });
+        });
+    }
+    run(command, args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                var _a, _b;
+                const child = (0, node_child_process_1.spawn)(command, args, {
+                    stdio: 'pipe',
+                    cwd: (options === null || options === void 0 ? void 0 : options.cwd) || process.cwd(),
+                });
+                let stdout = '';
+                let stderr = '';
+                (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (d) => { stdout += d.toString(); });
+                (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (d) => { stderr += d.toString(); });
+                child.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(stdout);
+                    }
+                    else {
+                        reject(new Error(stderr.trim() || `Command failed with exit code ${code}`));
+                    }
+                });
+                child.on('error', (err) => reject(err));
+            });
+        });
+    }
+}
+exports.SpawnCommandRunner = SpawnCommandRunner;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandFailedError = exports.CancelledError = exports.PrerequisiteError = void 0;
+class PrerequisiteError extends Error {
+    constructor(binary) {
+        super(`Required binary not found: ${binary}`);
+        this.binary = binary;
+        this.name = 'PrerequisiteError';
+    }
+}
+exports.PrerequisiteError = PrerequisiteError;
+class CancelledError extends Error {
+    constructor() {
+        super('Wizard cancelled');
+        this.name = 'CancelledError';
+    }
+}
+exports.CancelledError = CancelledError;
+class CommandFailedError extends Error {
+    constructor(command, exitCode) {
+        super(`Command "${command}" failed with exit code ${exitCode}`);
+        this.command = command;
+        this.exitCode = exitCode;
+        this.name = 'CommandFailedError';
+    }
+}
+exports.CommandFailedError = CommandFailedError;

package/dist/src/commands/code/ports/command-runner.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/commands/code/ports/file-store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/commands/code/ports/prompter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,392 @@
+"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 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, 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'),
+                },
+            ],
+        });
+        if (tool === 'opencode') {
+            yield setupOpenCode({ prompter, files, commands, homeDir, cwd, scope });
+            prompter.note(`Next steps:\n\n1. Run: opencode\n2. Type: /connect\n3. Choose your auth method:\n   \u2022 "Login with Berget" \u2014 Berget Code plan\n   \u2022 "Enter Berget API Key manually"\n   \u2022 (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 });
+            prompter.note(`Next steps:\n\n1. Restart Pi or run /reload\n2. Type: /login\n3. Choose your auth method:\n   \u2022 "Use a subscription" \u2192 Berget AI\n   \u2022 (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 (err) {
+            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');
+            }
+        }
+    });
+}
+// ─── 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';
+}
+// ─── Production CLI entry point ──────────────────────────────────────────────
+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 os = __importStar(require("os"));
+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(),
+                homeDir: os.homedir(),
+                cwd: process.cwd(),
+            });
+        }
+        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;