bonchi 0.1.0.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4401b948510406e541ccd17bc7aa34faefcf8d9f420ea9d4126da8776a6b3fc4
+  data.tar.gz: 1eca2f4dad53e1cf516fabef0def984cec178a0a9a604171a0053aa59d8e13c9
+SHA512:
+  metadata.gz: a1798321638aa5711f9fa042c5f1a667fb4e8469ee887830fcbd5efff5676ee1ff110c9df38c65fdb5af2521e28ff737ac032709045d8cf3feca3dec758a6890
+  data.tar.gz: 81e208dcb8c0fb44445669bf34976b7a5fbfaff7e77fc4a6ce6ddd6c998165f3a5ddeb147bf93d57ecc128bf813a79b62fa0d98be0c0b9f765937b1a7c3323e0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Gert Goet
+
+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/exe/bonchi

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "bonchi"
+
+Bonchi::CLI.start(ARGV)

data/lib/bonchi/cli.rb

@@ -0,0 +1,199 @@
+require "thor"
+
+module Bonchi
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "version", "Print version"
+    def version
+      puts "bonchi #{VERSION}"
+    end
+    map "--version" => :version
+    map "-v" => :version
+
+    desc "create BRANCH [BASE]", "Create new branch + worktree"
+    option :setup, type: :boolean, default: true, desc: "Run setup after creating worktree"
+    def create(branch, base = nil)
+      base ||= Git.default_base_branch
+      path = Git.worktree_dir(branch)
+
+      existing = Git.worktree_path_for(branch)
+      if existing
+        puts "Worktree already exists: #{existing}"
+        puts "BONCHI_CD:#{existing}"
+        return
+      end
+
+      Git.worktree_add_new_branch(path, branch, base)
+      puts "Worktree created at: #{path}"
+
+      if options[:setup] && Config.from_main_worktree
+        puts ""
+        Setup.new(worktree: path).run
+      else
+        puts "BONCHI_CD:#{path}"
+      end
+    end
+
+    desc "switch BRANCH", "Switch to existing branch in worktree"
+    def switch(branch)
+      existing = Git.worktree_path_for(branch)
+      if existing
+        puts "Worktree already exists: #{existing}"
+        puts "BONCHI_CD:#{existing}"
+        return
+      end
+
+      unless Git.branch_exists?(branch)
+        abort "Error: Branch '#{branch}' does not exist\nUse 'bonchi create #{branch}' to create a new branch"
+      end
+
+      path = Git.worktree_dir(branch)
+      Git.worktree_add(path, branch)
+      puts "Worktree created at: #{path}"
+
+      puts "BONCHI_CD:#{path}"
+    end
+
+    desc "pr NUMBER_OR_URL", "Checkout GitHub PR in worktree"
+    def pr(input)
+      pr_number = extract_pr_number(input)
+      branch = "pr-#{pr_number}"
+      path = Git.worktree_dir(branch)
+
+      existing = Git.worktree_path_for(branch)
+      if existing
+        puts "Worktree already exists: #{existing}"
+        puts "BONCHI_CD:#{existing}"
+        return
+      end
+
+      Git.fetch_pr(pr_number)
+      Git.worktree_add(path, branch)
+      puts "PR ##{pr_number} checked out at: #{path}"
+
+      puts "BONCHI_CD:#{path}"
+    end
+
+    desc "setup", "Run setup in current worktree (ports, copy, pre_setup, setup cmd)"
+    def setup
+      Setup.new.run
+    end
+
+    desc "list", "List all worktrees"
+    def list
+      Git.worktree_list.each { |line| puts line }
+    end
+
+    desc "remove BRANCH", "Remove a worktree"
+    def remove(branch)
+      path = Git.worktree_path_for(branch)
+      abort "Error: No worktree found for branch: #{branch}" unless path
+
+      Git.worktree_remove(path)
+      puts "Removed worktree: #{path}"
+    end
+
+    desc "prune", "Prune stale worktree admin files"
+    def prune
+      Git.worktree_prune
+      puts "Pruned stale worktree administrative files"
+    end
+
+    desc "shellenv", "Output shell function for auto-cd + completions"
+    def shellenv
+      puts SHELL_ENV
+    end
+
+    map "sw" => :switch
+    map "ls" => :list
+    map "rm" => :remove
+
+    private
+
+    def extract_pr_number(input)
+      case input
+      when %r{^https://github.com/.*/pull/(\d+)}
+        $1
+      when /^\d+$/
+        input
+      else
+        abort "Error: Invalid PR number or URL: #{input}"
+      end
+    end
+
+    SHELL_ENV = <<~'SHELL'
+      bonchi() {
+          local output
+          output=$(command bonchi "$@")
+          local exit_code=$?
+          echo "$output"
+          if [ $exit_code -eq 0 ]; then
+              local cd_path=$(echo "$output" | grep "^BONCHI_CD:" | cut -d: -f2-)
+              [ -n "$cd_path" ] && cd "$cd_path"
+          fi
+          return $exit_code
+      }
+
+      # Bash completion
+      if [ -n "$BASH_VERSION" ]; then
+          _bonchi_complete() {
+              local cur prev commands
+              COMPREPLY=()
+              cur="${COMP_WORDS[COMP_CWORD]}"
+              prev="${COMP_WORDS[COMP_CWORD-1]}"
+              commands="create switch sw pr setup list ls remove rm prune shellenv help"
+
+              if [ $COMP_CWORD -eq 1 ]; then
+                  COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+                  return 0
+              fi
+
+              case "$prev" in
+                  switch|sw|remove|rm)
+                      local branches
+                      branches=$(git worktree list 2>/dev/null | sed -n 's/.*\[\([^]]*\)\].*/\1/p' | tail -n +2)
+                      COMPREPLY=( $(compgen -W "$branches" -- "$cur") )
+                      return 0
+                      ;;
+              esac
+          }
+          complete -F _bonchi_complete bonchi
+      fi
+
+      # Zsh completion
+      if [ -n "$ZSH_VERSION" ]; then
+          _bonchi_complete_zsh() {
+              local -a commands branches
+              commands=(
+                  'create:Create new branch + worktree'
+                  'switch:Switch to existing branch in worktree'
+                  'sw:Switch to existing branch in worktree'
+                  'pr:Checkout GitHub PR in worktree'
+                  'setup:Run setup in current worktree'
+                  'list:List all worktrees'
+                  'ls:List all worktrees'
+                  'remove:Remove a worktree'
+                  'rm:Remove a worktree'
+                  'prune:Prune stale worktree admin files'
+                  'shellenv:Output shell function for auto-cd'
+              )
+
+              if (( CURRENT == 2 )); then
+                  _describe 'command' commands
+              elif (( CURRENT == 3 )); then
+                  case "$words[2]" in
+                      switch|sw|remove|rm)
+                          branches=(${(f)"$(git worktree list 2>/dev/null | sed -n 's/.*\[\([^]]*\)\].*/\1/p' | tail -n +1)"})
+                          _describe 'branch' branches
+                          ;;
+                  esac
+              fi
+          }
+          compdef _bonchi_complete_zsh bonchi
+      fi
+    SHELL
+  end
+end

data/lib/bonchi/config.rb

@@ -0,0 +1,23 @@
+require "yaml"
+
+module Bonchi
+  class Config
+    attr_reader :copy, :ports, :pre_setup, :setup
+
+    def initialize(path)
+      data = YAML.load_file(path)
+      @copy = Array(data["copy"])
+      @ports = Array(data["ports"])
+      @pre_setup = Array(data["pre_setup"])
+      @setup = data["setup"] || "bin/setup"
+    end
+
+    def self.from_main_worktree
+      main = Git.main_worktree
+      path = File.join(main, ".worktree.yml")
+      return nil unless File.exist?(path)
+
+      new(path)
+    end
+  end
+end

data/lib/bonchi/git.rb

@@ -0,0 +1,64 @@
+require "shellwords"
+
+module Bonchi
+  module Git
+    module_function
+
+    def repo_name
+      url = `git remote get-url origin 2>/dev/null`.strip
+      base = url.empty? ? `git rev-parse --show-toplevel`.strip : url
+      File.basename(base, ".git")
+    end
+
+    def default_base_branch
+      ref = `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null`.strip
+      ref.empty? ? "main" : ref.sub(%r{^refs/remotes/origin/}, "")
+    end
+
+    def main_worktree
+      `git worktree list --porcelain`.lines.first.sub("worktree ", "").strip
+    end
+
+    def worktree_list
+      `git worktree list`.lines.map(&:strip).reject(&:empty?)
+    end
+
+    def worktree_branches
+      worktree_list.filter_map { |line| line[/\[([^\]]+)\]/, 1] }
+    end
+
+    def worktree_path_for(branch)
+      line = `git worktree list`.lines.find { |l| l.include?("[#{branch}]") }
+      line&.split(/\s+/)&.first
+    end
+
+    def branch_exists?(branch)
+      system("git show-ref --verify --quiet refs/heads/#{branch.shellescape}") ||
+        system("git show-ref --verify --quiet refs/remotes/origin/#{branch.shellescape}")
+    end
+
+    def worktree_add(path, branch)
+      system("git", "worktree", "add", path, branch) || abort("Failed to add worktree")
+    end
+
+    def worktree_add_new_branch(path, branch, base)
+      system("git", "worktree", "add", path, "-b", branch, base) || abort("Failed to add worktree")
+    end
+
+    def worktree_remove(path)
+      system("git", "worktree", "remove", path) || abort("Failed to remove worktree")
+    end
+
+    def worktree_prune
+      system("git", "worktree", "prune")
+    end
+
+    def fetch_pr(pr_number)
+      system("git", "fetch", "origin", "pull/#{pr_number}/head:pr-#{pr_number}")
+    end
+
+    def worktree_dir(branch)
+      File.join(GlobalConfig.new.worktree_root, repo_name, branch)
+    end
+  end
+end

data/lib/bonchi/global_config.rb

@@ -0,0 +1,34 @@
+require "yaml"
+require "fileutils"
+
+module Bonchi
+  class GlobalConfig
+    def initialize
+      @path = self.class.config_path
+      @data = if File.exist?(@path)
+        YAML.safe_load_file(@path) || {}
+      else
+        {}
+      end
+    end
+
+    attr_reader :path, :data
+
+    def worktree_root
+      ENV.fetch("WORKTREE_ROOT") {
+        @data["worktree_root"] || File.join(Dir.home, "dev", "worktrees")
+      }
+    end
+
+    def self.config_path
+      xdg = ENV["XDG_CONFIG_HOME"]
+      if xdg && !xdg.empty?
+        dir = File.join(xdg, "bonchi")
+        FileUtils.mkdir_p(dir)
+        File.join(dir, "config.yml")
+      else
+        File.expand_path("~/.bonchi.yml")
+      end
+    end
+  end
+end

data/lib/bonchi/port_pool.rb

@@ -0,0 +1,80 @@
+require "yaml"
+require "socket"
+require "set"
+
+module Bonchi
+  class PortPool
+    DEFAULT_MIN = 4000
+    DEFAULT_MAX = 5000
+
+    def initialize
+      @path = GlobalConfig.config_path
+      load_config
+    end
+
+    def allocate(worktree_path, port_names)
+      prune_stale
+
+      existing = @allocated[worktree_path] || {}
+      if port_names.all? { |name| existing[name] }
+        port_names.each_with_object({}) do |name, result|
+          result[name] = existing[name]
+          puts "Reusing port #{existing[name]} for #{name}"
+        end
+      else
+        used = @allocated.reject { |k, _| k == worktree_path }
+          .values.flat_map { |ports| ports.values }.to_set
+
+        new_ports = {}
+        port_names.each do |name|
+          port = (@min..@max).find { |p| !used.include?(p) && port_available?(p) }
+          abort "Error: no available port for #{name}" unless port
+          used << port
+          new_ports[name] = port
+          puts "Allocated port #{port} for #{name}"
+        end
+
+        @allocated[worktree_path] = new_ports
+        save_config
+        new_ports
+      end
+    end
+
+    private
+
+    def load_config
+      if File.exist?(@path)
+        data = YAML.safe_load_file(@path) || {}
+      else
+        data = {}
+      end
+      pool = data["port_pool"] || {}
+      @min = pool["min"] || DEFAULT_MIN
+      @max = pool["max"] || DEFAULT_MAX
+      @allocated = pool["allocated"] || {}
+    end
+
+    def save_config
+      data = {
+        "port_pool" => {
+          "min" => @min,
+          "max" => @max,
+          "allocated" => @allocated
+        }
+      }
+      File.write(@path, YAML.dump(data))
+    end
+
+    def prune_stale
+      @allocated.delete_if { |path, _| !File.directory?(path) }
+    end
+
+    def port_available?(port)
+      server = TCPServer.new("127.0.0.1", port)
+      server.close
+      true
+    rescue Errno::EADDRINUSE
+      false
+    end
+  end
+end

data/lib/bonchi/setup.rb

@@ -0,0 +1,66 @@
+require "fileutils"
+require "shellwords"
+
+module Bonchi
+  class Setup
+    def initialize(worktree: nil)
+      @worktree = worktree || Dir.pwd
+      @main_worktree = Git.main_worktree
+    end
+
+    def run(args = [])
+      if @worktree == @main_worktree
+        abort "Error: already in the main worktree"
+      end
+
+      config = Config.from_main_worktree
+      abort "Error: .worktree.yml not found in main worktree" unless config
+
+      ENV["MAIN_WORKTREE"] = @main_worktree
+      ENV["WORKTREE"] = @worktree
+
+      puts "Setting up worktree from: #{@main_worktree}"
+
+      allocate_ports(config.ports) if config.ports.any?
+      copy_files(config.copy)
+      run_pre_setup(config.pre_setup)
+      exec_setup(config.setup, args)
+    end
+
+    private
+
+    def allocate_ports(port_names)
+      pool = PortPool.new
+      ports = pool.allocate(@worktree, port_names)
+      ports.each { |name, port| ENV[name] = port.to_s }
+    end
+
+    def copy_files(files)
+      files.each do |file|
+        src = File.join(@main_worktree, file)
+        if File.exist?(src)
+          FileUtils.cp(src, File.join(@worktree, file))
+          puts "Copied #{file}"
+        else
+          puts "Warning: #{file} not found in main worktree, skipping"
+        end
+      end
+    end
+
+    def run_pre_setup(commands)
+      commands.each do |cmd|
+        puts "Running: #{cmd}"
+        Dir.chdir(@worktree) do
+          system(cmd) || abort("Command failed: #{cmd}")
+        end
+      end
+    end
+
+    def exec_setup(setup_cmd, args)
+      puts "\n== Running #{setup_cmd} =="
+      Dir.chdir(@worktree) do
+        exec(*setup_cmd.shellsplit, *args)
+      end
+    end
+  end
+end

data/lib/bonchi/version.rb

@@ -0,0 +1,3 @@
+module Bonchi
+  VERSION = "0.1.0.dev"
+end

data/lib/bonchi.rb

@@ -0,0 +1,10 @@
+require_relative "bonchi/version"
+require_relative "bonchi/global_config"
+require_relative "bonchi/git"
+require_relative "bonchi/config"
+require_relative "bonchi/port_pool"
+require_relative "bonchi/setup"
+require_relative "bonchi/cli"
+
+module Bonchi
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: bonchi
+version: !ruby/object:Gem::Version
+  version: 0.1.0.dev
+platform: ruby
+authors:
+- Gert Goet
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Manage git worktrees with automatic port allocation, file copying, and
+  setup commands
+executables:
+- bonchi
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- exe/bonchi
+- lib/bonchi.rb
+- lib/bonchi/cli.rb
+- lib/bonchi/config.rb
+- lib/bonchi/git.rb
+- lib/bonchi/global_config.rb
+- lib/bonchi/port_pool.rb
+- lib/bonchi/setup.rb
+- lib/bonchi/version.rb
+homepage: https://github.com/gertgoet/bonchi
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Git worktree manager
+test_files: []