language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/formatters/optimization_formatter.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require 'pastel'
-
-module LanguageOperator
-  module CLI
-    module Formatters
-      # Formats optimization analysis and proposals for CLI display
-      class OptimizationFormatter
-        def initialize
-          @pastel = Pastel.new
-        end
-
-        # Format analysis results showing optimization opportunities
-        #
-        # @param agent_name [String] Name of the agent
-        # @param opportunities [Array<Hash>] Optimization opportunities
-        # @return [String] Formatted output
-        def format_analysis(agent_name:, opportunities:)
-          output = []
-          output << ''
-          output << @pastel.bold("Analyzing agent '#{agent_name}'...")
-          output << @pastel.dim('─' * 70)
-          output << ''
-
-          if opportunities.empty?
-            output << @pastel.yellow('No optimization opportunities found.')
-            output << ''
-            output << 'Possible reasons:'
-            output << '  • All tasks are already symbolic'
-            output << "  • Neural tasks haven't executed enough times (need 10+)"
-            output << '  • Execution patterns are too inconsistent (<85%)'
-            output << ''
-            return output.join("\n")
-          end
-
-          # Group by status
-          ready = opportunities.select { |opp| opp[:ready_for_learning] }
-          not_ready = opportunities.reject { |opp| opp[:ready_for_learning] }
-
-          output << @pastel.bold("Found #{opportunities.size} neural task(s)\n")
-
-          # Show ready tasks
-          if ready.any?
-            output << @pastel.green.bold("✓ Ready for Optimization (#{ready.size})")
-            output << ''
-            ready.each do |opp|
-              output << format_opportunity(opp, ready: true)
-              output << ''
-            end
-          end
-
-          # Show not ready tasks
-          if not_ready.any?
-            output << @pastel.yellow.bold("⚠ Not Ready (#{not_ready.size})")
-            output << ''
-            not_ready.each do |opp|
-              output << format_opportunity(opp, ready: false)
-              output << ''
-            end
-          end
-
-          # Summary
-          output << @pastel.dim('─' * 70)
-          output << if ready.any?
-                      @pastel.green.bold("#{ready.size}/#{opportunities.size} tasks eligible for optimization")
-                    else
-                      @pastel.yellow("0/#{opportunities.size} tasks ready - check requirements above")
-                    end
-          output << ''
-
-          output.join("\n")
-        end
-
-        # Format a single optimization opportunity
-        #
-        # @param opp [Hash] Opportunity data
-        # @param ready [Boolean] Whether task is ready for optimization
-        # @return [String] Formatted output
-        def format_opportunity(opp, ready:)
-          output = []
-
-          # Task name
-          status_icon = ready ? @pastel.green('✓') : @pastel.yellow('⚠')
-          output << "  #{status_icon} #{@pastel.bold(opp[:task_name])}"
-
-          # Metrics
-          exec_label = @pastel.dim('    Executions:')
-          exec_value = format_count_status(opp[:execution_count], 10, ready)
-          output << "#{exec_label} #{exec_value}"
-
-          cons_label = @pastel.dim('    Consistency:')
-          cons_value = format_percentage_status(opp[:consistency_score], 0.85, ready)
-          output << "#{cons_label} #{cons_value}"
-
-          # Pattern or reason
-          if ready && opp[:common_pattern]
-            output << "#{@pastel.dim('    Pattern:')} #{opp[:common_pattern]}"
-          elsif opp[:reason]
-            output << "#{@pastel.dim('    Reason:')} #{@pastel.yellow(opp[:reason])}"
-          end
-
-          output.join("\n")
-        end
-
-        # Format optimization proposal with diff and metrics
-        #
-        # @param proposal [Hash] Proposal data
-        # @return [String] Formatted output
-        def format_proposal(proposal:)
-          output = []
-          output << ''
-          output << @pastel.bold("Optimization Proposal: #{proposal[:task_name]}")
-          output << @pastel.dim('=' * 70)
-          output << ''
-
-          # Current code
-          output << @pastel.yellow.bold('Current (Neural):')
-          output << @pastel.dim('─' * 70)
-          proposal[:current_code].each_line do |line|
-            output << @pastel.yellow("  #{line.rstrip}")
-          end
-          output << ''
-
-          # Proposed code
-          output << @pastel.green.bold('Proposed (Symbolic):')
-          output << @pastel.dim('─' * 70)
-          proposal[:proposed_code].each_line do |line|
-            output << @pastel.green("  #{line.rstrip}")
-          end
-          output << ''
-
-          # Performance impact
-          output << @pastel.bold('Performance Impact:')
-          output << @pastel.dim('─' * 70)
-          impact = proposal[:performance_impact]
-          output << format_impact_line('Execution Time:', impact[:current_avg_time], impact[:optimized_avg_time], 's', impact[:time_reduction_pct])
-          output << format_impact_line('Cost Per Call:', impact[:current_avg_cost], impact[:optimized_avg_cost], '$', impact[:cost_reduction_pct])
-          output << ''
-          output << "  #{@pastel.dim('Projected Monthly Savings:')} #{@pastel.green.bold("$#{impact[:projected_monthly_savings]}")}"
-          output << ''
-
-          # Metadata
-          output << @pastel.bold('Analysis:')
-          output << @pastel.dim('─' * 70)
-          output << "  #{@pastel.dim('Executions Observed:')} #{proposal[:execution_count]}"
-          output << "  #{@pastel.dim('Pattern Consistency:')} #{format_percentage(proposal[:consistency_score])}"
-          output << "  #{@pastel.dim('Tool Sequence:')} #{proposal[:pattern]}"
-          output << "  #{@pastel.dim('Validation:')} #{proposal[:validation_violations].empty? ? @pastel.green('✓ Passed') : @pastel.red('✗ Failed')}"
-          output << ''
-
-          output.join("\n")
-        end
-
-        # Format success message after applying optimization
-        #
-        # @param result [Hash] Application result
-        # @return [String] Formatted output
-        def format_success(result:)
-          output = []
-          output << ''
-
-          if result[:success]
-            output << @pastel.green.bold('✓ Optimization applied successfully!')
-            output << ''
-            output << "  Task '#{result[:task_name]}' has been optimized to symbolic execution."
-            output << ''
-            output << @pastel.dim('Next steps:')
-            output << "  • Monitor performance: aictl agent logs #{result[:task_name]}"
-            output << "  • View changes: aictl agent code #{result[:task_name]}"
-          else
-            output << @pastel.red.bold('✗ Optimization failed!')
-            output << ''
-            output << "  Task: #{result[:task_name]}"
-            output << "  Error: #{result[:error]}"
-          end
-
-          output << ''
-          output.join("\n")
-        end
-
-        private
-
-        # Format a count with status indicator
-        def format_count_status(count, threshold, ready)
-          if count >= threshold
-            @pastel.green("#{count} (≥#{threshold})")
-          else
-            ready ? @pastel.yellow("#{count}/#{threshold}") : @pastel.red("#{count}/#{threshold}")
-          end
-        end
-
-        # Format a percentage with status indicator
-        def format_percentage_status(score, threshold, ready)
-          return @pastel.red('N/A') if score.nil?
-
-          pct = (score * 100).round(1)
-          threshold_pct = (threshold * 100).round(1)
-
-          if score >= threshold
-            @pastel.green("#{pct}% (≥#{threshold_pct}%)")
-          else
-            ready ? @pastel.yellow("#{pct}%/#{threshold_pct}%") : @pastel.red("#{pct}%/#{threshold_pct}%")
-          end
-        end
-
-        # Format percentage value
-        def format_percentage(score)
-          return @pastel.red('N/A') if score.nil?
-
-          pct = (score * 100).round(1)
-          @pastel.green("#{pct}%")
-        end
-
-        # Format performance impact line
-        def format_impact_line(label, current, optimized, unit, reduction_pct)
-          current_str = unit == '$' ? format('$%.4f', current) : "#{current}#{unit}"
-          optimized_str = unit == '$' ? format('$%.4f', optimized) : "#{optimized}#{unit}"
-
-          "  #{@pastel.dim(label)} #{current_str} → #{@pastel.green(optimized_str)} " \
-            "#{@pastel.green("(#{reduction_pct}% faster)")}"
-        end
-      end
-    end
-  end
-end

data/lib/language_operator/cli/helpers/pastel_helper.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'pastel'
-
-module LanguageOperator
-  module CLI
-    module Helpers
-      # Shared module providing Pastel color functionality
-      # to CLI commands, formatters, and helpers.
-      #
-      # Usage:
-      #   include PastelHelper
-      #   puts pastel.green("Success!")
-      module PastelHelper
-        # Returns a memoized Pastel instance for colorizing terminal output
-        #
-        # @return [Pastel] Pastel instance
-        def pastel
-          @pastel ||= Pastel.new
-        end
-      end
-    end
-  end
-end

data/lib/language_operator/learning/adapters/base_adapter.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module LanguageOperator
-  module Learning
-    module Adapters
-      # Abstract base class for OTLP backend query adapters
-      #
-      # Defines the interface that all backend adapters must implement.
-      # Adapters translate generic query requests into backend-specific
-      # API calls and normalize responses.
-      #
-      # @example Implementing a custom adapter
-      #   class CustomAdapter < BaseAdapter
-      #     def self.available?(endpoint, api_key = nil)
-      #       # Check if backend is reachable
-      #       true
-      #     end
-      #
-      #     def query_spans(filter:, time_range:, limit:)
-      #       # Query backend and return normalized spans
-      #       []
-      #     end
-      #   end
-      class BaseAdapter
-        # Initialize adapter with connection details
-        #
-        # @param endpoint [String] Backend endpoint URL
-        # @param api_key [String, nil] API key for authentication (if required)
-        # @param options [Hash] Additional adapter-specific options
-        def initialize(endpoint, api_key = nil, **options)
-          @endpoint = endpoint
-          @api_key = api_key
-          @logger = options[:logger] || ::Logger.new($stdout, level: ::Logger::WARN)
-          @options = options
-        end
-
-        # Check if this backend is available at the given endpoint
-        #
-        # @param endpoint [String] Backend endpoint URL
-        # @param api_key [String, nil] API key for authentication (optional)
-        # @return [Boolean] True if backend is reachable and compatible
-        def self.available?(endpoint, api_key = nil)
-          raise NotImplementedError, "#{self}.available? must be implemented"
-        end
-
-        # Query spans from the backend
-        #
-        # @param filter [Hash] Filter criteria
-        # @option filter [String] :task_name Task name to filter by
-        # @option filter [Hash] :attributes Additional span attributes to match
-        # @param time_range [Range<Time>] Time range for query
-        # @param limit [Integer] Maximum number of spans to return
-        # @return [Array<Hash>] Array of normalized span hashes
-        def query_spans(filter:, time_range:, limit:)
-          raise NotImplementedError, "#{self.class}#query_spans must be implemented"
-        end
-
-        # Extract task execution data from spans
-        #
-        # Groups spans by trace and extracts task-specific metadata:
-        # - inputs: Task input parameters
-        # - outputs: Task output values
-        # - tool_calls: Sequence of tools invoked
-        # - duration: Execution duration
-        #
-        # @param spans [Array<Hash>] Raw spans from backend
-        # @return [Array<Hash>] Task execution data grouped by trace
-        def extract_task_data(spans)
-          spans.group_by { |span| span[:trace_id] }.map do |trace_id, trace_spans|
-            task_span = trace_spans.find { |s| s[:name]&.include?('task_executor') }
-            next unless task_span
-
-            {
-              trace_id: trace_id,
-              task_name: task_span.dig(:attributes, 'task.name'),
-              inputs: extract_inputs(task_span),
-              outputs: extract_outputs(task_span),
-              tool_calls: extract_tool_calls(trace_spans),
-              duration_ms: task_span[:duration_ms],
-              timestamp: task_span[:timestamp]
-            }
-          end.compact
-        end
-
-        protected
-
-        attr_reader :endpoint, :api_key, :options
-
-        # Extract inputs from task span attributes
-        #
-        # @param span [Hash] Task execution span
-        # @return [Hash] Input parameters
-        def extract_inputs(span)
-          attrs = span[:attributes] || {}
-          input_keys = attrs['task.input.keys']&.split(',') || []
-
-          input_keys.each_with_object({}) do |key, inputs|
-            value_attr = "task.input.#{key}"
-            inputs[key.to_sym] = attrs[value_attr] if attrs[value_attr]
-          end
-        end
-
-        # Extract outputs from task span attributes
-        #
-        # @param span [Hash] Task execution span
-        # @return [Hash] Output values
-        def extract_outputs(span)
-          attrs = span[:attributes] || {}
-          output_keys = attrs['task.output.keys']&.split(',') || []
-
-          output_keys.each_with_object({}) do |key, outputs|
-            value_attr = "task.output.#{key}"
-            outputs[key.to_sym] = attrs[value_attr] if attrs[value_attr]
-          end
-        end
-
-        # Extract tool call sequence from trace spans
-        #
-        # @param trace_spans [Array<Hash>] All spans in trace
-        # @return [Array<Hash>] Ordered tool call sequence
-        def extract_tool_calls(trace_spans)
-          trace_spans
-            .select { |s| s.dig(:attributes, 'gen_ai.operation.name') == 'execute_tool' }
-            .sort_by { |s| s[:timestamp] }
-            .map do |tool_span|
-              {
-                tool_name: tool_span.dig(:attributes, 'gen_ai.tool.name'),
-                arguments: tool_span.dig(:attributes, 'gen_ai.tool.call.arguments'),
-                arguments_size: tool_span.dig(:attributes, 'gen_ai.tool.call.arguments.size'),
-                result: tool_span.dig(:attributes, 'gen_ai.tool.call.result'),
-                result_size: tool_span.dig(:attributes, 'gen_ai.tool.call.result.size')
-              }
-            end
-        end
-
-        # Parse time range into backend-specific format
-        #
-        # @param time_range [Range<Time>] Time range
-        # @return [Hash] Start and end times
-        def parse_time_range(time_range)
-          {
-            start: time_range.begin || (Time.now - (24 * 60 * 60)),
-            end: time_range.end || Time.now
-          }
-        end
-      end
-    end
-  end
-end

data/lib/language_operator/learning/adapters/jaeger_adapter.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'json'
-require 'uri'
-require_relative 'base_adapter'
-
-module LanguageOperator
-  module Learning
-    module Adapters
-      # Jaeger backend adapter for trace queries
-      #
-      # Queries Jaeger's trace storage via gRPC QueryService API (port 16685).
-      # Falls back to HTTP API (port 16686) if gRPC is unavailable, though
-      # HTTP API is undocumented and not recommended for production use.
-      #
-      # Note: This implementation uses HTTP fallback initially. Full gRPC support
-      # requires the 'grpc' gem and generated protobuf stubs.
-      #
-      # @example Basic usage
-      #   adapter = JaegerAdapter.new('http://jaeger-query:16686')
-      #
-      #   spans = adapter.query_spans(
-      #     filter: { task_name: 'fetch_data' },
-      #     time_range: (Time.now - 3600)..Time.now,
-      #     limit: 100
-      #   )
-      class JaegerAdapter < BaseAdapter
-        # Jaeger HTTP API search endpoint
-        SEARCH_PATH = '/api/traces'
-
-        # Jaeger gRPC port (for future gRPC implementation)
-        GRPC_PORT = 16_685
-
-        # Check if Jaeger is available at endpoint
-        #
-        # @param endpoint [String] Jaeger endpoint URL
-        # @param _api_key [String, nil] API key (unused, Jaeger typically doesn't require auth)
-        # @return [Boolean] True if Jaeger API is reachable
-        def self.available?(endpoint, _api_key = nil)
-          # Try HTTP query endpoint first
-          uri = URI.join(endpoint, SEARCH_PATH)
-          response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', open_timeout: 2, read_timeout: 2) do |http|
-            request = Net::HTTP::Get.new("#{uri.path}?service=test&limit=1")
-            http.request(request)
-          end
-
-          response.is_a?(Net::HTTPSuccess)
-        rescue StandardError
-          false
-        end
-
-        # Query spans from Jaeger
-        #
-        # Uses HTTP API for search. Note: Jaeger searches by trace attributes (tags),
-        # returning traces that contain at least one matching span.
-        #
-        # @param filter [Hash] Filter criteria
-        # @option filter [String] :task_name Task name to filter by
-        # @param time_range [Range<Time>] Time range for query
-        # @param limit [Integer] Maximum traces to return
-        # @return [Array<Hash>] Normalized span data
-        def query_spans(filter:, time_range:, limit:)
-          times = parse_time_range(time_range)
-          traces = search_traces(filter, times, limit)
-          extract_spans_from_traces(traces)
-        end
-
-        private
-
-        # Search traces via Jaeger HTTP API
-        #
-        # @param filter [Hash] Filter criteria
-        # @param times [Hash] Start and end times
-        # @param limit [Integer] Result limit
-        # @return [Array<Hash>] Trace data
-        def search_traces(filter, times, limit)
-          uri = build_search_uri(filter, times, limit)
-
-          Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', open_timeout: 5, read_timeout: 30) do |http|
-            request = Net::HTTP::Get.new(uri.request_uri)
-            request['Accept'] = 'application/json'
-
-            response = http.request(request)
-
-            raise "Jaeger query failed: #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
-
-            result = JSON.parse(response.body, symbolize_names: true)
-            result[:data] || []
-          end
-        end
-
-        # Build Jaeger search URI with query parameters
-        #
-        # @param filter [Hash] Filter criteria
-        # @param times [Hash] Start and end times
-        # @param limit [Integer] Result limit
-        # @return [URI] Complete URI with query params
-        def build_search_uri(filter, times, limit)
-          params = {
-            limit: limit,
-            start: (times[:start].to_f * 1_000_000).to_i, # Microseconds
-            end: (times[:end].to_f * 1_000_000).to_i
-          }
-
-          # Jaeger requires a service name for search
-          # We use a wildcard or extract from task name
-          params[:service] = extract_service_name(filter)
-
-          # Add tag filters
-          tags = {}
-          tags['task.name'] = filter[:task_name] if filter[:task_name]
-          tags['agent.name'] = filter[:agent_name] if filter[:agent_name]
-          params[:tags] = tags.to_json unless tags.empty?
-
-          uri = URI.join(@endpoint, SEARCH_PATH)
-          uri.query = URI.encode_www_form(params)
-          uri
-        end
-
-        # Extract service name from filter or use wildcard
-        #
-        # @param filter [Hash] Filter criteria
-        # @return [String] Service name
-        def extract_service_name(filter)
-          # Jaeger requires service name, but we don't always know it
-          # Use task name prefix or wildcard
-          if filter[:task_name]
-            # Assume service name from task (e.g., "user_service.fetch_user")
-            parts = filter[:task_name].split('.')
-            parts.size > 1 ? parts[0] : 'agent'
-          else
-            'agent' # Default service name
-          end
-        end
-
-        # Extract all spans from traces
-        #
-        # @param traces [Array<Hash>] Jaeger trace data
-        # @return [Array<Hash>] Normalized spans
-        def extract_spans_from_traces(traces)
-          spans = []
-
-          traces.each do |trace|
-            trace_id = trace[:traceID]
-            process_map = build_process_map(trace[:processes])
-
-            (trace[:spans] || []).each do |span_data|
-              spans << normalize_span(span_data, trace_id, process_map)
-            end
-          end
-
-          spans
-        end
-
-        # Build process map for resource attributes
-        #
-        # @param processes [Hash] Process definitions
-        # @return [Hash] Process ID to name mapping
-        def build_process_map(processes)
-          return {} unless processes.is_a?(Hash)
-
-          processes.transform_values do |process|
-            process[:serviceName] || 'unknown'
-          end
-        end
-
-        # Normalize Jaeger span to common format
-        #
-        # @param span_data [Hash] Raw Jaeger span
-        # @param trace_id [String] Trace ID
-        # @param process_map [Hash] Process mapping
-        # @return [Hash] Normalized span
-        def normalize_span(span_data, trace_id, process_map)
-          process_id = span_data[:processID] || 'p1'
-          service_name = process_map[process_id] || 'unknown'
-
-          {
-            span_id: span_data[:spanID],
-            trace_id: trace_id,
-            name: span_data[:operationName] || service_name,
-            timestamp: parse_timestamp(span_data[:startTime]),
-            duration_ms: (span_data[:duration] || 0) / 1000.0, # Microseconds to milliseconds
-            attributes: parse_tags(span_data[:tags])
-          }
-        end
-
-        # Parse Jaeger timestamp (microseconds) to Time
-        #
-        # @param timestamp [Integer] Timestamp in microseconds
-        # @return [Time] Parsed time
-        def parse_timestamp(timestamp)
-          return Time.now unless timestamp
-
-          Time.at(timestamp / 1_000_000.0)
-        end
-
-        # Parse Jaeger tags into flat attributes hash
-        #
-        # @param tags [Array<Hash>] Tag array
-        # @return [Hash] Flat attributes
-        def parse_tags(tags)
-          return {} unless tags.is_a?(Array)
-
-          tags.each_with_object({}) do |tag, attrs|
-            key = tag[:key].to_s
-            value = tag[:value]
-
-            # Jaeger tags have type-specific value fields
-            # Extract the actual value
-            attrs[key] = if value.is_a?(Hash)
-                           value[:stringValue] || value[:intValue] || value[:floatValue] || value[:boolValue]
-                         else
-                           value
-                         end
-          end
-        end
-      end
-    end
-  end
-end