ace-git-worktree 0.26.1 → 0.27.1

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

@@ -0,0 +1,186 @@
+# 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
+            @canonical_directories = {}
+            @canonical_worktree_paths = {}
+          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_worktree_path(entry) == 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_directory(entry) == 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_directory(entry)
+              absolute_path == directory || absolute_path.start_with?("#{directory}/")
+            end
+          end
+
+          # Canonical forms are compared on every lookup; resolve each entry's
+          # directory / recorded worktree path exactly once (realpath is a
+          # syscall per path component and dominates lookup time otherwise).
+          def canonical_directory(entry)
+            @canonical_directories.fetch(entry) { @canonical_directories[entry] = canonical_path(entry.directory) }
+          end
+
+          def canonical_worktree_path(entry)
+            @canonical_worktree_paths.fetch(entry) do
+              @canonical_worktree_paths[entry] = entry.worktree_path ? canonical_path(entry.worktree_path) : nil
+            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

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

@@ -22,7 +22,9 @@ module Ace
         #     task_id: "081"
         #   )
         class WorktreeInfo
-          attr_reader :path, :branch, :commit, :task_id, :bare, :detached, :created_at
+          attr_reader :path, :branch, :commit, :task_id, :bare, :detached, :created_at,
+            :task_id_source, :task_ids, :active_within_window, :last_commit,
+            :uncommitted, :pr, :probe_error
 
           # Initialize a new WorktreeInfo
           #
@@ -33,7 +35,17 @@ module Ace
           # @param bare [Boolean] Whether this is a bare worktree
           # @param detached [Boolean] Whether worktree is in detached HEAD state
           # @param created_at [Time, nil] When the worktree was created
-          def initialize(path:, commit:, branch: nil, task_id: nil, bare: false, detached: false, created_at: nil)
+          # @param task_id_source [String, nil] How the task id was resolved
+          #   (metadata|symlink|path|branch|task_files)
+          # @param task_ids [Array<String>] All inferred candidate task ids
+          # @param active_within_window [Boolean, nil] activity classification
+          # @param last_commit [Hash, nil] `{sha:, age_hours:, committed_at:, subject:}`
+          # @param uncommitted [Hash, nil] `{staged:, unstaged:, untracked:, total:}`
+          # @param pr [Hash, nil] `{number:, state:, draft:, matched_by:}`
+          # @param probe_error [Boolean] whether the per-worktree probe failed
+          def initialize(path:, commit:, branch: nil, task_id: nil, bare: false, detached: false, created_at: nil,
+            task_id_source: nil, task_ids: [], active_within_window: nil, last_commit: nil,
+            uncommitted: nil, pr: nil, probe_error: false)
             @path = path
             @branch = branch
             @commit = commit
@@ -41,6 +53,37 @@ module Ace
             @bare = bare
             @detached = detached
             @created_at = created_at
+            @task_id_source = task_id_source
+            @task_ids = Array(task_ids).freeze
+            @active_within_window = active_within_window
+            @last_commit = last_commit
+            @uncommitted = uncommitted
+            @pr = pr
+            @probe_error = probe_error
+          end
+
+          # Return a copy with enrichment fields applied.
+          #
+          # @param fields [Hash] enrichment overrides
+          # @return [WorktreeInfo]
+          def with_enrichment(**fields)
+            self.class.new(
+              path: @path, branch: @branch, commit: @commit, bare: @bare, detached: @detached,
+              created_at: @created_at,
+              task_id: fields.fetch(:task_id, @task_id),
+              task_id_source: fields.fetch(:task_id_source, @task_id_source),
+              task_ids: fields.fetch(:task_ids, @task_ids),
+              active_within_window: fields.fetch(:active_within_window, @active_within_window),
+              last_commit: fields.fetch(:last_commit, @last_commit),
+              uncommitted: fields.fetch(:uncommitted, @uncommitted),
+              pr: fields.fetch(:pr, @pr),
+              probe_error: fields.fetch(:probe_error, @probe_error)
+            )
+          end
+
+          # @return [Boolean] true when the per-worktree probe could not run
+          def probe_failed?
+            @probe_error
           end
 
           # Check if the worktree is associated with a task
@@ -231,13 +274,19 @@ module Ace
               branch: @branch,
               commit: @commit,
               task_id: @task_id,
+              task_id_source: @task_id_source,
+              task_ids: @task_ids,
               bare: @bare,
               detached: @detached,
               created_at: @created_at,
               usable: usable?,
               task_associated: task_associated?,
               exists: exists?,
-              empty: empty?
+              empty: empty?,
+              active_within_window: @active_within_window,
+              last_commit: @last_commit,
+              uncommitted: @uncommitted,
+              pr: @pr
             }
           end
 

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "ace/git"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Resolves the pull request associated with a worktree through the
+        # configured forge provider using exactly one bounded recent-PR query
+        # per listing run.
+        #
+        # Resolution order: branch match, then HEAD-sha match, then a unique
+        # task-reference match in a PR title/body. Any provider failure is
+        # swallowed: PR resolution never fails the command and never blocks
+        # output.
+        class PrStatusResolver
+          # Bounded recent-PR window fetched once per run.
+          PR_QUERY_LIMIT = 50
+
+          # Providers expose PR state as symbols; JSON/table use strings.
+          STATE_LABELS = {open: "open", merged: "merged", closed: "closed"}.freeze
+          STATE_PRIORITY = {open: 0, merged: 1, closed: 2}.freeze
+
+          # @param provider [Object, nil] injectable provider (tests)
+          # @param query [Proc, nil] injectable `->(limit:) { Array }` query (tests)
+          # @param limit [Integer] bounded query size
+          # @param timeout [Integer, nil] provider timeout
+          def initialize(query: nil, provider: nil, limit: PR_QUERY_LIMIT, timeout: nil)
+            @query = query
+            @provider = provider
+            @limit = limit
+            @timeout = timeout
+          end
+
+          # Resolve the PR for one worktree.
+          #
+          # @param worktree [Models::WorktreeInfo]
+          # @param task_id [String, nil] resolved task id
+          # @return [Hash, nil] `{number:, state:, draft:, matched_by:}`
+          def resolve(worktree, task_id)
+            pull_requests = recent_pull_requests
+            return nil if pull_requests.empty?
+
+            match = by_branch(pull_requests, worktree.branch) ||
+              by_head_sha(pull_requests, worktree.commit) ||
+              by_task_reference(pull_requests, task_id)
+            return nil unless match
+
+            {
+              number: match[:pull_request][:number],
+              state: STATE_LABELS.fetch(match[:pull_request][:state], match[:pull_request][:state].to_s),
+              draft: match[:pull_request][:draft] ? true : false,
+              matched_by: match[:matched_by]
+            }
+          end
+
+          # Render the PR cell text.
+          #
+          # @param pr [Hash, nil]
+          # @return [String]
+          def self.cell(pr)
+            return "-" if pr.nil? || pr[:number].nil?
+
+            label = "##{pr[:number]}"
+            case pr[:state].to_s
+            when "open" then pr[:draft] ? "#{label} draft" : label
+            when "merged" then "#{label} merged"
+            when "closed" then "#{label} closed"
+            else label
+            end
+          end
+
+          # The bounded recent-PR query, executed once per resolver.
+          #
+          # @return [Array<Hash>] normalized PR hashes
+          def recent_pull_requests
+            return @recent_pull_requests if defined?(@recent_pull_requests)
+
+            @recent_pull_requests = begin
+              rows = if @query
+                @query.call(limit: @limit)
+              else
+                provider = resolved_provider
+                provider ? provider.recent_pull_requests(limit: @limit) : []
+              end
+              Array(rows).map { |row| normalize(row) }.compact
+            rescue StandardError
+              []
+            end
+          end
+
+          private
+
+          def resolved_provider
+            return @provider if defined?(@provider) && @provider
+
+            @provider = begin
+              server = Ace::Git::ServerRegistry.resolve_default
+              server ? Ace::Git::Providers.for(server, timeout: @timeout) : nil
+            rescue StandardError
+              nil
+            end
+          end
+
+          def by_branch(pull_requests, branch)
+            return nil if branch.to_s.empty?
+
+            candidates = pull_requests.select { |pr| pr[:head_ref] == branch }
+            best_match(candidates, "branch")
+          end
+
+          def by_head_sha(pull_requests, commit)
+            return nil if commit.to_s.empty?
+
+            candidates = pull_requests.select { |pr| pr[:head_sha] == commit }
+            best_match(candidates, "head_sha")
+          end
+
+          def by_task_reference(pull_requests, task_id)
+            return nil if task_id.to_s.empty?
+
+            pattern = task_reference_pattern(task_id)
+            candidates = pull_requests.select do |pr|
+              pattern.match?(pr[:title].to_s) || pattern.match?(pr[:body].to_s)
+            end
+            # Exactly one recent PR may reference the task; ambiguity means no PR.
+            return nil unless candidates.length == 1
+
+            {pull_request: candidates.first, matched_by: "task_reference"}
+          end
+
+          # Prefer open PRs over merged/closed, then the most recent number.
+          def best_match(candidates, matched_by)
+            return nil if candidates.empty?
+
+            chosen = candidates.min_by do |pr|
+              [STATE_PRIORITY.fetch(pr[:state], STATE_PRIORITY.length), -pr[:number].to_i]
+            end
+            {pull_request: chosen, matched_by: matched_by}
+          end
+
+          # A bounded token: the task id must not be glued to other
+          # alphanumerics ("k9y", and inside "8xg.t.k9y").
+          def task_reference_pattern(task_id)
+            /(?<![0-9a-z])#{Regexp.escape(task_id)}(?![0-9a-z])/i
+          end
+
+          def normalize(row)
+            {
+              number: field(row, :number)&.to_i,
+              state: field(row, :state)&.to_sym,
+              draft: field(row, :draft) ? true : false,
+              head_ref: field(row, :head_ref),
+              head_sha: field(row, :head_sha),
+              title: field(row, :title),
+              body: field(row, :body)
+            }
+          end
+
+          def field(row, name)
+            if row.is_a?(Hash)
+              row[name] || row[name.to_s]
+            else
+              row.respond_to?(name) ? row.public_send(name) : nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Counts branches whose last commit landed inside the activity window but
+        # that have no worktree. This count is branch-based: worktree filters
+        # never change it.
+        class RecentBranchCounter
+          # @param worktrees [Array<Models::WorktreeInfo>] selected worktrees
+          # @param window_hours [Numeric] activity window in hours
+          # @param now [Time] clock snapshot shared with the listing run
+          # @param runner [Proc, nil] injectable ref lister returning
+          #   `"<branch>\0<committer unix>"` lines (tests)
+          def initialize(worktrees:, window_hours:, now: Time.now, runner: nil)
+            @worktrees = Array(worktrees)
+            @window_hours = window_hours
+            @now = now
+            @runner = runner
+          end
+
+          # @return [Integer]
+          def count
+            cutoff = @now.to_i - (@window_hours * 3600).to_i
+            checked_out = @worktrees.map(&:branch).compact
+            primary_branch = @worktrees.first&.branch
+
+            branch_rows.count do |branch, committed_at|
+              next false if branch.nil? || branch.empty?
+              next false if branch == primary_branch
+              next false if checked_out.include?(branch)
+              next false if committed_at.nil?
+
+              committed_at >= cutoff
+            end
+          rescue StandardError
+            0
+          end
+
+          private
+
+          # @return [Array<Array(String, Integer)>] branch/committer pairs
+          def branch_rows
+            output = @runner ? @runner.call : default_branch_listing
+            return [] if output.nil? || output.empty?
+
+            output.lines.filter_map do |line|
+              branch, epoch = line.chomp.split("\x00", 2)
+              next if branch.to_s.empty?
+
+              [branch, epoch && Integer(epoch, 10)]
+            rescue ArgumentError
+              nil
+            end
+          end
+
+          def default_branch_listing
+            stdout, _stderr, status = Open3.capture3(
+              "git", "for-each-ref", "--format=%(refname:short)%00%(committerdate:unix)", "refs/heads/"
+            )
+            status.success? ? stdout : ""
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/task_id_extractor"
+require_relative "../models/task_index"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Resolves a worktree to a task id without depending on worktree names.
+        #
+        # Precedence (first hit wins):
+        # 1. recorded task frontmatter metadata (`worktree.path` / `worktree.branch`);
+        # 2. the `_current` symlink at the worktree root resolving under `.ace-tasks/`;
+        # 3. a validated path/branch name extraction (rejected when the extracted
+        #    id names no known task);
+        # 4. task files changed inside the worktree (uncommitted first, then
+        #    committed against the primary branch merge-base);
+        # 5. unresolved (`task_id` stays nil -> rendered `-`).
+        class TaskAssociationResolver
+          # Task-provenance values exposed in JSON `task_id_source`.
+          SOURCES = %w[metadata symlink path branch task_files].freeze
+
+          # @param task_index [Models::TaskIndex]
+          def initialize(task_index:)
+            @task_index = task_index || Models::TaskIndex.new
+          end
+
+          # @param worktree [Models::WorktreeInfo]
+          # @param probe [Hash, nil] probe payload for this worktree
+          # @return [Models::WorktreeInfo] copy carrying task resolution fields
+          def resolve(worktree, probe)
+            resolved = resolve_source(worktree, probe || {})
+            worktree.with_enrichment(
+              task_id: resolved[:task_id],
+              task_id_source: resolved[:source],
+              task_ids: resolved[:task_ids]
+            )
+          end
+
+          private
+
+          def resolve_source(worktree, probe)
+            if (entry = recorded_metadata_entry(worktree))
+              return resolved_entry(entry, "metadata")
+            end
+
+            if (entry = symlink_entry(probe))
+              return resolved_entry(entry, "symlink")
+            end
+
+            if (named = name_extraction(worktree))
+              return named
+            end
+
+            if (inferred = task_file_inference(probe))
+              return inferred
+            end
+
+            {task_id: nil, source: nil, task_ids: []}
+          end
+
+          def resolved_entry(entry, source)
+            {task_id: entry.short_id, source: source, task_ids: [entry.short_id]}
+          end
+
+          def recorded_metadata_entry(worktree)
+            @task_index.find_by_worktree_path(worktree.path) ||
+              @task_index.find_by_worktree_branch(worktree.branch)
+          end
+
+          def symlink_entry(probe)
+            target = probe[:symlink_target]
+            return nil if target.to_s.empty?
+
+            @task_index.find_by_directory(target)
+          end
+
+          # Validate the existing path -> branch name extraction. Without a
+          # `.ace-tasks/` tree the extraction is accepted as before; with a task
+          # tree, the extracted id must resolve to a known task so meaningless
+          # directory names (e.g. "ace") do not pollute the Task column.
+          def name_extraction(worktree)
+            from_path = Atoms::TaskIDExtractor.normalize(File.basename(worktree.path))
+            if from_path && acceptable?(from_path)
+              return {task_id: from_path, source: "path", task_ids: [from_path]}
+            end
+
+            from_branch = worktree.branch && Atoms::TaskIDExtractor.normalize(worktree.branch)
+            if from_branch && acceptable?(from_branch)
+              return {task_id: from_branch, source: "branch", task_ids: [from_branch]}
+            end
+
+            nil
+          end
+
+          def acceptable?(task_id)
+            return true unless @task_index.available?
+
+            @task_index.task?(task_id)
+          end
+
+          def task_file_inference(probe)
+            paths = Array(probe[:changed_task_files])
+            paths = Array(probe[:committed_task_files]) if paths.empty?
+            return nil if paths.empty?
+
+            candidates = @task_index.candidates_for_paths(paths)
+            return nil if candidates.empty?
+
+            {
+              task_id: candidates.first[:entry].short_id,
+              source: "task_files",
+              task_ids: candidates.map { |candidate| candidate[:entry].short_id }
+            }
+          end
+        end
+      end
+    end
+  end
+end