language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/commands/system/helpers/llm_synthesis.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        module Helpers
+          # LLM synthesis utilities
+          module LlmSynthesis
+            # Call LLM to generate code from synthesis prompt using cluster model
+            def call_llm_for_synthesis(prompt, model_name)
+              require 'json'
+              require 'faraday'
+
+              # Get model resource
+              model = get_resource_or_exit('LanguageModel', model_name)
+              model_id = model.dig('spec', 'modelName')
+
+              # Get the model's pod
+              pod = get_model_pod(model_name)
+              pod_name = pod.dig('metadata', 'name')
+
+              # Set up port-forward to access the model pod
+              port_forward_pid = nil
+              local_port = find_available_port
+
+              begin
+                # Start kubectl port-forward in background
+                port_forward_pid = start_port_forward(pod_name, local_port, 4000)
+
+                # Wait for port-forward to be ready
+                wait_for_port(local_port)
+
+                # Build the JSON payload for the chat completion request
+                payload = {
+                  model: model_id,
+                  messages: [{ role: 'user', content: prompt }],
+                  max_tokens: 4000,
+                  temperature: 0.3
+                }
+
+                # Make HTTP request using Faraday
+                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
+
+                response = conn.post('/v1/chat/completions', payload)
+
+                # Parse response
+                result = response.body
+
+                if result['error']
+                  error_msg = result['error']['message'] || result['error']
+                  raise "Model error: #{error_msg}"
+                elsif !result['choices'] || result['choices'].empty?
+                  raise "Unexpected response format: #{result.inspect}"
+                end
+
+                # Extract the content from the first choice
+                result.dig('choices', 0, 'message', 'content')
+              rescue Faraday::TimeoutError
+                raise 'LLM request timed out after 120 seconds'
+              rescue Faraday::ConnectionFailed => e
+                raise "Failed to connect to model: #{e.message}"
+              rescue StandardError => e
+                Formatters::ProgressFormatter.error("LLM call failed: #{e.message}")
+                puts
+                puts "Make sure the model '#{model_name}' is running: kubectl get pods -n #{ctx.namespace}"
+                exit 1
+              ensure
+                # Clean up port-forward process
+                cleanup_port_forward(port_forward_pid) if port_forward_pid
+              end
+            end
+
+            # Get the pod for a model
+            def get_model_pod(model_name)
+              # Get the deployment for the model
+              deployment = ctx.client.get_resource('Deployment', model_name, ctx.namespace)
+              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_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(', ')
+                raise "No running pods found. Pod phases: #{pod_phases}"
+              end
+
+              running_pod
+            rescue K8s::Error::NotFound
+              raise "Model deployment '#{model_name}' not found"
+            end
+
+            # Find an available local port for port-forwarding
+            def find_available_port
+              require 'socket'
+
+              # Try ports in the range 14000-14999
+              (14_000..14_999).each do |port|
+                server = TCPServer.new('127.0.0.1', port)
+                server.close
+                return port
+              rescue Errno::EADDRINUSE
+                # Port in use, try next
+                next
+              end
+
+              raise 'No available ports found in range 14000-14999'
+            end
+
+            # Start kubectl port-forward in background
+            def start_port_forward(pod_name, local_port, remote_port)
+              require 'English'
+
+              cmd = "kubectl port-forward -n #{ctx.namespace} #{pod_name} #{local_port}:#{remote_port}"
+              pid = spawn(cmd, out: '/dev/null', err: '/dev/null')
+
+              # Detach so it runs in background
+              Process.detach(pid)
+
+              pid
+            end
+
+            # Wait for port-forward to be ready
+            def wait_for_port(port, max_attempts: 30)
+              require 'socket'
+
+              max_attempts.times do
+                socket = TCPSocket.new('127.0.0.1', port)
+                socket.close
+                return true
+              rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+                sleep 0.1
+              end
+
+              raise "Port-forward to localhost:#{port} failed to become ready after #{max_attempts} attempts"
+            end
+
+            # Clean up port-forward process
+            def cleanup_port_forward(pid)
+              return unless pid
+
+              begin
+                Process.kill('TERM', pid)
+                Process.wait(pid, Process::WNOHANG)
+              rescue Errno::ESRCH
+                # Process already gone
+              rescue Errno::ECHILD
+                # Process already reaped
+              end
+            end
+
+            # Extract Ruby code from LLM response
+            # Looks for ```ruby ... ``` blocks
+            def extract_ruby_code(response)
+              # Match ```ruby ... ``` blocks
+              match = response.match(/```ruby\n(.*?)```/m)
+              return match[1].strip if match
+
+              # Try without language specifier
+              match = response.match(/```\n(.*?)```/m)
+              return match[1].strip if match
+
+              # If no code blocks, return nil
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/system/helpers/pod_manager.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative '../../../../constants/kubernetes_labels'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        module Helpers
+          # Pod management utilities for exec command
+          module PodManager
+            # Create a ConfigMap with agent code
+            def create_agent_configmap(name, code)
+              configmap = {
+                'apiVersion' => 'v1',
+                'kind' => 'ConfigMap',
+                'metadata' => {
+                  'name' => name,
+                  'namespace' => ctx.namespace
+                },
+                'data' => {
+                  'agent.rb' => code
+                }
+              }
+
+              ctx.client.create_resource(configmap)
+            end
+
+            # Create a test pod for running the agent
+            def create_test_pod(name, configmap_name, image)
+              # Detect available models in the cluster
+              model_env = detect_model_config
+
+              if model_env.nil?
+                Formatters::ProgressFormatter.warn('Could not detect model configuration from cluster')
+                Formatters::ProgressFormatter.warn('Agent may fail without MODEL_ENDPOINTS configured')
+              end
+
+              env_vars = [
+                { 'name' => 'AGENT_NAME', 'value' => name },
+                { 'name' => 'AGENT_MODE', 'value' => 'autonomous' },
+                { 'name' => 'AGENT_CODE_PATH', 'value' => '/etc/agent/code/agent.rb' },
+                { 'name' => 'CONFIG_PATH', 'value' => '/nonexistent/config.yaml' }
+              ]
+
+              # Add model configuration if available
+              env_vars += model_env if model_env
+
+              pod = {
+                'apiVersion' => 'v1',
+                'kind' => 'Pod',
+                'metadata' => {
+                  'name' => name,
+                  'namespace' => ctx.namespace,
+                  'labels' => Constants::KubernetesLabels.test_agent_labels(name).merge(
+                    Constants::KubernetesLabels::KIND_LABEL => 'LanguageAgent'
+                  )
+                },
+                'spec' => {
+                  'restartPolicy' => 'Never',
+                  'containers' => [
+                    {
+                      'name' => 'agent',
+                      'image' => image,
+                      'imagePullPolicy' => 'Always',
+                      'env' => env_vars,
+                      'volumeMounts' => [
+                        {
+                          'name' => 'agent-code',
+                          'mountPath' => '/etc/agent/code',
+                          'readOnly' => true
+                        }
+                      ]
+                    }
+                  ],
+                  'volumes' => [
+                    {
+                      'name' => 'agent-code',
+                      'configMap' => {
+                        'name' => configmap_name
+                      }
+                    }
+                  ]
+                }
+              }
+
+              ctx.client.create_resource(pod)
+            end
+
+            # Detect model configuration from the cluster
+            def detect_model_config
+              models = ctx.client.list_resources('LanguageModel', namespace: ctx.namespace)
+              return nil if models.empty?
+
+              # Use first available model
+              model = models.first
+              model_name = model.dig('metadata', 'name')
+              model_id = model.dig('spec', 'modelName')
+
+              # Build endpoint URL (port 8000 is the model service port)
+              endpoint = "http://#{model_name}.#{ctx.namespace}.svc.cluster.local:8000"
+
+              [
+                { 'name' => 'MODEL_ENDPOINTS', 'value' => endpoint },
+                { 'name' => 'LLM_MODEL', 'value' => model_id },
+                { 'name' => 'OPENAI_API_KEY', 'value' => 'sk-dummy-key-for-local-proxy' }
+              ]
+            rescue StandardError => e
+              Formatters::ProgressFormatter.error("Failed to detect model configuration: #{e.message}")
+              nil
+            end
+
+            # Wait for pod to start (running or terminated)
+            def wait_for_pod_start(name, timeout: 60)
+              start_time = Time.now
+              loop do
+                pod = ctx.client.get_resource('Pod', name, ctx.namespace)
+                phase = pod.dig('status', 'phase')
+
+                return if %w[Running Succeeded Failed].include?(phase)
+
+                raise "Pod #{name} did not start within #{timeout} seconds" if Time.now - start_time > timeout
+
+                sleep 1
+              end
+            end
+
+            # Stream pod logs until completion
+            def stream_pod_logs(name, timeout: 300)
+              require 'open3'
+
+              cmd = "kubectl logs -f -n #{ctx.namespace} #{name} 2>&1"
+              Open3.popen3(cmd) do |_stdin, stdout, _stderr, wait_thr|
+                # Set up timeout
+                start_time = Time.now
+
+                # Stream logs
+                stdout.each_line do |line|
+                  puts line
+
+                  # Check timeout
+                  if Time.now - start_time > timeout
+                    Process.kill('TERM', wait_thr.pid)
+                    raise "Log streaming timed out after #{timeout} seconds"
+                  end
+                end
+
+                # Wait for process to complete
+                wait_thr.value
+              end
+            rescue Errno::EPIPE
+              # Pod terminated, logs finished
+            end
+
+            # Wait for pod to terminate and get exit code
+            def wait_for_pod_termination(name, timeout: 10)
+              # Give the pod a moment to fully transition after logs complete
+              sleep 2
+
+              start_time = Time.now
+              loop do
+                pod = ctx.client.get_resource('Pod', name, ctx.namespace)
+                phase = pod.dig('status', 'phase')
+                container_status = pod.dig('status', 'containerStatuses', 0)
+
+                # Pod completed successfully or failed
+                if %w[Succeeded Failed].include?(phase) && container_status && (terminated = container_status.dig('state', 'terminated'))
+                  return terminated['exitCode']
+                end
+
+                # Check timeout
+                if Time.now - start_time > timeout
+                  # Try one last time
+                  if container_status && (terminated = container_status.dig('state', 'terminated'))
+                    return terminated['exitCode']
+                  end
+
+                  return nil
+                end
+
+                sleep 0.5
+              rescue K8s::Error::NotFound
+                # Pod was deleted before we could get status
+                return nil
+              end
+            end
+
+            # Get pod status
+            def get_pod_status(name)
+              pod = ctx.client.get_resource('Pod', name, ctx.namespace)
+              pod.to_h.fetch('status', {})
+            end
+
+            # Delete a pod
+            def delete_pod(name)
+              ctx.client.delete_resource('Pod', name, ctx.namespace)
+            rescue K8s::Error::NotFound
+              # Already deleted
+            end
+
+            # Delete a ConfigMap
+            def delete_configmap(name)
+              ctx.client.delete_resource('ConfigMap', name, ctx.namespace)
+            rescue K8s::Error::NotFound
+              # Already deleted
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/system/helpers/template_loader.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        module Helpers
+          # Template loading utilities
+          module TemplateLoader
+            # Load template from bundled gem or operator ConfigMap
+            def load_template(type)
+              # Try to fetch from operator ConfigMap first (if kubectl available)
+              template = fetch_from_operator(type)
+              return template if template
+
+              # Fall back to bundled template
+              load_bundled_template(type)
+            end
+
+            # Fetch template from operator ConfigMap via kubectl
+            def fetch_from_operator(type)
+              configmap_name = type == 'agent' ? 'agent-synthesis-template' : 'persona-distillation-template'
+              result = `kubectl get configmap #{configmap_name} -n language-operator-system -o jsonpath='{.data.template}' 2>/dev/null`
+              result.empty? ? nil : result
+            rescue StandardError
+              nil
+            end
+
+            # Load bundled template from gem
+            def load_bundled_template(type)
+              filename = type == 'agent' ? 'agent_synthesis.tmpl' : 'persona_distillation.tmpl'
+              template_path = File.join(__dir__, '..', '..', '..', 'templates', filename)
+              File.read(template_path)
+            end
+
+            # Render Go-style template ({{.Variable}})
+            # Simplified implementation for basic variable substitution
+            def render_go_template(template, data)
+              result = template.dup
+
+              # Handle {{if .ErrorContext}} - remove this section for test-synthesis
+              result.gsub!(/{{if \.ErrorContext}}.*?{{else}}/m, '')
+              result.gsub!(/{{end}}/, '')
+
+              # Replace simple variables {{.Variable}}
+              data.each do |key, value|
+                result.gsub!("{{.#{key}}}", value.to_s)
+              end
+
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/system/helpers/template_validator.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        module Helpers
+          # Template validation utilities
+          module TemplateValidator
+            # Validate template syntax and structure
+            def validate_template_content(content, type)
+              errors = []
+              warnings = []
+
+              # Check for required placeholders based on type
+              required_placeholders = if type == 'agent'
+                                        %w[
+                                          Instructions ToolsList ModelsList AgentName TemporalIntent
+                                        ]
+                                      else
+                                        %w[
+                                          PersonaName PersonaDescription PersonaSystemPrompt
+                                          AgentInstructions AgentTools
+                                        ]
+                                      end
+
+              required_placeholders.each do |placeholder|
+                errors << "Missing required placeholder: {{.#{placeholder}}}" unless content.include?("{{.#{placeholder}}}")
+              end
+
+              # Check for balanced braces
+              open_braces = content.scan(/{{/).count
+              close_braces = content.scan(/}}/).count
+              errors << "Unbalanced template braces ({{ vs }}): #{open_braces} open, #{close_braces} close" if open_braces != close_braces
+
+              # Extract and validate Ruby code blocks
+              code_examples = extract_code_examples(content)
+              code_examples.each do |example|
+                code_result = validate_code_against_schema(example[:code])
+                unless code_result[:valid]
+                  code_result[:errors].each do |err|
+                    # Adjust line numbers to be relative to template
+                    line = example[:start_line] + (err[:location] || 0)
+                    errors << "Line #{line}: #{err[:message]}"
+                  end
+                end
+                code_result[:warnings].each do |warn|
+                  line = example[:start_line] + (warn[:location] || 0)
+                  warnings << "Line #{line}: #{warn[:message]}"
+                end
+              end
+
+              # Extract method calls and check if they're in the safe list
+              method_calls = extract_method_calls(content)
+              safe_methods = Dsl::Schema.safe_agent_methods +
+                             Dsl::Schema.safe_tool_methods +
+                             Dsl::Schema.safe_helper_methods
+              method_calls.each do |method|
+                next if safe_methods.include?(method)
+
+                warnings << "Method '#{method}' not in safe methods list (may be valid Ruby builtin)"
+              end
+
+              {
+                valid: errors.empty?,
+                errors: errors,
+                warnings: warnings
+              }
+            end
+
+            # Extract Ruby code examples from template
+            # Returns array of {code: String, start_line: Integer}
+            def extract_code_examples(template)
+              examples = []
+              lines = template.split("\n")
+              in_code_block = false
+              current_code = []
+              start_line = 0
+
+              lines.each_with_index do |line, idx|
+                if line.strip.start_with?('```ruby')
+                  in_code_block = true
+                  start_line = idx + 2 # idx is 0-based, we want line number (1-based) of first code line
+                  current_code = []
+                elsif line.strip == '```' && in_code_block
+                  in_code_block = false
+                  examples << { code: current_code.join("\n"), start_line: start_line } unless current_code.empty?
+                elsif in_code_block
+                  current_code << line
+                end
+              end
+
+              examples
+            end
+
+            # Extract method calls from template code
+            # Returns array of method name strings
+            def extract_method_calls(template)
+              require 'prism'
+
+              method_calls = []
+              code_examples = extract_code_examples(template)
+
+              code_examples.each do |example|
+                # Parse the code to find method calls
+                result = Prism.parse(example[:code])
+
+                # Walk the AST to find method calls
+                extract_methods_from_ast(result.value, method_calls) if result.success?
+              rescue Prism::ParseError
+                # Skip code with syntax errors - they'll be caught by validate_code_against_schema
+                next
+              end
+
+              method_calls.uniq
+            end
+
+            # Recursively extract method names from AST
+            def extract_methods_from_ast(node, methods)
+              return unless node
+
+              methods << node.name.to_s if node.is_a?(Prism::CallNode)
+
+              node.compact_child_nodes.each do |child|
+                extract_methods_from_ast(child, methods)
+              end
+            end
+
+            # Validate Ruby code against DSL schema
+            # Returns {valid: Boolean, errors: Array<Hash>, warnings: Array<Hash>}
+            def validate_code_against_schema(code)
+              require 'language_operator/agent/safety/ast_validator'
+
+              validator = LanguageOperator::Agent::Safety::ASTValidator.new
+              violations = validator.validate(code, '(template)')
+
+              errors = []
+              warnings = []
+
+              violations.each do |violation|
+                case violation[:type]
+                when :syntax_error
+                  errors << {
+                    type: :syntax_error,
+                    location: 0,
+                    message: violation[:message]
+                  }
+                when :dangerous_method, :dangerous_constant, :dangerous_constant_access, :dangerous_global, :backtick_execution
+                  errors << {
+                    type: violation[:type],
+                    location: violation[:location],
+                    message: violation[:message]
+                  }
+                else
+                  warnings << {
+                    type: violation[:type],
+                    location: violation[:location] || 0,
+                    message: violation[:message]
+                  }
+                end
+              end
+
+              {
+                valid: errors.empty?,
+                errors: errors,
+                warnings: warnings
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end