samagotchi 0.52.0 → 0.54.0

data/lib/samagotchi/guardrail_wiring.rb

@@ -151,26 +151,26 @@ module Samagotchi
     def bundle_rules
       require_relative "memory_bundle/provenance"
       rules = []
-      MemoryBundle::Provenance.each_installed(holding: :guardrails) do |bundle_name, data|
-        if data[:error]
-          Log.warn(:guardrails, "bundle_rules_invalid", echo: "[samagotchi:guardrails] bundle #{bundle_name}: #{data[:error]}", bundle: bundle_name)
-          @failures.add("rules (bundle #{bundle_name})", data[:error], required: true, group: :rules)
+      MemoryBundle::Provenance.each_installed(holding: :guardrails) do |bundle_name, bundle|
+        if bundle.error?
+          Log.warn(:guardrails, "bundle_rules_invalid", echo: "[samagotchi:guardrails] bundle #{bundle_name}: #{bundle.error}", bundle: bundle_name)
+          @failures.add("rules (bundle #{bundle_name})", bundle.error, required: true, group: :rules)
           next
         end
-        if (too_new = MemoryBundle::Manifest.requires_chi_failure(data[:requires_chi], Samagotchi::VERSION))
-          rules.concat(too_new_bundle_rules(bundle_name, data, too_new))
+        if (too_new = MemoryBundle::Manifest.requires_chi_failure(bundle.requires_chi, Samagotchi::VERSION))
+          rules.concat(too_new_bundle_rules(bundle_name, bundle, too_new))
           next
         end
         dir = MemoryBundle::Provenance.new(name: bundle_name).guardrails_dir
         loaded = []
         whole = true
-        data[:guardrails].sort_by { |k, _| k.to_s }.each do |basename, meta|
+        bundle.guardrails.sort.each do |basename, sha|
           what = "rules #{basename} (bundle #{bundle_name})"
-          path = File.join(dir, basename.to_s)
+          path = File.join(dir, basename)
           begin
             raise Guardrails::Rules::ParseError, "the file is missing" unless File.file?(path)
 
-            unless MemoryBundle::Provenance.sha_matches?(path, meta.is_a?(Hash) ? meta[:sha256] : nil)
+            unless MemoryBundle::Provenance.sha_matches?(path, sha)
               raise Guardrails::Rules::ParseError, "its sha256 differs from the installed one (edited after install? reinstall the bundle)"
             end
 
@@ -256,7 +256,7 @@ module Samagotchi
     # load the new ones). Never loaded (a chi older than the bundle it
     # starts with): none, and a required load failure, as the hook loader
     # does for a guardrail hook, so the calls aren't quietly unguarded.
-    def too_new_bundle_rules(bundle_name, data, reason)
+    def too_new_bundle_rules(bundle_name, bundle, reason)
       kept = @loaded_bundle_rules[bundle_name]
       unless kept
         Log.warn(:guardrails, "bundle_rules_requires_chi", echo: "[samagotchi:guardrails] bundle #{bundle_name}: its rules are not loaded: #{reason}",
@@ -266,19 +266,19 @@ module Samagotchi
         return []
       end
 
-      key = [bundle_name, data[:version].to_s]
+      key = [bundle_name, bundle.version.to_s]
       return kept if @kept_noticed[key]
 
       @kept_noticed[key] = true
-      Log.warn(:guardrails, "bundle_rules_kept", bundle: bundle_name, version: data[:version].to_s,
-                                                 requires_chi: data[:requires_chi].to_s)
-      @notify.call(kept_notice(bundle_name, data))
+      Log.warn(:guardrails, "bundle_rules_kept", bundle: bundle_name, version: bundle.version.to_s,
+                                                 requires_chi: bundle.requires_chi.to_s)
+      @notify.call(kept_notice(bundle_name, bundle))
       kept
     end
 
-    def kept_notice(bundle_name, data)
+    def kept_notice(bundle_name, bundle)
       id = @session_lookup.call&.id || "ID"
-      "bundle #{bundle_name} #{data[:version]} needs chi #{data[:requires_chi]} and this session runs chi #{Samagotchi::VERSION}: " \
+      "bundle #{bundle_name} #{bundle.version} needs chi #{bundle.requires_chi} and this session runs chi #{Samagotchi::VERSION}: " \
         "its new rules are not loaded, the ones loaded before still apply. Restart the session to load them " \
         "(chi sessions stop #{id}, then chi --resume #{id})"
     end

data/lib/samagotchi/hooks/bundle_loader.rb

@@ -3,6 +3,7 @@
 require_relative "registry"
 require "digest"
 require_relative "../log"
+require_relative "../memory_bundle/bundle_hook"
 require_relative "../memory_bundle/provenance"
 require_relative "../memory_bundle/manifest"
 require_relative "../version"
@@ -44,7 +45,8 @@ module Samagotchi
         #
         # @param bundle_name [String]
         # @param hooks_dir [String] directory containing the bundle's .rb hook files
-        # @param metadata [Hash] basename => { event:, on_error:, priority: }
+        # @param metadata [Hash] basename => { event:, on_error:, priority:,
+        #   sha256: } (MemoryBundle::BundleHook.parse reads it)
         # @param registry [Samagotchi::Hooks::Registry]
         # @param failures [Guardrails::LoadFailures, nil] collects hooks that
         #   failed to load
@@ -64,14 +66,13 @@ module Samagotchi
             basename = raw_basename.to_s
             next if basename.empty?
 
-            meta = ->(key) { raw_meta && (raw_meta[key] || raw_meta[key.to_s]) }
-            event = meta.call(:event).to_s
+            hook = MemoryBundle::BundleHook.parse(raw_meta)
             # A hook with no declared event cannot be auto-registered.
-            next if event.empty?
+            next if hook.event.empty?
 
-            event_sym = event.to_sym
-            on_error = (meta.call(:on_error) || "skip").to_s
-            priority = (meta.call(:priority) || 100).to_i
+            event_sym = hook.event.to_sym
+            on_error = hook.on_error
+            priority = hook.priority
             fail_closed = on_error == "fail_closed" && event_sym == :before_tool_call
             what = "hook #{basename} (bundle #{bundle_name})"
             file = hooks_dir && File.join(hooks_dir, basename)
@@ -79,7 +80,7 @@ module Samagotchi
               failures&.add(what, "the file is missing", required: true) if fail_closed
               next
             end
-            if (mismatch = too_old || sha_mismatch(file, meta.call(:sha256), required: fail_closed))
+            if (mismatch = too_old || sha_mismatch(file, hook.sha256, required: fail_closed))
               Log.warn(:hooks, "bundle_hook_mismatch", echo: "[samagotchi:hooks] bundle '#{bundle_name}' hook '#{basename}' not loaded: #{mismatch}", bundle: bundle_name, hook: basename.to_s)
               failures&.add(what, mismatch, required: fail_closed)
               next

data/lib/samagotchi/host_registry.rb

@@ -273,6 +273,19 @@ module Samagotchi
       ModelTarget.new(model: raw_model, entry: entry, bare_model: bare, client: client_for(entry))
     end
 
+    # What the alias +raw_model+ became, for an error that names only the
+    # host ("splash is an alias: gemma-x on host main"), or nil when it
+    # isn't an alias. An alias without a host of its own goes where a bare
+    # id goes (#host_for_model), often the default host the user never typed.
+    # @return [String, nil]
+    def alias_note(raw_model)
+      ref = model_ref(raw_model)
+      return nil unless ref.alias_name
+
+      target = resolve(raw_model)
+      "#{ref.alias_name} is an alias: #{target.bare_model} on host #{target.entry.name}"
+    end
+
     # The model id sent for +full_ref+: its alias applied, a known host
     # prefix stripped ("box:gemma" → "gemma").
     def bare_name(full_ref)

data/lib/samagotchi/kernel_loop.rb

@@ -726,9 +726,11 @@ module Samagotchi
     end
 
     # Estimate context usage for this iteration's prompt (ContextStatus#observe)
-    # and, when the emit gate fires, surface it to stream consumers as a
-    # :context_status event. The telemetry is not for the model (it used to
-    # be injected as a synthetic system message).
+    # and surface it to stream consumers as a :context_status event, on every
+    # request (observe returns the estimate each time it is enabled), so the
+    # web and the attached TUI get a fresh number per request. The telemetry
+    # is not for the model (it used to be injected as a synthetic system
+    # message); the model's own line is still left only on a rise.
     def emit_context_status_event(on_stream_event, context, prompt, iteration_index:, window:, image_tokens: 0)
       event = context.observe(prompt.length, iteration_index: iteration_index, window: window, image_tokens: image_tokens)
       return unless event

data/lib/samagotchi/llm/chat_loop.rb

@@ -651,10 +651,11 @@ module Samagotchi
 
         # Before a request, as the native loop: estimate how full the window
         # is (the server's last count plus what the turn appended since),
-        # emit :context_status on a bucket change, and put the model's own
-        # line on the tail on a rise that asks it for a change. The estimate
-        # counts the conversation's text and tool calls, not the tool
-        # schemas (the server's count does).
+        # emit :context_status on every request (observe returns the estimate
+        # each time it is enabled), and put the model's own line on the tail
+        # on a rise that asks it for a change. The estimate counts the
+        # conversation's text and tool calls, not the tool schemas (the
+        # server's count does).
         def observe_context(iteration, window)
           return unless window
 

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+require_relative "bundle_hook"
+require_relative "manifest"
+require_relative "provenance"
+require_relative "../version"
+
+module Samagotchi
+  module MemoryBundle
+    autoload :Installer, File.expand_path("installer", __dir__)
+
+    # The install of a bundle's parts that live in its own dir
+    # (<bundles>/<name>/, Provenance#bundle_dir) rather than in the
+    # memories dir: hooks/*.rb, guardrails/*.yml, the plugin file and
+    # scripts/*. Each replaces what an earlier version installed. Installer
+    # runs it after the memories; it adds to the installer's results and
+    # warnings, and #run returns what the record (Provenance#write) keeps.
+    class AssetInstaller
+      # What was installed: the paths Provenance#write records (each
+      # empty / nil on a dry run).
+      #   hooks       every hook basename the bundle ships
+      #   hook_files, guardrail_files, script_files
+      #               basename => installed path
+      #   plugin_file the installed plugin file, nil without one
+      Installed = Data.define(:hooks, :hook_files, :guardrail_files, :plugin_file, :script_files)
+
+      # @param source_dir [String] the normalized bundle source
+      # @param manifest [Manifest, nil] nil for a non-strict install without one
+      # @param existing [InstalledBundle, nil] the record before this install
+      # @param results, warnings, conflicts the Installer's (results and
+      #   warnings are added to)
+      def initialize(name:, source_dir:, manifest:, provenance:, existing:, results:, warnings:, conflicts:,
+                     force: false, strict: true, upgrade: false, dry_run: false)
+        @name = name
+        @bundle_dir = source_dir
+        @manifest = manifest
+        @provenance = provenance
+        @existing = existing
+        @results = results
+        @warnings = warnings
+        @conflicts = conflicts
+        @force = force
+        @strict = strict
+        @upgrade = upgrade
+        @dry_run = dry_run
+      end
+
+      # @return [Installed]
+      # @raise [Installer::InstallError] the manifest names a plugin or
+      #   script the bundle doesn't have
+      def run
+        install_hooks
+        prune_dropped_hooks if @upgrade && @existing && !@dry_run
+        verify_hook_checksums if @manifest && @strict
+        incoming_rules = Dir.glob(File.join(@bundle_dir, "guardrails", "*.yml")).sort
+        guardrail_files = install_guardrails(incoming_rules)
+        plugin_file = install_plugin
+        script_files = install_scripts
+        warn_hooks_requires_chi
+        warn_rules_requires_chi(incoming_rules)
+        Installed.new(hooks: @bundle_hooks, hook_files: @hook_files, guardrail_files: guardrail_files,
+                      plugin_file: plugin_file, script_files: script_files)
+      end
+
+      private
+
+      # Copies the bundle's hooks/*.rb into <bundle_dir>/hooks/: the ones
+      # its manifest lists, else (no hooks: in it) every hooks/*.rb, which is
+      # then added to manifest.hooks with no event (the loader skips it, the
+      # record keeps it). Without a manifest every hooks/*.rb is copied.
+      # Sets @bundle_hooks (every hook the bundle ships) and @hook_files
+      # (basename => installed path, for the record).
+      def install_hooks
+        @bundle_hooks = []
+        @hook_files = {}
+        return install_unlisted_hooks unless @manifest
+
+        hook_entries = @manifest.hooks
+        if hook_entries.empty?
+          Dir.glob(File.join(@bundle_dir, "hooks", "*.rb")).each { |p| hook_entries[File.basename(p)] = BundleHook.new }
+        end
+        hook_entries.each_key do |basename|
+          next unless basename.is_a?(String) && !basename.empty?
+
+          @bundle_hooks << basename
+          src = File.join(@bundle_dir, "hooks", basename)
+          install_hook(basename, src) if File.exist?(src)
+        end
+      end
+
+      # One listed hook; an upgrade overwrites a local edit with a warning.
+      def install_hook(basename, src)
+        dest = File.join(@provenance.hooks_dir, basename)
+        if @dry_run
+          @results[basename] = { status: File.exist?(dest) && !@force ? "would_skip" : "would_install" }
+          return
+        end
+
+        prev_sha = @existing&.hooks&.dig(basename)&.sha256
+        if @upgrade && File.exist?(dest) && !@force && !Provenance.recorded_sha(prev_sha).empty? && !Provenance.sha_matches?(dest, prev_sha)
+          @warnings << "Hook #{basename} was locally modified; overwriting"
+        end
+
+        FileUtils.mkdir_p(@provenance.hooks_dir)
+        unchanged = File.exist?(dest) && FileUtils.identical?(src, dest)
+        FileUtils.cp(src, dest)
+        @results[basename] = if unchanged
+                               { status: "skipped", reason: "already up to date" }
+                             elsif @upgrade && @existing
+                               { status: "updated" }
+                             else
+                               { status: "installed" }
+                             end
+        @hook_files[basename] = dest
+      end
+
+      # No manifest (a non-strict install): every hooks/*.rb is copied.
+      def install_unlisted_hooks
+        Dir.glob(File.join(@bundle_dir, "hooks", "*.rb")).each do |src|
+          basename = File.basename(src)
+          @bundle_hooks << basename
+          if @dry_run
+            @results[basename] = { status: "would_install" }
+          else
+            FileUtils.mkdir_p(@provenance.hooks_dir)
+            dest = File.join(@provenance.hooks_dir, basename)
+            FileUtils.cp(src, dest)
+            @results[basename] = { status: "installed" }
+            @hook_files[basename] = dest
+          end
+        end
+      end
+
+      # An upgrade removes the hooks the previous version shipped and this
+      # one doesn't (a local file too, with a warning).
+      def prune_dropped_hooks
+        @existing.hooks.each_key do |old_key_str|
+          next if @bundle_hooks.include?(old_key_str)
+
+          old_dest = File.join(@provenance.hooks_dir, old_key_str)
+          if File.exist?(old_dest) && !@force
+            @warnings << "Bundle no longer includes hook #{old_key_str} but local file exists — removing"
+          end
+          FileUtils.rm_f(old_dest)
+        end
+      end
+
+      # Strict mode: an installed hook whose sha256 differs from the one its
+      # manifest declares warns (as verify_memory_checksums does).
+      def verify_hook_checksums
+        @bundle_hooks.each do |basename|
+          next if @conflicts.key?(basename)
+
+          expected = @manifest.checksum_for_hook(basename)
+          next unless expected
+
+          dest = File.join(@provenance.hooks_dir, basename)
+          next unless File.exist?(dest)
+
+          actual = Digest::SHA256.hexdigest(File.read(dest))
+          if actual != expected
+            @warnings << "Checksum mismatch for hook #{basename}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
+          end
+        end
+      end
+
+      # The bundle's guardrails/*.yml into <bundle_dir>/guardrails/: the
+      # set replaces what an earlier version installed. Same bytes as
+      # installed are reported up to date, not "Installed".
+      # @return [Hash{String => String}] basename => installed path ({} on a dry run)
+      def install_guardrails(incoming_rules)
+        if @dry_run
+          incoming_rules.each { |src| @results["guardrails/#{File.basename(src)}"] = { status: "would_install" } }
+          return {}
+        end
+
+        target = @provenance.guardrails_dir
+        unchanged = incoming_rules.select do |src|
+          dest = File.join(target, File.basename(src))
+          File.file?(dest) && FileUtils.identical?(src, dest)
+        end
+        FileUtils.rm_rf(target)
+        return {} if incoming_rules.empty?
+
+        FileUtils.mkdir_p(target)
+        incoming_rules.to_h do |src|
+          dest = File.join(target, File.basename(src))
+          FileUtils.cp(src, dest)
+          @results["guardrails/#{File.basename(src)}"] =
+            unchanged.include?(src) ? { status: "skipped", reason: "already up to date" } : { status: "installed" }
+          [File.basename(src), dest]
+        end
+      end
+
+      # Copy the manifest's plugin file into the bundle's plugin/ dir,
+      # warning when its sha256 differs from the declared one or this chi
+      # doesn't meet requires_chi (the Engine then won't load it).
+      # @return [String, nil] the installed file (nil: none, or a dry run)
+      def install_plugin
+        plugin = @manifest&.plugin
+        unless plugin
+          FileUtils.rm_rf(@provenance.plugin_dir) unless @dry_run
+          return nil
+        end
+
+        src = File.join(@bundle_dir, plugin[:file])
+        raise Installer::InstallError, "the manifest names plugin #{plugin[:file]}, which the bundle doesn't have" unless File.file?(src)
+
+        if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, Samagotchi::VERSION))
+          @warnings << "Plugin #{plugin[:file]} won't load: #{failure}"
+        end
+        if @dry_run
+          @results[plugin[:file]] = { status: "would_install" }
+          return nil
+        end
+
+        dest = File.join(@provenance.plugin_dir, plugin[:file])
+        unchanged = File.file?(dest) && FileUtils.identical?(src, dest)
+        FileUtils.rm_rf(@provenance.plugin_dir)
+        FileUtils.mkdir_p(@provenance.plugin_dir)
+        FileUtils.cp(src, dest)
+        @results[plugin[:file]] = if unchanged
+                                    { status: "skipped", reason: "already up to date" }
+                                  elsif @upgrade && @provenance.installed?
+                                    { status: "updated" }
+                                  else
+                                    { status: "installed" }
+                                  end
+        expected = @manifest.checksum_for_plugin
+        actual = Digest::SHA256.hexdigest(File.binread(dest))
+        if @strict && expected && actual != expected
+          @warnings << "Checksum mismatch for plugin #{plugin[:file]}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
+        end
+        dest
+      end
+
+      # The manifest's scripts, copied into <bundle_dir>/scripts/ (the
+      # folder replaced: a script the new version dropped goes). A declared
+      # sha256 that differs warns, as a plugin's does.
+      # @return [Hash{String => String}] file name => installed path
+      def install_scripts
+        scripts = @manifest&.scripts || {}
+        scripts.each_key do |file|
+          next if File.file?(File.join(@bundle_dir, "scripts", file))
+
+          raise Installer::InstallError, "the manifest names scripts/#{file}, which the bundle doesn't have"
+        end
+        return {} if @dry_run
+
+        unchanged = scripts.keys.select do |file|
+          dest = File.join(@provenance.scripts_dir, file)
+          File.file?(dest) && FileUtils.identical?(File.join(@bundle_dir, "scripts", file), dest)
+        end
+        FileUtils.rm_rf(@provenance.scripts_dir)
+        return {} if scripts.empty?
+
+        FileUtils.mkdir_p(@provenance.scripts_dir)
+        scripts.to_h do |file, declared|
+          dest = File.join(@provenance.scripts_dir, file)
+          FileUtils.cp(File.join(@bundle_dir, "scripts", file), dest)
+          @results["scripts/#{file}"] = if unchanged.include?(file) then { status: "skipped", reason: "already up to date" }
+                                        elsif @upgrade && @provenance.installed? then { status: "updated" }
+                                        else { status: "installed" }
+                                        end
+          FileUtils.chmod(0o755, dest)
+          actual = Digest::SHA256.hexdigest(File.binread(dest))
+          expected = declared.to_s.delete_prefix("sha256:")
+          if @strict && !expected.empty? && actual != expected
+            @warnings << "Checksum mismatch for script #{file}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
+          end
+          [file, dest]
+        end
+      end
+
+      # The hook loader skips every hook of a bundle whose requires_chi this
+      # chi doesn't meet (Hooks::BundleLoader); say so at install, as
+      # install_plugin does for the plugin.
+      def warn_hooks_requires_chi
+        return if @manifest.nil? || @bundle_hooks.empty?
+
+        if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, Samagotchi::VERSION))
+          @warnings << "Bundle #{@name}: its hooks won't load: #{failure}"
+        end
+      end
+
+      # GuardrailWiring#bundle_rules doesn't read the rules of a bundle whose
+      # requires_chi this chi doesn't meet, and a session that never loaded
+      # them records a required load failure (the gate refuses guarded calls
+      # until chi is updated): say so at install, as the hooks warning does.
+      def warn_rules_requires_chi(rule_files)
+        return if @manifest.nil? || rule_files.empty?
+
+        if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, Samagotchi::VERSION))
+          @warnings << "Bundle #{@name}: its guardrail rules won't load: #{failure}; until chi is updated " \
+                       "(chi update), guarded tool calls are refused"
+        end
+      end
+    end
+  end
+end