ace-git-worktree 0.26.1 → 0.27.0

data/lib/ace/git/worktree/atoms/task_id_extractor.rb

@@ -53,6 +53,22 @@ module Ace
             task_data[:task_number]&.to_s || "unknown"
           end
 
+          # Derive the short form of a full Base36 task id.
+          #
+          # The short form is the three-character suffix plus an optional
+          # subtask segment (numeric or single character).
+          #
+          # @param full_id [String, nil] formatted task id (e.g. "8xg.t.k9y",
+          #   "8wr.t.qk0.3")
+          # @return [String, nil] short id (e.g. "k9y", "qk0.3") or nil when the
+          #   argument is not a full task id
+          def self.short_id(full_id)
+            match = full_id.to_s.strip.match(/\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3})(?:\.([0-9a-z]+))?\z/)
+            return nil unless match
+
+            match[2] ? "#{match[1]}.#{match[2]}" : match[1]
+          end
+
           # Normalize a task reference string to simple ID format
           #
           # @param task_ref [String] Task reference (e.g., "121.01", "v.0.9.0+task.121.01")
@@ -63,7 +79,7 @@ module Ace
 
             # Regex patterns for recognized ACE task ID formats
             # B36TS full ID: "8pp.t.hy4" -> "hy4", or subtask "8pp.t.hy4.a" -> "hy4.a"
-            if match = ref.match(/\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3}(?:\.[a-z0-9])?)\z/)
+            if match = ref.match(/\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3}(?:\.[0-9a-z]+)?)\z/)
               match[1]
             # B36TS short ref: exactly 3 lowercase alphanumeric chars (e.g., "hy4")
             elsif match = ref.match(/\A([0-9a-z]{3})\z/)
@@ -72,6 +88,9 @@ module Ace
             # Try hierarchical pattern first (e.g., "121.01", "task.121.01")
             elsif match = ref.match(/(\d{3})\.(\d{2})(?:\b|$)/)
               "#{match[1]}.#{match[2]}"
+            # B36TS short ref with subtask segment (e.g., "qk0.3", "hy4.a")
+            elsif match = ref.match(/\A([0-9a-z]{3})\.([0-9a-z]+)\z/)
+              "#{match[1]}.#{match[2]}"
             # Try ace-task/ace-t or task/t directory at end of path (e.g., "ace-task.hy4", "/path/to/task.121")
             elsif match = ref.match(/(?:ace-)?(?:task|t)\.([0-9a-z]{3})\/?$/)
               match[1]

data/lib/ace/git/worktree/atoms/text_truncator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Worktree
+      module Atoms
+        # Truncates single-column text using the single-character ellipsis `…`.
+        #
+        # Each helper returns a string no wider than `width` columns (the
+        # ellipsis counts as one column). Text that already fits is returned
+        # unchanged. Widths below 1 render an empty string; width 1 renders
+        # only the ellipsis.
+        #
+        # @example Branches keep both ends
+        #   TextTruncator.middle("codex/ei9-campaign-composition-join", 25)
+        #   # => "codex/ei9-ca…osition-join"
+        module TextTruncator
+          ELLIPSIS = "…"
+
+          class << self
+            # Keep the prefix and suffix; elide the middle.
+            # @param text [String, nil]
+            # @param width [Integer] target column width
+            # @return [String]
+            def middle(text, width)
+              value = text.to_s
+              return "" if width <= 0
+              return value if value.length <= width
+              return ELLIPSIS if width == 1
+
+              remaining = width - 1
+              prefix_length = (remaining + 1) / 2
+              suffix_length = remaining - prefix_length
+              "#{value[0, prefix_length]}#{ELLIPSIS}#{value[-suffix_length, suffix_length]}"
+            end
+
+            # Keep the prefix; truncate the tail.
+            # @param text [String, nil]
+            # @param width [Integer] target column width
+            # @return [String]
+            def right(text, width)
+              value = text.to_s
+              return "" if width <= 0
+              return value if value.length <= width
+              return ELLIPSIS if width == 1
+
+              "#{value[0, width - 1]}#{ELLIPSIS}"
+            end
+
+            # Keep the suffix; elide the head.
+            # @param text [String, nil]
+            # @param width [Integer] target column width
+            # @return [String]
+            def left(text, width)
+              value = text.to_s
+              return "" if width <= 0
+              return value if value.length <= width
+              return ELLIPSIS if width == 1
+
+              "#{ELLIPSIS}#{value[-(width - 1), width - 1]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/worktree/cli/commands/list.rb

@@ -12,28 +12,42 @@ module Ace
           class List < Ace::Support::Cli::Command
             include SharedHelpers
 
-            desc "List all worktrees with optional filtering"
+            desc <<~DESC.chomp
+              List active worktrees with task, activity, dirty-state, and PR context
+              Columns: Task, Branch, Age, Commit, Changes, PR, Path. A worktree is
+              active when its last commit is inside --active-within (default 18h) or
+              it has uncommitted changes. Task ids are inferred from recorded task
+              metadata, the _current symlink, validated path/branch names, or
+              .ace-tasks files changed in the worktree; PRs match by branch, then
+              HEAD commit sha, then a unique task reference. Columns shrink to the
+              terminal width and Path drops on very narrow terminals. Probing runs
+              in isolated child processes with a 5 second per-worktree budget;
+              unreadable probes render "?".
+            DESC
 
             example [
-              "                          # List all worktrees",
-              "--show-tasks              # Include task associations",
-              "--format json             # JSON output",
+              "                          # Worktrees active in the last 18h",
+              "--full                    # Every worktree with absolute paths",
+              "--active-within 3d        # Wider activity window",
+              "--format json             # Machine-readable output",
               "--search auth             # Filter by branch pattern"
             ]
 
             option :format, desc: "Output format: table, json, simple", aliases: [], default: "table"
-            option :show_tasks, desc: "Include task associations", type: :boolean
+            option :compact, desc: "Active worktrees only (default)", type: :boolean
+            option :full, desc: "List every worktree with absolute paths", type: :boolean
+            option :active_within, desc: "Activity window (Nm, Nh, Nd, or bare hours; default 18h)", aliases: []
             option :task_associated, desc: "Show only task-associated worktrees", type: :boolean
             option :usable, desc: "Show only usable worktrees", type: :boolean
             option :search, desc: "Filter by branch name pattern", aliases: []
-            option :quiet, type: :boolean, aliases: ["-q"], desc: "Suppress non-essential output"
+            option :quiet, type: :boolean, aliases: ["-q"], desc: "Suppress the count footer"
             option :verbose, type: :boolean, aliases: ["-v"], desc: "Show verbose output"
             option :debug, type: :boolean, aliases: ["-d"], desc: "Show debug output"
 
             def call(**options)
               display_config_summary("list", options) unless options[:format] == "json"
 
-              # Keep explicit false values as --no-* flags so legacy parser receives filters.
+              # Keep explicit false values as --no-* flags so the parser receives filters.
               args = list_options_to_args(options)
 
               Ace::Git::Worktree::Commands::ListCommand.new.run(args)
@@ -44,7 +58,14 @@ module Ace
             def list_options_to_args(options)
               args = []
               args.concat(format_arg(options))
-              args << "--show-tasks" if options[:show_tasks]
+              args << "--compact" if options[:compact]
+              args << "--full" if options[:full]
+              args << "--quiet" if options[:quiet]
+
+              if options[:active_within].is_a?(String) && !options[:active_within].empty?
+                args << "--active-within"
+                args << options[:active_within]
+              end
 
               unless options[:task_associated].nil?
                 args << (options[:task_associated] ? "--task-associated" : "--no-task-associated")

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

@@ -38,7 +38,7 @@ module Ace
 
         HELP_EXAMPLES = [
           "ace-git-worktree create --task 148    # Isolated worktree for task",
-          "ace-git-worktree list --show-tasks    # Worktrees with task context",
+          "ace-git-worktree list --full          # Every worktree with task context",
           "ace-git-worktree switch 148           # Get path for cd",
           "ace-git-worktree prune --dry-run      # Preview stale cleanup"
         ].freeze

data/lib/ace/git/worktree/commands/list_command.rb

@@ -6,21 +6,29 @@ module Ace
       module Commands
         # List command
         #
-        # Lists worktrees with various formatting and filtering options.
-        # Supports task-aware listing and search capabilities.
+        # Prints the active-worktree table: one enriched row per worktree whose
+        # last activity falls inside the activity window (committed or dirty),
+        # plus a two-line count footer. `--full` lists every worktree,
+        # `--format json` is the machine surface, `--format simple` is the
+        # branch-at-path listing.
         #
-        # @example List all worktrees
+        # @example Daily driver (last 18h)
         #   ListCommand.new.run([])
         #
-        # @example List with JSON output
-        #   ListCommand.new.run(["--format", "json"])
+        # @example Wider window in JSON
+        #   ListCommand.new.run(["--active-within", "3d", "--format", "json"])
         #
-        # @example List only task-associated worktrees
-        #   ListCommand.new.run(["--task-associated"])
+        # @example Exhaustive listing
+        #   ListCommand.new.run(["--full"])
         class ListCommand
+          # Supported output formats
+          FORMATS = %w[table json simple].freeze
+
           # Initialize a new ListCommand
-          def initialize
-            @manager = Organisms::WorktreeManager.new
+          #
+          # @param reporter [Organisms::WorktreeListReport, nil] injectable report
+          def initialize(reporter: nil)
+            @reporter = reporter
           end
 
           # Run the list command
@@ -33,13 +41,10 @@ module Ace
 
             validate_options(options)
 
-            # Convert format to symbol for WorktreeLister compatibility
-            options[:format] = options[:format].to_sym if options[:format]
-
-            result = @manager.list_all(options)
+            result = reporter.run(options)
 
             if result[:success]
-              display_list_result(result, options)
+              puts result[:output] unless result[:output].to_s.empty?
               0
             else
               puts "Failed to list worktrees: #{result[:error]}"
@@ -47,8 +52,6 @@ module Ace
             end
           rescue ArgumentError => e
             puts "Error: #{e.message}"
-            puts
-            show_help
             1
           rescue => e
             puts "Error: #{e.message}"
@@ -63,49 +66,61 @@ module Ace
               ace-git-worktree list - List worktrees
 
               USAGE:
-                  ace-git-worktree list [OPTIONS]
+                  ace-git-worktree list [--compact | --full] [--active-within DURATION] [OPTIONS]
+
+              VIEW:
+                  --compact               Active worktrees only (default)
+                  --full                  List every worktree with absolute paths
+                  --active-within <dur>   Activity window: Nm, Nh, Nd, or bare hours (default: 18h)
 
-              OUTPUT FORMATS:
+              OUTPUT:
                   --format <format>       Output format: table, json, simple (default: table)
-                  --show-tasks            Include task associations
+                  -q, --quiet             Suppress the count footer
 
               FILTERING:
-                  --task-associated       Show only task-associated worktrees
-                  --no-task-associated    Show only non-task worktrees
-                  --usable               Show only usable worktrees
-                  --no-usable            Show only unusable worktrees
+                  --task-associated       Show only worktrees with a resolved task id
+                  --no-task-associated    Show only worktrees without a task id
+                  --usable                Show only usable worktrees
+                  --no-usable             Show only unusable worktrees
                   --search <pattern>      Filter by branch name pattern
 
               EXAMPLES:
-                  # List all worktrees in table format
+                  # Worktrees active in the last 18 hours
                   ace-git-worktree list
 
-                  # List with task associations in JSON format
-                  ace-git-worktree list --show-tasks --format json
-
-                  # List only task-associated worktrees
-                  ace-git-worktree list --task-associated
-
-                  # Search for worktrees with "auth" in branch name
-                  ace-git-worktree list --search auth
-
-                  # List only usable worktrees
-                  ace-git-worktree list --usable
-
-              OUTPUT:
-                  Table format columns:
-                  - Task: Task ID (or - for non-task worktrees)
-                  - Branch: Git branch name
-                  - Path: Worktree directory path
-                  - Status: worktree status (task, normal, bare, detached, etc.)
-
-                  JSON format includes full worktree details and metadata.
+                  # Everything, including inactive worktrees
+                  ace-git-worktree list --full
+
+                  # After a weekend
+                  ace-git-worktree list --active-within 3d
+
+                  # Machine-readable output
+                  ace-git-worktree list --format json
+
+              COLUMNS:
+                  Task     Resolved task id (inferred from metadata, the _current symlink,
+                           validated names, or task files changed in the worktree)
+                  Branch   Checked-out branch (middle-elided when truncated)
+                  Age      Age of the last commit, one compact unit (8m, 3h, 9d, 3w, 2mo, 1y)
+                  Commit   Last commit subject (right-truncated)
+                  Changes  Uncommitted file count (staged + unstaged + untracked)
+                  PR       #N, #N draft, #N merged, #N closed, or - (matched by branch,
+                           HEAD commit, or a unique task reference)
+                  Path     Worktree path (~ shortened; --full prints it absolute)
+
+                  Columns shrink to fit the terminal width; Path is dropped on very
+                  narrow terminals. Probing runs in isolated child processes with a
+                  5 second per-worktree budget; unreadable probes render "?".
             HELP
             0
           end
 
           private
 
+          def reporter
+            @reporter || Organisms::WorktreeListReport.new(env: ENV)
+          end
+
           # Parse command line arguments
           #
           # @param args [Array<String>] Command arguments
@@ -113,10 +128,15 @@ module Ace
           def parse_arguments(args)
             options = {
               format: "table",
-              show_tasks: false,
+              compact: false,
+              full: false,
+              active_within: nil,
               task_associated: nil,
               usable: nil,
               search: nil,
+              quiet: false,
+              verbose: false,
+              debug: false,
               help: false
             }
 
@@ -128,13 +148,17 @@ module Ace
               when "--format"
                 i += 1
                 format = args[i]&.downcase
-                if %w[table json simple].include?(format)
-                  options[:format] = format
-                else
+                unless FORMATS.include?(format)
                   raise ArgumentError, "Invalid format: #{format}. Use: table, json, simple"
                 end
-              when "--show-tasks"
-                options[:show_tasks] = true
+                options[:format] = format
+              when "--compact"
+                options[:compact] = true
+              when "--full"
+                options[:full] = true
+              when "--active-within"
+                i += 1
+                options[:active_within] = args[i]
               when "--task-associated"
                 options[:task_associated] = true
               when "--no-task-associated"
@@ -146,6 +170,12 @@ module Ace
               when "--search"
                 i += 1
                 options[:search] = args[i]
+              when "--quiet", "-q"
+                options[:quiet] = true
+              when "--verbose", "-v"
+                options[:verbose] = true
+              when "--debug", "-d"
+                options[:debug] = true
               when "--help", "-h"
                 options[:help] = true
               when /^--/
@@ -164,14 +194,23 @@ module Ace
           #
           # @param options [Hash] Parsed options
           def validate_options(options)
+            if options[:compact] && options[:full]
+              raise ArgumentError, "--compact and --full are mutually exclusive"
+            end
+
             if options[:search] && options[:search].empty?
               raise ArgumentError, "Search pattern cannot be empty"
             end
 
-            if options[:format] && !%w[table json simple].include?(options[:format])
+            if options[:format] && !FORMATS.include?(options[:format])
               raise ArgumentError, "Invalid format: #{options[:format]}"
             end
 
+            # Parse eagerly so invalid windows fail before any output.
+            if options[:active_within]
+              Atoms::DurationParser.parse(options[:active_within])
+            end
+
             # Security validation for search patterns
             if options[:search] && contains_dangerous_patterns?(options[:search])
               raise ArgumentError, "Search pattern contains potentially dangerous characters"
@@ -197,49 +236,6 @@ module Ace
 
             dangerous_patterns.any? { |pattern| value.match?(pattern) }
           end
-
-          # Display list result
-          #
-          # @param result [Hash] List result
-          # @param options [Hash] Command options
-          def display_list_result(result, options)
-            if result[:worktrees].empty?
-              puts "No worktrees found."
-              return
-            end
-
-            # Display the formatted output
-            puts result[:formatted_output]
-
-            # Display summary if requested or if not JSON format
-            if options[:format] != :json
-              display_summary(result, options)
-            end
-          end
-
-          # Display summary information
-          #
-          # @param result [Hash] List result
-          # @param options [Hash] Command options
-          def display_summary(result, options)
-            stats = result[:statistics]
-            puts "\nSummary:"
-            puts "  Total worktrees: #{stats[:total]}"
-            puts "  Task-associated: #{stats[:task_associated]}"
-            puts "  Usable: #{stats[:usable]}"
-
-            if options[:show_tasks] && stats[:task_ids].any?
-              puts "  Tasks with worktrees: #{stats[:task_ids].join(", ")}"
-            end
-
-            if stats[:branches].any?
-              puts "  Branches: #{stats[:branches].join(", ")}"
-            end
-
-            # Show active worktrees count
-            active_count = result[:worktrees].count { |wt| wt.exists? && wt.usable? }
-            puts "  Active worktrees: #{active_count}"
-          end
         end
       end
     end

data/lib/ace/git/worktree/models/task_index.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/task_id_extractor"
+
+module Ace
+  module Git
+    module Worktree
+      module Models
+        # Immutable index of the current project's tasks, built from the
+        # `.ace-tasks/` tree once per listing run.
+        #
+        # The index maps task spec frontmatter ids (full and short form), task
+        # directories, and recorded `worktree.path` / `worktree.branch` metadata
+        # so the list command can associate worktrees to tasks without relying
+        # on worktree names.
+        #
+        # @example
+        #   index = TaskIndexBuilder.new.build
+        #   index.task?("k9y")                                # => true
+        #   index.find_by_worktree_branch("codex/k9y-list")   # => Entry
+        class TaskIndex
+          # One indexed task.
+          #
+          # @!attribute full_id [String] formatted id (e.g. "8xg.t.k9y")
+          # @!attribute short_id [String] short id (e.g. "k9y", "qk0.3")
+          # @!attribute directory [String] absolute task directory
+          # @!attribute spec_path [String] absolute task spec path
+          # @!attribute worktree_path [String, nil] absolute recorded worktree path
+          # @!attribute worktree_branch [String, nil] recorded worktree branch
+          Entry = Data.define(:full_id, :short_id, :directory, :spec_path, :worktree_path, :worktree_branch)
+
+          # @param entries [Array<Entry>] indexed tasks (unique short ids)
+          # @param available [Boolean] whether a `.ace-tasks/` tree was found
+          # @param project_root [String] project root the index was built from
+          def initialize(entries: [], available: false, project_root: nil)
+            @entries = entries.freeze
+            @available = available
+            @project_root = project_root
+          end
+
+          attr_reader :entries, :project_root
+
+          # Whether the project has a `.ace-tasks/` tree.
+          # @return [Boolean]
+          def available?
+            @available
+          end
+
+          # @return [Boolean]
+          def empty?
+            @entries.empty?
+          end
+
+          # Find an entry by short or full id.
+          #
+          # @param reference [String, nil]
+          # @return [Entry, nil]
+          def entry_for_reference(reference)
+            token = reference.to_s.strip
+            return nil if token.empty?
+
+            @entries.find { |entry| entry.full_id == token || entry.short_id == token }
+          end
+
+          # Whether the reference resolves to a known task.
+          #
+          # @param reference [String, nil]
+          # @return [Boolean]
+          def task?(reference)
+            !entry_for_reference(reference).nil?
+          end
+
+          # Resolve an arbitrary string to a short task id when it names a known
+          # task (extracting a task reference from it first).
+          #
+          # @param reference [String, nil]
+          # @return [String, nil]
+          def short_id_for(reference)
+            entry = entry_for_reference(reference)
+            return entry.short_id if entry
+
+            extracted = Atoms::TaskIDExtractor.normalize(reference)
+            extracted && task?(extracted) ? extracted : nil
+          end
+
+          # Find the task whose recorded worktree path matches.
+          #
+          # @param path [String, nil]
+          # @return [Entry, nil]
+          def find_by_worktree_path(path)
+            return nil if path.to_s.empty?
+
+            expanded = canonical_path(path)
+            @entries.find do |entry|
+              entry.worktree_path && canonical_path(entry.worktree_path) == expanded
+            end
+          end
+
+          # Find the task whose recorded worktree branch matches.
+          #
+          # @param branch [String, nil]
+          # @return [Entry, nil]
+          def find_by_worktree_branch(branch)
+            return nil if branch.to_s.empty?
+
+            @entries.find { |entry| entry.worktree_branch == branch }
+          end
+
+          # Find the task owning an absolute task directory.
+          #
+          # @param directory [String, nil]
+          # @return [Entry, nil]
+          def find_by_directory(directory)
+            return nil if directory.to_s.empty?
+
+            expanded = canonical_path(directory)
+            @entries.find { |entry| canonical_path(entry.directory) == expanded }
+          end
+
+          # Map changed file paths to task candidates.
+          #
+          # Paths are relative to the project root (as produced by git). Files
+          # changed under a task directory count towards that task; for a
+          # changed spec file the candidate id still comes from its directory.
+          #
+          # @param paths [Array<String>] repo-relative changed paths
+          # @return [Array<Hash>] `[{entry:, count:}]` sorted by count desc then
+          #   short id asc
+          def candidates_for_paths(paths)
+            counts = Hash.new(0)
+            Array(paths).each do |relative_path|
+              next if relative_path.to_s.empty?
+
+              absolute = canonical_path(File.expand_path(relative_path, @project_root || Dir.pwd))
+              entry = find_by_enclosing_directory(absolute)
+              counts[entry] += 1 if entry
+            end
+
+            counts.map { |entry, count| {entry: entry, count: count} }
+              .sort_by { |candidate| [-candidate[:count], candidate[:entry].short_id] }
+          end
+
+          private
+
+          # Locate the indexed task directory containing a file path (any depth
+          # under the task directory, including nested spec/artifact folders).
+          def find_by_enclosing_directory(absolute_path)
+            @entries.find do |entry|
+              directory = canonical_path(entry.directory)
+              absolute_path == directory || absolute_path.start_with?("#{directory}/")
+            end
+          end
+
+          # Canonical comparison form for paths that may be reached through a
+          # symlinked root (e.g. macOS /var -> /private/var).
+          def canonical_path(value)
+            expanded = File.expand_path(value)
+            return File.realpath(expanded) if File.exist?(expanded)
+
+            parent = File.dirname(expanded)
+            return expanded if parent == expanded
+
+            File.join(canonical_path(parent), File.basename(expanded))
+          rescue StandardError
+            File.expand_path(value)
+          end
+        end
+      end
+    end
+  end
+end