ace-git-worktree 0.19.0

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

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/task_id_extractor"
+
+module Ace
+  module Git
+    module Worktree
+      module Models
+        # Worktree information model
+        #
+        # Represents information about a git worktree, including its path,
+        # branch, commit, and associated task metadata.
+        #
+        # @example Create from git worktree list output
+        #   info = WorktreeInfo.from_git_output("/path/to/worktree abc123 [branch-name]")
+        #
+        # @example Create manually
+        #   info = WorktreeInfo.new(
+        #     path: "/project/.ace-wt/task.081",
+        #     branch: "081-fix-auth-bug",
+        #     commit: "abc123",
+        #     task_id: "081"
+        #   )
+        class WorktreeInfo
+          attr_reader :path, :branch, :commit, :task_id, :bare, :detached, :created_at
+
+          # Initialize a new WorktreeInfo
+          #
+          # @param path [String] Path to the worktree directory
+          # @param branch [String, nil] Branch name (nil if detached HEAD)
+          # @param commit [String] Commit hash
+          # @param task_id [String, nil] Associated task ID
+          # @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)
+            @path = path
+            @branch = branch
+            @commit = commit
+            @task_id = task_id
+            @bare = bare
+            @detached = detached
+            @created_at = created_at
+          end
+
+          # Check if the worktree is associated with a task
+          #
+          # @return [Boolean] true if task_id is present
+          def task_associated?
+            !@task_id.nil? && !@task_id.empty?
+          end
+
+          # Check if the worktree is in a usable state
+          #
+          # @return [Boolean] true if worktree is not bare or detached
+          def usable?
+            !@bare && !@detached
+          end
+
+          # Get the worktree directory name
+          #
+          # @return [String] Directory name (basename of path)
+          def directory_name
+            File.basename(@path)
+          end
+
+          # Check if the worktree directory exists
+          #
+          # @return [Boolean] true if directory exists
+          def exists?
+            File.directory?(@path)
+          end
+
+          # Check if the worktree directory is empty
+          #
+          # @return [Boolean] true if directory is empty
+          def empty?
+            return true unless exists?
+
+            Dir.empty?(@path)
+          end
+
+          # Get a human-readable description
+          #
+          # @return [String] Human-readable description
+          def description
+            if task_associated?
+              "Task #{@task_id}: #{@branch} at #{@path}"
+            else
+              "#{@branch || @commit[0, 8]} at #{@path}"
+            end
+          end
+
+          # Parse git worktree list output line
+          #
+          # @param line [String] Output line from `git worktree list`
+          # @return [WorktreeInfo, nil] Parsed worktree info or nil if parsing failed
+          #
+          # @example
+          #   WorktreeInfo.from_git_output("/path/to/worktree abc123 [branch-name]")
+          #   WorktreeInfo.from_git_output("/path/to/worktree abc123 (detached HEAD)")
+          def self.from_git_output(line)
+            return nil if line.nil? || line.strip.empty?
+
+            # Git worktree list format:
+            # /path/to/worktree abc123 [branch-name]
+            # /path/to/worktree abc123 (detached HEAD)
+            # /path/to/worktree abc123 + [branch-name]  (worktree has changes)
+
+            parts = line.strip.split(/\s+/, 3)
+            return nil if parts.length < 2
+
+            path = parts[0]
+            commit = parts[1]
+            branch = nil
+            bare = false
+            detached = false
+
+            # Parse the third part if present
+            if parts.length >= 3
+              third_part = parts[2]
+
+              if third_part.include?("[") && third_part.include?("]")
+                # Branch worktree: [branch-name]
+                branch_match = third_part.match(/\[([^\]]+)\]/)
+                branch = branch_match[1] if branch_match
+                bare = third_part.include?("bare")
+              elsif third_part.include?("detached HEAD")
+                # Detached HEAD worktree
+                detached = true
+              end
+            end
+
+            # Try to extract task ID from path or branch
+            task_id = extract_task_id(path, branch)
+
+            new(
+              path: path,
+              branch: branch,
+              commit: commit,
+              task_id: task_id,
+              bare: bare,
+              detached: detached
+            )
+          end
+
+          # Parse multiple lines from git worktree list output
+          #
+          # @param output [String] Full output from `git worktree list --porcelain`
+          # @return [Array<WorktreeInfo>] Array of parsed worktree info
+          #
+          # @example
+          #   worktrees = WorktreeInfo.from_git_output_list(`git worktree list --porcelain`)
+          def self.from_git_output_list(output)
+            return [] if output.nil? || output.empty?
+
+            # Split by blank lines to get per-worktree blocks
+            blocks = output.strip.split(/\n\n+/)
+            worktrees = []
+
+            blocks.each do |block|
+              lines = block.strip.split("\n").map(&:strip)
+              next unless lines.first&.start_with?("worktree ")
+
+              path = lines.first.sub(/^worktree\s+/, "")
+              commit = nil
+              branch = nil
+              detached = false
+              bare = false
+
+              lines[1..].each do |line|
+                if line.start_with?("HEAD ")
+                  commit = line.sub(/^HEAD\s+/, "")
+                elsif line.start_with?("branch ")
+                  branch_ref = line.sub(/^branch\s+/, "")
+                  if branch_ref.start_with?("refs/heads/")
+                    branch = branch_ref.sub(/^refs\/heads\//, "")
+                  end
+                elsif line == "detached"
+                  detached = true
+                elsif line == "bare"
+                  bare = true
+                end
+                # skip: locked, prunable, empty lines
+              end
+
+              # Detached if no branch line was found and not bare
+              detached = true if branch.nil? && !bare && commit
+
+              task_id = extract_task_id(path, branch)
+              worktrees << new(path: path, branch: branch, commit: commit,
+                task_id: task_id, bare: bare, detached: detached)
+            end
+
+            worktrees
+          end
+
+          # Find worktree info by task ID
+          #
+          # @param worktrees [Array<WorktreeInfo>] List of worktree info
+          # @param task_id [String] Task ID to search for
+          # @return [WorktreeInfo, nil] Matching worktree info or nil
+          def self.find_by_task_id(worktrees, task_id)
+            worktrees.find { |worktree| worktree.task_id == task_id.to_s }
+          end
+
+          # Find worktree info by directory name
+          #
+          # @param worktrees [Array<WorktreeInfo>] List of worktree info
+          # @param directory [String] Directory name to search for
+          # @return [WorktreeInfo, nil] Matching worktree info or nil
+          def self.find_by_directory(worktrees, directory)
+            worktrees.find { |worktree| worktree.directory_name == directory.to_s }
+          end
+
+          # Find worktree info by branch name
+          #
+          # @param worktrees [Array<WorktreeInfo>] List of worktree info
+          # @param branch [String] Branch name to search for
+          # @return [WorktreeInfo, nil] Matching worktree info or nil
+          def self.find_by_branch(worktrees, branch)
+            worktrees.find { |worktree| worktree.branch == branch.to_s }
+          end
+
+          # Convert to hash
+          #
+          # @return [Hash] Worktree info as hash
+          def to_h
+            {
+              path: @path,
+              branch: @branch,
+              commit: @commit,
+              task_id: @task_id,
+              bare: @bare,
+              detached: @detached,
+              created_at: @created_at,
+              usable: usable?,
+              task_associated: task_associated?,
+              exists: exists?,
+              empty: empty?
+            }
+          end
+
+          # Convert to JSON
+          #
+          # @return [String] JSON representation
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+
+          # Equality comparison
+          #
+          # @param other [WorktreeInfo] Other worktree info
+          # @return [Boolean] true if equal
+          def ==(other)
+            return false unless other.is_a?(WorktreeInfo)
+
+            @path == other.path &&
+              @branch == other.branch &&
+              @commit == other.commit &&
+              @task_id == other.task_id
+          end
+
+          alias_method :eql?, :==
+
+          # Hash for using as hash keys
+          #
+          # @return [Integer] Hash value
+          def hash
+            [@path, @branch, @commit, @task_id].hash
+          end
+
+          private
+
+          # Extract task ID from path or branch name
+          #
+          # @param path [String] Worktree path
+          # @param branch [String, nil] Branch name
+          # @return [String, nil] Extracted task ID or nil
+          def self.extract_task_id(path, branch)
+            # Try to extract from path first (e.g., task.081, 081-work)
+            path_task_id = extract_task_id_from_string(File.basename(path))
+            return path_task_id if path_task_id
+
+            # Try to extract from branch name (e.g., 081-fix-something)
+            extract_task_id_from_string(branch)
+          end
+
+          # Extract task ID from a string using common patterns
+          #
+          # @param string [String, nil] String to search
+          # @return [String, nil] Extracted task ID or nil (preserves subtask IDs like "121.01")
+          def self.extract_task_id_from_string(string)
+            return nil if string.nil? || string.empty?
+
+            # Use shared extractor that preserves subtask IDs (e.g., "121.01")
+            Atoms::TaskIDExtractor.normalize(string)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Worktree
+      module Models
+        # Worktree metadata model for task frontmatter
+        #
+        # Represents worktree information that gets added to task frontmatter
+        # to track the association between tasks and their worktrees.
+        #
+        # @example Create for a new worktree
+        #   metadata = WorktreeMetadata.new(
+        #     branch: "081-fix-authentication-bug",
+        #     path: ".ace-wt/task.081",
+        #     created_at: Time.now
+        #   )
+        #
+        # @example Load from task frontmatter
+        #   metadata = WorktreeMetadata.from_task_data(task_frontmatter_hash)
+        class WorktreeMetadata
+          attr_reader :branch, :path, :target_branch, :created_at, :updated_at
+
+          # Initialize a new WorktreeMetadata
+          #
+          # @param branch [String] Git branch name
+          # @param path [String] Worktree path (relative to project root)
+          # @param target_branch [String, nil] PR target branch (default: nil for main)
+          # @param created_at [Time] When the worktree was created
+          # @param updated_at [Time] When the worktree was last updated
+          def initialize(branch:, path:, target_branch: nil, created_at: Time.now, updated_at: Time.now)
+            @branch = branch.to_s
+            @path = path.to_s
+            @target_branch = target_branch&.to_s
+            @created_at = created_at.is_a?(Time) ? created_at : Time.parse(created_at.to_s)
+            @updated_at = updated_at.is_a?(Time) ? updated_at : Time.parse(updated_at.to_s)
+          end
+
+          # Update the metadata with new information
+          #
+          # @param branch [String, nil] New branch name
+          # @param path [String, nil] New path
+          # @return [WorktreeMetadata] Updated metadata
+          def update(branch: nil, path: nil)
+            WorktreeMetadata.new(
+              branch: branch || @branch,
+              path: path || @path,
+              target_branch: @target_branch,
+              created_at: @created_at,
+              updated_at: Time.now
+            )
+          end
+
+          # Check if the worktree is recent (created within last 7 days)
+          #
+          # @return [Boolean] true if worktree is recent
+          def recent?
+            @created_at > (Time.now - 7 * 24 * 60 * 60)
+          end
+
+          # Check if the worktree is stale (not updated in last 30 days)
+          #
+          # @return [Boolean] true if worktree is stale
+          def stale?
+            @updated_at < (Time.now - 30 * 24 * 60 * 60)
+          end
+
+          # Get the age of the worktree in days
+          #
+          # @return [Float] Age in days
+          def age_days
+            (Time.now - @created_at) / (24 * 60 * 60)
+          end
+
+          # Get the time since last update in days
+          #
+          # @return [Float] Days since last update
+          def days_since_update
+            (Time.now - @updated_at) / (24 * 60 * 60)
+          end
+
+          # Convert to hash for YAML serialization
+          #
+          # @return [Hash] Hash representation
+          def to_h
+            {
+              "branch" => @branch,
+              "path" => @path,
+              "created_at" => @created_at.strftime("%Y-%m-%d %H:%M:%S"),
+              "updated_at" => @updated_at.strftime("%Y-%m-%d %H:%M:%S")
+            }.tap do |hash|
+              hash["target_branch"] = @target_branch if @target_branch
+            end
+          end
+
+          # Convert to YAML string
+          #
+          # @return [String] YAML representation
+          def to_yaml
+            to_h.to_yaml
+          end
+
+          # Load from task frontmatter hash
+          #
+          # @param task_data [Hash] Task frontmatter data
+          # @return [WorktreeMetadata, nil] Worktree metadata or nil if not found
+          #
+          # @example
+          #   metadata = WorktreeMetadata.from_task_data({
+          #     "worktree" => {
+          #       "branch" => "081-fix-auth",
+          #       "path" => ".ace-wt/task.081",
+          #       "target_branch" => "080-parent-branch",
+          #       "created_at" => "2025-11-04 13:45:00"
+          #     }
+          #   })
+          def self.from_task_data(task_data)
+            worktree_data = task_data["worktree"]
+            return nil unless worktree_data.is_a?(Hash)
+
+            branch = worktree_data["branch"]
+            path = worktree_data["path"]
+            target_branch = worktree_data["target_branch"]
+            return nil unless branch && path
+
+            created_at = parse_time(worktree_data["created_at"]) || Time.now
+            updated_at = parse_time(worktree_data["updated_at"]) || created_at
+
+            new(
+              branch: branch,
+              path: path,
+              target_branch: target_branch,
+              created_at: created_at,
+              updated_at: updated_at
+            )
+          end
+
+          # Create from a worktree info object
+          #
+          # @param worktree_info [WorktreeInfo] Worktree information
+          # @param project_root [String] Project root directory
+          # @return [WorktreeMetadata] Worktree metadata
+          #
+          # @example
+          #   metadata = WorktreeMetadata.from_worktree_info(worktree_info, "/project")
+          def self.from_worktree_info(worktree_info, project_root = Dir.pwd)
+            require_relative "../atoms/path_expander"
+
+            # Make path relative to project root
+            relative_path = begin
+              Atoms::PathExpander.relative_to_git_root(worktree_info.path, project_root)
+            rescue
+              worktree_info.path
+            end
+
+            new(
+              branch: worktree_info.branch,
+              path: relative_path,
+              created_at: worktree_info.created_at || Time.now
+            )
+          end
+
+          # Merge worktree metadata into task frontmatter
+          #
+          # @param task_data [Hash] Existing task frontmatter
+          # @param worktree_metadata [WorktreeMetadata] Worktree metadata to merge
+          # @return [Hash] Updated task frontmatter
+          #
+          # @example
+          #   updated_data = WorktreeMetadata.merge_into_task_data(
+          #     existing_task_data,
+          #     worktree_metadata
+          #   )
+          def self.merge_into_task_data(task_data, worktree_metadata)
+            updated_data = task_data.dup
+            updated_data["worktree"] = worktree_metadata.to_h
+            updated_data
+          end
+
+          # Remove worktree metadata from task frontmatter
+          #
+          # @param task_data [Hash] Task frontmatter
+          # @return [Hash] Task frontmatter without worktree metadata
+          #
+          # @example
+          #   clean_data = WorktreeMetadata.remove_from_task_data(task_data)
+          def self.remove_from_task_data(task_data)
+            updated_data = task_data.dup
+            updated_data.delete("worktree")
+            updated_data
+          end
+
+          # Check if task has worktree metadata
+          #
+          # @param task_data [Hash] Task frontmatter
+          # @return [Boolean] true if worktree metadata is present
+          #
+          # @example
+          #   has_worktree = WorktreeMetadata.present_in_task?(task_data)
+          def self.present_in_task?(task_data)
+            worktree_data = task_data["worktree"]
+            worktree_data.is_a?(Hash) &&
+              worktree_data["branch"] &&
+              worktree_data["path"]
+          end
+
+          # Find worktree metadata by branch name
+          #
+          # @param tasks [Array<Hash>] Array of task frontmatter hashes
+          # @param branch [String] Branch name to search for
+          # @return [WorktreeMetadata, nil] Matching metadata or nil
+          #
+          # @example
+          #   metadata = WorktreeMetadata.find_by_branch(tasks, "081-fix-auth")
+          def self.find_by_branch(tasks, branch)
+            tasks.each do |task_data|
+              metadata = from_task_data(task_data)
+              return metadata if metadata && metadata.branch == branch
+            end
+            nil
+          end
+
+          # Find worktree metadata by path
+          #
+          # @param tasks [Array<Hash>] Array of task frontmatter hashes
+          # @param path [String] Path to search for
+          # @return [WorktreeMetadata, nil] Matching metadata or nil
+          #
+          # @example
+          #   metadata = WorktreeMetadata.find_by_path(tasks, ".ace-wt/task.081")
+          def self.find_by_path(tasks, path)
+            tasks.each do |task_data|
+              metadata = from_task_data(task_data)
+              return metadata if metadata && metadata.path == path
+            end
+            nil
+          end
+
+          # Equality comparison
+          #
+          # @param other [WorktreeMetadata] Other worktree metadata
+          # @return [Boolean] true if equal
+          def ==(other)
+            return false unless other.is_a?(WorktreeMetadata)
+
+            @branch == other.branch && @path == other.path
+          end
+
+          alias_method :eql?, :==
+
+          # Hash for using as hash keys
+          #
+          # @return [Integer] Hash value
+          def hash
+            [@branch, @path].hash
+          end
+
+          # String representation
+          #
+          # @return [String] String representation
+          def to_s
+            "#{@branch} at #{@path}"
+          end
+
+          # Inspect representation
+          #
+          # @return [String] Detailed inspect string
+          def inspect
+            "#<#{self.class.name} branch=#{@branch.inspect} path=#{@path.inspect} created=#{@created_at}>"
+          end
+
+          private
+
+          # Parse time from various formats
+          #
+          # @param time_input [String, Time, nil] Time input
+          # @return [Time, nil] Parsed time or nil
+          def self.parse_time(time_input)
+            return nil if time_input.nil?
+
+            case time_input
+            when Time
+              time_input
+            when String
+              Time.parse(time_input)
+            end
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+    end
+  end
+end