samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/answer_display.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "log"
+
+module Samagotchi
+  # How a turn's answer is shown, apart from what the model said: an
+  # after_turn hook (or a plugin's on(:after_turn)) calls event[:present]
+  # with a block that gets the current display text and returns the new
+  # one. The result is kept as `display` on the answer's model message in
+  # session.json; the web renders it instead of `content`. It is display
+  # only: nothing that talks to a model reads it (the payload builders take
+  # the fields they send, and the copies handed to hooks, plugins and the
+  # recap leave it out, see .strip).
+  #
+  # The target is the stored conversation's last message when it is the
+  # model's answer; a turn that ended any other way (cancelled, failed,
+  # empty: a turn note is last) has none and event[:present] does nothing.
+  class AnswerDisplay
+    KEY = :display
+    # A display text longer than this is refused (the display stays as it
+    # was): a hook must not bloat session.json or the page.
+    MAX_CHARS = 200_000
+
+    # A message as a model-facing reader may see it: without `display`.
+    # The same object when it has none.
+    def self.strip(message)
+      return message unless message.is_a?(Hash) && (message.key?(KEY) || message.key?(KEY.to_s))
+
+      message.reject { |key, _| key.to_s == KEY.to_s }
+    end
+
+    def self.strip_all(messages)
+      Array(messages).map { |message| strip(message) }
+    end
+
+    # @return [Hash, nil] the message event[:present] changes
+    attr_reader :target
+    # @return [String, nil] the display text so far
+    attr_reader :text
+
+    # @param messages [Array<Hash>] the conversation the turn stored
+    def initialize(messages)
+      last = Array(messages).last
+      @target = last if last.is_a?(Hash) && field(last, :role).to_s == "model"
+      @original = @target && (field(@target, KEY) || field(@target, :content)).to_s
+      @text = @original
+    end
+
+    # True when a hook set a display text other than what was shown before.
+    def changed?
+      !@target.nil? && @text != @original
+    end
+
+    # event[:present]: call it with a block; the block gets the current
+    # display text (the answer's content until a hook changed it) and
+    # returns the new one. A block that raises, returns something other than
+    # a String, or returns more than MAX_CHARS leaves the text unchanged
+    # (logged, named by event[:hook]).
+    # @param event [Hash] the after_turn event (for its :hook label)
+    # @return [Proc] returns the display text after the call, or nil when
+    #   the turn has no answer to present
+    def presenter(event)
+      lambda do |&block|
+        next nil unless @target
+        next @text unless block
+
+        apply(block, event[:hook])
+      end
+    end
+
+    private
+
+    def apply(block, hook)
+      value = begin
+        block.call(@text.dup)
+      rescue StandardError => e
+        return reject(hook, "raised #{e.class}: #{e.message}")
+      end
+      return reject(hook, "returned #{value.class}, not a String") unless value.is_a?(String)
+      return reject(hook, "returned #{value.length} characters (max #{MAX_CHARS})") if value.length > MAX_CHARS
+
+      @text = value.dup
+    end
+
+    def reject(hook, why)
+      Log.warn(:hooks, "present_rejected", echo: "[samagotchi:hooks] #{hook}: present #{why}; display unchanged",
+                                           hook: hook.to_s)
+      @text
+    end
+
+    def field(message, key)
+      message.key?(key) ? message[key] : message[key.to_s]
+    end
+  end
+end

data/lib/samagotchi/archive_store.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "time"
+
+require_relative "session"
+
+module Samagotchi
+  # A session's archive marker, <session dir>/archived (JSON):
+  #   {"archived_at": t}    archived: hidden from every list, kept by the
+  #                         retention sweep, not counted in its max_count
+  #   {"unarchived_at": t}  archived once, then unarchived: the sweep ages
+  #                         the session from max(updated_at, unarchived_at)
+  # A separate file, not a session.json field: Session#save rewrites that
+  # file from memory (and bumps updated_at) at every turn.
+  module ArchiveStore
+    FILE = "archived"
+    # Input a human typed: a web tab, a chi TUI, `chi send`, and nil (a
+    # worker's initial prompt; a web client may send none). Delegates,
+    # plugins and reminders are not (an allowlist, so a new automatic
+    # origin stays out).
+    USER_CLIENT_PREFIXES = %w[web: tui:].freeze
+    USER_CLIENT_IDS = ["cli:send"].freeze
+
+    # @return [Hash, nil] the marker (string keys), nil when none or unreadable
+    def self.read(session_dir)
+      data = JSON.parse(File.read(File.join(session_dir, FILE)))
+      data.is_a?(Hash) ? data : nil
+    rescue StandardError
+      nil
+    end
+
+    def self.archived?(session_dir)
+      read(session_dir)&.key?("archived_at") == true
+    end
+
+    # @return [Time, nil] when the session was last unarchived
+    def self.unarchived_at(session_dir)
+      value = read(session_dir)&.fetch("unarchived_at", nil)
+      value && Time.iso8601(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+
+    # @return [Boolean] whether the marker was written (false: the session
+    #   file is gone, so its dir is never recreated)
+    def self.archive(session_id, state_dir:)
+      write(session_id, { "archived_at" => Time.now.iso8601(3) }, state_dir: state_dir)
+    end
+
+    # @return [Boolean] whether it was archived (and is not now)
+    def self.unarchive(session_id, state_dir:)
+      return false unless archived?(Session.session_dir(session_id, state_dir: state_dir))
+
+      write(session_id, { "unarchived_at" => Time.now.iso8601(3) }, state_dir: state_dir)
+    end
+
+    # Whether +client_id+ (a turn's origin) is a human's input.
+    def self.user_input?(client_id)
+      return true if client_id.nil?
+
+      id = client_id.to_s
+      USER_CLIENT_IDS.include?(id) || USER_CLIENT_PREFIXES.any? { |prefix| id.start_with?(prefix) }
+    end
+
+    # A human's input came into the session: it is back in the lists. Its
+    # children stay archived. Never raises.
+    # @return [Boolean] whether it was archived
+    def self.user_input(session_id, state_dir:)
+      return false if session_id.nil?
+
+      unarchive(session_id, state_dir: state_dir)
+    rescue StandardError
+      false
+    end
+
+    def self.write(session_id, record, state_dir:)
+      return false unless File.exist?(File.join(state_dir, "#{session_id}#{Session::FILE_EXT}"))
+
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      path = File.join(dir, FILE)
+      File.write("#{path}.tmp", JSON.generate(record))
+      File.rename("#{path}.tmp", path)
+      true
+    end
+    private_class_method :write
+  end
+end

data/lib/samagotchi/bootstrap/config_writer.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "fileutils"
+require "ipaddr"
+require_relative "../config"
+
+module Samagotchi
+  module Bootstrap
+    # Writes the host `chi bootstrap` found into config.yml. With no file it
+    # writes a small commented one; an existing file is the edge case and
+    # gets a hosts: entry inserted as text (YAML.dump would drop the user's
+    # comments), after a backup, and is checked by parsing it again: every
+    # other key must be unchanged, or the backup goes back.
+    class ConfigWriter
+      Error = Class.new(StandardError)
+
+      # kind: :new (a fresh file), :appended, :exists (the host is already
+      #   there as +existing+; nothing written), :snippet (a file chi can't
+      #   edit safely: paste +text+ yourself), :failed (written, but the check
+      #   failed and the backup is back), :dry_run (+text+ is what would be
+      #   written or inserted, +where+ says where)
+      # model_hint: a line for the user to add when default: exists without model
+      Outcome = Data.define(:kind, :path, :backup, :text, :where, :name, :existing, :default_model, :model_hint) do
+        def self.of(kind, path:, backup: nil, text: nil, where: nil, name: nil, existing: nil, default_model: nil,
+                    model_hint: nil)
+          new(kind: kind, path: path, backup: backup, text: text, where: where, name: name, existing: existing,
+              default_model: default_model, model_hint: model_hint)
+        end
+      end
+
+      HOSTS_LINE_RE = /\Ahosts:[ \t]*(#.*)?\z/
+      DEFAULT_INDENT = 2
+      SERVER_TRANSPORTS = ConfigFile::VALID_TRANSPORTS_FOR_CONFIG
+
+      # The host part of a name: localhost/127.x → local, another IP → lan,
+      # a domain → its second-level label (api.openai.com → openai).
+      def self.derived_name(host)
+        text = host.to_s.downcase.delete_prefix("[").delete_suffix("]")
+        address = begin
+          IPAddr.new(text)
+        rescue IPAddr::InvalidAddressError, IPAddr::AddressFamilyError
+          nil
+        end
+        return "local" if text == "localhost" || address&.loopback?
+        return "lan" if address
+
+        labels = text.split(".").reject(&:empty?)
+        name = (labels.length >= 2 ? labels[-2] : labels.first).to_s.gsub(/[^a-z0-9._-]/, "-")
+        name.match?(ConfigFile::HOST_NAME_RE) ? name : "host"
+      end
+
+      attr_reader :path
+
+      # @param path [String] config.yml (a symlink is written through)
+      # @param env [Hash] the environment for the check (SAMAGOTCHI_HOSTS_JSON
+      #   is dropped: it would replace the file's hosts)
+      # @param now [Proc] the time for the backup's name and the header
+      def initialize(path:, env: ENV, now: -> { Time.now })
+        @path = path
+        @env = env.to_h.except("SAMAGOTCHI_HOSTS_JSON")
+        @now = now
+      end
+
+      def exists? = File.file?(@path)
+
+      # The file's data: {} for an empty file, nil when there is none or it
+      # doesn't parse.
+      def data
+        return @data if defined?(@data)
+
+        @data = exists? ? (parse(File.read(@path)) || {}) : nil
+      rescue StandardError
+        @data = nil
+      end
+
+      # The hosts entries the file routes to today, name → fields: its
+      # hosts:, or with none the `default` chi makes from server.*.
+      def current_hosts
+        raw = data.is_a?(Hash) ? data["hosts"] : nil
+        return raw.to_h { |name, fields| [name.to_s.downcase, fields.is_a?(Hash) ? fields : {}] } if raw.is_a?(Hash)
+        return {} if data.is_a?(Hash) && data.key?("hosts")
+
+        { "default" => server_entry }
+      end
+
+      # The name of an existing entry that points at the same server, or nil.
+      def duplicate_of(fields)
+        current_hosts.find { |_, existing| same_server?(existing, fields) }&.first
+      end
+
+      # The entry's name: +requested+ as given (it must be free), else
+      # +base+, with -2, -3… when the name is taken or is the prefix of a
+      # model id (chi would read "openai/gpt-x" as host openai, model gpt-x).
+      def host_name(base, requested: nil, model_ids: [])
+        taken = current_hosts.keys
+        if requested
+          name = requested.to_s.strip
+          raise Error, "--name must match #{ConfigFile::HOST_NAME_RE.source}" unless name.match?(ConfigFile::HOST_NAME_RE)
+          raise Error, "config.yml already has a host named '#{name}'; pick another --name" if taken.include?(name.downcase)
+
+          return name
+        end
+
+        prefixes = [*model_ids, configured_default_model].compact.map { |id| id.to_s.split(%r{[:/]}, 2).first.downcase }
+        name = base
+        n = 1
+        name = "#{base}-#{n += 1}" while taken.include?(name) || prefixes.include?(name)
+        name
+      end
+
+      # Write the entry. @param fields [Hash] the hosts entry (string keys,
+      # in the order written) @param model [String] the model id
+      # @return [Outcome]
+      def write(name:, fields:, model:, dry_run: false)
+        default_model = "#{name}:#{model}"
+        return write_new(name, fields, default_model, dry_run) unless exists?
+
+        existing = duplicate_of(fields)
+        return Outcome.of(:exists, path: @path, name: name, existing: existing) if existing
+
+        append(name, fields, default_model, dry_run)
+      end
+
+      private
+
+      def write_new(name, fields, default_model, dry_run)
+        text = <<~YAML
+          # Written by chi bootstrap on #{@now.call.strftime("%Y-%m-%d")}; see docs/configuration.md
+          default:
+            model: #{scalar(default_model)}
+          hosts:
+          #{entry_lines(name, fields, DEFAULT_INDENT, DEFAULT_INDENT).join}# More settings: docs/configuration.md#all-settings
+        YAML
+        return Outcome.of(:dry_run, path: @path, text: text, where: "a new file", name: name, default_model: default_model) if dry_run
+
+        FileUtils.mkdir_p(File.dirname(@path))
+        atomic_write(@path, text)
+        Outcome.of(:new, path: @path, name: name, default_model: default_model)
+      end
+
+      def append(name, fields, default_model, dry_run)
+        original = File.binread(@path).force_encoding(Encoding::UTF_8)
+        return snippet(name, fields) unless data.is_a?(Hash) && !anchors?(original)
+
+        eol = original.include?("\r\n") ? "\r\n" : "\n"
+        lines = original.split(/(?<=\n)/)
+        lines[-1] = "#{lines[-1]}#{eol}" if lines.any? && !lines[-1].end_with?("\n")
+        hosts_at = lines.index { |line| line.chomp.match?(HOSTS_LINE_RE) }
+        return snippet(name, fields) if hosts_at.nil? && data.key?("hosts")
+
+        default_entry = hosts_at || !routed? ? nil : server_entry
+        add_model, model_hint = default_model_change(default_model)
+
+        if hosts_at
+          at, child, step = block_end(lines, hosts_at)
+          inserted = entry_lines(name, fields, child, step)
+          where = "in hosts:, after line #{at}"
+          lines.insert(at, *inserted.map { |line| line.sub(/\n\z/, eol) })
+        else
+          inserted = ["hosts:\n", *(default_entry ? entry_lines("default", default_entry, DEFAULT_INDENT, DEFAULT_INDENT) : []),
+                      *entry_lines(name, fields, DEFAULT_INDENT, DEFAULT_INDENT)]
+          where = "a new hosts: section at the end"
+          lines.concat(inserted.map { |line| line.sub(/\n\z/, eol) })
+        end
+        if add_model
+          model_lines = ["default:\n", "  model: #{scalar(default_model)}\n"]
+          inserted += model_lines
+          lines.concat(model_lines.map { |line| line.sub(/\n\z/, eol) })
+        end
+        text = lines.join
+        if dry_run
+          return Outcome.of(:dry_run, path: @path, text: inserted.join, where: where, name: name,
+                                      default_model: add_model ? default_model : nil, model_hint: model_hint)
+        end
+
+        real = File.realpath(@path)
+        backup = backup_path(real)
+        FileUtils.cp(real, backup, preserve: true)
+        atomic_write(real, text)
+        expected = expected_data(name, fields, default_entry, add_model ? default_model : nil)
+        unless written_ok?(real, expected, name)
+          atomic_write(real, File.binread(backup))
+          return Outcome.of(:failed, path: @path, backup: backup, text: snippet_text(name, fields), name: name)
+        end
+
+        Outcome.of(:appended, path: @path, backup: backup, name: name, default_model: add_model ? default_model : nil,
+                              model_hint: model_hint)
+      end
+
+      # Where a new entry goes in the hosts: block starting at +hosts_at+:
+      # its end (the first entry is the default host, so never first),
+      # before trailing blank lines and comments shallower than an entry.
+      # @return [index, entry indent, field indent step]
+      def block_end(lines, hosts_at)
+        stop = hosts_at + 1
+        stop += 1 while stop < lines.length && inside_block?(lines[stop])
+        children = lines[(hosts_at + 1)...stop].reject { |line| blank_or_comment?(line) }
+        child = children.first ? indent(children.first) : DEFAULT_INDENT
+        field = children.find { |line| indent(line) > child }
+        step = field ? indent(field) - child : child
+        at = stop
+        at -= 1 while at > hosts_at + 1 && (lines[at - 1].strip.empty? || (comment?(lines[at - 1]) && indent(lines[at - 1]) < child))
+        [at, child, step]
+      end
+
+      def inside_block?(line)
+        return true if line.strip.empty?
+        return false if line.start_with?("---", "...")
+
+        line.start_with?(" ", "\t") || comment?(line)
+      end
+
+      def blank_or_comment?(line) = line.strip.empty? || comment?(line)
+      def comment?(line) = line.lstrip.start_with?("#")
+      def indent(line) = line[/\A */].length
+
+      def entry_lines(name, fields, child, step)
+        ["#{" " * child}#{name}:\n", *fields.map { |key, value| "#{" " * (child + step)}#{key}: #{scalar(value)}\n" }]
+      end
+
+      # Strings double-quoted (JSON's quoting is valid YAML): model ids hold
+      # "/" and ":".
+      def scalar(value) = value.is_a?(Integer) ? value.to_s : JSON.generate(value.to_s)
+
+      def snippet(name, fields)
+        Outcome.of(:snippet, path: @path, text: snippet_text(name, fields), name: name)
+      end
+
+      def snippet_text(name, fields) = "hosts:\n#{entry_lines(name, fields, DEFAULT_INDENT, DEFAULT_INDENT).join}"
+
+      # [add default.model?, a line to print instead]
+      def default_model_change(default_model)
+        return [false, nil] if configured_default_model
+        return [false, "  model: #{scalar(default_model)}   # under default:"] if data.key?("default")
+
+        [true, nil]
+      end
+
+      def configured_default_model
+        return nil unless data.is_a?(Hash)
+
+        section = data["default"]
+        value = section.is_a?(Hash) ? section["model"] : nil
+        value ||= data[ConfigFile::DEFAULT_MODEL_KEY]
+        value.to_s.strip.empty? ? nil : value.to_s.strip
+      end
+
+      # Whether bare model names go somewhere today: a default.model or a
+      # server: section. Then a new hosts: block keeps that route as `default`.
+      def routed?
+        configured_default_model || data.key?("server") || data.keys.any? { |key| key.to_s.start_with?("SAMAGOTCHI_SERVER_") }
+      end
+
+      # The `default` hosts entry chi derives from server.* when the file has
+      # no hosts:, written out so a new hosts: block doesn't reroute bare models.
+      def server_entry
+        file = data.is_a?(Hash) ? data : {}
+        host = Config.resolve("server.host", file_data: file, env: {}, cli_overrides: {}).to_s.strip
+        port = Config.resolve("server.port", file_data: file, env: {}, cli_overrides: {}).to_i
+        transport = Config.resolve("server.transport", file_data: file, env: {}, cli_overrides: {}).to_s.strip.downcase
+        entry = { "host" => host.empty? ? "localhost" : host, "port" => port.positive? ? port : 8080 }
+        entry["transport"] = transport if SERVER_TRANSPORTS.include?(transport) && transport != "llama_cpp"
+        entry
+      end
+
+      def same_server?(existing, fields)
+        a = location(existing)
+        b = location(fields)
+        a && b && a == b
+      end
+
+      # [scheme-less host, port, path] of an entry.
+      def location(fields)
+        url = fields["url"].to_s.strip
+        unless url.empty?
+          uri = URI.parse(url)
+          return [uri.host.to_s.downcase, uri.port, uri.path.to_s.chomp("/")]
+        end
+        host = fields["host"].to_s.strip.downcase
+        return nil if host.empty?
+
+        port = fields["port"].to_s.strip.empty? ? 8080 : fields["port"].to_i
+        [host, port, fields["api"].to_s == "openai" ? "/v1" : ""]
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def expected_data(name, fields, default_entry, default_model)
+        expected = Marshal.load(Marshal.dump(data))
+        hosts = expected["hosts"].is_a?(Hash) ? expected["hosts"] : {}
+        hosts["default"] = default_entry if default_entry
+        hosts[name] = fields
+        expected["hosts"] = hosts
+        expected["default"] = { "model" => default_model } if default_model
+        expected
+      end
+
+      def written_ok?(real, expected, name)
+        parse(File.read(real)) == expected &&
+          ConfigFile.hosts_config(env: @env, path: real).key?(name.downcase)
+      rescue StandardError
+        false
+      end
+
+      def parse(text) = YAML.safe_load(text, permitted_classes: [], aliases: false)
+
+      # Anchors and aliases: chi's reader refuses aliases, and an insert
+      # can't know what an anchor shares.
+      def anchors?(text)
+        stack = [Psych.parse_stream(text)]
+        until stack.empty?
+          node = stack.pop
+          return true if node.is_a?(Psych::Nodes::Alias) || (node.respond_to?(:anchor) && node.anchor)
+
+          stack.concat(Array(node.children)) if node.respond_to?(:children)
+        end
+        false
+      rescue Psych::Exception
+        true
+      end
+
+      def backup_path(real)
+        stamp = @now.call.utc.strftime("%Y%m%dT%H%M%SZ")
+        candidate = "#{real}.bak-#{stamp}"
+        n = 1
+        candidate = "#{real}.bak-#{stamp}-#{n += 1}" while File.exist?(candidate)
+        candidate
+      end
+
+      def atomic_write(target, text)
+        tmp = "#{target}.tmp-#{Process.pid}"
+        File.binwrite(tmp, text)
+        File.chmod(File.stat(target).mode & 0o7777, tmp) if File.exist?(target)
+        File.rename(tmp, target)
+      ensure
+        FileUtils.rm_f(tmp) if tmp && File.exist?(tmp)
+      end
+    end
+  end
+end