ace-git-worktree 0.19.0

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "ace/support/config"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Configuration loader molecule
+        #
+        # Loads and merges worktree configuration using ace-config cascade system.
+        # Handles configuration validation and provides access to merged configuration.
+        #
+        # @example Load configuration for current project
+        #   loader = ConfigLoader.new(Dir.pwd)
+        #   config = loader.load
+        #
+        # @example Load with custom project root
+        #   loader = ConfigLoader.new("/path/to/project")
+        #   config = loader.load
+        class ConfigLoader
+          # Initialize a new ConfigLoader
+          #
+          # @param project_root [String] Project root directory
+          def initialize(project_root = Dir.pwd)
+            @project_root = project_root
+          end
+
+          # Load and merge worktree configuration
+          #
+          # @return [WorktreeConfig] Loaded and validated configuration
+          #
+          # @example
+          #   loader = ConfigLoader.new
+          #   config = loader.load
+          #   config.root_path # => ".ace-wt"
+          #   config.mise_trust_auto? # => true
+          def load
+            # Load configuration using ace-config cascade
+            config_hash = load_config
+
+            # Create configuration object
+            config = Models::WorktreeConfig.new(config_hash, @project_root)
+
+            # Validate configuration
+            validate_config(config)
+
+            config
+          end
+
+          # Load configuration without validation (for testing)
+          #
+          # @return [WorktreeConfig] Configuration without validation
+          def load_without_validation
+            config_hash = load_config
+            Models::WorktreeConfig.new(config_hash, @project_root)
+          end
+
+          # Check if configuration exists
+          #
+          # @return [Boolean] true if configuration files exist
+          def config_exists?
+            # Check for configuration files in expected locations
+            config_files.each.any? { |file| File.exist?(file) }
+          end
+
+          # Get list of configuration files that would be checked
+          #
+          # @return [Array<String>] List of configuration file paths
+          def config_files
+            [
+              File.join(@project_root, ".ace", "git", "worktree.yml"),
+              File.join(@project_root, ".ace-defaults", "git", "worktree.yml"),
+              File.expand_path("~/.ace/git/worktree.yml")
+            ]
+          end
+
+          # Reset configuration cache
+          def reset_cache!
+            @config_hash = nil
+          end
+
+          private
+
+          # Load configuration using ace-config cascade
+          #
+          # @return [Hash] Configuration hash from ace-config
+          def load_config
+            return @config_hash if @config_hash
+
+            gem_root = Gem.loaded_specs["ace-git-worktree"]&.gem_dir ||
+              File.expand_path("../../../../..", __dir__)
+
+            resolver = Ace::Support::Config.create(
+              config_dir: ".ace",
+              defaults_dir: ".ace-defaults",
+              gem_path: gem_root
+            )
+
+            # Resolve config for git/worktree namespace
+            config = resolver.resolve_namespace("git", filename: "worktree")
+
+            @config_hash = config.data
+          rescue => e
+            warn "Warning: Error loading worktree configuration: #{e.message}"
+            @config_hash = {}
+          end
+
+          # Validate loaded configuration
+          #
+          # @param config [WorktreeConfig] Configuration to validate
+          # @raise [ArgumentError] If configuration is invalid
+          def validate_config(config)
+            errors = config.validate
+
+            if errors.any?
+              raise ArgumentError, "Invalid worktree configuration:\n#{errors.map { |e| "  - #{e}" }.join("\n")}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Creates and manages the _current symlink pointing to the active task directory
+        #
+        # This molecule provides quick access to the current working task without
+        # needing to remember task IDs. The symlink is created at project root.
+        #
+        # @example Create symlink to task directory
+        #   linker = CurrentTaskLinker.new(project_root: "/project")
+        #   result = linker.link("/project/.ace-task/v.0.9.0/tasks/145-feat/")
+        #   # => { success: true, symlink_path: "/project/_current", target: "..." }
+        #
+        # @example Remove symlink
+        #   linker.unlink
+        #   # => { success: true }
+        class CurrentTaskLinker
+          # Default name for the symlink
+          DEFAULT_SYMLINK_NAME = "_current"
+
+          # Initialize a new CurrentTaskLinker
+          #
+          # @param project_root [String, nil] Project root directory (defaults to Dir.pwd)
+          # @param symlink_name [String] Name of the symlink (default: "_current")
+          def initialize(project_root: nil, symlink_name: DEFAULT_SYMLINK_NAME)
+            @project_root = project_root || Dir.pwd
+            @symlink_name = symlink_name
+          end
+
+          # Create symlink to task directory
+          #
+          # Creates a symlink at project root pointing to the given task directory.
+          # Uses relative paths for portability. Removes existing symlink if present.
+          #
+          # @param task_directory [String] Absolute path to task directory
+          # @return [Hash] Result with :success, :symlink_path, :target, :relative_target, :error
+          def link(task_directory)
+            return {success: false, error: "Task directory is required"} if task_directory.nil? || task_directory.empty?
+            return {success: false, error: "Task directory does not exist: #{task_directory}"} unless Dir.exist?(task_directory)
+
+            symlink_path = File.join(@project_root, @symlink_name)
+
+            # Remove existing symlink or file if present
+            remove_existing(symlink_path)
+
+            # Calculate relative path from project root to task directory
+            relative_target = calculate_relative_path(task_directory)
+
+            # Create the symlink
+            File.symlink(relative_target, symlink_path)
+
+            {
+              success: true,
+              symlink_path: symlink_path,
+              target: task_directory,
+              relative_target: relative_target
+            }
+          rescue => e
+            {success: false, error: "Failed to create symlink: #{e.message}"}
+          end
+
+          # Remove the _current symlink
+          #
+          # @return [Hash] Result with :success, :error
+          def unlink
+            symlink_path = File.join(@project_root, @symlink_name)
+
+            return {success: true, existed: false} unless File.symlink?(symlink_path)
+
+            FileUtils.rm_f(symlink_path)
+            {success: true, existed: true}
+          rescue => e
+            {success: false, error: "Failed to remove symlink: #{e.message}"}
+          end
+
+          # Get the path to the current symlink
+          #
+          # @return [String] Path to the symlink
+          def symlink_path
+            File.join(@project_root, @symlink_name)
+          end
+
+          # Check if symlink exists
+          #
+          # @return [Boolean] true if symlink exists
+          def exists?
+            File.symlink?(symlink_path)
+          end
+
+          # Get the target of the current symlink
+          #
+          # @return [String, nil] Target path or nil if symlink doesn't exist
+          def current_target
+            return nil unless exists?
+
+            File.readlink(symlink_path)
+          end
+
+          # Get the absolute path to the current task directory
+          #
+          # @return [String, nil] Absolute path or nil if symlink doesn't exist
+          def current_absolute_path
+            return nil unless exists?
+
+            File.realpath(symlink_path)
+          rescue Errno::ENOENT
+            nil
+          end
+
+          private
+
+          # Remove existing symlink or file at path
+          #
+          # @param path [String] Path to remove
+          def remove_existing(path)
+            FileUtils.rm_f(path) if File.exist?(path) || File.symlink?(path)
+          end
+
+          # Calculate relative path from project root to target
+          #
+          # @param target [String] Absolute path to target
+          # @return [String] Relative path
+          def calculate_relative_path(target)
+            Pathname.new(target).relative_path_from(Pathname.new(@project_root)).to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Ace
+  module Git
+    module Worktree
+      module Molecules
+        # Hook executor molecule
+        #
+        # Executes after-create hooks defined in YAML configuration.
+        # Supports sequential command execution with timeout, error handling,
+        # and environment variable interpolation.
+        #
+        # @example Execute hooks from configuration
+        #   executor = HookExecutor.new
+        #   hooks = [
+        #     { "command" => "mise trust mise.toml", "timeout" => 10 },
+        #     { "command" => "echo 'Setup complete'" }
+        #   ]
+        #   result = executor.execute_hooks(hooks, worktree_path: "/path/to/worktree")
+        #
+        # @example Hook configuration format
+        #   hooks:
+        #     after_create:
+        #       - command: "mise trust mise*.toml"
+        #         working_dir: "."
+        #         timeout: 30
+        #         continue_on_error: true
+        #         env:
+        #           CUSTOM_VAR: "value"
+        class HookExecutor
+          # Fallback timeout for hook execution (seconds)
+          # Used only when config is unavailable
+          FALLBACK_DEFAULT_TIMEOUT = 30
+
+          # Fallback maximum timeout allowed (seconds)
+          # Used only when config is unavailable
+          FALLBACK_MAX_TIMEOUT = 300
+
+          # Initialize a new HookExecutor
+          def initialize
+            @results = []
+          end
+
+          # Get default timeout from config or fallback
+          # @return [Integer] Default timeout in seconds
+          def default_timeout
+            Ace::Git::Worktree.hook_timeout
+          rescue
+            FALLBACK_DEFAULT_TIMEOUT
+          end
+
+          # Get maximum timeout from config or fallback
+          # @return [Integer] Maximum timeout in seconds
+          def max_timeout
+            Ace::Git::Worktree.max_timeout
+          rescue
+            FALLBACK_MAX_TIMEOUT
+          end
+
+          # Execute a list of hooks
+          #
+          # @param hooks [Array<Hash>] Array of hook definitions
+          # @param worktree_path [String] Path to the worktree
+          # @param task_data [Hash, nil] Optional task data for variable interpolation
+          # @param project_root [String] Project root directory (default working dir)
+          # @return [Hash] Execution result with :success, :results, :errors
+          #
+          # @example
+          #   result = executor.execute_hooks(
+          #     [{ "command" => "mise trust" }],
+          #     worktree_path: "/path/to/worktree",
+          #     project_root: "/path/to/project",
+          #     task_data: { task_id: "081", title: "Fix bug" }
+          #   )
+          #   # => { success: true, results: [...], errors: [] }
+          def execute_hooks(hooks, worktree_path:, project_root: Dir.pwd, task_data: nil)
+            return success_result if hooks.nil? || hooks.empty?
+
+            @worktree_path = worktree_path
+            @project_root = project_root
+            @task_data = task_data || {}
+            @results = []
+            errors = []
+
+            hooks.each_with_index do |hook_config, index|
+              result = execute_hook(hook_config, index)
+              @results << result
+
+              unless result[:success]
+                errors << "Hook #{index + 1}: #{result[:error]}"
+                # Stop execution unless continue_on_error is true
+                break unless hook_config["continue_on_error"]
+              end
+            end
+
+            {
+              success: errors.empty?,
+              results: @results,
+              errors: errors
+            }
+          rescue => e
+            {
+              success: false,
+              results: @results,
+              errors: ["Unexpected error: #{e.message}"]
+            }
+          end
+
+          private
+
+          # Execute a single hook
+          #
+          # @param hook_config [Hash] Hook configuration
+          # @param index [Integer] Hook index for error messages
+          # @return [Hash] Execution result
+          def execute_hook(hook_config, index)
+            command = hook_config["command"]
+
+            # Validate command
+            unless command.is_a?(String) && !command.strip.empty?
+              return error_result(
+                command: command || "(empty)",
+                error: "Command must be a non-empty string"
+              )
+            end
+
+            # Interpolate variables
+            interpolated_command = interpolate_variables(command)
+
+            # Determine working directory
+            working_dir = resolve_working_dir(hook_config["working_dir"])
+
+            # Get timeout
+            timeout = get_timeout(hook_config["timeout"])
+
+            # Prepare environment
+            env = prepare_environment(hook_config["env"])
+
+            # Execute command
+            execute_command(
+              command: interpolated_command,
+              working_dir: working_dir,
+              timeout: timeout,
+              env: env
+            )
+          rescue => e
+            error_result(
+              command: command,
+              error: e.message
+            )
+          end
+
+          # Execute a shell command
+          #
+          # @param command [String] Command to execute
+          # @param working_dir [String] Working directory
+          # @param timeout [Integer] Timeout in seconds
+          # @param env [Hash] Environment variables
+          # @return [Hash] Execution result
+          def execute_command(command:, working_dir:, timeout:, env:)
+            start_time = Time.now
+
+            # Use Timeout module to enforce timeout
+            stdout, stderr, status = Timeout.timeout(timeout) do
+              Open3.capture3(
+                env,
+                command,
+                chdir: working_dir
+              )
+            end
+
+            duration = Time.now - start_time
+
+            if status.success?
+              success_result(
+                command: command,
+                stdout: stdout,
+                stderr: stderr,
+                duration: duration,
+                working_dir: working_dir
+              )
+            else
+              error_result(
+                command: command,
+                error: "Command failed with exit code #{status.exitstatus}",
+                stdout: stdout,
+                stderr: stderr,
+                duration: duration,
+                exit_code: status.exitstatus
+              )
+            end
+          rescue Timeout::Error
+            error_result(
+              command: command,
+              error: "Command timed out after #{timeout} seconds",
+              timeout: timeout
+            )
+          rescue => e
+            error_result(
+              command: command,
+              error: "Execution error: #{e.message}"
+            )
+          end
+
+          # Interpolate variables in command string
+          #
+          # @param command [String] Command with {variable} placeholders
+          # @return [String] Command with variables replaced
+          def interpolate_variables(command)
+            result = command.dup
+
+            # Worktree variables
+            result.gsub!("{worktree_path}", @worktree_path.to_s)
+            result.gsub!("{worktree_dir}", File.basename(@worktree_path.to_s))
+
+            # Task variables (if available)
+            if @task_data && !@task_data.empty?
+              result.gsub!("{task_id}", extract_task_id(@task_data))
+              result.gsub!("{task_title}", @task_data[:title].to_s)
+              result.gsub!("{slug}", extract_slug(@task_data))
+            end
+
+            result
+          end
+
+          # Resolve working directory
+          #
+          # @param working_dir [String, nil] Configured working directory
+          # @return [String] Absolute working directory path
+          def resolve_working_dir(working_dir)
+            # Default to project root if not specified
+            return @project_root if working_dir.nil? || working_dir.empty?
+
+            case working_dir
+            when "."
+              # "." means current project root
+              @project_root
+            when "worktree"
+              # Special keyword for worktree directory
+              @worktree_path
+            when /^\//
+              # Absolute path
+              working_dir
+            else
+              # Relative path from project root
+              File.join(@project_root, working_dir)
+            end
+          end
+
+          # Get validated timeout value
+          #
+          # @param timeout [Integer, nil] Configured timeout
+          # @return [Integer] Validated timeout in seconds
+          def get_timeout(timeout)
+            return default_timeout if timeout.nil?
+
+            timeout_int = timeout.to_i
+            return default_timeout if timeout_int <= 0
+
+            [timeout_int, max_timeout].min
+          end
+
+          # Prepare environment variables
+          #
+          # @param env_config [Hash, nil] Environment configuration
+          # @return [Hash] Environment hash for Open3
+          def prepare_environment(env_config)
+            env = {}
+
+            # Add project environment variables
+            env["ACE_PROJECT_ROOT"] = @project_root
+
+            # Add worktree environment variables
+            env["ACE_WORKTREE_PATH"] = @worktree_path
+            env["ACE_WORKTREE_DIR"] = File.basename(@worktree_path)
+
+            # Add task environment variables (if available)
+            if @task_data && !@task_data.empty?
+              env["ACE_TASK_ID"] = extract_task_id(@task_data)
+              env["ACE_TASK_TITLE"] = @task_data[:title].to_s
+            end
+
+            # Add custom environment variables
+            if env_config.is_a?(Hash)
+              env_config.each do |key, value|
+                env[key.to_s] = value.to_s
+              end
+            end
+
+            env
+          end
+
+          # Extract task ID from task data
+          #
+          # @param task_data [Hash] Task data
+          # @return [String] Task ID
+          def extract_task_id(task_data)
+            return task_data[:task_number].to_s if task_data[:task_number]
+
+            if task_data[:id]
+              match = task_data[:id].match(/task\.(\d+)$/)
+              return match[1] if match
+            end
+
+            "unknown"
+          end
+
+          # Extract slug from task data
+          #
+          # @param task_data [Hash] Task data
+          # @return [String] URL-safe slug
+          def extract_slug(task_data)
+            return task_data[:slug].to_s if task_data[:slug]
+
+            title = task_data[:title].to_s
+            return "" if title.empty?
+
+            # Generate slug from title
+            require_relative "../atoms/slug_generator"
+            Atoms::SlugGenerator.from_title(title)
+          end
+
+          # Create success result
+          #
+          # @param details [Hash] Additional details
+          # @return [Hash] Success result
+          def success_result(**details)
+            {
+              success: true,
+              command: details[:command] || "",
+              stdout: details[:stdout] || "",
+              stderr: details[:stderr] || "",
+              duration: details[:duration] || 0,
+              working_dir: details[:working_dir]
+            }.compact
+          end
+
+          # Create error result
+          #
+          # @param details [Hash] Error details
+          # @return [Hash] Error result
+          def error_result(**details)
+            {
+              success: false,
+              command: details[:command] || "",
+              error: details[:error] || "Unknown error",
+              stdout: details[:stdout] || "",
+              stderr: details[:stderr] || "",
+              duration: details[:duration],
+              exit_code: details[:exit_code],
+              timeout: details[:timeout]
+            }.compact
+          end
+        end
+      end
+    end
+  end
+end