hiiro 0.1.50 → 0.1.51

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bec62fbab5b37a26be0c5ebb4dcd22ab074a34742591639ff307ccd5fced02e8
-  data.tar.gz: 8581b7676239c1a528a6d47defe0389b6e4494624e25e7c3978a2c5bc8e92d39
+  metadata.gz: 6181ad8d712bc544591aaa46f8c5c555b33f76cf6ed572cb70369f1f56b91bd9
+  data.tar.gz: 1a7490eb2e795ffab86b7b4ad1f24fe46fc6d0ba508e76bc074a88470b1eb437
 SHA512:
-  metadata.gz: 0143e20a9ed37176b309ee43ad2ce9bf2ad64a0f266fa8628f9321581b6c3cd31f250025bacefd941b79e48c9b2da6c931be7895e298ef6a2260539b28d2f07f
-  data.tar.gz: 2a37a1b8cc2991154a334aa54b60bb3243f5d3f4776936eb2b6c3b3f8b7166f00e6aafa1374d19faa7fbef535f85d6a1a658be4ff26aad42590ca7d8a4f60ba1
+  metadata.gz: 2ad79ec0a1e709d3cc7ce65e3142c23612b34f4b63e15d2811671cdca96858744f9dc57d2541b297df6e3abddaf61714ffe06f9491d694622ce129e65a3d5841
+  data.tar.gz: 7e9e81804965cb3d58a7baa8a2d2ed1597ff474ec0cf56998a86328fe91014286ff7604d7faf6940b6e09e91453afd357285f2be3d2160fb22455dea65275ec6

data/bin/h-app

@@ -11,11 +11,6 @@ def load_apps
   YAML.safe_load_file(APPS_FILE) || {}
 end
 
-def git_root
-  root = `git rev-parse --show-toplevel 2>/dev/null`.strip
-  root.empty? ? nil : root
-end
-
 def task_root
   # Fall back to current task's tree path if not in a git repo
   env = Environment.current rescue nil
@@ -28,12 +23,6 @@ def task_root
   tree&.path
 end
 
-def resolve_app_path(app_relative_path)
-  root = git_root || task_root
-  return nil unless root
-
-  File.join(root, app_relative_path)
-end
 
 def relative_cd_path(target_path)
   pwd = Pathname.new(Dir.pwd)
@@ -57,7 +46,7 @@ Hiiro.run(*ARGV, plugins: [:Tasks]) {
   }
 
   add_subcmd(:cd) { |app_name=nil|
-    root = git_root || task_root
+    root = git.root || task_root
 
     unless root
       puts "Not in a git repo or task - cannot resolve path"
@@ -97,4 +86,53 @@ Hiiro.run(*ARGV, plugins: [:Tasks]) {
       apps.each { |name, path| puts format("  %-20s => %s", name, path) }
     end
   }
+
+  add_subcmd(:path) { |app_name=nil|
+    root = git.root || task_root
+
+    unless root
+      puts "Not in a git repo or task - cannot resolve path"
+      next
+    end
+
+    if app_name.nil? || app_name.empty?
+      puts relative_cd_path(root)
+      next
+    end
+
+    apps = load_apps
+    match = apps.find { |name, _| name.start_with?(app_name) }
+
+    if match
+      name, app_relative_path = match
+      target = File.join(root, app_relative_path)
+      puts relative_cd_path(target)
+    else
+      puts "App '#{app_name}' not found"
+    end
+  }
+
+  add_subcmd(:abspath) { |app_name=nil|
+    root = git.root || task_root
+
+    unless root
+      puts "Not in a git repo or task - cannot resolve path"
+      next
+    end
+
+    if app_name.nil? || app_name.empty?
+      puts root
+      next
+    end
+
+    apps = load_apps
+    match = apps.find { |name, _| name.start_with?(app_name) }
+
+    if match
+      name, app_relative_path = match
+      puts File.join(root, app_relative_path)
+    else
+      puts "App '#{app_name}' not found"
+    end
+  }
 }

data/bin/h-branch

@@ -107,8 +107,7 @@ class BranchManager
   private
 
   def current_branch
-    branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
-    branch.empty? ? nil : branch
+    hiiro.git.branch
   end
 
   def build_entry(branch_name)
@@ -208,10 +207,10 @@ hiiro.add_subcmd(:save) { manager.save }
 hiiro.add_subcmd(:history) { |*args| manager.history(args) }
 hiiro.add_subcmd(:current) { manager.current }
 hiiro.add_subcmd(:select) do |*args|
-  branches = `git branch -i --sort=authordate`.lines(chomp: true)
+  branches = hiiro.git.branches(sort_by: 'authordate', ignore_case: true)
 
-  lines = branches.each_with_object({}) do |ln,h|
-    h[ln] = ln.sub(/../, '')
+  lines = branches.each_with_object({}) do |name, h|
+    h["  #{name}"] = name
   end
 
   if args.any?

data/lib/hiiro/git/branch.rb

@@ -0,0 +1,65 @@
+class Hiiro
+  class Git
+    class Branch
+      attr_reader :name, :ref, :upstream, :head
+
+      def self.from_format_line(line, format: :short)
+        # Parses output from git branch --format
+        new(name: line.strip)
+      end
+
+      def self.current
+        name = `git branch --show-current 2>/dev/null`.strip
+        return nil if name.empty?
+        new(name: name, current: true)
+      end
+
+      def initialize(name:, ref: nil, upstream: nil, head: nil, current: false)
+        @name = name
+        @ref = ref || "refs/heads/#{name}"
+        @upstream = upstream
+        @head = head
+        @current = current
+      end
+
+      def current?
+        @current
+      end
+
+      def local?
+        ref.start_with?('refs/heads/')
+      end
+
+      def remote?
+        ref.start_with?('refs/remotes/')
+      end
+
+      def checkout
+        system('git', 'checkout', name)
+      end
+
+      def delete(force: false)
+        flag = force ? '-D' : '-d'
+        system('git', 'branch', flag, name)
+      end
+
+      def exists?
+        system('git', 'show-ref', '--verify', '--quiet', ref)
+      end
+
+      def to_s
+        name
+      end
+
+      def to_h
+        {
+          name: name,
+          ref: ref,
+          upstream: upstream,
+          head: head,
+          current: current?,
+        }.compact
+      end
+    end
+  end
+end

data/lib/hiiro/git/branches.rb

@@ -0,0 +1,79 @@
+class Hiiro
+  class Git
+    class Branches
+      include Enumerable
+
+      def self.fetch(sort_by: nil, ignore_case: false, remote: false)
+        args = ['git', 'branch', '--format=%(refname:short)']
+        args << '-i' if ignore_case
+        args << '-r' if remote
+        args << "-a" if remote == :all
+        args << "--sort=#{sort_by}" if sort_by
+
+        output = `#{args.shelljoin} 2>/dev/null`
+        from_names(output.split("\n").map(&:strip))
+      end
+
+      def self.from_names(names)
+        branches = names.map { |name| Branch.new(name: name) }
+        new(branches)
+      end
+
+      def self.local(sort_by: nil, ignore_case: false)
+        fetch(sort_by: sort_by, ignore_case: ignore_case, remote: false)
+      end
+
+      def self.remote(sort_by: nil, ignore_case: false)
+        fetch(sort_by: sort_by, ignore_case: ignore_case, remote: true)
+      end
+
+      def self.all(sort_by: nil, ignore_case: false)
+        fetch(sort_by: sort_by, ignore_case: ignore_case, remote: :all)
+      end
+
+      attr_reader :branches
+
+      def initialize(branches)
+        @branches = branches
+      end
+
+      def each(&block)
+        branches.each(&block)
+      end
+
+      def find_by_name(name)
+        branches.find { |b| b.name == name }
+      end
+
+      def matching(prefix)
+        self.class.new(branches.select { |b| b.name.start_with?(prefix) })
+      end
+
+      def containing(substring)
+        self.class.new(branches.select { |b| b.name.include?(substring) })
+      end
+
+      def names
+        branches.map(&:name)
+      end
+
+      def current
+        branches.find(&:current?)
+      end
+
+      def empty?
+        branches.empty?
+      end
+
+      def size
+        branches.size
+      end
+      alias count size
+      alias length size
+
+      def to_a
+        branches.dup
+      end
+    end
+  end
+end

data/lib/hiiro/git/pr.rb

@@ -0,0 +1,107 @@
+class Hiiro
+  class Git
+    class Pr
+      attr_reader :number, :title, :state, :url, :head_branch, :base_branch
+
+      def self.current
+        output = `gh pr view --json number,title,state,url,headRefName,baseRefName 2>/dev/null`
+        return nil if output.empty?
+
+        require 'json'
+        data = JSON.parse(output)
+        from_gh_json(data)
+      rescue
+        nil
+      end
+
+      def self.from_gh_json(data)
+        new(
+          number: data['number'],
+          title: data['title'],
+          state: data['state'],
+          url: data['url'],
+          head_branch: data['headRefName'],
+          base_branch: data['baseRefName'],
+        )
+      end
+
+      def self.list(state: 'open', limit: 30)
+        output = `gh pr list --state #{state} --limit #{limit} --json number,title,state,url,headRefName,baseRefName 2>/dev/null`
+        return [] if output.empty?
+
+        require 'json'
+        JSON.parse(output).map { |data| from_gh_json(data) }
+      rescue
+        []
+      end
+
+      def self.create(title:, body: nil, base: nil, draft: false)
+        args = ['gh', 'pr', 'create', '--title', title]
+        args += ['--body', body] if body
+        args += ['--base', base] if base
+        args << '--draft' if draft
+
+        system(*args)
+      end
+
+      def initialize(number:, title: nil, state: nil, url: nil, head_branch: nil, base_branch: nil)
+        @number = number
+        @title = title
+        @state = state
+        @url = url
+        @head_branch = head_branch
+        @base_branch = base_branch
+      end
+
+      def open?
+        state&.downcase == 'open'
+      end
+
+      def closed?
+        state&.downcase == 'closed'
+      end
+
+      def merged?
+        state&.downcase == 'merged'
+      end
+
+      def view
+        system('gh', 'pr', 'view', number.to_s)
+      end
+
+      def checkout
+        system('gh', 'pr', 'checkout', number.to_s)
+      end
+
+      def merge(method: nil, delete_branch: true)
+        args = ['gh', 'pr', 'merge', number.to_s]
+        args << "--#{method}" if method # squash, merge, rebase
+        args << '--delete-branch' if delete_branch
+        system(*args)
+      end
+
+      def close
+        system('gh', 'pr', 'close', number.to_s)
+      end
+
+      def reopen
+        system('gh', 'pr', 'reopen', number.to_s)
+      end
+
+      def to_s
+        "##{number}: #{title}"
+      end
+
+      def to_h
+        {
+          number: number,
+          title: title,
+          state: state,
+          url: url,
+          head_branch: head_branch,
+          base_branch: base_branch,
+        }.compact
+      end
+    end
+  end
+end

data/lib/hiiro/git/remote.rb

@@ -0,0 +1,77 @@
+class Hiiro
+  class Git
+    class Remote
+      attr_reader :name, :fetch_url, :push_url
+
+      def self.all
+        output = `git remote 2>/dev/null`
+        output.split("\n").map { |name| new(name: name.strip) }
+      end
+
+      def self.origin
+        new(name: 'origin')
+      end
+
+      def self.from_verbose_line(line)
+        # Parses: origin	git@github.com:user/repo.git (fetch)
+        match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)/)
+        return nil unless match
+
+        name, url, type = match.captures
+        attrs = { name: name }
+        attrs[type == 'fetch' ? :fetch_url : :push_url] = url
+        new(**attrs)
+      end
+
+      def initialize(name:, fetch_url: nil, push_url: nil)
+        @name = name
+        @fetch_url = fetch_url
+        @push_url = push_url
+      end
+
+      def url
+        fetch_url || push_url || fetch_remote_url
+      end
+
+      def push(branch = nil, force: false)
+        args = ['git', 'push', name]
+        args << '-f' if force
+        args << branch if branch
+        system(*args)
+      end
+
+      def pull(branch = nil)
+        args = ['git', 'pull', name]
+        args << branch if branch
+        system(*args)
+      end
+
+      def fetch_remote
+        system('git', 'fetch', name)
+      end
+
+      def exists?
+        system('git', 'remote', 'get-url', name, out: File::NULL, err: File::NULL)
+      end
+
+      def to_s
+        name
+      end
+
+      def to_h
+        {
+          name: name,
+          fetch_url: fetch_url,
+          push_url: push_url,
+        }.compact
+      end
+
+      private
+
+      def fetch_remote_url
+        url = `git remote get-url #{name.shellescape} 2>/dev/null`.strip
+        url.empty? ? nil : url
+      end
+    end
+  end
+end

data/lib/hiiro/git/worktree.rb

@@ -0,0 +1,60 @@
+class Hiiro
+  class Git
+    class Worktree
+      attr_reader :path, :head, :branch
+
+      def self.from_porcelain_block(lines)
+        attrs = {}
+        lines.each do |line|
+          case line
+          when /^worktree (.+)/
+            attrs[:path] = $1
+          when /^HEAD (.+)/
+            attrs[:head] = $1
+          when /^branch refs\/heads\/(.+)/
+            attrs[:branch] = $1
+          when 'detached'
+            attrs[:detached] = true
+          when 'bare'
+            attrs[:bare] = true
+          end
+        end
+        new(**attrs) if attrs[:path]
+      end
+
+      def initialize(path:, head: nil, branch: nil, detached: false, bare: false)
+        @path = path
+        @head = head
+        @branch = branch
+        @detached = detached
+        @bare = bare
+      end
+
+      def detached?
+        @detached
+      end
+
+      def bare?
+        @bare
+      end
+
+      def name
+        File.basename(path)
+      end
+
+      def match?(pwd)
+        pwd == path || pwd.start_with?(path + '/')
+      end
+
+      def to_h
+        {
+          path: path,
+          head: head,
+          branch: branch,
+          detached: detached?,
+          bare: bare?,
+        }.compact
+      end
+    end
+  end
+end

data/lib/hiiro/git/worktrees.rb

@@ -0,0 +1,93 @@
+class Hiiro
+  class Git
+    class Worktrees
+      include Enumerable
+
+      def self.from_porcelain(output)
+        return new([]) if output.nil? || output.empty?
+
+        blocks = []
+        current_block = []
+
+        output.each_line do |line|
+          line = line.chomp
+          if line.empty?
+            blocks << current_block unless current_block.empty?
+            current_block = []
+          else
+            current_block << line
+          end
+        end
+        blocks << current_block unless current_block.empty?
+
+        worktrees = blocks.map { |block| Worktree.from_porcelain_block(block) }.compact
+        new(worktrees)
+      end
+
+      def self.fetch(repo_path: nil)
+        output = if repo_path
+          `git -C #{repo_path.shellescape} worktree list --porcelain 2>/dev/null`
+        else
+          `git worktree list --porcelain 2>/dev/null`
+        end
+        from_porcelain(output)
+      end
+
+      attr_reader :worktrees
+
+      def initialize(worktrees)
+        @worktrees = worktrees
+      end
+
+      def each(&block)
+        worktrees.each(&block)
+      end
+
+      def find_by_path(path)
+        worktrees.find { |wt| wt.path == path }
+      end
+
+      def find_by_name(name)
+        worktrees.find { |wt| wt.name == name }
+      end
+
+      def find_by_branch(branch)
+        worktrees.find { |wt| wt.branch == branch }
+      end
+
+      def matching(pwd)
+        worktrees.find { |wt| wt.match?(pwd) }
+      end
+
+      def without_bare
+        self.class.new(worktrees.reject(&:bare?))
+      end
+
+      def detached
+        self.class.new(worktrees.select(&:detached?))
+      end
+
+      def with_branch
+        self.class.new(worktrees.reject(&:detached?))
+      end
+
+      def names
+        worktrees.map(&:name)
+      end
+
+      def paths
+        worktrees.map(&:path)
+      end
+
+      def empty?
+        worktrees.empty?
+      end
+
+      def size
+        worktrees.size
+      end
+      alias count size
+      alias length size
+    end
+  end
+end

data/lib/hiiro/git.rb

@@ -0,0 +1,197 @@
+require_relative 'git/worktree'
+require_relative 'git/worktrees'
+require_relative 'git/branch'
+require_relative 'git/branches'
+require_relative 'git/remote'
+require_relative 'git/pr'
+
+class Hiiro
+  class Git
+    attr_reader :hiiro, :pwd
+
+    def initialize(hiiro, pwd)
+      @hiiro = hiiro
+      @pwd = pwd
+    end
+
+    # Query methods
+
+    def in_repo?
+      !root.nil?
+    end
+
+    def root
+      @root ||= run_safe('rev-parse', '--show-toplevel')
+    end
+
+    def detached?
+      current_branch_name == 'HEAD'
+    end
+
+    def commit(ref = 'HEAD', short: false)
+      args = short ? ['rev-parse', '--short', ref] : ['rev-parse', ref]
+      run_safe(*args)
+    end
+
+    # Branch convenience methods
+
+    def branch
+      current_branch_name
+    end
+
+    def branch_current
+      run_safe('branch', '--show-current')
+    end
+
+    def current_branch
+      Branch.current
+    end
+
+    def current_branch_name
+      run_safe('rev-parse', '--abbrev-ref', 'HEAD')
+    end
+
+    def branches(sort_by: nil, ignore_case: false)
+      Branches.fetch(sort_by: sort_by, ignore_case: ignore_case).names
+    end
+
+    def branches_collection(sort_by: nil, ignore_case: false)
+      Branches.fetch(sort_by: sort_by, ignore_case: ignore_case)
+    end
+
+    def branch_exists?(name)
+      run_success?('show-ref', '--verify', '--quiet', "refs/heads/#{name}")
+    end
+
+    def create_branch(name, start_point = nil)
+      args = ['checkout', '-b', name]
+      args << start_point if start_point
+      run_system(*args)
+    end
+
+    def checkout(ref)
+      run_system('checkout', ref)
+    end
+
+    def delete_branch(name, force: false)
+      flag = force ? '-D' : '-d'
+      run_system('branch', flag, name)
+    end
+
+    # Worktree convenience methods
+
+    def worktrees(repo_path: nil)
+      worktrees_collection(repo_path: repo_path).to_a
+    end
+
+    def worktrees_collection(repo_path: nil)
+      Worktrees.fetch(repo_path: repo_path)
+    end
+
+    def worktrees_porcelain(repo_path: nil)
+      if repo_path
+        run_safe('-C', repo_path, 'worktree', 'list', '--porcelain')
+      else
+        run_safe('worktree', 'list', '--porcelain')
+      end
+    end
+
+    def add_worktree(path, branch: nil, detach: false)
+      args = ['worktree', 'add']
+      args << '--detach' if detach
+      args << path
+      args << branch if branch && !detach
+      run_system(*args)
+    end
+
+    def add_worktree_detached(path, repo_path: nil)
+      if repo_path
+        run_system('-C', repo_path, 'worktree', 'add', '--detach', path)
+      else
+        run_system('worktree', 'add', '--detach', path)
+      end
+    end
+
+    def move_worktree(from, to, repo_path: nil)
+      if repo_path
+        run_system('-C', repo_path, 'worktree', 'move', from, to)
+      else
+        run_system('worktree', 'move', from, to)
+      end
+    end
+
+    def remove_worktree(path, force: false)
+      args = ['worktree', 'remove']
+      args << '--force' if force
+      args << path
+      run_system(*args)
+    end
+
+    def lock_worktree(path)
+      run_system('worktree', 'lock', path)
+    end
+
+    def unlock_worktree(path)
+      run_system('worktree', 'unlock', path)
+    end
+
+    def prune_worktrees
+      run_system('worktree', 'prune')
+    end
+
+    def repair_worktrees
+      run_system('worktree', 'repair')
+    end
+
+    # Remote convenience methods
+
+    def remotes
+      Remote.all
+    end
+
+    def origin
+      Remote.origin
+    end
+
+    def push(remote: 'origin', branch: nil, force: false)
+      Remote.new(name: remote).push(branch, force: force)
+    end
+
+    def pull(remote: 'origin', branch: nil)
+      Remote.new(name: remote).pull(branch)
+    end
+
+    def fetch_remote(remote: 'origin')
+      Remote.new(name: remote).fetch_remote
+    end
+
+    # PR convenience methods
+
+    def current_pr
+      Pr.current
+    end
+
+    def list_prs(state: 'open', limit: 30)
+      Pr.list(state: state, limit: limit)
+    end
+
+    def create_pr(title:, body: nil, base: nil, draft: false)
+      Pr.create(title: title, body: body, base: base, draft: draft)
+    end
+
+    private
+
+    def run_safe(*args)
+      result = `git #{args.shelljoin} 2>/dev/null`.strip
+      result.empty? ? nil : result
+    end
+
+    def run_system(*args)
+      system('git', *args)
+    end
+
+    def run_success?(*args)
+      system('git', *args, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/hiiro/history.rb

@@ -259,17 +259,15 @@ class Hiiro
     end
 
     def current_git_branch
-      branch = `git branch --show-current 2>/dev/null`.strip
-      branch.empty? ? nil : branch
-    rescue
-      nil
+      git_helper.branch_current
     end
 
     def current_git_worktree
-      worktree = `git rev-parse --show-toplevel 2>/dev/null`.strip
-      worktree.empty? ? nil : worktree
-    rescue
-      nil
+      git_helper.root
+    end
+
+    def git_helper
+      @git_helper ||= Git.new(nil, Dir.pwd)
     end
   end
 end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.50"
+  VERSION = "0.1.51"
 end

data/lib/hiiro.rb

@@ -3,6 +3,7 @@ require "yaml"
 require "shellwords"
 
 require_relative "hiiro/version"
+require_relative "hiiro/git"
 require_relative "hiiro/history"
 require_relative "hiiro/options"
 require_relative "hiiro/sk"
@@ -148,6 +149,10 @@ class Hiiro
 
   def pins = @pins ||= Pin.new(self)
 
+  def git
+    @git ||= Git.new(self, Dir.pwd)
+  end
+
   def load_plugins(*plugins)
     plugins.flatten.each { |plugin| load_plugin(plugin) }
   end

data/plugins/tasks.rb

@@ -36,27 +36,11 @@ class Tree
   attr_reader :path, :head, :branch
 
   def self.all(repo_path: REPO_PATH)
-    output = `git -C #{repo_path} worktree list --porcelain 2>/dev/null`
-
-    trees = []
-    current = nil
-
-    output.lines(chomp: true).each do |line|
-      case line
-      when /^worktree (.*)/
-        trees << new(**current) if current
-        current = { path: $1 }
-      when /^HEAD (.*)/
-        current[:head] = $1 if current
-      when /^branch refs\/heads\/(.*)/
-        current[:branch] = $1 if current
-      when 'bare'
-        current = nil
-      end
-    end
-
-    trees << new(**current) if current
-    trees
+    git = Hiiro::Git.new(nil, repo_path)
+    git.worktrees(repo_path: repo_path).map do |wt|
+      next if wt.bare?
+      new(path: wt.path, head: wt.head, branch: wt.branch)
+    end.compact
   end
 
   def initialize(path:, head: nil, branch: nil)
@@ -401,18 +385,19 @@ class TaskManager
 
     target_path = File.join(WORK_DIR, subtree_name)
 
+    git = Hiiro::Git.new(nil, REPO_PATH)
     available = find_available_tree
     if available
       puts "Renaming worktree '#{available.name}' to '#{subtree_name}'..."
       FileUtils.mkdir_p(File.dirname(target_path))
-      unless system('git', '-C', REPO_PATH, 'worktree', 'move', available.path, target_path)
+      unless git.move_worktree(available.path, target_path, repo_path: REPO_PATH)
         puts "ERROR: Failed to rename worktree"
         return
       end
     else
       puts "Creating new worktree '#{subtree_name}'..."
       FileUtils.mkdir_p(File.dirname(target_path))
-      unless system('git', '-C', REPO_PATH, 'worktree', 'add', '--detach', target_path)
+      unless git.add_worktree_detached(target_path, repo_path: REPO_PATH)
         puts "ERROR: Failed to create worktree"
         return
       end
@@ -507,7 +492,7 @@ class TaskManager
       display_name = scope == :subtask ? task.short_name : task.name
       puts format("%s %-25s  tree: %-20s%s", marker, display_name, task.tree_name || '(none)', branch_str)
 
-      # Show subtask count for top-level tasks
+      # Show subtasks under parent
       if scope == :task
         subs = subtasks(task)
         subs.each do |st|
@@ -515,8 +500,7 @@ class TaskManager
           sub_tree = environment.find_tree(st.tree_name)
           sub_branch = sub_tree&.branch || (sub_tree&.detached? ? '(detached)' : nil)
           sub_branch_str = sub_branch ? "  [#{sub_branch}]" : ""
-          padding = " " * task.name.length
-          puts format("%s %s/%-*s  tree: %-20s%s", sub_marker, padding, 25 - task.name.length - 1, st.short_name, st.tree_name || '(none)', sub_branch_str)
+          puts format("%s - %-23s  tree: %-20s%s", sub_marker, st.short_name, st.tree_name || '(none)', sub_branch_str)
         end
       end
     end
@@ -627,7 +611,7 @@ class TaskManager
       tree = environment.find_tree(task.tree_name)
       tree&.path || File.join(WORK_DIR, task.tree_name)
     else
-      `git rev-parse --show-toplevel`.strip
+      Hiiro::Git.new(nil, Dir.pwd).root
     end
 
     if app_name.nil?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.50
+  version: 0.1.51
 platform: ruby
 authors:
 - Joshua Toyota
@@ -69,6 +69,13 @@ files:
 - exe/h
 - hiiro.gemspec
 - lib/hiiro.rb
+- lib/hiiro/git.rb
+- lib/hiiro/git/branch.rb
+- lib/hiiro/git/branches.rb
+- lib/hiiro/git/pr.rb
+- lib/hiiro/git/remote.rb
+- lib/hiiro/git/worktree.rb
+- lib/hiiro/git/worktrees.rb
 - lib/hiiro/history.rb
 - lib/hiiro/options.rb
 - lib/hiiro/sk.rb