aidp 0.10.0 → 0.11.0

data/lib/aidp/providers/opencode.rb

@@ -18,6 +18,10 @@ module Aidp
         "opencode"
       end
 
+      def display_name
+        "OpenCode"
+      end
+
       def send(prompt:, session: nil)
         raise "opencode not available" unless self.class.available?
 
@@ -27,6 +31,12 @@ module Aidp
         debug_provider("opencode", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to opencode (length: #{prompt.length})", level: :info)
 
+        # Check if streaming mode is enabled
+        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
+        if streaming_enabled
+          display_message("📺 Display streaming enabled - output buffering reduced (opencode does not support true streaming)", type: :info)
+        end
+
         # 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)
@@ -36,6 +46,10 @@ module Aidp
         setup_activity_monitoring("opencode", method(:activity_callback))
         record_activity("Starting opencode execution")
 
+        # Create a spinner for activity display
+        spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
+        spinner.auto_spin
+
         # Start activity display thread with timeout
         activity_display_thread = Thread.new do
           start_time = Time.now
@@ -46,7 +60,7 @@ module Aidp
             # 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)
+            update_spinner_status(spinner, elapsed, "🔄 opencode")
           end
         end
 
@@ -54,54 +68,33 @@ module Aidp
           # 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)
+          result = debug_execute_command("opencode", args: ["run", "-m", model, prompt], timeout: timeout_seconds, streaming: streaming_enabled)
 
           # 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
+            spinner.success("✓")
             mark_completed
             result.out
           else
+            spinner.error("✗")
             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
+          spinner&.error("✗")
           mark_failed("opencode execution failed: #{e.message}")
           debug_error(e, {provider: "opencode", prompt_length: prompt.length})
           raise
+        ensure
+          cleanup_activity_display(activity_display_thread, spinner)
         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
-      end
-
-      def clear_activity_status
-        # Clear the activity status line
-        print "\r" + " " * 50 + "\r"
-      end
-
       def calculate_timeout
         # Priority order for timeout calculation:
         # 1. Quick mode (for testing)
@@ -110,8 +103,8 @@ module Aidp
         # 4. Default timeout
 
         if ENV["AIDP_QUICK_MODE"]
-          display_message("⚡ Quick mode enabled - 2 minute timeout", type: :highlight)
-          return 120
+          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
+          return TIMEOUT_QUICK_MODE
         end
 
         if ENV["AIDP_OPENCODE_TIMEOUT"]
@@ -125,9 +118,9 @@ module Aidp
           return step_timeout
         end
 
-        # Default timeout (5 minutes for interactive use)
-        display_message("📋 Using default timeout: 5 minutes", type: :info)
-        300
+        # Default timeout
+        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
+        TIMEOUT_DEFAULT
       end
 
       def get_adaptive_timeout
@@ -136,21 +129,21 @@ module Aidp
 
         case step_name
         when /REPOSITORY_ANALYSIS/
-          180  # 3 minutes - repository analysis can be quick
+          TIMEOUT_REPOSITORY_ANALYSIS
         when /ARCHITECTURE_ANALYSIS/
-          600  # 10 minutes - architecture analysis needs more time
+          TIMEOUT_ARCHITECTURE_ANALYSIS
         when /TEST_ANALYSIS/
-          300  # 5 minutes - test analysis is moderate
+          TIMEOUT_TEST_ANALYSIS
         when /FUNCTIONALITY_ANALYSIS/
-          600  # 10 minutes - functionality analysis is complex
+          TIMEOUT_FUNCTIONALITY_ANALYSIS
         when /DOCUMENTATION_ANALYSIS/
-          300  # 5 minutes - documentation analysis is moderate
+          TIMEOUT_DOCUMENTATION_ANALYSIS
         when /STATIC_ANALYSIS/
-          450  # 7.5 minutes - static analysis can be intensive
+          TIMEOUT_STATIC_ANALYSIS
         when /REFACTORING_RECOMMENDATIONS/
-          600  # 10 minutes - refactoring recommendations are complex
+          TIMEOUT_REFACTORING_RECOMMENDATIONS
         else
-          nil  # Use default
+          nil # Use default
         end
       end
 

data/lib/aidp/version.rb

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

data/lib/aidp/workflows/definitions.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Workflows
+    # Centralized workflow definitions for both Analyze and Execute modes
+    # Provides pre-configured workflows at various levels of depth/complexity
+    module Definitions
+      # Analyze mode workflows - from surface-level to deep analysis
+      ANALYZE_WORKFLOWS = {
+        quick_overview: {
+          name: "Quick Overview",
+          description: "Surface-level understanding - What does this project do?",
+          icon: "🔍",
+          details: [
+            "Repository structure scan",
+            "High-level functionality mapping",
+            "Quick documentation review"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "04_FUNCTIONALITY_ANALYSIS",
+            "05_DOCUMENTATION_ANALYSIS"
+          ]
+        },
+
+        style_guide: {
+          name: "Style & Patterns",
+          description: "Identify coding patterns and create style guide",
+          icon: "📐",
+          details: [
+            "Code pattern analysis",
+            "Style consistency review",
+            "Generate project style guide"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN"
+          ]
+        },
+
+        architecture_review: {
+          name: "Architecture Review",
+          description: "Understand system architecture and dependencies",
+          icon: "🏗️",
+          details: [
+            "Architecture pattern analysis",
+            "Dependency mapping",
+            "Component relationships",
+            "Design principles review"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "02_ARCHITECTURE_ANALYSIS",
+            "06A_TREE_SITTER_SCAN"
+          ]
+        },
+
+        quality_assessment: {
+          name: "Quality Assessment",
+          description: "Comprehensive code quality and test coverage analysis",
+          icon: "✅",
+          details: [
+            "Test coverage analysis",
+            "Code quality metrics",
+            "Static analysis review",
+            "Refactoring opportunities"
+          ],
+          steps: [
+            "03_TEST_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "07_REFACTORING_RECOMMENDATIONS"
+          ]
+        },
+
+        deep_analysis: {
+          name: "Deep Analysis",
+          description: "Complete analysis for extension/refactoring",
+          icon: "🔬",
+          details: [
+            "Full repository analysis",
+            "Architecture deep dive",
+            "Complete test coverage analysis",
+            "Functionality mapping",
+            "Documentation review",
+            "Static analysis",
+            "Tree-sitter knowledge base",
+            "Refactoring recommendations"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "02_ARCHITECTURE_ANALYSIS",
+            "03_TEST_ANALYSIS",
+            "04_FUNCTIONALITY_ANALYSIS",
+            "05_DOCUMENTATION_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "07_REFACTORING_RECOMMENDATIONS"
+          ]
+        },
+
+        custom: {
+          name: "Custom Analysis",
+          description: "Choose specific analysis steps",
+          icon: "⚙️",
+          details: ["Select exactly which analysis steps you need"],
+          steps: :custom # Will be populated by user selection
+        }
+      }.freeze
+
+      # Execute mode workflows - from quick prototype to enterprise-grade
+      EXECUTE_WORKFLOWS = {
+        quick_prototype: {
+          name: "Quick Prototype",
+          description: "Rapid prototype - minimal planning, fast iteration",
+          icon: "⚡",
+          details: [
+            "Minimal PRD",
+            "Basic testing strategy",
+            "Direct to implementation"
+          ],
+          steps: [
+            "00_PRD",
+            "10_TESTING_STRATEGY",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        exploration: {
+          name: "Exploration/Experiment",
+          description: "Proof of concept with basic quality checks",
+          icon: "🔬",
+          details: [
+            "Quick PRD generation",
+            "Testing strategy",
+            "Static analysis setup",
+            "Implementation with work loops"
+          ],
+          steps: [
+            "00_PRD",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        feature_development: {
+          name: "Feature Development",
+          description: "Standard feature with architecture and testing",
+          icon: "🚀",
+          details: [
+            "Product requirements",
+            "Architecture design",
+            "Testing strategy",
+            "Static analysis",
+            "Implementation"
+          ],
+          steps: [
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        production_ready: {
+          name: "Production-Ready",
+          description: "Enterprise-grade with NFRs and compliance",
+          icon: "🏗️",
+          details: [
+            "Comprehensive PRD",
+            "Non-functional requirements",
+            "System architecture",
+            "Security review",
+            "Performance planning",
+            "Testing strategy",
+            "Observability & SLOs",
+            "Delivery planning",
+            "Implementation"
+          ],
+          steps: [
+            "00_PRD",
+            "01_NFRS",
+            "02_ARCHITECTURE",
+            "07_SECURITY_REVIEW",
+            "08_PERFORMANCE_REVIEW",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "12_OBSERVABILITY_SLOS",
+            "13_DELIVERY_ROLLOUT",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        full_enterprise: {
+          name: "Full Enterprise",
+          description: "Complete enterprise workflow with all governance",
+          icon: "🏢",
+          details: [
+            "All planning documents",
+            "Architecture decision records",
+            "Domain decomposition",
+            "API design",
+            "Security & performance reviews",
+            "Reliability planning",
+            "Complete observability",
+            "Documentation portal"
+          ],
+          steps: [
+            "00_PRD",
+            "01_NFRS",
+            "02_ARCHITECTURE",
+            "03_ADR_FACTORY",
+            "04_DOMAIN_DECOMPOSITION",
+            "05_API_DESIGN",
+            "07_SECURITY_REVIEW",
+            "08_PERFORMANCE_REVIEW",
+            "09_RELIABILITY_REVIEW",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "12_OBSERVABILITY_SLOS",
+            "13_DELIVERY_ROLLOUT",
+            "14_DOCS_PORTAL",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        custom: {
+          name: "Custom Workflow",
+          description: "Choose specific planning and implementation steps",
+          icon: "⚙️",
+          details: ["Select exactly which steps you need"],
+          steps: :custom # Will be populated by user selection
+        }
+      }.freeze
+
+      # Hybrid workflows - mix of analyze and execute steps
+      HYBRID_WORKFLOWS = {
+        legacy_modernization: {
+          name: "Legacy Modernization",
+          description: "Analyze existing code then plan modernization",
+          icon: "♻️",
+          details: [
+            "Deep code analysis",
+            "Refactoring recommendations",
+            "Architecture design for new system",
+            "Migration planning",
+            "Implementation"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "02_ARCHITECTURE_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "07_REFACTORING_RECOMMENDATIONS",
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        style_guide_enforcement: {
+          name: "Style Guide Enforcement",
+          description: "Extract patterns then enforce them",
+          icon: "📏",
+          details: [
+            "Analyze existing patterns",
+            "Generate LLM style guide",
+            "Configure static analysis",
+            "Implement enforcement"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "00_LLM_STYLE_GUIDE",
+            "11_STATIC_ANALYSIS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        test_coverage_improvement: {
+          name: "Test Coverage Improvement",
+          description: "Analyze gaps then implement comprehensive tests",
+          icon: "🧪",
+          details: [
+            "Test coverage analysis",
+            "Functionality mapping",
+            "Testing strategy design",
+            "Test implementation"
+          ],
+          steps: [
+            "03_TEST_ANALYSIS",
+            "04_FUNCTIONALITY_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "10_TESTING_STRATEGY",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        custom_hybrid: {
+          name: "Custom Hybrid",
+          description: "Mix analyze and execute steps",
+          icon: "🔀",
+          details: ["Choose from both analyze and execute steps"],
+          steps: :custom # Will be populated by user selection
+        }
+      }.freeze
+
+      # Get all available steps for custom selection
+      def self.all_available_steps
+        analyze_steps = Aidp::Analyze::Steps::SPEC.keys.map do |step|
+          {
+            step: step,
+            mode: :analyze,
+            description: Aidp::Analyze::Steps::SPEC[step]["description"]
+          }
+        end
+
+        execute_steps = Aidp::Execute::Steps::SPEC.keys.map do |step|
+          {
+            step: step,
+            mode: :execute,
+            description: Aidp::Execute::Steps::SPEC[step]["description"]
+          }
+        end
+
+        (analyze_steps + execute_steps).sort_by { |s| s[:step] }
+      end
+
+      # Get workflow definition by key
+      def self.get_workflow(mode, workflow_key)
+        case mode
+        when :analyze
+          ANALYZE_WORKFLOWS[workflow_key]
+        when :execute
+          EXECUTE_WORKFLOWS[workflow_key]
+        when :hybrid
+          HYBRID_WORKFLOWS[workflow_key]
+        end
+      end
+
+      # Get all workflows for a mode
+      def self.workflows_for_mode(mode)
+        case mode
+        when :analyze
+          ANALYZE_WORKFLOWS
+        when :execute
+          EXECUTE_WORKFLOWS
+        when :hybrid
+          HYBRID_WORKFLOWS
+        end
+      end
+    end
+  end
+end

data/lib/aidp/workflows/selector.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "definitions"
+require_relative "../message_display"
+
+module Aidp
+  module Workflows
+    # Enhanced workflow selector with support for custom workflows
+    # Handles selection for analyze, execute, and hybrid modes
+    class Selector
+      include Aidp::MessageDisplay
+
+      def initialize(prompt: TTY::Prompt.new)
+        @prompt = prompt
+      end
+
+      # Select mode (analyze, execute, or hybrid)
+      def select_mode
+        display_message("\n🚀 Welcome to AI Dev Pipeline!", type: :highlight)
+        display_message("Choose your mode:\n", type: :highlight)
+
+        choices = {
+          "🔬 Analyze Mode" => :analyze,
+          "🏗️  Execute Mode" => :execute,
+          "🔀 Hybrid Mode" => :hybrid
+        }
+
+        @prompt.select("What would you like to do?", choices, per_page: 10)
+      end
+
+      # Select workflow for the given mode
+      def select_workflow(mode)
+        workflows = Definitions.workflows_for_mode(mode)
+
+        display_message("\n#{mode_header(mode)}", type: :highlight)
+        display_message("Choose a workflow:\n")
+
+        # Build choices with icons and descriptions
+        choices = workflows.map do |key, workflow|
+          {
+            name: "#{workflow[:icon]} #{workflow[:name]} - #{workflow[:description]}",
+            value: key
+          }
+        end
+
+        selected = @prompt.select(
+          "Select workflow:",
+          choices,
+          per_page: 15,
+          help: "(↑/↓ to navigate, Enter to select)"
+        )
+
+        workflow = workflows[selected]
+
+        # Show workflow details
+        display_workflow_details(workflow)
+
+        # Handle custom workflows
+        if workflow[:steps] == :custom
+          steps = select_custom_steps(mode)
+          {workflow_key: selected, steps: steps, workflow: workflow}
+        else
+          {workflow_key: selected, steps: workflow[:steps], workflow: workflow}
+        end
+      end
+
+      # Select custom steps for hybrid or custom workflows
+      def select_custom_steps(mode)
+        display_message("\n⚙️ Custom Step Selection", type: :highlight)
+        display_message("")
+
+        if mode == :hybrid
+          select_hybrid_steps
+        elsif mode == :analyze
+          select_steps_from_mode(:analyze)
+        elsif mode == :execute
+          select_steps_from_mode(:execute)
+        end
+      end
+
+      private
+
+      def mode_header(mode)
+        case mode
+        when :analyze
+          "🔬 Analyze Mode - Understand Your Codebase"
+        when :execute
+          "🏗️ Execute Mode - Build New Features"
+        when :hybrid
+          "🔀 Hybrid Mode - Analyze Then Execute"
+        end
+      end
+
+      def display_workflow_details(workflow)
+        display_message("\n#{workflow[:icon]} #{workflow[:name]}", type: :highlight)
+        display_message("─" * 60, type: :muted)
+        display_message("")
+        display_message("Description: #{workflow[:description]}")
+        display_message("")
+        display_message("Includes:", type: :highlight)
+        workflow[:details].each do |detail|
+          display_message("  • #{detail}", type: :info)
+        end
+        display_message("")
+      end
+
+      def select_steps_from_mode(mode)
+        spec = (mode == :analyze) ? Aidp::Analyze::Steps::SPEC : Aidp::Execute::Steps::SPEC
+
+        display_message("Available #{mode} steps:")
+        display_message("")
+
+        # Build step choices
+        step_choices = spec.map do |step_key, step_spec|
+          {
+            name: "#{step_key} - #{step_spec["description"]}",
+            value: step_key,
+            disabled: step_spec["gate"] ? "(requires manual review)" : false
+          }
+        end
+
+        selected_steps = @prompt.multi_select(
+          "Select steps (Space to select, Enter when done):",
+          step_choices,
+          per_page: 20,
+          help: "Select one or more steps"
+        )
+
+        if selected_steps.empty?
+          display_message("⚠️  No steps selected, using default workflow", type: :warning)
+          # Return a sensible default
+          (mode == :analyze) ? ["01_REPOSITORY_ANALYSIS"] : ["00_PRD", "16_IMPLEMENTATION"]
+        else
+          selected_steps.sort
+        end
+      end
+
+      def select_hybrid_steps
+        display_message("You can mix analyze and execute steps for a custom hybrid workflow.")
+        display_message("")
+
+        all_steps = Definitions.all_available_steps
+
+        # Group steps by mode for display
+        step_choices = all_steps.map do |step_info|
+          mode_tag = (step_info[:mode] == :analyze) ? "[ANALYZE]" : "[EXECUTE]"
+          {
+            name: "#{mode_tag} #{step_info[:step]} - #{step_info[:description]}",
+            value: step_info[:step]
+          }
+        end
+
+        selected_steps = @prompt.multi_select(
+          "Select steps (Space to select, Enter when done):",
+          step_choices,
+          per_page: 25,
+          help: "Mix analyze and execute steps as needed"
+        )
+
+        if selected_steps.empty?
+          display_message("⚠️  No steps selected, using default hybrid workflow", type: :warning)
+          # Return a sensible default hybrid
+          ["01_REPOSITORY_ANALYSIS", "00_PRD", "16_IMPLEMENTATION"]
+        else
+          selected_steps.sort
+        end
+      end
+    end
+  end
+end