aidp 0.15.1 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 179466fc22044805c9256aefd1945b799869cf2bbf304c4df049ff5917188c64
-  data.tar.gz: 5c550222222cca3b14c071e05cf5e52ca9994446d8656481dce758b99cd5cf69
+  metadata.gz: '0691816c2748d6704d61bba9ed4c992f1b7d3ac8f70385ac94cb199916b71491'
+  data.tar.gz: e0a8b4a7c9ece98972565635894d7312c4253c2adb3341192c7622e8e28d3a12
 SHA512:
-  metadata.gz: 5b840f4dff232b7ba80b3a38cc78cd244f7c399455b00aecec622cd9106326f003958dd42be8db73a77d8110e6d4a2a5454e11ec8b77386547898333c6b6a704
-  data.tar.gz: a51ac5d52712a3a792beb88bcdd0000f9775dc1d744f98aeaedd54b4f6a82f7f8fb09ec58b090cd014fcf07fae5f5c63db292a146fdd7df87748105a9398c843
+  metadata.gz: 0d3ffce4b6aa8913658862e4412c165c4f20e8164845267d9d85c574b340d4140e63abbae359c47387255081c2738cbdaae215c159e1aeb4d36e7a84b5405dfc
+  data.tar.gz: d2a809ea1b79bbe97e8adfe90903ecb610851837d7b744da208c20e74574346e18e4e3a25ebb136f702fb2501cf5855f1aac0d70d31b6be618c0843a51d5d90f

data/lib/aidp/cli.rb

@@ -353,7 +353,7 @@ module Aidp
         when "mcp" then run_mcp_command(args)
         when "issue" then run_issue_command(args)
         when "config" then run_config_command(args)
-        when "init" then run_init_command
+        when "init" then run_init_command(args)
         when "watch" then run_watch_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
@@ -1015,11 +1015,49 @@ module Aidp
         wizard.run
       end
 
-      def run_init_command
-        runner = Aidp::Init::Runner.new(Dir.pwd, prompt: TTY::Prompt.new)
+      def run_init_command(args = [])
+        options = {}
+
+        until args.empty?
+          token = args.shift
+          case token
+          when "--explain-detection"
+            options[:explain_detection] = true
+          when "--dry-run"
+            options[:dry_run] = true
+          when "--preview"
+            options[:preview] = true
+          when "-h", "--help"
+            display_init_usage
+            return
+          else
+            display_message("Unknown init option: #{token}", type: :error)
+            display_init_usage
+            return
+          end
+        end
+
+        require_relative "init/runner"
+        runner = Aidp::Init::Runner.new(Dir.pwd, prompt: TTY::Prompt.new, options: options)
         runner.run
       end
 
+      def display_init_usage
+        display_message("Usage: aidp init [options]", type: :info)
+        display_message("", type: :info)
+        display_message("Options:", type: :info)
+        display_message("  --explain-detection    Show detailed evidence for all detections", type: :info)
+        display_message("  --dry-run              Run analysis without generating files", type: :info)
+        display_message("  --preview              Show preview before writing files", type: :info)
+        display_message("  -h, --help             Show this help message", type: :info)
+        display_message("", type: :info)
+        display_message("Examples:", type: :info)
+        display_message("  aidp init                           # Run full init workflow", type: :info)
+        display_message("  aidp init --explain-detection       # Show detailed detection evidence", type: :info)
+        display_message("  aidp init --dry-run                 # Preview without writing files", type: :info)
+        display_message("  aidp init --preview                 # Show preview before writing", type: :info)
+      end
+
       def run_watch_command(args)
         if args.empty?
           display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once]", type: :info)

data/lib/aidp/harness/provider_info.rb

@@ -283,7 +283,7 @@ module Aidp
         when "codex"
           "codex"
         when "github_copilot"
-          "gh"
+          "copilot"
         when "opencode"
           "opencode"
         else

data/lib/aidp/harness/provider_manager.rb

@@ -71,19 +71,20 @@ module Aidp
 
       # Switch to next available provider with sophisticated fallback logic
       def switch_provider(reason = "manual_switch", context = {})
-        Aidp.logger.info("provider_manager", "Attempting provider switch", reason: reason, current: current_provider, **context)
+        old_provider = current_provider
+        Aidp.logger.info("provider_manager", "Attempting provider switch", reason: reason, current: old_provider, **context)
 
         # Get fallback chain for current provider
-        provider_fallback_chain = fallback_chain(current_provider)
+        provider_fallback_chain = fallback_chain(old_provider)
 
         # Find next healthy provider in fallback chain
-        next_provider = find_next_healthy_provider(provider_fallback_chain, current_provider)
+        next_provider = find_next_healthy_provider(provider_fallback_chain, old_provider)
 
         if next_provider
           success = set_current_provider(next_provider, reason, context)
           if success
-            log_provider_switch(current_provider, next_provider, reason, context)
-            Aidp.logger.info("provider_manager", "Provider switched successfully", from: current_provider, to: next_provider, reason: reason)
+            log_provider_switch(old_provider, next_provider, reason, context)
+            Aidp.logger.info("provider_manager", "Provider switched successfully", from: old_provider, to: next_provider, reason: reason)
             return next_provider
           else
             Aidp.logger.warn("provider_manager", "Failed to switch to provider", provider: next_provider, reason: reason)
@@ -96,7 +97,7 @@ module Aidp
           if next_provider
             success = set_current_provider(next_provider, reason, context)
             if success
-              log_provider_switch(current_provider, next_provider, reason, context)
+              log_provider_switch(old_provider, next_provider, reason, context)
               return next_provider
             end
           end
@@ -107,14 +108,14 @@ module Aidp
         if next_provider
           success = set_current_provider(next_provider, reason, context)
           if success
-            log_provider_switch(current_provider, next_provider, reason, context)
+            log_provider_switch(old_provider, next_provider, reason, context)
             return next_provider
           end
         end
 
         # No providers available
         log_no_providers_available(reason, context)
-        Aidp.logger.error("provider_manager", "No providers available for fallback", reason: reason, **context)
+        Aidp.logger.error("provider_manager", "No providers available for fallback", reason: reason, provider: old_provider)
         nil
       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|