berget 2.2.11 → 2.2.13

package/tests/commands/code.test.ts

@@ -1,507 +1,29 @@
 import { Command } from 'commander';
-import * as fs from 'node:fs';
-import { readFile, writeFile } from 'node:fs/promises';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 
 import { registerCodeCommands } from '../../src/commands/code';
-import { ApiKeyService } from '../../src/services/api-key-service';
-import { updateEnvFile as updateEnvironmentFile } from '../../src/utils/env-manager';
-
-// Mock dependencies
-vi.mock('../../src/services/api-key-service');
-vi.mock('fs', () => ({
-  default: {
-    existsSync: vi.fn(),
-    readFileSync: vi.fn(),
-  },
-}));
-vi.mock('fs/promises', () => ({
-  readFile: vi.fn(),
-  writeFile: vi.fn(),
-}));
-vi.mock('../../src/utils/env-manager');
-vi.mock('child_process', () => ({
-  spawn: vi.fn(),
-}));
-vi.mock('readline', () => ({
-  createInterface: vi.fn(() => ({
-    close: vi.fn(),
-    question: vi.fn(),
-  })),
-}));
 
 describe('Code Commands', () => {
   let program: Command;
-  let mockApiKeyService: any;
-  let mockFs: any;
-  let mockFsPromises: any;
-  let mockSpawn: any;
 
   beforeEach(() => {
     program = new Command();
-
-    // Mock ApiKeyService
-    mockApiKeyService = {
-      create: vi.fn(),
-      list: vi.fn(),
-      rotate: vi.fn(),
-    };
-    vi.mocked(ApiKeyService.getInstance).mockReturnValue(mockApiKeyService);
-
-    // Mock fs
-    mockFs = vi.mocked(fs);
-    mockFs.existsSync = vi.fn();
-    mockFs.readFileSync = vi.fn();
-
-    // Mock fs/promises
-    mockFsPromises = vi.mocked({ readFile, writeFile });
-    mockFsPromises.readFile = vi.fn();
-    mockFsPromises.writeFile = vi.fn();
-
-    // Mock spawn
-    mockSpawn = vi.fn();
-    vi.doMock('child_process', () => ({ spawn: mockSpawn }));
-
     registerCodeCommands(program);
   });
 
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
   describe('code init command', () => {
     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');
 
       expect(initCommand).toBeDefined();
-      expect(initCommand?.description()).toBe('Initialize project for AI coding assistant');
-    });
-
-    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');
-
-      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');
-
-      expect(nameOption).toBeDefined();
-      expect(nameOption?.description).toContain('Project name');
-      expect(forceOption).toBeDefined();
-      expect(forceOption?.description).toContain('Overwrite existing configuration');
-      expect(yesOption).toBeDefined();
-      expect(yesOption?.description).toContain('Automatically answer yes');
-    });
-
-    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');
-
-      expect(initCommand).toBeDefined();
-
-      // The command should attempt to spawn opencode --version
-      // This is tested implicitly through the spawn mock
-    });
-
-    it('should list existing API keys and allow selection', async () => {
-      // Mock successful opencode installation check
-      mockSpawn.mockImplementation((command: string, arguments_: string[]) => {
-        if (command === 'opencode' && arguments_[0] === '--version') {
-          return {
-            on: vi.fn().mockImplementation((event, callback) => {
-              if (event === 'close') callback(0);
-            }),
-          };
-        }
-        return { on: 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
-      expect(mockApiKeyService.list).toBeDefined();
-    });
-
-    it('should create new API key with project-based naming', async () => {
-      // Mock successful opencode installation check
-      mockSpawn.mockImplementation((command: string, arguments_: string[]) => {
-        if (command === 'opencode' && arguments_[0] === '--version') {
-          return {
-            on: vi.fn().mockImplementation((event, callback) => {
-              if (event === 'close') callback(0);
-            }),
-          };
-        }
-        return { on: 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
-      expect(mockApiKeyService.create).toBeDefined();
-    });
-
-    it('should create opencode.json with correct structure', async () => {
-      // This tests the expected config structure
-      const expectedConfig = {
-        apiKey: 'test-api-key',
-        created: expect.any(String),
-        model: 'berget/glm-4-6',
-        projectName: 'testproject',
-        provider: 'berget',
-        version: '1.0.0',
-      };
-
-      expect(expectedConfig.model).toBe('berget/glm-4-6');
-      expect(expectedConfig.provider).toBe('berget');
-      expect(expectedConfig.version).toBe('1.0.0');
-    });
-
-    it('should handle existing config file', () => {
-      const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-      const initCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'init');
-
-      expect(initCommand).toBeDefined();
-
-      // Should check if opencode.json exists before proceeding
-      expect(mockFs.existsSync).toBeDefined();
-    });
-  });
-
-  describe('code run command', () => {
-    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');
-
-      expect(runCommand).toBeDefined();
-      expect(runCommand?.description()).toBe('Run AI coding assistant');
-    });
-
-    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');
-
-      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');
-
-      expect(modelOption).toBeDefined();
-      expect(modelOption?.description).toContain('Model to use');
-      expect(noConfigOption).toBeDefined();
-      expect(noConfigOption?.description).toContain('Run without loading project config');
-      expect(yesOption).toBeDefined();
-      expect(yesOption?.description).toContain('Automatically answer yes');
-    });
-
-    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: string, arguments_: string[]) => {
-        if (command === 'opencode' && arguments_[0] === '--version') {
-          return {
-            on: vi.fn().mockImplementation((event, callback) => {
-              if (event === 'close') callback(0);
-            }),
-          };
-        }
-        return { on: vi.fn() };
-      });
-
-      // Verify config structure expectations
-      expect(mockConfig.model).toBe('berget/glm-4-6');
-      expect(mockConfig.apiKey).toBe('test-api-key');
-      expect(mockConfig.projectName).toBe('testproject');
-    });
-
-    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');
-
-      expect(runCommand).toBeDefined();
-
-      // Should spawn opencode with appropriate arguments
-      expect(mockSpawn).toBeDefined();
+      expect(initCommand?.description()).toBe('Interactive setup for Berget AI coding tools');
     });
 
-    it('should handle missing configuration file', () => {
+    it('should not have any other subcommands', () => {
       const codeCommand = program.commands.find((cmd) => cmd.name() === 'code');
-      const runCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'run');
-
-      expect(runCommand).toBeDefined();
-
-      // Should check if opencode.json exists
-      expect(mockFs.existsSync).toBeDefined();
-    });
-  });
-
-  describe('opencode installation', () => {
-    it('should check if opencode is installed', () => {
-      // The spawn function should be called with opencode --version
-      expect(mockSpawn).toBeDefined();
-    });
-
-    it('should offer to install opencode if not found', () => {
-      // Mock opencode not installed
-      mockSpawn.mockImplementation((command: string, arguments_: string[]) => {
-        if (command === 'opencode' && arguments_[0] === '--version') {
-          return {
-            on: vi.fn().mockImplementation((event, callback) => {
-              if (event === 'close') callback(1); // Non-zero exit code
-            }),
-          };
-        }
-        return { on: vi.fn() };
-      });
-
-      // Should handle the case where opencode is not installed
-      expect(mockSpawn).toBeDefined();
-    });
-
-    it('should install opencode via npm if user agrees', () => {
-      // Should spawn npm install -g opencode-ai
-      expect(mockSpawn).toBeDefined();
-    });
-  });
-
-  describe('automation support', () => {
-    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');
-
-      expect(initCommand).toBeDefined();
-
-      const yesOption = initCommand?.options.find((opt) => opt.long === '--yes');
-      expect(yesOption).toBeDefined();
-      expect(yesOption?.description).toContain('automation');
-    });
-
-    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');
-
-      expect(runCommand).toBeDefined();
-
-      const yesOption = runCommand?.options.find((opt) => opt.long === '--yes');
-      expect(yesOption).toBeDefined();
-      expect(yesOption?.description).toContain('automation');
-    });
-
-    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';
-
-      expect(process.env.BERGET_API_KEY).toBe('test-env-key');
-
-      // Clean up
-      delete process.env.BERGET_API_KEY;
-    });
-  });
-
-  describe('.env file handling', () => {
-    let mockUpdateEnvironmentFile: any;
-
-    beforeEach(() => {
-      mockUpdateEnvironmentFile = vi.mocked(updateEnvironmentFile);
-    });
-
-    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
-      expect(mockUpdateEnvironmentFile).toBeDefined();
-    });
-
-    it('should not overwrite existing BERGET_API_KEY in .env', async () => {
-      const consoleSpy = 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: any) => {
-        if (options.key === 'BERGET_API_KEY' && !options.force) {
-          console.log(`⚠ ${options.key} already exists in .env - leaving unchanged`);
-          return false;
-        }
-        return true;
-      });
-
-      await updateEnvironmentFile({
-        key: 'BERGET_API_KEY',
-        value: 'new_key',
-      });
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('BERGET_API_KEY already exists in .env - leaving unchanged'),
-      );
-
-      consoleSpy.mockRestore();
-    });
-
-    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 updateEnvironmentFile({
-        comment: 'Berget AI Configuration',
-        key: 'BERGET_API_KEY',
-        value: 'new_api_key',
-      });
-
-      expect(mockUpdateEnvironmentFile).toHaveBeenCalledWith({
-        comment: 'Berget AI Configuration',
-        key: 'BERGET_API_KEY',
-        value: 'new_api_key',
-      });
-    });
-
-    it('should create new .env file when none exists', async () => {
-      mockFs.existsSync.mockReturnValue(false);
-      mockUpdateEnvironmentFile.mockResolvedValue(true);
-
-      await updateEnvironmentFile({
-        key: 'BERGET_API_KEY',
-        value: 'new_api_key',
-      });
-
-      expect(mockUpdateEnvironmentFile).toHaveBeenCalledWith({
-        key: 'BERGET_API_KEY',
-        value: 'new_api_key',
-      });
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle API key creation failures', () => {
-      // Mock API key service to throw error
-      mockApiKeyService.create.mockRejectedValue(new Error('API Error'));
-
-      expect(mockApiKeyService.create).toBeDefined();
-    });
-
-    it('should handle file system errors', () => {
-      // Mock file operations to throw errors
-      mockFsPromises.writeFile.mockRejectedValue(new Error('File write error'));
-
-      expect(mockFsPromises.writeFile).toBeDefined();
-    });
-
-    it('should handle spawn errors', () => {
-      // Mock spawn to throw error
-      mockSpawn.mockImplementation(() => {
-        throw new Error('Command not found');
-      });
-
-      expect(mockSpawn).toBeDefined();
-    });
-
-    it('should handle .env update failures', async () => {
-      const mockUpdateEnvironmentFile = vi.mocked(updateEnvironmentFile);
-      mockUpdateEnvironmentFile.mockRejectedValue(new Error('Env update failed'));
-
-      await expect(
-        updateEnvironmentFile({
-          key: 'TEST_KEY',
-          value: 'test_value',
-        }),
-      ).rejects.toThrow('Env update failed');
-    });
-  });
-
-  describe('experimental features', () => {
-    let originalEnvironment: string | undefined;
-
-    beforeEach(() => {
-      originalEnvironment = process.env.BERGET_EXPERIMENTAL;
-    });
-
-    afterEach(() => {
-      if (originalEnvironment === undefined) {
-        delete process.env.BERGET_EXPERIMENTAL;
-      } else {
-        process.env.BERGET_EXPERIMENTAL = originalEnvironment;
-      }
-    });
-
-    it('should NOT show setup command when BERGET_EXPERIMENTAL is not set', () => {
-      delete process.env.BERGET_EXPERIMENTAL;
-
-      const freshProgram = new Command();
-      registerCodeCommands(freshProgram);
-
-      const codeCommand = freshProgram.commands.find((cmd) => cmd.name() === 'code');
-      const setupCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'setup');
-
-      expect(setupCommand).toBeUndefined();
-    });
-
-    it('should show setup command when BERGET_EXPERIMENTAL is set', () => {
-      process.env.BERGET_EXPERIMENTAL = '1';
-
-      const freshProgram = new Command();
-      registerCodeCommands(freshProgram);
-
-      const codeCommand = freshProgram.commands.find((cmd) => cmd.name() === 'code');
-      const setupCommand = codeCommand?.commands.find((cmd) => cmd.name() === 'setup');
-
-      expect(setupCommand).toBeDefined();
-      expect(setupCommand?.description()).toBe('Interactive setup for Berget AI coding tools');
+      expect(codeCommand?.commands).toHaveLength(1);
+      expect(codeCommand?.commands[0]?.name()).toBe('init');
     });
   });
 });

package/templates/agents/app.md

@@ -1,23 +0,0 @@
----
-description: Expo + React Native apps; props-first, offline-aware, shared tokens.
-mode: primary
-temperature: 0.4
-top_p: 0.9
-permission:
-  edit: allow
-  bash: deny
-  webfetch: allow
----
-
-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/templates/agents/backend.md

@@ -1,23 +0,0 @@
----
-description: Functional, modular Koa + TypeScript services; schema-first with code quality focus.
-mode: primary
-temperature: 0.3
-top_p: 0.9
-permission:
-  edit: allow
-  bash: allow
-  webfetch: allow
----
-
-You are Berget Code Backend agent. Voice: Scandinavian calm—precise, concise, confident. TypeScript + Koa. Prefer many small pure functions; avoid big try/catch blocks. Routes thin; logic in services/adapters/domain. Validate with Zod; auto-generate OpenAPI. Adapters isolate external systems; domain never depends on framework. Test with supertest; idempotent and stateless by default. Each microservice emits an OpenAPI contract; changes propagate upward to types. Code Quality & Refactoring Principles: Apply Single Responsibility Principle, fail fast with explicit errors, eliminate code duplication, remove nested complexity, use descriptive error codes, keep functions under 30 lines. Always leave code cleaner and more readable than you found it.
-
-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 backend implementation tasks are complete and ready for merge, ALWAYS invoke @quality subagent to handle testing, building, and complete PR management including URL provision.

package/templates/agents/devops.md

@@ -1,30 +0,0 @@
----
-description: Declarative GitOps infra with FluxCD, Kustomize, Helm, operators.
-mode: primary
-temperature: 0.3
-top_p: 0.8
-permission:
-  edit: allow
-  bash: allow
-  webfetch: allow
----
-
-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.

package/templates/agents/frontend.md

@@ -1,25 +0,0 @@
----
-description: Builds Scandinavian, type-safe UIs with React, Tailwind, Shadcn.
-mode: primary
-temperature: 0.4
-top_p: 0.9
-permission:
-  edit: allow
-  bash: deny
-  webfetch: allow
----
-
-You are Berget Code Frontend agent. Voice: Scandinavian calm—precise, concise, confident. React 18 + TypeScript. Tailwind + Shadcn UI only via the design system (index.css, tailwind.config.ts). Use semantic tokens for color/spacing/typography/motion; never ad-hoc classes or inline colors. Components are pure and responsive; props-first data; minimal global state (Zustand/Jotai). Accessibility and keyboard navigation mandatory. Mock data only at init under /data via typed hooks (e.g., useProducts() reading /data/products.json). Design: minimal, balanced, quiet motion.
-
-IMPORTANT: You have NO bash access and cannot run git commands. When your frontend implementation tasks are complete, inform the user that changes are ready and suggest using /pr command to create a pull request with proper testing and quality checks.
-
-CODE QUALITY RULES:
-
-- Write clean, production-ready code
-- Follow React and TypeScript best practices
-- Ensure accessibility and responsive design
-- Use semantic tokens from design system
-- Test your components manually when possible
-- Document any complex logic with comments
-
-CRITICAL: When frontend implementation is complete, ALWAYS inform the user to use "/pr" command to handle testing, building, and pull request creation.

package/templates/agents/fullstack.md

@@ -1,23 +0,0 @@
----
-description: Router/coordinator agent for full-stack development with schema-driven architecture
-mode: primary
-temperature: 0.3
-top_p: 0.9
-permission:
-  edit: allow
-  bash: allow
-  webfetch: allow
----
-
-Voice: Scandinavian calm—precise, concise, confident; no fluff. You are Berget Code Fullstack agent. Act as a router and coordinator in a monorepo. Bottom-up schema: database → OpenAPI → generated types. Top-down types: API → UI → components. Use openapi-fetch and Zod at every boundary; compile-time errors are desired when contracts change. Routing rules: if task/paths match /apps/frontend or React (.tsx) → use frontend; if /apps/app or Expo/React Native → app; if /infra, /k8s, flux-system, kustomization.yaml, Helm values → devops; if /services, Koa routers, services/adapters/domain → backend. If ambiguous, remain fullstack and outline the end-to-end plan, then delegate subtasks to the right persona. Security: validate inputs; secrets via FluxCD SOPS/Sealed Secrets. Documentation is generated from code—never duplicated.
-
-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 implementation tasks are complete and ready for merge, ALWAYS invoke @quality subagent to handle testing, building, and complete PR management including URL provision.