hiiro 0.1.313 → 0.1.314

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0760d73ced611f47a517d2faa6cacca8efeb97060d8a4ed4fb3731e0a32dc27
-  data.tar.gz: 44833c289d4d8519b840597cd8eb276085918b39a2e4dd97a4ea280b22fc747a
+  metadata.gz: 6fd4ee6b28c10a3203f70a472a4e65bae62c1636f24dceb4a1b21fe48c96c3ff
+  data.tar.gz: 1ddaded4e27043098e685c7af4445e042119ff2bdee80a47ac25a29d4f05ba2d
 SHA512:
-  metadata.gz: a2cf3d9a87608e3e37a571e2e177f42383e691c80a7a1a7325ed3fa42a4ab7daf7ebc8d193db753cd9026ae57a56e0d1e75cea31a99332c539dcaf099b48c331
-  data.tar.gz: 68694cb3fb0de4bcf5be5d2af5e374be9eb48e356ea61215cf6fb23d2a803b04d67b44c00c002e2ef05542557fe5a33bd1c594ef93ce24bbb0198351744ed006
+  metadata.gz: 7ff30eb7284958c439bc087bad2e1a74a805c6955a9482d8f4a0b6198f0fc6e35181742537102b7f8d0abeb5fc1ea8bce38a595042a5df2cf1470470a239ee52
+  data.tar.gz: 68d4ab840a4535a86f99faf26d910cc2fee354b35fd5a2fdcdec22e8fa4bc4b962a9cca0a18c56250076dd28db28102fe76b798621bd5b7084d516314a54182a

data/CHANGELOG.md

@@ -1,6 +1,10 @@
-```markdown
 # Changelog
 
+## [0.1.314] - 2026-04-01
+
+### Fixed
+- Rename `Gem` class to `RubyGem` in publish script to avoid conflict with Ruby stdlib
+
 ## [0.1.313] - 2026-04-01
 
 ### Fixed
@@ -194,5 +198,4 @@
 ## [0.1.295]
 
 ### Changed
-- Filter logic changes for PR management
-```
+- Filter logic changes for PR management

data/exe/h

@@ -225,7 +225,7 @@ Hiiro.run(*ARGV, cwd: Dir.pwd, tasks: true) do
       end
 
       unless found
-        system('say', 'hiiro publish timed out')
+        system('terminal-notifier', '-title', 'hiiro publish', '-message', 'Timed out waiting for RubyGems')
         exit 1
       end
 
@@ -239,11 +239,11 @@ Hiiro.run(*ARGV, cwd: Dir.pwd, tasks: true) do
         output.match?(/hiiro \\([^)]*#{Regexp.escape(expected)}/)
       end
       if mismatched.empty?
-        system('say', 'hiiro updated')
+        system('terminal-notifier', '-title', 'hiiro updated', '-message', "v\#{expected} installed across all rbenv versions")
       elsif mismatched.size == versions.size
-        system('say', 'no versions updated')
+        system('terminal-notifier', '-title', 'hiiro update failed', '-message', "v\#{expected} not installed in any rbenv version")
       else
-        system('say', "\#{mismatched.size} version\#{mismatched.size == 1 ? '' : 's'} not updated")
+        system('terminal-notifier', '-title', 'hiiro updated', '-message', "v\#{expected} installed — \#{mismatched.size} version\#{mismatched.size == 1 ? '' : 's'} skipped")
       end
     RUBY
 

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.313"
+  VERSION = "0.1.314"
 end

data/script/publish

@@ -3,202 +3,238 @@
 require "net/http"
 require "json"
 
-# Parse -t flag for pre-release
-pre_release = ARGV.include?('-t') || `git branch --show-current`.strip != 'main'
-
-# Check for uncommitted changes before we modify anything
-has_pending_changes = !`git status --porcelain`.strip.empty?
-
-# Ensure local branch is up to date with remote
-system('git', 'fetch', 'origin')
-behind = `git rev-list HEAD..origin/main --count`.strip.to_i
-if behind > 0
-  puts "ERROR: Local branch is #{behind} commit(s) behind origin/main. Pull before publishing."
-  exit 1
-end
+# ─── RubyGems API ────────────────────────────────────────────────────────────
 
-puts ""
-# 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
+class RubyGems
+  def self.published_versions(gem_name)
+    uri = URI("https://rubygems.org/api/v1/versions/#{gem_name}.json")
+    JSON.parse(Net::HTTP.get(uri)).map { |v| v["number"] }
+  rescue => e
+    puts "Warning: could not fetch versions from RubyGems (#{e.message}), falling back to local"
+    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 }
+  def self.wait_for(gem_name, version, max_attempts: 40)
+    attempts = 0
+    loop do
+      sleep(attempts == 0 ? 5 : 15)
+      attempts += 1
+      versions = published_versions(gem_name)
+      return true if versions.include?(version)
+      puts "Waiting for v#{version} on RubyGems (attempt #{attempts}/#{max_attempts})..."
+      return false if attempts >= max_attempts
+    end
+  rescue => e
+    puts "RubyGems poll error: #{e.message}"
+    false
   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]]
+# ─── Version bumping ─────────────────────────────────────────────────────────
+
+class Version
+  attr_reader :major, :minor, :patch, :pre, :pre_num
+
+  def self.parse(str)
+    parts = str.split(".")
+    pre   = parts.length >= 5 && parts[-2] == "pre"
+    new(parts[0].to_i, parts[1].to_i, parts[2].to_i, pre, pre ? parts[-1].to_i : 0)
+  end
+
+  def self.latest(versions)
+    versions.max_by { |v| parse(v).sort_key }
   end
+
+  def self.bump(current_str, pre_release:)
+    v = parse(current_str)
+    if v.pre
+      pre_release ? "#{v.major}.#{v.minor}.#{v.patch}.pre.#{v.pre_num + 1}"
+                  : "#{v.major}.#{v.minor}.#{v.patch}"
+    else
+      pre_release ? "#{v.major}.#{v.minor}.#{v.patch + 1}.pre.1"
+                  : "#{v.major}.#{v.minor}.#{v.patch + 1}"
+    end
+  end
+
+  def initialize(major, minor, patch, pre, pre_num)
+    @major, @minor, @patch, @pre, @pre_num = major, minor, patch, pre, pre_num
+  end
+
+  def sort_key = [major, minor, patch, pre ? 0 : 1, pre_num]
 end
 
-versions = fetch_versions
-current = latest_version(versions)
-puts "Latest published version: #{current}"
+# ─── Git ─────────────────────────────────────────────────────────────────────
 
-parts = current.split(?.)
-is_pre = parts.length >= 5 && parts[-2] == 'pre'
+class Git
+  def self.current_branch  = `git branch --show-current`.strip
+  def self.pending_changes? = !`git status --porcelain`.strip.empty?
+  def self.diff             = `git diff HEAD`
+  def self.status           = `git status --short`
 
-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(?.)
+  def self.ensure_up_to_date!
+    system("git", "fetch", "origin")
+    behind = `git rev-list HEAD..origin/main --count`.strip.to_i
+    if behind > 0
+      puts "ERROR: #{behind} commit(s) behind origin/main — pull before publishing."
+      exit 1
+    end
   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(?.)
+
+  def self.commits_since_last_tag
+    last_tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
+    last_tag.empty? ? `git log --oneline` : `git log #{last_tag}..HEAD --oneline`
+  end
+
+  def self.stage_and_commit(files, message)
+    system("git", "reset", "HEAD")
+    files.each { |f| system("git", "add", "--", f) }
+    system("git", "commit", "-m", message)
+    puts "  → #{message}"
+  end
+
+  def self.commit_all(message)
+    system("git", "add", "--all")
+    system("git", "commit", "-m", message)
+  end
+
+  def self.tag(version)
+    system("git", "tag", "-a", "v#{version}", "-m", "v#{version}")
+    puts "Tagged v#{version}"
+  end
+
+  def self.push
+    if system("git", "push", "origin", "main", "--follow-tags")
+      puts "Pushed to origin/main"
+    else
+      branch = "publish-v#{version}"
+      system("git", "checkout", "-b", branch)
+      system("git", "push", "origin", branch, "--follow-tags") \
+        ? puts("Push to main failed — pushed to origin/#{branch} instead")
+        : puts("ERROR: unable to push to origin")
+      system("git", "checkout", "main")
+    end
   end
 end
 
-puts "New version: #{new_version}"
+# ─── Claude AI calls ─────────────────────────────────────────────────────────
 
-if has_pending_changes
-  puts ""
-  puts "Generating commit plan for pending changes..."
+class Claude
+  MODEL = "claude-haiku-4-5-20251001"
 
-  diff   = `git diff HEAD`
-  status = `git status --short`
+  Result = Struct.new(:commits, :changelog)
 
-  commit_prompt = <<~PROMPT
-    Analyze these git changes and create a logical commit plan.
+  # Single call: returns a Result with commit plan + updated changelog
+  def self.prepare_release(version:, diff:, status:, git_log:, existing_changelog:)
+    prompt = <<~PROMPT
+      You are preparing a release for the Ruby gem "hiiro" version #{version}.
+      Do two things and return them as a single JSON object — no explanation, no markdown fences.
 
-    git status:
-    #{status.strip}
+      ## 1. Commit plan
+      Analyze the pending git changes below and group them into logical commits.
+      Use conventional commit format (feat:, fix:, chore:, refactor:, docs:, etc.).
+      Only include files that appear in the git status output.
 
-    git diff:
-    #{diff.strip}
+      git status:
+      #{status.strip}
 
-    Group related changes into logical commits. Output a JSON array only, no explanation, no markdown fences:
-    [
-      {"message": "commit message", "files": ["path/to/file"]},
-      ...
-    ]
+      git diff:
+      #{diff.strip}
 
-    Use conventional commit format (feat:, fix:, chore:, refactor:, docs:, etc.).
-    Only include files that appear in the status output above.
-  PROMPT
+      ## 2. Changelog
+      Write a complete updated CHANGELOG.md. Add a new section for v#{version} at the top
+      with today's date. Group changes into Added, Changed, Fixed, Removed where appropriate.
+      Be concise.
 
-  response = IO.popen(['claude', '-p', '--model', 'claude-haiku-4-5-20251001'], 'r+') { |io|
-    io.write(commit_prompt)
-    io.close_write
-    io.read
-  }
+      Recent commits (for changelog context):
+      #{git_log.strip}
 
-  begin
-    json_str = response.strip.gsub(/\A```(?:json)?\n?/, '').gsub(/\n?```\z/, '')
-    commits  = JSON.parse(json_str)
-
-    system('git', 'add', '--all')
-    commits.each do |commit|
-      system('git', 'reset', 'HEAD')
-      commit['files'].each { |f| system('git', 'add', '--', f) }
-      system('git', 'commit', '-m', commit['message'])
-      puts "  → #{commit['message']}"
-    end
-  rescue => e
-    puts "Warning: could not parse claude commit plan (#{e.message}), committing all as one"
-    system('git', 'add', '--all')
-    system('git', 'commit', '-m', 'chore: pre-publish changes')
+      Existing CHANGELOG.md:
+      #{existing_changelog.empty? ? "(none)" : existing_changelog}
+
+      ## Output format (JSON only, no extra text)
+      {
+        "commits": [
+          {"message": "commit message", "files": ["path/to/file"]},
+          ...
+        ],
+        "changelog": "full CHANGELOG.md content here"
+      }
+    PROMPT
+
+    raw = IO.popen(["claude", "-p", "--model", MODEL], "r+") { |io|
+      io.write(prompt)
+      io.close_write
+      io.read
+    }.strip.gsub(/\A```(?:json)?\n?/, "").gsub(/\n?```\z/, "")
+
+    parsed = JSON.parse(raw)
+    Result.new(parsed["commits"], parsed["changelog"])
   end
 end
 
-puts ""
-puts "Generating CHANGELOG.md..."
-last_tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
-commit_log = last_tag.empty? ? `git log --oneline` : `git log #{last_tag}..HEAD --oneline`
-existing_changelog = File.exist?('CHANGELOG.md') ? File.read('CHANGELOG.md') : ''
+# ─── Gem publishing ──────────────────────────────────────────────────────────
 
-changelog_prompt = <<~PROMPT
-  Update or create a CHANGELOG.md for the Ruby gem "hiiro" version #{new_version}.
+class RubyGem
+  def self.build(version)
+    system("gem", "build", "hiiro.gemspec") || abort("ERROR: gem build failed")
+  end
 
-  Recent commits (since #{last_tag.empty? ? 'the beginning' : last_tag}):
-  #{commit_log.strip}
+  def self.push(version)
+    system("gem", "push", "hiiro-#{version}.gem")
+  end
+end
 
-  Existing CHANGELOG.md:
-  #{existing_changelog.empty? ? '(none)' : existing_changelog}
+# ─── Main ─────────────────────────────────────────────────────────────────────
 
-  Write the complete updated CHANGELOG.md. Add a new section for v#{new_version} at the top
-  with today's date. Group changes into Added, Changed, Fixed, Removed where appropriate.
-  Be concise. Output only the file content, no explanation.
-PROMPT
+pre_release    = ARGV.include?("-t") || Git.current_branch != "main"
+pending_before = Git.pending_changes?
 
-new_changelog = IO.popen(['claude', '-p', '--model', 'claude-haiku-4-5-20251001'], 'r+') { |io|
-  io.write(changelog_prompt)
-  io.close_write
-  io.read
-}
+Git.ensure_up_to_date!
 
-if new_changelog && !new_changelog.strip.empty?
-  File.write('CHANGELOG.md', new_changelog)
-  puts "Updated CHANGELOG.md"
-else
-  puts "Warning: could not generate CHANGELOG.md"
-end
+current_version = Version.latest(RubyGems.published_versions("hiiro"))
+new_version     = Version.bump(current_version, pre_release: pre_release)
+puts "Latest: #{current_version}  →  New: #{new_version}"
+
+puts "\nAsking Claude to plan commits and generate changelog..."
+release = Claude.prepare_release(
+  version:            new_version,
+  diff:               pending_before ? Git.diff   : "",
+  status:             pending_before ? Git.status : "",
+  git_log:            Git.commits_since_last_tag,
+  existing_changelog: File.exist?("CHANGELOG.md") ? File.read("CHANGELOG.md") : ""
+)
 
-puts ""
-File.open('lib/hiiro/version.rb', 'w+') do |f|
-  f.puts 'class Hiiro'
-  f.puts "  VERSION = #{new_version.inspect}"
-  f.puts 'end'
+if pending_before
+  begin
+    system("git", "add", "--all")
+    release.commits.each { |c| Git.stage_and_commit(c["files"], c["message"]) }
+  rescue => e
+    puts "Warning: could not apply Claude commit plan (#{e.message}) — committing all as one"
+    Git.commit_all("chore: pre-publish changes")
+  end
 end
 
-built = system('gem', 'build', 'hiiro.gemspec')
-puts "\nERROR: unable to build gem\n" unless built
+File.write("CHANGELOG.md", release.changelog) if release.changelog && !release.changelog.strip.empty?
 
-puts ""
-pushed = system('gem', 'push', "hiiro-#{new_version}.gem")
-puts "\nERROR: unable to push\n" unless pushed
+File.write("lib/hiiro/version.rb", "class Hiiro\n  VERSION = #{new_version.inspect}\nend\n")
 
-puts ""
-system 'git', 'add', '--all'
-system 'git', 'commit', '-m', "publishing v#{new_version}"
+RubyGem.build(new_version)
 
-system 'git', 'tag', '-a', "v#{new_version}", '-m', "v#{new_version}"
-puts "Tagged v#{new_version}"
+unless RubyGem.push(new_version)
+  abort("ERROR: gem push failed — skipping git commit, tag, and push")
+end
 
-puts ""
-# Try to push to origin main (tags follow via push.followTags), fallback to a branch if needed
-if system('git', 'push', 'origin', 'main', '--follow-tags')
-  puts "Pushed to origin/main"
+Git.commit_all("publishing v#{new_version}")
+Git.tag(new_version)
+Git.push
+
+puts "\nWaiting for v#{new_version} to appear on RubyGems..."
+if RubyGems.wait_for("hiiro", new_version)
+  puts "v#{new_version} available — running h update -a"
+  update_args = ["update", "-a"]
+  update_args << "--pre" if pre_release
+  system("h", *update_args)
 else
-  branch_name = "publish-v#{new_version}"
-  system 'git', 'checkout', '-b', branch_name
-  if system('git', 'push', 'origin', branch_name, '--follow-tags')
-    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'
+  puts "WARNING: timed out waiting for v#{new_version} on RubyGems — run `h update -a` manually"
 end
-
-puts ""
-puts "Running: h delayed_update #{new_version}"
-system('h', 'delayed_update', new_version)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.313
+  version: 0.1.314
 platform: ruby
 authors:
 - Joshua Toyota