ollama_agent 0.1.0 → 0.3.0

data/lib/ollama_agent/context/manager.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "token_counter"
+
+module OllamaAgent
+  module Context
+    # Trims the messages array to fit within a token budget before each chat call.
+    # Never mutates the input. Never removes the system message or the last user message.
+    class Manager
+      DEFAULT_MAX_TOKENS = 32_768
+      TRIM_THRESHOLD     = 0.85
+
+      def initialize(max_tokens: nil, context_summarize: false)
+        @max_tokens = (max_tokens || env_max_tokens).to_i
+        @context_summarize = context_summarize
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # Returns a (possibly shorter) copy of messages that fits within the token budget.
+      def trim(messages)
+        normalized = messages.map { |m| m.transform_keys(&:to_sym) }
+        estimates = normalized.map { |m| TokenCounter.estimate(m[:content].to_s) }
+        return normalized unless over_budget_sum?(estimates)
+
+        trimmed = normalized.dup
+        est = estimates.dup
+        last_user_idx = trimmed.rindex { |m| m[:role] == "user" }
+        dropped = [] if @context_summarize
+
+        while over_budget_sum?(est)
+          drop_idx = find_droppable_index(trimmed, last_user_idx)
+          break if drop_idx.nil?
+
+          msgs = if assistant_with_tool_calls?(trimmed[drop_idx])
+                   drop_assistant_and_tool_results(trimmed, est, drop_idx)
+                 else
+                   est.delete_at(drop_idx)
+                   [trimmed.delete_at(drop_idx)]
+                 end
+          dropped&.concat(msgs)
+          last_user_idx = trimmed.rindex { |m| m[:role] == "user" }
+        end
+
+        inject_summary(trimmed, dropped) if @context_summarize && dropped&.any?
+        trimmed
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
+
+      def inject_summary(messages, dropped)
+        n = dropped.size
+        summary = "Note: Earlier conversation history was trimmed to fit token budget (#{n} messages dropped)."
+        messages.insert(1, { role: "system", content: summary })
+      end
+
+      def over_budget_sum?(estimates)
+        estimates.sum > (@max_tokens * TRIM_THRESHOLD).to_i
+      end
+
+      def find_droppable_index(messages, last_user_idx)
+        messages.each_index.find do |i|
+          messages[i][:role] != "system" && i != last_user_idx
+        end
+      end
+
+      def assistant_with_tool_calls?(message)
+        message[:role] == "assistant" && message[:tool_calls] && !message[:tool_calls].empty?
+      end
+
+      # rubocop:disable Metrics/MethodLength -- drop contiguous tool rows and parallel token estimates
+      def drop_assistant_and_tool_results(messages, estimates, assistant_idx)
+        indices_to_drop = [assistant_idx]
+        ((assistant_idx + 1)...messages.size).each do |i|
+          break if messages[i][:role] != "tool"
+
+          indices_to_drop << i
+        end
+
+        dropped_messages = indices_to_drop.map { |i| messages[i] }
+        indices_to_drop.sort.reverse_each do |i|
+          messages.delete_at(i)
+          estimates.delete_at(i)
+        end
+
+        dropped_messages
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def env_max_tokens
+        v = ENV.fetch("OLLAMA_AGENT_MAX_TOKENS", nil)
+        return DEFAULT_MAX_TOKENS if v.nil? || v.to_s.strip.empty?
+
+        Integer(v)
+      rescue ArgumentError, TypeError
+        DEFAULT_MAX_TOKENS
+      end
+    end
+  end
+end

data/lib/ollama_agent/context/token_counter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module Context
+    # Estimates token count using chars/4 integer division (floor).
+    # Auto-upgrades to tiktoken_ruby (gpt-4 tokenizer) if available in host bundle.
+    module TokenCounter
+      @tokenizer = nil
+      @tiktoken_loaded = false
+
+      def self.estimate(text)
+        ensure_tiktoken_loaded
+        return @tokenizer.encode(text.to_s).length if @tokenizer
+
+        text.to_s.length / 4
+      end
+
+      def self.ensure_tiktoken_loaded
+        return if @tiktoken_loaded
+
+        begin
+          require "tiktoken_ruby"
+          @tokenizer = Tiktoken.encoding_for_model("gpt-4")
+        rescue LoadError
+          @tokenizer = nil
+        ensure
+          @tiktoken_loaded = true
+        end
+      end
+      private_class_method :ensure_tiktoken_loaded
+    end
+  end
+end

data/lib/ollama_agent/diff_path_validator.rb

@@ -4,6 +4,7 @@ require "pathname"
 
 module OllamaAgent
   # Validates unified diffs: hunk headers and path alignment with edit_file (applyability is patch --dry-run).
+  # rubocop:disable Metrics/ClassLength -- normalization helpers live alongside validation
   class DiffPathValidator
     # Legacy context-diff hunks (`--- N,M ----`) are not unified diffs; models sometimes emit them by mistake.
     CONTEXT_DIFF_HUNK = /^\s*---\s+\d+\s*,\s*\d+\s*----\s*$/m
@@ -14,16 +15,36 @@ module OllamaAgent
 
     # Normalizes newlines and escaped "\\n" sequences models sometimes send in tool args.
     def self.normalize_diff(diff)
-      d = diff.to_s
-      d = d.gsub("\r\n", "\n").gsub("\r", "\n")
-      d = d.gsub("\\\\n", "\n").gsub("\\n", "\n") if d.include?("\\n") && !d.include?("\n")
+      d = normalize_newlines(diff.to_s)
+      d = expand_escaped_newlines_when_no_real_newlines(d)
       d = strip_cursor_patch_markers(d)
-      # Strip trailing commas on ---/+++ lines (models copy commas from bad examples).
-      d = d.gsub(/^((?:---|\+\+\+)[^\n]+),\s*$/m, "\\1")
-      # Split "--- a/foo @@ -1,3" when glued on one line (common LLM mistake).
-      d = d.gsub(/(\S)\s(@@ -\d[^\n]*)/, "\\1\n\\2")
-      d += "\n" unless d.empty? || d.end_with?("\n")
-      d
+      d = strip_trailing_commas_on_headers(d)
+      d = split_glued_hunk_headers(d)
+      ensure_trailing_newline(d)
+    end
+
+    def self.normalize_newlines(diff)
+      diff.gsub("\r\n", "\n").gsub("\r", "\n")
+    end
+
+    def self.expand_escaped_newlines_when_no_real_newlines(diff)
+      return diff unless diff.include?("\\n") && !diff.include?("\n")
+
+      diff.gsub("\\\\n", "\n").gsub("\\n", "\n")
+    end
+
+    def self.strip_trailing_commas_on_headers(diff)
+      diff.gsub(/^((?:---|\+\+\+)[^\n]+),\s*$/m, "\\1")
+    end
+
+    def self.split_glued_hunk_headers(diff)
+      diff.gsub(/(\S)\s(@@ -\d[^\n]*)/, "\\1\n\\2")
+    end
+
+    def self.ensure_trailing_newline(diff)
+      return diff if diff.empty? || diff.end_with?("\n")
+
+      "#{diff}\n"
     end
 
     def self.strip_cursor_patch_markers(diff)
@@ -77,7 +98,7 @@ module OllamaAgent
 
       <<~MSG.strip
         A unified diff must list --- a/<path>, then +++ b/<path>, then @@ ... @@ before any changed lines.
-        Do not put @@ on the line right after --- without a +++ line; use the same order as `git diff`.
+        Put a +++ b/<file> line before the first @@ hunk (e.g. +++ b/README.md); do not place @@ immediately after --- alone.
       MSG
     end
 
@@ -138,4 +159,5 @@ module OllamaAgent
       Pathname(path).cleanpath.to_s
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ollama_agent/env_config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  # Centralized ENV parsing with safe fallbacks; warns on malformed values when OLLAMA_AGENT_DEBUG=1.
+  # Set OLLAMA_AGENT_STRICT_ENV=1 to raise {ConfigurationError} on invalid numeric values (CI / operators).
+  module EnvConfig
+    module_function
+
+    # @return [Boolean] true when +OLLAMA_AGENT_STRICT_ENV=1+ (invalid numeric ENV raises {ConfigurationError}).
+    def strict_env?
+      ENV["OLLAMA_AGENT_STRICT_ENV"] == "1"
+    end
+
+    def warn_invalid(name, raw, fallback)
+      return unless ENV["OLLAMA_AGENT_DEBUG"] == "1"
+
+      warn "ollama_agent: #{name}=#{raw.inspect} is invalid; using #{fallback}."
+    end
+
+    def fetch_int(name, default, strict: strict_env?)
+      v = ENV.fetch(name, nil)
+      return default if v.nil? || v.to_s.strip.empty?
+
+      Integer(v)
+    rescue ArgumentError, TypeError
+      raise ConfigurationError, "ollama_agent: #{name}=#{v.inspect} is not a valid integer" if strict
+
+      warn_invalid(name, v, default)
+      default
+    end
+
+    def fetch_float(name, default, strict: strict_env?)
+      v = ENV.fetch(name, nil)
+      return default if v.nil? || v.to_s.strip.empty?
+
+      Float(v)
+    rescue ArgumentError, TypeError
+      raise ConfigurationError, "ollama_agent: #{name}=#{v.inspect} is not a valid float" if strict
+
+      warn_invalid(name, v, default)
+      default
+    end
+  end
+end