samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/tools/edit.rb

@@ -22,9 +22,25 @@ module Samagotchi
 
       def self.call(content, path:, start_line: nil, end_line: nil)
         path = ToolPath.normalize(path)
+        result = apply(content, path: path, start_line: start_line, end_line: end_line)
+        return result if result.is_a?(String)
+
+        updated, message = result
+        File.write(path, updated)
+        message
+      rescue => e
+        "Error: #{e.message}"
+      end
+
+      # The edit without the write: [updated, message] or "Error: …", with
+      # exactly the strings call returns. +read+ reads the file, so a dry run
+      # (EditPreview) can reuse a copy it already has; each mode keeps its own
+      # check order (exact: tags first; range: file not found first).
+      def self.apply(content, path:, start_line: nil, end_line: nil, read: ->(p) { File.read(p) })
+        path = ToolPath.normalize(path)
 
         if range_requested?(start_line, end_line)
-          return call_range_mode(content, path: path, start_line: start_line, end_line: end_line)
+          return apply_range_mode(content, path: path, start_line: start_line, end_line: end_line, read: read)
         end
 
         old_text = extract_tag(content, "old")
@@ -35,7 +51,7 @@ module Samagotchi
         return "Error: <old> block is empty" if old_text.empty?
         return "Error: file not found: #{path}" unless File.exist?(path)
 
-        source = File.read(path)
+        source = read.(path)
         count  = count_occurrences(source, old_text)
 
         return "Error: old text not found in #{path}" if count == 0
@@ -43,13 +59,12 @@ module Samagotchi
 
         idx     = source.index(old_text)
         updated = source[0, idx] + new_text + source[idx + old_text.length..]
-        File.write(path, updated)
-        "Edited #{path}: replaced #{old_text.bytesize} bytes with #{new_text.bytesize} bytes"
+        [updated, "Edited #{path}: replaced #{old_text.bytesize} bytes with #{new_text.bytesize} bytes"]
       rescue => e
         "Error: #{e.message}"
       end
 
-      def self.call_range_mode(content, path:, start_line:, end_line:)
+      def self.apply_range_mode(content, path:, start_line:, end_line:, read:)
         return "Error: file not found: #{path}" unless File.exist?(path)
 
         new_text = extract_tag(content, "new")
@@ -59,7 +74,7 @@ module Samagotchi
         return start_num if start_num.is_a?(String)
         return "Error: start_line must be provided for range edits" if start_num.nil?
 
-        source = File.read(path)
+        source = read.(path)
         lines = source.lines
         total_lines = lines.length
 
@@ -102,15 +117,14 @@ module Samagotchi
         # first suffix line isn't concatenated onto the last replacement line.
         normalized = (!new_text.empty? && !suffix.empty? && !new_text.end_with?("\n")) ? new_text + "\n" : new_text
         updated = prefix + normalized + suffix
-        File.write(path, updated)
 
         replaced_lines = (end_value - start_num) + 1
         new_line_count = new_text.lines.length
-        "Edited #{path}: replaced lines #{start_num}-#{end_value} (#{replaced_lines} lines) with #{new_line_count} lines#{clamp_note}"
+        [updated, "Edited #{path}: replaced lines #{start_num}-#{end_value} (#{replaced_lines} lines) with #{new_line_count} lines#{clamp_note}"]
       rescue => e
         "Error: #{e.message}"
       end
-      private_class_method :call_range_mode
+      private_class_method :apply_range_mode
 
       # Count non-overlapping literal occurrences of +needle+ in +haystack+.
       def self.count_occurrences(haystack, needle)

data/lib/samagotchi/tools/execute.rb

@@ -18,16 +18,22 @@ module Samagotchi
       TIMEOUT_SEC = 30
       STOP_GRACE_SEC = 1.0
       STOP_POLL_INTERVAL_SEC = 0.05
+      WAIT_SLICE_SEC = 0.2
+      NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
 
       def self.name        = NAME
 
-      def self.call(command, cwd: nil)
+      # @param cancelled [#call] true once the user stopped the turn: the
+      #   command is killed (or not started) and its output so far returned
+      def self.call(command, cwd: nil, cancelled: -> { false })
+        return NOT_RUN_ON_STOP if cancelled.call
+
         command = command.strip
         resolved_cwd = resolve_cwd(cwd)
         return "Error: cwd not found: #{resolved_cwd}" unless resolved_cwd
 
         timeout_sec = timeout_seconds
-        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd)
+        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled)
 
         stdout_block = output_block("stdout", stdout)
         stderr_block = output_block("stderr", stderr)
@@ -45,19 +51,29 @@ module Samagotchi
       rescue CommandTimedOut => e
         # Keep the "Error:" first line (callers classify on it) and return
         # whatever the command printed before it was killed.
-        parts = ["Error: command timed out after #{timeout_sec}s"]
-        parts << output_block("stdout", e.stdout)
-        parts << output_block("stderr", e.stderr)
-        parts.compact.join("\n")
+        stopped_result("Error: command timed out after #{timeout_sec}s", e)
+      rescue CommandCancelled => e
+        stopped_result("Error: command stopped by the user after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue => e
         "Error: #{e.message}"
       end
 
-      def self.run_command(command, timeout_sec:, cwd:)
+      def self.stopped_result(first_line, error)
+        parts = [first_line]
+        parts << output_block("stdout", error.stdout)
+        parts << output_block("stderr", error.stderr)
+        parts.compact.join("\n")
+      end
+      private_class_method :stopped_result
+
+      def self.run_command(command, timeout_sec:, cwd:, cancelled: -> { false })
         stdout_text = ""
         stderr_text = ""
         status = nil
         timed_out = false
+        was_cancelled = false
+        started = monotonic_time
+        deadline = started + timeout_sec
 
         Open3.popen3(command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
@@ -65,14 +81,24 @@ module Samagotchi
           stderr_reader = reader_thread_for(stderr)
 
           begin
-            if wait_thr.join(timeout_sec)
-              status = wait_thr.value
-            else
-              timed_out = true
-              terminate_process_tree(wait_thr.pid)
-              wait_thr.join
-              status = wait_thr.value
+            until wait_thr.join(WAIT_SLICE_SEC)
+              if cancelled.call
+                was_cancelled = true
+                break
+              elsif monotonic_time > deadline
+                timed_out = true
+                break
+              end
             end
+            terminate_process_tree(wait_thr.pid) if timed_out || was_cancelled
+            wait_thr.join
+            status = wait_thr.value
+          rescue Exception # rubocop:disable Lint/RescueException -- kill the child, then re-raise
+            # An Interrupt (or anything else) mid-wait: the child is in its own
+            # process group, so it never saw the SIGINT. Kill it, or the reads
+            # below block until it closes stdout.
+            terminate_process_tree(wait_thr.pid)
+            raise
           ensure
             # Read the buffered output before closing the pipes. For a process
             # that exits almost instantly (e.g. `echo hello`), the background
@@ -86,6 +112,7 @@ module Samagotchi
         end
 
         raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
+        raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
 
         [stdout_text, stderr_text, status]
       end
@@ -209,6 +236,17 @@ module Samagotchi
           super("command timed out")
         end
       end
+
+      class CommandCancelled < StandardError
+        attr_reader :stdout, :stderr, :elapsed
+
+        def initialize(stdout, stderr, elapsed)
+          @stdout = stdout
+          @stderr = stderr
+          @elapsed = elapsed
+          super("command stopped by the user")
+        end
+      end
     end
   end
 end

data/lib/samagotchi/tools/task_runtime.rb

@@ -94,6 +94,25 @@ module Samagotchi
         end.compact.sort_by { |record| record["created_at"].to_s }.reverse
       end
 
+      # The tasks this conversation's task_create calls started that are
+      # still running. Only task_create results count: records are shared by
+      # every session in the worker's cwd, and task_list shows them all.
+      # A native tool_response joins its calls' results with "---".
+      # @return [Array<Hash>] {id:, command:}, oldest first
+      def running_created_in(messages)
+        ids = Array(messages).flat_map do |message|
+          next [] unless (message[:role] || message["role"]).to_s == "tool_response"
+
+          (message[:content] || message["content"]).to_s.split("\n\n---\n\n").filter_map do |block|
+            block[/\A\[task_create\]\ntask_id: (\S+)/, 1]
+          end
+        end
+        ids.uniq.filter_map do |id|
+          record, _error = get_record(id)
+          { id: id, command: record["command"].to_s } if record&.fetch("status") == "running"
+        end
+      end
+
       def get_record(task_id)
         record = load_record(task_id)
         return [nil, "Error: task not found: #{task_id}"] unless record

data/lib/samagotchi/tools/task_wait.rb

@@ -14,7 +14,10 @@ module Samagotchi
 
       def self.name = NAME
 
-      def self.call(task_id, timeout: TIMEOUT_DEFAULT, tail_lines: TAIL_LINES_DEFAULT, done_pattern: nil)
+      # @param cancelled [#call] true once the user stopped the turn: the
+      #   wait returns then, and the task keeps running
+      def self.call(task_id, timeout: TIMEOUT_DEFAULT, tail_lines: TAIL_LINES_DEFAULT, done_pattern: nil,
+                    cancelled: -> { false })
         timeout = TIMEOUT_DEFAULT if blank?(timeout)
         tail_lines = TAIL_LINES_DEFAULT if blank?(tail_lines)
         timeout = timeout.to_i
@@ -27,7 +30,8 @@ module Samagotchi
         return completion_pattern if completion_pattern.is_a?(String)
 
         task_id = task_id.to_s.strip
-        deadline = monotonic_time + timeout
+        started = monotonic_time
+        deadline = started + timeout
 
         loop do
           record, error = TaskRuntime.get_record(task_id)
@@ -41,6 +45,8 @@ module Samagotchi
             return format_response(record, wait_result: "pattern_matched", output_tail: output_tail) if completion_pattern.match?(output_tail)
           end
 
+          return cancelled_response(task_id, tail_lines, started) if cancelled.call
+
           break if monotonic_time > deadline
           sleep(POLL_INTERVAL)
         end
@@ -55,7 +61,24 @@ module Samagotchi
         "Error: #{e.message}"
       end
 
-      def self.format_response(record, wait_result: nil, output_tail: nil)
+      # The task may have finished between the poll and the Stop: then the
+      # normal finished result. Only a task still running says so.
+      def self.cancelled_response(task_id, tail_lines, started)
+        record, error = TaskRuntime.get_record(task_id)
+        return "Error: #{error}" if error
+        return format_response(record) unless record.fetch("status") == "running"
+
+        output_tail = TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+        note = [
+          "note: the user stopped the turn while waiting; the task is STILL RUNNING.",
+          "  To keep waiting: task_wait #{task_id}. If it is stuck or no longer needed: task_stop #{task_id}.",
+          "waited: #{(monotonic_time - started).round}s"
+        ]
+        format_response(record, wait_result: "canceled", output_tail: output_tail, extra: note)
+      end
+      private_class_method :cancelled_response
+
+      def self.format_response(record, wait_result: nil, output_tail: nil, extra: [])
         lines = [
           "task_id: #{record.fetch("id")}",
           "status: #{record.fetch("status")}",
@@ -66,6 +89,7 @@ module Samagotchi
         return lines.join("\n") unless wait_result
 
         lines << "wait_result: #{wait_result}"
+        lines.concat(extra)
         lines << "output_tail:"
         lines << output_tail.rstrip unless output_tail.empty?
         lines.join("\n")

data/lib/samagotchi/tools/write.rb

@@ -14,6 +14,10 @@ module Samagotchi
       def self.name        = NAME
 
       def self.call(content, path:)
+        # A native call without content/text arrives as nil; check before
+        # touching the file, or File.write(path, nil) would empty it.
+        return "Error: missing content" unless content.is_a?(String)
+
         path = ToolPath.normalize(path)
         FileUtils.mkdir_p(File.dirname(path))
         File.write(path, content)

data/lib/samagotchi/turn_flow.rb

@@ -143,9 +143,19 @@ module Samagotchi
       @checkpoint = nil
     end
 
-    # A reminder turn ran. The checkpoint stays only for a pending offer.
+    # A reminder turn is about to run: a pending continue offer goes, as for
+    # a new prompt (the partial turn stays), so a later "no" can't roll the
+    # reminder's exchange back with it.
+    # @return [Boolean] whether an offer was pending
+    def before_reminder_turn
+      offered = awaiting_continue?
+      @offer = nil
+      offered
+    end
+
+    # A reminder turn ran: the rollback window closes.
     def after_reminder_turn
-      @checkpoint = nil unless awaiting_continue?
+      @checkpoint = nil
     end
 
     private

data/lib/samagotchi/turn_note.rb

@@ -13,6 +13,10 @@ module Samagotchi
     KIND = "turn_note"
     OPEN = "[SYSTEM: "
     CLOSE = "]"
+    FAILED = "the previous turn failed before any answer: "
+    RESTORED = "The message went back to the user, who may send it again."
+    TASKS_LISTED = 5
+    TASK_COMMAND_CHARS = 60
 
     module_function
 
@@ -21,28 +25,48 @@ module Samagotchi
     #   failed user message is not in the conversation any more)
     # @param continued [Boolean] it was a continue turn (no user message)
     def failed(summary, restored: false, continued: false)
-      tail = if restored then "The message went back to the user, who may send it again."
+      tail = if restored then RESTORED
              elsif continued then "The continued turn stopped there."
              else "The user's last message was not answered."
              end
-      message("the previous turn failed before any answer: #{one_line(summary)}. #{tail}")
+      message("#{FAILED}#{one_line(summary)}. #{tail}")
     end
 
     # @param reason [Symbol, String, nil] the cancel reason (:ctrl_c, :user…)
     # @param seconds [Numeric, nil] how long the turn had run
     # @param shown [Boolean] visible text had streamed (an `[interrupted]`
     #   model message precedes this note)
-    def cancelled(reason, seconds: nil, shown: false)
+    # @param running_tasks [Array<Hash>] {id:, command:} of this session's
+    #   background tasks still running: a Stop doesn't end them
+    def cancelled(reason, seconds: nil, shown: false, running_tasks: [])
       why = reason.to_s.empty? ? "" : " (#{reason.to_s.tr("_", "-")})"
       after = seconds ? " after #{seconds.round}s" : ""
       what = shown ? "the answer above ends where it was cut off." : "no answer had been shown."
-      message("the previous turn was cancelled#{why}#{after}; #{what}")
+      message("the previous turn was cancelled#{why}#{after}; #{what}#{still_running(running_tasks)}")
+    end
+
+    def still_running(tasks)
+      return "" if tasks.empty?
+
+      listed = tasks.first(TASKS_LISTED).map do |task|
+        command = one_line(task[:command])
+        command = "#{command[0, TASK_COMMAND_CHARS - 1]}…" if command.length > TASK_COMMAND_CHARS
+        "task #{task[:id]} (#{command})"
+      end
+      listed << "#{tasks.size - TASKS_LISTED} more (task_list)" if tasks.size > TASKS_LISTED
+      " Still running: #{listed.join(", ")}. Continue with task_wait <id> or stop with task_stop <id>."
     end
 
     def empty
       message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
     end
 
+    # The hidden nudge before a retry of an empty answer (EmptyAnswerRetry):
+    # the model never sees its empty generation, so it is told what happened.
+    def empty_retry
+      message("your last reply had no visible answer. Answer the user's last message now, briefly.")
+    end
+
     def note?(entry)
       return false unless entry.respond_to?(:[])
 
@@ -56,11 +80,41 @@ module Samagotchi
     # +messages+ plus +note+, in place of a note already at the tail (behind
     # context notes at most): failed retries leave one note, not a pile.
     def replace_trailing(messages, note)
+      without_trailing(messages) << note
+    end
+
+    # A copy of +messages+ without the note at its tail (behind context
+    # notes at most).
+    def without_trailing(messages)
       list = Array(messages).dup
+      index = trailing_index(list)
+      list.delete_at(index) if index
+      list
+    end
+
+    # The index of the note at the tail of +list+ (behind context notes at
+    # most), or nil.
+    def trailing_index(list)
       index = list.length - 1
       index -= 1 while index >= 0 && (list[index][:role] || list[index]["role"]).to_s == "system" && !note?(list[index])
-      list.delete_at(index) if index >= 0 && note?(list[index])
-      list << note
+      index >= 0 && note?(list[index]) ? index : nil
+    end
+
+    # The failure summary of the note at the tail of +messages+ (behind
+    # context notes at most) when it says a failed turn's prompt went back
+    # to the user, else nil: the prompt is not in the conversation any more
+    # (the session's last_prompt holds it), so a UI shows it from here.
+    def restored_failure(messages)
+      list = Array(messages)
+      index = trailing_index(list)
+      return nil unless index
+
+      text = (list[index][:content] || list[index]["content"]).to_s
+      prefix = "#{OPEN}#{FAILED}"
+      suffix = ". #{RESTORED}#{CLOSE}"
+      return nil unless text.start_with?(prefix) && text.end_with?(suffix)
+
+      text[prefix.length...-suffix.length]
     end
 
     # The last message is a reply cut short (`[interrupted]`).