aidp 0.27.0 → 0.28.0

data/lib/aidp/watch/ci_log_extractor.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require "json"
+
+module Aidp
+  module Watch
+    # Intelligently extracts relevant failure information from CI logs
+    # to reduce token usage when analyzing failures with AI.
+    #
+    # Instead of feeding full CI output to AI, this creates a tailored
+    # extraction script for each failure type, runs it, and provides
+    # only the relevant excerpts.
+    class CiLogExtractor
+      # Maximum size for extracted log content (in characters)
+      MAX_EXTRACTED_SIZE = 10_000
+
+      def initialize(provider_manager:)
+        @provider_manager = provider_manager
+      end
+
+      # Extract relevant failure information from a CI check
+      #
+      # @param check [Hash] Failed check information
+      # @param check_run_url [String] URL to the GitHub Actions run (optional)
+      # @return [Hash] Extracted failure info with :summary, :details, :script_used
+      def extract_failure_info(check:, check_run_url: nil)
+        Aidp.log_debug("ci_log_extractor", "extract_start",
+          check_name: check[:name],
+          has_output: !check[:output].nil?)
+
+        # If we have structured output from the check, use it
+        if check[:output] && check[:output]["summary"]
+          return extract_from_structured_output(check)
+        end
+
+        # If we have a check run URL, fetch the logs
+        if check_run_url
+          raw_logs = fetch_check_logs(check_run_url)
+          return extract_from_raw_logs(check: check, raw_logs: raw_logs) if raw_logs
+        end
+
+        # Fallback: minimal information
+        {
+          summary: "Check '#{check[:name]}' failed",
+          details: check[:output]&.dig("text") || "No additional details available",
+          extraction_method: "fallback"
+        }
+      end
+
+      private
+
+      def extract_from_structured_output(check)
+        summary = check[:output]["summary"] || ""
+        text = check[:output]["text"] || ""
+
+        # If the output is already concise, return it directly
+        full_output = "#{summary}\n\n#{text}".strip
+        if full_output.length <= MAX_EXTRACTED_SIZE
+          return {
+            summary: summary,
+            details: text,
+            extraction_method: "structured"
+          }
+        end
+
+        # Output is too large, create extraction script
+        extraction_result = create_and_run_extraction_script(
+          check_name: check[:name],
+          raw_content: full_output
+        )
+
+        {
+          summary: summary,
+          details: extraction_result[:extracted_content],
+          extraction_method: "ai_script",
+          script_used: extraction_result[:script]
+        }
+      end
+
+      def extract_from_raw_logs(check:, raw_logs:)
+        # If logs are already concise, return them
+        if raw_logs.length <= MAX_EXTRACTED_SIZE
+          return {
+            summary: "Check '#{check[:name]}' failed",
+            details: raw_logs,
+            extraction_method: "raw"
+          }
+        end
+
+        # Logs are too large, create extraction script
+        extraction_result = create_and_run_extraction_script(
+          check_name: check[:name],
+          raw_content: raw_logs
+        )
+
+        {
+          summary: "Check '#{check[:name]}' failed",
+          details: extraction_result[:extracted_content],
+          extraction_method: "ai_script",
+          script_used: extraction_result[:script]
+        }
+      end
+
+      def create_and_run_extraction_script(check_name:, raw_content:)
+        Aidp.log_debug("ci_log_extractor", "creating_script",
+          check_name: check_name,
+          content_size: raw_content.length)
+
+        # Ask AI to create an extraction script
+        script = generate_extraction_script(
+          check_name: check_name,
+          sample_content: truncate_sample(raw_content)
+        )
+
+        # Run the script
+        extracted = run_extraction_script(script: script, input: raw_content)
+
+        {
+          extracted_content: extracted,
+          script: script
+        }
+      rescue => e
+        Aidp.log_warn("ci_log_extractor", "script_execution_failed",
+          error: e.message,
+          check_name: check_name)
+
+        # Fallback: simple head/tail extraction
+        {
+          extracted_content: simple_extract(raw_content),
+          script: nil
+        }
+      end
+
+      def generate_extraction_script(check_name:, sample_content:)
+        prompt = <<~PROMPT
+          Create a shell script that extracts relevant failure information from CI logs.
+
+          The script should:
+          1. Read from STDIN
+          2. Extract ONLY the relevant error messages, failed tests, and stack traces
+          3. Omit verbose output, successful tests, and build information
+          4. Keep the extracted output under #{MAX_EXTRACTED_SIZE} characters
+          5. Output the extracted content to STDOUT
+
+          Check type: #{check_name}
+
+          Sample of the log content (first ~2000 chars):
+          ```
+          #{sample_content}
+          ```
+
+          Requirements:
+          - Use standard Unix tools (grep, awk, sed, head, tail)
+          - Handle multi-line error messages
+          - Focus on actionable error information
+          - If it's a test failure, extract test names and failure messages
+          - If it's a linting error, extract file names, line numbers, and violations
+
+          Respond ONLY with the shell script code, no explanation.
+          The script must be a valid bash script that reads STDIN.
+
+          Example format:
+          #!/bin/bash
+          grep -A 5 "FAILED" | head -n 100
+        PROMPT
+
+        response = @provider_manager.send_message(prompt: prompt)
+        extract_script_from_response(response.to_s)
+      end
+
+      def extract_script_from_response(response)
+        # Remove markdown code fences if present
+        script = response.strip
+        script = script.gsub(/^```(?:bash|sh)?\n/, "")
+        script = script.gsub(/\n```$/, "")
+
+        # Ensure it starts with shebang
+        unless script.start_with?("#!/")
+          script = "#!/bin/bash\n#{script}"
+        end
+
+        script
+      end
+
+      def run_extraction_script(script:, input:)
+        Tempfile.create(["ci_extract", ".sh"]) do |script_file|
+          script_file.write(script)
+          script_file.flush
+          script_file.chmod(0o755)
+
+          stdout, stderr, status = Open3.capture3(
+            "bash", script_file.path,
+            stdin_data: input,
+            chdir: Dir.tmpdir
+          )
+
+          unless status.success?
+            Aidp.log_warn("ci_log_extractor", "script_failed",
+              exit_code: status.exitstatus,
+              stderr: stderr[0, 500])
+            return simple_extract(input)
+          end
+
+          # Ensure output is within size limit
+          truncate_to_size(stdout)
+        end
+      end
+
+      def fetch_check_logs(check_run_url)
+        # TODO: Implement fetching logs from GitHub Actions
+        # This would require parsing the check run URL and using gh CLI or API
+        # For now, return nil to use structured output
+        nil
+      end
+
+      def truncate_sample(content, size: 2000)
+        return content if content.length <= size
+        "#{content[0, size]}\n... [truncated]"
+      end
+
+      def simple_extract(content)
+        # Simple fallback: extract lines containing error keywords
+        lines = content.lines
+        error_lines = lines.select do |line|
+          line.match?(/error|fail|exception|assert/i)
+        end
+
+        # If we found error lines, return them with context
+        if error_lines.any?
+          # Get line numbers of errors and include surrounding context
+          result = []
+          lines.each_with_index do |line, i|
+            if line.match?(/error|fail|exception|assert/i)
+              # Include 2 lines before and 3 lines after
+              start_idx = [0, i - 2].max
+              end_idx = [lines.length - 1, i + 3].min
+              result.concat(lines[start_idx..end_idx])
+            end
+          end
+
+          truncate_to_size(result.uniq.join)
+        else
+          # No clear errors, return head and tail
+          head = lines.first(50).join
+          tail = lines.last(50).join
+          truncate_to_size("=== First 50 lines ===\n#{head}\n\n=== Last 50 lines ===\n#{tail}")
+        end
+      end
+
+      def truncate_to_size(content, size: MAX_EXTRACTED_SIZE)
+        return content if content.length <= size
+        "#{content[0, size - 20]}\n... [truncated]"
+      end
+    end
+  end
+end

data/lib/aidp/watch/github_state_extractor.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Aidp
+  module Watch
+    # Extracts state information from GitHub issues/PRs using labels and comments
+    # as the single source of truth, enabling multiple AIDP instances to coordinate
+    # without local state files.
+    class GitHubStateExtractor
+      # Pattern for detecting completion comments
+      COMPLETION_PATTERN = /✅ Implementation complete for #(\d+)/i
+
+      # Pattern for detecting detection comments
+      DETECTION_PATTERN = /aidp detected `([^`]+)` at ([^\n]+) and is working on it/i
+
+      # Pattern for detecting plan proposal comments
+      PLAN_PROPOSAL_PATTERN = /<!-- PLAN_SUMMARY_START -->/i
+
+      # Pattern for detecting in-progress label
+      IN_PROGRESS_LABEL = "aidp-in-progress"
+
+      def initialize(repository_client:)
+        @repository_client = repository_client
+      end
+
+      # Check if an issue/PR is currently being worked on by another instance
+      def in_progress?(item)
+        has_label?(item, IN_PROGRESS_LABEL)
+      end
+
+      # Check if build is already completed for an issue
+      # Looks for completion comment from AIDP
+      def build_completed?(issue)
+        return false unless issue[:comments]
+
+        issue[:comments].any? do |comment|
+          comment["body"]&.match?(COMPLETION_PATTERN)
+        end
+      end
+
+      # Check if a plan has been posted for an issue
+      def plan_posted?(issue)
+        return false unless issue[:comments]
+
+        issue[:comments].any? do |comment|
+          comment["body"]&.match?(PLAN_PROPOSAL_PATTERN)
+        end
+      end
+
+      # Extract the most recent plan data from comments
+      def extract_plan_data(issue)
+        return nil unless issue[:comments]
+
+        # Find the most recent plan proposal comment
+        plan_comment = issue[:comments].reverse.find do |comment|
+          comment["body"]&.match?(PLAN_PROPOSAL_PATTERN)
+        end
+
+        return nil unless plan_comment
+
+        body = plan_comment["body"]
+
+        {
+          summary: extract_section(body, "PLAN_SUMMARY"),
+          tasks: extract_tasks(body),
+          questions: extract_questions(body),
+          comment_body: body,
+          comment_hint: "## 🤖 AIDP Plan Proposal",
+          comment_id: plan_comment["id"],
+          posted_at: plan_comment["createdAt"] || Time.now.utc.iso8601
+        }
+      end
+
+      # Check if detection comment was already posted for this label
+      def detection_comment_posted?(item, label)
+        return false unless item[:comments]
+
+        item[:comments].any? do |comment|
+          next unless comment["body"]
+
+          match = comment["body"].match(DETECTION_PATTERN)
+          match && match[1] == label
+        end
+      end
+
+      # Check if review has been completed for a PR
+      def review_completed?(pr)
+        return false unless pr[:comments]
+
+        pr[:comments].any? do |comment|
+          comment["body"]&.match?(/🔍.*Review complete/i)
+        end
+      end
+
+      # Check if CI fix has been completed for a PR
+      def ci_fix_completed?(pr)
+        return false unless pr[:comments]
+
+        pr[:comments].any? do |comment|
+          body = comment["body"]
+          next false unless body
+
+          body.include?("✅") && (
+            body.match?(/CI fixes applied/i) ||
+            (body.match?(/CI check/i) && body.match?(/passed/i))
+          )
+        end
+      end
+
+      # Check if change request has been processed for a PR
+      def change_request_processed?(pr)
+        return false unless pr[:comments]
+
+        pr[:comments].any? do |comment|
+          body = comment["body"]
+          next false unless body
+
+          body.include?("✅") && body.match?(/Change requests? (?:addressed|applied|complete)/i)
+        end
+      end
+
+      # Extract linked issue number from PR description
+      # Looks for patterns like "Fixes #123", "Closes #456", "Resolves #789"
+      # Returns the issue number as an integer, or nil if not found
+      def extract_linked_issue(pr_body)
+        return nil unless pr_body
+
+        # Match common GitHub issue linking patterns
+        # https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+        match = pr_body.match(/(?:Fixes|Closes|Resolves|Close|Fix|Resolve)\s+#(\d+)/i)
+        match ? match[1].to_i : nil
+      end
+
+      private
+
+      def has_label?(item, label_name)
+        Array(item[:labels]).any? do |label|
+          name = label.is_a?(Hash) ? label["name"] : label.to_s
+          name.casecmp?(label_name)
+        end
+      end
+
+      def extract_section(body, section_name)
+        start_marker = "<!-- #{section_name}_START -->"
+        end_marker = "<!-- #{section_name}_END -->"
+
+        start_idx = body.index(start_marker)
+        end_idx = body.index(end_marker)
+
+        return nil unless start_idx && end_idx
+
+        content = body[(start_idx + start_marker.length)...end_idx]
+
+        # Remove markdown heading if present (e.g., "## Heading\n" or "### Heading\n")
+        # Strip lines starting with ## or ### to avoid ReDoS
+        content.lines.reject { |line| line.start_with?("##", "###") }.join.strip
+      end
+
+      def extract_tasks(body)
+        tasks_section = extract_section(body, "PLAN_TASKS")
+        return [] unless tasks_section
+
+        # Extract markdown list items (- followed by space and content)
+        tasks_section.scan(/^- (.+)$/).flatten
+      end
+
+      def extract_questions(body)
+        questions_section = extract_section(body, "CLARIFYING_QUESTIONS")
+        return [] unless questions_section
+
+        # Extract numbered list items (number, dot, space, content)
+        questions_section.scan(/^\d+\. (.+)$/).flatten
+      end
+    end
+  end
+end