aidp 0.15.1 → 0.16.0

data/lib/aidp/harness/status_display.rb

@@ -54,24 +54,17 @@ module Aidp
         @display_mode = display_mode
         @last_update = Time.now
 
-        # Start status display using Async (skip in test mode)
         unless ENV["RACK_ENV"] == "test" || defined?(RSpec)
-          require "async"
-          Async do |task|
-            task.async do
-              while @running
-                begin
-                  collect_status_data
-                  display_status
-                  check_alerts
-                  if ENV["RACK_ENV"] == "test" || defined?(RSpec)
-                    sleep(@update_interval)
-                  else
-                    Async::Task.current.sleep(@update_interval)
-                  end
-                rescue => e
-                  handle_display_error(e)
-                end
+          require "concurrent"
+          @status_future = Concurrent::Future.execute do
+            while @running
+              begin
+                collect_status_data
+                display_status
+                check_alerts
+                sleep(@update_interval)
+              rescue => e
+                handle_display_error(e)
               end
             end
           end
@@ -81,7 +74,7 @@ module Aidp
       # Stop status updates
       def stop_status_updates
         @running = false
-        @status_thread&.join
+        @status_future&.wait(5)
         clear_display
       end
 

data/lib/aidp/harness/ui/navigation/submenu.rb

@@ -16,6 +16,7 @@ module Aidp
             super(ui_components)
             @title = title
             @parent_menu = parent_menu
+            @ui_components = ui_components
             @submenu_items = []
             @drill_down_enabled = true
             @max_depth = 5

data/lib/aidp/harness/ui/workflow_controller.rb

@@ -265,7 +265,7 @@ module Aidp
         def control_interface_loop
           loop do
             handle_control_input
-            sleep(0.1) # Small delay to prevent excessive CPU usage
+            sleep(0.1)
           rescue => e
             @status_manager.show_error_status("Control interface error: #{e.message}")
           end

data/lib/aidp/harness/user_interface.rb

@@ -2056,14 +2056,13 @@ module Aidp
         return unless @control_interface_enabled
 
         @control_mutex.synchronize do
-          return if @control_thread&.alive?
+          return if @control_future&.pending?
 
-          # Start control interface using Async (skip in test mode)
+          # Start control interface using concurrent-ruby (skip in test mode)
+          # Using Concurrent::Future for background execution with proper thread pool management
           unless ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            require "async"
-            Async do |task|
-              task.async { control_interface_loop }
-            end
+            require "concurrent"
+            @control_future = Concurrent::Future.execute { control_interface_loop }
           end
         end
 
@@ -2079,9 +2078,9 @@ module Aidp
       # Stop the control interface
       def stop_control_interface
         @control_mutex.synchronize do
-          if @control_thread&.alive?
-            @control_thread.kill
-            @control_thread = nil
+          if @control_future
+            @control_future.cancel
+            @control_future = nil
           end
         end
 
@@ -2153,10 +2152,9 @@ module Aidp
           elsif resume_requested?
             handle_resume_state
             break
-          elsif ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            sleep(0.1)
           else
-            Async::Task.current.sleep(0.1)
+            # Periodic check for user input/state changes
+            sleep(0.1)
           end
         end
       end
@@ -2400,10 +2398,9 @@ module Aidp
           elsif Time.now - start_time > timeout_seconds
             display_message("\n⏰ Control interface timeout reached. Continuing execution...", type: :warning)
             break
-          elsif ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            sleep(0.1)
           else
-            Async::Task.current.sleep(0.1)
+            # Periodic check for user confirmation
+            sleep(0.1)
           end
         end
       end

data/lib/aidp/init/doc_generator.rb

@@ -32,10 +32,11 @@ module Aidp
 
       def write_style_guide(analysis, preferences)
         languages = format_list(analysis[:languages].keys)
-        frameworks = format_list(analysis[:frameworks])
-        test_frameworks = format_list(analysis[:test_frameworks])
+        # Extract high-confidence frameworks (>= 0.7)
+        frameworks = extract_confident_names(analysis[:frameworks], threshold: 0.7)
+        test_frameworks = extract_confident_names(analysis[:test_frameworks], threshold: 0.7)
         key_dirs = format_list(analysis[:key_directories])
-        tooling = analysis[:tooling].keys.map { |tool| format_tool(tool) }.sort
+        tooling = extract_confident_names(analysis[:tooling], threshold: 0.7, key: :tool).map { |tool| format_tool(tool) }.sort
 
         adoption_note = if truthy?(preferences[:adopt_new_conventions])
           "This project has opted to adopt new conventions recommended by aidp init. When in doubt, prefer the rules below over legacy patterns."
@@ -43,14 +44,17 @@ module Aidp
           "Retain existing conventions when they do not conflict with the guidance below."
         end
 
+        frameworks_text = frameworks.empty? ? "None detected" : frameworks.join(", ")
+        test_frameworks_text = test_frameworks.empty? ? "Unknown" : test_frameworks.join(", ")
+
         content = <<~GUIDE
           # Project LLM Style Guide
 
           > Generated automatically by `aidp init` on #{Time.now.utc.iso8601}.
           >
           > Detected languages: #{languages}
-          > Framework hints: #{frameworks.empty? ? "None detected" : frameworks}
-          > Primary test frameworks: #{test_frameworks.empty? ? "Unknown" : test_frameworks}
+          > Framework hints: #{frameworks_text}
+          > Primary test frameworks: #{test_frameworks_text}
           > Key directories: #{key_dirs.empty? ? "Standard structure" : key_dirs}
 
           #{adoption_note}
@@ -115,9 +119,10 @@ module Aidp
 
       def write_project_analysis(analysis)
         languages = format_language_breakdown(analysis[:languages])
-        frameworks = bullet_list(analysis[:frameworks], default: "_None detected_")
+        frameworks = format_framework_detection(analysis[:frameworks])
+        test_frameworks = format_framework_detection(analysis[:test_frameworks])
         config_files = bullet_list(analysis[:config_files], default: "_No dedicated configuration files discovered_")
-        tooling = format_tooling_section(analysis[:tooling])
+        tooling = format_tooling_detection(analysis[:tooling])
 
         stats = analysis[:repo_stats]
         stats_lines = [
@@ -146,7 +151,7 @@ module Aidp
           #{config_files}
 
           ## Test & Quality Signals
-          #{bullet_list(analysis[:test_frameworks], prefix: "- Detected test suite: ", default: "_Unable to infer test suite_")}
+          #{test_frameworks}
 
           ## Local Quality Toolchain
           #{tooling}
@@ -175,13 +180,19 @@ module Aidp
           "- Keep legacy style deviations documented until dedicated refactors are scheduled.\n"
         end
 
+        tooling_section = if tooling.empty?
+          "_No linting/formatting tools detected. Consider adding RuboCop, ESLint, or Prettier based on the primary language._"
+        else
+          format_tooling_detection_table(tooling)
+        end
+
         content = <<~PLAN
           # Code Quality Plan
 
           This plan captures the current tooling landscape and proposes next steps for keeping the codebase healthy. Generated by `aidp init` on #{Time.now.utc.iso8601}.
 
           ## Local Quality Toolchain
-          #{tooling.empty? ? "_No linting/formatting tools detected. Consider adding RuboCop, ESLint, or Prettier based on the primary language._" : format_tooling_table(tooling)}
+          #{tooling_section}
 
           ## Immediate Actions
           #{proactive}#{migration}- Document onboarding steps in `docs/` to ensure future contributors follow the agreed workflow.
@@ -189,7 +200,7 @@ module Aidp
           ## Long-Term Improvements
           - Keep the style guide in sync with real-world code changes; regenerate with `aidp init` after major rewrites.
           - Automate test and lint runs via CI (detected: #{analysis.dig(:repo_stats, :has_ci_config) ? "yes" : "no"}).
-          - Track flaky tests or unstable tooling in `PROJECT_ANALYSIS.md` under a “Health Log” section.
+          - Track flaky tests or unstable tooling in `PROJECT_ANALYSIS.md` under a "Health Log" section.
 
           ---
           Based on templates: `analysis/analyze_static_code.md`, `analysis/analyze_tests.md`.
@@ -251,6 +262,60 @@ module Aidp
       rescue
         false
       end
+
+      # Extract confident names from detection results
+      def extract_confident_names(detections, threshold: 0.7, key: :name)
+        return [] if detections.nil? || detections.empty?
+
+        detections.select { |d| d[:confidence] >= threshold }.map { |d| d[key] }
+      end
+
+      # Format framework detection with confidence levels
+      def format_framework_detection(detections)
+        return "_None detected_" if detections.nil? || detections.empty?
+
+        lines = detections.map do |detection|
+          name = detection[:name]
+          confidence = (detection[:confidence] * 100).round
+          evidence = detection[:evidence].join("; ")
+          "- **#{name}** (#{confidence}% confidence)\n  - Evidence: #{evidence}"
+        end
+
+        lines.join("\n")
+      end
+
+      # Format tooling detection with confidence levels
+      def format_tooling_detection(tooling)
+        return "_No tooling detected._" if tooling.nil? || tooling.empty?
+
+        header = "| Tool | Confidence | Evidence |\n|------|------------|----------|"
+        rows = tooling.map do |tool_data|
+          tool_name = format_tool(tool_data[:tool])
+          confidence = "#{(tool_data[:confidence] * 100).round}%"
+          evidence = tool_data[:evidence].join(", ")
+          "| #{tool_name} | #{confidence} | #{evidence} |"
+        end
+
+        ([header] + rows).join("\n")
+      end
+
+      # Format tooling detection table for quality plan
+      def format_tooling_detection_table(tooling)
+        return "_No tooling detected._" if tooling.nil? || tooling.empty?
+
+        header = "| Tool | Evidence |\n|------|----------|"
+        rows = tooling.select { |t| t[:confidence] >= 0.7 }.map do |tool_data|
+          tool_name = format_tool(tool_data[:tool])
+          evidence = tool_data[:evidence].join(", ")
+          "| #{tool_name} | #{evidence} |"
+        end
+
+        if rows.empty?
+          "_No high-confidence tooling detected. Consider adding linting and formatting tools._"
+        else
+          ([header] + rows).join("\n")
+        end
+      end
     end
   end
 end

data/lib/aidp/init/project_analyzer.rb

@@ -155,7 +155,9 @@ module Aidp
         @project_dir = project_dir
       end
 
-      def analyze
+      def analyze(options = {})
+        @explain_detection = options[:explain_detection] || false
+
         {
           languages: detect_languages,
           frameworks: detect_frameworks,
@@ -185,21 +187,57 @@ module Aidp
       end
 
       def detect_frameworks
-        frameworks = Set.new
+        results = []
 
         FRAMEWORK_HINTS.each do |framework, rules|
-          if rules[:files]&.any? { |file| project_glob?(file) }
-            if rules[:contents]
-              frameworks << framework if rules[:contents].any? { |pattern| search_files_for_pattern(rules[:files], pattern) }
-            else
-              frameworks << framework
+          evidence = []
+          confidence = 0.0
+
+          # Check for required files
+          matched_files = []
+          if rules[:files]
+            matched_files = rules[:files].select { |file| project_glob?(file) }
+            if matched_files.any?
+              evidence << "Found files: #{matched_files.join(", ")}"
+              confidence += 0.3
+            end
+          end
+
+          # Check for content patterns in specific files or across project
+          if rules[:contents]
+            rules[:contents].each do |pattern|
+              if matched_files.any?
+                # Search only in the matched files
+                if search_files_for_pattern(matched_files, pattern)
+                  evidence << "Found pattern '#{pattern.inspect}' in #{matched_files.join(", ")}"
+                  confidence += 0.7
+                end
+              elsif search_project_for_pattern(pattern)
+                # Search across all project files (less confident)
+                evidence << "Found pattern '#{pattern.inspect}' in project files"
+                confidence += 0.4
+              end
             end
-          elsif rules[:contents]&.any? { |pattern| search_project_for_pattern(pattern) }
-            frameworks << framework
+          elsif matched_files.any?
+            # Files exist but no content check needed - moderately confident
+            confidence = 0.6
+          end
+
+          # Only include frameworks with evidence
+          if evidence.any? && confidence > 0.0
+            # Cap confidence at 1.0
+            confidence = [confidence, 1.0].min
+
+            results << {
+              name: framework,
+              confidence: confidence,
+              evidence: evidence
+            }
           end
         end
 
-        frameworks.to_a.sort
+        # Sort by confidence (descending) then name
+        results.sort_by { |r| [-r[:confidence], r[:name]] }
       end
 
       def detect_key_directories
@@ -212,28 +250,82 @@ module Aidp
 
       def detect_test_frameworks
         results = []
+        dependency_files = ["Gemfile", "Gemfile.lock", "package.json", "pyproject.toml", "requirements.txt", "go.mod", "mix.exs", "composer.json", "Cargo.toml"]
 
         TEST_FRAMEWORK_HINTS.each do |framework, hints|
-          has_directory = hints[:directories]&.any? { |dir| Dir.exist?(File.join(project_dir, dir)) }
-          has_dependency = hints[:dependencies]&.any? { |pattern| search_project_for_pattern(pattern, limit_files: ["Gemfile", "Gemfile.lock", "package.json", "pyproject.toml", "requirements.txt", "go.mod", "mix.exs", "composer.json", "Cargo.toml"]) }
-          has_files = hints[:files]&.any? { |glob| project_glob?(glob) }
+          evidence = []
+          confidence = 0.0
+
+          # Check for test directories
+          if hints[:directories]
+            found_dirs = hints[:directories].select { |dir| Dir.exist?(File.join(project_dir, dir)) }
+            if found_dirs.any?
+              evidence << "Found directories: #{found_dirs.join(", ")}"
+              confidence += 0.5
+            end
+          end
+
+          # Check for dependencies in lockfiles/manifests
+          hints[:dependencies]&.each do |pattern|
+            matched_files = []
+            dependency_files.each do |dep_file|
+              path = File.join(project_dir, dep_file)
+              next unless File.exist?(path)
+
+              begin
+                if File.read(path).match?(pattern)
+                  matched_files << dep_file
+                end
+              rescue Errno::ENOENT, ArgumentError, Encoding::InvalidByteSequenceError
+                next
+              end
+            end
+
+            if matched_files.any?
+              evidence << "Found dependency pattern '#{pattern.inspect}' in #{matched_files.join(", ")}"
+              confidence += 0.6
+            end
+          end
 
-          results << framework if has_directory || has_dependency || has_files
+          # Check for test files
+          if hints[:files]
+            matched_globs = hints[:files].select { |glob| project_glob?(glob) }
+            if matched_globs.any?
+              evidence << "Found test files matching: #{matched_globs.join(", ")}"
+              confidence += 0.4
+            end
+          end
+
+          # Only include test frameworks with evidence
+          if evidence.any? && confidence > 0.0
+            confidence = [confidence, 1.0].min
+
+            results << {
+              name: framework,
+              confidence: confidence,
+              evidence: evidence
+            }
+          end
         end
 
-        results.uniq.sort
+        # Sort by confidence (descending) then name
+        results.sort_by { |r| [-r[:confidence], r[:name]] }
       end
 
       def detect_tooling
-        tooling = Hash.new { |hash, key| hash[key] = [] }
+        results = []
 
         TOOLING_HINTS.each do |tool, indicators|
-          hit = indicators.any? do |indicator|
-            if indicator.include?("*")
-            end
-            project_glob?(indicator)
+          evidence = []
+          confidence = 0.0
+
+          matched_indicators = indicators.select { |indicator| project_glob?(indicator) }
+          if matched_indicators.any?
+            evidence << "Found config files: #{matched_indicators.join(", ")}"
+            confidence += 0.8
           end
-          tooling[tool] << "config" if hit
+
+          results << {tool: tool, evidence: evidence, confidence: confidence} if evidence.any?
         end
 
         # Post-process for package.json to extract scripts referencing linters
@@ -242,15 +334,31 @@ module Aidp
           begin
             json = JSON.parse(File.read(package_json_path))
             scripts = json.fetch("scripts", {})
-            tooling[:eslint] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("eslint") }
-            tooling[:prettier] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("prettier") }
-            tooling[:jest] << "package.json scripts" if scripts.values.any? { |cmd| cmd.include?("jest") }
+
+            [:eslint, :prettier, :jest].each do |tool|
+              tool_str = tool.to_s
+              if scripts.values.any? { |cmd| cmd.include?(tool_str) }
+                # Check if we already have this tool from config detection
+                existing = results.find { |r| r[:tool] == tool }
+                if existing
+                  existing[:evidence] << "Referenced in package.json scripts"
+                  existing[:confidence] = [existing[:confidence] + 0.3, 1.0].min
+                else
+                  results << {
+                    tool: tool,
+                    evidence: ["Referenced in package.json scripts"],
+                    confidence: 0.6
+                  }
+                end
+              end
+            end
           rescue JSON::ParserError
             # ignore malformed package.json
           end
         end
 
-        tooling.delete_if { |_tool, evidence| evidence.empty? }
+        # Sort by confidence (descending) then tool name
+        results.sort_by { |r| [-r[:confidence], r[:tool].to_s] }
       end
 
       def collect_repo_stats
@@ -306,13 +414,33 @@ module Aidp
       def search_files_for_pattern(files, pattern)
         files.any? do |file|
           Dir.glob(File.join(project_dir, file)).any? do |path|
-            File.read(path).match?(pattern)
+            # Special handling for package.json - only search in dependencies
+            if File.basename(path) == "package.json"
+              check_package_json_dependency(path, pattern)
+            else
+              File.read(path).match?(pattern)
+            end
           rescue Errno::ENOENT, Errno::EISDIR
             false
           end
         end
       end
 
+      def check_package_json_dependency(path, pattern)
+        json = JSON.parse(File.read(path))
+        deps = json.fetch("dependencies", {})
+        dev_deps = json.fetch("devDependencies", {})
+        peer_deps = json.fetch("peerDependencies", {})
+
+        all_deps = deps.keys + dev_deps.keys + peer_deps.keys
+        all_deps.any? { |dep| dep.match?(pattern) }
+      rescue JSON::ParserError, Errno::ENOENT
+        # Fallback to simple text search if JSON parsing fails
+        File.read(path).match?(pattern)
+      rescue
+        false
+      end
+
       def search_project_for_pattern(pattern, limit_files: nil)
         if limit_files
           limit_files.any? do |file|