aidp 0.34.0 → 0.39.3

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that creates a pull request from implemented changes
+      # Handles git operations and GitHub PR creation
+      class CreatePrActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            issue_number = input[:issue_number]
+            implementation = input[:implementation]
+            iterations = input[:iterations]
+
+            # Validate issue_number is numeric to prevent injection
+            unless issue_number.to_s.match?(/\A\d+\z/)
+              return error_result("Invalid issue number: must be numeric")
+            end
+
+            log_activity("creating_pr",
+              project_dir: project_dir,
+              issue_number: issue_number)
+
+            # Ensure we have commits to push
+            unless has_uncommitted_changes?(project_dir) || has_unpushed_commits?(project_dir)
+              return error_result("No changes to create PR from")
+            end
+
+            # Create branch if needed
+            branch_name = ensure_branch(project_dir, issue_number)
+
+            heartbeat(phase: "branch_created", branch: branch_name)
+
+            # Commit any uncommitted changes
+            if has_uncommitted_changes?(project_dir)
+              commit_changes(project_dir, issue_number, iterations)
+            end
+
+            heartbeat(phase: "changes_committed")
+
+            # Push branch
+            push_branch(project_dir, branch_name)
+
+            heartbeat(phase: "branch_pushed")
+
+            # Create PR
+            pr_result = create_pull_request(
+              project_dir: project_dir,
+              branch_name: branch_name,
+              issue_number: issue_number,
+              implementation: implementation,
+              iterations: iterations
+            )
+
+            if pr_result[:success]
+              success_result(
+                pr_url: pr_result[:pr_url],
+                pr_number: pr_result[:pr_number],
+                branch: branch_name
+              )
+            else
+              error_result(pr_result[:error] || "Failed to create PR")
+            end
+          end
+        end
+
+        private
+
+        def has_uncommitted_changes?(project_dir)
+          stdout, _stderr, status = Open3.capture3("git", "status", "--porcelain", chdir: project_dir)
+          status.success? && !stdout.strip.empty?
+        end
+
+        def has_unpushed_commits?(project_dir)
+          stdout, _stderr, status = Open3.capture3(
+            "git", "rev-list", "--count", "@{upstream}..HEAD",
+            chdir: project_dir
+          )
+          status.success? && stdout.strip.to_i > 0
+        rescue
+          false
+        end
+
+        def ensure_branch(project_dir, issue_number)
+          # issue_number is validated as numeric in execute()
+          branch_name = "aidp/issue-#{issue_number}"
+
+          stdout, _stderr, _status = Open3.capture3("git", "branch", "--show-current", chdir: project_dir)
+          current_branch = stdout.strip
+
+          if current_branch != branch_name
+            # Check if branch exists using array-style system call
+            ref_path = "refs/heads/#{branch_name}"
+            _stdout, _stderr, status = Open3.capture3(
+              "git", "show-ref", "--verify", "--quiet", ref_path,
+              chdir: project_dir
+            )
+
+            if status.success?
+              Open3.capture3("git", "checkout", branch_name, chdir: project_dir)
+            else
+              Open3.capture3("git", "checkout", "-b", branch_name, chdir: project_dir)
+            end
+          end
+
+          branch_name
+        end
+
+        def commit_changes(project_dir, issue_number, iterations)
+          # Stage all changes
+          Open3.capture3("git", "add", "-A", chdir: project_dir)
+
+          # Build commit message (issue_number validated as numeric)
+          commit_message = build_commit_message(issue_number, iterations)
+
+          # Use array-style to avoid shell injection
+          Open3.capture3("git", "commit", "-m", commit_message, chdir: project_dir)
+        end
+
+        def build_commit_message(issue_number, iterations)
+          # issue_number is validated as numeric, iterations is an integer
+          safe_iterations = iterations.to_i
+
+          "fix: implement changes for issue ##{issue_number}\n\n" \
+            "Implemented via AIDP Temporal workflow\n" \
+            "Iterations: #{safe_iterations}\n\n" \
+            "Closes ##{issue_number}"
+        end
+
+        def push_branch(project_dir, branch_name)
+          # branch_name is constructed from validated issue_number
+          Open3.capture3("git", "push", "-u", "origin", branch_name, chdir: project_dir)
+        end
+
+        def create_pull_request(project_dir:, branch_name:, issue_number:, implementation:, iterations:)
+          # issue_number is validated as numeric
+          title = "Fix ##{issue_number}"
+          body = build_pr_body(issue_number, implementation, iterations)
+
+          # Use array-style Open3 to avoid shell injection
+          stdout, stderr, status = Open3.capture3(
+            "gh", "pr", "create", "--title", title, "--body", body,
+            chdir: project_dir
+          )
+
+          if status.success?
+            # Extract PR URL from output
+            pr_url = stdout.strip
+            pr_number = pr_url.split("/").last.to_i
+
+            {
+              success: true,
+              pr_url: pr_url,
+              pr_number: pr_number
+            }
+          else
+            {
+              success: false,
+              error: stderr.empty? ? stdout : stderr
+            }
+          end
+        end
+
+        def build_pr_body(issue_number, implementation, iterations)
+          # issue_number validated as numeric, iterations is integer
+          safe_iterations = iterations.to_i
+
+          <<~BODY
+            ## Summary
+
+            Implements changes requested in ##{issue_number}
+
+            ## Implementation Details
+
+            This PR was created via AIDP Temporal workflow after #{safe_iterations} iterations of the fix-forward work loop.
+
+            ## Testing
+
+            - [ ] All tests pass
+            - [ ] Lint checks pass
+            - [ ] Manual testing completed
+
+            Closes ##{issue_number}
+          BODY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that creates the initial PROMPT.md for a work loop
+      # Assembles context, instructions, and constraints
+      class CreatePromptActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            step_name = input[:step_name]
+            step_spec = input[:step_spec] || {}
+            context = input[:context] || {}
+
+            log_activity("creating_prompt",
+              project_dir: project_dir,
+              step_name: step_name)
+
+            # Load configuration
+            config = load_config(project_dir)
+
+            # Create prompt manager
+            prompt_manager = Aidp::Execute::PromptManager.new(project_dir, config: config)
+
+            # Build initial prompt content
+            prompt_content = build_prompt_content(
+              project_dir: project_dir,
+              step_name: step_name,
+              step_spec: step_spec,
+              context: context
+            )
+
+            # Write the prompt
+            prompt_manager.write(prompt_content)
+
+            heartbeat(phase: "prompt_created", step_name: step_name)
+
+            success_result(
+              prompt_path: prompt_manager.prompt_path,
+              prompt_length: prompt_content.length,
+              step_name: step_name
+            )
+          end
+        end
+
+        private
+
+        def build_prompt_content(project_dir:, step_name:, step_spec:, context:)
+          sections = []
+
+          # Header
+          sections << "# Implementation Task: #{step_name}"
+          sections << ""
+          sections << "Generated at: #{Time.now.iso8601}"
+          sections << ""
+
+          # Step specification
+          if step_spec[:description]
+            sections << "## Objective"
+            sections << ""
+            sections << step_spec[:description]
+            sections << ""
+          end
+
+          # Context from previous steps
+          if context[:previous_output]
+            sections << "## Context from Previous Steps"
+            sections << ""
+            sections << context[:previous_output]
+            sections << ""
+          end
+
+          # Requirements
+          if context[:requirements]&.any?
+            sections << "## Requirements"
+            sections << ""
+            context[:requirements].each do |req|
+              sections << "- #{req}"
+            end
+            sections << ""
+          end
+
+          # Constraints
+          sections << "## Constraints"
+          sections << ""
+          sections << "- Follow the existing code style and patterns"
+          sections << "- Make minimal changes to achieve the objective"
+          sections << "- Ensure all tests pass after changes"
+          sections << "- Do not introduce new dependencies without justification"
+          sections << ""
+
+          # Style guide reference
+          style_guide_path = File.join(project_dir, "docs", "LLM_STYLE_GUIDE.md")
+          if File.exist?(style_guide_path)
+            sections << "## Style Guide"
+            sections << ""
+            sections << "Please follow the guidelines in `docs/LLM_STYLE_GUIDE.md`"
+            sections << ""
+          end
+
+          # Instructions
+          sections << "## Instructions"
+          sections << ""
+          sections << "1. Review the existing codebase to understand context"
+          sections << "2. Implement the changes described in the objective"
+          sections << "3. Ensure all tests pass"
+          sections << "4. Signal completion when done"
+          sections << ""
+
+          sections.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that analyzes test/lint failures and prepares feedback
+      # Extracts actionable information from failure output
+      class DiagnoseFailureActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            iteration = input[:iteration]
+            test_result = input[:test_result]
+
+            log_activity("diagnosing_failure",
+              project_dir: project_dir,
+              iteration: iteration)
+
+            # Analyze failure results
+            diagnosis = analyze_failures(test_result)
+
+            # Update PROMPT.md with failure information
+            update_prompt_with_diagnosis(project_dir, diagnosis)
+
+            success_result(
+              diagnosis: diagnosis,
+              iteration: iteration,
+              failure_count: diagnosis[:failure_count]
+            )
+          end
+        end
+
+        private
+
+        def analyze_failures(test_result)
+          results = test_result[:results] || {}
+          failures = []
+          failure_count = 0
+
+          results.each do |phase, result|
+            next if result[:success]
+
+            phase_failures = extract_failures(phase, result)
+            failures.concat(phase_failures)
+            failure_count += phase_failures.length
+          end
+
+          {
+            failure_count: failure_count,
+            failures: failures,
+            summary: build_failure_summary(failures),
+            recommendations: generate_recommendations(failures)
+          }
+        end
+
+        def extract_failures(phase, result)
+          output = result[:output] || ""
+          failures = []
+
+          case phase.to_sym
+          when :test
+            # Extract test failure details - process line by line to avoid ReDoS
+            extract_test_failures(output, failures, phase)
+          when :lint
+            # Extract lint errors - line by line processing
+            extract_lint_failures(output, failures, phase)
+          when :typecheck
+            # Extract type errors - line by line processing
+            extract_typecheck_failures(output, failures, phase)
+          else
+            # Generic failure extraction
+            failures << {
+              type: :unknown,
+              phase: phase,
+              message: output.slice(0, 500)
+            }
+          end
+
+          failures.first(20) # Limit to prevent massive payloads
+        end
+
+        def extract_test_failures(output, failures, phase)
+          # Process output in chunks separated by blank lines
+          current_failure = nil
+
+          output.each_line do |line|
+            if line.match?(/\A\s*(FAIL|ERROR|Failure)/i)
+              # Save previous failure if exists
+              if current_failure
+                failures << {
+                  type: :test,
+                  phase: phase,
+                  message: current_failure.strip.slice(0, 500)
+                }
+              end
+              current_failure = line
+            elsif current_failure
+              if line.strip.empty?
+                # End of failure block
+                failures << {
+                  type: :test,
+                  phase: phase,
+                  message: current_failure.strip.slice(0, 500)
+                }
+                current_failure = nil
+              else
+                # Continue accumulating failure message
+                current_failure += line
+              end
+            end
+          end
+
+          # Don't forget the last failure
+          if current_failure
+            failures << {
+              type: :test,
+              phase: phase,
+              message: current_failure.strip.slice(0, 500)
+            }
+          end
+        end
+
+        def extract_lint_failures(output, failures, phase)
+          # Match lint output format: file:line:col: message
+          output.each_line do |line|
+            if line.match?(/\A[^:]+:\d+:\d+:/)
+              failures << {
+                type: :lint,
+                phase: phase,
+                message: line.strip
+              }
+            end
+          end
+        end
+
+        def extract_typecheck_failures(output, failures, phase)
+          # Match lines containing "error" (case insensitive)
+          output.each_line do |line|
+            if line.downcase.include?("error")
+              failures << {
+                type: :typecheck,
+                phase: phase,
+                message: line.strip
+              }
+            end
+          end
+        end
+
+        def build_failure_summary(failures)
+          return "No failures found" if failures.empty?
+
+          by_type = failures.group_by { |f| f[:type] }
+          parts = by_type.map { |type, items| "#{items.length} #{type} failure(s)" }
+          parts.join(", ")
+        end
+
+        def generate_recommendations(failures)
+          recommendations = []
+
+          if failures.any? { |f| f[:type] == :test }
+            recommendations << "Review failing test assertions and update implementation"
+          end
+
+          if failures.any? { |f| f[:type] == :lint }
+            recommendations << "Fix code style issues to match project standards"
+          end
+
+          if failures.any? { |f| f[:type] == :typecheck }
+            recommendations << "Fix type errors to ensure type safety"
+          end
+
+          recommendations
+        end
+
+        def update_prompt_with_diagnosis(project_dir, diagnosis)
+          prompt_manager = Aidp::Execute::PromptManager.new(project_dir)
+          current_prompt = prompt_manager.read
+
+          return unless current_prompt
+
+          # Build failure section
+          failure_section = build_failure_section(diagnosis)
+
+          # Append to prompt
+          updated_prompt = <<~PROMPT
+            #{current_prompt}
+
+            ---
+            ## Test/Lint Failures (Fix These)
+
+            #{failure_section}
+
+            Please address the above failures in this iteration.
+          PROMPT
+
+          prompt_manager.write(updated_prompt)
+        end
+
+        def build_failure_section(diagnosis)
+          sections = []
+
+          sections << "**Summary:** #{diagnosis[:summary]}"
+          sections << ""
+
+          diagnosis[:failures].first(10).each_with_index do |failure, idx|
+            sections << "### Failure #{idx + 1} (#{failure[:type]})"
+            sections << ""
+            sections << "```"
+            sections << failure[:message]
+            sections << "```"
+            sections << ""
+          end
+
+          if diagnosis[:recommendations].any?
+            sections << "### Recommendations"
+            diagnosis[:recommendations].each do |rec|
+              sections << "- #{rec}"
+            end
+          end
+
+          sections.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "base_activity"
+
+module Aidp
+  module Temporal
+    module Activities
+      # Activity that prepares for the next work loop iteration
+      # Updates PROMPT.md with relevant context for continued work
+      class PrepareNextIterationActivity < BaseActivity
+        def execute(input)
+          with_activity_context do
+            project_dir = input[:project_dir]
+            iteration = input[:iteration]
+            test_result = input[:test_result]
+            failures_only = input[:failures_only] || true
+
+            log_activity("preparing_next_iteration",
+              project_dir: project_dir,
+              iteration: iteration)
+
+            # Prepare context for next iteration
+            preparation = prepare_iteration_context(
+              project_dir: project_dir,
+              iteration: iteration,
+              test_result: test_result,
+              failures_only: failures_only
+            )
+
+            success_result(
+              iteration: iteration + 1,
+              preparation: preparation
+            )
+          end
+        end
+
+        private
+
+        def prepare_iteration_context(project_dir:, iteration:, test_result:, failures_only:)
+          prompt_manager = Aidp::Execute::PromptManager.new(project_dir)
+
+          # Get current prompt
+          current_prompt = prompt_manager.read || ""
+
+          # Clean up previous iteration markers
+          current_prompt = clean_iteration_markers(current_prompt)
+
+          # Add iteration context
+          iteration_header = build_iteration_header(iteration + 1, test_result)
+
+          # Build focused context based on failures_only flag
+          context_section = if failures_only
+            build_failures_context(test_result)
+          else
+            build_full_context(test_result)
+          end
+
+          # Update prompt
+          updated_prompt = <<~PROMPT
+            #{current_prompt}
+
+            #{iteration_header}
+
+            #{context_section}
+          PROMPT
+
+          prompt_manager.write(updated_prompt.strip)
+
+          {
+            prompt_updated: true,
+            next_iteration: iteration + 1,
+            context_type: failures_only ? "failures_only" : "full"
+          }
+        end
+
+        def clean_iteration_markers(prompt)
+          # Remove previous iteration headers and context
+          prompt
+            .gsub(/---\n## Iteration \d+ Context.*?(?=---\n##|\z)/m, "")
+            .gsub(/---\n## Test\/Lint Failures.*?(?=---\n##|\z)/m, "")
+            .strip
+        end
+
+        def build_iteration_header(next_iteration, test_result)
+          results = test_result[:results] || {}
+          passing = results.count { |_, r| r[:success] }
+          total = results.count
+
+          <<~HEADER
+            ---
+            ## Iteration #{next_iteration} Context
+
+            Previous iteration status: #{passing}/#{total} checks passing
+            Continuing with fix-forward pattern.
+          HEADER
+        end
+
+        def build_failures_context(test_result)
+          results = test_result[:results] || {}
+          failed = results.reject { |_, r| r[:success] }
+
+          return "All checks passing in previous iteration." if failed.empty?
+
+          sections = ["### Remaining Failures to Fix", ""]
+
+          failed.each do |phase, result|
+            sections << "#### #{phase.to_s.capitalize}"
+            sections << ""
+            sections << "```"
+            sections << truncate_output(result[:output])
+            sections << "```"
+            sections << ""
+          end
+
+          sections.join("\n")
+        end
+
+        def build_full_context(test_result)
+          results = test_result[:results] || {}
+          sections = ["### Full Test Results", ""]
+
+          results.each do |phase, result|
+            status = result[:success] ? "PASS" : "FAIL"
+            sections << "#### #{phase.to_s.capitalize}: #{status}"
+            sections << ""
+            sections << "```"
+            sections << truncate_output(result[:output])
+            sections << "```"
+            sections << ""
+          end
+
+          sections.join("\n")
+        end
+
+        def truncate_output(output, max_length: 2000)
+          return "" unless output
+
+          if output.length > max_length
+            "#{output.slice(0, max_length)}\n... (truncated)"
+          else
+            output
+          end
+        end
+      end
+    end
+  end
+end