aidp 0.26.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b4770edc850e936b3201ec532cdd369f7fd881ff79dd10e24407c6453b8cb22
-  data.tar.gz: d7d2640aa63d2c25afbf795bbf77d48741bdd99d6a074765fa5595f3982b96e6
+  metadata.gz: 931d08a58cf52b7acc999d7e3320181c29710c50922463f4fb5c4e0a76c02e04
+  data.tar.gz: 1971534889d0fde6daa6d8da6f345ffac4a698f827a205e445f75e7fa26d38da
 SHA512:
-  metadata.gz: 1841e0b35478d65d382d13dd138955c30655002b91c2a83d96ec2c83925eec4f954892aa710ded867b50554dbc9653bddfad5c5aa915890e674bb49afed347bc
-  data.tar.gz: 1fc1443566c4e01e0c6ff25f1ae62c890ddcd5373257265ee7119ea8db359c20282cf646d61b955204e4dc538ceb9c6313725cb4fed21cda231b97321cc2c030
+  metadata.gz: b87667e112faeb9818187eb97e281539e936ad213dcd49867781b37ff57ae9c827308cb9d4f7bdf707e48133fc3efcc79d1815d5a9b12cb3b395aad5d0e432cf
+  data.tar.gz: 5b9fa041a4e680115248fad3fad2ccd7c8ab9cc956a471051b2e2945b1d2277cfea2af7f1d3f105dd36e8e9be1f149f42fb91080496f055deb0c26e8daef1427

data/README.md

@@ -135,6 +135,95 @@ AIDP implements **work loops** - an iterative execution pattern where AI agents
 
 See [Work Loops Guide](docs/WORK_LOOPS_GUIDE.md) for details.
 
+### Waterfall Planning Mode
+
+Create comprehensive project plans with work breakdown structures, Gantt charts, and automated task assignments:
+
+```bash
+# Start planning workflow
+aidp execute
+# Select "Waterfall Planning"
+
+# Choose your path:
+# - Ingest existing documentation (PRDs, design docs)
+# - Generate from scratch through AI dialogue
+```
+
+**Generated Artifacts** (in `.aidp/docs/`):
+
+- **PRD.md** - Product requirements document
+- **TECH_DESIGN.md** - Technical architecture and design
+- **WBS.md** - Work breakdown structure with phases and tasks
+- **GANTT.md** - Mermaid Gantt chart with critical path analysis
+- **persona_map.yml** - AI-powered task-to-persona assignments
+- **PROJECT_PLAN.md** - Complete integrated project plan
+
+**Key Features:**
+
+- **Documentation Ingestion** - Import and enhance existing project docs
+- **AI-Guided Planning** - Generate complete plans through dialogue
+- **Critical Path Analysis** - Identify project bottlenecks
+- **Zero Framework Cognition** - AI-powered persona assignment (no heuristics)
+- **Mermaid Visualizations** - Gantt charts renderable on GitHub/GitLab
+- **TDD Integration** - Optional test-driven development workflow
+
+See [Waterfall Planning Mode Guide](docs/WATERFALL_PLANNING_MODE.md) for complete documentation.
+
+### Agile Development Mode
+
+Build products iteratively with user feedback loops, MVP scoping, and data-driven iteration planning:
+
+```bash
+# Start planning workflow
+aidp execute
+# Select "Agile MVP Planning", "Agile Iteration Planning", or "Legacy Product Research"
+```
+
+**Three Agile Workflows:**
+
+#### 1. MVP Planning
+
+Define minimum viable product scope, create user testing plans, and generate marketing materials:
+
+- **Input**: Product Requirements Document (PRD)
+- **Outputs**: MVP scope, user testing plan, marketing report
+- **Use case**: Launching a new product with user validation
+
+#### 2. Iteration Planning
+
+Analyze user feedback and plan next development iteration:
+
+- **Input**: User feedback data (CSV/JSON/markdown)
+- **Outputs**: Feedback analysis, iteration plan with prioritized tasks
+- **Use case**: Improving product based on real user data
+
+#### 3. Legacy Research
+
+Analyze existing codebase and create user research plan:
+
+- **Input**: Codebase path and language
+- **Outputs**: Research plan, feature audit, testing strategy
+- **Use case**: Understanding user needs for existing product
+
+**Generated Artifacts** (in `.aidp/docs/`):
+
+- **MVP_SCOPE.md** - Must-have vs nice-to-have feature breakdown
+- **USER_TEST_PLAN.md** - Comprehensive user testing strategy
+- **MARKETING_REPORT.md** - Value propositions and messaging
+- **USER_FEEDBACK_ANALYSIS.md** - AI-powered semantic feedback analysis
+- **NEXT_ITERATION_PLAN.md** - Prioritized tasks for next iteration
+- **LEGACY_USER_RESEARCH_PLAN.md** - Research strategy for existing product
+
+**Key Features:**
+
+- **Zero Framework Cognition** - AI-powered semantic analysis (no heuristics)
+- **Multi-Format Support** - Ingest feedback from CSV, JSON, or markdown
+- **Iterative Loops** - Continuous improvement based on user data
+- **Marketing Focus** - Translate features into customer value
+- **Three New Personas** - Product Manager, UX Researcher, Marketing Strategist
+
+See [Agile Development Mode Guide](docs/AGILE_MODE_GUIDE.md) for complete documentation.
+
 ### Job Management
 
 Monitor and control background jobs:

data/lib/aidp/cli/checkpoint_command.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../execute/checkpoint"
+require_relative "../execute/checkpoint_display"
+
+module Aidp
+  class CLI
+    # Command handler for `aidp checkpoint` subcommand
+    #
+    # Provides commands for managing workflow checkpoints:
+    #   - show: Display latest checkpoint data
+    #   - summary: Show progress summary with trends
+    #   - history: Show last N checkpoints
+    #   - metrics: Show detailed metrics
+    #   - clear: Clear all checkpoint data
+    #
+    # Usage:
+    #   aidp checkpoint show
+    #   aidp checkpoint summary --watch
+    #   aidp checkpoint history 10
+    #   aidp checkpoint metrics
+    #   aidp checkpoint clear --force
+    class CheckpointCommand
+      include Aidp::MessageDisplay
+
+      def initialize(prompt: TTY::Prompt.new, checkpoint_class: nil, display_class: nil, project_dir: nil)
+        @prompt = prompt
+        @checkpoint_class = checkpoint_class || Aidp::Execute::Checkpoint
+        @display_class = display_class || Aidp::Execute::CheckpointDisplay
+        @project_dir = project_dir || Dir.pwd
+      end
+
+      # Main entry point for checkpoint subcommands
+      def run(args)
+        sub = args.shift || "summary"
+        checkpoint = @checkpoint_class.new(@project_dir)
+        display = @display_class.new
+
+        case sub
+        when "show"
+          run_show_command(checkpoint, display)
+        when "summary"
+          run_summary_command(checkpoint, display, args)
+        when "history"
+          run_history_command(checkpoint, display, args)
+        when "metrics"
+          run_metrics_command(checkpoint)
+        when "clear"
+          run_clear_command(checkpoint, args)
+        else
+          display_usage
+        end
+      end
+
+      private
+
+      def run_show_command(checkpoint, display)
+        latest = checkpoint.latest_checkpoint
+        if latest
+          display.display_checkpoint(latest, show_details: true)
+        else
+          display_message("No checkpoint data found.", type: :info)
+        end
+      end
+
+      def run_summary_command(checkpoint, display, args)
+        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
+      end
+
+      def run_history_command(checkpoint, display, args)
+        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
+      end
+
+      def run_metrics_command(checkpoint)
+        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.key?(:tests_passing)
+          status = metrics[:tests_passing] ? "✓ Passing" : "✗ Failing"
+          display_message("Tests: #{status}", type: :info)
+        end
+
+        if metrics.key?(:linters_passing)
+          status = metrics[:linters_passing] ? "✓ Passing" : "✗ Failing"
+          display_message("Linters: #{status}", type: :info)
+        end
+
+        display_message("=" * 60, type: :muted)
+        display_message("", type: :info)
+      end
+
+      def run_clear_command(checkpoint, args)
+        force = args.include?("--force")
+        unless force
+          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)
+      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 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 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 display_usage
+        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
+  end
+end

data/lib/aidp/cli/config_command.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../setup/wizard"
+
+module Aidp
+  class CLI
+    # Command handler for `aidp config` subcommand
+    #
+    # Provides commands for managing AIDP configuration:
+    #   - Interactive configuration wizard
+    #   - Dry-run mode for testing configuration changes
+    #
+    # Usage:
+    #   aidp config --interactive
+    #   aidp config --interactive --dry-run
+    class ConfigCommand
+      include Aidp::MessageDisplay
+
+      def initialize(prompt: TTY::Prompt.new, wizard_class: nil, project_dir: nil)
+        @prompt = prompt
+        @wizard_class = wizard_class || Aidp::Setup::Wizard
+        @project_dir = project_dir || Dir.pwd
+      end
+
+      # Main entry point for config command
+      def run(args)
+        interactive = false
+        dry_run = false
+
+        until args.empty?
+          token = args.shift
+          case token
+          when "--interactive"
+            interactive = true
+          when "--dry-run"
+            dry_run = true
+          when "-h", "--help"
+            display_usage
+            return
+          else
+            display_message("Unknown option: #{token}", type: :error)
+            display_usage
+            return
+          end
+        end
+
+        unless interactive
+          display_usage
+          return
+        end
+
+        wizard = @wizard_class.new(@project_dir, prompt: @prompt, dry_run: dry_run)
+        wizard.run
+      end
+
+      private
+
+      def display_usage
+        display_message("\nUsage: aidp config --interactive [--dry-run]", type: :info)
+        display_message("\nOptions:", type: :info)
+        display_message("  --interactive    Run interactive configuration wizard", type: :info)
+        display_message("  --dry-run        Perform a dry run without making changes", type: :info)
+        display_message("  -h, --help       Show this help message", type: :info)
+        display_message("\nExamples:", type: :info)
+        display_message("  aidp config --interactive", type: :info)
+        display_message("  aidp config --interactive --dry-run", type: :info)
+      end
+    end
+  end
+end

data/lib/aidp/cli/enhanced_input.rb

@@ -21,6 +21,8 @@ module Aidp
       # - Ctrl-T: Transpose characters
       # - And many more Emacs-style bindings
 
+      attr_reader :use_reline, :show_hints
+
       def initialize(prompt: nil, input: nil, output: nil, use_reline: true)
         @use_reline = use_reline
         @input = input || $stdin

data/lib/aidp/cli/first_run_wizard.rb

@@ -10,10 +10,10 @@ module Aidp
     class FirstRunWizard
       include Aidp::MessageDisplay
 
-      def self.ensure_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new)
+      def self.ensure_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new, wizard_class: Aidp::Setup::Wizard)
         return true if Aidp::Config.config_exists?(project_dir)
 
-        wizard = new(project_dir, prompt: prompt)
+        wizard = new(project_dir, prompt: prompt, wizard_class: wizard_class)
 
         if non_interactive
           wizard.create_minimal_config
@@ -24,22 +24,23 @@ module Aidp
         end
       end
 
-      def self.setup_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new)
+      def self.setup_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new, wizard_class: Aidp::Setup::Wizard)
         if non_interactive
-          new(project_dir, prompt: prompt).send(:display_message, "Configuration setup skipped in non-interactive environment", type: :info)
+          new(project_dir, prompt: prompt, wizard_class: wizard_class).send(:display_message, "Configuration setup skipped in non-interactive environment", type: :info)
           return true
         end
 
-        new(project_dir, prompt: prompt).run
+        new(project_dir, prompt: prompt, wizard_class: wizard_class).run
       end
 
-      def initialize(project_dir, prompt: TTY::Prompt.new)
+      def initialize(project_dir, prompt: TTY::Prompt.new, wizard_class: Aidp::Setup::Wizard)
         @project_dir = project_dir
         @prompt = prompt
+        @wizard_class = wizard_class
       end
 
       def run
-        wizard = Aidp::Setup::Wizard.new(@project_dir, prompt: @prompt)
+        wizard = @wizard_class.new(@project_dir, prompt: @prompt)
         wizard.run
       end
 

data/lib/aidp/cli/harness_command.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "../harness/runner"
+
+module Aidp
+  class CLI
+    # Command handler for `aidp harness status` and `aidp harness reset` subcommands
+    #
+    # Provides commands for viewing and managing harness state:
+    #   - status: Show detailed harness status for all modes
+    #   - reset: Reset harness state for a specific mode
+    #
+    # Usage:
+    #   aidp harness status
+    #   aidp harness reset --mode analyze
+    class HarnessCommand
+      include Aidp::MessageDisplay
+      include Aidp::RescueLogging
+
+      def initialize(prompt: TTY::Prompt.new, runner_class: nil, project_dir: nil)
+        @prompt = prompt
+        @runner_class = runner_class || Aidp::Harness::Runner
+        @project_dir = project_dir || Dir.pwd
+      end
+
+      # Main entry point for harness status/reset subcommands
+      def run(args, subcommand:, options: {})
+        case subcommand
+        when "status"
+          run_status_command
+        when "reset"
+          run_reset_command(options)
+        else
+          display_message("Unknown harness subcommand: #{subcommand}", type: :error)
+          display_help
+          1
+        end
+      end
+
+      private
+
+      def run_status_command
+        modes = %i[analyze execute]
+        display_message("🔧 Harness Status", type: :highlight)
+        modes.each do |mode|
+          status = fetch_harness_status(mode)
+          print_harness_mode_status(mode, status)
+        end
+      end
+
+      def run_reset_command(options)
+        mode = (options[:mode] || "analyze").to_s
+        unless %w[analyze execute].include?(mode)
+          display_message("❌ Invalid mode. Use 'analyze' or 'execute'", type: :error)
+          return
+        end
+
+        # Build a runner to access state manager
+        runner = @runner_class.new(@project_dir, mode.to_sym, {})
+        state_manager = runner.instance_variable_get(:@state_manager)
+        state_manager.reset_all if state_manager.respond_to?(:reset_all)
+        display_message("✅ Reset harness state for #{mode} mode", type: :success)
+      end
+
+      def fetch_harness_status(mode)
+        runner = @runner_class.new(@project_dir, mode, {})
+        if runner.respond_to?(:detailed_status)
+          runner.detailed_status
+        else
+          {harness: {state: "unknown"}}
+        end
+      rescue => e
+        log_rescue(e, component: "harness_command", action: "fetch_harness_status", fallback: {harness: {state: "error"}}, mode: mode)
+        {harness: {state: "error", error: e.message}}
+      end
+
+      def print_harness_mode_status(mode, status)
+        harness = status[:harness] || {}
+        display_message("\n📋 #{mode.to_s.capitalize} Mode:", type: :info)
+        display_message("   State: #{harness[:state]}", type: :info)
+        if harness[:progress]
+          prog = harness[:progress]
+          display_message("   Progress: #{prog[:completed_steps]}/#{prog[:total_steps]}", type: :success)
+          display_message("   Current Step: #{harness[:current_step]}", type: :info) if harness[:current_step]
+        end
+      end
+
+      def display_help
+        display_message("\nUsage: aidp harness <subcommand> [options]", type: :info)
+        display_message("\nSubcommands:", type: :info)
+        display_message("  status           Show harness status for all modes", type: :info)
+        display_message("  reset            Reset harness state for a mode", type: :info)
+        display_message("\nOptions:", type: :info)
+        display_message("  --mode MODE      Specify mode for reset (analyze|execute)", type: :info)
+        display_message("\nExamples:", type: :info)
+        display_message("  aidp harness status", type: :info)
+        display_message("  aidp harness reset --mode analyze", type: :info)
+      end
+    end
+  end
+end

data/lib/aidp/cli/jobs_command.rb

@@ -14,7 +14,7 @@ module Aidp
     class JobsCommand
       include Aidp::MessageDisplay
 
-      def initialize(input: nil, output: nil, prompt: TTY::Prompt.new)
+      def initialize(input: nil, output: nil, prompt: TTY::Prompt.new, file_manager: nil, background_runner: nil)
         @io = TerminalIO.new(input: input, output: output)
         @prompt = prompt
         @pastel = Pastel.new
@@ -22,8 +22,8 @@ module Aidp
         @view_mode = :list
         @selected_job_id = nil
         @jobs_displayed = false # Track if we've displayed jobs in interactive mode
-        @file_manager = Aidp::Storage::FileManager.new(File.join(Dir.pwd, ".aidp"))
-        @background_runner = Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
+        @file_manager = file_manager || Aidp::Storage::FileManager.new(File.join(Dir.pwd, ".aidp"))
+        @background_runner = background_runner || Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
         @screen_width = 80 # Default screen width
       end
 

data/lib/aidp/cli/mcp_dashboard.rb

@@ -10,9 +10,10 @@ module Aidp
     class McpDashboard
       include Aidp::MessageDisplay
 
-      def initialize(root_dir = nil)
+      def initialize(root_dir = nil, configuration: nil, provider_info_class: Aidp::Harness::ProviderInfo)
         @root_dir = root_dir || Dir.pwd
-        @configuration = Aidp::Harness::Configuration.new(@root_dir)
+        @configuration = configuration || Aidp::Harness::Configuration.new(@root_dir)
+        @provider_info_class = provider_info_class
       end
 
       # Display MCP dashboard showing all servers across all providers
@@ -101,7 +102,7 @@ module Aidp
         provider_servers = {} # provider_name => [server_info]
 
         providers.each do |provider|
-          provider_info = Aidp::Harness::ProviderInfo.new(provider, @root_dir)
+          provider_info = @provider_info_class.new(provider, @root_dir)
           info = provider_info.info
 
           next unless info[:mcp_support]