aidp 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffba477d4ca2e297b4fe81d7ecb32ccf37d161df6bcd2dceaa91e94ccbc8ea8f
-  data.tar.gz: 851fdc47c7a12bd8f6f8304badf60ffdb6855787d0982645d80a309d9caee40b
+  metadata.gz: a5c07df32790749c9d60716d1ae3133f0a232cda036e7523b74b8c0725a0b066
+  data.tar.gz: b15140f57f3d8cc58dc4b4e79200d3b0ef50152c5f6bcd6f45b030aeca8c863e
 SHA512:
-  metadata.gz: ef68650e5a8c55d8b219a00a42ba7fbff2c87bdd5cacf5f450c8bf406c481d6d1e4c00cd7edabbf41b07928bb28c2b5246c54392e67f52ee8381bac1668d9463
-  data.tar.gz: d2ae0a1bc041b0f8c0cdf1ccb3c328fc7bb1c4ba3cbb0599c983f4937056a8ad1f47e0bcb475a96dd8d4d936cfc6d7452a0333121ed36e29a14708b8e4bd15ec
+  metadata.gz: 1e5e5b0f9c209dea98509a29b4004f264cb49706d961cafe42ad2867a40abc6ecd9e3cf279a541e714c914f975ec25f6ed898a7be7549dc6ae1292e369eaa7b9
+  data.tar.gz: 5f7a286a65cd9e1ecbdbd167182fa1471e9407171a2fc028cfa144d9204606d8c8e3a7138348c8406133713aa1724749e7abcc0fa6904fca64b65b43355bbfd8

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
 

data/lib/aidp/harness/provider_info.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "fileutils"
+
+module Aidp
+  module Harness
+    # Stores detailed information about AI providers gathered from their CLI tools
+    class ProviderInfo
+      attr_reader :provider_name, :info_file_path
+
+      def initialize(provider_name, root_dir = nil)
+        @provider_name = provider_name
+        @root_dir = root_dir || Dir.pwd
+        @info_file_path = File.join(@root_dir, ".aidp", "providers", "#{provider_name}_info.yml")
+        ensure_directory_exists
+      end
+
+      # Gather information about the provider by introspecting its CLI
+      def gather_info
+        info = {
+          provider: @provider_name,
+          last_checked: Time.now.iso8601,
+          cli_available: false,
+          help_output: nil,
+          capabilities: {},
+          permission_modes: [],
+          mcp_support: false,
+          mcp_servers: [],
+          auth_method: nil,
+          flags: {}
+        }
+
+        # Try to get help output from the provider CLI
+        help_output = fetch_help_output
+        if help_output
+          info[:cli_available] = true
+          info[:help_output] = help_output
+          info.merge!(parse_help_output(help_output))
+        end
+
+        # Try to get MCP server list if supported
+        if info[:mcp_support]
+          mcp_servers = fetch_mcp_servers
+          info[:mcp_servers] = mcp_servers if mcp_servers
+        end
+
+        save_info(info)
+        info
+      end
+
+      # Load stored provider info
+      def load_info
+        return nil unless File.exist?(@info_file_path)
+
+        YAML.safe_load_file(@info_file_path, permitted_classes: [Time, Symbol])
+      rescue => e
+        warn "Failed to load provider info for #{@provider_name}: #{e.message}"
+        nil
+      end
+
+      # Get provider info, refreshing if needed
+      def get_info(force_refresh: false, max_age: 86400)
+        existing_info = load_info
+
+        # Refresh if forced, missing, or stale
+        if force_refresh || existing_info.nil? || info_stale?(existing_info, max_age)
+          gather_info
+        else
+          existing_info
+        end
+      end
+
+      # Check if provider supports MCP servers
+      def supports_mcp?
+        info = load_info
+        return false unless info
+
+        info[:mcp_support] == true
+      end
+
+      # Get permission modes available
+      def permission_modes
+        info = load_info
+        return [] unless info
+
+        info[:permission_modes] || []
+      end
+
+      # Get authentication method
+      def auth_method
+        info = load_info
+        return nil unless info
+
+        info[:auth_method]
+      end
+
+      # Get available flags/options
+      def available_flags
+        info = load_info
+        return {} unless info
+
+        info[:flags] || {}
+      end
+
+      # Get configured MCP servers
+      def mcp_servers
+        info = load_info
+        return [] unless info
+
+        info[:mcp_servers] || []
+      end
+
+      # Check if provider has MCP servers configured
+      def has_mcp_servers?
+        mcp_servers.any?
+      end
+
+      private
+
+      def ensure_directory_exists
+        dir = File.dirname(@info_file_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      def save_info(info)
+        File.write(@info_file_path, YAML.dump(info))
+      end
+
+      def info_stale?(info, max_age)
+        return true unless info[:last_checked]
+
+        last_checked = Time.parse(info[:last_checked].to_s)
+        (Time.now - last_checked) > max_age
+      rescue
+        true
+      end
+
+      def fetch_help_output
+        execute_provider_command("--help")
+      end
+
+      def fetch_mcp_servers
+        binary = get_binary_name
+        return nil unless binary
+
+        # Try different MCP list commands based on provider
+        mcp_output = case @provider_name
+        when "claude", "anthropic"
+          execute_provider_command("mcp", "list")
+        end
+
+        return nil unless mcp_output
+
+        parse_mcp_servers(mcp_output)
+      end
+
+      def execute_provider_command(*args)
+        binary = get_binary_name
+        return nil unless binary
+
+        # Try to find the binary
+        path = begin
+          Aidp::Util.which(binary)
+        rescue
+          nil
+        end
+        return nil unless path
+
+        # Execute command with timeout
+        begin
+          r, w = IO.pipe
+          pid = Process.spawn(binary, *args, out: w, err: w)
+          w.close
+
+          # Wait with timeout
+          deadline = Time.now + 5
+          status = nil
+          while Time.now < deadline
+            pid_done, status = Process.waitpid2(pid, Process::WNOHANG)
+            break if pid_done
+            sleep 0.05
+          end
+
+          # Kill if timed out
+          unless status
+            begin
+              Process.kill("TERM", pid)
+              sleep 0.1
+              Process.kill("KILL", pid)
+            rescue
+              nil
+            end
+            return nil
+          end
+
+          output = r.read
+          r.close
+          output
+        rescue
+          nil
+        end
+      end
+
+      def parse_mcp_servers(output)
+        servers = []
+        return servers unless output
+
+        # Parse MCP server list output
+        # Claude format (as of 2025):
+        # dash-api: uvx --from git+https://... - ✓ Connected
+        # or
+        # server-name: command - ✗ Error message
+        #
+        # Legacy format:
+        # Name              Status    Description
+        # filesystem        enabled   File system access
+
+        lines = output.lines
+
+        # Skip header lines
+        lines.reject! { |line| /checking mcp server health/i.match?(line) }
+
+        lines.each do |line|
+          line = line.strip
+          next if line.empty?
+
+          # Try to parse new Claude format: "name: command - ✓ Connected"
+          if line =~ /^([^:]+):\s*(.+?)\s*-\s*(✓|✗)\s*(.+)$/
+            name = Regexp.last_match(1).strip
+            command = Regexp.last_match(2).strip
+            status_symbol = Regexp.last_match(3)
+            status_text = Regexp.last_match(4).strip
+
+            servers << {
+              name: name,
+              status: (status_symbol == "✓") ? "connected" : "error",
+              description: command,
+              enabled: status_symbol == "✓",
+              error: (status_symbol == "✗") ? status_text : nil
+            }
+            next
+          end
+
+          # Try to parse legacy table format
+          # Skip header line
+          next if /Name.*Status/i.match?(line)
+          next if /^[-=]+$/.match?(line) # Skip separator lines
+
+          # Parse table format: columns separated by multiple spaces
+          parts = line.split(/\s{2,}/)
+          next if parts.size < 2
+
+          name = parts[0]&.strip
+          status = parts[1]&.strip
+          description = parts[2..]&.join(" ")&.strip
+
+          next unless name && !name.empty?
+
+          servers << {
+            name: name,
+            status: status || "unknown",
+            description: description,
+            enabled: status&.downcase == "enabled" || status&.downcase == "connected"
+          }
+        end
+
+        servers
+      end
+
+      def get_binary_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 parse_help_output(help_text)
+        parsed = {
+          capabilities: {},
+          permission_modes: [],
+          mcp_support: false,
+          auth_method: nil,
+          flags: {}
+        }
+
+        # Check for MCP support
+        parsed[:mcp_support] = !!(help_text =~ /mcp|MCP|Model Context Protocol/i)
+
+        # Extract permission modes
+        if help_text =~ /--permission-mode\s+<mode>\s+.*?\(choices:\s*([^)]+)\)/m
+          modes = Regexp.last_match(1).split(",").map(&:strip).map { |m| m.gsub(/["']/, "") }
+          parsed[:permission_modes] = modes
+        end
+
+        # Check for dangerous skip permissions
+        parsed[:capabilities][:bypass_permissions] = !!(help_text =~ /--dangerously-skip-permissions/)
+
+        # Check for API key / subscription patterns
+        if /--api-key|API_KEY|setup-token|subscription/i.match?(help_text)
+          parsed[:auth_method] = if /setup-token|subscription/i.match?(help_text)
+            "subscription"
+          else
+            "api_key"
+          end
+        end
+
+        # Extract model configuration
+        parsed[:capabilities][:model_selection] = !!(help_text =~ /--model\s+<model>/)
+
+        # Extract MCP configuration
+        parsed[:capabilities][:mcp_config] = !!(help_text =~ /--mcp-config/)
+
+        # Extract allowed/disallowed tools
+        parsed[:capabilities][:tool_restrictions] = !!(help_text =~ /--allowed-tools|--disallowed-tools/)
+
+        # Extract session management
+        parsed[:capabilities][:session_management] = !!(help_text =~ /--continue|--resume|--fork-session/)
+
+        # Extract output formats
+        if help_text =~ /--output-format\s+.*?\(choices:\s*([^)]+)\)/m
+          formats = Regexp.last_match(1).split(",").map(&:strip).map { |f| f.gsub(/["']/, "") }
+          parsed[:capabilities][:output_formats] = formats
+        end
+
+        # Extract notable flags
+        extract_flags(help_text, parsed[:flags])
+
+        parsed
+      end
+
+      def extract_flags(help_text, flags_hash)
+        # Extract all flags with their descriptions
+        help_text.scan(/^\s+(--[\w-]+(?:\s+<\w+>)?)\s+(.+?)(?=^\s+(?:--|\w|$))/m).each do |flag, desc|
+          flag_name = flag.split.first.gsub(/^--/, "")
+          flags_hash[flag_name] = {
+            flag: flag.strip,
+            description: desc.strip.gsub(/\s+/, " ")
+          }
+        end
+
+        # Also capture short flags
+        help_text.scan(/^\s+(-\w),\s+(--[\w-]+(?:\s+<\w+>)?)\s+(.+?)(?=^\s+(?:--|-\w|$))/m).each do |short, long, desc|
+          flag_name = long.split.first.gsub(/^--/, "")
+          flags_hash[flag_name] ||= {}
+          flags_hash[flag_name][:short] = short
+          flags_hash[flag_name][:flag] = long.strip
+          flags_hash[flag_name][:description] = desc.strip.gsub(/\s+/, " ")
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative "enhanced_tui"
 require_relative "../../workflows/selector"
+require_relative "../../workflows/guided_agent"
 
 module Aidp
   module Harness
@@ -10,10 +11,11 @@ module Aidp
       class EnhancedWorkflowSelector
         class WorkflowError < StandardError; end
 
-        def initialize(tui = nil)
+        def initialize(tui = nil, project_dir: Dir.pwd)
           @tui = tui || EnhancedTUI.new
           @user_input = {}
           @workflow_selector = Aidp::Workflows::Selector.new
+          @project_dir = project_dir
         end
 
         def select_workflow(harness_mode: false, mode: :analyze)
@@ -28,6 +30,8 @@ module Aidp
 
         def select_workflow_interactive(mode)
           case mode
+          when :guided
+            select_guided_workflow
           when :analyze
             select_analyze_workflow_interactive
           when :execute
@@ -243,6 +247,23 @@ module Aidp
             "16_IMPLEMENTATION"
           ]
         end
+
+        def select_guided_workflow
+          # Use the guided agent to help user select workflow
+          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir, prompt: @tui.instance_variable_get(:@prompt))
+          result = guided_agent.select_workflow
+
+          # Store user input for later use
+          @user_input = result[:user_input]
+
+          # Return in the expected format
+          {
+            workflow_type: result[:workflow_type],
+            steps: result[:steps],
+            user_input: @user_input,
+            workflow: result[:workflow]
+          }
+        end
       end
     end
   end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.11.0"
+  VERSION = "0.12.0"
 end

data/lib/aidp/workflows/guided_agent.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require_relative "../harness/provider_manager"
+require_relative "../harness/provider_factory"
+require_relative "../harness/configuration"
+require_relative "definitions"
+require_relative "../message_display"
+
+module Aidp
+  module Workflows
+    # Guided workflow agent that uses AI to help users select appropriate workflows
+    # Acts as a copilot to match user intent to AIDP capabilities
+    class GuidedAgent
+      include Aidp::MessageDisplay
+
+      class ConversationError < StandardError; end
+
+      def initialize(project_dir, prompt: nil)
+        @project_dir = project_dir
+        @prompt = prompt || TTY::Prompt.new
+        @configuration = Aidp::Harness::Configuration.new(project_dir)
+        @provider_manager = Aidp::Harness::ProviderManager.new(@configuration, prompt: @prompt)
+        @conversation_history = []
+        @user_input = {}
+      end
+
+      # Main entry point for guided workflow selection
+      def select_workflow
+        display_message("\n🤖 Welcome to AIDP Guided Workflow!", type: :highlight)
+        display_message("I'll help you choose the right workflow for your needs.\n", type: :info)
+
+        # Step 1: Get user's high-level goal
+        user_goal = get_user_goal
+
+        # Step 2: Use AI to analyze intent and recommend workflow
+        recommendation = analyze_user_intent(user_goal)
+
+        # Step 3: Present recommendation and get confirmation
+        workflow_selection = present_recommendation(recommendation)
+
+        # Step 4: Collect any additional required information
+        collect_workflow_details(workflow_selection)
+
+        workflow_selection
+      rescue => e
+        raise ConversationError, "Failed to guide workflow selection: #{e.message}"
+      end
+
+      private
+
+      def get_user_goal
+        display_message("What would you like to do?", type: :highlight)
+        display_message("Examples:", type: :muted)
+        display_message("  • Build a new feature for user authentication", type: :muted)
+        display_message("  • Understand how this codebase handles payments", type: :muted)
+        display_message("  • Improve test coverage in my API layer", type: :muted)
+        display_message("  • Create a quick prototype for data export\n", type: :muted)
+
+        goal = @prompt.ask("Your goal:", required: true)
+        @user_input[:original_goal] = goal
+        goal
+      end
+
+      def analyze_user_intent(user_goal)
+        display_message("\n🔍 Analyzing your request...", type: :info)
+
+        # Build the system prompt with AIDP capabilities
+        system_prompt = build_system_prompt
+
+        # Build the user prompt
+        user_prompt = build_analysis_prompt(user_goal)
+
+        # Call provider to analyze intent
+        response = call_provider_for_analysis(system_prompt, user_prompt)
+
+        # Parse the response
+        parse_recommendation(response)
+      end
+
+      def build_system_prompt
+        # Try to load from project dir first, fall back to gem's docs
+        capabilities_path = File.join(@project_dir, "docs", "AIDP_CAPABILITIES.md")
+        unless File.exist?(capabilities_path)
+          # Use the gem's copy
+          gem_root = File.expand_path("../../..", __dir__)
+          capabilities_path = File.join(gem_root, "docs", "AIDP_CAPABILITIES.md")
+        end
+
+        capabilities_doc = File.read(capabilities_path)
+
+        <<~PROMPT
+          You are an expert AI assistant helping users select the right AIDP workflow for their needs.
+
+          Your role:
+          1. Understand what the user wants to accomplish
+          2. Match their intent to AIDP's capabilities
+          3. Recommend the most appropriate workflow
+          4. Explain why this workflow fits their needs
+          5. Identify if custom steps or templates are needed
+
+          AIDP Capabilities Reference:
+          #{capabilities_doc}
+
+          Response Format:
+          Provide a JSON response with:
+          {
+            "mode": "analyze|execute|hybrid",
+            "workflow_key": "specific_workflow_key",
+            "reasoning": "brief explanation of why this fits",
+            "additional_steps": ["any", "custom", "steps", "if", "needed"],
+            "questions": ["any", "clarifying", "questions"],
+            "confidence": "high|medium|low"
+          }
+
+          Be concise to preserve the user's context window.
+        PROMPT
+      end
+
+      def build_analysis_prompt(user_goal)
+        <<~PROMPT
+          User Goal: #{user_goal}
+
+          Analyze this goal and recommend the most appropriate AIDP workflow.
+          Consider:
+          - Is this analysis or development?
+          - What level of rigor is needed?
+          - Are there any gaps in existing workflows?
+
+          Provide your recommendation in JSON format.
+        PROMPT
+      end
+
+      def call_provider_for_analysis(system_prompt, user_prompt)
+        # Get current provider from provider manager
+        provider_name = @provider_manager.current_provider
+
+        unless provider_name
+          raise ConversationError, "No provider configured for guided workflow"
+        end
+
+        # Create provider instance using ProviderFactory
+        provider_factory = Aidp::Harness::ProviderFactory.new(@configuration)
+        provider = provider_factory.create_provider(provider_name, prompt: @prompt)
+
+        unless provider
+          raise ConversationError, "Failed to create provider instance for #{provider_name}"
+        end
+
+        # Make the request - combine system and user prompts
+        combined_prompt = "#{system_prompt}\n\n#{user_prompt}"
+
+        result = provider.send(prompt: combined_prompt)
+
+        unless result[:status] == :success
+          raise ConversationError, "Provider request failed: #{result[:error]}"
+        end
+
+        result[:content]
+      end
+
+      def parse_recommendation(response_text)
+        # Extract JSON from response (might be wrapped in markdown code blocks)
+        json_match = response_text.match(/```json\s*(\{.*?\})\s*```/m) ||
+          response_text.match(/(\{.*\})/m)
+
+        unless json_match
+          raise ConversationError, "Could not parse recommendation from response"
+        end
+
+        JSON.parse(json_match[1], symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise ConversationError, "Invalid JSON in recommendation: #{e.message}"
+      end
+
+      def present_recommendation(recommendation)
+        display_message("\n✨ Recommendation", type: :highlight)
+        display_message("─" * 60, type: :muted)
+
+        mode = recommendation[:mode].to_sym
+        workflow_key = recommendation[:workflow_key].to_sym
+
+        # Get workflow details
+        workflow = Definitions.get_workflow(mode, workflow_key)
+
+        unless workflow
+          # Handle custom workflow or error
+          return handle_custom_workflow(recommendation)
+        end
+
+        # Display the recommendation
+        display_message("Mode: #{mode.to_s.capitalize}", type: :info)
+        display_message("Workflow: #{workflow[:name]}", type: :info)
+        display_message("\n#{workflow[:description]}", type: :muted)
+        display_message("\nReasoning: #{recommendation[:reasoning]}\n", type: :info)
+
+        # Show what's included
+        display_message("This workflow includes:", type: :highlight)
+        workflow[:details].each do |detail|
+          display_message("  • #{detail}", type: :info)
+        end
+
+        # Handle additional steps if needed
+        steps = workflow[:steps]
+        if recommendation[:additional_steps]&.any?
+          display_message("\nAdditional custom steps recommended:", type: :highlight)
+          recommendation[:additional_steps].each do |step|
+            display_message("  • #{step}", type: :info)
+          end
+          steps = workflow[:steps] + recommendation[:additional_steps]
+        end
+
+        # Ask for confirmation
+        display_message("")
+        confirmed = @prompt.yes?("Does this workflow fit your needs?")
+
+        if confirmed
+          {
+            mode: mode,
+            workflow_key: workflow_key,
+            workflow_type: workflow_key,
+            steps: steps,
+            user_input: @user_input,
+            workflow: workflow
+          }
+        else
+          # Offer alternatives
+          offer_alternatives(mode)
+        end
+      end
+
+      def handle_custom_workflow(recommendation)
+        display_message("\n💡 Custom Workflow Needed", type: :highlight)
+        display_message("The AI recommends creating a custom workflow:\n", type: :info)
+        display_message(recommendation[:reasoning], type: :muted)
+
+        if recommendation[:questions]&.any?
+          display_message("\nLet me gather some more information:\n", type: :highlight)
+          recommendation[:questions].each do |question|
+            answer = @prompt.ask(question)
+            @user_input[question.downcase.gsub(/\s+/, "_").to_sym] = answer
+          end
+        end
+
+        # Let user select from available steps
+        mode = recommendation[:mode].to_sym
+        display_message("\nLet's build a custom workflow by selecting specific steps:", type: :info)
+
+        steps = select_custom_steps(mode, recommendation[:additional_steps])
+
+        {
+          mode: mode,
+          workflow_key: :custom,
+          workflow_type: :custom,
+          steps: steps,
+          user_input: @user_input,
+          workflow: {
+            name: "Custom Workflow",
+            description: recommendation[:reasoning],
+            details: steps
+          }
+        }
+      end
+
+      def select_custom_steps(mode, suggested_steps = [])
+        # Get available steps for the mode
+        spec = case mode
+        when :analyze
+          Aidp::Analyze::Steps::SPEC
+        when :execute
+          Aidp::Execute::Steps::SPEC
+        when :hybrid
+          # Combine both
+          Aidp::Analyze::Steps::SPEC.merge(Aidp::Execute::Steps::SPEC)
+        else
+          {}
+        end
+
+        step_choices = spec.map do |step_key, step_spec|
+          {
+            name: "#{step_key} - #{step_spec["description"]}",
+            value: step_key
+          }
+        end
+
+        # Pre-select suggested steps
+        default_indices = suggested_steps.map do |step|
+          step_choices.index { |choice| choice[:value].to_s == step.to_s }
+        end.compact
+
+        selected_steps = @prompt.multi_select(
+          "Select steps for your custom workflow:",
+          step_choices,
+          default: default_indices,
+          per_page: 20
+        )
+
+        selected_steps.empty? ? suggested_steps : selected_steps
+      end
+
+      def offer_alternatives(current_mode)
+        display_message("\n🔄 Let's find a better fit", type: :highlight)
+
+        choices = [
+          {name: "Try a different #{current_mode} workflow", value: :different_workflow},
+          {name: "Switch to a different mode", value: :different_mode},
+          {name: "Build a custom workflow", value: :custom},
+          {name: "Start over", value: :restart}
+        ]
+
+        choice = @prompt.select("What would you like to do?", choices)
+
+        case choice
+        when :different_workflow
+          select_manual_workflow(current_mode)
+        when :different_mode
+          # Let user pick mode manually then workflow
+          new_mode = @prompt.select(
+            "Select mode:",
+            {
+              "🔬 Analyze Mode" => :analyze,
+              "🏗️  Execute Mode" => :execute,
+              "🔀 Hybrid Mode" => :hybrid
+            }
+          )
+          select_manual_workflow(new_mode)
+        when :custom
+          select_custom_steps(current_mode)
+        when :restart
+          select_workflow # Recursive call to start over
+        end
+      end
+
+      def select_manual_workflow(mode)
+        workflows = Definitions.workflows_for_mode(mode)
+
+        choices = workflows.map do |key, workflow|
+          {
+            name: "#{workflow[:icon]} #{workflow[:name]} - #{workflow[:description]}",
+            value: key
+          }
+        end
+
+        selected_key = @prompt.select("Choose a workflow:", choices, per_page: 15)
+        workflow = workflows[selected_key]
+
+        {
+          mode: mode,
+          workflow_key: selected_key,
+          workflow_type: selected_key,
+          steps: workflow[:steps],
+          user_input: @user_input,
+          workflow: workflow
+        }
+      end
+
+      def collect_workflow_details(workflow_selection)
+        # Collect additional information based on mode
+        case workflow_selection[:mode]
+        when :execute
+          collect_execute_details
+        when :analyze
+          # Analyze mode typically doesn't need much user input
+          @user_input[:analysis_goal] = @user_input[:original_goal]
+        when :hybrid
+          collect_execute_details # Hybrid often needs project details
+        end
+
+        # Update the workflow selection with collected input
+        workflow_selection[:user_input] = @user_input
+      end
+
+      def collect_execute_details
+        return if @user_input[:project_description] # Already collected
+
+        display_message("\n📝 Project Information", type: :highlight)
+        display_message("Let me gather some details for the PRD:\n", type: :info)
+
+        @user_input[:project_description] = @prompt.ask(
+          "Describe what you're building (can reference your original goal):",
+          default: @user_input[:original_goal]
+        )
+
+        @user_input[:tech_stack] = @prompt.ask(
+          "Tech stack (e.g., Ruby/Rails, Node.js, Python)? [optional]",
+          required: false
+        )
+
+        @user_input[:target_users] = @prompt.ask(
+          "Who will use this? [optional]",
+          required: false
+        )
+
+        @user_input[:success_criteria] = @prompt.ask(
+          "How will you measure success? [optional]",
+          required: false
+        )
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -250,6 +250,7 @@ files:
 - lib/aidp/cli/checkpoint_command.rb
 - lib/aidp/cli/first_run_wizard.rb
 - lib/aidp/cli/jobs_command.rb
+- lib/aidp/cli/mcp_dashboard.rb
 - lib/aidp/cli/terminal_io.rb
 - lib/aidp/config.rb
 - lib/aidp/core_ext/class_attribute.rb
@@ -274,6 +275,7 @@ files:
 - lib/aidp/harness/error_handler.rb
 - lib/aidp/harness/provider_config.rb
 - lib/aidp/harness/provider_factory.rb
+- lib/aidp/harness/provider_info.rb
 - lib/aidp/harness/provider_manager.rb
 - lib/aidp/harness/provider_type_checker.rb
 - lib/aidp/harness/runner.rb
@@ -324,6 +326,7 @@ files:
 - lib/aidp/util.rb
 - lib/aidp/version.rb
 - lib/aidp/workflows/definitions.rb
+- lib/aidp/workflows/guided_agent.rb
 - lib/aidp/workflows/selector.rb
 - templates/COMMON/AGENT_BASE.md
 - templates/COMMON/CONVENTIONS.md