hiiro 0.1.308.pre.1 → 0.1.308.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5133c5b05e6f2040b092c49a8ff75a1e665f9506d5a6b7afc9078dcd9c3d20a2
-  data.tar.gz: bea25caa37de50a810b76b72b8eebe5eb1fd37141542aaea21da1932e3dbae9d
+  metadata.gz: 5908ae11780b1bb36df988cc84a6246a0fd6baf0a62491990d8a3603b0a10b93
+  data.tar.gz: afb4b4b786c1cd4e41a8c09c082cfa2f7aba9ee20f8fed33cc4292202c7a4fe0
 SHA512:
-  metadata.gz: 321291e9a574a533d3647c7c4a54040fdbf993c174923958a4d1fdb7936bee373c838c689ca10fb50b48940d4a9aefc662c4a72714442271c7180eccf82d748f
-  data.tar.gz: 15d46bd5f44affa4fb6418f6f76e61cef848a4ade2a975cba450825aeb730da8362fbc0a885241bad31bae4969f752063de95d9143ab72127576850cf3c4e804
+  metadata.gz: f159eb57fac642d228e6e5fa9ab9d5d9d13fe0442150f333462c69100f345ce5c5175efc90da208e6febda0c0d5a3acd4e26cfd3b2a263e407d479af7e98a3d3
+  data.tar.gz: 11e4b59102767d7052eaee3f0117dcf72beb0ff28c8aa8efe7f545cbe24f9352d99055909e5e8ceb3c68146b6b1cf32c47d25a468fc0c419f36ac24561f0d553

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 ```markdown
 # Changelog
 
+## [0.1.308.pre.2] - 2026-03-31
+
+### Added
+- `--pre`/`-p` flag to `h install` and `h update` for installing/updating pre-release versions
+
+### Changed
+- Merge `prs` and `pinned_prs` tables into single `prs` table in SQLite schema
+- Refactor PR storage to use unified table structure
+
+### Fixed
+- YAML migration for todos, prs, pinned_prs, and tags to correctly handle merged schema
+
 ## [0.1.308.pre.1] - 2026-03-31
 
 ### Added

data/bin/h-db

@@ -163,6 +163,14 @@ Hiiro.run(*ARGV) do
     puts "  tar xvzf #{File.basename(archive)}"
   end
 
+  add_subcmd(:remigrate) do |*args|
+    opts = Hiiro::Options.parse(args) do
+      option(:only, desc: 'Comma-separated list of tables to remigrate (e.g. todos,tags,pinned_prs)')
+    end
+    tables = opts[:only]&.split(',')&.map(&:strip)
+    Hiiro::DB.remigrate!(only: tables)
+  end
+
   add_subcmd(:restore) do
     config_dir = File.expand_path('~/.config/hiiro')
     archives   = Dir.glob(File.join(config_dir, 'sqlite-migration.*.tar.gz')).sort

data/exe/h

@@ -3,12 +3,12 @@
 require "hiiro"
 require "fileutils"
 
-def update_hiiro(version=nil)
+def update_hiiro(version=nil, pre: false)
   ver = version || Hiiro::Rbenv.current_version
   puts
-  puts "INSTALLING hiiro for RUBY #{ver}"
+  puts "INSTALLING hiiro for RUBY #{ver} #{pre.inspect}"
 
-  Hiiro::Rbenv.install_gem('hiiro', version: ver)
+  Hiiro::Rbenv.install_gem('hiiro', pre: pre, version: ver)
   Hiiro::Rbenv.run('h', 'setup', version: ver)
 end
 
@@ -32,20 +32,21 @@ Hiiro.run(*ARGV, cwd: Dir.pwd, tasks: true) do
   add_subcmd(:install, :update) { |*args|
     opts = Hiiro::Options.setup {
       flag(:all, short: :a)
+      flag(:pre, short: :p)
     }.parse!(ARGV)
 
     if opts.all
       Hiiro::Rbenv.versions.each do |ver|
         shell_cmd = [
-          "(RBENV_VERSION=#{ver.shellescape} rbenv exec gem update hiiro",
-          "|| RBENV_VERSION=#{ver.shellescape} rbenv exec gem install hiiro)",
+          "(RBENV_VERSION=#{ver.shellescape} rbenv exec gem update hiiro #{opts.pre ? '--pre' : ''}",
+          "|| RBENV_VERSION=#{ver.shellescape} rbenv exec gem install hiiro #{opts.pre ? '--pre' : ''})",
           "&& RBENV_VERSION=#{ver.shellescape} rbenv exec h setup",
         ].join(' ')
         puts "Queuing update for Ruby #{ver}..."
         Hiiro::Background.run('sh', '-c', shell_cmd)
       end
     else
-      update_hiiro
+      update_hiiro(pre: opts.pre)
     end
   }
 

data/lib/hiiro/check_run.rb

@@ -0,0 +1,36 @@
+require 'sequel'
+
+class Hiiro
+  class CheckRun < Sequel::Model(:check_runs)
+    Hiiro::DB.register(self)
+
+    def self.create_table!(db)
+      db.create_table?(:check_runs) do
+        primary_key :id
+        Integer :pr_number, null: false
+        String :name
+        String :url
+        String :status      # COMPLETED, IN_PROGRESS, QUEUED, WAITING, PENDING
+        String :conclusion  # SUCCESS, FAILURE, CANCELLED, SKIPPED, NEUTRAL, TIMED_OUT
+        String :updated_at
+        index :pr_number
+      end
+    end
+
+    def self.for_pr(number) = where(pr_number: number.to_i).all
+    def self.upsert_for_pr(number, runs)
+      where(pr_number: number.to_i).delete
+      Array(runs).each do |run|
+        next unless run.is_a?(Hash)
+        insert(
+          pr_number:  number.to_i,
+          name:       run['name']&.to_s,
+          url:        (run['url'] || run['detailsUrl'])&.to_s,
+          status:     run['status']&.to_s,
+          conclusion: run['conclusion']&.to_s,
+          updated_at: Time.now.iso8601
+        )
+      end
+    end
+  end
+end

data/lib/hiiro/db.rb

@@ -69,6 +69,18 @@ class Hiiro
         connection[:schema_migrations].insert_conflict.insert(name: 'full_migration', ran_at: Time.now.iso8601)
       end
 
+      ALL_IMPORTERS = %i[todos links branches prs pinned_prs tasks assignments apps projects pane_homes pins reminders tags].freeze
+
+      # Re-run import for specific tables (or all if none specified).
+      # Useful after a migration that partially failed. The YAML source files must
+      # still exist (they are only renamed to .bak on successful import).
+      def remigrate!(only: nil)
+        base = Hiiro::Config::BASE_DIR
+        targets = only ? Array(only).map(&:to_sym) & ALL_IMPORTERS : ALL_IMPORTERS
+        targets.each { |name| send(:"import_#{name}", base) }
+        puts "Remigration complete: #{targets.join(', ')}"
+      end
+
       private
 
       def migrate_yaml!
@@ -105,6 +117,8 @@ class Hiiro
         File.rename(path, path + '.bak') if File.exist?(path)
       end
 
+      TODO_COLUMNS = %w[id text status tags task_name subtask_name tree branch session created_at updated_at].freeze
+
       def import_todos(base)
         path = File.join(base, 'todo.yml')
         data = load_yaml(path)
@@ -113,7 +127,35 @@ class Hiiro
         todos = data.is_a?(Hash) ? (data['todos'] || []) : []
         todos.each do |row|
           next unless row.is_a?(Hash)
-          connection[:todos].insert(row.transform_keys(&:to_s))
+          r = row.transform_keys(&:to_s)
+
+          # Map legacy boolean started/done fields to status string
+          status = if r['done'] == true || r['status'] == 'done'
+            'done'
+          elsif r['started'] == true || r['status'] == 'started'
+            'started'
+          elsif r['skip'] == true || r['status'] == 'skip'
+            'skip'
+          elsif r['status']
+            r['status'].to_s
+          else
+            'not_started'
+          end
+
+          record = {
+            'text'         => r['text']&.to_s,
+            'status'       => status,
+            'tags'         => r['tags']&.to_s,
+            'task_name'    => r['task_name']&.to_s,
+            'subtask_name' => r['subtask_name']&.to_s,
+            'tree'         => r['tree']&.to_s,
+            'branch'       => r['branch']&.to_s,
+            'session'      => r['session']&.to_s,
+            'created_at'   => r['created_at']&.to_s,
+            'updated_at'   => r['updated_at']&.to_s,
+          }.compact
+          record['id'] = r['id'].to_i if r['id']
+          connection[:todos].insert(record)
         end
         bak(path)
       rescue => e
@@ -153,6 +195,10 @@ class Hiiro
         warn "Hiiro::DB: failed to import branches: #{e}"
       end
 
+      # Old prs.yml from TrackedPr (worktree-tracked PRs, not pinned). Now imported
+      # into the merged :prs table with pinned: false.
+      TRACKED_PR_COLUMNS = %w[number title url branch state worktree task tmux_json created_at updated_at].freeze
+
       def import_prs(base)
         path = File.join(base, 'prs.yml')
         data = load_yaml(path)
@@ -164,27 +210,65 @@ class Hiiro
           normalized = row.transform_keys(&:to_s)
           tmux = normalized.delete('tmux')
           normalized['tmux_json'] = ::JSON.generate(tmux) if tmux
-          connection[:prs].insert(normalized)
+          record = normalized.select { |k, _| TRACKED_PR_COLUMNS.include?(k) }
+          record['pinned'] = false
+          connection[:prs].insert(record) unless record.empty?
         end
         bak(path)
       rescue => e
         warn "Hiiro::DB: failed to import prs: #{e}"
       end
 
+      # Maps YAML camelCase/legacy keys to the merged prs schema column names.
+      PINNED_PR_KEY_MAP = {
+        'headRefName'       => 'head_ref_name',
+        'checks'            => 'checks_json',
+        'statusCheckRollup' => 'check_runs_json',
+        'reviews'           => 'reviews_json',
+        'tags'              => 'tags_json',
+        'depends_on'        => 'depends_on_json',
+      }.freeze
+
+      PINNED_PR_COLUMNS = %w[
+        number title state url head_ref_name branch repo slot pinned is_draft mergeable
+        review_decision checks_json check_runs_json reviews_json task worktree
+        tmux_session tmux_json tags_json assigned authored depends_on_json last_checked
+        pinned_at created_at updated_at
+      ].freeze
+
       def import_pinned_prs(base)
         path = File.join(base, 'pinned_prs.yml')
         data = load_yaml(path)
         return unless data
 
         prs = data.is_a?(Array) ? data : []
-        json_fields = %w[checks statusCheckRollup reviews tags depends_on]
         prs.each do |row|
           next unless row.is_a?(Hash)
           normalized = row.transform_keys(&:to_s)
-          json_fields.each do |field|
-            normalized[field] = ::JSON.generate(normalized[field]) if normalized.key?(field)
+
+          # Rename camelCase/legacy keys to schema column names
+          PINNED_PR_KEY_MAP.each do |from, to|
+            normalized[to] = normalized.delete(from) if normalized.key?(from)
+          end
+
+          # JSON-encode any complex values in *_json columns
+          %w[checks_json check_runs_json reviews_json tags_json depends_on_json].each do |col|
+            v = normalized[col]
+            normalized[col] = ::JSON.generate(v) if v && !v.is_a?(String)
+          end
+
+          # Filter to known schema columns, mark as pinned
+          record = normalized.select { |k, _| PINNED_PR_COLUMNS.include?(k) }
+          record['pinned'] = true
+          next if record.empty?
+
+          connection[:prs].insert(record)
+
+          # Populate check_runs table from check_runs_json if present
+          if (runs_json = record['check_runs_json'])
+            runs = ::JSON.parse(runs_json) rescue nil
+            Hiiro::CheckRun.upsert_for_pr(record['number'], runs) if runs && record['number']
           end
-          connection[:pinned_prs].insert(normalized)
         end
         bak(path)
       rescue => e
@@ -321,6 +405,14 @@ class Hiiro
         warn "Hiiro::DB: failed to import reminders: #{e}"
       end
 
+      # Maps old YAML tag namespace to the Sequel model class name used in taggable_type.
+      TAG_NAMESPACE_TO_TYPE = {
+        'branch'  => 'Branch',
+        'pr'      => 'PinnedPr',
+        'link'    => 'Link',
+        'task'    => 'TaskRecord',
+      }.freeze
+
       def import_tags(base)
         path = File.join(base, 'tags.yml')
         data = load_yaml(path)
@@ -328,13 +420,14 @@ class Hiiro
 
         data.each do |namespace, keys|
           next unless keys.is_a?(Hash)
+          taggable_type = TAG_NAMESPACE_TO_TYPE[namespace.to_s] || namespace.to_s.capitalize
           keys.each do |key, tags|
             next unless tags.is_a?(Array)
             tags.each do |tag|
               connection[:tags].insert(
-                'namespace' => namespace.to_s,
-                'key'       => key.to_s,
-                'tag'       => tag.to_s
+                'name'          => tag.to_s,
+                'taggable_type' => taggable_type,
+                'taggable_id'   => key.to_s
               )
             end
           end

data/lib/hiiro/pinned_pr.rb

@@ -1,19 +1,28 @@
 require 'sequel'
 
 class Hiiro
-  class PinnedPr < Sequel::Model(:pinned_prs)
+  class PinnedPr < Sequel::Model(:prs)
     Hiiro::DB.register(self)
 
     def self.create_table!(db)
-      db.create_table?(:pinned_prs) do
+      # Drop the old TrackedPr schema (prs table without head_ref_name) so we can
+      # create the merged schema. TrackedPr rows are migration artifacts only — no
+      # live code reads from them.
+      if db.table_exists?(:prs) && !db.schema(:prs).any? { |col, _| col == :head_ref_name }
+        db.drop_table(:prs)
+      end
+
+      db.create_table?(:prs) do
         primary_key :id
         Integer :number
         String :title
         String :state
         String :url
         String :head_ref_name
+        String :branch             # from old TrackedPr
         String :repo
         Integer :slot
+        TrueClass :pinned          # true = pinned/monitored, false/nil = just tracked
         TrueClass :is_draft
         String :mergeable
         String :review_decision
@@ -23,14 +32,24 @@ class Hiiro
         String :task
         String :worktree
         String :tmux_session
+        String :tmux_json          # from old TrackedPr: JSON { session, window, pane }
         String :tags_json          # JSON array of strings
         TrueClass :assigned
         TrueClass :authored
         String :depends_on_json    # JSON array of PR numbers
         String :last_checked
         String :pinned_at
+        String :created_at
         String :updated_at
       end
+
+      # Migrate data from legacy pinned_prs table if it still exists
+      if db.table_exists?(:pinned_prs) && db[:pinned_prs].count > 0
+        db[:pinned_prs].each do |row|
+          db[:prs].insert(row.reject { |k, _| k == :id }.merge(pinned: true))
+        end
+      end
+      db.drop_table?(:pinned_prs)
     end
 
     # --- JSON virtual accessors ---
@@ -54,11 +73,17 @@ class Hiiro
     # --- Class methods ---
 
     def self.by_slot
-      order(:slot)
+      order(:slot).where(pinned: true)
     end
 
     def self.find_by_number(n)
-      where(number: n).first
+      where(number: n, pinned: true).first
+    end
+
+    # Sync the check_runs table for this PR from the cached check_runs_json blob.
+    def sync_check_runs
+      runs = Hiiro::DB::JSON.load(check_runs_json)
+      Hiiro::CheckRun.upsert_for_pr(number, runs) if number && runs
     end
 
     # Build an in-memory PinnedPr from a Hiiro::Git::Pr (does NOT save).
@@ -71,6 +96,7 @@ class Hiiro
         head_ref_name:   pr.head_branch,
         repo:            pr.repo,
         slot:            pr.slot,
+        pinned:          true,
         is_draft:        pr.is_draft,
         mergeable:       pr.mergeable,
         review_decision: pr.review_decision,

data/lib/hiiro/pinned_pr_manager.rb

@@ -89,11 +89,14 @@ class Hiiro
 
     def save_pinned(prs)
       Hiiro::DB.connection.transaction do
-        Hiiro::PinnedPr.dataset.delete
+        Hiiro::PinnedPr.where(pinned: true).delete
         prs.each do |pr|
           pinned = pr.is_a?(Hiiro::PinnedPr) ? pr : Hiiro::PinnedPr.from_git_pr(pr)
           attrs  = pinned.to_hash.reject { |k, _| k == :id }
-          Hiiro::PinnedPr.insert(attrs)
+          attrs[:pinned] = true
+          saved = Hiiro::PinnedPr.new(attrs)
+          saved.save
+          saved.sync_check_runs
         end
       end
       # Dual-write YAML for backward compat
@@ -130,11 +133,14 @@ class Hiiro
         updates[:assigned]        = pr.assigned        unless pr.assigned.nil?
         updates[:authored]        = pr.authored        unless pr.authored.nil?
         existing.update(updates)
+        existing.sync_check_runs if updates.key?(:check_runs_json)
       else
         pinned = pr.is_a?(Hiiro::PinnedPr) ? pr : Hiiro::PinnedPr.from_git_pr(pr)
-        pinned.slot     = Hiiro::PinnedPr.max(:slot).to_i + 1
+        pinned.slot      = Hiiro::PinnedPr.max(:slot).to_i + 1
         pinned.pinned_at = Time.now.iso8601
+        pinned.pinned    = true
         pinned.save
+        pinned.sync_check_runs
       end
 
       # Dual-write YAML

data/lib/hiiro/rbenv.rb

@@ -69,17 +69,17 @@ class Hiiro
       end
 
       # Install or update a gem in the given version.
-      def install_gem(gem_name, version: current_version)
+      def install_gem(gem_name, version: current_version, pre: false)
         if gem_installed?(gem_name, version: version)
-          run('gem', 'update', gem_name, version: version)
+          run('gem', 'update', gem_name, pre ? '--pre' : '', version: version)
         else
-          run('gem', 'install', gem_name, version: version)
+          run('gem', 'install', gem_name, pre ? '--pre' : '', version: version)
         end
       end
 
       # Install or update a gem across all installed versions.
-      def install_gem_in_all(gem_name)
-        versions.each { |ver| install_gem(gem_name, version: ver) }
+      def install_gem_in_all(gem_name, pre: false)
+        versions.each { |ver| install_gem(gem_name, pre: pre, version: ver) }
       end
 
       # --- Path helpers ---

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.308.pre.1"
+  VERSION = "0.1.308.pre.2"
 end

data/lib/hiiro.rb

@@ -21,7 +21,7 @@ require_relative "hiiro/input_file"
 require_relative "hiiro/paths"
 require_relative "hiiro/link"
 require_relative "hiiro/branch"
-require_relative "hiiro/tracked_pr"
+require_relative "hiiro/check_run"
 require_relative "hiiro/tags"
 require_relative "hiiro/queue"
 require_relative "hiiro/task_record"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.308.pre.1
+  version: 0.1.308.pre.2
 platform: ruby
 authors:
 - Joshua Toyota
@@ -289,6 +289,7 @@ files:
 - lib/hiiro/background.rb
 - lib/hiiro/bins.rb
 - lib/hiiro/branch.rb
+- lib/hiiro/check_run.rb
 - lib/hiiro/config.rb
 - lib/hiiro/db.rb
 - lib/hiiro/effects.rb
@@ -334,7 +335,6 @@ files:
 - lib/hiiro/tmux/window.rb
 - lib/hiiro/tmux/windows.rb
 - lib/hiiro/todo.rb
-- lib/hiiro/tracked_pr.rb
 - lib/hiiro/version.rb
 - notes
 - obsidian_slides.md

data/lib/hiiro/tracked_pr.rb

@@ -1,30 +0,0 @@
-require 'sequel'
-
-class Hiiro
-  class TrackedPr < Sequel::Model(:prs)
-    Hiiro::DB.register(self)
-
-    def self.create_table!(db)
-      db.create_table?(:prs) do
-        primary_key :id
-        Integer :number
-        String :title
-        String :url
-        String :branch
-        String :state
-        String :worktree
-        String :task
-        String :tmux_json  # JSON: { session, window, pane }
-        String :created_at
-      end
-    end
-
-    def tmux     = Hiiro::DB::JSON.load(tmux_json) || {}
-    def tmux=(v) ; self.tmux_json = Hiiro::DB::JSON.dump(v); end
-
-    def self.for_task(t)       = where(task: t).all
-    def self.for_worktree(w)   = where(worktree: w).all
-    def self.open              = where(state: 'OPEN').all
-    def self.find_by_number(n) = where(number: n).first
-  end
-end