hiiro 0.1.42 → 0.1.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1a957e724383a7df39d3cfb3697cd364839cc46cb38349cdcb67bf17bd56fd7
-  data.tar.gz: 9e54741f54b9074cb94e5325c8baa030c62b500de13bd735c2e064931dcc98fe
+  metadata.gz: 905c984e32273b1a0c950252f7a7380ca84edfdea8293161a19537b638087b7b
+  data.tar.gz: 9597fa067608d4afda704464685aeb1839a3e6664dade67a95609afc4d6c47d2
 SHA512:
-  metadata.gz: '098472ad16ff1d6c5522c8d04d4de49ea798c7ed676329ed55e7674b8fdb5b9a93381555027aecb2cd286497632640121d3fd8b9da5552805417e218aa4ab01c'
-  data.tar.gz: 48642a4e5f8c32be7ad500d19bb832d448ebb58adb7470b22476bff4ddbf4d1b2fb5f323a605ad1bb90cc0c64a94d117c60e0f39dc0ddd7e155c43454636c5bd
+  metadata.gz: 0e2d3891085e9ba9ed96405fe8ce94b51ea74967df558ab8dd8fc77b7135a59047041b8fe3edae7b5dcef841761afdee4288d91b33c916c64d499a2a7a541429
+  data.tar.gz: 1514c66640b2c1aba783740110abd6b341e1abe9dbc5beb2c675190823c7963e6d6013538b6ceaf435b83cadc86d7649e4e170004b0499cf7831d86ca19fd6c6

data/bin/h-app

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'pathname'
+require 'hiiro'
+
+APPS_FILE = File.join(Dir.home, '.config', 'hiiro', 'apps.yml')
+
+def load_apps
+  return {} unless File.exist?(APPS_FILE)
+  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
+  return nil unless env
+
+  task = env.task
+  return nil unless task
+
+  tree = env.find_tree(task.tree_name)
+  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)
+  target = Pathname.new(target_path)
+  target.relative_path_from(pwd).to_s
+end
+
+def send_cd(path)
+  pane = ENV['TMUX_PANE']
+  if pane
+    system('tmux', 'send-keys', '-t', pane, "cd #{path}\n")
+  else
+    system('tmux', 'send-keys', "cd #{path}\n")
+  end
+end
+
+Hiiro.run(*ARGV, plugins: [:Tasks]) {
+  add_subcmd(:config) {
+    editor = ENV['EDITOR'] || 'nvim'
+    system(editor, APPS_FILE)
+  }
+
+  add_subcmd(:cd) { |app_name|
+    apps = load_apps
+    match = apps.find { |name, _| name.start_with?(app_name) }
+
+    if match
+      name, app_relative_path = match
+      target = resolve_app_path(app_relative_path)
+
+      if target
+        cd_path = relative_cd_path(target)
+        send_cd(cd_path)
+      else
+        puts "Not in a git repo or task - cannot resolve app path"
+      end
+    else
+      puts "App '#{app_name}' not found"
+      puts
+      puts "Available apps:"
+      apps.each { |name, path| puts format("  %-20s => %s", name, path) }
+    end
+  }
+
+  add_subcmd(:ls) {
+    apps = load_apps
+
+    if apps.empty?
+      puts "No apps configured."
+      puts "Create #{APPS_FILE} with format:"
+      puts "  app_name: /path/to/app"
+    else
+      puts "Configured apps:"
+      puts
+      apps.each { |name, path| puts format("  %-20s => %s", name, path) }
+    end
+  }
+}

data/bin/h-config

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'hiiro'
+
+def open_config(dir:, file:)
+  editor = ENV['EDITOR'] || 'nvim'
+  full_path = File.expand_path(File.join(dir, file))
+  Dir.chdir(File.expand_path(dir))
+  system(editor, full_path)
+end
+
+Hiiro.run(*ARGV) {
+  add_subcmd(:vim) {
+    dir = '~/.config/nvim'
+    file = File.exist?(File.expand_path('~/.config/nvim/init.lua')) ? 'init.lua' : 'init.vim'
+    open_config(dir: dir, file: file)
+  }
+
+  add_subcmd(:tmux) {
+    open_config(dir: '~', file: '.tmux.conf')
+  }
+
+  add_subcmd(:zsh) {
+    open_config(dir: '~', file: '.zshrc')
+  }
+
+  add_subcmd(:profile) {
+    open_config(dir: '~', file: '.zprofile')
+  }
+
+  add_subcmd(:starship) {
+    open_config(dir: '~/.config/starship', file: 'starship.toml')
+  }
+
+  add_subcmd(:claude) {
+    open_config(dir: '~/.claude', file: 'settings.json')
+  }
+}

data/lib/hiiro/options.rb

@@ -0,0 +1,168 @@
+class Hiiro
+  class Options
+    class Definition
+      attr_reader :name, :short, :type, :default, :desc, :multi
+
+      def initialize(name, short: nil, type: :string, default: nil, desc: nil, multi: false)
+        @name = name.to_sym
+        @short = short&.to_s
+        @type = type
+        @default = default
+        @desc = desc
+        @multi = multi
+      end
+
+      def flag?
+        type == :flag
+      end
+
+      def long_form
+        "--#{name.to_s.tr('_', '-')}"
+      end
+
+      def short_form
+        short ? "-#{short}" : nil
+      end
+
+      def match?(arg)
+        arg == long_form || arg == short_form
+      end
+
+      def coerce(value)
+        case type
+        when :integer then value.to_i
+        when :float then value.to_f
+        else value
+        end
+      end
+    end
+
+    attr_reader :definitions, :values, :remaining_args
+    alias args remaining_args
+
+    def initialize(raw_args = [], &block)
+      @raw_args = raw_args.dup
+      @definitions = {}
+      @values = {}
+      @remaining_args = []
+      @parsed = false
+
+      instance_eval(&block) if block
+      parse! if block
+    end
+
+    # DSL: define a toggle flag (default false, presence inverts)
+    def flag(name, short: nil, default: false, desc: nil)
+      defn = Definition.new(name, short: short, type: :flag, default: default, desc: desc)
+      @definitions[name.to_sym] = defn
+      self
+    end
+
+    # DSL: define an option that takes a value
+    def option(name, short: nil, type: :string, default: nil, desc: nil, multi: false)
+      defn = Definition.new(name, short: short, type: type, default: default, desc: desc, multi: multi)
+      @definitions[name.to_sym] = defn
+      self
+    end
+
+    def parse!
+      return self if @parsed
+
+      @definitions.each do |name, defn|
+        @values[name] = defn.multi ? [] : defn.default
+      end
+
+      args = @raw_args.dup
+      while args.any?
+        arg = args.shift
+
+        if arg == '--'
+          @remaining_args.concat(args)
+          break
+        elsif arg.start_with?('--')
+          parse_long_option(arg, args)
+        elsif arg.start_with?('-') && arg.length > 1
+          parse_short_options(arg, args)
+        else
+          @remaining_args << arg
+        end
+      end
+
+      @parsed = true
+      self
+    end
+
+    def [](name)
+      @values[name.to_sym]
+    end
+
+    def method_missing(name, *args, &block)
+      name_str = name.to_s
+      if name_str.end_with?('?')
+        key = name_str.chomp('?').to_sym
+        return !!@values[key] if @definitions.key?(key)
+      else
+        return @values[name] if @definitions.key?(name)
+      end
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      key = name.to_s.chomp('?').to_sym
+      @definitions.key?(key) || super
+    end
+
+    def to_h
+      @values.dup
+    end
+
+    private
+
+    def parse_long_option(arg, args)
+      if arg.include?('=')
+        opt, value = arg.split('=', 2)
+        name = opt.sub(/^--/, '').tr('-', '_').to_sym
+      else
+        name = arg.sub(/^--/, '').tr('-', '_').to_sym
+        value = nil
+      end
+
+      defn = @definitions[name]
+      return unless defn
+
+      if defn.flag?
+        @values[name] = !defn.default
+      else
+        value ||= args.shift
+        store_value(defn, value)
+      end
+    end
+
+    def parse_short_options(arg, args)
+      chars = arg.sub(/^-/, '').chars
+
+      chars.each_with_index do |char, idx|
+        defn = @definitions.values.find { |d| d.short == char }
+        next unless defn
+
+        if defn.flag?
+          @values[defn.name] = !defn.default
+        elsif idx == chars.length - 1
+          store_value(defn, args.shift)
+        else
+          store_value(defn, chars[(idx + 1)..].join)
+          break
+        end
+      end
+    end
+
+    def store_value(defn, value)
+      coerced = defn.coerce(value)
+      if defn.multi
+        @values[defn.name] << coerced
+      else
+        @values[defn.name] = coerced
+      end
+    end
+  end
+end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.42"
+  VERSION = "0.1.44"
 end

data/lib/hiiro.rb

@@ -4,6 +4,7 @@ require "shellwords"
 
 require_relative "hiiro/version"
 require_relative "hiiro/history"
+require_relative "hiiro/options"
 
 class String
   def underscore(camel_cased_word=self)
@@ -39,7 +40,13 @@ class Hiiro
         system(ENV['EDITOR'] || 'nvim', hiiro.bin)
       }
 
-      block.call(hiiro) if block
+      if block
+        if block.arity == 1
+          block.call(hiiro)
+        else
+          hiiro.instance_eval(&block)
+        end
+      end
     end
   end
 

data/plugins/tasks.rb

@@ -672,7 +672,11 @@ class TaskManager
   # --- Interactive selection with sk ---
 
   def select_task_interactive(prompt = nil)
-    names = tasks.map { |t| scope == :subtask ? t.short_name : t.name }
+    names = if scope == :subtask
+      tasks.map(&:short_name)
+    else
+      environment.all_tasks.map(&:name)
+    end
     return nil if names.empty?
 
     sk_select(names)

data/script/publish

@@ -1,10 +1,72 @@
 #!/usr/bin/env ruby
 
-require "hiiro"
+require "net/http"
+require "json"
 
-major, minor, patch = Hiiro::VERSION.split(?.)
+# Parse -t flag for pre-release
+pre_release = ARGV.include?('-t')
 
-new_version = [major, minor, patch.to_i + 1].join(?.)
+# Fetch all published versions from RubyGems
+def fetch_versions
+  uri = URI("https://rubygems.org/api/v1/versions/hiiro.json")
+  response = Net::HTTP.get(uri)
+  JSON.parse(response).map { |v| v["number"] }
+rescue => e
+  puts "Warning: Could not fetch versions from RubyGems: #{e.message}"
+  puts "Falling back to local version"
+  require "hiiro"
+  [Hiiro::VERSION]
+end
+
+# Parse version string into comparable components
+def parse_version(version)
+  parts = version.split(?.)
+  is_pre = parts.length >= 5 && parts[-2] == 'pre'
+  if is_pre
+    { major: parts[0].to_i, minor: parts[1].to_i, patch: parts[2].to_i, pre: true, pre_num: parts[-1].to_i }
+  else
+    { major: parts[0].to_i, minor: parts[1].to_i, patch: parts[2].to_i, pre: false, pre_num: 0 }
+  end
+end
+
+# Find the latest version (prioritize release over pre for same patch)
+def latest_version(versions)
+  versions.max_by do |v|
+    p = parse_version(v)
+    # Sort by major, minor, patch, then non-pre before pre, then pre_num
+    [p[:major], p[:minor], p[:patch], p[:pre] ? 0 : 1, p[:pre_num]]
+  end
+end
+
+versions = fetch_versions
+current = latest_version(versions)
+puts "Latest published version: #{current}"
+
+parts = current.split(?.)
+is_pre = parts.length >= 5 && parts[-2] == 'pre'
+
+if is_pre
+  major, minor, patch = parts[0..2]
+  pre_num = parts[-1].to_i
+  if pre_release
+    # pre -> pre: increment pre number
+    new_version = [major, minor, patch, 'pre', pre_num + 1].join(?.)
+  else
+    # pre -> release: remove pre, keep same version number
+    new_version = [major, minor, patch].join(?.)
+  end
+else
+  major, minor, patch = parts[0..2]
+  if pre_release
+    # release -> pre: increment patch and add pre.1
+    new_version = [major, minor, patch.to_i + 1, 'pre', 1].join(?.)
+  else
+    # release -> release: increment patch
+    new_version = [major, minor, patch.to_i + 1].join(?.)
+  end
+end
+
+puts "New version: #{new_version}"
 
 File.open('lib/hiiro/version.rb', 'w+') do |f|
   f.puts 'class Hiiro'
@@ -23,3 +85,16 @@ puts "\nERROR: unable to push\n" unless pushed
 system 'git', 'add', '--all'
 system 'git', 'commit', '-m', "publishing v#{new_version}"
 
+# Try to push to origin main, fallback to a separate branch if it fails
+if system('git', 'push', 'origin', 'main')
+  puts "Pushed to origin/main"
+else
+  branch_name = "publish-v#{new_version}"
+  system 'git', 'checkout', '-b', branch_name
+  if system('git', 'push', 'origin', branch_name)
+    puts "Push to main failed. Pushed to origin/#{branch_name} instead"
+  else
+    puts "\nERROR: unable to push to origin\n"
+  end
+  system 'git', 'checkout', 'main'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.42
+  version: 0.1.44
 platform: ruby
 authors:
 - Joshua Toyota
@@ -41,8 +41,10 @@ files:
 - TODO.md
 - bin/g-pr
 - bin/h
+- bin/h-app
 - bin/h-branch
 - bin/h-buffer
+- bin/h-config
 - bin/h-dot
 - bin/h-dotfiles
 - bin/h-home
@@ -77,6 +79,7 @@ files:
 - hiiro.gemspec
 - lib/hiiro.rb
 - lib/hiiro/history.rb
+- lib/hiiro/options.rb
 - lib/hiiro/version.rb
 - notes
 - plugins/notify.rb