aidp 0.12.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e672ad3f8f54f1b3ad0cc4a804a63d1fa048709d47112497d5a4871d046dfb8b
-  data.tar.gz: 665d0b12e5dff272a0da11fd20d80299eaa4657ab7a87fe4e8b0f80e039e437d
+  metadata.gz: 75047af72249152053d5dfe5b5e7800c0c8c844c7a513cf227601b8adb006af2
+  data.tar.gz: 574d521b5065f17afa618cfd6b672ed834badca459631011dddde7888796d7c6
 SHA512:
-  metadata.gz: 384734aed97d697dce2c06ac6bf6f52b161b6436081ff4feb3b8e99e8038bef2b62a9aa3613b21dc92705569741598b98dcbf72805868f6cbdf82a1a19c3c6dd
-  data.tar.gz: 3bd5a990c925f10bb1ad863097b1f0a1e84b682e2489b0793242c37cc4034eb6ac8777559cecb6acaef915391dfeb60337074267e52a1cc4c35aee87c793d672
+  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/analyze/json_file_storage.rb

@@ -14,7 +14,7 @@ module Aidp
 
       # Store data in a JSON file
       def store_data(filename, data)
-        file_path = get_file_path(filename)
+        file_path = file_path(filename)
 
         # Ensure directory exists
         FileUtils.mkdir_p(File.dirname(file_path))
@@ -31,8 +31,8 @@ module Aidp
       end
 
       # Retrieve data from a JSON file
-      def get_data(filename)
-        file_path = get_file_path(filename)
+      def data(filename)
+        file_path = file_path(filename)
 
         return nil unless File.exist?(file_path)
 
@@ -45,12 +45,12 @@ module Aidp
 
       # Check if a JSON file exists
       def data_exists?(filename)
-        File.exist?(get_file_path(filename))
+        File.exist?(file_path(filename))
       end
 
       # Delete a JSON file
       def delete_data(filename)
-        file_path = get_file_path(filename)
+        file_path = file_path(filename)
 
         if File.exist?(file_path)
           File.delete(file_path)
@@ -89,8 +89,8 @@ module Aidp
       end
 
       # Get project configuration
-      def get_project_config
-        get_data("project_config.json")
+      def project_config
+        data("project_config.json")
       end
 
       # Store runtime status
@@ -99,8 +99,8 @@ module Aidp
       end
 
       # Get runtime status
-      def get_runtime_status
-        get_data("runtime_status.json")
+      def runtime_status
+        data("runtime_status.json")
       end
 
       # Store simple metrics
@@ -109,8 +109,8 @@ module Aidp
       end
 
       # Get simple metrics
-      def get_simple_metrics
-        get_data("simple_metrics.json")
+      def simple_metrics
+        data("simple_metrics.json")
       end
 
       # Store analysis session data
@@ -119,8 +119,8 @@ module Aidp
       end
 
       # Get analysis session data
-      def get_analysis_session(session_id)
-        get_data("sessions/#{session_id}.json")
+      def analysis_session(session_id)
+        data("sessions/#{session_id}.json")
       end
 
       # List analysis sessions
@@ -145,8 +145,8 @@ module Aidp
       end
 
       # Get user preferences
-      def get_user_preferences
-        get_data("user_preferences.json")
+      def user_preferences
+        data("user_preferences.json")
       end
 
       # Store cache data
@@ -161,8 +161,8 @@ module Aidp
       end
 
       # Get cache data (respects TTL)
-      def get_cache(cache_key)
-        cache_file_data = get_data("cache/#{cache_key}.json")
+      def cache(cache_key)
+        cache_file_data = data("cache/#{cache_key}.json")
         return nil unless cache_file_data
 
         # Check TTL if specified
@@ -203,7 +203,7 @@ module Aidp
       end
 
       # Get storage statistics
-      def get_storage_statistics
+      def storage_statistics
         files = list_files
 
         {
@@ -226,7 +226,7 @@ module Aidp
 
         files = list_files
         files.each do |file_info|
-          data = get_data(file_info[:filename])
+          data = data(file_info[:filename])
           export_data["files"][file_info[:filename]] = {
             "data" => data,
             "metadata" => {
@@ -249,7 +249,7 @@ module Aidp
 
       # Import data from an exported JSON file
       def import_data(import_filename)
-        import_path = get_file_path(import_filename)
+        import_path = file_path(import_filename)
 
         unless File.exist?(import_path)
           raise "Import file does not exist: #{import_filename}"
@@ -280,7 +280,7 @@ module Aidp
 
       private
 
-      def get_file_path(filename)
+      def file_path(filename)
         File.join(@storage_dir, filename)
       end
 

data/lib/aidp/cli/enhanced_input.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "reline"
+
+module Aidp
+  class CLI
+    # Enhanced input handler with full readline-style key bindings using Reline
+    class EnhancedInput
+      # Standard key bindings supported by Reline:
+      # - Ctrl-A: Move to beginning of line
+      # - Ctrl-E: Move to end of line
+      # - Ctrl-W: Delete word backward
+      # - Ctrl-K: Kill to end of line
+      # - Ctrl-U: Kill to beginning of line
+      # - Ctrl-D: Delete character forward
+      # - Ctrl-H/Backspace: Delete character backward
+      # - Left/Right arrows: Move cursor
+      # - Alt-F/Alt-B: Move forward/backward by word
+      # - Home/End: Jump to beginning/end
+      # - Ctrl-T: Transpose characters
+      # - And many more Emacs-style bindings
+
+      def initialize(prompt: nil, input: nil, output: nil, use_reline: true)
+        @use_reline = use_reline
+        @input = input || $stdin
+        @output = output || $stdout
+        @prompt = prompt || TTY::Prompt.new(
+          input: @input,
+          output: @output,
+          enable_color: true,
+          interrupt: :exit
+        )
+        @show_hints = false
+      end
+
+      # Ask a question with full readline support
+      # Uses Reline for readline-style editing when use_reline is true
+      def ask(question, **options)
+        # If reline is enabled and we're in a TTY, use reline for better editing
+        if @use_reline && @input.tty?
+          default = options[:default]
+          required = options[:required] || false
+
+          # Display helpful hint on first use
+          if @show_hints
+            @output.puts "💡 Hint: Use Ctrl-A (start), Ctrl-E (end), Ctrl-W (delete word), Ctrl-K (kill line)"
+            @show_hints = false
+          end
+
+          # Use Reline for input with full key binding support
+          loop do
+            prompt_text = question.to_s
+            prompt_text += " (#{default})" if default
+            prompt_text += " "
+
+            # Reline provides full readline editing capabilities
+            Reline.output = @output
+            Reline.input = @input
+            Reline.completion_append_character = " "
+
+            answer = Reline.readline(prompt_text, false)
+
+            # Handle Ctrl-D (nil return)
+            if answer.nil?
+              @output.puts
+              raise Interrupt
+            end
+
+            answer = answer.strip
+            answer = default if answer.empty? && default
+
+            if required && (answer.nil? || answer.empty?)
+              @output.puts "  Value required."
+              next
+            end
+
+            return answer
+          end
+        else
+          # Fall back to TTY::Prompt's ask
+          @prompt.ask(question, **options)
+        end
+      rescue Interrupt
+        @output.puts
+        raise
+      end
+
+      # Enable hints for key bindings
+      def enable_hints!
+        @show_hints = true
+      end
+
+      # Disable Reline (fall back to TTY::Prompt)
+      def disable_reline!
+        @use_reline = false
+      end
+
+      # Enable Reline
+      def enable_reline!
+        @use_reline = true
+      end
+
+      # Delegate other methods to underlying prompt
+      def method_missing(method, *args, **kwargs, &block)
+        @prompt.send(method, *args, **kwargs, &block)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @prompt.respond_to?(method, include_private) || super
+      end
+    end
+  end
+end

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,306 +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("")
-
-        # Get available providers for validation
-        available_providers = get_available_providers
-
-        # 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("")
-
-        # Get available providers for validation
-        available_providers = get_available_providers
-
-        # 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 get_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