aidp 0.5.0 → 0.8.0

data/lib/aidp/harness/state/metrics.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    module State
+      # Manages metrics, analytics, and performance calculations
+      class Metrics
+        def initialize(persistence, workflow_state)
+          @persistence = persistence
+          @workflow_state = workflow_state
+        end
+
+        def record_provider_switch(from_provider, to_provider)
+          current_state = load_state
+          provider_switches = (current_state[:provider_switches] || 0) + 1
+
+          update_state(
+            provider_switches: provider_switches,
+            last_provider_switch: create_switch_record(from_provider, to_provider)
+          )
+        end
+
+        def record_rate_limit_event(provider_name, reset_time)
+          current_state = load_state
+          rate_limit_events = (current_state[:rate_limit_events] || 0) + 1
+
+          update_state(
+            rate_limit_events: rate_limit_events,
+            last_rate_limit: create_rate_limit_record(provider_name, reset_time)
+          )
+        end
+
+        def record_user_feedback_request(step_name, questions_count)
+          current_state = load_state
+          user_feedback_requests = (current_state[:user_feedback_requests] || 0) + 1
+
+          update_state(
+            user_feedback_requests: user_feedback_requests,
+            last_user_feedback: create_feedback_record(step_name, questions_count)
+          )
+        end
+
+        def record_error_event(step_name, error_type, provider_name = nil)
+          current_state = load_state
+          error_events = (current_state[:error_events] || 0) + 1
+
+          update_state(
+            error_events: error_events,
+            last_error: create_error_record(step_name, error_type, provider_name)
+          )
+        end
+
+        def record_retry_attempt(step_name, provider_name, attempt_number)
+          current_state = load_state
+          retry_attempts = (current_state[:retry_attempts] || 0) + 1
+
+          update_state(
+            retry_attempts: retry_attempts,
+            last_retry: create_retry_record(step_name, provider_name, attempt_number)
+          )
+        end
+
+        def harness_metrics
+          state = load_state
+          {
+            provider_switches: state[:provider_switches] || 0,
+            rate_limit_events: state[:rate_limit_events] || 0,
+            user_feedback_requests: state[:user_feedback_requests] || 0,
+            error_events: state[:error_events] || 0,
+            retry_attempts: state[:retry_attempts] || 0,
+            current_provider: state[:current_provider],
+            harness_state: state[:state],
+            last_activity: state[:last_updated]
+          }
+        end
+
+        def performance_metrics
+          {
+            efficiency: calculate_efficiency_metrics,
+            reliability: calculate_reliability_metrics,
+            performance: calculate_performance_metrics
+          }
+        end
+
+        private
+
+        def load_state
+          @persistence.load_state
+        end
+
+        def update_state(updates)
+          current_state = load_state
+          updated_state = current_state.merge(updates)
+          updated_state[:last_updated] = Time.now
+          @persistence.save_state(updated_state)
+        end
+
+        def create_switch_record(from_provider, to_provider)
+          {
+            from: from_provider,
+            to: to_provider,
+            timestamp: Time.now
+          }
+        end
+
+        def create_rate_limit_record(provider_name, reset_time)
+          {
+            provider: provider_name,
+            reset_time: reset_time,
+            timestamp: Time.now
+          }
+        end
+
+        def create_feedback_record(step_name, questions_count)
+          {
+            step: step_name,
+            questions_count: questions_count,
+            timestamp: Time.now
+          }
+        end
+
+        def create_error_record(step_name, error_type, provider_name)
+          {
+            step: step_name,
+            error_type: error_type,
+            provider: provider_name,
+            timestamp: Time.now
+          }
+        end
+
+        def create_retry_record(step_name, provider_name, attempt_number)
+          {
+            step: step_name,
+            provider: provider_name,
+            attempt: attempt_number,
+            timestamp: Time.now
+          }
+        end
+
+        def calculate_efficiency_metrics
+          {
+            provider_switches_per_step: calculate_switches_per_step,
+            average_retries_per_step: calculate_retries_per_step,
+            user_feedback_ratio: calculate_feedback_ratio
+          }
+        end
+
+        def calculate_reliability_metrics
+          {
+            error_rate: calculate_error_rate,
+            rate_limit_frequency: calculate_rate_limit_frequency,
+            success_rate: calculate_success_rate
+          }
+        end
+
+        def calculate_performance_metrics
+          {
+            session_duration: @workflow_state.session_duration,
+            steps_per_hour: calculate_steps_per_hour,
+            average_step_duration: calculate_average_step_duration
+          }
+        end
+
+        def calculate_switches_per_step
+          provider_switches = load_state[:provider_switches] || 0
+          completed_steps_count = @workflow_state.completed_steps.size
+          return 0 if completed_steps_count == 0
+          (provider_switches.to_f / completed_steps_count).round(2)
+        end
+
+        def calculate_retries_per_step
+          retry_attempts = load_state[:retry_attempts] || 0
+          completed_steps_count = @workflow_state.completed_steps.size
+          return 0 if completed_steps_count == 0
+          (retry_attempts.to_f / completed_steps_count).round(2)
+        end
+
+        def calculate_feedback_ratio
+          user_feedback_requests = load_state[:user_feedback_requests] || 0
+          completed_steps_count = @workflow_state.completed_steps.size
+          return 0 if completed_steps_count == 0
+          (user_feedback_requests.to_f / completed_steps_count).round(2)
+        end
+
+        def calculate_error_rate
+          error_events = load_state[:error_events] || 0
+          total_events = error_events + @workflow_state.completed_steps.size
+          return 0 if total_events == 0
+          (error_events.to_f / total_events * 100).round(2)
+        end
+
+        def calculate_rate_limit_frequency
+          rate_limit_events = load_state[:rate_limit_events] || 0
+          session_duration_hours = @workflow_state.session_duration / 3600.0
+          return 0 if session_duration_hours == 0
+          (rate_limit_events / session_duration_hours).round(2)
+        end
+
+        def calculate_success_rate
+          error_events = load_state[:error_events] || 0
+          total_attempts = @workflow_state.completed_steps.size + error_events
+          return 100 if total_attempts == 0
+          ((@workflow_state.completed_steps.size.to_f / total_attempts) * 100).round(2)
+        end
+
+        def calculate_steps_per_hour
+          session_duration_hours = @workflow_state.session_duration / 3600.0
+          return 0 if session_duration_hours == 0
+          (@workflow_state.completed_steps.size / session_duration_hours).round(2)
+        end
+
+        def calculate_average_step_duration
+          return 0 if @workflow_state.completed_steps.size == 0
+          (@workflow_state.session_duration / @workflow_state.completed_steps.size).round(2)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/state/persistence.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aidp
+  module Harness
+    module State
+      # Handles file I/O and persistence for state management
+      class Persistence
+        def initialize(project_dir, mode)
+          @project_dir = project_dir
+          @mode = mode
+          @state_dir = File.join(project_dir, ".aidp", "harness")
+          @state_file = File.join(@state_dir, "#{mode}_state.json")
+          @lock_file = File.join(@state_dir, "#{mode}_state.lock")
+          ensure_state_directory
+        end
+
+        def has_state?
+          return false if test_mode?
+          File.exist?(@state_file)
+        end
+
+        def load_state
+          return {} if test_mode? || !has_state?
+
+          with_lock do
+            content = File.read(@state_file)
+            JSON.parse(content, symbolize_names: true)
+          rescue JSON::ParserError => e
+            warn "Failed to parse state file: #{e.message}"
+            {}
+          end
+        end
+
+        def save_state(state_data)
+          return if test_mode?
+
+          with_lock do
+            state_with_metadata = add_metadata(state_data)
+            write_atomically(state_with_metadata)
+          end
+        end
+
+        def clear_state
+          return if test_mode?
+
+          with_lock do
+            File.delete(@state_file) if File.exist?(@state_file)
+          end
+        end
+
+        private
+
+        def test_mode?
+          ENV["RACK_ENV"] == "test" || defined?(RSpec)
+        end
+
+        def add_metadata(state_data)
+          state_data.merge(
+            mode: @mode,
+            project_dir: @project_dir,
+            saved_at: Time.now.iso8601
+          )
+        end
+
+        def write_atomically(state_with_metadata)
+          temp_file = "#{@state_file}.tmp"
+          File.write(temp_file, JSON.pretty_generate(state_with_metadata))
+          File.rename(temp_file, @state_file)
+        end
+
+        def ensure_state_directory
+          FileUtils.mkdir_p(@state_dir) unless Dir.exist?(@state_dir)
+        end
+
+        def with_lock(&block)
+          return yield if test_mode?
+
+          acquire_lock_with_timeout(&block)
+        ensure
+          cleanup_lock_file
+        end
+
+        def acquire_lock_with_timeout(&block)
+          lock_acquired = false
+          timeout = 30
+          start_time = Time.now
+
+          while (Time.now - start_time) < timeout
+            lock_acquired = try_acquire_lock(&block)
+            break if lock_acquired
+            sleep_briefly
+          end
+
+          raise_lock_timeout_error unless lock_acquired
+        end
+
+        def try_acquire_lock(&block)
+          File.open(@lock_file, File::CREAT | File::EXCL | File::WRONLY) do |_lock|
+            yield
+            true
+          end
+        rescue Errno::EEXIST
+          false
+        end
+
+        def sleep_briefly
+          require "async"
+          if Async::Task.current?
+            Async::Task.current.sleep(0.1)
+          else
+            sleep(0.1)
+          end
+        end
+
+        def raise_lock_timeout_error
+          raise "Could not acquire state lock within 30 seconds"
+        end
+
+        def cleanup_lock_file
+          File.delete(@lock_file) if File.exist?(@lock_file)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/state/provider_state.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    module State
+      # Manages provider-specific state and rate limiting
+      class ProviderState
+        def initialize(persistence)
+          @persistence = persistence
+        end
+
+        def provider_state
+          state[:provider_state] || {}
+        end
+
+        def update_provider_state(provider_name, provider_data)
+          current_provider_state = provider_state
+          current_provider_state[provider_name] = provider_data
+          update_state(provider_state: current_provider_state)
+        end
+
+        def rate_limit_info
+          state[:rate_limit_info] || {}
+        end
+
+        def update_rate_limit_info(provider_name, reset_time, error_count = 0)
+          current_info = rate_limit_info
+          current_info[provider_name] = create_rate_limit_entry(reset_time, error_count)
+          update_state(rate_limit_info: current_info)
+        end
+
+        def provider_rate_limited?(provider_name)
+          info = rate_limit_info[provider_name]
+          return false unless info
+
+          reset_time = parse_reset_time(info[:reset_time])
+          reset_time && Time.now < reset_time
+        end
+
+        def next_provider_reset_time
+          rate_limit_info.map do |_provider, info|
+            parse_reset_time(info[:reset_time])
+          end.compact.min
+        end
+
+        def token_usage
+          state[:token_usage] || {}
+        end
+
+        def record_token_usage(provider_name, model_name, input_tokens, output_tokens, cost = nil)
+          current_usage = token_usage
+          key = "#{provider_name}:#{model_name}"
+
+          current_usage[key] = update_token_usage_entry(
+            current_usage[key], input_tokens, output_tokens, cost
+          )
+
+          update_state(token_usage: current_usage)
+        end
+
+        def token_usage_summary
+          usage = token_usage
+          {
+            total_tokens: calculate_total_tokens(usage),
+            total_cost: calculate_total_cost(usage),
+            total_requests: calculate_total_requests(usage),
+            by_provider_model: usage
+          }
+        end
+
+        private
+
+        def state
+          @persistence.load_state
+        end
+
+        def update_state(updates)
+          current_state = state
+          updated_state = current_state.merge(updates)
+          updated_state[:last_updated] = Time.now
+          @persistence.save_state(updated_state)
+        end
+
+        def create_rate_limit_entry(reset_time, error_count)
+          {
+            reset_time: reset_time&.iso8601,
+            error_count: error_count,
+            last_updated: Time.now.iso8601
+          }
+        end
+
+        def parse_reset_time(reset_time_string)
+          Time.parse(reset_time_string) if reset_time_string
+        end
+
+        def update_token_usage_entry(existing_entry, input_tokens, output_tokens, cost)
+          existing_entry ||= create_empty_token_usage_entry
+
+          existing_entry[:input_tokens] += input_tokens
+          existing_entry[:output_tokens] += output_tokens
+          existing_entry[:total_tokens] += (input_tokens + output_tokens)
+          existing_entry[:cost] += cost if cost
+          existing_entry[:requests] += 1
+
+          existing_entry
+        end
+
+        def create_empty_token_usage_entry
+          {
+            input_tokens: 0,
+            output_tokens: 0,
+            total_tokens: 0,
+            cost: 0.0,
+            requests: 0
+          }
+        end
+
+        def calculate_total_tokens(usage)
+          usage.values.sum { |entry| entry[:total_tokens] }
+        end
+
+        def calculate_total_cost(usage)
+          usage.values.sum { |entry| entry[:cost] }
+        end
+
+        def calculate_total_requests(usage)
+          usage.values.sum { |entry| entry[:requests] }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/state/ui_state.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    module State
+      # Manages UI-specific state and user interactions
+      class UIState
+        def initialize(persistence)
+          @persistence = persistence
+        end
+
+        def user_input
+          state[:user_input] || {}
+        end
+
+        def add_user_input(key, value)
+          current_input = user_input
+          current_input[key] = value
+          update_state(user_input: current_input)
+        end
+
+        def execution_log
+          state[:execution_log] || []
+        end
+
+        def add_execution_log(entry)
+          current_log = execution_log
+          current_log << entry
+          update_state(execution_log: current_log)
+        end
+
+        def current_step
+          state[:current_step]
+        end
+
+        def set_current_step(step_name)
+          update_state(current_step: step_name)
+        end
+
+        def state_metadata
+          return {} unless @persistence.has_state?
+
+          state_data = state
+          {
+            mode: state_data[:mode],
+            saved_at: state_data[:saved_at],
+            current_step: state_data[:current_step],
+            state: state_data[:state],
+            last_updated: state_data[:last_updated]
+          }
+        end
+
+        private
+
+        def state
+          @persistence.load_state
+        end
+
+        def update_state(updates)
+          current_state = state
+          updated_state = current_state.merge(updates)
+          updated_state[:last_updated] = Time.now
+          @persistence.save_state(updated_state)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/state/workflow_state.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "../../execute/progress"
+require_relative "../../analyze/progress"
+require_relative "../../execute/steps"
+require_relative "../../analyze/steps"
+
+module Aidp
+  module Harness
+    module State
+      # Manages workflow-specific state and progress tracking
+      class WorkflowState
+        def initialize(persistence, project_dir, mode)
+          @persistence = persistence
+          @project_dir = project_dir
+          @mode = mode
+          @progress_tracker = create_progress_tracker
+        end
+
+        def completed_steps
+          @progress_tracker.completed_steps
+        end
+
+        def current_step
+          @progress_tracker.current_step
+        end
+
+        def step_completed?(step_name)
+          @progress_tracker.step_completed?(step_name)
+        end
+
+        def mark_step_completed(step_name)
+          @progress_tracker.mark_step_completed(step_name)
+          update_harness_state(current_step: nil, last_step_completed: step_name)
+        end
+
+        def mark_step_in_progress(step_name)
+          @progress_tracker.mark_step_in_progress(step_name)
+          update_harness_state(current_step: step_name)
+        end
+
+        def next_step
+          @progress_tracker.next_step
+        end
+
+        def total_steps
+          steps_spec.keys.size
+        end
+
+        def all_steps_completed?
+          completed_steps.size == total_steps
+        end
+
+        def progress_percentage
+          return 100.0 if all_steps_completed?
+          (completed_steps.size.to_f / total_steps * 100).round(2)
+        end
+
+        def session_duration
+          return 0 unless @progress_tracker.started_at
+          Time.now - @progress_tracker.started_at
+        end
+
+        def reset_all
+          @progress_tracker.reset
+          @persistence.clear_state
+        end
+
+        def progress_summary
+          {
+            mode: @mode,
+            completed_steps: completed_steps.size,
+            total_steps: total_steps,
+            current_step: current_step,
+            next_step: next_step,
+            all_completed: all_steps_completed?,
+            started_at: @progress_tracker.started_at,
+            harness_state: harness_state,
+            progress_percentage: progress_percentage,
+            session_duration: session_duration
+          }
+        end
+
+        attr_reader :progress_tracker
+
+        private
+
+        def create_progress_tracker
+          case @mode
+          when :analyze
+            Aidp::Analyze::Progress.new(@project_dir)
+          when :execute
+            Aidp::Execute::Progress.new(@project_dir)
+          else
+            raise ArgumentError, "Unsupported mode: #{@mode}"
+          end
+        end
+
+        def steps_spec
+          case @mode
+          when :analyze
+            Aidp::Analyze::Steps::SPEC
+          when :execute
+            Aidp::Execute::Steps::SPEC
+          else
+            {}
+          end
+        end
+
+        def harness_state
+          @persistence.has_state? ? @persistence.load_state : {}
+        end
+
+        def update_harness_state(updates)
+          current_state = @persistence.load_state
+          updated_state = current_state.merge(updates)
+          updated_state[:last_updated] = Time.now
+          @persistence.save_state(updated_state)
+        end
+      end
+    end
+  end
+end