berget 0.1.0 → 1.1.0

package/src/services/cluster-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface Cluster {
   id: string
@@ -8,9 +9,19 @@ export interface Cluster {
   created: string
 }
 
+/**
+ * Service for managing Kubernetes clusters
+ * Command group: clusters
+ */
 export class ClusterService {
   private static instance: ClusterService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.CLUSTERS
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.CLUSTERS
 
   private constructor() {}
 
@@ -21,7 +32,11 @@ export class ClusterService {
     return ClusterService.instance
   }
 
-  public async getClusterUsage(clusterId: string): Promise<any> {
+  /**
+   * Get resource usage for a cluster
+   * Command: berget clusters get-usage
+   */
+  public async getUsage(clusterId: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET(
         '/v1/clusters/{clusterId}/usage',
@@ -37,7 +52,11 @@ export class ClusterService {
     }
   }
 
-  public async listClusters(): Promise<Cluster[]> {
+  /**
+   * List all clusters
+   * Command: berget clusters list
+   */
+  public async list(): Promise<Cluster[]> {
     try {
       const { data, error } = await this.client.GET('/v1/clusters')
       if (error) throw new Error(JSON.stringify(error))
@@ -47,4 +66,20 @@ export class ClusterService {
       throw error
     }
   }
+  
+  /**
+   * Get detailed information about a cluster
+   * Command: berget clusters describe
+   */
+  public async describe(clusterId: string): Promise<Cluster | null> {
+    try {
+      // This is a placeholder since the API doesn't have a specific endpoint
+      // In a real implementation, this would call a specific endpoint
+      const clusters = await this.list()
+      return clusters.find(cluster => cluster.id === clusterId) || null
+    } catch (error) {
+      console.error('Failed to describe cluster:', error)
+      throw error
+    }
+  }
 }

package/src/services/collaborator-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface Collaborator {
   username: string
@@ -6,9 +7,19 @@ export interface Collaborator {
   status: string
 }
 
+/**
+ * Service for managing collaborators
+ * Command group: users
+ */
 export class CollaboratorService {
   private static instance: CollaboratorService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.USERS
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.USERS
 
   private constructor() {}
 
@@ -19,16 +30,24 @@ export class CollaboratorService {
     return CollaboratorService.instance
   }
 
-  // This endpoint is not available in the API
-  public async addCollaborator(
+  /**
+   * Invite a new collaborator
+   * Command: berget users invite
+   * This endpoint is not available in the API
+   */
+  public async invite(
     clusterId: string,
     githubUsername: string
   ): Promise<Collaborator[]> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async listCollaborators(clusterId: string): Promise<Collaborator[]> {
+  /**
+   * List all collaborators
+   * Command: berget users list
+   * This endpoint is not available in the API
+   */
+  public async list(clusterId: string): Promise<Collaborator[]> {
     throw new Error('This functionality is not available in the API')
   }
 }

package/src/services/flux-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface FluxInstallOptions {
   cluster: string
@@ -12,9 +13,19 @@ export interface FluxBootstrapOptions {
   personal?: boolean
 }
 
+/**
+ * Service for managing Flux CD
+ * Command group: flux
+ */
 export class FluxService {
   private static instance: FluxService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.FLUX
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.FLUX
 
   private constructor() {}
 
@@ -25,13 +36,21 @@ export class FluxService {
     return FluxService.instance
   }
 
-  // This endpoint is not available in the API
-  public async installFlux(options: FluxInstallOptions): Promise<boolean> {
+  /**
+   * Install Flux CD
+   * Command: berget flux install
+   * This endpoint is not available in the API
+   */
+  public async install(options: FluxInstallOptions): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async bootstrapFlux(options: FluxBootstrapOptions): Promise<boolean> {
+  /**
+   * Bootstrap Flux CD
+   * Command: berget flux bootstrap
+   * This endpoint is not available in the API
+   */
+  public async bootstrap(options: FluxBootstrapOptions): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 }

package/src/services/helm-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface HelmRepoAddOptions {
   name: string
@@ -12,9 +13,19 @@ export interface HelmInstallOptions {
   values?: Record<string, string>
 }
 
+/**
+ * Service for managing Helm charts
+ * Command group: helm
+ */
 export class HelmService {
   private static instance: HelmService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.HELM
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.HELM
 
   private constructor() {}
 
@@ -25,13 +36,21 @@ export class HelmService {
     return HelmService.instance
   }
 
-  // This endpoint is not available in the API
+  /**
+   * Add a Helm repository
+   * Command: berget helm add-repo
+   * This endpoint is not available in the API
+   */
   public async addRepo(options: HelmRepoAddOptions): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async installChart(options: HelmInstallOptions): Promise<any> {
+  /**
+   * Install a Helm chart
+   * Command: berget helm install
+   * This endpoint is not available in the API
+   */
+  public async install(options: HelmInstallOptions): Promise<any> {
     throw new Error('This functionality is not available in the API')
   }
 }

package/src/services/kubectl-service.ts

@@ -1,8 +1,19 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
+/**
+ * Service for managing Kubernetes resources
+ * Command group: kubectl
+ */
 export class KubectlService {
   private static instance: KubectlService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.KUBECTL
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.KUBECTL
 
   private constructor() {}
 
@@ -13,18 +24,30 @@ export class KubectlService {
     return KubectlService.instance
   }
 
-  // This endpoint is not available in the API
+  /**
+   * Create a Kubernetes namespace
+   * Command: berget kubectl create-namespace
+   * This endpoint is not available in the API
+   */
   public async createNamespace(name: string): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async applyConfiguration(filename: string): Promise<boolean> {
+  /**
+   * Apply a Kubernetes configuration
+   * Command: berget kubectl apply
+   * This endpoint is not available in the API
+   */
+  public async apply(filename: string): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async getResources(
+  /**
+   * Get Kubernetes resources
+   * Command: berget kubectl get
+   * This endpoint is not available in the API
+   */
+  public async get(
     resource: string,
     namespace?: string
   ): Promise<any[]> {

package/src/types/api.d.ts

@@ -351,16 +351,17 @@ export interface paths {
   "/v1/auth/login": {
     /**
      * OAuth login
-     * @description Initiates OAuth flow for user authentication.
-     *
-     * If you don't have an account yet, you can create one during the login process
-     * by clicking on the "Register" link on the login page.
-     *
-     * This is the recommended way to authenticate with the Berget AI API.
+     * @description Initiates OAuth login flow via Keycloak
      */
     get: {
+      parameters: {
+        query?: {
+          /** @description URL to redirect to after successful login */
+          redirect_uri?: string;
+        };
+      };
       responses: {
-        /** @description Redirects to authentication provider */
+        /** @description Redirects to Keycloak for login */
         302: {
           content: never;
         };
@@ -370,98 +371,60 @@ export interface paths {
   "/v1/auth/callback": {
     /**
      * OAuth callback
-     * @description Handles the callback from OAuth authentication. After successful authentication, you'll receive an access token to use for API requests.
+     * @description Handles Keycloak login callback and exchanges token
      */
     get: {
       parameters: {
-        query?: {
-          /** @description Authorization code */
-          code?: string;
-          /** @description State parameter for CSRF protection */
-          state?: string;
+        query: {
+          code: string;
+          state: string;
         };
       };
       responses: {
-        /** @description Redirects to frontend with token */
+        /** @description Redirects to frontend */
         302: {
           content: never;
         };
-        /** @description Invalid request */
-        400: {
-          content: never;
-        };
-        /** @description Authentication failed */
-        401: {
+      };
+    };
+  };
+  "/v1/auth/device": {
+    /** Initiate device authorization flow */
+    post: {
+      responses: {
+        /** @description Device authorization initiated */
+        200: {
           content: never;
         };
       };
     };
   };
-  "/v1/auth/keycloak": {
-    /**
-     * Authenticate with OAuth tokens
-     * @description Exchange OAuth tokens for our system token
-     */
+  "/v1/auth/device/token": {
+    /** Poll for device token */
     post: {
       requestBody: {
         content: {
           "application/json": {
-            /** @description Subject identifier from authentication provider */
-            sub: string;
-            /**
-             * Format: email
-             * @description User's email address
-             */
-            email: string;
-            /** @description User's full name */
-            name?: string;
-            /** @description User's preferred username */
-            preferred_username?: string;
-            /** @description OAuth access token */
-            access_token: string;
-            /** @description OAuth refresh token */
-            refresh_token?: string;
-            /** @description OAuth ID token */
-            id_token?: string;
+            device_code?: string;
           };
         };
       };
       responses: {
-        /** @description Authentication successful */
+        /** @description Token returned or pending status */
         200: {
-          content: {
-            "application/json": {
-              /** @description JWT token for our system */
-              token?: string;
-              /** @description User information */
-              user?: Record<string, never>;
-            };
-          };
-        };
-        /** @description Invalid request */
-        400: {
-          content: never;
-        };
-        /** @description Authentication failed */
-        401: {
           content: never;
         };
       };
     };
   };
   "/v1/auth/register-url": {
-    /**
-     * Get registration URL
-     * @description Returns the URL where users can register a new account.
-     * This is the recommended way for new users to create accounts.
-     */
+    /** Get Keycloak registration URL */
     get: {
       responses: {
-        /** @description Registration URL */
+        /** @description Registration URL returned */
         200: {
           content: {
             "application/json": {
-              /** @description URL to registration page */
               url?: string;
             };
           };
@@ -469,82 +432,14 @@ export interface paths {
       };
     };
   };
-  "/v1/auth/device": {
-    /**
-     * Initiate device authorization flow
-     * @description Initiates a device authorization flow for CLI tools.
-     * Returns a verification URL and device code for the user to complete authentication.
-     */
-    post: {
-      responses: {
-        /** @description Device authorization initiated */
-        200: {
-          content: {
-            "application/json": {
-              /** @description URL where the user should go to authenticate */
-              verification_url?: string;
-              /** @description Code the user should enter on the verification page */
-              user_code?: string;
-              /** @description Code used by the device to poll for authentication status */
-              device_code?: string;
-              /** @description Seconds until the device code expires */
-              expires_in?: number;
-              /** @description Polling interval in seconds */
-              interval?: number;
-            };
-          };
-        };
-      };
-    };
-  };
-  "/v1/auth/device/token": {
-    /**
-     * Poll for device authorization token
-     * @description Polls for the completion of a device authorization flow.
-     * The CLI tool should call this endpoint repeatedly until authentication is complete.
-     */
-    post: {
-      requestBody: {
-        content: {
-          "application/json": {
-            /** @description Device code received from the /device endpoint */
-            device_code: string;
-          };
-        };
-      };
-      responses: {
-        /** @description Authentication successful */
-        200: {
-          content: {
-            "application/json": {
-              /** @description JWT token for API access */
-              token?: string;
-              /** @description User information */
-              user?: Record<string, never>;
-            };
-          };
-        };
-        /** @description Invalid request */
-        400: {
-          content: never;
-        };
-        /** @description Authentication pending or failed */
-        401: {
-          content: never;
-        };
-      };
-    };
-  };
   "/v1/auth/logout": {
     /**
      * Logout
-     * @description Redirects to logout endpoint to properly terminate the session.
-     * Optionally accepts a redirect_uri query parameter to specify where to redirect after logout.
+     * @description Clears cookies and redirects to Keycloak logout
      */
     get: {
       parameters: {
         query?: {
-          /** @description URL to redirect to after logout */
           redirect_uri?: string;
         };
       };
@@ -969,6 +864,28 @@ export interface paths {
       };
     };
   };
+  "/v1/users/me": {
+    /**
+     * Get current user profile
+     * @description Retrieves the profile of the currently authenticated user
+     */
+    get: {
+      responses: {
+        /** @description User profile */
+        200: {
+          content: {
+            "application/json": components["schemas"]["UserProfile"];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrorResponse"];
+          };
+        };
+      };
+    };
+  };
   "/v1/users/{id}": {
     /**
      * Get user details
@@ -1073,28 +990,6 @@ export interface paths {
       };
     };
   };
-  "/v1/users/me": {
-    /**
-     * Get current user profile
-     * @description Retrieves the profile of the currently authenticated user
-     */
-    get: {
-      responses: {
-        /** @description User profile */
-        200: {
-          content: {
-            "application/json": components["schemas"]["UserProfile"];
-          };
-        };
-        /** @description Unauthorized */
-        401: {
-          content: {
-            "application/json": components["schemas"]["ErrorResponse"];
-          };
-        };
-      };
-    };
-  };
   "/v1/users/invite": {
     /**
      * Invite team member
@@ -1797,46 +1692,17 @@ export interface components {
         };
       };
     };
-    /** @description Pricing information for the model */
-    ModelPricing: {
-      /** @description Cost per token for input in the specified currency */
-      input: number;
-      /** @description Cost per token for output in the specified currency */
-      output: number;
-      /** @description The unit of pricing (e.g., "token") */
-      unit: string;
-      /** @description The currency of the pricing (e.g., "USD") */
-      currency: string;
-    };
-    /** @description Model capabilities */
-    ModelCapabilities: {
-      /** @description Whether the model supports vision/image input */
-      vision: boolean;
-      /** @description Whether the model supports function calling */
-      function_calling: boolean;
-      /** @description Whether the model supports JSON mode */
-      json_mode: boolean;
-    };
     Model: {
       /** @description Unique identifier for the model */
       id: string;
-      /**
-       * @description Object type
-       * @enum {string}
-       */
-      object: "model";
-      /** @description Unix timestamp of when the model was created */
-      created: number;
-      /** @description Organization that owns the model */
-      owned_by: string;
-      pricing: components["schemas"]["ModelPricing"];
-      capabilities: components["schemas"]["ModelCapabilities"];
-    };
-    ModelList: {
-      data: components["schemas"]["Model"][];
-      /** @enum {string} */
-      object: "list";
+      /** @description Name of the model */
+      name: string;
+      /** @description Description of the model */
+      description: string;
+      /** @description Whether the model is active */
+      active: boolean;
     };
+    ModelList: components["schemas"]["Model"][];
     /** @description Cost information for this usage */
     TokenCost: {
       /** @description Cost amount */

package/src/utils/config-checker.ts

@@ -0,0 +1,23 @@
+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')
+  if (fs.existsSync(configPath)) {
+    try {
+      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('')
+      }
+    } catch (error) {
+      // Silently ignore errors reading config
+    }
+  }
+}