berget 2.2.7 → 2.2.8

package/src/types/json.d.ts

@@ -1,4 +1,4 @@
-declare module "*.json" {
+declare module '*.json' {
   const value: any;
   export = value;
 }

package/src/utils/config-checker.ts

@@ -1,20 +1,20 @@
-import * as fs from "fs";
-import * as path from "path";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 /**
  * Check for .bergetconfig file and handle cluster switching
  */
 export function checkBergetConfig(): void {
-  const configPath = path.join(process.cwd(), ".bergetconfig");
+  const configPath = path.join(process.cwd(), '.bergetconfig');
   if (fs.existsSync(configPath)) {
     try {
-      const config = fs.readFileSync(configPath, "utf8");
+      const config = fs.readFileSync(configPath, 'utf8');
       const match = config.match(/cluster:\s*(.+)/);
       if (match && match[1]) {
         const clusterName = match[1].trim();
         console.log(`🔄 Berget: Switched to cluster "${clusterName}"`);
-        console.log("✓ kubectl config updated");
-        console.log("");
+        console.log('✓ kubectl config updated');
+        console.log('');
       }
     } catch {
       // Silently ignore errors reading config

package/src/utils/config-loader.ts

@@ -1,6 +1,7 @@
-import * as fs from "fs";
-import * as path from "path";
-import { logger } from "./logger";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { logger } from './logger';
 
 /**
  * Centralized agent configuration loader
@@ -8,18 +9,18 @@ import { logger } from "./logger";
  */
 
 export interface AgentConfig {
+  description?: string;
+  mode: 'primary' | 'subagent';
   model: string;
-  temperature: number;
-  top_p: number;
-  mode: "primary" | "subagent";
+  note?: string;
   permission: {
-    edit: "allow" | "deny";
-    bash: "allow" | "deny";
-    webfetch: "allow" | "deny";
+    bash: 'allow' | 'deny';
+    edit: 'allow' | 'deny';
+    webfetch: 'allow' | 'deny';
   };
-  description?: string;
   prompt?: string;
-  note?: string;
+  temperature: number;
+  top_p: number;
 }
 
 export interface ModelConfig {
@@ -27,47 +28,40 @@ export interface ModelConfig {
   small: string;
 }
 
+export interface OpenCodeConfig {
+  $schema?: string;
+  agent?: Record<string, AgentConfig>;
+  autoupdate?: boolean;
+  command?: Record<string, any>;
+  model?: string;
+  provider?: Record<string, any>;
+  share?: string;
+  small_model?: string;
+  theme?: string;
+  username?: string;
+  watcher?: Record<string, any>;
+}
+
 export interface ProviderModelConfig {
-  name: string;
   limit: {
-    output: number;
     context: number;
+    output: number;
   };
   modalities?: {
     input: string[];
     output: string[];
   };
-}
-
-export interface OpenCodeConfig {
-  $schema?: string;
-  username?: string;
-  theme?: string;
-  share?: string;
-  autoupdate?: boolean;
-  model?: string;
-  small_model?: string;
-  agent?: Record<string, AgentConfig>;
-  command?: Record<string, any>;
-  watcher?: Record<string, any>;
-  provider?: Record<string, any>;
+  name: string;
 }
 
 export class ConfigLoader {
   private static instance: ConfigLoader;
-  private config: OpenCodeConfig | null = null;
+  private config: null | OpenCodeConfig = null;
   private configPath: string;
 
   private constructor(configPath?: string) {
     // Default to opencode.json in current working directory
-    this.configPath = configPath || path.join(process.cwd(), "opencode.json");
-  }
-
-  public static getInstance(configPath?: string): ConfigLoader {
-    if (!ConfigLoader.instance) {
-      ConfigLoader.instance = new ConfigLoader(configPath);
-    }
-    return ConfigLoader.instance;
+    this.configPath = configPath || path.join(process.cwd(), 'opencode.json');
   }
 
   /**
@@ -77,30 +71,11 @@ export class ConfigLoader {
     ConfigLoader.instance = null as any;
   }
 
-  /**
-   * Load configuration from opencode.json
-   */
-  public loadConfig(): OpenCodeConfig {
-    if (this.config) {
-      return this.config;
-    }
-
-    try {
-      if (!fs.existsSync(this.configPath)) {
-        throw new Error(`Configuration file not found: ${this.configPath}`);
-      }
-
-      const configContent = fs.readFileSync(this.configPath, "utf8");
-      this.config = JSON.parse(configContent) as OpenCodeConfig;
-
-      logger.debug(`Loaded configuration from ${this.configPath}`);
-      return this.config;
-    } catch (error) {
-      logger.error(`Failed to load configuration from ${this.configPath}:`, error);
-      throw new Error(
-        `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`
-      );
+  public static getInstance(configPath?: string): ConfigLoader {
+    if (!ConfigLoader.instance) {
+      ConfigLoader.instance = new ConfigLoader(configPath);
     }
+    return ConfigLoader.instance;
   }
 
   /**
@@ -116,6 +91,13 @@ export class ConfigLoader {
     }
   }
 
+  /**
+   * Get list of all available agent names
+   */
+  public getAgentNames(): string[] {
+    return Object.keys(this.getAllAgentConfigs());
+  }
+
   /**
    * Get all agent configurations
    */
@@ -129,6 +111,26 @@ export class ConfigLoader {
     }
   }
 
+  /**
+   * Get command configurations
+   */
+  public getCommandConfigs(): Record<string, any> {
+    try {
+      const config = this.loadConfig();
+      return config.command || {};
+    } catch {
+      // Config file doesn't exist, return empty object
+      return {};
+    }
+  }
+
+  /**
+   * Get the current configuration path
+   */
+  public getConfigPath(): string {
+    return this.configPath;
+  }
+
   /**
    * Get model configuration
    */
@@ -137,19 +139,40 @@ export class ConfigLoader {
       const config = this.loadConfig();
 
       // Extract from config or fall back to defaults
-      const primary = config.model || "berget/glm-4.7";
-      const small = config.small_model || "berget/gpt-oss";
+      const primary = config.model || 'berget/glm-4.7';
+      const small = config.small_model || 'berget/gpt-oss';
 
       return { primary, small };
     } catch {
       // Fallback to defaults when no config exists (init scenario)
       return {
-        primary: "berget/glm-4.7",
-        small: "berget/gpt-oss",
+        primary: 'berget/glm-4.7',
+        small: 'berget/gpt-oss',
       };
     }
   }
 
+  /**
+   * Get list of primary agents (mode: 'primary')
+   */
+  public getPrimaryAgentNames(): string[] {
+    const agents = this.getAllAgentConfigs();
+    return Object.keys(agents).filter((name) => agents[name].mode === 'primary');
+  }
+
+  /**
+   * Get provider configuration
+   */
+  public getProviderConfig(): Record<string, any> {
+    try {
+      const config = this.loadConfig();
+      return config.provider || {};
+    } catch {
+      // Config file doesn't exist, return empty object
+      return {};
+    }
+  }
+
   /**
    * Get provider model configuration
    */
@@ -167,36 +190,31 @@ export class ConfigLoader {
 
     // Fallback to defaults
     return {
-      "glm-4.7": {
-        name: "GLM-4.7",
-        limit: { output: 4000, context: 90000 },
+      'glm-4.7': {
+        limit: { context: 90_000, output: 4000 },
+        name: 'GLM-4.7',
       },
-      "gpt-oss": {
-        name: "GPT-OSS",
-        limit: { output: 4000, context: 128000 },
+      'gpt-oss': {
+        limit: { context: 128_000, output: 4000 },
         modalities: {
-          input: ["text", "image"],
-          output: ["text"],
+          input: ['text', 'image'],
+          output: ['text'],
         },
+        name: 'GPT-OSS',
       },
-      "llama-8b": {
-        name: "llama-3.1-8b",
-        limit: { output: 4000, context: 128000 },
+      'llama-8b': {
+        limit: { context: 128_000, output: 4000 },
+        name: 'llama-3.1-8b',
       },
     };
   }
 
   /**
-   * Get command configurations
+   * Get list of subagents (mode: 'subagent')
    */
-  public getCommandConfigs(): Record<string, any> {
-    try {
-      const config = this.loadConfig();
-      return config.command || {};
-    } catch {
-      // Config file doesn't exist, return empty object
-      return {};
-    }
+  public getSubagentNames(): string[] {
+    const agents = this.getAllAgentConfigs();
+    return Object.keys(agents).filter((name) => agents[name].mode === 'subagent');
   }
 
   /**
@@ -207,25 +225,12 @@ export class ConfigLoader {
       const config = this.loadConfig();
       return (
         config.watcher || {
-          ignore: ["node_modules", "dist", ".git", "coverage"],
+          ignore: ['node_modules', 'dist', '.git', 'coverage'],
         }
       );
     } catch {
       // Config file doesn't exist, return default watcher config
-      return { ignore: ["node_modules", "dist", ".git", "coverage"] };
-    }
-  }
-
-  /**
-   * Get provider configuration
-   */
-  public getProviderConfig(): Record<string, any> {
-    try {
-      const config = this.loadConfig();
-      return config.provider || {};
-    } catch {
-      // Config file doesn't exist, return empty object
-      return {};
+      return { ignore: ['node_modules', 'dist', '.git', 'coverage'] };
     }
   }
 
@@ -237,26 +242,29 @@ export class ConfigLoader {
   }
 
   /**
-   * Get list of all available agent names
+   * Load configuration from opencode.json
    */
-  public getAgentNames(): string[] {
-    return Object.keys(this.getAllAgentConfigs());
-  }
+  public loadConfig(): OpenCodeConfig {
+    if (this.config) {
+      return this.config;
+    }
 
-  /**
-   * Get list of primary agents (mode: 'primary')
-   */
-  public getPrimaryAgentNames(): string[] {
-    const agents = this.getAllAgentConfigs();
-    return Object.keys(agents).filter(name => agents[name].mode === "primary");
-  }
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        throw new Error(`Configuration file not found: ${this.configPath}`);
+      }
 
-  /**
-   * Get list of subagents (mode: 'subagent')
-   */
-  public getSubagentNames(): string[] {
-    const agents = this.getAllAgentConfigs();
-    return Object.keys(agents).filter(name => agents[name].mode === "subagent");
+      const configContent = fs.readFileSync(this.configPath, 'utf8');
+      this.config = JSON.parse(configContent) as OpenCodeConfig;
+
+      logger.debug(`Loaded configuration from ${this.configPath}`);
+      return this.config;
+    } catch (error) {
+      logger.error(`Failed to load configuration from ${this.configPath}:`, error);
+      throw new Error(
+        `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 
   /**
@@ -274,20 +282,6 @@ export class ConfigLoader {
     this.configPath = configPath;
     this.config = null; // Force reload
   }
-
-  /**
-   * Get the current configuration path
-   */
-  public getConfigPath(): string {
-    return this.configPath;
-  }
-}
-
-/**
- * Convenience function to get the config loader instance
- */
-export function getConfigLoader(configPath?: string): ConfigLoader {
-  return ConfigLoader.getInstance(configPath);
 }
 
 /**
@@ -304,6 +298,13 @@ export function getAllAgentConfigs(configPath?: string): Record<string, AgentCon
   return getConfigLoader(configPath).getAllAgentConfigs();
 }
 
+/**
+ * Convenience function to get the config loader instance
+ */
+export function getConfigLoader(configPath?: string): ConfigLoader {
+  return ConfigLoader.getInstance(configPath);
+}
+
 /**
  * Convenience function to get model configuration
  */

package/src/utils/default-api-key.ts

@@ -1,15 +1,16 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { ApiKeyService } from "../services/api-key-service";
-import readline from "readline";
-import { logger } from "./logger";
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import readline from 'node:readline';
+
+import { ApiKeyService } from '../services/api-key-service';
+import { logger } from './logger';
 
 interface DefaultApiKeyData {
   id: string;
+  key: string;
   name: string;
   prefix: string;
-  key: string;
 }
 
 /**
@@ -22,11 +23,11 @@ export class DefaultApiKeyManager {
 
   private constructor() {
     // Set up config file path in user's home directory
-    const bergetDir = path.join(os.homedir(), ".berget");
+    const bergetDir = path.join(os.homedir(), '.berget');
     if (!fs.existsSync(bergetDir)) {
       fs.mkdirSync(bergetDir, { recursive: true });
     }
-    this.configFilePath = path.join(bergetDir, "default-api-key.json");
+    this.configFilePath = path.join(bergetDir, 'default-api-key.json');
     this.loadConfig();
   }
 
@@ -38,52 +39,17 @@ export class DefaultApiKeyManager {
   }
 
   /**
-   * Load default API key from file
-   */
-  private loadConfig(): void {
-    try {
-      if (fs.existsSync(this.configFilePath)) {
-        const data = fs.readFileSync(this.configFilePath, "utf8");
-        this.defaultApiKey = JSON.parse(data);
-      }
-    } catch {
-      logger.debug("Failed to load default API key configuration");
-      this.defaultApiKey = null;
-    }
-  }
-
-  /**
-   * Save default API key to file
-   */
-  private saveConfig(): void {
-    try {
-      if (this.defaultApiKey) {
-        fs.writeFileSync(this.configFilePath, JSON.stringify(this.defaultApiKey, null, 2));
-        // Set file permissions to be readable only by the owner
-        fs.chmodSync(this.configFilePath, 0o600);
-      } else {
-        // If default API key is null, remove the file
-        if (fs.existsSync(this.configFilePath)) {
-          fs.unlinkSync(this.configFilePath);
-        }
-      }
-    } catch {
-      logger.debug("Failed to save default API key configuration");
-    }
-  }
-
-  /**
-   * Set the default API key
+   * Clear the default API key
    */
-  public setDefaultApiKey(id: string, name: string, prefix: string, key: string): void {
-    this.defaultApiKey = { id, name, prefix, key };
+  public clearDefaultApiKey(): void {
+    this.defaultApiKey = null;
     this.saveConfig();
   }
 
   /**
    * Get the default API key string
    */
-  public getDefaultApiKey(): string | null {
+  public getDefaultApiKey(): null | string {
     return this.defaultApiKey?.key || null;
   }
 
@@ -94,43 +60,35 @@ export class DefaultApiKeyManager {
     return this.defaultApiKey;
   }
 
-  /**
-   * Clear the default API key
-   */
-  public clearDefaultApiKey(): void {
-    this.defaultApiKey = null;
-    this.saveConfig();
-  }
-
   /**
    * Prompts the user to select a default API key if none is set
    * @returns The selected API key or null if none was selected
    */
-  public async promptForDefaultApiKey(): Promise<string | null> {
+  public async promptForDefaultApiKey(): Promise<null | string> {
     try {
-      logger.debug("promptForDefaultApiKey called");
+      logger.debug('promptForDefaultApiKey called');
 
       // If we already have a default API key, return it
       if (this.defaultApiKey) {
-        logger.debug("Using existing default API key");
+        logger.debug('Using existing default API key');
         return this.defaultApiKey.key;
       }
 
-      logger.debug("No default API key found, getting ApiKeyService");
+      logger.debug('No default API key found, getting ApiKeyService');
 
       const apiKeyService = ApiKeyService.getInstance();
 
       // Get all API keys
       let apiKeys;
       try {
-        logger.debug("Calling apiKeyService.list()");
+        logger.debug('Calling apiKeyService.list()');
 
         apiKeys = await apiKeyService.list();
 
         logger.debug(`Got ${apiKeys ? apiKeys.length : 0} API keys`);
 
         if (!apiKeys || apiKeys.length === 0) {
-          logger.warn("No API keys found. Create one with:");
+          logger.warn('No API keys found. Create one with:');
           logger.info('  berget api-keys create --name "My Key"');
           return null;
         }
@@ -138,14 +96,14 @@ export class DefaultApiKeyManager {
         // Check if this is an authentication error
         const errorMessage = error instanceof Error ? error.message : String(error);
         const isAuthError =
-          errorMessage.includes("Unauthorized") ||
-          errorMessage.includes("Authentication failed") ||
-          errorMessage.includes("AUTH_FAILED");
+          errorMessage.includes('Unauthorized') ||
+          errorMessage.includes('Authentication failed') ||
+          errorMessage.includes('AUTH_FAILED');
 
         if (isAuthError) {
-          logger.warn("Authentication required. Please run `berget auth login` first.");
+          logger.warn('Authentication required. Please run `berget auth login` first.');
         } else {
-          logger.error("Error fetching API keys:");
+          logger.error('Error fetching API keys:');
           if (error instanceof Error) {
             logger.error(error.message);
             logger.debug(`API key list error: ${error.message}`);
@@ -155,12 +113,12 @@ export class DefaultApiKeyManager {
         return null;
       }
 
-      logger.info("Select an API key to use as default:");
+      logger.info('Select an API key to use as default:');
 
       // Display available API keys
-      apiKeys.forEach((key, index) => {
+      for (const [index, key] of apiKeys.entries()) {
         logger.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`);
-      });
+      }
 
       // Create readline interface for user input
       const rl = readline.createInterface({
@@ -169,20 +127,20 @@ export class DefaultApiKeyManager {
       });
 
       // Prompt for selection
-      const selection = await new Promise<number>(resolve => {
-        rl.question("Enter number (or press Enter to cancel): ", answer => {
+      const selection = await new Promise<number>((resolve) => {
+        rl.question('Enter number (or press Enter to cancel): ', (answer) => {
           rl.close();
-          const num = parseInt(answer.trim(), 10);
-          if (isNaN(num) || num < 1 || num > apiKeys.length) {
+          const number_ = Number.parseInt(answer.trim(), 10);
+          if (isNaN(number_) || number_ < 1 || number_ > apiKeys.length) {
             resolve(-1); // Invalid selection
           } else {
-            resolve(num - 1); // Convert to zero-based index
+            resolve(number_ - 1); // Convert to zero-based index
           }
         });
       });
 
       if (selection === -1) {
-        logger.warn("No API key selected");
+        logger.warn('No API key selected');
         return null;
       }
 
@@ -190,23 +148,66 @@ export class DefaultApiKeyManager {
 
       // Create a new API key with the selected name
       const newKey = await apiKeyService.create({
+        description: 'Created automatically by the Berget CLI for default use',
         name: `CLI Default (copy of ${selectedKey.name})`,
-        description: "Created automatically by the Berget CLI for default use",
       });
 
       // Save the new key as default
       this.setDefaultApiKey(
         newKey.id.toString(),
         newKey.name,
-        newKey.key.substring(0, 8), // Use first 8 chars as prefix
-        newKey.key
+        newKey.key.slice(0, 8), // Use first 8 chars as prefix
+        newKey.key,
       );
 
       logger.success(`✓ Default API key set to: ${newKey.name}`);
       return newKey.key;
     } catch (error) {
-      logger.error("Failed to set default API key:", error);
+      logger.error('Failed to set default API key:', error);
       return null;
     }
   }
+
+  /**
+   * Set the default API key
+   */
+  public setDefaultApiKey(id: string, name: string, prefix: string, key: string): void {
+    this.defaultApiKey = { id, key, name, prefix };
+    this.saveConfig();
+  }
+
+  /**
+   * Load default API key from file
+   */
+  private loadConfig(): void {
+    try {
+      if (fs.existsSync(this.configFilePath)) {
+        const data = fs.readFileSync(this.configFilePath, 'utf8');
+        this.defaultApiKey = JSON.parse(data);
+      }
+    } catch {
+      logger.debug('Failed to load default API key configuration');
+      this.defaultApiKey = null;
+    }
+  }
+
+  /**
+   * Save default API key to file
+   */
+  private saveConfig(): void {
+    try {
+      if (this.defaultApiKey) {
+        fs.writeFileSync(this.configFilePath, JSON.stringify(this.defaultApiKey, null, 2));
+        // Set file permissions to be readable only by the owner
+        fs.chmodSync(this.configFilePath, 0o600);
+      } else {
+        // If default API key is null, remove the file
+        if (fs.existsSync(this.configFilePath)) {
+          fs.unlinkSync(this.configFilePath);
+        }
+      }
+    } catch {
+      logger.debug('Failed to save default API key configuration');
+    }
+  }
 }