sxn 0.2.2 → 0.2.5

data/lib/sxn/commands/sessions.rb

@@ -2,6 +2,7 @@
 
 require "thor"
 require "time"
+require "shellwords"
 
 module Sxn
   module Commands
@@ -16,12 +17,16 @@ module Sxn
         @table = Sxn::UI::Table.new
         @config_manager = Sxn::Core::ConfigManager.new
         @session_manager = Sxn::Core::SessionManager.new(@config_manager)
+        @project_manager = Sxn::Core::ProjectManager.new(@config_manager)
+        @worktree_manager = Sxn::Core::WorktreeManager.new(@config_manager, @session_manager)
       end
 
       desc "add NAME", "Create a new session"
       option :description, type: :string, aliases: "-d", desc: "Session description"
       option :linear_task, type: :string, aliases: "-l", desc: "Linear task ID"
+      option :branch, type: :string, aliases: "-b", desc: "Default branch for worktrees"
       option :activate, type: :boolean, default: true, desc: "Activate session after creation"
+      option :skip_worktree, type: :boolean, default: false, desc: "Skip worktree creation wizard"
 
       def add(name = nil)
         ensure_initialized!
@@ -32,24 +37,31 @@ module Sxn
           name = @prompt.session_name(existing_sessions: existing_sessions)
         end
 
+        # Get default branch - use provided option, or prompt interactively
+        default_branch = options[:branch]
+        default_branch ||= @prompt.default_branch(session_name: name)
+
         begin
           @ui.progress_start("Creating session '#{name}'")
 
           session = @session_manager.create_session(
             name,
             description: options[:description],
-            linear_task: options[:linear_task]
+            linear_task: options[:linear_task],
+            default_branch: default_branch
           )
 
           @ui.progress_done
           @ui.success("Created session '#{name}'")
 
-          if options[:activate]
-            @session_manager.use_session(name)
-            @ui.success("Activated session '#{name}'")
-          end
+          # Always activate the new session (this is the expected behavior)
+          @session_manager.use_session(name)
+          @ui.success("Switched to session '#{name}'")
 
           display_session_info(session)
+
+          # Offer to add a worktree unless skipped
+          offer_worktree_wizard(name) unless options[:skip_worktree]
         rescue Sxn::Error => e
           @ui.progress_failed
           @ui.error(e.message)
@@ -168,12 +180,23 @@ module Sxn
         end
       end
 
-      desc "current", "Show current session"
+      desc "current [SUBCOMMAND]", "Show current session or enter its directory"
       option :verbose, type: :boolean, aliases: "-v", desc: "Show detailed information"
+      option :path, type: :boolean, aliases: "-p", desc: "Output only the session path (for shell integration)"
 
-      def current
+      def current(subcommand = nil)
         ensure_initialized!
 
+        # Handle 'sxn current enter' subcommand
+        if subcommand == "enter"
+          enter_session
+          return
+        elsif subcommand
+          @ui.error("Unknown subcommand: #{subcommand}")
+          @ui.info("Available: enter")
+          exit(1)
+        end
+
         begin
           session = @session_manager.current_session
 
@@ -183,6 +206,12 @@ module Sxn
             return
           end
 
+          # If --path flag, just output the path for shell integration
+          if options[:path]
+            puts session[:path]
+            return
+          end
+
           @ui.section("Current Session")
           display_session_info(session, verbose: options[:verbose])
         rescue Sxn::Error => e
@@ -191,6 +220,11 @@ module Sxn
         end
       end
 
+      desc "enter", "Enter the current session directory (outputs cd command)"
+      def enter
+        enter_session
+      end
+
       desc "archive NAME", "Archive a session"
       def archive(name = nil)
         ensure_initialized!
@@ -256,6 +290,7 @@ module Sxn
         @ui.key_value("Name", session[:name] || "Unknown")
         @ui.key_value("Status", (session[:status] || "unknown").capitalize)
         @ui.key_value("Path", session[:path] || "Unknown")
+        @ui.key_value("Default Branch", session[:default_branch]) if session[:default_branch]
 
         @ui.key_value("Description", session[:description]) if session[:description]
 
@@ -310,6 +345,161 @@ module Sxn
       rescue ArgumentError
         timestamp # Return original if parsing fails
       end
+
+      def offer_worktree_wizard(session_name)
+        @ui.newline
+        @ui.section("Add Worktree")
+
+        # Check if there are any projects configured
+        projects = @project_manager.list_projects
+        if projects.empty?
+          @ui.info("No projects configured yet.")
+          @ui.recovery_suggestion("Add projects with 'sxn projects add <name> <path>'")
+          return
+        end
+
+        # Ask if user wants to add a worktree
+        return unless @prompt.ask_yes_no("Would you like to add a worktree to this session?", default: true)
+
+        # Step 1: Select project with descriptions
+        @ui.newline
+        @ui.info("A worktree is a linked copy of a project that allows you to work on a branch")
+        @ui.info("without affecting the main repository. Select which project to add:")
+        @ui.newline
+
+        project_choices = projects.map do |p|
+          {
+            name: "#{p[:name]} (#{p[:type]}) - #{p[:path]}",
+            value: p[:name]
+          }
+        end
+        project_name = @prompt.select("Select project:", project_choices)
+
+        # Step 2: Get branch name with explanation
+        # Get session's default branch for the default value
+        session = @session_manager.get_session(session_name)
+        default_branch_for_worktree = session[:default_branch] || session_name
+
+        @ui.newline
+        @ui.info("Enter the branch name for this worktree.")
+        @ui.info("This can be an existing branch or a new one to create.")
+        @ui.info("Tip: Use 'remote:<branch>' to track a remote branch (e.g., 'remote:origin/main')")
+        @ui.newline
+
+        branch = @prompt.branch_name(
+          "Branch name:",
+          default: default_branch_for_worktree
+        )
+
+        # Step 3: Create the worktree
+        create_worktree_for_session(project_name, branch, session_name)
+
+        # Offer to add more worktrees
+        add_more_worktrees(session_name)
+      end
+
+      def create_worktree_for_session(project_name, branch, session_name)
+        @ui.newline
+        @ui.progress_start("Creating worktree for #{project_name}")
+
+        worktree = @worktree_manager.add_worktree(
+          project_name,
+          branch,
+          session_name: session_name
+        )
+
+        @ui.progress_done
+        @ui.success("Created worktree for #{project_name}")
+
+        display_worktree_info(worktree)
+
+        # Apply rules
+        apply_project_rules(project_name, session_name)
+      rescue Sxn::Error => e
+        @ui.progress_failed
+        @ui.error(e.message)
+        @ui.recovery_suggestion("You can try again with 'sxn worktree add #{project_name}'")
+      end
+
+      def add_more_worktrees(session_name)
+        projects = @project_manager.list_projects
+        return if projects.empty?
+
+        # Get session's default branch for the default value
+        session = @session_manager.get_session(session_name)
+        default_branch_for_worktree = session[:default_branch] || session_name
+
+        while @prompt.ask_yes_no("Would you like to add another worktree?", default: false)
+          @ui.newline
+
+          project_choices = projects.map do |p|
+            {
+              name: "#{p[:name]} (#{p[:type]}) - #{p[:path]}",
+              value: p[:name]
+            }
+          end
+          project_name = @prompt.select("Select project:", project_choices)
+
+          branch = @prompt.branch_name(
+            "Branch name:",
+            default: default_branch_for_worktree
+          )
+
+          create_worktree_for_session(project_name, branch, session_name)
+        end
+      end
+
+      def display_worktree_info(worktree)
+        @ui.newline
+        @ui.key_value("Project", worktree[:project])
+        @ui.key_value("Branch", worktree[:branch])
+        @ui.key_value("Path", worktree[:path])
+      end
+
+      def enter_session
+        session = @session_manager.current_session
+
+        if session.nil?
+          # When no session, provide helpful guidance instead of just a cd command
+          warn "No active session. Use 'sxn use <session>' to activate a session first."
+          warn ""
+          warn "Tip: Add this function to your shell profile for easier navigation:"
+          warn ""
+          warn "  sxn-enter() { eval \"$(sxn enter 2>/dev/null)\" || sxn enter; }"
+          warn ""
+          exit(1)
+        end
+
+        session_path = session[:path]
+
+        unless session_path && File.directory?(session_path)
+          warn "Session directory does not exist: #{session_path || "nil"}"
+          exit(1)
+        end
+
+        # Output the cd command for shell integration
+        # Users can use: eval "$(sxn enter)" or the sxn-enter shell function
+        puts "cd #{Shellwords.escape(session_path)}"
+      rescue Sxn::Error => e
+        warn e.message
+        exit(e.exit_code)
+      end
+
+      def apply_project_rules(project_name, session_name)
+        rules_manager = Sxn::Core::RulesManager.new(@config_manager, @project_manager)
+
+        @ui.progress_start("Applying rules for #{project_name}")
+        results = rules_manager.apply_rules(project_name, session_name)
+        @ui.progress_done
+
+        if results[:success]
+          @ui.success("Applied #{results[:applied_count]} rules") if results[:applied_count].positive?
+        else
+          @ui.warning("Some rules failed to apply")
+        end
+      rescue StandardError => e
+        @ui.warning("Could not apply rules: #{e.message}")
+      end
     end
   end
 end

data/lib/sxn/commands/worktrees.rb

@@ -19,10 +19,29 @@ module Sxn
         @worktree_manager = Sxn::Core::WorktreeManager.new(@config_manager, @session_manager)
       end
 
-      desc "add PROJECT [BRANCH]", "Add worktree to current session"
+      desc "add PROJECT [BRANCH]", "Add worktree to current session (defaults branch to session name)"
+      long_desc <<-DESC
+        Add a worktree for a project to the current session.
+
+        Branch options:
+        - No branch specified: Uses the session name as the branch name
+        - Branch name: Creates or checks out the specified branch
+        - remote:<branch>: Fetches and tracks the remote branch
+
+        Examples:
+        - sxn worktree add atlas-core
+          Creates worktree with branch name matching current session
+
+        - sxn worktree add atlas-core feature-branch
+          Creates worktree with specified branch name
+
+        - sxn worktree add atlas-core remote:origin/main
+          Fetches and tracks the remote branch
+      DESC
       option :session, type: :string, aliases: "-s", desc: "Target session (defaults to current)"
       option :apply_rules, type: :boolean, default: true, desc: "Apply project rules after creation"
       option :interactive, type: :boolean, aliases: "-i", desc: "Interactive mode"
+      option :verbose, type: :boolean, aliases: "-v", desc: "Show detailed output for debugging"
 
       def add(project_name = nil, branch = nil)
         ensure_initialized!
@@ -33,10 +52,11 @@ module Sxn
           return if project_name.nil?
         end
 
-        # Interactive branch selection if not provided
+        # Interactive branch selection if not provided and interactive mode
+        # Note: If branch is nil, WorktreeManager will use session name as default
         if options[:interactive] && branch.nil?
-          project = @project_manager.get_project(project_name)
-          branch = @prompt.branch_name("Enter branch name:", default: project[:default_branch])
+          session_name = options[:session] || @config_manager.current_session
+          branch = @prompt.branch_name("Enter branch name:", default: session_name)
         end
 
         session_name = options[:session] || @config_manager.current_session
@@ -47,12 +67,16 @@ module Sxn
         end
 
         begin
+          # Enable debug mode if verbose flag is set
+          ENV["SXN_DEBUG"] = "true" if options[:verbose]
+
           @ui.progress_start("Creating worktree for #{project_name}")
 
           worktree = @worktree_manager.add_worktree(
             project_name,
             branch,
-            session_name: session_name
+            session_name: session_name,
+            verbose: options[:verbose]
           )
 
           @ui.progress_done
@@ -65,7 +89,18 @@ module Sxn
         rescue Sxn::Error => e
           @ui.progress_failed
           @ui.error(e.message)
+
+          if options[:verbose] && e.respond_to?(:details)
+            @ui.newline
+            @ui.subsection("Debug Information")
+            @ui.info(e.details)
+          elsif !options[:verbose]
+            @ui.recovery_suggestion("Run with --verbose flag for more details")
+          end
+
           exit(e.exit_code)
+        ensure
+          ENV.delete("SXN_DEBUG") if options[:verbose]
         end
       end
 

data/lib/sxn/core/config_manager.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require "yaml"
 require "pathname"
+require "ostruct"
 
 module Sxn
   module Core
@@ -40,7 +41,10 @@ module Sxn
         raise Sxn::ConfigurationError, "Project not initialized. Run 'sxn init' first." unless initialized?
 
         discovery = Sxn::Config::ConfigDiscovery.new(@base_path)
-        discovery.discover_config
+        config_hash = discovery.discover_config
+
+        # Convert nested hashes to OpenStruct recursively
+        config_to_struct(config_hash)
       end
 
       def update_current_session(session_name)
@@ -58,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"] ||= {}
@@ -194,6 +202,14 @@ module Sxn
 
       private
 
+      def config_to_struct(obj)
+        return obj unless obj.is_a?(Hash)
+
+        OpenStruct.new(
+          obj.transform_values { |v| config_to_struct(v) }
+        )
+      end
+
       def sessions_folder_relative_path
         return ".sxn" unless @sessions_folder
 

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,91 @@
+# 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:)
+        config = {
+          "version" => 1,
+          "parent_sxn_path" => parent_sxn_path,
+          "default_branch" => default_branch,
+          "session_name" => session_name,
+          "created_at" => Time.now.iso8601
+        }
+        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 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)
         validate_session_name!(name)
         ensure_sessions_folder_exists!
 
@@ -21,10 +21,19 @@ 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 .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
+        )
+
         # Create session record
         session_data = {
           id: session_id,
@@ -35,6 +44,7 @@ module Sxn
           status: "active",
           description: description,
           linear_task: linear_task,
+          default_branch: branch,
           projects: [],
           worktrees: {}
         }
@@ -162,6 +172,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 +243,7 @@ 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],
           # Support both metadata and database columns for backward compatibility
           projects: db_row[:projects] || metadata["projects"] || [],
           worktrees: db_row[:worktrees] || metadata["worktrees"] || {}