letsdo 0.1.0 → 0.2.0

data/lib/letsdo/output_streamer.rb

@@ -1,45 +1,12 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 
 module Letsdo
-  # Routes pi output across two streams:
-  #   stdout — only the agent's answer text (text_delta), no service lines;
-  #   stderr — service lines: tool calls (name, arguments, result) as
-  #            execution progress.
-  #
-  # Every action line gets a shared HH:MM:SS time prefix: the difference
-  # between prefixes shows how long ago an action happened and how long
-  # a tool ran. Format of service tool lines:
-  #   HH:MM:SS ⚙ name: arguments    — tool call on one line (for bash the
-  #                                   command text, for read/write/edit the
-  #                                   path, etc.);
-  #   indented "  " lines           — execution result (stdout/stderr),
-  #                                   no time prefix (data, not actions);
-  #   HH:MM:SS ✓ name: done (Xs)    — tool completion (success), printed
-  #                                   after the result block;
-  #   HH:MM:SS ✖ name: error (Xs)   — tool completion (error);
-  #   ✖ Error: ...                  — error result marked explicitly;
-  #   … [output truncated: N lines, M] — big output → summary note.
-  # Remembers the last response character so that on finish a final newline
-  # is guaranteed — output must not break in the middle.
+  # Routes pi output: agent text on stdout, tool lines on stderr (or a log).
   class OutputStreamer
-    # Max lines of a tool result in service output.
-    MAX_RESULT_LINES = 100
-    # Max characters of a tool result in service output.
-    MAX_RESULT_CHARS = 4_000
-    # Max characters of a short call-arguments representation.
     MAX_ARGS_CHARS = 300
 
-    # @param stdout [IO] stream for the agent's answer text
-    # @param stderr [IO] stream for service lines
-    # @param log [Object, nil] an alternate log target (TUI mode): when
-    #        given, ALL output — answer text and service tool lines — is
-    #        written there as one combined stream (a
-    #        Letsdo::Tui::LogBuffer); without it the plain stdout/stderr
-    #        split is byte-identical to before
-    # @param clock [Proc] callable → Time, the source of time for prefixes
-    #        (injected in tests for deterministic HH:MM:SS)
     def initialize(stdout: $stdout, stderr: $stderr, log: nil, clock: nil)
       @stdout = stdout
       @stderr = stderr
@@ -49,9 +16,6 @@ module Letsdo
       @action_started_at = nil
     end
 
-    # Prints a chunk of the agent's answer text immediately.
-    #
-    # @param delta [String] the next text fragment
     def text_delta(delta)
       return if delta.nil? || delta.empty?
 
@@ -60,51 +24,18 @@ module Letsdo
       @last_char = delta[-1]
     end
 
-    # A service line about a tool call: HH:MM:SS time prefix, tool name and
-    # short arguments (e.g. the executed bash command text). One line without
-    # empty placeholders, to stderr so it does not mix with the agent text
-    # on stdout. The call moment is remembered — the action duration in the
-    # completion line is measured from it.
-    #
-    # @param name [String] tool name
-    # @param args [Hash, String, nil] call arguments (pi event)
     def tool_start(name, args: nil)
       @action_started_at = @clock.call
       line = +"#{timestamp} ⚙ #{name}"
-      summary = summarize_args(name, args)
+      summary = ArgSummary.call(name, args)
       line << ": #{summary}" if summary
       write_service("#{line}\n")
     end
 
-    # Service lines of the tool result (command/file output): an indented
-    # block without a time prefix (action data) plus a completion line with
-    # the HH:MM:SS prefix, name, verdict and duration. Very large output is
-    # trimmed neatly with a summary note, errors are marked explicitly.
-    # An empty result yields only the completion line.
-    #
-    # @param name [String] tool name
-    # @param text [String] result text
-    # @param error [Boolean] whether the execution failed
-    def tool_result(name, text, error: false)
-      out = String.new
-      unless text.nil? || text.empty?
-        lines = text.lines
-        kept, truncated = truncate_result(text)
-        kept.each_with_index do |line, index|
-          line = line.chomp
-          next if line.empty? && index == kept.length - 1 # no trailing empty line
-
-          prefix = index.zero? ? (error ? "  ✖ Error: " : "  ") : "  "
-          out << "#{prefix}#{line}\n"
-        end
-        out << result_note(lines) if truncated
-      end
-      out << completion_line(name, error)
-      write_service(out)
+    def tool_result(name, error: false)
+      write_service(completion_line(name, error))
     end
 
-    # Finishes the output: if the answer did not end with a newline — adds
-    # one so the next terminal output does not stick to the agent's answer.
     def finish
       return unless @last_char && @last_char != "\n"
 
@@ -114,156 +45,28 @@ module Letsdo
 
     private
 
-    # Shared time prefix for all action lines: HH:MM:SS.
-    #
-    # @return [String] local time as hours:minutes:seconds
     def timestamp
-      @clock.call.strftime("%H:%M:%S")
+      @clock.call.strftime('%H:%M:%S')
     end
 
-    # Tool completion line: time prefix, verdict, name and action duration
-    # (seconds between call and completion). The duration is not printed
-    # when no action start was recorded (e.g. a result without a preceding
-    # call).
-    #
-    # @param name [String] tool name
-    # @param error [Boolean] whether the execution failed
-    # @return [String] completion line with a trailing newline
     def completion_line(name, error)
-      mark = error ? "✖" : "✓"
-      verdict = error ? "error" : "done"
+      mark = error ? '✖' : '✓'
+      verdict = error ? 'error' : 'done'
       elapsed = elapsed_seconds
-      duration = elapsed ? " (#{format_elapsed(elapsed)})" : ""
+      duration = elapsed ? " (#{format_elapsed(elapsed)})" : ''
       "#{timestamp} #{mark} #{name}: #{verdict}#{duration}\n"
     end
 
-    # Seconds from the current action start to its completion.
-    #
-    # @return [Float, nil] duration, or nil if there was no start
     def elapsed_seconds
       return nil unless @action_started_at
 
       @clock.call - @action_started_at
     end
 
-    # A neat duration: seconds with one decimal place up to 10s, whole
-    # seconds after.
     def format_elapsed(seconds)
-      seconds < 10 ? format("%.1fs", seconds) : "#{seconds.round}s"
-    end
-
-    # Truncates the result text by line and character limits.
-    #
-    # @param text [String] the whole result text
-    # @return [Array(Array<String>, Boolean)] kept lines and truncation flag
-    def truncate_result(text)
-      lines = text.lines
-      kept = []
-      chars = 0
-      truncated = false
-      lines.each do |line|
-        if kept.length >= MAX_RESULT_LINES || (!kept.empty? && chars + line.length > MAX_RESULT_CHARS)
-          truncated = true
-          break
-        end
-        kept << line
-        chars += line.length
-      end
-      # A single line longer than the char limit — cut the line itself.
-      if kept.first && kept.first.length > MAX_RESULT_CHARS
-        kept[0] = kept[0].slice(0, MAX_RESULT_CHARS)
-        truncated = true
-      end
-      [kept, truncated]
-    end
-
-    # Summary note about the truncated result.
-    def result_note(lines)
-      total_lines = lines.length
-      total_chars = lines.sum(&:length)
-      lines_word = plural(total_lines, "line", "lines")
-      chars_word = plural(total_chars, "character", "characters")
-      "  … [output truncated: #{total_lines} #{lines_word}, #{total_chars} #{chars_word}]\n"
-    end
-
-    # English singular/plural for a noun after a number.
-    def plural(count, singular, plural_form)
-      count == 1 ? singular : plural_form
-    end
-
-    # Short one-line representation of the tool call arguments.
-    #
-    # @param name [String] tool name
-    # @param args [Hash, String, nil] call arguments
-    # @return [String, nil] arguments string or nil (print nothing)
-    def summarize_args(name, args)
-      case name
-      when "bash", "powershell"
-        one_line(args_value(args, "command"))
-      when "read"
-        path = args_value(args, "path") || args_value(args, "file_path")
-        return nil unless path
-
-        range = read_range(args)
-        "#{path}#{range}"
-      when "write", "edit", "find", "ls"
-        args_value(args, "path") || args_value(args, "file_path")
-      when "grep"
-        pattern = one_line(args_value(args, "pattern"))
-        path = args_value(args, "path") || args_value(args, "file_path")
-        return nil unless pattern
-
-        path ? "#{pattern} #{path}" : pattern
-      else
-        summarize_generic(args)
-      end
+      seconds < 10 ? format('%.1fs', seconds) : "#{seconds.round}s"
     end
 
-    # Read line range (offset/limit) as ":N-M", when given.
-    def read_range(args)
-      return nil unless args.is_a?(Hash)
-
-      offset = args["offset"]
-      return nil unless offset
-
-      limit = args["limit"]
-      limit ? ":#{offset}-#{offset + limit - 1}" : ":#{offset}"
-    end
-
-    # Tool argument value as a string; nil when absent.
-    def args_value(args, key)
-      return nil unless args.is_a?(Hash)
-
-      value = args[key]
-      value.nil? ? nil : value.to_s
-    end
-
-    # Universal arguments representation (other tools): short JSON on one line.
-    def summarize_generic(args)
-      return nil if args.nil? || (args.is_a?(Hash) && args.empty?)
-
-      text =
-        case args
-        when String then args
-        when Hash then JSON.generate(args)
-        else args.to_s
-        end
-      one_line(text)
-    end
-
-    # Collapses whitespace into a single line and cuts by the limit.
-    def one_line(value, max: MAX_ARGS_CHARS)
-      return nil if value.nil?
-
-      text = value.to_s.gsub(/\s+/, " ").strip
-      return nil if text.empty?
-
-      text.length > max ? "#{text.slice(0, max)}…" : text
-    end
-
-    # Writes a service line to stderr and flushes immediately so output
-    # appears as it is produced; in TUI mode the line goes to the shared
-    # log buffer instead.
     def write_service(text)
       if @log
         @log.write(text)
@@ -273,10 +76,10 @@ module Letsdo
       end
     end
 
-    # Where the agent's answer text goes: the shared log in TUI mode,
-    # stdout otherwise.
     def text_sink
       @log || @stdout
     end
   end
-end
+end
+
+require_relative 'output_streamer/arg_summary'

data/lib/letsdo/pi_runner/events.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Letsdo
+  # Pi JSON event-stream handlers used by PiRunner.
+  module PiRunnerEvents
+    private
+
+    def read_pi_stream(out_r)
+      out_r.each_line { |line| handle_line(line) }
+      debug('stream: EOF')
+    end
+
+    def handle_line(line)
+      line = line.strip
+      return if line.empty?
+
+      event = parse_event(line)
+      dispatch_event(event) if event
+    end
+
+    def dispatch_event(event)
+      case event['type']
+      when 'message_update' then handle_message_update(event)
+      when 'tool_execution_start' then handle_tool_start(event)
+      when 'tool_execution_end' then handle_tool_execution_end(event)
+      when 'agent_end' then flush_pending_tools
+      end
+    end
+
+    def handle_tool_start(event)
+      @pending_tools.delete(event['toolCallId'])
+      @streamer.tool_start(event['toolName'] || 'tool', args: event['args'])
+    end
+
+    def handle_message_update(event)
+      payload = event['assistantMessageEvent']
+      return unless payload
+
+      handle_text_delta(payload) || remember_toolcall(event, payload)
+    end
+
+    def handle_text_delta(payload)
+      return unless payload['type'] == 'text_delta'
+
+      delta = payload['delta']
+      @streamer.text_delta(delta) if delta && !delta.empty?
+      true
+    end
+
+    def remember_toolcall(event, payload)
+      return unless payload['type'] == 'toolcall_start'
+
+      id = event['id'] || payload['id']
+      name = event['toolName'] || payload['toolName'] || 'tool'
+      @pending_tools[id] = name unless id.nil?
+    end
+
+    def handle_tool_execution_end(event)
+      name = event['toolName'] || 'tool'
+      error = event['isError'] == true
+      @streamer.tool_result(name, error: error)
+    end
+
+    def flush_pending_tools
+      @pending_tools.each_value { |name| @streamer.tool_start(name) }
+      @pending_tools.clear
+    end
+
+    def parse_event(line)
+      JSON.parse(line)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/letsdo/pi_runner/process.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Letsdo
+  # Process-group control for a running pi child.
+  module PiRunnerProcess
+    def terminate(signal: 'TERM', grace: 3.0, tick: 0.05)
+      pid = @pid
+      return true unless pid
+
+      send_signal('CONT', pid)
+      send_signal(signal, pid)
+      wait_for_exit(pid, grace, tick)
+    end
+
+    private
+
+    def wait_for_exit(pid, grace, tick)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + grace
+      loop do
+        status = wait_status(pid, nonblock: true)
+        return status if status
+        break unless alive?(pid)
+        return kill_and_reap(pid, tick) if overdue_deadline?(deadline)
+
+        sleep(tick)
+      end
+      true
+    end
+
+    def overdue_deadline?(deadline)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+    end
+
+    def kill_and_reap(pid, tick)
+      send_signal('KILL', pid)
+      sleep(tick)
+      wait_status(pid, nonblock: true) || true
+    end
+
+    def wait_status(pid, nonblock: false)
+      _, status = Process.wait2(pid, nonblock ? Process::WNOHANG : 0)
+      @reaped_status = status if status
+      status
+    rescue Errno::ECHILD
+      @reaped_status
+    end
+
+    def send_signal(signal, pid)
+      Process.kill(signal, -pid)
+    rescue Errno::ESRCH, Errno::EPERM
+      nil
+    end
+
+    def alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    def exit_code(status)
+      return 1 if status.nil?
+      return status.exitstatus if status.exitstatus
+
+      status.termsig ? 128 + status.termsig : 1
+    end
+  end
+end