berget 0.0.4 → 1.0.0

package/src/client.ts

@@ -1,22 +1,23 @@
-import createClient from 'openapi-fetch';
-import type { paths } from './types/api';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import chalk from 'chalk';
+import createClient from 'openapi-fetch'
+import type { paths } from './types/api'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import chalk from 'chalk'
 
 // Configuration directory
-const CONFIG_DIR = path.join(os.homedir(), '.berget');
-const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+const CONFIG_DIR = path.join(os.homedir(), '.berget')
+const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json')
 
 // API Base URL
 // Use --local flag to test against local API
-const isLocalMode = process.argv.includes('--local');
-const API_BASE_URL = process.env.BERGET_API_URL || 
-                    (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai');
+const isLocalMode = process.argv.includes('--local')
+const API_BASE_URL =
+  process.env.BERGET_API_URL ||
+  (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai')
 
 if (isLocalMode && !process.env.BERGET_API_URL) {
-  console.log(chalk.yellow('Using local API endpoint: http://localhost:3000'));
+  console.log(chalk.yellow('Using local API endpoint: http://localhost:3000'))
 }
 
 // Create a typed client for the Berget API
@@ -24,100 +25,109 @@ export const apiClient = createClient<paths>({
   baseUrl: API_BASE_URL,
   headers: {
     'Content-Type': 'application/json',
-    'Accept': 'application/json'
-  }
-});
+    Accept: 'application/json',
+  },
+})
 
 // Authentication functions
 export const getAuthToken = (): string | null => {
   try {
     if (fs.existsSync(TOKEN_FILE)) {
-      const tokenData = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
-      return tokenData.accessToken;
+      const tokenData = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'))
+      return tokenData.accessToken
     }
   } catch (error) {
-    console.error('Error reading auth token:', error);
+    console.error('Error reading auth token:', error)
   }
-  return null;
-};
+  return null
+}
 
 // Check if token is expired (JWT tokens have an exp claim)
 export const isTokenExpired = (token: string): boolean => {
   try {
-    const base64Url = token.split('.')[1];
-    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const base64Url = token.split('.')[1]
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/')
     const jsonPayload = decodeURIComponent(
       atob(base64)
         .split('')
-        .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+        .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
         .join('')
-    );
-    const payload = JSON.parse(jsonPayload);
-    
+    )
+    const payload = JSON.parse(jsonPayload)
+
     // Check if token has expired
     if (payload.exp) {
-      return payload.exp * 1000 < Date.now();
+      return payload.exp * 1000 < Date.now()
     }
   } catch (error) {
     // If we can't decode the token, assume it's expired
-    return true;
+    return true
   }
-  
+
   // If there's no exp claim, assume it's valid
-  return false;
-};
+  return false
+}
 
 export const saveAuthToken = (token: string): void => {
   try {
     if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      fs.mkdirSync(CONFIG_DIR, { recursive: true })
     }
-    fs.writeFileSync(TOKEN_FILE, JSON.stringify({ accessToken: token }), 'utf8');
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify({ accessToken: token }), 'utf8')
     // Set file permissions to be readable only by the owner
-    fs.chmodSync(TOKEN_FILE, 0o600);
+    fs.chmodSync(TOKEN_FILE, 0o600)
   } catch (error) {
-    console.error('Error saving auth token:', error);
+    console.error('Error saving auth token:', error)
   }
-};
+}
 
 export const clearAuthToken = (): void => {
   try {
     if (fs.existsSync(TOKEN_FILE)) {
-      fs.unlinkSync(TOKEN_FILE);
+      fs.unlinkSync(TOKEN_FILE)
     }
   } catch (error) {
-    console.error('Error clearing auth token:', error);
+    console.error('Error clearing auth token:', error)
   }
-};
+}
 
 // Create an authenticated client
 export const createAuthenticatedClient = () => {
-  const token = getAuthToken();
-  
+  const token = getAuthToken()
   if (!token) {
-    console.warn(chalk.yellow('No authentication token found. Please run `berget login` first.'));
+    console.warn(
+      chalk.yellow(
+        'No authentication token found. Please run `berget login` first.'
+      )
+    )
   } else if (isTokenExpired(token)) {
-    console.warn(chalk.yellow('Your authentication token has expired. Please run `berget login` to get a new token.'));
+    console.warn(
+      chalk.yellow(
+        'Your authentication token has expired. Please run `berget login` to get a new token.'
+      )
+    )
     // Optionally clear the expired token
-    clearAuthToken();
+    clearAuthToken()
     return createClient<paths>({
       baseUrl: API_BASE_URL,
       headers: {
         'Content-Type': 'application/json',
-        'Accept': 'application/json'
-      }
-    });
+        Accept: 'application/json',
+      },
+    })
   }
-  
+
   return createClient<paths>({
     baseUrl: API_BASE_URL,
-    headers: token ? { 
-      'Authorization': `Bearer ${token}`,
-      'Content-Type': 'application/json',
-      'Accept': 'application/json'
-    } : {
-      'Content-Type': 'application/json',
-      'Accept': 'application/json'
-    },
-  });
-};
+    headers: token
+      ? {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        }
+      : {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+  })
+}

package/src/constants/command-structure.ts

@@ -0,0 +1,168 @@
+/**
+ * Command structure constants for the CLI
+ * Following patterns from AWS CLI and Google Cloud CLI
+ */
+
+// Main command groups
+export const COMMAND_GROUPS = {
+  AUTH: 'auth',
+  API_KEYS: 'api-keys',
+  CLUSTERS: 'clusters',
+  APPS: 'apps',
+  MODELS: 'models',
+  HELM: 'helm',
+  KUBECTL: 'kubectl',
+  FLUX: 'flux',
+  USERS: 'users',
+  BILLING: 'billing',
+}
+
+// Subcommands for each group
+export const SUBCOMMANDS = {
+  // Auth commands
+  AUTH: {
+    LOGIN: 'login',
+    LOGOUT: 'logout',
+    WHOAMI: 'whoami',
+  },
+  
+  // API Keys commands
+  API_KEYS: {
+    LIST: 'list',
+    CREATE: 'create',
+    DELETE: 'delete',
+    ROTATE: 'rotate',
+    DESCRIBE: 'describe',
+  },
+  
+  // Clusters commands
+  CLUSTERS: {
+    LIST: 'list',
+    DESCRIBE: 'describe',
+    GET_USAGE: 'get-usage',
+  },
+  
+  // Apps commands
+  APPS: {
+    LIST_TEMPLATES: 'list-templates',
+    DESCRIBE_TEMPLATE: 'describe-template',
+    LIST_INSTALLATIONS: 'list-installations',
+    INSTALL: 'install',
+    UNINSTALL: 'uninstall',
+    DESCRIBE_INSTALLATION: 'describe-installation',
+  },
+  
+  // Models commands
+  MODELS: {
+    LIST: 'list',
+    DESCRIBE: 'describe',
+  },
+  
+  // Helm commands
+  HELM: {
+    ADD_REPO: 'add-repo',
+    INSTALL: 'install',
+  },
+  
+  // Kubectl commands
+  KUBECTL: {
+    CREATE_NAMESPACE: 'create-namespace',
+    APPLY: 'apply',
+    GET: 'get',
+  },
+  
+  // Flux commands
+  FLUX: {
+    INSTALL: 'install',
+    BOOTSTRAP: 'bootstrap',
+  },
+  
+  // Users commands
+  USERS: {
+    LIST: 'list',
+    DESCRIBE: 'describe',
+    UPDATE: 'update',
+    INVITE: 'invite',
+  },
+  
+  // Billing commands
+  BILLING: {
+    GET_USAGE: 'get-usage',
+    LIST_INVOICES: 'list-invoices',
+    DESCRIBE_INVOICE: 'describe-invoice',
+    LIST_PAYMENT_METHODS: 'list-payment-methods',
+    ADD_PAYMENT_METHOD: 'add-payment-method',
+    REMOVE_PAYMENT_METHOD: 'remove-payment-method',
+    UPDATE_SUBSCRIPTION: 'update-subscription',
+  },
+}
+
+// Command descriptions
+export const COMMAND_DESCRIPTIONS = {
+  // Auth group
+  [COMMAND_GROUPS.AUTH]: 'Manage authentication and authorization',
+  [`${COMMAND_GROUPS.AUTH} ${SUBCOMMANDS.AUTH.LOGIN}`]: 'Log in to Berget AI',
+  [`${COMMAND_GROUPS.AUTH} ${SUBCOMMANDS.AUTH.LOGOUT}`]: 'Log out from Berget AI',
+  [`${COMMAND_GROUPS.AUTH} ${SUBCOMMANDS.AUTH.WHOAMI}`]: 'Display current user information',
+  
+  // API Keys group
+  [COMMAND_GROUPS.API_KEYS]: 'Manage API keys',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.LIST}`]: 'List all API keys',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.CREATE}`]: 'Create a new API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.DELETE}`]: 'Delete an API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.ROTATE}`]: 'Rotate an API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.DESCRIBE}`]: 'Get usage statistics for an API key',
+  
+  // Clusters group
+  [COMMAND_GROUPS.CLUSTERS]: 'Manage Kubernetes clusters',
+  [`${COMMAND_GROUPS.CLUSTERS} ${SUBCOMMANDS.CLUSTERS.LIST}`]: 'List all clusters',
+  [`${COMMAND_GROUPS.CLUSTERS} ${SUBCOMMANDS.CLUSTERS.DESCRIBE}`]: 'Get detailed information about a cluster',
+  [`${COMMAND_GROUPS.CLUSTERS} ${SUBCOMMANDS.CLUSTERS.GET_USAGE}`]: 'Get resource usage for a cluster',
+  
+  // Apps group
+  [COMMAND_GROUPS.APPS]: 'Manage applications',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.LIST_TEMPLATES}`]: 'List available application templates',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.DESCRIBE_TEMPLATE}`]: 'Get detailed information about an application template',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.LIST_INSTALLATIONS}`]: 'List installed applications',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.INSTALL}`]: 'Install an application',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.UNINSTALL}`]: 'Uninstall an application',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.DESCRIBE_INSTALLATION}`]: 'Get detailed information about an installed application',
+  
+  // Models group
+  [COMMAND_GROUPS.MODELS]: 'Manage AI models',
+  [`${COMMAND_GROUPS.MODELS} ${SUBCOMMANDS.MODELS.LIST}`]: 'List available AI models',
+  [`${COMMAND_GROUPS.MODELS} ${SUBCOMMANDS.MODELS.DESCRIBE}`]: 'Get detailed information about an AI model',
+  
+  // Helm group
+  [COMMAND_GROUPS.HELM]: 'Manage Helm charts',
+  [`${COMMAND_GROUPS.HELM} ${SUBCOMMANDS.HELM.ADD_REPO}`]: 'Add a Helm repository',
+  [`${COMMAND_GROUPS.HELM} ${SUBCOMMANDS.HELM.INSTALL}`]: 'Install a Helm chart',
+  
+  // Kubectl group
+  [COMMAND_GROUPS.KUBECTL]: 'Manage Kubernetes resources',
+  [`${COMMAND_GROUPS.KUBECTL} ${SUBCOMMANDS.KUBECTL.CREATE_NAMESPACE}`]: 'Create a Kubernetes namespace',
+  [`${COMMAND_GROUPS.KUBECTL} ${SUBCOMMANDS.KUBECTL.APPLY}`]: 'Apply a Kubernetes configuration',
+  [`${COMMAND_GROUPS.KUBECTL} ${SUBCOMMANDS.KUBECTL.GET}`]: 'Get Kubernetes resources',
+  
+  // Flux group
+  [COMMAND_GROUPS.FLUX]: 'Manage Flux CD',
+  [`${COMMAND_GROUPS.FLUX} ${SUBCOMMANDS.FLUX.INSTALL}`]: 'Install Flux CD',
+  [`${COMMAND_GROUPS.FLUX} ${SUBCOMMANDS.FLUX.BOOTSTRAP}`]: 'Bootstrap Flux CD',
+  
+  // Users group
+  [COMMAND_GROUPS.USERS]: 'Manage users',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.LIST}`]: 'List all users in your organization',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.DESCRIBE}`]: 'Get detailed information about a user',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.UPDATE}`]: 'Update user information',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.INVITE}`]: 'Invite a new user to your organization',
+  
+  // Billing group
+  [COMMAND_GROUPS.BILLING]: 'Manage billing and usage',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.GET_USAGE}`]: 'Get current usage metrics',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.LIST_INVOICES}`]: 'List all invoices',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.DESCRIBE_INVOICE}`]: 'Get detailed information about an invoice',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.LIST_PAYMENT_METHODS}`]: 'List all payment methods',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.ADD_PAYMENT_METHOD}`]: 'Add a new payment method',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.REMOVE_PAYMENT_METHOD}`]: 'Remove a payment method',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.UPDATE_SUBSCRIPTION}`]: 'Update subscription plan',
+}

package/src/services/api-key-service.ts

@@ -1,5 +1,6 @@
 import { createAuthenticatedClient } from '../client'
 import { handleError } from '../utils/error-handler'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface ApiKey {
   id: number
@@ -25,9 +26,19 @@ export interface ApiKeyResponse {
   created: string
 }
 
+/**
+ * Service for managing API keys
+ * Command group: api-keys
+ */
 export class ApiKeyService {
   private static instance: ApiKeyService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.API_KEYS
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.API_KEYS
 
   private constructor() {}
 
@@ -38,7 +49,11 @@ export class ApiKeyService {
     return ApiKeyService.instance
   }
 
-  public async listApiKeys(): Promise<ApiKey[]> {
+  /**
+   * List all API keys
+   * Command: berget api-keys list
+   */
+  public async list(): Promise<ApiKey[]> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys')
       if (error) {
@@ -60,7 +75,11 @@ export class ApiKeyService {
     }
   }
 
-  public async createApiKey(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
+  /**
+   * Create a new API key
+   * Command: berget api-keys create
+   */
+  public async create(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.POST('/v1/api-keys', {
         body: options
@@ -73,7 +92,11 @@ export class ApiKeyService {
     }
   }
 
-  public async deleteApiKey(id: string): Promise<boolean> {
+  /**
+   * Delete an API key
+   * Command: berget api-keys delete
+   */
+  public async delete(id: string): Promise<boolean> {
     try {
       const { error } = await this.client.DELETE('/v1/api-keys/{id}', {
         params: { path: { id } }
@@ -86,7 +109,11 @@ export class ApiKeyService {
     }
   }
 
-  public async rotateApiKey(id: string): Promise<ApiKeyResponse> {
+  /**
+   * Rotate an API key
+   * Command: berget api-keys rotate
+   */
+  public async rotate(id: string): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.PUT('/v1/api-keys/{id}/rotate', {
         params: { path: { id } }
@@ -99,7 +126,11 @@ export class ApiKeyService {
     }
   }
 
-  public async getApiKeyUsage(id: string): Promise<any> {
+  /**
+   * Get usage statistics for an API key
+   * Command: berget api-keys describe
+   */
+  public async describe(id: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys/{id}/usage', {
         params: { path: { id } }