ace-git-worktree 0.26.0 → 0.27.0

data/lib/ace/git/worktree/molecules/worktree_lister.rb

@@ -15,9 +15,6 @@ module Ace
         #
         # @example Find worktree by task ID
         #   worktree = lister.find_by_task_id("081")
-        #
-        # @example List with task associations
-        #   worktrees = lister.list_with_tasks
         class WorktreeLister
           # Fallback timeout for git commands
           # Used only when config is unavailable
@@ -42,6 +39,18 @@ module Ace
 
           public
 
+          # Read the worktree inventory.
+          #
+          # @return [Hash] `{success:, worktrees:}` or `{success: false, error:}`
+          def inventory
+            result = Atoms::GitCommand.worktree("list", "--porcelain", timeout: @timeout)
+            unless result[:success]
+              return {success: false, error: result[:error].to_s.empty? ? "git worktree list failed" : result[:error]}
+            end
+
+            {success: true, worktrees: Models::WorktreeInfo.from_git_output_list(result[:output])}
+          end
+
           # List all worktrees in the repository
           #
           # @return [Array<WorktreeInfo>] Array of worktree information
@@ -51,22 +60,8 @@ module Ace
           #   worktrees = lister.list_all
           #   worktrees.each { |wt| puts "#{wt.branch} at #{wt.path}" }
           def list_all
-            output = execute_git_worktree_list
-            return [] unless output
-
-            Models::WorktreeInfo.from_git_output_list(output)
-          end
-
-          # List worktrees with task associations resolved
-          #
-          # @return [Array<WorktreeInfo>] Array of worktree information with task IDs
-          #
-          # @example
-          #   worktrees = lister.list_with_tasks
-          #   worktrees.each { |wt| puts "Task #{wt.task_id}: #{wt.branch}" if wt.task_associated? }
-          def list_with_tasks
-            worktrees = list_all
-            resolve_task_associations(worktrees)
+            result = inventory
+            result[:success] ? result[:worktrees] : []
           end
 
           # Find worktree by task ID
@@ -80,7 +75,7 @@ module Ace
           #     puts "Found worktree for task 081: #{worktree.path}"
           #   end
           def find_by_task_id(task_id)
-            worktrees = list_with_tasks
+            worktrees = list_all
             Models::WorktreeInfo.find_by_task_id(worktrees, task_id.to_s)
           end
 
@@ -191,7 +186,7 @@ module Ace
           def search(query, search_in: [:branch, :path, :task_id])
             return [] if query.nil? || query.empty?
 
-            worktrees = list_with_tasks
+            worktrees = list_all
             pattern = Regexp.new(query, Regexp::IGNORECASE)
 
             worktrees.select do |worktree|
@@ -221,7 +216,7 @@ module Ace
           #   puts "Task-associated: #{stats[:task_associated]}"
           #   puts "Usable: #{stats[:usable]}"
           def get_statistics(worktrees = nil)
-            worktrees = worktrees ? Array(worktrees) : list_with_tasks
+            worktrees = worktrees ? Array(worktrees) : list_all
 
             {
               total: worktrees.length,
@@ -236,92 +231,26 @@ module Ace
             }
           end
 
-          # Format worktree list for display
+          # Format worktree list for non-report consumers.
           #
           # @param worktrees [Array<WorktreeInfo>] Worktrees to format
-          # @param format [Symbol] Output format (:table, :json, :simple)
+          # @param format [Symbol] Output format (:json, :simple)
           # @return [String] Formatted output
           #
           # @example
-          #   output = lister.format_for_display(worktrees, :table)
+          #   output = lister.format_for_display(worktrees, :simple)
           #   puts output
-          def format_for_display(worktrees, format = :table)
+          def format_for_display(worktrees, format = :simple)
             case format
-            when :table
-              format_as_table(worktrees)
             when :json
               format_as_json(worktrees)
-            when :simple
-              format_as_simple(worktrees)
             else
-              format_as_table(worktrees)
+              format_as_simple(worktrees)
             end
           end
 
           private
 
-          # Execute git worktree list command
-          #
-          # @return [String, nil] Command output or nil if failed
-          def execute_git_worktree_list
-            require_relative "../atoms/git_command"
-            result = Atoms::GitCommand.worktree("list", "--porcelain", timeout: @timeout)
-            result[:success] ? result[:output] : nil
-          end
-
-          # Resolve task associations for worktrees
-          #
-          # @param worktrees [Array<WorktreeInfo>] Worktrees to process
-          # @return [Array<WorktreeInfo>] Worktrees with resolved task associations
-          def resolve_task_associations(worktrees)
-            return worktrees if worktrees.empty?
-
-            # Try to resolve task associations from worktree metadata
-            # This would typically involve looking up task files
-            # For now, we'll use the automatic extraction from WorktreeInfo
-
-            worktrees
-          end
-
-          # Format worktrees as a table
-          #
-          # @param worktrees [Array<WorktreeInfo>] Worktrees to format
-          # @return [String] Table-formatted string
-          def format_as_table(worktrees)
-            return "No worktrees found.\n" if worktrees.empty?
-
-            # Calculate column widths
-            max_path_width = [worktrees.map { |wt| wt.path.length }.max, 40].max
-            max_branch_width = [worktrees.map { |wt| (wt.branch || "detached").length }.max, 15].max
-            max_task_width = [worktrees.map { |wt| (wt.task_id || "-").length }.max, 8].max
-
-            # Build header
-            header = sprintf("%-#{max_task_width}s %-#{max_branch_width}s %-#{max_path_width}s %s",
-              "Task", "Branch", "Path", "Status")
-            separator = "-" * header.length
-
-            # Build table rows
-            rows = worktrees.map do |wt|
-              status = if wt.bare
-                "bare"
-              elsif wt.detached
-                "detached"
-              elsif wt.task_associated?
-                "task"
-              else
-                "normal"
-              end
-
-              sprintf("%-#{max_task_width}s %-#{max_branch_width}s %-#{max_path_width}s %s",
-                wt.task_id || "-",
-                wt.branch || "detached",
-                wt.path,
-                status)
-            end
-
-            [header, separator, *rows].join("\n") + "\n"
-          end
-
           # Format worktrees as JSON
           #
           # @param worktrees [Array<WorktreeInfo>] Worktrees to format

data/lib/ace/git/worktree/molecules/worktree_probe.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "open3"
+require "time"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Read-only inspection of one worktree, designed to run inside a forked
+        # probe child (see {Organisms::WorktreeProbeRunner}).
+        #
+        # The probe reports raw signals only: HEAD commit metadata, uncommitted
+        # change counts, task files changed in the worktree, and the resolved
+        # `_current` symlink target. The parent process owns clock reads,
+        # rendering, and task/PR resolution so ordering and ages stay
+        # deterministic.
+        #
+        # All git calls pass the worktree explicitly via `-C <path>` (ADR-031);
+        # the probe never changes the parent process working directory and
+        # never writes repository state.
+        class WorktreeProbe
+          # Marker for a task-tree-relative path prefix.
+          TASK_TREE_PREFIX = ".ace-tasks/"
+
+          # @param project_root [String] primary project root (contains `.ace-tasks/`)
+          # @param base_ref [String, nil] primary worktree HEAD sha used as the
+          #   merge-base reference for committed task-file diffs
+          def initialize(project_root:, base_ref: nil)
+            @project_root = project_root
+            @base_ref = base_ref
+            @task_root = project_root ? File.join(project_root, ".ace-tasks") : nil
+          end
+
+          # Probe one worktree.
+          #
+          # @param path [String] worktree directory
+          # @return [Hash, nil] serializable probe payload, or nil when the
+          #   worktree cannot be inspected (missing path / git failure)
+          def probe(path)
+            return nil unless path && File.directory?(path)
+
+            head = head_metadata(path)
+            status = status_snapshot(path)
+            return nil if status.nil?
+
+            committed_task_files = committed_task_paths(path, head && head[:sha])
+
+            {
+              head_sha: head && head[:sha],
+              head_committer_epoch: head && head[:committer_epoch],
+              head_subject: head && head[:subject],
+              staged: status[:staged],
+              unstaged: status[:unstaged],
+              untracked: status[:untracked],
+              uncommitted_paths: status[:paths],
+              changed_task_files: status[:paths].select { |p| task_tree_path?(p) },
+              committed_task_files: committed_task_files,
+              symlink_target: current_task_target(path)
+            }
+          rescue StandardError
+            nil
+          end
+
+          # Resolve the `_current` symlink at a worktree root when it points
+          # into the project task tree.
+          #
+          # @param path [String] worktree directory
+          # @return [String, nil] absolute task directory
+          def current_task_target(path)
+            symlink = File.join(path, "_current")
+            return nil unless File.symlink?(symlink) && @task_root
+
+            target = canonical_path(File.expand_path(File.readlink(symlink), path))
+            root = canonical_path(@task_root)
+            target.start_with?("#{root}/") ? target : nil
+          rescue StandardError
+            nil
+          end
+
+          # Canonical comparison form for paths that may be reached through a
+          # symlinked root (e.g. macOS /var -> /private/var).
+          def canonical_path(value)
+            File.realpath(value)
+          rescue StandardError
+            File.expand_path(value)
+          end
+
+          private
+
+          # @return [Hash, nil] `{sha:, committer_epoch:, subject:}` for HEAD
+          def head_metadata(path)
+            output = git(path, "log", "-1", "--format=%H%x1f%ct%x1f%s")
+            return nil if output.nil?
+
+            sha, epoch, subject = output.chomp.split("\x1f", 3)
+            return nil if sha.to_s.empty?
+
+            {sha: sha, committer_epoch: Integer(epoch, 10), subject: subject.to_s}
+          rescue ArgumentError
+            nil
+          end
+
+          # @return [Hash, nil] staged/unstaged/untracked counts and changed paths
+          def status_snapshot(path)
+            output = git(path, "status", "--porcelain=v1", "-z", "--untracked-files=all")
+            return nil if output.nil?
+
+            staged = 0
+            unstaged = 0
+            untracked = 0
+            paths = []
+            records = output.split("\x00")
+            index = 0
+
+            while index < records.length
+              record = records[index]
+              index += 1
+              next if record.nil? || record.length < 4
+
+              xy = record[0, 2]
+              file = scrub(record[3..].to_s)
+              # Rename/copy records carry the original path in the next record.
+              index += 1 if xy[0] == "R" || xy[0] == "C"
+
+              if xy == "??"
+                untracked += 1
+              else
+                staged += 1 unless xy[0] == " " || xy[0] == "?"
+                unstaged += 1 unless xy[1] == " " || xy[1] == "?"
+              end
+              paths << file
+            end
+
+            {staged: staged, unstaged: unstaged, untracked: untracked, paths: paths}
+          end
+
+          # Task-tree files changed by this worktree's commits, relative to the
+          # merge-base with the primary worktree. Falls back to the HEAD
+          # commit's changed files when no merge-base exists.
+          #
+          # @return [Array<String>] repo-relative `.ace-tasks/` paths
+          def committed_task_paths(path, head_sha)
+            return [] if head_sha.nil?
+
+            merge_base = @base_ref ? git(path, "merge-base", @base_ref, head_sha)&.strip : nil
+            output = if merge_base && !merge_base.empty?
+              git(path, "diff", "--name-only", merge_base, head_sha, "--", ".ace-tasks")
+            else
+              git(path, "diff-tree", "--no-commit-id", "--name-only", "-r", head_sha, "--", ".ace-tasks")
+            end
+            return [] if output.nil?
+
+            output.lines.map { |line| scrub(line.chomp) }.reject(&:empty?).select { |p| task_tree_path?(p) }
+          end
+
+          def task_tree_path?(relative_path)
+            relative_path.start_with?(TASK_TREE_PREFIX)
+          end
+
+          # Run git in the worktree; nil on any failure.
+          #
+          # @return [String, nil]
+          def git(path, *args)
+            stdout, _stderr, status = Open3.capture3("git", "-C", path, *args)
+            status.success? ? stdout : nil
+          end
+
+          def scrub(value)
+            value.dup.force_encoding(Encoding::UTF_8).scrub
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/worktree/molecules/worktree_table_formatter.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "io/console"
+require_relative "../atoms/relative_age_formatter"
+require_relative "pr_status_resolver"
+require_relative "../atoms/text_truncator"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Renders the width-aware listing table.
+        #
+        # Layout targets (two-space gutters): Task = max(task cells, 4),
+        # Branch 25 (min 12), Age 5, Commit 24 (min 10), Changes 7, PR 11,
+        # Path 32 (min 10). When the target total exceeds the detected width,
+        # columns shrink in priority order Path -> Commit -> Branch down to
+        # their minima, then Path is dropped, then Commit. Compact output never
+        # exceeds the detected width; `--full` prints untruncated absolute paths
+        # and is exempt from width limits.
+        class WorktreeTableFormatter
+          GUTTER = "  "
+          COLUMNS_MIN_WIDTH = 40
+          DEFAULT_WIDTH = 120
+
+          BRANCH_TARGET = 25
+          BRANCH_MIN = 12
+          AGE_WIDTH = 5
+          COMMIT_TARGET = 24
+          COMMIT_MIN = 10
+          CHANGES_WIDTH = 7
+          PR_WIDTH = 11
+          PATH_TARGET = 32
+          PATH_MIN = 10
+          TASK_MIN = 4
+
+          # @param width [Integer] detected terminal width
+          # @param full [Boolean] exhaustive listing (no truncation)
+          # @param env [Hash] environment (HOME shortening, COLUMNS detection)
+          def initialize(width: nil, full: false, env: ENV, stdout: $stdout)
+            @width = width || self.class.detected_width(env: env, stdout: stdout)
+            @full = full
+            @env = env
+          end
+
+          # Detect the output width.
+          #
+          # @param env [Hash]
+          # @param stdout [IO]
+          # @return [Integer]
+          def self.detected_width(env: ENV, stdout: $stdout)
+            columns = env["COLUMNS"].to_s.strip
+            if columns.match?(/\A\d+\z/)
+              value = Integer(columns, 10)
+              return value if value >= COLUMNS_MIN_WIDTH
+            end
+
+            if stdout.respond_to?(:tty?) && stdout.tty?
+              winsize = IO.console&.winsize
+              return winsize.last if winsize&.last
+            end
+
+            DEFAULT_WIDTH
+          rescue StandardError
+            DEFAULT_WIDTH
+          end
+
+          # Render header + separator + rows.
+          #
+          # @param worktrees [Array<Models::WorktreeInfo>]
+          # @return [Array<String>] output lines
+          def render(worktrees)
+            rows = Array(worktrees)
+            layout = compute_layout(rows)
+            [header_line(layout), separator_line(layout), *rows.map { |worktree| row_line(worktree, layout) }]
+          end
+
+          private
+
+          Layout = Struct.new(:task, :branch, :age, :commit, :changes, :pr, :path, :total_width,
+            keyword_init: true)
+
+          def compute_layout(worktrees)
+            task_width = [TASK_MIN, *worktrees.map { |wt| task_cell(wt).length }].max
+            branch_width = BRANCH_TARGET
+            commit_width = COMMIT_TARGET
+            path_width = PATH_TARGET
+
+            if @full
+              path_width = [PATH_TARGET, *worktrees.map { |wt| full_path(wt).length }].max
+              return build_layout(task_width, branch_width, commit_width, path_width)
+            end
+
+            while total_width(task_width, branch_width, commit_width, path_width) > @width
+              if path_width > PATH_MIN
+                path_width -= 1
+              elsif commit_width > COMMIT_MIN
+                commit_width -= 1
+              elsif branch_width > BRANCH_MIN
+                branch_width -= 1
+              else
+                break
+              end
+            end
+
+            layout = build_layout(task_width, branch_width, commit_width, path_width)
+            return layout if layout[:total_width] <= @width
+
+            drop_path(layout)
+          end
+
+          def build_layout(task_width, branch_width, commit_width, path_width)
+            total = total_width(task_width, branch_width, commit_width, path_width)
+            Layout.new(task: task_width, branch: branch_width, age: AGE_WIDTH, commit: commit_width,
+              changes: CHANGES_WIDTH, pr: PR_WIDTH, path: path_width, total_width: total)
+          end
+
+          def total_width(task_width, branch_width, commit_width, path_width)
+            task_width + branch_width + AGE_WIDTH + commit_width + CHANGES_WIDTH + PR_WIDTH +
+              path_width + (GUTTER.length * 6)
+          end
+
+          # Drop the Path column when even the minimum layout overflows; then
+          # drop Commit as the last resort.
+          def drop_path(layout)
+            without_path = Layout.new(
+              task: layout[:task], branch: layout[:branch], age: layout[:age], commit: layout[:commit],
+              changes: layout[:changes], pr: layout[:pr], path: 0,
+              total_width: layout[:total_width] - layout[:path] - GUTTER.length
+            )
+            return without_path if without_path[:total_width] <= @width
+
+            Layout.new(
+              task: without_path[:task], branch: without_path[:branch], age: without_path[:age],
+              commit: 0, changes: without_path[:changes], pr: without_path[:pr], path: 0,
+              total_width: without_path[:total_width] - without_path[:commit] - GUTTER.length
+            )
+          end
+
+          def header_line(layout)
+            cells = []
+            cells << pad("Task", layout[:task], :left)
+            cells << pad("Branch", layout[:branch], :left)
+            cells << pad("Age", layout[:age], :right)
+            cells << pad("Commit", layout[:commit], :left) if layout[:commit].positive?
+            cells << pad("Changes", layout[:changes], :right)
+            cells << pad("PR", layout[:pr], :left)
+            cells << pad("Path", layout[:path], :left) if layout[:path].positive?
+            cells.join(GUTTER).rstrip
+          end
+
+          def separator_line(layout)
+            "-" * layout[:total_width]
+          end
+
+          def row_line(worktree, layout)
+            cells = []
+            cells << pad(task_cell(worktree), layout[:task], :left)
+            cells << pad(branch_cell(worktree, layout[:branch]), layout[:branch], :left)
+            cells << pad(age_cell(worktree), layout[:age], :right)
+            cells << pad(commit_cell(worktree, layout[:commit]), layout[:commit], :left) if layout[:commit].positive?
+            cells << pad(changes_cell(worktree), layout[:changes], :right)
+            cells << pad(pr_cell(worktree), layout[:pr], :left)
+            cells << pad(path_cell(worktree, layout[:path]), layout[:path], :left) if layout[:path].positive?
+            cells.join(GUTTER).rstrip
+          end
+
+          # --- Cell contents ---
+
+          def task_cell(worktree)
+            return "-" if worktree.task_id.to_s.empty?
+
+            extra = worktree.task_ids.length - 1
+            extra.positive? ? "#{worktree.task_id}+#{extra}" : worktree.task_id
+          end
+
+          def branch_cell(worktree, width)
+            label = worktree.branch.to_s.empty? ? "detached" : worktree.branch
+            Atoms::TextTruncator.middle(label, width)
+          end
+
+          def age_cell(worktree)
+            return "?" if worktree.probe_failed?
+            return "never" if worktree.last_commit.nil?
+
+            Atoms::RelativeAgeFormatter.format(worktree.last_commit[:age_hours].to_f * 3600)
+          end
+
+          def commit_cell(worktree, width)
+            return "?" if worktree.probe_failed?
+            return "" if worktree.last_commit.nil?
+
+            Atoms::TextTruncator.right(worktree.last_commit[:subject].to_s, width)
+          end
+
+          def changes_cell(worktree)
+            return "?" if worktree.probe_failed?
+            return "-" if worktree.uncommitted.nil?
+
+            worktree.uncommitted[:total].to_i.to_s
+          end
+
+          def pr_cell(worktree)
+            PrStatusResolver.cell(worktree.pr)
+          end
+
+          def path_cell(worktree, width)
+            return "" if width <= 0
+
+            path = @full ? full_path(worktree) : compact_path(worktree)
+            Atoms::TextTruncator.left(path, width)
+          end
+
+          def full_path(worktree)
+            File.expand_path(worktree.path)
+          end
+
+          def compact_path(worktree)
+            path = worktree.path.to_s
+            home = @env["HOME"].to_s
+            path = "~#{path[home.length..]}" if !home.empty? && path.start_with?(home)
+            path
+          end
+
+          def pad(value, width, alignment)
+            text = value.to_s
+            text = text[0, width].to_s if text.length > width
+            return text.ljust(width) if alignment == :left
+
+            text.rjust(width)
+          end
+        end
+      end
+    end
+  end
+end