aidp 0.9.6 → 0.11.0

data/lib/aidp/{analysis → analyze}/kb_inspector.rb

@@ -2,12 +2,16 @@
 
 require "json"
 require "tty-box"
+require "tty-prompt"
 
 module Aidp
-  module Analysis
+  module Analyze
     class KBInspector
-      def initialize(kb_dir = ".aidp/kb")
+      include Aidp::MessageDisplay
+
+      def initialize(kb_dir = ".aidp/kb", prompt: TTY::Prompt.new)
         @kb_dir = File.expand_path(kb_dir)
+        @prompt = prompt
         @data = load_kb_data
       end
 
@@ -28,8 +32,8 @@ module Aidp
         when "summary"
           show_summary(format)
         else
-          puts "Unknown KB type: #{type}"
-          puts "Available types: seams, hotspots, cycles, apis, symbols, imports, summary"
+          display_message("Unknown KB type: #{type}", type: :error)
+          display_message("Available types: seams, hotspots, cycles, apis, symbols, imports, summary", type: :info)
         end
       end
 
@@ -42,8 +46,8 @@ module Aidp
         when "cycles"
           generate_cycle_graph(format, output)
         else
-          puts "Unknown graph type: #{type}"
-          puts "Available types: imports, calls, cycles"
+          display_message("Unknown graph type: #{type}", type: :error)
+          display_message("Available types: imports, calls, cycles", type: :info)
         end
       end
 
@@ -73,7 +77,7 @@ module Aidp
           border: :thick,
           padding: [1, 2]
         )
-        puts box
+        display_message(box)
       end
 
       def load_kb_data
@@ -87,7 +91,7 @@ module Aidp
             rescue JSON::ParserError => e
               # Suppress warnings in test mode to avoid CI failures
               unless ENV["RACK_ENV"] == "test" || defined?(RSpec)
-                puts "Warning: Could not parse #{file_path}: #{e.message}"
+                display_message("Warning: Could not parse #{file_path}: #{e.message}", type: :warn)
               end
               data[type.to_sym] = []
             end
@@ -100,42 +104,42 @@ module Aidp
       end
 
       def show_summary(_format)
-        puts "\n📊 Knowledge Base Summary"
-        puts "=" * 50
-
-        puts "📁 KB Directory: #{@kb_dir}"
-        puts "📄 Files analyzed: #{count_files}"
-        puts "🏗️  Symbols: #{@data[:symbols]&.length || 0}"
-        puts "📦 Imports: #{@data[:imports]&.length || 0}"
-        puts "🔗 Calls: #{@data[:calls]&.length || 0}"
-        puts "📏 Metrics: #{@data[:metrics]&.length || 0}"
-        puts "🔧 Seams: #{@data[:seams]&.length || 0}"
-        puts "🔥 Hotspots: #{@data[:hotspots]&.length || 0}"
-        puts "🧪 Tests: #{@data[:tests]&.length || 0}"
-        puts "🔄 Cycles: #{@data[:cycles]&.length || 0}"
+        display_message("\n📊 Knowledge Base Summary", type: :highlight)
+        display_message("=" * 50, type: :info)
+
+        display_message("📁 KB Directory: #{@kb_dir}", type: :info)
+        display_message("📄 Files analyzed: #{count_files}", type: :info)
+        display_message("🏗️  Symbols: #{@data[:symbols]&.length || 0}", type: :info)
+        display_message("📦 Imports: #{@data[:imports]&.length || 0}", type: :info)
+        display_message("🔗 Calls: #{@data[:calls]&.length || 0}", type: :info)
+        display_message("📏 Metrics: #{@data[:metrics]&.length || 0}", type: :info)
+        display_message("🔧 Seams: #{@data[:seams]&.length || 0}", type: :info)
+        display_message("🔥 Hotspots: #{@data[:hotspots]&.length || 0}", type: :info)
+        display_message("🧪 Tests: #{@data[:tests]&.length || 0}", type: :info)
+        display_message("🔄 Cycles: #{@data[:cycles]&.length || 0}", type: :info)
 
         if @data[:seams]&.any?
-          puts "\n🔧 Seam Types:"
+          display_message("\n🔧 Seam Types:", type: :info)
           seam_types = @data[:seams].group_by { |s| s[:kind] }
           seam_types.each do |type, seams|
-            puts "  #{type}: #{seams.length}"
+            display_message("  #{type}: #{seams.length}", type: :info)
           end
         end
 
         if @data[:hotspots]&.any?
-          puts "\n🔥 Top 5 Hotspots:"
+          display_message("\n🔥 Top 5 Hotspots:", type: :info)
           @data[:hotspots].first(5).each_with_index do |hotspot, i|
-            puts "  #{i + 1}. #{hotspot[:file]}:#{hotspot[:method]} (score: #{hotspot[:score]})"
+            display_message("  #{i + 1}. #{hotspot[:file]}:#{hotspot[:method]} (score: #{hotspot[:score]})", type: :info)
           end
         end
       end
 
       def show_seams(format)
-        return puts "No seams data available" unless @data[:seams]&.any?
+        return display_message("No seams data available") unless @data[:seams]&.any?
 
         case format
         when "json"
-          puts JSON.pretty_generate(@data[:seams])
+          display_message(JSON.pretty_generate(@data[:seams]))
         when "table"
           show_seams_table
         else
@@ -144,8 +148,8 @@ module Aidp
       end
 
       def show_seams_table
-        puts "\n🔧 Seams Analysis"
-        puts "=" * 80
+        display_message("\n🔧 Seams Analysis")
+        display_message("=" * 80)
 
         create_table(
           ["Type", "File", "Line", "Symbol", "Suggestion"],
@@ -162,34 +166,34 @@ module Aidp
       end
 
       def show_seams_summary
-        puts "\n🔧 Seams Analysis"
-        puts "=" * 50
+        display_message("\n🔧 Seams Analysis")
+        display_message("=" * 50)
 
         seam_types = @data[:seams].group_by { |s| s[:kind] }
 
         seam_types.each do |type, seams|
-          puts "\n📌 #{type.upcase} (#{seams.length} found)"
-          puts "-" * 30
+          display_message("\n📌 #{type.upcase} (#{seams.length} found)")
+          display_message("-" * 30)
 
           seams.first(10).each do |seam|
-            puts "  #{seam[:file]}:#{seam[:line]}"
-            puts "    Symbol: #{seam[:symbol_id]&.split(":")&.last}"
-            puts "    Suggestion: #{seam[:suggestion]}"
-            puts
+            display_message("  #{seam[:file]}:#{seam[:line]}")
+            display_message("    Symbol: #{seam[:symbol_id]&.split(":")&.last}")
+            display_message("    Suggestion: #{seam[:suggestion]}")
+            display_message("")
           end
 
           if seams.length > 10
-            puts "  ... and #{seams.length - 10} more"
+            display_message("  ... and #{seams.length - 10} more")
           end
         end
       end
 
       def show_hotspots(format)
-        return puts "No hotspots data available" unless @data[:hotspots]&.any?
+        return display_message("No hotspots data available") unless @data[:hotspots]&.any?
 
         case format
         when "json"
-          puts JSON.pretty_generate(@data[:hotspots])
+          display_message(JSON.pretty_generate(@data[:hotspots]))
         when "table"
           show_hotspots_table
         else
@@ -198,8 +202,8 @@ module Aidp
       end
 
       def show_hotspots_table
-        puts "\n🔥 Code Hotspots"
-        puts "=" * 80
+        display_message("\n🔥 Code Hotspots")
+        display_message("=" * 80)
 
         create_table(
           ["Rank", "File", "Method", "Score", "Complexity", "Touches"],
@@ -217,81 +221,81 @@ module Aidp
       end
 
       def show_hotspots_summary
-        puts "\n🔥 Code Hotspots (Top 20)"
-        puts "=" * 50
+        display_message("\n🔥 Code Hotspots (Top 20)")
+        display_message("=" * 50)
 
         @data[:hotspots].each_with_index do |hotspot, i|
-          puts "#{i + 1}. #{hotspot[:file]}:#{hotspot[:method]}"
-          puts "   Score: #{hotspot[:score]} (Complexity: #{hotspot[:complexity]}, Touches: #{hotspot[:touches]})"
-          puts
+          display_message("#{i + 1}. #{hotspot[:file]}:#{hotspot[:method]}")
+          display_message("   Score: #{hotspot[:score]} (Complexity: #{hotspot[:complexity]}, Touches: #{hotspot[:touches]})")
+          display_message("")
         end
       end
 
       def show_cycles(format)
-        return puts "No cycles data available" unless @data[:cycles]&.any?
+        return display_message("No cycles data available") unless @data[:cycles]&.any?
 
         case format
         when "json"
-          puts JSON.pretty_generate(@data[:cycles])
+          display_message(JSON.pretty_generate(@data[:cycles]))
         else
           show_cycles_summary
         end
       end
 
       def show_cycles_summary
-        puts "\n🔄 Import Cycles"
-        puts "=" * 50
+        display_message("\n🔄 Import Cycles")
+        display_message("=" * 50)
 
         @data[:cycles].each_with_index do |cycle, i|
-          puts "Cycle #{i + 1}:"
+          display_message("Cycle #{i + 1}:")
           cycle[:members].each do |member|
-            puts "  - #{member}"
+            display_message("  - #{member}")
           end
-          puts "  Weight: #{cycle[:weight]}" if cycle[:weight]
-          puts
+          display_message("  Weight: #{cycle[:weight]}") if cycle[:weight]
+          display_message("")
         end
       end
 
       def show_apis(format)
-        return puts "No APIs data available" unless @data[:tests]&.any?
+        return display_message("No APIs data available") unless @data[:tests]&.any?
 
         untested_apis = @data[:tests].select { |t| t[:tests].empty? }
 
         case format
         when "json"
-          puts JSON.pretty_generate(untested_apis)
+          display_message(JSON.pretty_generate(untested_apis))
         else
           show_apis_summary(untested_apis)
         end
       end
 
       def show_apis_summary(untested_apis)
-        puts "\n🧪 Untested Public APIs"
-        puts "=" * 50
+        display_message("\n🧪 Untested Public APIs")
+        display_message("=" * 50)
 
         if untested_apis.empty?
-          puts "✅ All public APIs have associated tests!"
+          display_message("✅ All public APIs have associated tests!")
         else
-          puts "Found #{untested_apis.length} untested public APIs:"
-          puts
+          display_message("Found #{untested_apis.length} untested public APIs:")
+          display_message("")
 
           untested_apis.each do |api|
             symbol = @data[:symbols]&.find { |s| s[:id] == api[:symbol_id] }
             if symbol
-              puts "  #{symbol[:file]}:#{symbol[:line]} - #{symbol[:name]}"
-              puts "    Suggestion: Create characterization tests"
-              puts
+              display_message("  #{symbol[:file]}:#{symbol[:line]} - #{symbol[:name]}")
+              display_message("    Suggestion: Create characterization tests")
+              display_message("")
             end
           end
         end
       end
 
       def show_symbols(format)
-        return puts "No symbols data available" unless @data[:symbols]&.any?
+        return display_message("No symbols data available") unless @data[:symbols]&.any?
 
         case format
         when "json"
-          puts JSON.pretty_generate(@data[:symbols])
+          display_message(JSON.pretty_generate(@data[:symbols]))
         when "table"
           show_symbols_table
         else
@@ -300,8 +304,8 @@ module Aidp
       end
 
       def show_symbols_table
-        puts "\n🏗️  Symbols"
-        puts "=" * 80
+        display_message("\n🏗️  Symbols")
+        display_message("=" * 80)
 
         create_table(
           ["Type", "Name", "File", "Line", "Visibility"],
@@ -318,22 +322,22 @@ module Aidp
       end
 
       def show_symbols_summary
-        puts "\n🏗️  Symbols Summary"
-        puts "=" * 50
+        display_message("\n🏗️  Symbols Summary")
+        display_message("=" * 50)
 
         symbol_types = @data[:symbols].group_by { |s| s[:kind] }
 
         symbol_types.each do |type, symbols|
-          puts "#{type.capitalize}: #{symbols.length}"
+          display_message("#{type.capitalize}: #{symbols.length}")
         end
       end
 
       def show_imports(format)
-        return puts "No imports data available" unless @data[:imports]&.any?
+        return display_message("No imports data available") unless @data[:imports]&.any?
 
         case format
         when "json"
-          puts JSON.pretty_generate(@data[:imports])
+          display_message(JSON.pretty_generate(@data[:imports]))
         when "table"
           show_imports_table
         else
@@ -342,8 +346,8 @@ module Aidp
       end
 
       def show_imports_table
-        puts "\n📦 Imports"
-        puts "=" * 80
+        display_message("\n📦 Imports")
+        display_message("=" * 80)
 
         create_table(
           ["Type", "Target", "File", "Line"],
@@ -359,18 +363,18 @@ module Aidp
       end
 
       def show_imports_summary
-        puts "\n📦 Imports Summary"
-        puts "=" * 50
+        display_message("\n📦 Imports Summary")
+        display_message("=" * 50)
 
         import_types = @data[:imports].group_by { |i| i[:kind] }
 
         import_types.each do |type, imports|
-          puts "#{type.capitalize}: #{imports.length}"
+          display_message("#{type.capitalize}: #{imports.length}")
         end
       end
 
       def generate_import_graph(format, output)
-        puts "Generating import graph in #{format} format..."
+        display_message("Generating import graph in #{format} format...")
 
         case format
         when "dot"
@@ -380,7 +384,7 @@ module Aidp
         when "json"
           generate_json_graph(output)
         else
-          puts "Unsupported graph format: #{format}"
+          display_message("Unsupported graph format: #{format}")
         end
       end
 
@@ -399,9 +403,9 @@ module Aidp
 
         if output
           File.write(output, content.join("\n"))
-          puts "Graph written to #{output}"
+          display_message("Graph written to #{output}")
         else
-          puts content.join("\n")
+          display_message(content.join("\n"))
         end
       end
 
@@ -416,9 +420,9 @@ module Aidp
 
         if output
           File.write(output, content.join("\n"))
-          puts "Graph written to #{output}"
+          display_message("Graph written to #{output}")
         else
-          puts content.join("\n")
+          display_message(content.join("\n"))
         end
       end
 
@@ -447,20 +451,20 @@ module Aidp
 
         if output
           File.write(output, JSON.pretty_generate(graph_data))
-          puts "Graph written to #{output}"
+          display_message("Graph written to #{output}")
         else
-          puts JSON.pretty_generate(graph_data)
+          display_message(JSON.pretty_generate(graph_data))
         end
       end
 
       def generate_call_graph(_format, _output)
         # Similar to import graph but for method calls
-        puts "Call graph generation not yet implemented"
+        display_message("Call graph generation not yet implemented")
       end
 
       def generate_cycle_graph(_format, _output)
         # Generate graph showing only the cycles
-        puts "Cycle graph generation not yet implemented"
+        display_message("Cycle graph generation not yet implemented")
       end
 
       def count_files

data/lib/aidp/analyze/prioritizer.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
+require "tty-prompt"
 require_relative "ruby_maat_integration"
 require_relative "feature_analyzer"
 
 module Aidp
   module Analyze
     class Prioritizer
-      def initialize(project_dir = Dir.pwd)
+      def initialize(project_dir = Dir.pwd, prompt: TTY::Prompt.new)
         @project_dir = project_dir
-        @code_maat = Aidp::Analyze::RubyMaatIntegration.new(project_dir)
+        @code_maat = Aidp::Analyze::RubyMaatIntegration.new(project_dir, prompt: prompt)
         @feature_analyzer = Aidp::Analyze::FeatureAnalyzer.new(project_dir)
       end
 

data/lib/aidp/analyze/progress.rb

@@ -11,7 +11,7 @@ module Aidp
 
       def initialize(project_dir)
         @project_dir = project_dir
-        @progress_file = File.join(project_dir, ".aidp-analyze-progress.yml")
+        @progress_file = File.join(project_dir, ".aidp", "progress", "analyze.yml")
         load_progress
       end
 
@@ -80,6 +80,7 @@ module Aidp
         # In test mode, skip file operations to avoid hanging
         return if ENV["RACK_ENV"] == "test" || defined?(RSpec)
 
+        FileUtils.mkdir_p(File.dirname(@progress_file))
         File.write(@progress_file, @progress.to_yaml)
       end
     end

data/lib/aidp/analyze/ruby_maat_integration.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
 require "tty-command"
+require "tty-prompt"
 require "json"
 require "fileutils"
 
 module Aidp
   module Analyze
     class RubyMaatIntegration
-      def initialize(project_dir = Dir.pwd)
+      include Aidp::MessageDisplay
+
+      def initialize(project_dir = Dir.pwd, prompt: TTY::Prompt.new)
         @project_dir = project_dir
+        @prompt = prompt
       end
 
       # Check if RubyMaat gem is available and accessible
@@ -80,7 +84,7 @@ module Aidp
 
       # Run analysis on large repositories using chunking
       def run_chunked_analysis(git_log_file)
-        puts "Large repository detected. Running chunked analysis..."
+        display_message("Large repository detected. Running chunked analysis...", type: :info)
 
         # Split analysis into chunks
         chunks = create_analysis_chunks(git_log_file)
@@ -93,7 +97,7 @@ module Aidp
         }
 
         chunks.each_with_index do |chunk, index|
-          puts "Processing chunk #{index + 1}/#{chunks.length}..."
+          display_message("Processing chunk #{index + 1}/#{chunks.length}...", type: :info)
 
           chunk_results = analyze_chunk(chunk)
 

data/lib/aidp/analyze/runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "tty-prompt"
 require_relative "steps"
 require_relative "progress"
 require_relative "../storage/file_manager"
@@ -9,18 +10,24 @@ module Aidp
   module Analyze
     class Runner
       include Aidp::DebugMixin
+      include Aidp::MessageDisplay
 
-      def initialize(project_dir, harness_runner = nil)
+      def initialize(project_dir, harness_runner = nil, prompt: TTY::Prompt.new)
         @project_dir = project_dir
         @harness_runner = harness_runner
         @is_harness_mode = !harness_runner.nil?
         @file_manager = Aidp::Storage::FileManager.new(File.join(project_dir, ".aidp"))
+        @prompt = prompt
       end
 
       def progress
         @progress ||= Aidp::Analyze::Progress.new(@project_dir)
       end
 
+      private
+
+      public
+
       def run_step(step_name, options = {})
         # Always validate step exists first
         step_spec = Aidp::Analyze::Steps::SPEC[step_name]
@@ -42,7 +49,7 @@ module Aidp
       # Harness-aware step execution
       def run_step_with_harness(step_name, options = {})
         # Get current provider from harness
-        current_provider = @harness_runner.instance_variable_get(:@current_provider)
+        current_provider = get_harness_provider_safely
         provider_type = current_provider || "cursor"
 
         debug_step(step_name, "Harness execution", {
@@ -72,7 +79,7 @@ module Aidp
 
       # Standalone step execution (simplified - synchronous)
       def run_step_standalone(step_name, options = {})
-        puts "🚀 Running step synchronously: #{step_name}"
+        display_message("🚀 Running step synchronously: #{step_name}", type: :info)
 
         start_time = Time.now
         prompt = composed_prompt(step_name, options)
@@ -85,7 +92,7 @@ module Aidp
         # Store execution metrics
         @file_manager.record_step_execution(step_name, "cursor", duration, result[:status] == "completed")
 
-        puts "✅ Step completed in #{duration.round(2)}s"
+        display_message("✅ Step completed in #{duration.round(2)}s", type: :success)
         result
       end
 
@@ -180,7 +187,10 @@ module Aidp
 
       def template_search_paths
         [
-          File.join(@project_dir, "templates", "ANALYZE"),
+          File.join(@project_dir, "templates"),        # Root templates folder
+          File.join(@project_dir, "templates", "analysis"),
+          File.join(@project_dir, "templates", "planning"),
+          File.join(@project_dir, "templates", "implementation"),
           File.join(@project_dir, "templates", "COMMON")
         ]
       end
@@ -223,11 +233,11 @@ module Aidp
         # Add current execution context
         context_parts << "## Analysis Context"
         context_parts << "Project Directory: #{@project_dir}"
-        context_parts << "Current Step: #{@harness_runner.instance_variable_get(:@current_step)}"
-        context_parts << "Current Provider: #{@harness_runner.instance_variable_get(:@current_provider)}"
+        context_parts << "Current Step: #{get_harness_current_step_safely}"
+        context_parts << "Current Provider: #{get_harness_provider_safely}"
 
         # Add user input context
-        user_input = @harness_runner.instance_variable_get(:@user_input)
+        user_input = get_harness_user_input_safely
         if user_input && !user_input.empty?
           context_parts << "\n## Previous User Input"
           user_input.each do |key, value|
@@ -236,7 +246,7 @@ module Aidp
         end
 
         # Add execution history context
-        execution_log = @harness_runner.instance_variable_get(:@execution_log)
+        execution_log = get_harness_execution_log_safely
         if execution_log && !execution_log.empty?
           context_parts << "\n## Analysis History"
           recent_logs = execution_log.last(5) # Last 5 entries
@@ -250,8 +260,9 @@ module Aidp
 
       # Execute step with harness provider management
       def execute_with_harness_provider(provider_type, prompt, step_name, _options)
-        # Get provider manager from harness
-        provider_manager = @harness_runner.instance_variable_get(:@provider_manager)
+        # Get provider manager from harness safely
+        provider_manager = get_harness_provider_manager_safely
+        return {status: "failed", error: "No provider manager available"} unless provider_manager
 
         # Execute with provider
         provider_manager.execute_with_provider(provider_type, prompt, {
@@ -325,6 +336,57 @@ module Aidp
           })
         end
       end
+
+      # Safely get current provider from harness runner
+      def get_harness_provider_safely
+        return "cursor" unless @harness_runner
+        return "cursor" unless @harness_runner.respond_to?(:current_provider)
+
+        @harness_runner.current_provider || "cursor"
+      rescue => e
+        debug_log("⚠️ Failed to get current provider from harness", level: :warn, data: {error: e.message})
+        "cursor"
+      end
+
+      def get_harness_current_step_safely
+        return "unknown" unless @harness_runner
+        return "unknown" unless @harness_runner.respond_to?(:current_step)
+
+        @harness_runner.current_step || "unknown"
+      rescue => e
+        debug_log("⚠️ Failed to get current step from harness", level: :warn, data: {error: e.message})
+        "unknown"
+      end
+
+      def get_harness_user_input_safely
+        return {} unless @harness_runner
+        return {} unless @harness_runner.respond_to?(:user_input)
+
+        @harness_runner.user_input || {}
+      rescue => e
+        debug_log("⚠️ Failed to get user input from harness", level: :warn, data: {error: e.message})
+        {}
+      end
+
+      def get_harness_execution_log_safely
+        return [] unless @harness_runner
+        return [] unless @harness_runner.respond_to?(:execution_log)
+
+        @harness_runner.execution_log || []
+      rescue => e
+        debug_log("⚠️ Failed to get execution log from harness", level: :warn, data: {error: e.message})
+        []
+      end
+
+      def get_harness_provider_manager_safely
+        return nil unless @harness_runner
+        return nil unless @harness_runner.respond_to?(:provider_manager)
+
+        @harness_runner.provider_manager
+      rescue => e
+        debug_log("⚠️ Failed to get provider manager from harness", level: :warn, data: {error: e.message})
+        nil
+      end
     end
   end
 end

data/lib/aidp/{analysis → analyze}/seams.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Aidp
-  module Analysis
+  module Analyze
     module Seams
       # I/O and OS integration patterns
       IO_PATTERNS = [