aidp 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f6484f93a1d57d07f223f49abab2f1a919490d4cb25e6623e76ca85b430a0be
-  data.tar.gz: 6f765c07f09d77cf3ffab88c36aa9a04acf90c39fc44d326a594b7ff4b67759b
+  metadata.gz: 75047af72249152053d5dfe5b5e7800c0c8c844c7a513cf227601b8adb006af2
+  data.tar.gz: 574d521b5065f17afa618cfd6b672ed834badca459631011dddde7888796d7c6
 SHA512:
-  metadata.gz: e3219a59423ae33fc74bfaf38ac3ecebc3a157ac4f789c22252527652f02f63a1d98078de3db8b277d323073bf5cec8b86c97e9e7749f9a4e3097c6d849a4c2e
-  data.tar.gz: 3ec1273d7a35839fef07a02fa3a77e9340c008146c87ae790c8829f851f668af5fe1a1df12e28244b2b78c3313dd4ca667cb5e794232a3c4507f09f540d46cd9
+  metadata.gz: 323d8e0cfe1f37934d703488c00cbb4d1769bc0dea9d6f2d826a1a995861e6a8c84d697963a5e9880e5555e1d3e3f32f551f5db8c7ca273de8d79514dbad0e70
+  data.tar.gz: 98c37900f0672cade4a7fa838ae94282355e8645fc0ea9a0e2a2e6b2c3d78d265f91e4f66c0f592cf1b8d3297984fdc6fdc26d8efd584df8a0b0c2b543c1f3b8

data/README.md

@@ -11,6 +11,13 @@ gem install aidp
 # Navigate to your project
 cd /your/project
 
+# Launch the interactive configuration wizard
+aidp config --interactive
+
+# Analyze and bootstrap project docs
+aidp init
+# Creates LLM_STYLE_GUIDE.md, PROJECT_ANALYSIS.md, CODE_QUALITY_PLAN.md
+
 # Start an interactive workflow
 aidp execute
 

data/lib/aidp/cli/first_run_wizard.rb

@@ -1,44 +1,36 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "yaml"
+require "time"
 require "tty-prompt"
-require_relative "../harness/provider_factory"
-require_relative "../config/paths"
 
 module Aidp
   class CLI
-    # Handles interactive first-time project setup when no aidp.yml exists
+    # Wrapper around Aidp::Setup::Wizard to preserve existing CLI entry points.
     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)
         return true if Aidp::Config.config_exists?(project_dir)
 
         wizard = new(project_dir, prompt: prompt)
 
         if non_interactive
-          # Non-interactive environment - create minimal config silently
-          path = wizard.send(:write_minimal_config, project_dir)
-          wizard.send(:display_message, "Created minimal configuration at #{wizard.send(:relative, path)} (non-interactive default)", type: :success)
-          return true
+          wizard.create_minimal_config
+          wizard.send(:display_message, "Created minimal configuration (non-interactive default)", type: :success)
+          true
+        else
+          wizard.run
         end
-
-        wizard.run
       end
 
       def self.setup_config(project_dir, non_interactive: false, prompt: TTY::Prompt.new)
-        wizard = new(project_dir, prompt: prompt)
-
         if non_interactive
-          # Non-interactive environment - skip setup
-          wizard.send(:display_message, "Configuration setup skipped in non-interactive environment", type: :info)
+          new(project_dir, prompt: prompt).send(:display_message, "Configuration setup skipped in non-interactive environment", type: :info)
           return true
         end
 
-        wizard.run_setup_config
+        new(project_dir, prompt: prompt).run
       end
 
       def initialize(project_dir, prompt: TTY::Prompt.new)
@@ -47,300 +39,33 @@ module Aidp
       end
 
       def run
-        banner
-        # Always run the full interactive custom configuration flow.
-        finish(run_custom)
-      end
-
-      def run_setup_config
-        @prompt.say("🔧 Configuration Setup", color: :blue)
-        @prompt.say("Setting up your configuration file with current values as defaults.")
-        @prompt.say("")
-
-        # Load existing config to use as defaults (if it exists)
-        existing_config = load_existing_config
-
-        if existing_config
-          # Run custom configuration with existing values as defaults
-          finish(run_custom_with_defaults(existing_config))
-        else
-          # No existing config, run the normal setup flow
-          @prompt.say("No existing configuration found. Running first-time setup...")
-          @prompt.say("")
-          run
-        end
-      end
-
-      private
-
-      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("Creating a configuration so you can start using AI Dev Pipeline.")
-        display_message("")
-      end
-
-      def finish(path)
-        if path
-          display_message("\n✅ Configuration created at #{relative(path)}", type: :success)
-          display_message("You can edit this file anytime. Continuing startup...\n")
-          true
-        else
-          display_message("❌ Failed to create configuration file.", type: :error)
-          false
-        end
+        wizard = Aidp::Setup::Wizard.new(@project_dir, prompt: @prompt)
+        wizard.run
       end
 
-      def copy_template(filename)
-        src = File.join(TEMPLATES_DIR, filename)
-        unless File.exist?(src)
-          display_message("Template not found: #{filename}", type: :error)
-          return nil
-        end
-        dest = Aidp::ConfigPaths.config_file(@project_dir)
+      def create_minimal_config
         Aidp::ConfigPaths.ensure_config_dir(@project_dir)
-        File.write(dest, File.read(src))
-        dest
-      end
-
-      def write_minimal_config(project_dir)
-        dest = Aidp::ConfigPaths.config_file(project_dir)
-        return dest if File.exist?(dest)
-        data = {
-          "harness" => {
-            "max_retries" => 2,
-            "default_provider" => "cursor",
-            "fallback_providers" => ["cursor"],
-            "no_api_keys_required" => false
-          },
+        minimal = {
+          "schema_version" => Aidp::Setup::Wizard::SCHEMA_VERSION,
+          "generated_by" => "aidp setup wizard minimal",
+          "generated_at" => Time.now.utc.iso8601,
           "providers" => {
-            "cursor" => {
-              "type" => "subscription",
-              "default_flags" => []
+            "llm" => {
+              "name" => "cursor",
+              "model" => "cursor-agent",
+              "temperature" => 0.2,
+              "max_tokens" => 1024
             }
-          }
-        }
-        Aidp::ConfigPaths.ensure_config_dir(project_dir)
-        File.write(dest, YAML.dump(data))
-        dest
-      end
-
-      def write_example_config(project_dir)
-        Aidp::Config.create_example_config(project_dir)
-        Aidp::ConfigPaths.config_file(project_dir)
-      end
-
-      def run_custom
-        dest = Aidp::ConfigPaths.config_file(@project_dir)
-        return dest if File.exist?(dest)
-
-        @prompt.say("Interactive custom configuration: press Enter to accept defaults shown in [brackets].")
-        @prompt.say("")
-
-        # Use TTY::Prompt select for primary provider
-        # Find the formatted string that matches the default
-        default_option = available_providers.find { |option| option.start_with?("cursor -") } || available_providers.first
-        default_provider = @prompt.select("Default provider?", available_providers, default: default_option)
-
-        # Extract just the provider name from the formatted string
-        provider_name = default_provider.split(" - ").first
-
-        # Validate fallback providers
-        fallback_providers = select_fallback_providers(available_providers, provider_name)
-
-        restrict = @prompt.yes?("Only use providers that don't require API keys?", default: false)
-
-        # Process providers preserving order
-        providers = [provider_name] + fallback_providers
-        providers.uniq!
-
-        provider_section = {}
-        providers.each do |prov|
-          provider_section[prov] = {"type" => (prov == "cursor") ? "subscription" : "usage_based", "default_flags" => []}
-        end
-
-        data = {
-          "harness" => {
-            "max_retries" => 2,
-            "default_provider" => provider_name,
-            "fallback_providers" => fallback_providers,
-            "no_api_keys_required" => restrict
-          },
-          "providers" => provider_section
-        }
-        Aidp::ConfigPaths.ensure_config_dir(@project_dir)
-        File.write(dest, YAML.dump(data))
-        dest
-      end
-
-      def run_custom_with_defaults(existing_config)
-        dest = Aidp::ConfigPaths.config_file(@project_dir)
-
-        # Extract current values from existing config
-        harness_config = existing_config[:harness] || existing_config["harness"] || {}
-        providers_config = existing_config[:providers] || existing_config["providers"] || {}
-
-        current_default = harness_config[:default_provider] || harness_config["default_provider"] || "cursor"
-        current_fallbacks = harness_config[:fallback_providers] || harness_config["fallback_providers"] || [current_default]
-        current_restrict = harness_config[:no_api_keys_required] || harness_config["no_api_keys_required"] || false
-
-        # Use TTY::Prompt for interactive configuration
-        @prompt.say("Interactive configuration update: press Enter to keep current values shown in [brackets].")
-        @prompt.say("")
-
-        # Use TTY::Prompt select for primary provider
-        # Find the formatted string that matches the current default
-        default_option = available_providers.find { |option| option.start_with?("#{current_default} -") } || available_providers.first
-        default_provider = @prompt.select("Default provider?", available_providers, default: default_option)
-
-        # Extract just the provider name from the formatted string
-        provider_name = default_provider.split(" - ").first
-
-        # Validate fallback providers
-        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 providers preserving order
-        providers = [provider_name] + fallback_providers
-        providers.uniq!
-
-        # Build provider section
-        provider_section = {}
-        providers.each do |prov|
-          # Try to preserve existing provider config if it exists
-          existing_provider = providers_config[prov.to_sym] || providers_config[prov.to_s]
-          if existing_provider
-            # Convert existing provider config to string keys
-            converted_provider = {}
-            existing_provider.each { |k, v| converted_provider[k.to_s] = v }
-            # Ensure the type is correct (fix old "package" and "api" types)
-            if converted_provider["type"] == "package"
-              converted_provider["type"] = "subscription"
-            elsif converted_provider["type"] == "api"
-              converted_provider["type"] = "usage_based"
-            end
-            provider_section[prov] = converted_provider
-          else
-            provider_section[prov] = {"type" => (prov == "cursor") ? "subscription" : "usage_based", "default_flags" => []}
-          end
-        end
-
-        # Build the new config
-        data = {
-          "harness" => {
-            "max_retries" => harness_config[:max_retries] || harness_config["max_retries"] || 2,
-            "default_provider" => provider_name,
-            "fallback_providers" => fallback_providers,
-            "no_api_keys_required" => restrict_input
           },
-          "providers" => provider_section
+          "work_loop" => {
+            "test" => {
+              "unit" => "bundle exec rspec",
+              "timeout_seconds" => 1800
+            }
+          }
         }
 
-        Aidp::ConfigPaths.ensure_config_dir(@project_dir)
-        File.write(dest, YAML.dump(data))
-        dest
-      end
-
-      def load_existing_config
-        config_file = Aidp::ConfigPaths.config_file(@project_dir)
-        return nil unless File.exist?(config_file)
-
-        begin
-          YAML.load_file(config_file) || {}
-        rescue => e
-          @prompt.say("❌ Failed to load existing configuration: #{e.message}", color: :red)
-          nil
-        end
-      end
-
-      def ask(prompt, default: nil)
-        if default
-          @prompt.ask("#{prompt}:", default: default)
-        else
-          @prompt.ask("#{prompt}:")
-        end
-      end
-
-      def relative(path)
-        pn = Pathname.new(path)
-        wd = Pathname.new(@project_dir)
-        rel = pn.relative_path_from(wd).to_s
-        rel.start_with?("..") ? path : rel
-      rescue
-        path
-      end
-
-      # Get available providers for validation
-      def available_providers
-        # 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_name
-          end
-        end
-      end
-
-      # Validate provider list input
-      def validate_provider_list(input, available_providers)
-        return true if input.nil? || input.empty?
-
-        # Extract provider names from the input
-        providers = input.split(/\s*,\s*/).map(&:strip).reject(&:empty?)
-
-        # Check if all providers are valid
-        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
+        File.write(Aidp::ConfigPaths.config_file(@project_dir), minimal.to_yaml)
       end
     end
   end