aidp 0.34.1 → 0.39.3

data/lib/aidp/shell_executor.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Aidp
+  # Shell command executor wrapper for testability
+  #
+  # Provides two modes of execution:
+  # 1. `run(command)` - Captures output silently via backticks
+  # 2. `system(*args)` - Wraps Kernel.system() with optional output suppression
+  #
+  # In tests, set `ShellExecutor.suppress_output = true` to suppress all
+  # system() output without changing any production code behavior.
+  #
+  # @example Production usage
+  #   executor = Aidp::ShellExecutor.new
+  #   executor.system("git", "fetch", "origin")  # Output shown normally
+  #
+  # @example Test setup (in spec_helper.rb)
+  #   Aidp::ShellExecutor.suppress_output = true
+  #
+  class ShellExecutor
+    class << self
+      # When true, system() calls will have output redirected to /dev/null
+      # Default: false (output shown normally)
+      attr_accessor :suppress_output
+    end
+    self.suppress_output = false
+
+    # Run a command and capture its output
+    #
+    # @param command [String] The shell command to run
+    # @return [String] The command's stdout output
+    def run(command)
+      `#{command}`
+    end
+
+    # Check if the last command succeeded
+    #
+    # @return [Boolean] true if last command exited with status 0
+    def success?
+      $?.success?
+    end
+
+    # Run a command via system(), optionally suppressing output
+    #
+    # When suppress_output is true, output is redirected to /dev/null
+    # unless explicit out:/err: options are provided.
+    #
+    # @param args [Array] Arguments passed to Kernel.system
+    # @param opts [Hash] Options passed to Kernel.system
+    # @return [Boolean, nil] Same as Kernel.system
+    def system(*args, **opts)
+      if self.class.suppress_output && !opts.key?(:out) && !opts.key?(:err)
+        opts = opts.merge(out: File::NULL, err: File::NULL)
+      end
+      Kernel.system(*args, **opts)
+    end
+  end
+end

data/lib/aidp/style_guide/selector.rb

@@ -152,13 +152,35 @@ module Aidp
 
       # Check if a provider needs style guide injection
       #
+      # Providers with instruction files (CLAUDE.md, .github/copilot-instructions.md, etc.)
+      # don't need style guide injected as they have their own instruction mechanism.
+      #
       # @param provider_name [String] Name of the provider
       # @return [Boolean] true if style guide should be injected
       def provider_needs_style_guide?(provider_name)
         return true if provider_name.nil?
 
         normalized = provider_name.to_s.downcase.strip
-        !PROVIDERS_WITH_INSTRUCTION_FILES.include?(normalized)
+
+        # Check legacy constant first for backwards compatibility
+        return false if PROVIDERS_WITH_INSTRUCTION_FILES.include?(normalized)
+
+        # Dynamically check if provider has instruction files
+        !provider_has_instruction_files?(normalized)
+      end
+
+      # Check if a provider class defines instruction file paths
+      #
+      # @param provider_name [String] Name of the provider
+      # @return [Boolean] true if provider has instruction files defined
+      def provider_has_instruction_files?(provider_name)
+        provider_class = find_provider_class(provider_name)
+        return false unless provider_class
+
+        instruction_paths = provider_class.instruction_file_paths
+        instruction_paths.is_a?(Array) && instruction_paths.any?
+      rescue NoMethodError
+        false
       end
 
       # Select relevant sections from STYLE_GUIDE.md based on keywords
@@ -355,6 +377,39 @@ module Aidp
 
         patterns.uniq
       end
+
+      # Find provider class by name
+      #
+      # @param provider_name [String] Name of the provider
+      # @return [Class, nil] The provider class or nil if not found
+      def find_provider_class(provider_name)
+        # Map common provider names to class names
+        class_name = case provider_name.to_s.downcase
+        when "anthropic", "claude"
+          "Anthropic"
+        when "github_copilot", "copilot"
+          "GithubCopilot"
+        when "cursor"
+          "Cursor"
+        when "gemini"
+          "Gemini"
+        when "aider"
+          "Aider"
+        when "kilocode"
+          "Kilocode"
+        when "opencode"
+          "Opencode"
+        when "codex"
+          "Codex"
+        else
+          # Try to find by capitalizing the name
+          provider_name.to_s.split("_").map(&:capitalize).join
+        end
+
+        AgentHarness::Providers.const_get(class_name)
+      rescue NameError
+        nil
+      end
     end
   end
 end

data/lib/aidp/temporal/activities/analyze_issue_activity.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that analyzes a GitHub issue
+      # Extracts requirements, acceptance criteria, and context
+      class AnalyzeIssueActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            issue_number = input[:issue_number]
+            issue_url = input[:issue_url]
+
+            # Validate issue_number is numeric
+            unless issue_number.to_s.match?(/\A\d+\z/)
+              return error_result("Invalid issue number: must be numeric")
+            end
+
+            log_activity("analyzing_issue",
+              project_dir: project_dir,
+              issue_number: issue_number)
+
+            # Fetch issue details
+            issue_data = fetch_issue(project_dir, issue_number, issue_url)
+
+            unless issue_data
+              return error_result("Failed to fetch issue ##{issue_number}")
+            end
+
+            heartbeat(phase: "analysis", issue_number: issue_number)
+
+            # Extract structured information
+            analysis = analyze_issue_content(project_dir, issue_data)
+
+            success_result(
+              result: analysis,
+              issue_number: issue_number,
+              issue_title: issue_data[:title]
+            )
+          end
+        end
+
+        private
+
+        def fetch_issue(project_dir, issue_number, issue_url)
+          # Check if gh CLI is available
+          _stdout, _stderr, status = Open3.capture3("which", "gh")
+          if status.success?
+            fetch_with_gh_cli(issue_number)
+          elsif issue_url
+            fetch_with_url(issue_url)
+          end
+        rescue => e
+          Aidp.log_error("analyze_issue_activity", "fetch_failed",
+            issue_number: issue_number,
+            error: e.message)
+          nil
+        end
+
+        def fetch_with_gh_cli(issue_number)
+          # issue_number is validated as numeric in execute()
+          stdout, _stderr, status = Open3.capture3(
+            "gh", "issue", "view", issue_number.to_s,
+            "--json", "title,body,labels,comments"
+          )
+          return nil unless status.success?
+
+          data = JSON.parse(stdout, symbolize_names: true)
+          {
+            number: issue_number,
+            title: data[:title],
+            body: data[:body],
+            labels: data[:labels]&.map { |l| l[:name] } || [],
+            comments: data[:comments]&.map { |c| c[:body] } || []
+          }
+        end
+
+        def fetch_with_url(issue_url)
+          # Parse issue URL to extract owner/repo/number
+          # This regex is safe - no backtracking issues
+          match = issue_url.match(%r{\Ahttps?://github\.com/([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)/issues/(\d+)})
+          return nil unless match
+
+          owner, repo, number = match.captures
+
+          # Validate extracted values
+          return nil unless owner.match?(/\A[A-Za-z0-9_.-]+\z/)
+          return nil unless repo.match?(/\A[A-Za-z0-9_.-]+\z/)
+          return nil unless number.match?(/\A\d+\z/)
+
+          # Use array-style Open3 to avoid shell injection
+          stdout, _stderr, status = Open3.capture3(
+            "gh", "issue", "view", number,
+            "--repo", "#{owner}/#{repo}",
+            "--json", "title,body,labels,comments"
+          )
+          return nil unless status.success?
+
+          data = JSON.parse(stdout, symbolize_names: true)
+          {
+            number: number.to_i,
+            title: data[:title],
+            body: data[:body],
+            labels: data[:labels]&.map { |l| l[:name] } || [],
+            comments: data[:comments]&.map { |c| c[:body] } || []
+          }
+        end
+
+        def analyze_issue_content(project_dir, issue_data)
+          # Build analysis structure
+          {
+            issue_number: issue_data[:number],
+            title: issue_data[:title],
+            description: issue_data[:body],
+            labels: issue_data[:labels],
+            comments: issue_data[:comments],
+            requirements: extract_requirements(issue_data),
+            acceptance_criteria: extract_acceptance_criteria(issue_data),
+            affected_areas: identify_affected_areas(project_dir, issue_data)
+          }
+        end
+
+        def extract_requirements(issue_data)
+          body = issue_data[:body] || ""
+          comments = issue_data[:comments] || []
+
+          # Simple extraction - look for requirement patterns
+          requirements = []
+
+          # From body - process line by line to avoid ReDoS
+          extract_list_items(body, requirements)
+
+          # From comments with context
+          comments.each do |comment|
+            extract_list_items(comment, requirements)
+          end
+
+          requirements.uniq.first(20)
+        end
+
+        def extract_list_items(text, items)
+          text.each_line do |line|
+            # Match lines starting with - or *
+            if line.match?(/\A\s{0,50}[-*]/)
+              content = line.sub(/\A\s{0,50}[-*]\s{0,50}/, "").strip
+              items << content if content.length > 10
+            end
+          end
+        end
+
+        def extract_acceptance_criteria(issue_data)
+          body = issue_data[:body] || ""
+
+          # Look for acceptance criteria section
+          criteria = []
+
+          if body.downcase.include?("acceptance criteria")
+            section = body.split(/acceptance criteria/i).last
+            section = section.split("\n##").first if section.include?("\n##")
+
+            # Process line by line to avoid ReDoS
+            section.each_line do |line|
+              # Match lines starting with -, *, or numbers
+              if line.match?(/\A\s{0,50}[-*\d.]/)
+                content = line.sub(/\A\s{0,50}[-*\d.]+\s{0,50}/, "").strip
+                criteria << content if content.length > 5
+              end
+            end
+          end
+
+          criteria.first(10)
+        end
+
+        def identify_affected_areas(project_dir, issue_data)
+          title = issue_data[:title] || ""
+          body = issue_data[:body] || ""
+          combined = "#{title}\n#{body}".downcase
+
+          areas = []
+
+          # Common area patterns
+          areas << "tests" if combined.include?("test") || combined.include?("spec")
+          areas << "documentation" if combined.include?("doc") || combined.include?("readme")
+          areas << "configuration" if combined.include?("config") || combined.include?("setting")
+          areas << "api" if combined.include?("api") || combined.include?("endpoint")
+          areas << "ui" if combined.include?("ui") || combined.include?("interface") || combined.include?("display")
+          areas << "database" if combined.include?("database") || combined.include?("migration") || combined.include?("schema")
+
+          areas.uniq
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/activities/analyze_sub_task_activity.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that analyzes a sub-task for decomposition
+      # Determines complexity and identifies further sub-tasks if needed
+      class AnalyzeSubTaskActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            sub_issue_id = input[:sub_issue_id]
+            task_description = input[:task_description]
+            context = input[:context] || {}
+
+            log_activity("analyzing_sub_task",
+              project_dir: project_dir,
+              sub_issue_id: sub_issue_id)
+
+            # Analyze complexity
+            analysis = analyze_task_complexity(
+              project_dir: project_dir,
+              task_description: task_description,
+              context: context
+            )
+
+            success_result(
+              result: analysis,
+              sub_issue_id: sub_issue_id
+            )
+          end
+        end
+
+        private
+
+        def analyze_task_complexity(project_dir:, task_description:, context:)
+          # Estimate complexity based on description
+          estimated_iterations = estimate_iterations(task_description)
+
+          # Identify potential sub-tasks
+          sub_tasks = identify_sub_tasks(task_description)
+
+          # Identify affected files
+          affected_files = identify_affected_files(project_dir, task_description)
+
+          {
+            task_description: task_description,
+            estimated_iterations: estimated_iterations,
+            complexity: complexity_level(estimated_iterations),
+            sub_tasks: sub_tasks,
+            affected_files: affected_files,
+            decomposition_recommended: sub_tasks.length >= 3 || estimated_iterations > 20
+          }
+        end
+
+        def estimate_iterations(description)
+          return 1 unless description
+
+          # Simple heuristics based on description length and keywords
+          base = 2
+
+          # Longer descriptions usually mean more work
+          base += (description.length / 200).clamp(0, 5)
+
+          # Keywords that suggest complexity
+          complexity_keywords = %w[refactor migrate multiple all entire complete comprehensive]
+          base += complexity_keywords.count { |kw| description.downcase.include?(kw) }
+
+          base.clamp(1, 30)
+        end
+
+        def complexity_level(iterations)
+          case iterations
+          when 1..3 then :simple
+          when 4..10 then :moderate
+          when 11..20 then :complex
+          else :very_complex
+          end
+        end
+
+        def identify_sub_tasks(description)
+          return [] unless description
+
+          sub_tasks = []
+
+          # Look for numbered lists - process line by line to avoid ReDoS
+          description.each_line do |line|
+            if line.match?(/\A\d+[.)]/)
+              # Extract content after the number marker
+              content = line.sub(/\A\d+[.)]\s{0,50}/, "").strip
+              next if content.empty?
+
+              sub_tasks << {
+                description: content,
+                estimated_iterations: estimate_iterations(content)
+              }
+            end
+          end
+
+          # Look for bullet points if no numbered items found
+          if sub_tasks.empty?
+            description.each_line do |line|
+              if line.match?(/\A[-*]/)
+                content = line.sub(/\A[-*]\s{0,50}/, "").strip
+                next if content.length < 10
+
+                sub_tasks << {
+                  description: content,
+                  estimated_iterations: estimate_iterations(content)
+                }
+              end
+            end
+          end
+
+          # Limit to reasonable number
+          sub_tasks.first(10)
+        end
+
+        def identify_affected_files(project_dir, description)
+          return [] unless description
+
+          affected = []
+
+          # Look for file paths in description - use word boundaries to avoid ReDoS
+          # Match patterns like "lib/foo/bar.rb" with limited path depth
+          file_extensions = %w[rb py js ts jsx tsx go rs]
+          file_extensions.each do |ext|
+            # Use a simpler pattern that matches word characters and slashes, limited depth
+            description.scan(/\b(\w[\w\/]{0,100}\.#{ext})\b/).flatten.each do |file_path|
+              next unless file_path.include?("/") || file_path.match?(/^\w+\.#{ext}$/)
+
+              full_path = File.join(project_dir, file_path)
+              affected << file_path if File.exist?(full_path)
+            end
+          end
+
+          # Look for common patterns
+          patterns = {
+            "test" => "spec/**/*_spec.rb",
+            "spec" => "spec/**/*_spec.rb",
+            "config" => "config/**/*.yml",
+            "migration" => "db/migrate/*.rb",
+            "api" => "lib/**/api*.rb",
+            "cli" => "lib/**/cli*.rb"
+          }
+
+          patterns.each do |keyword, pattern|
+            if description.downcase.include?(keyword)
+              Dir.glob(File.join(project_dir, pattern)).each do |file|
+                relative = file.sub("#{project_dir}/", "")
+                affected << relative
+              end
+            end
+          end
+
+          affected.uniq.first(20)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/activities/base_activity.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "temporalio/activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Base class for AIDP Temporal activities
+      # Provides common patterns and utilities for activity implementations
+      class BaseActivity < Temporalio::Activity::Definition
+        # Activity context (set by Temporal)
+        def activity_context
+          Temporalio::Activity.context
+        end
+
+        # Send heartbeat to indicate activity is still running
+        def heartbeat(*details)
+          Temporalio::Activity.heartbeat(*details)
+        end
+
+        # Check if cancellation was requested
+        def cancellation_requested?
+          Temporalio::Activity.cancellation_requested?
+        end
+
+        # Raise if cancellation was requested
+        def check_cancellation!
+          raise Temporalio::Error::CanceledError, "Activity canceled" if cancellation_requested?
+        end
+
+        protected
+
+        # Log within activity context
+        def log_activity(action, **context)
+          info = activity_context&.info
+          Aidp.log_debug("temporal_activity", action,
+            activity_type: self.class.name.split("::").last,
+            task_token: info&.task_token&.slice(0, 8),
+            **context)
+        end
+
+        # Wrap activity execution with standard error handling
+        def with_activity_context
+          log_activity("started")
+
+          result = yield
+
+          log_activity("completed", success: true)
+          result
+        rescue => e
+          log_activity("failed", error: e.message, error_class: e.class.name)
+          raise
+        end
+
+        # Load AIDP configuration for project
+        def load_config(project_dir)
+          Aidp::Config.load_harness_config(project_dir)
+        end
+
+        # Create a provider manager for the project
+        def create_provider_manager(project_dir, config)
+          require_relative "../../harness/provider_manager"
+          Aidp::Harness::ProviderManager.new(project_dir, config)
+        end
+
+        # Build success result
+        def success_result(data = {})
+          {success: true}.merge(data)
+        end
+
+        # Build error result
+        def error_result(message, data = {})
+          {success: false, error: message}.merge(data)
+        end
+      end
+    end
+  end
+end

data/lib/aidp/temporal/activities/create_plan_activity.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that creates an implementation plan from issue analysis
+      # Generates step-by-step plan with dependencies
+      class CreatePlanActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            issue_number = input[:issue_number]
+            analysis = input[:analysis]
+
+            log_activity("creating_plan",
+              project_dir: project_dir,
+              issue_number: issue_number)
+
+            # Generate implementation plan
+            plan = generate_plan(project_dir, analysis)
+
+            # Write plan to .aidp directory
+            write_plan(project_dir, issue_number, plan)
+
+            heartbeat(phase: "plan_complete", issue_number: issue_number)
+
+            success_result(
+              result: plan,
+              issue_number: issue_number,
+              step_count: plan[:steps]&.length || 0
+            )
+          end
+        end
+
+        private
+
+        def generate_plan(project_dir, analysis)
+          requirements = analysis[:requirements] || []
+          acceptance_criteria = analysis[:acceptance_criteria] || []
+          affected_areas = analysis[:affected_areas] || []
+
+          steps = []
+
+          # Step 1: Setup/preparation
+          steps << {
+            name: "setup",
+            description: "Review existing code and understand context",
+            type: :preparation,
+            estimated_iterations: 1
+          }
+
+          # Generate implementation steps from requirements
+          requirements.each_with_index do |req, idx|
+            steps << {
+              name: "implement_#{idx + 1}",
+              description: "Implement: #{req}",
+              type: :implementation,
+              estimated_iterations: 2
+            }
+          end
+
+          # Add testing step
+          if affected_areas.include?("tests")
+            steps << {
+              name: "add_tests",
+              description: "Add or update tests for new functionality",
+              type: :testing,
+              estimated_iterations: 2
+            }
+          end
+
+          # Add documentation step
+          if affected_areas.include?("documentation")
+            steps << {
+              name: "update_docs",
+              description: "Update documentation",
+              type: :documentation,
+              estimated_iterations: 1
+            }
+          end
+
+          # Final validation step
+          steps << {
+            name: "validate",
+            description: "Run full test suite and validate all changes",
+            type: :validation,
+            estimated_iterations: 1
+          }
+
+          {
+            issue_number: analysis[:issue_number],
+            title: analysis[:title],
+            steps: steps,
+            requirements: requirements,
+            acceptance_criteria: acceptance_criteria,
+            estimated_total_iterations: steps.sum { |s| s[:estimated_iterations] },
+            created_at: Time.now.iso8601
+          }
+        end
+
+        def write_plan(project_dir, issue_number, plan)
+          plan_dir = File.join(project_dir, ".aidp", "plans")
+          FileUtils.mkdir_p(plan_dir)
+
+          plan_file = File.join(plan_dir, "issue_#{issue_number}_plan.yml")
+          File.write(plan_file, plan.to_yaml)
+
+          log_activity("plan_written", file: plan_file)
+        end
+      end
+    end
+  end
+end