samagotchi 0.17.0 → 0.18.0

data/lib/samagotchi/guardrails/shell_git_dirs.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Guardrails
+    # Where a shell command runs a git subcommand that changes a checkout
+    # (commit, add, reset, …): the directories, or :unknown for one that
+    # can't be read from the text ($VAR, $(…), `cd -`). Pure text: it
+    # follows cd/pushd/popd, ( … ) subshells, git -C/--git-dir/--work-tree
+    # and GIT_DIR/GIT_WORK_TREE. It catches honest mistakes (cd into
+    # another checkout and commit there); sh -c, scripts, aliases and
+    # $(…) bodies get through. Never raises on odd input.
+    module ShellGitDirs
+      MUTATING = %w[commit add reset checkout switch rebase merge push stash rm mv
+                    cherry-pick revert pull restore am].freeze
+      STASH_READS = %w[list show].freeze
+      # Longest first: "&&" before "&", ";;" before ";".
+      OPERATORS = ["&&", "||", ";;", "|&", ";", "|", "&", "\n", "(", ")"].freeze
+      PREFIXES = %w[command builtin exec time nohup env ! { if then else elif do while until].freeze
+      # git global options that take the next word as their value.
+      VALUE_OPTIONS = %w[-C -c --git-dir --work-tree --namespace].freeze
+      SUBST = "\0SUBST"
+      REDIRECT = /\A\d*[<>]/
+
+      # @param command [String] the shell command
+      # @param cwd [String] where it starts (the call's cwd:, else the session's)
+      # @param home [String] for ~, $HOME, ${HOME} and a bare cd
+      # @return [Array<String, Symbol>] absolute dirs and :unknown, unique
+      def self.for(command, cwd:, home: Dir.home)
+        Walk.new(cwd, home).run(simple_commands(lex(command.to_s)))
+      rescue ArgumentError, EncodingError
+        [] # a NUL byte, invalid UTF-8: the shell would refuse it too
+      end
+
+      # Words and operators ([:word, "x"] / [:op, "&&"]).
+      def self.lex(text)
+        Lexer.new(text).tokens
+      end
+
+      # The token stream split at operators into word lists; ( and ) become
+      # :open / :close markers.
+      def self.simple_commands(tokens)
+        commands = [[]]
+        tokens.each do |kind, value|
+          if kind == :op
+            commands << :open if value == "("
+            commands << :close if value == ")"
+            commands << []
+          else
+            commands.last << value
+          end
+        end
+        commands.reject { |c| c.is_a?(Array) && c.empty? }
+      end
+
+      # A hand-written shell lexer: quotes, backslashes, comments, $(…) and
+      # backticks (an opaque marker inside the word), redirections kept in
+      # their word (2>&1 doesn't split on &), operators.
+      class Lexer
+        def initialize(text)
+          @s = text
+          @i = 0
+          @tokens = []
+          @word = +""
+          @in_word = false
+        end
+
+        def tokens
+          step while @i < @s.size
+          flush
+          @tokens
+        end
+
+        private
+
+        def step
+          c = @s[@i]
+          case c
+          when "\\" then add(@s[@i + 1].to_s, 2)
+          when "'" then single_quote
+          when '"' then double_quote
+          when "`" then backtick
+          when "$" then @s[@i + 1] == "(" ? substitution : add(c, 1)
+          when "#" then @in_word ? add(c, 1) : comment
+          when ">", "<" then redirection
+          when " ", "\t" then flush && (@i += 1)
+          else operator_or_char(c)
+          end
+        end
+
+        def add(text, advance)
+          @word << text
+          @in_word = true
+          @i += advance
+        end
+
+        def flush
+          @tokens << [:word, @word.dup] if @in_word
+          @word.clear
+          @in_word = false
+          true
+        end
+
+        def single_quote
+          close = @s.index("'", @i + 1) || @s.size
+          add(@s[(@i + 1)...close].to_s, close + 1 - @i)
+        end
+
+        def double_quote
+          @i += 1
+          @in_word = true
+          while @i < @s.size && @s[@i] != '"'
+            if @s[@i] == "\\" && @i + 1 < @s.size
+              @word << @s[@i + 1]
+              @i += 2
+            else
+              @word << @s[@i]
+              @i += 1
+            end
+          end
+          @i += 1
+        end
+
+        def backtick
+          close = @s.index("`", @i + 1) || @s.size
+          add(SUBST, close + 1 - @i)
+        end
+
+        def substitution
+          depth = 0
+          j = @i + 1
+          loop do
+            depth += 1 if @s[j] == "("
+            depth -= 1 if @s[j] == ")"
+            j += 1
+            break if depth.zero? || j >= @s.size
+          end
+          add(SUBST, j - @i)
+        end
+
+        def comment
+          @i = @s.index("\n", @i) || @s.size
+        end
+
+        # >, >>, 2>&1, &>, <, <<: kept in the word (the walk drops them).
+        def redirection
+          add(@s[@i], 1)
+          add(@s[@i], 1) while @i < @s.size && @s[@i].match?(/[&\d>-]/) && @word.match?(/>\z/)
+        end
+
+        def operator_or_char(char)
+          op = OPERATORS.find { |o| @s[@i, o.size] == o }
+          return add(char, 1) unless op
+
+          if op == "&" && @word.match?(/\d*>\z/)
+            add(op, 1)
+          else
+            flush
+            @tokens << [:op, op]
+            @i += op.size
+          end
+        end
+      end
+
+      # Follows the current dir through the simple commands and records
+      # where each mutating git runs.
+      class Walk
+        def initialize(cwd, home)
+          @dir = cwd
+          @home = home
+          @subshells = []
+          @pushed = []
+          @found = []
+        end
+
+        def run(commands)
+          commands.each do |words|
+            case words
+            when :open then @subshells << @dir
+            when :close then @dir = @subshells.pop || @dir
+            else simple(words.dup)
+            end
+          end
+          @found.uniq
+        end
+
+        private
+
+        def simple(words)
+          env = {}
+          while (word = words.first)
+            if word.match?(/\A[A-Za-z_]\w*=/)
+              key, value = word.split("=", 2)
+              env[key] = value
+            elsif !PREFIXES.include?(word)
+              break
+            end
+            words.shift
+          end
+          verb = words.shift or return
+          args = words.grep_v(REDIRECT)
+          case verb
+          when "cd" then cd(args)
+          when "pushd"
+            @pushed << @dir
+            @dir = args.first ? expand(args.first, @dir) : nil
+          when "popd" then @dir = @pushed.pop unless @pushed.empty?
+          else git(args, env) if verb == "git" || verb.end_with?("/git")
+          end
+        end
+
+        def cd(args)
+          target = args.reject { |a| %w[-P -L -e -@].include?(a) }.first
+          @dir = if target.nil? then @home
+                 elsif target == "-" then nil
+                 else expand(target, @dir)
+                 end
+        end
+
+        def git(args, env)
+          dir = @dir
+          work_tree = env["GIT_WORK_TREE"] && expand(env["GIT_WORK_TREE"], dir)
+          git_dir = env["GIT_DIR"] && expand(env["GIT_DIR"], dir)
+          sub = nil
+          until args.empty?
+            arg = args.shift
+            case arg
+            when *VALUE_OPTIONS
+              value = args.shift.to_s
+              dir = expand(value, dir) if arg == "-C"
+              git_dir = expand(value, dir) if arg == "--git-dir"
+              work_tree = expand(value, dir) if arg == "--work-tree"
+            when /\A--git-dir=(.*)\z/m then git_dir = expand(Regexp.last_match(1), dir)
+            when /\A--work-tree=(.*)\z/m then work_tree = expand(Regexp.last_match(1), dir)
+            when /\A-/ then next
+            else
+              sub = arg
+              break
+            end
+          end
+          return unless MUTATING.include?(sub)
+          return if sub == "stash" && STASH_READS.include?(args.first)
+
+          @found << (work_tree || repo_of(git_dir) || dir || :unknown)
+        end
+
+        def repo_of(git_dir)
+          return nil unless git_dir
+
+          File.basename(git_dir) == ".git" ? File.dirname(git_dir) : git_dir
+        end
+
+        # An absolute path for +arg+ against +dir+; nil when it can't be
+        # told from the text (a variable, a substitution, a relative path
+        # against an unknown dir).
+        def expand(arg, dir)
+          return nil if arg.include?(SUBST)
+
+          arg = arg.sub(/\A(~|\$HOME|\$\{HOME\})(?=\/|\z)/) { @home }
+          return nil if arg.include?("$") || arg.start_with?("~")
+          return File.expand_path(arg) if arg.start_with?("/")
+
+          dir && File.expand_path(arg, dir)
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails/targets.rb

@@ -4,20 +4,27 @@ require_relative "../tools/tool_path"
 require_relative "../tools/memory"
 require_relative "../log"
 require_relative "model_size"
-require_relative "../memory_bundle/index_sync"
+require_relative "outside"
+require_relative "shell_git_dirs"
 
 module Samagotchi
   module Guardrails
     # What a tool call acts on, resolved the way the tools resolve it: the
     # shell command, absolute paths (against Dir.pwd, as the file tools have
     # no cwd:), the directory a command runs in, its repo root, and whether
-    # a path leaves the repo (the cwd when there is no repo).
+    # a path leaves the session's repo (Outside: the context cwd's repo
+    # root, the cwd when there is no repo; not the call's own cwd:).
     class Targets
       SHELL_TOOLS = %w[execute task_create].freeze
       PATH_TOOLS = %w[write edit read memory_write].freeze
 
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
+      # @return [String] the session's repo root (the context cwd's; the cwd
+      #   outside a repo): what outside_repo measures from. repo_root is the
+      #   call's (its own cwd: for shell and plugin tools).
+      attr_reader :session_root
+
       # @return [String, nil] the effective model: its bare name (no host
       #   prefix) and its key (ModelOverlay.key_for), for a rule's models:
       attr_reader :model_name, :model_key
@@ -62,7 +69,7 @@ module Samagotchi
           args = call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
         end
         new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args,
-            model_name: model_name, model_key: model_key)
+            model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base)
       end
 
       # What a plugin tool's targets: callable says the call acts on:
@@ -102,7 +109,9 @@ module Samagotchi
         nil
       end
 
-      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil)
+      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil,
+                     session_root: nil)
+        @session_root = session_root || repo_root || cwd
         @args = args
         @model_name = model_name
         @model_key = model_key
@@ -123,20 +132,28 @@ module Samagotchi
         @small_model = ModelSize.small?(@model_name, @model_key)
       end
 
-      # Whether any path is outside the repo root (the cwd outside a repo).
-      # A memory's file doesn't count (MemoryBundle::IndexSync.memory_scope):
-      # write/edit there is what memory_write does, unasked; index.md, the
-      # bundles dir and the rest of chi's config dir still count.
+      # Whether any path is outside the session's repo (Outside.outside?:
+      # symlinks resolved; a memory's file and tmp dirs don't count).
       def outside_repo?
-        root = @repo_root || @cwd
-        @paths.any? do |p|
-          p != root && !p.start_with?(File.join(root, "")) && !MemoryBundle::IndexSync.memory_scope(p)
-        end
+        @paths.any? { |p| Outside.outside?(p, root: @session_root) }
+      end
+
+      # Where a shell call runs mutating git (ShellGitDirs: dirs, and
+      # :unknown for one the text doesn't tell); [] for other tools.
+      def git_dirs
+        @git_dirs ||= shell? ? ShellGitDirs.for(@command, cwd: @cwd) : []
+      end
+
+      # Whether a shell call runs mutating git outside the session's repo
+      # (an :unknown dir doesn't count).
+      def git_outside_repo?
+        git_dirs.any? { |dir| dir.is_a?(String) && Outside.outside?(dir, root: @session_root) }
       end
 
       # The hook event's targets: hash.
       def to_h
-        { command: @command, paths: @paths, cwd: @cwd, repo_root: @repo_root, outside_repo: outside_repo? }
+        { command: @command, paths: @paths, cwd: @cwd, repo_root: @repo_root, outside_repo: outside_repo?,
+          git_dirs: git_dirs.map(&:to_s) }
       end
     end
   end

data/lib/samagotchi/guardrails.rb

@@ -2,6 +2,8 @@
 
 require_relative "guardrails/verdict"
 require_relative "guardrails/context"
+require_relative "guardrails/outside"
+require_relative "guardrails/shell_git_dirs"
 require_relative "guardrails/targets"
 require_relative "guardrails/model_size"
 require_relative "guardrails/approval"

data/lib/samagotchi/iteration_limit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "log"
+
+module Samagotchi
+  # A turn's iteration limit (how many model ↔ tool rounds before the turn
+  # stops and offers to continue), one resolver for the Engine, the worker
+  # and the REPL.
+  module IterationLimit
+    KEY = "turn.max_iterations"
+    # A turn's limit unless turn.max_iterations says otherwise, and the
+    # loops' own default.
+    DEFAULT = 100
+    # A --no-interrupt / --non-interactive turn's, at least: nobody is there
+    # to answer a continue offer.
+    NO_INTERRUPT = 1000
+
+    # @param no_interrupt [Boolean] the turn runs with nobody to answer: the
+    #   larger of NO_INTERRUPT and the configured limit, so a configured one
+    #   above 1000 is never lowered
+    # @return [Integer]
+    def self.for(no_interrupt: false) = no_interrupt ? [NO_INTERRUPT, configured].max : configured
+
+    # turn.max_iterations (env SAMAGOTCHI_TURN_MAX_ITERATIONS); one below 1
+    # is DEFAULT, with a warning.
+    # @return [Integer]
+    def self.configured
+      value = Config.get(KEY)
+      return DEFAULT if value.nil?
+      return value if value.is_a?(Integer) && value >= 1
+
+      Log.warn(:config, "invalid_value", echo: "Warning: #{KEY} must be 1 or more, got #{value.inspect} — using #{DEFAULT}",
+                                         key: KEY)
+      DEFAULT
+    end
+  end
+end

data/lib/samagotchi/kernel_loop.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "iteration_limit"
 require_relative "model_profile"
 require_relative "tool_call_parser"
 require_relative "config"
@@ -174,7 +175,7 @@ module Samagotchi
     #   at the conversation tail (prefix KV cache preserved) and a
     #   :pending_input_merged stream event is emitted.
     # @return [LLM::ModelResult] final visible response with continuation metadata
-    def run(messages, max_iterations: 100, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
       @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
                                   pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))

data/lib/samagotchi/llm/backend.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require_relative "model_result"
 
 module Samagotchi
@@ -14,7 +15,7 @@ module Samagotchi
     #
     # The raw-prompt KernelLoop is NativeBackend; the chat loop is ChatLoop.
     class ModelBackend
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         raise NotImplementedError, "#{self.class}#complete must be implemented"
       end

data/lib/samagotchi/llm/chat_loop.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require "json"
 require_relative "backend"
 require_relative "model_result"
@@ -56,7 +57,7 @@ module Samagotchi
 
       def provider = :chat
 
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         raise ArgumentError, "ChatLoop has no adapter" unless @adapter
 

data/lib/samagotchi/llm/native_backend.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require_relative "backend"
 require_relative "model_result"
 
@@ -15,7 +16,7 @@ module Samagotchi
 
       def provider = :native
 
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         @kernel.run(
           messages,

data/lib/samagotchi/memory_bundle/trash.rb

@@ -9,13 +9,52 @@ module Samagotchi
     # (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. Nothing prunes
-    # it: the user deletes it when sure.
+    # 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
 
@@ -52,6 +91,46 @@ module Samagotchi
         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