aidp 0.3.0 → 0.7.0

data/lib/aidp/providers/supervised_base.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require_relative "agent_supervisor"
+
+module Aidp
+  module Providers
+    # Base class for providers that use the agent supervisor
+    class SupervisedBase
+      # Timeout constants are now configurable via environment variables for flexibility
+      DEFAULT_TIMEOUT = Integer(ENV.fetch("AIDP_DEFAULT_TIMEOUT", "300"))             # 5 minutes for general operations
+      QUICK_MODE_TIMEOUT = Integer(ENV.fetch("AIDP_QUICK_MODE_TIMEOUT", "120"))       # 2 minutes for testing
+      REPOSITORY_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_REPOSITORY_ANALYSIS_TIMEOUT", "180")) # 3 minutes
+      ARCHITECTURE_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_ARCHITECTURE_ANALYSIS_TIMEOUT", "600"))  # 10 minutes
+      TEST_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_TEST_ANALYSIS_TIMEOUT", "300"))       # 5 minutes
+      FUNCTIONALITY_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_FUNCTIONALITY_ANALYSIS_TIMEOUT", "600"))  # 10 minutes
+      DOCUMENTATION_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_DOCUMENTATION_ANALYSIS_TIMEOUT", "300"))  # 5 minutes
+      STATIC_ANALYSIS_TIMEOUT = Integer(ENV.fetch("AIDP_STATIC_ANALYSIS_TIMEOUT", "450"))     # 7.5 minutes
+      REFACTORING_RECOMMENDATIONS_TIMEOUT = Integer(ENV.fetch("AIDP_REFACTORING_RECOMMENDATIONS_TIMEOUT", "600"))  # 10 minutes
+      ADAPTIVE_TIMEOUT_BUFFER = Float(ENV.fetch("AIDP_ADAPTIVE_TIMEOUT_BUFFER", "1.2"))     # 20% buffer for adaptive timeouts
+      attr_reader :name, :last_execution_result, :metrics
+
+      def initialize
+        @last_execution_result = nil
+        @metrics = {
+          total_executions: 0,
+          successful_executions: 0,
+          timeout_count: 0,
+          failure_count: 0,
+          average_duration: 0.0,
+          total_duration: 0.0
+        }
+        @job_context = nil
+      end
+
+      # Abstract method - must be implemented by subclasses
+      def command
+        raise NotImplementedError, "#{self.class} must implement #command"
+      end
+
+      # Abstract method - must be implemented by subclasses
+      def provider_name
+        raise NotImplementedError, "#{self.class} must implement #provider_name"
+      end
+
+      # Set job context for background execution
+      def set_job_context(job_id:, execution_id:, job_manager:)
+        @job_context = {
+          job_id: job_id,
+          execution_id: execution_id,
+          job_manager: job_manager
+        }
+      end
+
+      # Execute with supervision and recovery
+      def send(prompt:, session: nil)
+        timeout_seconds = calculate_timeout
+        debug = ENV["AIDP_DEBUG"] == "1"
+
+        log_info("Executing with #{provider_name} provider (timeout: #{timeout_seconds}s)")
+
+        # Create supervisor
+        supervisor = AgentSupervisor.new(
+          command,
+          timeout_seconds: timeout_seconds,
+          debug: debug
+        )
+
+        begin
+          # Execute with supervision
+          result = supervisor.execute(prompt)
+
+          # Update metrics
+          update_metrics(supervisor, result)
+
+          # Store result for debugging
+          @last_execution_result = result
+
+          if result[:success]
+            log_info("#{provider_name} completed successfully in #{format_duration(result[:duration])}")
+            result[:output]
+          else
+            handle_execution_failure(result, supervisor)
+          end
+        rescue => e
+          log_error("#{provider_name} execution error: #{e.message}")
+
+          # Try to kill the process if it's still running
+          supervisor.kill! if supervisor.active?
+
+          raise
+        end
+      end
+
+      # Get execution statistics
+      def stats
+        @metrics.dup
+      end
+
+      # Reset statistics
+      def reset_stats!
+        @metrics = {
+          total_executions: 0,
+          successful_executions: 0,
+          timeout_count: 0,
+          failure_count: 0,
+          average_duration: 0.0,
+          total_duration: 0.0
+        }
+      end
+
+      # Check if provider supports activity monitoring
+      def supports_activity_monitoring?
+        true # Supervised providers always support activity monitoring
+      end
+
+      # Get activity summary for metrics (compatibility with old interface)
+      def activity_summary
+        return {} unless @last_execution_result
+
+        {
+          provider: provider_name,
+          step_name: ENV["AIDP_CURRENT_STEP"],
+          start_time: @last_execution_result[:start_time],
+          end_time: @last_execution_result[:end_time],
+          duration: @last_execution_result[:duration],
+          final_state: @last_execution_result[:state],
+          stuck_detected: false, # Supervisor handles this differently
+          output_count: @last_execution_result[:output_count] || 0
+        }
+      end
+
+      # Compatibility methods for old activity monitoring interface
+      def setup_activity_monitoring(step_name, callback = nil, timeout = nil)
+        # No-op for supervised providers - supervisor handles this
+      end
+
+      def record_activity(message = nil)
+        # No-op for supervised providers - supervisor handles this
+      end
+
+      def mark_completed
+        # No-op for supervised providers - supervisor handles this
+      end
+
+      def mark_failed(message = nil)
+        # No-op for supervised providers - supervisor handles this
+      end
+
+      private
+
+      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"]
+          log_info("Quick mode enabled - #{QUICK_MODE_TIMEOUT / 60} minute timeout")
+          return QUICK_MODE_TIMEOUT
+        end
+
+        provider_timeout_var = "AIDP_#{provider_name.upcase}_TIMEOUT"
+        if ENV[provider_timeout_var]
+          return ENV[provider_timeout_var].to_i
+        end
+
+        # Adaptive timeout based on step type
+        step_timeout = get_adaptive_timeout
+        if step_timeout
+          log_info("Using adaptive timeout: #{step_timeout} seconds")
+          return step_timeout
+        end
+
+        # Default timeout for interactive use
+        log_info("Using default timeout: #{DEFAULT_TIMEOUT / 60} minutes")
+        DEFAULT_TIMEOUT
+      end
+
+      def get_adaptive_timeout
+        # Try to get timeout recommendations from metrics storage
+        begin
+          require_relative "../analyze/metrics_storage"
+          storage = Aidp::Analyze::MetricsStorage.new(Dir.pwd)
+          recommendations = storage.calculate_timeout_recommendations
+
+          # Get current step name from environment or context
+          step_name = ENV["AIDP_CURRENT_STEP"] || "unknown"
+
+          if recommendations[step_name]
+            recommended = recommendations[step_name][:recommended_timeout]
+            # Add buffer for safety
+            return (recommended * ADAPTIVE_TIMEOUT_BUFFER).ceil
+          end
+        rescue => e
+          log_warning("Could not get adaptive timeout: #{e.message}") if ENV["AIDP_DEBUG"]
+        end
+
+        # Fallback timeouts based on step type patterns
+        step_name = ENV["AIDP_CURRENT_STEP"] || ""
+
+        case step_name
+        when /REPOSITORY_ANALYSIS/
+          REPOSITORY_ANALYSIS_TIMEOUT
+        when /ARCHITECTURE_ANALYSIS/
+          ARCHITECTURE_ANALYSIS_TIMEOUT
+        when /TEST_ANALYSIS/
+          TEST_ANALYSIS_TIMEOUT
+        when /FUNCTIONALITY_ANALYSIS/
+          FUNCTIONALITY_ANALYSIS_TIMEOUT
+        when /DOCUMENTATION_ANALYSIS/
+          DOCUMENTATION_ANALYSIS_TIMEOUT
+        when /STATIC_ANALYSIS/
+          STATIC_ANALYSIS_TIMEOUT
+        when /REFACTORING_RECOMMENDATIONS/
+          REFACTORING_RECOMMENDATIONS_TIMEOUT
+        else
+          nil  # Use default
+        end
+      end
+
+      def update_metrics(supervisor, result)
+        @metrics[:total_executions] += 1
+        @metrics[:total_duration] += supervisor.duration
+        @metrics[:average_duration] = @metrics[:total_duration] / @metrics[:total_executions]
+
+        case result[:state]
+        when :completed
+          @metrics[:successful_executions] += 1
+        when :timeout
+          @metrics[:timeout_count] += 1
+        when :failed, :killed
+          @metrics[:failure_count] += 1
+        end
+
+        # Log metrics update if in job context
+        if @job_context
+          @job_context[:job_manager].log_message(
+            @job_context[:job_id],
+            @job_context[:execution_id],
+            "Updated execution metrics",
+            "debug",
+            @metrics
+          )
+        end
+      end
+
+      def handle_execution_failure(result, supervisor)
+        case result[:reason]
+        when "user_aborted"
+          message = "#{provider_name} was aborted by user after #{format_duration(result[:duration])}"
+          log_error(message)
+          raise Interrupt, message
+        when "non_zero_exit"
+          error_msg = result[:error_output].empty? ? "Unknown error" : result[:error_output].strip
+          message = "#{provider_name} failed with exit code #{result[:exit_code]}: #{error_msg}"
+          log_error(message)
+          raise message
+        else
+          message = "#{provider_name} failed: #{result[:reason] || "Unknown error"}"
+          log_error(message)
+          raise message
+        end
+      end
+
+      def format_duration(seconds)
+        minutes = (seconds / 60).to_i
+        secs = (seconds % 60).to_i
+
+        if minutes > 0
+          "#{minutes}m #{secs}s"
+        else
+          "#{secs}s"
+        end
+      end
+
+      def log_info(message)
+        if @job_context
+          @job_context[:job_manager].log_message(
+            @job_context[:job_id],
+            @job_context[:execution_id],
+            message,
+            "info"
+          )
+        else
+          puts message
+        end
+      end
+
+      def log_warning(message)
+        if @job_context
+          @job_context[:job_manager].log_message(
+            @job_context[:job_id],
+            @job_context[:execution_id],
+            message,
+            "warning"
+          )
+        else
+          puts "⚠️  #{message}"
+        end
+      end
+
+      def log_error(message)
+        if @job_context
+          @job_context[:job_manager].log_message(
+            @job_context[:job_id],
+            @job_context[:execution_id],
+            message,
+            "error"
+          )
+        else
+          puts "❌ #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/aidp/providers/supervised_cursor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "supervised_base"
+require_relative "../util"
+
+module Aidp
+  module Providers
+    class SupervisedCursor < SupervisedBase
+      def self.available?
+        !!Aidp::Util.which("cursor-agent")
+      end
+
+      def provider_name
+        "cursor"
+      end
+
+      def command
+        ["cursor-agent", "-p"]
+      end
+    end
+  end
+end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.3.0"
+  VERSION = "0.7.0"
 end

data/lib/aidp.rb

@@ -1,53 +1,50 @@
 # frozen_string_literal: true
 
+# Core extensions
+require "aidp/core_ext/class_attribute"
+
 # Shared modules
 require "aidp/version"
 require "aidp/config"
 require "aidp/workspace"
 require "aidp/util"
 require "aidp/cli"
+require "aidp/cli/jobs_command"
 require "aidp/project_detector"
 require "aidp/sync"
+
+# Database
+require "aidp/database_connection"
+
+# Job infrastructure
+require "aidp/job_manager"
+require "aidp/jobs/base_job"
+require "aidp/jobs/provider_execution_job"
+
+# Providers
 require "aidp/providers/base"
 require "aidp/providers/cursor"
 require "aidp/providers/anthropic"
 require "aidp/providers/gemini"
 require "aidp/providers/macos_ui"
+require "aidp/provider_manager"
 
-# Execute mode modules
-require "aidp/execute/steps"
-require "aidp/execute/runner"
-require "aidp/execute/progress"
-
-# Analyze mode modules
-require "aidp/analyze/steps"
+# Analyze mode
+require "aidp/analyze/error_handler"
+require "aidp/analyze/parallel_processor"
+require "aidp/analyze/repository_chunker"
+require "aidp/analyze/ruby_maat_integration"
 require "aidp/analyze/runner"
+require "aidp/analyze/steps"
 require "aidp/analyze/progress"
-require "aidp/analyze/dependencies"
-require "aidp/analyze/storage"
-require "aidp/analyze/prioritizer"
-require "aidp/analyze/database"
-require "aidp/analyze/ruby_maat_integration"
-require "aidp/analyze/feature_analyzer"
-require "aidp/analyze/focus_guidance"
-require "aidp/analyze/agent_personas"
-require "aidp/analyze/agent_tool_executor"
-require "aidp/analyze/static_analysis_detector"
-require "aidp/analyze/tool_configuration"
-require "aidp/analyze/tool_modernization"
-require "aidp/analyze/language_analysis_strategies"
-require "aidp/analyze/report_generator"
-require "aidp/analyze/export_manager"
-require "aidp/analyze/incremental_analyzer"
-require "aidp/analyze/progress_visualizer"
-require "aidp/analyze/data_retention_manager"
-require "aidp/analyze/repository_chunker"
-require "aidp/analyze/parallel_processor"
-require "aidp/analyze/memory_manager"
-require "aidp/analyze/large_analysis_progress"
-require "aidp/analyze/performance_optimizer"
-require "aidp/analyze/error_handler"
 
-module Aidp
-  class Error < StandardError; end
-end
+# Tree-sitter analysis
+require "aidp/analysis/tree_sitter_grammar_loader"
+require "aidp/analysis/seams"
+require "aidp/analysis/tree_sitter_scan"
+require "aidp/analysis/kb_inspector"
+
+# Execute mode
+require "aidp/execute/steps"
+require "aidp/execute/runner"
+require "aidp/execute/progress"

data/templates/ANALYZE/01_REPOSITORY_ANALYSIS.md

@@ -13,7 +13,7 @@ You are a **Repository Analyst**, an expert in version control analysis and code
 
 ## Analysis Objectives
 
-1. **Repository Mining**: Use Code Maat to analyze repository activity
+1. **Repository Mining**: Use ruby-maat gem to analyze repository activity
 2. **Churn Analysis**: Identify high-activity areas that may indicate technical debt
 3. **Coupling Analysis**: Understand dependencies between modules/components
 4. **Authorship Patterns**: Analyze code ownership and knowledge distribution
@@ -21,10 +21,10 @@ You are a **Repository Analyst**, an expert in version control analysis and code
 
 ## Required Analysis Steps
 
-### 1. Code Maat Integration
+### 1. Ruby Maat Integration
 
-- Check if Docker is available for Code Maat analysis
-- Run Code Maat analysis for the repository
+- Use the ruby-maat gem for repository analysis (no Docker required)
+- Run ruby-maat analysis for the repository
 - Parse and interpret the results
 
 ### 2. Repository Activity Analysis

data/templates/ANALYZE/06a_tree_sitter_scan.md

@@ -0,0 +1,217 @@
+# Tree-sitter Static Analysis Template
+
+You are a **Tree-sitter Static Analysis Expert**, specializing in advanced static code analysis using Tree-sitter parsers. Your role is to analyze the codebase using Tree-sitter-powered static analysis, build a comprehensive knowledge base, and provide insights based on Michael Feathers' "Working Effectively with Legacy Code" strategies.
+
+## Your Expertise
+
+- Tree-sitter parser technology and AST analysis
+- Static code analysis and metrics calculation
+- Legacy code refactoring strategies (Feathers' techniques)
+- Seam detection and dependency analysis
+- Code complexity and hotspot identification
+- Test coverage analysis and characterization test recommendations
+
+## Analysis Objectives
+
+1. **Knowledge Base Construction**: Build a comprehensive machine-readable knowledge base of the codebase structure
+2. **Seam Detection**: Identify integration points and dependency injection opportunities using Feathers' strategies
+3. **Hotspot Analysis**: Identify high-change, high-complexity areas that need attention
+4. **Dependency Mapping**: Map import/require relationships and detect cycles
+5. **Test Gap Analysis**: Identify untested public APIs and recommend characterization tests
+6. **Refactoring Opportunities**: Provide specific, actionable refactoring recommendations
+
+## Required Analysis Steps
+
+### 1. Tree-sitter Knowledge Base Generation
+
+Run the Tree-sitter analysis to generate the knowledge base:
+
+```bash
+aidp analyze code --langs ruby,js,ts,py --threads 4
+```
+
+This will generate the following KB files in `.aidp/kb/`:
+
+- `symbols.json` - Classes, modules, methods with metadata
+- `imports.json` - Require/import statements and dependencies
+- `calls.json` - Method call relationships
+- `metrics.json` - Complexity and size metrics
+- `seams.json` - Integration points and dependency injection opportunities
+- `hotspots.json` - High-change, high-complexity areas
+- `tests.json` - Test coverage mapping
+- `cycles.json` - Import/dependency cycles
+
+### 2. Seam Analysis and Feathers' Strategy Application
+
+Analyze the seams data to identify refactoring opportunities:
+
+#### I/O Integration Seams
+
+- **File Operations**: `File.*`, `IO.*`, `Dir.*` calls
+- **Network Operations**: `Net::HTTP.*`, `Socket.*` calls
+- **System Operations**: `Kernel.system`, `Process.*` calls
+- **Database Operations**: `ActiveRecord.*`, `Sequel.*` calls
+
+**Feathers' Recommendations**:
+
+- Extract I/O operations to separate service classes
+- Use dependency injection for external dependencies
+- Create adapter interfaces for external services
+
+#### Global State and Singleton Seams
+
+- **Global Variables**: `$var`, `@@var` usage
+- **Singleton Patterns**: `include Singleton`, `extend Singleton`
+- **Module-level State**: Mutable state in modules
+
+**Feathers' Recommendations**:
+
+- Replace singletons with dependency injection
+- Encapsulate global state in configuration objects
+- Use constructor injection for dependencies
+
+#### Constructor with Work Seams
+
+- **Complex Initialization**: Constructors with significant logic
+- **External Dependencies**: I/O or service calls in constructors
+- **High Complexity**: Constructors with multiple branches
+
+**Feathers' Recommendations**:
+
+- Extract initialization logic to factory methods
+- Use builder pattern for complex object creation
+- Separate construction from initialization
+
+### 3. Hotspot Analysis and Prioritization
+
+Analyze the hotspots data to prioritize refactoring efforts:
+
+#### Hotspot Scoring
+
+- **Change Frequency**: Number of times files have been modified
+- **Complexity**: Cyclomatic complexity and nesting depth
+- **Size**: Lines of code and method count
+- **Dependencies**: Fan-in and fan-out metrics
+
+#### Top 20 Hotspots Analysis
+
+For each hotspot, provide:
+
+- **Rationale**: Why this area is a hotspot
+- **Risk Assessment**: Potential impact of changes
+- **Refactoring Strategy**: Specific Feathers' techniques to apply
+- **Test Strategy**: Characterization test recommendations
+
+### 4. Dependency Cycle Detection
+
+Analyze import cycles and provide breaking strategies:
+
+#### Cycle Types
+
+- **Import Cycles**: Circular require/import dependencies
+- **Call Cycles**: Circular method call dependencies
+- **Inheritance Cycles**: Circular class inheritance
+
+#### Breaking Strategies
+
+- **Dependency Inversion**: Extract interfaces and invert dependencies
+- **Event-Driven Architecture**: Use events to decouple components
+- **Facade Pattern**: Create facades to break direct dependencies
+
+### 5. Test Coverage Analysis
+
+Analyze untested public APIs and recommend characterization tests:
+
+#### Characterization Test Strategy
+
+- **Public API Mapping**: Identify all public methods and classes
+- **Test Coverage**: Map existing tests to public APIs
+- **Gap Analysis**: Identify untested public APIs
+- **Test Recommendations**: Suggest specific characterization tests
+
+#### Test Implementation Guidelines
+
+- **Golden Master Tests**: Capture current behavior before refactoring
+- **Parameterized Tests**: Test with various inputs
+- **Integration Tests**: Test with real dependencies
+- **Mock Tests**: Test with controlled dependencies
+
+## Output Requirements
+
+### 1. Knowledge Base Summary
+
+- Total files analyzed
+- Symbol counts by type (classes, modules, methods)
+- Import/dependency statistics
+- Complexity metrics summary
+
+### 2. Seam Analysis Report
+
+- **I/O Integration Seams**: List with file locations and refactoring suggestions
+- **Global State Seams**: List with specific global usage and encapsulation strategies
+- **Constructor Work Seams**: List with complexity metrics and extraction recommendations
+
+### 3. Hotspot Analysis Report
+
+- **Top 20 Hotspots**: Ranked list with scores and rationale
+- **Refactoring Priorities**: Recommended order for addressing hotspots
+- **Risk Assessment**: Impact analysis for each hotspot
+
+### 4. Dependency Analysis Report
+
+- **Import Graph**: Visualization of file dependencies
+- **Cycle Detection**: List of detected cycles with breaking strategies
+- **Coupling Analysis**: High-coupling areas and decoupling recommendations
+
+### 5. Test Strategy Report
+
+- **Untested APIs**: List of public APIs without tests
+- **Characterization Test Plan**: Specific test recommendations
+- **Test Implementation Guide**: Step-by-step test creation process
+
+### 6. Refactoring Roadmap
+
+- **Phase 1**: Address highest-priority seams and hotspots
+- **Phase 2**: Break dependency cycles
+- **Phase 3**: Implement characterization tests
+- **Phase 4**: Apply systematic refactoring techniques
+
+## Technical Implementation Notes
+
+### Tree-sitter Integration
+
+- Use `aidp analyze code` command to generate KB
+- Leverage `aidp kb show` commands for data inspection
+- Generate graphs with `aidp kb graph` for visualization
+
+### Feathers' Techniques Application
+
+- **Sprout Method**: Extract small methods from large ones
+- **Sprout Class**: Extract new classes for specific responsibilities
+- **Extract Interface**: Create interfaces for dependency injection
+- **Move Method**: Move methods to appropriate classes
+- **Extract Method**: Break down large methods
+
+### Quality Metrics
+
+- **Cyclomatic Complexity**: Target < 10 per method
+- **Lines of Code**: Target < 20 per method
+- **Fan-out**: Target < 7 per method
+- **Nesting Depth**: Target < 4 levels
+
+## Success Criteria
+
+1. **Complete KB Generation**: All source files parsed and analyzed
+2. **Seam Identification**: All integration points identified with specific recommendations
+3. **Hotspot Prioritization**: Top 20 hotspots identified with actionable strategies
+4. **Cycle Detection**: All dependency cycles identified with breaking strategies
+5. **Test Gap Analysis**: All untested public APIs identified with test recommendations
+6. **Refactoring Roadmap**: Prioritized, actionable refactoring plan provided
+
+## Deliverables
+
+1. **Knowledge Base Files**: Complete `.aidp/kb/` directory with all JSON files
+2. **Analysis Report**: Comprehensive markdown report with all findings
+3. **Visualization Files**: Graph files for dependency visualization
+4. **Refactoring Plan**: Detailed, prioritized refactoring roadmap
+5. **Test Strategy**: Specific characterization test recommendations