lux-hammer 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 851bca602512cce6e27c0b2ddba4b9282d0aab24fa86f24de0ec04aabc98a034
-  data.tar.gz: 4176bbdc0763fea935d6f8758128c61f09262f029a36e161bd4f9d3cdbe523f4
+  metadata.gz: 7e19b144891467fd0209c27265352a153f340820d14384d8deacb46e8ef58532
+  data.tar.gz: 279c7ac83d6f597d28e42b799e5cfdc917b0ce10f88d2950d9f0fe562ed674de
 SHA512:
-  metadata.gz: ae6d18d7c53d52c04cd783a745b420caa420dd6e440cd512afc6d80b5c9ec05ef806732c58aa7467266bf3f4bceb0f0b72cbd7f80b6cee5bf61e0c4e7b78aafb
-  data.tar.gz: c02de0cdb479bf2a8d88ceb6d7306835426719ed735a2beb7e3c6b3fd881dda97f7d2d9dbc9d64e7c8fe2fb794cf91cdc6f6f844570d9ff8d99859dd0538a963
+  metadata.gz: e9baea7eb17ad8b98ec3f7778431c603a03283e029a95e9140f83026aa88f587e01a4e87bf7dc09b6538a95f463f067293daf147df02e3454f161d737c9e6bad
+  data.tar.gz: 4b41c8875111734dfbe6402b97eaa03be209081f3086096cde94343eacbb1c5fd18d2933575ad1818ca08e6ffae363fd695cb107d5ddb7068610580bd04b7289

data/.version

@@ -1 +1 @@
-0.3.5
+0.3.7

data/AGENTS.md

@@ -45,7 +45,7 @@ lib/hammer/loader.rb        # `*_hammer.rb` fragment loader (auto/glob/file)
 lib/hammer/builder.rb       # Block-DSL context (Hammerfile / Hammer.run)
 lib/hammer/command_builder.rb # `task :name do ... end` context
 lib/hammer/recipe.rb        # Recipe discovery (gem + user dir, desc, stub)
-lib/hammer/builtins.rb      # Lazy-loaded `self:` namespace (recipe, ai, update)
+lib/hammer/builtins.rb      # Built-in tasks (recipes, update, agents, version, init, ...)
 recipes/                    # Bundled recipes (each `<name>.rb` -> a bin via stub)
 test/dsl_test.rb            # DSL surface, dispatch, help formatting
 test/load_test.rb           # `load` / `*_hammer.rb` fragment loader
@@ -143,11 +143,20 @@ Runtime cross-invocation:
   (`bin/hammer`).
 * `Hammer.cli(argv = ARGV)` - internal entry for `bin/hammer` only:
   walks up from `Dir.pwd` for a `Hammerfile`, chdirs into its dir,
-  errors if none found anywhere up the tree. Also lazy-registers the
-  `self:` namespace when argv shows the user wants help or a
-  `self:`-prefixed command. Not part of the user-facing surface -
-  don't recommend it in examples; `Hammer.run` is what library users
-  should reach for.
+  errors if none found anywhere up the tree (unless the invocation
+  routes to a built-in - see `dispatches_to_builtin?` /
+  `looks_like_builtin?`, true for bare invocation / leading flag /
+  explicit help / a built-in task name). After evaluating the
+  Hammerfile, registers the always-on core built-ins (`:default`,
+  `:help`, `:update`, `:agents`, `:version`) via
+  `Hammer::Builtins.register_core` - each guarded by
+  `unless commands.key?(...)` so a user-defined task wins silently.
+  No-project-only built-ins (`:recipes`, `:init`) are NOT registered
+  when a Hammerfile loaded - reach them with `--system`. The
+  `--system` flag is peeled off argv at the top and forces the
+  no-Hammerfile branch. Not part of the user-facing surface - don't
+  recommend it in examples; `Hammer.run` is what library users should
+  reach for.
 * `Hammer.recipe(name, argv = ARGV)` - entry for recipe stubs in PATH.
   Loads `<gem>/recipes/<name>.rb` (or its user-dir override), runs as
   a standalone CLI with `program_name = name`. No Hammerfile lookup,
@@ -186,7 +195,9 @@ explicit ADR-level discussion. Keys:
   actually picked when fuzzy matching kicks in. Only options that
   differ from their default are listed; booleans render as `--flag`
   / `--no-flag`. Help paths (`-h`, bare namespace) short-circuit
-  before the banner.
+  before the banner. Set `HAMMER_QUIET=1` to suppress the banner
+  globally - useful when a task writes machine-readable output to
+  stdout (e.g. a JSON-emitting Claude Code / Codex hook).
 * There is **no per-level dispatch**. A namespace is a container, not a
   CLI of its own. Do not reintroduce `subclass.start(remaining_argv)`.
 * `start(argv)` is a two-step pipeline: `split_chain(argv)` (private)
@@ -206,11 +217,57 @@ explicit ADR-level discussion. Keys:
   is the whole API. `Hammer.cli` warms the cache before chdir-ing into
   the Hammerfile's directory so the resolved name stays relative to the
   cwd the user invoked from.
-* `hammer` (no args) prints just the command listing (with a top gray
-  `lux-hammer VERSION - <homepage>` banner for the hammer binary).
-* `hammer -h` / `hammer --help` adds global flags, a small Hammerfile
-  example, and the footer link on top of the same listing.
+* `hammer` (no args) routes to the `:default` built-in task, which
+  falls through to `print_help(extended: false)` - the brief command
+  listing with a top gray `lux-hammer VERSION - <homepage>` banner.
+* `hammer -h` / `--help` / `help [TARGET]` routes to the `:help`
+  built-in task, which calls `print_help(target, extended: true)` -
+  adds global flags (rendered from `:default`'s declared opts),
+  `Recipes:` section (hammer binary only), a small Hammerfile example,
+  and the footer link.
 * `hammer COMMAND -h` / `--help` prints per-command help (reserved on every command).
+
+## Built-in tasks (user-overridable)
+
+`Hammer::Builtins` defines two registration entry points; both register
+**after** Hammerfile evaluation and skip each task when the user
+already defined it (`unless klass.commands.key?(name)` - no
+redefinition warning).
+
+* `register_core(klass)` - always called. Registers `:default`,
+  `:help`, `:update`, `:agents`, `:version`. These coexist with
+  Hammerfile tasks.
+* `register_no_project(klass)` - called only on the no-Hammerfile
+  branch of `Hammer.cli` (which `--system` also routes through).
+  Registers `:recipes` and `:init` - tasks that would collide too
+  easily with user tasks inside a project.
+
+No reserved namespace. Names like `:self`, `:recipes`, `:update` can
+all be defined freely in a Hammerfile; the built-ins yield.
+
+Task contracts:
+
+* `:default` - hidden (no desc). Just prints `self.class.root.print_help`
+  (brief). Fires for bare `hammer` and leading-flag invocations where
+  the first token starts with `-` and isn't `-h` / `--help` (see
+  `Hammer.dispatch`). User overrides typically declare flag opts and
+  fall through to `hammer :help` when none matched.
+* `:help` - has a desc, shows in listings. Calls
+  `self.class.root.print_help(opts[:args].first, extended: true)`.
+  Fires for `help` / `-h` / `--help` at the top level.
+* `:update` / `:agents` / `:version` - thin wrappers around
+  `Hammer.self_update` / `Hammer.print_ai_help` / `puts Hammer::VERSION`.
+* `:recipes` - all recipe-management actions on one task, picked via
+  boolean opts: `--install [NAME [TARGET]]`, `--show NAME`,
+  `--path NAME`, `--edit NAME`, `--run NAME [ARGS]` (use `--` to
+  forward flags through). Bare invocation lists.
+* `:init` - writes `Hammer::STARTER_HAMMERFILE` to `./Hammerfile`;
+  refuses if one exists.
+
+Both `:default` and `:help` are invoked via `run_command(cmd, argv,
+full: name, quiet: true)` - the gray `> prog cmd ...` banner is
+suppressed because the user didn't type `hammer default` /
+`hammer help` literally.
 * Commands listed flat with colon paths, grouped by top-level namespace.
 * Bare namespace (`hammer db`) prints the same listing scoped to that
   namespace.

data/README.md

@@ -73,7 +73,7 @@ Clones into `~/.local/share/lux-hammer` (override with `LUX_HAMMER_DIR=`),
 builds the gem, and installs it. Re-run any time, or use:
 
 ```sh
-hammer --update   # git pull main + rebuild + reinstall
+hammer update   # git pull main + rebuild + reinstall
 ```
 
 ## Quick start
@@ -483,10 +483,6 @@ hammer :                  # trailing colon at root: full help for every command
 Namespaces nest to any depth. There is no per-level dispatch - the root
 parses the whole colon path and walks the namespace tree.
 
-The `self:` namespace is reserved for hammer's own built-in commands
-(see [Recipes](#recipes-shareable-mini-clis-shipped-with-hammer)
-below). Defining `namespace :self` in a Hammerfile raises an error.
-
 ## Pre-hooks (`before`)
 
 A `before do ... end` block at the root scope or inside a `namespace`
@@ -541,6 +537,78 @@ end
 `hammer` and `hammer db` won't list `env`, but `hammer env`,
 `hammer :env` from another proc, and `before { hammer :env }` all work.
 
+## Built-in tasks (all overridable)
+
+The `hammer` binary auto-registers a small set of built-in tasks at
+the root of your CLI. Each one is guarded by `unless commands.key?` -
+defining your own `task :name` in a Hammerfile silently replaces the
+built-in.
+
+Always available (with or without a Hammerfile):
+
+* `:default` - fires on bare `hammer` and on leading-flag invocations.
+  Hidden from listings. Just prints the brief help by default; override
+  to wire up your own global flags.
+* `:help` - `hammer help [TARGET]`, `hammer -h`, `hammer --help`. Prints
+  the extended help view; `TARGET` accepts a command path or a `ns:`
+  prefix.
+* `:update` - rebuild + reinstall lux-hammer from main.
+* `:agents` - dump AGENTS.md (AI-friendly Hammerfile authoring docs).
+* `:version` - print the lux-hammer version.
+
+Only when no Hammerfile is loaded (or `--system` is passed - see below):
+
+* `:recipes` - list / install / show / edit recipes.
+* `:init` - write a starter Hammerfile in cwd (refuses if one exists).
+
+These two are skipped inside a project so they don't shadow user tasks.
+To reach them from inside a project, pass `--system`:
+
+```sh
+hammer --system recipes              # list recipes from anywhere
+hammer --system recipes --install srt ~/bin/srt
+```
+
+`--system` forces the no-Hammerfile branch - the Hammerfile in the
+current tree (if any) isn't loaded for that invocation.
+
+Customize bare `hammer` by replacing `:default`:
+
+```ruby
+# Hammerfile
+
+task :default do
+  opt :version, type: :boolean, alias: :v
+  opt :status,  type: :boolean, alias: :s
+
+  proc do |opts|
+    if opts[:version]
+      say "myapp #{MyApp::VERSION}"
+    elsif opts[:status]
+      sh 'bin/myapp status'
+    else
+      hammer :help                # fall through to help
+    end
+  end
+end
+```
+
+Or replace `:help` to add a banner:
+
+```ruby
+task :help do
+  desc 'Show help (with a banner)'
+  proc do |opts|
+    say.cyan "MyApp #{MyApp::VERSION} - https://internal/docs"
+    say ''
+    self.class.root.print_help(opts[:args].first, extended: true)
+  end
+end
+```
+
+`-h` / `--help` stay reserved on every command - you can't shadow them
+with an `opt`.
+
 ## Prereqs (`needs`)
 
 Declare commands that must run before this one (Rake-style task deps):
@@ -1003,19 +1071,29 @@ A **recipe** is a standalone Hammerfile-style script bundled inside the
 top-level binary in your `PATH` - so `srt` becomes a real command, not
 `hammer srt:shift`.
 
+Recipe management lives under the `recipes` task. From inside a
+project the task isn't registered (so it can't shadow user tasks);
+pass `--system` to reach it from anywhere.
+
 Listing what's available:
 
 ```sh
-$ hammer self:recipe
+$ hammer recipes                    # from any non-project dir
+$ hammer --system recipes           # from inside a project
 gem:
   srt  # Subtitle (.srt) toolkit - shift timestamps, show stats
-         [install: hammer self:recipe install srt]
+         [install: hammer recipes --install srt]
+  llm  # personal LLM utility CLI (memory store, prompt-token expander, ...)
+         [install: hammer recipes --install llm]
 ```
 
-Installing one (you control the path; nothing is written for you):
+Installing one. With no TARGET, the stub is printed to stdout (you
+redirect it yourself); with a TARGET path, lux-hammer writes the file
+and chmods +x in one step:
 
 ```sh
-$ hammer self:recipe install srt > ~/bin/srt && chmod +x ~/bin/srt
+$ hammer recipes --install srt ~/bin/srt    # write + chmod
+$ hammer recipes --install srt > ~/bin/srt && chmod +x ~/bin/srt
 $ srt --help
 Usage: srt COMMAND [ARGS]
 
@@ -1032,8 +1110,8 @@ so the recipe always runs the version currently in the gem.
 ### Authoring your own
 
 Drop a plain `.rb` file in `~/.config/hammer/recipes/`. The first
-`# desc: ...` comment is what shows in `hammer self:recipe`. The file
-body uses the same DSL as a Hammerfile - `task`, `namespace`, `before`,
+`# desc: ...` comment is what shows in `hammer recipes`. The file body
+uses the same DSL as a Hammerfile - `task`, `namespace`, `before`,
 `load`. Example `~/.config/hammer/recipes/json.rb`:
 
 ```ruby
@@ -1052,20 +1130,22 @@ end
 Install it the same way:
 
 ```sh
-$ hammer self:recipe install json > ~/bin/json && chmod +x ~/bin/json
+$ hammer recipes --install json ~/bin/json
 ```
 
 User-dir recipes override gem recipes with the same name, so you can
 fork without forking.
 
-### Other `self:recipe` actions
+### Other `recipes` actions
 
 ```sh
-hammer self:recipe              # list all
-hammer self:recipe install      # interactive picker, then prints stub
-hammer self:recipe show <NAME>  # cat the recipe source
-hammer self:recipe path <NAME>  # absolute path
-hammer self:recipe edit <NAME>  # open in $EDITOR (copies gem -> user dir first)
+hammer recipes                            # list all
+hammer recipes --install                  # interactive picker, then prints stub
+hammer recipes --show NAME                # cat the recipe source
+hammer recipes --path NAME                # absolute path
+hammer recipes --edit NAME                # open in $EDITOR (copies gem -> user dir first)
+hammer recipes --run  NAME [ARGS]         # run without installing its bin
+hammer recipes --run  NAME -- --help      # `--` forwards flags to the recipe
 ```
 
 ## Programmatic use

data/lib/hammer/builtins.rb

@@ -1,78 +1,166 @@
 class Hammer
-  # Lazy-loaded "built-ins" attached under the reserved `self:` namespace
-  # of the `hammer` binary. Hosts management commands (recipes, AGENTS.md
-  # dump, self-update) that should not appear on every user-command run.
-  # `Hammer.cli` only calls `register` when argv shows the user is
-  # asking for help or invoking a `self:`-prefixed command.
+  # Built-in tasks of the `hammer` binary - all live at the root level
+  # (no reserved namespace). Two registration entry points:
+  #
+  # * register_core - tasks always available (subject to user override
+  #   via the `unless commands.key?(...)` guard): :default, :help,
+  #   :update, :agents, :version. These coexist with Hammerfile tasks.
+  #
+  # * register_no_project - tasks meaningful only when no Hammerfile is
+  #   loaded (or `--system` was passed): :recipes, :init. These would
+  #   collide too easily with user tasks if always registered, so the
+  #   Hammerfile branch skips them.
   module Builtins
     module_function
 
-    # Wire the `self:` namespace into `klass`. Idempotent - safe to call
-    # twice; the second call replaces the existing subclass.
-    def register(klass)
-      Thread.current[:hammer_builtins_loading] = true
-      klass.namespace(:self) do
-        task :ai do
-          desc 'Print AGENTS.md (AI-friendly Hammerfile authoring docs)'
-          proc { Hammer.print_ai_help }
+    def register_core(klass)
+      register_help(klass)    unless klass.commands.key?('help')
+      register_default(klass) unless klass.commands.key?('default')
+      register_update(klass)  unless klass.commands.key?('update')
+      register_agents(klass)  unless klass.commands.key?('agents')
+      register_version(klass) unless klass.commands.key?('version')
+    end
+
+    def register_no_project(klass)
+      register_recipes(klass) unless klass.commands.key?('recipes')
+      register_init(klass)    unless klass.commands.key?('init')
+    end
+
+    def register_help(klass)
+      klass.class_eval do
+        task :help do
+          desc <<~TXT
+            Show help. Optional TARGET = command name or namespace (`ns:`).
+
+            Without TARGET prints the extended top-level help (commands,
+            recipes, global flags, examples). With a command path prints
+            per-command help; with a namespace prefix prints that
+            namespace's command listing.
+          TXT
+          example 'help'
+          example 'help build'
+          example 'help db:'
+          proc do |opts|
+            self.class.root.print_help(opts[:args].first, extended: true)
+          end
         end
+      end
+    end
+
+    # `:default` fires on bare `hammer` and on leading-flag invocations
+    # (other than -h/--help). Hidden from listings (no desc). All it
+    # does now is print help - the old flag opts (--update, --ai, ...)
+    # moved to dedicated tasks (:update, :agents, ...).
+    def register_default(klass)
+      klass.class_eval do
+        task :default do
+          proc { self.class.root.print_help }
+        end
+      end
+    end
 
+    def register_update(klass)
+      klass.class_eval do
         task :update do
-          desc 'Update lux-hammer from github main (requires install.sh checkout)'
+          desc 'Rebuild + reinstall lux-hammer from main'
           proc { Hammer.self_update }
         end
+      end
+    end
 
-        task :recipe do
+    def register_agents(klass)
+      klass.class_eval do
+        task :agents do
+          desc 'Print AGENTS.md (Hammerfile authoring docs for AI assistants)'
+          proc { Hammer.print_ai_help }
+        end
+      end
+    end
+
+    def register_version(klass)
+      klass.class_eval do
+        task :version do
+          desc 'Print lux-hammer version'
+          proc { puts Hammer::VERSION }
+        end
+      end
+    end
+
+    def register_init(klass)
+      klass.class_eval do
+        task :init do
+          desc 'Write a starter Hammerfile in the current directory'
+          proc { Hammer::Builtins.write_starter_hammerfile }
+        end
+      end
+    end
+
+    # `:recipes` rolls all recipe-management actions into one task. Bare
+    # invocation lists; opts pick the action and positional args carry
+    # the recipe name (and optional target path for --install). Run via
+    # `--run NAME [ARGS]` - use `--` to forward flags to the recipe
+    # itself (e.g. `hammer recipes --run srt -- --help`).
+    def register_recipes(klass)
+      klass.class_eval do
+        task :recipes do
           desc <<~TXT
-            Manage recipes. First positional argument is the action.
-
-              (no args)              list all recipes
-              install [NAME] [PATH]  install stub. No PATH: print to stdout. With PATH: write + chmod +x.
-              show    NAME           cat recipe source
-              path    NAME           print recipe abs path
-              edit    NAME           open recipe in $EDITOR
-              run     NAME [ARGS]    run a recipe without installing its bin
+            Manage recipes - the standalone Hammerfile-style scripts
+            bundled with the gem (and under ~/.config/hammer/recipes).
+            Bare invocation lists; flags pick the action.
           TXT
-          example 'self:recipe'
-          example 'self:recipe install srt ~/bin/srt        # write + chmod in one shot'
-          example 'self:recipe install srt > ~/bin/srt && chmod +x $_'
-          example 'self:recipe show srt'
-          example 'self:recipe run srt extract movie.mp4'
-          example 'self:recipe run srt -- --help            # -- forwards flags to the recipe'
+          opt :install, type: :boolean, desc: 'install recipe stub (picker if no NAME). With TARGET path: write + chmod.'
+          opt :show,    type: :boolean, desc: 'cat recipe source'
+          opt :path,    type: :boolean, desc: 'print recipe abs path'
+          opt :edit,    type: :boolean, desc: 'open recipe in $EDITOR (copies gem -> user dir first)'
+          opt :run,     type: :boolean, desc: 'run a recipe without installing its bin (forwards remaining args)'
+          example 'recipes'
+          example 'recipes --install srt ~/bin/srt    # write + chmod in one shot'
+          example 'recipes --install srt > ~/bin/srt && chmod +x $_'
+          example 'recipes --show srt'
+          example 'recipes --run srt extract movie.mp4'
+          example 'recipes --run srt -- --help        # -- forwards flags to the recipe'
           proc do |opts|
-            action, name, *rest = opts[:args]
-            Hammer::Builtins::Recipes.dispatch(action, name, rest)
+            args = opts[:args]
+            if opts[:install]
+              Hammer::Builtins::RecipesActions.install(args[0], args[1])
+            elsif opts[:show]
+              Hammer::Builtins::RecipesActions.show(Hammer::Builtins::RecipesActions.require_name!(args[0], 'show'))
+            elsif opts[:path]
+              Hammer::Builtins::RecipesActions.path(Hammer::Builtins::RecipesActions.require_name!(args[0], 'path'))
+            elsif opts[:edit]
+              Hammer::Builtins::RecipesActions.edit(Hammer::Builtins::RecipesActions.require_name!(args[0], 'edit'))
+            elsif opts[:run]
+              name = Hammer::Builtins::RecipesActions.require_name!(args[0], 'run')
+              Hammer.recipe(name, args[1..])
+            else
+              Hammer::Builtins::RecipesActions.list
+            end
           end
         end
       end
-    ensure
-      Thread.current[:hammer_builtins_loading] = nil
     end
 
-    # Implementations of the `self:recipe <action>` sub-commands, plus
-    # the no-action listing view. Kept in its own module so the
-    # namespace definition above stays small and skimmable.
-    module Recipes
-      module_function
-
-      def dispatch(action, name, rest = [])
-        case action
-        when nil       then list
-        when 'install' then install(name, rest.first)
-        when 'show'    then show(require_name!(name, 'show'))
-        when 'path'    then path(require_name!(name, 'path'))
-        when 'edit'    then edit(require_name!(name, 'edit'))
-        when 'run'     then Hammer.recipe(require_name!(name, 'run'), rest)
-        else
-          Shell.print_error "unknown action: #{action}"
-          Shell.say 'valid: install, show, path, edit, run (or omit for list)', :yellow
-          exit 1
-        end
+    # Writes ./Hammerfile with the canonical starter template. Refuses
+    # if one already exists - `init` must not clobber.
+    def write_starter_hammerfile
+      target = File.join(Dir.pwd, 'Hammerfile')
+      if File.exist?(target)
+        Shell.print_error "Hammerfile already exists at #{target}"
+        exit 1
       end
+      File.write(target, Hammer::STARTER_HAMMERFILE)
+      Shell.say "created #{target}", :green
+    end
+
+    # Implementations of the `recipes` task's action flags, plus the
+    # no-flag listing view. Separate module so the task definition above
+    # stays small.
+    module RecipesActions
+      module_function
 
       def require_name!(name, action)
         return name if name
-        Shell.print_error "missing recipe name (usage: self:recipe #{action} NAME)"
+        Shell.print_error "missing recipe name (usage: recipes --#{action} NAME)"
         exit 1
       end
 
@@ -94,7 +182,7 @@ class Hammer
           Shell.say "#{source}:", :yellow
           items.each_key do |name|
             _n, desc, installed = rows.find { |r| r.first == name }
-            status = installed ? "(installed: #{installed})" : "[install: hammer self:recipe install #{name}]"
+            status = installed ? "(installed: #{installed})" : "[install: hammer recipes --install #{name}]"
             line = "  #{name.ljust(width)}  # #{desc}"
             Shell.say line
             Shell.say "  #{' ' * width}    #{status}", :gray
@@ -144,7 +232,7 @@ class Hammer
       end
 
       # For a gem recipe, offer to copy to user dir first so edits
-      # survive `hammer self:update`. Then exec $EDITOR on the file.
+      # survive `hammer update`. Then exec $EDITOR on the file.
       def edit(name)
         path = Hammer::Recipe.path(name) or fail_unknown(name)
         editor = ENV['EDITOR'] || ENV['VISUAL']

data/lib/hammer/command.rb

@@ -2,7 +2,7 @@ class Hammer
   # A single registered command on a Hammer class.
   class Command
     attr_reader :name, :desc, :options, :examples, :alts, :needs
-    attr_accessor :handler
+    attr_accessor :handler, :location, :prev_location
 
     def initialize(name:, desc: '', handler: nil)
       @name     = name.to_s

data/lib/hammer/recipe.rb

@@ -49,14 +49,14 @@ class Hammer
       ''
     end
 
-    # Ruby wrapper text printed by `hammer self:recipe install`. User
+    # Ruby wrapper text printed by `hammer recipes --install`. User
     # redirects it to a file in PATH and chmods +x. The leading comment
     # documents the canonical install command. Name is passed as a
     # string literal so hyphenated names (`git-helper`) work too.
     def stub(name)
       <<~RUBY
         #!/usr/bin/env ruby
-        # install: hammer self:recipe install #{name} > ~/bin/#{name} && chmod +x $_
+        # install: hammer recipes --install #{name} > ~/bin/#{name} && chmod +x $_
         require 'lux-hammer'
         Hammer.recipe('#{name}', ARGV)
       RUBY