language-operator 0.1.61 → 0.1.62

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'English'
+require 'shellwords'
+require 'tempfile'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Model
+        module Test
+          def self.included(base)
+            base.class_eval do
+              desc 'test NAME', 'Test model connectivity and functionality'
+              long_desc <<-DESC
+                Test that a model is operational by:
+                1. Verifying the pod is running
+                2. Testing the chat completion endpoint with a simple message
+
+                This command helps diagnose model deployment issues.
+              DESC
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              option :timeout, type: :numeric, default: 30, desc: 'Timeout in seconds for endpoint test'
+              def test(name)
+                handle_command_error('test model') do
+                  # 1. Get model resource
+                  model = get_resource_or_exit(RESOURCE_MODEL, name)
+                  model_name = model.dig('spec', 'modelName')
+
+                  # 2. Check deployment status
+                  deployment = check_deployment_status(name)
+
+                  # 3. Check pod status
+                  pod = check_pod_status(name, deployment)
+
+                  # 4. Test chat completion endpoint
+                  test_chat_completion(name, model_name, pod, options[:timeout])
+                end
+              end
+
+              private
+
+              def check_deployment_status(name)
+                Formatters::ProgressFormatter.with_spinner('Verifying deployment') do
+                  deployment = ctx.client.get_resource('Deployment', name, ctx.namespace)
+                  replicas = deployment.dig('spec', 'replicas') || 1
+                  ready_replicas = deployment.dig('status', 'readyReplicas') || 0
+
+                  unless ready_replicas >= replicas
+                    raise "Deployment not ready (#{ready_replicas}/#{replicas}). " \
+                          "Run 'kubectl get deployment #{name} -n #{ctx.namespace}' for details."
+                  end
+
+                  deployment
+                end
+              rescue K8s::Error::NotFound
+                Formatters::ProgressFormatter.error("Deployment '#{name}' not found")
+                exit 1
+              end
+
+              def check_pod_status(name, deployment)
+                Formatters::ProgressFormatter.with_spinner('Verifying pod') do
+                  labels = deployment.dig('spec', 'selector', 'matchLabels')
+
+                  # Find matching pods using centralized utility
+                  pods = CLI::Helpers::LabelUtils.find_pods_by_deployment_labels(ctx, name, labels)
+                  raise "No pods found for model '#{name}'" if pods.empty?
+
+                  # Find a running pod
+                  running_pod = pods.find do |pod|
+                    pod.dig('status', 'phase') == 'Running' &&
+                      pod.dig('status', 'conditions')&.any? { |c| c['type'] == 'Ready' && c['status'] == 'True' }
+                  end
+
+                  if running_pod.nil?
+                    pod_phases = pods.map { |p| p.dig('status', 'phase') }.join(', ')
+                    # Get label selector for error message
+                    labels_hash = labels.respond_to?(:to_h) ? labels.to_h : labels
+                    label_selector = labels_hash.map { |k, v| "#{k}=#{v}" }.join(',')
+                    raise "No running pods found. Pod phases: #{pod_phases}. " \
+                          "Run 'kubectl get pods -l #{label_selector} -n #{ctx.namespace}' for details."
+                  end
+
+                  running_pod
+                end
+              end
+
+              def test_chat_completion(_name, model_name, pod, timeout)
+                Formatters::ProgressFormatter.with_spinner('Verifying chat completion requests') do
+                  pod_name = pod.dig('metadata', 'name')
+
+                  # Build the JSON payload
+                  payload = JSON.generate({
+                                            model: model_name,
+                                            messages: [{ role: 'user', content: 'hello' }],
+                                            max_tokens: 10
+                                          })
+
+                  # Create temporary file to avoid command injection
+                  temp_file = nil
+                  begin
+                    temp_file = Tempfile.new(['model_test_payload', '.json'])
+                    temp_file.write(payload)
+                    temp_file.close
+
+                    # Build secure curl command using temp file
+                    # This eliminates shell injection vulnerability
+                    curl_command = 'curl -s -X POST http://localhost:4000/v1/chat/completions ' \
+                                   "-H 'Content-Type: application/json' -d @#{temp_file.path} --max-time #{timeout.to_i}"
+
+                    # Execute the curl command inside the pod
+                    result = execute_in_pod(pod_name, curl_command)
+                  ensure
+                    # Clean up temporary file
+                    temp_file&.unlink
+                  end
+
+                  # Parse the response
+                  response = JSON.parse(result)
+
+                  if response['error']
+                    error_msg = response['error']['message'] || response['error']
+                    raise error_msg
+                  elsif !response['choices']
+                    raise "Unexpected response format: #{result.lines.first.strip}"
+                  end
+
+                  response
+                rescue JSON::ParserError => e
+                  raise "Failed to parse response: #{e.message}"
+                end
+              rescue StandardError => e
+                # Display error in bold red
+                puts
+                puts Formatters::ProgressFormatter.pastel.bold.red(e.message)
+                exit 1
+              end
+
+              def execute_in_pod(pod_name, command)
+                # Use kubectl exec to run command in pod
+                # command can be a string or array
+                kubectl_command = if command.is_a?(String)
+                                    "kubectl exec -n #{ctx.namespace} #{pod_name} -- sh -c #{Shellwords.escape(command)}"
+                                  else
+                                    Shellwords.join(['kubectl', 'exec', '-n', ctx.namespace, pod_name, '--'] + command)
+                                  end
+
+                output = `#{kubectl_command} 2>&1`
+                exit_code = $CHILD_STATUS.exitstatus
+
+                if exit_code != 0
+                  Formatters::ProgressFormatter.error("Failed to execute command in pod: #{output}")
+                  exit 1
+                end
+
+                output
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,31 +1,22 @@
 # 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 '../helpers/resource_dependency_checker'
-require_relative '../helpers/editor_helper'
-require_relative '../helpers/pastel_helper'
-require_relative '../../config/cluster_config'
-require_relative '../../kubernetes/client'
-require_relative '../../kubernetes/resource_builder'
+require_relative '../command_loader'
 
 module LanguageOperator
   module CLI
     module Commands
       # Persona management commands
       class Persona < BaseCommand
+        include Constants
         include Helpers::ClusterValidator
-        include Helpers::PastelHelper
+        include Helpers::UxHelper
 
         desc 'list', 'List all personas in current cluster'
         option :cluster, type: :string, desc: 'Override current cluster context'
         def list
           handle_command_error('list personas') do
-            personas = list_resources_or_empty('LanguagePersona') do
+            personas = list_resources_or_empty(RESOURCE_PERSONA) do
               puts
               puts 'Personas define the personality and capabilities of agents.'
               puts
@@ -36,7 +27,7 @@ module LanguageOperator
             return if personas.empty?
 
             # Get agents to count usage
-            agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+            agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
 
             table_data = personas.map do |persona|
               name = persona.dig('metadata', 'name')
@@ -58,7 +49,7 @@ module LanguageOperator
         option :cluster, type: :string, desc: 'Override current cluster context'
         def show(name)
           handle_command_error('show persona') do
-            persona = get_resource_or_exit('LanguagePersona', name)
+            persona = get_resource_or_exit(RESOURCE_PERSONA, name)
 
             puts
             puts "Persona: #{pastel.cyan.bold(name)}"
@@ -123,7 +114,7 @@ module LanguageOperator
           handle_command_error('create persona') do
             # Check if persona already exists
             begin
-              ctx.client.get_resource('LanguagePersona', name, ctx.namespace)
+              ctx.client.get_resource(RESOURCE_PERSONA, name, ctx.namespace)
               Formatters::ProgressFormatter.error("Persona '#{name}' already exists in cluster '#{ctx.name}'")
               puts
               puts 'Use a different name or delete the existing persona first:'
@@ -136,7 +127,7 @@ module LanguageOperator
             # If --from flag provided, copy from existing persona
             base_persona = nil
             if options[:from]
-              base_persona = get_resource_or_exit('LanguagePersona', options[:from],
+              base_persona = get_resource_or_exit(RESOURCE_PERSONA, options[:from],
                                                   error_message: "Source persona '#{options[:from]}' not found")
               Formatters::ProgressFormatter.info("Copying from persona '#{options[:from]}'")
               puts
@@ -144,7 +135,7 @@ module LanguageOperator
 
             # Interactive prompts
             require 'tty-prompt'
-            prompt = TTY::Prompt.new
+            # prompt available via UxHelper
 
             puts
             puts '=' * 80
@@ -245,7 +236,7 @@ module LanguageOperator
         def edit(name)
           handle_command_error('edit persona') do
             # Get current persona
-            persona = get_resource_or_exit('LanguagePersona', name)
+            persona = get_resource_or_exit(RESOURCE_PERSONA, name)
 
             # Open in editor
             original_yaml = YAML.dump(persona)
@@ -279,7 +270,7 @@ module LanguageOperator
             Formatters::ProgressFormatter.success("Persona '#{name}' updated successfully")
 
             # Check for agents using this persona
-            agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+            agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
             agents_using = Helpers::ResourceDependencyChecker.agents_using_persona(agents, name)
 
             if agents_using.any?
@@ -298,26 +289,17 @@ module LanguageOperator
         def delete(name)
           handle_command_error('delete persona') do
             # Get persona
-            persona = get_resource_or_exit('LanguagePersona', name)
+            get_resource_or_exit(RESOURCE_PERSONA, name)
 
             # Check dependencies and get confirmation
             return unless check_dependencies_and_confirm('persona', name, force: options[:force])
 
             # Confirm deletion unless --force
-            if confirm_deletion(
-              'persona', name, ctx.name,
-              details: {
-                'Tone' => persona.dig('spec', 'tone'),
-                'Description' => persona.dig('spec', 'description')
-              },
-              force: options[:force]
-            )
-              # Delete persona
-              Formatters::ProgressFormatter.with_spinner("Deleting persona '#{name}'") do
-                ctx.client.delete_resource('LanguagePersona', name, ctx.namespace)
-              end
+            return unless confirm_deletion_with_force('persona', name, ctx.name, force: options[:force])
 
-              Formatters::ProgressFormatter.success("Persona '#{name}' deleted successfully")
+            # Delete persona
+            Formatters::ProgressFormatter.with_spinner("Deleting persona '#{name}'") do
+              ctx.client.delete_resource(RESOURCE_PERSONA, name, ctx.namespace)
             end
           end
         end

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

@@ -2,7 +2,7 @@
 
 require_relative '../base_command'
 require_relative '../formatters/progress_formatter'
-require_relative '../../ux/quickstart'
+require_relative '../wizards/quickstart_wizard'
 
 module LanguageOperator
   module CLI
@@ -11,7 +11,8 @@ module LanguageOperator
       class Quickstart < BaseCommand
         desc 'start', 'Interactive setup wizard for first-time users'
         def start
-          Ux::Quickstart.execute
+          wizard = Wizards::QuickstartWizard.new
+          wizard.run
         end
 
         default_task :start

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

@@ -1,20 +1,14 @@
 # frozen_string_literal: true
 
-require_relative '../base_command'
-require_relative '../formatters/progress_formatter'
-require_relative '../formatters/table_formatter'
-require_relative '../formatters/status_formatter'
-require_relative '../helpers/pastel_helper'
-require_relative '../../config/cluster_config'
-require_relative '../../kubernetes/client'
-require_relative '../helpers/cluster_validator'
+require_relative '../command_loader'
 
 module LanguageOperator
   module CLI
     module Commands
       # System status and overview command
       class Status < BaseCommand
-        include Helpers::PastelHelper
+        include Constants
+        include Helpers::UxHelper
 
         desc 'overview', 'Show system status and overview'
         def overview
@@ -26,21 +20,48 @@ module LanguageOperator
             if current_cluster
               cluster_config = Config::ClusterConfig.get_cluster(current_cluster)
 
-              puts "\nCluster Details"
-              puts '----------------'
-              puts "Name: #{pastel.bold.white(current_cluster)}"
-              puts "Namespace: #{pastel.bold.white(cluster_config[:namespace])}"
-              puts
-
               # Check cluster health
               k8s = Helpers::ClusterValidator.kubernetes_client(current_cluster)
 
-              # Operator status
+              # Try to get actual cluster resource from Kubernetes
+              cluster_resource = nil
               if k8s.operator_installed?
-                version = k8s.operator_version || 'installed'
-                Formatters::ProgressFormatter.success("Operator: #{version}")
+                begin
+                  cluster_resource = k8s.get_resource('LanguageCluster', current_cluster, cluster_config[:namespace])
+                rescue StandardError
+                  # Cluster resource might not exist yet
+                end
+              end
+
+              # Format cluster info using UxHelper
+              logo(title: 'cluster status')
+              
+              if cluster_resource
+                # Use actual cluster resource data
+                status = cluster_resource.dig('status', 'phase') || 'Unknown'
+                domain = cluster_resource.dig('spec', 'domain')
+                created = cluster_resource.dig('metadata', 'creationTimestamp')
+                
+                format_cluster_details(
+                  name: current_cluster,
+                  namespace: cluster_config[:namespace],
+                  context: cluster_config[:context],
+                  status: status,
+                  domain: domain,
+                  created: created
+                )
               else
-                Formatters::ProgressFormatter.error('Operator: not installed')
+                # Fallback to local config and operator status
+                format_cluster_details(
+                  name: current_cluster,
+                  namespace: cluster_config[:namespace],
+                  context: cluster_config[:context],
+                  status: k8s.operator_installed? ? (k8s.operator_version || 'installed') : 'operator not installed'
+                )
+              end
+
+              # Early exit if operator not installed
+              unless k8s.operator_installed?
                 puts
                 puts 'Install the operator with:'
                 puts '  aictl install'
@@ -48,54 +69,6 @@ module LanguageOperator
                 return
               end
 
-              # Agent statistics
-              agents = k8s.list_resources('LanguageAgent', namespace: cluster_config[:namespace])
-              agent_stats = categorize_by_status(agents)
-
-              puts
-              puts "Agents (#{agents.count} total):"
-              agent_stats.each do |status, count|
-                puts "  #{format_status(status)}: #{count}"
-              end
-
-              # Tool statistics
-              tools = k8s.list_resources('LanguageTool', namespace: cluster_config[:namespace])
-              puts
-              puts "Tools (#{tools.count} total):"
-              if tools.any?
-                tool_types = tools.group_by { |t| t.dig('spec', 'type') }
-                tool_types.each do |type, items|
-                  puts "  #{type}: #{items.count}"
-                end
-              else
-                puts '  (none)'
-              end
-
-              # Model statistics
-              models = k8s.list_resources('LanguageModel', namespace: cluster_config[:namespace])
-              puts
-              puts "Models (#{models.count} total):"
-              if models.any?
-                model_providers = models.group_by { |m| m.dig('spec', 'provider') }
-                model_providers.each do |provider, items|
-                  puts "  #{provider}: #{items.count}"
-                end
-              else
-                puts '  (none)'
-              end
-
-              # Persona statistics
-              personas = k8s.list_resources('LanguagePersona', namespace: cluster_config[:namespace])
-              puts
-              puts "Personas (#{personas.count} total):"
-              if personas.any?
-                personas.each do |persona|
-                  tone = persona.dig('spec', 'tone')
-                  puts "  - #{persona.dig('metadata', 'name')} (#{tone})"
-                end
-              else
-                puts '  (none)'
-              end
             else
               Formatters::ProgressFormatter.warn('No cluster selected')
               puts

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+require_relative '../../base_command'
+require_relative '../../formatters/progress_formatter'
+require_relative '../../../dsl/schema'
+
+# Include all system subcommand modules
+require_relative 'schema'
+require_relative 'validate_template'
+require_relative 'synthesize'
+require_relative 'exec'
+require_relative 'synthesis_template'
+
+# Include helper modules
+require_relative 'helpers/template_loader'
+require_relative 'helpers/template_validator'
+require_relative 'helpers/llm_synthesis'
+require_relative 'helpers/pod_manager'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        # Base system command class
+        class Base < BaseCommand
+          # Include all helper modules
+          include Helpers::TemplateLoader
+          include Helpers::TemplateValidator
+          include Helpers::LlmSynthesis
+          include Helpers::PodManager
+
+          # Include all subcommand modules
+          include Schema
+          include ValidateTemplate
+          include Synthesize
+          include Exec
+          include SynthesisTemplate
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/system/exec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        # Agent execution in test pod
+        module Exec
+          def self.included(base)
+            base.class_eval do
+              desc 'exec [AGENT_FILE]', 'Execute an agent file in a test pod on the cluster'
+              long_desc <<-DESC
+                Deploy and execute an agent file in a temporary test pod on the Kubernetes cluster.
+
+                This command creates a ConfigMap with the agent code, deploys a test pod,
+                streams the logs until completion, and cleans up all resources.
+
+                The agent code is mounted at /etc/agent/code/agent.rb as expected by the agent runtime.
+
+                Agent code can be provided either as a file path or via STDIN.
+                If no file path is provided, the command will read from STDIN.
+
+                Examples:
+                  # Execute a synthesized agent file
+                  aictl system exec agent.rb
+
+                  # Execute with a custom agent name
+                  aictl system exec agent.rb --agent-name my-test
+
+                  # Keep the pod after execution for debugging
+                  aictl system exec agent.rb --keep-pod
+
+                  # Use a different agent image
+                  aictl system exec agent.rb --image ghcr.io/language-operator/agent:v0.1.0
+
+                  # Read agent code from STDIN
+                  cat agent.rb | aictl system exec
+
+                  # Pipe synthesized code directly to execution
+                  cat agent.txt | aictl system synthesize | aictl system exec
+              DESC
+              option :agent_name, type: :string, default: 'test-agent', desc: 'Name for the test agent pod'
+              option :keep_pod, type: :boolean, default: false, desc: 'Keep the pod after execution (for debugging)'
+              option :image, type: :string, default: 'ghcr.io/language-operator/agent:latest', desc: 'Agent container image'
+              option :timeout, type: :numeric, default: 300, desc: 'Timeout in seconds for agent execution'
+              def exec(agent_file = nil)
+                handle_command_error('exec agent') do
+                  # Verify cluster is selected
+                  unless ctx.client
+                    Formatters::ProgressFormatter.error('No cluster context available')
+                    puts
+                    puts 'Please configure kubectl with a valid cluster context:'
+                    puts '  kubectl config get-contexts'
+                    puts '  kubectl config use-context <context-name>'
+                    exit 1
+                  end
+
+                  # Read agent code from file or STDIN
+                  agent_code = if agent_file && !agent_file.strip.empty?
+                                 # Read from file
+                                 unless File.exist?(agent_file)
+                                   Formatters::ProgressFormatter.error("Agent file not found: #{agent_file}")
+                                   exit 1
+                                 end
+                                 File.read(agent_file)
+                               elsif $stdin.tty?
+                                 # Read from STDIN
+                                 Formatters::ProgressFormatter.error('No agent code provided')
+                                 puts
+                                 puts 'Provide agent code either as a file or via STDIN:'
+                                 puts '  aictl system exec agent.rb'
+                                 puts '  cat agent.rb | aictl system exec'
+                                 exit 1
+                               else
+                                 code = $stdin.read.strip
+                                 if code.empty?
+                                   Formatters::ProgressFormatter.error('No agent code provided')
+                                   puts
+                                   puts 'Provide agent code either as a file or via STDIN:'
+                                   puts '  aictl system exec agent.rb'
+                                   puts '  cat agent.rb | aictl system exec'
+                                   exit 1
+                                 end
+                                 code
+                               end
+
+                  # Generate unique names
+                  timestamp = Time.now.to_i
+                  configmap_name = "#{options[:agent_name]}-code-#{timestamp}"
+                  pod_name = "#{options[:agent_name]}-#{timestamp}"
+
+                  begin
+                    # Create ConfigMap with agent code
+                    Formatters::ProgressFormatter.with_spinner('Creating ConfigMap with agent code') do
+                      create_agent_configmap(configmap_name, agent_code)
+                    end
+
+                    # Create test pod
+                    Formatters::ProgressFormatter.with_spinner('Creating test pod') do
+                      create_test_pod(pod_name, configmap_name, options[:image])
+                    end
+
+                    # Wait for pod to be ready or running
+                    Formatters::ProgressFormatter.with_spinner('Waiting for pod to start') do
+                      wait_for_pod_start(pod_name, timeout: 60)
+                    end
+
+                    # Stream logs until pod completes
+                    stream_pod_logs(pod_name, timeout: options[:timeout])
+
+                    # Wait for pod to fully terminate and get final status
+                    exit_code = wait_for_pod_termination(pod_name)
+
+                    if exit_code&.zero?
+                      Formatters::ProgressFormatter.success('Agent completed successfully')
+                    elsif exit_code
+                      Formatters::ProgressFormatter.error("Agent failed with exit code: #{exit_code}")
+                    else
+                      Formatters::ProgressFormatter.warn('Unable to determine pod exit status')
+                    end
+                  ensure
+                    # Clean up resources unless --keep-pod
+                    puts
+                    puts
+                    if options[:keep_pod]
+                      Formatters::ProgressFormatter.info('Resources kept for debugging:')
+                      puts "  Pod: #{pod_name}"
+                      puts "  ConfigMap: #{configmap_name}"
+                      puts
+                      puts "To view logs: kubectl logs -n #{ctx.namespace} #{pod_name}"
+                      puts "To delete:    kubectl delete pod,configmap -n #{ctx.namespace} #{pod_name} #{configmap_name}"
+                    else
+                      Formatters::ProgressFormatter.with_spinner('Cleaning up resources') do
+                        delete_pod(pod_name)
+                        delete_configmap(configmap_name)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end