harnex 0.2.0

data/lib/harnex/commands/logs.rb

@@ -0,0 +1,184 @@
+require "optparse"
+
+module Harnex
+  class Logs
+    DEFAULT_LINES = 200
+    POLL_INTERVAL = 0.1
+    READ_CHUNK_SIZE = 4096
+
+    def self.usage(program_name = "harnex logs")
+      <<~TEXT
+        Usage: #{program_name} [options]
+
+        Options:
+          --id ID       Session ID to inspect (required)
+          --repo PATH   Resolve using PATH's repo root (default: current repo)
+          --cli CLI     Filter the active session by CLI
+          --follow      Keep streaming appended output until session exit
+          --lines N     Print the last N lines before following (default: #{DEFAULT_LINES})
+          -h, --help    Show this help
+      TEXT
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {
+        id: nil,
+        repo_path: Dir.pwd,
+        cli: nil,
+        follow: false,
+        lines: DEFAULT_LINES,
+        help: false
+      }
+    end
+
+    def run
+      parser.parse!(@argv)
+      if @options[:help]
+        puts self.class.usage
+        return 0
+      end
+
+      raise "--id is required for harnex logs" unless @options[:id]
+      raise OptionParser::InvalidArgument, "--lines must be >= 0" if @options[:lines].negative?
+
+      target = resolve_target
+      return 1 unless target
+
+      offset = print_snapshot(target.fetch(:path))
+      return 0 unless @options[:follow] && target[:live]
+
+      follow(target.fetch(:path), offset, target.fetch(:pid))
+      0
+    end
+
+    private
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: harnex logs [options]"
+        opts.on("--id ID", "Session ID to inspect") { |value| @options[:id] = Harnex.normalize_id(value) }
+        opts.on("--repo PATH", "Resolve using PATH's repo root") { |value| @options[:repo_path] = value }
+        opts.on("--cli CLI", "Filter the active session by CLI") { |value| @options[:cli] = value }
+        opts.on("--follow", "Keep streaming appended output until session exit") { @options[:follow] = true }
+        opts.on("--lines N", Integer, "Print the last N lines before following") { |value| @options[:lines] = value }
+        opts.on("-h", "--help", "Show help") { @options[:help] = true }
+      end
+    end
+
+    def resolve_target
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      session = Harnex.read_registry(repo_root, @options[:id], cli: @options[:cli])
+
+      if session
+        path = session["output_log_path"].to_s
+        path = Harnex.output_log_path(repo_root, @options[:id]) if path.empty?
+        return log_target(path, live: true, pid: session["pid"], repo_root: repo_root)
+      end
+
+      if cli_filter_mismatch?(repo_root)
+        warn("harnex logs: no active session found with id #{@options[:id].inspect} and cli #{@options[:cli].inspect}")
+        return nil
+      end
+
+      log_target(Harnex.output_log_path(repo_root, @options[:id]), live: false, pid: nil, repo_root: repo_root)
+    end
+
+    def cli_filter_mismatch?(repo_root)
+      return false unless @options[:cli]
+
+      session = Harnex.read_registry(repo_root, @options[:id])
+      return false unless session
+
+      Harnex.cli_key(Harnex.session_cli(session)) != Harnex.cli_key(@options[:cli])
+    end
+
+    def log_target(path, live:, pid:, repo_root:)
+      return { path: path, live: live, pid: pid, repo_root: repo_root } if File.file?(path)
+
+      if live
+        warn("harnex logs: transcript not found at #{path}")
+      else
+        warn("harnex logs: no session or transcript found with id #{@options[:id].inspect} for #{repo_root}")
+      end
+      nil
+    end
+
+    def print_snapshot(path)
+      data, offset = snapshot_data(path, @options[:lines])
+      $stdout.write(data)
+      $stdout.flush
+      offset
+    end
+
+    def snapshot_data(path, line_limit)
+      size = File.size?(path).to_i
+      return ["".b, size] if size.zero? || line_limit.zero?
+
+      offset = size
+      buffer = +"".b
+
+      File.open(path, "rb") do |file|
+        while offset.positive?
+          chunk_size = [READ_CHUNK_SIZE, offset].min
+          offset -= chunk_size
+          file.seek(offset)
+          chunk = file.read(chunk_size)
+          next if chunk.nil? || chunk.empty?
+
+          buffer = chunk.b + buffer
+          break if buffer.count("\n") >= line_limit
+        end
+      end
+
+      lines = buffer.lines
+      data =
+        if lines.length > line_limit
+          lines.last(line_limit).join
+        else
+          buffer
+        end
+      [data, size]
+    end
+
+    def follow(path, offset, pid)
+      current_offset = offset
+
+      loop do
+        current_offset = stream_growth(path, current_offset)
+        unless Harnex.alive_pid?(pid)
+          drain_growth(path, current_offset)
+          return
+        end
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    def drain_growth(path, offset)
+      current_offset = offset
+
+      loop do
+        next_offset = stream_growth(path, current_offset)
+        return next_offset if next_offset == current_offset
+
+        current_offset = next_offset
+      end
+    end
+
+    def stream_growth(path, offset)
+      size = File.size?(path).to_i
+      offset = size if offset > size
+      return offset if size == offset
+
+      File.open(path, "rb") do |file|
+        file.seek(offset)
+        while (chunk = file.read(READ_CHUNK_SIZE))
+          $stdout.write(chunk)
+        end
+      end
+      $stdout.flush
+      size
+    end
+  end
+end

data/lib/harnex/commands/pane.rb

@@ -0,0 +1,251 @@
+require "json"
+require "optparse"
+require "open3"
+require "time"
+
+module Harnex
+  class Pane
+    FOLLOW_INTERVAL = 1.0
+
+    def self.usage(program_name = "harnex pane")
+      <<~TEXT
+        Usage: #{program_name} [options]
+
+        Options:
+          --id ID       Session ID to inspect (required)
+          --repo PATH   Resolve using PATH's repo root (default: current repo)
+          --cli CLI     Filter the active session by CLI
+          --lines N     Capture the last N lines instead of the full pane
+          --follow      Refresh the pane snapshot every second until the session exits
+          --interval N  Refresh interval in seconds for --follow (default: #{FOLLOW_INTERVAL.to_i})
+          --json        Output JSON with capture metadata
+          -h, --help    Show this help
+      TEXT
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {
+        id: nil,
+        repo_path: Dir.pwd,
+        repo_explicit: false,
+        cli: nil,
+        lines: nil,
+        follow: false,
+        interval: FOLLOW_INTERVAL,
+        json: false,
+        help: false
+      }
+    end
+
+    def run
+      parser.parse!(@argv)
+      if @options[:help]
+        puts self.class.usage
+        return 0
+      end
+
+      raise "--id is required for harnex pane" unless @options[:id]
+      if @options[:lines] && @options[:lines] < 1
+        raise OptionParser::InvalidArgument, "--lines must be >= 1"
+      end
+
+      session = resolve_session
+      return 1 unless session
+
+      return 1 unless tmux_available?
+
+      target = resolve_tmux_target(session)
+      return 1 unless target
+      return 1 unless tmux_target_exists?(session, target)
+
+      if @options[:follow]
+        follow(session, target)
+      else
+        text = capture(target)
+        return 1 unless text
+
+        emit_output(session.fetch("id"), text)
+      end
+      0
+    end
+
+    private
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: harnex pane [options]"
+        opts.on("--id ID", "Session ID to inspect") { |value| @options[:id] = Harnex.normalize_id(value) }
+        opts.on("--repo PATH", "Resolve using PATH's repo root") do |value|
+          @options[:repo_path] = value
+          @options[:repo_explicit] = true
+        end
+        opts.on("--cli CLI", "Filter the active session by CLI") { |value| @options[:cli] = value }
+        opts.on("--lines N", Integer, "Capture the last N lines instead of the full pane") { |value| @options[:lines] = value }
+        opts.on("--follow", "Refresh the pane snapshot until the session exits") { @options[:follow] = true }
+        opts.on("--interval N", Float, "Refresh interval in seconds for --follow") { |value| @options[:interval] = value }
+        opts.on("--json", "Output JSON with capture metadata") { @options[:json] = true }
+        opts.on("-h", "--help", "Show help") { @options[:help] = true }
+      end
+    end
+
+    def resolve_session
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      session = Harnex.read_registry(repo_root, @options[:id], cli: @options[:cli])
+      return session if session
+
+      unless @options[:repo_explicit]
+        candidates = Harnex.active_sessions(nil, id: @options[:id], cli: @options[:cli])
+        return candidates.first if candidates.length == 1
+
+        if candidates.length > 1
+          repos = candidates.map { |candidate| candidate["repo_root"].to_s }.uniq.sort
+          warn("harnex pane: multiple active sessions found with id #{@options[:id].inspect}; use --repo to disambiguate: #{repos.join(', ')}")
+          return nil
+        end
+      end
+
+      if cli_filter_mismatch?(repo_root)
+        warn("harnex pane: no active session found with id #{@options[:id].inspect} and cli #{@options[:cli].inspect}")
+      else
+        warn("harnex pane: no active session found with id #{@options[:id].inspect} for #{repo_root}")
+      end
+      nil
+    end
+
+    def cli_filter_mismatch?(repo_root)
+      return false unless @options[:cli]
+
+      session = Harnex.read_registry(repo_root, @options[:id])
+      return false unless session
+
+      Harnex.cli_key(Harnex.session_cli(session)) != Harnex.cli_key(@options[:cli])
+    end
+
+    def resolve_tmux_target(session)
+      target = session["tmux_target"].to_s.strip
+      return target unless target.empty?
+
+      discovery = Harnex.tmux_pane_for_pid(session["pid"])
+      if discovery
+        persist_tmux_metadata(session, discovery)
+        return discovery.fetch(:target)
+      end
+
+      tmux_session = session["tmux_session"].to_s.strip
+      tmux_window = session["tmux_window"].to_s.strip
+      unless tmux_session.empty? || tmux_window.empty?
+        return "#{tmux_session}:#{tmux_window}"
+      end
+
+      warn("harnex pane: session #{session.fetch('id').inspect} is not tmux-backed or the tmux pane could not be located")
+      nil
+    end
+
+    def persist_tmux_metadata(session, discovery)
+      session["tmux_target"] = discovery.fetch(:target)
+      session["tmux_session"] = discovery.fetch(:session_name)
+      session["tmux_window"] = discovery.fetch(:window_name)
+
+      path = session["registry_path"].to_s
+      return if path.empty? || !File.exist?(path)
+
+      payload = JSON.parse(File.read(path))
+      payload["tmux_target"] = session["tmux_target"]
+      payload["tmux_session"] = session["tmux_session"]
+      payload["tmux_window"] = session["tmux_window"]
+      Harnex.write_registry(path, payload)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def tmux_available?
+      return true if system("tmux", "-V", out: File::NULL, err: File::NULL)
+
+      warn("harnex pane: tmux is not installed or not available in PATH")
+      false
+    rescue Errno::ENOENT
+      warn("harnex pane: tmux is not installed or not available in PATH")
+      false
+    end
+
+    def tmux_target_exists?(session, target)
+      return true if system("tmux", "has-session", "-t", target, out: File::NULL, err: File::NULL)
+
+      warn("harnex pane: session #{session.fetch('id').inspect} is not tmux-backed or the tmux target #{target.inspect} no longer exists")
+      false
+    rescue Errno::ENOENT
+      warn("harnex pane: tmux is not installed or not available in PATH")
+      false
+    end
+
+    def follow(session, target)
+      pid = session["pid"].to_i
+      last_text = nil
+
+      loop do
+        text = capture(target)
+        break unless text
+
+        if text != last_text
+          clear_screen
+          if @options[:json]
+            emit_output(session.fetch("id"), text)
+          else
+            $stdout.write(text)
+            $stdout.flush
+          end
+          last_text = text
+        end
+
+        break unless Harnex.alive_pid?(pid)
+
+        sleep @options[:interval]
+      end
+    end
+
+    def clear_screen
+      $stdout.write("\e[H\e[2J")
+      $stdout.flush
+    end
+
+    def capture(target)
+      stdout, stderr, status = capture_command(capture_command_args(target))
+      return stdout if status.success?
+
+      message = stderr.to_s.strip
+      message = "tmux capture-pane failed" if message.empty?
+      warn("harnex pane: #{message}")
+      nil
+    rescue Errno::ENOENT
+      warn("harnex pane: tmux is not installed or not available in PATH")
+      nil
+    end
+
+    def capture_command_args(target)
+      command = ["tmux", "capture-pane", "-t", target, "-p"]
+      command += ["-S", "-#{@options[:lines]}"] if @options[:lines]
+      command
+    end
+
+    def capture_command(command)
+      Open3.capture3(*command)
+    end
+
+    def emit_output(id, text)
+      if @options[:json]
+        puts JSON.generate({
+          ok: true,
+          id: id,
+          captured_at: Time.now.iso8601,
+          lines: @options[:lines],
+          text: text
+        })
+        return
+      end
+
+      $stdout.write(text)
+      $stdout.flush
+    end
+  end
+end

data/lib/harnex/commands/recipes.rb

@@ -0,0 +1,104 @@
+require "optparse"
+
+module Harnex
+  class Recipes
+    RECIPES_DIR = File.expand_path("../../../../recipes", __FILE__)
+
+    def self.usage
+      <<~TEXT
+        Usage: harnex recipes [list|show <name>]
+
+        Subcommands:
+          list          List available recipes (default)
+          show <name>   Print a recipe by name or number
+
+        Examples:
+          harnex recipes
+          harnex recipes list
+          harnex recipes show 01
+          harnex recipes show fire_and_watch
+      TEXT
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def run
+      subcommand = @argv.shift
+      case subcommand
+      when nil, "list"
+        list_recipes
+      when "show"
+        show_recipe(@argv.first)
+      when "-h", "--help"
+        puts self.class.usage
+        0
+      else
+        # Treat bare arg as show
+        show_recipe(subcommand)
+      end
+    end
+
+    private
+
+    def list_recipes
+      files = recipe_files
+      if files.empty?
+        puts "No recipes found."
+        return 0
+      end
+
+      puts "Recipes:\n\n"
+      files.each do |file|
+        name = File.basename(file, ".md")
+        title = extract_title(file)
+        puts "  #{name}  #{title}"
+      end
+      puts "\nRun `harnex recipes show <name>` to read one."
+      0
+    end
+
+    def show_recipe(query)
+      unless query
+        warn("harnex recipes show: recipe name required")
+        return 1
+      end
+
+      file = find_recipe(query)
+      unless file
+        warn("harnex recipes: no recipe matching #{query.inspect}")
+        warn("Run `harnex recipes list` to see available recipes.")
+        return 1
+      end
+
+      puts File.read(file)
+      0
+    end
+
+    def find_recipe(query)
+      files = recipe_files
+      # Exact basename match (with or without .md)
+      exact = files.find { |f| File.basename(f, ".md") == query }
+      return exact if exact
+
+      # Prefix match (e.g. "01" matches "01_fire_and_watch")
+      prefix = files.find { |f| File.basename(f, ".md").start_with?(query) }
+      return prefix if prefix
+
+      # Substring match (e.g. "fire" matches "01_fire_and_watch")
+      files.find { |f| File.basename(f, ".md").include?(query) }
+    end
+
+    def recipe_files
+      return [] unless Dir.exist?(RECIPES_DIR)
+
+      Dir.glob(File.join(RECIPES_DIR, "*.md")).sort
+    end
+
+    def extract_title(file)
+      first_line = File.foreach(file).first.to_s.strip
+      first_line.start_with?("#") ? first_line.sub(/^#+\s*/, "") : ""
+    end
+  end
+end