berget 2.2.5 → 2.2.7

package/src/types/json.d.ts

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

package/src/utils/config-checker.ts

@@ -1,22 +1,22 @@
-import * as fs from 'fs'
-import * as path from 'path'
+import * as fs from "fs";
+import * as path from "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 match = config.match(/cluster:\s*(.+)/)
+      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('')
+        const clusterName = match[1].trim();
+        console.log(`🔄 Berget: Switched to cluster "${clusterName}"`);
+        console.log("✓ kubectl config updated");
+        console.log("");
       }
-    } catch (error) {
+    } catch {
       // Silently ignore errors reading config
     }
   }

package/src/utils/config-loader.ts

@@ -1,6 +1,6 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import { logger } from './logger'
+import * as fs from "fs";
+import * as path from "path";
+import { logger } from "./logger";
 
 /**
  * Centralized agent configuration loader
@@ -8,73 +8,73 @@ import { logger } from './logger'
  */
 
 export interface AgentConfig {
-  model: string
-  temperature: number
-  top_p: number
-  mode: 'primary' | 'subagent'
+  model: string;
+  temperature: number;
+  top_p: number;
+  mode: "primary" | "subagent";
   permission: {
-    edit: 'allow' | 'deny'
-    bash: 'allow' | 'deny'
-    webfetch: 'allow' | 'deny'
-  }
-  description?: string
-  prompt?: string
-  note?: string
+    edit: "allow" | "deny";
+    bash: "allow" | "deny";
+    webfetch: "allow" | "deny";
+  };
+  description?: string;
+  prompt?: string;
+  note?: string;
 }
 
 export interface ModelConfig {
-  primary: string
-  small: string
+  primary: string;
+  small: string;
 }
 
 export interface ProviderModelConfig {
-  name: string
+  name: string;
   limit: {
-    output: number
-    context: number
-  }
+    output: number;
+    context: number;
+  };
   modalities?: {
-    input: string[]
-    output: string[]
-  }
+    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>
+  $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>;
 }
 
 export class ConfigLoader {
-  private static instance: ConfigLoader
-  private config: OpenCodeConfig | null = null
-  private configPath: string
+  private static instance: ConfigLoader;
+  private config: OpenCodeConfig | null = 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')
+    this.configPath = configPath || path.join(process.cwd(), "opencode.json");
   }
 
   public static getInstance(configPath?: string): ConfigLoader {
     if (!ConfigLoader.instance) {
-      ConfigLoader.instance = new ConfigLoader(configPath)
+      ConfigLoader.instance = new ConfigLoader(configPath);
     }
-    return ConfigLoader.instance
+    return ConfigLoader.instance;
   }
 
   /**
    * Clear the singleton instance (for testing purposes)
    */
   public static clearInstance(): void {
-    ConfigLoader.instance = null as any
+    ConfigLoader.instance = null as any;
   }
 
   /**
@@ -82,29 +82,24 @@ export class ConfigLoader {
    */
   public loadConfig(): OpenCodeConfig {
     if (this.config) {
-      return this.config
+      return this.config;
     }
 
     try {
       if (!fs.existsSync(this.configPath)) {
-        throw new Error(`Configuration file not found: ${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
+      const configContent = fs.readFileSync(this.configPath, "utf8");
+      this.config = JSON.parse(configContent) as OpenCodeConfig;
 
-      logger.debug(`Loaded configuration from ${this.configPath}`)
-      return this.config
+      logger.debug(`Loaded configuration from ${this.configPath}`);
+      return this.config;
     } catch (error) {
-      logger.error(
-        `Failed to load configuration from ${this.configPath}:`,
-        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)
-        }`
-      )
+        `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
 
@@ -113,11 +108,11 @@ export class ConfigLoader {
    */
   public getAgentConfig(agentName: string): AgentConfig | null {
     try {
-      const config = this.loadConfig()
-      return config.agent?.[agentName] || null
-    } catch (error) {
+      const config = this.loadConfig();
+      return config.agent?.[agentName] || null;
+    } catch {
       // Config file doesn't exist, return null
-      return null
+      return null;
     }
   }
 
@@ -126,11 +121,11 @@ export class ConfigLoader {
    */
   public getAllAgentConfigs(): Record<string, AgentConfig> {
     try {
-      const config = this.loadConfig()
-      return config.agent || {}
-    } catch (error) {
+      const config = this.loadConfig();
+      return config.agent || {};
+    } catch {
       // Config file doesn't exist, return empty object
-      return {}
+      return {};
     }
   }
 
@@ -139,19 +134,19 @@ export class ConfigLoader {
    */
   public getModelConfig(): ModelConfig {
     try {
-      const config = this.loadConfig()
+      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 (error) {
+      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",
+      };
     }
   }
 
@@ -160,38 +155,35 @@ export class ConfigLoader {
    */
   public getProviderModels(): Record<string, ProviderModelConfig> {
     try {
-      const config = this.loadConfig()
+      const config = this.loadConfig();
 
       // Extract from provider configuration
       if (config.provider?.berget?.models) {
-        return config.provider.berget.models as Record<
-          string,
-          ProviderModelConfig
-        >
+        return config.provider.berget.models as Record<string, ProviderModelConfig>;
       }
-    } catch (error) {
+    } catch {
       // Config file doesn't exist, use fallback defaults
     }
 
     // Fallback to defaults
     return {
-      'glm-4.7': {
-        name: 'GLM-4.7',
+      "glm-4.7": {
+        name: "GLM-4.7",
         limit: { output: 4000, context: 90000 },
       },
-      'gpt-oss': {
-        name: 'GPT-OSS',
+      "gpt-oss": {
+        name: "GPT-OSS",
         limit: { output: 4000, context: 128000 },
         modalities: {
-          input: ['text', 'image'],
-          output: ['text'],
+          input: ["text", "image"],
+          output: ["text"],
         },
       },
-      'llama-8b': {
-        name: 'llama-3.1-8b',
+      "llama-8b": {
+        name: "llama-3.1-8b",
         limit: { output: 4000, context: 128000 },
       },
-    }
+    };
   }
 
   /**
@@ -199,11 +191,11 @@ export class ConfigLoader {
    */
   public getCommandConfigs(): Record<string, any> {
     try {
-      const config = this.loadConfig()
-      return config.command || {}
-    } catch (error) {
+      const config = this.loadConfig();
+      return config.command || {};
+    } catch {
       // Config file doesn't exist, return empty object
-      return {}
+      return {};
     }
   }
 
@@ -212,15 +204,15 @@ export class ConfigLoader {
    */
   public getWatcherConfig(): Record<string, any> {
     try {
-      const config = this.loadConfig()
+      const config = this.loadConfig();
       return (
         config.watcher || {
-          ignore: ['node_modules', 'dist', '.git', 'coverage'],
+          ignore: ["node_modules", "dist", ".git", "coverage"],
         }
-      )
-    } catch (error) {
+      );
+    } catch {
       // Config file doesn't exist, return default watcher config
-      return { ignore: ['node_modules', 'dist', '.git', 'coverage'] }
+      return { ignore: ["node_modules", "dist", ".git", "coverage"] };
     }
   }
 
@@ -229,11 +221,11 @@ export class ConfigLoader {
    */
   public getProviderConfig(): Record<string, any> {
     try {
-      const config = this.loadConfig()
-      return config.provider || {}
-    } catch (error) {
+      const config = this.loadConfig();
+      return config.provider || {};
+    } catch {
       // Config file doesn't exist, return empty object
-      return {}
+      return {};
     }
   }
 
@@ -241,55 +233,53 @@ export class ConfigLoader {
    * Check if an agent exists
    */
   public hasAgent(agentName: string): boolean {
-    return agentName in this.getAllAgentConfigs()
+    return agentName in this.getAllAgentConfigs();
   }
 
   /**
    * Get list of all available agent names
    */
   public getAgentNames(): string[] {
-    return Object.keys(this.getAllAgentConfigs())
+    return Object.keys(this.getAllAgentConfigs());
   }
 
   /**
    * Get list of primary agents (mode: 'primary')
    */
   public getPrimaryAgentNames(): string[] {
-    const agents = this.getAllAgentConfigs()
-    return Object.keys(agents).filter((name) => agents[name].mode === 'primary')
+    const agents = this.getAllAgentConfigs();
+    return Object.keys(agents).filter(name => agents[name].mode === "primary");
   }
 
   /**
    * Get list of subagents (mode: 'subagent')
    */
   public getSubagentNames(): string[] {
-    const agents = this.getAllAgentConfigs()
-    return Object.keys(agents).filter(
-      (name) => agents[name].mode === 'subagent'
-    )
+    const agents = this.getAllAgentConfigs();
+    return Object.keys(agents).filter(name => agents[name].mode === "subagent");
   }
 
   /**
    * Reload configuration from file
    */
   public reloadConfig(): OpenCodeConfig {
-    this.config = null
-    return this.loadConfig()
+    this.config = null;
+    return this.loadConfig();
   }
 
   /**
    * Set custom configuration path (for testing or different environments)
    */
   public setConfigPath(configPath: string): void {
-    this.configPath = configPath
-    this.config = null // Force reload
+    this.configPath = configPath;
+    this.config = null; // Force reload
   }
 
   /**
    * Get the current configuration path
    */
   public getConfigPath(): string {
-    return this.configPath
+    return this.configPath;
   }
 }
 
@@ -297,40 +287,33 @@ export class ConfigLoader {
  * Convenience function to get the config loader instance
  */
 export function getConfigLoader(configPath?: string): ConfigLoader {
-  return ConfigLoader.getInstance(configPath)
+  return ConfigLoader.getInstance(configPath);
 }
 
 /**
  * Convenience function to get agent configuration
  */
-export function getAgentConfig(
-  agentName: string,
-  configPath?: string
-): AgentConfig | null {
-  return getConfigLoader(configPath).getAgentConfig(agentName)
+export function getAgentConfig(agentName: string, configPath?: string): AgentConfig | null {
+  return getConfigLoader(configPath).getAgentConfig(agentName);
 }
 
 /**
  * Convenience function to get all agent configurations
  */
-export function getAllAgentConfigs(
-  configPath?: string
-): Record<string, AgentConfig> {
-  return getConfigLoader(configPath).getAllAgentConfigs()
+export function getAllAgentConfigs(configPath?: string): Record<string, AgentConfig> {
+  return getConfigLoader(configPath).getAllAgentConfigs();
 }
 
 /**
  * Convenience function to get model configuration
  */
 export function getModelConfig(configPath?: string): ModelConfig {
-  return getConfigLoader(configPath).getModelConfig()
+  return getConfigLoader(configPath).getModelConfig();
 }
 
 /**
  * Convenience function to get provider models
  */
-export function getProviderModels(
-  configPath?: string
-): Record<string, ProviderModelConfig> {
-  return getConfigLoader(configPath).getProviderModels()
+export function getProviderModels(configPath?: string): Record<string, ProviderModelConfig> {
+  return getConfigLoader(configPath).getProviderModels();
 }