ace-git-worktree 0.26.1 → 0.27.1

data/lib/ace/git/worktree/organisms/worktree_probe_runner.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require "json"
+require "timeout"
+require_relative "../molecules/worktree_probe"
+
+module Ace
+  module Git
+    module Worktree
+      module Organisms
+        # Runs one read-only probe per worktree in isolated child processes.
+        #
+        # Contract:
+        # - one child per worktree, at most {MAX_LIVE_CHILDREN} alive at once;
+        # - each child has a hard {PROBE_TIMEOUT} second budget; a timed-out
+        #   child is killed together with its process group (no orphan `git`);
+        # - children never write repository state or the terminal, and results
+        #   are stored by input index so output order never depends on child
+        #   completion order;
+        # - a failed/timed-out probe yields nil (rendered as `?` by callers);
+        # - when `fork` is unavailable, probes run sequentially with the same
+        #   per-probe timeout and the same result contract.
+        class WorktreeProbeRunner
+          # Maximum number of live probe children.
+          MAX_LIVE_CHILDREN = 16
+
+          # Per-probe hard timeout in seconds (implementation constant).
+          PROBE_TIMEOUT = 5
+
+          # @param project_root [String, nil] project root for probe task signals
+          # @param base_ref [String, nil] primary worktree head for merge-base diffs
+          # @param probe [Proc, nil] injectable probe callable for tests
+          #   (receives a worktree, returns a Hash or nil); runs inside the child
+          # @param max_children [Integer] maximum live children
+          # @param timeout [Numeric] per-probe timeout in seconds
+          # @param fork_supported [Boolean, nil] force the sequential fallback
+          #   when false (nil = detect POSIX fork)
+          def initialize(project_root: nil, base_ref: nil, probe: nil,
+            max_children: MAX_LIVE_CHILDREN, timeout: PROBE_TIMEOUT, fork_supported: nil)
+            @project_root = project_root
+            @base_ref = base_ref
+            @probe = probe
+            @max_children = max_children
+            @timeout = timeout
+            @fork_supported = fork_supported.nil? ? fork_supported? : fork_supported
+          end
+
+          # Probe every worktree.
+          #
+          # @param worktrees [Array<Models::WorktreeInfo>] worktrees in display order
+          # @return [Array<Hash, nil>] payload per worktree, aligned with input
+          def run(worktrees)
+            list = Array(worktrees)
+            return [] if list.empty?
+            return sequential_all(list) unless @fork_supported
+
+            begin
+              fork_all(list)
+            rescue NotImplementedError
+              # fork exists but is unavailable in this environment (e.g. a
+              # restricted container): fall back to sequential probes.
+              @fork_supported = false
+              sequential_all(list)
+            end
+          end
+
+          private
+
+          def fork_supported?
+            Process.respond_to?(:fork) && !Gem.win_platform?
+          end
+
+          # --- Forked pool ---
+
+          def fork_all(worktrees)
+            results = Array.new(worktrees.length)
+            pending = worktrees.each_with_index.map { |worktree, index| [index, worktree] }
+            active = {}
+
+            begin
+              until pending.empty? && active.empty?
+                start_children(pending, active) while active.length < @max_children && !pending.empty?
+                break if active.empty?
+
+                wait_for_results(active, results)
+              end
+            ensure
+              terminate_all(active, results)
+            end
+
+            results
+          end
+
+          def start_children(pending, active)
+            index, worktree = pending.shift
+            pipe_read, pipe_write = IO.pipe
+            flush_standard_streams
+            pid = fork do
+              child_process(pipe_read, pipe_write, worktree)
+              exit!(0)
+            end
+
+            pipe_write.close
+            pipe_read.binmode
+            active[pid] = {
+              index: index,
+              pipe: pipe_read,
+              buffer: +"",
+              deadline: monotonic_now + @timeout
+            }
+          end
+
+          # Body executed in the forked child. Never raises to the parent and
+          # never writes to the inherited terminal.
+          def child_process(pipe_read, pipe_write, worktree)
+            pipe_read.close
+            begin
+              Process.setpgid(0, 0)
+            rescue StandardError
+              # Process group isolation is best effort on exotic platforms.
+            end
+            begin
+              STDOUT.reopen(File::NULL)
+              STDERR.reopen(File::NULL)
+            rescue StandardError
+              nil
+            end
+
+            payload = execute_probe(worktree)
+            pipe_write.write(JSON.generate(payload)) if payload
+          rescue Exception # rubocop:disable Lint/RescueException
+            nil
+          ensure
+            begin
+              pipe_write.close
+            rescue StandardError
+              nil
+            end
+          end
+
+          # Wait for at least one child to finish or for the nearest deadline.
+          def wait_for_results(active, results)
+            pipes = active.values.map { |job| job[:pipe] }
+            nearest_deadline = active.values.map { |job| job[:deadline] }.min
+            wait_seconds = [nearest_deadline - monotonic_now, 0].max
+
+            ready = IO.select(pipes, nil, nil, wait_seconds)
+
+            if ready.nil?
+              expire_timed_out(active, results)
+            else
+              ready.first.each { |pipe| drain_child_pipe(pipe, active, results) }
+              expire_timed_out(active, results)
+            end
+          end
+
+          # Read currently available bytes; on EOF parse and reap the child.
+          def drain_child_pipe(pipe, active, results)
+            job = active.values.find { |candidate| candidate[:pipe] == pipe }
+            return unless job
+
+            loop do
+              job[:buffer] << pipe.read_nonblock(65_536)
+            rescue IO::WaitReadable
+              return
+            rescue EOFError
+              finish_job(active, job, success: true, results: results)
+              return
+            end
+          end
+
+          def finish_job(active, job, success:, results:)
+            pid = active.key(job)
+            active.delete(pid) if pid
+
+            if success
+              results[job[:index]] = parse_payload(job[:buffer])
+            end
+
+            begin
+              job[:pipe].close unless job[:pipe].closed?
+            rescue StandardError
+              nil
+            end
+
+            reap(pid) if pid
+          end
+
+          def expire_timed_out(active, results)
+            now = monotonic_now
+            active.values.each do |job|
+              next if job[:deadline] > now
+
+              pid = active.key(job)
+              next unless pid
+
+              terminate(pid)
+              results[job[:index]] = nil
+              begin
+                job[:pipe].close unless job[:pipe].closed?
+              rescue StandardError
+                nil
+              end
+              active.delete(pid)
+            end
+          end
+
+          # Kill a child's process group (TERM, then KILL) and reap it.
+          def terminate(pid)
+            terminate_process_group(pid, "TERM")
+            # Give the child a brief chance to exit cleanly.
+            deadline = monotonic_now + 0.2
+            loop do
+              break if reap_nonblocking(pid)
+              break if monotonic_now > deadline
+
+              sleep 0.01
+            end
+            terminate_process_group(pid, "KILL")
+            reap(pid)
+          rescue Errno::ESRCH
+            nil
+          end
+
+          def terminate_all(active, results)
+            active.each do |pid, job|
+              terminate(pid)
+              results[job[:index]] ||= nil
+            end
+            active.clear
+          end
+
+          def terminate_process_group(pid, signal)
+            Process.kill("-#{signal}", pid)
+          rescue Errno::ESRCH
+            # Group already gone.
+            nil
+          rescue StandardError
+            begin
+              Process.kill(signal, pid)
+            rescue StandardError
+              nil
+            end
+          end
+
+          def reap(pid)
+            Process.wait(pid)
+          rescue Errno::ECHILD
+            nil
+          end
+
+          def reap_nonblocking(pid)
+            reaped = Process.wait(pid, Process::WNOHANG)
+            !reaped.nil?
+          rescue Errno::ECHILD
+            true
+          end
+
+          # --- Sequential fallback ---
+
+          def sequential_all(worktrees)
+            worktrees.map do |worktree|
+              Timeout.timeout(@timeout) { normalize_payload(execute_probe(worktree)) }
+            rescue Timeout::Error, StandardError
+              nil
+            end
+          end
+
+          # --- Probe execution ---
+
+          def execute_probe(worktree)
+            if @probe
+              @probe.call(worktree)
+            else
+              Molecules::WorktreeProbe.new(project_root: @project_root, base_ref: @base_ref).probe(worktree.path)
+            end
+          end
+
+          def parse_payload(buffer)
+            return nil if buffer.to_s.strip.empty?
+
+            normalize_payload(JSON.parse(buffer))
+          rescue JSON::ParserError
+            nil
+          end
+
+          def normalize_payload(payload)
+            return nil unless payload.is_a?(Hash)
+
+            deep_symbolize(payload)
+          end
+
+          def deep_symbolize(value)
+            case value
+            when Hash
+              value.each_with_object({}) { |(key, item), memo| memo[key.to_sym] = deep_symbolize(item) }
+            when Array
+              value.map { |item| deep_symbolize(item) }
+            else
+              value
+            end
+          end
+
+          # Flush buffered parent output before forking so children never
+          # inherit (and re-emit) unflushed terminal output.
+          def flush_standard_streams
+            $stdout.flush
+            $stderr.flush
+          rescue StandardError
+            nil
+          end
+
+          def monotonic_now
+            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/worktree/version.rb

@@ -3,7 +3,7 @@
 module Ace
   module Git
     module Worktree
-      VERSION = "0.26.1"
+      VERSION = "0.27.1"
     end
   end
 end

data/lib/ace/git/worktree.rb

@@ -184,12 +184,24 @@ module Ace
       require_relative "worktree/models/worktree_config"
       require_relative "worktree/models/worktree_info"
       require_relative "worktree/models/worktree_metadata"
+      require_relative "worktree/models/task_index"
 
       require_relative "worktree/atoms/git_command"
       require_relative "worktree/atoms/path_expander"
       require_relative "worktree/atoms/slug_generator"
+      require_relative "worktree/atoms/task_id_extractor"
+      require_relative "worktree/atoms/duration_parser"
+      require_relative "worktree/atoms/relative_age_formatter"
+      require_relative "worktree/atoms/text_truncator"
 
       require_relative "worktree/molecules/config_loader"
+      require_relative "worktree/molecules/task_index_builder"
+      require_relative "worktree/molecules/worktree_probe"
+      require_relative "worktree/molecules/task_association_resolver"
+      require_relative "worktree/molecules/pr_status_resolver"
+      require_relative "worktree/molecules/recent_branch_counter"
+      require_relative "worktree/molecules/worktree_table_formatter"
+      require_relative "worktree/molecules/worktree_footer_formatter"
       require_relative "worktree/molecules/task_fetcher"
       require_relative "worktree/molecules/pull_request_creator"
       require_relative "worktree/molecules/pull_request_evidence_resolver"
@@ -203,6 +215,8 @@ module Ace
       require_relative "worktree/molecules/hook_executor"
 
       require_relative "worktree/organisms/task_worktree_orchestrator"
+      require_relative "worktree/organisms/worktree_probe_runner"
+      require_relative "worktree/organisms/worktree_list_report"
       require_relative "worktree/organisms/worktree_manager"
 
       require_relative "worktree/commands/create_command"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-git-worktree
 version: !ruby/object:Gem::Version
-  version: 0.26.1
+  version: 0.27.1
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-12 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -199,10 +199,13 @@ files:
 - handbook/workflow-instructions/git/worktree-manage.wf.md
 - handbook/workflow-instructions/git/worktree.wf.md
 - lib/ace/git/worktree.rb
+- lib/ace/git/worktree/atoms/duration_parser.rb
 - lib/ace/git/worktree/atoms/git_command.rb
 - lib/ace/git/worktree/atoms/path_expander.rb
+- lib/ace/git/worktree/atoms/relative_age_formatter.rb
 - lib/ace/git/worktree/atoms/slug_generator.rb
 - lib/ace/git/worktree/atoms/task_id_extractor.rb
+- lib/ace/git/worktree/atoms/text_truncator.rb
 - lib/ace/git/worktree/cli.rb
 - lib/ace/git/worktree/cli/commands/bootstrap.rb
 - lib/ace/git/worktree/cli/commands/cleanup.rb
@@ -222,6 +225,7 @@ files:
 - lib/ace/git/worktree/commands/remove_command.rb
 - lib/ace/git/worktree/commands/switch_command.rb
 - lib/ace/git/worktree/configuration.rb
+- lib/ace/git/worktree/models/task_index.rb
 - lib/ace/git/worktree/models/worktree_config.rb
 - lib/ace/git/worktree/models/worktree_info.rb
 - lib/ace/git/worktree/models/worktree_metadata.rb
@@ -233,19 +237,28 @@ files:
 - lib/ace/git/worktree/molecules/current_task_linker.rb
 - lib/ace/git/worktree/molecules/hook_executor.rb
 - lib/ace/git/worktree/molecules/parent_task_resolver.rb
+- lib/ace/git/worktree/molecules/pr_status_resolver.rb
 - lib/ace/git/worktree/molecules/pull_request_checkout_preparer.rb
 - lib/ace/git/worktree/molecules/pull_request_creator.rb
 - lib/ace/git/worktree/molecules/pull_request_evidence_resolver.rb
+- lib/ace/git/worktree/molecules/recent_branch_counter.rb
+- lib/ace/git/worktree/molecules/task_association_resolver.rb
 - lib/ace/git/worktree/molecules/task_committer.rb
 - lib/ace/git/worktree/molecules/task_fetcher.rb
+- lib/ace/git/worktree/molecules/task_index_builder.rb
 - lib/ace/git/worktree/molecules/task_pusher.rb
 - lib/ace/git/worktree/molecules/task_status_updater.rb
 - lib/ace/git/worktree/molecules/toolchain_truster.rb
 - lib/ace/git/worktree/molecules/worktree_creator.rb
+- lib/ace/git/worktree/molecules/worktree_footer_formatter.rb
 - lib/ace/git/worktree/molecules/worktree_lister.rb
+- lib/ace/git/worktree/molecules/worktree_probe.rb
 - lib/ace/git/worktree/molecules/worktree_remover.rb
+- lib/ace/git/worktree/molecules/worktree_table_formatter.rb
 - lib/ace/git/worktree/organisms/task_worktree_orchestrator.rb
+- lib/ace/git/worktree/organisms/worktree_list_report.rb
 - lib/ace/git/worktree/organisms/worktree_manager.rb
+- lib/ace/git/worktree/organisms/worktree_probe_runner.rb
 - lib/ace/git/worktree/version.rb
 homepage: https://github.com/cs3b/ace
 licenses: