language-operator 0.1.61 → 0.1.62

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        # Code viewing and editing for agents
+        module CodeOperations
+          def self.included(base)
+            base.class_eval do
+              desc 'code NAME', 'Display synthesized agent code'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              option :raw, type: :boolean, default: false, desc: 'Output raw code without formatting'
+              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}'")
+                    puts
+                    puts 'Possible reasons:'
+                    puts '  - Agent synthesis not yet complete'
+                    puts '  - Agent synthesis failed'
+                    puts
+                    puts 'Check synthesis 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')
+                  unless code_content
+                    Formatters::ProgressFormatter.error('Code content not found in ConfigMap')
+                    exit 1
+                  end
+
+                  # Raw output mode - just print the code
+                  if options[:raw]
+                    puts code_content
+                    return
+                  end
+
+                  # Display with syntax highlighting
+                  Formatters::CodeFormatter.display_ruby_code(
+                    code_content,
+                    title: "Synthesized Code for Agent: #{name}"
+                  )
+                end
+              end
+
+              desc 'edit NAME', 'Edit agent instructions'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              def edit(name)
+                handle_command_error('edit agent') do
+                  ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                  # Get current agent
+                  agent = get_resource_or_exit(LanguageOperator::Constants::RESOURCE_AGENT, name)
+
+                  current_instructions = agent.dig('spec', 'instructions')
+
+                  # Edit instructions in user's editor
+                  new_instructions = Helpers::EditorHelper.edit_content(
+                    current_instructions,
+                    'agent-instructions-',
+                    '.txt'
+                  ).strip
+
+                  # Check if changed
+                  if new_instructions == current_instructions
+                    Formatters::ProgressFormatter.info('No changes made')
+                    return
+                  end
+
+                  # Update agent resource
+                  agent['spec']['instructions'] = new_instructions
+
+                  Formatters::ProgressFormatter.with_spinner('Updating agent instructions') do
+                    ctx.client.apply_resource(agent)
+                  end
+
+                  Formatters::ProgressFormatter.success('Agent instructions updated')
+                  puts
+                  puts 'The operator will automatically re-synthesize the agent code.'
+                  puts
+                  puts 'Watch synthesis progress with:'
+                  puts "  aictl agent inspect #{name}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/agent/helpers/cluster_llm_client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'faraday'
+require 'json'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        module Helpers
+          # LLM client that uses port-forwarding to cluster model deployments (LiteLLM proxy)
+          class ClusterLLMClient
+            def initialize(ctx:, model_name:, model_id:, agent_command:)
+              @ctx = ctx
+              @model_name = model_name
+              @model_id = model_id
+              @agent_command = agent_command
+            end
+
+            def chat(prompt)
+              pod = get_model_pod
+              pod_name = pod.dig('metadata', 'name')
+
+              local_port = find_available_port
+              port_forward_pid = nil
+
+              begin
+                port_forward_pid = start_port_forward(pod_name, local_port, 4000)
+                wait_for_port(local_port)
+
+                conn = Faraday.new(url: "http://localhost:#{local_port}") do |f|
+                  f.request :json
+                  f.response :json
+                  f.adapter Faraday.default_adapter
+                  f.options.timeout = 120
+                  f.options.open_timeout = 10
+                end
+
+                payload = {
+                  model: @model_id,
+                  messages: [{ role: 'user', content: prompt }],
+                  max_tokens: 4000,
+                  temperature: 0.3
+                }
+
+                response = conn.post('/v1/chat/completions', payload)
+                result = response.body
+
+                raise "LLM error: #{result['error']['message'] || result['error']}" if result['error']
+
+                result.dig('choices', 0, 'message', 'content')
+              ensure
+                cleanup_port_forward(port_forward_pid) if port_forward_pid
+              end
+            end
+
+            private
+
+            def get_model_pod
+              # Get the deployment for the model
+              deployment = @ctx.client.get_resource('Deployment', @model_name, @ctx.namespace)
+              raise "Deployment '#{@model_name}' not found in namespace '#{@ctx.namespace}'" if deployment.nil?
+
+              labels = deployment.dig('spec', 'selector', 'matchLabels')
+
+              # Find matching pods using centralized utility
+              pods = CLI::Helpers::LabelUtils.find_pods_by_deployment_labels(@ctx, @model_name, labels)
+              raise "No pods found for model '#{@model_name}'" if pods.empty?
+
+              running_pods = pods.select { |p| p.dig('status', 'phase') == 'Running' }
+              raise "No running pods found for model '#{@model_name}'" if running_pods.empty?
+
+              running_pods.first
+            end
+
+            def find_available_port
+              server = TCPServer.new('127.0.0.1', 0)
+              port = server.addr[1]
+              server.close
+              port
+            end
+
+            def start_port_forward(pod_name, local_port, remote_port)
+              pid = spawn(
+                'kubectl', 'port-forward',
+                '-n', @ctx.namespace,
+                "pod/#{pod_name}",
+                "#{local_port}:#{remote_port}",
+                %i[out err] => '/dev/null'
+              )
+              Process.detach(pid)
+              pid
+            end
+
+            def wait_for_port(port, max_attempts: 30)
+              max_attempts.times do
+                TCPSocket.new('127.0.0.1', port).close
+                return true
+              rescue Errno::ECONNREFUSED
+                sleep 0.1
+              end
+              raise "Port #{port} not available after #{max_attempts} attempts"
+            end
+
+            def cleanup_port_forward(pid)
+              Process.kill('TERM', pid)
+            rescue Errno::ESRCH
+              # Process already gone
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/agent/helpers/code_parser.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        module Helpers
+          # Helper methods for parsing agent code from ConfigMaps
+          module CodeParser
+            # Load agent definition from ConfigMap
+            #
+            # @param ctx [ClusterContext] Cluster context
+            # @param agent_name [String] Name of the agent
+            # @return [Object, nil] Agent definition or nil if not found
+            def load_agent_definition(ctx, agent_name)
+              # Try to get the agent code ConfigMap
+              configmap_name = "#{agent_name}-code"
+              begin
+                configmap = ctx.client.get_resource('ConfigMap', configmap_name, ctx.namespace)
+                code_content = configmap.dig('data', 'agent.rb')
+
+                return nil unless code_content
+
+                # Parse the code to extract agent definition
+                # For now, we'll create a mock definition with the task structure
+                # In a full implementation, this would eval the code safely
+                parse_agent_code(code_content)
+              rescue K8s::Error::NotFound
+                nil
+              rescue StandardError => e
+                @logger&.error("Failed to load agent definition: #{e.message}")
+                nil
+              end
+            end
+
+            # Parse agent code to extract definition
+            #
+            # @param code [String] Ruby agent code
+            # @return [Object] Agent definition structure
+            def parse_agent_code(code)
+              require_relative '../../../../dsl/agent_definition'
+
+              # Create a minimal agent definition structure
+              agent_def = Struct.new(:tasks, :name, :mcp_servers) do
+                def initialize
+                  super({}, 'agent', {})
+                end
+              end
+
+              agent = agent_def.new
+
+              # Parse tasks from code - extract full task definitions
+              code.scan(/task\s+:(\w+),?\s*(.*?)(?=\n\s*(?:task\s+:|main\s+do|end\s*$))/m) do |match|
+                task_name = match[0].to_sym
+                task_block = match[1]
+
+                # Check if neural (has instructions but no do block) or symbolic
+                is_neural = task_block.include?('instructions:') && !task_block.match?(/\bdo\s*\|/)
+
+                # Extract instructions
+                instructions = extract_string_value(task_block, 'instructions')
+
+                # Extract inputs hash
+                inputs = extract_hash_value(task_block, 'inputs')
+
+                # Extract outputs hash
+                outputs = extract_hash_value(task_block, 'outputs')
+
+                task = Struct.new(:name, :neural?, :instructions, :inputs, :outputs).new(
+                  task_name, is_neural, instructions, inputs, outputs
+                )
+
+                agent.tasks[task_name] = task
+              end
+
+              agent
+            end
+
+            # Extract a string value from DSL code (e.g., instructions: "...")
+            #
+            # @param code [String] Code snippet
+            # @param key [String] Key to extract
+            # @return [String] Extracted value or empty string
+            def extract_string_value(code, key)
+              # Match both single and double quoted strings, including multi-line
+              match = code.match(/#{key}:\s*(['"])(.*?)\1/m) ||
+                      code.match(/#{key}:\s*(['"])(.+?)\1/m)
+              match ? match[2] : ''
+            end
+
+            # Extract a hash value from DSL code (e.g., inputs: { foo: 'bar' })
+            #
+            # @param code [String] Code snippet
+            # @param key [String] Key to extract
+            # @return [Hash] Extracted hash or empty hash
+            def extract_hash_value(code, key)
+              match = code.match(/#{key}:\s*\{([^}]*)\}/)
+              return {} unless match
+
+              hash_content = match[1].strip
+              return {} if hash_content.empty?
+
+              # Parse simple key: 'value' or key: "value" pairs
+              result = {}
+              hash_content.scan(/(\w+):\s*(['"])([^'"]*)\2/) do |k, _quote, v|
+                result[k.to_sym] = v
+              end
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/agent/helpers/synthesis_watcher.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        module Helpers
+          # Helper methods for watching agent synthesis status
+          module SynthesisWatcher
+            # Watch synthesis status with progress spinner
+            #
+            # @param k8s [Kubernetes::Client] Kubernetes client
+            # @param agent_name [String] Agent name
+            # @param namespace [String] Namespace
+            # @return [Hash] Synthesis result with success status and metadata
+            def watch_synthesis_status(k8s, agent_name, namespace)
+              max_wait = 600 # Wait up to 10 minutes (local models can be slow)
+              interval = 2   # Check every 2 seconds
+              elapsed = 0
+              start_time = Time.now
+              synthesis_data = {}
+
+              Formatters::ProgressFormatter.with_spinner('Synthesizing code from instructions') do
+                synthesis_result = nil
+                loop do
+                  status = check_synthesis_status(k8s, agent_name, namespace, synthesis_data, start_time)
+                  if status
+                    synthesis_result = status
+                    break
+                  end
+
+                  # Timeout check
+                  if elapsed >= max_wait
+                    Formatters::ProgressFormatter.warn('Synthesis taking longer than expected, continuing in background...')
+                    puts
+                    puts 'Check synthesis status with:'
+                    puts "  aictl agent inspect #{agent_name}"
+                    synthesis_result = { success: true, timeout: true }
+                    break
+                  end
+
+                  sleep interval
+                  elapsed += interval
+                end
+                synthesis_result
+              rescue K8s::Error::NotFound
+                # Agent not found yet, keep waiting
+                sleep interval
+                elapsed += interval
+                retry if elapsed < max_wait
+
+                Formatters::ProgressFormatter.error('Agent resource not found')
+                return { success: false }
+              rescue StandardError => e
+                Formatters::ProgressFormatter.warn("Could not watch synthesis: #{e.message}")
+                return { success: true } # Continue anyway
+              end
+            end
+
+            # Check synthesis status for a specific agent
+            #
+            # @param k8s [Kubernetes::Client] Kubernetes client
+            # @param agent_name [String] Agent name
+            # @param namespace [String] Namespace
+            # @param synthesis_data [Hash] Hash to populate with synthesis metadata
+            # @param start_time [Time] Synthesis start time
+            # @return [Hash, nil] Synthesis status or nil if not complete
+            def check_synthesis_status(k8s, agent_name, namespace, synthesis_data, start_time)
+              agent = k8s.get_resource('LanguageAgent', agent_name, namespace)
+              conditions = agent.dig('status', 'conditions') || []
+              synthesis_status = agent.dig('status', 'synthesis')
+
+              # Capture synthesis metadata
+              if synthesis_status
+                synthesis_data[:model] = synthesis_status['model']
+                synthesis_data[:token_count] = synthesis_status['tokenCount']
+              end
+
+              # Check for synthesis completion
+              synthesized = conditions.find { |c| c['type'] == 'Synthesized' }
+              return nil unless synthesized
+
+              if synthesized['status'] == 'True'
+                duration = Time.now - start_time
+                { success: true, duration: duration, **synthesis_data }
+              elsif synthesized['status'] == 'False'
+                Formatters::ProgressFormatter.error("Synthesis failed: #{synthesized['message']}")
+                { success: false }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end