hiiro 0.1.349 → 0.1.351

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6b10e8a634a24ac7953cb7a8639574cd7e8b7b33b4876d6930bbdc5edc2a938
-  data.tar.gz: 2ea99568dc1b989af28b281268587f7c33c1f5174ed115935e938b0a2f21dc86
+  metadata.gz: '0586a9cc0e070785c9a0ef12282146ed71172875e706480d3dca6d663f5a46e8'
+  data.tar.gz: ffec55f5b2ce8882cb06189dedf5e29ccb75a3b8214a76fc72e7dc460851f2cd
 SHA512:
-  metadata.gz: 7e8c40d072f6e425770b8b817c08e35aca290ce8af7468e3ddb8bde5f2f5c137055843210abb08b241f36562bad44b779790aad009998cb2172adf649a529ead
-  data.tar.gz: 5e83c626d13d0b0497c95a3a159eb20b6bffecb6168f8b7d2290a3cd89c312a0038aaf5dc3339a28bc448d5655b87cccffabc848c17bd857b81a9cde28a408c3
+  metadata.gz: e40c167924bce7ac225b17e0fd7c82855c0d6034e66814c4b3e4897ee00dc80b9214b52dafe4d3a98c7916b0194c0a7d4b234e9f55a5a51fd0d73329315132ee
+  data.tar.gz: 994e44431c7a4dc5a15a2eaaa0ffa6c9b0382229b5d84dac1521c56129b599c08316e124511e6f5cf830e7189ab326672e599c228c11b7ddb7776be42c86bfdc

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [Unreleased]
+
+### Fixed
+- `h capture path <num>` now prints the path of the Nth most recent capture (was always printing the captures dir regardless of args)
+- `h capture new` / `h capture file` now record to the DB even when interrupted (Ctrl-C, exception) so partial captures show up in `h capture ls`. Interrupted captures display with the existing `?` glyph and `(exit interrupted)` message.
+
+## [0.1.350] - 2026-04-18
+
+### Added
+- `h-capture` command and `Hiiro::Capture` module for clipboard/selection capture
+
+### Changed
+- Optimize `Hiiro::Shell::Result#plain_text` and `#lines` with instance-level caching
+- Refactor `Shell::Result#lines` to use `String#lines(chomp: true)` for improved line handling
+- Reduce Claude API effort to `low` in publish script for faster changelog generation
+
 ## [0.1.349] - 2026-04-17
 
 ### Removed
@@ -300,93 +316,4 @@
 - `h db cleanup` subcommand to preview and prune duplicate rows from SQLite tables
 
 ### Fixed
-- Prevent duplicate pinned_prs during import with `insert_conflict` and per-row rescue
-
-## [0.1.308.pre.6] - 2026-03-31
-
-### Fixed
-- Prevent duplicate pinned_prs during import with `insert_conflict` and per-row rescue
-
-## [0.1.308.pre.5] - 2026-03-31
-
-### Added
-- `h-claude vim` subcommand to open all matched files in `$EDITOR`
-
-### Fixed
-- `h branch ls` now sorts oldest-first so most recent branches appear at bottom
-
-## [0.1.308.pre.4] - 2026-03-31
-
-### Fixed
-- Don't pass empty string arg to gem when `--pre` is false
-
-## [0.1.308.pre.3] - 2026-03-31
-
-### Changed
-- Poll RubyGems in `delayed_update` instead of blind sleep for more reliable version detection
-
-### Fixed
-- Per-row rescue in `import_todos` so one bad row doesn't abort the entire batch
-
-## [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
-- `Hiiro::Effects` injectable interface for testable file system and command execution
-- `null_fs` to `TestHarness` for testing without side effects
-- Effects helpers and accessors to `TestHarness` for controlled effect simulation
-- `Hiiro::Invocation` and `Hiiro::InvocationResolution` tracking in PaneHome SQLite migration
-
-### Changed
-- Refactor effects layer: expose `executor` and `fs` as accessors on `Hiiro::Effects`
-- `h-db` command now includes h-pane in SQLite migration
-- Gem version handling: treat non-main branches as pre-release in publish script
-
-### Fixed
-- `h-branch co` and `h-branch rm` restore extra argument pass-through
-- Test suite: add missing `TestHarness` stubs and fix pre-existing test failures
-- Test fixtures: anchor `load_bin` path to project root instead of `Dir.pwd`
-
-### Deprecated
-- `SystemCallCapture` — use `Hiiro::Effects` helpers in `TestHarness` instead
-
-## [0.1.307]
-
-### Added
-- `Hiiro::DB` — SQLite foundation via Sequel; `DB.setup!` creates all tables, `DB.connection` establishes connection eagerly at load time; supports `HIIRO_TEST_DB=sqlite::memory:` for tests
-- `lib/hiiro/db.rb` — one-time YAML→SQLite migration (`migrate_yaml!`) guarded by `schema_migrations` table; dual-write mode (`dual_write?` / `disable_dual_write!`) for gradual cutover
-- `lib/hiiro/branch.rb` — `Hiiro::Branch` Sequel model for worktree branch records
-- `lib/hiiro/tracked_pr.rb` — `Hiiro::TrackedPr` Sequel model for tracked PR records (`:prs` table)
-- `lib/hiiro/link.rb` — `Hiiro::Link` Sequel model with `matches?`, `display_string`, `to_h` helpers
-- `lib/hiiro/project.rb` — `Hiiro::Project` Sequel model
-- `lib/hiiro/pane_home.rb` — `Hiiro::PaneHome` Sequel model with `data_json` JSON blob
-- `lib/hiiro/pin_record.rb` — `Hiiro::PinRecord` Sequel model for per-command key-value pin storage
-- `lib/hiiro/task_record.rb` — `Hiiro::TaskRecord` Sequel model for task metadata
-- `lib/hiiro/app_record.rb` — `Hiiro::AppRecord` Sequel model for app directory mappings
-- `lib/hiiro/assignment.rb` — `Hiiro::Assignment` Sequel model for worktree→branch assignments
-- `lib/hiiro/reminder.rb` — `Hiiro::Reminder` Sequel model
-- `lib/hiiro/invocation.rb` — `Hiiro::Invocation` and `Hiiro::InvocationResolution` Sequel models; every CLI invocation is recorded to SQLite for history/analytics
-- `bin/h-db` — new subcommand: `h db status`, `h db tables`, `h db q <sql>`, `h db migrate`, `h db restore`
-
-### Changed
-- `lib/hiiro/todo.rb` — `TodoItem` is now a `Sequel::Model`; `TodoManager` reads/writes via SQLite with YAML dual-write fallback
-- `lib/hiiro/tags.rb` — `Tag` is now a `Sequel::Model`; tag operations persist to SQLite with YAML dual-write fallback
-- `lib/hiiro/pinned_pr_manager.rb` — `PinnedPR` is now a `Sequel::Model` (`lib/hiiro/pinned_pr.rb`); `PinnedPRManager` reads/writes via SQLite with YAML dual-write
-- `lib/hiiro/projects.rb` — `Projects#from_config` reads from `Hiiro::Project` SQLite model with YAML fallback
-- `lib/hiiro/tasks.rb` — `TaskManager::Config` reads/writes tasks and apps via `Hiiro::TaskRecord` and `Hiiro::AppRecord` SQLite models
-- `bin/h-branch` — `BranchManager` reads/writes via `Hiiro::Branch` and `Hiiro::TrackedPr` SQLite models with YAML dual-write fallback; adds `q`/`query` subcommands for raw SQL inspection
-- `bin/h-link` — reads/writes links via `Hiiro::Link` SQLite model with YAML dual-write fallback; adds `q`/`query` subcommands
-- `bin/h-pane` — load/save pane homes via `Hiiro::PaneHome` model with YAML dual-write
-- `bin/h-pr` — adds `q`/`query` subcommands for inspecting PR records via raw SQL
-- `plugins/pins.rb` — `Pin` class reads/writes via `Hiiro::PinRecord` SQLite model with YAML dual-write fallback
+- Prevent duplicate pinned_prs during import with `insert_conflict` and per-row rescue

data/bin/h-capture

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'open3'
+require 'time'
+require 'hiiro'
+
+CAPTURES_DIR = File.expand_path('~/.local/share/hiiro/captures')
+
+# TODO(USER): implement resolve_path.
+#
+# Given a name-or-path string from `h capture file <fpath_or_name> ...`,
+# return the absolute filesystem path where the capture should be written.
+#
+# Spec from the user:
+#   - If the input has NO path separators (just a bare filename like "build.log"),
+#     the file goes in CAPTURES_DIR.
+#   - Otherwise it's a path expression — write it relative to the current
+#     working directory (or honor it as-is if already absolute).
+#
+# Open design questions for you to decide:
+#   - Should "~/foo.log" be expanded? (File.expand_path handles this for free)
+#   - Should we ensure parent dirs exist via FileUtils.mkdir_p?
+#   - Should paths starting with "./" be normalized?
+#
+# Whichever rules you pick, this 5–8 line method is the contract for where
+# `h capture file` writes — so it's worth getting right for your workflow.
+def resolve_path(name_or_path)
+  if File.dirname(name_or_path) != ?.
+    FileUtils.mkdir_p(File.dirname(name_or_path))
+    return name_or_path
+  end
+
+  FileUtils.mkdir_p(CAPTURES_DIR)
+  File.join(CAPTURES_DIR, name_or_path)
+end
+
+def ensure_dir(path)
+  FileUtils.mkdir_p(File.dirname(path))
+end
+
+# Run cmd, tee combined stdout+stderr to terminal AND to output_path.
+# If our own stdin is piped (not a tty), forward it into the subprocess.
+def run_and_capture(cmd_args, output_path)
+  ensure_dir(output_path)
+  exit_status = nil
+
+  File.open(output_path, 'w') do |f|
+    Open3.popen2e(*cmd_args) do |stdin, stdout_err, wait_thr|
+      pipe_thread = if !STDIN.tty?
+        Thread.new do
+          IO.copy_stream(STDIN, stdin)
+        rescue Errno::EPIPE, IOError
+          # subprocess closed stdin early — fine
+        ensure
+          stdin.close rescue nil
+        end
+      else
+        stdin.close
+        nil
+      end
+
+      loop do
+        chunk = stdout_err.readpartial(4096)
+        $stdout.write(chunk)
+        $stdout.flush
+        f.write(chunk)
+      rescue EOFError
+        break
+      end
+
+      pipe_thread&.join
+      exit_status = wait_thr.value.exitstatus
+    end
+  end
+
+  exit_status
+end
+
+def fetch_capture(num)
+  Hiiro::Capture.at_offset(num.to_i)
+end
+
+def record_capture(name:, path:, command:, exit_status:)
+  Hiiro::Capture.create(
+    name: name,
+    path: path,
+    command: command,
+    exit_status: exit_status
+  )
+end
+
+# Run the command and record the capture even if interrupted (Ctrl-C, error).
+# `exit_status` is nil when the process didn't reach a clean exit — the `?`
+# glyph in Hiiro::Capture#status_glyph already handles that case.
+def capture_and_record(args, path:, name:)
+  code = nil
+  begin
+    code = run_and_capture(args, path)
+  ensure
+    record_capture(name: name, path: path, command: args.join(' '), exit_status: code)
+    warn "\n[capture saved: #{path} (exit #{code || 'interrupted'})]"
+  end
+end
+
+Hiiro.run(*ARGV) do
+  add_subcmd(:new) do |*args|
+    if args.empty?
+      puts "Usage: h capture new <command> [args...]"
+      exit 1
+    end
+
+    name = "#{Time.now.strftime('%Y%m%d%H%M%S')}.output"
+    path = File.join(CAPTURES_DIR, name)
+    ensure_dir(path)
+
+    capture_and_record(args, path: path, name: name)
+  end
+
+  add_subcmd(:file) do |fpath = nil, *args|
+    if fpath.nil? || args.empty?
+      puts "Usage: h capture file <fpath_or_name> <command> [args...]"
+      exit 1
+    end
+
+    path = resolve_path(fpath)
+    name = File.basename(fpath)
+
+    capture_and_record(args, path: path, name: name)
+  end
+
+  add_subcmd(:ls) do |num = nil|
+    captures = if num.nil?
+      Hiiro::Capture.recent
+    elsif num.to_i >= 0
+      cap = Hiiro::Capture.at_offset(num.to_i)
+      cap ? [cap] : []
+    else
+      Hiiro::Capture.recent(num.to_i.abs)
+    end
+
+    if captures.empty?
+      puts "No captures."
+      next
+    end
+
+    captures.each_with_index { |cap, i| puts cap.display_string(i) }
+  end
+
+  add_subcmd(:cat) do |num = 0|
+    cap = fetch_capture(num)
+    if cap.nil?
+      warn "No capture at offset #{num}."
+      exit 1
+    end
+    unless File.exist?(cap.path)
+      warn "File missing: #{cap.path}"
+      exit 1
+    end
+    $stdout.write(File.read(cap.path))
+  end
+
+  add_subcmd(:cppath) do |num = 0|
+    cap = fetch_capture(num)
+    if cap.nil?
+      warn "No capture at offset #{num}."
+      exit 1
+    end
+    Hiiro::Shell.pipe(cap.path, 'pbcopy')
+    puts "Copied path: #{cap.path}"
+  end
+
+  add_subcmd(:cp) do |num = 0|
+    cap = fetch_capture(num)
+    if cap.nil?
+      warn "No capture at offset #{num}."
+      exit 1
+    end
+    unless File.exist?(cap.path)
+      warn "File missing: #{cap.path}"
+      exit 1
+    end
+    Hiiro::Shell.pipe(File.read(cap.path), 'pbcopy')
+    puts "Copied contents of: #{cap.path}"
+  end
+
+  add_subcmd(:path) do |num = nil|
+    if num.nil?
+      print CAPTURES_DIR
+      next
+    end
+
+    cap = fetch_capture(num)
+    if cap.nil?
+      warn "No capture at offset #{num}."
+      exit 1
+    end
+    print cap.path
+  end
+end

data/lib/hiiro/capture.rb

@@ -0,0 +1,42 @@
+require 'sequel'
+
+class Hiiro
+  class Capture < Sequel::Model(:captures)
+    Hiiro::DB.register(self)
+
+    def self.create_table!(db)
+      db.create_table?(:captures) do
+        primary_key :id
+        String :name, null: false
+        String :path, null: false
+        String :command
+        Integer :exit_status
+      end
+    end
+
+    # Most-recent-first scope. id is autoincrement, so desc(:id) == chronological reverse.
+    def self.recent(limit = nil)
+      ds = order(Sequel.desc(:id))
+      limit ? ds.limit(limit).all : ds.all
+    end
+
+    # Fetch the capture at offset n from the most recent (0 = newest).
+    def self.at_offset(n)
+      order(Sequel.desc(:id)).offset(n.to_i).first
+    end
+
+    def status_glyph
+      case exit_status
+      when 0   then "\e[32m✓\e[0m"
+      when nil then "\e[33m?\e[0m"
+      else          "\e[31m✗\e[0m"
+      end
+    end
+
+    def display_string(idx)
+      cmd = command.to_s
+      cmd = cmd[0, 57] + '…' if cmd.length > 60
+      format("%4d. %s  %-22s  %s", idx, status_glyph, name, cmd)
+    end
+  end
+end

data/lib/hiiro/shell.rb

@@ -77,6 +77,21 @@ class Hiiro
   end
 
   class Result
+    # Factory: reads chunks from an IO (popen handle), optionally tee-ing
+    # each chunk to `tee` as it arrives. Used by Shell.stream / stream_combined.
+    # Pass tee: nil to capture without printing.
+    def self.collect_chunks(io, wait_thr, tee: $stdout)
+      output = +""
+      loop do
+        chunk = io.readpartial(4096)
+        tee&.write(chunk)
+        output << chunk
+      rescue EOFError
+        break
+      end
+      new(output, wait_thr.value)
+    end
+
     # Matches the full ANSI/VT100 escape sequence spec:
     # cursor movement, erase, colors, SGR — everything a terminal interprets.
     # [^[] catches all single-char Fe sequences (e.g. \eM, \eD); \[...] catches CSI.
@@ -115,27 +130,12 @@ class Hiiro
     # Strip ANSI escape codes for text processing or filtering.
     # Also strips bare \r (carriage-return-only, used by progress bars).
     def plain_text
-      stdout.gsub(ANSI_PATTERN, '').gsub(/\r(?!\n)/, '')
+      @plain_text ||= stdout.gsub(ANSI_PATTERN, '').gsub(/\r(?!\n)/, '')
     end
 
     # Plain text split into non-empty lines.
     def lines
-      plain_text.split("\n").reject(&:empty?)
-    end
-
-    # Factory: reads chunks from an IO (popen handle), optionally tee-ing
-    # each chunk to `tee` as it arrives. Used by Shell.stream / stream_combined.
-    # Pass tee: nil to capture without printing.
-    def self.collect_chunks(io, wait_thr, tee: $stdout)
-      output = +""
-      loop do
-        chunk = io.readpartial(4096)
-        tee&.write(chunk)
-        output << chunk
-      rescue EOFError
-        break
-      end
-      new(output, wait_thr.value)
+      @lines ||= plain_text.lines(chomp: true)
     end
   end
 end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.349"
+  VERSION = "0.1.351"
 end

data/lib/hiiro.rb

@@ -21,6 +21,7 @@ require_relative "hiiro/options"
 require_relative "hiiro/input_file"
 require_relative "hiiro/paths"
 require_relative "hiiro/link"
+require_relative "hiiro/capture"
 require_relative "hiiro/branch"
 require_relative "hiiro/check_run"
 require_relative "hiiro/tags"

data/script/publish

@@ -166,7 +166,7 @@ class Claude
       }
     PROMPT
 
-    raw = IO.popen(["claude", "-p", "--model", MODEL], "r+") { |io|
+    raw = IO.popen(["claude", "-p", "--model", MODEL, '--effort', 'low'], "r+") { |io|
       io.write(prompt)
       io.close_write
       io.read

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.349
+  version: 0.1.351
 platform: ruby
 authors:
 - Joshua Toyota
@@ -131,6 +131,7 @@ files:
 - bin/h-bin
 - bin/h-branch
 - bin/h-buffer
+- bin/h-capture
 - bin/h-claude
 - bin/h-commit
 - bin/h-config
@@ -326,6 +327,7 @@ files:
 - lib/hiiro/background.rb
 - lib/hiiro/bins.rb
 - lib/hiiro/branch.rb
+- lib/hiiro/capture.rb
 - lib/hiiro/check_run.rb
 - lib/hiiro/config.rb
 - lib/hiiro/db.rb