lux-hammer 0.3.29 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dab0deb8eba80ec1aac72b16620370af2d80d2528641e9117be71df84e8d416
-  data.tar.gz: 6460bbda170ba18cedf234846e4898f1c6efc48732c81ed122fc6eaa11d237b8
+  metadata.gz: 62f3507ae302513e173b9c4ee719b1c27448d47ef4a8568f0be0e8e8485410c5
+  data.tar.gz: 92983a6f6e7c0dd96c75f0dd3abca3bab91808c4f2c10b93205aa426932d7405
 SHA512:
-  metadata.gz: c24c74422db1ac9a72b5a03ae4f7d4e56e486c7622be40f5e136c16b9a15b2a04feeb7d2f61cdfdaaeafbc5c3913e71c2f8faf567cac8ea236eaeeadcb7fcb4f
-  data.tar.gz: 823288d67fd112a118c09b3b1dd3599a3b080c5c74fd6e5a35492be182a72fa3fbe82359498e1facb0396b61773b1a51e61dba786284d2bde19426a8e3eddc81
+  metadata.gz: 1fd6204a4915f166d68bbb51fe33474ae44dff46e088486e939b0f7b887378a150548cb5fb646c25699381fcfeb79c97ed4028ee0149a1f8872daac38b755eee
+  data.tar.gz: c798f9716fe791388075077034486e817dca3025a9f042bf04d8ac472c2af8e1c67d36b4914c8c100ecf7fd253d830738ccca619ce2aabe7808130232c980571

data/.version

@@ -1 +1 @@
-0.3.29
+0.8.4

data/AGENTS.md

@@ -15,8 +15,9 @@ usable as a library (`require 'lux-hammer'`, subclass `Hammer`, call
 
 * **One root constant**: `Hammer`. Never pollute `Object` or introduce
   another top-level constant. Sub-types live as `Hammer::Shell`,
-  `Hammer::Option`, `Hammer::Parser`, `Hammer::Command`,
-  `Hammer::Loader`, `Hammer::Builder`, `Hammer::CommandBuilder`. The one
+  `Hammer::Version`, `Hammer::Option`, `Hammer::Parser`,
+  `Hammer::Command`, `Hammer::Loader`, `Hammer::Builder`,
+  `Hammer::CommandBuilder`. The one
   exception is `String#color(:name)` (defined in `lib/hammer/shell.rb`)
   - a tiny convenience for `"hi".color(:cyan)`. Do not add more
   monkey-patches.
@@ -39,6 +40,7 @@ usable as a library (`require 'lux-hammer'`, subclass `Hammer`, call
 bin/hammer                  # CLI entry point
 lib/lux-hammer.rb           # Entry - defines class Hammer and its DSL
 lib/hammer/shell.rb         # ANSI/IO helpers
+lib/hammer/version.rb       # Hammer::Version - git-count version + .version fallback
 lib/hammer/option.rb        # One option definition (types: string/boolean/integer/float/array/json)
 lib/hammer/input.rb         # opts[:stdin], prepare_json!, JSON @file / pipe helpers
 lib/hammer/parser.rb        # ARGV -> [positional, opts_hash]
@@ -58,6 +60,7 @@ test/parser_test.rb         # ARGV parsing edge cases
 test/option_test.rb         # Option declaration / casting
 test/command_test.rb        # Command data type
 test/shell_test.rb          # ANSI / IO helpers
+test/version_test.rb        # version formatting (git count -> dotted)
 test/cli_test.rb            # `hammer` binary end-to-end
 test/cron_test.rb           # schedule parser (matches?/due?/next_run)
 test/cron_server_test.rb    # job discovery, state, rotation, web UI
@@ -422,6 +425,22 @@ new code in this gem should show.
 * Inside a handler, just call `error 'msg'` - it resolves via the
   `Shell` mixin.
 
+## Versioning
+
+* `Hammer::VERSION` is the dboss-style formatted commit count on `main`
+  (falling back to `master`, then `HEAD`): `v82` -> `0.8.2`, `v1123` ->
+  `11.2.3`, left-padded so `v5` -> `0.0.5`. It is bare (no leading `v`)
+  so it stays a valid `Gem::Version`.
+* `Hammer::Version.string` is that value, `Hammer::Version.raw` is the
+  `v<count>` behind it, and `Hammer::Version.format` is the pure
+  formatter (a non-`v<digits>` string is returned unchanged).
+* A released gem has no `.git` and falls back to the committed
+  `.version` file. `hammer gem --inc` writes the git-count value into
+  `.version` (overwriting `.version.prev`), so the built gem's version
+  matches the checkout; the release workflow tags `v$(cat .version)`.
+* Don't reintroduce manual major/minor/patch bumps - the count is the
+  version.
+
 ## Coding rules
 
 * No trailing spaces on empty lines. End every file with a newline.

data/lib/hammer/version.rb

@@ -0,0 +1,52 @@
+class Hammer
+  # The running version, derived the way dboss derives its own: the number
+  # of commits reachable from main (or master, or HEAD) rendered as a dotted
+  # triple, so v82 -> 0.8.2 and v1123 -> 11.2.3. A released gem has no .git
+  # and falls back to the .version file baked in at build time, which is also
+  # what `hammer gem --inc` writes.
+  module Version
+    module_function
+
+    ROOT ||= File.expand_path('../..', __dir__)
+
+    # Dotted, no leading v, so it stays a valid Gem::Version (v1.2.3 -> 1.2.3).
+    def string
+      format(raw)
+    end
+
+    # v<commit count> in a git checkout, else the packaged .version string.
+    def raw
+      count = git_count
+      count ? "v#{count}" : file_version
+    end
+
+    # v123 -> 1.2.3, v1123 -> 11.2.3, v5 -> 0.0.5. Anything that is not
+    # v<digits> (dev, an already-dotted version) is returned unchanged.
+    def format(version)
+      text  = version.to_s
+      count = text.start_with?('v') ? text[1..] : nil
+      return text unless count && !count.empty? && count.match?(/\A\d+\z/)
+
+      count = count.rjust(3, '0')
+      "#{count[0...-2]}.#{count[-2]}.#{count[-1]}"
+    end
+
+    def git_count
+      return nil unless File.exist?(File.join(ROOT, '.git'))
+
+      %w[main master HEAD].each do |ref|
+        out = IO.popen(['git', '-C', ROOT, 'rev-list', '--count', ref],
+                       err: File::NULL, &:read).to_s.strip
+        return out.to_i if out.match?(/\A\d+\z/)
+      end
+      nil
+    rescue SystemCallError
+      nil
+    end
+
+    def file_version
+      path = File.join(ROOT, '.version')
+      File.exist?(path) ? File.read(path).strip : 'dev'
+    end
+  end
+end

data/lib/lux-hammer.rb

@@ -1,4 +1,5 @@
 require_relative 'hammer/shell'
+require_relative 'hammer/version'
 require_relative 'hammer/input'
 require_relative 'hammer/option'
 require_relative 'hammer/parser'
@@ -47,8 +48,9 @@ class Hammer
   Error          ||= Class.new(StandardError)
   AmbiguousMatch ||= Class.new(Error)
 
-  # Gem version, read once from the bundled .version file.
-  VERSION ||= File.read(File.expand_path('../.version', __dir__)).strip
+  # Gem version: the formatted main-branch commit count in a checkout, or the
+  # bundled .version baked into a released gem. See Hammer::Version.
+  VERSION ||= Version.string
 
   # Convenience aliases so recipes can write `Hammer.prepare_json!(opts)`
   # without the Input module path. See Hammer::Input.
@@ -1281,10 +1283,12 @@ class Hammer
   # built-ins (so the script's `--help` shows only what it defines).
   # `program_name` is the script's basename so help reads "myscript foo"
   # rather than "hammer foo" - works even when invoked via a symlink in
-  # PATH, since argv[0] is the path the user typed.
+  # PATH, since argv[0] is the path the user typed. `.rb` is stripped so
+  # a recipe exec'd as `recipes/llm.rb` (typical `~/bin/llm` stub) still
+  # banners as `llm`, matching `Hammer.recipe(:llm)`.
   def self.run_shebang(path, argv)
     klass = Class.new(Hammer)
-    klass.instance_variable_set(:@program_name, File.basename(path))
+    klass.instance_variable_set(:@program_name, File.basename(path, '.rb'))
     Builder.new(klass).evaluate(File.read(path), path)
     klass.start(argv)
   end

data/recipes/git-helper.rb

@@ -450,6 +450,26 @@ task :pr do
   proc { open_in_browser(remote_pr_url) }
 end
 
+task :prs do
+  desc 'list open PRs: id, author, short title, url (others first, then mine)'
+  proc do |_|
+    require 'json'
+    out = `GH_PAGER=cat gh pr list --state open --limit 100 --json number,title,url,author`
+    error 'gh pr list failed' unless $?.success?
+    prs = JSON.parse(out)
+    next say('No open PRs', :yellow) if prs.empty?
+    me = `GH_PAGER=cat gh api user --jq .login`.chomp
+    mine, others = prs.partition { |pr| pr.dig('author', 'login') == me }
+    author_width = prs.map { |pr| pr.dig('author', 'login').to_s.length }.max
+    (others + mine).each do |pr|
+      title  = pr['title'].length > 50 ? "#{pr['title'][0, 49]}…" : pr['title']
+      author = pr.dig('author', 'login').to_s.ljust(author_width)
+      author = author.color(mine.include?(pr) ? :green : :blue)
+      puts "#{"##{pr['number']}".ljust(7).color(:yellow)} #{author}  #{title.ljust(50)}  #{pr['url']}"
+    end
+  end
+end
+
 # ---- tags / users / stats --------------------------------------------
 
 task :tag do

data/recipes/lib/llm/launch.rb

@@ -9,17 +9,24 @@ require 'pathname'
 module LlmLaunch
   Launch = Struct.new(:argv, :env, :files)
 
+  # The one registry of agent CLIs. :continue / :full / :agents drive a launch;
+  # :update / :version / :models drive `llm wrap:run --update` (LlmUpdate).
   # :agents gets the combined AGENTS.md text and the file paths, and answers
   # with the argv to add and/or env to set - opencode has no flag for
   # instructions, only inline config, and that one takes paths.
+  # :models is nil where the CLI has no listing command - skip, not "none".
   TOOLS ||= {
     'claude'   => { continue: %w[-c],            full: %w[--dangerously-skip-permissions],
+                    update: %w[claude update],   version: %w[claude --version],   models: nil,
                     agents: ->(text, _files) { { args: ['--append-system-prompt', text] } } },
     'codex'    => { continue: %w[resume --last], full: %w[--dangerously-bypass-approvals-and-sandbox],
+                    update: %w[codex update],    version: %w[codex --version],    models: nil,
                     agents: ->(text, _files) { { args: ['-c', "developer_instructions=#{text}"] } } },
     'grok'     => { continue: %w[-c],            full: %w[--always-approve],
+                    update: %w[grok update],     version: %w[grok version],       models: %w[grok models],
                     agents: ->(text, _files) { { args: ['--rules', text] } } },
     'opencode' => { continue: %w[-c],            full: %w[--auto],
+                    update: %w[opencode upgrade], version: %w[opencode --version], models: %w[opencode models],
                     agents: ->(_text, files) { { env: { 'OPENCODE_CONFIG_CONTENT' => { instructions: files }.to_json } } } },
   }.freeze
 

data/recipes/lib/llm/update.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require_relative 'launch'
+
+# Backs `llm wrap:run --update` (`ai --update`): runs each agent CLI's own
+# updater and reports old -> new, then re-reads the model lists and shows what
+# appeared or disappeared since the last run. None of these tools download
+# model weights - the models are API-side, so the list is the thing that moves.
+module LlmUpdate
+  extend Hammer::Shell
+
+  CACHE_PATH ||= File.expand_path('~/.cache/llm/models.json')
+  WIDTH      ||= LlmLaunch::TOOLS.keys.map(&:size).max
+
+  # How each CLI prints its list: grok bullets it under a preamble ("You are
+  # not authenticated." when logged out) and marks the default, opencode prints
+  # one bare provider/model per line.
+  MODEL_RE ||= {
+    'grok'     => /\A\s*[*-]\s+(\S+)/,
+    'opencode' => %r{\A(\S+/\S+)\z},
+  }.freeze
+
+  module_function
+
+  # Returns the exit status - non-zero if any updater failed.
+  def run(tools)
+    rows = tools.map { |tool| update_one(tool) }
+    say ''
+    rows.each { |row| report(row) }
+    report_models(rows.select { |row| row[:installed] }.map { |row| row[:tool] })
+    rows.any? { |row| row[:failed] } ? 1 : 0
+  end
+
+  def update_one(tool)
+    return { tool: tool, installed: false } unless command?(tool)
+
+    argv = LlmLaunch::TOOLS.fetch(tool)[:update]
+    before = version(tool)
+    say.gray "$ #{argv.join(' ')}"
+    ok = system(*argv)
+    { tool: tool, installed: true, before: before, after: version(tool), failed: !ok }
+  end
+
+  def report(row)
+    name = row[:tool].ljust(WIDTH)
+    return say.gray("* #{name}  not installed") unless row[:installed]
+    return say.red("* #{name}  update failed") if row[:failed]
+
+    before, after = row.values_at(:before, :after)
+    if before && after && before != after
+      say.green "* #{name}  #{before} -> #{after}"
+    elsif after
+      say "* #{name}  #{after} (latest)"
+    else
+      say "* #{name}  #{before || 'unknown version'}"
+    end
+  end
+
+  def report_models(tools)
+    tools = tools.select { |tool| LlmLaunch::TOOLS.fetch(tool)[:models] }
+    return if tools.empty?
+
+    cache = cache_read
+    say ''
+    say 'models'
+    tools.each { |tool| cache[tool] = report_model_list(tool, cache[tool]) }
+    cache_write(cache)
+  end
+
+  # Prints one tool's list against the previously cached one, and answers with
+  # the fresh list so the caller can write it back.
+  def report_model_list(tool, old)
+    list = models(tool)
+    name = tool.ljust(WIDTH)
+    if list.empty?
+      say.gray "  #{name}  no models listed"
+      return old || []
+    end
+
+    say "  #{name}  #{list.size} models"
+    unless old
+      say.gray '    (first run)'
+      return list
+    end
+
+    added, removed = diff(old, list)
+    say.gray('    unchanged') if added.empty? && removed.empty?
+    added.each   { |model| say.green "    + #{model}" }
+    removed.each { |model| say.gray "    - #{model}" }
+    list
+  end
+
+  def version(tool)
+    parse_version(capture(LlmLaunch::TOOLS.fetch(tool)[:version]))
+  end
+
+  def models(tool)
+    parse_models(tool, capture(LlmLaunch::TOOLS.fetch(tool)[:models]))
+  end
+
+  # `2.1.268 (Claude Code)`, `codex-cli 0.154.0`, `grok 1.0.25 (f7e67d6) [stable]`, `1.18.30`
+  def parse_version(out)
+    out.to_s.lines.first.to_s[/\d+\.\d+(?:\.\d+)*/]
+  end
+
+  def parse_models(tool, out)
+    re = MODEL_RE[tool]
+    return [] unless re
+    out.to_s.lines.filter_map { |line| line.rstrip[re, 1] }.uniq.sort
+  end
+
+  def diff(old, new)
+    [new - old, old - new]
+  end
+
+  def cache_read
+    JSON.parse(File.read(CACHE_PATH))
+  rescue StandardError
+    {}
+  end
+
+  def cache_write(data)
+    FileUtils.mkdir_p(File.dirname(CACHE_PATH))
+    tmp = "#{CACHE_PATH}.#{Process.pid}.tmp"
+    File.write(tmp, JSON.pretty_generate(data))
+    File.rename(tmp, CACHE_PATH)
+  end
+
+  def capture(argv)
+    IO.popen(argv, err: %i[child out], &:read).to_s
+  rescue StandardError
+    ''
+  end
+
+  def command?(name)
+    ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, name)) }
+  end
+end

data/recipes/lib/llm/usage.rb

@@ -770,12 +770,19 @@ module LlmUsage
 
   def row_cells(row, period)
     if period_label(period) == 'month'
-      [row.name, row.month_pct || '-', row.month_reset || '-']
+      [row.name, utilization_bar(row.month_pct), row.month_reset || '-']
     else
-      [row.name, row.session_pct, row.session_reset, row.week_pct, row.week_reset]
+      [row.name, utilization_bar(row.session_pct), row.session_reset, utilization_bar(row.week_pct), row.week_reset]
     end
   end
 
+  def utilization_bar(value)
+    return '-' if value.nil? || value == '-'
+
+    filled = (value.to_f.clamp(0, 100) / 10).round
+    "[#{'#' * filled}#{'-' * (10 - filled)}] #{value.rjust(4)}"
+  end
+
   def row_to_hash(row, period: nil)
     if period_label(period) == 'month'
       # Mirror row_cells: providers with no month window render '-', not null.

data/recipes/lib/llm/wrap.rb

@@ -673,10 +673,12 @@ module LlmWrap
   #   * a sequence, leaving the introducer stranded and its tail printed as
   #     text - the literal "[22m" on screen
   #   * a UTF-8 character, which comes out as a replacement glyph
-  #   * a DECSC the child opened and has not closed yet. The terminal has one
-  #     save slot; we take it, and the child's own ESC8 then puts its cursor on
-  #     our bar and it draws the rest of the frame over the top. Claude Code
-  #     wraps every repaint in ESC7 ... ESC8, so this one is not theoretical.
+  #   * a cursor save the child opened and has not restored yet, in either the
+  #     DECSC (ESC7/ESC8) or SCO (CSI s / CSI u) form. The terminal has one save
+  #     slot; we take it, and the child's own restore then puts its cursor on our
+  #     bar and it draws the rest of the frame over the top. Claude Code brackets
+  #     every repaint in ESC7 ... ESC8 and OpenCode uses CSI s ... CSI u, so this
+  #     one is not theoretical.
   #
   # This is only ever asked about the *end* of what we have written so far, so
   # there is no need to understand the sequences - just to know where they stop.
@@ -774,11 +776,20 @@ module LlmWrap
     end
 
     def csi(byte)
+      first = @len.zero?
       @len += 1
       return @state = :esc if byte == ESC       # aborted, a new one starting
       return @state = :text if @len > MAX_CSI
 
-      @state = :text if byte >= 0x40 && byte <= 0x7e
+      if byte >= 0x40 && byte <= 0x7e
+        # SCO save/restore (CSI s / CSI u) share the single save slot with
+        # DECSC/DECRC on the emulators we run against, and OpenCode repaints
+        # through this pair - a paint between them takes the slot and its
+        # restore lands the rest of the frame on our bar.
+        @saved += 1 if first && byte == 0x73
+        @saved -= 1 if first && byte == 0x75 && @saved.positive?
+        @state = :text
+      end
     end
 
     # String payloads run to BEL or ST (ESC \).

data/recipes/llm.rb

@@ -9,7 +9,7 @@ desc <<~TXT
     browser  drive a local Chrome with Stagehand, thinking through claude / codex / ollama
     memory   persistent memory store (backs the Claude Code memory plugin)
     plan     apply a /plan bundle - sha1 checked, drift aware
-    prompt   token-prefix prompt expander (UserPromptSubmit hook + CLI)
+    prompt   ::token prompt expander (UserPromptSubmit hook + CLI)
 
   Commands:
     usage    subscription limits and per-model token usage
@@ -207,6 +207,11 @@ namespace :wrap do
                                               approvals-and-sandbox, --always-approve, --auto
         -b  bare - no AGENTS.md injection     skips the default below
 
+      --update runs each CLI's own updater (claude/codex/grok update, opencode upgrade),
+      reports old -> new, then re-reads the model lists and shows what appeared or
+      disappeared since the last run. A TOOL prefix scopes it to that one tool; no prefix
+      updates all four.
+
       By default every AGENTS.md from ~ down to cwd is handed to the tool: claude
       --append-system-prompt, codex -c developer_instructions, grok --rules, opencode
       inline config. codex, grok and opencode read AGENTS.md from the git root down by
@@ -217,10 +222,12 @@ namespace :wrap do
     example 'wrap:run g -cf'
     example 'wrap:run cod -cb'
     example 'wrap:run c -- --model opus'
+    example 'wrap:run --update'
 
     opt :continue, type: :boolean, desc: 'continue the last session in this folder'
     opt :full,     type: :boolean, desc: 'full permissions, no approval prompts'
     opt :bare,     type: :boolean, desc: 'bare agent - do not inject AGENTS.md'
+    opt :update,   type: :boolean, desc: 'update the agent CLIs, then show model changes'
 
     proc do |opts|
       require File.join(_llm_root, 'lib/llm/wrap')
@@ -232,6 +239,11 @@ namespace :wrap do
              error("unknown tool #{prefix.inspect} - one of #{LlmLaunch::TOOLS.keys.join(', ')}")
       extra = prefix ? args.drop(1) : args
 
+      if opts[:update]
+        require File.join(_llm_root, 'lib/llm/update')
+        exit LlmUpdate.run(prefix ? [tool] : LlmLaunch::TOOLS.keys)
+      end
+
       launch = LlmLaunch.build(tool, extra, continue: opts[:continue], full: opts[:full], bare: opts[:bare])
       ENV.update(launch.env)
       say.gray "agents: #{launch.files.map { |f| f.to_s.sub(Dir.home, '~') }.join(', ')}" if launch.files.any?
@@ -486,7 +498,7 @@ end
 
 namespace :prompt do
   TOKEN_PATTERN        ||= /[a-z0-9_-]+/.freeze
-  TOKEN_LINE_RE        ||= /\A(?:\s*:[a-z0-9_-]+)+\s*\z/.freeze
+  TOKEN_LINE_RE        ||= /\A(?:\s*::[a-z0-9_-]+)+\s*\z/.freeze
   HOOK_EVENT           ||= 'UserPromptSubmit'
   VERBATIM_INSTRUCTION ||= "INSTRUCTION TO ASSISTANT: Do not answer the user's prompt. Print the message below verbatim to the user, preserving every line exactly as written. Do not summarize, truncate, or paraphrase."
   QUESTION_RULE        ||= <<~RULE.strip
@@ -508,8 +520,8 @@ namespace :prompt do
   def tokens_in(input)
     out = []
     scanner = input.to_s.strip
-    while (m = scanner.match(/\A(?::(?<pre>#{TOKEN_PATTERN})|(?<post>#{TOKEN_PATTERN}):)(?=\s|$)/))
-      out << (m[:pre] || m[:post])
+    while (m = scanner.match(/\A::(#{TOKEN_PATTERN})(?=\s|$)/))
+      out << m[1]
       scanner = scanner[m[0].length..].to_s.lstrip
     end
     out.uniq
@@ -531,7 +543,7 @@ namespace :prompt do
     ordered = folders.sort_by { |label, _| label == 'global' ? 0 : 1 }
     ordered.map do |label, folder|
       toks = Dir.glob(File.join(folder, '*.md')).map { |p| File.basename(p, '.md') }.sort
-      items = toks.empty? ? '(none)' : toks.map { |t| ":#{t}" }.join(', ')
+      items = toks.empty? ? '(none)' : toks.map { |t| "::#{t}" }.join(', ')
       "Available #{label} in #{display_path(folder)} -> #{items}"
     end.join("\n")
   end
@@ -549,7 +561,7 @@ namespace :prompt do
           name = File.basename(path, '.md')
           dscr = first_line_description(path)
           dscr = '(no description)' if dscr.empty?
-          "  :#{name.ljust(width)}  #{dscr}"
+          "  ::#{name.ljust(width)}  #{dscr}"
         end
         "#{header}\n#{entries.join("\n")}"
       end
@@ -619,7 +631,7 @@ namespace :prompt do
       end
 
       break unless stripped =~ TOKEN_LINE_RE
-      prefix_tokens.concat(stripped.scan(/:(#{TOKEN_PATTERN})/).flatten)
+      prefix_tokens.concat(stripped.scan(/::(#{TOKEN_PATTERN})/).flatten)
       remaining = rest.to_s
     end
 
@@ -640,9 +652,9 @@ namespace :prompt do
   end
 
   def load_command_content(token, seen)
-    error "circular include of :#{token}" if seen.include?(token)
+    error "circular include of ::#{token}" if seen.include?(token)
     path = find_command_path(token)
-    error %(custom token ":#{token}" not found.\n\n#{grouped_listing}) unless path
+    error %(custom token "::#{token}" not found.\n\n#{grouped_listing}) unless path
 
     child_seen = seen + [token]
     content = File.read(path)
@@ -671,7 +683,7 @@ namespace :prompt do
     seen = Set.new
     loaded = toks.map do |token|
       path = find_command_path(token)
-      error %(custom token ":#{token}" not found.\n\n#{grouped_listing}) unless path
+      error %(custom token "::#{token}" not found.\n\n#{grouped_listing}) unless path
       [token, Pathname.new(path).cleanpath.to_s, load_command_content(token, seen)]
     end
 
@@ -721,12 +733,11 @@ namespace :prompt do
 
   task :expand do
     desc 'Expand prompt token(s) and print the resulting context'
-    example 'prompt:expand :foo :bar'
-    example 'prompt:expand foo:'
+    example 'prompt:expand ::foo ::bar'
 
     proc do |opts|
       input = opts[:args].join(' ')
-      error 'usage: llm prompt:expand :token [:token ...]' if input.empty?
+      error 'usage: llm prompt:expand ::token [::token ...]' if input.empty?
       out = load_context(input)
       say out unless out.empty?
     end
@@ -735,7 +746,7 @@ namespace :prompt do
   task :hook do
     desc <<~D
       UserPromptSubmit hook entry. Reads {"prompt": ...} JSON on stdin,
-      expands any token prefix, and emits hookSpecificOutput JSON on stdout.
+      expands any ::token prefix, and emits hookSpecificOutput JSON on stdout.
 
       Pair with HAMMER_QUIET=1 in the hook command so the runtime banner
       doesn't pollute stdout.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lux-hammer
 version: !ruby/object:Gem::Version
-  version: 0.3.29
+  version: 0.8.4
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-10 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,12 +52,14 @@ files:
 - "./lib/hammer/parser.rb"
 - "./lib/hammer/recipe.rb"
 - "./lib/hammer/shell.rb"
+- "./lib/hammer/version.rb"
 - "./lib/lux-hammer.rb"
 - "./recipes/deploy.rb"
 - "./recipes/git-helper.rb"
 - "./recipes/lib/llm/browser.rb"
 - "./recipes/lib/llm/launch.rb"
 - "./recipes/lib/llm/plan.rb"
+- "./recipes/lib/llm/update.rb"
 - "./recipes/lib/llm/usage.rb"
 - "./recipes/lib/llm/wrap.rb"
 - "./recipes/llm.rb"