language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/commands/cluster.rb

@@ -1,21 +1,16 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require_relative '../base_command'
-require_relative '../formatters/progress_formatter'
-require_relative '../formatters/table_formatter'
-require_relative '../helpers/cluster_validator'
-require_relative '../helpers/user_prompts'
-require_relative '../../config/cluster_config'
-require_relative '../../kubernetes/client'
-require_relative '../../kubernetes/resource_builder'
+require_relative '../command_loader'
+require_relative '../../utils/secure_path'
 
 module LanguageOperator
   module CLI
     module Commands
       # Cluster management commands
       class Cluster < BaseCommand
-        include Helpers::PastelHelper
+        include Constants
+        include Helpers::UxHelper
 
         desc 'create NAME', 'Create a new language cluster'
         option :namespace, type: :string, desc: 'Kubernetes namespace (defaults to current context namespace)'
@@ -23,6 +18,7 @@ module LanguageOperator
         option :context, type: :string, desc: 'Kubernetes context to use'
         option :switch, type: :boolean, default: true, desc: 'Switch to new cluster context'
         option :dry_run, type: :boolean, default: false, desc: 'Output the manifest without creating'
+        option :domain, type: :string, desc: 'Base domain for webhook routing (e.g., example.com)'
         def create(name)
           handle_command_error('create cluster') do
             kubeconfig = options[:kubeconfig]
@@ -31,7 +27,7 @@ module LanguageOperator
             # Handle dry-run: output manifest and exit early
             if options[:dry_run]
               namespace = options[:namespace] || 'default'
-              resource = Kubernetes::ResourceBuilder.language_cluster(name, namespace: namespace)
+              resource = Kubernetes::ResourceBuilder.language_cluster(name, namespace: namespace, domain: options[:domain])
               puts resource.to_yaml
               return
             end
@@ -61,16 +57,15 @@ module LanguageOperator
             # Create namespace if it doesn't exist
             unless k8s.namespace_exists?(namespace)
               Formatters::ProgressFormatter.with_spinner("Creating namespace '#{namespace}'") do
-                k8s.create_namespace(namespace, labels: {
-                                       'app.kubernetes.io/managed-by' => 'aictl',
-                                       'langop.io/cluster' => name
-                                     })
+                k8s.create_namespace(namespace, labels: Constants::KubernetesLabels.cluster_management_labels.merge(
+                                       Constants::KubernetesLabels::CLUSTER_LABEL => name
+                                     ))
               end
             end
 
             # Create LanguageCluster resource
             Formatters::ProgressFormatter.with_spinner('Creating LanguageCluster resource') do
-              resource = Kubernetes::ResourceBuilder.language_cluster(name, namespace: namespace)
+              resource = Kubernetes::ResourceBuilder.language_cluster(name, namespace: namespace, domain: options[:domain])
               k8s.apply_resource(resource)
               resource
             end
@@ -83,26 +78,30 @@ module LanguageOperator
               Config::ClusterConfig.add_cluster(
                 name,
                 namespace,
-                kubeconfig || ENV.fetch('KUBECONFIG', File.expand_path('~/.kube/config')),
+                kubeconfig || ENV.fetch('KUBECONFIG', LanguageOperator::Utils::SecurePath.expand_home_path('.kube/config')),
                 actual_context
               )
             end
 
             # Switch to new cluster if requested
-            if options[:switch]
-              Config::ClusterConfig.set_current_cluster(name)
-              Formatters::ProgressFormatter.success("Created and switched to cluster '#{name}'")
-            else
-              Formatters::ProgressFormatter.success("Created cluster '#{name}'")
-              puts "\nSwitch to this cluster with:"
-              puts "  aictl use #{name}"
-            end
+            Config::ClusterConfig.set_current_cluster(name) if options[:switch]
 
-            puts "\nCluster Details"
-            puts '---------------'
-            puts "Name: #{pastel.bold.white(name)}"
-            puts "Namespace: #{pastel.bold.white(namespace)}"
-            puts "Context: #{pastel.bold.white(actual_context)}"
+            puts
+            format_cluster_details(
+              name: name,
+              namespace: namespace,
+              context: actual_context,
+              domain: options[:domain],
+              status: 'Ready',
+              created: Time.now.strftime('%Y-%m-%dT%H:%M:%SZ')
+            )
+
+            # Show usage instructions if not auto-switched
+            unless options[:switch]
+              puts
+              puts 'Switch to this cluster with:'
+              puts pastel.dim("  aictl use #{name}")
+            end
           end
         end
 
@@ -120,21 +119,54 @@ module LanguageOperator
               return
             end
 
+            # Cache clients by kubeconfig:context to prevent resource leaks
+            clients_cache = {}
+
             # Build table data
             table_data = clusters.map do |cluster|
-              k8s = Helpers::ClusterValidator.kubernetes_client(cluster[:name])
+              begin
+                # Get cluster config for cache key and reuse clients
+                cluster_config = Config::ClusterConfig.get_cluster(cluster[:name])
+                cache_key = "#{cluster_config[:kubeconfig]}:#{cluster_config[:context]}"
+
+                # Reuse existing client or create new one
+                k8s = clients_cache[cache_key] ||= begin
+                  # Validate kubeconfig exists before creating client
+                  Helpers::ClusterValidator.validate_kubeconfig!(cluster_config)
+                  require_relative '../../kubernetes/client'
+                  Kubernetes::Client.new(
+                    kubeconfig: cluster_config[:kubeconfig],
+                    context: cluster_config[:context]
+                  )
+                end
+              rescue StandardError
+                # Handle cluster config or client creation errors
+                name_display = cluster[:name]
+                name_display += ' *' if cluster[:name] == current
+
+                next {
+                  name: name_display,
+                  namespace: cluster[:namespace],
+                  agents: '?',
+                  tools: '?',
+                  models: '?',
+                  status: 'Config Error',
+                  domain: '?'
+                }
+              end
 
               # Get cluster stats
-              agents = k8s.list_resources('LanguageAgent', namespace: cluster[:namespace])
-              tools = k8s.list_resources('LanguageTool', namespace: cluster[:namespace])
-              models = k8s.list_resources('LanguageModel', namespace: cluster[:namespace])
+              agents = k8s.list_resources(RESOURCE_AGENT, namespace: cluster[:namespace])
+              tools = k8s.list_resources(RESOURCE_TOOL, namespace: cluster[:namespace])
+              models = k8s.list_resources(RESOURCE_MODEL, namespace: cluster[:namespace])
 
-              # Get cluster status
+              # Get cluster status and domain
               cluster_resource = k8s.get_resource('LanguageCluster', cluster[:name], cluster[:namespace])
               status = cluster_resource.dig('status', 'phase') || 'Unknown'
+              domain = cluster_resource.dig('spec', 'domain')
 
               name_display = cluster[:name]
-              name_display += ' *' if cluster[:name] == current
+              name_display = "#{pastel.bold(cluster[:name])} (selected)" if cluster[:name] == current
 
               {
                 name: name_display,
@@ -142,7 +174,8 @@ module LanguageOperator
                 agents: agents.count,
                 tools: tools.count,
                 models: models.count,
-                status: status
+                status: status,
+                domain: domain
               }
             rescue K8s::Error::NotFound
               # Cluster exists in local config but not in Kubernetes
@@ -155,7 +188,8 @@ module LanguageOperator
                 agents: '-',
                 tools: '-',
                 models: '-',
-                status: 'Not Found'
+                status: 'Not Found',
+                domain: '-'
               }
             rescue StandardError
               # Other errors (connection issues, auth problems, etc.)
@@ -168,17 +202,14 @@ module LanguageOperator
                 agents: '?',
                 tools: '?',
                 models: '?',
-                status: 'Error'
+                status: 'Error',
+                domain: '?'
               }
             end
 
             Formatters::TableFormatter.clusters(table_data)
 
-            if current
-              puts "\nCurrent cluster: #{current} (*)"
-            else
-              puts "\nNo cluster selected. Use 'aictl use <cluster>' to select one."
-            end
+            puts "\nNo cluster selected. Use 'aictl use <cluster>' to select one." unless current
 
             # Show helpful message if any clusters are not found
             not_found_clusters = table_data.select { |c| c[:status] == 'Not Found' }
@@ -242,6 +273,7 @@ module LanguageOperator
 
         desc 'delete NAME', 'Delete a cluster'
         option :force, type: :boolean, default: false, desc: 'Skip confirmation'
+        option :force_local, type: :boolean, default: false, desc: 'Force removal from local config only (skip Kubernetes deletion)'
         def delete(name)
           handle_command_error('delete cluster') do
             unless Config::ClusterConfig.cluster_exists?(name)
@@ -252,32 +284,40 @@ module LanguageOperator
             cluster = Config::ClusterConfig.get_cluster(name)
 
             # Confirm deletion
-            unless options[:force]
-              puts "This will delete cluster #{pastel.bold.red(name)} and all its resources (agents, models, tools, personas)."
-              puts
-              return unless Helpers::UserPrompts.confirm('Are you sure?')
-            end
+            return if !options[:force] && !confirm_deletion('cluster', name, name)
 
-            # Delete LanguageCluster resource
-            begin
-              k8s = Helpers::ClusterValidator.kubernetes_client(name)
-
-              Formatters::ProgressFormatter.with_spinner('Deleting LanguageCluster resource') do
-                k8s.delete_resource('LanguageCluster', name, cluster[:namespace])
+            # Delete LanguageCluster resource from Kubernetes (unless --force-local)
+            if options[:force_local]
+              Formatters::ProgressFormatter.warn('Skipping Kubernetes resource deletion (--force-local specified)')
+            else
+              begin
+                k8s = Helpers::ClusterValidator.kubernetes_client(name)
+
+                Formatters::ProgressFormatter.with_spinner('Deleting LanguageCluster resource') do
+                  k8s.delete_resource('LanguageCluster', name, cluster[:namespace])
+                end
+              rescue StandardError => e
+                Formatters::ProgressFormatter.error("Failed to delete cluster resource: #{e.message}")
+                puts
+                puts 'Cluster deletion failed. The LanguageCluster resource could not be removed from Kubernetes.'
+                puts 'This may be due to:'
+                puts '  • Network connectivity issues'
+                puts '  • Insufficient permissions'
+                puts '  • The cluster resource no longer exists'
+                puts
+                puts 'To force removal from local configuration only, use:'
+                puts pastel.dim("  aictl cluster delete #{name} --force-local")
+                exit 1
               end
-            rescue StandardError => e
-              Formatters::ProgressFormatter.warn("Failed to delete cluster resource: #{e.message}")
             end
 
-            # Remove from config
+            # Remove from config only after successful Kubernetes deletion
             Formatters::ProgressFormatter.with_spinner('Removing cluster from configuration') do
               Config::ClusterConfig.remove_cluster(name)
             end
 
             # Clear current cluster if this was it
             Config::ClusterConfig.set_current_cluster(nil) if Config::ClusterConfig.current_cluster == name
-
-            Formatters::ProgressFormatter.success("Deleted cluster '#{name}'")
           end
         end
 
@@ -291,12 +331,6 @@ module LanguageOperator
 
             cluster = Config::ClusterConfig.get_cluster(name)
 
-            puts "Cluster: #{name}"
-            puts "  Namespace: #{cluster[:namespace]}"
-            puts "  Context:   #{cluster[:context] || 'default'}"
-            puts "  Created:   #{cluster[:created]}"
-            puts
-
             # Get detailed cluster info
             begin
               k8s = Helpers::ClusterValidator.kubernetes_client(name)
@@ -304,45 +338,56 @@ module LanguageOperator
               # Get cluster resource
               cluster_resource = k8s.get_resource('LanguageCluster', name, cluster[:namespace])
               status = cluster_resource.dig('status', 'phase') || 'Unknown'
+              domain = cluster_resource.dig('spec', 'domain')
 
-              puts "Status: #{status}"
+              # Main cluster information
+              puts
+              highlighted_box(
+                title: 'LanguageCluster',
+                rows: {
+                  'Name' => pastel.white.bold(name),
+                  'Namespace' => cluster[:namespace],
+                  'Cluster' => name,
+                  'Context' => cluster[:context] || 'default',
+                  'Domain' => domain,
+                  'Status' => status,
+                  'Created' => cluster[:created]
+                }.compact
+              )
               puts
 
               # Get agents
-              agents = k8s.list_resources('LanguageAgent', namespace: cluster[:namespace])
-              puts "Agents: #{agents.count}"
-              agents.each do |agent|
-                agent_status = agent.dig('status', 'phase') || 'Unknown'
-                puts "  - #{agent.dig('metadata', 'name')} (#{agent_status})"
+              agents = k8s.list_resources(RESOURCE_AGENT, namespace: cluster[:namespace])
+              agent_items = agents.map do |agent|
+                { name: agent.dig('metadata', 'name'), status: agent.dig('status', 'phase') || 'Unknown' }
               end
+              list_box(title: 'Agents', items: agent_items, style: :detailed)
               puts
 
               # Get tools
-              tools = k8s.list_resources('LanguageTool', namespace: cluster[:namespace])
-              puts "Tools: #{tools.count}"
-              tools.each do |tool|
-                tool_type = tool.dig('spec', 'type')
-                puts "  - #{tool.dig('metadata', 'name')} (#{tool_type})"
+              tools = k8s.list_resources(RESOURCE_TOOL, namespace: cluster[:namespace])
+              tool_items = tools.map do |tool|
+                { name: tool.dig('metadata', 'name') }
               end
+              list_box(title: 'Tools', items: tool_items, style: :detailed)
               puts
 
               # Get models
-              models = k8s.list_resources('LanguageModel', namespace: cluster[:namespace])
-              puts "Models: #{models.count}"
-              models.each do |model|
+              models = k8s.list_resources(RESOURCE_MODEL, namespace: cluster[:namespace])
+              model_items = models.map do |model|
                 provider = model.dig('spec', 'provider')
                 model_name = model.dig('spec', 'modelName')
-                puts "  - #{model.dig('metadata', 'name')} (#{provider}/#{model_name})"
+                { name: model.dig('metadata', 'name'), meta: "#{provider}/#{model_name}" }
               end
+              list_box(title: 'Models', items: model_items, style: :detailed)
               puts
 
               # Get personas
               personas = k8s.list_resources('LanguagePersona', namespace: cluster[:namespace])
-              puts "Personas: #{personas.count}"
-              personas.each do |persona|
-                tone = persona.dig('spec', 'tone')
-                puts "  - #{persona.dig('metadata', 'name')} (#{tone})"
+              persona_items = personas.map do |persona|
+                { name: persona.dig('metadata', 'name'), meta: persona.dig('spec', 'tone') }
               end
+              list_box(title: 'Personas', items: persona_items, style: :detailed)
             rescue StandardError => e
               Formatters::ProgressFormatter.error("Failed to get cluster details: #{e.message}")
               raise if ENV['DEBUG']

data/lib/language_operator/cli/commands/install.rb

@@ -275,7 +275,7 @@ module LanguageOperator
               puts '  - LanguageModel resources'
               puts '  - LanguagePersona resources'
               puts
-              return unless Helpers::UserPrompts.confirm('Continue with uninstall?')
+              return unless CLI::Helpers::UserPrompts.confirm('Continue with uninstall?')
             end
 
             # Build helm uninstall command

data/lib/language_operator/cli/commands/model/base.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative '../../command_loader'
+require_relative '../../wizards/model_wizard'
+require_relative 'test'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Model
+        # Model management commands
+        class Base < BaseCommand
+          include Constants
+          include Helpers::ClusterValidator
+          include Test
+
+          desc 'list', 'List all models in current cluster'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          def list
+            handle_command_error('list models') do
+              models = list_resources_or_empty(RESOURCE_MODEL, resource_name: 'models') do
+                puts
+                puts 'Create a model with:'
+                puts '  aictl model create <name> --provider <provider> --model <model>'
+              end
+
+              return if models.empty?
+
+              table_data = models.map do |model|
+                name = model.dig('metadata', 'name')
+                provider = model.dig('spec', 'provider') || 'unknown'
+                model_name = model.dig('spec', 'modelName') || 'unknown'
+                status = model.dig('status', 'phase') || 'Unknown'
+
+                {
+                  name: name,
+                  namespace: model.dig('metadata', 'namespace') || ctx.namespace,
+                  provider: provider,
+                  model: model_name,
+                  status: status
+                }
+              end
+
+              Formatters::TableFormatter.models(table_data)
+            end
+          end
+
+          desc 'create [NAME]', 'Create a new model'
+          long_desc <<-DESC
+            Create a new LanguageModel resource in the cluster.
+
+            If NAME is omitted and no options are provided, an interactive wizard will guide you.
+
+            Examples:
+              aictl model create                  # Launch interactive wizard
+              aictl model create gpt4 --provider openai --model gpt-4-turbo
+              aictl model create claude --provider anthropic --model claude-3-opus-20240229
+              aictl model create local --provider openai_compatible --model llama-3 --endpoint http://localhost:8080
+          DESC
+          option :provider, type: :string, required: false, desc: 'LLM provider (e.g., openai, anthropic, openai_compatible)'
+          option :model, type: :string, required: false, desc: 'Model identifier (e.g., gpt-4, claude-3-opus)'
+          option :endpoint, type: :string, desc: 'Custom endpoint URL (for openai_compatible or self-hosted)'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          option :dry_run, type: :boolean, default: false, desc: 'Output the manifest without creating'
+          def create(name = nil)
+            handle_command_error('create model') do
+              # Launch interactive wizard if no arguments provided
+              if name.nil? && options[:provider].nil? && options[:model].nil?
+                wizard = Wizards::ModelWizard.new(ctx)
+                wizard.run
+                return
+              end
+
+              # Validate required options for non-interactive mode
+              if options[:provider].nil? || options[:model].nil?
+                Formatters::ProgressFormatter.error(
+                  'Must provide both --provider and --model, or use interactive mode (run without arguments)'
+                )
+                exit 1
+              end
+
+              # Build LanguageModel resource
+              resource = Kubernetes::ResourceBuilder.language_model(
+                name,
+                provider: options[:provider],
+                model: options[:model],
+                endpoint: options[:endpoint],
+                cluster: ctx.namespace,
+                cluster_ref: ctx.name
+              )
+
+              # Handle dry-run: output manifest and exit
+              if options[:dry_run]
+                puts resource.to_yaml
+                return
+              end
+
+              # Check if model already exists
+              begin
+                ctx.client.get_resource(RESOURCE_MODEL, name, ctx.namespace)
+                Formatters::ProgressFormatter.error("Model '#{name}' already exists in cluster '#{ctx.name}'")
+                exit 1
+              rescue K8s::Error::NotFound
+                # Model doesn't exist, proceed with creation
+              end
+
+              # Create model
+              Formatters::ProgressFormatter.with_spinner("Creating model '#{name}'") do
+                ctx.client.apply_resource(resource)
+              end
+
+              Formatters::ProgressFormatter.success("Model '#{name}' created successfully")
+              puts
+              format_model_details(
+                name: name,
+                namespace: ctx.namespace,
+                cluster: ctx.name,
+                status: 'Ready',
+                provider: options[:provider],
+                model: options[:model],
+                endpoint: options[:endpoint],
+                created: Time.now.strftime('%Y-%m-%dT%H:%M:%SZ')
+              )
+            end
+          end
+
+          desc 'inspect NAME', 'Show detailed model information'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          def inspect(name)
+            handle_command_error('inspect model') do
+              model = get_resource_or_exit(RESOURCE_MODEL, name)
+
+              puts
+              format_model_details(
+                name: name,
+                namespace: ctx.namespace,
+                cluster: ctx.name,
+                status: model.dig('status', 'phase') || 'Unknown',
+                provider: model.dig('spec', 'provider'),
+                model: model.dig('spec', 'modelName'),
+                endpoint: model.dig('spec', 'endpoint'),
+                created: model.dig('metadata', 'creationTimestamp')
+              )
+              puts
+
+              # Get agents using this model
+              agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
+              agents_using = Helpers::ResourceDependencyChecker.agents_using_model(agents, name)
+              agent_names = agents_using.map { |agent| agent.dig('metadata', 'name') }
+
+              list_box(
+                title: 'Agents using this model',
+                items: agent_names,
+                empty_message: 'No agents using this model'
+              )
+
+              puts
+              labels = model.dig('metadata', 'labels') || {}
+              list_box(
+                title: 'Labels',
+                items: labels,
+                style: :key_value
+              )
+            end
+          end
+
+          desc 'delete NAME', 'Delete a model'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          option :force, type: :boolean, default: false, desc: 'Skip confirmation'
+          def delete(name)
+            handle_command_error('delete model') do
+              get_resource_or_exit(RESOURCE_MODEL, name)
+
+              # Check dependencies and get confirmation
+              return unless check_dependencies_and_confirm('model', name, force: options[:force])
+
+              # Confirm deletion unless --force
+              return unless confirm_deletion_with_force('model', name, ctx.name, force: options[:force])
+
+              # Delete model
+              Formatters::ProgressFormatter.with_spinner("Deleting model '#{name}'") do
+                ctx.client.delete_resource(RESOURCE_MODEL, name, ctx.namespace)
+              end
+            end
+          end
+
+          desc 'edit NAME', 'Edit model configuration'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          def edit(name)
+            handle_command_error('edit model') do
+              model = get_resource_or_exit(RESOURCE_MODEL, name)
+
+              # Edit model YAML in user's editor
+              edited_yaml = Helpers::EditorHelper.edit_content(
+                model.to_yaml,
+                'model-',
+                '.yaml',
+                default_editor: 'vim'
+              )
+              edited_model = YAML.safe_load(edited_yaml)
+
+              # Apply changes
+              Formatters::ProgressFormatter.with_spinner("Updating model '#{name}'") do
+                ctx.client.apply_resource(edited_model)
+              end
+
+              Formatters::ProgressFormatter.success("Model '#{name}' updated successfully")
+            end
+          end
+        end
+      end
+    end
+  end
+end