aidp 0.10.0 → 0.11.0

data/lib/aidp/cli.rb

@@ -12,6 +12,8 @@ require_relative "cli/first_run_wizard"
 module Aidp
   # CLI interface for AIDP
   class CLI
+    include Aidp::MessageDisplay
+
     # Simple options holder for instance methods (used in specs)
     attr_accessor :options
 
@@ -20,21 +22,6 @@ 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
-
     # Instance version of harness status (used by specs; non-interactive)
     def harness_status
       modes = %i[analyze execute]
@@ -68,9 +55,9 @@ module Aidp
       status = if options[:expect_error] == true
         "error"
       elsif step.nil?
-        "success"  # Initial call without step
+        "success" # Initial call without step
       else
-        "completed"  # Subsequent calls with specific step
+        "completed" # Subsequent calls with specific step
       end
 
       {
@@ -154,20 +141,7 @@ module Aidp
     end
 
     class << self
-      # Class-level display_message method for CLI output
-      def display_message(message, type: :info)
-        prompt = TTY::Prompt.new
-        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
+      extend Aidp::MessageDisplay::ClassMethods
 
       def run(args = ARGV)
         # Handle subcommands first (status, jobs, kb, harness)
@@ -251,15 +225,58 @@ module Aidp
         options = {}
 
         parser = OptionParser.new do |opts|
-          opts.banner = "Usage: aidp [options]"
+          opts.banner = "Usage: aidp [COMMAND] [options]"
+          opts.separator ""
+          opts.separator "AI Development Pipeline - Autonomous development workflow automation"
           opts.separator ""
-          opts.separator "Start the interactive TUI (default)"
+          opts.separator "Commands:"
+          opts.separator "  analyze [--background]   Start analyze mode workflow"
+          opts.separator "  execute [--background]   Start execute mode workflow"
+          opts.separator "  status                   Show current system status"
+          opts.separator "  jobs                     Manage background jobs"
+          opts.separator "    list                     - List all jobs"
+          opts.separator "    status <id> [--follow]   - Show job status"
+          opts.separator "    logs <id> [--tail]       - Show job logs"
+          opts.separator "    stop <id>                - Stop a running job"
+          opts.separator "  checkpoint               View progress checkpoints and metrics"
+          opts.separator "    show                     - Show latest checkpoint"
+          opts.separator "    summary [--watch]        - Show progress summary with trends"
+          opts.separator "    history [N]              - Show last N checkpoints"
+          opts.separator "    metrics                  - Show detailed metrics"
+          opts.separator "    clear [--force]          - Clear checkpoint data"
+          opts.separator "  providers                Show provider health dashboard"
+          opts.separator "  harness                  Manage harness state"
+          opts.separator "    status                   - Show harness status"
+          opts.separator "    reset                    - Reset harness state"
+          opts.separator "  kb                       Knowledge base commands"
+          opts.separator "    show <topic>             - Show knowledge base topic"
           opts.separator ""
           opts.separator "Options:"
 
           opts.on("-h", "--help", "Show this help message") { options[:help] = true }
           opts.on("-v", "--version", "Show version information") { options[:version] = true }
-          opts.on("--setup-config", "Setup or reconfigure config file with current values as defaults") { options[:setup_config] = true }
+          opts.on("--setup-config", "Setup or reconfigure config file") { options[:setup_config] = true }
+
+          opts.separator ""
+          opts.separator "Examples:"
+          opts.separator "  # Start background execution"
+          opts.separator "  aidp execute --background"
+          opts.separator "  aidp execute --background --follow    # Start and follow logs"
+          opts.separator ""
+          opts.separator "  # Monitor background jobs"
+          opts.separator "  aidp jobs list                        # List all jobs"
+          opts.separator "  aidp jobs status <job_id>             # Show job status"
+          opts.separator "  aidp jobs logs <job_id> --tail        # Tail job logs"
+          opts.separator ""
+          opts.separator "  # Watch progress in real-time"
+          opts.separator "  aidp checkpoint summary --watch       # Auto-refresh every 5s"
+          opts.separator "  aidp checkpoint summary --watch --interval 10"
+          opts.separator ""
+          opts.separator "  # Other commands"
+          opts.separator "  aidp providers                        # Check provider health"
+          opts.separator "  aidp checkpoint history 20            # Show last 20 checkpoints"
+          opts.separator ""
+          opts.separator "For more information, visit: https://github.com/viamin/aidp"
         end
 
         parser.parse!(args)
@@ -270,18 +287,20 @@ module Aidp
       # Determine if the invocation is a subcommand style call
       def subcommand?(args)
         return false if args.nil? || args.empty?
-        %w[status jobs kb harness execute analyze].include?(args.first)
+        %w[status jobs kb harness execute analyze providers checkpoint].include?(args.first)
       end
 
       def run_subcommand(args)
         cmd = args.shift
         case cmd
         when "status" then run_status_command
-        when "jobs" then run_jobs_command
+        when "jobs" then run_jobs_command(args)
         when "kb" then run_kb_command(args)
         when "harness" then run_harness_command(args)
         when "execute" then run_execute_command(args)
         when "analyze" then run_execute_command(args, mode: :analyze) # symmetry
+        when "providers" then run_providers_command(args)
+        when "checkpoint" then run_checkpoint_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -298,10 +317,11 @@ module Aidp
         display_message("Use 'aidp analyze' or 'aidp execute' to start a workflow", type: :info)
       end
 
-      def run_jobs_command
+      def run_jobs_command(args = [])
         require_relative "cli/jobs_command"
         jobs_cmd = Aidp::CLI::JobsCommand.new(prompt: TTY::Prompt.new)
-        jobs_cmd.run
+        subcommand = args.shift
+        jobs_cmd.run(subcommand, args)
       end
 
       def run_kb_command(args)
@@ -336,6 +356,8 @@ module Aidp
         approve_step = nil
         reset = false
         no_harness = false
+        background = false
+        follow = false
 
         until flags.empty?
           token = flags.shift
@@ -343,6 +365,8 @@ module Aidp
           when "--no-harness" then no_harness = true
           when "--reset" then reset = true
           when "--approve" then approve_step = flags.shift
+          when "--background" then background = true
+          when "--follow" then follow = true
           else
             step ||= token unless token.start_with?("--")
           end
@@ -361,6 +385,35 @@ module Aidp
           display_message("Use 'aidp #{mode}' without arguments", type: :info)
           return
         end
+
+        # Handle background execution
+        if background
+          require_relative "jobs/background_runner"
+          runner = Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
+
+          display_message("Starting #{mode} mode in background...", type: :info)
+          job_id = runner.start(mode, {})
+
+          display_message("✓ Started background job: #{job_id}", type: :success)
+          display_message("", type: :info)
+          display_message("Monitor progress:", type: :info)
+          display_message("  aidp jobs status #{job_id}", type: :info)
+          display_message("  aidp jobs logs #{job_id} --tail", type: :info)
+          display_message("  aidp checkpoint summary", type: :info)
+          display_message("", type: :info)
+          display_message("Stop the job:", type: :info)
+          display_message("  aidp jobs stop #{job_id}", type: :info)
+
+          if follow
+            display_message("", type: :info)
+            display_message("Following logs (Ctrl+C to stop following)...", type: :info)
+            sleep 1 # Give daemon time to start writing logs
+            runner.follow_job_logs(job_id)
+          end
+
+          return
+        end
+
         if step
           display_message("Running #{mode} step '#{step}' with enhanced TUI harness", type: :highlight)
           display_message("progress indicators", type: :info)
@@ -386,6 +439,227 @@ module Aidp
         display_message("workflow selection options", type: :info)
       end
 
+      def run_checkpoint_command(args)
+        require_relative "execute/checkpoint"
+        require_relative "execute/checkpoint_display"
+
+        sub = args.shift || "summary"
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        display = Aidp::Execute::CheckpointDisplay.new
+
+        case sub
+        when "show"
+          latest = checkpoint.latest_checkpoint
+          if latest
+            display.display_checkpoint(latest, show_details: true)
+          else
+            display_message("No checkpoint data found.", type: :info)
+          end
+
+        when "summary"
+          watch = args.include?("--watch")
+          interval = extract_interval_option(args) || 5
+
+          if watch
+            watch_checkpoint_summary(checkpoint, display, interval)
+          else
+            summary = checkpoint.progress_summary
+            if summary
+              display.display_progress_summary(summary)
+            else
+              display_message("No checkpoint data found.", type: :info)
+            end
+          end
+
+        when "history"
+          limit = args.shift || "10"
+          history = checkpoint.checkpoint_history(limit: limit.to_i)
+          if history.any?
+            display.display_checkpoint_history(history, limit: limit.to_i)
+          else
+            display_message("No checkpoint history found.", type: :info)
+          end
+
+        when "metrics"
+          latest = checkpoint.latest_checkpoint
+          unless latest
+            display_message("No checkpoint data found.", type: :info)
+            return
+          end
+
+          display_message("", type: :info)
+          display_message("📊 Detailed Metrics", type: :info)
+          display_message("=" * 60, type: :muted)
+
+          metrics = latest[:metrics]
+          display_message("Lines of Code: #{metrics[:lines_of_code]}", type: :info)
+          display_message("File Count: #{metrics[:file_count]}", type: :info)
+          display_message("Test Coverage: #{metrics[:test_coverage]}%", type: :info)
+          display_message("Code Quality: #{metrics[:code_quality]}%", type: :info)
+          display_message("PRD Task Progress: #{metrics[:prd_task_progress]}%", type: :info)
+
+          if metrics[:tests_passing]
+            status = metrics[:tests_passing] ? "✓ Passing" : "✗ Failing"
+            display_message("Tests: #{status}", type: :info)
+          end
+
+          if metrics[:linters_passing]
+            status = metrics[:linters_passing] ? "✓ Passing" : "✗ Failing"
+            display_message("Linters: #{status}", type: :info)
+          end
+
+          display_message("=" * 60, type: :muted)
+          display_message("", type: :info)
+
+        when "clear"
+          force = args.include?("--force")
+          unless force
+            prompt = TTY::Prompt.new
+            confirm = prompt.yes?("Are you sure you want to clear all checkpoint data?")
+            return unless confirm
+          end
+
+          checkpoint.clear
+          display_message("✓ Checkpoint data cleared.", type: :success)
+
+        else
+          display_message("Usage: aidp checkpoint <show|summary|history|metrics|clear>", type: :info)
+          display_message("  show              - Show the latest checkpoint data", type: :info)
+          display_message("  summary [--watch] - Show progress summary with trends", type: :info)
+          display_message("  history [N]       - Show last N checkpoints", type: :info)
+          display_message("  metrics           - Show detailed metrics", type: :info)
+          display_message("  clear [--force]   - Clear all checkpoint data", type: :info)
+        end
+      end
+
+      def watch_checkpoint_summary(checkpoint, display, interval)
+        display_message("Watching checkpoint summary (refresh: #{interval}s, Ctrl+C to exit)...", type: :info)
+        display_message("", type: :info)
+
+        begin
+          loop do
+            # Clear screen
+            print "\e[2J\e[H"
+
+            summary = checkpoint.progress_summary
+            if summary
+              display.display_progress_summary(summary)
+
+              # Show last update time
+              if summary[:current] && summary[:current][:timestamp]
+                last_update = Time.parse(summary[:current][:timestamp])
+                age = Time.now - last_update
+                display_message("", type: :info)
+                display_message("Last update: #{format_time_ago_simple(age)} | Refreshing in #{interval}s...", type: :muted)
+              end
+            else
+              display_message("No checkpoint data found. Waiting for data...", type: :info)
+            end
+
+            sleep interval
+          end
+        rescue Interrupt
+          display_message("\nStopped watching checkpoint summary", type: :info)
+        end
+      end
+
+      def extract_interval_option(args)
+        args.each_with_index do |arg, i|
+          if arg == "--interval" && args[i + 1]
+            return args[i + 1].to_i
+          elsif arg.start_with?("--interval=")
+            return arg.split("=")[1].to_i
+          end
+        end
+        nil
+      end
+
+      def format_time_ago_simple(seconds)
+        if seconds < 60
+          "#{seconds.to_i}s ago"
+        elsif seconds < 3600
+          "#{(seconds / 60).to_i}m ago"
+        else
+          "#{(seconds / 3600).to_i}h ago"
+        end
+      end
+
+      def run_providers_command(args)
+        # Accept flags directly on `aidp providers` now (health is implicit)
+        no_color = false
+        args.reject! do |a|
+          if a == "--no-color"
+            no_color = true
+            true
+          else
+            false
+          end
+        end
+        configuration = Aidp::Harness::Configuration.new(Dir.pwd)
+        pm = Aidp::Harness::ProviderManager.new(configuration, prompt: TTY::Prompt.new)
+
+        # Use TTY::Spinner for progress indication
+        require "tty-spinner"
+        start_time = Time.now
+        spinner = TTY::Spinner.new(":spinner Gathering provider health...", format: :dots)
+        spinner.auto_spin
+
+        begin
+          rows = pm.health_dashboard
+        ensure
+          spinner.stop
+          elapsed = (Time.now - start_time).round(2)
+          display_message("Provider Health Dashboard (#{elapsed}s)", type: :highlight)
+        end
+        require "tty-table"
+        color = ->(text, code) { "\e[#{code}m#{text}\e[0m" }
+        status_color = lambda do |status|
+          case status
+          when /healthy/ then 32
+          when /unhealthy_auth/ then 31
+          when /unhealthy/ then 33
+          when /circuit/ then 35
+          else 37
+          end
+        end
+        availability_color = ->(avail) { (avail == "yes") ? 32 : 31 }
+        rate_color = ->(rl) { rl.start_with?("yes") ? 33 : 36 }
+        circuit_color = lambda do |c|
+          c.start_with?("open") ? 31 : 32
+        end
+        table_rows = rows.map do |r|
+          last_used = r[:last_used] ? r[:last_used].strftime("%H:%M:%S") : "-"
+          cb = r[:circuit_breaker]
+          cb += " (#{r[:circuit_breaker_remaining]}s)" if r[:circuit_breaker_remaining]
+          rl = if r[:rate_limited]
+            r[:rate_limit_reset_in] ? "yes (#{r[:rate_limit_reset_in]}s)" : "yes"
+          else
+            "no"
+          end
+          tokens = (r[:total_tokens].to_i > 0) ? r[:total_tokens].to_s : "0"
+          reason = r[:unhealthy_reason] || "-"
+          if no_color || !$stdout.tty?
+            [r[:provider], r[:status], (r[:available] ? "yes" : "no"), cb, rl, tokens, last_used, reason]
+          else
+            [
+              color.call(r[:provider], "1;97"),
+              color.call(r[:status], status_color.call(r[:status])),
+              color.call(r[:available] ? "yes" : "no", availability_color.call(r[:available] ? "yes" : "no")),
+              color.call(cb, circuit_color.call(cb)),
+              color.call(rl, rate_color.call(rl)),
+              color.call(tokens, 37),
+              color.call(last_used, 90),
+              ((reason == "-") ? reason : color.call(reason, 33))
+            ]
+          end
+        end
+        header = ["Provider", "Status", "Avail", "Circuit", "RateLimited", "Tokens", "LastUsed", "Reason"]
+        table = TTY::Table.new header, table_rows
+        display_message(table.render(:basic), type: :info)
+      rescue => e
+        display_message("Failed to display provider health: #{e.message}", type: :error)
+      end
+
       def extract_mode_option(args)
         mode = nil
         args.each do |arg|

data/lib/aidp/config.rb

@@ -165,14 +165,10 @@ module Aidp
     }.freeze
 
     def self.load(project_dir = Dir.pwd)
-      # Try new aidp.yml format first, then fall back to .aidp.yml
-      config_file = File.join(project_dir, "aidp.yml")
-      legacy_config_file = File.join(project_dir, ".aidp.yml")
+      config_file = File.join(project_dir, ".aidp", "aidp.yml")
 
       if File.exist?(config_file)
         load_yaml_config(config_file)
-      elsif File.exist?(legacy_config_file)
-        load_yaml_config(legacy_config_file)
       else
         {}
       end
@@ -248,15 +244,16 @@ module Aidp
 
     # Check if configuration file exists
     def self.config_exists?(project_dir = Dir.pwd)
-      File.exist?(File.join(project_dir, "aidp.yml")) ||
-        File.exist?(File.join(project_dir, ".aidp.yml"))
+      File.exist?(File.join(project_dir, ".aidp", "aidp.yml"))
     end
 
     # Create example configuration file
     def self.create_example_config(project_dir = Dir.pwd)
-      config_path = File.join(project_dir, "aidp.yml")
+      config_path = File.join(project_dir, ".aidp", "aidp.yml")
       return false if File.exist?(config_path)
 
+      FileUtils.mkdir_p(File.dirname(config_path))
+
       example_config = {
         harness: {
           max_retries: 2,

data/lib/aidp/debug_logger.rb

@@ -94,7 +94,7 @@ module Aidp
 
       # Also output to console if debug is enabled
       if ENV["DEBUG"] && ENV["DEBUG"].to_i > 0
-        puts "\e[36m#{banner}\e[0m"  # Cyan color
+        puts "\e[36m#{banner}\e[0m" # Cyan color
       end
     end
 
@@ -127,11 +127,11 @@ module Aidp
       when :error
         warn message
       when :warn
-        puts "\e[33m#{message}\e[0m"  # Yellow
+        puts "\e[33m#{message}\e[0m" # Yellow
       when :info
-        puts "\e[36m#{message}\e[0m"   # Cyan
+        puts "\e[36m#{message}\e[0m" # Cyan
       when :debug
-        puts "\e[90m#{message}\e[0m"   # Gray
+        puts "\e[90m#{message}\e[0m" # Gray
       else
         puts message
       end

data/lib/aidp/debug_mixin.rb

@@ -7,8 +7,8 @@ module Aidp
   module DebugMixin
     # Debug levels
     DEBUG_OFF = 0
-    DEBUG_BASIC = 1  # Commands and stderr
-    DEBUG_VERBOSE = 2  # Everything including prompts and stdout
+    DEBUG_BASIC = 1 # Commands and stderr
+    DEBUG_VERBOSE = 2 # Everything including prompts and stdout
 
     def self.included(base)
       base.extend(ClassMethods)
@@ -145,7 +145,7 @@ module Aidp
     end
 
     # Execute command with debug logging
-    def debug_execute_command(cmd, args: [], input: nil, timeout: nil, **options)
+    def debug_execute_command(cmd, args: [], input: nil, timeout: nil, streaming: false, **options)
       require "tty-command"
 
       command_str = [cmd, *args].join(" ")
@@ -154,7 +154,14 @@ module Aidp
       debug_log("🚀 Starting command execution: #{command_str}", level: :info)
 
       begin
-        cmd_obj = TTY::Command.new(printer: :null) # Disable TTY::Command's own output
+        # Configure printer based on streaming mode
+        if streaming
+          # Use progress printer for real-time output
+          cmd_obj = TTY::Command.new(printer: :progress)
+          debug_log("📺 Streaming mode enabled - showing real-time output", level: :info)
+        else
+          cmd_obj = TTY::Command.new(printer: :null) # Disable TTY::Command's own output
+        end
 
         # Prepare input
         input_data = nil