aidp 0.7.0 → 0.8.1

data/lib/aidp/providers/opencode.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "base"
+require_relative "../util"
+require_relative "../debug_mixin"
+
+module Aidp
+  module Providers
+    class Opencode < Base
+      include Aidp::DebugMixin
+
+      def self.available?
+        !!Aidp::Util.which("opencode")
+      end
+
+      def name
+        "opencode"
+      end
+
+      def send(prompt:, session: nil)
+        raise "opencode not available" unless self.class.available?
+
+        # Smart timeout calculation
+        timeout_seconds = calculate_timeout
+
+        debug_provider("opencode", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to opencode (length: #{prompt.length})", level: :info)
+
+        # Check if prompt is too large and warn
+        if prompt.length > 3000
+          debug_log("⚠️  Large prompt detected (#{prompt.length} chars) - this may cause rate limiting", level: :warn)
+        end
+
+        # Set up activity monitoring
+        setup_activity_monitoring("opencode", method(:activity_callback))
+        record_activity("Starting opencode execution")
+
+        # Start activity display thread with timeout
+        activity_display_thread = Thread.new do
+          start_time = Time.now
+          loop do
+            sleep 0.5 # Update every 500ms to reduce spam
+            elapsed = Time.now - start_time
+
+            # Break if we've been running too long or state changed
+            break if elapsed > timeout_seconds || @activity_state == :completed || @activity_state == :failed
+
+            print_activity_status(elapsed)
+          end
+        end
+
+        begin
+          # Use debug_execute_command for better debugging
+          # opencode run command with prompt and model
+          model = ENV["OPENCODE_MODEL"] || "github-copilot/claude-3.5-sonnet"
+          result = debug_execute_command("opencode", args: ["run", "-m", model, prompt], timeout: timeout_seconds)
+
+          # Log the results
+          debug_command("opencode", args: ["run", "-m", model, prompt], input: nil, output: result.out, error: result.err, exit_code: result.exit_status)
+
+          # Stop activity display
+          activity_display_thread.kill if activity_display_thread.alive?
+          activity_display_thread.join(0.1) # Give it 100ms to finish
+          clear_activity_status
+
+          if result.exit_status == 0
+            mark_completed
+            result.out
+          else
+            mark_failed("opencode failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("opencode failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "opencode failed with exit code #{result.exit_status}: #{result.err}"
+          end
+        rescue => e
+          # Stop activity display
+          activity_display_thread.kill if activity_display_thread.alive?
+          activity_display_thread.join(0.1) # Give it 100ms to finish
+          clear_activity_status
+          mark_failed("opencode execution failed: #{e.message}")
+          debug_error(e, {provider: "opencode", prompt_length: prompt.length})
+          raise
+        end
+      end
+
+      private
+
+      def print_activity_status(elapsed)
+        # Print activity status during opencode execution with elapsed time
+        minutes = (elapsed / 60).to_i
+        seconds = (elapsed % 60).to_i
+
+        if minutes > 0
+          print "\r🔄 opencode is running... (#{minutes}m #{seconds}s)"
+        else
+          print "\r🔄 opencode is running... (#{seconds}s)"
+        end
+        $stdout.flush
+      end
+
+      def clear_activity_status
+        # Clear the activity status line
+        print "\r" + " " * 50 + "\r"
+        $stdout.flush
+      end
+
+      def calculate_timeout
+        # Priority order for timeout calculation:
+        # 1. Quick mode (for testing)
+        # 2. Environment variable override
+        # 3. Adaptive timeout based on step type
+        # 4. Default timeout
+
+        if ENV["AIDP_QUICK_MODE"]
+          puts "⚡ Quick mode enabled - 2 minute timeout"
+          return 120
+        end
+
+        if ENV["AIDP_OPENCODE_TIMEOUT"]
+          return ENV["AIDP_OPENCODE_TIMEOUT"].to_i
+        end
+
+        # Adaptive timeout based on step type
+        step_timeout = get_adaptive_timeout
+        if step_timeout
+          puts "🧠 Using adaptive timeout: #{step_timeout} seconds"
+          return step_timeout
+        end
+
+        # Default timeout (5 minutes for interactive use)
+        puts "📋 Using default timeout: 5 minutes"
+        300
+      end
+
+      def get_adaptive_timeout
+        # Timeout recommendations based on step type patterns
+        step_name = ENV["AIDP_CURRENT_STEP"] || ""
+
+        case step_name
+        when /REPOSITORY_ANALYSIS/
+          180  # 3 minutes - repository analysis can be quick
+        when /ARCHITECTURE_ANALYSIS/
+          600  # 10 minutes - architecture analysis needs more time
+        when /TEST_ANALYSIS/
+          300  # 5 minutes - test analysis is moderate
+        when /FUNCTIONALITY_ANALYSIS/
+          600  # 10 minutes - functionality analysis is complex
+        when /DOCUMENTATION_ANALYSIS/
+          300  # 5 minutes - documentation analysis is moderate
+        when /STATIC_ANALYSIS/
+          450  # 7.5 minutes - static analysis can be intensive
+        when /REFACTORING_RECOMMENDATIONS/
+          600  # 10 minutes - refactoring recommendations are complex
+        else
+          nil  # Use default
+        end
+      end
+
+      def activity_callback(state, message, provider)
+        # This is now handled by the animated display thread
+        # Only print static messages for state changes
+        case state
+        when :starting
+          puts "🚀 Starting opencode execution..."
+        when :completed
+          puts "✅ opencode execution completed"
+        when :failed
+          puts "❌ opencode execution failed: #{message}"
+        end
+      end
+
+      def setup_activity_monitoring(provider_name, callback)
+        @activity_callback = callback
+        @activity_state = :starting
+        @activity_start_time = Time.now
+      end
+
+      def record_activity(message)
+        @activity_state = :running
+        @activity_callback&.call(:running, message, "opencode")
+      end
+
+      def mark_completed
+        @activity_state = :completed
+        @activity_callback&.call(:completed, "Execution completed", "opencode")
+      end
+
+      def mark_failed(reason)
+        @activity_state = :failed
+        @activity_callback&.call(:failed, reason, "opencode")
+      end
+    end
+  end
+end

data/lib/aidp/storage/csv_storage.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "csv"
+require "fileutils"
+
+module Aidp
+  module Storage
+    # Simple CSV file storage for tabular data
+    class CsvStorage
+      def initialize(base_dir = ".aidp")
+        @base_dir = base_dir
+        ensure_directory_exists
+      end
+
+      # Append a row to CSV file
+      def append(filename, row_data)
+        file_path = get_file_path(filename)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        # Add timestamp if not present
+        row_data["created_at"] ||= Time.now.iso8601
+
+        # Convert all values to strings
+        row_data = row_data.transform_values(&:to_s)
+
+        # If file doesn't exist, write headers first
+        if !File.exist?(file_path)
+          CSV.open(file_path, "w") do |csv|
+            csv << row_data.keys
+          end
+        end
+
+        # Append the row
+        CSV.open(file_path, "a") do |csv|
+          csv << row_data.values
+        end
+
+        {
+          filename: filename,
+          file_path: file_path,
+          row_count: count_rows(filename),
+          success: true
+        }
+      rescue => error
+        {
+          filename: filename,
+          error: error.message,
+          success: false
+        }
+      end
+
+      # Read all rows from CSV file
+      def read_all(filename)
+        file_path = get_file_path(filename)
+        return [] unless File.exist?(file_path)
+
+        rows = []
+        CSV.foreach(file_path, headers: true) do |row|
+          rows << row.to_h
+        end
+        rows
+      rescue => error
+        puts "Error reading #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        []
+      end
+
+      # Read rows with filtering
+      def read_filtered(filename, filters = {})
+        all_rows = read_all(filename)
+        return all_rows if filters.empty?
+
+        all_rows.select do |row|
+          filters.all? { |key, value| row[key.to_s] == value.to_s }
+        end
+      end
+
+      # Count rows in CSV file
+      def count_rows(filename)
+        file_path = get_file_path(filename)
+        return 0 unless File.exist?(file_path)
+
+        count = 0
+        CSV.foreach(file_path) { count += 1 }
+        count - 1 # Subtract 1 for header row
+      rescue => error
+        puts "Error counting rows in #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        0
+      end
+
+      # Get unique values for a column
+      def unique_values(filename, column)
+        all_rows = read_all(filename)
+        all_rows.map { |row| row[column.to_s] }.compact.uniq
+      end
+
+      # Get summary statistics
+      def summary(filename)
+        file_path = get_file_path(filename)
+        return nil unless File.exist?(file_path)
+
+        rows = read_all(filename)
+        return nil if rows.empty?
+
+        headers = rows.first.keys
+        numeric_columns = headers.select do |col|
+          rows.all? { |row| row[col] =~ /^-?\d+\.?\d*$/ }
+        end
+
+        summary_data = {
+          filename: filename,
+          file_path: file_path,
+          total_rows: rows.length,
+          columns: headers,
+          numeric_columns: numeric_columns,
+          file_size: File.size(file_path)
+        }
+
+        # Add basic stats for numeric columns
+        numeric_columns.each do |col|
+          values = rows.map { |row| row[col].to_f }
+          summary_data["#{col}_stats"] = {
+            min: values.min,
+            max: values.max,
+            avg: values.sum / values.length
+          }
+        end
+
+        summary_data
+      rescue => error
+        puts "Error generating summary for #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        nil
+      end
+
+      # Check if file exists
+      def exists?(filename)
+        File.exist?(get_file_path(filename))
+      end
+
+      # Delete file
+      def delete(filename)
+        file_path = get_file_path(filename)
+        return {success: true, message: "File does not exist"} unless File.exist?(file_path)
+
+        File.delete(file_path)
+        {success: true, message: "File deleted"}
+      rescue => error
+        {success: false, error: error.message}
+      end
+
+      # List all CSV files
+      def list
+        return [] unless Dir.exist?(@base_dir)
+
+        Dir.glob(File.join(@base_dir, "**", "*.csv")).map do |file|
+          File.basename(file, ".csv")
+        end
+      end
+
+      private
+
+      def get_file_path(filename)
+        # Ensure filename has .csv extension
+        filename += ".csv" unless filename.end_with?(".csv")
+        File.join(@base_dir, filename)
+      end
+
+      def ensure_directory_exists
+        FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
+      end
+    end
+  end
+end

data/lib/aidp/storage/file_manager.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative "json_storage"
+require_relative "csv_storage"
+
+module Aidp
+  module Storage
+    # Simple file manager that provides easy access to JSON and CSV storage
+    class FileManager
+      def initialize(base_dir = ".aidp")
+        @base_dir = base_dir
+        @json_storage = JsonStorage.new(base_dir)
+        @csv_storage = CsvStorage.new(base_dir)
+      end
+
+      # JSON operations for structured data
+      def store_json(filename, data)
+        @json_storage.store(filename, data)
+      end
+
+      def load_json(filename)
+        @json_storage.load(filename)
+      end
+
+      def update_json(filename, data)
+        @json_storage.update(filename, data)
+      end
+
+      def json_exists?(filename)
+        @json_storage.exists?(filename)
+      end
+
+      def json_metadata(filename)
+        @json_storage.metadata(filename)
+      end
+
+      # CSV operations for tabular data
+      def append_csv(filename, row_data)
+        @csv_storage.append(filename, row_data)
+      end
+
+      def read_csv(filename, filters = {})
+        if filters.empty?
+          @csv_storage.read_all(filename)
+        else
+          @csv_storage.read_filtered(filename, filters)
+        end
+      end
+
+      def csv_summary(filename)
+        @csv_storage.summary(filename)
+      end
+
+      def csv_exists?(filename)
+        @csv_storage.exists?(filename)
+      end
+
+      # Convenience methods for common data types
+
+      # Analysis results (structured data)
+      def store_analysis_result(step_name, data, metadata = {})
+        result = {
+          step_name: step_name,
+          data: data,
+          metadata: metadata
+        }
+        store_json("analysis_results", result)
+      end
+
+      def load_analysis_result
+        load_json("analysis_results")
+      end
+
+      # Embeddings (structured data)
+      def store_embeddings(step_name, embeddings_data)
+        result = {
+          step_name: step_name,
+          embeddings_data: embeddings_data
+        }
+        store_json("embeddings", result)
+      end
+
+      def load_embeddings
+        load_json("embeddings")
+      end
+
+      # Metrics (tabular data)
+      def record_metric(step_name, metric_name, value, metadata = {})
+        row_data = {
+          step_name: step_name,
+          metric_name: metric_name,
+          value: value,
+          recorded_at: Time.now.iso8601
+        }.merge(metadata)
+
+        append_csv("metrics", row_data)
+      end
+
+      def get_metrics(filters = {})
+        read_csv("metrics", filters)
+      end
+
+      def get_metrics_summary
+        csv_summary("metrics")
+      end
+
+      # Step executions (tabular data)
+      def record_step_execution(step_name, provider_name, duration, success, metadata = {})
+        row_data = {
+          step_name: step_name,
+          provider_name: provider_name,
+          duration: duration,
+          success: success,
+          created_at: Time.now.iso8601
+        }.merge(metadata)
+
+        append_csv("step_executions", row_data)
+      end
+
+      def get_step_executions(filters = {})
+        read_csv("step_executions", filters)
+      end
+
+      def get_step_executions_summary
+        csv_summary("step_executions")
+      end
+
+      # Provider activities (tabular data)
+      def record_provider_activity(provider_name, step_name, start_time, end_time, duration, final_state, stuck_detected = false)
+        row_data = {
+          provider_name: provider_name,
+          step_name: step_name,
+          start_time: start_time&.iso8601,
+          end_time: end_time&.iso8601,
+          duration: duration,
+          final_state: final_state,
+          stuck_detected: stuck_detected,
+          created_at: Time.now.iso8601
+        }
+
+        append_csv("provider_activities", row_data)
+      end
+
+      def get_provider_activities(filters = {})
+        read_csv("provider_activities", filters)
+      end
+
+      def get_provider_activities_summary
+        csv_summary("provider_activities")
+      end
+
+      # Configuration and status (structured data)
+      def store_config(config_data)
+        store_json("config", config_data)
+      end
+
+      def load_config
+        load_json("config")
+      end
+
+      def store_status(status_data)
+        store_json("status", status_data)
+      end
+
+      def load_status
+        load_json("status")
+      end
+
+      # List all files
+      def list_json_files
+        @json_storage.list
+      end
+
+      def list_csv_files
+        @csv_storage.list
+      end
+
+      def list_all_files
+        {
+          json_files: list_json_files,
+          csv_files: list_csv_files
+        }
+      end
+
+      # Backup and restore
+      def backup_to(destination_dir)
+        FileUtils.mkdir_p(destination_dir)
+        # Copy contents of base_dir to destination_dir, avoiding recursive copying
+        if Dir.exist?(@base_dir)
+          Dir.glob(File.join(@base_dir, "*")).each do |item|
+            next if File.expand_path(item) == File.expand_path(destination_dir)
+            FileUtils.cp_r(item, destination_dir)
+          end
+        end
+        {success: true, backup_location: destination_dir}
+      rescue => error
+        {success: false, error: error.message}
+      end
+
+      def restore_from(source_dir)
+        return {success: false, error: "Source directory does not exist"} unless Dir.exist?(source_dir)
+
+        # Clear existing data
+        FileUtils.rm_rf(@base_dir) if Dir.exist?(@base_dir)
+
+        # Copy from source
+        FileUtils.cp_r(source_dir, @base_dir)
+        {success: true, restored_from: source_dir}
+      rescue => error
+        {success: false, error: error.message}
+      end
+    end
+  end
+end

data/lib/aidp/storage/json_storage.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aidp
+  module Storage
+    # Simple JSON file storage for structured data
+    class JsonStorage
+      def initialize(base_dir = ".aidp")
+        @base_dir = base_dir
+        ensure_directory_exists
+      end
+
+      # Store data as JSON file
+      def store(filename, data)
+        file_path = get_file_path(filename)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        json_data = {
+          "data" => data,
+          "created_at" => Time.now.iso8601,
+          "updated_at" => Time.now.iso8601
+        }
+
+        File.write(file_path, JSON.pretty_generate(json_data))
+
+        {
+          filename: filename,
+          file_path: file_path,
+          stored_at: Time.now,
+          success: true
+        }
+      rescue => error
+        {
+          filename: filename,
+          error: error.message,
+          success: false
+        }
+      end
+
+      # Load data from JSON file
+      def load(filename)
+        file_path = get_file_path(filename)
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        json_data = JSON.parse(content)
+        json_data["data"]
+      rescue => error
+        puts "Error loading #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        nil
+      end
+
+      # Update existing data
+      def update(filename, data)
+        existing = load(filename)
+        return store(filename, data) unless existing
+
+        file_path = get_file_path(filename)
+        json_data = JSON.parse(File.read(file_path))
+
+        json_data["data"] = data
+        json_data["updated_at"] = Time.now.iso8601
+
+        File.write(file_path, JSON.pretty_generate(json_data))
+
+        {
+          filename: filename,
+          file_path: file_path,
+          updated_at: Time.now,
+          success: true
+        }
+      rescue => error
+        {
+          filename: filename,
+          error: error.message,
+          success: false
+        }
+      end
+
+      # Check if file exists
+      def exists?(filename)
+        File.exist?(get_file_path(filename))
+      end
+
+      # Delete file
+      def delete(filename)
+        file_path = get_file_path(filename)
+        return {success: true, message: "File does not exist"} unless File.exist?(file_path)
+
+        File.delete(file_path)
+        {success: true, message: "File deleted"}
+      rescue => error
+        {success: false, error: error.message}
+      end
+
+      # List all JSON files
+      def list
+        return [] unless Dir.exist?(@base_dir)
+
+        Dir.glob(File.join(@base_dir, "**", "*.json")).map do |file|
+          File.basename(file, ".json")
+        end
+      end
+
+      # Get file metadata
+      def metadata(filename)
+        file_path = get_file_path(filename)
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        json_data = JSON.parse(content)
+
+        {
+          filename: filename,
+          file_path: file_path,
+          created_at: json_data["created_at"],
+          updated_at: json_data["updated_at"],
+          size: File.size(file_path)
+        }
+      rescue => error
+        puts "Error getting metadata for #{filename}: #{error.message}" if ENV["AIDP_DEBUG"]
+        nil
+      end
+
+      private
+
+      def get_file_path(filename)
+        # Ensure filename has .json extension
+        filename += ".json" unless filename.end_with?(".json")
+        File.join(@base_dir, filename)
+      end
+
+      def ensure_directory_exists
+        FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
+      end
+    end
+  end
+end