aidp 0.17.0 → 0.18.0

data/lib/aidp/execute/repl_macros.rb

@@ -275,6 +275,24 @@ module Aidp
             usage: "/skill <list|show|use> [args]",
             example: "/skill list",
             handler: method(:cmd_skill)
+          },
+          "/tools" => {
+            description: "Manage available tools (coverage, testing, etc.)",
+            usage: "/tools <show|coverage|test> [subcommand]",
+            example: "/tools show",
+            handler: method(:cmd_tools)
+          },
+          "/thinking" => {
+            description: "Manage thinking depth tier for model selection",
+            usage: "/thinking <show|set|max|reset> [tier]",
+            example: "/thinking show",
+            handler: method(:cmd_thinking)
+          },
+          "/prompt" => {
+            description: "Inspect and control prompt optimization",
+            usage: "/prompt <explain|stats|expand|reset>",
+            example: "/prompt explain",
+            handler: method(:cmd_prompt)
           }
         }
       end
@@ -1489,6 +1507,543 @@ module Aidp
           }
         end
       end
+
+      # /tools command - manage available tools
+      def cmd_tools(args)
+        Aidp.log_debug("repl_macros", "Executing /tools command", args: args)
+
+        subcommand = args[0]&.downcase
+
+        case subcommand
+        when "show"
+          cmd_tools_show
+        when "coverage"
+          cmd_tools_coverage(args[1..])
+        when "test"
+          cmd_tools_test(args[1..])
+        else
+          {
+            success: false,
+            message: "Usage: /tools <command> [args]\n\nCommands:\n  show           - Show configured tools and their status\n  coverage       - Run coverage analysis and show delta\n  test <type>    - Run interactive tests (web, cli, desktop)\n\nExamples:\n  /tools show\n  /tools coverage\n  /tools test web",
+            action: :none
+          }
+        end
+      end
+
+      def cmd_tools_show
+        require_relative "../harness/configuration"
+
+        begin
+          config = Aidp::Harness::Configuration.new(@project_dir)
+
+          output = ["📊 Configured Tools\n", "=" * 50]
+
+          # Coverage tools
+          if config.coverage_enabled?
+            output << "\n🔍 Coverage:"
+            output << "  Tool: #{config.coverage_tool || "not specified"}"
+            output << "  Command: #{config.coverage_run_command || "not specified"}"
+            output << "  Report paths: #{config.coverage_report_paths.join(", ")}" if config.coverage_report_paths.any?
+            output << "  Fail on drop: #{config.coverage_fail_on_drop? ? "yes" : "no"}"
+            output << "  Minimum coverage: #{config.coverage_minimum || "not set"}%" if config.coverage_minimum
+          else
+            output << "\n🔍 Coverage: disabled"
+          end
+
+          # VCS configuration
+          output << "\n\n🗂️  Version Control:"
+          output << "  Tool: #{config.vcs_tool}"
+          output << "  Behavior: #{config.vcs_behavior}"
+          output << "  Conventional commits: #{config.conventional_commits? ? "yes" : "no"}"
+
+          # Interactive testing
+          if config.interactive_testing_enabled?
+            output << "\n\n🎯 Interactive Testing:"
+            output << "  App type: #{config.interactive_testing_app_type}"
+            tools = config.interactive_testing_tools
+            if tools.any?
+              tools.each do |category, category_tools|
+                output << "  #{category.to_s.capitalize}:"
+                category_tools.each do |tool_name, tool_config|
+                  next unless tool_config[:enabled]
+                  output << "    • #{tool_name}: enabled"
+                  output << "      Run: #{tool_config[:run]}" if tool_config[:run]
+                  output << "      Specs: #{tool_config[:specs_dir]}" if tool_config[:specs_dir]
+                end
+              end
+            else
+              output << "  No tools configured"
+            end
+          else
+            output << "\n\n🎯 Interactive Testing: disabled"
+          end
+
+          # Model families
+          output << "\n\n🤖 Model Families:"
+          config.configured_providers.each do |provider|
+            family = config.model_family(provider)
+            output << "  #{provider}: #{family}"
+          end
+
+          {
+            success: true,
+            message: output.join("\n"),
+            action: :none
+          }
+        rescue => e
+          Aidp.log_error("repl_macros", "Failed to show tools", error: e.message)
+          {
+            success: false,
+            message: "Failed to load tool configuration: #{e.message}",
+            action: :none
+          }
+        end
+      end
+
+      def cmd_tools_coverage(args)
+        require_relative "../harness/configuration"
+
+        begin
+          config = Aidp::Harness::Configuration.new(@project_dir)
+
+          unless config.coverage_enabled?
+            return {
+              success: false,
+              message: "Coverage is not enabled. Run 'aidp config --interactive' to configure coverage.",
+              action: :none
+            }
+          end
+
+          unless config.coverage_run_command
+            return {
+              success: false,
+              message: "Coverage run command not configured. Run 'aidp config --interactive' to set it up.",
+              action: :none
+            }
+          end
+
+          Aidp.log_debug("repl_macros", "Running coverage", command: config.coverage_run_command)
+
+          {
+            success: true,
+            message: "Running coverage with: #{config.coverage_run_command}\n(Coverage execution to be implemented in work loop)",
+            action: :run_coverage,
+            data: {
+              command: config.coverage_run_command,
+              tool: config.coverage_tool,
+              report_paths: config.coverage_report_paths
+            }
+          }
+        rescue => e
+          Aidp.log_error("repl_macros", "Failed to run coverage", error: e.message)
+          {
+            success: false,
+            message: "Failed to run coverage: #{e.message}",
+            action: :none
+          }
+        end
+      end
+
+      def cmd_tools_test(args)
+        require_relative "../harness/configuration"
+
+        test_type = args[0]&.downcase
+
+        begin
+          config = Aidp::Harness::Configuration.new(@project_dir)
+
+          unless config.interactive_testing_enabled?
+            return {
+              success: false,
+              message: "Interactive testing is not enabled. Run 'aidp config --interactive' to configure it.",
+              action: :none
+            }
+          end
+
+          unless test_type
+            return {
+              success: false,
+              message: "Usage: /tools test <type>\n\nTypes: web, cli, desktop\n\nExample: /tools test web",
+              action: :none
+            }
+          end
+
+          unless %w[web cli desktop].include?(test_type)
+            return {
+              success: false,
+              message: "Invalid test type: #{test_type}. Must be one of: web, cli, desktop",
+              action: :none
+            }
+          end
+
+          tools = config.interactive_testing_tools.dig(test_type.to_sym)
+          unless tools&.any? { |_, t| t[:enabled] }
+            return {
+              success: false,
+              message: "No #{test_type} testing tools configured. Run 'aidp config --interactive' to set them up.",
+              action: :none
+            }
+          end
+
+          enabled_tools = tools.select { |_, t| t[:enabled] }
+          tool_list = enabled_tools.map { |name, cfg| "  • #{name}: #{cfg[:run] || "no command"}" }.join("\n")
+
+          Aidp.log_debug("repl_macros", "Running interactive tests", type: test_type, tools: enabled_tools.keys)
+
+          {
+            success: true,
+            message: "Running #{test_type} tests:\n#{tool_list}\n(Test execution to be implemented in work loop)",
+            action: :run_interactive_tests,
+            data: {
+              test_type: test_type,
+              tools: enabled_tools
+            }
+          }
+        rescue => e
+          Aidp.log_error("repl_macros", "Failed to run interactive tests", error: e.message)
+          {
+            success: false,
+            message: "Failed to run interactive tests: #{e.message}",
+            action: :none
+          }
+        end
+      end
+
+      # Command: /thinking
+      def cmd_thinking(args)
+        subcommand = args[0]
+
+        case subcommand
+        when "show"
+          cmd_thinking_show
+        when "set"
+          cmd_thinking_set(args[1])
+        when "max"
+          cmd_thinking_max(args[1])
+        when "reset"
+          cmd_thinking_reset
+        else
+          {
+            success: false,
+            message: "Unknown subcommand: #{subcommand}\nUsage: /thinking <show|set|max|reset> [tier]",
+            action: :none
+          }
+        end
+      rescue => e
+        Aidp.log_error("repl_macros", "Failed to execute thinking command", error: e.message)
+        {
+          success: false,
+          message: "Failed to execute thinking command: #{e.message}",
+          action: :none
+        }
+      end
+
+      # Subcommand: /thinking show
+      def cmd_thinking_show
+        require_relative "../harness/configuration"
+        require_relative "../harness/thinking_depth_manager"
+
+        config = Aidp::Harness::Configuration.new(@project_dir)
+        manager = Aidp::Harness::ThinkingDepthManager.new(config, root_dir: @project_dir)
+
+        lines = []
+        lines << "Thinking Depth Configuration:"
+        lines << ""
+        lines << "Current Tier: #{manager.current_tier}"
+        lines << "Default Tier: #{manager.default_tier}"
+        lines << "Max Tier: #{manager.max_tier}"
+        lines << ""
+
+        # Show all available tiers
+        require_relative "../harness/capability_registry"
+        lines << "Available Tiers:"
+        Aidp::Harness::CapabilityRegistry::VALID_TIERS.each do |tier|
+          marker = if tier == manager.current_tier
+            "→"
+          elsif tier == manager.max_tier
+            "↑"
+          else
+            " "
+          end
+          lines << "  #{marker} #{tier}"
+        end
+        lines << ""
+        lines << "Legend: → current, ↑ max allowed"
+        lines << ""
+
+        # Show current model selection
+        current_model = manager.select_model_for_tier
+        if current_model
+          provider, model_name, model_data = current_model
+          lines << "Current Model: #{provider}/#{model_name}"
+          lines << "  Tier: #{model_data["tier"]}" if model_data["tier"]
+          lines << "  Context Window: #{model_data["context_window"]}" if model_data["context_window"]
+        else
+          lines << "Current Model: (none selected)"
+        end
+
+        lines << ""
+        lines << "Provider Switching: #{config.allow_provider_switch_for_tier? ? "enabled" : "disabled"}"
+
+        # Show escalation config
+        escalation = config.escalation_config
+        lines << ""
+        lines << "Escalation Settings:"
+        lines << "  Fail Attempts Threshold: #{escalation[:on_fail_attempts]}"
+        if escalation[:on_complexity_threshold]&.any?
+          lines << "  Complexity Thresholds:"
+          escalation[:on_complexity_threshold].each do |key, value|
+            lines << "    #{key}: #{value}"
+          end
+        end
+
+        {
+          success: true,
+          message: lines.join("\n"),
+          action: :display
+        }
+      end
+
+      # Subcommand: /thinking set <tier>
+      def cmd_thinking_set(tier)
+        unless tier
+          return {
+            success: false,
+            message: "Usage: /thinking set <tier>\nTiers: mini, standard, thinking, pro, max",
+            action: :none
+          }
+        end
+
+        require_relative "../harness/configuration"
+        require_relative "../harness/thinking_depth_manager"
+
+        config = Aidp::Harness::Configuration.new(@project_dir)
+        manager = Aidp::Harness::ThinkingDepthManager.new(config, root_dir: @project_dir)
+
+        old_tier = manager.current_tier
+        manager.current_tier = tier
+
+        {
+          success: true,
+          message: "Thinking tier changed: #{old_tier} → #{tier}\nMax tier: #{manager.max_tier}",
+          action: :tier_changed
+        }
+      rescue ArgumentError => e
+        {
+          success: false,
+          message: "Invalid tier: #{e.message}\nValid tiers: mini, standard, thinking, pro, max",
+          action: :none
+        }
+      end
+
+      # Subcommand: /thinking max <tier>
+      def cmd_thinking_max(tier)
+        unless tier
+          return {
+            success: false,
+            message: "Usage: /thinking max <tier>\nTiers: mini, standard, thinking, pro, max",
+            action: :none
+          }
+        end
+
+        require_relative "../harness/configuration"
+        require_relative "../harness/thinking_depth_manager"
+
+        config = Aidp::Harness::Configuration.new(@project_dir)
+        manager = Aidp::Harness::ThinkingDepthManager.new(config, root_dir: @project_dir)
+
+        old_max = manager.max_tier
+        manager.max_tier = tier
+
+        {
+          success: true,
+          message: "Max tier changed: #{old_max} → #{tier}\nCurrent tier: #{manager.current_tier}",
+          action: :max_tier_changed
+        }
+      rescue ArgumentError => e
+        {
+          success: false,
+          message: "Invalid tier: #{e.message}\nValid tiers: mini, standard, thinking, pro, max",
+          action: :none
+        }
+      end
+
+      # Subcommand: /thinking reset
+      def cmd_thinking_reset
+        require_relative "../harness/configuration"
+        require_relative "../harness/thinking_depth_manager"
+
+        config = Aidp::Harness::Configuration.new(@project_dir)
+        manager = Aidp::Harness::ThinkingDepthManager.new(config, root_dir: @project_dir)
+
+        old_tier = manager.current_tier
+        manager.reset_to_default
+
+        {
+          success: true,
+          message: "Thinking tier reset: #{old_tier} → #{manager.current_tier}\nEscalation count cleared",
+          action: :tier_reset
+        }
+      end
+
+      # Command: /prompt - Inspect and control prompt optimization
+      def cmd_prompt(args)
+        subcommand = args[0]
+
+        case subcommand
+        when "explain"
+          cmd_prompt_explain
+        when "stats"
+          cmd_prompt_stats
+        when "expand"
+          cmd_prompt_expand(args[1])
+        when "reset"
+          cmd_prompt_reset
+        else
+          {
+            success: false,
+            message: "Unknown subcommand: #{subcommand}\nUsage: /prompt <explain|stats|expand|reset>",
+            action: :none
+          }
+        end
+      rescue => e
+        Aidp.log_error("repl_macros", "Failed to execute prompt command", error: e.message)
+        {
+          success: false,
+          message: "Failed to execute prompt command: #{e.message}",
+          action: :none
+        }
+      end
+
+      # Subcommand: /prompt explain
+      # Shows which fragments were selected for the current prompt and why
+      def cmd_prompt_explain
+        require_relative "prompt_manager"
+
+        prompt_manager = PromptManager.new(@project_dir, config: load_config)
+
+        unless prompt_manager.optimization_enabled?
+          return {
+            success: false,
+            message: "Prompt optimization is not enabled. Check your .aidp/config.yml:\n" \
+                     "prompt_optimization:\n  enabled: true",
+            action: :none
+          }
+        end
+
+        unless prompt_manager.last_optimization_stats
+          return {
+            success: false,
+            message: "No optimization performed yet. Prompt optimization will be used on the next work loop iteration.",
+            action: :none
+          }
+        end
+
+        report = prompt_manager.optimization_report
+        {
+          success: true,
+          message: report,
+          action: :show_optimization_report
+        }
+      end
+
+      # Subcommand: /prompt stats
+      # Shows overall optimizer statistics across all runs
+      def cmd_prompt_stats
+        require_relative "prompt_manager"
+
+        prompt_manager = PromptManager.new(@project_dir, config: load_config)
+
+        unless prompt_manager.optimization_enabled?
+          return {
+            success: false,
+            message: "Prompt optimization is not enabled.",
+            action: :none
+          }
+        end
+
+        stats = prompt_manager.optimizer_stats
+        unless stats
+          return {
+            success: false,
+            message: "No optimization statistics available.",
+            action: :none
+          }
+        end
+
+        lines = []
+        lines << "# Prompt Optimizer Statistics"
+        lines << ""
+        lines << "- **Total Runs**: #{stats[:runs_count]}"
+        lines << "- **Total Fragments Indexed**: #{stats[:total_fragments_indexed]}"
+        lines << "- **Total Fragments Selected**: #{stats[:total_fragments_selected]}"
+        lines << "- **Total Fragments Excluded**: #{stats[:total_fragments_excluded]}"
+        lines << "- **Total Tokens Used**: #{stats[:total_tokens_used]}"
+        lines << "- **Average Fragments/Run**: #{stats[:average_fragments_selected]}"
+        lines << "- **Average Budget Utilization**: #{stats[:average_budget_utilization]}%"
+        lines << "- **Average Optimization Time**: #{stats[:average_optimization_time_ms]}ms"
+
+        {
+          success: true,
+          message: lines.join("\n"),
+          action: :show_optimizer_stats
+        }
+      end
+
+      # Subcommand: /prompt expand <fragment_id>
+      # Adds a specific omitted fragment to the next prompt
+      def cmd_prompt_expand(fragment_id)
+        unless fragment_id
+          return {
+            success: false,
+            message: "Usage: /prompt expand <fragment_id>\nUse /prompt explain to see available fragments",
+            action: :none
+          }
+        end
+
+        # For now, this is a placeholder - full implementation would:
+        # 1. Look up the fragment by ID
+        # 2. Add it to an override list
+        # 3. Include it in the next prompt generation
+        {
+          success: true,
+          message: "Fragment expansion not yet implemented.\n" \
+                   "This will be available in a future update to manually include excluded fragments.",
+          action: :feature_not_implemented
+        }
+      end
+
+      # Subcommand: /prompt reset
+      # Clears optimizer cache and resets to default behavior
+      def cmd_prompt_reset
+        require_relative "prompt_manager"
+
+        prompt_manager = PromptManager.new(@project_dir, config: load_config)
+
+        unless prompt_manager.optimization_enabled?
+          return {
+            success: false,
+            message: "Prompt optimization is not enabled.",
+            action: :none
+          }
+        end
+
+        prompt_manager.optimizer.clear_cache
+
+        {
+          success: true,
+          message: "Optimizer cache cleared. Next prompt will use fresh indexing.",
+          action: :optimizer_reset
+        }
+      end
+
+      private
+
+      # Load configuration for prompt commands
+      def load_config
+        require_relative "../harness/configuration"
+        Aidp::Harness::Configuration.new(@project_dir)
+      end
     end
   end
 end

data/lib/aidp/execute/work_loop_runner.rb

@@ -46,7 +46,7 @@ module Aidp
         @project_dir = project_dir
         @provider_manager = provider_manager
         @config = config
-        @prompt_manager = PromptManager.new(project_dir)
+        @prompt_manager = PromptManager.new(project_dir, config: config)
         @test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
         @checkpoint = Checkpoint.new(project_dir)
         @checkpoint_display = CheckpointDisplay.new
@@ -343,6 +343,16 @@ module Aidp
 
       # Create initial PROMPT.md with all context
       def create_initial_prompt(step_spec, context)
+        # Try intelligent prompt optimization first (ZFC-powered)
+        if @prompt_manager.optimization_enabled?
+          if create_optimized_prompt(step_spec, context)
+            return
+          end
+          # Fallback to traditional prompt on optimization failure
+          display_message("  ⚠️  Prompt optimization failed, using traditional approach", type: :warning)
+        end
+
+        # Traditional prompt building (fallback or when optimization disabled)
         template_content = load_template(step_spec["templates"]&.first)
         prd_content = load_prd
         style_guide = load_style_guide
@@ -364,6 +374,103 @@ module Aidp
         display_message("  Created PROMPT.md (#{initial_prompt.length} chars)", type: :info)
       end
 
+      # Create prompt using intelligent optimization (Zero Framework Cognition)
+      # Selects only the most relevant fragments from style guide, templates, and code
+      def create_optimized_prompt(step_spec, context)
+        user_input = format_user_input(context[:user_input])
+
+        # Infer task type from step name
+        task_type = infer_task_type(step_spec, user_input)
+
+        # Extract affected files from context or PRD
+        affected_files = extract_affected_files(context, user_input)
+
+        # Build task context for optimizer
+        task_context = {
+          task_type: task_type,
+          description: build_task_description(user_input, context),
+          affected_files: affected_files,
+          step_name: @step_name,
+          tags: extract_tags(user_input, step_spec)
+        }
+
+        # Use optimizer to create prompt
+        success = @prompt_manager.write_optimized(
+          task_context,
+          include_metadata: @config.prompt_log_fragments?
+        )
+
+        if success
+          stats = @prompt_manager.last_optimization_stats
+          display_message("  ✨ Created optimized PROMPT.md", type: :success)
+          display_message("     Selected: #{stats.selected_count} fragments, Excluded: #{stats.excluded_count}", type: :info)
+          display_message("     Tokens: #{stats.total_tokens} (#{stats.budget_utilization.round(1)}% of budget)", type: :info)
+          display_message("     Avg relevance: #{(stats.average_score * 100).round(1)}%", type: :info)
+        end
+
+        success
+      end
+
+      # Infer task type from step name and context
+      def infer_task_type(step_spec, user_input)
+        step_name = @step_name.to_s.downcase
+        input_lower = user_input.to_s.downcase
+
+        return :test if step_name.include?("test") || input_lower.include?("test")
+        return :bugfix if step_name.include?("fix") || input_lower.include?("fix") || input_lower.include?("bug")
+        return :refactor if step_name.include?("refactor") || input_lower.include?("refactor")
+        return :analysis if step_name.include?("analyz") || step_name.include?("review")
+
+        :feature # Default to feature
+      end
+
+      # Extract files that will be affected by this work
+      def extract_affected_files(context, user_input)
+        files = []
+
+        # From user input (e.g., "update lib/user.rb")
+        user_input&.scan(/[\w\/]+\.rb/)&.each do |file|
+          files << file
+        end
+
+        # From deterministic outputs
+        context[:deterministic_outputs]&.each do |output|
+          if output[:output_path]&.end_with?(".rb")
+            files << output[:output_path]
+          end
+        end
+
+        files.uniq
+      end
+
+      # Build task description from context
+      def build_task_description(user_input, context)
+        parts = []
+        parts << user_input if user_input && !user_input.empty?
+        parts << context[:previous_agent_summary] if context[:previous_agent_summary]
+        parts.join("\n\n")
+      end
+
+      # Extract relevant tags from input and spec
+      def extract_tags(user_input, step_spec)
+        tags = []
+        input_lower = user_input.to_s.downcase
+
+        # Common tags from content
+        tags << "testing" if input_lower.include?("test")
+        tags << "security" if input_lower.include?("security") || input_lower.include?("auth")
+        tags << "api" if input_lower.include?("api") || input_lower.include?("endpoint")
+        tags << "database" if input_lower.include?("database") || input_lower.include?("migration")
+        tags << "performance" if input_lower.include?("performance") || input_lower.include?("optim")
+
+        # Tags from step spec
+        if step_spec["tags"]
+          tags.concat(Array(step_spec["tags"]))
+        end
+
+        tags.uniq
+      end
+
       def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:, deterministic_outputs:, previous_agent_summary:)
         parts = []