hiiro 0.1.378 → 0.1.379

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc8c7a68d7b0fc2d7d6182b1d307978ba4ed185d4b6162800821ef12c8fa5d4e
-  data.tar.gz: 3708447b7e35a09e59deb4cc570a770619054c299852e3ead032f6240180cfcf
+  metadata.gz: 437599f5b96592172456a116919ccc4774cae2ecd248537f098f9c49f2e08446
+  data.tar.gz: 9a892f045ab4722668b7d89fc7412ec51c3fc954ffc4dd4c1d7f60c516cdaa1e
 SHA512:
-  metadata.gz: 0c4a5a117425f0b879607a1040d7a757b696b0b4773d8ff1cc4747a403123029217e3ec4744031ff45b14a3f5565727c8a3a2d40097a017cf8b6bcbd68b4c93f
-  data.tar.gz: 219ff3e0aa32313353c2aad202c745788d1a6327816a90b54e9b9adee90a975709c64a36ce40c7f5425510af1e979240eb213f496ddd81da151e39e4249ee550
+  metadata.gz: c55442904262705529cbc815ece19453841348d65a9c2de7601edd268b06d81cc9b8140823a4c2e55e7085169379d838543a54f11ff0f404973d4a7bf55d77c7
+  data.tar.gz: 0c6e2780c3500669cad8748280cd3da8ecf1d19a909ef547245467ef2a9feb03441d1430696732c926b27a4c86074db4c86190961eba652387f7c2edc44009ea

data/CHANGELOG.md

@@ -10,6 +10,9 @@
 - `t path`, `t cd`, `t start`, and `t switch` accept optional `APP` argument to select a configured relative directory beneath the task root
 - APP resolves by exact name or unique case-sensitive prefix; fails when ambiguous or missing
 
+### Added
+- `t switch` / `t workspace` and `t cd` accept an optional APP positional (or `--app`) resolving through the apps registry by exact name or unique prefix; the workspace or pane cd targets the app directory under the task worktree, e.g. `t switch aldi cpm` opens `~/work/aldi/main/retailer-tools/content-page-migrator`
+
 ## [0.1.376] - 2026-09-14
 
 ### Changed

data/README.md

@@ -92,8 +92,11 @@ prefix or a missing current task opens the fuzzy finder; non-interactive runs fa
 
 The current task is the calling Herdr workspace, then the current directory
 inside a task home, code directory, worktree, or registered directory, then the
-task saved with `t use TASK`. `t switch TASK` focuses or creates the task
-workspace and also saves it. `t current` only prints.
+task saved with `t use TASK`. `t switch TASK [APP]` focuses or creates the task
+workspace and also saves it; APP (exact name or unique prefix from the apps
+registry) opens the workspace in that app's directory under the task worktree.
+`t cd TASK [APP]` sends the same `cd` to the calling Herdr pane. `t current`
+only prints.
 
 ```sh
 t new investigation
@@ -105,7 +108,7 @@ t show investigation
 t todo rm 42                          # an ID printed by show or todo list
 t use investigation
 t switch investigation
-t switch investigation frontend          # app name or unique prefix
+t switch investigation frontend        # open in an app directory (unique prefix)
 t switch --show
 t next . "Write the handoff"
 t start investigation frontend            # tree new + app start directory

data/bin/hh

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'hiiro'
+
+Hiiro.run do
+  add_cmd(:ls) do
+    cmd = 'herdr', 'session', 'list', *opts.original_args
+    temp = Tempfile.new('asdf')
+    system(*cmd)
+  end
+
+  add_cmd(:switch, :start) do
+    cmd = 'herdr', 'session', 'list'
+    temp = Tempfile.new('asdf')
+    system(*cmd, out: temp.path)
+
+    lines = File.readlines(temp.path, chomp: true)
+
+    sessions = lines.filter_map.with_index{|x, i| next if i == 0; [x, x.split(/\s+/, 2).first] }.to_h
+
+    ses = 
+      if opts.args.empty?
+        fuzzyfind_from_map(sessions)
+      else
+        opts.args.first
+      end
+
+    use = sessions.values.find{|ss| ss.start_with?(ses) }
+
+    system('herdr', '--session', use)
+  end
+
+  add_cmd(:kill, :stop, :rm, :remove) do
+    tmp = Tempfile.new 'asdf'
+    result = system 'herdr', 'session' ,'stop', *opts.args, err: tmp.path
+
+    if result
+      result = system 'herdr', 'session' ,'delete', *opts.args 
+    else
+      reason = File.read tmp.path
+      if reason[/running/]
+        result = system 'herdr', 'session' ,'delete', *opts.args 
+      end
+    end
+  end
+
+  add_default do |*args|
+    system 'herdr', *args
+  end
+end

data/docs/t.md

@@ -95,7 +95,7 @@ t doc open [TASK] [NAME]
 | `t path [TASK] [APP]` | Start directory, optionally beneath the configured relative directory for APP |
 | `t branch [TASK]` | Worktree branch or `(detached)` |
 | `t sh [TASK] [CMD...]` | Changes to the start directory and execs a shell or CMD |
-| `t cd [TASK] [APP]` | Sends `cd` to the calling Herdr pane |
+| `t cd [TASK] [APP]` | Sends `cd` to the calling Herdr pane; APP narrows to a registry app directory under the task worktree |
 
 Worktree creation is `Hiiro::TaskManager#create_tree`, shared with the legacy `h task start` code path.
 
@@ -104,7 +104,7 @@ APP resolves against configured Hiiro apps by exact name or unique case-sensitiv
 ## Herdr workspaces, tabs, and panes
 
 ```text
-t switch [TASK] [APP] [--directory PATH] [--show]      alias: workspace
+t switch [TASK] [APP] [--directory PATH] [--show]   alias: workspace
 t tab ls [TASK]
 t tab new [TASK] [LABEL] [--directory PATH] [--command COMMAND]
 t tab open [TASK] [ID|LABEL]
@@ -117,6 +117,10 @@ t pane split [TASK] ID|LABEL [--direction right|down] [--directory PATH] [--comm
 
 These require a running Herdr server. The workspace label is the task session or name with `.` replaced by `_`. For a task, optional APP selects its configured relative directory when creating the workspace; when the workspace already exists, `switch` focuses it and sends `cd` to its focused pane. APP and `--directory` cannot be combined. `switch` also accepts the name of a live Herdr workspace that belongs to no task, exactly or by unique prefix, and focuses it; APP is invalid for loose workspaces and panes. A task with the same name wins. An exact pane ID such as `w6:p2` focuses that pane, and the picker lists every live pane with its directory and foreground command. When the name is ambiguous, or no task or context is given, a terminal gets a fuzzy finder over tasks and loose workspaces, with duplicate workspace names numbered in the label only. Commands that jump somewhere never assume the current task: `t switch`, `t tab open`, and `t pane open` with no task open the picker instead (or fail when stdin is not a terminal); use `.` explicitly for the current task.
 
+### App directories
+
+`t switch TASK APP` and `t cd TASK APP` accept APP as an exact name or unique prefix from the apps registry (`Hiiro::AppRecord`); `--app APP` is the flag form. The workspace opens (or the pane cds) into the app's directory under the task worktree, e.g. with `aldi` registered as `retailer-tools/content-page-migrator`, `t switch aldi cpm` opens `~/work/aldi/main/retailer-tools/content-page-migrator`. An ambiguous prefix is an error; APP only applies to task workspaces, not panes or loose workspaces.
+
 ## Native AI sessions
 
 `t omp [TASK] [ARGS...]`, `t codex` / `cdx`, and `t claude` / `cld` create a new focused tab in the task workspace, creating the workspace if needed, and run the native tool with ARGS forwarded verbatim. A leading argument that is a prefix of `resume` turns into the tool's native resume flag; bare `resume` with exactly one running pane of that tool focuses it instead.

data/lib/hiiro/task_cli.rb

@@ -63,6 +63,18 @@ class Hiiro
         lookup_task(reference) || raise(Error, "Task not found: #{reference}; run t new #{reference}")
       end
 
+      # [name, relative_path] from the apps registry: exact name wins, else a
+      # unique prefix; ambiguity and no-match are errors.
+      def lookup_app!(reference)
+        apps = Hiiro::AppRecord.all_as_hash
+        raise Error, 'No apps are configured' if apps.empty?
+        return [reference, apps[reference]] if apps[reference]
+        found = Hiiro::Matcher.by_prefix(apps.keys.sort, reference).matches.map(&:item)
+        raise Error, "No app matches #{reference}" if found.empty?
+        raise Error, "Ambiguous app #{reference}: #{found.join(', ')}" unless found.one?
+        [found.first, apps[found.first]]
+      end
+
       # Current task from Herdr, directory, or the saved pin. With no context at all,
       # a TTY gets the fuzzy finder over every task; ambiguous or stale context still fails.
       def current_task
@@ -469,6 +481,26 @@ class Hiiro
           herdr
         end
       end
+      # App reference (positional or --app) resolves through the apps registry
+      # under the task worktree; explicit param wins over the option.
+      def start_directory(task, app: nil)
+        app = opts&.fetch(:app) if app.nil?
+        path = opts&.fetch(:directory) || (app && app_directory(task, app)) || code_directory(task) || ensure_home(task)
+        existing_path(path, directory: true)
+      end
+
+      # Registry app directory under the task worktree.
+      def app_directory(task, reference)
+        _name, relative = lookup_app!(reference)
+        root = code_directory(task)
+        raise Error, "#{task.name} has no worktree; run t tree new #{task.name} first" unless root
+        File.join(root, relative)
+      end
+
+      def open_workspace(task, save:, app: nil)
+        open_task_workspace(task, start_directory(task, app: app))
+        save_current(task) if save
+      end
 
       def workspace_for(task, required: true)
         label = workspace_label(task)
@@ -480,29 +512,6 @@ class Hiiro
         matches.first
       end
 
-      def app_directory(path, app_name)
-        return path unless app_name
-        result = Hiiro::Matcher.new(Hiiro::AppRecord.all, :name).by_prefix(app_name)
-        app = result.resolved&.item
-        if !app && result.ambiguous?
-          raise Error, "Ambiguous app #{app_name}: #{result.matches.map { |match| match.item.name }.join(', ')}"
-        end
-        raise Error, "App not found: #{app_name}" unless app
-        File.join(path, app.path)
-      end
-
-      def start_directory(task, app_name = nil)
-        path = opts&.fetch(:directory)
-        raise Error, 'Use an app or --directory, not both' if path && app_name
-        path ||= code_directory(task) || ensure_home(task)
-        existing_path(app_directory(path, app_name), directory: true)
-      end
-
-      def open_workspace(task, save:, app_name: nil)
-        open_task_workspace(task, start_directory(task, app_name), chdir: !app_name.nil?)
-        save_current(task) if save
-      end
-
       # Focus the task workspace or create it at directory. With optional: true,
       # a stopped Herdr prints a hint instead of failing (used after worktree changes).
       def open_task_workspace(task, directory, optional: false, chdir: false)
@@ -556,51 +565,47 @@ class Hiiro
         puts pane_line(pane)
       end
 
-      # [target, explicit, app_name]. A task wins over a workspace with the same name.
+      # [target, explicit, rest]. A task wins over a workspace with the same name.
+      # The first positional names the target; any remaining positional is the app.
       def switch_target(args)
         args = args.dup
-        return [lookup_task!(opts.task), true, single(args, optional: true)] if opts.task
-        return [pick_switch_target(Hiiro::TaskRecord.all_as_list, loose_workspaces), true, single(args, optional: true)] if opts.find
-        first = args.first
+        first = args.shift
+        rest = args
+        if opts.task || opts.find
+          # Flag forces the target, so the first positional is the app.
+          app = [first].compact
+          no_args!(rest)
+          return [lookup_task!(opts.task), true, app] if opts.task
+          return [pick_switch_target(Hiiro::TaskRecord.all_as_list, loose_workspaces), true, app] if opts.find
+        end
+        no_args!(rest.drop(1))
         if first && first != '.' && !first.start_with?('-')
-          args.shift
-          app_name = single(args, optional: true)
           tasks = Hiiro::TaskRecord.all_as_list
           workspaces = loose_workspaces
           exact = tasks.find { |task| task.name == first }
-          return [exact, true, app_name] if exact
+          return [exact, true, rest] if exact
           pane = live_panes.values.flatten.find { |candidate| candidate.id == first }
-          raise Error, 'An app applies only to task workspaces' if pane && app_name
-          return [pane, false, nil] if pane
+          return [pane, false, rest] if pane
           exact_ws = workspaces.select { |workspace| workspace.name == first }
-          if exact_ws.one?
-            raise Error, 'An app applies only to task workspaces' if app_name
-            return [exact_ws.first, false, nil]
-          end
+          return [exact_ws.first, false, rest] if exact_ws.one?
           task_matches = tasks.select { |task| task.name.start_with?(first) }
           ws_matches = exact_ws.any? ? exact_ws : workspaces.select { |workspace| workspace.name.start_with?(first) }
-          return [task_matches.first, true, app_name] if task_matches.one? && ws_matches.empty?
-          if ws_matches.one? && task_matches.empty?
-            raise Error, 'An app applies only to task workspaces' if app_name
-            return [ws_matches.first, false, nil]
-          end
+          return [task_matches.first, true, rest] if task_matches.one? && ws_matches.empty?
+          return [ws_matches.first, false, rest] if ws_matches.one? && task_matches.empty?
           raise Error, "No task or workspace matches #{first}" if task_matches.empty? && ws_matches.empty?
           names = (task_matches.map(&:name) + ws_matches.map { |w| "#{w.name} (workspace)" }).join(', ')
           raise Error, "Ambiguous #{first}: #{names}" unless $stdin.tty?
           target = pick_switch_target(task_matches, ws_matches, panes: [])
-          raise Error, 'An app applies only to task workspaces' if app_name && !target.is_a?(Hiiro::TaskRecord)
-          return [target, target.is_a?(Hiiro::TaskRecord), app_name]
+          return [target, target.is_a?(Hiiro::TaskRecord), rest]
         end
+        no_args!(rest)
         if first == '.'
-          args.shift
-          app_name = single(args, optional: true)
-          return [Hiiro::CurrentTask.new(herdr: -> { herdr_client }, pin: true).resolve!, false, app_name]
+          return [Hiiro::CurrentTask.new(herdr: -> { herdr_client }, pin: true).resolve!, false, rest]
         end
-        no_args!(args)
         # Jumping somewhere never assumes the current task: pick a destination.
         raise Error, 'Name a task, workspace, or pane to switch to, or use . for the current task' unless $stdin.tty?
         target = pick_switch_target(Hiiro::TaskRecord.all_as_list, loose_workspaces)
-        [target, target.is_a?(Hiiro::TaskRecord), nil]
+        [target, target.is_a?(Hiiro::TaskRecord), rest]
       end
 
       def require_picker!(what)
@@ -707,10 +712,10 @@ class Hiiro
         command.empty? ? exec(ENV['SHELL'] || 'zsh') : exec(*command)
       end
 
-      def cd_to(task, app_name = nil)
+      def cd_to(task, app: nil)
         pane = ENV['HERDR_PANE_ID']
         raise Error, 'Not running inside a Herdr pane' unless pane
-        check_result(client.run_in_pane(pane, "cd #{start_directory(task, app_name).shellescape}"))
+        check_result(client.run_in_pane(pane, "cd #{start_directory(task, app: app).shellescape}"))
       end
 
       def show_workspace(task)
@@ -850,45 +855,36 @@ class Hiiro
           end
         end
 
-        add_cmd(:path, args: ['task?', 'app?'], opts: TASK_OPTIONS) do
-          task, rest = take_task(opts.args)
-          puts start_directory(task, single(rest, optional: true))
-        end
-        add_cmd(:branch, args: ['task?'], opts: TASK_OPTIONS) { puts current_branch(take_task_only(opts.args)) }
-        add_cmd(:cd, args: ['task?', 'app?'], opts: TASK_OPTIONS) do
-          task, rest = take_task(opts.args)
-          cd_to(task, single(rest, optional: true))
-        end
-        add_cmd(:sh, args: ['task?', 'command...'], passthrough: true) do
-          task, rest = take_task(args, options: nil)
-          run_shell(task, rest)
-        end
-
         add_option :directory, desc: 'Existing start directory'
-        add_option :app, desc: 'App directory to open in the workspace'
-        add_option :sparse, short: :s, desc: 'Sparse checkout group (repeatable)', multi: true
-        add_cmd(:start, args: %i[name app?], opts: [*TASK_OPTIONS, :app, :sparse]) do
-          if opts.task
-            new_tree([lookup_task!(opts.task).name, *opts.args], opts.app, opts.sparse)
-          elsif opts.find
-            new_tree([pick_task(Hiiro::TaskRecord.all_as_list).name, *opts.args], opts.app, opts.sparse)
-          else
-            new_tree(opts.args, opts.app, opts.sparse)
-          end
-        end
-        add_cmd(:switch, :workspace, args: ['task-or-workspace?', 'app?'], opts: [*TASK_OPTIONS, :directory, :show]) do
-          target, explicit, app_name = switch_target(opts.args)
+        add_option :app, desc: 'Registry app directory under the task worktree'
+        add_cmd(:switch, :workspace, args: ['task-or-workspace?', 'app?'], opts: [*TASK_OPTIONS, :directory, :app, :show]) do
+          target, explicit, rest = switch_target(opts.args)
+          app = opts.app || rest.first
           if target.is_a?(Hiiro::Herdr::Pane)
             raise Error, '--show applies to task workspaces' if opts.show
+            raise Error, 'An APP only applies to task workspaces' if app
             focus_pane_target(target)
           elsif target.is_a?(Hiiro::Herdr::Workspace)
             raise Error, '--show applies to task workspaces' if opts.show
+            raise Error, 'An APP only applies to task workspaces' if app
             check_result(client.focus_workspace(target.id))
             puts target
           else
-            opts.show ? show_workspace(target) : open_workspace(target, save: explicit, app_name: app_name)
+            opts.show ? show_workspace(target) : open_workspace(target, save: explicit, app: app)
           end
         end
+        add_cmd(:path, args: ['task?'], opts: TASK_OPTIONS) { puts start_directory(take_task_only(opts.args)) }
+        add_cmd(:branch, args: ['task?'], opts: TASK_OPTIONS) { puts current_branch(take_task_only(opts.args)) }
+        add_cmd(:cd, args: ['task?', 'app?'], opts: TASK_OPTIONS) do
+          task, rest = take_task(opts.args)
+          no_args!(rest.drop(1))
+          cd_to(task, app: rest.first)
+        end
+
+        add_cmd(:sh, args: ['task?', 'command...'], passthrough: true) do
+          task, rest = take_task(args, options: nil)
+          run_shell(task, rest)
+        end
 
         [%w[omp], %w[codex cdx], %w[claude cld]].each do |names|
           add_cmd(*names, args: ['task?', 'cli-args...'], passthrough: true) do

data/lib/hiiro/version.rb

@@ -1,4 +1,4 @@
 class Hiiro
-  VERSION = "0.1.378"
+  VERSION = "0.1.379"
   SUPPORTED_RUBY_VERSION = ">= 3.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.378
+  version: 0.1.379
 platform: ruby
 authors:
 - Joshua Toyota
@@ -219,6 +219,7 @@ files:
 - bin/h-wtree
 - bin/h-xxserve
 - bin/h-zosubtask
+- bin/hh
 - bin/t
 - bin/tt
 - demo.sh