lux-hammer 0.3.24 → 0.3.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68c2cd8d90138ab3eaf6a68a23aeabc273b31d26122224ba3966d235a9841657
-  data.tar.gz: ae13bf1ca96c396b51a1db3801ce4aa4179ad67f5bb8e4b04467715b9744164e
+  metadata.gz: acc942b0818d0cc60a8cbe9a55fbf092665d6efcb46df209b2a8e9721aa1e190
+  data.tar.gz: 94baed7a0025611360d0315d084fd7432a1eb68d84302bfeaf0960ee0326aee7
 SHA512:
-  metadata.gz: 222754053a8ca203a8f0344fd0007174e1a333f92e69935fd908567e7e6a8a1d1c8675d5bd8a443a905fd9140ba54ed4afc2fdbd7abe817c8cc90d3643e97fa1
-  data.tar.gz: 345ebe94f0d5eb3383fb4a0df98a1cc95d611fa330d2174c2ed6b3b25de724ee0acc51100682cd93cce813c446298cd0e19d004998e3fe95e8f5b01434368faa
+  metadata.gz: 486bb304e25a56faada26757651998d75e589fabca7402f499dc9cdd3228a90b30cc3fc7cda765d2cd34fc90eecc906208681c031e38628e0087f59eb5250af7
+  data.tar.gz: 87115686cf4bbdd6a47ed9a25e048cf811fe1c8071966e5ee3143b7fcafc286ff1480d00c5ba494e407fa9032b8e1b6dda43e8623c011ae9ffdbdf70e8a33612

data/.version

@@ -1 +1 @@
-0.3.24
+0.3.26

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/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

@@ -9,11 +9,11 @@ desc <<~TXT
     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)
-    todo     per-project task queue for agents (./LLM_TODO.local.md)
 
   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'
@@ -186,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.
@@ -333,292 +385,6 @@ namespace :memory do
   end
 end
 
-TODO_GUIDE ||= <<~TXT
-  Per-project task queue in ./LLM_TODO.local.md - workable by humans and any agent.
-
-  Human usage:
-    llm todo:add "fix login redirect"   queue a task; pipe stdin for bulk:
-                                        `* ` bullets delimit tasks (multi-line ok),
-                                        no bullets at all = one task per line
-    llm todo:list                       tasks by id, counts, format warnings
-    llm todo:pop + llm todo:done        take / finish a single task by hand
-
-    Edit the file freely: only the `# todo`, `# doing` and `# done` sections are
-    managed. `# plan`, `# idea` and any prose stay untouched. A task starts with
-    `*` at the line start and runs until the next `*` or header; when finished it
-    moves to `# done` verbatim.
-
-  LLM usage - one of these lines is the whole prompt:
-    "Run `llm todo go` and follow its output."               work through every task
-    "Run `llm todo pop`, do the task, run `llm todo done`."  do a single task
-
-    Task text is printed raw on stdout. `todo go` repeats the protocol after each
-    task and says when the queue is empty; `todo pop` re-prints the task in
-    progress, so an interrupted agent resumes instead of skipping ahead.
-TXT
-
-task :todo do
-  desc <<~D
-    How the todo queue works, for humans and LLMs.
-
-    #{TODO_GUIDE}
-  D
-  example 'todo'
-
-  proc do
-    say TODO_GUIDE
-    say ''
-    self.class.print_help 'todo:'
-  end
-end
-
-namespace :todo do
-  # Same story as :memory - helpers must live inside the namespace block.
-  private
-
-  TODO_FILE     ||= 'LLM_TODO.local.md'
-  TODO_SECTIONS ||= { todo: 'todo', doing: 'doing', done: 'done' }.freeze
-
-  def todo_path
-    File.join(Dir.pwd, TODO_FILE)
-  end
-
-  # Exact title match on purpose - "# done ideas" must stay an unmanaged section.
-  def todo_section_key(title)
-    case title.strip.downcase
-    when 'todo', 'pending'                     then :todo
-    when 'doing', 'in progress', 'in-progress' then :doing
-    when 'done', 'completed'                   then :done
-    end
-  end
-
-  # The tool manages only the `# todo`, `# doing` and `# done` sections (any
-  # heading level). Inside them a task starts at a `*` or `-` bullet in the
-  # first column and runs until the next bullet or header, so tasks can span
-  # multiple lines and move between sections verbatim. Every other section
-  # (`# plan`, `# idea`, ...) and any preamble is kept as-is and never touched.
-  # Returns [tasks, nodes]; nodes reproduce the document layout for todo_save.
-  def todo_parse
-    tasks = { todo: [], doing: [], done: [] }
-    nodes = []
-    return [tasks, nodes] unless File.file?(todo_path)
-
-    section = nil # managed section key, nil while inside a raw chunk
-    current = nil # lines of the task being collected
-
-    flush_task = lambda do
-      tasks[section] << current.join("\n").rstrip if current
-      current = nil
-    end
-
-    File.foreach(todo_path) do |raw|
-      line = raw.chomp
-      if (m = line.match(/^#+\s*(\S.*?)\s*$/))
-        flush_task.call
-        section = todo_section_key(m[1])
-        if section
-          nodes << [:section, section] unless nodes.include?([:section, section])
-        else
-          nodes << [:raw, [line]]
-        end
-      elsif section
-        if line =~ /^[-*]\s+(.*)$/
-          flush_task.call
-          current = [$1.strip]
-        elsif current
-          current << line.rstrip
-        end
-      else
-        nodes << [:raw, []] unless nodes.last && nodes.last[0] == :raw
-        nodes.last[1] << line.rstrip
-      end
-    end
-    flush_task.call
-    [tasks, nodes]
-  end
-
-  # Rewrite: managed sections in canonical form, raw chunks verbatim, original
-  # order kept. Managed sections missing from the file are appended at the end.
-  def todo_save(tasks, nodes)
-    order = nodes + (TODO_SECTIONS.keys - nodes.map { |t, v| v if t == :section }).map { |k| [:section, k] }
-
-    File.open(todo_path, 'w') do |io|
-      order.each_with_index do |(type, value), i|
-        io.puts unless i.zero?
-        if type == :section
-          io.puts "# #{TODO_SECTIONS[value]}"
-          tasks[value].each do |text|
-            io.puts
-            io.puts "* #{text}"
-          end
-        else
-          lines = value.dup
-          lines.pop while lines.any? && lines.last.empty?
-          lines.each { |l| io.puts l }
-        end
-      end
-    end
-  end
-
-  # One-line label for confirmations - multi-line tasks show their first line.
-  def todo_label(text)
-    first, rest = text.split("\n", 2)
-    rest ? "#{first} ..." : first
-  end
-
-  # Format sanity check for hand-edited files. Returns warning strings.
-  def todo_lint(tasks)
-    warns   = []
-    seen    = Hash.new(0)
-    section = :preamble
-    File.foreach(todo_path) do |raw|
-      line = raw.chomp
-      if (m = line.match(/^#+\s*(\S.*?)\s*$/))
-        key       = todo_section_key(m[1])
-        section   = key || :other
-        seen[key] += 1 if key
-      elsif section == :preamble && line =~ /^[-*]\s/
-        warns << "ignored bullet before any section header: #{line}"
-      end
-    end
-    TODO_SECTIONS.each_key do |key|
-      warns << "duplicate '# #{key}' sections - their tasks are merged" if seen[key] > 1
-      warns << "missing '# #{key}' section - will be added on next write" if seen[key].zero?
-    end
-    warns << "#{tasks[:doing].length} tasks in doing - expected at most 1" if tasks[:doing].length > 1
-    warns
-  end
-
-  task :add do
-    desc <<~DESC
-      Add task(s) to ./#{TODO_FILE} (created on first add).
-
-      Text comes from the argument (one task), or from stdin. Piped input
-      that has `*` / `-` bullets is a list: a bullet begins a task and the
-      lines under it belong to it, so multi-line tasks and whole lists can be
-      piped in at once. Input with no bullets at all is one task per line.
-    DESC
-    example 'todo add "migrate the user model to Sequel"'
-    example 'cat tasks.md | llm todo add'
-    opt :text, desc: 'task text (or pipe tasks on stdin)'
-
-    proc do |opts|
-      # unquoted multi-word input lands in :text + :args - join it back
-      arg = [opts[:text], *opts[:args]].compact.join(' ').strip
-      if arg.empty?
-        lines     = opts[:stdin].to_s.split("\n")
-        bulleted  = lines.any? { |l| l =~ /^[-*]\s+/ }
-        new_tasks = []
-        lines.each do |line|
-          if line =~ /^[-*]\s+(.*)$/
-            new_tasks << [$1.strip]
-          elsif bulleted
-            new_tasks.last << line.rstrip if new_tasks.any?
-          elsif line.strip != ''
-            new_tasks << [line.rstrip]
-          end
-        end
-        new_tasks = new_tasks.map { |ls| ls.join("\n").rstrip }.reject(&:empty?)
-      else
-        new_tasks = [arg]
-      end
-      error 'usage: llm todo add <text> (or pipe tasks on stdin)' if new_tasks.empty?
-
-      tasks, nodes = todo_parse
-      tasks[:todo].concat new_tasks
-      todo_save tasks, nodes
-      new_tasks.each { |t| say "added: #{todo_label(t)}", :green }
-    end
-  end
-
-  task :pop do
-    desc <<~DESC
-      Print the current task and stop there - one task, no loop.
-
-      Moves the first todo task to doing if nothing is doing yet. Prints only
-      the raw task text (agent-friendly stdout). Re-running without `todo done`
-      prints the same task again, so an interrupted agent resumes instead of
-      starting the next one. Exits 1 when the list is empty.
-    DESC
-    example 'todo pop'
-
-    proc do
-      tasks, nodes = todo_parse
-      if tasks[:doing].empty?
-        error 'todo list is empty' if tasks[:todo].empty?
-        tasks[:doing] << tasks[:todo].shift
-        todo_save tasks, nodes
-      end
-      puts tasks[:doing].first
-    end
-  end
-
-  task :go do
-    desc <<~DESC
-      Agent entry point: work through the whole todo list.
-
-      Prints the current task (pop) followed by the loop protocol, so telling
-      any agent "run llm todo go" is enough to drain the queue. When the list
-      is empty it says so and tells the agent to stop and summarize.
-    DESC
-    example 'todo go'
-
-    proc do
-      tasks, nodes = todo_parse
-      if tasks[:doing].empty? && tasks[:todo].empty?
-        say 'All tasks done - stop the loop and summarize what was done.'
-        next
-      end
-      if tasks[:doing].empty?
-        tasks[:doing] << tasks[:todo].shift
-        todo_save tasks, nodes
-      end
-      say "TASK: #{tasks[:doing].first}"
-      say ''
-      say 'Do this task fully and verify it. Then run `llm todo done`, and `llm todo go` for the next one.'
-    end
-  end
-
-  task :done do
-    desc 'Mark the in-progress task as done'
-    example 'todo done'
-
-    proc do
-      tasks, nodes = todo_parse
-      error 'no task in progress (run: llm todo pop)' if tasks[:doing].empty?
-      text = tasks[:doing].shift
-      tasks[:done] << text
-      todo_save tasks, nodes
-      say "done: #{todo_label(text)}", :green
-    end
-  end
-
-  task :list do
-    alt :inspect
-    desc 'Inspect the todo file: tasks by id, counts, format validity warnings'
-    example 'todo list'
-
-    proc do
-      error "no #{TODO_FILE} in #{Dir.pwd} (run: llm todo add <text>)" unless File.file?(todo_path)
-      tasks, = todo_parse
-      id = 0
-      TODO_SECTIONS.each do |key, title|
-        say "#{title}:", :cyan
-        color = { todo: nil, doing: :yellow, done: :gray }[key]
-        tasks[key].each do |text|
-          first, *rest = text.split("\n")
-          say "#{(id += 1).to_s.rjust(3)}. #{first}", color
-          rest.each { |l| say "     #{l}", color }
-        end
-        say '  (none)', :gray if tasks[key].empty?
-      end
-      say ''
-      say "#{tasks[:todo].length} todo, #{tasks[:doing].length} doing, #{tasks[:done].length} done"
-      todo_lint(tasks).each { |w| say "warning: #{w}", :yellow }
-    end
-  end
-end
-
 namespace :prompt do
   TOKEN_PATTERN        ||= /[a-z0-9_-]+/.freeze
   TOKEN_LINE_RE        ||= /\A(?:\s*:[a-z0-9_-]+)+\s*\z/.freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lux-hammer
 version: !ruby/object:Gem::Version
-  version: 0.3.24
+  version: 0.3.26
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-08-27 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"