language-operator 0.1.63 → 0.1.66

data/lib/language_operator/agent.rb

@@ -4,6 +4,7 @@ require_relative 'agent/base'
 require_relative 'agent/executor'
 require_relative 'agent/task_executor'
 require_relative 'agent/web_server'
+require_relative 'agent/instrumentation'
 require_relative 'dsl'
 require_relative 'logger'
 
@@ -24,6 +25,8 @@ module LanguageOperator
   #   agent.execute_goal("Summarize daily news")
   # rubocop:disable Metrics/ModuleLength
   module Agent
+    extend LanguageOperator::Agent::Instrumentation
+
     # Module-level logger for Agent framework
     @logger = LanguageOperator::Logger.new(component: 'Agent')
 
@@ -215,22 +218,29 @@ module LanguageOperator
                   agent: agent_def.name,
                   task_count: agent_def.tasks.size)
 
-      # Get inputs from environment or default to empty hash
-      inputs = {}
-
-      # Execute main block with task executor as context
-      result = agent_def.main.call(inputs, task_executor)
-
-      logger.info('Main block execution completed',
-                  result: result)
+      # Execute main block within agent_executor span for learning system integration
+      with_span('agent_executor', attributes: {
+                  'agent.name' => agent_def.name,
+                  'agent.task_count' => agent_def.tasks.size,
+                  'agent.mode' => ENV.fetch('AGENT_MODE', 'unknown')
+                }) do
+        # Get inputs from environment or default to empty hash
+        inputs = {}
+
+        # Execute main block with task executor as context
+        result = agent_def.main.call(inputs, task_executor)
+
+        logger.info('Main block execution completed',
+                    result: result)
+
+        # Call output handler if defined
+        if agent_def.output
+          logger.debug('Executing output handler', outputs: result)
+          execute_output_handler(agent_def, result, task_executor)
+        end
 
-      # Call output handler if defined
-      if agent_def.output
-        logger.debug('Executing output handler', outputs: result)
-        execute_output_handler(agent_def, result, task_executor)
+        result
       end
-
-      result
     end
 
     # Execute main block (DSL v1) in persistent mode for autonomous agents

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'json'
 require_relative '../../command_loader'
 require_relative '../../wizards/agent_wizard'
 
@@ -9,7 +10,6 @@ require_relative 'workspace'
 require_relative 'code_operations'
 require_relative 'logs'
 require_relative 'lifecycle'
-require_relative 'learning'
 
 # Include helper modules
 require_relative 'helpers/cluster_llm_client'
@@ -35,7 +35,6 @@ module LanguageOperator
           include CodeOperations
           include Logs
           include Lifecycle
-          include Learning
 
           # NOTE: Core commands (create, list, inspect, delete) will be added below
           # This file is a placeholder for the refactoring process
@@ -173,6 +172,9 @@ module LanguageOperator
               # Main agent information
               puts
               status = agent.dig('status', 'phase') || 'Unknown'
+              creation_timestamp = agent.dig('metadata', 'creationTimestamp')
+              formatted_created = creation_timestamp ? Formatters::ValueFormatter.time_ago(Time.parse(creation_timestamp)) : nil
+
               format_agent_details(
                 name: name,
                 namespace: ctx.namespace,
@@ -180,8 +182,8 @@ module LanguageOperator
                 status: format_status(status),
                 mode: agent.dig('spec', 'executionMode') || 'autonomous',
                 schedule: agent.dig('spec', 'schedule'),
-                persona: agent.dig('spec', 'persona'),
-                created: agent.dig('metadata', 'creationTimestamp')
+                persona: agent.dig('spec', 'persona') || 'None',
+                created: formatted_created
               )
               puts
 
@@ -189,9 +191,8 @@ module LanguageOperator
               mode = agent.dig('spec', 'executionMode') || 'autonomous'
               if mode == 'scheduled'
                 exec_data = get_execution_data(name, ctx)
-                
+
                 exec_rows = {
-                  'Total Runs' => exec_data[:total_runs],
                   'Last Run' => exec_data[:last_run] || 'Never'
                 }
                 exec_rows['Next Run'] = exec_data[:next_run] || 'N/A' if agent.dig('spec', 'schedule')
@@ -200,6 +201,10 @@ module LanguageOperator
                 puts
               end
 
+              # Learning status
+              display_learning_section(agent, name, ctx)
+              puts
+
               # Resources
               resources = agent.dig('spec', 'resources')
               if resources
@@ -302,62 +307,71 @@ module LanguageOperator
               Formatters::ProgressFormatter.with_spinner("Deleting agent '#{name}'") do
                 ctx.client.delete_resource(RESOURCE_AGENT, name, ctx.namespace)
               end
+
+              # Verify deletion completed
+              verify_agent_deletion(ctx, name)
             end
           end
 
-          desc 'versions NAME', 'Show ConfigMap versions managed by operator'
-          long_desc <<-DESC
-            List the versioned ConfigMaps created by the operator for an agent.
+          private
 
-            Shows the automatic optimization history and available versions for rollback.
+          # Display learning status section in agent inspect
+          def display_learning_section(agent, _name, _ctx)
+            annotations = agent.dig('metadata', 'annotations')
+            annotations = annotations.respond_to?(:to_h) ? annotations.to_h : (annotations || {})
 
-            Examples:
-              aictl agent versions my-agent
-              aictl agent versions my-agent --cluster production
-          DESC
-          option :cluster, type: :string, desc: 'Override current cluster context'
-          def versions(name)
-            handle_command_error('list agent versions') do
-              ctx = CLI::Helpers::ClusterContext.from_options(options)
+            # Determine learning state
+            learning_enabled = !annotations.key?(Constants::KubernetesLabels::LEARNING_DISABLED_LABEL)
 
-              # Get agent to verify it exists
-              get_resource_or_exit(RESOURCE_AGENT, name)
+            # Get runs pending learning from agent status
+            runs_pending_learning = agent.dig('status', 'runsPendingLearning') || 0
+            learning_threshold = 10 # Standard threshold
 
-              # List all ConfigMaps with the agent label
-              config_maps = ctx.client.list_resources('ConfigMap', namespace: ctx.namespace)
+            # Calculate progress percentage
+            progress_percent = [(runs_pending_learning.to_f / learning_threshold * 100).round, 100].min
+            runs_display = if runs_pending_learning >= learning_threshold
+                             "#{runs_pending_learning}/#{learning_threshold} #{pastel.green('(Ready)')}"
+                           else
+                             "#{runs_pending_learning}/#{learning_threshold} (#{progress_percent}%)"
+                           end
 
-              # Filter for versioned ConfigMaps for this agent
-              agent_configs = config_maps.select do |cm|
-                labels = cm.dig('metadata', 'labels') || {}
-                labels['agent'] == name && labels['version']
-              end
+            status_color = learning_enabled ? :green : :yellow
+            status_text = learning_enabled ? 'Enabled' : 'Disabled'
 
-              # Sort by version (assuming numeric versions)
-              agent_configs.sort! do |a, b|
-                version_a = a.dig('metadata', 'labels', 'version').to_i
-                version_b = b.dig('metadata', 'labels', 'version').to_i
-                version_b <=> version_a # Reverse order (newest first)
-              end
-
-              display_agent_versions(agent_configs, name, ctx.name)
-            end
+            highlighted_box(
+              title: 'Learning',
+              color: :cyan,
+              rows: {
+                'Status' => pastel.send(status_color).bold(status_text),
+                'Threshold' => "#{pastel.cyan('10 successful runs')} (auto-learning trigger)",
+                'Confidence Target' => "#{pastel.cyan('85%')} (pattern detection)",
+                'Runs Recorded' => runs_display
+              }
+            )
           end
 
-          private
-
           # Shared helper methods that are used across multiple commands
           # These will be extracted from the original agent.rb
 
-          def handle_agent_not_found(name, ctx, error)
+          def handle_agent_not_found(name, ctx, error = nil)
             # Get available agents for fuzzy matching
             agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
             available_names = agents.map { |a| a.dig('metadata', 'name') }
 
-            CLI::Errors::Handler.handle_not_found(error,
-                                                  resource_type: RESOURCE_AGENT,
-                                                  resource_name: name,
-                                                  cluster: ctx.name,
-                                                  available_resources: available_names)
+            # Create error if not provided
+            error ||= K8s::Error::NotFound.new('GET', "/apis/langop.io/v1alpha1/namespaces/#{ctx.namespace}/languageagents/#{name}", 404, 'Not Found')
+
+            begin
+              CLI::Errors::Handler.handle_not_found(error, {
+                                                      resource_type: RESOURCE_AGENT,
+                                                      resource_name: name,
+                                                      cluster: ctx.name,
+                                                      available_resources: available_names
+                                                    })
+            rescue CLI::Errors::NotFoundError
+              # Error message already displayed by handler, just exit gracefully
+              exit 1
+            end
           end
 
           def display_agent_created(agent, ctx, _description, _synthesis_result)
@@ -372,8 +386,8 @@ module LanguageOperator
               status: format_status(status),
               mode: agent.dig('spec', 'executionMode') || 'autonomous',
               schedule: agent.dig('spec', 'schedule'),
-              persona: agent.dig('spec', 'persona') || '(auto-selected)',
-              created: Time.now.strftime('%Y-%m-%dT%H:%M:%SZ')
+              persona: agent.dig('spec', 'persona') || 'None',
+              created: 'just now'
             )
 
             puts
@@ -526,11 +540,17 @@ module LanguageOperator
             end
 
             table_data = agents.map do |agent|
+              status = if agent.dig('metadata', 'deletionTimestamp')
+                         'Pending Deletion'
+                       else
+                         agent.dig('status', 'phase') || 'Unknown'
+                       end
+
               {
                 name: agent.dig('metadata', 'name'),
                 namespace: agent.dig('metadata', 'namespace') || context.namespace,
                 mode: agent.dig('spec', 'executionMode') || 'autonomous',
-                status: agent.dig('status', 'phase') || 'Unknown'
+                status: status
               }
             end
 
@@ -556,11 +576,17 @@ module LanguageOperator
               agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
 
               agents.each do |agent|
+                status = if agent.dig('metadata', 'deletionTimestamp')
+                           'Pending Deletion'
+                         else
+                           agent.dig('status', 'phase') || 'Unknown'
+                         end
+
                 all_agents << {
                   cluster: cluster[:name],
                   name: agent.dig('metadata', 'name'),
                   mode: agent.dig('spec', 'executionMode') || 'autonomous',
-                  status: agent.dig('status', 'phase') || 'Unknown',
+                  status: status,
                   next_run: agent.dig('status', 'nextRun') || 'N/A',
                   executions: agent.dig('status', 'executionCount') || 0
                 }
@@ -740,7 +766,7 @@ module LanguageOperator
             begin
               # Get CronJob to find last execution time and next run
               cronjob = ctx.client.get_resource('CronJob', agent_name, ctx.namespace)
-              
+
               # Get last successful execution time
               last_successful = cronjob.dig('status', 'lastSuccessfulTime')
               if last_successful
@@ -750,9 +776,7 @@ module LanguageOperator
 
               # Calculate next run time from schedule
               schedule = cronjob.dig('spec', 'schedule')
-              if schedule
-                execution_data[:next_run] = calculate_next_run(schedule)
-              end
+              execution_data[:next_run] = calculate_next_run(schedule) if schedule
             rescue K8s::Error::NotFound, StandardError
               # CronJob not found or parsing error, continue with job counting
             end
@@ -761,7 +785,7 @@ module LanguageOperator
             begin
               # Count total completed jobs for this agent
               jobs = ctx.client.list_resources('Job', namespace: ctx.namespace)
-              
+
               agent_jobs = jobs.select do |job|
                 labels = job.dig('metadata', 'labels') || {}
                 labels['app.kubernetes.io/name'] == agent_name
@@ -772,7 +796,7 @@ module LanguageOperator
                 conditions = job.dig('status', 'conditions') || []
                 conditions.any? { |c| c['type'] == 'Complete' && c['status'] == 'True' }
               end
-              
+
               execution_data[:total_runs] = successful_jobs.length
             rescue StandardError
               # If job listing fails, keep default count of 0
@@ -784,32 +808,32 @@ module LanguageOperator
           def calculate_next_run(schedule)
             # Simple next run calculation for common cron patterns
             # Handle the most common case: */N * * * * (every N minutes)
-            
+
             parts = schedule.split
             return schedule unless parts.length == 5 # Not a valid cron expression
-            
+
             minute, hour, day, month, weekday = parts
             current_time = Time.now
-            
+
             # Handle every-N-minutes pattern: */10 * * * *
             if minute.start_with?('*/') && hour == '*' && day == '*' && month == '*' && weekday == '*'
               interval = minute[2..].to_i
               if interval > 0 && interval < 60
                 current_minute = current_time.min
-                current_second = current_time.sec
-                
+                current_time.sec
+
                 # Find the next occurrence
                 next_minute_mark = ((current_minute / interval) + 1) * interval
-                
+
                 if next_minute_mark < 60
                   # Same hour
-                  next_time = Time.new(current_time.year, current_time.month, current_time.day, 
+                  next_time = Time.new(current_time.year, current_time.month, current_time.day,
                                        current_time.hour, next_minute_mark, 0)
                 else
                   # Next hour
                   next_hour = current_time.hour + 1
                   next_minute = next_minute_mark - 60
-                  
+
                   if next_hour < 24
                     next_time = Time.new(current_time.year, current_time.month, current_time.day,
                                          next_hour, next_minute, 0)
@@ -820,16 +844,83 @@ module LanguageOperator
                                          0, next_minute, 0)
                   end
                 end
-                
+
                 return Formatters::ValueFormatter.time_until(next_time)
               end
             end
-            
+
             # For other patterns, show the schedule (could add more patterns later)
             schedule
           rescue StandardError
             schedule
           end
+
+          def verify_agent_deletion(ctx, name)
+            max_wait = 30  # Wait up to 30 seconds
+            interval = 2   # Check every 2 seconds
+            elapsed = 0
+
+            Formatters::ProgressFormatter.with_spinner('Verifying deletion') do
+              loop do
+                begin
+                  agent = ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
+                  
+                  # Check if deletion is stuck on finalizers
+                  deletion_timestamp = agent.dig('metadata', 'deletionTimestamp')
+                  if deletion_timestamp
+                    finalizers = agent.dig('metadata', 'finalizers') || []
+                    if finalizers.any?
+                      if elapsed >= max_wait
+                        deletion_stuck_error(name, finalizers)
+                        return
+                      end
+                    end
+                  end
+                rescue K8s::Error::NotFound
+                  # Agent successfully deleted
+                  break
+                end
+
+                if elapsed >= max_wait
+                  deletion_timeout_error(name)
+                  return
+                end
+
+                sleep interval
+                elapsed += interval
+              end
+            end
+
+            # Deletion verified - no additional success message needed
+          end
+
+          def deletion_stuck_error(name, finalizers)
+            puts
+            Formatters::ProgressFormatter.error("Deletion of agent '#{name}' is stuck")
+            puts
+            puts "The agent has the following finalizers preventing deletion:"
+            finalizers.each { |f| puts "  - #{pastel.yellow(f)}" }
+            puts
+            puts "This usually indicates the operator is not running properly."
+            puts
+            puts "To diagnose:"
+            puts "  kubectl get pods -n kube-system | grep language-operator"
+            puts "  kubectl logs -n kube-system -l app.kubernetes.io/name=language-operator"
+            puts
+            puts "Emergency cleanup (advanced users only):"
+            puts "  kubectl patch languageagent #{name} -p '{\"metadata\":{\"finalizers\":null}}' --type=merge"
+          end
+
+          def deletion_timeout_error(name)
+            puts
+            Formatters::ProgressFormatter.warn("Could not verify deletion of agent '#{name}' within 30 seconds")
+            puts
+            puts "Check deletion status with:"
+            puts "  aictl agent list"
+            puts "  kubectl get languageagent #{name}"
+            puts
+            puts "If the agent shows 'Unknown' status, it may be pending deletion."
+          end
         end
       end
     end

data/lib/language_operator/cli/commands/agent/code_operations.rb

@@ -4,42 +4,57 @@ module LanguageOperator
   module CLI
     module Commands
       module Agent
-        # Code viewing and editing for agents
+        # Code viewing and editing for agents using LanguageAgentVersion CRD
         module CodeOperations
           def self.included(base)
             base.class_eval do
-              desc 'code NAME', 'Display synthesized agent code'
+              desc 'code NAME', 'Display agent code from LanguageAgentVersion'
               option :cluster, type: :string, desc: 'Override current cluster context'
               option :raw, type: :boolean, default: false, desc: 'Output raw code without formatting'
+              option :version, type: :string, desc: 'Display specific version (e.g., --version=2)'
               def code(name)
                 handle_command_error('get code') do
                   require_relative '../../formatters/code_formatter'
 
                   ctx = CLI::Helpers::ClusterContext.from_options(options)
 
-                  # Get the code ConfigMap for this agent
-                  configmap_name = "#{name}-code"
-                  begin
-                    configmap = ctx.client.get_resource('ConfigMap', configmap_name, ctx.namespace)
-                  rescue K8s::Error::NotFound
-                    Formatters::ProgressFormatter.error("Synthesized code not found for agent '#{name}'")
+                  # Get the LanguageAgentVersion resource
+                  version_resource = get_agent_version_resource(ctx, name, options[:version])
+
+                  unless version_resource
+                    Formatters::ProgressFormatter.error("No code versions found for agent '#{name}'")
                     puts
-                    puts 'Possible reasons:'
-                    puts '  - Agent synthesis not yet complete'
+                    puts 'This may indicate:'
+                    puts '  - Agent has not been synthesized yet'
                     puts '  - Agent synthesis failed'
                     puts
-                    puts 'Check synthesis status with:'
+                    puts 'Check agent status with:'
                     puts "  aictl agent inspect #{name}"
                     exit 1
                   end
 
-                  # Get the agent.rb code from the ConfigMap
-                  code_content = configmap.dig('data', 'agent.rb')
+                  # Get code from LanguageAgentVersion spec
+                  code_content = version_resource.dig('spec', 'code')
                   unless code_content
-                    Formatters::ProgressFormatter.error('Code content not found in ConfigMap')
+                    Formatters::ProgressFormatter.error('Code content not found in LanguageAgentVersion')
                     exit 1
                   end
 
+                  # Determine version info for title
+                  version_num = version_resource.dig('spec', 'version')
+                  source_type = version_resource.dig('spec', 'sourceType') || 'manual'
+                  
+                  title = if options[:version]
+                            "Code for Agent: #{name} (Version #{version_num})"
+                          else
+                            active_version = get_active_version(ctx, name)
+                            if version_num.to_s == active_version
+                              "Current Code for Agent: #{name} (Version #{version_num} - #{source_type})"
+                            else
+                              "Code for Agent: #{name} (Version #{version_num} - #{source_type})"
+                            end
+                          end
+
                   # Raw output mode - just print the code
                   if options[:raw]
                     puts code_content
@@ -49,11 +64,137 @@ module LanguageOperator
                   # Display with syntax highlighting
                   Formatters::CodeFormatter.display_ruby_code(
                     code_content,
-                    title: "Synthesized Code for Agent: #{name}"
+                    title: title
                   )
                 end
               end
 
+              desc 'versions NAME', 'List available LanguageAgentVersion resources'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              def versions(name)
+                handle_command_error('list versions') do
+                  ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                  # Get agent to verify it exists
+                  get_resource_or_exit(Constants::RESOURCE_AGENT, name)
+
+                  # Find all LanguageAgentVersion resources for this agent
+                  versions = ctx.client.list_resources(Constants::RESOURCE_AGENT_VERSION, namespace: ctx.namespace)
+                                      .select { |v| v.dig('spec', 'agentRef', 'name') == name }
+                                      .sort_by { |v| v.dig('spec', 'version').to_i }
+
+                  if versions.empty?
+                    puts
+                    puts "No LanguageAgentVersion resources found for agent: #{pastel.bold(name)}"
+                    puts
+                    puts pastel.yellow('No versions have been created yet.')
+                    puts
+                    puts 'Versions are created automatically during agent synthesis.'
+                    puts "Check agent status: #{pastel.dim("aictl agent inspect #{name}")}"
+                    return
+                  end
+
+                  # Get current active version
+                  active_version = get_active_version(ctx, name)
+
+                  # Build table data
+                  table_data = versions.map do |version_resource|
+                    version_num = version_resource.dig('spec', 'version').to_s
+                    status = version_num == active_version ? 'current' : 'available'
+                    source_type = version_resource.dig('spec', 'sourceType') || 'manual'
+                    created = version_resource.dig('metadata', 'creationTimestamp')
+                    created = created ? Time.parse(created).strftime('%Y-%m-%d %H:%M') : 'Unknown'
+
+                    {
+                      version: "v#{version_num}",
+                      status: status,
+                      type: source_type.capitalize,
+                      created: created
+                    }
+                  end
+
+                  # Display table
+                  headers = %w[VERSION STATUS TYPE CREATED]
+                  rows = table_data.map do |row|
+                    status_indicator = row[:status] == 'current' ? pastel.green('●') : pastel.dim('○')
+                    status_text = row[:status] == 'current' ? pastel.green('current') : 'available'
+
+                    [
+                      row[:version],
+                      "#{status_indicator} #{status_text}",
+                      row[:type],
+                      row[:created]
+                    ]
+                  end
+
+                  puts
+                  puts "Code versions for agent: #{pastel.bold(name)}"
+                  puts
+                  puts table(headers, rows)
+                  puts
+                  puts 'Usage:'
+                  puts "  #{pastel.dim("aictl agent code #{name}")}"
+                  puts "  #{pastel.dim("aictl agent code #{name} --version=X")}"
+                end
+              end
+
+              private
+
+              def get_active_version(ctx, agent_name)
+                begin
+                  agent = ctx.client.get_resource(Constants::RESOURCE_AGENT, agent_name, ctx.namespace)
+                  version_ref = agent.dig('spec', 'agentVersionRef', 'name')
+                  return nil unless version_ref
+
+                  # Extract version number from "agent-name-vX" format
+                  version_ref.split('-v').last
+                rescue K8s::Error::NotFound
+                  nil
+                end
+              end
+
+              def get_agent_version_resource(ctx, agent_name, requested_version = nil)
+                # Query LanguageAgentVersion resources for this agent
+                versions = ctx.client.list_resources(Constants::RESOURCE_AGENT_VERSION, namespace: ctx.namespace)
+                                    .select { |v| v.dig('spec', 'agentRef', 'name') == agent_name }
+
+                if versions.empty?
+                  return nil
+                end
+
+                if requested_version
+                  # Find specific version
+                  target_version = versions.find { |v| v.dig('spec', 'version').to_s == requested_version }
+                  
+                  unless target_version
+                    Formatters::ProgressFormatter.error("Version #{requested_version} not found for agent '#{agent_name}'")
+                    puts
+                    puts 'Available versions:'
+                    versions.each do |v|
+                      version_num = v.dig('spec', 'version')
+                      puts "  v#{version_num}"
+                    end
+                    puts
+                    puts "Use 'aictl agent versions #{agent_name}' to see all available versions"
+                    exit 1
+                  end
+
+                  return target_version
+                else
+                  # Get currently active version
+                  active_version = get_active_version(ctx, agent_name)
+                  
+                  if active_version
+                    # Find the currently active version resource
+                    active_version_resource = versions.find { |v| v.dig('spec', 'version').to_s == active_version }
+                    return active_version_resource if active_version_resource
+                  end
+
+                  # Fall back to latest version if no active version or active version not found
+                  return versions.max_by { |v| v.dig('spec', 'version').to_i }
+                end
+              end
+
               desc 'edit NAME', 'Edit agent instructions'
               option :cluster, type: :string, desc: 'Override current cluster context'
               def edit(name)
@@ -99,4 +240,4 @@ module LanguageOperator
       end
     end
   end
-end
+end