aidp 0.27.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 174c58fcccbc5d5c927cb30dd3bf8c735de926cf52de5eb2a4bb56f2bc984cc3
-  data.tar.gz: 73efb11b31d3ff346a482fde9616047fd64525e44ffe768a81a6e4808e748cd1
+  metadata.gz: 00cbc8656c3ce1550f5246837062879c70a0206fa62c00a7bef6cd20979b9be5
+  data.tar.gz: 353616de5a90d4cf722673040d6e7fba09d60ff63618a3c135688202694e3075
 SHA512:
-  metadata.gz: 407aecc4942fbda7fbf09e15ebfdfa6ba8595be9f282a0b425ce65dc22e45d3a524fe5dd211ce96ec59029801df01528a835412ba38f90cb273c5b1594df2016
-  data.tar.gz: 174a42200bb01198f3c88de3ec35198c9475f018f06a673e7d1d3c0e0dda9c294dd832519327261ac767a42323e965f1fa7ea1fa1d3b394425604ceaaa7bf371
+  metadata.gz: 65109acb0af57d4fefccbefa626f928cec5faaa3eedb5dfe4c0141521e03d95c8f7ca2dac8455baebdf6c14d0cbcd6cd81557a0bf4b2f0cdadb62547f60b414d
+  data.tar.gz: ea289ac3406776ccc1c602795fe6fa0a54c09fe8b3729b7e0f3b0151ba2782613cc2fee68b1111f9f6b81c78efeb7d31e77ab233ea49fba48e6d5585505e60f8

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/models_command.rb

@@ -4,28 +4,28 @@ require "tty-table"
 require "tty-prompt"
 require "tty-spinner"
 require_relative "../harness/model_registry"
-require_relative "../harness/model_discovery_service"
+require_relative "../harness/ruby_llm_registry"
 
 module Aidp
   class CLI
     # Command handler for `aidp models` subcommand group
     #
-    # Provides commands for viewing and discovering AI models:
+    # Provides commands for viewing AI models from the RubyLLM registry:
     #   - list: Show all available models with tier information
-    #   - discover: Discover models from configured providers
-    #   - refresh: Refresh the model cache
+    #   - discover: Discover models from RubyLLM registry for a provider
+    #   - validate: Validate model configuration
     #
     # Usage:
     #   aidp models list [--provider=<name>] [--tier=<tier>]
     #   aidp models discover [--provider=<name>]
-    #   aidp models refresh [--provider=<name>]
+    #   aidp models validate
     class ModelsCommand
       include Aidp::MessageDisplay
 
-      def initialize(prompt: TTY::Prompt.new, registry: nil, discovery_service: nil)
+      def initialize(prompt: TTY::Prompt.new, registry: nil, ruby_llm_registry: nil)
         @prompt = prompt
         @registry = registry
-        @discovery_service = discovery_service
+        @ruby_llm_registry = ruby_llm_registry
       end
 
       # Main entry point for models subcommand
@@ -39,9 +39,6 @@ module Aidp
         when "discover"
           args.shift
           run_discover_command(args)
-        when "refresh"
-          args.shift
-          run_refresh_command(args)
         when "validate"
           args.shift
           run_validate_command(args)
@@ -58,16 +55,15 @@ module Aidp
         @registry ||= Aidp::Harness::ModelRegistry.new
       end
 
-      def discovery_service
-        @discovery_service ||= Aidp::Harness::ModelDiscoveryService.new
+      def ruby_llm_registry
+        @ruby_llm_registry ||= Aidp::Harness::RubyLLMRegistry.new
       end
 
       def display_help
         display_message("\nUsage: aidp models <subcommand> [options]", type: :info)
         display_message("\nSubcommands:", type: :info)
         display_message("  list              List all available models with tier information", type: :info)
-        display_message("  discover          Discover models from configured providers", type: :info)
-        display_message("  refresh           Refresh the model discovery cache", type: :info)
+        display_message("  discover          Discover models from RubyLLM registry for a provider", type: :info)
         display_message("  validate          Validate model configuration for all tiers", type: :info)
         display_message("\nOptions:", type: :info)
         display_message("  --provider=<name> Filter/target specific provider", type: :info)
@@ -76,9 +72,7 @@ module Aidp
         display_message("  aidp models list", type: :info)
         display_message("  aidp models list --tier=mini", type: :info)
         display_message("  aidp models list --provider=anthropic", type: :info)
-        display_message("  aidp models discover", type: :info)
         display_message("  aidp models discover --provider=anthropic", type: :info)
-        display_message("  aidp models refresh", type: :info)
         display_message("  aidp models validate", type: :info)
       end
 
@@ -86,42 +80,35 @@ module Aidp
         options = parse_list_options(args)
 
         begin
-          # Get all model families from registry
-          families = registry.all_families
-
-          # Apply tier filter if specified
-          if options[:tier]
-            families = families.select { |family|
-              info = registry.get_model_info(family)
-              info && info["tier"] == options[:tier]
-            }
+          # Get models from RubyLLM registry
+          all_model_ids = if options[:provider]
+            ruby_llm_registry.models_for_provider(options[:provider])
+          else
+            # Get all models by iterating known providers
+            known_providers = %w[anthropic openai google azure bedrock openrouter]
+            known_providers.flat_map { |p| ruby_llm_registry.models_for_provider(p) }.uniq
           end
 
           # Build table rows
           rows = []
-          families.each do |family|
-            info = registry.get_model_info(family)
+          all_model_ids.each do |model_id|
+            info = ruby_llm_registry.get_model_info(model_id)
             next unless info
 
-            # Get providers that support this family
-            providers = find_providers_for_family(family)
+            # Map advanced -> pro for display consistency
+            display_tier = (info[:tier] == "advanced") ? "pro" : info[:tier]
 
-            # Apply provider filter if specified
-            next if options[:provider] && !providers.include?(options[:provider])
-
-            # Add a row for each provider that supports this family
-            if providers.empty?
-              # No provider support - show as registry-only
-              rows << build_table_row(nil, family, info, "registry")
-            else
-              providers.each do |provider_name|
-                rows << build_table_row(provider_name, family, info, "registry")
-              end
+            # Apply tier filter if specified (handle pro/advanced mapping)
+            if options[:tier]
+              filter_tier = (options[:tier] == "pro") ? "advanced" : options[:tier]
+              next unless info[:tier] == filter_tier
             end
+
+            rows << build_table_row(info[:provider], model_id, info, display_tier)
           end
 
           # Sort rows by tier, then provider, then model name
-          tier_order = {"mini" => 0, "standard" => 1, "advanced" => 2}
+          tier_order = {"mini" => 0, "standard" => 1, "pro" => 2, "advanced" => 2}
           rows.sort_by! { |r| [tier_order[r[2]] || 3, r[0] || "", r[1]] }
 
           # Display table
@@ -156,6 +143,7 @@ module Aidp
 
       def parse_list_options(args)
         options = {}
+        valid_tiers = %w[mini standard pro advanced]
 
         args.each do |arg|
           case arg
@@ -163,8 +151,8 @@ module Aidp
             options[:provider] = Regexp.last_match(1)
           when /^--tier=(.+)$/
             tier = Regexp.last_match(1)
-            unless Aidp::Harness::ModelRegistry::VALID_TIERS.include?(tier)
-              display_message("Invalid tier: #{tier}. Valid tiers: #{Aidp::Harness::ModelRegistry::VALID_TIERS.join(", ")}", type: :error)
+            unless valid_tiers.include?(tier)
+              display_message("Invalid tier: #{tier}. Valid tiers: #{valid_tiers.join(", ")}", type: :error)
               exit 1
             end
             options[:tier] = tier
@@ -177,18 +165,17 @@ module Aidp
         options
       end
 
-      def build_table_row(provider_name, family, info, source)
-        capabilities = (info["capabilities"] || []).join(",")
-        context = format_context_window(info["context_window"])
-        speed = info["speed"] || "unknown"
+      def build_table_row(provider_name, model_id, info, display_tier)
+        capabilities = (info[:capabilities] || []).join(",")
+        context = format_context_window(info[:context_window])
 
         [
           provider_name || "-",
-          family,
-          info["tier"] || "unknown",
+          model_id,
+          display_tier || "unknown",
           capabilities.empty? ? "-" : capabilities,
           context,
-          speed
+          "-" # Speed not available in registry
         ]
       end
 
@@ -213,8 +200,8 @@ module Aidp
 
       def build_footer(count)
         tips = [
-          "💡 Showing #{count} model#{"s" unless count == 1} from the static registry",
-          "💡 Model families are provider-agnostic (e.g., 'claude-3-5-sonnet' works across providers)"
+          "💡 Showing #{count} model#{"s" unless count == 1} from RubyLLM registry",
+          "💡 Registry updated regularly via ruby_llm gem updates"
         ]
         tips.join("\n")
       end
@@ -249,81 +236,56 @@ module Aidp
       def run_discover_command(args)
         options = parse_discover_options(args)
 
-        begin
-          display_message("\n🔍 Discovering models from configured providers...\n", type: :highlight)
-
-          spinner = TTY::Spinner.new("[:spinner] Querying provider APIs...", format: :dots)
-          spinner.auto_spin
-
-          # Discover models
-          results = if options[:provider]
-            {options[:provider] => discovery_service.discover_models(options[:provider], use_cache: false)}
-          else
-            discovery_service.discover_all_models(use_cache: false)
-          end
+        unless options[:provider]
+          display_message("\n⚠️  Please specify a provider with --provider=<name>", type: :warning)
+          display_message("Example: aidp models discover --provider=anthropic\n", type: :info)
+          return 1
+        end
 
-          spinner.success("✓")
+        begin
+          display_message("\n🔍 Discovering models for #{options[:provider]} from RubyLLM registry...\n", type: :highlight)
 
-          # Display results
-          total_models = 0
-          results.each do |provider, models|
-            next if models.empty?
-
-            total_models += models.size
-            display_message("\n✓ Found #{models.size} models for #{provider}:", type: :success)
-
-            # Group by tier
-            by_tier = models.group_by { |m| m[:tier] }
-            %w[mini standard advanced].each do |tier|
-              tier_models = by_tier[tier] || []
-              next if tier_models.empty?
-
-              display_message("  #{tier.capitalize} tier:", type: :info)
-              tier_models.each do |model|
-                display_message("    - #{model[:name]}", type: :info)
-              end
-            end
-          end
+          # Get models from registry
+          model_ids = ruby_llm_registry.models_for_provider(options[:provider])
 
-          if total_models == 0
-            display_message("\n⚠️  No models discovered. Ensure provider CLIs are installed and configured.", type: :warning)
+          if model_ids.empty?
+            display_message("\n⚠️  No models found for provider '#{options[:provider]}'.", type: :warning)
+            display_message("Provider may not be supported or name may be incorrect.\n", type: :info)
             return 1
           end
 
-          display_message("\n✅ Discovered #{total_models} total model#{"s" unless total_models == 1}", type: :success)
-          display_message("💾 Models cached for 24 hours\n", type: :info)
-          0
-        rescue => e
-          display_message("Error discovering models: #{e.message}", type: :error)
-          Aidp.log_error("models_command", "discovery error", error: e.message, backtrace: e.backtrace.first(5))
-          1
-        end
-      end
+          # Group by tier
+          models_by_tier = Hash.new { |h, k| h[k] = [] }
+          model_ids.each do |model_id|
+            info = ruby_llm_registry.get_model_info(model_id)
+            next unless info
 
-      def run_refresh_command(args)
-        options = parse_refresh_options(args)
+            # Map advanced -> pro for display
+            tier = (info[:tier] == "advanced") ? "pro" : info[:tier]
+            models_by_tier[tier] << model_id
+          end
 
-        begin
-          display_message("\n♻️  Refreshing model cache...\n", type: :highlight)
+          # Display results
+          display_message("\n✓ Found #{model_ids.size} models for #{options[:provider]}:", type: :success)
 
-          spinner = TTY::Spinner.new("[:spinner] Clearing cache and re-discovering...", format: :dots)
-          spinner.auto_spin
+          %w[mini standard pro].each do |tier|
+            tier_models = models_by_tier[tier]
+            next if tier_models.empty?
 
-          if options[:provider]
-            discovery_service.refresh_cache(options[:provider])
-            spinner.success("✓")
-            display_message("\n✅ Refreshed cache for #{options[:provider]}", type: :success)
-          else
-            discovery_service.refresh_all_caches
-            spinner.success("✓")
-            display_message("\n✅ Refreshed cache for all providers", type: :success)
+            display_message("\n  #{tier.capitalize} tier (#{tier_models.size} model#{"s" unless tier_models.size == 1}):", type: :info)
+            tier_models.first(5).each do |model|
+              display_message("    - #{model}", type: :info)
+            end
+            if tier_models.size > 5
+              display_message("    ... and #{tier_models.size - 5} more", type: :info)
+            end
           end
 
-          display_message("💡 Run 'aidp models discover' to see the updated models\n", type: :info)
+          display_message("\n💡 Use 'aidp models list --provider=#{options[:provider]}' to see full details\n", type: :info)
           0
         rescue => e
-          display_message("Error refreshing cache: #{e.message}", type: :error)
-          Aidp.log_error("models_command", "refresh error", error: e.message, backtrace: e.backtrace.first(5))
+          display_message("Error discovering models: #{e.message}", type: :error)
+          Aidp.log_error("models_command", "discovery error", error: e.message, backtrace: e.backtrace.first(5))
           1
         end
       end
@@ -344,10 +306,6 @@ module Aidp
         options
       end
 
-      def parse_refresh_options(args)
-        parse_discover_options(args)
-      end
-
       def run_validate_command(args)
         parse_validate_options(args)
 
@@ -437,8 +395,8 @@ module Aidp
 
         configured_providers.any? do |provider_name|
           provider_cfg = config.provider_config(provider_name)
-          tier_config = provider_cfg.dig(:thinking, :tiers, tier.to_sym) ||
-            provider_cfg.dig(:thinking, :tiers, tier)
+          tier_config = provider_cfg.dig(:thinking_tiers, tier.to_sym) ||
+            provider_cfg.dig(:thinking_tiers, tier)
 
           tier_config && tier_config[:models] && !tier_config[:models].empty?
         end
@@ -455,8 +413,7 @@ module Aidp
           next unless provider_class
 
           provider_cfg = config.provider_config(provider_name)
-          thinking_cfg = provider_cfg[:thinking] || {}
-          tiers_cfg = thinking_cfg[:tiers] || {}
+          tiers_cfg = provider_cfg[:thinking_tiers] || {}
 
           # Validate models in each tier
           tiers_cfg.each do |tier, tier_config|
@@ -537,8 +494,8 @@ module Aidp
         end
 
         if suggested_model
-          "Add to aidp.yml under providers.#{suggested_model[:provider]}.thinking.tiers.#{tier}.models:\n" \
-          "  - model: #{suggested_model[:family]}"
+          "Add to aidp.yml under providers.#{suggested_model[:provider]}.thinking_tiers.#{tier}.models:\n" \
+          "  - #{suggested_model[:family]}"
         else
           "Configure a model for this tier in aidp.yml"
         end