aidp 0.11.0 → 0.12.1

data/lib/aidp/config/paths.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  # Centralized path management for all AIDP internal files
+  # Ensures consistent file locations and prevents path-related bugs
+  module ConfigPaths
+    # Get the main AIDP directory for a project
+    def self.aidp_dir(project_dir = Dir.pwd)
+      File.join(project_dir, ".aidp")
+    end
+
+    # Get the main configuration file path
+    def self.config_file(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "aidp.yml")
+    end
+
+    # Get the configuration directory path
+    def self.config_dir(project_dir = Dir.pwd)
+      aidp_dir(project_dir)
+    end
+
+    # Get the progress directory path
+    def self.progress_dir(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "progress")
+    end
+
+    # Get the execute progress file path
+    def self.execute_progress_file(project_dir = Dir.pwd)
+      File.join(progress_dir(project_dir), "execute.yml")
+    end
+
+    # Get the analyze progress file path
+    def self.analyze_progress_file(project_dir = Dir.pwd)
+      File.join(progress_dir(project_dir), "analyze.yml")
+    end
+
+    # Get the harness state directory path
+    def self.harness_state_dir(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "harness")
+    end
+
+    # Get the harness state file path for a specific mode
+    def self.harness_state_file(mode, project_dir = Dir.pwd)
+      File.join(harness_state_dir(project_dir), "#{mode}_state.json")
+    end
+
+    # Get the providers directory path
+    def self.providers_dir(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "providers")
+    end
+
+    # Get the provider info file path
+    def self.provider_info_file(provider_name, project_dir = Dir.pwd)
+      File.join(providers_dir(project_dir), "#{provider_name}_info.yml")
+    end
+
+    # Get the jobs directory path
+    def self.jobs_dir(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "jobs")
+    end
+
+    # Get the checkpoint file path
+    def self.checkpoint_file(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "checkpoint.yml")
+    end
+
+    # Get the checkpoint history file path
+    def self.checkpoint_history_file(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "checkpoint_history.jsonl")
+    end
+
+    # Get the JSON storage directory path
+    def self.json_storage_dir(project_dir = Dir.pwd)
+      File.join(aidp_dir(project_dir), "json")
+    end
+
+    # Check if the main configuration file exists
+    def self.config_exists?(project_dir = Dir.pwd)
+      File.exist?(config_file(project_dir))
+    end
+
+    # Ensure the main AIDP directory exists
+    def self.ensure_aidp_dir(project_dir = Dir.pwd)
+      dir = aidp_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    # Ensure the configuration directory exists
+    def self.ensure_config_dir(project_dir = Dir.pwd)
+      ensure_aidp_dir(project_dir)
+    end
+
+    # Ensure the progress directory exists
+    def self.ensure_progress_dir(project_dir = Dir.pwd)
+      dir = progress_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    # Ensure the harness state directory exists
+    def self.ensure_harness_state_dir(project_dir = Dir.pwd)
+      dir = harness_state_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    # Ensure the providers directory exists
+    def self.ensure_providers_dir(project_dir = Dir.pwd)
+      dir = providers_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    # Ensure the jobs directory exists
+    def self.ensure_jobs_dir(project_dir = Dir.pwd)
+      dir = jobs_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+
+    # Ensure the JSON storage directory exists
+    def self.ensure_json_storage_dir(project_dir = Dir.pwd)
+      dir = json_storage_dir(project_dir)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dir
+    end
+  end
+end

data/lib/aidp/config.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require_relative "config/paths"
 
 module Aidp
   # Configuration management for both execute and analyze modes
@@ -165,7 +166,7 @@ module Aidp
     }.freeze
 
     def self.load(project_dir = Dir.pwd)
-      config_file = File.join(project_dir, ".aidp", "aidp.yml")
+      config_file = ConfigPaths.config_file(project_dir)
 
       if File.exist?(config_file)
         load_yaml_config(config_file)
@@ -244,15 +245,15 @@ module Aidp
 
     # Check if configuration file exists
     def self.config_exists?(project_dir = Dir.pwd)
-      File.exist?(File.join(project_dir, ".aidp", "aidp.yml"))
+      ConfigPaths.config_exists?(project_dir)
     end
 
     # Create example configuration file
     def self.create_example_config(project_dir = Dir.pwd)
-      config_path = File.join(project_dir, ".aidp", "aidp.yml")
+      config_path = ConfigPaths.config_file(project_dir)
       return false if File.exist?(config_path)
 
-      FileUtils.mkdir_p(File.dirname(config_path))
+      ConfigPaths.ensure_config_dir(project_dir)
 
       example_config = {
         harness: {
@@ -283,6 +284,19 @@ module Aidp
       true
     end
 
+    # Expose path methods for convenience
+    def self.config_file(project_dir = Dir.pwd)
+      ConfigPaths.config_file(project_dir)
+    end
+
+    def self.config_dir(project_dir = Dir.pwd)
+      ConfigPaths.config_dir(project_dir)
+    end
+
+    def self.aidp_dir(project_dir = Dir.pwd)
+      ConfigPaths.aidp_dir(project_dir)
+    end
+
     private_class_method def self.load_yaml_config(config_file)
       YAML.load_file(config_file) || {}
     rescue => e

data/lib/aidp/harness/config_validator.rb

@@ -2,6 +2,7 @@
 
 require "yaml"
 require_relative "config_schema"
+require_relative "../config/paths"
 
 module Aidp
   module Harness
@@ -76,9 +77,9 @@ module Aidp
         return false if config_exists?
 
         example_config = ConfigSchema.generate_example
-        config_path = File.join(@project_dir, ".aidp", "aidp.yml")
+        config_path = Aidp::ConfigPaths.config_file(@project_dir)
 
-        FileUtils.mkdir_p(File.dirname(config_path))
+        Aidp::ConfigPaths.ensure_config_dir(@project_dir)
         File.write(config_path, YAML.dump(example_config))
         true
       end
@@ -244,7 +245,7 @@ module Aidp
       private
 
       def find_config_file
-        config_file = File.join(@project_dir, ".aidp", "aidp.yml")
+        config_file = Aidp::ConfigPaths.config_file(@project_dir)
 
         if File.exist?(config_file)
           config_file

data/lib/aidp/harness/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../config"
+require_relative "../config/paths"
 
 module Aidp
   module Harness
@@ -211,7 +212,7 @@ module Aidp
 
       # Get configuration path
       def config_path
-        File.join(@project_dir, ".aidp", "aidp.yml")
+        Aidp::ConfigPaths.config_file(@project_dir)
       end
 
       # Get logging configuration

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.1"
 end