ace-git-worktree 0.26.1 → 0.27.1

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

@@ -0,0 +1,241 @@
+# 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.
+        #
+        # Each worktree renders as three lines: the aligned columns
+        # (Task/Branch/Age/Commit/Changes/PR), the never-truncated path
+        # indented to the Commit column, and a blank separator line, so each
+        # entry is visually grouped and the displayed path is always directly
+        # usable (copy/paste, cd).
+        #
+        # Layout targets (two-space gutters): Task = max(task cells, 4),
+        # Branch 25 (min 12), Age 5, Commit 24 (min 10), Changes 7, PR 11.
+        # When the target total exceeds the detected width, columns shrink in
+        # priority order Commit -> Branch down to their minima, then Commit is
+        # dropped. Column lines never exceed the detected width; `--full`
+        # prints 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
+          TASK_MIN = 4
+          PATH_INDENT = "  "
+
+          # @param width [Integer] detected terminal width
+          # @param full [Boolean] exhaustive listing (absolute paths)
+          # @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 + three lines per worktree (columns,
+          # indented full path, blank separator).
+          #
+          # @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.flat_map { |worktree| [row_line(worktree, layout), path_line(worktree, layout), ""] }
+            ]
+          end
+
+          private
+
+          Layout = Struct.new(:task, :branch, :age, :commit, :changes, :pr, :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
+
+            unless @full
+              while total_width(task_width, branch_width, commit_width) > @width
+                if commit_width > COMMIT_MIN
+                  commit_width -= 1
+                elsif branch_width > BRANCH_MIN
+                  branch_width -= 1
+                else
+                  break
+                end
+              end
+            end
+
+            layout = build_layout(task_width, branch_width, commit_width)
+            return layout if layout[:total_width] <= @width
+
+            drop_commit(layout)
+          end
+
+          def build_layout(task_width, branch_width, commit_width)
+            total = total_width(task_width, branch_width, commit_width)
+            Layout.new(task: task_width, branch: branch_width, age: AGE_WIDTH, commit: commit_width,
+              changes: CHANGES_WIDTH, pr: PR_WIDTH, total_width: total)
+          end
+
+          def total_width(task_width, branch_width, commit_width)
+            task_width + branch_width + AGE_WIDTH + commit_width + CHANGES_WIDTH + PR_WIDTH +
+              (GUTTER.length * 5)
+          end
+
+          # Drop the Commit column when even the minimum layout overflows.
+          def drop_commit(layout)
+            Layout.new(
+              task: layout[:task], branch: layout[:branch], age: layout[:age],
+              commit: 0, changes: layout[:changes], pr: layout[:pr],
+              total_width: layout[:total_width] - layout[: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.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.join(GUTTER).rstrip
+          end
+
+          # The full, never-truncated worktree path on its own line, indented
+          # to the Commit column so it reads as a continuation of the row
+          # (falls back to the Branch column, then a minimal indent).
+          def path_line(worktree, layout)
+            path = @full ? full_path(worktree) : compact_path(worktree)
+            "#{path_indent(layout)}#{path}"
+          end
+
+          def path_indent(layout)
+            if layout[:commit].positive?
+              " " * (layout[:task] + GUTTER.length + layout[:branch] + GUTTER.length +
+                layout[:age] + GUTTER.length)
+            elsif layout[:branch].positive?
+              " " * (layout[:task] + GUTTER.length)
+            else
+              PATH_INDENT
+            end
+          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 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

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

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "../atoms/duration_parser"
+require_relative "../molecules/worktree_lister"
+require_relative "../molecules/task_index_builder"
+require_relative "../molecules/task_association_resolver"
+require_relative "../molecules/pr_status_resolver"
+require_relative "../molecules/recent_branch_counter"
+require_relative "../molecules/worktree_table_formatter"
+require_relative "../molecules/worktree_footer_formatter"
+require_relative "worktree_probe_runner"
+
+module Ace
+  module Git
+    module Worktree
+      module Organisms
+        # Builds the `ace-git-worktree list` report end to end.
+        #
+        # Pipeline: inventory worktrees once -> build the `.ace-tasks/` index
+        # once -> fork-probe every worktree -> resolve task association ->
+        # classify activity from one clock snapshot -> resolve PRs (one bounded
+        # query) -> apply filters -> split active/inactive -> render.
+        #
+        # The report owns all ordering, clock reads, filtering, and rendering;
+        # probe children only report raw signals.
+        class WorktreeListReport
+          # @param lister [Molecules::WorktreeLister, nil]
+          # @param task_index_builder [Molecules::TaskIndexBuilder, nil]
+          # @param probe_runner [Organisms::WorktreeProbeRunner, nil] injectable
+          # @param pr_resolver [Molecules::PrStatusResolver, nil] injectable
+          # @param branch_counter [Molecules::RecentBranchCounter, nil] injectable
+          # @param clock [Proc, nil] injectable clock (`-> { Time }`) for tests
+          # @param project_root [String, nil]
+          # @param env [Hash]
+          # @param stdout [IO]
+          def initialize(lister: nil, task_index_builder: nil, probe_runner: nil, pr_resolver: nil,
+            branch_counter: nil, clock: nil, project_root: nil, env: ENV, stdout: $stdout)
+            @lister = lister || Molecules::WorktreeLister.new
+            @task_index_builder = task_index_builder
+            @probe_runner = probe_runner
+            @pr_resolver = pr_resolver
+            @branch_counter = branch_counter
+            @clock = clock
+            @project_root = project_root
+            @env = env
+            @stdout = stdout
+          end
+
+          # Run the report.
+          #
+          # @param options [Hash] parsed list options
+          # @return [Hash] `{success:, output:, worktrees:, statistics:}`
+          def run(options = {})
+            options = normalize_options(options)
+            inventory = @lister.inventory
+            unless inventory[:success]
+              return {success: false, error: inventory[:error], worktrees: [], statistics: {}}
+            end
+
+            raw_worktrees = inventory[:worktrees]
+            now = (@clock ? @clock.call : Time.now)
+            task_index = build_task_index
+            project_root = task_index.project_root || @project_root
+
+            probes = probe_worktrees(raw_worktrees, project_root)
+            supplement_untracked_task_files(raw_worktrees, probes, project_root, task_index)
+            enriched = enrich(raw_worktrees, probes, task_index, now, options)
+            selected = apply_filters(enriched, options)
+            active, inactive = selected.partition { |worktree| worktree.active_within_window }
+
+            statistics = build_statistics(selected, active, inactive, now, options, raw_worktrees)
+            output = render(selected, active, inactive, statistics, options)
+
+            {
+              success: true,
+              output: output,
+              worktrees: selected,
+              statistics: statistics
+            }
+          end
+
+          private
+
+          def normalize_options(options)
+            window = options[:active_within]
+            window = Atoms::DurationParser.parse(window) if window.is_a?(String)
+            window ||= Atoms::DurationParser.default
+            options.merge(
+              format: (options[:format] || :table).to_sym,
+              window_hours: window[:hours],
+              window_label: window[:label],
+              full: options[:full] ? true : false,
+              quiet: options[:quiet] ? true : false
+            )
+          end
+
+          def build_task_index
+            if @task_index_builder
+              @task_index_builder.build
+            else
+              Molecules::TaskIndexBuilder.new(project_root: @project_root).build
+            end
+          end
+
+          def probe_worktrees(raw_worktrees, project_root)
+            runner = @probe_runner || WorktreeProbeRunner.new(
+              project_root: project_root,
+              base_ref: raw_worktrees.first&.commit
+            )
+            runner.run(raw_worktrees)
+          end
+
+          # Second probe round, only for worktrees the cheap association tiers
+          # (metadata, `_current` symlink, validated name, tracked task-file
+          # changes, committed task files) could not resolve. The deep
+          # `.ace-tasks/` untracked scan dominates listing time on large
+          # repositories, so it runs selectively and merges its findings back
+          # into the round-one payloads (counts + changed task paths) before
+          # enrichment classifies activity and renders.
+          def supplement_untracked_task_files(raw_worktrees, probes, project_root, task_index)
+            return unless task_index.available?
+
+            resolver = Molecules::TaskAssociationResolver.new(task_index: task_index)
+            unresolved = raw_worktrees.each_index.select do |index|
+              probe = probes[index]
+              probe && resolver.resolve(raw_worktrees[index], probe).task_id.nil?
+            end
+            return if unresolved.empty?
+
+            probe_molecule = Molecules::WorktreeProbe.new(project_root: project_root)
+            supplement = ->(worktree) { {untracked_task_files: probe_molecule.untracked_task_files(worktree.path)} }
+            runner = WorktreeProbeRunner.new(project_root: project_root, probe: supplement)
+            payloads = runner.run(unresolved.map { |index| raw_worktrees[index] })
+
+            unresolved.each_with_index do |probe_index, position|
+              payload = payloads[position]
+              next if payload.nil? || payload[:untracked_task_files].to_a.empty?
+
+              paths = payload[:untracked_task_files]
+              probe = probes[probe_index]
+              probe[:untracked] = probe[:untracked].to_i + paths.length
+              probe[:uncommitted_paths] = Array(probe[:uncommitted_paths]) + paths
+              probe[:changed_task_files] = Array(probe[:changed_task_files]) + paths
+            end
+          end
+
+          def enrich(raw_worktrees, probes, task_index, now, options)
+            resolver = Molecules::TaskAssociationResolver.new(task_index: task_index)
+            pr_resolver = @pr_resolver || Molecules::PrStatusResolver.new
+
+            raw_worktrees.each_with_index.map do |worktree, index|
+              probe = probes[index]
+              associated = resolver.resolve(worktree, probe)
+              last_commit = last_commit_hash(probe, now)
+              uncommitted = uncommitted_hash(probe)
+              active = active_worktree?(worktree, probe, options[:window_hours], now)
+              pr = pr_resolver.resolve(associated, associated.task_id)
+
+              associated.with_enrichment(
+                last_commit: last_commit,
+                uncommitted: uncommitted,
+                active_within_window: active,
+                pr: pr,
+                probe_error: probe.nil?
+              )
+            end
+          end
+
+          def last_commit_hash(probe, now)
+            return nil if probe.nil? || probe[:head_sha].nil?
+
+            committed_at = Time.at(probe[:head_committer_epoch].to_i).utc
+            {
+              sha: probe[:head_sha],
+              age_hours: ((now - committed_at) / 3600.0).round(2),
+              committed_at: committed_at.iso8601,
+              subject: probe[:head_subject].to_s
+            }
+          end
+
+          def uncommitted_hash(probe)
+            return nil if probe.nil?
+
+            staged = probe[:staged].to_i
+            unstaged = probe[:unstaged].to_i
+            untracked = probe[:untracked].to_i
+            total = staged + unstaged + untracked
+            return nil unless total.positive?
+
+            {staged: staged, unstaged: unstaged, untracked: untracked, total: total}
+          end
+
+          # A worktree is active inside the window when its HEAD commit is in
+          # the window or it has uncommitted changes. Bare worktrees are never
+          # active; probe failures classify as inactive.
+          def active_worktree?(worktree, probe, window_hours, now)
+            return false if worktree.bare || probe.nil?
+
+            committed_at = probe[:head_committer_epoch]
+            recent_commit = committed_at && now.to_i - committed_at.to_i <= (window_hours * 3600).to_i
+            dirty = uncommitted_hash(probe)
+            recent_commit || !dirty.nil?
+          end
+
+          def apply_filters(worktrees, options)
+            filtered = Array(worktrees)
+
+            if options[:task_associated] == true
+              filtered = filtered.select { |worktree| worktree.task_associated? }
+            elsif options[:task_associated] == false
+              filtered = filtered.reject { |worktree| worktree.task_associated? }
+            end
+
+            if options[:usable] == true
+              filtered = filtered.select(&:usable?)
+            elsif options[:usable] == false
+              filtered = filtered.reject(&:usable?)
+            end
+
+            if options[:search] && !options[:search].to_s.empty?
+              pattern = Regexp.new(options[:search].to_s, Regexp::IGNORECASE)
+              filtered = filtered.select { |worktree| worktree.branch&.match?(pattern) }
+            end
+
+            filtered
+          end
+
+          def build_statistics(selected, active, inactive, now, options, raw_worktrees)
+            {
+              total: selected.length,
+              active: active.length,
+              inactive: inactive.length,
+              task_associated: selected.count(&:task_associated?),
+              usable: selected.count(&:usable?),
+              recent_branches: recent_branch_count(raw_worktrees, now, options),
+              window_hours: options[:window_hours],
+              window_label: options[:window_label]
+            }
+          end
+
+          # Branch-based count; worktree filters never change it, so checkout
+          # exclusions use the complete inventory.
+          def recent_branch_count(raw_worktrees, now, options)
+            if @branch_counter
+              @branch_counter.call(worktrees: raw_worktrees, window_hours: options[:window_hours], now: now)
+            else
+              Molecules::RecentBranchCounter.new(
+                worktrees: raw_worktrees, window_hours: options[:window_hours], now: now
+              ).count
+            end
+          end
+
+          # --- Rendering ---
+
+          def render(selected, active, inactive, statistics, options)
+            case options[:format]
+            when :json
+              render_json(selected)
+            when :simple
+              render_simple(selected)
+            else
+              render_table(active, inactive, statistics, options)
+            end
+          end
+
+          def render_json(worktrees)
+            JSON.generate(worktrees.map(&:to_h))
+          end
+
+          def render_simple(worktrees)
+            @lister.format_for_display(worktrees, :simple)
+          end
+
+          def render_table(active, inactive, statistics, options)
+            footer = Molecules::WorktreeFooterFormatter.new(
+              window_label: statistics[:window_label],
+              full: options[:full]
+            )
+            table = Molecules::WorktreeTableFormatter.new(env: @env, full: options[:full], stdout: @stdout)
+
+            lines = [footer.header(active_count: active.length, total_count: statistics[:total])]
+
+            if statistics[:total].zero?
+              return "No worktrees found."
+            end
+
+            rows = options[:full] ? (active + inactive) : active
+            table_ended_with_blank = false
+            if rows.empty?
+              lines << footer.no_active_message
+            else
+              lines.concat(table.render(rows))
+              table_ended_with_blank = true
+            end
+
+            unless options[:quiet]
+              # The table already ends each entry with a blank separator line.
+              lines << "" unless table_ended_with_blank
+              lines.concat(footer.lines(
+                inactive: inactive.length,
+                task_associated: statistics[:task_associated],
+                usable: statistics[:usable],
+                recent_branches: statistics[:recent_branches]
+              ))
+            end
+
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -270,24 +270,33 @@ module Ace
           #
           # @example
           #   result = manager.list_all
-          #   result = manager.list_all(format: :json, show_tasks: true)
+          #   result = manager.list_all(format: :json)
           #
-          # @option options [Symbol] :format Output format (:table, :json, :simple)
-          # @option options [Boolean] :show_tasks Include task associations
+          # Programmatic inventory for internal consumers (overseer, prune,
+          # switch/remove hints). The user-facing enriched table is rendered by
+          # {WorktreeListReport}, not here.
+          #
+          # @option options [Symbol] :format Optional formatting (:simple, :json)
           # @option options [Boolean] :task_associated Filter by task association
           # @option options [Boolean] :usable Filter by usability
           # @option options [String] :search Filter by search pattern
           def list_all(options = {})
-            task_filter_requested = !options[:task_associated].nil?
-
-            # Get worktrees
-            worktrees = if options[:show_tasks] || task_filter_requested
-              @worktree_lister.list_with_tasks
-            else
-              @worktree_lister.list_all
+            inventory = @worktree_lister.inventory
+            unless inventory[:success]
+              # Programmatic inventory keeps its historical tolerant contract:
+              # outside a repository it returns an empty list, not an error.
+              return {
+                success: true,
+                worktrees: [],
+                formatted_output: nil,
+                statistics: @worktree_lister.get_statistics([]),
+                count: 0,
+                warning: inventory[:error]
+              }
             end
 
-            # Apply filters
+            worktrees = inventory[:worktrees]
+
             if !options[:task_associated].nil? || !options[:usable].nil? || options[:search] || options[:task_id] || options[:pr_number]
               worktrees = @worktree_lister.filter(
                 worktrees,
@@ -299,13 +308,7 @@ module Ace
               )
             end
 
-            # Format output
-            formatted_output = @worktree_lister.format_for_display(
-              worktrees,
-              options[:format] || :table
-            )
-
-            # Get statistics
+            formatted_output = options[:format] && @worktree_lister.format_for_display(worktrees, options[:format])
             stats = @worktree_lister.get_statistics(worktrees)
 
             {
@@ -441,8 +444,7 @@ module Ace
           #   status = manager.get_status
           #   puts "Total worktrees: #{status[:statistics][:total]}"
           def get_status
-            # Get all worktrees with task associations
-            worktrees = @worktree_lister.list_with_tasks
+            worktrees = @worktree_lister.list_all
             stats = @worktree_lister.get_statistics
 
             # Get task worktree status