git_worktree_manager 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b65284335c00fd4d1c52d5ec1502638ffa09124b1287d8530dcb6b5771bbc77c
+  data.tar.gz: 9601148263bd10cd38311c94de945be980fa0f8fc8f3848317ee5e307aa87d9c
+SHA512:
+  metadata.gz: 91881dfa53a2277f76e2994132ab28ba083d3bb433ddd607fbed542a14a803010a483c6b9f79903cfc6a4b1de96a0f039f7b2c7b3c63389af4003de05d771d47
+  data.tar.gz: 9751f6b855a7ccc289c506ea4d9c4fe41929a27e9849de47673f894120e2ef5aa3185427bc0065b924d7148d404423f16fe92718a1f94998a9994dc768900871

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Franck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# Git Worktree Manager
+
+A shell-agnostic Ruby gem for managing git worktrees with isolated databases, unique ports for Rails and Vite servers, and separate environments.
+
+## Features
+
+- ✅ **Shell Agnostic** - Works with bash, zsh, fish, or any POSIX shell
+- ✅ **Isolated Databases** - Each worktree gets its own PostgreSQL database  
+- ✅ **Automatic Port Assignment** - Rails (3001+) and Vite (5174+) ports
+- ✅ **Environment Management** - Copies and configures .env files
+- ✅ **Dependency Installation** - Auto-runs bundle/yarn install
+- ✅ **Easy Cleanup** - Remove worktrees and databases with one command
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'git_worktree_manager'
+```
+
+Then run:
+
+```bash
+bundle install
+rails generate git_worktree_manager:install
+```
+
+This will install the `worktree` command in your project's `bin/` directory.
+
+### Shell Function (for cd functionality)
+
+Add this to your shell config file:
+
+**For Bash/Zsh (`~/.bashrc` or `~/.zshrc`):**
+
+```bash
+worktree() {
+  ./bin/worktree "$@"
+  if [ -f /tmp/worktree_cd_$$ ]; then
+    cd "$(cat /tmp/worktree_cd_$$)"
+    rm /tmp/worktree_cd_$$
+  fi
+}
+```
+
+**For Fish (`~/.config/fish/config.fish`):**
+
+```fish
+function worktree
+  ./bin/worktree $argv
+  if test -f /tmp/worktree_cd_(echo %self)
+    cd (cat /tmp/worktree_cd_(echo %self))
+    rm /tmp/worktree_cd_(echo %self)
+  end
+end
+```
+
+## Configuration
+
+On first use, the gem will auto-detect your main database name from `config/database.yml` or `.env` files. You can view or change the configuration:
+
+```bash
+worktree config
+worktree config --main-database=myapp_development
+worktree config --database-prefix=myapp
+```
+
+The configuration is stored in `.worktree_config.yml` in your project root.
+
+## Usage
+
+```bash
+worktree create feature-branch-name
+worktree list
+worktree status feature-branch-name
+worktree start feature-branch-name
+worktree remove feature-branch-name
+worktree cleanup
+worktree config
+```
+
+### Options
+
+**Create:**
+- `--copy-data` - Copy data from main database to worktree database
+- `--no-install` - Skip bundle/yarn install
+
+## Requirements
+
+- Ruby >= 3.0.0
+- Git
+- PostgreSQL (optional, only if using database features)
+- Rails project
+
+## Recommendations
+
+Add `.worktree_config.yml` to your `.gitignore` if you don't want to share worktree configuration with your team:
+
+```bash
+echo ".worktree_config.yml" >> .gitignore
+```
+
+## License
+
+MIT License

data/bin/worktree

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'bundler/setup'
+  require 'git_worktree_manager'
+rescue LoadError => e
+  $stderr.puts "Error loading git_worktree_manager: #{e.message}"
+  $stderr.puts "Make sure the gem is installed: bundle install"
+  exit 1
+end
+
+begin
+  GitWorktreeManager::CLI.start(ARGV)
+rescue Interrupt
+  puts "\n"
+  puts "Interrupted"
+  exit 130
+rescue => e
+  puts "Error: #{e.message}"
+  puts e.backtrace if ENV['DEBUG']
+  exit 1
+end

data/lib/generators/git_worktree_manager/install_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators'
+
+module GitWorktreeManager
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../../..', __dir__)
+
+      def copy_executable
+        template 'bin/worktree', 'bin/worktree'
+        chmod 'bin/worktree', 0o755
+      end
+
+      def show_readme
+        readme 'INSTALL_README' if behavior == :invoke
+      end
+
+      private
+
+      def readme(_filename)
+        say "\n" + '=' * 80
+        say 'Git Worktree Manager installed successfully!'
+        say '=' * 80
+        say "\nThe 'worktree' command has been added to your project's bin/ directory."
+        say "\nYou can now use it with:"
+        say '  ./bin/worktree', :green
+        say "\nOr add ./bin to your PATH to use it directly:"
+        say '  export PATH="./bin:$PATH"', :cyan
+        say '  worktree', :green
+        say "\nRun './bin/worktree help' to see available commands."
+        say '=' * 80 + "\n"
+      end
+    end
+  end
+end

data/lib/git_worktree_manager/cli.rb

@@ -0,0 +1,53 @@
+require 'thor'
+
+module GitWorktreeManager
+  class CLI < Thor
+    desc 'create BRANCH', 'Create a new worktree for a branch'
+    option :copy_data, type: :boolean, default: false, desc: 'Copy database from main worktree'
+    option :no_install, type: :boolean, default: false, desc: 'Skip bundle/yarn install'
+    def create(branch)
+      Worktree.new.create(
+        branch,
+        copy_data: options[:copy_data],
+        no_install: options[:no_install]
+      )
+    end
+
+    desc 'list', 'List all worktrees with their info'
+    def list
+      Worktree.new.list
+    end
+
+    desc 'status BRANCH', 'Show status of a specific worktree'
+    def status(branch)
+      Worktree.new.status(branch)
+    end
+
+    desc 'start BRANCH', 'Start tmux session with servers for a worktree'
+    def start(branch)
+      Worktree.new.start(branch)
+    end
+
+    desc 'remove BRANCH', 'Remove a worktree and its database'
+    option :force, type: :boolean, default: false, aliases: '-f', desc: 'Force removal without confirmation'
+    def remove(branch)
+      Worktree.new.remove(branch, force: options[:force])
+    end
+
+    desc 'cleanup', 'Clean up stale worktree references'
+    def cleanup
+      Worktree.new.cleanup
+    end
+
+    desc 'config', 'Show or set configuration'
+    option :main_database, type: :string, desc: 'Set the main database name'
+    option :database_prefix, type: :string, desc: 'Set the database prefix for worktrees'
+    def config
+      Worktree.new.config(options)
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+  end
+end

data/lib/git_worktree_manager/config.rb

@@ -0,0 +1,139 @@
+require 'yaml'
+require 'fileutils'
+require 'time'
+
+module GitWorktreeManager
+  class Config
+    attr_reader :config_file, :root_path
+
+    def initialize(root_path)
+      @root_path = root_path
+      @config_file = File.join(root_path, '.worktree_config.yml')
+      @config = load_config
+      ensure_settings
+    end
+
+    def main_database
+      @config['settings']&.dig('main_database') || detect_main_database
+    end
+
+    def database_prefix
+      @config['settings']&.dig('database_prefix') || File.basename(@root_path)
+    end
+
+    def save_settings(main_database: nil, database_prefix: nil)
+      @config['settings'] ||= {}
+      @config['settings']['main_database'] = main_database if main_database
+      @config['settings']['database_prefix'] = database_prefix if database_prefix
+      save_config
+    end
+
+    def save_worktree(branch, path:, rails_port:, vite_port:, database:)
+      @config[normalize_branch_name(branch)] = {
+        'path' => path,
+        'rails_port' => rails_port,
+        'vite_port' => vite_port,
+        'database' => database,
+        'created_at' => Time.now.iso8601
+      }
+      save_config
+    end
+
+    def get_worktree(branch)
+      @config[normalize_branch_name(branch)]
+    end
+
+    def remove_worktree(branch)
+      @config.delete(normalize_branch_name(branch))
+      save_config
+    end
+
+    def all_worktrees
+      @config.select { |_k, v| v.is_a?(Hash) && v['path'] }
+    end
+
+    def next_ports
+      return [3001, 5174] if @config.empty?
+
+      rails_ports = @config.values.map { |v| v['rails_port'] }.compact
+      vite_ports = @config.values.map { |v| v['vite_port'] }.compact
+
+      max_rails = rails_ports.max || 3000
+      max_vite = vite_ports.max || 5173
+
+      rails_port = max_rails >= 3001 ? max_rails + 1 : 3001
+      vite_port = max_vite >= 5174 ? max_vite + 1 : 5174
+
+      [rails_port, vite_port]
+    end
+
+    private
+
+    def normalize_branch_name(branch)
+      branch.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+    end
+
+    def load_config
+      return {} unless File.exist?(@config_file)
+
+      YAML.load_file(@config_file) || {}
+    rescue StandardError => e
+      warn "Warning: Could not load config file: #{e.message}"
+      {}
+    end
+
+    def save_config
+      FileUtils.mkdir_p(File.dirname(@config_file))
+      File.write(@config_file, YAML.dump(@config))
+    end
+
+    def ensure_settings
+      return if @config['settings'] && @config['settings']['main_database'] && @config['settings']['database_prefix']
+
+      @config['settings'] ||= {}
+      @config['settings']['main_database'] ||= detect_main_database
+      @config['settings']['database_prefix'] ||= File.basename(@root_path)
+      save_config
+    end
+
+    def detect_main_database
+      db_config_path = File.join(@root_path, 'config', 'database.yml')
+
+      if File.exist?(db_config_path)
+        require 'yaml'
+        db_config = YAML.load_file(db_config_path)
+        return db_config.dig('development', 'database') if db_config.dig('development', 'database')
+      end
+
+      env_local = File.join(@root_path, '.env.local')
+      env_file = File.join(@root_path, '.env')
+
+      [env_local, env_file].each do |env_path|
+        next unless File.exist?(env_path)
+
+        File.readlines(env_path).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#')
+
+          return ::Regexp.last_match(1).strip.gsub(/^["']|["']$/, '') if line =~ /^DB_NAME=(.+)$/
+        end
+      end
+
+      "#{File.basename(@root_path)}_development"
+    end
+
+    def load_config
+      return {} unless File.exist?(@config_file)
+
+      YAML.load_file(@config_file) || {}
+    rescue StandardError => e
+      warn "Warning: Could not load config file: #{e.message}"
+      {}
+    end
+
+    def save_config
+      FileUtils.mkdir_p(File.dirname(@config_file))
+      File.write(@config_file, YAML.dump(@config))
+    end
+  end
+end

data/lib/git_worktree_manager/database.rb

@@ -0,0 +1,81 @@
+require 'shellwords'
+
+module GitWorktreeManager
+  class Database
+    def initialize(credentials, logger)
+      @credentials = credentials
+      @logger = logger
+    end
+    
+    def create(database_name)
+      run_rails_command("db:create", database_name)
+    end
+    
+    def migrate(database_name)
+      run_rails_command("db:migrate", database_name)
+    end
+    
+    def drop(database_name)
+      cmd = build_dropdb_command(database_name)
+      env = { 'PGPASSWORD' => @credentials[:password].to_s }
+      
+      success = system(env, cmd, out: File::NULL, err: File::NULL)
+      
+      if success
+        @logger.success("Database dropped")
+      else
+        @logger.warning("Failed to drop database (may not exist)")
+      end
+    end
+    
+    def copy(source_db, target_db)
+      dump_cmd = build_pg_dump_command(source_db)
+      psql_cmd = build_psql_command(target_db)
+      
+      env = { 'PGPASSWORD' => @credentials[:password].to_s }
+      full_cmd = "#{dump_cmd} | #{psql_cmd}"
+      
+      success = system(env, full_cmd)
+      
+      if success
+        @logger.success("Database copied successfully")
+      else
+        @logger.warning("Failed to copy database data (this is optional)")
+      end
+    end
+    
+    private
+    
+    def run_rails_command(task, database_name)
+      env = {
+        'RAILS_ENV' => 'development',
+        'DB_NAME' => database_name
+      }
+      system(env, "bundle exec rails #{task}")
+    end
+    
+    def build_dropdb_command(database_name)
+      cmd = "dropdb"
+      cmd += " -h #{Shellwords.escape(@credentials[:host])}" if @credentials[:host]
+      cmd += " -U #{Shellwords.escape(@credentials[:user])}" if @credentials[:user]
+      cmd += " #{Shellwords.escape(database_name)}"
+      cmd
+    end
+    
+    def build_pg_dump_command(database_name)
+      cmd = "pg_dump"
+      cmd += " -h #{Shellwords.escape(@credentials[:host])}" if @credentials[:host]
+      cmd += " -U #{Shellwords.escape(@credentials[:user])}" if @credentials[:user]
+      cmd += " #{Shellwords.escape(database_name)}"
+      cmd
+    end
+    
+    def build_psql_command(database_name)
+      cmd = "psql"
+      cmd += " -h #{Shellwords.escape(@credentials[:host])}" if @credentials[:host]
+      cmd += " -U #{Shellwords.escape(@credentials[:user])}" if @credentials[:user]
+      cmd += " #{Shellwords.escape(database_name)}"
+      cmd
+    end
+  end
+end

data/lib/git_worktree_manager/environment.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+
+module GitWorktreeManager
+  class Environment
+    def initialize(project_root)
+      @project_root = project_root
+    end
+    
+    def setup_env_files(worktree_path, rails_port:, vite_port:, database:, db_credentials:)
+      copy_env_files(worktree_path)
+      append_worktree_config(worktree_path, rails_port, vite_port, database, db_credentials)
+    end
+    
+    def read_db_credentials
+      credentials = {}
+      
+      ['.env.local', '.env'].each do |env_file|
+        env_path = File.join(@project_root, env_file)
+        next unless File.exist?(env_path)
+        
+        File.readlines(env_path).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#')
+          
+          if line =~ /^DB_USER=(.+)$/
+            credentials[:user] ||= unquote($1)
+          elsif line =~ /^DB_PASSWORD=(.+)$/
+            credentials[:password] ||= unquote($1)
+          elsif line =~ /^DB_HOST=(.+)$/
+            credentials[:host] ||= unquote($1)
+          end
+        end
+      end
+      
+      credentials[:user] ||= 'postgres'
+      credentials[:password] ||= 'postgres'
+      credentials[:host] ||= 'localhost'
+      
+      credentials
+    end
+    
+    private
+    
+    def copy_env_files(worktree_path)
+      ['.env', '.env.local'].each do |env_file|
+        source = File.join(@project_root, env_file)
+        target = File.join(worktree_path, env_file)
+        
+        FileUtils.cp(source, target) if File.exist?(source)
+      end
+    end
+    
+    def append_worktree_config(worktree_path, rails_port, vite_port, database, db_credentials)
+      env_local = File.join(worktree_path, '.env.local')
+      
+      config = <<~CONFIG
+        
+        # Worktree-specific configuration
+        DB_NAME=#{database}
+        DB_USER=#{db_credentials[:user]}
+        DB_PASSWORD=#{db_credentials[:password]}
+        DB_HOST=#{db_credentials[:host]}
+        RAILS_PORT=#{rails_port}
+        VITE_PORT=#{vite_port}
+      CONFIG
+      
+      File.open(env_local, 'a') { |f| f.write(config) }
+    end
+    
+    def unquote(value)
+      value.strip.gsub(/^["']|["']$/, '')
+    end
+  end
+end

data/lib/git_worktree_manager/git_operations.rb

@@ -0,0 +1,63 @@
+require 'open3'
+require 'shellwords'
+require 'fileutils'
+
+module GitWorktreeManager
+  class GitOperations
+    def initialize(project_root, logger)
+      @project_root = project_root
+      @logger = logger
+    end
+    
+    def worktree_exists?(path)
+      Dir.exist?(path)
+    end
+    
+    def branch_exists?(branch)
+      cmd = "git rev-parse --verify #{Shellwords.escape(branch)}"
+      system(cmd, out: File::NULL, err: File::NULL)
+    end
+    
+    def create_worktree(path, branch)
+      Dir.chdir(@project_root) do
+        if branch_exists?(branch)
+          @logger.info("Checking out existing branch: #{branch}")
+          system("git worktree add #{Shellwords.escape(path)} #{Shellwords.escape(branch)}")
+        else
+          @logger.info("Creating new branch: #{branch}")
+          system("git worktree add -b #{Shellwords.escape(branch)} #{Shellwords.escape(path)}")
+        end
+      end
+    end
+    
+    def remove_worktree(path)
+      Dir.chdir(@project_root) do
+        system("git worktree remove #{Shellwords.escape(path)} --force 2>/dev/null")
+        
+        if Dir.exist?(path)
+          FileUtils.rm_rf(path)
+        end
+      end
+    end
+    
+    def list_worktrees
+      Dir.chdir(@project_root) do
+        output, _status = Open3.capture2("git worktree list")
+        output
+      end
+    end
+    
+    def prune_worktrees
+      Dir.chdir(@project_root) do
+        system("git worktree prune")
+      end
+    end
+    
+    def git_status(worktree_path)
+      Dir.chdir(worktree_path) do
+        output, _status = Open3.capture2("git status -sb")
+        output
+      end
+    end
+  end
+end

data/lib/git_worktree_manager/logger.rb

@@ -0,0 +1,29 @@
+require 'pastel'
+
+module GitWorktreeManager
+  class Logger
+    def initialize
+      @pastel = Pastel.new
+    end
+    
+    def info(message)
+      puts "#{@pastel.blue('ℹ')} #{message}"
+    end
+    
+    def success(message)
+      puts "#{@pastel.green('✓')} #{message}"
+    end
+    
+    def warning(message)
+      puts "#{@pastel.yellow('⚠')} #{message}"
+    end
+    
+    def error(message)
+      puts "#{@pastel.red('✗')} #{message}"
+    end
+    
+    def plain(message)
+      puts message
+    end
+  end
+end

data/lib/git_worktree_manager/ports.rb

@@ -0,0 +1,13 @@
+module GitWorktreeManager
+  class Ports
+    def self.check_port_available(port)
+      cmd = "lsof -i :#{port}"
+      !system(cmd, out: File::NULL, err: File::NULL)
+    end
+    
+    def self.find_process_on_port(port)
+      output = `lsof -i :#{port} 2>/dev/null | grep LISTEN`
+      output.strip.empty? ? nil : output
+    end
+  end
+end

data/lib/git_worktree_manager/shell.rb

@@ -0,0 +1,30 @@
+require 'shellwords'
+
+module GitWorktreeManager
+  class Shell
+    def self.change_directory(path)
+      marker_file = "/tmp/worktree_cd_#{Process.pid}"
+      File.write(marker_file, path)
+      
+      Dir.chdir(path) if Dir.exist?(path)
+    end
+    
+    def self.spawn_shell_in_directory(path)
+      Dir.chdir(path) if Dir.exist?(path)
+      
+      shell = ENV['SHELL'] || '/bin/bash'
+      
+      change_directory(path)
+      
+      exec(shell)
+    end
+    
+    def self.current_shell
+      ENV['SHELL'] || '/bin/bash'
+    end
+    
+    def self.in_directory?(current_path, target_path)
+      current_path.start_with?(target_path)
+    end
+  end
+end

data/lib/git_worktree_manager/version.rb

@@ -0,0 +1,3 @@
+module GitWorktreeManager
+  VERSION = "0.1.0"
+end

data/lib/git_worktree_manager/worktree.rb

@@ -0,0 +1,345 @@
+require 'fileutils'
+require 'tty-prompt'
+require 'tty-table'
+
+module GitWorktreeManager
+  class Worktree
+    def initialize(project_root: nil)
+      @project_root = project_root || detect_project_root
+      @project_name = File.basename(@project_root)
+      @parent_dir = File.dirname(@project_root)
+
+      @logger = Logger.new
+      @config = Config.new(@project_root)
+      @env = Environment.new(@project_root)
+      @git = GitOperations.new(@project_root, @logger)
+    end
+
+    def create(branch, copy_data: false, no_install: false)
+      worktree_name = "#{@project_name}-#{branch}"
+      worktree_path = File.join(@parent_dir, worktree_name)
+
+      if @git.worktree_exists?(worktree_path)
+        @logger.error("Worktree already exists at #{worktree_path}")
+        exit 1
+      end
+
+      @logger.info("Creating worktree for branch: #{branch}")
+
+      unless @git.create_worktree(worktree_path, branch)
+        @logger.error('Failed to create worktree')
+        exit 1
+      end
+
+      @logger.success("Worktree created at #{worktree_path}")
+
+      rails_port, vite_port = @config.next_ports
+      db_prefix = @config.database_prefix
+      db_name = "#{db_prefix}_development_#{branch.gsub(/[^a-zA-Z0-9]/, '_')}"
+
+      @logger.info('Setting up environment (.env and .env.local)')
+
+      db_credentials = @env.read_db_credentials
+      @env.setup_env_files(
+        worktree_path,
+        rails_port: rails_port,
+        vite_port: vite_port,
+        database: db_name,
+        db_credentials: db_credentials
+      )
+
+      @logger.success("Environment configured (Rails: #{rails_port}, Vite: #{vite_port}, DB: #{db_name})")
+
+      @config.save_worktree(
+        branch,
+        path: worktree_path,
+        rails_port: rails_port,
+        vite_port: vite_port,
+        database: db_name
+      )
+
+      Dir.chdir(worktree_path)
+
+      install_dependencies unless no_install
+
+      setup_database(db_name, db_credentials, copy_data)
+
+      @logger.success('Worktree setup complete!')
+      @logger.plain('')
+      @logger.info('Environment configured:')
+      @logger.plain("  Rails port: #{rails_port}")
+      @logger.plain("  Vite port:  #{vite_port}")
+      @logger.plain("  Database:   #{db_name}")
+      @logger.plain('')
+      @logger.info('To start servers, run: ./.tmux')
+
+      Shell.spawn_shell_in_directory(worktree_path)
+    end
+
+    def list
+      @logger.info('Git Worktrees:')
+      @logger.plain('')
+      @logger.plain(@git.list_worktrees)
+
+      @logger.plain('')
+      @logger.info('Configured Worktrees:')
+      @logger.plain('')
+
+      worktrees = @config.all_worktrees
+
+      if worktrees.empty?
+        @logger.warning('No worktree configuration found')
+        return
+      end
+
+      rows = worktrees.map do |branch, info|
+        next unless Dir.exist?(info['path'])
+
+        [
+          branch,
+          "#{info['rails_port']}:#{info['vite_port']}",
+          info['database'],
+          info['path']
+        ]
+      end.compact
+
+      table = TTY::Table.new(
+        header: ['BRANCH', 'RAILS:VITE', 'DATABASE', 'PATH'],
+        rows: rows
+      )
+
+      puts table.render(:basic)
+    end
+
+    def status(branch)
+      info = @config.get_worktree(branch)
+
+      unless info
+        @logger.error("Worktree not found for branch: #{branch}")
+        exit 1
+      end
+
+      @logger.plain("Branch:      #{branch}")
+      @logger.plain("Path:        #{info['path']}")
+      @logger.plain("Rails Port:  #{info['rails_port']}")
+      @logger.plain("Vite Port:   #{info['vite_port']}")
+      @logger.plain("Database:    #{info['database']}")
+      @logger.plain('')
+
+      if Dir.exist?(info['path'])
+        @logger.success('Worktree directory exists')
+      else
+        @logger.error('Worktree directory not found')
+      end
+
+      @logger.plain('')
+      @logger.info('Git status:')
+      @logger.plain(@git.git_status(info['path']))
+
+      @logger.plain('')
+      @logger.info('Server status:')
+
+      check_port_status(info['rails_port'], 'Rails')
+      check_port_status(info['vite_port'], 'Vite')
+    end
+
+    def start(branch)
+      info = @config.get_worktree(branch)
+
+      unless info
+        @logger.error("Worktree not found for branch: #{branch}")
+        exit 1
+      end
+
+      worktree_path = info['path']
+
+      unless Dir.exist?(worktree_path)
+        @logger.error("Worktree directory not found: #{worktree_path}")
+        exit 1
+      end
+
+      @logger.info("Starting tmux session for branch: #{branch}")
+      @logger.info("Path: #{worktree_path}")
+      @logger.info("Rails port: #{info['rails_port']}, Vite port: #{info['vite_port']}")
+      @logger.plain('')
+
+      Dir.chdir(worktree_path)
+
+      tmux_script = File.join(worktree_path, '.tmux')
+
+      if File.exist?(tmux_script)
+        exec(tmux_script)
+      else
+        @logger.error('.tmux script not found')
+        @logger.info('Start servers manually:')
+        @logger.plain("  rails s -p #{info['rails_port']}")
+        @logger.plain("  VITE_RUBY_PORT=#{info['vite_port']} bin/vite dev")
+        exit 1
+      end
+    end
+
+    def remove(branch, force: false)
+      info = @config.get_worktree(branch)
+
+      unless info
+        worktree_name = "#{@project_name}-#{branch}"
+        worktree_path = File.join(@parent_dir, worktree_name)
+
+        if Dir.exist?(worktree_path) && @git.worktree_exists?(worktree_path)
+          @logger.warning("Worktree exists but not configured. Attempting to remove: #{worktree_path}")
+
+          unless force
+            prompt = TTY::Prompt.new
+            return unless prompt.yes?('Remove unconfigured worktree?')
+          end
+
+          current_dir = Dir.pwd
+          Shell.in_directory?(current_dir, worktree_path)
+
+          @git.remove_worktree(worktree_path)
+          @logger.success('Worktree removed')
+
+          @logger.info('Navigating to main worktree...')
+          Shell.spawn_shell_in_directory(@project_root)
+          return
+        end
+
+        @logger.error("Worktree not found for branch: #{branch}")
+        exit 1
+      end
+
+      worktree_path = info['path']
+      db_name = info['database']
+
+      unless force
+        @logger.warning('This will remove:')
+        @logger.plain("  - Worktree at: #{worktree_path}")
+        @logger.plain("  - Database: #{db_name}")
+        @logger.plain('')
+
+        prompt = TTY::Prompt.new
+        return unless prompt.yes?('Are you sure?')
+      end
+
+      @logger.info('Removing worktree...')
+
+      current_dir = Dir.pwd
+      Shell.in_directory?(current_dir, worktree_path)
+
+      @git.remove_worktree(worktree_path)
+      @logger.success('Worktree removed')
+
+      if db_name
+        @logger.info("Dropping database: #{db_name}")
+        db_credentials = @env.read_db_credentials
+        db = Database.new(db_credentials, @logger)
+        db.drop(db_name)
+      end
+
+      @config.remove_worktree(branch)
+      @logger.success('Cleanup complete')
+
+      @logger.info('Navigating to main worktree...')
+      Shell.spawn_shell_in_directory(@project_root)
+    end
+
+    def cleanup
+      @logger.info('Cleaning up stale worktree references...')
+
+      @git.prune_worktrees
+
+      worktrees = @config.all_worktrees
+      cleaned = 0
+
+      worktrees.each do |branch, info|
+        unless Dir.exist?(info['path'])
+          @logger.info("Removing stale config for: #{branch}")
+          @config.remove_worktree(branch)
+          cleaned += 1
+        end
+      end
+
+      @logger.success("Cleaned up #{cleaned} stale configuration(s)")
+    end
+    
+    def config(options)
+      if options[:main_database] || options[:database_prefix]
+        @config.save_settings(
+          main_database: options[:main_database],
+          database_prefix: options[:database_prefix]
+        )
+        @logger.success('Configuration updated')
+      end
+      
+      @logger.plain('Current configuration:')
+      @logger.plain('')
+      @logger.plain("  Main database:   #{@config.main_database}")
+      @logger.plain("  Database prefix: #{@config.database_prefix}")
+      @logger.plain('')
+      @logger.info('To change settings, use:')
+      @logger.plain('  worktree config --main-database=mydb_development')
+      @logger.plain('  worktree config --database-prefix=myproject')
+    end
+
+      @logger.success("Cleaned up #{cleaned} stale configuration(s)")
+    end
+
+    private
+
+    def detect_project_root
+      current_dir = Dir.pwd
+
+      current_dir = File.dirname(current_dir) until current_dir == '/' || File.exist?(File.join(current_dir, '.git'))
+
+      if current_dir == '/'
+        puts 'Error: Not in a git repository'
+        exit 1
+      end
+
+      current_dir
+    end
+
+    def install_dependencies
+      @logger.info('Installing dependencies...')
+
+      if File.exist?('Gemfile')
+        @logger.info('Running bundle install...')
+        system('bundle install')
+      end
+
+      if File.exist?('package.json')
+        @logger.info('Running yarn install...')
+        system('yarn install')
+      end
+
+      @logger.success('Dependencies installed')
+    end
+
+    def setup_database(db_name, db_credentials, copy_data)
+      db = Database.new(db_credentials, @logger)
+
+      @logger.info("Creating database: #{db_name}")
+      db.create(db_name)
+
+      @logger.info('Running migrations...')
+      db.migrate(db_name)
+
+      return unless copy_data
+
+      main_db = @config.main_database
+      @logger.info("Copying data from #{main_db} to #{db_name}...")
+      db.copy(main_db, db_name)
+    end
+
+    def check_port_status(port, server_name)
+      process_info = Ports.find_process_on_port(port)
+
+      if process_info
+        @logger.success("#{server_name} server is running on port #{port}")
+        @logger.plain(process_info)
+      else
+        @logger.info("#{server_name} server is not running on port #{port}")
+      end
+    end
+  end
+end

data/lib/git_worktree_manager.rb

@@ -0,0 +1,15 @@
+require_relative 'git_worktree_manager/version'
+require_relative 'git_worktree_manager/logger'
+require_relative 'git_worktree_manager/config'
+require_relative 'git_worktree_manager/environment'
+require_relative 'git_worktree_manager/database'
+require_relative 'git_worktree_manager/shell'
+require_relative 'git_worktree_manager/git_operations'
+require_relative 'git_worktree_manager/ports'
+require_relative 'git_worktree_manager/worktree'
+require_relative 'git_worktree_manager/cli'
+
+require_relative 'generators/git_worktree_manager/install_generator' if defined?(Rails::Railtie)
+
+module GitWorktreeManager
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: git_worktree_manager
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Franck
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: Shell-agnostic tool for managing Rails git worktrees with separate databases,
+  unique ports for Rails and Vite, and isolated environments
+email:
+- franck.dagostini@gmail.com
+executables:
+- worktree
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/worktree
+- lib/generators/git_worktree_manager/install_generator.rb
+- lib/git_worktree_manager.rb
+- lib/git_worktree_manager/cli.rb
+- lib/git_worktree_manager/config.rb
+- lib/git_worktree_manager/database.rb
+- lib/git_worktree_manager/environment.rb
+- lib/git_worktree_manager/git_operations.rb
+- lib/git_worktree_manager/logger.rb
+- lib/git_worktree_manager/ports.rb
+- lib/git_worktree_manager/shell.rb
+- lib/git_worktree_manager/version.rb
+- lib/git_worktree_manager/worktree.rb
+homepage: https://github.com/franck/git_worktree_manager
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Manage git worktrees with isolated databases and ports
+test_files: []