ace-git-worktree 0.21.8 → 0.22.0

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

@@ -106,6 +106,7 @@ module Ace
                   --no-push               Skip pushing task changes to remote (task mode only)
                   --no-upstream           Skip pushing worktree branch with upstream tracking (task mode only)
                   --no-pr                 Skip creating draft PR (task mode only)
+                  --no-bootstrap          Skip worktree bootstrap preparation
                   --push-remote <name>    Remote to push to (default: origin) (task mode only)
                   --no-auto-navigate      Stay in current directory (default: navigate to worktree)
                   --commit-message <msg>  Custom commit message for task updates (task mode only)
@@ -173,6 +174,7 @@ module Ace
               no_push: false,
               no_upstream: false,
               no_pr: false,
+              no_bootstrap: false,
               push_remote: nil,
               no_auto_navigate: false,
               commit_message: nil,
@@ -213,6 +215,8 @@ module Ace
                 options[:no_upstream] = true
               when "--no-pr"
                 options[:no_pr] = true
+              when "--no-bootstrap"
+                options[:no_bootstrap] = true
               when "--push-remote"
                 i += 1
                 options[:push_remote] = args[i]
@@ -367,6 +371,7 @@ module Ace
               no_push: options[:no_push],
               no_upstream: options[:no_upstream],
               no_pr: options[:no_pr],
+              no_bootstrap: options[:no_bootstrap],
               push_remote: options[:push_remote],
               commit_message: options[:commit_message],
               target_branch: options[:target_branch],

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

@@ -61,6 +61,13 @@ module Ace
               "on_merge" => false,
               "on_delete" => true
             },
+            "bootstrap" => {
+              "command" => nil,
+              "working_dir" => ".",
+              "timeout" => 60,
+              "policy" => "required",
+              "env" => {}
+            },
             "hooks" => {
               "after_create" => []
             }
@@ -69,7 +76,7 @@ module Ace
           # Configuration namespace paths
           CONFIG_NAMESPACE = ["git", "worktree"].freeze
 
-          attr_reader :root_path, :auto_navigate, :tmux, :mise_trust_auto, :task_config, :pr_config, :branch_config, :cleanup_config, :hooks_config
+          attr_reader :root_path, :auto_navigate, :tmux, :mise_trust_auto, :task_config, :pr_config, :branch_config, :cleanup_config, :bootstrap_config, :hooks_config
 
           # Initialize a new WorktreeConfig
           #
@@ -370,11 +377,27 @@ module Ace
               auto_navigate: auto_navigate?,
               mise_trust_auto: mise_trust_auto?,
               task: @task_config.dup,
+              bootstrap: @bootstrap_config.dup,
               cleanup: @cleanup_config.dup,
               hooks: @hooks_config.dup
             }
           end
 
+          # Get bootstrap configuration
+          #
+          # @return [Hash] Bootstrap configuration hash
+          def bootstrap
+            @bootstrap_config
+          end
+
+          # Check if bootstrap is configured with a command
+          #
+          # @return [Boolean] true if bootstrap command is set
+          def bootstrap_configured?
+            cmd = @bootstrap_config["command"]
+            !cmd.nil? && !cmd.to_s.strip.empty?
+          end
+
           private
 
           # Find invalid template variables in a template string
@@ -397,8 +420,14 @@ module Ace
           # @param config_hash [Hash] Full configuration hash
           # @return [Hash] Worktree-specific configuration
           def extract_worktree_config(config_hash)
-            CONFIG_NAMESPACE.reduce(config_hash) do |current, key|
-              current&.dig(key) || {}
+            return {} unless config_hash.is_a?(Hash)
+
+            if config_hash.key?("git")
+              config_hash.dig("git", "worktree") || config_hash
+            elsif config_hash.key?("worktree")
+              config_hash.dig("worktree") || config_hash
+            else
+              config_hash
             end
           end
 
@@ -435,6 +464,7 @@ module Ace
             @pr_config = @merged_config["pr"] || {}
             @branch_config = @merged_config["branch"] || {}
             @cleanup_config = @merged_config["cleanup"] || {}
+            @bootstrap_config = @merged_config["bootstrap"] || {}
             @hooks_config = @merged_config["hooks"] || {}
           end
 

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Molecule for executing worktree preparation bootstrap phase
+        class BootstrapExecutor
+          # Initialize BootstrapExecutor
+          #
+          # @param project_root [String] Project root path
+          # @param worktree_path [String] Target worktree path
+          # @param bootstrap_config [Hash] Resolved bootstrap policy configuration
+          # @param no_bootstrap [Boolean] Whether bootstrap was explicitly skipped
+          def initialize(project_root: Dir.pwd, worktree_path: nil, bootstrap_config: nil, no_bootstrap: false)
+            @project_root = project_root
+            @worktree_path = worktree_path || project_root
+            @config = bootstrap_config || {}
+            @no_bootstrap = no_bootstrap
+          end
+
+          # Execute or skip bootstrap phase
+          #
+          # @return [Hash] Phase ledger item
+          def run
+            policy = @config["policy"] || "required"
+
+            if @no_bootstrap
+              return {
+                phase: "bootstrap",
+                policy: policy,
+                status: "skipped",
+                command: nil,
+                duration: 0.0
+              }
+            end
+
+            command = @config["command"]
+            if command.nil? || command.to_s.strip.empty?
+              return {
+                phase: "bootstrap",
+                policy: policy,
+                status: "not_configured",
+                command: nil,
+                duration: 0.0
+              }
+            end
+
+            working_dir = @config["working_dir"] || "."
+            target_dir = File.expand_path(working_dir, @worktree_path)
+            timeout_sec = (@config["timeout"] || 60).to_i
+            env_vars = (@config["env"] || {}).transform_keys(&:to_s).transform_values(&:to_s)
+
+            start_time = Time.now
+            output = ""
+            exit_code = 1
+
+            begin
+              Timeout.timeout(timeout_sec) do
+                stdout, stderr, proc_status = Open3.capture3(env_vars, command, chdir: target_dir)
+                output = "#{stdout}\n#{stderr}".strip
+                exit_code = proc_status.exitstatus || (proc_status.success? ? 0 : 1)
+              end
+              if exit_code == 0
+                status = "succeeded"
+              else
+                status = (policy == "advisory") ? "advisory_failed" : "required_failed"
+              end
+            rescue Timeout::Error
+              output = "Execution timed out after #{timeout_sec}s"
+              exit_code = 124
+              status = (policy == "advisory") ? "advisory_failed" : "required_failed"
+            rescue => e
+              output = "Execution error: #{e.message}"
+              exit_code = 1
+              status = (policy == "advisory") ? "advisory_failed" : "required_failed"
+            end
+
+            duration = (Time.now - start_time).round(3)
+
+            {
+              phase: "bootstrap",
+              policy: policy,
+              status: status,
+              command: command,
+              working_dir: working_dir,
+              exit_code: exit_code,
+              output: output,
+              duration: duration
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Applies a reviewed worktree cleanup plan with strict drift guards.
+        class CleanupApplier
+          # @param report [Hash] The reconstructed cleanup report
+          # @param approved_digest [String] The approved plan digest
+          def initialize(report, approved_digest)
+            @report = report
+            @approved_digest = approved_digest
+            @ledger = []
+          end
+
+          # Execute the cleanup plan
+          # @return [Hash] Application result including the ledger and final strict rescan status
+          def apply
+            if @report[:plan_digest] != @approved_digest
+              return error_result("Digest mismatch. The repository state has drifted since approval. Expected: #{@approved_digest}, Got: #{@report[:plan_digest]}. Please review the new report.")
+            end
+
+            actions = @report[:actions]
+            return success_result if actions.empty?
+
+            # Fixed order execution: worktrees, local refs, remote refs
+            worktree_actions = actions.select { |a| a[:type] == "remove_worktree" }
+            local_ref_actions = actions.select { |a| a[:type] == "delete_local_ref" }
+            remote_ref_actions = actions.select { |a| a[:type] == "delete_remote_ref" }
+
+            failed = false
+
+            worktree_actions.each do |action|
+              next if failed
+              failed = !execute_worktree_removal(action)
+            end
+
+            local_ref_actions.each do |action|
+              next if failed
+              failed = !execute_local_ref_deletion(action)
+            end
+
+            remote_ref_actions.each do |action|
+              next if failed
+              failed = !execute_remote_ref_deletion(action)
+            end
+
+            if failed
+              {
+                success: false,
+                error: "Cleanup partially failed. See ledger for details.",
+                ledger: @ledger,
+                partial_failure: true
+              }
+            else
+              success_result
+            end
+          end
+
+          private
+
+          def success_result
+            {
+              success: true,
+              ledger: @ledger,
+              partial_failure: false
+            }
+          end
+
+          def error_result(message)
+            {
+              success: false,
+              error: message,
+              ledger: @ledger,
+              partial_failure: false
+            }
+          end
+
+          def record_ledger(action, success, error = nil)
+            @ledger << {
+              action: action,
+              success: success,
+              error: error
+            }
+            success
+          end
+
+          # --- Action Execution ---
+
+          def execute_worktree_removal(action)
+            path = action[:target]
+            expected_sha = action[:sha]
+
+            # Re-verify path safety (Trash adapter logic)
+            unless safe_trash_path?(path)
+              return record_ledger(action, false, "Unsafe worktree path: #{path}")
+            end
+
+            # Immediate drift guard: dirty check
+            dirty_result = dirty_state(path)
+            if dirty_result.nil?
+              return record_ledger(action, false, "Worktree path not found or not a git directory")
+            elsif !dirty_result.values.all?(&:empty?)
+              return record_ledger(action, false, "Worktree became dirty since report")
+            end
+
+            # Immediate drift guard: sha check
+            current_sha = resolve_worktree_head(path)
+            if current_sha != expected_sha
+              return record_ledger(action, false, "Worktree HEAD changed (expected #{expected_sha}, got #{current_sha})")
+            end
+
+            # Execute removal
+            _out, _err, status = Open3.capture3("git", "worktree", "remove", "--force", path)
+            unless status.success?
+              return record_ledger(action, false, "git worktree remove failed")
+            end
+
+            record_ledger(action, true)
+          end
+
+          def execute_local_ref_deletion(action)
+            ref = action[:target]
+            expected_sha = action[:sha]
+
+            # Immediate drift guard: check current SHA
+            current_sha = resolve_local_ref(ref)
+            if current_sha.nil?
+              # Already gone, consider it a success but note it
+              return record_ledger(action, true, "Ref was already deleted")
+            elsif current_sha != expected_sha
+              return record_ledger(action, false, "Ref SHA changed (expected #{expected_sha}, got #{current_sha})")
+            end
+
+            # Execute deletion
+            _out, _err, status = Open3.capture3("git", "branch", "-D", ref)
+            unless status.success?
+              return record_ledger(action, false, "git branch -D failed")
+            end
+
+            record_ledger(action, true)
+          end
+
+          def execute_remote_ref_deletion(action)
+            ref = action[:target] # e.g. origin/feature -> we need remote and branch
+            expected_sha = action[:sha]
+            
+            # Action target for remote refs is typically "origin/feature"
+            parts = ref.split("/", 2)
+            remote = parts[0]
+            branch = parts[1]
+            
+            # The exact lease will prevent deletion if remote ref has advanced
+            # git push <remote> --delete <branch> --force-with-lease=<branch>:<expected_sha>
+            cmd = ["git", "push", remote, "--delete", branch, "--force-with-lease=#{branch}:#{expected_sha}"]
+            _out, _err, status = Open3.capture3(*cmd)
+            
+            unless status.success?
+              return record_ledger(action, false, "Remote push --delete with lease failed")
+            end
+            
+            record_ledger(action, true)
+          end
+
+          # --- Guards and Helpers ---
+
+          def safe_trash_path?(path)
+            # Rejects root, home, etc. 
+            # In a real app this would delegate to a Trash adapter, but we validate safety here.
+            abs_path = File.expand_path(path)
+            return false if abs_path == "/"
+            return false if abs_path == File.expand_path("~")
+            
+            # Must be within a project or temp space conceptually, but strictly we just need it to be a valid git dir
+            # that is not the main repository.
+            # We already have @report[:repository] (common_dir)
+            common_dir = File.expand_path(@report[:repository])
+            return false if abs_path == File.expand_path(File.dirname(common_dir))
+            
+            true
+          end
+
+          def dirty_state(path)
+            return nil unless File.directory?(path)
+            out, status = Open3.capture2("git", "-C", path, "status", "--porcelain")
+            return nil unless status.success?
+            
+            lines = out.lines.map(&:chomp).reject(&:empty?)
+            staged = []
+            unstaged = []
+            untracked = []
+
+            lines.each do |line|
+              xy = line[0..1]
+              if xy[0] == "?"
+                untracked << line[3..]
+              elsif xy[0] != " "
+                staged << line[3..]
+              end
+              if xy[1] != " " && xy[1] != "?"
+                unstaged << line[3..]
+              end
+            end
+
+            {staged: staged, unstaged: unstaged, untracked: untracked}
+          end
+
+          def resolve_worktree_head(path)
+            out, status = Open3.capture2("git", "-C", path, "rev-parse", "HEAD")
+            status.success? ? out.strip : nil
+          end
+          
+          def resolve_local_ref(ref)
+            out, status = Open3.capture2("git", "rev-parse", "--verify", "refs/heads/#{ref}^{commit}")
+            status.success? ? out.strip : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "ace/git/molecules/pr_metadata_fetcher"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Resolves PR evidence for candidate branches to prove safe squash-merge cleanup.
+        class CleanupPrResolver
+          def initialize(target:, target_sha:, offline: false)
+            @target = target
+            @target_sha = target_sha
+            @offline = offline
+            
+            # Cache gh availability to avoid repeated checks
+            @gh_available = Ace::Git::Molecules::PrMetadataFetcher.gh_installed? && 
+                            Ace::Git::Molecules::PrMetadataFetcher.gh_authenticated?
+          end
+
+          # Classify a candidate branch with GitHub PR evidence.
+          #
+          # @param branch [String] The branch name (e.g. "feature")
+          # @param candidate_sha [String] The commit SHA of the candidate
+          # @return [Hash] Proof classification result
+          def classify(branch, candidate_sha)
+            return offline_result unless @gh_available && !@offline
+
+            prs = fetch_merged_prs_for_branch(branch)
+            return unproven_result if prs.nil? || prs.empty?
+
+            # Find a PR that targets the configured base and is actually reachable
+            valid_pr = prs.find do |pr|
+              pr["baseRefName"] == @target && 
+              pr["state"] == "MERGED" && 
+              pr["mergeCommit"] && 
+              pr["mergeCommit"]["oid"] &&
+              ancestor?(pr["mergeCommit"]["oid"], @target_sha)
+            end
+
+            return ambiguous_result(prs) if prs.length > 1 && !valid_pr
+            return unproven_result unless valid_pr
+
+            merge_commit_sha = valid_pr["mergeCommit"]["oid"]
+            pr_head_sha = valid_pr["headRefOid"]
+
+            if candidate_sha == pr_head_sha
+              {
+                proof: "exact_merged_pr_head",
+                pr: valid_pr["number"],
+                candidate_head: candidate_sha,
+                merged_head: pr_head_sha,
+                merge_commit: merge_commit_sha,
+                target_reachable: true,
+                path_type_mode_match: true,
+                provider_status: "available",
+                action: "remove"
+              }
+            elsif patch_equivalent?(candidate_sha, merge_commit_sha)
+              {
+                proof: "stable_patch_equivalence",
+                pr: valid_pr["number"],
+                candidate_head: candidate_sha,
+                merged_head: pr_head_sha,
+                merge_commit: merge_commit_sha,
+                target_reachable: true,
+                path_type_mode_match: true,
+                provider_status: "available",
+                action: "remove"
+              }
+            else
+              {
+                proof: "none",
+                pr: valid_pr["number"],
+                candidate_head: candidate_sha,
+                merged_head: pr_head_sha,
+                merge_commit: merge_commit_sha,
+                target_reachable: true,
+                path_type_mode_match: false,
+                provider_status: "available",
+                action: "retain",
+                retention_reason: "patch_mismatch"
+              }
+            end
+          rescue Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError, Ace::Git::TimeoutError
+            # Provider failure degradation
+            offline_result("unavailable")
+          end
+
+          private
+
+          def fetch_merged_prs_for_branch(branch)
+            # Use `gh pr list --head <branch> --state merged` to find the exact PR
+            cmd = [
+              "gh", "pr", "list", "--state", "merged", "--head", branch,
+              "--json", "number,state,headRefOid,mergeCommit,baseRefName"
+            ]
+            
+            # Using Open3 directly to avoid circular dependencies if we don't want to augment ace-git too heavily for just this
+            # but we can rely on LC_ALL=C for safety.
+            env = {"LC_ALL" => "C"}
+            out, err, status = Open3.capture3(env, *cmd)
+            
+            return nil unless status.success?
+            
+            JSON.parse(out)
+          rescue JSON::ParserError, Errno::ENOENT
+            nil
+          end
+
+          def ancestor?(candidate, target)
+            out, status = Open3.capture2("git", "merge-base", "--is-ancestor", candidate, target)
+            status.success?
+          end
+
+          def patch_equivalent?(candidate_sha, merge_commit_sha)
+            # 1. Candidate patch inventory
+            # We want the diff between the candidate's merge-base with target, and the candidate itself
+            base, status = Open3.capture2("git", "merge-base", candidate_sha, @target_sha)
+            return false unless status.success?
+            base = base.strip
+            
+            # Candidate inventory: path, type, mode changes
+            cand_inv = tree_diff_inventory(base, candidate_sha)
+            return false unless cand_inv
+
+            # 2. Merged commit patch inventory
+            # We want the diff between the merge commit's first parent, and the merge commit itself
+            mc_inv = tree_diff_inventory("#{merge_commit_sha}^1", merge_commit_sha)
+            return false unless mc_inv
+
+            cand_inv == mc_inv
+          end
+
+          def tree_diff_inventory(tree_a, tree_b)
+            # git diff-tree -r --name-status or raw mode
+            # using raw mode to get exact mode and type
+            # :100644 100644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 0000000000000000000000000000000000000000 M  file
+            out, status = Open3.capture2("git", "diff-tree", "-r", "--no-commit-id", tree_a, tree_b)
+            return nil unless status.success?
+
+            inventory = {}
+            out.each_line do |line|
+              # Format: :src_mode dst_mode src_sha dst_sha status\tpath
+              parts = line.strip.split("\t", 2)
+              meta = parts[0].split(" ")
+              path = parts[1]
+              
+              dst_mode = meta[1]
+              dst_sha = meta[3]
+              status_char = meta[4]
+              
+              inventory[path] = {
+                mode: dst_mode,
+                sha: dst_sha,
+                status: status_char[0] # handle R100 etc by taking first char
+              }
+            end
+            
+            inventory
+          end
+
+          def offline_result(status = "offline")
+            {
+              proof: "none",
+              pr: nil,
+              candidate_head: nil,
+              merged_head: nil,
+              merge_commit: nil,
+              target_reachable: "unknown",
+              path_type_mode_match: "unknown",
+              provider_status: status,
+              action: "retain",
+              retention_reason: "ancestry_unproven"
+            }
+          end
+
+          def unproven_result
+            {
+              proof: "none",
+              pr: nil,
+              candidate_head: nil,
+              merged_head: nil,
+              merge_commit: nil,
+              target_reachable: "unknown",
+              path_type_mode_match: "unknown",
+              provider_status: "available",
+              action: "retain",
+              retention_reason: "ancestry_unproven"
+            }
+          end
+
+          def ambiguous_result(prs)
+            {
+              proof: "none",
+              pr: nil,
+              candidate_head: nil,
+              merged_head: nil,
+              merge_commit: nil,
+              target_reachable: "unknown",
+              path_type_mode_match: "unknown",
+              provider_status: "ambiguous",
+              action: "retain",
+              retention_reason: "ambiguous_prs"
+            }
+          end
+        end
+      end
+    end
+  end
+end