aidp 0.11.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffba477d4ca2e297b4fe81d7ecb32ccf37d161df6bcd2dceaa91e94ccbc8ea8f
-  data.tar.gz: 851fdc47c7a12bd8f6f8304badf60ffdb6855787d0982645d80a309d9caee40b
+  metadata.gz: e672ad3f8f54f1b3ad0cc4a804a63d1fa048709d47112497d5a4871d046dfb8b
+  data.tar.gz: 665d0b12e5dff272a0da11fd20d80299eaa4657ab7a87fe4e8b0f80e039e437d
 SHA512:
-  metadata.gz: ef68650e5a8c55d8b219a00a42ba7fbff2c87bdd5cacf5f450c8bf406c481d6d1e4c00cd7edabbf41b07928bb28c2b5246c54392e67f52ee8381bac1668d9463
-  data.tar.gz: d2ae0a1bc041b0f8c0cdf1ccb3c328fc7bb1c4ba3cbb0599c983f4937056a8ad1f47e0bcb475a96dd8d4d936cfc6d7452a0333121ed36e29a14708b8e4bd15ec
+  metadata.gz: 384734aed97d697dce2c06ac6bf6f52b161b6436081ff4feb3b8e99e8038bef2b62a9aa3613b21dc92705569741598b98dcbf72805868f6cbdf82a1a19c3c6dd
+  data.tar.gz: 3bd5a990c925f10bb1ad863097b1f0a1e84b682e2489b0793242c37cc4034eb6ac8777559cecb6acaef915391dfeb60337074267e52a1cc4c35aee87c793d672

data/lib/aidp/cli/first_run_wizard.rb

@@ -4,6 +4,7 @@
 require "yaml"
 require "tty-prompt"
 require_relative "../harness/provider_factory"
+require_relative "../config/paths"
 
 module Aidp
   class CLI
@@ -96,13 +97,14 @@ module Aidp
           display_message("Template not found: #{filename}", type: :error)
           return nil
         end
-        dest = File.join(@project_dir, "aidp.yml")
+        dest = Aidp::ConfigPaths.config_file(@project_dir)
+        Aidp::ConfigPaths.ensure_config_dir(@project_dir)
         File.write(dest, File.read(src))
         dest
       end
 
       def write_minimal_config(project_dir)
-        dest = File.join(project_dir, ".aidp", "aidp.yml")
+        dest = Aidp::ConfigPaths.config_file(project_dir)
         return dest if File.exist?(dest)
         data = {
           "harness" => {
@@ -118,18 +120,18 @@ module Aidp
             }
           }
         }
-        FileUtils.mkdir_p(File.dirname(dest))
+        Aidp::ConfigPaths.ensure_config_dir(project_dir)
         File.write(dest, YAML.dump(data))
         dest
       end
 
       def write_example_config(project_dir)
         Aidp::Config.create_example_config(project_dir)
-        File.join(project_dir, "aidp.yml")
+        Aidp::ConfigPaths.config_file(project_dir)
       end
 
       def run_custom
-        dest = File.join(@project_dir, "aidp.yml")
+        dest = Aidp::ConfigPaths.config_file(@project_dir)
         return dest if File.exist?(dest)
 
         @prompt.say("Interactive custom configuration: press Enter to accept defaults shown in [brackets].")
@@ -169,12 +171,13 @@ module Aidp
           },
           "providers" => provider_section
         }
+        Aidp::ConfigPaths.ensure_config_dir(@project_dir)
         File.write(dest, YAML.dump(data))
         dest
       end
 
       def run_custom_with_defaults(existing_config)
-        dest = File.join(@project_dir, "aidp.yml")
+        dest = Aidp::ConfigPaths.config_file(@project_dir)
 
         # Extract current values from existing config
         harness_config = existing_config[:harness] || existing_config["harness"] || {}
@@ -240,12 +243,13 @@ module Aidp
           "providers" => provider_section
         }
 
+        Aidp::ConfigPaths.ensure_config_dir(@project_dir)
         File.write(dest, YAML.dump(data))
         dest
       end
 
       def load_existing_config
-        config_file = File.join(@project_dir, "aidp.yml")
+        config_file = Aidp::ConfigPaths.config_file(@project_dir)
         return nil unless File.exist?(config_file)
 
         begin

data/lib/aidp/cli/mcp_dashboard.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "tty-table"
+require_relative "../harness/provider_info"
+require_relative "../harness/configuration"
+
+module Aidp
+  class CLI
+    # Dashboard for viewing MCP servers across all providers
+    class McpDashboard
+      include Aidp::MessageDisplay
+
+      def initialize(root_dir = nil)
+        @root_dir = root_dir || Dir.pwd
+        @configuration = Aidp::Harness::Configuration.new(@root_dir)
+      end
+
+      # Display MCP dashboard showing all servers across all providers
+      def display_dashboard(options = {})
+        no_color = options[:no_color] || false
+
+        # Gather MCP server information from all providers
+        server_matrix = build_server_matrix
+
+        # Display summary
+        display_message("MCP Server Dashboard", type: :highlight)
+        display_message("=" * 80, type: :muted)
+        display_message("", type: :info)
+
+        # Check if there are any MCP-capable providers
+        if server_matrix[:providers].empty?
+          display_message("No providers with MCP support configured.", type: :info)
+          display_message("MCP is supported by providers like: claude", type: :muted)
+          display_message("\n" + "=" * 80, type: :muted)
+          return
+        end
+
+        # Check if there are any MCP servers configured
+        if server_matrix[:servers].empty?
+          display_message("No MCP servers configured across any providers.", type: :info)
+          display_message("Add MCP servers with: claude mcp add <name> -- <command>", type: :muted)
+          display_message("\n" + "=" * 80, type: :muted)
+          return
+        end
+
+        # Display the main table
+        display_server_table(server_matrix, no_color)
+
+        # Display eligibility warnings
+        display_eligibility_warnings(server_matrix)
+
+        display_message("\n" + "=" * 80, type: :muted)
+      end
+
+      # Get MCP server availability for a specific task requirement
+      def check_task_eligibility(required_servers)
+        server_matrix = build_server_matrix
+        eligible_providers = []
+
+        @configuration.configured_providers.each do |provider|
+          provider_servers = server_matrix[:provider_servers][provider] || []
+          enabled_servers = provider_servers.select { |s| s[:enabled] }.map { |s| s[:name] }
+
+          # Check if provider has all required servers
+          if required_servers.all? { |req| enabled_servers.include?(req) }
+            eligible_providers << provider
+          end
+        end
+
+        {
+          required_servers: required_servers,
+          eligible_providers: eligible_providers,
+          total_providers: @configuration.configured_providers.size
+        }
+      end
+
+      # Display eligibility check for specific servers
+      def display_task_eligibility(required_servers)
+        result = check_task_eligibility(required_servers)
+
+        display_message("\nTask Eligibility Check", type: :highlight)
+        display_message("Required MCP Servers: #{required_servers.join(", ")}", type: :info)
+        display_message("", type: :info)
+
+        if result[:eligible_providers].any?
+          display_message("✓ Eligible Providers (#{result[:eligible_providers].size}/#{result[:total_providers]}):", type: :success)
+          result[:eligible_providers].each do |provider|
+            display_message("  • #{provider}", type: :success)
+          end
+        else
+          display_message("✗ No providers have all required MCP servers", type: :error)
+          display_message("  Consider configuring MCP servers for at least one provider", type: :warning)
+        end
+      end
+
+      private
+
+      def build_server_matrix
+        providers = @configuration.configured_providers
+        all_servers = {} # server_name => {providers: {provider_name => server_info}}
+        provider_servers = {} # provider_name => [server_info]
+
+        providers.each do |provider|
+          provider_info = Aidp::Harness::ProviderInfo.new(provider, @root_dir)
+          info = provider_info.get_info
+
+          next unless info[:mcp_support]
+
+          servers = info[:mcp_servers] || []
+          provider_servers[provider] = servers
+
+          servers.each do |server|
+            server_name = server[:name]
+            all_servers[server_name] ||= {providers: {}}
+            all_servers[server_name][:providers][provider] = server
+          end
+        end
+
+        {
+          servers: all_servers,
+          provider_servers: provider_servers,
+          providers: providers.select { |p| provider_servers.key?(p) }
+        }
+      end
+
+      def display_server_table(matrix, no_color)
+        # Check if we have any providers with MCP support
+        if matrix[:providers].empty?
+          display_message("No providers with MCP support configured.", type: :info)
+          return
+        end
+
+        # Build table rows
+        headers = ["MCP Server"] + matrix[:providers].map { |p| normalize_provider_name(p) }
+        rows = []
+
+        matrix[:servers].keys.sort.each do |server_name|
+          row = [server_name]
+
+          matrix[:providers].each do |provider|
+            server = matrix[:servers][server_name][:providers][provider]
+            cell = if server
+              format_server_status(server, no_color)
+            else
+              (no_color || !$stdout.tty?) ? "-" : "\e[90m-\e[0m"
+            end
+            row << cell
+          end
+
+          rows << row
+        end
+
+        # Create and display table
+        table = TTY::Table.new(headers, rows)
+        display_message(table.render(:basic), type: :info)
+        display_message("", type: :info)
+
+        # Legend
+        display_legend(no_color)
+      end
+
+      def format_server_status(server, no_color)
+        if no_color || !$stdout.tty?
+          server[:enabled] ? "✓" : "✗"
+        elsif server[:enabled]
+          "\e[32m✓\e[0m" # Green checkmark
+        else
+          "\e[31m✗\e[0m" # Red X
+        end
+      end
+
+      def display_legend(no_color)
+        if no_color || !$stdout.tty?
+          display_message("Legend: ✓ = Enabled  ✗ = Error/Disabled  - = Not configured", type: :muted)
+        else
+          display_message("Legend: \e[32m✓\e[0m = Enabled  \e[31m✗\e[0m = Error/Disabled  \e[90m-\e[0m = Not configured", type: :muted)
+        end
+      end
+
+      def display_eligibility_warnings(matrix)
+        # Find servers that are only configured on some providers
+        partially_configured = matrix[:servers].select do |_name, info|
+          configured_count = info[:providers].size
+          configured_count > 0 && configured_count < matrix[:providers].size
+        end
+
+        return if partially_configured.empty?
+
+        display_message("\n⚠ Eligibility Warnings:", type: :warning)
+        partially_configured.each do |server_name, info|
+          missing_providers = matrix[:providers] - info[:providers].keys
+          if missing_providers.any?
+            display_message("  • '#{server_name}' not configured on: #{missing_providers.join(", ")}", type: :warning)
+            display_message("    These providers won't be eligible for tasks requiring this MCP server", type: :muted)
+          end
+        end
+      end
+
+      def normalize_provider_name(name)
+        return "claude" if name == "anthropic"
+        name
+      end
+    end
+  end
+end

data/lib/aidp/cli.rb

@@ -183,7 +183,7 @@ module Aidp
 
         # Initialize the enhanced TUI
         tui = Aidp::Harness::UI::EnhancedTUI.new
-        workflow_selector = Aidp::Harness::UI::EnhancedWorkflowSelector.new(tui)
+        workflow_selector = Aidp::Harness::UI::EnhancedWorkflowSelector.new(tui, project_dir: Dir.pwd)
 
         # Start TUI display loop
         tui.start_display_loop
@@ -245,6 +245,11 @@ module Aidp
           opts.separator "    metrics                  - Show detailed metrics"
           opts.separator "    clear [--force]          - Clear checkpoint data"
           opts.separator "  providers                Show provider health dashboard"
+          opts.separator "    info <name>              - Show detailed provider information"
+          opts.separator "    refresh [name]           - Refresh provider capabilities info"
+          opts.separator "  mcp                      MCP server dashboard and management"
+          opts.separator "    dashboard                - Show all MCP servers across providers"
+          opts.separator "    check <servers...>       - Check provider eligibility for servers"
           opts.separator "  harness                  Manage harness state"
           opts.separator "    status                   - Show harness status"
           opts.separator "    reset                    - Reset harness state"
@@ -274,6 +279,10 @@ module Aidp
           opts.separator ""
           opts.separator "  # Other commands"
           opts.separator "  aidp providers                        # Check provider health"
+          opts.separator "  aidp providers info claude            # Show detailed provider info"
+          opts.separator "  aidp providers refresh                # Refresh all provider info"
+          opts.separator "  aidp mcp                              # Show MCP server dashboard"
+          opts.separator "  aidp mcp check dash-api filesystem    # Check provider eligibility"
           opts.separator "  aidp checkpoint history 20            # Show last 20 checkpoints"
           opts.separator ""
           opts.separator "For more information, visit: https://github.com/viamin/aidp"
@@ -287,7 +296,7 @@ module Aidp
       # Determine if the invocation is a subcommand style call
       def subcommand?(args)
         return false if args.nil? || args.empty?
-        %w[status jobs kb harness execute analyze providers checkpoint].include?(args.first)
+        %w[status jobs kb harness execute analyze providers checkpoint mcp].include?(args.first)
       end
 
       def run_subcommand(args)
@@ -301,6 +310,7 @@ module Aidp
         when "analyze" then run_execute_command(args, mode: :analyze) # symmetry
         when "providers" then run_providers_command(args)
         when "checkpoint" then run_checkpoint_command(args)
+        when "mcp" then run_mcp_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -585,6 +595,19 @@ module Aidp
       end
 
       def run_providers_command(args)
+        subcommand = args.first if args.first && !args.first.start_with?("--")
+
+        case subcommand
+        when "info"
+          args.shift # Remove 'info'
+          run_providers_info_command(args)
+          return
+        when "refresh"
+          args.shift # Remove 'refresh'
+          run_providers_refresh_command(args)
+          return
+        end
+
         # Accept flags directly on `aidp providers` now (health is implicit)
         no_color = false
         args.reject! do |a|
@@ -660,6 +683,180 @@ module Aidp
         display_message("Failed to display provider health: #{e.message}", type: :error)
       end
 
+      def run_providers_info_command(args)
+        require_relative "harness/provider_info"
+
+        provider_name = args.shift
+        unless provider_name
+          display_message("Usage: aidp providers info <provider_name>", type: :info)
+          display_message("Example: aidp providers info claude", type: :info)
+          return
+        end
+
+        force_refresh = args.include?("--refresh")
+
+        display_message("Provider Information: #{provider_name}", type: :highlight)
+        display_message("=" * 60, type: :muted)
+
+        provider_info = Aidp::Harness::ProviderInfo.new(provider_name, Dir.pwd)
+        info = provider_info.get_info(force_refresh: force_refresh)
+
+        if info.nil?
+          display_message("No information available for provider: #{provider_name}", type: :error)
+          return
+        end
+
+        # Display basic info
+        display_message("Last Checked: #{info[:last_checked]}", type: :info)
+        display_message("CLI Available: #{info[:cli_available] ? "Yes" : "No"}", type: info[:cli_available] ? :success : :error)
+
+        # Display authentication
+        if info[:auth_method]
+          display_message("\nAuthentication Method: #{info[:auth_method]}", type: :info)
+        end
+
+        # Display MCP support
+        display_message("\nMCP Support: #{info[:mcp_support] ? "Yes" : "No"}", type: info[:mcp_support] ? :success : :info)
+
+        # Display MCP servers if available
+        if info[:mcp_servers]&.any?
+          display_message("\nMCP Servers: (#{info[:mcp_servers].size} configured)", type: :highlight)
+          info[:mcp_servers].each do |server|
+            status_symbol = server[:enabled] ? "✓" : "○"
+            display_message("  #{status_symbol} #{server[:name]} (#{server[:status]})", type: server[:enabled] ? :success : :muted)
+            display_message("    #{server[:description]}", type: :muted) if server[:description]
+          end
+        elsif info[:mcp_support]
+          display_message("\nMCP Servers: None configured", type: :muted)
+        end
+
+        # Display permission modes
+        if info[:permission_modes]&.any?
+          display_message("\nPermission Modes:", type: :highlight)
+          info[:permission_modes].each do |mode|
+            display_message("  - #{mode}", type: :info)
+          end
+        end
+
+        # Display capabilities
+        if info[:capabilities]&.any?
+          display_message("\nCapabilities:", type: :highlight)
+          info[:capabilities].each do |cap, value|
+            next unless value
+
+            display_message("  ✓ #{cap.to_s.split("_").map(&:capitalize).join(" ")}", type: :success)
+          end
+        end
+
+        # Display notable flags
+        if info[:flags]&.any?
+          display_message("\nNotable Flags: (#{info[:flags].size} total)", type: :highlight)
+          # Show first 10 flags
+          info[:flags].take(10).each do |name, flag_info|
+            display_message("  #{flag_info[:flag]}", type: :info)
+            display_message("    #{flag_info[:description][0..80]}...", type: :muted) if flag_info[:description]
+          end
+
+          if info[:flags].size > 10
+            display_message("\n  ... and #{info[:flags].size - 10} more flags", type: :muted)
+            display_message("  Run '#{get_binary_name(provider_name)} --help' for full details", type: :muted)
+          end
+        end
+
+        display_message("\n" + "=" * 60, type: :muted)
+        display_message("Tip: Use --refresh to update this information", type: :muted)
+      end
+
+      def run_providers_refresh_command(args)
+        require_relative "harness/provider_info"
+        require "tty-spinner"
+
+        provider_name = args.shift
+        configuration = Aidp::Harness::Configuration.new(Dir.pwd)
+        providers_to_refresh = if provider_name
+          [provider_name]
+        else
+          configuration.configured_providers
+        end
+
+        display_message("Refreshing provider information...", type: :info)
+        display_message("", type: :info)
+
+        providers_to_refresh.each do |prov|
+          spinner = TTY::Spinner.new("[:spinner] #{prov}...", format: :dots)
+          spinner.auto_spin
+
+          provider_info = Aidp::Harness::ProviderInfo.new(prov, Dir.pwd)
+          info = provider_info.gather_info
+
+          if info[:cli_available]
+            spinner.success("(available)")
+          else
+            spinner.error("(unavailable)")
+          end
+        end
+
+        display_message("\n✓ Provider information refreshed", type: :success)
+        display_message("Use 'aidp providers info <name>' to view details", type: :muted)
+      end
+
+      def run_mcp_command(args)
+        require_relative "cli/mcp_dashboard"
+
+        subcommand = args.shift
+
+        dashboard = Aidp::CLI::McpDashboard.new(Dir.pwd)
+
+        case subcommand
+        when "dashboard", "list", nil
+          # Extract flags
+          no_color = args.include?("--no-color")
+          dashboard.display_dashboard(no_color: no_color)
+
+        when "check"
+          # Check eligibility for specific servers
+          required_servers = args
+          if required_servers.empty?
+            display_message("Usage: aidp mcp check <server1> [server2] ...", type: :info)
+            display_message("Example: aidp mcp check filesystem brave-search", type: :info)
+            return
+          end
+
+          dashboard.display_task_eligibility(required_servers)
+
+        else
+          display_message("Usage: aidp mcp <command>", type: :info)
+          display_message("", type: :info)
+          display_message("Commands:", type: :info)
+          display_message("  dashboard, list     Show MCP servers across all providers (default)", type: :info)
+          display_message("  check <servers...>  Check which providers have required MCP servers", type: :info)
+          display_message("", type: :info)
+          display_message("Examples:", type: :info)
+          display_message("  aidp mcp                              # Show dashboard", type: :info)
+          display_message("  aidp mcp dashboard --no-color         # Show without colors", type: :info)
+          display_message("  aidp mcp check filesystem dash-api    # Check provider eligibility", type: :info)
+        end
+      end
+
+      def get_binary_name(provider_name)
+        case provider_name
+        when "claude", "anthropic"
+          "claude"
+        when "cursor"
+          "cursor"
+        when "gemini"
+          "gemini"
+        when "codex"
+          "codex"
+        when "github_copilot"
+          "gh"
+        when "opencode"
+          "opencode"
+        else
+          provider_name
+        end
+      end
+
       def extract_mode_option(args)
         mode = nil
         args.each do |arg|
@@ -677,17 +874,20 @@ module Aidp
 
       def select_mode_interactive(tui)
         mode_options = [
+          "🤖 Guided Workflow (Copilot) - AI helps you choose the right workflow",
           "🔬 Analyze Mode - Analyze your codebase for insights and recommendations",
           "🏗️ Execute Mode - Build new features with guided development workflow"
         ]
         selected = tui.single_select("Welcome to AI Dev Pipeline! Choose your mode", mode_options, default: 1)
         # Announce mode explicitly in headless contexts (handled internally otherwise)
         if (defined?(RSpec) || ENV["RSPEC_RUNNING"]) && tui.respond_to?(:announce_mode)
-          tui.announce_mode(:analyze) if selected == mode_options[0]
-          tui.announce_mode(:execute) if selected == mode_options[1]
+          tui.announce_mode(:guided) if selected == mode_options[0]
+          tui.announce_mode(:analyze) if selected == mode_options[1]
+          tui.announce_mode(:execute) if selected == mode_options[2]
         end
-        return :analyze if selected == mode_options[0]
-        return :execute if selected == mode_options[1]
+        return :guided if selected == mode_options[0]
+        return :analyze if selected == mode_options[1]
+        return :execute if selected == mode_options[2]
         :analyze
       end