sxn 0.2.3 → 0.3.0

data/lib/sxn/config/templates_config.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Sxn
+  module Config
+    # Handles loading and saving session templates from .sxn/templates.yml
+    #
+    # Templates define collections of projects (worktree configurations)
+    # that can be applied when creating a session.
+    class TemplatesConfig
+      TEMPLATES_FILE = "templates.yml"
+
+      attr_reader :sxn_path, :templates_file_path
+
+      def initialize(sxn_path)
+        @sxn_path = Pathname.new(sxn_path)
+        @templates_file_path = @sxn_path / TEMPLATES_FILE
+      end
+
+      # Load templates configuration from file
+      # @return [Hash] Templates configuration
+      def load
+        return default_config unless templates_file_path.exist?
+
+        content = File.read(templates_file_path)
+        config = YAML.safe_load(content, permitted_classes: [], permitted_symbols: [], aliases: false) || {}
+        normalize_config(config)
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "Invalid YAML in #{templates_file_path}: #{e.message}"
+      rescue StandardError => e
+        raise ConfigurationError, "Failed to load templates file #{templates_file_path}: #{e.message}"
+      end
+
+      # Save templates configuration to file
+      # @param config [Hash] Templates configuration
+      def save(config)
+        ensure_directory_exists!
+
+        # Ensure version is set
+        config["version"] ||= 1
+        config["templates"] ||= {}
+
+        File.write(templates_file_path, YAML.dump(stringify_keys(config)))
+      end
+
+      # Check if templates file exists
+      # @return [Boolean]
+      def exists?
+        templates_file_path.exist?
+      end
+
+      # Get a specific template by name
+      # @param name [String] Template name
+      # @return [Hash, nil] Template configuration or nil if not found
+      def get_template(name)
+        config = load
+        templates = config["templates"] || {}
+        template = templates[name]
+
+        return nil unless template
+
+        # Normalize project entries to hashes
+        normalize_template(name, template)
+      end
+
+      # List all template names
+      # @return [Array<String>] Template names
+      def list_template_names
+        config = load
+        (config["templates"] || {}).keys
+      end
+
+      # Add or update a template
+      # @param name [String] Template name
+      # @param template [Hash] Template configuration
+      def set_template(name, template)
+        config = load
+        config["templates"] ||= {}
+        config["templates"][name] = template
+        save(config)
+      end
+
+      # Remove a template
+      # @param name [String] Template name
+      # @return [Boolean] True if template was removed
+      def remove_template(name)
+        config = load
+        templates = config["templates"] || {}
+
+        return false unless templates.key?(name)
+
+        templates.delete(name)
+        save(config)
+        true
+      end
+
+      private
+
+      def default_config
+        {
+          "version" => 1,
+          "templates" => {}
+        }
+      end
+
+      def normalize_config(config)
+        config["version"] ||= 1
+        config["templates"] ||= {}
+        config
+      end
+
+      def normalize_template(name, template)
+        {
+          "name" => name,
+          "description" => template["description"],
+          "projects" => normalize_projects(template["projects"] || [])
+        }
+      end
+
+      def normalize_projects(projects)
+        projects.map do |project|
+          if project.is_a?(String)
+            { "name" => project }
+          elsif project.is_a?(Hash)
+            # Ensure name key exists
+            project["name"] ||= project[:name]
+            stringify_keys(project)
+          else
+            { "name" => project.to_s }
+          end
+        end
+      end
+
+      def stringify_keys(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.transform_keys(&:to_s).transform_values do |value|
+          case value
+          when Hash then stringify_keys(value)
+          when Array then value.map { |v| v.is_a?(Hash) ? stringify_keys(v) : v }
+          else value
+          end
+        end
+      end
+
+      def ensure_directory_exists!
+        FileUtils.mkdir_p(sxn_path) unless sxn_path.exist?
+      end
+    end
+  end
+end

data/lib/sxn/config.rb

@@ -3,6 +3,7 @@
 require_relative "config/config_discovery"
 require_relative "config/config_cache"
 require_relative "config/config_validator"
+require_relative "config/templates_config"
 
 module Sxn
   module Config

data/lib/sxn/core/config_manager.rb

@@ -62,6 +62,10 @@ module Sxn
         @sessions_folder || (load_config && @sessions_folder)
       end
 
+      def sxn_folder_path
+        File.dirname(@config_path)
+      end
+
       def add_project(name, path, type: nil, default_branch: nil)
         config = load_config_file
         config["projects"] ||= {}

data/lib/sxn/core/project_manager.rb

@@ -193,9 +193,26 @@ module Sxn
 
         # Get project-specific rules from config
         config = @config_manager.get_config
-        project_config = config.projects[name]
 
-        rules = project_config&.dig("rules") || {}
+        # Handle both OpenStruct and Hash for projects config
+        projects = config.projects
+        project_config = if projects.is_a?(OpenStruct)
+                           projects.to_h[name.to_sym] || projects.to_h[name]
+                         elsif projects.is_a?(Hash)
+                           projects[name]
+                         end
+
+        # Extract rules, handling both OpenStruct and Hash
+        rules = if project_config.is_a?(OpenStruct)
+                  project_config.to_h[:rules] || project_config.to_h["rules"] || {}
+                elsif project_config.is_a?(Hash)
+                  project_config["rules"] || project_config[:rules] || {}
+                else
+                  {}
+                end
+
+        # Convert OpenStruct rules to hash if needed
+        rules = rules.to_h if rules.is_a?(OpenStruct)
 
         # Add default rules based on project type
         default_rules = get_default_rules_for_type(project[:type])

data/lib/sxn/core/rules_manager.rb

@@ -87,11 +87,69 @@ module Sxn
                 "No worktree found for project '#{project_name}' in session '#{session_name}'"
         end
 
-        # Get project rules
+        # Get project rules (format: { "copy_files" => [...], "setup_commands" => [...] })
         rules = @project_manager.get_project_rules(project_name)
 
-        # Apply rules to worktree
-        @rules_engine.apply_rules(rules)
+        # Transform rules to RulesEngine format and apply
+        apply_rules_to_worktree(project, worktree, rules)
+      end
+
+      def apply_rules_to_worktree(project, worktree, rules)
+        project_path = project[:path]
+        worktree_path = worktree[:path]
+
+        # Ensure paths exist
+        raise Sxn::InvalidProjectPathError, "Project path does not exist: #{project_path}" unless File.directory?(project_path)
+        raise Sxn::WorktreeNotFoundError, "Worktree path does not exist: #{worktree_path}" unless File.directory?(worktree_path)
+
+        applied_count = 0
+        errors = []
+
+        # Apply copy_files rules
+        rules["copy_files"]&.each do |rule_config|
+          apply_copy_file_rule(project_path, worktree_path, rule_config)
+          applied_count += 1
+        rescue StandardError => e
+          errors << "copy_files: #{e.message}"
+        end
+
+        # Apply setup_commands rules (skip for now as they can be slow)
+        # Users can run these manually if needed
+
+        {
+          success: errors.empty?,
+          applied_count: applied_count,
+          errors: errors
+        }
+      end
+
+      def apply_copy_file_rule(project_path, worktree_path, rule_config)
+        source_pattern = rule_config["source"]
+        strategy = rule_config["strategy"] || "copy"
+
+        # Handle glob patterns
+        source_files = if source_pattern.include?("*")
+                         Dir.glob(File.join(project_path, source_pattern))
+                       else
+                         single_file = File.join(project_path, source_pattern)
+                         File.exist?(single_file) ? [single_file] : []
+                       end
+
+        source_files.each do |file_path|
+          # Calculate relative path from project root
+          relative_path = file_path.sub("#{project_path}/", "")
+          dest_file = File.join(worktree_path, relative_path)
+
+          # Create destination directory if needed
+          FileUtils.mkdir_p(File.dirname(dest_file))
+
+          case strategy
+          when "copy"
+            FileUtils.cp(file_path, dest_file)
+          when "symlink"
+            FileUtils.ln_sf(file_path, dest_file)
+          end
+        end
       end
 
       def validate_rules(project_name)

data/lib/sxn/core/session_config.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Sxn
+  module Core
+    # Manages .sxnrc session configuration files
+    class SessionConfig
+      FILENAME = ".sxnrc"
+
+      attr_reader :session_path, :config_path
+
+      def initialize(session_path)
+        @session_path = session_path
+        @config_path = File.join(session_path, FILENAME)
+      end
+
+      def create(parent_sxn_path:, default_branch:, session_name:, template_id: nil)
+        config = {
+          "version" => 1,
+          "parent_sxn_path" => parent_sxn_path,
+          "default_branch" => default_branch,
+          "session_name" => session_name,
+          "created_at" => Time.now.iso8601
+        }
+        config["template_id"] = template_id if template_id
+        File.write(@config_path, YAML.dump(config))
+        config
+      end
+
+      def exists?
+        File.exist?(@config_path)
+      end
+
+      def read
+        return nil unless exists?
+
+        YAML.safe_load_file(@config_path) || {}
+      rescue Psych::SyntaxError
+        nil
+      end
+
+      def parent_sxn_path
+        read&.dig("parent_sxn_path")
+      end
+
+      def default_branch
+        read&.dig("default_branch")
+      end
+
+      def session_name
+        read&.dig("session_name")
+      end
+
+      def template_id
+        read&.dig("template_id")
+      end
+
+      def project_root
+        parent_path = parent_sxn_path
+        return nil unless parent_path
+
+        # parent_sxn_path points to .sxn folder, project root is its parent
+        File.dirname(parent_path)
+      end
+
+      def update(updates)
+        config = read || {}
+        updates.each do |key, value|
+          config[key.to_s] = value
+        end
+        File.write(@config_path, YAML.dump(config))
+        config
+      end
+
+      # Class method: Find .sxnrc by walking up directory tree
+      def self.find_from_path(start_path)
+        current = File.expand_path(start_path)
+
+        while current != "/" && current != File.dirname(current)
+          config_path = File.join(current, FILENAME)
+          return new(current) if File.exist?(config_path)
+
+          current = File.dirname(current)
+        end
+
+        nil
+      end
+
+      # Class method: Check if path is within a session
+      def self.in_session?(path = Dir.pwd)
+        !find_from_path(path).nil?
+      end
+    end
+  end
+end

data/lib/sxn/core/session_manager.rb

@@ -13,7 +13,7 @@ module Sxn
         @database = initialize_database
       end
 
-      def create_session(name, description: nil, linear_task: nil)
+      def create_session(name, description: nil, linear_task: nil, default_branch: nil, template_id: nil)
         validate_session_name!(name)
         ensure_sessions_folder_exists!
 
@@ -21,11 +21,24 @@ module Sxn
 
         session_id = SecureRandom.uuid
         session_path = File.join(@config_manager.sessions_folder_path, name)
+        branch = default_branch || name
 
         # Create session directory
         FileUtils.mkdir_p(session_path)
 
-        # Create session record
+        # Create .sxnrc configuration file
+        session_config = SessionConfig.new(session_path)
+        session_config.create(
+          parent_sxn_path: @config_manager.sxn_folder_path,
+          default_branch: branch,
+          session_name: name,
+          template_id: template_id
+        )
+
+        # Create session record with template_id in metadata
+        metadata = {}
+        metadata["template_id"] = template_id if template_id
+
         session_data = {
           id: session_id,
           name: name,
@@ -35,8 +48,10 @@ module Sxn
           status: "active",
           description: description,
           linear_task: linear_task,
+          default_branch: branch,
           projects: [],
-          worktrees: {}
+          worktrees: {},
+          metadata: metadata
         }
 
         @database.create_session(session_data)
@@ -162,6 +177,15 @@ module Sxn
         session_data[:worktrees] || {}
       end
 
+      def get_session_default_branch(session_name)
+        session = get_session(session_name)
+        return nil unless session
+
+        # Read from .sxnrc file in session directory
+        session_config = SessionConfig.new(session[:path])
+        session_config.default_branch
+      end
+
       def archive_session(name)
         update_session_status_by_name(name, "archived")
         true
@@ -224,6 +248,8 @@ module Sxn
           status: db_row[:status],
           description: metadata["description"] || db_row[:description],
           linear_task: metadata["linear_task"] || db_row[:linear_task],
+          default_branch: metadata["default_branch"] || db_row[:default_branch],
+          template_id: metadata["template_id"],
           # Support both metadata and database columns for backward compatibility
           projects: db_row[:projects] || metadata["projects"] || [],
           worktrees: db_row[:worktrees] || metadata["worktrees"] || {}

data/lib/sxn/core/template_manager.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../config/templates_config"
+
+module Sxn
+  module Core
+    # Manages session templates - collections of projects that can be
+    # applied when creating a session to automatically create multiple worktrees.
+    class TemplateManager
+      attr_reader :config_manager, :templates_config
+
+      def initialize(config_manager)
+        @config_manager = config_manager
+        @templates_config = Config::TemplatesConfig.new(config_manager.sxn_folder_path)
+      end
+
+      # List all available templates
+      # @return [Array<Hash>] Array of template info hashes
+      def list_templates
+        config = templates_config.load
+        templates = config["templates"] || {}
+
+        templates.map do |name, template|
+          {
+            name: name,
+            description: template["description"],
+            project_count: (template["projects"] || []).size
+          }
+        end
+      end
+
+      # Get a specific template by name
+      # @param name [String] Template name
+      # @return [Hash] Template configuration
+      # @raise [SessionTemplateNotFoundError] If template not found
+      def get_template(name)
+        template = templates_config.get_template(name)
+
+        unless template
+          available = list_template_names
+          raise SessionTemplateNotFoundError.new(name, available: available)
+        end
+
+        template
+      end
+
+      # Get list of template names
+      # @return [Array<String>] Template names
+      def list_template_names
+        templates_config.list_template_names
+      end
+
+      # Validate a template before use
+      # @param name [String] Template name
+      # @raise [SessionTemplateValidationError] If template is invalid
+      # @raise [SessionTemplateNotFoundError] If template not found
+      def validate_template(name)
+        template = get_template(name)
+        projects = template["projects"] || []
+        errors = []
+
+        errors << "Template has no projects defined" if projects.empty?
+
+        # Validate each project exists in config
+        projects.each do |project_config|
+          project_name = project_config["name"]
+          project = config_manager.get_project(project_name)
+
+          errors << "Project '#{project_name}' not found in configuration" unless project
+        end
+
+        raise SessionTemplateValidationError.new(name, errors.join("; ")) if errors.any?
+
+        true
+      end
+
+      # Create a new template
+      # @param name [String] Template name
+      # @param description [String] Template description
+      # @param projects [Array<String>] Array of project names
+      # @return [Hash] Created template
+      def create_template(name, description: nil, projects: [])
+        validate_template_name!(name)
+
+        raise SessionTemplateValidationError.new(name, "Template already exists") if template_exists?(name)
+
+        # Validate all projects exist
+        projects.each do |project_name|
+          project = config_manager.get_project(project_name)
+          raise SessionTemplateValidationError.new(name, "Project '#{project_name}' not found") unless project
+        end
+
+        template = {
+          "description" => description,
+          "projects" => projects.map { |p| { "name" => p } }
+        }
+
+        templates_config.set_template(name, template)
+
+        get_template(name)
+      end
+
+      # Update an existing template
+      # @param name [String] Template name
+      # @param description [String, nil] New description
+      # @param projects [Array<String>, nil] New project list
+      # @return [Hash] Updated template
+      def update_template(name, description: nil, projects: nil)
+        template = get_template(name)
+
+        # Update description if provided
+        template["description"] = description if description
+
+        # Update projects if provided
+        if projects
+          # Validate all projects exist
+          projects.each do |project_name|
+            project = config_manager.get_project(project_name)
+            raise SessionTemplateValidationError.new(name, "Project '#{project_name}' not found") unless project
+          end
+
+          template["projects"] = projects.map { |p| { "name" => p } }
+        end
+
+        # Save back to config
+        config = templates_config.load
+        config["templates"] ||= {}
+        config["templates"][name] = {
+          "description" => template["description"],
+          "projects" => template["projects"]
+        }
+        templates_config.save(config)
+
+        get_template(name)
+      end
+
+      # Remove a template
+      # @param name [String] Template name
+      # @return [Boolean] True if removed
+      def remove_template(name)
+        # Verify template exists
+        get_template(name)
+
+        templates_config.remove_template(name)
+      end
+
+      # Check if a template exists
+      # @param name [String] Template name
+      # @return [Boolean]
+      def template_exists?(name)
+        templates_config.get_template(name) != nil
+      end
+
+      # Get project configurations for a template with branch resolution
+      # @param name [String] Template name
+      # @param default_branch [String] Default branch to use if not specified per-project
+      # @return [Array<Hash>] Array of project configs with resolved branches
+      def get_template_projects(name, default_branch:)
+        template = get_template(name)
+        projects = template["projects"] || []
+
+        projects.map do |project_config|
+          project_name = project_config["name"]
+          project = config_manager.get_project(project_name)
+
+          {
+            name: project_name,
+            path: project[:path],
+            branch: project_config["branch"] || default_branch,
+            rules: project_config["rules"]
+          }
+        end
+      end
+
+      private
+
+      def validate_template_name!(name)
+        return if name.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+        raise SessionTemplateValidationError.new(
+          name,
+          "Template name must contain only letters, numbers, hyphens, and underscores"
+        )
+      end
+    end
+  end
+end