hiiro 0.1.277 → 0.1.279

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c0ebae864202a90016b7b7df7f65a32836cc11c144ea85638a9c75b22279b72
-  data.tar.gz: 9a5e414ec3dc428f932acdaf47f989c80d2ca50a1fd19fe4d2d7fa9e4c634a76
+  metadata.gz: dac54cf95b87a2dd963a261922d9d269597970236714ace84586538ee38b643c
+  data.tar.gz: '0408a01c35a5888a2ff78d880085278b719007aa47ed40257749c65410225592'
 SHA512:
-  metadata.gz: 4cbdc7c7029c4acfbf6720c47d63d330bb71c270ba1546d76e743a6c05fef40f98229458a39d981627fb49767fac3c63e745b681e12ddde30e180b251ac94087
-  data.tar.gz: 3a95e13a5ebc85325d8426d398812499924bc8605f7e5e0e785cbb16b3ffafa6161ec7d04d1ff72387286779f8142bcff3f338348c35791192b1d97c72e5f780
+  metadata.gz: 74324fbd4fcfdb860270388df1a19f1affff4030d1d0a2c88362c9c3d26f1a1af7170a9eae2303b8467b2a60f6492166cdb2a0f69ba79adbe58dfcc8378ea005
+  data.tar.gz: b6d351fd166a8b694c067d83ffba0f63681f37c08565ebd3d24eaa3c2bad7d2a598327b54a47eb49f3ccc04d658b0be12cfd52fae4574a2fcfc712f24742cc8b

data/CHANGELOG.md

@@ -1,6 +1 @@
-Done. Updated CHANGELOG.md:
-
-- Moved `Hiiro#add_resolver` and `Hiiro#resolve` from the Unreleased section to the new v0.1.277 release section (2026-03-24)
-- Added them to the Added subsection of v0.1.277
-- Added a Changed entry documenting the `h pr` refactoring that uses these new methods
-- Updated the Unreleased section to remove these items and add a note in Changed about the `h pr` refactoring
+Done. CHANGELOG.md has been updated with v0.1.279 for 2026-03-25. The new section documents the refactoring of `Hiiro::PinnedPRManager` extraction to `lib/hiiro/pinned_pr_manager.rb`, which is the only meaningful code change in the recent commits (the others were script updates and documentation restoration).

data/bin/h-app

@@ -251,6 +251,22 @@ Hiiro.run(*ARGV) {
     exec('vim', *args)
   }
 
+  add_subcmd(:sh) { |app_name=nil, *args|
+    root = git.root || task_root
+    unless root
+      puts "Not in a git repo or task - cannot resolve path"
+      next
+    end
+    result = environment.app_matcher.find(app_name.to_s)
+    unless result.match?
+      puts "App '#{app_name}' not found"
+      next
+    end
+    app_path = File.join(root, result.first.item.relative_path)
+    Dir.chdir(app_path)
+    args.empty? ? exec(ENV['SHELL'] || 'zsh') : exec(*args)
+  }
+
   add_subcmd(:service) do |*svc_args|
     sm = Hiiro::ServiceManager.new
     Hiiro::ServiceManager.build_hiiro(this, sm).run

data/bin/h-pr

@@ -7,573 +7,6 @@ require "yaml"
 require "json"
 require "tempfile"
 
-class PinnedPRManager
-  def pr_repo(pr)
-    pr.repo || Hiiro::Git::Pr.repo_from_url(pr.url)
-  end
-
-  def initialize
-    ensure_file
-  end
-
-  def ensure_file
-    dir = File.dirname(Hiiro::Git::Pr::PINNED_FILE)
-    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-    File.write(Hiiro::Git::Pr::PINNED_FILE, [].to_yaml) unless File.exist?(Hiiro::Git::Pr::PINNED_FILE)
-  end
-
-  def load_pinned
-    ensure_file
-    prs = Hiiro::Git::Pr.pinned_prs
-    if prs.any? { |p| p.slot.nil? }
-      next_slot = prs.map { |p| p.slot.to_i }.max.to_i
-      prs.each do |p|
-        next if p.slot
-        next_slot += 1
-        p.slot = next_slot
-      end
-      save_pinned(prs)
-    end
-    prs
-  end
-
-  def save_pinned(prs)
-    ensure_file
-    File.write(Hiiro::Git::Pr::PINNED_FILE, prs.map(&:to_pinned_h).to_yaml)
-  end
-
-  def pin(pr)
-    pr.repo ||= Hiiro::Git::Pr.repo_from_url(pr.url)
-
-    pinned = load_pinned
-    existing = pinned.find { |p|
-      p.number == pr.number && pr_repo(p) == pr_repo(pr)
-    }
-
-    if existing
-      existing.title           = pr.title           unless pr.title.nil?
-      existing.state           = pr.state           unless pr.state.nil?
-      existing.url             = pr.url             unless pr.url.nil?
-      existing.head_branch     = pr.head_branch     unless pr.head_branch.nil?
-      existing.repo            = pr.repo            unless pr.repo.nil?
-      existing.is_draft        = pr.is_draft        unless pr.is_draft.nil?
-      existing.mergeable       = pr.mergeable       unless pr.mergeable.nil?
-      existing.review_decision = pr.review_decision unless pr.review_decision.nil?
-      existing.check_runs      = pr.check_runs      unless pr.check_runs.nil?
-      existing.checks          = pr.checks          unless pr.checks.nil?
-      existing.reviews         = pr.reviews         unless pr.reviews.nil?
-      existing.task            = pr.task            unless pr.task.nil?
-      existing.worktree        = pr.worktree        unless pr.worktree.nil?
-      existing.tmux_session    = pr.tmux_session    unless pr.tmux_session.nil?
-      existing.tags            = pr.tags            unless pr.tags.nil?
-      existing.assigned        = pr.assigned        unless pr.assigned.nil?
-      existing.authored        = pr.authored        unless pr.authored.nil?
-      existing.updated_at      = Time.now.iso8601
-    else
-      pr.slot      = (pinned.map { |p| p.slot.to_i }.max.to_i) + 1
-      pr.pinned_at = Time.now.iso8601
-      pinned << pr
-    end
-
-    save_pinned(pinned)
-    pr
-  end
-
-  def unpin(pr_number)
-    pinned = load_pinned
-    removed = pinned.reject! { |p| p.number.to_s == pr_number.to_s }
-    save_pinned(pinned)
-    removed
-  end
-
-  def pinned?(pr_number)
-    load_pinned.any? { |p| p.number.to_s == pr_number.to_s }
-  end
-
-  def fetch_pr_info(pr_number, repo: nil)
-    fields = 'number,title,url,headRefName,state,statusCheckRollup,reviewDecision,reviews,isDraft,mergeable'
-    repo_flag = repo ? " --repo #{repo}" : ""
-    output = `gh pr view #{pr_number}#{repo_flag} --json #{fields} 2>/dev/null`.strip
-    return nil if output.empty?
-    Hiiro::Git::Pr.from_gh_json(JSON.parse(output))
-  rescue JSON::ParserError
-    nil
-  end
-
-  def fetch_current_branch_pr
-    fields = 'number,title,url,headRefName,state'
-    output = `gh pr view --json #{fields} 2>/dev/null`.strip
-    return nil if output.empty?
-    Hiiro::Git::Pr.from_gh_json(JSON.parse(output))
-  rescue JSON::ParserError
-    nil
-  end
-
-  def fetch_my_prs
-    output = `gh pr list --author @me --state open --json number,title,headRefName,url 2>/dev/null`.strip
-    return [] if output.empty?
-    prs = JSON.parse(output) rescue []
-    prs.map { |data| Hiiro::Git::Pr.from_gh_json(data) }
-  end
-
-  def fetch_assigned_prs
-    output = `gh pr list --assignee @me --state open --json number,title,headRefName,url 2>/dev/null`.strip
-    return [] if output.empty?
-    prs = JSON.parse(output) rescue []
-    prs.map { |data| Hiiro::Git::Pr.from_gh_json(data) }
-  end
-
-  def fetch_my_and_assigned_prs
-    authored_prs = fetch_my_prs
-    assigned_prs = fetch_assigned_prs
-
-    authored_numbers = authored_prs.map(&:number).to_set
-    assigned_prs.each { |pr| pr.assigned = true unless authored_numbers.include?(pr.number) }
-    authored_prs.each { |pr| pr.authored = true }
-
-    (authored_prs + assigned_prs).uniq(&:number)
-  end
-
-  def needs_refresh?(pr, force: false)
-    return true if force
-    return true unless pr.last_checked
-
-    last_check_time = Time.parse(pr.last_checked) rescue nil
-    return true unless last_check_time
-
-    # Refresh if last check was more than 2 minutes ago
-    (Time.now - last_check_time) > 120
-  end
-
-  def code_freeze_active?
-    return @code_freeze_active unless @code_freeze_active.nil?
-
-    output = `isc codefreeze list 2>/dev/null`.strip
-    return @code_freeze_active = false if output.empty?
-
-    now = Time.now
-    @code_freeze_active = output.lines.drop(1).any? do |line|
-      parts = line.strip.split(/\s{2,}/)
-      next false if parts.length < 2
-
-      start_time = Time.parse(parts[0]) rescue nil
-      end_time   = Time.parse(parts[1]) rescue nil
-      next false unless start_time && end_time
-
-      now >= start_time && now <= end_time
-    end
-  rescue
-    @code_freeze_active = false
-  end
-
-  # Overrides the ISC code freeze StatusContext in a raw statusCheckRollup array
-  # to reflect the actual current freeze state rather than GitHub's cached value.
-  def apply_isc_code_freeze_override!(rollup, frozen)
-    return unless rollup.is_a?(Array)
-
-    rollup.each do |ctx|
-      next unless ctx['__typename'] == 'StatusContext' && ctx['context'] == 'ISC code freeze'
-      ctx['state'] = frozen ? 'FAILURE' : 'SUCCESS'
-    end
-  end
-
-
-  # Accepts an array of PR records (each with 'number' and optionally 'repo'/'url'),
-  # groups them by repo, and fetches in batches per repo via GraphQL.
-  def batch_fetch_pr_info(prs)
-    return {} if prs.empty?
-
-    by_repo = prs.group_by { |pr| pr_repo(pr) || 'instacart/carrot' }
-
-    result = {}
-    by_repo.each do |repo_path, repo_prs|
-      owner, name = repo_path.split('/', 2)
-      pr_numbers = repo_prs.map(&:number)
-      result.merge!(fetch_batch_for_repo(owner, name, pr_numbers))
-    end
-    result
-  end
-
-  private
-
-  def fetch_batch_for_repo(owner, name, pr_numbers)
-    return {} if pr_numbers.empty?
-
-    pr_queries = pr_numbers.map.with_index do |num, idx|
-      <<~GRAPHQL.strip
-        pr#{idx}: pullRequest(number: #{num}) {
-          number
-          title
-          url
-          headRefName
-          state
-          isDraft
-          mergeable
-          reviewDecision
-          statusCheckRollup {
-            contexts(last: 100) {
-              nodes {
-                ... on CheckRun {
-                  __typename
-                  name
-                  conclusion
-                  status
-                  detailsUrl
-                }
-                ... on StatusContext {
-                  __typename
-                  context
-                  state
-                  targetUrl
-                }
-              }
-            }
-          }
-          reviews(last: 50) {
-            nodes {
-              author {
-                login
-              }
-              state
-            }
-          }
-        }
-      GRAPHQL
-    end
-
-    query = <<~GRAPHQL
-      query {
-        repository(owner: "#{owner}", name: "#{name}") {
-          #{pr_queries.join("\n")}
-        }
-      }
-    GRAPHQL
-
-    result = `gh api graphql -f query='#{query.gsub("'", "'\\''")}' 2>/dev/null`
-    return {} if result.empty?
-
-    data = JSON.parse(result)
-    repo_data = data.dig('data', 'repository')
-    return {} unless repo_data
-
-    pr_info_by_key = {}
-    repo_path = "#{owner}/#{name}"
-    pr_numbers.each_with_index do |num, idx|
-      pr_data = repo_data["pr#{idx}"]
-      next unless pr_data
-
-      pr_info_by_key[[num, repo_path]] = {
-        'number' => pr_data['number'],
-        'title' => pr_data['title'],
-        'url' => pr_data['url'],
-        'headRefName' => pr_data['headRefName'],
-        'state' => pr_data['state'],
-        'isDraft' => pr_data['isDraft'],
-        'mergeable' => pr_data['mergeable'],
-        'reviewDecision' => pr_data['reviewDecision'],
-        'statusCheckRollup' => pr_data.dig('statusCheckRollup', 'contexts', 'nodes'),
-        'reviews' => pr_data.dig('reviews', 'nodes') || [],
-        'repo' => repo_path
-      }
-    end
-
-    pr_info_by_key
-  rescue JSON::ParserError, StandardError
-    {}
-  end
-
-  public
-
-  def refresh_all_status(prs, force: false)
-    prs_to_refresh = prs.select { |pr| needs_refresh?(pr, force: force) }
-
-    if prs_to_refresh.empty?
-      puts "All PRs recently checked (within last 2 minutes). Use -U to force update." unless force
-      return prs
-    end
-
-    # infos is keyed by [number, repo] to avoid collisions across repos
-    infos = batch_fetch_pr_info(prs_to_refresh)
-    frozen = code_freeze_active?
-
-    prs_to_refresh.each do |pr|
-      info = infos[[pr.number, pr_repo(pr) || 'instacart/carrot']]
-      next unless info
-
-      rollup = info['statusCheckRollup']
-      apply_isc_code_freeze_override!(rollup, frozen)
-
-      pr.state           = info['state']
-      pr.title           = info['title']
-      pr.check_runs      = rollup
-      pr.checks          = Hiiro::Git::Pr.summarize_checks(rollup)
-      pr.reviews         = Hiiro::Git::Pr.summarize_reviews(info['reviews'])
-      pr.review_decision = info['reviewDecision']
-      pr.is_draft        = info['isDraft']
-      pr.mergeable       = info['mergeable']
-      pr.last_checked    = Time.now.iso8601
-    end
-
-    prs
-  end
-
-  def refresh_status(pr, force: false)
-    return pr unless needs_refresh?(pr, force: force)
-
-    info = fetch_pr_info(pr.number, repo: pr_repo(pr))
-    return pr unless info
-
-    rollup = info.check_runs
-    apply_isc_code_freeze_override!(rollup, code_freeze_active?)
-
-    pr.state           = info.state
-    pr.title           = info.title
-    pr.check_runs      = rollup
-    pr.checks          = Hiiro::Git::Pr.summarize_checks(rollup)
-    pr.reviews         = info.reviews
-    pr.review_decision = info.review_decision
-    pr.is_draft        = info.is_draft
-    pr.mergeable       = info.mergeable
-    pr.last_checked    = Time.now.iso8601
-    pr
-  end
-
-  FILTER_PREDICATES = {
-    red:       ->(pr) { (c = pr.checks) && c['failed'].to_i > 0 },
-    green:     ->(pr) { (c = pr.checks) && c['failed'].to_i == 0 && c['pending'].to_i == 0 && c['success'].to_i > 0 },
-    conflicts: ->(pr) { pr.conflicting? },
-    drafts:    ->(pr) { pr.draft? },
-    pending:   ->(pr) { (c = pr.checks) && c['pending'].to_i > 0 && c['failed'].to_i == 0 },
-    merged:    ->(pr) { pr.merged? },
-    active:    ->(pr) { !pr.merged? && !pr.closed? },
-  }.freeze
-
-  def display_pinned(pr, idx = nil, widths: {}, oneline: false)
-    slot_w  = widths[:slot]  || 1
-    succ_w  = widths[:succ]  || 1
-    total_w = widths[:total] || 1
-    as_w    = widths[:as]    || 1
-    crs_w   = widths[:crs]   || 1
-
-    slot_num = (pr.slot || (idx ? idx + 1 : 1)).to_s
-    num    = "#{slot_num.rjust(slot_w)}."
-    indent = " " * (slot_w + 2)
-
-    check_emoji, checks_count_str =
-      if pr.checks
-        c = pr.checks
-        has_failed   = c['failed'].to_i > 0
-        has_pending  = c['pending'].to_i > 0
-        only_frozen  = has_failed && c['failed'].to_i == c['frozen'].to_i
-        emoji = if has_failed && has_pending
-          only_frozen ? "⏳❄️" : "⏳❌"
-        elsif has_failed
-          only_frozen ? "　❄️" : "　❌"
-        elsif has_pending
-          "⏳　"
-        else
-          "　✅"
-        end
-        succ  = c['success'].to_i.to_s.rjust(succ_w)
-        total = c['total'].to_i.to_s.rjust(total_w)
-        [emoji, "#{succ}/#{total}"]
-      else
-        ["", nil]
-      end
-
-    state_label = case pr.state
-    when 'MERGED' then 'M'
-    when 'CLOSED' then 'X'
-    else pr.draft? ? 'd' : 'o'
-    end
-
-    bracket_parts = [state_label, check_emoji, checks_count_str].reject { |p| p.nil? || p.empty? }
-    state_icon = "[#{bracket_parts.join(' ')}]"
-
-    r = pr.reviews || {}
-    as  = r['approved'].to_i
-    crs = r['changes_requested'].to_i
-
-    as_val  = as  > 0 ? as.to_s  : '-'
-    crs_val = crs > 0 ? crs.to_s : '-'
-    as_colored  = as  > 0 ? "\e[30;102m#{as_val}\e[0m"  : as_val
-    crs_colored = crs > 0 ? "\e[30;103m#{crs_val}\e[0m" : crs_val
-    as_pad  = " " * [as_w  - as_val.length,  0].max
-    crs_pad = " " * [crs_w - crs_val.length, 0].max
-    conflict_str = pr.conflicting? ? " \e[30;101mC\e[0m" : ""
-    reviews_str = "#{as_pad}#{as_colored}a/#{crs_pad}#{crs_colored}cr#{conflict_str}"
-
-    repo = pr_repo(pr)
-    repo_label = (repo && repo != 'instacart/carrot') ? "[#{repo}] " : ""
-
-    tags = Array(pr.tags)
-    tags_str = tags.any? ? tags.map { |t| "\e[30;104m#{t}\e[0m" }.join(' ') : nil
-
-    branch_str = pr.head_branch ? " \e[90m#{pr.head_branch}\e[0m" : ""
-    title_str = "\e[1m#{pr.title}\e[0m"
-    line1 = "#{num} ##{pr.number} #{state_icon} #{reviews_str}#{branch_str}"
-    line2 = "#{indent}#{repo_label}#{title_str}"
-    line3 = pr.url ? "#{indent}#{pr.url}" : nil
-    line4 = tags_str ? "#{indent}#{tags_str}" : nil
-
-    if oneline
-      "#{line1} #{repo_label}#{title_str}#{tags_str ? "  #{tags_str}" : ""}"
-    else
-      [line1, line2, line3, line4].compact.join("\n")
-    end
-  end
-
-  def filter_active?(opts)
-    FILTER_PREDICATES.keys.any? { |f| opts.respond_to?(f) && opts.send(f) } ||
-      (opts.respond_to?(:tag) && Array(opts.tag).any?)
-  end
-
-  def apply_filters(prs, opts, forced: [])
-    active = FILTER_PREDICATES.keys.select { |f| opts.respond_to?(f) && opts.send(f) }
-    active = (active + forced).uniq
-
-    results = active.empty? ? prs : prs.select { |pr| active.any? { |f| FILTER_PREDICATES[f]&.call(pr) } }
-
-    # Tags are an AND post-filter; multiple tags are OR'd among themselves
-    tag_filter = Array(opts.respond_to?(:tag) ? opts.tag : nil).map(&:to_s).reject(&:empty?)
-    unless tag_filter.empty?
-      results = results.select { |pr| (Array(pr.tags) & tag_filter).any? }
-    end
-
-    results
-  end
-
-  def display_detailed(pr, idx = nil)
-    lines = []
-    num = idx ? "#{idx + 1}." : ""
-
-    state_str = case pr.state
-    when 'MERGED' then 'MERGED'
-    when 'CLOSED' then 'CLOSED'
-    else pr.draft? ? 'DRAFT' : 'OPEN'
-    end
-
-    repo = pr_repo(pr)
-    repo_label = (repo && repo != 'instacart/carrot') ? " [#{repo}]" : ""
-
-    lines << "#{num} ##{pr.number}#{repo_label} - #{pr.title}"
-    lines << "   State: #{state_str}"
-    lines << "   Branch: #{pr.head_branch}" if pr.head_branch
-    lines << "   URL: #{pr.url}" if pr.url
-
-    # Checks
-    if pr.checks
-      c = pr.checks
-      check_status = if c['failed'] > 0
-        "FAILING (#{c['success']}/#{c['total']} passed, #{c['failed']} failed)"
-      elsif c['pending'] > 0
-        "PENDING (#{c['success']}/#{c['total']} passed, #{c['pending']} pending)"
-      else
-        "PASSING (#{c['success']}/#{c['total']})"
-      end
-      lines << "   Checks: #{check_status}"
-    else
-      lines << "   Checks: (none)"
-    end
-
-    # Reviews
-    if pr.reviews
-      r = pr.reviews
-      review_parts = []
-      review_parts << "#{r['approved']} approved" if r['approved'] > 0
-      review_parts << "#{r['changes_requested']} requesting changes" if r['changes_requested'] > 0
-      review_parts << "#{r['commented']} commented" if r['commented'] > 0
-
-      if review_parts.any?
-        lines << "   Reviews: #{review_parts.join(', ')}"
-        if r['reviewers'] && !r['reviewers'].empty?
-          r['reviewers'].each do |author, state|
-            icon = case state
-            when 'APPROVED' then '+'
-            when 'CHANGES_REQUESTED' then '-'
-            else '?'
-            end
-            lines << "      #{icon} #{author}: #{state.downcase.gsub('_', ' ')}"
-          end
-        end
-      else
-        lines << "   Reviews: (none)"
-      end
-    else
-      lines << "   Reviews: (not fetched)"
-    end
-
-    lines << "   Mergeable: #{pr.mergeable}" if pr.mergeable
-
-    lines.join("\n")
-  end
-
-  def pr_yaml_lines(prs = nil)
-    (prs || load_pinned).map do |pr|
-      branch = pr.head_branch ? "[#{pr.head_branch}]" : "[##{pr.number}]"
-      "- #{pr.number}  # #{branch} #{pr.title}"
-    end
-  end
-
-  def strip_ansi(str)
-    str.gsub(/\e\[[0-9;]*m/, '')
-  end
-
-  def display_check_runs(pr, indent: "   ")
-    runs = pr.check_runs
-    return unless runs.is_a?(Array) && runs.any?
-
-    runs.each do |run|
-      case run['__typename']
-      when 'CheckRun'
-        emoji = check_run_emoji(run['conclusion'], run['status'])
-        name  = run['name'] || run['workflowName'] || '(unknown)'
-        url   = run['detailsUrl']
-      when 'StatusContext'
-        emoji = status_context_emoji(run['state'])
-        name  = run['context'] || '(unknown)'
-        url   = run['targetUrl']
-      else
-        emoji = '?'
-        name  = run['name'] || run['context'] || '(unknown)'
-        url   = run['detailsUrl'] || run['targetUrl']
-      end
-
-      line = "#{indent}#{emoji}  #{name}"
-      line += "\n#{indent}   #{url}" if url
-      puts line
-    end
-  end
-
-  private
-
-  def check_run_emoji(conclusion, status)
-    return "⏳" if %w[QUEUED IN_PROGRESS PENDING REQUESTED WAITING].include?(status) && conclusion.nil?
-    case conclusion
-    when 'SUCCESS'          then "✅"
-    when 'FAILURE', 'ERROR' then "❌"
-    when 'TIMED_OUT'        then "⏰"
-    when 'CANCELLED'        then "🚫"
-    when 'SKIPPED'          then "⏭ "
-    when 'NEUTRAL'          then "⚪"
-    when 'STARTUP_FAILURE'  then "💥"
-    when 'ACTION_REQUIRED'  then "⚠️ "
-    else                         "⏳"
-    end
-  end
-
-  def status_context_emoji(state)
-    case state
-    when 'SUCCESS'          then "✅"
-    when 'FAILURE', 'ERROR' then "❌"
-    when 'PENDING'          then "⏳"
-    else                         "❓"
-    end
-  end
-
-  public
-end
-
 FILTER_OPTS = Proc.new {
   flag(:red,       short: 'r', desc: 'filter: failing checks')
   flag(:green,     short: 'g', desc: 'filter: passing checks')
@@ -587,44 +20,8 @@ FILTER_OPTS = Proc.new {
 }
 
 Hiiro.run(*ARGV, plugins: [Pins]) do
-  pinned_manager = PinnedPRManager.new
-
-  add_resolver(:pr,
-    -> {
-      pinned = pinned_manager.load_pinned
-      if pinned.empty?
-        STDERR.puts "No tracked PRs. Use a PR number or 'h pr track' to track PRs."
-        nil
-      else
-        lines = pinned.each_with_index.each_with_object({}) do |(pr, idx), h|
-          h[pinned_manager.strip_ansi(pinned_manager.display_pinned(pr, idx, oneline: true))] = pr.number.to_s
-        end
-        fuzzyfind_from_map(lines)
-      end
-    }
-  ) do |ref|
-    if (pin_value = pins.get(ref.to_s))
-      pin_value
-    else
-      pinned = pinned_manager.load_pinned
-      if pinned.any? { |pr| pr.number.to_s == ref.to_s }
-        ref.to_s
-      elsif ref.to_s =~ /^\d+$/ && ref.to_i > 0
-        slot = ref.to_i
-        by_slot = pinned.find { |p| p.slot.to_i == slot }
-        if by_slot
-          by_slot.number.to_s
-        elsif slot - 1 < pinned.length
-          # Fall back to 1-based index for unslotted data
-          pinned[slot - 1].number.to_s
-        else
-          ref.to_s
-        end
-      else
-        ref.to_s
-      end
-    end
-  end
+  pinned_manager = Hiiro::PinnedPRManager.new
+  Hiiro::PinnedPRManager.add_resolvers(self)
 
   watch_block = ->(original_pr_number=nil, *watch_args) {
     watch = get_value(:watch)

data/bin/h-project

@@ -209,6 +209,35 @@ Hiiro.run(*ARGV) do
     HELP
   }
 
+  # === SHELL IN PROJECT ===
+  add_subcmd(:sh) { |project_name=nil, *args|
+    if project_name.nil? || project_name.empty?
+      puts "Usage: h project sh <project_name> [command...]"
+      next
+    end
+
+    re = /#{project_name}/i
+    conf_matches = (projects_from_config || {}).select { |k, v| k.match?(re) }
+    dir_matches  = (project_dirs || {}).select { |proj, path| proj.match?(re) }
+    matches = dir_matches.merge(conf_matches)
+    matches = matches.select { |name, path| name == project_name } if matches.count > 1
+
+    case matches.count
+    when 0
+      puts "Project '#{project_name}' not found"
+      puts
+      puts "Available projects:"
+      project_dirs.merge(projects_from_config).keys.sort.each { |k| puts "  #{k}" }
+    when 1
+      _, path = matches.first
+      Dir.chdir(path)
+      args.empty? ? exec(ENV['SHELL'] || 'zsh') : exec(*args)
+    else
+      puts "Ambiguous project '#{project_name}' — multiple matches:"
+      matches.each { |name, path| puts format("  %-15s %s", name, path) }
+    end
+  }
+
   add_default {
     run_subcmd(:help)
   }