rubino-agent 0.3.0

data/lib/rubino/config/reasoning_prefs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Config
+    # Single source of truth for how reasoning/thinking preferences are resolved
+    # from config, shared by the LLM adapter gate and the CLI render path so they
+    # can never drift.
+    #
+    # Two orthogonal knobs:
+    #   * display.reasoning — how reasoning is RENDERED (hidden | collapsed | full)
+    #   * thinking.effort   — how HARD the model thinks (off | low | medium | high)
+    #
+    # display.show_reasoning (legacy boolean) maps in for back-compat ONLY when
+    # display.reasoning is unset: true→full, false→hidden.
+    module ReasoningPrefs
+      RENDER_MODES = %i[hidden collapsed full].freeze
+      DEFAULT_MODE = :collapsed
+
+      EFFORTS = %i[off low medium high].freeze
+      DEFAULT_EFFORT = :medium
+
+      # Effort → Anthropic thinking-token budget. off disables thinking (0).
+      EFFORT_BUDGETS = {
+        off: 0,
+        low: 4_000,
+        medium: 8_000,
+        high: 16_000
+      }.freeze
+
+      module_function
+
+      # The render mode symbol for a config object. Prefers display.reasoning;
+      # falls back to the legacy display.show_reasoning boolean; else the default.
+      def mode(config)
+        raw = config&.dig("display", "reasoning")
+        sym = raw.to_s.strip.downcase.to_sym unless raw.nil?
+        return sym if RENDER_MODES.include?(sym)
+
+        legacy = config&.dig("display", "show_reasoning")
+        return :full if legacy == true
+        return :hidden if legacy == false
+
+        DEFAULT_MODE
+      end
+
+      # The effort symbol for a config object, or nil when thinking.effort is
+      # unset (so callers can fall back to the existing thinking_budget chain).
+      def effort(config)
+        raw = config&.dig("thinking", "effort")
+        return nil if raw.nil?
+        # YAML parses an unquoted `off` as the boolean false, which used to
+        # silently break thinking-budget gating (#79) — coerce it back to :off
+        # here, the single read boundary, so a doc-following config keeps working.
+        return :off if raw == false
+
+        sym = raw.to_s.strip.downcase.to_sym
+        EFFORTS.include?(sym) ? sym : nil
+      end
+
+      # Token budget for an effort symbol (nil/unknown → nil so the caller can
+      # fall back to its own default chain).
+      def effort_budget(effort)
+        EFFORT_BUDGETS[effort]
+      end
+    end
+  end
+end

data/lib/rubino/config/writer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Rubino
+  module Config
+    # Writes configuration changes back to the YAML file.
+    class Writer
+      def initialize(config_path:)
+        @config_path = config_path
+      end
+
+      # Sets a single key (dot-notation) to a value and persists
+      def set(key_path, value)
+        raw = load_raw
+        keys = key_path.split(".")
+        hash = raw
+
+        keys[0..-2].each_with_index do |k, i|
+          hash[k] ||= {}
+          hash = hash[k]
+          next if hash.is_a?(Hash)
+
+          traversed = keys[0..i].join(".")
+          raise ConfigurationError,
+                "cannot set '#{key_path}': '#{traversed}' is a scalar value, not a section"
+        end
+
+        hash[keys.last] = coerce_value(value)
+        save(raw)
+      end
+
+      # Returns the value at a dot-notation key path
+      def get(key_path)
+        raw = load_raw
+        keys = key_path.split(".")
+        # A scalar intermediate node (e.g. a String) has no #dig; treat such a
+        # path as "not found" rather than crashing with a TypeError.
+        raw.dig(*keys)
+      rescue TypeError
+        nil
+      end
+
+      private
+
+      def load_raw
+        if File.exist?(@config_path)
+          YAML.safe_load_file(@config_path, permitted_classes: [Symbol]) || {}
+        else
+          {}
+        end
+      end
+
+      def save(raw)
+        FileUtils.mkdir_p(File.dirname(@config_path))
+        File.write(@config_path, raw.to_yaml)
+      end
+
+      def coerce_value(value)
+        case value
+        when "true" then true
+        when "false" then false
+        when "nil", "null" then nil
+        when /\A\d+\z/ then value.to_i
+        when /\A\d+\.\d+\z/ then value.to_f
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/rubino/context/compressor.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Rubino
+  module Context
+    # Orchestrates context compaction: flush memory, split messages into
+    # head/middle/tail, generate summary, create child session.
+    class Compressor
+      def initialize(session_id:, config: nil, db: nil)
+        @session_id = session_id
+        @config = config || Rubino.configuration
+        @db = db || Rubino.database.db
+        @message_store = Session::Store.new(db: @db)
+        @session_repo = Session::Repository.new(db: @db)
+        @summary_store = Session::SummaryStore.new(db: @db)
+      end
+
+      # Performs full compaction and returns metadata
+      def compact!
+        session = @session_repo.find(@session_id)
+        raise CompactionError, "Session not found: #{@session_id}" unless session
+
+        messages = @message_store.for_session(@session_id)
+        return no_op_result if messages.size < minimum_messages
+
+        # 1. Flush memory before compaction
+        flush_memory!
+
+        # 2. Split messages into head / middle / tail
+        boundary = MessageBoundary.new(messages: messages, config: @config)
+        head = boundary.head
+        middle = boundary.middle
+        tail = boundary.tail
+
+        return no_op_result if middle.empty?
+
+        # 3. Sanitize tool pairs in middle
+        if @config.compression_preserve_tool_pairs?
+          sanitizer = ToolPairSanitizer.new
+          middle = sanitizer.sanitize(middle)
+        end
+
+        # 4. Load previous summary (capture id now, before the insert below
+        #    overwrites "latest" — the lineage link must point at the prior row)
+        previous = @summary_store.latest(@session_id)
+        previous_summary = previous&.dig(:content)
+        previous_summary_id = previous&.dig(:id)
+
+        # 5. Generate new summary
+        summary_builder = SummaryBuilder.new(session_id: @session_id)
+        new_summary = summary_builder.build(
+          messages: middle,
+          previous_summary: previous_summary
+        )
+
+        # 6. Save summary (chains parent_summary_id to the previous row)
+        summary_id = @summary_store.insert(session_id: @session_id, content: new_summary)
+
+        # 7. Create child session with compacted context
+        child_session = create_child_session(session, head, new_summary, tail)
+
+        # 8. Record compaction lineage
+        record_compaction(
+          source_id: @session_id,
+          target_id: child_session[:id],
+          previous_summary_id: previous_summary_id,
+          new_summary_id: summary_id,
+          original_tokens: estimate_tokens(messages),
+          compacted_tokens: estimate_tokens(head + tail)
+        )
+
+        {
+          source_session_id: @session_id,
+          target_session_id: child_session[:id],
+          original_messages: messages.size,
+          compacted_messages: head.size + tail.size + 1, # +1 for summary
+          saved_tokens: estimate_tokens(middle),
+          summary_id: summary_id
+        }
+      end
+
+      private
+
+      def flush_memory!
+        flusher = Memory::Flusher.new
+        flusher.flush_before_compaction!(@session_id)
+      end
+
+      def create_child_session(parent_session, head, summary, tail)
+        child = @session_repo.create(
+          source: "compaction",
+          model: parent_session[:model],
+          provider: parent_session[:provider],
+          title: parent_session[:title],
+          parent_session_id: parent_session[:id]
+        )
+
+        # Copy head messages — faithful copy preserves metadata[:tool_calls]
+        # and token_count, otherwise compaction strips the assistant toolUse
+        # block and orphans the matching tool result (400 on resume).
+        @message_store.copy_into(child[:id], head)
+
+        # Insert summary as system message
+        @message_store.create(
+          session_id: child[:id],
+          role: "system",
+          content: "[Compacted Summary]\n#{summary}"
+        )
+
+        # Copy tail messages (same faithful copy as head)
+        @message_store.copy_into(child[:id], tail)
+
+        # End the parent session
+        @session_repo.update(parent_session[:id], status: "compacted")
+
+        child
+      end
+
+      def record_compaction(source_id:, target_id:, previous_summary_id:, new_summary_id:,
+                            original_tokens:, compacted_tokens:)
+        @db[:compactions].insert(
+          id: SecureRandom.uuid,
+          source_session_id: source_id,
+          target_session_id: target_id,
+          previous_summary_id: previous_summary_id,
+          new_summary_id: new_summary_id,
+          original_token_count: original_tokens,
+          compacted_token_count: compacted_tokens,
+          saved_token_count: original_tokens - compacted_tokens,
+          created_at: Time.now.utc.iso8601
+        )
+      end
+
+      def estimate_tokens(messages)
+        total = messages.sum { |m| (m.respond_to?(:content) ? m.content : m[:content] || "").length }
+        (total / 4.0).ceil
+      end
+
+      def minimum_messages
+        @config.compression_protect_first_n + @config.compression_protect_last_n + 5
+      end
+
+      def no_op_result
+        { source_session_id: @session_id, saved_tokens: 0, skipped: true }
+      end
+    end
+  end
+end

data/lib/rubino/context/environment_inspector.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "date"
+
+module Rubino
+  module Context
+    # Builds the "[Environment]" block injected into every system prompt.
+    #
+    # Probes the host once per process for the static bits (OS, ruby/python
+    # versions, external utilities on PATH) and asks for the dynamic bits
+    # (date, cwd, git branch) on every build. The static cache survives the
+    # length of the process — long enough for an HTTP server's lifetime,
+    # short enough that a `gem install` between deploys repopulates it.
+    #
+    # The goal is a concrete, honest description of the *actual* runtime the
+    # model is talking to. If markitdown isn't installed in the VM image, we
+    # don't list it — the agent will then ask the user instead of confidently
+    # invoking a binary that doesn't exist.
+    class EnvironmentInspector
+      # External CLI tools we probe by default. The list mixes hard
+      # dependencies (git, ruby) and useful-but-optional binaries the agent
+      # may want to shell out to (markitdown, pandoc, …). Anything not
+      # found on PATH is silently dropped — see #available_utilities.
+      DEFAULT_UTILITIES = %w[
+        git gh rg jq curl wget
+        ruby python3 node npm bundle
+        docker psql sqlite3 redis-cli
+        ffmpeg pandoc markitdown pdftotext tesseract
+      ].freeze
+
+      class << self
+        # Process-wide cache of the static fields. Reset via #reset_cache!
+        # from specs.
+        def cache
+          @cache ||= {}
+        end
+
+        def reset_cache!
+          @cache = {}
+        end
+      end
+
+      def initialize(extra_utilities: [], cwd: nil, clock: -> { Time.now })
+        @extra_utilities = Array(extra_utilities).map(&:to_s)
+        @cwd = cwd
+        @clock = clock
+      end
+
+      # Returns the assembled [Environment] block, or nil if the caller
+      # disabled it at the config layer (PromptAssembler decides — this
+      # class always renders when asked).
+      def render
+        lines = []
+        lines << "[Environment]"
+        lines << "- Today's date: #{today}"
+        lines << "- Platform: #{platform}"
+        lines << "- Shell: #{shell}"
+        lines << "- Working dir: #{working_dir}"
+        git = git_description
+        lines << "- Git: #{git}" if git
+        lines << "- Runtimes: #{runtimes}"
+        utilities = available_utilities
+        lines << "- Available CLI tools on PATH: #{utilities.join(", ")}" if utilities.any?
+        docs = document_formats
+        if docs.any?
+          lines << "- Document reading: the `read_attachment` tool converts these formats " \
+                   "to Markdown in-process (no external binary needed): #{docs.join(", ")}"
+        end
+        lines.join("\n")
+      end
+
+      # The CORE document formats readable in-process via read_attachment
+      # (driven by which optional extraction gems loaded). Advertised so the
+      # model knows it can read a docx/pdf even when no `markitdown` binary
+      # exists on PATH -- closing the gap this file's own comment describes.
+      def document_formats
+        self.class.cache[:document_formats] ||= begin
+          Rubino::Documents::Registry.available_formats
+        rescue StandardError
+          []
+        end
+      end
+
+      # Public for spec inspection. The list is sorted to keep the prompt
+      # stable turn-to-turn (otherwise reordering would invalidate the
+      # provider-side prompt cache).
+      def available_utilities
+        probes = (DEFAULT_UTILITIES + @extra_utilities).uniq
+        self.class.cache[:utilities] ||= probes.select { |bin| on_path?(bin) }.sort
+      end
+
+      private
+
+      def today
+        @clock.call.strftime("%Y-%m-%d")
+      end
+
+      def platform
+        self.class.cache[:platform] ||= begin
+          host_os = RbConfig::CONFIG["host_os"]
+          arch    = RbConfig::CONFIG["host_cpu"]
+          os_name =
+            case host_os
+            when /darwin/  then "macOS"
+            when /linux/   then linux_distro || "Linux"
+            when /mswin|mingw|cygwin/ then "Windows"
+            else host_os
+            end
+          "#{os_name} (#{arch})"
+        end
+      end
+
+      def linux_distro
+        return nil unless File.readable?("/etc/os-release")
+
+        pretty = File.read("/etc/os-release").lines.find { |l| l.start_with?("PRETTY_NAME=") }
+        pretty&.split("=", 2)&.last&.strip&.delete('"')
+      rescue StandardError
+        nil
+      end
+
+      def shell
+        self.class.cache[:shell] ||= File.basename(ENV["SHELL"] || "sh")
+      end
+
+      def working_dir
+        @cwd || Dir.pwd
+      rescue StandardError
+        "(unavailable)"
+      end
+
+      def git_description
+        dir = working_dir
+        return nil unless File.directory?(File.join(dir, ".git"))
+
+        branch = `git -C #{shellescape(dir)} rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+        branch.empty? ? "repo (detached HEAD)" : "repo on branch #{branch}"
+      rescue StandardError
+        nil
+      end
+
+      def runtimes
+        self.class.cache[:runtimes] ||= begin
+          parts = []
+          parts << "Ruby #{RUBY_VERSION}"
+          py = probe_version("python3", "--version")
+          parts << "Python #{py}" if py
+          node = probe_version("node", "--version")
+          parts << "Node #{node.sub(/\Av/, "")}" if node
+          parts.join(", ")
+        end
+      end
+
+      def probe_version(bin, flag)
+        return nil unless on_path?(bin)
+
+        out = `#{shellescape(bin)} #{flag} 2>&1`.strip
+        out.split.last
+      rescue StandardError
+        nil
+      end
+
+      def on_path?(bin)
+        ENV["PATH"].to_s.split(File::PATH_SEPARATOR).any? do |dir|
+          path = File.join(dir, bin)
+          File.executable?(path) && !File.directory?(path)
+        end
+      end
+
+      def shellescape(str)
+        str.to_s.gsub(%r{([^A-Za-z0-9_\-.,:/@\n])}, "\\\\\\1")
+      end
+    end
+  end
+end

data/lib/rubino/context/file_discovery.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Context
+    # Discovers and loads project context files from the working directory.
+    # Supports multiple file conventions (.rubino.md, AGENTS.md, etc.)
+    class FileDiscovery
+      CONTEXT_FILES = %w[
+        .rubino.md
+        RUBINO.md
+        AGENTS.md
+        CLAUDE.md
+        .cursorrules
+      ].freeze
+
+      def initialize(base_path: nil)
+        @base_path = base_path || Dir.pwd
+      end
+
+      # Loads and concatenates all found project context files
+      def load_project_context
+        files = discover_files
+        return nil if files.empty?
+
+        files.map { |f| File.read(f) }.join("\n\n---\n\n")
+      end
+
+      # Returns list of discovered context file paths
+      def discover_files
+        CONTEXT_FILES.filter_map do |filename|
+          path = File.join(@base_path, filename)
+          path if File.exist?(path)
+        end
+      end
+
+      # Checks a subdirectory for local context files
+      def local_context(subdir)
+        CONTEXT_FILES.filter_map do |filename|
+          path = File.join(@base_path, subdir, filename)
+          File.read(path) if File.exist?(path)
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/rubino/context/message_boundary.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Context
+    # Splits messages into head (protected), middle (compressible), tail (protected).
+    class MessageBoundary
+      def initialize(messages:, config: nil)
+        @messages = messages
+        @config = config || Rubino.configuration
+        @protect_first = @config.compression_protect_first_n
+        @protect_last = @config.compression_protect_last_n
+      end
+
+      # Returns the protected head messages (system prompt + first N)
+      def head
+        @messages.first(@protect_first)
+      end
+
+      # Returns the compressible middle messages
+      def middle
+        return [] if @messages.size <= (@protect_first + @protect_last)
+
+        @messages[@protect_first...-@protect_last]
+      end
+
+      # Returns the protected tail messages (recent context)
+      def tail
+        return [] if @messages.size <= @protect_last
+
+        @messages.last(@protect_last)
+      end
+
+      # Returns true if there are enough messages to have a middle section
+      def has_compressible_middle?
+        !middle.empty?
+      end
+    end
+  end
+end