berget 2.2.4 → 2.2.6

package/dist/src/constants/command-structure.js

@@ -39,6 +39,7 @@ exports.SUBCOMMANDS = {
         RUN: 'run',
         UPDATE: 'update',
         SERVE: 'serve',
+        SETUP: 'setup',
     },
     // API Keys commands
     API_KEYS: {
@@ -171,6 +172,7 @@ exports.COMMAND_DESCRIPTIONS = {
     [`${exports.COMMAND_GROUPS.CHAT} ${exports.SUBCOMMANDS.CHAT.LIST}`]: 'List available chat models',
     // Code group
     [exports.COMMAND_GROUPS.CODE]: 'AI-powered coding assistant with OpenCode',
+    [`${exports.COMMAND_GROUPS.CODE} ${exports.SUBCOMMANDS.CODE.SETUP}`]: 'Interactive setup for Berget AI coding tools',
     [`${exports.COMMAND_GROUPS.CODE} ${exports.SUBCOMMANDS.CODE.INIT}`]: 'Initialize project for AI coding assistant',
     [`${exports.COMMAND_GROUPS.CODE} ${exports.SUBCOMMANDS.CODE.RUN}`]: 'Run AI coding assistant',
     [`${exports.COMMAND_GROUPS.CODE} ${exports.SUBCOMMANDS.CODE.SERVE}`]: 'Start OpenCode web server',

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

@@ -411,4 +411,35 @@ vitest_1.vi.mock('readline', () => ({
             })).rejects.toThrow('Env update failed');
         }));
     });
+    (0, vitest_1.describe)('experimental features', () => {
+        let originalEnv;
+        (0, vitest_1.beforeEach)(() => {
+            originalEnv = process.env.BERGET_EXPERIMENTAL;
+        });
+        (0, vitest_1.afterEach)(() => {
+            if (originalEnv === undefined) {
+                delete process.env.BERGET_EXPERIMENTAL;
+            }
+            else {
+                process.env.BERGET_EXPERIMENTAL = originalEnv;
+            }
+        });
+        (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 === null || codeCommand === void 0 ? void 0 : 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 === null || codeCommand === void 0 ? void 0 : codeCommand.commands.find((cmd) => cmd.name() === 'setup');
+            (0, vitest_1.expect)(setupCommand).toBeDefined();
+            (0, vitest_1.expect)(setupCommand === null || setupCommand === void 0 ? void 0 : setupCommand.description()).toBe('Interactive setup for Berget AI coding tools');
+        });
+    });
 });

package/dist/tests/utils/opencode-validator.test.js

@@ -81,23 +81,24 @@ const fs_1 = require("fs");
     });
     (0, vitest_1.it)('should validate the current opencode.json file', () => {
         var _a;
+        let currentConfig;
         try {
-            const currentConfig = JSON.parse((0, fs_1.readFileSync)('opencode.json', 'utf8'));
-            // Apply fixes to handle common issues
-            const fixedConfig = (0, opencode_validator_1.fixOpenCodeConfig)(currentConfig);
-            // Validate the fixed config
-            const result = (0, opencode_validator_1.validateOpenCodeConfig)(fixedConfig);
-            // The fixed config should be valid according to the JSON Schema
-            (0, vitest_1.expect)(result.valid).toBe(true);
-            if (!result.valid) {
-                console.log('Fixed opencode.json validation errors:');
-                (_a = result.errors) === null || _a === void 0 ? void 0 : _a.forEach((err) => console.log(`  - ${err}`));
-            }
+            currentConfig = JSON.parse((0, fs_1.readFileSync)('opencode.json', 'utf8'));
         }
         catch (error) {
-            // If we can't read the file, that's ok for this test
-            console.log('Could not read opencode.json for testing:', error);
-            vitest_1.expect.fail('Should be able to read opencode.json');
+            // Skip when opencode.json is not present (e.g. in CI or clean checkouts)
+            console.log('Skipping: opencode.json not found:', error);
+            return;
+        }
+        // Apply fixes to handle common issues
+        const fixedConfig = (0, opencode_validator_1.fixOpenCodeConfig)(currentConfig);
+        // Validate the fixed config
+        const result = (0, opencode_validator_1.validateOpenCodeConfig)(fixedConfig);
+        // The fixed config should be valid according to the JSON Schema
+        (0, vitest_1.expect)(result.valid).toBe(true);
+        if (!result.valid) {
+            console.log('Fixed opencode.json validation errors:');
+            (_a = result.errors) === null || _a === void 0 ? void 0 : _a.forEach((err) => console.log(`  - ${err}`));
         }
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "berget",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"
@@ -33,12 +33,14 @@
     "vitest": "^1.0.0"
   },
   "dependencies": {
+    "@clack/prompts": "^0.10.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "chalk": "^4.1.2",
     "commander": "^12.0.0",
     "dotenv": "^17.2.3",
     "fs-extra": "^11.3.0",
+    "jsonc-parser": "^3.3.1",
     "marked": "^9.1.6",
     "marked-terminal": "^6.2.0",
     "open": "^9.1.0",

package/src/commands/code/__tests__/fake-command-runner.ts

@@ -0,0 +1,47 @@
+import type { CommandRunner } from '../ports/command-runner'
+
+type Handler = {
+	match: (command: string, args: readonly string[]) => boolean
+	response: string | Error | ((command: string, args: readonly string[]) => string | Error)
+}
+
+export class FakeCommandRunner implements CommandRunner {
+	private handlers: Handler[] = []
+	private _calls: Array<{ command: string; args: string[]; options?: { cwd?: string } }> = []
+
+	handle(match: string | RegExp, response: string | Error): this {
+		this.handlers.push({
+			match: (cmd, args) => {
+				const full = `${cmd} ${args.join(' ')}`
+				if (typeof match === 'string') return full.startsWith(match)
+				return match.test(full)
+			},
+			response,
+		})
+		return this
+	}
+
+	checkInstalled(binary: string): Promise<boolean> {
+		this._calls.push({ command: `check:${binary}`, args: [] })
+		return Promise.resolve(
+			this.handlers.some(h => h.match(binary, ['--version'])) || false
+		)
+	}
+
+	async run(command: string, args: readonly string[], options?: { cwd?: string }): Promise<string> {
+		this._calls.push({ command, args: [...args], options })
+		const handler = this.handlers.find(h => h.match(command, args))
+		if (!handler) throw new Error(`Unexpected command: ${command} ${args.join(' ')}`)
+
+		const result = typeof handler.response === 'function'
+			? handler.response(command, args)
+			: handler.response
+
+		if (result instanceof Error) throw result
+		return result
+	}
+
+	get calls() {
+		return this._calls
+	}
+}

package/src/commands/code/__tests__/fake-file-store.ts

@@ -0,0 +1,35 @@
+import type { FileStore } from '../ports/file-store'
+
+export interface FileEntry {
+	content: string
+	isDirectory?: boolean
+}
+
+export class FakeFileStore implements FileStore {
+	private files: Map<string, string> = new Map()
+	private dirs: Set<string> = new Set()
+
+	seed(path: string, content: string): void {
+		this.files.set(path, content)
+	}
+
+	async exists(path: string): Promise<boolean> {
+		return this.files.has(path) || this.dirs.has(path)
+	}
+
+	async readFile(path: string): Promise<string | null> {
+		return this.files.get(path) ?? null
+	}
+
+	async writeFile(path: string, content: string): Promise<void> {
+		this.files.set(path, content)
+	}
+
+	async mkdir(path: string): Promise<void> {
+		this.dirs.add(path)
+	}
+
+	getWrittenFiles(): Map<string, string> {
+		return new Map(this.files)
+	}
+}

package/src/commands/code/__tests__/fake-prompter.ts

@@ -0,0 +1,83 @@
+import { CancelledError } from '../errors'
+import type { Prompter, Spinner } from '../ports/prompter'
+
+export const CANCEL = Symbol('cancel')
+
+type PromptEntry =
+	| { kind: 'select'; match?: RegExp; response: string | symbol }
+	| { kind: 'confirm'; match?: RegExp; response: boolean | symbol }
+
+export const select = <T>(
+	value: T | symbol,
+	match?: string | RegExp
+): PromptEntry => ({
+	kind: 'select',
+	match: typeof match === 'string' ? new RegExp(match) : match,
+	response: typeof value === 'symbol' ? value : String(value),
+})
+
+export const confirm = (
+	value: boolean | symbol,
+	match?: string | RegExp
+): PromptEntry => ({
+	kind: 'confirm',
+	match: typeof match === 'string' ? new RegExp(match) : match,
+	response: value,
+})
+
+export class FakePrompter implements Prompter {
+	private _calls: Array<{ method: string; args: unknown }> = []
+	private _cursor = 0
+
+	constructor(private readonly _script: PromptEntry[]) {}
+
+	intro(message: string): void {
+		this._calls.push({ method: 'intro', args: { message } })
+	}
+	outro(message: string): void {
+		this._calls.push({ method: 'outro', args: { message } })
+	}
+	note(message: string, title?: string): void {
+		this._calls.push({ method: 'note', args: { message, title } })
+	}
+	spinner(): Spinner {
+		return {
+			start: (msg: string) => {
+				this._calls.push({ method: 'spinner.start', args: { message: msg } })
+			},
+			stop: (msg: string) => {
+				this._calls.push({ method: 'spinner.stop', args: { message: msg } })
+			},
+		}
+	}
+
+	async select<T>(opts: { message: string }): Promise<T> {
+		this._calls.push({ method: 'select', args: opts })
+		const entry = this._script[this._cursor++]
+		if (!entry) throw new Error(`No script entry for select #${this._cursor} (${opts.message})`)
+		if (entry.kind !== 'select') throw new Error(`Expected confirm, got select for ${opts.message}`)
+		if (entry.match && !entry.match.test(opts.message)) throw new Error(`Message mismatch: got "${opts.message}"`)
+		if (entry.response === CANCEL) throw new CancelledError()
+		return entry.response as T
+	}
+
+	async confirm(opts: { message: string }): Promise<boolean> {
+		this._calls.push({ method: 'confirm', args: opts })
+		const entry = this._script[this._cursor++]
+		if (!entry) throw new Error(`No script entry for confirm #${this._cursor} (${opts.message})`)
+		if (entry.kind !== 'confirm') throw new Error(`Expected select, got confirm for ${opts.message}`)
+		if (entry.match && !entry.match.test(opts.message)) throw new Error(`Message mismatch: got "${opts.message}"`)
+		if (entry.response === CANCEL) throw new CancelledError()
+		return entry.response as boolean
+	}
+
+	get calls() {
+		return this._calls
+	}
+
+	assertExhausted() {
+		if (this._cursor !== this._script.length) {
+			throw new Error(`Script not exhausted: ${this._script.length - this._cursor} entries left`)
+		}
+	}
+}

package/src/commands/code/__tests__/setup-flow.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from 'vitest'
+import { runSetup } from '../setup'
+import { CancelledError, CommandFailedError, PrerequisiteError } from '../errors'
+import { FakePrompter, CANCEL, select, confirm } from './fake-prompter'
+import { FakeFileStore } from './fake-file-store'
+import { FakeCommandRunner } from './fake-command-runner'
+
+const makeDeps = (overrides: Partial<Parameters<typeof runSetup>[0]> = {}) => ({
+	prompter: new FakePrompter([]),
+	files: new FakeFileStore(),
+	commands: new FakeCommandRunner()
+		.handle('opencode --version', 'mocked')
+		.handle('pi --version', 'mocked'),
+	homeDir: '/home/user',
+	cwd: '/home/user/project',
+	...overrides,
+})
+
+describe('runSetup', () => {
+	describe('happy path', () => {
+		it('sets up opencode project without existing config', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('project'),
+					confirm(true, 'Create'),
+				]),
+			})
+
+			await runSetup(deps)
+			
+			const files = deps.files as FakeFileStore
+			const written = files.getWrittenFiles()
+			expect(written.has('/home/user/project/opencode.json')).toBe(true)
+			const config = JSON.parse(written.get('/home/user/project/opencode.json')!)
+			expect(config.plugin).toContain('@bergetai/opencode-auth@1.0.16')
+		})
+
+		it('sets up opencode globally without existing config', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('global'),
+					confirm(true, 'Create'),
+				]),
+			})
+
+			await runSetup(deps)
+			
+			const files = deps.files as FakeFileStore
+			const written = files.getWrittenFiles()
+			expect(written.has('/home/user/.config/opencode/opencode.json')).toBe(true)
+		})
+
+		it('sets up pi project with fresh install', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('pi'),
+					select('project'),
+					confirm(true, 'Proceed'),
+				]),
+				commands: new FakeCommandRunner()
+					.handle('pi --version', 'mocked') // For checkInstalled
+					.handle('pi install', ''), // For actual install
+			})
+
+			await runSetup(deps)
+			
+			const commands = deps.commands as FakeCommandRunner
+			expect(commands.calls.length).toBeGreaterThan(0)
+			const installCall = commands.calls.find(c => c.command === 'pi')
+			expect(installCall?.args).toContain('npm:@bergetai/pi-provider')
+		})
+	})
+
+	describe('prerequisites', () => {
+		it('throws PrerequisiteError when opencode is not installed', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('project'),
+				]),
+				commands: new FakeCommandRunner(),
+			})
+			
+			// Simulate opencode not being installed
+			await expect(runSetup(deps)).rejects.toBeInstanceOf(PrerequisiteError)
+		})
+	})
+
+	describe('cancellation', () => {
+		it('throws CancelledError when user cancels at tool selection', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select(CANCEL),
+				]),
+			})
+
+			await expect(runSetup(deps)).rejects.toBeInstanceOf(CancelledError)
+		})
+
+		it('throws CancelledError when user cancels at write confirmation', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('project'),
+					confirm(false, 'Create'),
+				]),
+			})
+
+			await expect(runSetup(deps)).rejects.toBeInstanceOf(CancelledError)
+		})
+	})
+
+	describe('file operations', () => {
+		it('preserves existing configuration keys when updating', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('project'),
+					confirm(true, 'Write'),
+				]),
+			})
+			
+			const files = deps.files as FakeFileStore
+			files.seed('/home/user/project/opencode.json', JSON.stringify({
+				customField: 'should-preserve',
+				plugin: ['other-plugin'],
+			}))
+
+			await runSetup(deps)
+
+			const written = files.getWrittenFiles()
+			const config = JSON.parse(written.get('/home/user/project/opencode.json')!)
+			expect(config.customField).toBe('should-preserve')
+			expect(config.plugin).toContain('other-plugin')
+			expect(config.plugin).toContain('@bergetai/opencode-auth@1.0.16')
+		})
+
+		it('preserves jsonc comments when updating', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('project'),
+					confirm(true, 'Write'),
+				]),
+			})
+			
+			const files = deps.files as FakeFileStore
+			files.seed('/home/user/project/opencode.jsonc', `{
+  // This is my custom config
+  "customField": "should-preserve",
+  /* block comment explaining plugin */
+  "plugin": ["other-plugin"]
+}`)
+
+			await runSetup(deps)
+
+			const written = files.getWrittenFiles()
+			const content = written.get('/home/user/project/opencode.jsonc')!
+			expect(content).toContain('// This is my custom config')
+			expect(content).toContain('/* block comment explaining plugin */')
+			expect(content).toContain('"customField": "should-preserve"')
+			expect(content).toContain('@bergetai/opencode-auth@1.0.16')
+		})
+
+		it('shows no changes needed when config is already up to date', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('project'),
+				]),
+			})
+			
+			const files = deps.files as FakeFileStore
+			// Already has the exact same plugin version
+			files.seed('/home/user/project/opencode.json', JSON.stringify({
+				$schema: 'https://opencode.ai/config.json',
+				plugin: ['@bergetai/opencode-auth@1.0.16'],
+			}, null, 2) + '\n')
+
+			await runSetup(deps)
+
+			// Check that no write happened — content should be unchanged
+			const written = files.getWrittenFiles()
+			const content = written.get('/home/user/project/opencode.json')!
+			const config = JSON.parse(content)
+			expect(config.plugin).toEqual(['@bergetai/opencode-auth@1.0.16'])
+			expect(content).toContain('$schema')
+		})
+
+		it('preserves existing Pi settings when setting defaultProvider', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('pi'),
+					select('project'),
+					confirm(true, 'Proceed'),
+				]),
+				commands: new FakeCommandRunner()
+					.handle('pi --version', 'mocked')
+					.handle('pi install', ''),
+			})
+
+			const files = deps.files as FakeFileStore
+			files.seed('/home/user/project/.pi/settings.json', JSON.stringify({
+				existingKey: 'should-preserve',
+				anotherSetting: true,
+			}))
+
+			await runSetup(deps)
+
+			const written = files.getWrittenFiles()
+			const settings = JSON.parse(written.get('/home/user/project/.pi/settings.json')!)
+			expect(settings.existingKey).toBe('should-preserve')
+			expect(settings.anotherSetting).toBe(true)
+			expect(settings.defaultProvider).toBe('berget')
+		})
+
+		it('creates parent directories when writing files', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('opencode'),
+					select('global'),
+					confirm(true, 'Create'),
+				]),
+			})
+
+			await runSetup(deps)
+
+			const files = deps.files as FakeFileStore
+			const written = files.getWrittenFiles()
+			expect(written.has('/home/user/.config/opencode/opencode.json')).toBe(true)
+		})
+	})
+
+	describe('command execution', () => {
+		it('passes arguments as array (no shell injection)', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('pi'),
+					select('project'),
+					confirm(true, 'Proceed'),
+				]),
+				commands: new FakeCommandRunner()
+					.handle('pi --version', 'mocked')
+					.handle('pi install', ''),
+			})
+
+			await runSetup(deps)
+
+			const commands = deps.commands as FakeCommandRunner
+			const installCall = commands.calls.find(c => c.command === 'pi')
+			expect(installCall?.args).toContain('npm:@bergetai/pi-provider')
+			expect(installCall?.args).toContain('-l')
+		})
+	})
+
+	describe('error handling', () => {
+		it('throws CommandFailedError when pi install fails', async () => {
+			const deps = makeDeps({
+				prompter: new FakePrompter([
+					select('pi'),
+					select('project'),
+					confirm(true, 'Proceed'),
+				]),
+				commands: new FakeCommandRunner()
+					.handle('pi --version', 'mocked')
+					.handle('pi install', new Error('npm error')),
+			})
+
+			await expect(runSetup(deps)).rejects.toBeInstanceOf(CommandFailedError)
+		})
+	})
+})

package/src/commands/code/adapters/clack-prompter.ts

@@ -0,0 +1,43 @@
+import * as p from '@clack/prompts'
+import { CancelledError } from '../errors'
+import type { Prompter, Spinner } from '../ports/prompter'
+
+const unwrap = <T>(v: T | symbol): T => {
+	if (p.isCancel(v)) throw new CancelledError()
+	return v as T
+}
+
+export class ClackPrompter implements Prompter {
+	intro(message: string): void {
+		p.intro(message)
+	}
+	outro(message: string): void {
+		p.outro(message)
+	}
+	note(message: string, title?: string): void {
+		p.note(message, title)
+	}
+	spinner(): Spinner {
+		const s = p.spinner()
+		return {
+			start: (msg: string) => s.start(msg),
+			stop: (msg: string) => s.stop(msg),
+		}
+	}
+	async select<T>(opts: {
+		message: string
+		options: ReadonlyArray<{
+			value: T
+			label: string
+			hint?: string
+		}>
+	}): Promise<T> {
+		return unwrap(await p.select(opts as any))
+	}
+	async confirm(opts: {
+		message: string
+		initialValue?: boolean
+	}): Promise<boolean> {
+		return unwrap(await p.confirm(opts))
+	}
+}

package/src/commands/code/adapters/fs-file-store.ts

@@ -0,0 +1,33 @@
+import { promises as fs } from 'node:fs'
+import * as path from 'node:path'
+import type { FileStore } from '../ports/file-store'
+
+export class FsFileStore implements FileStore {
+	async exists(filePath: string): Promise<boolean> {
+		try {
+			await fs.access(filePath)
+			return true
+		} catch {
+			return false
+		}
+	}
+
+	async readFile(filePath: string): Promise<string | null> {
+		try {
+			return await fs.readFile(filePath, 'utf8')
+		} catch (err: any) {
+			if (err.code === 'ENOENT') return null
+			throw err
+		}
+	}
+
+	async writeFile(filePath: string, content: string): Promise<void> {
+		const dir = path.dirname(filePath)
+		await fs.mkdir(dir, { recursive: true })
+		await fs.writeFile(filePath, content, 'utf8')
+	}
+
+	async mkdir(dir: string): Promise<void> {
+		await fs.mkdir(dir, { recursive: true })
+	}
+}

package/src/commands/code/adapters/spawn-command-runner.ts

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process'
+import type { CommandRunner } from '../ports/command-runner'
+
+export class SpawnCommandRunner implements CommandRunner {
+	async checkInstalled(binary: string): Promise<boolean> {
+		return new Promise((resolve) => {
+			const child = spawn('which', [binary], { stdio: 'pipe' })
+			child.on('close', (code) => resolve(code === 0))
+			child.on('error', () => resolve(false))
+		})
+	}
+
+	async run(command: string, args: readonly string[], options?: { cwd?: string }): Promise<string> {
+		return new Promise<string>((resolve, reject) => {
+			const child = spawn(command, args as string[], {
+				stdio: 'pipe',
+				cwd: options?.cwd || process.cwd(),
+			})
+
+			let stdout = ''
+			let stderr = ''
+
+			child.stdout?.on('data', (d) => { stdout += d.toString() })
+			child.stderr?.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))
+		})
+	}
+}