ace-git-worktree 0.26.1 → 0.27.1

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

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

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

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

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