ace-git-worktree 0.26.1 → 0.27.0

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

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+require "open3"
+require_relative "../atoms/task_id_extractor"
+require_relative "../models/task_index"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Builds the `.ace-tasks/` task index once per listing run.
+        #
+        # Scans every task spec (`*.s.md`) under the project's task tree,
+        # including special folders such as `_archive/` and `_maybe/`, and reads
+        # only the frontmatter (``id`` plus recorded ``worktree`` metadata).
+        # Current-tree entries win over archived entries for the same short id.
+        class TaskIndexBuilder
+          # File glob for task specs under the task root.
+          SPEC_GLOB = "**/*.s.md"
+
+          # @param project_root [String, nil] project root (defaults to the git
+          #   common-dir parent of the current repository)
+          def initialize(project_root: nil)
+            @project_root = project_root
+          end
+
+          # @return [Models::TaskIndex]
+          def build
+            root = resolved_project_root
+            tasks_root = root ? File.join(root, ".ace-tasks") : nil
+            unless tasks_root && Dir.exist?(tasks_root)
+              return Models::TaskIndex.new(available: false, project_root: root)
+            end
+
+            entries = Dir.glob(File.join(tasks_root, SPEC_GLOB)).filter_map do |spec_path|
+              entry_for(spec_path, root)
+            end
+
+            Models::TaskIndex.new(entries: deduplicate(entries), available: true, project_root: root)
+          end
+
+          private
+
+          # Resolve the project root: the primary working tree that holds
+          # `.ace-tasks/`. Uses the git common dir so a linked worktree still
+          # reads the project's task tree.
+          def resolved_project_root
+            return File.expand_path(@project_root) if @project_root
+
+            out, status = Open3.capture2("git", "rev-parse", "--path-format=absolute", "--git-common-dir")
+            return Dir.pwd unless status.success?
+
+            common_dir = out.to_s.strip
+            return Dir.pwd if common_dir.empty?
+
+            File.dirname(common_dir)
+          rescue StandardError
+            Dir.pwd
+          end
+
+          # @return [Models::TaskIndex::Entry, nil]
+          def entry_for(spec_path, root)
+            frontmatter = read_frontmatter(spec_path)
+            return nil if frontmatter.nil?
+
+            full_id = frontmatter["id"].to_s.strip
+            short_id = Atoms::TaskIDExtractor.short_id(full_id) ||
+              Atoms::TaskIDExtractor.normalize(full_id)
+            return nil if short_id.nil? || short_id.empty? || full_id.empty?
+
+            worktree = frontmatter["worktree"].is_a?(Hash) ? frontmatter["worktree"] : {}
+            Models::TaskIndex::Entry.new(
+              full_id: full_id,
+              short_id: short_id,
+              directory: File.dirname(spec_path),
+              spec_path: spec_path,
+              worktree_path: expand_worktree_path(worktree["path"], root),
+              worktree_branch: blank_to_nil(worktree["branch"])
+            )
+          end
+
+          # @return [Hash, nil] parsed YAML frontmatter
+          def read_frontmatter(spec_path)
+            content = File.read(spec_path)
+            match = content.match(/\A---\s*\n(.*?)\n---\s*(?:\n|\z)/m)
+            return nil unless match
+
+            YAML.safe_load(match[1], permitted_classes: [Date, Time], aliases: true) || {}
+          rescue StandardError
+            nil
+          end
+
+          def expand_worktree_path(path, root)
+            return nil if path.to_s.strip.empty?
+
+            File.expand_path(path.to_s.strip, root)
+          end
+
+          def blank_to_nil(value)
+            value.to_s.strip.empty? ? nil : value.to_s.strip
+          end
+
+          # Keep one entry per short id: the current tree wins over special
+          # folders (first path segment starting with "_").
+          def deduplicate(entries)
+            entries.group_by(&:short_id).map do |_short_id, candidates|
+              candidates.min_by { |entry| [archived?(entry) ? 1 : 0, entry.directory] }
+            end
+          end
+
+          def archived?(entry)
+            relative = entry.directory.sub(%r{\A.*/\.ace-tasks/}, "")
+            relative.split("/").any? { |segment| segment.start_with?("_") }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Renders the listing header, empty-state line, and two-line count footer.
+        class WorktreeFooterFormatter
+          # @param window_label [String] canonical activity window (e.g. "18h")
+          # @param full [Boolean] whether every worktree is listed
+          def initialize(window_label:, full: false)
+            @window_label = window_label
+            @full = full
+          end
+
+          # @return [String] e.g. "Active worktrees (last 18h) -- 3 of 88:"
+          def header(active_count:, total_count:)
+            "Active worktrees (last #{@window_label}) -- #{active_count} of #{total_count}:"
+          end
+
+          # @return [String] empty-state line for a zero-active window
+          def no_active_message
+            "No active worktrees in the last #{@window_label}."
+          end
+
+          # @return [Array<String>] the count footer lines
+          def lines(inactive:, task_associated:, usable:, recent_branches:)
+            inactive_line = if @full
+              "Inactive: #{inactive}"
+            else
+              "Inactive: #{inactive}  (use --full to list all)"
+            end
+            [
+              inactive_line,
+              "Task-associated: #{task_associated}    Usable: #{usable}    " \
+                "Recent branches without worktrees: #{recent_branches}"
+            ]
+          end
+        end
+      end
+    end
+  end
+end