lux-hammer 0.3.25 → 0.3.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 273ffb060fd16cb52423002e5e8e041481a37b0487395d966a8f9ba90cfa53fa
-  data.tar.gz: 9dc14e358bfafc0050379d671711ca28d6d6eb3aa1935f7440c93ea897267431
+  metadata.gz: cbcb0355f0ce770acb1ace879a1567ee1193de1da5ac6e6c32e36faa8f2a48fe
+  data.tar.gz: 8299d3bf2a47844e0e5c01ba73225d43be8aef718ceee3cf9603d0ec85e3e582
 SHA512:
-  metadata.gz: 8c9e26f85ded5283505130548bcd1b64718d1a405013149d086881e166c59239cb1a4db3fbefcb2a990ed2a06b82d90ae54769e6650be6d1d6032a9fe48328d5
-  data.tar.gz: 700f84954436b3e606d2b5234ff682f19c27d651083037e0faaa0f9ca796b1df604704d6908d58f7fa6a133dc9fa314df71084a805c6219b1d46d963557fe22b
+  metadata.gz: 6f5a7f793308a5f55e1bdb99ab85ae7aa8b271c92a073f33e1e7130f757395a97071da89a0933958cd89279a7a2004372a71746f1d83c945747ea1cb785f9f75
+  data.tar.gz: b5ee6d077d5b14fd5c448a28ea53e15da59198c067a568bee97193b5352cfea78dd073dff9054af58501453a72cbdae5b0d6c6af5e3e578004b102434a98b29d

data/.version

@@ -1 +1 @@
-0.3.25
+0.3.27

data/AGENTS.md

@@ -22,8 +22,9 @@ usable as a library (`require 'lux-hammer'`, subclass `Hammer`, call
   monkey-patches.
 * **Zero runtime dependencies**. The gem must work with stdlib only. New
   dependencies require explicit user approval.
-* **Ruby >= 2.7**. Do not use language features introduced after 2.7
-  without flagging.
+* **Ruby >= 2.7** for `lib/` and `bin/`. Do not use language features
+  introduced after 2.7 there without flagging. Bundled recipes may sit
+  higher - the `llm` recipe needs >= 3.1 (endless methods, shorthand hash).
 * **`desc` is single-arg, multi-line allowed**. The argument is one
   string; it may contain newlines. The first line is the brief shown in
   command listings, the full string renders (indented) in per-command
@@ -300,7 +301,10 @@ Task contracts:
   `--path NAME`, `--edit NAME`, `--run NAME [ARGS]` (use `--` to
   forward flags through). Bare invocation lists.
 * `h:init` - writes `Hammer::STARTER_HAMMERFILE` to `./Hammerfile`;
-  refuses if one exists.
+  refuses if one exists. `--script` writes `Hammer::STARTER_SCRIPT`
+  (shebang + one `hello` task) to stdout instead, or to a positional
+  TARGET with mode 0755. Both templates are single-quoted heredocs in
+  `lib/lux-hammer.rb` - the one source of truth, also rendered in help.
 * `h:json` - `puts JSON` of `root.export_spec` (tasks grouped exactly
   like the bare listing via `section_for`, root group keyed `__root`).
   `--all` keeps the `h:` tree, `--compact` minifies.

data/README.md

@@ -634,6 +634,9 @@ Under the `h:` namespace:
 * `h:version` - print the lux-hammer version.
 * `h:recipes` - list / install / show / edit recipes.
 * `h:init` - write a starter Hammerfile in cwd (refuses if one exists).
+  `--script` prints a minimal standalone CLI to stdout instead (shebang
+  plus one `hello` task) - pipe it to a file and `chmod +x`, or name a
+  target to write and chmod in one step.
 * `h:json` - dump the CLI definition as JSON (tasks grouped like the
   bare listing, with desc/options/examples/aliases/needs/cron); `--all`
   includes the `h:` tasks, `--compact` minifies. Output is plain stdout
@@ -1135,7 +1138,16 @@ end
 ### `#!/usr/bin/env hammer` (single-file scripts)
 
 For a one-off CLI that lives as a single executable file, point the
-shebang straight at `hammer` - no `require`, no boilerplate:
+shebang straight at `hammer` - no `require`, no boilerplate. Start from
+the bundled template:
+
+```sh
+$ hammer h:init --script greet   # or: h:init --script > greet
+$ ./greet hello
+Hello from Hammer
+```
+
+Then fill it in - the body is plain Hammerfile DSL:
 
 ```ruby
 #!/usr/bin/env hammer

data/lib/hammer/builtins.rb

@@ -108,8 +108,24 @@ class Hammer
     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 }
+          desc <<~TXT
+            Write a starter Hammerfile in the current directory.
+
+            --script prints a minimal standalone CLI (shebang + one `hello`
+            task) to stdout instead - pipe it to a file, chmod +x, run it.
+            Name a TARGET to write and chmod in one step.
+          TXT
+          example 'h:init'
+          example 'h:init --script > mytool && chmod +x mytool'
+          example 'h:init --script mytool'
+          opt :script, type: :boolean, alias: :s, desc: 'print a standalone executable CLI (TARGET writes + chmod +x)'
+          proc do |opts|
+            if opts[:script]
+              Hammer::Builtins.write_starter_script(opts[:args].first)
+            else
+              Hammer::Builtins.write_starter_hammerfile
+            end
+          end
         end
       end
     end
@@ -237,6 +253,20 @@ class Hammer
       Shell.say "created #{target}", :green
     end
 
+    # `h:init --script`. No target -> stdout, so `> tool` works; with a
+    # target it lands executable. Never clobbers, same as the Hammerfile.
+    def write_starter_script(target = nil)
+      return puts(Hammer::STARTER_SCRIPT) unless target
+
+      if File.exist?(target)
+        Shell.print_error "#{target} already exists"
+        exit 1
+      end
+      File.write(target, Hammer::STARTER_SCRIPT)
+      File.chmod(0o755, target)
+      Shell.say "created #{target} (chmod +x)", :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.

data/lib/hammer/parser.rb

@@ -50,6 +50,17 @@ class Hammer
           next
         end
 
+        # Bundled boolean short flags: `-cf` is `-c -f`. Only when every letter
+        # is a boolean switch, so `-pVALUE` below keeps its meaning.
+        if token =~ /\A-[^-]{2,}\z/
+          bundle = token[1..-1].chars.map { |ch| @by_switch["-#{ch}"] }
+          if bundle.all? { |o| o&.boolean? }
+            bundle.each { |o| values[o.name] = true }
+            i += 1
+            next
+          end
+        end
+
         # Glued short flag with value: `-pVALUE` (non-boolean short opts only).
         if token.start_with?('-') && !token.start_with?('--') && token.length > 2
           if (opt = @by_switch[token[0, 2]]) && !opt.boolean?

data/lib/lux-hammer.rb

@@ -1118,6 +1118,20 @@ class Hammer
     end
   RUBY
 
+  # Minimal standalone CLI, dumped by `hammer h:init --script`. The
+  # shebang is what `shebang_script` sniffs for, so `chmod +x` is all
+  # that stands between this and a working binary.
+  STARTER_SCRIPT ||= <<~'RUBY'
+    #!/usr/bin/env hammer
+
+    desc 'My standalone CLI'
+
+    task :hello do
+      desc 'Print a greeting'
+      proc { say.green 'Hello from Hammer' }
+    end
+  RUBY
+
   # Default install dir used by install.sh and `hammer h:update`.
   SELF_UPDATE_DIR  ||= File.expand_path('~/.local/share/lux-hammer')
   SELF_UPDATE_REPO ||= 'https://github.com/dux/hammer.git'

data/recipes/lib/llm/launch.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+
+# Builds the command `llm wrap:run` hands to LlmWrap: picks the agent CLI by
+# prefix and maps the generic -c / -f / -a switches to what that CLI takes.
+module LlmLaunch
+  Launch = Struct.new(:argv, :env, :files)
+
+  # :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.
+  TOOLS ||= {
+    'claude'   => { continue: %w[-c],            full: %w[--dangerously-skip-permissions],
+                    agents: ->(text, _files) { { args: ['--append-system-prompt', text] } } },
+    'codex'    => { continue: %w[resume --last], full: %w[--dangerously-bypass-approvals-and-sandbox],
+                    agents: ->(text, _files) { { args: ['-c', "developer_instructions=#{text}"] } } },
+    'grok'     => { continue: %w[-c],            full: %w[--always-approve],
+                    agents: ->(text, _files) { { args: ['--rules', text] } } },
+    'opencode' => { continue: %w[-c],            full: %w[--auto],
+                    agents: ->(_text, files) { { env: { 'OPENCODE_CONFIG_CONTENT' => { instructions: files }.to_json } } } },
+  }.freeze
+
+  # Read AGENTS.md from the git root down on their own; -a only adds the
+  # files above it for these. Claude reads CLAUDE.md, so it gets the chain.
+  NATIVE_AGENTS ||= %w[codex grok opencode].freeze
+
+  # First tool whose name starts with the prefix, in TOOLS order: `c` is
+  # claude, `co` codex. No prefix means claude.
+  def self.tool(prefix)
+    return 'claude' if prefix.nil? || prefix.empty?
+    TOOLS.keys.find { |name| name.start_with?(prefix) }
+  end
+
+  def self.build(tool, extra = [], continue: false, full: false, agents: false, cwd: Dir.pwd, home: Dir.home)
+    spec = TOOLS.fetch(tool)
+    argv = [tool]
+    argv.concat(spec[:continue]) if continue
+    argv.concat(spec[:full]) if full
+
+    files = agents ? agents_files(tool, cwd: cwd, home: home) : []
+    env = {}
+    if files.any?
+      added = spec[:agents].call(agents_text(files), files.map(&:to_s))
+      argv.concat(added[:args] || [])
+      env.update(added[:env] || {})
+    end
+
+    argv.concat(extra)
+    Launch.new(argv, env, files)
+  end
+
+  # AGENTS.md from home down to cwd, outermost first. For NATIVE_AGENTS tools
+  # the walk stops above the git root - or above cwd outside git, since that is
+  # what they take as the project then.
+  def self.agents_files(tool, cwd: Dir.pwd, home: Dir.home)
+    stop = nil
+    if NATIVE_AGENTS.include?(tool)
+      stop = IO.popen(['git', '-C', cwd, 'rev-parse', '--show-toplevel'], err: File::NULL, &:read).to_s.strip
+      stop = cwd if stop.empty?
+    end
+
+    Pathname(cwd).ascend
+      .select { |dir| dir.to_s.start_with?(home) }
+      .reject { |dir| stop && dir.to_s.start_with?(stop) }
+      .reverse
+      .map { |dir| dir + 'AGENTS.md' }
+      .select(&:file?)
+  end
+
+  def self.agents_text(files)
+    body = files.map { |f| "## #{f}\n\n#{f.read.strip}\n" }.join("\n")
+    "Project instructions (AGENTS.md), broad to specific:\n\n#{body}"
+  end
+end

data/recipes/llm.rb

@@ -13,6 +13,7 @@ desc <<~TXT
   Commands:
     usage    subscription limits and per-model token usage
     wrap     run a command with your last two prompts pinned to the screen
+    wrap:run start claude / codex / grok / opencode in wrap, same -c -f -a switches for all
 TXT
 
 require 'fileutils'
@@ -185,6 +186,58 @@ task :wrap do
   end
 end
 
+namespace :wrap do
+  task :run do
+    desc <<~D
+      Start an agent CLI inside `llm wrap`, with the same switches whichever one it is.
+
+      TOOL is a prefix of claude, codex, grok or opencode - first match wins, so `c` is
+      claude and `co` is codex. No tool means claude. The switches map to what each
+      CLI actually takes:
+
+        -c  continue the last session here    claude/grok/opencode -c, codex resume --last
+        -f  full permissions, no prompts      --dangerously-skip-permissions, --dangerously-bypass-
+                                              approvals-and-sandbox, --always-approve, --auto
+        -a  AGENTS.md from ~ down to cwd      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 themselves, so
+      -a only adds the files above the repo for them; claude gets the whole chain.
+      Anything after `--` is handed to the tool untouched. `~/bin/ai` is this command.
+    D
+    example 'wrap:run'
+    example 'wrap:run g -cf'
+    example 'wrap:run cod -ca'
+    example 'wrap:run c -- --model opus'
+
+    opt :continue, type: :boolean, desc: 'continue the last session in this folder'
+    opt :full,     type: :boolean, desc: 'full permissions, no approval prompts'
+    opt :agents,   type: :boolean, desc: 'inject AGENTS.md found from ~ down to cwd'
+
+    proc do |opts|
+      require File.join(_llm_root, 'lib/llm/wrap')
+      require File.join(_llm_root, 'lib/llm/launch')
+
+      args = Array(opts[:args])
+      prefix = args.first unless args.first.nil? || args.first.start_with?('-')
+      tool = LlmLaunch.tool(prefix) ||
+             error("unknown tool #{prefix.inspect} - one of #{LlmLaunch::TOOLS.keys.join(', ')}")
+      extra = prefix ? args.drop(1) : args
+
+      launch = LlmLaunch.build(tool, extra, continue: opts[:continue], full: opts[:full], agents: opts[:agents])
+      ENV.update(launch.env)
+      say.gray "agents: #{launch.files.map { |f| f.to_s.sub(Dir.home, '~') }.join(', ')}" if launch.files.any?
+
+      flags = %i[continue full agents].select { |k| opts[k] }.map { |k| "--#{k}" }
+      origin = ['llm', 'wrap:run', tool, *flags, '--', *extra]
+      # Piped stdout is block-buffered and exec drops the buffer with the banner in it.
+      $stdout.flush
+      exit LlmWrap.run(launch.argv, origin: origin)
+    end
+  end
+end
+
 namespace :memory do
   # Helpers are defined inside the namespace block (class_eval'd on the
   # namespace's anonymous Hammer subclass) so the task procs reach them.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lux-hammer
 version: !ruby/object:Gem::Version
-  version: 0.3.25
+  version: 0.3.27
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -55,6 +55,7 @@ files:
 - "./lib/lux-hammer.rb"
 - "./recipes/deploy.rb"
 - "./recipes/git-helper.rb"
+- "./recipes/lib/llm/launch.rb"
 - "./recipes/lib/llm/plan.rb"
 - "./recipes/lib/llm/usage.rb"
 - "./recipes/lib/llm/wrap.rb"