aidp 0.15.2 → 0.17.0

data/lib/aidp/watch/build_processor.rb

@@ -6,6 +6,7 @@ require "time"
 require_relative "../message_display"
 require_relative "../execute/prompt_manager"
 require_relative "../harness/runner"
+require_relative "../worktree"
 
 module Aidp
   module Watch
@@ -17,10 +18,11 @@ module Aidp
       BUILD_LABEL = "aidp-build"
       IMPLEMENTATION_STEP = "16_IMPLEMENTATION"
 
-      def initialize(repository_client:, state_store:, project_dir: Dir.pwd)
+      def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true)
         @repository_client = repository_client
         @state_store = state_store
         @project_dir = project_dir
+        @use_workstreams = use_workstreams
       end
 
       def process(issue)
@@ -30,27 +32,36 @@ module Aidp
         plan_data = ensure_plan_data(number)
         return unless plan_data
 
+        slug = workstream_slug_for(issue)
         branch_name = branch_name_for(issue)
-        @state_store.record_build_status(number, status: "running", details: {branch: branch_name, started_at: Time.now.utc.iso8601})
+        @state_store.record_build_status(number, status: "running", details: {branch: branch_name, workstream: slug, started_at: Time.now.utc.iso8601})
 
         ensure_git_repo!
         base_branch = detect_base_branch
 
-        checkout_branch(base_branch, branch_name)
+        if @use_workstreams
+          workstream_path = setup_workstream(slug: slug, branch_name: branch_name, base_branch: base_branch)
+          working_dir = workstream_path
+        else
+          checkout_branch(base_branch, branch_name)
+          working_dir = @project_dir
+        end
+
         prompt_content = build_prompt(issue: issue, plan_data: plan_data)
-        write_prompt(prompt_content)
+        write_prompt(prompt_content, working_dir: working_dir)
 
         user_input = build_user_input(issue: issue, plan_data: plan_data)
-        result = run_harness(user_input: user_input)
+        result = run_harness(user_input: user_input, working_dir: working_dir)
 
         if result[:status] == "completed"
-          handle_success(issue: issue, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data)
+          handle_success(issue: issue, slug: slug, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data, working_dir: working_dir)
         else
-          handle_failure(issue: issue, result: result)
+          handle_failure(issue: issue, slug: slug, result: result)
         end
       rescue => e
         display_message("❌ Implementation failed: #{e.message}", type: :error)
         @state_store.record_build_status(issue[:number], status: "failed", details: {error: e.message})
+        cleanup_workstream(slug) if @use_workstreams && slug
         raise
       end
 
@@ -96,9 +107,56 @@ module Aidp
         display_message("🌿 Checked out #{branch_name}", type: :info)
       end
 
-      def branch_name_for(issue)
+      def workstream_slug_for(issue)
         slug = issue[:title].to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")
-        "aidp/issue-#{issue[:number]}-#{slug[0, 32]}"
+        "issue-#{issue[:number]}-#{slug[0, 32]}"
+      end
+
+      def branch_name_for(issue)
+        "aidp/#{workstream_slug_for(issue)}"
+      end
+
+      def setup_workstream(slug:, branch_name:, base_branch:)
+        # Check if workstream already exists
+        existing = Aidp::Worktree.info(slug: slug, project_dir: @project_dir)
+        if existing
+          display_message("🔄 Reusing existing workstream: #{slug}", type: :info)
+          Dir.chdir(existing[:path]) do
+            run_git(["checkout", existing[:branch]])
+            run_git(%w[pull --ff-only], allow_failure: true)
+          end
+          return existing[:path]
+        end
+
+        # Create new workstream
+        display_message("🌿 Creating workstream: #{slug}", type: :info)
+        result = Aidp::Worktree.create(
+          slug: slug,
+          project_dir: @project_dir,
+          branch: branch_name,
+          base_branch: base_branch
+        )
+
+        if result[:success]
+          display_message("✅ Workstream created at #{result[:path]}", type: :success)
+          result[:path]
+        else
+          raise "Failed to create workstream: #{result[:message]}"
+        end
+      end
+
+      def cleanup_workstream(slug)
+        return unless slug
+
+        display_message("🧹 Cleaning up workstream: #{slug}", type: :info)
+        result = Aidp::Worktree.remove(slug: slug, project_dir: @project_dir, force: true)
+        if result[:success]
+          display_message("✅ Workstream removed", type: :success)
+        else
+          display_message("⚠️  Failed to remove workstream: #{result[:message]}", type: :warn)
+        end
+      rescue => e
+        display_message("⚠️  Error cleaning up workstream: #{e.message}", type: :warn)
       end
 
       def build_prompt(issue:, plan_data:)
@@ -141,8 +199,8 @@ module Aidp
         "_Unable to parse comment thread._"
       end
 
-      def write_prompt(content)
-        prompt_manager = Aidp::Execute::PromptManager.new(@project_dir)
+      def write_prompt(content, working_dir: @project_dir)
+        prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
         prompt_manager.write(content)
         display_message("📝 Wrote PROMPT.md with implementation contract", type: :info)
       end
@@ -156,23 +214,24 @@ module Aidp
         }.delete_if { |_k, v| v.nil? || v.empty? }
       end
 
-      def run_harness(user_input:)
+      def run_harness(user_input:, working_dir: @project_dir)
         options = {
           selected_steps: [IMPLEMENTATION_STEP],
           workflow_type: :watch_mode,
           user_input: user_input
         }
-        runner = Aidp::Harness::Runner.new(@project_dir, :execute, options)
+        runner = Aidp::Harness::Runner.new(working_dir, :execute, options)
         runner.run
       end
 
-      def handle_success(issue:, branch_name:, base_branch:, plan_data:)
-        stage_and_commit(issue)
-        pr_url = create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch)
+      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)
 
+        workstream_note = @use_workstreams ? "\n- Workstream: `#{slug}`" : ""
         comment = <<~COMMENT
           ✅ Implementation complete for ##{issue[:number]}.
-          - Branch: `#{branch_name}`
+          - Branch: `#{branch_name}`#{workstream_note}
           - Pull Request: #{pr_url}
 
           Summary:
@@ -183,32 +242,38 @@ module Aidp
         @state_store.record_build_status(
           issue[:number],
           status: "completed",
-          details: {branch: branch_name, pr_url: pr_url}
+          details: {branch: branch_name, workstream: slug, pr_url: pr_url}
         )
         display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
+
+        # Keep workstream for review - don't auto-cleanup on success
+        if @use_workstreams
+          display_message("ℹ️  Workstream #{slug} preserved for review. Remove with: aidp ws rm #{slug}", type: :muted)
+        end
       end
 
-      def handle_failure(issue:, result:)
+      def handle_failure(issue:, slug:, result:)
         message = result[:message] || "Unknown failure"
+        workstream_note = @use_workstreams ? " The workstream `#{slug}` has been left intact for debugging." : " The branch has been left intact for debugging."
         comment = <<~COMMENT
           ❌ Implementation attempt for ##{issue[:number]} failed.
 
           Status: #{result[:status]}
           Details: #{message}
 
-          Please review the repository for partial changes. The branch has been left intact for debugging.
+          Please review the repository for partial changes.#{workstream_note}
         COMMENT
         @repository_client.post_comment(issue[:number], comment)
         @state_store.record_build_status(
           issue[:number],
           status: "failed",
-          details: {message: message}
+          details: {message: message, workstream: slug}
         )
         display_message("⚠️  Build failure recorded for issue ##{issue[:number]}", type: :warn)
       end
 
-      def stage_and_commit(issue)
-        Dir.chdir(@project_dir) do
+      def stage_and_commit(issue, working_dir: @project_dir)
+        Dir.chdir(working_dir) do
           status_output = run_git(%w[status --porcelain])
           if status_output.strip.empty?
             display_message("ℹ️  No file changes detected after work loop.", type: :muted)
@@ -222,9 +287,9 @@ module Aidp
         end
       end
 
-      def create_pull_request(issue:, branch_name:, base_branch:)
+      def create_pull_request(issue:, branch_name:, base_branch:, working_dir: @project_dir)
         title = "aidp: Resolve ##{issue[:number]} - #{issue[:title]}"
-        test_summary = gather_test_summary
+        test_summary = gather_test_summary(working_dir: working_dir)
         body = <<~BODY
           ## Summary
           - Automated resolution for ##{issue[:number]}
@@ -244,8 +309,8 @@ module Aidp
         extract_pr_url(output)
       end
 
-      def gather_test_summary
-        Dir.chdir(@project_dir) do
+      def gather_test_summary(working_dir: @project_dir)
+        Dir.chdir(working_dir) do
           log_path = File.join(".aidp", "logs", "test_runner.log")
           return "- Fix-forward harness executed; refer to #{log_path}" unless File.exist?(log_path)
 
@@ -257,7 +322,7 @@ module Aidp
           end
         end
       rescue
-        "- Fix-forward harness executed successfully."
+        "- Fix-forward harness extracted successfully."
       end
 
       def extract_pr_url(output)

data/lib/aidp/watch/runner.rb

@@ -18,7 +18,7 @@ module Aidp
 
       DEFAULT_INTERVAL = 30
 
-      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, prompt: TTY::Prompt.new)
+      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new)
         @prompt = prompt
         @interval = interval
         @once = once
@@ -35,7 +35,8 @@ module Aidp
         @build_processor = BuildProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
-          project_dir: project_dir
+          project_dir: project_dir,
+          use_workstreams: use_workstreams
         )
       end
 

data/lib/aidp/workstream_executor.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+require "time"
+require_relative "worktree"
+require_relative "workstream_state"
+require_relative "harness/runner"
+require_relative "message_display"
+
+module Aidp
+  # Executes multiple workstreams in parallel using concurrent-ruby.
+  # Provides true parallel execution with process isolation and status tracking.
+  class WorkstreamExecutor
+    include Aidp::MessageDisplay
+
+    # Result from executing a workstream
+    WorkstreamResult = Struct.new(
+      :slug,
+      :status,
+      :exit_code,
+      :started_at,
+      :completed_at,
+      :duration,
+      :error,
+      keyword_init: true
+    )
+
+    def initialize(project_dir: Dir.pwd, max_concurrent: 3)
+      @project_dir = project_dir
+      @max_concurrent = max_concurrent
+      @results = Concurrent::Hash.new
+      @start_times = Concurrent::Hash.new
+    end
+
+    # Execute multiple workstreams in parallel
+    #
+    # @param slugs [Array<String>] Workstream slugs to execute
+    # @param options [Hash] Execution options
+    # @option options [Array<String>] :selected_steps Steps to execute
+    # @option options [Symbol] :workflow_type Workflow type (:execute, :analyze, etc.)
+    # @option options [Hash] :user_input User input for harness
+    # @return [Array<WorkstreamResult>] Results for each workstream
+    def execute_parallel(slugs, options = {})
+      validate_workstreams!(slugs)
+
+      display_message("🚀 Starting parallel execution of #{slugs.size} workstreams (max #{@max_concurrent} concurrent)", type: :info)
+
+      # Create thread pool with max concurrent limit
+      pool = Concurrent::FixedThreadPool.new(@max_concurrent)
+
+      # Create futures for each workstream
+      futures = slugs.map do |slug|
+        Concurrent::Future.execute(executor: pool) do
+          execute_workstream(slug, options)
+        end
+      end
+
+      # Wait for all futures to complete
+      results = futures.map(&:value)
+
+      # Shutdown pool gracefully
+      pool.shutdown
+      pool.wait_for_termination(30)
+
+      display_execution_summary(results)
+      results
+    end
+
+    # Execute all active workstreams in parallel
+    #
+    # @param options [Hash] Execution options (same as execute_parallel)
+    # @return [Array<WorkstreamResult>] Results for each workstream
+    def execute_all(options = {})
+      workstreams = Aidp::Worktree.list(project_dir: @project_dir)
+      active_slugs = workstreams.select { |ws| ws[:active] }.map { |ws| ws[:slug] }
+
+      if active_slugs.empty?
+        display_message("⚠️  No active workstreams found", type: :warn)
+        return []
+      end
+
+      execute_parallel(active_slugs, options)
+    end
+
+    # Execute a single workstream (used by futures in parallel execution)
+    #
+    # @param slug [String] Workstream slug
+    # @param options [Hash] Execution options
+    # @return [WorkstreamResult] Execution result
+    def execute_workstream(slug, options = {})
+      started_at = Time.now
+      @start_times[slug] = started_at
+
+      workstream = Aidp::Worktree.info(slug: slug, project_dir: @project_dir)
+      unless workstream
+        return WorkstreamResult.new(
+          slug: slug,
+          status: "error",
+          exit_code: 1,
+          started_at: started_at,
+          completed_at: Time.now,
+          duration: 0,
+          error: "Workstream not found"
+        )
+      end
+
+      display_message("▶️  [#{slug}] Starting execution in #{workstream[:path]}", type: :info)
+
+      # Update workstream state to active
+      Aidp::WorkstreamState.update(
+        slug: slug,
+        project_dir: @project_dir,
+        status: "active",
+        started_at: started_at.utc.iso8601
+      )
+
+      # Execute in forked process for true isolation
+      pid = fork do
+        # Change to workstream directory
+        Dir.chdir(workstream[:path])
+
+        # Execute harness
+        runner = Aidp::Harness::Runner.new(
+          workstream[:path],
+          options[:mode] || :execute,
+          options
+        )
+
+        result = runner.run
+
+        # Update state on completion
+        exit_code = (result[:status] == "completed") ? 0 : 1
+        final_status = (result[:status] == "completed") ? "completed" : "failed"
+
+        Aidp::WorkstreamState.update(
+          slug: slug,
+          project_dir: @project_dir,
+          status: final_status,
+          completed_at: Time.now.utc.iso8601
+        )
+
+        exit(exit_code)
+      rescue => e
+        # Update state on error
+        Aidp::WorkstreamState.update(
+          slug: slug,
+          project_dir: @project_dir,
+          status: "failed",
+          completed_at: Time.now.utc.iso8601
+        )
+
+        # Log error and exit
+        warn("Error in workstream #{slug}: #{e.message}")
+        warn(e.backtrace.first(5).join("\n"))
+        exit(1)
+      end
+
+      # Wait for child process
+      _pid, status = Process.wait2(pid)
+      completed_at = Time.now
+      duration = completed_at - started_at
+
+      # Build result
+      result_status = status.success? ? "completed" : "failed"
+      result = WorkstreamResult.new(
+        slug: slug,
+        status: result_status,
+        exit_code: status.exitstatus,
+        started_at: started_at,
+        completed_at: completed_at,
+        duration: duration,
+        error: status.success? ? nil : "Process exited with code #{status.exitstatus}"
+      )
+
+      @results[slug] = result
+
+      display_message("#{status.success? ? "✅" : "❌"} [#{slug}] #{result_status.capitalize} in #{format_duration(duration)}", type: status.success? ? :success : :error)
+
+      result
+    rescue => e
+      completed_at = Time.now
+      duration = completed_at - started_at
+
+      WorkstreamResult.new(
+        slug: slug,
+        status: "error",
+        exit_code: 1,
+        started_at: started_at,
+        completed_at: completed_at,
+        duration: duration,
+        error: e.message
+      )
+    end
+
+    private
+
+    # Validate that all workstreams exist
+    def validate_workstreams!(slugs)
+      invalid = slugs.reject do |slug|
+        Aidp::Worktree.exists?(slug: slug, project_dir: @project_dir)
+      end
+
+      unless invalid.empty?
+        raise ArgumentError, "Workstreams not found: #{invalid.join(", ")}"
+      end
+    end
+
+    # Display execution summary
+    def display_execution_summary(results)
+      completed = results.count { |r| r.status == "completed" }
+      failed = results.count { |r| r.status == "failed" || r.status == "error" }
+      total_duration = results.sum(&:duration)
+
+      display_message("\n" + "=" * 60, type: :muted)
+      display_message("📊 Execution Summary", type: :info)
+      display_message("Total: #{results.size} | Completed: #{completed} | Failed: #{failed}", type: :info)
+      display_message("Total Duration: #{format_duration(total_duration)}", type: :info)
+
+      if failed > 0
+        display_message("\n❌ Failed Workstreams:", type: :error)
+        results.select { |r| r.status != "completed" }.each do |result|
+          display_message("  - #{result.slug}: #{result.error}", type: :error)
+        end
+      end
+
+      display_message("=" * 60, type: :muted)
+    end
+
+    # Format duration in human-readable format
+    def format_duration(seconds)
+      if seconds < 60
+        "#{seconds.round(1)}s"
+      elsif seconds < 3600
+        minutes = (seconds / 60).floor
+        secs = (seconds % 60).round
+        "#{minutes}m #{secs}s"
+      else
+        hours = (seconds / 3600).floor
+        minutes = ((seconds % 3600) / 60).floor
+        "#{hours}h #{minutes}m"
+      end
+    end
+  end
+end