ollama_agent 0.1.0 → 0.3.0

data/lib/ollama_agent/resilience/audit_logger.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module OllamaAgent
+  module Resilience
+    # Subscribes to Streaming::Hooks and writes structured NDJSON audit logs.
+    # Activated by OLLAMA_AGENT_AUDIT=1 or audit: true in Runner.build.
+    class AuditLogger
+      DEFAULT_MAX_RESULT_BYTES = 4_096
+
+      def initialize(log_dir:, hooks:, max_result_bytes: nil)
+        @log_dir          = log_dir
+        @hooks            = hooks
+        @max_result_bytes = max_result_bytes || env_max_result_bytes
+      end
+
+      def attach
+        @hooks.on(:on_tool_call)   { |payload| write_entry(tool_call_entry(payload)) }
+        @hooks.on(:on_tool_result) { |payload| write_entry(tool_result_entry(payload)) }
+        @hooks.on(:on_complete)    { |payload| write_entry(complete_entry(payload)) }
+        @hooks.on(:on_error)       { |payload| write_entry(error_entry(payload)) }
+        @hooks.on(:on_retry)       { |payload| write_entry(retry_entry(payload)) }
+      end
+
+      private
+
+      def write_entry(hash)
+        FileUtils.mkdir_p(@log_dir)
+        File.open(log_path, "a", encoding: Encoding::UTF_8) { |f| f.puts(JSON.generate(hash)) }
+      rescue StandardError
+        nil
+      end
+
+      def log_path
+        File.join(@log_dir, "#{Time.now.strftime("%Y-%m-%d")}.ndjson")
+      end
+
+      def ts
+        Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+
+      def tool_call_entry(payload)
+        { ts: ts, event: "tool_call", name: payload[:name], args: payload[:args], turn: payload[:turn] }
+      end
+
+      def tool_result_entry(payload)
+        result = payload[:result].to_s
+        result = result.byteslice(0, @max_result_bytes) if result.bytesize > @max_result_bytes
+        { ts: ts, event: "tool_result", name: payload[:name], bytes: payload[:result].to_s.bytesize,
+          result_preview: result, turn: payload[:turn] }
+      end
+
+      def complete_entry(payload)
+        { ts: ts, event: "agent_complete", turns: payload[:turns] }
+      end
+
+      def error_entry(payload)
+        { ts: ts, event: "agent_error", error: payload[:error].class.name,
+          message: payload[:error].message, turn: payload[:turn] }
+      end
+
+      def retry_entry(payload)
+        { ts: ts, event: "http_retry", attempt: payload[:attempt],
+          delay_ms: payload[:delay_ms], error: payload[:error].class.name }
+      end
+
+      def env_max_result_bytes
+        v = ENV.fetch("OLLAMA_AGENT_AUDIT_MAX_RESULT_BYTES", nil)
+        return DEFAULT_MAX_RESULT_BYTES if v.nil? || v.to_s.strip.empty?
+
+        Integer(v)
+      rescue ArgumentError, TypeError
+        DEFAULT_MAX_RESULT_BYTES
+      end
+    end
+  end
+end

data/lib/ollama_agent/resilience/retry_middleware.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "retry_policy"
+
+module OllamaAgent
+  module Resilience
+    # Wraps an Ollama::Client with exponential backoff retry for transient errors.
+    class RetryMiddleware
+      DEFAULT_MAX_ATTEMPTS = RetryPolicy::DEFAULT_MAX_ATTEMPTS
+      DEFAULT_BASE_DELAY   = RetryPolicy::DEFAULT_BASE_DELAY
+
+      def initialize(client:, max_attempts: DEFAULT_MAX_ATTEMPTS, hooks: nil, base_delay: DEFAULT_BASE_DELAY)
+        @client  = client
+        @hooks   = hooks
+        @policy  = RetryPolicy.new(max_attempts: max_attempts, base_delay: base_delay)
+      end
+
+      # rubocop:disable Metrics/MethodLength -- single rescue/retry loop
+      def chat(**args)
+        attempt = 0
+        begin
+          @client.chat(**args)
+        rescue *RetryPolicy::RETRYABLE => e
+          raise if http_error_non_retryable?(e)
+
+          attempt += 1
+          raise if attempt >= @policy.max_attempts
+
+          delay = @policy.backoff(attempt)
+          @hooks&.emit(:on_retry, { error: e, attempt: attempt, delay_ms: (delay * 1000).round })
+          sleep delay
+          retry
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def http_error_non_retryable?(error)
+        error.is_a?(Ollama::HTTPError) && !@policy.retryable_http_error?(error)
+      end
+    end
+  end
+end

data/lib/ollama_agent/resilience/retry_policy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module OllamaAgent
+  module Resilience
+    # Retryable exception list and HTTP status / backoff rules for {RetryMiddleware}.
+    class RetryPolicy
+      DEFAULT_MAX_ATTEMPTS = 3
+      DEFAULT_BASE_DELAY   = 2.0
+
+      RETRYABLE = begin
+        list = [Ollama::TimeoutError, Timeout::Error, Errno::ECONNREFUSED, Errno::ECONNRESET]
+        list << SocketError if defined?(SocketError)
+        list << Socket::ResolutionError if defined?(Socket::ResolutionError)
+        list << Ollama::Error if defined?(Ollama::Error)
+        list << Ollama::HTTPError if defined?(Ollama::HTTPError)
+        list
+      rescue NameError
+        [Timeout::Error, Errno::ECONNREFUSED, Errno::ECONNRESET]
+      end.freeze
+
+      attr_reader :max_attempts, :base_delay
+
+      def initialize(max_attempts: DEFAULT_MAX_ATTEMPTS, base_delay: DEFAULT_BASE_DELAY)
+        @max_attempts = max_attempts.to_i
+        @base_delay   = base_delay.to_f
+      end
+
+      def retryable_http_error?(error)
+        msg = error.message.to_s
+        status = msg[/HTTP (\d+)/, 1].to_i
+        return false if status.zero?
+
+        if status == 429
+          return false if msg.downcase.include?("weekly usage limit")
+          return false if msg.downcase.include?("monthly usage limit")
+
+          return true
+        end
+
+        status.between?(500, 599)
+      end
+
+      def backoff(attempt)
+        jitter = @base_delay.positive? ? rand * 0.5 : 0
+        [(@base_delay * (2**(attempt - 1))) + jitter, 30.0].min
+      end
+    end
+  end
+end

data/lib/ollama_agent/ruby_index_tool_support.rb

@@ -39,14 +39,25 @@ module OllamaAgent
 
     # Rebuild only when OLLAMA_AGENT_INDEX_REBUILD changes (avoids rebuilding on every call while it stays "1").
     def ruby_index
-      fingerprint = ENV.fetch("OLLAMA_AGENT_INDEX_REBUILD", "")
-      @ruby_index = nil if fingerprint != @ruby_index_cache_fingerprint
-      @ruby_index_cache_fingerprint = fingerprint
+      @ruby_index_mutex ||= Mutex.new
+      @ruby_index_mutex.synchronize { synchronized_ruby_index }
+    end
+
+    def synchronized_ruby_index
+      invalidate_ruby_index_if_fingerprint_changed
       return @ruby_index if @ruby_index
 
-      @ruby_index = RubyIndex.build(root: @root)
-      warn "ollama_agent: #{@ruby_index.summary_line}" if ENV["OLLAMA_AGENT_DEBUG"] == "1"
-      @ruby_index
+      @ruby_index = RubyIndex.build(root: @root).tap do |idx|
+        warn "ollama_agent: #{idx.summary_line}" if ENV["OLLAMA_AGENT_DEBUG"] == "1"
+      end
+    end
+
+    def invalidate_ruby_index_if_fingerprint_changed
+      fp = ENV.fetch("OLLAMA_AGENT_INDEX_REBUILD", "")
+      return if fp == @ruby_index_cache_fingerprint
+
+      @ruby_index = nil
+      @ruby_index_cache_fingerprint = fp
     end
   end
 end

data/lib/ollama_agent/runner.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "agent"
+require_relative "streaming/hooks"
+require_relative "streaming/console_streamer"
+
+module OllamaAgent
+  # Stable public facade for library consumers.
+  # Configure via Runner.build, then call #run.
+  #
+  # @example
+  #   runner = OllamaAgent::Runner.build(root: "/my/project", stream: true, audit: true)
+  #   runner.hooks.on(:on_token) { |p| print p[:token] }
+  #   runner.run("Refactor the auth module")
+  class Runner
+    # @return [Streaming::Hooks] the hooks bus — attach subscribers before calling #run
+    def hooks
+      @agent.hooks
+    end
+
+    # @return [String, nil] the current session id
+    attr_reader :session_id
+
+    # Build a configured Runner.
+    #
+    # @param root [String] project root directory (default: Dir.pwd)
+    # @param model [String, nil] Ollama model name
+    # @param stream [Boolean] enable streaming token output to stdout
+    # @param session_id [String, nil] named session for persistence
+    # @param resume [Boolean] load prior session messages before running
+    # @param max_retries [Integer] HTTP retry attempts (0 = disable)
+    # @param audit [Boolean] enable structured audit logging
+    # @param read_only [Boolean] disable write tools
+    # @param skills_enabled [Boolean] include bundled prompt skills
+    # @param skill_paths [Array<String>, nil] extra .md skill paths
+    # @param confirm_patches [Boolean] prompt before applying patches
+    # @param orchestrator [Boolean] enable external agent delegation
+    # @param think [String, nil] thinking mode (true/false/high/medium/low)
+    # @param http_timeout [Integer, nil] HTTP timeout in seconds
+    # @param stdin [IO] input for patch/write/delegate confirmations (default +$stdin+)
+    # @param stdout [IO] output for confirmation prompts (default +$stdout+)
+    # @return [Runner]
+    # rubocop:disable Metrics/ParameterLists -- library facade must expose all Agent options
+    def self.build(
+      root:            Dir.pwd,
+      model:           nil,
+      stream:          false,
+      session_id:      nil,
+      resume:          false,
+      max_tokens:      nil,
+      context_summarize: false,
+      max_retries:     nil,
+      audit:           nil,
+      read_only:       false,
+      skills_enabled:  true,
+      skill_paths:     nil,
+      confirm_patches: true,
+      orchestrator:    false,
+      think:           nil,
+      http_timeout:    nil,
+      stdin:           $stdin,
+      stdout:          $stdout
+    )
+      new(
+        root: root, model: model, stream: stream,
+        session_id: session_id, resume: resume,
+        max_tokens: max_tokens, context_summarize: context_summarize,
+        max_retries: max_retries, audit: audit, read_only: read_only,
+        skills_enabled: skills_enabled, skill_paths: skill_paths,
+        confirm_patches: confirm_patches, orchestrator: orchestrator,
+        think: think, http_timeout: http_timeout,
+        stdin: stdin, stdout: stdout
+      )
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # Execute a query. Blocks until the agent loop completes.
+    # @param query [String]
+    def run(query)
+      agent.run(query)
+    end
+
+    protected
+
+    # Exposed for spec stubbing only.
+    attr_reader :agent
+
+    private
+
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def initialize(root:, model:, stream:, session_id:, resume:,
+                   max_tokens:, context_summarize:,
+                   max_retries:, audit:, read_only:, skills_enabled:, skill_paths:,
+                   confirm_patches:, orchestrator:, think:, http_timeout:,
+                   stdin:, stdout:)
+      @session_id = session_id
+
+      config = Agent::AgentConfig.new(
+        root: root,
+        model: model,
+        confirm_patches: confirm_patches,
+        http_timeout: http_timeout,
+        think: think,
+        read_only: read_only,
+        skills_enabled: skills_enabled,
+        skill_paths: skill_paths ? Array(skill_paths) : nil,
+        orchestrator: orchestrator,
+        session_id: session_id,
+        resume: resume,
+        max_retries: max_retries,
+        audit: audit,
+        max_tokens: max_tokens,
+        context_summarize: context_summarize,
+        stdin: stdin,
+        stdout: stdout
+      )
+      @agent = Agent.new(config: config)
+
+      Streaming::ConsoleStreamer.new.attach(@agent.hooks) if stream
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+  end
+end

data/lib/ollama_agent/sandboxed_tools/delegate_external.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module SandboxedTools
+    # Orchestrator tools: list and delegate to external CLI agents.
+    module DelegateExternal
+      private
+
+      def execute_list_external_agents(_args)
+        return "list_external_agents is only available in orchestrator mode." unless @orchestrator
+
+        require "json"
+        rows = external_registry.agents.map { |a| ExternalAgents::Probe.fetch_status(a) }
+        JSON.pretty_generate(rows)
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def execute_delegate_to_agent_tool(args)
+        return "delegate_to_agent is only available in orchestrator mode." unless @orchestrator
+        return "delegate_to_agent is disabled in read-only mode." if @read_only
+
+        id = tool_arg(args, "agent_id")
+        task = tool_arg(args, "task")
+        return missing_tool_argument("delegate_to_agent", "agent_id") if blank_tool_value?(id)
+        return missing_tool_argument("delegate_to_agent", "task") if blank_tool_value?(task)
+
+        agent_def = external_registry.find(id.to_s)
+        return "Unknown agent_id: #{id}. Call list_external_agents first." unless agent_def
+
+        exe = ExternalAgents::Probe.resolve_executable(agent_def)
+        return "Agent #{id} is not available (not on PATH). Check list_external_agents." unless exe
+
+        return "Cancelled by user" if @confirm_delegation && !user_confirms_delegate?(id, task)
+
+        timeout_sec = integer_or(tool_arg(args, "timeout_seconds"), agent_def["timeout_sec"] || 600)
+        paths = tool_arg(args, "paths")
+        paths = [] unless paths.is_a?(Array)
+
+        ExternalAgents::Runner.run(
+          agent_def: agent_def,
+          root: @root,
+          executable: exe,
+          task: task,
+          context_summary: tool_arg(args, "context_summary").to_s,
+          paths: paths,
+          timeout_sec: timeout_sec
+        )
+      rescue ArgumentError => e
+        e.message
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def external_registry
+        @external_registry ||= ExternalAgents::Registry.load
+      end
+
+      def user_confirms_delegate?(agent_id, task)
+        user_prompt.confirm_delegate(agent_id, task)
+      end
+    end
+  end
+end

data/lib/ollama_agent/sandboxed_tools/file_read_write.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module SandboxedTools
+    # read_file / write_file and line-range helpers.
+    module FileReadWrite
+      private
+
+      def execute_read_file(args)
+        path = tool_arg(args, "path")
+        return missing_tool_argument("read_file", "path") if blank_tool_value?(path)
+
+        read_file(
+          path,
+          start_line: tool_arg(args, "start_line"),
+          end_line: tool_arg(args, "end_line")
+        )
+      end
+
+      def execute_write_file_tool(args)
+        path = tool_arg(args, "path")
+        content = tool_arg(args, "content")
+        return missing_tool_argument("write_file", "path") if blank_tool_value?(path)
+        return missing_tool_argument("write_file", "content") if content.nil?
+
+        write_file(path, content)
+      end
+
+      def write_file(path, content)
+        return disallowed_path_message(path) unless path_allowed?(path)
+        return "write_file is disabled in read-only mode." if @read_only
+
+        return "Cancelled by user" if @confirm_patches && !user_prompt.confirm_write_file(path, content.to_s[0, 2000])
+
+        abs = resolve_path(path)
+        FileUtils.mkdir_p(File.dirname(abs))
+        File.write(abs, content.to_s, encoding: Encoding::UTF_8)
+        "Written: #{path}"
+      rescue Errno::EACCES => e
+        "Error writing file: #{e.message}"
+      end
+
+      def read_file(path, start_line: nil, end_line: nil)
+        return disallowed_path_message(path) unless path_allowed?(path)
+
+        abs = resolve_path(path)
+        return read_file_lines(abs, start_line, end_line) if start_line || end_line
+
+        return read_file_too_large(abs) if File.size(abs) > max_read_file_bytes
+
+        File.read(abs)
+      rescue Errno::ENOENT => e
+        "Error reading file: #{e.message}"
+      end
+
+      def read_file_too_large(abs)
+        n = max_read_file_bytes
+        "Error reading file: ollama_agent: file too large for full read (max #{n} bytes); use read_file with " \
+          "start_line and end_line, or raise OLLAMA_AGENT_MAX_READ_FILE_BYTES. Path: #{abs}"
+      end
+
+      def max_read_file_bytes
+        EnvConfig.fetch_int(
+          "OLLAMA_AGENT_MAX_READ_FILE_BYTES",
+          DEFAULT_MAX_READ_FILE_BYTES,
+          strict: EnvConfig.strict_env?
+        )
+      end
+
+      def read_file_lines(abs, start_line, end_line)
+        start_i = read_line_start_index(start_line)
+        end_i = read_line_end_index(end_line)
+        return "" if end_i && start_i > end_i
+
+        accumulate_file_lines(abs, start_i, end_i)
+      rescue Errno::ENOENT => e
+        "Error reading file: #{e.message}"
+      end
+
+      def read_line_start_index(start_line)
+        [integer_or(start_line, 1), 1].max
+      end
+
+      def read_line_end_index(end_line)
+        end_line.nil? ? nil : integer_or(end_line, 1)
+      end
+
+      def accumulate_file_lines(abs, start_i, end_i)
+        buf = +""
+        File.foreach(abs).with_index(1) do |line, lineno|
+          next if lineno < start_i
+          break if end_i && lineno > end_i
+
+          buf << line
+        end
+        buf
+      end
+    end
+  end
+end

data/lib/ollama_agent/sandboxed_tools/search_text.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../search_backend"
+
+module OllamaAgent
+  module SandboxedTools
+    # ripgrep/grep-backed search_code (text mode).
+    module SearchText
+      private
+
+      def execute_search_code(args)
+        pattern = tool_arg(args, "pattern").to_s
+        mode = (tool_arg(args, "mode") || "text").to_s.downcase
+
+        return missing_tool_argument("search_code", "pattern") if blank_tool_value?(pattern)
+
+        return search_code_ruby(pattern, mode) if ruby_search_mode?(mode)
+
+        search_code(pattern, tool_arg(args, "directory") || ".")
+      end
+
+      def search_code(pattern, directory)
+        dir = directory.to_s.empty? ? "." : directory
+        return disallowed_path_message(dir) unless path_allowed?(dir)
+
+        return search_code_no_backends_message unless rg_available? || grep_available?
+
+        return search_with_ripgrep(pattern, dir) if rg_available?
+
+        search_with_grep!(pattern, dir)
+      end
+
+      def search_with_ripgrep(pattern, directory)
+        bin = SearchBackend.rg_executable
+        stdout, = Open3.capture2(bin, "-n", "--", pattern, resolve_path(directory))
+        stdout.to_s
+      end
+
+      def search_with_grep!(pattern, directory)
+        bin = SearchBackend.grep_executable
+        stdout, = Open3.capture2(bin, "-rn", "--", pattern, resolve_path(directory))
+        stdout.to_s
+      end
+
+      def search_code_no_backends_message
+        <<~MSG.strip
+          Error: ollama_agent: no text search backend available. Install ripgrep (`rg`) or GNU grep on PATH.
+        MSG
+      end
+
+      def rg_available?
+        !SearchBackend.rg_executable.nil?
+      end
+
+      def grep_available?
+        !SearchBackend.grep_executable.nil?
+      end
+    end
+  end
+end