sxn 0.2.2 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9758f35bc9f122c019b15dd8a46f712cda58eb86495c6e5bb8c63791b10525e
-  data.tar.gz: 628449e55edf8b33ade3f83cdfab4369234bd22e26e5625cc3890b3c46a74702
+  metadata.gz: 30ceb6fb94a023b31e9b9c4c4354806a5343b7cefa8f1b43047011f86e3048cf
+  data.tar.gz: 071b888de74d9e284376acf2ed425a5a33ddf329ac01112bc3fbc65acc8dd363
 SHA512:
-  metadata.gz: 7970fbb77d1b7b21da3b93d566bb54a42219c787ca081b2319ec6c3dcf7b31dee35761339da42322ac2acf393232fa458325e3573dfebec546caa2e14f9da0eb
-  data.tar.gz: bd4f880ea4b2aa55b1a0de1d87d6e6bcc41a787218d29c104c644c87d07d2c43048b77217ba6ceae3f3df66a2da63c531a6b7f6cc96781d1454f0a2622232d1a
+  metadata.gz: 93cb3f85f80ccc13ffcc62662fa86bd0e8b7531105ab08dc49f0213744a858bbaf7fff8823c2d5358617704eeb5aae6f2264ba02f20e14c71003fd8e912136d4
+  data.tar.gz: fc1e076616d354218525d2d8ee6a6454a04dfd5d1db969f7032792c91ec1679605a4d0351573a57cd3b5af64c8d06fdecad1068b51dfd66bc2bea5c92bc52dfc

data/CHANGELOG.md

@@ -5,6 +5,54 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.5] - 2025-11-30
+
+### Added
+- `sxn enter` command to quickly navigate to current session directory
+- `sxn current enter` subcommand as alternative way to enter session
+- `--path` option for `sxn current` to output only the session path
+- `sxn shell` command to install shell integration (idempotent)
+  - Auto-detects shell type (bash/zsh)
+  - Installs `sxn-enter` function to shell config
+  - Supports `--uninstall` to remove integration
+  - Supports `--shell-type` to specify shell explicitly
+
+## [0.2.4] - 2025-11-30
+
+### Added
+- Interactive worktree wizard after session creation
+  - Prompts to add worktrees with descriptive explanations
+  - Supports adding multiple worktrees in sequence
+  - Explains branch options including remote tracking syntax
+- `--skip-worktree` flag to bypass the wizard when creating sessions
+- `--verbose` flag for worktree debugging with detailed git output
+
+### Changed
+- Sessions now automatically switch to newly created session (no need to run `sxn use` afterwards)
+- Improved project manager to safely handle nil projects configuration
+
+### Fixed
+- Fixed test mocks for verbose parameter in worktree operations
+- Fixed version spec to support semver pre-release format
+
+## [0.2.3] - 2025-09-16
+
+### Added
+- Smart branch defaults: worktrees now use session name as default branch
+- Remote branch tracking with `remote:` prefix syntax (e.g., `sxn worktree add project remote:origin/feature`)
+- Automatic orphaned worktree recovery and cleanup
+- Enhanced error messages with actionable suggestions
+
+### Changed
+- Improved worktree creation logic to handle existing/orphaned states
+- Better error handling for remote branch operations
+- Updated CLI documentation with new branch options
+
+### Fixed
+- Orphaned worktree cleanup now works for both existing and missing directories
+- Worktree creation properly handles branch conflicts
+- Test suite compatibility with new worktree features
+
 ## [0.2.1] - 2025-01-20
 
 ### Fixed
@@ -53,5 +101,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial placeholder release
 - Basic gem structure
 
+[0.2.4]: https://github.com/idl3/sxn/compare/v0.2.3...v0.2.4
+[0.2.3]: https://github.com/idl3/sxn/compare/v0.2.1...v0.2.3
+[0.2.1]: https://github.com/idl3/sxn/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/idl3/sxn/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/idl3/sxn/releases/tag/v0.1.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sxn (0.2.2)
+    sxn (0.2.5)
       async (~> 2.0)
       bcrypt (~> 3.1)
       dry-configurable (~> 1.0)

data/README.md

@@ -1,10 +1,10 @@
-# Sxn
+# sxn
 
 [![CI](https://github.com/idl3/sxn/actions/workflows/ci.yml/badge.svg)](https://github.com/idl3/sxn/actions/workflows/ci.yml)
 [![Ruby Version](https://img.shields.io/badge/ruby-3.2%2B-red)](https://www.ruby-lang.org)
 [![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE.txt)
 
-Sxn is a powerful session management tool for multi-repository development. It helps developers manage complex development environments with multiple git repositories, providing isolated workspaces, automatic project setup, and intelligent session management.
+sxn is a powerful session management tool for multi-repository development. It helps developers manage complex development environments with multiple git repositories, providing isolated workspaces, automatic project setup, and intelligent session management.
 
 ## Features
 
@@ -38,7 +38,7 @@ gem install sxn
 
 ## Quick Start
 
-### Initialize Sxn in your workspace
+### Initialize sxn in your workspace
 
 ```bash
 sxn init
@@ -135,7 +135,7 @@ sxn rules apply my-app
 
 ## Configuration
 
-Sxn stores its configuration in `.sxn/config.yml` in your workspace:
+sxn stores its configuration in `.sxn/config.yml` in your workspace:
 
 ```yaml
 sessions_folder: .sxn-sessions
@@ -168,7 +168,7 @@ rules:
 
 ## Templates
 
-Sxn includes templates for common project types:
+sxn includes templates for common project types:
 
 - **Rails**: CLAUDE.md, database.yml, session-info.md
 - **JavaScript**: README.md, session-info.md
@@ -178,19 +178,87 @@ Templates use Liquid syntax and have access to session, project, and environment
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+### Setup
 
-### Running Tests
+After cloning the repository, run:
+
+```bash
+bundle install
+./script/setup-hooks  # Set up git hooks for automated checks
+```
+
+### Testing and Code Quality
+
+**Important**: All code must pass tests and linting before being pushed to the repository.
+
+#### Running Tests
 
 ```bash
 # Run all tests
 bundle exec rspec
 
+# Run tests in parallel (faster)
+bundle exec rake parallel:spec
+
+# Run with coverage report
+bundle exec rake parallel:spec_with_coverage
+```
+
+#### Code Style
+
+```bash
+# Check code style
+bundle exec rubocop
+
+# Auto-fix code style issues
+bundle exec rubocop -a
+```
+
+#### Git Hooks
+
+The project includes a pre-push hook that automatically runs RuboCop and RSpec before allowing pushes. To set it up:
+
+```bash
+./script/setup-hooks
+```
+
+To bypass hooks in emergency situations (not recommended):
+```bash
+git push --no-verify
+```
+
+### Development Workflow
+
+1. Make your changes
+2. Run `bundle exec rubocop -a` to fix any style issues
+3. Run `bundle exec rspec` to ensure tests pass
+4. Commit your changes
+5. Push (pre-push hooks will run automatically)
+
+### Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Ensure tests pass and code style is correct
+5. Commit your changes with meaningful commit messages
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+### Additional Testing Options
+
+```bash
+# Run all tests in parallel (recommended for speed)
+bundle exec parallel_rspec spec/
+
+# Run all tests sequentially
+bundle exec rspec
+
 # Run only unit tests
 bundle exec rspec spec/unit
 
 # Run with coverage
-ENABLE_SIMPLECOV=true bundle exec rspec
+ENABLE_SIMPLECOV=true bundle exec parallel_rspec spec/
 ```
 
 ### Type Checking

data/lib/sxn/CLI.rb

@@ -41,8 +41,11 @@ module Sxn
     desc "add SESSION_NAME", "Create a new session (shortcut for 'sxn sessions add')"
     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"
     def add(session_name)
-      Commands::Sessions.new.add(session_name)
+      cmd = Commands::Sessions.new
+      cmd.options = options
+      cmd.add(session_name)
     rescue Sxn::Error => e
       handle_error(e)
     end
@@ -62,10 +65,102 @@ module Sxn
       handle_error(e)
     end
 
-    desc "current", "Show current session (shortcut for 'sxn sessions current')"
+    desc "current [SUBCOMMAND]", "Show current session (shortcut for 'sxn sessions current')"
     option :verbose, type: :boolean, aliases: "-v", desc: "Show detailed information"
-    def current
-      Commands::Sessions.new.current
+    option :path, type: :boolean, aliases: "-p", desc: "Output only the session path"
+    def current(subcommand = nil)
+      Commands::Sessions.new.current(subcommand)
+    rescue Sxn::Error => e
+      handle_error(e)
+    end
+
+    desc "enter", "Enter current session directory (outputs cd command for shell eval)"
+    long_desc <<-LONGDESC
+      Outputs a cd command to navigate to the current session directory.
+
+      Usage with shell eval:
+        eval "$(sxn enter)"
+
+      Or install shell integration for easier use:
+        sxn shell
+
+      Then simply run:
+        sxn-enter
+    LONGDESC
+    def enter
+      Commands::Sessions.new.enter
+    rescue Sxn::Error => e
+      handle_error(e)
+    end
+
+    desc "up", "Navigate to project root from session (outputs cd command for shell eval)"
+    long_desc <<-LONGDESC
+      Outputs a cd command to navigate to the project root from within a session.
+
+      The project root is determined from the .sxnrc file in the session directory,
+      which points back to the parent .sxn folder.
+
+      Usage with shell eval:
+        eval "$(sxn up)"
+
+      Or install shell integration for easier use:
+        sxn shell
+
+      Then simply run:
+        sxn-up
+    LONGDESC
+    def up
+      require "shellwords"
+
+      session_config = Sxn::Core::SessionConfig.find_from_path(Dir.pwd)
+
+      unless session_config
+        warn "Not in a session directory."
+        warn ""
+        warn "This command works when run from within a session folder."
+        warn "Session folders contain a .sxnrc file that points back to the project."
+        warn ""
+        warn "Tip: Add this function to your shell profile for easier navigation:"
+        warn ""
+        warn "  sxn-up() { eval \"$(sxn up 2>/dev/null)\" || sxn up; }"
+        exit(1)
+      end
+
+      project_root = session_config.project_root
+
+      unless project_root && File.directory?(project_root)
+        warn "Could not determine project root from .sxnrc"
+        warn "parent_sxn_path: #{session_config.parent_sxn_path || "nil"}"
+        exit(1)
+      end
+
+      # Output the cd command for shell integration
+      puts "cd #{Shellwords.escape(project_root)}"
+    rescue Sxn::Error => e
+      handle_error(e)
+    end
+
+    desc "shell", "Install shell integration (sxn-enter function)"
+    option :shell_type, type: :string, enum: %w[bash zsh auto], default: "auto",
+                        desc: "Shell type (bash, zsh, or auto-detect)"
+    option :uninstall, type: :boolean, default: false, desc: "Remove shell integration"
+    long_desc <<-LONGDESC
+      Installs shell integration to your shell configuration file (.zshrc or .bashrc).
+
+      This adds the sxn-enter function which allows you to quickly navigate
+      to your current session directory.
+
+      The installation is idempotent - running it multiple times will not
+      add duplicate entries.
+
+      Examples:
+        sxn shell                   # Auto-detect shell and install
+        sxn shell --shell-type=zsh  # Install for zsh specifically
+        sxn shell --uninstall       # Remove shell integration
+    LONGDESC
+    map "shell" => :install_shell_wrapper
+    def install_shell_wrapper
+      Commands::Init.new.invoke(:install_shell, [], options)
     rescue Sxn::Error => e
       handle_error(e)
     end

data/lib/sxn/commands/init.rb

@@ -8,6 +8,34 @@ module Sxn
     class Init < Thor
       include Thor::Actions
 
+      # Shell integration marker - used to identify sxn shell functions
+      SHELL_MARKER = "# sxn shell integration"
+      SHELL_MARKER_END = "# end sxn shell integration"
+
+      # Shell function that gets installed
+      SHELL_FUNCTION = <<~SHELL.freeze
+        #{SHELL_MARKER}
+        sxn-enter() {
+          local cmd
+          cmd="$(sxn enter 2>/dev/null)"
+          if [ $? -eq 0 ] && [ -n "$cmd" ]; then
+            eval "$cmd"
+          else
+            sxn enter
+          fi
+        }
+        sxn-up() {
+          local cmd
+          cmd="$(sxn up 2>/dev/null)"
+          if [ $? -eq 0 ] && [ -n "$cmd" ]; then
+            eval "$cmd"
+          else
+            sxn up
+          fi
+        }
+        #{SHELL_MARKER_END}
+      SHELL
+
       desc "init [FOLDER]", "Initialize sxn in a project folder"
       option :force, type: :boolean, desc: "Force initialization even if already initialized"
       option :auto_detect, type: :boolean, default: true, desc: "Automatically detect and register projects"
@@ -55,8 +83,116 @@ module Sxn
         end
       end
 
+      desc "install_shell", "Install shell integration (sxn-enter function)"
+      option :shell_type, type: :string, enum: %w[bash zsh auto], default: "auto",
+                          desc: "Shell type (bash, zsh, or auto-detect)"
+      option :uninstall, type: :boolean, default: false, desc: "Remove shell integration"
+      def install_shell
+        @ui.section("Shell Integration")
+
+        shell_type = detect_shell_type
+        rc_file = shell_rc_file(shell_type)
+
+        unless rc_file
+          @ui.error("Could not determine shell configuration file")
+          @ui.info("Supported shells: bash, zsh")
+          exit(1)
+        end
+
+        if options[:uninstall]
+          uninstall_shell_integration(rc_file, shell_type)
+        else
+          install_shell_integration(rc_file, shell_type)
+        end
+      end
+
       private
 
+      def detect_shell_type
+        shell_opt = options[:shell_type] || options[:shell] || "auto"
+        return shell_opt unless shell_opt == "auto"
+
+        # Check SHELL environment variable
+        current_shell = ENV.fetch("SHELL", "")
+        if current_shell.include?("zsh")
+          "zsh"
+        elsif current_shell.include?("bash")
+          "bash"
+        else
+          # Default to bash
+          "bash"
+        end
+      end
+
+      def shell_rc_file(shell_type)
+        home = Dir.home
+        case shell_type
+        when "zsh"
+          File.join(home, ".zshrc")
+        when "bash"
+          # Prefer .bashrc, fall back to .bash_profile on macOS
+          bashrc = File.join(home, ".bashrc")
+          bash_profile = File.join(home, ".bash_profile")
+          File.exist?(bashrc) ? bashrc : bash_profile
+        end
+      end
+
+      def shell_integration_installed?(rc_file)
+        return false unless File.exist?(rc_file)
+
+        content = File.read(rc_file)
+        content.include?(SHELL_MARKER)
+      end
+
+      def install_shell_integration(rc_file, _shell_type)
+        if shell_integration_installed?(rc_file)
+          @ui.info("Shell integration already installed in #{rc_file}")
+          @ui.info("Use --uninstall to remove it first if you want to reinstall")
+          return
+        end
+
+        # Ensure rc file exists
+        FileUtils.touch(rc_file) unless File.exist?(rc_file)
+
+        # Append shell function
+        File.open(rc_file, "a") do |f|
+          f.puts "" # Add blank line before
+          f.puts SHELL_FUNCTION
+        end
+
+        @ui.success("Installed shell integration to #{rc_file}")
+        @ui.newline
+        @ui.info("The following functions were added:")
+        @ui.newline
+        puts "  sxn-enter  - Navigate to current session directory"
+        puts "  sxn-up     - Navigate to project root from session"
+        @ui.newline
+        @ui.recovery_suggestion("Run 'source #{rc_file}' or restart your shell to use them")
+      end
+
+      def uninstall_shell_integration(rc_file, _shell_type)
+        unless File.exist?(rc_file)
+          @ui.info("Shell configuration file not found: #{rc_file}")
+          return
+        end
+
+        unless shell_integration_installed?(rc_file)
+          @ui.info("Shell integration not installed in #{rc_file}")
+          return
+        end
+
+        # Read file and remove sxn block
+        content = File.read(rc_file)
+        # Remove the block between markers (including blank line before)
+        pattern = /\n?#{Regexp.escape(SHELL_MARKER)}.*?#{Regexp.escape(SHELL_MARKER_END)}\n?/m
+        new_content = content.gsub(pattern, "\n")
+
+        File.write(rc_file, new_content)
+
+        @ui.success("Removed shell integration from #{rc_file}")
+        @ui.recovery_suggestion("Run 'source #{rc_file}' or restart your shell")
+      end
+
       def determine_sessions_folder(folder)
         return folder if folder && !options[:quiet]