samagotchi 0.16.0 → 0.18.0

data/lib/samagotchi/memory_bundle/trash.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../memory_paths"
+
+module Samagotchi
+  module MemoryBundle
+    # Where a bundle operation puts the memory files it takes away
+    # (uninstall, an upgrade's dropped file): moved, never deleted, into
+    # <system memories>/.bundles/.trash/<bundle>-<YYYYmmdd-HHMMSS>/, one dir
+    # per operation (-2, -3… when one already has that name). A dot dir, so
+    # Provenance.each_installed never reads it as a bundle.
+    #
+    # `chi bundle trash` lists and empties the trash.
+    class Trash
+      # A single trash entry (one directory in the trash).
+      Entry = Data.define(:name, :path, :time, :files, :bytes)
+
+      def self.root(bundles_dir: MemoryPaths.bundles_dir)
+        File.join(bundles_dir, ".trash")
+      end
+
+      # Returns an array of {Entry} for every real directory directly inside
+      # the trash, oldest first.  A missing or empty trash gives [].
+      #
+      # +now+ is the reference time (default: Time.now); used only when a
+      # directory name has no timestamp (mtime fallback).
+      def self.entries(bundles_dir: MemoryPaths.bundles_dir, now: Time.now)
+        trash_dir = root(bundles_dir: bundles_dir)
+        return [] unless Dir.exist?(trash_dir)
+
+        Dir.children(trash_dir)
+          .select { |c| real_dir?(File.join(trash_dir, c)) }
+          .map { |name| entry_for(trash_dir, name, now) }
+          .sort_by(&:time)
+      end
+
+      # Deletes every entry that matches the filter, returning the entries
+      # that were (or would be) deleted.
+      #
+      # +older_than_days+ nil = all; a positive integer keeps newer dirs.
+      # +dry_run+ true = only return what would be deleted.
+      # +now+ reference time (default: Time.now).
+      def self.empty!(bundles_dir: MemoryPaths.bundles_dir, older_than_days: nil, now: Time.now, dry_run: false)
+        entries = self.entries(bundles_dir: bundles_dir, now: now)
+        if older_than_days
+          cutoff = now - older_than_days.to_i * 86_400
+          entries = entries.select { |e| e.time < cutoff }
+        end
+        return entries if dry_run
+
+        entries.each do |e|
+          FileUtils.rm_rf(e.path)
+        end
+        entries
+      end
+
+      # The dir, once a file was moved (nil before).
+      attr_reader :dir
+
+      def initialize(name, now: Time.now, bundles_dir: MemoryPaths.bundles_dir)
+        @name = name.to_s
+        @now = now
+        @bundles_dir = bundles_dir
+        @dir = nil
+      end
+
+      # Moves +path+ into the trash dir (created on the first call).
+      # @return [String] the file's new path
+      def move(path)
+        dest = File.join(ensure_dir, File.basename(path))
+        FileUtils.mv(path, dest)
+        dest
+      end
+
+      private
+
+      def ensure_dir
+        return @dir if @dir
+
+        base = File.join(self.class.root(bundles_dir: @bundles_dir), "#{@name}-#{@now.strftime("%Y%m%d-%H%M%S")}")
+        FileUtils.mkdir_p(File.dirname(base))
+        candidate = base
+        n = 1
+        loop do
+          Dir.mkdir(candidate)
+          break
+        rescue Errno::EEXIST
+          n += 1
+          candidate = "#{base}-#{n}"
+        end
+        @dir = candidate
+      end
+
+      # Class methods below.
+
+      def self.real_dir?(path)
+        File.directory?(path) && !File.symlink?(path)
+      end
+
+      def self.entry_for(trash_dir, name, now)
+        path = File.join(trash_dir, name)
+        time = parse_timestamp(name) || File.mtime(path)
+        files, bytes = count_files(path)
+        Entry.new(name: name, path: path, time: time, files: files, bytes: bytes)
+      end
+
+      # Extracts a Time from "bundle-YYYYmmdd-HHMMSS" or "bundle-YYYYmmdd-HHMMSS-2".
+      # Returns nil if the pattern doesn't match.
+      TIMESTAMP_RE = /\A.*?-(\d{8})-(\d{6})(?:-\d+)?\z/
+
+      def self.parse_timestamp(name)
+        m = name.match(TIMESTAMP_RE)
+        return nil unless m
+
+        begin
+          Time.strptime("#{m[1]}-#{m[2]}", "%Y%m%d-%H%M%S")
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      # Recursively counts files and sums their sizes.
+      def self.count_files(dir)
+        files = 0
+        bytes = 0
+        Dir.glob(File.join(dir, "**", "*"), File::FNM_DOTMATCH).each do |f|
+          next if File.directory?(f)
+          files += 1
+          bytes += File.size(f) rescue 0
+        end
+        [files, bytes]
+      end
+    end
+  end
+end

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -5,13 +5,17 @@ require_relative "../memory_paths"
 require_relative "provenance"
 require_relative "index_updater"
 require_relative "merger"
+require_relative "trash"
 
 module Samagotchi
   module MemoryBundle
     class Uninstaller
       class UninstallError < StandardError; end
 
-      attr_reader :warnings, :removed_files
+      # removed_files: the bundle's own hooks/ and plugin/ files (deleted);
+      # trashed_files: its memory files, moved to trash_dir (Trash), nil
+      # when none was moved.
+      attr_reader :warnings, :removed_files, :trashed_files
 
       def initialize(name:, scope: nil, force: false)
         @name = name
@@ -19,8 +23,12 @@ module Samagotchi
         @force = force
         @warnings = []
         @removed_files = []
+        @trashed_files = []
+        @trash = Trash.new(name)
       end
 
+      def trash_dir = @trash.dir
+
       def run
         provenance = Provenance.new(name: @name)
         data = provenance.read
@@ -40,12 +48,18 @@ module Samagotchi
           return true
         end
 
+        # A file another installed bundle lists too stays, edited or not.
+        shared = files.keys.map(&:to_s).to_h do |key|
+          [key, Provenance.claimants(key, scope: target_scope, except: @name)]
+        end.reject { |_, others| others.empty? }
+
         blocked = []
         files.each do |file_key, meta|
           file_key_str = file_key.to_s
           target_path = File.join(target_dir, file_key_str)
           base_path = provenance.base_path(file_key_str)
           next unless File.exist?(target_path)
+          next if shared.key?(file_key_str)
           if !@force && File.exist?(base_path) && Merger.current_modified?(base_path, target_path)
             blocked << file_key_str
             @warnings << "Skipped #{file_key_str}: local edits detected (use --force to remove)"
@@ -57,15 +71,23 @@ module Samagotchi
         files.each do |file_key, _meta|
           file_key_str = file_key.to_s
           target_path = File.join(target_dir, file_key_str)
+          if (others = shared[file_key_str])
+            next unless File.exist?(target_path)
+
+            @warnings << "Kept #{file_key_str}: bundle #{others.join(", ")} has it too"
+            retag(target_scope, target_path, file_key_str, others.first)
+            next
+          end
           if File.exist?(target_path)
-            FileUtils.rm_f(target_path)
-            @removed_files << file_key_str
+            @trash.move(target_path)
+            @trashed_files << file_key_str
           end
-          # Remove index line
+          # Remove index line (not fatal: a warning says so)
           begin
             IndexUpdater.remove_index(target_scope, file_key_str.delete_suffix(".md"))
             IndexUpdater.remove_index(target_scope, file_key_str) # legacy "name.md" line
-          rescue => _e
+          rescue StandardError => e
+            @warnings << "index.md: line for #{file_key_str.delete_suffix(".md")} not removed (#{e.message})"
           end
         end
 
@@ -97,6 +119,13 @@ module Samagotchi
 
       private
 
+      # A kept shared file's index line names the bundle that still has it.
+      def retag(scope, path, file_key, bundle)
+        IndexUpdater.update_index(scope, file_key.delete_suffix(".md"), File.size(path), source: bundle)
+      rescue StandardError => e
+        @warnings << "index.md: line for #{file_key.delete_suffix(".md")} not updated (#{e.message})"
+      end
+
       def resolve_target_dir(scope)
         MemoryPaths.scope_dir(scope) or raise UninstallError, "invalid scope: #{scope}"
       end

data/lib/samagotchi/parent_report.rb

@@ -31,8 +31,10 @@ module Samagotchi
     module_function
 
     # @param result [ReplyWait::Result]
-    # @return [String] answered, question, failed, canceled, no_answer,
-    #   error, worker_gone, stopped or running
+    # @return [String] answered, question, failed, canceled, limit (the
+    #   turn ran out of iterations, nobody asked), not_continued (a Stop
+    #   answered the step-limit question), no_answer, error, worker_gone,
+    #   stopped or running
     def status(result)
       case result.status
       when :done then "answered"
@@ -41,6 +43,8 @@ module Samagotchi
         case result.outcome
         when "failed" then "failed"
         when "canceled" then "canceled"
+        when "exhausted" then "limit"
+        when "not_continued" then "not_continued"
         else "no_answer"
         end
       when :error then "error"
@@ -52,11 +56,12 @@ module Samagotchi
       end
     end
 
-    # @return [Integer] 0 answered, 3 a question waits, 4 still running,
-    #   1 anything else
+    # @return [Integer] 0 answered (or not continued: the Stop asked for
+    #   was carried out), 3 a question waits, 4 still running, 1 anything
+    #   else
     def exit_status(result)
       case status(result)
-      when "answered" then CLI::Exit::OK
+      when "answered", "not_continued" then CLI::Exit::OK
       when "question" then CLI::Exit::QUESTION
       when "running" then CLI::Exit::RUNNING
       else CLI::Exit::FAILED
@@ -116,7 +121,8 @@ module Samagotchi
 
     # A pending question (Session#pending_question) as a parent sees it.
     # kind is "question" for the model's own (the desk stores none),
-    # "hook" or "approval".
+    # "hook", "approval" or "continue" (the step-limit question, with the
+    # turn's limit).
     # @return [Hash]
     def question(pending)
       pending ||= {}
@@ -129,15 +135,18 @@ module Samagotchi
         options: Array(pending[:options]).map(&:to_s),
         multi_select: !!pending[:multi_select],
         allow_freeform: !!pending[:allow_freeform],
+        limit: pending[:limit],
         approval: approval&.slice(*APPROVAL_KEYS)
       }.compact
     end
 
     # The command that answers +question+; N is the parent's to fill in.
     # An approval's is a deny: allowing it is the user's
-    # (Guardrails::ParentApprovals).
+    # (Guardrails::ParentApprovals). A step-limit question's continues the
+    # turn (its Stop form is in #question_text).
     def answer_with(session_id, question)
       return "chi answer #{session_id} --question #{question[:id]} --option Deny --text WHY" if approval?(question)
+      return "chi answer #{session_id} --question #{question[:id]} --option Continue" if continue?(question)
 
       "chi answer #{session_id} --question #{question[:id]} --option N"
     end
@@ -156,6 +165,16 @@ module Samagotchi
       question.is_a?(Hash) && (question[:kind] || question["kind"]).to_s == "approval"
     end
 
+    # The step-limit question (ContinueOffer).
+    def continue?(question)
+      question.is_a?(Hash) && (question[:kind] || question["kind"]).to_s == "continue"
+    end
+
+    # What a message does to a step-limit question.
+    def message_drops(session_id)
+      "a message instead (chi send #{session_id} -m …) drops it and starts a new turn"
+    end
+
     # What a wait that ended without an answer says, one line.
     def detail(result, session_id:, timeout: nil)
       attach = "chi --attach #{session_id}"
@@ -163,10 +182,13 @@ module Samagotchi
       when :waiting_for_answer
         if approval?(result.question)
           "waiting for an approval: #{first_line(result.question[:question])}; #{DENY_AND_TELL}"
+        elsif continue?(result.question)
+          "waiting at the step limit: #{first_line(result.question[:question])}; " \
+            "answer Continue or Stop: chi answer #{session_id} --question #{result.question[:id]} --option Continue"
         else
           "waiting for an answer: #{first_line(result.question&.dig(:question))}; open it: #{attach} or the web"
         end
-      when :no_reply then "#{no_reply_line(result)}; #{attach} shows it"
+      when :no_reply then "#{no_reply_line(result, session_id)}; #{attach} shows it"
       when :error then "the worker failed: #{result.text}; #{attach} shows what happened"
       when :worker_gone then "the worker is gone; #{attach} shows what happened"
       when :stopped then "the session was stopped (chi sessions stop)"
@@ -188,6 +210,10 @@ module Samagotchi
         lines << "  allowing it is up to your user: #{DENY_AND_TELL}"
         lines << "  deny: #{answer_with(session_id, q)}"
         lines << "  #{leave_open(session_id)}"
+      elsif continue?(q)
+        lines << "  continue: #{answer_with(session_id, q)}"
+        lines << "  stop: chi answer #{session_id} --question #{q[:id]} --option Stop --text WHY (the text is optional; the model reads it)"
+        lines << "  #{message_drops(session_id)}"
       else
         lines << "  more than one allowed: repeat --option" if q[:multi_select]
         lines << "  free text allowed: --text" if q[:allow_freeform]
@@ -197,11 +223,15 @@ module Samagotchi
       lines.map { |line| "#{line}\n" }.join
     end
 
-    def no_reply_line(result)
+    def no_reply_line(result, session_id = nil)
       case result.outcome
       when "failed" then result.text.to_s.strip.empty? ? "the turn failed" : "the turn failed: #{result.text.strip}"
       when "canceled" then "the turn was canceled"
       when "completed" then "the turn ended with no visible answer"
+      when "not_continued" then "the turn was not continued (Stop); its work so far stays"
+      when "exhausted"
+        "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered; " \
+          "chi send #{session_id} -m '/continue yes' continues it, a message drops it"
       else "the turn ended without a reply (canceled, failed or empty)"
       end
     end

data/lib/samagotchi/plugin/context.rb

@@ -18,11 +18,14 @@ module Samagotchi
     # (chat messages, timeout:, max_tokens:, cancel_controller:) and returns
     # the answer text.
     # +messages_partial+ says whether +messages+ leaves out a running turn;
-    # +model_name+ and +state_dir+ are what ctx.sessions forks with.
+    # +model_name+ (the session's resolved model ref, live after /model) and
+    # +state_dir+ are what ctx.sessions forks with; +model_key+ is the
+    # model's memory overlay key (ctx.model, ctx.model_key).
     # +steer+ takes (text, label), +stop_turn+ and +stop_generation+
     # (reason, label), each true when it acted on a running turn.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
-                      :ask_model, :model_name, :state_dir, :scratch, :steer, :stop_turn, :stop_generation, keyword_init: true)
+                      :ask_model, :model_name, :model_key, :state_dir, :scratch, :steer, :stop_turn, :stop_generation,
+                      keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -86,6 +89,15 @@ module Samagotchi
       # @return [String, nil] the session's id (nil before the first one)
       def session_id = @host.session_id.call
 
+      # @return [String, nil] the model the session runs on now: its
+      #   resolved ref ("host:id"), right after /model too
+      def model = @host.model_name&.call
+
+      # @return [String, nil] the model's memory overlay key
+      #   (`<name>.<key>.md`, ModelOverlay.key_for), as memory_write
+      #   current_model_only names it
+      def model_key = @host.model_key&.call
+
       # @return [String] the session's working directory
       def cwd = @host.cwd.call || Dir.pwd