aidp 0.27.0 → 0.28.0

data/lib/aidp/setup/wizard.rb

@@ -308,8 +308,12 @@ module Aidp
         end
 
         # Check if user wants to use automated discovery
-        existing_tiers = get([:thinking, :tiers])
-        if existing_tiers && !existing_tiers.empty?
+        has_existing_tiers = all_providers.any? do |provider|
+          existing_tiers = get([:providers, provider.to_sym, :thinking_tiers])
+          existing_tiers && !existing_tiers.empty?
+        end
+
+        if has_existing_tiers
           prompt.say("📝 Found existing tier configuration")
           unless prompt.yes?("Would you like to update it with discovered models?", default: false)
             return
@@ -332,16 +336,19 @@ module Aidp
         # Display discovered models
         display_discovered_models(discovered_models)
 
-        # Generate tier configuration
-        tier_config = generate_tier_configuration(discovered_models, primary_provider)
+        # Generate tier configuration (now provider-specific)
+        tier_configs = generate_provider_tier_configurations(discovered_models)
 
         # Show preview
         prompt.say("\n📋 Proposed tier configuration:")
-        display_tier_preview(tier_config)
+        display_provider_tier_preview(tier_configs)
 
         # Confirm and save
         if prompt.yes?("\nSave this tier configuration?", default: true)
-          set([:thinking, :tiers], tier_config)
+          # Write to provider-specific paths
+          tier_configs.each do |provider, provider_tiers|
+            set([:providers, provider.to_sym, :thinking_tiers], provider_tiers)
+          end
           prompt.ok("✅ Thinking tiers configured successfully")
         else
           prompt.say("💡 Skipped tier configuration. You can run 'aidp models discover' later")
@@ -474,38 +481,30 @@ module Aidp
         end
       end
 
-      def generate_tier_configuration(discovered_models, primary_provider)
-        tier_config = {}
+      def generate_provider_tier_configurations(discovered_models)
+        provider_configs = {}
 
-        # Configure the three most common tiers: mini, standard, and pro
-        DEFAULT_AUTOCONFIG_TIERS.each do |tier|
-          tier_models = []
-
-          # Collect primary provider models first (if available)
-          primary_models = find_models_for_tier(discovered_models[primary_provider], tier)
-          tier_models.concat(primary_models) if primary_models&.any?
+        # Organize by provider first, then by tier
+        discovered_models.each do |provider, models|
+          provider_tiers = {}
 
-          # Add models from other providers
-          discovered_models.each do |provider, models|
-            next if provider == primary_provider
-            provider_models = find_models_for_tier(models, tier)
-            tier_models.concat(provider_models) if provider_models&.any?
-          end
+          # Configure the three most common tiers: mini, standard, and pro
+          DEFAULT_AUTOCONFIG_TIERS.each do |tier|
+            tier_models = find_models_for_tier(models, tier)
 
-          # Add to config if we found any models for this tier
-          if tier_models.any?
-            tier_config[tier.to_sym] = {
-              models: tier_models.map { |m|
-                {
-                  provider: m[:provider],
-                  model: m[:name]
-                }
+            # Add to config if we found any models for this tier
+            if tier_models.any?
+              provider_tiers[tier.to_sym] = {
+                models: tier_models.map { |m| m[:name] }
               }
-            }
+            end
           end
+
+          # Only add provider if it has at least one tier configured
+          provider_configs[provider] = provider_tiers if provider_tiers.any?
         end
 
-        tier_config
+        provider_configs
       end
 
       def find_model_for_tier(models, target_tier)
@@ -520,16 +519,19 @@ module Aidp
         models.select { |m| m[:tier] == target_tier }
       end
 
-      def display_tier_preview(tier_config)
-        return if tier_config.empty?
+      def display_provider_tier_preview(provider_configs)
+        return if provider_configs.empty?
 
-        tier_config.each do |tier, config|
-          models = config[:models] || []
-          prompt.say("  #{tier}:")
-          models.each do |model_entry|
-            prompt.say("    - provider: #{model_entry[:provider]}")
-            prompt.say("      model: #{model_entry[:model]}")
+        provider_configs.each do |provider, provider_tiers|
+          prompt.say("  #{provider}:")
+          provider_tiers.each do |tier, tier_config|
+            models = tier_config[:models] || []
+            prompt.say("    #{tier}:")
+            models.each do |model_name|
+              prompt.say("      - #{model_name}")
+            end
           end
+          prompt.say("") # Blank line between providers
         end
       end
 
@@ -1066,6 +1068,7 @@ module Aidp
 
         configure_watch_safety
         configure_watch_labels
+        configure_watch_label_creation
       end
 
       def configure_watch_safety
@@ -1148,6 +1151,213 @@ module Aidp
         })
       end
 
+      def configure_watch_label_creation
+        prompt.say("\n🏷️  GitHub Label Auto-Creation")
+        prompt.say("  Automatically create GitHub labels for watch mode if they don't exist")
+
+        Aidp.log_debug("setup_wizard.label_creation", "start")
+
+        # Ask if user wants to auto-create labels
+        unless prompt.yes?("Auto-create GitHub labels if missing?", default: true)
+          Aidp.log_debug("setup_wizard.label_creation", "user_declined")
+          return
+        end
+
+        # Check if gh CLI is available
+        unless gh_cli_available?
+          prompt.warn("⚠️  GitHub CLI (gh) not found. Install it to enable label auto-creation.")
+          prompt.say("   Visit: https://cli.github.com/")
+          Aidp.log_debug("setup_wizard.label_creation", "gh_not_available")
+          return
+        end
+
+        # Extract repository info
+        repo_info = extract_repo_info
+        unless repo_info
+          prompt.warn("⚠️  Could not determine GitHub repository from git remote.")
+          prompt.say("   Ensure you're in a git repository with a GitHub remote configured.")
+          Aidp.log_debug("setup_wizard.label_creation", "repo_info_failed")
+          return
+        end
+
+        owner, repo = repo_info
+        Aidp.log_debug("setup_wizard.label_creation", "repo_detected", owner: owner, repo: repo)
+        prompt.say("📦 Repository: #{owner}/#{repo}")
+
+        # Fetch existing labels
+        existing_labels = fetch_existing_labels(owner, repo)
+        unless existing_labels
+          prompt.warn("⚠️  Failed to fetch existing labels. Check your GitHub authentication.")
+          Aidp.log_debug("setup_wizard.label_creation", "fetch_labels_failed")
+          return
+        end
+
+        Aidp.log_debug("setup_wizard.label_creation", "existing_labels_fetched", count: existing_labels.size)
+
+        # Get configured label names
+        labels_config = get([:watch, :labels]) || {}
+        required_labels = collect_required_labels(labels_config)
+
+        # Determine which labels need to be created
+        labels_to_create = required_labels.reject { |label| existing_labels.include?(label[:name]) }
+
+        if labels_to_create.empty?
+          prompt.ok("✅ All required labels already exist!")
+          Aidp.log_debug("setup_wizard.label_creation", "all_labels_exist")
+          return
+        end
+
+        # Show labels to be created
+        prompt.say("\n📝 Labels to create:")
+        labels_to_create.each do |label|
+          prompt.say("  • #{label[:name]} (#{label[:color]})")
+        end
+
+        # Confirm creation
+        unless prompt.yes?("Create these labels?", default: true)
+          Aidp.log_debug("setup_wizard.label_creation", "creation_declined")
+          return
+        end
+
+        # Create labels
+        create_labels(owner, repo, labels_to_create)
+      end
+
+      # Check if gh CLI is available
+      def gh_cli_available?
+        require "open3"
+        _stdout, _stderr, status = Open3.capture3("gh", "--version")
+        Aidp.log_debug("setup_wizard.gh_check", "version_check", success: status.success?)
+        status.success?
+      rescue Errno::ENOENT
+        Aidp.log_debug("setup_wizard.gh_check", "not_found")
+        false
+      end
+
+      # Extract repository owner and name from git remote
+      def extract_repo_info
+        require "open3"
+        stdout, stderr, status = Open3.capture3("git", "remote", "get-url", "origin")
+
+        unless status.success?
+          Aidp.log_debug("setup_wizard.repo_extraction", "git_remote_failed", error: stderr)
+          return nil
+        end
+
+        remote_url = stdout.strip
+        Aidp.log_debug("setup_wizard.repo_extraction", "remote_url_found", url: remote_url)
+
+        # Parse GitHub URL (supports both HTTPS and SSH formats)
+        # HTTPS: https://github.com/owner/repo.git
+        # SSH: git@github.com:owner/repo.git
+        if remote_url =~ %r{github\.com[:/]([^/]+)/(.+?)(?:\.git)?$}
+          owner = Regexp.last_match(1)
+          repo = Regexp.last_match(2)
+          Aidp.log_debug("setup_wizard.repo_extraction", "parsed", owner: owner, repo: repo)
+          [owner, repo]
+        else
+          Aidp.log_debug("setup_wizard.repo_extraction", "parse_failed", url: remote_url)
+          nil
+        end
+      rescue => e
+        Aidp.log_error("setup_wizard.repo_extraction", "exception", error: e.message)
+        nil
+      end
+
+      # Fetch existing labels from GitHub
+      def fetch_existing_labels(owner, repo)
+        require "open3"
+        stdout, stderr, status = Open3.capture3("gh", "label", "list", "-R", "#{owner}/#{repo}", "--json", "name", "--jq", ".[].name")
+
+        unless status.success?
+          Aidp.log_error("setup_wizard.fetch_labels", "gh_failed", error: stderr)
+          return nil
+        end
+
+        labels = stdout.strip.split("\n").map(&:strip).reject(&:empty?)
+        Aidp.log_debug("setup_wizard.fetch_labels", "fetched", count: labels.size)
+        labels
+      rescue => e
+        Aidp.log_error("setup_wizard.fetch_labels", "exception", error: e.message)
+        nil
+      end
+
+      # Collect required labels with their default colors
+      def collect_required_labels(labels_config)
+        default_colors = {
+          plan_trigger: "0E8A16",        # Green
+          needs_input: "D93F0B",         # Red
+          ready_to_build: "0075CA",      # Blue
+          build_trigger: "5319E7",       # Purple
+          review_trigger: "FBCA04",      # Yellow
+          ci_fix_trigger: "D93F0B",      # Red
+          change_request_trigger: "F9D0C4",  # Light pink
+          in_progress: "1D76DB"          # Dark blue (internal coordination)
+        }
+
+        required = []
+        labels_config.each do |key, name|
+          next if name.nil? || name.to_s.strip.empty?
+
+          color = default_colors[key] || "EDEDED"  # Gray fallback
+          required << {name: name, color: color, key: key}
+        end
+
+        # Always include the internal in-progress label for coordination
+        required << {
+          name: "aidp-in-progress",
+          color: default_colors[:in_progress],
+          key: :in_progress,
+          internal: true
+        }
+
+        Aidp.log_debug("setup_wizard.collect_labels", "collected", count: required.size)
+        required
+      end
+
+      # Create labels on GitHub
+      def create_labels(owner, repo, labels)
+        require "open3"
+
+        created = 0
+        failed = 0
+
+        labels.each do |label|
+          Aidp.log_debug("setup_wizard.create_label", "creating", name: label[:name], color: label[:color])
+
+          _stdout, stderr, status = Open3.capture3(
+            "gh", "label", "create", label[:name],
+            "--color", label[:color],
+            "-R", "#{owner}/#{repo}"
+          )
+
+          if status.success?
+            prompt.ok("  ✅ Created: #{label[:name]}")
+            Aidp.log_info("setup_wizard.create_label", "success", name: label[:name])
+            created += 1
+          else
+            prompt.warn("  ⚠️  Failed to create: #{label[:name]} - #{stderr.strip}")
+            Aidp.log_error("setup_wizard.create_label", "failed", name: label[:name], error: stderr.strip)
+            failed += 1
+          end
+        rescue => e
+          prompt.warn("  ⚠️  Error creating #{label[:name]}: #{e.message}")
+          Aidp.log_error("setup_wizard.create_label", "exception", name: label[:name], error: e.message)
+          failed += 1
+        end
+
+        # Summary
+        prompt.say("")
+        if created > 0
+          prompt.ok("✅ Successfully created #{created} label#{"s" unless created == 1}")
+        end
+        if failed > 0
+          prompt.warn("⚠️  Failed to create #{failed} label#{"s" unless failed == 1}")
+        end
+
+        Aidp.log_info("setup_wizard.create_labels", "complete", created: created, failed: failed)
+      end
+
       # -------------------------------------------
       # Preview & persistence
       # -------------------------------------------

data/lib/aidp/version.rb

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

data/lib/aidp/watch/build_processor.rb

@@ -10,6 +10,8 @@ require_relative "../harness/runner"
 require_relative "../harness/state_manager"
 require_relative "../worktree"
 require_relative "../execute/progress"
+require_relative "github_state_extractor"
+require_relative "implementation_verifier"
 
 module Aidp
   module Watch
@@ -27,6 +29,8 @@ module Aidp
       def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true, verbose: false, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
+        @state_extractor = GitHubStateExtractor.new(repository_client: repository_client)
+        @verifier = ImplementationVerifier.new(repository_client: repository_client, project_dir: project_dir)
         @project_dir = project_dir
         @use_workstreams = use_workstreams
         @verbose = verbose
@@ -40,7 +44,7 @@ module Aidp
         number = issue[:number]
         display_message("🛠️  Starting implementation for issue ##{number}", type: :info)
 
-        plan_data = ensure_plan_data(number)
+        plan_data = ensure_plan_data(issue)
         return unless plan_data
 
         slug = workstream_slug_for(issue)
@@ -87,27 +91,34 @@ module Aidp
           backtrace: e.backtrace&.first(10)
         )
 
-        # Create error result to pass to handle_failure
-        error_result = {
+        # Record failure state internally but DON'T post error to GitHub
+        # (per issue #280 - error messages should never appear on issues)
+        @state_store.record_build_status(
+          issue[:number],
           status: "error",
-          error: e.message,
-          error_class: e.class.name,
-          message: "Exception during harness execution: #{e.message}"
-        }
-
-        # Handle as failure (posts comment, updates state) but DON'T re-raise
-        handle_failure(issue: issue, slug: slug, result: error_result)
+          details: {
+            error: e.message,
+            error_class: e.class.name,
+            workstream: slug,
+            timestamp: Time.now.utc.iso8601
+          }
+        )
 
         # Note: We intentionally DON'T re-raise here to allow watch mode to continue
-        # The error has been logged, recorded, and reported to GitHub
+        # The error has been logged and recorded internally
       end
 
       private
 
-      def ensure_plan_data(number)
-        data = @state_store.plan_data(number)
+      def ensure_plan_data(issue)
+        # First try to extract from the issue that was passed in (already has comments)
+        data = @state_extractor.extract_plan_data(issue)
+
+        # Fallback to local state store if needed (for backward compatibility)
+        data ||= @state_store.plan_data(issue[:number])
+
         unless data
-          display_message("⚠️  No recorded plan for issue ##{number}. Skipping build trigger.", type: :warn)
+          display_message("⚠️  No recorded plan for issue ##{issue[:number]}. Skipping build trigger.", type: :warn)
         end
         data
       end
@@ -419,11 +430,36 @@ module Aidp
           return
         end
 
+        # Verify implementation completeness before creating PR
+        verification = @verifier.verify(issue: issue, working_dir: working_dir)
+
+        unless verification[:verified]
+          handle_incomplete_implementation(
+            issue: issue,
+            slug: slug,
+            branch_name: branch_name,
+            working_dir: working_dir,
+            verification: verification
+          )
+          return
+        end
+
+        display_message("✅ Implementation verified complete", type: :success)
+
         # Check if PR should be created based on VCS preferences
         # For watch mode, default to creating PRs (set to false to disable)
         vcs_config = config_dig(:work_loop, :version_control) || {}
         auto_create_pr = config_value(vcs_config, :auto_create_pr, true)
 
+        Aidp.log_debug(
+          "build_processor",
+          "evaluating_pr_creation",
+          issue: issue[:number],
+          changes_committed: changes_committed,
+          auto_create_pr: auto_create_pr,
+          gh_available: @repository_client.gh_available?
+        )
+
         pr_url = if !changes_committed
           Aidp.log_info(
             "build_processor",
@@ -441,14 +477,37 @@ module Aidp
             issue: issue[:number],
             branch: branch_name,
             base_branch: base_branch,
-            working_dir: working_dir
+            working_dir: working_dir,
+            gh_available: @repository_client.gh_available?
           )
           create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch, working_dir: working_dir)
         else
+          Aidp.log_info(
+            "build_processor",
+            "skipping_pr_vcs_preference",
+            issue: issue[:number],
+            auto_create_pr: auto_create_pr
+          )
           display_message("ℹ️  Skipping PR creation (disabled in VCS preferences)", type: :muted)
           nil
         end
 
+        # Record build status BEFORE posting completion comment
+        @state_store.record_build_status(
+          issue[:number],
+          status: "completed",
+          details: {branch: branch_name, workstream: slug, pr_url: pr_url}
+        )
+
+        # Remove build label BEFORE posting completion comment
+        begin
+          @repository_client.remove_labels(issue[:number], @build_label)
+          display_message("🏷️  Removed '#{@build_label}' label after completion", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to remove build label: #{e.message}", type: :warn)
+          # Don't fail the process if label removal fails
+        end
+
         # Fetch the user who added the most recent label
         label_actor = @repository_client.most_recent_label_actor(issue[:number])
 
@@ -456,6 +515,7 @@ module Aidp
         pr_line = pr_url ? "\n- Pull Request: #{pr_url}" : ""
         actor_tag = label_actor ? "cc @#{label_actor}\n\n" : ""
 
+        # Post completion comment LAST - after all other operations complete successfully
         comment = <<~COMMENT
           ✅ Implementation complete for ##{issue[:number]}.
 
@@ -466,22 +526,8 @@ module Aidp
         COMMENT
 
         @repository_client.post_comment(issue[:number], comment)
-        @state_store.record_build_status(
-          issue[:number],
-          status: "completed",
-          details: {branch: branch_name, workstream: slug, pr_url: pr_url}
-        )
         display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
 
-        # Remove build label after successful completion
-        begin
-          @repository_client.remove_labels(issue[:number], @build_label)
-          display_message("🏷️  Removed '#{@build_label}' label after completion", type: :info)
-        rescue => e
-          display_message("⚠️  Failed to remove build label: #{e.message}", type: :warn)
-          # Don't fail the process if label removal fails
-        end
-
         # Keep workstream for review - don't auto-cleanup on success
         if @use_workstreams
           display_message("ℹ️  Workstream #{slug} preserved for review. Remove with: aidp ws rm #{slug}", type: :muted)
@@ -624,6 +670,103 @@ module Aidp
         )
       end
 
+      def handle_incomplete_implementation(issue:, slug:, branch_name:, working_dir:, verification:)
+        display_message("⚠️  Implementation incomplete; scheduling additional work.", type: :warn)
+
+        # Create tasks for missing requirements
+        if verification[:additional_work] && !verification[:additional_work].empty?
+          create_follow_up_tasks(working_dir, verification[:additional_work])
+        end
+
+        # Schedule another agentic work unit
+        enqueue_decider_followup(working_dir)
+
+        workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved for continued work." : " The branch has been preserved for continued work."
+
+        # Fetch the user who added the most recent label
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+        actor_tag = label_actor ? "cc @#{label_actor}\n\n" : ""
+
+        # Post status comment
+        missing_section = if verification[:missing_items] && !verification[:missing_items].empty?
+          "\n### Missing Requirements\n" + verification[:missing_items].map { |item| "- #{item}" }.join("\n")
+        else
+          ""
+        end
+
+        additional_work_section = if verification[:additional_work] && !verification[:additional_work].empty?
+          "\n### Additional Work Needed\n" + verification[:additional_work].map { |item| "- #{item}" }.join("\n")
+        else
+          ""
+        end
+
+        comment = <<~COMMENT
+          🔄 Implementation in progress for ##{issue[:number]}.
+
+          #{actor_tag}The automated implementation has made progress but is not yet complete. Additional work is needed to fully address the issue requirements.
+
+          ### Verification Result
+          #{verification[:reason]}#{missing_section}#{additional_work_section}
+
+          The work loop will continue automatically to complete the remaining tasks.#{workstream_note}
+        COMMENT
+
+        @repository_client.post_comment(issue[:number], comment)
+        display_message("💬 Posted incomplete implementation status for issue ##{issue[:number]}", type: :info)
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "incomplete",
+          details: {
+            branch: branch_name,
+            workstream: slug,
+            verification: verification
+          }
+        )
+
+        Aidp.log_info(
+          "build_processor",
+          "incomplete_implementation",
+          issue: issue[:number],
+          branch: branch_name,
+          workstream: slug,
+          missing_items: verification[:missing_items],
+          additional_work: verification[:additional_work]
+        )
+      end
+
+      def create_follow_up_tasks(working_dir, additional_work)
+        return if additional_work.nil? || additional_work.empty?
+
+        tasklist_file = File.join(working_dir, ".aidp", "tasklist.jsonl")
+        FileUtils.mkdir_p(File.dirname(tasklist_file))
+
+        require_relative "../execute/persistent_tasklist"
+        tasklist = Aidp::Execute::PersistentTasklist.new(working_dir)
+
+        additional_work.each do |task_description|
+          tasklist.create(
+            description: task_description,
+            priority: :high,
+            tags: ["auto-generated", "verification"]
+          )
+        end
+
+        Aidp.log_info(
+          "build_processor",
+          "created_follow_up_tasks",
+          working_dir: working_dir,
+          task_count: additional_work.length
+        )
+      rescue => e
+        Aidp.log_warn(
+          "build_processor",
+          "failed_to_create_follow_up_tasks",
+          error: e.message,
+          working_dir: working_dir
+        )
+      end
+
       def stage_and_commit(issue, working_dir: @project_dir)
         commit_created = false
 
@@ -771,6 +914,19 @@ module Aidp
           fallback_to_author: label_actor.nil?
         )
 
+        Aidp.log_debug(
+          "build_processor",
+          "attempting_pr_creation",
+          issue: issue[:number],
+          branch_name: branch_name,
+          base_branch: base_branch,
+          draft: draft,
+          assignee: assignee,
+          gh_available: @repository_client.gh_available?,
+          title: title,
+          body_length: body.length
+        )
+
         output = @repository_client.create_pull_request(
           title: title,
           body: body,
@@ -789,9 +945,34 @@ module Aidp
           branch: branch_name,
           base_branch: base_branch,
           pr_url: pr_url,
-          assignee: assignee
+          assignee: assignee,
+          raw_output: output
         )
         pr_url
+      rescue => e
+        Aidp.log_error(
+          "build_processor",
+          "pr_creation_failed",
+          issue: issue[:number],
+          branch_name: branch_name,
+          base_branch: base_branch,
+          error: e.message,
+          error_class: e.class.name,
+          gh_available: @repository_client.gh_available?,
+          backtrace: e.backtrace&.first(10),
+          assignee: assignee,
+          title: title
+        )
+        display_message("⚠️  Failed to create pull request: #{e.message}", type: :warn)
+
+        # Continue gracefully - PR creation failure shouldn't crash the processor
+        Aidp.log_info(
+          "build_processor",
+          "continuing_after_pr_failure",
+          issue: issue[:number],
+          message: "Implementation complete but PR creation failed"
+        )
+        nil
       end
 
       def gather_test_summary(working_dir: @project_dir)