aidp 0.26.0 → 0.28.0

data/lib/aidp/watch/implementation_verifier.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../harness/ai_decision_engine"
+require_relative "../message_display"
+
+module Aidp
+  module Watch
+    # Verifies that implementation fully addresses issue requirements using ZFC
+    # before allowing PR creation in watch mode build workflow
+    class ImplementationVerifier
+      include Aidp::MessageDisplay
+
+      def initialize(repository_client:, project_dir:, ai_decision_engine: nil)
+        @repository_client = repository_client
+        @project_dir = project_dir
+        @ai_decision_engine = ai_decision_engine || build_default_ai_decision_engine
+      end
+
+      # Verify implementation against issue requirements
+      # Returns: { verified: true/false, reason: String, missing_items: Array }
+      def verify(issue:, working_dir:)
+        Aidp.log_debug("implementation_verifier", "starting_verification", issue: issue[:number], working_dir: working_dir)
+
+        display_message("🔍 Verifying implementation completeness...", type: :info)
+
+        # Gather verification inputs
+        issue_requirements = extract_issue_requirements(issue)
+        implementation_changes = extract_implementation_changes(working_dir)
+
+        # Use ZFC to verify completeness
+        result = perform_zfc_verification(
+          issue_number: issue[:number],
+          issue_requirements: issue_requirements,
+          implementation_changes: implementation_changes
+        )
+
+        Aidp.log_info(
+          "implementation_verifier",
+          "verification_complete",
+          issue: issue[:number],
+          verified: result[:verified],
+          reason: result[:reason]
+        )
+
+        result
+      end
+
+      private
+
+      def extract_issue_requirements(issue)
+        # Collect full issue context including comments for plan
+        requirements = {
+          title: issue[:title],
+          body: issue[:body] || "",
+          comments: []
+        }
+
+        # Extract relevant comments (include plan comments and user responses)
+        issue[:comments]&.each do |comment|
+          requirements[:comments] << {
+            author: comment["author"] || comment[:author],
+            body: comment["body"] || comment[:body],
+            created_at: comment["createdAt"] || comment[:createdAt]
+          }
+        end
+
+        requirements
+      end
+
+      def extract_implementation_changes(working_dir)
+        Dir.chdir(working_dir) do
+          # Get the base branch to compare against
+          base_branch = detect_base_branch
+
+          # Get diff from base branch
+          diff_output, _stderr, status = Open3.capture3("git", "diff", "#{base_branch}...HEAD")
+
+          unless status.success?
+            Aidp.log_warn("implementation_verifier", "git_diff_failed", working_dir: working_dir)
+            return "Unable to extract changes: git diff failed"
+          end
+
+          # Get list of changed files with stats
+          files_output, _stderr, files_status = Open3.capture3("git", "diff", "--stat", "#{base_branch}...HEAD")
+
+          changes = {
+            diff: diff_output,
+            files_changed: files_status.success? ? files_output : "Unable to get file list"
+          }
+
+          Aidp.log_debug(
+            "implementation_verifier",
+            "extracted_changes",
+            working_dir: working_dir,
+            base_branch: base_branch,
+            diff_size: diff_output.bytesize,
+            files_changed_count: files_output.lines.count
+          )
+
+          changes
+        end
+      rescue => e
+        Aidp.log_error("implementation_verifier", "extract_changes_failed", error: e.message, working_dir: working_dir)
+        {error: "Failed to extract changes: #{e.message}"}
+      end
+
+      def detect_base_branch
+        stdout, _stderr, status = Open3.capture3("git", "symbolic-ref", "refs/remotes/origin/HEAD")
+        if status.success?
+          ref = stdout.strip
+          return ref.split("/").last if ref.include?("/")
+        end
+
+        # Fallback to common branch names
+        %w[main master trunk].find do |candidate|
+          _out, _err, branch_status = Open3.capture3("git", "rev-parse", "--verify", candidate)
+          branch_status.success?
+        end || "main"
+      end
+
+      def perform_zfc_verification(issue_number:, issue_requirements:, implementation_changes:)
+        # Check if AI decision engine is available
+        unless @ai_decision_engine
+          Aidp.log_error(
+            "implementation_verifier",
+            "ai_decision_engine_not_available",
+            issue: issue_number
+          )
+          return {
+            verified: false,
+            reason: "AI decision engine not available for verification",
+            missing_items: ["Unable to verify - AI decision engine initialization failed"],
+            additional_work: []
+          }
+        end
+
+        prompt = build_verification_prompt(issue_number, issue_requirements, implementation_changes)
+
+        schema = {
+          type: "object",
+          properties: {
+            fully_implemented: {
+              type: "boolean",
+              description: "True if the implementation fully addresses all issue requirements"
+            },
+            reasoning: {
+              type: "string",
+              description: "Detailed explanation of the verification decision"
+            },
+            missing_requirements: {
+              type: "array",
+              items: {type: "string"},
+              description: "List of specific requirements from the issue that are not yet implemented (empty if fully_implemented is true)"
+            },
+            additional_work_needed: {
+              type: "array",
+              items: {type: "string"},
+              description: "List of specific tasks needed to complete the implementation (empty if fully_implemented is true)"
+            }
+          },
+          required: ["fully_implemented", "reasoning", "missing_requirements", "additional_work_needed"]
+        }
+
+        # Use AIDecisionEngine with custom prompt
+        # We use a custom decision type since this is a one-off verification
+        decision = @ai_decision_engine.decide(
+          :implementation_verification,
+          context: {prompt: prompt},
+          schema: schema,
+          tier: :mini,
+          cache_ttl: nil # Don't cache verification results as they're context-specific
+        )
+
+        # Convert AI decision to verification result
+        {
+          verified: decision[:fully_implemented],
+          reason: decision[:reasoning],
+          missing_items: decision[:missing_requirements] || [],
+          additional_work: decision[:additional_work_needed] || []
+        }
+      rescue => e
+        Aidp.log_error(
+          "implementation_verifier",
+          "zfc_verification_failed",
+          issue: issue_number,
+          error: e.message,
+          error_class: e.class.name
+        )
+
+        # On error, fail safe by marking as not verified
+        {
+          verified: false,
+          reason: "Verification failed due to error: #{e.message}",
+          missing_items: ["Unable to verify due to technical error"],
+          additional_work: []
+        }
+      end
+
+      def build_verification_prompt(issue_number, issue_requirements, implementation_changes)
+        <<~PROMPT
+          You are verifying that an implementation fully addresses the requirements specified in a GitHub issue.
+
+          ## Task
+          Compare the issue requirements with the actual implementation changes and determine if the implementation is complete.
+
+          ## Issue ##{issue_number} Requirements
+
+          ### Title
+          #{issue_requirements[:title]}
+
+          ### Description
+          #{issue_requirements[:body]}
+
+          ### Discussion Thread / Plan
+          #{format_comments(issue_requirements[:comments])}
+
+          ## Implementation Changes
+
+          ### Files Changed
+          #{implementation_changes[:files_changed]}
+
+          ### Code Changes (Diff)
+          #{truncate_diff(implementation_changes[:diff])}
+
+          ## Verification Criteria
+
+          1. **All explicit requirements** from the issue description must be addressed
+          2. **All tasks from the plan** (if present in comments) must be completed
+          3. **Code changes must be substantive** - not just documentation or planning files
+          4. **Test requirements** are NOT part of this verification (handled separately)
+          5. **Quality/style requirements** are NOT part of this verification (handled by linters)
+
+          ## Your Decision
+
+          Determine if the implementation FULLY addresses the issue requirements. Be thorough but fair:
+          - If all requirements are met, mark as fully_implemented = true
+          - If any requirements are missing or incomplete, mark as fully_implemented = false and list them
+          - Focus on FUNCTIONAL requirements, not code quality or style
+        PROMPT
+      end
+
+      def format_comments(comments)
+        return "_No discussion thread_" if comments.nil? || comments.empty?
+
+        comments.map do |comment|
+          author = comment[:author] || "unknown"
+          timestamp = comment[:created_at] || "unknown"
+          body = comment[:body] || ""
+
+          "### #{author} (#{timestamp})\n#{body}"
+        end.join("\n\n")
+      end
+
+      def truncate_diff(diff)
+        return "_No changes detected_" if diff.nil? || diff.empty?
+
+        max_size = 15_000 # ~15KB to stay within token limits
+        if diff.bytesize > max_size
+          truncated = diff.byteslice(0, max_size)
+          "#{truncated}\n\n[... diff truncated, showing first #{max_size} bytes of #{diff.bytesize} total ...]"
+        else
+          diff
+        end
+      end
+
+      def build_default_ai_decision_engine
+        # Load config and create AI decision engine
+        config = Aidp::Harness::Configuration.new(@project_dir)
+
+        Aidp::Harness::AIDecisionEngine.new(config)
+      rescue => e
+        Aidp.log_warn(
+          "implementation_verifier",
+          "failed_to_create_ai_decision_engine",
+          error: e.message,
+          project_dir: @project_dir
+        )
+        # Return nil and fail verification gracefully
+        nil
+      end
+    end
+  end
+end

data/lib/aidp/watch/plan_generator.rb

@@ -29,32 +29,103 @@ module Aidp
       def initialize(provider_name: nil, verbose: false)
         @provider_name = provider_name
         @verbose = verbose
+        @providers_attempted = []
       end
 
       def generate(issue)
-        provider = resolve_provider
-        if provider
-          generate_with_provider(provider, issue)
-        else
-          display_message("⚠️  No active provider available. Falling back to heuristic plan.", type: :warn)
-          heuristic_plan(issue)
+        Aidp.log_debug("plan_generator", "generate.start", provider: @provider_name, issue: issue[:number])
+
+        # Try providers in fallback chain order
+        providers_to_try = build_provider_fallback_chain
+        Aidp.log_debug("plan_generator", "fallback_chain", providers: providers_to_try, count: providers_to_try.size)
+
+        providers_to_try.each do |provider_name|
+          next if @providers_attempted.include?(provider_name)
+
+          Aidp.log_debug("plan_generator", "trying_provider", provider: provider_name, attempted: @providers_attempted)
+
+          provider = resolve_provider(provider_name)
+          unless provider
+            Aidp.log_debug("plan_generator", "provider_unavailable", provider: provider_name, reason: "not resolved")
+            @providers_attempted << provider_name
+            next
+          end
+
+          begin
+            Aidp.log_info("plan_generator", "generate_with_provider", provider: provider_name, issue: issue[:number])
+            result = generate_with_provider(provider, issue, provider_name)
+            if result
+              Aidp.log_info("plan_generator", "generation_success", provider: provider_name, issue: issue[:number])
+              return result
+            end
+
+            # Provider returned nil - try next provider
+            Aidp.log_warn("plan_generator", "provider_returned_nil", provider: provider_name)
+            @providers_attempted << provider_name
+          rescue => e
+            # Log error and try next provider in chain
+            Aidp.log_warn("plan_generator", "provider_failed", provider: provider_name, error: e.message, error_class: e.class.name)
+            @providers_attempted << provider_name
+          end
         end
+
+        # All providers exhausted - silently fail without heuristic fallback
+        Aidp.log_warn("plan_generator", "all_providers_exhausted", attempted: @providers_attempted, result: "failed")
+        display_message("⚠️  All providers unavailable or failed. Unable to generate plan.", type: :warn)
+        nil
       rescue => e
-        display_message("⚠️  Plan generation failed (#{e.message}). Using heuristic.", type: :warn)
-        heuristic_plan(issue)
+        Aidp.log_error("plan_generator", "generation_failed_unexpectedly", error: e.message, backtrace: e.backtrace&.first(3))
+        display_message("⚠️  Plan generation failed unexpectedly (#{e.message}).", type: :warn)
+        nil
       end
 
       private
 
-      def resolve_provider
-        provider_name = @provider_name || detect_default_provider
+      def build_provider_fallback_chain
+        # Start with specified provider or default
+        primary_provider = @provider_name || detect_default_provider
+        providers = []
+
+        # Add primary provider first
+        providers << primary_provider if primary_provider
+
+        # Try to get fallback chain from config
+        begin
+          config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+          fallback_providers = config_manager.fallback_providers || []
+
+          # Add fallback providers that aren't already in the list
+          fallback_providers.each do |fallback|
+            providers << fallback unless providers.include?(fallback)
+          end
+        rescue => e
+          Aidp.log_debug("plan_generator", "config_fallback_unavailable", error: e.message)
+        end
+
+        # If we still have no providers, add cursor as last resort
+        providers << "cursor" if providers.empty?
+
+        # Remove duplicates while preserving order
+        providers.uniq
+      end
+
+      def resolve_provider(provider_name = nil)
+        provider_name ||= @provider_name || detect_default_provider
         return nil unless provider_name
 
-        provider = Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
-        return provider if provider&.available?
+        Aidp.log_debug("plan_generator", "resolve_provider", provider: provider_name)
+
+        provider = Aidp::ProviderManager.get_provider(provider_name)
+
+        if provider&.available?
+          Aidp.log_debug("plan_generator", "provider_resolved", provider: provider_name, available: true)
+          return provider
+        end
 
+        Aidp.log_debug("plan_generator", "provider_not_available", provider: provider_name, available: provider&.available?)
         nil
       rescue => e
+        Aidp.log_warn("plan_generator", "resolve_provider_failed", provider: provider_name, error: e.message)
         display_message("⚠️  Failed to resolve provider #{provider_name}: #{e.message}", type: :warn)
         nil
       end
@@ -66,9 +137,11 @@ module Aidp
         "cursor"
       end
 
-      def generate_with_provider(provider, issue)
+      def generate_with_provider(provider, issue, provider_name = "unknown")
         payload = build_prompt(issue)
 
+        Aidp.log_debug("plan_generator", "sending_to_provider", provider: provider_name, prompt_length: payload.length)
+
         if @verbose
           display_message("\n--- Plan Generation Prompt ---", type: :muted)
           display_message(payload.strip, type: :muted)
@@ -77,6 +150,8 @@ module Aidp
 
         response = provider.send_message(prompt: payload)
 
+        Aidp.log_debug("plan_generator", "provider_response_received", provider: provider_name, response_length: response&.length || 0)
+
         if @verbose
           display_message("\n--- Provider Response ---", type: :muted)
           display_message(response.strip, type: :muted)
@@ -85,10 +160,14 @@ module Aidp
 
         parsed = parse_structured_response(response)
 
-        return parsed if parsed
+        if parsed
+          Aidp.log_debug("plan_generator", "response_parsed", provider: provider_name, has_summary: !parsed[:summary].to_s.empty?, tasks_count: parsed[:tasks]&.size || 0)
+          return parsed
+        end
 
-        display_message("⚠️  Unable to parse provider response. Using heuristic plan.", type: :warn)
-        heuristic_plan(issue)
+        Aidp.log_warn("plan_generator", "parse_failed", provider: provider_name)
+        display_message("⚠️  Unable to parse #{provider_name} response. Trying next provider.", type: :warn)
+        nil
       end
 
       def build_prompt(issue)
@@ -140,42 +219,6 @@ module Aidp
         json_match = text.match(/\{.*\}/m)
         json_match ? json_match[0] : nil
       end
-
-      def heuristic_plan(issue)
-        body = issue[:body].to_s
-        bullet_tasks = body.lines
-          .map(&:strip)
-          .select { |line| line.start_with?("-", "*") }
-          .map { |line| line.sub(/\A[-*]\s*/, "") }
-          .uniq
-          .first(5)
-
-        paragraphs = body.split(/\n{2,}/).map(&:strip).reject(&:empty?)
-        summary = paragraphs.first(2).join(" ")
-        summary = summary.empty? ? "Implement the requested changes described in the issue." : summary
-
-        tasks = if bullet_tasks.empty?
-          [
-            "Review the repository context and identify impacted components.",
-            "Implement the necessary code changes and add tests.",
-            "Document the changes and ensure lint/test pipelines succeed."
-          ]
-        else
-          bullet_tasks
-        end
-
-        questions = [
-          "Are there constraints (framework versions, performance budgets) we must respect?",
-          "Are there existing tests or acceptance criteria we should extend?",
-          "Is there additional context (design docs, related issues) we should review?"
-        ]
-
-        {
-          summary: summary,
-          tasks: tasks,
-          questions: questions
-        }
-      end
     end
   end
 end

data/lib/aidp/watch/plan_processor.rb

@@ -33,12 +33,6 @@ module Aidp
         @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
       end
 
-      # For backward compatibility
-      def self.plan_label_from_config(config)
-        labels = config[:labels] || config["labels"] || {}
-        labels[:plan_trigger] || labels["plan_trigger"] || DEFAULT_PLAN_LABEL
-      end
-
       def process(issue)
         number = issue[:number]
         existing_plan = @state_store.plan_data(number)
@@ -51,6 +45,13 @@ module Aidp
 
         plan_data = @plan_generator.generate(issue)
 
+        # If plan generation failed (all providers unavailable), silently skip
+        unless plan_data
+          Aidp.log_warn("plan_processor", "plan_generation_failed", issue: number, reason: "no plan data returned")
+          display_message("⚠️  Unable to generate plan for issue ##{number} - all providers failed", type: :warn)
+          return
+        end
+
         # Fetch the user who added the most recent label
         label_actor = @repository_client.most_recent_label_actor(number)