aidp 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15737cc2920d4af142a562df51e1acd5951625e836584f62dca3d30f7eb51a81
-  data.tar.gz: a8243c124ab94cc09f775088cbb62faf6f6fa558f3c6a78bbf52b455d3b446f5
+  metadata.gz: ceebdfcb742085ac8d9ea6b5db63557d5fe999f498e97699c199fc9651cf4654
+  data.tar.gz: f1b230dcc33692c4c0391464beaf305b76993dbe02964d8c80198a7a50294a5c
 SHA512:
-  metadata.gz: db054e792e7c69e22ea2ccda883674e9045febe6907e7d8a9ffc925db952c98e253303d883b3dbb744b079255ea554b66448bdd3eaf6ce0a60130c09ddac6868
-  data.tar.gz: 4ebe66fadbdef39a5ddad1df6fb7790b86a16a0fef306636b00b7154dc5191c403763484d1448b21c89daf0c5f22c9a39cda1bc7fe2668e632b817951a4d9a3a
+  metadata.gz: d20547fa251feb09a97e6795b04fc09dd13d0f0fd801c5abdc994bb27a20898a604692eb04b7ed8a370ac7619bcbaf89a17af60dc34c844e782e8b68087ef67a
+  data.tar.gz: cb8503f9b0a85d6113d9ab2dada1cb0087b9b9e6ab1abb44894aa5152d3596c782c08f4708e3f03f9b969a94736acb7d882350b6f0cb869787069c8b12ddde85

data/bin/aidp

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'aidp'
-Aidp::Shared::CLI.start(ARGV)
+require "aidp"
+Aidp::CLI.start(ARGV)

data/lib/aidp/analyze/data_retention_manager.rb

@@ -19,8 +19,8 @@ module Aidp
       # Default retention periods (in days)
       DEFAULT_RETENTION_PERIODS = {
         "analysis_results" => 90, # 3 months
-        "execution_logs" => 30,   # 1 month
-        "temporary_data" => 1     # 1 day
+        "execution_logs" => 30, # 1 month
+        "temporary_data" => 1 # 1 day
       }.freeze
 
       def initialize(project_dir = Dir.pwd, config = {})

data/lib/aidp/analyze/large_analysis_progress.rb

@@ -13,7 +13,7 @@ module Aidp
     # Default configuration
     DEFAULT_CONFIG = {
       checkpoint_interval: 100, # Save progress every 100 items
-      max_checkpoints: 50,      # Keep last 50 checkpoints
+      max_checkpoints: 50, # Keep last 50 checkpoints
       progress_file: ".aidp-large-analysis-progress.yml",
       auto_save: true,
       detailed_logging: false
@@ -280,7 +280,7 @@ module Aidp
       when "json"
         JSON.parse(data)
       when "yaml"
-        YAML.load(data)
+        YAML.safe_load(data)
       else
         raise "Unsupported import format: #{format}"
       end

data/lib/aidp/analyze/prioritizer.rb

@@ -281,9 +281,9 @@ module Aidp
 
         # Adjust for authorship patterns
         if authorship_file[:author_count] == 1
-          base_score *= 1.5  # Knowledge silo penalty
+          base_score *= 1.5 # Knowledge silo penalty
         elsif authorship_file[:author_count] > 3
-          base_score *= 1.2  # Coordination complexity penalty
+          base_score *= 1.2 # Coordination complexity penalty
         end
 
         base_score

data/lib/aidp/analyze/repository_chunker.rb

@@ -13,15 +13,15 @@ module Aidp
       DEFAULT_CHUNK_CONFIG = {
         "time_based" => {
           "chunk_size" => "30d", # 30 days
-          "overlap" => "7d"      # 7 days overlap
+          "overlap" => "7d" # 7 days overlap
         },
         "commit_count" => {
-          "chunk_size" => 1000,  # 1000 commits per chunk
-          "overlap" => 100       # 100 commits overlap
+          "chunk_size" => 1000, # 1000 commits per chunk
+          "overlap" => 100 # 100 commits overlap
         },
         "size_based" => {
           "chunk_size" => "100MB", # 100MB per chunk
-          "overlap" => "10MB"      # 10MB overlap
+          "overlap" => "10MB" # 10MB overlap
         },
         "feature_based" => {
           "max_files_per_chunk" => 500,
@@ -358,14 +358,15 @@ module Aidp
 
       def parse_time_duration(duration_str)
         # Parse duration strings like "30d", "7d", "1w", etc.
-        case duration_str
-        when /(\d+)d/
+        # Use anchored patterns with limited digit repetition to prevent ReDoS
+        case duration_str.to_s.strip
+        when /\A(\d{1,6})d\z/
           ::Regexp.last_match(1).to_i * 24 * 60 * 60
-        when /(\d+)w/
+        when /\A(\d{1,6})w\z/
           ::Regexp.last_match(1).to_i * 7 * 24 * 60 * 60
-        when /(\d+)m/
+        when /\A(\d{1,6})m\z/
           ::Regexp.last_match(1).to_i * 30 * 24 * 60 * 60
-        when /(\d+)y/
+        when /\A(\d{1,6})y\z/
           ::Regexp.last_match(1).to_i * 365 * 24 * 60 * 60
         else
           30 * 24 * 60 * 60 # Default to 30 days
@@ -374,12 +375,13 @@ module Aidp
 
       def parse_size(size_str)
         # Parse size strings like "100MB", "1GB", etc.
-        case size_str
-        when /(\d+)KB/i
+        # Use anchored patterns with limited digit repetition to prevent ReDoS
+        case size_str.to_s.strip
+        when /\A(\d{1,10})KB\z/i
           ::Regexp.last_match(1).to_i * 1024
-        when /(\d+)MB/i
+        when /\A(\d{1,10})MB\z/i
           ::Regexp.last_match(1).to_i * 1024 * 1024
-        when /(\d+)GB/i
+        when /\A(\d{1,10})GB\z/i
           ::Regexp.last_match(1).to_i * 1024 * 1024 * 1024
         else
           100 * 1024 * 1024 # Default to 100MB

data/lib/aidp/analyze/storage.rb

@@ -288,7 +288,7 @@ module Aidp
       when "json"
         JSON.parse(data)
       when "yaml"
-        YAML.load(data)
+        YAML.safe_load(data)
       else
         raise "Unsupported import format: #{format}"
       end

data/lib/aidp/cli.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Aidp
+  # CLI interface for both execute and analyze modes
+  class CLI < Thor
+    desc "execute [STEP]", "Run execute mode step(s)"
+    option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
+    option :rerun, type: :boolean, desc: "Re-run a completed step"
+    def execute(project_dir = Dir.pwd, step_name = nil, custom_options = {})
+      if step_name
+        runner = Aidp::Execute::Runner.new(project_dir)
+        # Merge Thor options with custom options
+        all_options = options.merge(custom_options)
+        runner.run_step(step_name, all_options)
+      else
+        puts "Available execute steps:"
+        Aidp::Execute::Steps::SPEC.keys.each { |step| puts "  - #{step}" }
+        progress = Aidp::Execute::Progress.new(project_dir)
+        next_step = progress.next_step
+        {status: "success", message: "Available steps listed", next_step: next_step}
+      end
+    end
+
+    desc "analyze [STEP]", "Run analyze mode step(s)"
+    long_desc <<~DESC
+      Run analyze mode steps. STEP can be:
+      - A full step name (e.g., 01_REPOSITORY_ANALYSIS)
+      - A step number (e.g., 01, 02, 03)
+      - 'next' to run the next unfinished step
+      - 'current' to run the current step
+      - Empty to list available steps
+    DESC
+    option :force, type: :boolean, desc: "Force execution even if dependencies are not met"
+    option :rerun, type: :boolean, desc: "Re-run a completed step"
+    def analyze(project_dir = Dir.pwd, step_name = nil, custom_options = {})
+      progress = Aidp::Analyze::Progress.new(project_dir)
+
+      if step_name
+        # Resolve the step name
+        resolved_step = resolve_analyze_step(step_name, progress)
+
+        if resolved_step
+          runner = Aidp::Analyze::Runner.new(project_dir)
+          # Merge Thor options with custom options
+          all_options = options.merge(custom_options)
+          runner.run_step(resolved_step, all_options)
+        else
+          puts "❌ Step '#{step_name}' not found or not available"
+          puts "\nAvailable steps:"
+          Aidp::Analyze::Steps::SPEC.keys.each_with_index do |step, index|
+            status = progress.step_completed?(step) ? "✅" : "⏳"
+            puts "  #{status} #{sprintf("%02d", index + 1)}: #{step}"
+          end
+          {status: "error", message: "Step not found"}
+        end
+      else
+        puts "Available analyze steps:"
+        Aidp::Analyze::Steps::SPEC.keys.each_with_index do |step, index|
+          status = progress.step_completed?(step) ? "✅" : "⏳"
+          puts "  #{status} #{sprintf("%02d", index + 1)}: #{step}"
+        end
+
+        next_step = progress.next_step
+        if next_step
+          puts "\n💡 Run 'aidp analyze next' or 'aidp analyze #{next_step.match(/^(\d+)/)[1]}' to run the next step"
+        end
+
+        {status: "success", message: "Available steps listed", next_step: next_step,
+         completed_steps: progress.completed_steps}
+      end
+    end
+
+    desc "analyze-approve STEP", "Approve a completed analyze gate step"
+    def analyze_approve(project_dir = Dir.pwd, step_name = nil)
+      progress = Aidp::Analyze::Progress.new(project_dir)
+      progress.mark_step_completed(step_name)
+      puts "✅ Approved analyze step: #{step_name}"
+      {status: "success", step: step_name}
+    end
+
+    desc "analyze-reset", "Reset analyze mode progress"
+    def analyze_reset(project_dir = Dir.pwd)
+      progress = Aidp::Analyze::Progress.new(project_dir)
+      progress.reset
+      puts "🔄 Reset analyze mode progress"
+      {status: "success", message: "Progress reset"}
+    end
+
+    desc "execute-approve STEP", "Approve a completed execute gate step"
+    def execute_approve(project_dir = Dir.pwd, step_name = nil)
+      progress = Aidp::Execute::Progress.new(project_dir)
+      progress.mark_step_completed(step_name)
+      puts "✅ Approved execute step: #{step_name}"
+      {status: "success", step: step_name}
+    end
+
+    desc "execute-reset", "Reset execute mode progress"
+    def execute_reset(project_dir = Dir.pwd)
+      progress = Aidp::Execute::Progress.new(project_dir)
+      progress.reset
+      puts "🔄 Reset execute mode progress"
+      {status: "success", message: "Progress reset"}
+    end
+
+    # Backward compatibility aliases
+    desc "approve STEP", "Approve a completed execute gate step (alias for execute-approve)"
+    def approve(project_dir = Dir.pwd, step_name = nil)
+      execute_approve(project_dir, step_name)
+    end
+
+    desc "reset", "Reset execute mode progress (alias for execute-reset)"
+    def reset(project_dir = Dir.pwd)
+      execute_reset(project_dir)
+    end
+
+    desc "status", "Show current progress for both modes"
+    def status
+      puts "\n📊 AI Dev Pipeline Status"
+      puts "=" * 50
+
+      # Execute mode status
+      execute_progress = Aidp::Execute::Progress.new(Dir.pwd)
+      puts "\n🔧 Execute Mode:"
+      Aidp::Execute::Steps::SPEC.keys.each do |step|
+        status = execute_progress.step_completed?(step) ? "✅" : "⏳"
+        puts "  #{status} #{step}"
+      end
+
+      # Analyze mode status
+      analyze_progress = Aidp::Analyze::Progress.new(Dir.pwd)
+      puts "\n🔍 Analyze Mode:"
+      Aidp::Analyze::Steps::SPEC.keys.each do |step|
+        status = analyze_progress.step_completed?(step) ? "✅" : "⏳"
+        puts "  #{status} #{step}"
+      end
+    end
+
+    desc "version", "Show version information"
+    def version
+      puts "Aidp version #{Aidp::VERSION}"
+    end
+
+    private
+
+    def resolve_analyze_step(step_input, progress)
+      step_input = step_input.to_s.downcase.strip
+
+      case step_input
+      when "next"
+        progress.next_step
+      when "current"
+        progress.current_step || progress.next_step
+      else
+        # Check if it's a step number (e.g., "01", "02", "1", "2")
+        if step_input.match?(/^\d{1,2}$/)
+          step_number = sprintf("%02d", step_input.to_i)
+          # Find step that starts with this number
+          Aidp::Analyze::Steps::SPEC.keys.find { |step| step.start_with?(step_number) }
+        else
+          # Check if it's a full step name (case insensitive)
+          Aidp::Analyze::Steps::SPEC.keys.find { |step| step.downcase == step_input }
+        end
+      end
+    end
+  end
+end

data/lib/aidp/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Aidp
+  # Configuration management for both execute and analyze modes
+  class Config
+    def self.load(project_dir = Dir.pwd)
+      config_file = File.join(project_dir, ".aidp.yml")
+      if File.exist?(config_file)
+        YAML.load_file(config_file) || {}
+      else
+        {}
+      end
+    end
+
+    def self.templates_root
+      File.join(Dir.pwd, "templates")
+    end
+
+    def self.analyze_templates_root
+      File.join(Dir.pwd, "templates", "ANALYZE")
+    end
+
+    def self.execute_templates_root
+      File.join(Dir.pwd, "templates", "EXECUTE")
+    end
+
+    def self.common_templates_root
+      File.join(Dir.pwd, "templates", "COMMON")
+    end
+  end
+end

data/lib/aidp/project_detector.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Aidp
+  # Detects project type, language, framework, and other characteristics
+  class ProjectDetector
+    attr_reader :project_dir
+
+    def initialize(project_dir = Dir.pwd)
+      @project_dir = project_dir
+    end
+
+    def detect
+      {
+        language: detect_language,
+        framework: detect_framework,
+        build_system: detect_build_system,
+        package_manager: detect_package_manager,
+        static_analysis_tools: detect_static_analysis_tools,
+        test_framework: detect_test_framework,
+        database: detect_database,
+        deployment: detect_deployment
+      }
+    end
+
+    private
+
+    def detect_language
+      return "ruby" if File.exist?(File.join(@project_dir, "Gemfile"))
+      return "javascript" if File.exist?(File.join(@project_dir, "package.json"))
+      return "python" if File.exist?(File.join(@project_dir, "requirements.txt")) || File.exist?(File.join(@project_dir, "pyproject.toml"))
+      return "java" if File.exist?(File.join(@project_dir, "pom.xml")) || File.exist?(File.join(@project_dir, "build.gradle"))
+      return "go" if File.exist?(File.join(@project_dir, "go.mod"))
+      return "rust" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+      return "csharp" if File.exist?(File.join(@project_dir, "*.csproj"))
+      "unknown"
+    end
+
+    def detect_framework
+      case detect_language
+      when "ruby"
+        return "rails" if File.exist?(File.join(@project_dir, "config", "application.rb"))
+        return "sinatra" if File.exist?(File.join(@project_dir, "app.rb")) && File.read(File.join(@project_dir, "app.rb")).include?("Sinatra")
+      when "javascript"
+        return "react" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("react")
+        return "vue" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("vue")
+        return "angular" if File.exist?(File.join(@project_dir, "angular.json"))
+        return "express" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("express")
+      when "python"
+        return "django" if File.exist?(File.join(@project_dir, "manage.py"))
+        return "flask" if File.exist?(File.join(@project_dir, "app.py")) && File.read(File.join(@project_dir, "app.py")).include?("Flask")
+      when "java"
+        return "spring" if File.exist?(File.join(@project_dir, "pom.xml")) && File.read(File.join(@project_dir, "pom.xml")).include?("spring-boot")
+      end
+      "unknown"
+    end
+
+    def detect_build_system
+      return "maven" if File.exist?(File.join(@project_dir, "pom.xml"))
+      return "gradle" if File.exist?(File.join(@project_dir, "build.gradle"))
+      return "npm" if File.exist?(File.join(@project_dir, "package.json"))
+      return "bundler" if File.exist?(File.join(@project_dir, "Gemfile"))
+      return "pip" if File.exist?(File.join(@project_dir, "requirements.txt"))
+      return "cargo" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+      return "go" if File.exist?(File.join(@project_dir, "go.mod"))
+      "unknown"
+    end
+
+    def detect_package_manager
+      detect_build_system
+    end
+
+    def detect_static_analysis_tools
+      tools = []
+      tools << "rubocop" if File.exist?(File.join(@project_dir, ".rubocop.yml"))
+      tools << "eslint" if File.exist?(File.join(@project_dir, ".eslintrc"))
+      tools << "flake8" if File.exist?(File.join(@project_dir, ".flake8"))
+      tools << "checkstyle" if File.exist?(File.join(@project_dir, "checkstyle.xml"))
+      tools << "clippy" if File.exist?(File.join(@project_dir, "Cargo.toml"))
+      tools
+    end
+
+    def detect_test_framework
+      case detect_language
+      when "ruby"
+        return "rspec" if File.exist?(File.join(@project_dir, "spec"))
+        return "minitest" if File.exist?(File.join(@project_dir, "test"))
+      when "javascript"
+        return "jest" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("jest")
+        return "mocha" if File.exist?(File.join(@project_dir, "package.json")) && File.read(File.join(@project_dir, "package.json")).include?("mocha")
+      when "python"
+        return "pytest" if File.exist?(File.join(@project_dir, "pytest.ini"))
+        return "unittest" if Dir.exist?(File.join(@project_dir, "tests"))
+      when "java"
+        return "junit" if File.exist?(File.join(@project_dir, "src", "test"))
+      end
+      "unknown"
+    end
+
+    def detect_database
+      return "postgresql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("postgresql")
+      return "mysql" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("mysql")
+      return "sqlite" if File.exist?(File.join(@project_dir, "config", "database.yml")) && File.read(File.join(@project_dir, "config", "database.yml")).include?("sqlite")
+      "unknown"
+    end
+
+    def detect_deployment
+      return "docker" if File.exist?(File.join(@project_dir, "Dockerfile"))
+      return "kubernetes" if File.exist?(File.join(@project_dir, "k8s")) || File.exist?(File.join(@project_dir, "kubernetes"))
+      return "heroku" if File.exist?(File.join(@project_dir, "Procfile"))
+      return "aws" if File.exist?(File.join(@project_dir, "serverless.yml")) || File.exist?(File.join(@project_dir, "template.yaml"))
+      "unknown"
+    end
+  end
+end

data/lib/aidp/providers/anthropic.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Providers
+    class Anthropic < Base
+      def self.available?
+        !!Aidp::Util.which("claude")
+      end
+
+      def name = "anthropic"
+
+      def send(prompt:, session: nil)
+        raise "claude CLI not available" unless self.class.available?
+
+        # Use Claude CLI for non-interactive mode
+        cmd = ["claude", "compose", "--prompt", prompt]
+        system(*cmd)
+        :ok
+      end
+    end
+  end
+end

data/lib/aidp/providers/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Providers
+    class Base
+      def name = raise(NotImplementedError)
+
+      # Send a composed prompt string to the provider.
+      # Return :ok when command completed successfully,
+      # Return :interactive when starting an interactive session (for gate steps),
+      # or return a string if we captured output and the caller should write to a file.
+      def send(prompt:, session: nil) = raise(NotImplementedError)
+    end
+  end
+end

data/lib/aidp/providers/cursor.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+require_relative "base"
+require_relative "../util"
+
+module Aidp
+  module Providers
+    class Cursor < Base
+      def self.available?
+        !!Aidp::Util.which("cursor-agent")
+      end
+
+      def name = "cursor"
+
+      def send(prompt:, session: nil)
+        raise "cursor-agent not available" unless self.class.available?
+
+        # Always use non-interactive mode with -p flag
+        cmd = ["cursor-agent", "-p"]
+        puts "📝 Sending prompt to cursor-agent"
+
+        # Enable debug output if requested
+        if ENV["AIDP_DEBUG"]
+          puts "🔍 Debug mode enabled - showing cursor-agent output"
+        end
+
+        # Setup logging if log file is specified
+        log_file = ENV["AIDP_LOG_FILE"]
+        if log_file
+          puts "📝 Logging to: #{log_file}"
+        end
+
+        Open3.popen3(*cmd) do |stdin, stdout, stderr, wait|
+          # Send the prompt to stdin
+          stdin.puts prompt
+          stdin.close
+
+          # Log the prompt if debugging
+          if ENV["AIDP_DEBUG"] || log_file
+            prompt_log = "📝 Sending prompt to cursor-agent:\n#{prompt}"
+            puts prompt_log if ENV["AIDP_DEBUG"]
+            File.write(log_file, "#{Time.now.iso8601} #{prompt_log}\n", mode: "a") if log_file
+          end
+
+          # Handle debug output and logging
+          if ENV["AIDP_DEBUG"] || log_file
+            # Start threads to capture and display output in real-time
+            stdout_thread = Thread.new do
+              stdout.each_line do |line|
+                output = "📤 cursor-agent: #{line.chomp}"
+                puts output if ENV["AIDP_DEBUG"]
+                File.write(log_file, "#{Time.now.iso8601} #{output}\n", mode: "a") if log_file
+              end
+            end
+
+            stderr_thread = Thread.new do
+              stderr.each_line do |line|
+                output = "❌ cursor-agent error: #{line.chomp}"
+                puts output if ENV["AIDP_DEBUG"]
+                File.write(log_file, "#{Time.now.iso8601} #{output}\n", mode: "a") if log_file
+              end
+            end
+          end
+
+          # Wait for completion with a reasonable timeout
+          begin
+            Timeout.timeout(300) do # 5 minutes timeout
+              result = wait.value
+
+              # Stop debug threads
+              if ENV["AIDP_DEBUG"]
+                stdout_thread&.kill
+                stderr_thread&.kill
+              end
+
+              return :ok if result.success?
+              raise "cursor-agent failed with exit code #{result.exitstatus}"
+            end
+          rescue Timeout::Error
+            # Stop debug threads
+            if ENV["AIDP_DEBUG"]
+              stdout_thread&.kill
+              stderr_thread&.kill
+            end
+
+            # Kill the process if it's taking too long
+            begin
+              Process.kill("TERM", wait.pid)
+            rescue
+              nil
+            end
+            raise Timeout::Error, "cursor-agent timed out after 5 minutes"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/providers/gemini.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Providers
+    class Gemini < Base
+      def self.available?
+        !!Aidp::Util.which("gemini")
+      end
+
+      def name = "gemini"
+
+      def send(prompt:, session: nil)
+        raise "gemini CLI not available" unless self.class.available?
+
+        # Use Gemini CLI for non-interactive mode
+        cmd = ["gemini", "chat", "--prompt", prompt]
+        system(*cmd)
+        :ok
+      end
+    end
+  end
+end

data/lib/aidp/providers/macos_ui.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Aidp
+  module Providers
+    class MacOSUI < Base
+      def self.available?
+        RUBY_PLATFORM.include?("darwin")
+      end
+
+      def name = "macos"
+
+      def send(prompt:, session: nil)
+        raise "macOS UI not available on this platform" unless self.class.available?
+
+        # Use macOS UI for interactive mode
+        cmd = ["osascript", "-e", "display dialog \"#{prompt}\" with title \"Aidp\" buttons {\"OK\"} default button \"OK\""]
+        system(*cmd)
+        :ok
+      end
+    end
+  end
+end

data/lib/aidp/sync.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  # Synchronization utilities
+  class Sync
+    def self.ensure_workspace_sync
+      # Placeholder for workspace synchronization logic
+      true
+    end
+  end
+end