aidp 0.10.0 → 0.11.0

data/lib/aidp/cli/checkpoint_command.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "../execute/checkpoint"
+require_relative "../execute/checkpoint_display"
+
+module Aidp
+  module CLI
+    # CLI command for viewing checkpoint data and progress reports
+    class CheckpointCommand < Thor
+      desc "show", "Show the latest checkpoint data"
+      def show
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        display = Aidp::Execute::CheckpointDisplay.new
+
+        latest = checkpoint.latest_checkpoint
+        if latest
+          display.display_checkpoint(latest, show_details: true)
+        else
+          puts "No checkpoint data found."
+        end
+      end
+
+      desc "summary", "Show progress summary with trends"
+      def summary
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        display = Aidp::Execute::CheckpointDisplay.new
+
+        summary = checkpoint.progress_summary
+        if summary
+          display.display_progress_summary(summary)
+        else
+          puts "No checkpoint data found."
+        end
+      end
+
+      desc "history [LIMIT]", "Show checkpoint history (default: last 10)"
+      def history(limit = "10")
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        display = Aidp::Execute::CheckpointDisplay.new
+
+        history = checkpoint.checkpoint_history(limit: limit.to_i)
+        if history.any?
+          display.display_checkpoint_history(history, limit: limit.to_i)
+        else
+          puts "No checkpoint history found."
+        end
+      end
+
+      desc "clear", "Clear all checkpoint data"
+      option :force, type: :boolean, default: false, desc: "Skip confirmation"
+      def clear
+        unless options[:force]
+          prompt = TTY::Prompt.new
+          confirm = prompt.yes?("Are you sure you want to clear all checkpoint data?")
+          return unless confirm
+        end
+
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        checkpoint.clear
+        puts "✓ Checkpoint data cleared."
+      end
+
+      desc "metrics", "Show detailed metrics for the latest checkpoint"
+      def metrics
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        latest = checkpoint.latest_checkpoint
+
+        unless latest
+          puts "No checkpoint data found."
+          return
+        end
+
+        puts
+        puts "📊 Detailed Metrics"
+        puts "=" * 60
+
+        metrics = latest[:metrics]
+        puts "Lines of Code: #{metrics[:lines_of_code]}"
+        puts "File Count: #{metrics[:file_count]}"
+        puts "Test Coverage: #{metrics[:test_coverage]}%"
+        puts "Code Quality: #{metrics[:code_quality]}%"
+        puts "PRD Task Progress: #{metrics[:prd_task_progress]}%"
+
+        if metrics[:tests_passing]
+          puts "Tests: #{metrics[:tests_passing] ? "✓ Passing" : "✗ Failing"}"
+        end
+
+        if metrics[:linters_passing]
+          puts "Linters: #{metrics[:linters_passing] ? "✓ Passing" : "✗ Failing"}"
+        end
+
+        puts "=" * 60
+        puts
+      end
+    end
+  end
+end

data/lib/aidp/cli/first_run_wizard.rb

@@ -3,11 +3,14 @@
 
 require "yaml"
 require "tty-prompt"
+require_relative "../harness/provider_factory"
 
 module Aidp
   class CLI
     # Handles interactive first-time project setup when no aidp.yml exists
     class FirstRunWizard
+      include Aidp::MessageDisplay
+
       TEMPLATES_DIR = File.expand_path(File.join(__dir__, "..", "..", "..", "templates"))
 
       def self.ensure_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new)
@@ -42,34 +45,10 @@ module Aidp
         @prompt = prompt
       end
 
-      # Helper method for consistent message display using TTY::Prompt
-      def display_message(message, type: :info)
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
-        end
-
-        @prompt.say(message, color: color)
-      end
-
       def run
         banner
-        loop do
-          choice = ask_choice
-          case choice
-          when "1" then return finish(write_quick_config(@project_dir))
-          when "2" then return finish(run_custom)
-          when "q", "Q" then display_message("Exiting without creating configuration.")
-                             return false
-          else
-            display_message("Invalid selection. Please choose one of the listed options.", type: :warning)
-          end
-        end
+        # Always run the full interactive custom configuration flow.
+        finish(run_custom)
       end
 
       def run_setup_config
@@ -96,22 +75,10 @@ module Aidp
       def banner
         display_message("\n🚀 First-time setup detected", type: :highlight)
         display_message("No 'aidp.yml' configuration file found in #{relative(@project_dir)}.")
-        display_message("Let's create one so you can start using AI Dev Pipeline.")
+        display_message("Creating a configuration so you can start using AI Dev Pipeline.")
         display_message("")
       end
 
-      def ask_choice
-        display_message("Choose a configuration style:") unless @asking
-
-        options = {
-          "Quick setup (cursor + macos, no API keys needed)" => "1",
-          "Custom setup (choose your own providers and settings)" => "2",
-          "Quit" => "q"
-        }
-
-        @prompt.select("Select an option:", options, default: "Quick setup (cursor + macos, no API keys needed)")
-      end
-
       def finish(path)
         if path
           display_message("\n✅ Configuration created at #{relative(path)}", type: :success)
@@ -135,7 +102,7 @@ module Aidp
       end
 
       def write_minimal_config(project_dir)
-        dest = File.join(project_dir, "aidp.yml")
+        dest = File.join(project_dir, ".aidp", "aidp.yml")
         return dest if File.exist?(dest)
         data = {
           "harness" => {
@@ -151,31 +118,7 @@ module Aidp
             }
           }
         }
-        File.write(dest, YAML.dump(data))
-        dest
-      end
-
-      def write_quick_config(project_dir)
-        dest = File.join(project_dir, "aidp.yml")
-        return dest if File.exist?(dest)
-        data = {
-          "harness" => {
-            "max_retries" => 2,
-            "default_provider" => "cursor",
-            "fallback_providers" => ["macos"],
-            "no_api_keys_required" => true
-          },
-          "providers" => {
-            "cursor" => {
-              "type" => "subscription",
-              "default_flags" => []
-            },
-            "macos" => {
-              "type" => "usage_based",
-              "default_flags" => []
-            }
-          }
-        }
+        FileUtils.mkdir_p(File.dirname(dest))
         File.write(dest, YAML.dump(data))
         dest
       end
@@ -204,15 +147,11 @@ module Aidp
         provider_name = default_provider.split(" - ").first
 
         # Validate fallback providers
-        fallback_input = @prompt.ask("Fallback providers (comma-separated)?", default: provider_name) do |q|
-          q.validate(/^[a-zA-Z0-9_,\s]+$/, "Invalid characters. Use only letters, numbers, commas, and spaces.")
-          q.validate(->(input) { validate_provider_list(input, available_providers) }, "One or more providers are not supported.")
-        end
+        fallback_providers = select_fallback_providers(available_providers, provider_name)
 
         restrict = @prompt.yes?("Only use providers that don't require API keys?", default: false)
 
-        # Process the inputs
-        fallback_providers = fallback_input.split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+        # Process providers preserving order
         providers = [provider_name] + fallback_providers
         providers.uniq!
 
@@ -261,15 +200,11 @@ module Aidp
         provider_name = default_provider.split(" - ").first
 
         # Validate fallback providers
-        fallback_input = @prompt.ask("Fallback providers (comma-separated)?", default: current_fallbacks.join(", ")) do |q|
-          q.validate(/^[a-zA-Z0-9_,\s]+$/, "Invalid characters. Use only letters, numbers, commas, and spaces.")
-          q.validate(->(input) { validate_provider_list(input, available_providers) }, "One or more providers are not supported.")
-        end
+        fallback_providers = select_fallback_providers(available_providers, provider_name, preselected: current_fallbacks - [provider_name])
 
         restrict_input = @prompt.yes?("Only use providers that don't require API keys?", default: current_restrict)
 
-        # Process the inputs
-        fallback_providers = fallback_input.split(/\s*,\s*/).map(&:strip).reject(&:empty?)
+        # Process providers preserving order
         providers = [provider_name] + fallback_providers
         providers.uniq!
 
@@ -340,24 +275,25 @@ module Aidp
 
       # Get available providers for validation
       def get_available_providers
-        # Define the available providers based on the system
-        available = ["cursor", "anthropic", "gemini", "macos", "opencode"]
-
-        # Add descriptions for better UX
-        available.map do |provider|
-          case provider
-          when "cursor"
-            "cursor - Cursor AI (no API key required)"
-          when "anthropic"
-            "anthropic - Anthropic Claude (requires API key)"
-          when "gemini"
-            "gemini - Google Gemini (requires API key)"
-          when "macos"
-            "macos - macOS UI Automation (no API key required)"
-          when "opencode"
-            "opencode - OpenCode (no API key required)"
+        # Get all supported providers from the factory (single source of truth)
+        all_providers = Aidp::Harness::ProviderFactory::PROVIDER_CLASSES.keys
+
+        # Filter out providers we don't want to show in the wizard
+        # - "anthropic" is an internal name, we show "claude" instead
+        # - "macos" is disabled (as per issue #73)
+        excluded = ["anthropic", "macos"]
+        available = all_providers - excluded
+
+        # Get display names from the providers themselves
+        available.map do |provider_name|
+          provider_class = Aidp::Harness::ProviderFactory::PROVIDER_CLASSES[provider_name]
+          if provider_class
+            # Instantiate to get display name
+            instance = provider_class.new
+            display_name = instance.display_name
+            "#{provider_name} - #{display_name}"
           else
-            provider
+            provider_name
           end
         end
       end
@@ -373,6 +309,41 @@ module Aidp
         valid_providers = available_providers.map { |p| p.split(" - ").first }
         providers.all? { |provider| valid_providers.include?(provider) }
       end
+
+      # Interactive ordered multi-select for fallback providers
+      def select_fallback_providers(available_with_labels, default_provider, preselected: [])
+        # Extract provider names and exclude the already chosen default
+        options = available_with_labels.map { |o| o.split(" - ").first }
+        candidates = options.reject { |p| p == default_provider }
+
+        return [] if candidates.empty?
+
+        selected = preselected.select { |p| candidates.include?(p) }
+
+        loop do
+          display_message("\nSelect fallback providers in order of preference (first = highest priority).", type: :info)
+          display_message("Current order: #{selected.empty? ? "(none)" : selected.join(" > ")}", type: :muted)
+          choice = @prompt.select("Add provider, or choose an action:", cycle: true) do |menu|
+            (candidates - selected).each { |prov| menu.choice("Add #{prov}", prov) }
+            menu.choice("Done", :done)
+            menu.choice("Clear", :clear) unless selected.empty?
+            menu.choice("Remove last (#{selected.last})", :remove) unless selected.empty?
+          end
+
+          case choice
+          when :done
+            break
+          when :clear
+            selected.clear
+          when :remove
+            selected.pop
+          else
+            selected << choice unless selected.include?(choice)
+          end
+        end
+
+        selected
+      end
     end
   end
 end

data/lib/aidp/cli/jobs_command.rb

@@ -7,10 +7,13 @@ require "io/console"
 require "json"
 require_relative "terminal_io"
 require_relative "../storage/file_manager"
+require_relative "../jobs/background_runner"
 
 module Aidp
   class CLI
     class JobsCommand
+      include Aidp::MessageDisplay
+
       def initialize(input: nil, output: nil, prompt: TTY::Prompt.new)
         @io = TerminalIO.new(input: input, output: output)
         @prompt = prompt
@@ -18,47 +21,271 @@ module Aidp
         @running = true
         @view_mode = :list
         @selected_job_id = nil
-        @jobs_displayed = false  # Track if we've displayed jobs in interactive mode
+        @jobs_displayed = false # Track if we've displayed jobs in interactive mode
         @file_manager = Aidp::Storage::FileManager.new(File.join(Dir.pwd, ".aidp"))
-        @screen_width = 80  # Default screen width
+        @background_runner = Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
+        @screen_width = 80 # Default screen width
       end
 
       private
 
-      def display_message(message, type: :info)
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
+      public
+
+      def run(subcommand = nil, args = [])
+        case subcommand
+        when "list", nil
+          list_jobs
+        when "status"
+          job_id = args.shift
+          if job_id
+            show_job_status(job_id, follow: args.include?("--follow"))
+          else
+            display_message("Usage: aidp jobs status <job_id> [--follow]", type: :error)
+          end
+        when "stop"
+          job_id = args.shift
+          if job_id
+            stop_job(job_id)
+          else
+            display_message("Usage: aidp jobs stop <job_id>", type: :error)
+          end
+        when "logs"
+          job_id = args.shift
+          if job_id
+            show_job_logs(job_id, tail: args.include?("--tail"), follow: args.include?("--follow"))
+          else
+            display_message("Usage: aidp jobs logs <job_id> [--tail] [--follow]", type: :error)
+          end
+        else
+          display_message("Unknown jobs subcommand: #{subcommand}", type: :error)
+          display_message("Available: list, status, stop, logs", type: :info)
         end
-        @prompt.say(message, color: color)
       end
 
-      public
-
-      def run
-        # Simple harness jobs display
-        jobs = fetch_harness_jobs
+      def list_jobs
+        jobs = @background_runner.list_jobs
 
         if jobs.empty?
-          display_message("Harness Jobs", type: :info)
+          display_message("Background Jobs", type: :info)
           display_message("-" * @screen_width, type: :muted)
           display_message("")
-          display_message("No harness jobs found", type: :info)
+          display_message("No background jobs found", type: :info)
           display_message("")
-          display_message("Harness jobs are background tasks that run during harness mode.", type: :info)
-          display_message("They are stored as JSON files in the .aidp/harness_logs/ directory.", type: :info)
+          display_message("Start a background job with:", type: :info)
+          display_message("  aidp execute --background", type: :info)
+          display_message("  aidp analyze --background", type: :info)
+          return
+        end
+
+        render_background_jobs(jobs)
+      end
+
+      def show_job_status(job_id, follow: false)
+        if follow
+          follow_job_status(job_id)
+        else
+          status = @background_runner.job_status(job_id)
+          unless status
+            display_message("Job not found: #{job_id}", type: :error)
+            return
+          end
+
+          render_job_status(status)
+        end
+      end
+
+      def stop_job(job_id)
+        result = @background_runner.stop_job(job_id)
+
+        if result[:success]
+          display_message("✓ #{result[:message]}", type: :success)
+        else
+          display_message("✗ #{result[:message]}", type: :error)
+        end
+      end
+
+      def show_job_logs(job_id, tail: false, follow: false)
+        if follow
+          display_message("Following logs for job #{job_id} (Ctrl+C to exit)...", type: :info)
+          @background_runner.follow_job_logs(job_id)
         else
-          render_harness_jobs(jobs)
+          logs = @background_runner.job_logs(job_id, tail: tail, lines: 50)
+          unless logs
+            display_message("No logs found for job: #{job_id}", type: :error)
+            return
+          end
+
+          display_message("Logs for job #{job_id}:", type: :info)
+          display_message("-" * @screen_width, type: :muted)
+          puts logs
         end
       end
 
       private
 
+      def render_background_jobs(jobs)
+        require "tty-table"
+
+        display_message("Background Jobs", type: :info)
+        display_message("=" * @screen_width, type: :muted)
+        display_message("")
+
+        headers = ["Job ID", "Mode", "Status", "Started", "Duration"]
+        rows = jobs.map do |job|
+          [
+            job[:job_id][0..15] + "...",
+            job[:mode].to_s.capitalize,
+            format_job_status(job[:status]),
+            format_time(job[:started_at]),
+            format_duration_from_start(job[:started_at], job[:completed_at])
+          ]
+        end
+
+        table = TTY::Table.new(headers, rows)
+        puts table.render(:basic)
+
+        display_message("")
+        display_message("Commands:", type: :info)
+        display_message("  aidp jobs status <job_id>        - Show detailed status", type: :info)
+        display_message("  aidp jobs logs <job_id> --tail   - Show recent logs", type: :info)
+        display_message("  aidp jobs stop <job_id>          - Stop a running job", type: :info)
+      end
+
+      def render_job_status(status)
+        display_message("Job Status: #{status[:job_id]}", type: :info)
+        display_message("=" * @screen_width, type: :muted)
+        display_message("")
+        display_message("Mode:       #{status[:mode]}", type: :info)
+        display_message("Status:     #{format_job_status(status[:status])}", type: :info)
+        display_message("PID:        #{status[:pid] || "N/A"}", type: :info)
+        display_message("Running:    #{status[:running] ? "Yes" : "No"}", type: :info)
+        display_message("Started:    #{format_time(status[:started_at])}", type: :info)
+
+        if status[:completed_at]
+          display_message("Completed:  #{format_time(status[:completed_at])}", type: :info)
+          display_message("Duration:   #{format_duration_from_start(status[:started_at], status[:completed_at])}", type: :info)
+        end
+
+        if status[:checkpoint]
+          display_message("", type: :info)
+          display_message("Latest Checkpoint:", type: :info)
+          cp = status[:checkpoint]
+          display_message("  Step:       #{cp[:step_name]}", type: :info)
+          display_message("  Iteration:  #{cp[:iteration]}", type: :info)
+          display_message("  Updated:    #{format_checkpoint_age(cp[:timestamp])}", type: :info)
+
+          if cp[:metrics]
+            display_message("  Metrics:", type: :info)
+            display_message("    LOC:      #{cp[:metrics][:lines_of_code]}", type: :info)
+            display_message("    Coverage: #{cp[:metrics][:test_coverage]}%", type: :info)
+            display_message("    Quality:  #{cp[:metrics][:code_quality]}%", type: :info)
+          end
+        end
+
+        display_message("", type: :info)
+        display_message("Log file: #{status[:log_file]}", type: :muted)
+      end
+
+      def follow_job_status(job_id)
+        display_message("Following job status for #{job_id} (Ctrl+C to exit)...", type: :info)
+        display_message("")
+
+        begin
+          loop do
+            # Clear screen
+            print "\e[2J\e[H"
+
+            status = @background_runner.job_status(job_id)
+            unless status
+              display_message("Job not found: #{job_id}", type: :error)
+              break
+            end
+
+            render_job_status(status)
+
+            # Exit if job is done
+            break unless status[:running]
+
+            # Wait before next update
+            sleep 2
+          end
+        rescue Interrupt
+          display_message("\nStopped following job status", type: :info)
+        end
+      end
+
+      def format_job_status(status)
+        case status.to_s
+        when "running"
+          @pastel.green("● Running")
+        when "completed"
+          @pastel.cyan("✓ Completed")
+        when "failed"
+          @pastel.red("✗ Failed")
+        when "stopped"
+          @pastel.yellow("⏹ Stopped")
+        when "stuck"
+          @pastel.magenta("⚠ Stuck")
+        else
+          @pastel.dim(status.to_s)
+        end
+      end
+
+      def format_time(time)
+        return "N/A" unless time
+
+        begin
+          time = Time.parse(time.to_s) if time.is_a?(String)
+          time.strftime("%Y-%m-%d %H:%M:%S")
+        rescue
+          time.to_s
+        end
+      end
+
+      def format_duration_from_start(started_at, completed_at)
+        return "N/A" unless started_at
+
+        start_time = started_at.is_a?(String) ? Time.parse(started_at) : started_at
+        end_time = if completed_at
+          completed_at.is_a?(String) ? Time.parse(completed_at) : completed_at
+        else
+          Time.now
+        end
+
+        duration = end_time - start_time
+        format_duration(duration)
+      end
+
+      def format_duration(seconds)
+        return "0s" if seconds.nil? || seconds <= 0
+
+        hours = (seconds / 3600).to_i
+        minutes = ((seconds % 3600) / 60).to_i
+        secs = (seconds % 60).to_i
+
+        parts = []
+        parts << "#{hours}h" if hours > 0
+        parts << "#{minutes}m" if minutes > 0
+        parts << "#{secs}s" if secs > 0 || parts.empty?
+
+        parts.join(" ")
+      end
+
+      def format_checkpoint_age(timestamp)
+        return "N/A" unless timestamp
+
+        time = Time.parse(timestamp.to_s)
+        age = Time.now - time
+
+        if age < 60
+          "#{age.to_i}s ago"
+        elsif age < 3600
+          "#{(age / 60).to_i}m ago"
+        else
+          "#{(age / 3600).to_i}h ago"
+        end
+      end
+
       # Fetch harness jobs from file-based storage
       def fetch_harness_jobs
         jobs = []
@@ -148,18 +375,6 @@ module Aidp
         display_message("Note: Harness jobs are stored as JSON files in .aidp/harness_logs/", type: :muted)
       end
 
-      # Format timestamp for display
-      def format_time(timestamp)
-        return "unknown" unless timestamp
-
-        begin
-          time = Time.parse(timestamp)
-          time.strftime("%Y-%m-%d %H:%M:%S")
-        rescue
-          timestamp
-        end
-      end
-
       # Truncate message for table display
       def truncate_message(message)
         return "N/A" unless message