berget 2.2.6 → 2.2.8

package/dist/tests/utils/env-manager.test.js

@@ -1,134 +1,125 @@
 "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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
 const vitest_1 = require("vitest");
-const fs_1 = __importDefault(require("fs"));
-const promises_1 = require("fs/promises");
-const path_1 = __importDefault(require("path"));
 const env_manager_1 = require("../../src/utils/env-manager");
 vitest_1.vi.mock('fs');
 vitest_1.vi.mock('fs/promises');
 vitest_1.vi.mock('path');
-const mockFs = vitest_1.vi.mocked(fs_1.default);
+const mockFs = vitest_1.vi.mocked(node_fs_1.default);
 const mockWriteFile = vitest_1.vi.mocked(promises_1.writeFile);
-const mockPath = vitest_1.vi.mocked(path_1.default);
+const mockPath = vitest_1.vi.mocked(node_path_1.default);
 (0, vitest_1.describe)('env-manager', () => {
-    const testEnvPath = '/test/.env';
+    const testEnvironmentPath = '/test/.env';
     const testCwd = '/test';
     (0, vitest_1.beforeEach)(() => {
         vitest_1.vi.clearAllMocks();
-        mockPath.join.mockReturnValue(testEnvPath);
+        mockPath.join.mockReturnValue(testEnvironmentPath);
         vitest_1.vi.spyOn(process, 'cwd').mockReturnValue(testCwd);
     });
     (0, vitest_1.afterEach)(() => {
         vitest_1.vi.restoreAllMocks();
     });
     (0, vitest_1.describe)('updateEnvFile', () => {
-        (0, vitest_1.it)('should create a new .env file with the key when file does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.it)('should create a new .env file with the key when file does not exist', async () => {
             mockFs.existsSync.mockReturnValue(false);
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Test comment',
                 key: 'TEST_KEY',
                 value: 'test_value',
-                comment: 'Test comment',
             });
-            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath);
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, '# Test comment\nTEST_KEY=test_value\n');
-        }));
-        (0, vitest_1.it)('should append to existing .env file when key does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, '# Test comment\nTEST_KEY=test_value\n');
+        });
+        (0, vitest_1.it)('should append to existing .env file when key does not exist', async () => {
             const existingContent = 'EXISTING_KEY=existing_value\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Test comment',
                 key: 'NEW_KEY',
                 value: 'new_value',
-                comment: 'Test comment',
             });
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, 'EXISTING_KEY=existing_value\nNEW_KEY=new_value\n');
-        }));
-        (0, vitest_1.it)('should not update when key already exists and force is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, 'EXISTING_KEY=existing_value\nNEW_KEY=new_value\n');
+        });
+        (0, vitest_1.it)('should not update when key already exists and force is false', async () => {
             const existingContent = 'EXISTING_KEY=existing_value\nTEST_KEY=old_value\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
             const consoleSpy = vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
                 key: 'TEST_KEY',
                 value: 'new_value',
             });
             (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('TEST_KEY already exists in .env - leaving unchanged'));
             (0, vitest_1.expect)(mockWriteFile).not.toHaveBeenCalled();
             consoleSpy.mockRestore();
-        }));
-        (0, vitest_1.it)('should update existing key when force is true', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        (0, vitest_1.it)('should update existing key when force is true', async () => {
             const existingContent = 'EXISTING_KEY=existing_value\nTEST_KEY=old_value\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
+                force: true,
                 key: 'TEST_KEY',
                 value: 'new_value',
-                force: true,
             });
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, 'EXISTING_KEY=existing_value\nTEST_KEY=new_value\n');
-        }));
-        (0, vitest_1.it)('should handle complex values with quotes and special characters', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, 'EXISTING_KEY=existing_value\nTEST_KEY=new_value\n');
+        });
+        (0, vitest_1.it)('should handle complex values with quotes and special characters', async () => {
             mockFs.existsSync.mockReturnValue(false);
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
+                comment: 'Complex test',
                 key: 'COMPLEX_KEY',
                 value: 'value with "quotes" and $special',
-                comment: 'Complex test',
             });
-            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvPath, '# Complex test\nCOMPLEX_KEY=value with "quotes" and $special\n');
-        }));
-        (0, vitest_1.it)('should use custom env path when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(testEnvironmentPath, '# Complex test\nCOMPLEX_KEY=value with "quotes" and $special\n');
+        });
+        (0, vitest_1.it)('should use custom env path when provided', async () => {
             const customPath = '/custom/.env';
             mockFs.existsSync.mockReturnValue(false);
-            yield (0, env_manager_1.updateEnvFile)({
+            await (0, env_manager_1.updateEnvFile)({
                 envPath: customPath,
                 key: 'TEST_KEY',
                 value: 'test_value',
             });
             (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(customPath);
             (0, vitest_1.expect)(mockWriteFile).toHaveBeenCalledWith(customPath, 'TEST_KEY=test_value\n');
-        }));
-        (0, vitest_1.it)('should throw error when write fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        (0, vitest_1.it)('should throw error when write fails', async () => {
             mockFs.existsSync.mockReturnValue(false);
             mockWriteFile.mockRejectedValue(new Error('Write error'));
-            yield (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
+            await (0, vitest_1.expect)((0, env_manager_1.updateEnvFile)({
                 key: 'TEST_KEY',
                 value: 'test_value',
             })).rejects.toThrow('Write error');
-        }));
+        });
     });
     (0, vitest_1.describe)('hasEnvKey', () => {
         (0, vitest_1.it)('should return false when .env file does not exist', () => {
             mockFs.existsSync.mockReturnValue(false);
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, 'TEST_KEY');
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(false);
-            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath);
+            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
             (0, vitest_1.expect)(mockFs.readFileSync).not.toHaveBeenCalled();
         });
         (0, vitest_1.it)('should return true when key exists in .env file', () => {
             const existingContent = 'KEY1=value1\nTEST_KEY=test_value\nKEY2=value2\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, 'TEST_KEY');
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(true);
         });
         (0, vitest_1.it)('should return false when key does not exist in .env file', () => {
             const existingContent = 'KEY1=value1\nKEY2=value2\n';
             mockFs.existsSync.mockReturnValue(true);
             mockFs.readFileSync.mockReturnValue(existingContent);
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, 'TEST_KEY');
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(false);
         });
         (0, vitest_1.it)('should return false when .env file is malformed', () => {
@@ -136,13 +127,13 @@ const mockPath = vitest_1.vi.mocked(path_1.default);
             mockFs.readFileSync.mockImplementation(() => {
                 throw new Error('Read error');
             });
-            const result = (0, env_manager_1.hasEnvKey)(testEnvPath, 'TEST_KEY');
+            const result = (0, env_manager_1.hasEnvKey)(testEnvironmentPath, 'TEST_KEY');
             (0, vitest_1.expect)(result).toBe(false);
         });
         (0, vitest_1.it)('should use default path when not provided', () => {
             mockFs.existsSync.mockReturnValue(false);
             (0, env_manager_1.hasEnvKey)(undefined, 'TEST_KEY');
-            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvPath);
+            (0, vitest_1.expect)(mockFs.existsSync).toHaveBeenCalledWith(testEnvironmentPath);
         });
     });
 });

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

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
 const vitest_1 = require("vitest");
 const opencode_validator_1 = require("../../src/utils/opencode-validator");
-const fs_1 = require("fs");
 (0, vitest_1.describe)('OpenCode Validator', () => {
     (0, vitest_1.it)('should validate a correct OpenCode configuration', () => {
         const validConfig = {
             $schema: 'https://opencode.ai/config.json',
-            username: 'test-user',
-            model: 'gpt-4',
             agent: {
                 test: {
                     model: 'gpt-4',
-                    temperature: 0.7,
-                    prompt: 'Test agent',
                     permission: {
-                        edit: 'allow',
                         bash: 'allow',
+                        edit: 'allow',
                         webfetch: 'allow',
                     },
+                    prompt: 'Test agent',
+                    temperature: 0.7,
                 },
             },
+            model: 'gpt-4',
+            username: 'test-user',
         };
         const result = (0, opencode_validator_1.validateOpenCodeConfig)(validConfig);
         (0, vitest_1.expect)(result.valid).toBe(true);
@@ -28,20 +28,20 @@ const fs_1 = require("fs");
     });
     (0, vitest_1.it)('should reject invalid configuration', () => {
         const invalidConfig = {
-            username: 123, // Should be string
-            model: 'gpt-4',
             agent: {
                 test: {
                     model: 'gpt-4',
-                    temperature: 'high', // Should be number
-                    prompt: 'Test agent',
                     permission: {
-                        edit: 'invalid', // Should be enum value
                         bash: 'allow',
+                        edit: 'invalid', // Should be enum value
                         webfetch: 'allow',
                     },
+                    prompt: 'Test agent',
+                    temperature: 'high', // Should be number
                 },
             },
+            model: 'gpt-4',
+            username: 123, // Should be string
         };
         const result = (0, opencode_validator_1.validateOpenCodeConfig)(invalidConfig);
         (0, vitest_1.expect)(result.valid).toBe(false);
@@ -50,23 +50,23 @@ const fs_1 = require("fs");
     });
     (0, vitest_1.it)('should fix common configuration issues', () => {
         const configWithIssues = {
-            username: 'test-user',
-            model: 'gpt-4',
-            tools: {
-                compact: { threshold: 80000 }, // Should be boolean
-            },
             maxTokens: 4000, // Invalid property
+            model: 'gpt-4',
             provider: {
                 berget: {
                     models: {
                         'test-model': {
-                            name: 'Test Model',
-                            maxTokens: 4000, // Should be moved to limit.context
                             contextWindow: 8000, // Should be moved to limit.context
+                            maxTokens: 4000, // Should be moved to limit.context
+                            name: 'Test Model',
                         },
                     },
                 },
             },
+            tools: {
+                compact: { threshold: 80000 }, // Should be boolean
+            },
+            username: 'test-user',
         };
         const fixed = (0, opencode_validator_1.fixOpenCodeConfig)(configWithIssues);
         // tools.compact should be boolean
@@ -80,10 +80,9 @@ const fs_1 = require("fs");
         (0, vitest_1.expect)(fixed.provider.berget.models['test-model'].contextWindow).toBeUndefined();
     });
     (0, vitest_1.it)('should validate the current opencode.json file', () => {
-        var _a;
         let currentConfig;
         try {
-            currentConfig = JSON.parse((0, fs_1.readFileSync)('opencode.json', 'utf8'));
+            currentConfig = JSON.parse((0, node_fs_1.readFileSync)('opencode.json', 'utf8'));
         }
         catch (error) {
             // Skip when opencode.json is not present (e.g. in CI or clean checkouts)
@@ -98,7 +97,9 @@ const fs_1 = require("fs");
         (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}`));
+            if (result.errors)
+                for (const error of result.errors)
+                    console.log(`  - ${error}`);
         }
     });
 });

package/dist/vitest.config.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = require("vitest/config");
 exports.default = (0, config_1.defineConfig)({
     test: {
-        globals: true,
         environment: 'node',
+        globals: true,
     },
 });

package/eslint.config.mjs

@@ -0,0 +1,67 @@
+import vitest from '@vitest/eslint-plugin';
+import perfectionist from 'eslint-plugin-perfectionist';
+import prettier from 'eslint-plugin-prettier';
+import promise from 'eslint-plugin-promise';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  {
+    ignores: [
+      'node_modules/**',
+      'dist/**',
+      'build/**',
+      '*.lock',
+      '.husky/**',
+      'coverage/**',
+      '.nyc_output/**',
+      'test-results/**',
+      'playwright-report/**',
+      '.pi/**',
+      'src/types/api.d.ts',
+    ],
+  },
+  ...tseslint.configs.recommended,
+  ...tseslint.configs.strict,
+  promise.configs['flat/recommended'],
+  perfectionist.configs['recommended-natural'],
+  {
+    files: ['**/*.test.ts', '**/*.spec.ts', '**/*.test.tsx', '**/*.spec.tsx'],
+    languageOptions: {
+      globals: {
+        ...vitest.environments.env.globals,
+      },
+    },
+    plugins: {
+      vitest,
+    },
+    rules: {
+      ...vitest.configs.recommended.rules,
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+    },
+  },
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      ecmaVersion: 'latest',
+      parserOptions: {
+        project: './tsconfig.json',
+        tsconfigRootDir: process.cwd(),
+      },
+      sourceType: 'commonjs',
+    },
+    plugins: {
+      prettier,
+    },
+    rules: {
+      ...prettier.configs.recommended.rules,
+      '@typescript-eslint/no-dynamic-delete': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+      ],
+    },
+  },
+);

package/index.ts

@@ -1,12 +1,11 @@
-#!/usr/bin/env node
+import chalk from 'chalk';
+import { Option, program } from 'commander';
 
-import { program, Option } from 'commander'
-import { registerCommands } from './src/commands'
-import { checkBergetConfig } from './src/utils/config-checker'
-import chalk from 'chalk'
-import { version } from './package.json'
-process.env.DOTENV_CONFIG_OVERRIDE = 'true'
-import 'dotenv/config'
+import { version } from './package.json';
+import { registerCommands } from './src/commands';
+import { checkBergetConfig } from './src/utils/config-checker';
+process.env.DOTENV_CONFIG_OVERRIDE = 'true';
+import 'dotenv/config';
 
 // Set version and description
 program
@@ -20,72 +19,66 @@ program
 \\____/ \\___|_|  \\__, |\\___|\\_\\_ \\_| |_/\\___/ 
                  __/ |                      
                 |___/   AI on European terms
-Version: ${version}`
+Version: ${version}`,
   )
   .version(version, '-v, --version')
   .addOption(new Option('--local').default(false).hideHelp())
   .addOption(new Option('--stage').default(false).hideHelp())
-  .option('--debug', 'Enable debug output', false)
+  .option('--debug', 'Enable debug output', false);
 
 // Register all commands
-registerCommands(program)
+registerCommands(program);
 
 // Check for .bergetconfig if not running a command
 if (process.argv.length <= 2) {
-  checkBergetConfig()
+  checkBergetConfig();
 
   // Show the full help (including logo and commands)
-  program.outputHelp()
-  process.exit(0)
+  program.outputHelp();
+  process.exit(0);
 }
 
 // Add helpful suggestions for common command mistakes
 const commonMistakes: Record<string, string> = {
-  login: 'auth login',
-  logout: 'auth logout',
-  whoami: 'auth whoami',
-  'list-models': 'models list',
-  'list-keys': 'api-keys list',
   'create-key': 'api-keys create',
+  init: 'code init',
   'list-clusters': 'clusters list',
+  'list-keys': 'api-keys list',
+  'list-models': 'models list',
+  login: 'auth login',
+  logout: 'auth logout',
   usage: 'billing usage',
-  init: 'code init',
-}
+  whoami: 'auth whoami',
+};
 
 // Add error handler for unknown commands
 program.on('command:*', (operands) => {
-  const unknownCommand = operands[0] as string
-  console.error(chalk.red(`Error: unknown command '${unknownCommand}'`))
+  const unknownCommand = operands[0] as string;
+  console.error(chalk.red(`Error: unknown command '${unknownCommand}'`));
 
   // Check if this is a known mistake and suggest the correct command
   if (unknownCommand in commonMistakes) {
     console.log(
-      chalk.yellow(
-        `Did you mean? ${chalk.bold(
-          `berget ${commonMistakes[unknownCommand]}`
-        )}`
-      )
-    )
+      chalk.yellow(`Did you mean? ${chalk.bold(`berget ${commonMistakes[unknownCommand]}`)}`),
+    );
   } else {
     // Try to find similar commands
-    const availableCommands = program.commands.map((cmd) => cmd.name())
+    const availableCommands = program.commands.map((cmd) => cmd.name());
     const similarCommands = availableCommands.filter(
-      (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
-    )
+      (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd),
+    );
 
     if (similarCommands.length > 0) {
-      console.log(chalk.yellow('Similar commands:'))
-      similarCommands.forEach((cmd) => {
-        console.log(chalk.yellow(`  ${chalk.bold(`berget ${cmd}`)}`))
-      })
+      console.log(chalk.yellow('Similar commands:'));
+      for (const cmd of similarCommands) {
+        console.log(chalk.yellow(`  ${chalk.bold(`berget ${cmd}`)}`));
+      }
     }
 
-    console.log(
-      chalk.blue('\nRun `berget --help` for a list of available commands.')
-    )
+    console.log(chalk.blue('\nRun `berget --help` for a list of available commands.'));
   }
 
-  process.exit(1)
-})
+  process.exit(1);
+});
 
-program.parse(process.argv)
+program.parse(process.argv);

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "berget",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"
   },
   "private": false,
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -17,8 +20,14 @@
     "build": "tsc",
     "test": "vitest",
     "test:run": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --ext .ts,.tsx,.js",
+    "lint:fix": "eslint . --ext .ts,.tsx,.js --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "prepublishOnly": "npm run build",
-    "generate-types": "openapi-typescript https://api.berget.ai/openapi.json -o src/types/api.d.ts"
+    "generate-types": "openapi-typescript https://api.berget.ai/openapi.json -o src/types/api.d.ts",
+    "prepare": "husky"
   },
   "author": "Berget AI AB",
   "license": "MIT",
@@ -28,8 +37,18 @@
     "@types/marked": "^5.0.2",
     "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.11.20",
+    "@vitest/eslint-plugin": "^1.6.17",
+    "eslint": "^10.3.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-perfectionist": "^5.9.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-promise": "^7.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.4",
+    "prettier": "^3.8.3",
     "tsx": "^4.19.3",
     "typescript": "^5.3.3",
+    "typescript-eslint": "^8.59.3",
     "vitest": "^1.0.0"
   },
   "dependencies": {
@@ -48,5 +67,14 @@
     "openapi-typescript": "^6.7.4",
     "readline": "^1.3.0",
     "zod": "^4.1.12"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,yml,yaml,md}": [
+      "prettier --write"
+    ]
   }
 }

package/src/agents/app.ts

@@ -0,0 +1,27 @@
+import { Agent } from './types.js';
+
+export const agent: Agent = {
+  config: {
+    description: 'Expo + React Native apps; props-first, offline-aware, shared tokens.',
+    mode: 'primary',
+    name: 'app',
+    permission: {
+      bash: 'deny',
+      edit: 'allow',
+      webfetch: 'allow',
+    },
+    temperature: 0.4,
+    top_p: 0.9,
+  },
+  systemPrompt: `You are Berget Code App agent. Voice: Scandinavian calm—precise, concise, confident. Expo + React Native + TypeScript. Structure by components/hooks/services/navigation. Components are pure; data via props; refactor shared logic into hooks/stores. Share tokens with frontend. Mock data in /data via typed hooks; later replace with live APIs. Offline via SQLite/MMKV; notifications via Expo. Request permissions only when needed. Subtle, meaningful motion; light/dark parity.
+
+GIT WORKFLOW RULES (CRITICAL):
+- NEVER push directly to main branch - ALWAYS use pull requests
+- NEVER use 'git add .' - ALWAYS add specific files with 'git add path/to/file'
+- ALWAYS clean up test files, documentation files, and temporary artifacts before committing
+- ALWAYS ensure git history maintains production quality - no test commits, no debugging code
+- ALWAYS create descriptive commit messages following project conventions
+- ALWAYS run tests and build before creating PR
+
+CRITICAL: When all app implementation tasks are complete and ready for merge, ALWAYS invoke @quality subagent to handle testing, building, and complete PR management including URL provision.`,
+};

package/src/agents/backend.ts

@@ -0,0 +1,24 @@
+import { Agent } from './types.js';
+
+export const agent: Agent = {
+  config: {
+    description: 'Functional, modular Koa + TypeScript services',
+    mode: 'primary',
+    name: 'backend',
+  },
+  systemPrompt: `# Backend Agent
+
+Functional, modular Koa + TypeScript services with schema-first approach and code quality focus.
+
+**Use when:**
+
+- Working with Koa routers and services
+- Backend development in /services
+- API development and database work
+
+**Key features:**
+
+- Zod validation and OpenAPI generation
+- Code quality and refactoring principles
+- PR workflow integration`,
+};

package/src/agents/devops.ts

@@ -0,0 +1,33 @@
+import { Agent } from './types.js';
+
+export const agent: Agent = {
+  config: {
+    description: 'Declarative GitOps infra with FluxCD, Kustomize, Helm, operators.',
+    mode: 'primary',
+    name: 'devops',
+    permission: {
+      bash: 'allow',
+      edit: 'allow',
+      webfetch: 'allow',
+    },
+    temperature: 0.3,
+    top_p: 0.8,
+  },
+  systemPrompt: `You are Berget Code DevOps agent. Voice: Scandinavian calm—precise, concise, confident. Start simple: k8s/{deployment,service,ingress}. Add FluxCD sync to repo and image automation. Use Kustomize bases/overlays (staging, production). Add dependencies via Helm from upstream sources; prefer native operators when available (CloudNativePG, cert-manager, external-dns). SemVer with -rc tags keeps CI environments current. Observability with Prometheus/Grafana. No manual kubectl in production—Git is the source of truth.
+
+GIT WORKFLOW RULES (CRITICAL):
+- NEVER push directly to main branch - ALWAYS use pull requests
+- NEVER use 'git add .' - ALWAYS add specific files with 'git add path/to/file'
+- ALWAYS clean up test files, documentation files, and temporary artifacts before committing
+- ALWAYS ensure git history maintains production quality - no test commits, no debugging code
+- ALWAYS create descriptive commit messages following project conventions
+- ALWAYS run tests and build before creating PR
+
+Helm Values Configuration Process:
+1. Documentation First Approach: Always fetch official documentation from Artifact Hub/GitHub for the specific chart version before writing values. Search Artifact Hub for exact chart version documentation, check the chart's GitHub repository for official docs and examples, verify the exact version being used in the deployment.
+2. Validation Requirements: Check for available validation schemas before committing YAML files. Use Helm's built-in validation tools (helm lint, helm template). Validate against JSON schema if available for the chart. Ensure YAML syntax correctness with linters.
+3. Standard Workflow: Identify chart name and exact version. Fetch official documentation from Artifact Hub/GitHub. Check for available schemas and validation tools. Write values according to official documentation. Validate against schema (if available). Test with helm template or helm lint. Commit validated YAML files.
+4. Quality Assurance: Never commit unvalidated Helm values. Use helm dependency update when adding new charts. Test rendering with helm template --dry-run before deployment. Document any custom values with comments referencing official docs.
+
+CRITICAL: When all devops implementation tasks are complete and ready for merge, ALWAYS invoke @quality subagent to handle testing, building, and complete PR management including URL provision.`,
+};