letsdo 0.4.0 → 0.5.0

data/lib/letsdo/pi_runner/events.rb

@@ -1,75 +0,0 @@
-# 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

@@ -1,68 +0,0 @@
-# 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

data/lib/letsdo/pi_runner.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Letsdo
-  # Runs pi in --mode json and hands events to the output streamer.
-  class PiRunner
-    COMMAND = 'pi'
-    MODE = 'json'
-    MESSAGE_UPDATE = 'message_update'
-    TOOL_EXECUTION_START = 'tool_execution_start'
-    TOOL_EXECUTION_END = 'tool_execution_end'
-    AGENT_END = 'agent_end'
-  end
-end
-
-require_relative 'pi_runner/events'
-require_relative 'pi_runner/process'
-
-module Letsdo
-  # Pi process spawn, stream drain, and pause/resume signals.
-  class PiRunner
-    include PiRunnerEvents
-    include PiRunnerProcess
-
-    def initialize(prompt:, streamer:, **opts)
-      @prompt = prompt
-      @streamer = streamer
-      @flags = opts.fetch(:flags, [])
-      @command = opts.fetch(:command, COMMAND)
-      @pending_tools = {}
-      @reaped_status = nil
-      @debug = opts[:debug].nil? ? (opts[:config] || Config.new).debug? : opts[:debug]
-    end
-
-    def run
-      out_r = spawn_pi
-      drain_stream(out_r)
-      finish_run
-    ensure
-      @pid = nil
-      @reaped_status = nil
-    end
-
-    def debug(message)
-      warn("[letsdo] pi: #{message}") if @debug
-    end
-
-    def terminate_now
-      pid = @pid
-      send_signal('TERM', pid) if pid
-    end
-
-    def pause
-      pid = @pid
-      send_signal('STOP', pid) if pid
-    end
-
-    def resume
-      pid = @pid
-      send_signal('CONT', pid) if pid
-    end
-
-    private
-
-    def spawn_pi
-      cmd = [@command, '--mode', MODE, *@flags, @prompt]
-      out_r, out_w = IO.pipe
-      @pid = Process.spawn(*cmd, out: out_w, err: $stderr, pgroup: true)
-      out_w.close
-      debug("spawned pid=#{@pid} (own group)")
-      out_r
-    end
-
-    def drain_stream(out_r)
-      read_pi_stream(out_r)
-    rescue Letsdo::Stopped
-      debug('stopped by signal, terminating pi')
-      terminate
-      wait_status(@pid)
-      @streamer.finish
-      raise
-    ensure
-      close_pipe(out_r)
-      flush_pending_tools
-    end
-
-    def close_pipe(out_r)
-      out_r.close
-    rescue IOError
-      nil
-    end
-
-    def finish_run
-      status = wait_status(@pid)
-      @streamer.finish
-      debug("exit status=#{status.inspect} code=#{exit_code(status)}")
-      exit_code(status)
-    end
-  end
-end