aidp 0.17.1 → 0.19.0

data/lib/aidp/execute/repl_macros.rb

@@ -275,6 +275,30 @@ 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)
+          },
+          "/tasks" => {
+            description: "Manage persistent tasklist (cross-session task tracking)",
+            usage: "/tasks <list|show|done|abandon|stats> [args]",
+            example: "/tasks list pending",
+            handler: method(:cmd_tasks)
           }
         }
       end
@@ -1489,6 +1513,701 @@ 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
+
+      # Manage persistent tasklist
+      def cmd_tasks(args)
+        tasklist = PersistentTasklist.new(@project_dir)
+        subcommand = args[0]
+
+        case subcommand
+        when "list", nil
+          cmd_tasks_list(tasklist, args[1])
+        when "show"
+          cmd_tasks_show(tasklist, args[1])
+        when "done"
+          cmd_tasks_done(tasklist, args[1])
+        when "abandon"
+          cmd_tasks_abandon(tasklist, args[1], args[2..]&.join(" "))
+        when "stats"
+          cmd_tasks_stats(tasklist)
+        else
+          {
+            success: false,
+            message: "Unknown subcommand: #{subcommand}. Use: list, show, done, abandon, stats",
+            action: :none
+          }
+        end
+      rescue => e
+        Aidp.log_error("repl_macros", "Tasks command failed", error: e.message)
+        {success: false, message: "Error: #{e.message}", action: :none}
+      end
+
+      private
+
+      # List tasks with optional status filter
+      def cmd_tasks_list(tasklist, status_filter = nil)
+        status = status_filter&.to_sym
+        tasks = status ? tasklist.all(status: status) : tasklist.all
+
+        if tasks.empty?
+          message = status ? "No #{status} tasks found." : "No tasks found."
+          return {success: true, message: message, action: :display}
+        end
+
+        # Group by status
+        by_status = tasks.group_by(&:status)
+        output = []
+
+        [:pending, :in_progress, :done, :abandoned].each do |st|
+          next unless by_status[st]
+          next if status && st != status # Skip if filtering by specific status
+
+          output << ""
+          output << "#{st.to_s.upcase.tr("_", " ")} (#{by_status[st].size})"
+          output << "=" * 50
+
+          by_status[st].each do |task|
+            priority_icon = case task.priority
+            when :high then "⚠️ "
+            when :medium then "○ "
+            when :low then "· "
+            end
+
+            age = ((Time.now - task.created_at) / 86400).to_i
+            age_str = (age > 0) ? " (#{age}d ago)" : " (today)"
+
+            output << "  #{priority_icon}[#{task.id}] #{task.description}#{age_str}"
+          end
+        end
+
+        {
+          success: true,
+          message: output.join("\n"),
+          action: :display
+        }
+      end
+
+      # Show detailed information about a specific task
+      def cmd_tasks_show(tasklist, task_id)
+        return {success: false, message: "Usage: /tasks show <task_id>", action: :none} unless task_id
+
+        task = tasklist.find(task_id)
+        unless task
+          return {success: false, message: "Task not found: #{task_id}", action: :none}
+        end
+
+        output = []
+        output << ""
+        output << "Task Details:"
+        output << "=" * 50
+        output << "ID:          #{task.id}"
+        output << "Description: #{task.description}"
+        output << "Status:      #{task.status}"
+        output << "Priority:    #{task.priority}"
+        output << "Created:     #{task.created_at}"
+        output << "Updated:     #{task.updated_at}"
+        output << "Session:     #{task.session}" if task.session
+        output << "Context:     #{task.discovered_during}" if task.discovered_during
+        output << "Started:     #{task.started_at}" if task.started_at
+        output << "Completed:   #{task.completed_at}" if task.completed_at
+        output << "Abandoned:   #{task.abandoned_at} (#{task.abandoned_reason})" if task.abandoned_at
+        output << "Tags:        #{task.tags.join(", ")}" if task.tags&.any?
+
+        {
+          success: true,
+          message: output.join("\n"),
+          action: :display
+        }
+      end
+
+      # Mark a task as done
+      def cmd_tasks_done(tasklist, task_id)
+        return {success: false, message: "Usage: /tasks done <task_id>", action: :none} unless task_id
+
+        task = tasklist.update_status(task_id, :done)
+        {
+          success: true,
+          message: "✓ Task marked as done: #{task.description}",
+          action: :display
+        }
+      rescue PersistentTasklist::TaskNotFoundError
+        {success: false, message: "Task not found: #{task_id}", action: :none}
+      end
+
+      # Abandon a task with optional reason
+      def cmd_tasks_abandon(tasklist, task_id, reason = nil)
+        return {success: false, message: "Usage: /tasks abandon <task_id> [reason]", action: :none} unless task_id
+
+        task = tasklist.update_status(task_id, :abandoned, reason: reason)
+        message = "✗ Task abandoned: #{task.description}"
+        message += " (Reason: #{reason})" if reason
+
+        {
+          success: true,
+          message: message,
+          action: :display
+        }
+      rescue PersistentTasklist::TaskNotFoundError
+        {success: false, message: "Task not found: #{task_id}", action: :none}
+      end
+
+      # Show task statistics
+      def cmd_tasks_stats(tasklist)
+        counts = tasklist.counts
+
+        output = []
+        output << ""
+        output << "Task Statistics:"
+        output << "=" * 50
+        output << "Total:       #{counts[:total]}"
+        output << "Pending:     #{counts[:pending]}"
+        output << "In Progress: #{counts[:in_progress]}"
+        output << "Done:        #{counts[:done]}"
+        output << "Abandoned:   #{counts[:abandoned]}"
+
+        {
+          success: true,
+          message: output.join("\n"),
+          action: :display
+        }
+      end
+
+      private
+
+      # Load configuration for prompt commands
+      def load_config
+        require_relative "../harness/configuration"
+        Aidp::Harness::Configuration.new(@project_dir)
+      end
     end
   end
 end