lux-hammer 0.3.23 → 0.3.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74dd44bca6cf689dcfe0396d90e05e51b0605821314fb6d5b742502662f4e8e8
-  data.tar.gz: a84eaa4fcce83f951905bab3419d18adfcce409cd0f9d2f23db910569443a2ce
+  metadata.gz: 273ffb060fd16cb52423002e5e8e041481a37b0487395d966a8f9ba90cfa53fa
+  data.tar.gz: 9dc14e358bfafc0050379d671711ca28d6d6eb3aa1935f7440c93ea897267431
 SHA512:
-  metadata.gz: 044a31c525aba212012888f39d938fa37dc2e69e59097fa10f1dda53723b0a267dae2dad0e77887c19ad801a64fcb47e03b8aa95d916b04474d5239628a9b8f0
-  data.tar.gz: 3ec9940429c06e4bfb00669184fe3d4f78fff0ed693f857fcd37c682bf89b70a214f3a7e92e24826a1ab5889c62de26f05e0f9b78fe22c1c65b12227d4a18681
+  metadata.gz: 8c9e26f85ded5283505130548bcd1b64718d1a405013149d086881e166c59239cb1a4db3fbefcb2a990ed2a06b82d90ae54769e6650be6d1d6032a9fe48328d5
+  data.tar.gz: 700f84954436b3e606d2b5234ff682f19c27d651083037e0faaa0f9ca796b1df604704d6908d58f7fa6a133dc9fa314df71084a805c6219b1d46d963557fe22b

data/.version

@@ -1 +1 @@
-0.3.23
+0.3.25

data/README.md

@@ -506,9 +506,11 @@ end
 
 ## Stdin, JSON input, and global options
 
-Every command receives **`opts[:stdin]`** automatically when stdin is a
-pipe (non-TTY) and non-empty; otherwise it is `nil`. Interactive TTYs are
-never consumed.
+Every command can read **`opts[:stdin]`**: piped stdin (non-TTY, non-empty)
+as a string, otherwise `nil`. It is read on the first lookup and kept, so a
+command that never looks never waits on a pipe. Interactive TTYs are never
+consumed, and a socket with nothing pending (agent harnesses hand one to
+every command) reads as `nil` rather than blocking.
 
 ```ruby
 task :count do

data/lib/hammer/input.rb

@@ -3,18 +3,23 @@
 require 'json'
 
 class Hammer
-  # Stdin + JSON helpers for opts. Hammer always attaches piped stdin as
-  # `opts[:stdin]`; recipes opt into JSON body handling via
-  # `Hammer::Input.prepare_json!` (typically from a `before` hook) and/or
-  # `opt :json, type: :json` / `global_opt :json, type: :json`.
+  # Stdin + JSON helpers for opts. Hammer exposes piped stdin as
+  # `opts[:stdin]`, read lazily on first access; recipes opt into JSON body
+  # handling via `Hammer::Input.prepare_json!` (typically from a `before`
+  # hook) and/or `opt :json, type: :json` / `global_opt :json, type: :json`.
   module Input
     module_function
 
     # Read piped stdin once. Returns nil when stdin is a TTY or empty.
-    # Does not consume an interactive TTY.
+    # Does not consume an interactive TTY, and does not block on a socket
+    # that has nothing pending: agent harnesses (Claude Code's Bash tool)
+    # hand every command a unix socket as stdin that never reaches EOF, so
+    # a plain read would hang there for good. A shell pipe or a redirected
+    # file is a FIFO or a regular file and is still read in full.
     def read_stdin
       return nil if $stdin.closed?
       return nil if $stdin.tty?
+      return nil if idle_socket?($stdin)
 
       data = $stdin.read
       return nil if data.nil?
@@ -25,11 +30,26 @@ class Hammer
       nil
     end
 
-    # Idempotent: sets opts[:stdin] if not already present.
+    def idle_socket?(io)
+      return false unless io.respond_to?(:stat) && io.stat.socket?
+
+      IO.select([io], nil, nil, 0).nil?
+    rescue StandardError
+      false
+    end
+
+    # Reads stdin into the hash on the first `opts[:stdin]` lookup and keeps
+    # the result, so a command that never asks for stdin never waits on it.
+    LAZY_STDIN = lambda do |hash, key|
+      key == :stdin ? (hash[:stdin] = Input.read_stdin) : nil
+    end
+
+    # Idempotent: leaves an explicit opts[:stdin] alone, otherwise installs
+    # the lazy reader. Nothing is read until a recipe looks at opts[:stdin].
     def attach_stdin!(opts)
-      return opts[:stdin] if opts.key?(:stdin)
+      return if opts.key?(:stdin) || opts.default_proc.equal?(LAZY_STDIN)
 
-      opts[:stdin] = read_stdin
+      opts.default_proc = LAZY_STDIN
     end
 
     # Parse a JSON source string into a Hash/Array with symbol keys.

data/lib/lux-hammer.rb

@@ -690,8 +690,9 @@ class Hammer
       options = effective_options(cmd)
       positional, opts = Parser.new(options).parse(argv)
       opts[:args] = positional
-      # Always attach piped stdin (nil when TTY / empty). Recipes that want
-      # JSON body handling call Hammer::Input.prepare_json! in a before hook.
+      # opts[:stdin] reads piped stdin on first access (nil when TTY / empty).
+      # Recipes that want JSON body handling call Hammer::Input.prepare_json!
+      # in a before hook.
       Hammer::Input.attach_stdin!(opts)
       print_run_banner(cmd, full || cmd.name, positional, opts, options: options) unless quiet || ENV['HAMMER_QUIET']
       instance = new

data/recipes/llm.rb

@@ -9,7 +9,6 @@ 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
@@ -333,287 +332,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 / multi-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 - there a `*` at
-      the start of a line begins a new task and following lines belong to it,
-      so multi-line tasks and whole lists can be piped in at once.
-    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?
-        new_tasks = []
-        opts[:stdin].to_s.split("\n").each do |line|
-          if line =~ /^[-*]\s+(.*)$/
-            new_tasks << [$1.strip]
-          elsif new_tasks.any?
-            new_tasks.last << line.rstrip
-          elsif line.strip != ''
-            new_tasks << [line.rstrip]
-          end
-        end
-        new_tasks = new_tasks.map { |lines| lines.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.23
+  version: 0.3.25
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-19 00:00:00.000000000 Z
+date: 2026-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest