berget 2.2.11 → 2.2.12

package/dist/tests/commands/code.test.js

@@ -1,436 +1,25 @@
 "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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const fs = __importStar(require("node:fs"));
-const promises_1 = require("node:fs/promises");
 const vitest_1 = require("vitest");
 const code_1 = require("../../src/commands/code");
-const api_key_service_1 = require("../../src/services/api-key-service");
-const env_manager_1 = require("../../src/utils/env-manager");
-// Mock dependencies
-vitest_1.vi.mock('../../src/services/api-key-service');
-vitest_1.vi.mock('fs', () => ({
-    default: {
-        existsSync: vitest_1.vi.fn(),
-        readFileSync: vitest_1.vi.fn(),
-    },
-}));
-vitest_1.vi.mock('fs/promises', () => ({
-    readFile: vitest_1.vi.fn(),
-    writeFile: vitest_1.vi.fn(),
-}));
-vitest_1.vi.mock('../../src/utils/env-manager');
-vitest_1.vi.mock('child_process', () => ({
-    spawn: vitest_1.vi.fn(),
-}));
-vitest_1.vi.mock('readline', () => ({
-    createInterface: vitest_1.vi.fn(() => ({
-        close: vitest_1.vi.fn(),
-        question: vitest_1.vi.fn(),
-    })),
-}));
 (0, vitest_1.describe)('Code Commands', () => {
     let program;
-    let mockApiKeyService;
-    let mockFs;
-    let mockFsPromises;
-    let mockSpawn;
     (0, vitest_1.beforeEach)(() => {
         program = new commander_1.Command();
-        // Mock ApiKeyService
-        mockApiKeyService = {
-            create: vitest_1.vi.fn(),
-            list: vitest_1.vi.fn(),
-            rotate: vitest_1.vi.fn(),
-        };
-        vitest_1.vi.mocked(api_key_service_1.ApiKeyService.getInstance).mockReturnValue(mockApiKeyService);
-        // Mock fs
-        mockFs = vitest_1.vi.mocked(fs);
-        mockFs.existsSync = vitest_1.vi.fn();
-        mockFs.readFileSync = vitest_1.vi.fn();
-        // Mock fs/promises
-        mockFsPromises = vitest_1.vi.mocked({ readFile: promises_1.readFile, writeFile: promises_1.writeFile });
-        mockFsPromises.readFile = vitest_1.vi.fn();
-        mockFsPromises.writeFile = vitest_1.vi.fn();
-        // Mock spawn
-        mockSpawn = vitest_1.vi.fn();
-        vitest_1.vi.doMock('child_process', () => ({ spawn: mockSpawn }));
         (0, code_1.registerCodeCommands)(program);
     });
-    (0, vitest_1.afterEach)(() => {
-        vitest_1.vi.clearAllMocks();
-    });
     (0, vitest_1.describe)('code init command', () => {
         (0, vitest_1.it)('should register init command with correct description', () => {
             const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
             const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
             (0, vitest_1.expect)(initCommand).toBeDefined();
-            (0, vitest_1.expect)(initCommand?.description()).toBe('Initialize project for AI coding assistant');
-        });
-        (0, vitest_1.it)('should have name, force, and yes options', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
-            (0, vitest_1.expect)(initCommand).toBeDefined();
-            const nameOption = initCommand?.options.find((opt) => opt.long === '--name');
-            const forceOption = initCommand?.options.find((opt) => opt.long === '--force');
-            const yesOption = initCommand?.options.find((opt) => opt.long === '--yes');
-            (0, vitest_1.expect)(nameOption).toBeDefined();
-            (0, vitest_1.expect)(nameOption?.description).toContain('Project name');
-            (0, vitest_1.expect)(forceOption).toBeDefined();
-            (0, vitest_1.expect)(forceOption?.description).toContain('Overwrite existing configuration');
-            (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption?.description).toContain('Automatically answer yes');
-        });
-        (0, vitest_1.it)('should check if opencode is installed', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
-            (0, vitest_1.expect)(initCommand).toBeDefined();
-            // The command should attempt to spawn opencode --version
-            // This is tested implicitly through the spawn mock
-        });
-        (0, vitest_1.it)('should list existing API keys and allow selection', async () => {
-            // Mock successful opencode installation check
-            mockSpawn.mockImplementation((command, arguments_) => {
-                if (command === 'opencode' && arguments_[0] === '--version') {
-                    return {
-                        on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === 'close')
-                                callback(0);
-                        }),
-                    };
-                }
-                return { on: vitest_1.vi.fn() };
-            });
-            // Mock existing API keys
-            const mockExistingKeys = [
-                {
-                    created: '2023-01-01T00:00:00.000Z',
-                    id: 1,
-                    lastUsed: null,
-                    name: 'existing-key-1',
-                    prefix: 'sk_ber',
-                },
-                {
-                    created: '2023-01-02T00:00:00.000Z',
-                    id: 2,
-                    lastUsed: '2023-01-03T00:00:00.000Z',
-                    name: 'existing-key-2',
-                    prefix: 'sk_ber',
-                },
-            ];
-            mockApiKeyService.list.mockResolvedValue(mockExistingKeys);
-            // Mock file operations
-            mockFs.existsSync.mockReturnValue(false);
-            mockFsPromises.writeFile.mockResolvedValue();
-            // Verify that the list method is called
-            (0, vitest_1.expect)(mockApiKeyService.list).toBeDefined();
+            (0, vitest_1.expect)(initCommand?.description()).toBe('Interactive setup for Berget AI coding tools');
         });
-        (0, vitest_1.it)('should create new API key with project-based naming', async () => {
-            // Mock successful opencode installation check
-            mockSpawn.mockImplementation((command, arguments_) => {
-                if (command === 'opencode' && arguments_[0] === '--version') {
-                    return {
-                        on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === 'close')
-                                callback(0);
-                        }),
-                    };
-                }
-                return { on: vitest_1.vi.fn() };
-            });
-            // Mock no existing keys
-            mockApiKeyService.list.mockResolvedValue([]);
-            // Mock successful API key creation
-            const mockApiKeyData = {
-                id: 123,
-                key: 'test-api-key-12345',
-                name: 'opencode-testproject-1234567890',
-            };
-            mockApiKeyService.create.mockResolvedValue(mockApiKeyData);
-            // Mock file operations
-            mockFs.existsSync.mockReturnValue(false);
-            mockFsPromises.writeFile.mockResolvedValue();
-            // Verify that the create method is available
-            (0, vitest_1.expect)(mockApiKeyService.create).toBeDefined();
-        });
-        (0, vitest_1.it)('should create opencode.json with correct structure', async () => {
-            // This tests the expected config structure
-            const expectedConfig = {
-                apiKey: 'test-api-key',
-                created: vitest_1.expect.any(String),
-                model: 'berget/glm-4-6',
-                projectName: 'testproject',
-                provider: 'berget',
-                version: '1.0.0',
-            };
-            (0, vitest_1.expect)(expectedConfig.model).toBe('berget/glm-4-6');
-            (0, vitest_1.expect)(expectedConfig.provider).toBe('berget');
-            (0, vitest_1.expect)(expectedConfig.version).toBe('1.0.0');
-        });
-        (0, vitest_1.it)('should handle existing config file', () => {
+        (0, vitest_1.it)('should not have any other subcommands', () => {
             const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
-            (0, vitest_1.expect)(initCommand).toBeDefined();
-            // Should check if opencode.json exists before proceeding
-            (0, vitest_1.expect)(mockFs.existsSync).toBeDefined();
-        });
-    });
-    (0, vitest_1.describe)('code run command', () => {
-        (0, vitest_1.it)('should register run command with correct description', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
-            (0, vitest_1.expect)(runCommand).toBeDefined();
-            (0, vitest_1.expect)(runCommand?.description()).toBe('Run AI coding assistant');
-        });
-        (0, vitest_1.it)('should accept prompt argument and model, no-config, and yes options', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
-            (0, vitest_1.expect)(runCommand).toBeDefined();
-            const modelOption = runCommand?.options.find((opt) => opt.long === '--model');
-            const noConfigOption = runCommand?.options.find((opt) => opt.long === '--no-config');
-            const yesOption = runCommand?.options.find((opt) => opt.long === '--yes');
-            (0, vitest_1.expect)(modelOption).toBeDefined();
-            (0, vitest_1.expect)(modelOption?.description).toContain('Model to use');
-            (0, vitest_1.expect)(noConfigOption).toBeDefined();
-            (0, vitest_1.expect)(noConfigOption?.description).toContain('Run without loading project config');
-            (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption?.description).toContain('Automatically answer yes');
-        });
-        (0, vitest_1.it)('should load configuration from opencode.json', async () => {
-            const mockConfig = {
-                apiKey: 'test-api-key',
-                created: '2023-01-01T00:00:00.000Z',
-                model: 'berget/glm-4-6',
-                projectName: 'testproject',
-                provider: 'berget',
-                version: '1.0.0',
-            };
-            // Mock file exists and contains config
-            mockFs.existsSync.mockReturnValue(true);
-            mockFsPromises.readFile.mockResolvedValue(JSON.stringify(mockConfig));
-            // Mock successful opencode check
-            mockSpawn.mockImplementation((command, arguments_) => {
-                if (command === 'opencode' && arguments_[0] === '--version') {
-                    return {
-                        on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === 'close')
-                                callback(0);
-                        }),
-                    };
-                }
-                return { on: vitest_1.vi.fn() };
-            });
-            // Verify config structure expectations
-            (0, vitest_1.expect)(mockConfig.model).toBe('berget/glm-4-6');
-            (0, vitest_1.expect)(mockConfig.apiKey).toBe('test-api-key');
-            (0, vitest_1.expect)(mockConfig.projectName).toBe('testproject');
-        });
-        (0, vitest_1.it)('should spawn opencode with correct arguments', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
-            (0, vitest_1.expect)(runCommand).toBeDefined();
-            // Should spawn opencode with appropriate arguments
-            (0, vitest_1.expect)(mockSpawn).toBeDefined();
-        });
-        (0, vitest_1.it)('should handle missing configuration file', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
-            (0, vitest_1.expect)(runCommand).toBeDefined();
-            // Should check if opencode.json exists
-            (0, vitest_1.expect)(mockFs.existsSync).toBeDefined();
-        });
-    });
-    (0, vitest_1.describe)('opencode installation', () => {
-        (0, vitest_1.it)('should check if opencode is installed', () => {
-            // The spawn function should be called with opencode --version
-            (0, vitest_1.expect)(mockSpawn).toBeDefined();
-        });
-        (0, vitest_1.it)('should offer to install opencode if not found', () => {
-            // Mock opencode not installed
-            mockSpawn.mockImplementation((command, arguments_) => {
-                if (command === 'opencode' && arguments_[0] === '--version') {
-                    return {
-                        on: vitest_1.vi.fn().mockImplementation((event, callback) => {
-                            if (event === 'close')
-                                callback(1); // Non-zero exit code
-                        }),
-                    };
-                }
-                return { on: vitest_1.vi.fn() };
-            });
-            // Should handle the case where opencode is not installed
-            (0, vitest_1.expect)(mockSpawn).toBeDefined();
-        });
-        (0, vitest_1.it)('should install opencode via npm if user agrees', () => {
-            // Should spawn npm install -g opencode-ai
-            (0, vitest_1.expect)(mockSpawn).toBeDefined();
-        });
-    });
-    (0, vitest_1.describe)('automation support', () => {
-        (0, vitest_1.it)('should support -y flag for automated initialization', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
-            (0, vitest_1.expect)(initCommand).toBeDefined();
-            const yesOption = initCommand?.options.find((opt) => opt.long === '--yes');
-            (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption?.description).toContain('automation');
-        });
-        (0, vitest_1.it)('should support -y flag for automated run', () => {
-            const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-            const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
-            (0, vitest_1.expect)(runCommand).toBeDefined();
-            const yesOption = runCommand?.options.find((opt) => opt.long === '--yes');
-            (0, vitest_1.expect)(yesOption).toBeDefined();
-            (0, vitest_1.expect)(yesOption?.description).toContain('automation');
-        });
-        (0, vitest_1.it)('should use BERGET_API_KEY environment variable in automation mode', () => {
-            // Test that environment variable is used when -y flag is set
-            process.env.BERGET_API_KEY = 'test-env-key';
-            (0, vitest_1.expect)(process.env.BERGET_API_KEY).toBe('test-env-key');
-            // Clean up
-            delete process.env.BERGET_API_KEY;
-        });
-    });
-    (0, vitest_1.describe)('.env file handling', () => {
-        let mockUpdateEnvironmentFile;
-        (0, vitest_1.beforeEach)(() => {
-            mockUpdateEnvironmentFile = vitest_1.vi.mocked(env_manager_1.updateEnvFile);
-        });
-        (0, vitest_1.it)('should call updateEnvFile when creating new project', async () => {
-            mockUpdateEnvironmentFile.mockResolvedValue(true);
-            mockFs.existsSync.mockReturnValue(false); // .env doesn't exist
-            mockFsPromises.writeFile.mockResolvedValue();
-            // This would be tested by actually calling the init command
-            // For now we verify the mock is properly set up
-            (0, vitest_1.expect)(mockUpdateEnvironmentFile).toBeDefined();
-        });
-        (0, vitest_1.it)('should not overwrite existing BERGET_API_KEY in .env', async () => {
-            const consoleSpy = vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
-            // Mock existing .env with BERGET_API_KEY
-            mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue('BERGET_API_KEY=existing_key\nOTHER_KEY=value\n');
-            // Mock updateEnvFile to simulate the check
-            mockUpdateEnvironmentFile.mockImplementation(async (options) => {
-                if (options.key === 'BERGET_API_KEY' && !options.force) {
-                    console.log(`⚠ ${options.key} already exists in .env - leaving unchanged`);
-                    return false;
-                }
-                return true;
-            });
-            await (0, env_manager_1.updateEnvFile)({
-                key: 'BERGET_API_KEY',
-                value: 'new_key',
-            });
-            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('BERGET_API_KEY already exists in .env - leaving unchanged'));
-            consoleSpy.mockRestore();
-        });
-        (0, vitest_1.it)('should add new key to existing .env file', async () => {
-            mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue('EXISTING_KEY=value\n');
-            mockUpdateEnvironmentFile.mockResolvedValue(true);
-            await (0, env_manager_1.updateEnvFile)({
-                comment: 'Berget AI Configuration',
-                key: 'BERGET_API_KEY',
-                value: 'new_api_key',
-            });
-            (0, vitest_1.expect)(mockUpdateEnvironmentFile).toHaveBeenCalledWith({
-                comment: 'Berget AI Configuration',
-                key: 'BERGET_API_KEY',
-                value: 'new_api_key',
-            });
-        });
-        (0, vitest_1.it)('should create new .env file when none exists', async () => {
-            mockFs.existsSync.mockReturnValue(false);
-            mockUpdateEnvironmentFile.mockResolvedValue(true);
-            await (0, env_manager_1.updateEnvFile)({
-                key: 'BERGET_API_KEY',
-                value: 'new_api_key',
-            });
-            (0, vitest_1.expect)(mockUpdateEnvironmentFile).toHaveBeenCalledWith({
-                key: 'BERGET_API_KEY',
-                value: 'new_api_key',
-            });
-        });
-    });
-    (0, vitest_1.describe)('error handling', () => {
-        (0, vitest_1.it)('should handle API key creation failures', () => {
-            // Mock API key service to throw error
-            mockApiKeyService.create.mockRejectedValue(new Error('API Error'));
-            (0, vitest_1.expect)(mockApiKeyService.create).toBeDefined();
-        });
-        (0, vitest_1.it)('should handle file system errors', () => {
-            // Mock file operations to throw errors
-            mockFsPromises.writeFile.mockRejectedValue(new Error('File write error'));
-            (0, vitest_1.expect)(mockFsPromises.writeFile).toBeDefined();
-        });
-        (0, vitest_1.it)('should handle spawn errors', () => {
-            // Mock spawn to throw error
-            mockSpawn.mockImplementation(() => {
-                throw new Error('Command not found');
-            });
-            (0, vitest_1.expect)(mockSpawn).toBeDefined();
-        });
-        (0, vitest_1.it)('should handle .env update failures', async () => {
-            const mockUpdateEnvironmentFile = vitest_1.vi.mocked(env_manager_1.updateEnvFile);
-            mockUpdateEnvironmentFile.mockRejectedValue(new Error('Env update failed'));
-            await (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
-                key: 'TEST_KEY',
-                value: 'test_value',
-            })).rejects.toThrow('Env update failed');
-        });
-    });
-    (0, vitest_1.describe)('experimental features', () => {
-        let originalEnvironment;
-        (0, vitest_1.beforeEach)(() => {
-            originalEnvironment = process.env.BERGET_EXPERIMENTAL;
-        });
-        (0, vitest_1.afterEach)(() => {
-            if (originalEnvironment === undefined) {
-                delete process.env.BERGET_EXPERIMENTAL;
-            }
-            else {
-                process.env.BERGET_EXPERIMENTAL = originalEnvironment;
-            }
-        });
-        (0, vitest_1.it)('should NOT show setup command when BERGET_EXPERIMENTAL is not set', () => {
-            delete process.env.BERGET_EXPERIMENTAL;
-            const freshProgram = new commander_1.Command();
-            (0, code_1.registerCodeCommands)(freshProgram);
-            const codeCommand = freshProgram.commands.find((cmd) => cmd.name() === 'code');
-            const setupCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'setup');
-            (0, vitest_1.expect)(setupCommand).toBeUndefined();
-        });
-        (0, vitest_1.it)('should show setup command when BERGET_EXPERIMENTAL is set', () => {
-            process.env.BERGET_EXPERIMENTAL = '1';
-            const freshProgram = new commander_1.Command();
-            (0, code_1.registerCodeCommands)(freshProgram);
-            const codeCommand = freshProgram.commands.find((cmd) => cmd.name() === 'code');
-            const setupCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'setup');
-            (0, vitest_1.expect)(setupCommand).toBeDefined();
-            (0, vitest_1.expect)(setupCommand?.description()).toBe('Interactive setup for Berget AI coding tools');
+            (0, vitest_1.expect)(codeCommand?.commands).toHaveLength(1);
+            (0, vitest_1.expect)(codeCommand?.commands[0]?.name()).toBe('init');
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "berget",
-  "version": "2.2.11",
+  "version": "2.2.12",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"