aidp 0.17.1 → 0.18.0

data/lib/aidp/setup/wizard.rb

@@ -92,8 +92,8 @@ module Aidp
         providers_dir = File.join(__dir__, "../providers")
         provider_files = Dir.glob("*.rb", base: providers_dir)
 
-        # Exclude base classes and utility classes
-        excluded_files = ["base.rb", "macos_ui.rb"]
+        # Exclude base classes
+        excluded_files = ["base.rb"]
         provider_files -= excluded_files
 
         providers = {}
@@ -186,6 +186,9 @@ module Aidp
         configure_linting
         configure_watch_patterns
         configure_guards
+        configure_coverage
+        configure_interactive_testing
+        configure_vcs_behavior
       end
 
       def configure_test_commands
@@ -252,6 +255,242 @@ module Aidp
         })
       end
 
+      def configure_coverage
+        prompt.say("\n📊 Coverage configuration")
+        existing = get([:work_loop, :coverage]) || {}
+
+        enabled = prompt.yes?("Enable coverage tracking?", default: existing.fetch(:enabled, false))
+        return set([:work_loop, :coverage], {enabled: false}) unless enabled
+
+        tool = prompt.select("Which coverage tool do you use?", default: existing[:tool]) do |menu|
+          menu.choice "SimpleCov (Ruby)", "simplecov"
+          menu.choice "NYC/Istanbul (JavaScript)", "nyc"
+          menu.choice "Coverage.py (Python)", "coverage.py"
+          menu.choice "go test -cover (Go)", "go-cover"
+          menu.choice "Jest (JavaScript)", "jest"
+          menu.choice "Other", "other"
+        end
+
+        run_command = ask_with_default("Coverage run command", existing[:run_command] || detect_coverage_command(tool))
+        report_paths = ask_list("Coverage report paths", existing[:report_paths] || detect_coverage_report_paths(tool))
+        fail_on_drop = prompt.yes?("Fail on coverage drop?", default: existing.fetch(:fail_on_drop, false))
+
+        minimum_coverage_default = existing[:minimum_coverage]&.to_s
+        minimum_coverage_answer = ask_with_default("Minimum coverage % (optional - press enter to skip)", minimum_coverage_default)
+        minimum_coverage = if minimum_coverage_answer && !minimum_coverage_answer.to_s.strip.empty?
+          minimum_coverage_answer.to_f
+        end
+
+        set([:work_loop, :coverage], {
+          enabled: true,
+          tool: tool,
+          run_command: run_command,
+          report_paths: report_paths,
+          fail_on_drop: fail_on_drop,
+          minimum_coverage: minimum_coverage
+        }.compact)
+
+        validate_command(run_command)
+      end
+
+      def configure_interactive_testing
+        prompt.say("\n🎯 Interactive testing configuration")
+        existing = get([:work_loop, :interactive_testing]) || {}
+
+        enabled = prompt.yes?("Enable interactive testing tools?", default: existing.fetch(:enabled, false))
+        return set([:work_loop, :interactive_testing], {enabled: false}) unless enabled
+
+        app_type = prompt.select("What type of application are you testing?", default: existing[:app_type]) do |menu|
+          menu.choice "Web application", "web"
+          menu.choice "CLI application", "cli"
+          menu.choice "Desktop application", "desktop"
+        end
+
+        tools = {}
+
+        case app_type
+        when "web"
+          tools[:web] = configure_web_testing_tools(existing.dig(:tools, :web) || {})
+        when "cli"
+          tools[:cli] = configure_cli_testing_tools(existing.dig(:tools, :cli) || {})
+        when "desktop"
+          tools[:desktop] = configure_desktop_testing_tools(existing.dig(:tools, :desktop) || {})
+        end
+
+        set([:work_loop, :interactive_testing], {
+          enabled: true,
+          app_type: app_type,
+          tools: tools
+        })
+      end
+
+      def configure_web_testing_tools(existing)
+        tools = {}
+
+        playwright_enabled = prompt.yes?("Enable Playwright MCP?", default: existing.dig(:playwright_mcp, :enabled) || false)
+        if playwright_enabled
+          playwright_run = ask_with_default("Playwright run command", existing.dig(:playwright_mcp, :run) || "npx playwright test")
+          playwright_specs = ask_with_default("Playwright specs directory", existing.dig(:playwright_mcp, :specs_dir) || ".aidp/tests/web")
+          tools[:playwright_mcp] = {enabled: true, run: playwright_run, specs_dir: playwright_specs}
+        end
+
+        chrome_enabled = prompt.yes?("Enable Chrome DevTools MCP?", default: existing.dig(:chrome_devtools_mcp, :enabled) || false)
+        if chrome_enabled
+          chrome_run = ask_with_default("Chrome DevTools run command", existing.dig(:chrome_devtools_mcp, :run) || "")
+          chrome_specs = ask_with_default("Chrome DevTools specs directory", existing.dig(:chrome_devtools_mcp, :specs_dir) || ".aidp/tests/web")
+          tools[:chrome_devtools_mcp] = {enabled: true, run: chrome_run, specs_dir: chrome_specs}
+        end
+
+        tools
+      end
+
+      def configure_cli_testing_tools(existing)
+        tools = {}
+
+        expect_enabled = prompt.yes?("Enable expect scripts?", default: existing.dig(:expect, :enabled) || false)
+        if expect_enabled
+          expect_run = ask_with_default("Expect run command", existing.dig(:expect, :run) || "expect .aidp/tests/cli/smoke.exp")
+          expect_specs = ask_with_default("Expect specs directory", existing.dig(:expect, :specs_dir) || ".aidp/tests/cli")
+          tools[:expect] = {enabled: true, run: expect_run, specs_dir: expect_specs}
+        end
+
+        tools
+      end
+
+      def configure_desktop_testing_tools(existing)
+        tools = {}
+
+        applescript_enabled = prompt.yes?("Enable AppleScript testing?", default: existing.dig(:applescript, :enabled) || false)
+        if applescript_enabled
+          applescript_run = ask_with_default("AppleScript run command", existing.dig(:applescript, :run) || "osascript .aidp/tests/desktop/smoke.scpt")
+          applescript_specs = ask_with_default("AppleScript specs directory", existing.dig(:applescript, :specs_dir) || ".aidp/tests/desktop")
+          tools[:applescript] = {enabled: true, run: applescript_run, specs_dir: applescript_specs}
+        end
+
+        screen_reader_enabled = prompt.yes?("Enable screen reader testing?", default: existing.dig(:screen_reader, :enabled) || false)
+        if screen_reader_enabled
+          screen_reader_notes = ask_with_default("Screen reader testing notes (optional)", existing.dig(:screen_reader, :notes) || "VoiceOver scripted checks")
+          tools[:screen_reader] = {enabled: true, notes: screen_reader_notes}
+        end
+
+        tools
+      end
+
+      def configure_vcs_behavior
+        prompt.say("\n🗂️  Version control configuration")
+        existing = get([:work_loop, :version_control]) || {}
+
+        # Detect VCS
+        detected_vcs = detect_vcs_tool
+        vcs_tool = if detected_vcs
+          prompt.select("Detected #{detected_vcs}. Use this version control system?", default: existing[:tool] || detected_vcs) do |menu|
+            menu.choice "git", "git"
+            menu.choice "svn", "svn"
+            menu.choice "none (no VCS)", "none"
+          end
+        else
+          prompt.select("Which version control system do you use?", default: existing[:tool] || "git") do |menu|
+            menu.choice "git", "git"
+            menu.choice "svn", "svn"
+            menu.choice "none (no VCS)", "none"
+          end
+        end
+
+        return set([:work_loop, :version_control], {tool: "none", behavior: "nothing"}) if vcs_tool == "none"
+
+        prompt.say("\n📋 Commit Behavior (applies to copilot/interactive mode only)")
+        prompt.say("Note: Watch mode and fully automatic daemon mode will always commit changes.")
+        behavior = prompt.select("In copilot mode, should aidp:", default: existing[:behavior] || "nothing") do |menu|
+          menu.choice "Do nothing (manual git operations)", "nothing"
+          menu.choice "Stage changes only", "stage"
+          menu.choice "Stage and commit changes", "commit"
+        end
+
+        # Commit message configuration
+        commit_config = configure_commit_messages(existing, behavior)
+
+        # PR configuration (only relevant for git with remote)
+        pr_config = if vcs_tool == "git" && behavior == "commit"
+          configure_pull_requests(existing)
+        else
+          {auto_create_pr: false}
+        end
+
+        set([:work_loop, :version_control], {
+          tool: vcs_tool,
+          behavior: behavior,
+          **commit_config,
+          **pr_config
+        })
+      end
+
+      def configure_commit_messages(existing, behavior)
+        return {} unless behavior == "commit"
+
+        prompt.say("\n💬 Commit Message Configuration")
+
+        # Conventional commits
+        conventional_commits = prompt.yes?(
+          "Use conventional commit format (e.g., 'feat:', 'fix:', 'docs:')?",
+          default: existing.fetch(:conventional_commits, false)
+        )
+
+        # Commit message style
+        commit_style = if conventional_commits
+          prompt.select("Conventional commit style:", default: existing[:commit_style] || "default") do |menu|
+            menu.choice "Default (e.g., 'feat: add user authentication')", "default"
+            menu.choice "Angular (with scope: 'feat(auth): add login')", "angular"
+            menu.choice "Emoji (e.g., '✨ feat: add user authentication')", "emoji"
+          end
+        else
+          "default"
+        end
+
+        # Co-authored-by attribution
+        co_author = prompt.yes?(
+          "Include 'Co-authored-by: <AI Provider>' in commit messages?",
+          default: existing.fetch(:co_author_ai, true)
+        )
+
+        {
+          conventional_commits: conventional_commits,
+          commit_style: commit_style,
+          co_author_ai: co_author
+        }
+      end
+
+      def configure_pull_requests(existing)
+        prompt.say("\n🔀 Pull Request Configuration")
+
+        # Check if remote exists
+        has_remote = system("git remote -v > /dev/null 2>&1")
+
+        unless has_remote
+          prompt.say("No git remote detected. PR creation will be disabled.")
+          return {auto_create_pr: false}
+        end
+
+        auto_create_pr = prompt.yes?(
+          "Automatically create pull requests after successful builds? (watch/daemon mode only)",
+          default: existing.fetch(:auto_create_pr, false)
+        )
+
+        if auto_create_pr
+          pr_strategy = prompt.select("PR creation strategy:", default: existing[:pr_strategy] || "draft") do |menu|
+            menu.choice "Create as draft PR (safe, allows review before merge)", "draft"
+            menu.choice "Create as ready PR (immediately reviewable)", "ready"
+            menu.choice "Create and auto-merge (fully autonomous, requires approval rules)", "auto_merge"
+          end
+
+          {
+            auto_create_pr: true,
+            pr_strategy: pr_strategy
+          }
+        else
+          {auto_create_pr: false}
+        end
+      end
+
       def configure_branching
         prompt.say("\n🌿 Branching strategy")
         prompt.say("-" * 40)
@@ -604,6 +843,46 @@ module Aidp
         end
       end
 
+      def detect_coverage_command(tool)
+        case tool
+        when "simplecov"
+          "bundle exec rspec"
+        when "nyc", "istanbul"
+          "nyc npm test"
+        when "coverage.py"
+          "coverage run -m pytest"
+        when "go-cover"
+          "go test -cover ./..."
+        when "jest"
+          "jest --coverage"
+        else
+          "echo 'Configure coverage command'"
+        end
+      end
+
+      def detect_coverage_report_paths(tool)
+        case tool
+        when "simplecov"
+          ["coverage/index.html", "coverage/.resultset.json"]
+        when "nyc", "istanbul"
+          ["coverage/lcov-report/index.html", "coverage/lcov.info"]
+        when "coverage.py"
+          [".coverage", "htmlcov/index.html"]
+        when "go-cover"
+          ["coverage.out"]
+        when "jest"
+          ["coverage/lcov-report/index.html"]
+        else
+          []
+        end
+      end
+
+      def detect_vcs_tool
+        return "git" if Dir.exist?(File.join(project_dir, ".git"))
+        return "svn" if Dir.exist?(File.join(project_dir, ".svn"))
+        nil
+      end
+
       def detect_stack
         return :rails if project_file?("Gemfile") && project_file?("config/application.rb")
         return :node if project_file?("package.json")
@@ -626,12 +905,18 @@ module Aidp
 
         if existing && existing[:type]
           prompt.say("  • Provider '#{provider_name}' already configured (type: #{existing[:type]})")
+          # Still ask for model family if not set
+          unless existing[:model_family]
+            model_family = ask_model_family(provider_name, existing[:model_family])
+            set([:providers, provider_name.to_sym, :model_family], model_family)
+          end
           return
         end
 
         provider_type = ask_provider_billing_type(provider_name)
-        set([:providers, provider_name.to_sym], {type: provider_type})
-        prompt.say("  • Added provider '#{provider_name}' with billing type '#{provider_type}' (no secrets stored)")
+        model_family = ask_model_family(provider_name)
+        set([:providers, provider_name.to_sym], {type: provider_type, model_family: model_family})
+        prompt.say("  • Added provider '#{provider_name}' with billing type '#{provider_type}' and model family '#{model_family}' (no secrets stored)")
       end
 
       def ask_provider_billing_type(provider_name)
@@ -643,6 +928,16 @@ module Aidp
         end
       end
 
+      def ask_model_family(provider_name, default = "auto")
+        prompt.select("Preferred model family for #{provider_name}:", default: default) do |menu|
+          menu.choice "Auto (let provider decide)", "auto"
+          menu.choice "OpenAI o-series (reasoning models)", "openai_o"
+          menu.choice "Anthropic Claude (balanced)", "claude"
+          menu.choice "Mistral (European/open)", "mistral"
+          menu.choice "Local LLM (self-hosted)", "local"
+        end
+      end
+
       def load_existing_config
         return {} unless File.exist?(config_path)
         YAML.safe_load_file(config_path, permitted_classes: [Time]) || {}

data/lib/aidp/utils/devcontainer_detector.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Utils
+    # Detects if AIDP is running inside a devcontainer
+    #
+    # Uses multiple heuristics to determine container environment:
+    # - Environment variables (REMOTE_CONTAINERS, CODESPACES)
+    # - Filesystem markers (/.dockerenv, /run/.containerenv)
+    # - Hostname patterns
+    # - cgroup information
+    #
+    # @example
+    #   if DevcontainerDetector.in_devcontainer?
+    #     puts "Running in devcontainer with elevated permissions"
+    #   end
+    class DevcontainerDetector
+      class << self
+        # Check if running inside a devcontainer
+        #
+        # @return [Boolean] true if inside a devcontainer
+        def in_devcontainer?
+          @in_devcontainer ||= detect_devcontainer
+        end
+
+        # Check if running inside any container (Docker, Podman, etc.)
+        #
+        # @return [Boolean] true if inside any container
+        def in_container?
+          @in_container ||= detect_container
+        end
+
+        # Check if running in GitHub Codespaces
+        #
+        # @return [Boolean] true if in Codespaces
+        def in_codespaces?
+          ENV["CODESPACES"] == "true"
+        end
+
+        # Check if running in VS Code Remote Containers
+        #
+        # @return [Boolean] true if in VS Code Remote Containers
+        def in_vscode_remote?
+          ENV["REMOTE_CONTAINERS"] == "true" || ENV["VSCODE_REMOTE_CONTAINERS"] == "true"
+        end
+
+        # Get container type (docker, podman, codespaces, vscode, unknown)
+        #
+        # @return [Symbol] container type
+        def container_type
+          return :codespaces if in_codespaces?
+          return :vscode if in_vscode_remote?
+          return :docker if docker_container?
+          return :podman if podman_container?
+          return :unknown if in_container?
+          :none
+        end
+
+        # Get detailed container information
+        #
+        # @return [Hash] container information
+        def container_info
+          {
+            in_devcontainer: in_devcontainer?,
+            in_container: in_container?,
+            container_type: container_type,
+            hostname: hostname,
+            docker_env: File.exist?("/.dockerenv"),
+            container_env: File.exist?("/run/.containerenv"),
+            cgroup_docker: cgroup_contains?("docker"),
+            cgroup_containerd: cgroup_contains?("containerd"),
+            remote_containers_env: ENV["REMOTE_CONTAINERS"],
+            codespaces_env: ENV["CODESPACES"]
+          }
+        end
+
+        # Reset cached detection (useful for testing)
+        def reset!
+          @in_devcontainer = nil
+          @in_container = nil
+        end
+
+        private
+
+        def detect_devcontainer
+          # Check for VS Code Remote Containers or Codespaces
+          return true if in_vscode_remote?
+          return true if in_codespaces?
+
+          # Check for devcontainer-specific environment markers
+          return true if ENV["AIDP_ENV"] == "development" && in_container?
+
+          # Generic container detection with additional heuristics
+          in_container? && likely_dev_environment?
+        end
+
+        def detect_container
+          # Check environment variable
+          return true if ENV["container"]
+
+          # Check for Docker environment file
+          return true if File.exist?("/.dockerenv")
+
+          # Check for Podman/containers environment file
+          return true if File.exist?("/run/.containerenv")
+
+          # Check cgroup for container indicators
+          return true if cgroup_indicates_container?
+
+          # Check hostname patterns (containers often have short hex hostnames)
+          return true if hostname_indicates_container?
+
+          false
+        end
+
+        def docker_container?
+          File.exist?("/.dockerenv") || cgroup_contains?("docker")
+        end
+
+        def podman_container?
+          File.exist?("/run/.containerenv") || cgroup_contains?("podman")
+        end
+
+        def cgroup_indicates_container?
+          return false unless File.exist?("/proc/1/cgroup")
+
+          File.readlines("/proc/1/cgroup").any? do |line|
+            line.include?("docker") ||
+              line.include?("lxc") ||
+              line.include?("containerd") ||
+              line.include?("podman")
+          end
+        rescue
+          false
+        end
+
+        def cgroup_contains?(pattern)
+          return false unless File.exist?("/proc/1/cgroup")
+
+          File.readlines("/proc/1/cgroup").any? { |line| line.include?(pattern) }
+        rescue
+          false
+        end
+
+        def hostname
+          ENV["HOSTNAME"] || `hostname`.strip
+        rescue
+          "unknown"
+        end
+
+        def hostname_indicates_container?
+          host = hostname
+          # Containers often have short hex hostnames (12 chars) or specific patterns
+          host.length == 12 && host.match?(/^[0-9a-f]+$/)
+        end
+
+        def likely_dev_environment?
+          # Check for common development tools and patterns
+          File.exist?("/workspace") ||
+            ENV["TERM_PROGRAM"] == "vscode" ||
+            ENV["EDITOR"]&.include?("code")
+        end
+      end
+    end
+  end
+end

data/lib/aidp/version.rb

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

data/lib/aidp/watch/build_processor.rb

@@ -226,13 +226,24 @@ module Aidp
 
       def handle_success(issue:, slug:, branch_name:, base_branch:, plan_data:, working_dir:)
         stage_and_commit(issue, working_dir: working_dir)
-        pr_url = create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch, working_dir: working_dir)
+
+        # Check if PR should be created based on VCS preferences
+        vcs_config = config.dig(:work_loop, :version_control) || {}
+        auto_create_pr = vcs_config.fetch(:auto_create_pr, false)
+
+        pr_url = if auto_create_pr
+          create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch, working_dir: working_dir)
+        else
+          display_message("ℹ️  Skipping PR creation (disabled in VCS preferences)", type: :muted)
+          nil
+        end
 
         workstream_note = @use_workstreams ? "\n- Workstream: `#{slug}`" : ""
+        pr_line = pr_url ? "\n- Pull Request: #{pr_url}" : ""
+
         comment = <<~COMMENT
           ✅ Implementation complete for ##{issue[:number]}.
-          - Branch: `#{branch_name}`#{workstream_note}
-          - Pull Request: #{pr_url}
+          - Branch: `#{branch_name}`#{workstream_note}#{pr_line}
 
           Summary:
           #{plan_value(plan_data, "summary")}
@@ -281,9 +292,58 @@ module Aidp
           end
 
           run_git(%w[add -A])
-          commit_message = "feat: implement ##{issue[:number]} #{issue[:title]}"
+          commit_message = build_commit_message(issue)
           run_git(["commit", "-m", commit_message])
-          display_message("💾 Created commit: #{commit_message}", type: :info)
+          display_message("💾 Created commit: #{commit_message.lines.first.strip}", type: :info)
+        end
+      end
+
+      def build_commit_message(issue)
+        vcs_config = config.dig(:work_loop, :version_control) || {}
+
+        # Base message components
+        issue_ref = "##{issue[:number]}"
+        title = issue[:title]
+
+        # Determine commit prefix based on configuration
+        prefix = if vcs_config[:conventional_commits]
+          commit_style = vcs_config[:commit_style] || "default"
+          emoji = (commit_style == "emoji") ? "✨ " : ""
+          scope = (commit_style == "angular") ? "(implementation)" : ""
+          "#{emoji}feat#{scope}: "
+        else
+          ""
+        end
+
+        # Build main message
+        main_message = "#{prefix}implement #{issue_ref} #{title}"
+
+        # Add co-author attribution if configured
+        if vcs_config.fetch(:co_author_ai, true)
+          provider_name = detect_current_provider || "AI Agent"
+          co_author = "\n\nCo-authored-by: #{provider_name} <ai@aidp.dev>"
+          main_message + co_author
+        else
+          main_message
+        end
+      end
+
+      def detect_current_provider
+        # Attempt to detect which provider is being used
+        # This is a best-effort detection
+        config_manager = Aidp::Harness::ConfigManager.new(@project_dir)
+        default_provider = config_manager.config.dig(:harness, :default_provider)
+        default_provider&.capitalize
+      rescue
+        nil
+      end
+
+      def config
+        @config ||= begin
+          config_manager = Aidp::Harness::ConfigManager.new(@project_dir)
+          config_manager.config || {}
+        rescue
+          {}
         end
       end
 
@@ -298,12 +358,18 @@ module Aidp
           #{test_summary}
         BODY
 
+        # Determine if PR should be draft based on VCS preferences
+        vcs_config = config.dig(:work_loop, :version_control) || {}
+        pr_strategy = vcs_config[:pr_strategy] || "draft"
+        draft = (pr_strategy == "draft")
+
         output = @repository_client.create_pull_request(
           title: title,
           body: body,
           head: branch_name,
           base: base_branch,
-          issue_number: issue[:number]
+          issue_number: issue[:number],
+          draft: draft
         )
 
         extract_pr_url(output)

data/lib/aidp/watch/repository_client.rb

@@ -162,7 +162,7 @@ module Aidp
         response.body
       end
 
-      def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:)
+      def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:, draft: false)
         cmd = [
           "gh", "pr", "create",
           "--repo", full_repo,
@@ -172,6 +172,7 @@ module Aidp
           "--base", base
         ]
         cmd += ["--issue", issue_number.to_s] if issue_number
+        cmd += ["--draft"] if draft
 
         stdout, stderr, status = Open3.capture3(*cmd)
         raise "Failed to create PR via gh: #{stderr.strip}" unless status.success?

data/lib/aidp.rb

@@ -25,7 +25,6 @@ require_relative "aidp/providers/base"
 require_relative "aidp/providers/cursor"
 require_relative "aidp/providers/anthropic"
 require_relative "aidp/providers/gemini"
-require_relative "aidp/providers/macos_ui"
 # Supervised providers removed - using direct execution model
 require_relative "aidp/provider_manager"