ollama_agent 0.3.0 → 1.0.0

data/lib/ollama_agent/memory/session_memory.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module OllamaAgent
+  module Memory
+    # Session-scoped key-value store for goals, task progress, and intermediate state.
+    # Persisted to YAML under .ollama_agent/memory/<session_id>.yml.
+    # Outlives a single run but is scoped to a session.
+    class SessionMemory
+      attr_reader :session_id
+
+      def initialize(root:, session_id: nil)
+        @root       = File.expand_path(root)
+        @session_id = session_id || "default"
+        @store      = load_or_initialize
+      end
+
+      # @param key   [String, Symbol]
+      # @param value [Object]  must be YAML-serialisable
+      def set(key, value)
+        @store[key.to_s] = value
+        persist!
+        value
+      end
+
+      def get(key)
+        @store[key.to_s]
+      end
+
+      def delete(key)
+        @store.delete(key.to_s)
+        persist!
+      end
+
+      def keys
+        @store.keys
+      end
+
+      def all
+        @store.dup
+      end
+
+      def clear!
+        @store = {}
+        persist!
+      end
+
+      # Active goals tracking
+      def set_goal(description)
+        goals = @store.fetch("_goals", [])
+        goals << { description: description, status: "active", added_at: Time.now.iso8601 }
+        set("_goals", goals)
+      end
+
+      def complete_goal(description)
+        goals = @store.fetch("_goals", [])
+        goals.each { |g| g[:status] = "done" if g[:description] == description }
+        set("_goals", goals)
+      end
+
+      def active_goals
+        @store.fetch("_goals", []).select { |g| g[:status] == "active" }
+      end
+
+      private
+
+      def memory_dir
+        File.join(@root, ".ollama_agent", "memory")
+      end
+
+      def memory_path
+        File.join(memory_dir, "#{@session_id}.yml")
+      end
+
+      def load_or_initialize
+        return {} unless File.exist?(memory_path)
+
+        YAML.safe_load_file(memory_path, permitted_classes: [Symbol, Time]) || {}
+      rescue StandardError
+        {}
+      end
+
+      def persist!
+        FileUtils.mkdir_p(memory_dir)
+        File.write(memory_path, YAML.dump(@store))
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/ollama_agent/memory/short_term.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module Memory
+    # In-memory sliding window of recent tool calls and observations.
+    # Cleared at the end of each run. Never persisted.
+    class ShortTerm
+      DEFAULT_MAX_ENTRIES = 20
+
+      Entry = Data.define(:type, :content, :ts)
+
+      attr_reader :entries
+
+      def initialize(max: DEFAULT_MAX_ENTRIES)
+        @max     = max
+        @entries = []
+      end
+
+      # Record a new entry.
+      # @param type    [Symbol]  :tool_call, :tool_result, :observation, :reasoning
+      # @param content [Object]  anything serialisable
+      def record(type, content)
+        @entries << Entry.new(type: type.to_sym, content: content, ts: Time.now.to_f)
+        @entries.shift if @entries.size > @max
+        nil
+      end
+
+      # Return the N most recent entries.
+      def recent(n = 5)
+        @entries.last(n)
+      end
+
+      # Return all entries of a given type.
+      def by_type(type)
+        @entries.select { |e| e.type == type.to_sym }
+      end
+
+      # Last N tool calls (name + args)
+      def recent_tool_calls(n = 5)
+        by_type(:tool_call).last(n)
+      end
+
+      # True if the same tool+args was called recently (loop hint).
+      def recently_called?(tool_name, args, window: 6)
+        recent(window).any? do |e|
+          e.type == :tool_call &&
+            e.content[:tool] == tool_name.to_s &&
+            e.content[:args].to_s == args.to_s
+        end
+      end
+
+      def size
+        @entries.size
+      end
+
+      def clear!
+        @entries.clear
+        nil
+      end
+
+      def to_a
+        @entries.map(&:to_h)
+      end
+    end
+  end
+end

data/lib/ollama_agent/ollama_cloud_catalog.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module OllamaAgent
+  # Fetches the public Ollama cloud model catalog (+/api/tags+ on ollama.com).
+  #
+  # See https://docs.ollama.com/cloud — list models with +curl https://ollama.com/api/tags+.
+  # Optional +OLLAMA_API_KEY+ is sent as +Authorization: Bearer+ when set.
+  module OllamaCloudCatalog
+    DEFAULT_TAGS_URL = "https://ollama.com/api/tags"
+
+    module_function
+
+    # @param base_url [String, nil] override catalog host (default +ollama.com+ or +OLLAMA_AGENT_CLOUD_CATALOG_URL+)
+    # @param api_key [String, nil] Bearer token (default +ENV["OLLAMA_API_KEY"]+)
+    # @return [Array<String>] sorted unique model names, or empty on failure
+    def list_model_names(base_url: nil, api_key: nil, open_timeout: 5, read_timeout: 20)
+      uri = catalog_uri(base_url)
+      return [] unless uri
+
+      key = api_key_string(api_key)
+      res = http_get(uri, api_key: key, open_timeout: open_timeout, read_timeout: read_timeout)
+      return [] unless res.is_a?(Net::HTTPSuccess)
+
+      names_from_tags_json(res.body)
+    rescue StandardError
+      []
+    end
+
+    # @param body [String] raw JSON from +/api/tags+
+    # @return [Array<String>]
+    def names_from_tags_json(body)
+      parsed = JSON.parse(body.to_s)
+      models = parsed["models"] || []
+      models.filter_map { |m| m["name"] }.uniq.sort
+    end
+
+    def catalog_uri(base_url)
+      raw = base_url || ENV.fetch("OLLAMA_AGENT_CLOUD_CATALOG_URL", nil)
+      raw = DEFAULT_TAGS_URL if raw.nil? || raw.to_s.strip.empty?
+      URI(raw.to_s.strip)
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def api_key_string(api_key)
+      k = api_key || ENV.fetch("OLLAMA_API_KEY", nil)
+      k.to_s.strip
+    end
+
+    def http_get(uri, api_key:, open_timeout:, read_timeout:)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = open_timeout
+      http.read_timeout = read_timeout
+
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{api_key}" unless api_key.empty?
+
+      http.request(req)
+    end
+  end
+end

data/lib/ollama_agent/ollama_connection.rb

@@ -15,5 +15,35 @@ module OllamaAgent
       model = ModelEnv.resolved_model_from_env
       config.model = model if model
     end
+
+    # Builds an +Ollama::Client+ wrapped in {Resilience::RetryMiddleware}.
+    #
+    # @param timeout [Numeric] read/open timeout seconds
+    # @param max_attempts [Integer] retry attempts for the middleware
+    # @param base_url [String, nil] optional explicit API base URL (e.g. from +OLLAMA_HOST+); +nil+ keeps config default
+    # @param hooks [Streaming::Hooks, nil] optional hooks for retry events
+    # @param base_delay [Float, nil] backoff base; default from {Resilience::RetryMiddleware}
+    # @return [Resilience::RetryMiddleware]
+    def self.retry_wrapped_client(timeout:, max_attempts:, base_url: nil, hooks: nil, base_delay: nil)
+      require "ollama_client"
+      require_relative "resilience/retry_middleware"
+
+      inner = Ollama::Client.new(config: config_for_client(base_url: base_url, timeout: timeout))
+      Resilience::RetryMiddleware.new(
+        client: inner,
+        max_attempts: max_attempts,
+        hooks: hooks,
+        base_delay: base_delay || Resilience::RetryMiddleware::DEFAULT_BASE_DELAY
+      )
+    end
+
+    def self.config_for_client(base_url:, timeout:)
+      config = Ollama::Config.new
+      config.base_url = base_url if base_url && !base_url.to_s.strip.empty?
+      config.timeout = timeout
+      apply_env_to_config(config)
+      config
+    end
+    private_class_method :config_for_client
   end
 end

data/lib/ollama_agent/plugins/loader.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "registry"
+
+module OllamaAgent
+  module Plugins
+    # Loads plugins from:
+    #   1. OLLAMA_AGENT_PLUGINS env var (comma-separated require paths)
+    #   2. ~/.config/ollama_agent/plugins.rb  (user global plugins)
+    #   3. <project_root>/.ollama_agent/plugins.rb  (project-local plugins)
+    #   4. Gem-installed plugins with name matching "ollama_agent_*"
+    #
+    # Each loaded file is expected to call:
+    #   OllamaAgent::Plugins::Registry.register(:my_plugin) { |r| ... }
+    class Loader
+      GLOBAL_PLUGINS_PATH  = File.join(Dir.home, ".config", "ollama_agent", "plugins.rb")
+      GEM_PLUGIN_PREFIX    = "ollama_agent_"
+
+      def initialize(root: Dir.pwd, registry: nil)
+        @root     = File.expand_path(root)
+        @registry = registry || Registry.instance
+      end
+
+      # Load all applicable plugins.
+      # @param skip_gems [Boolean] skip gem-installed plugins (useful in tests)
+      # @return [Array<String>] paths/names of successfully loaded plugins
+      def load_all(skip_gems: false)
+        loaded = []
+
+        loaded.concat(load_env_plugins)
+        loaded.concat(load_file_plugin(GLOBAL_PLUGINS_PATH))
+        loaded.concat(load_file_plugin(project_plugins_path))
+        loaded.concat(load_gem_plugins) unless skip_gems
+
+        loaded
+      end
+
+      # Load a single plugin from a require path or file.
+      def load_plugin(path_or_require)
+        if File.exist?(path_or_require)
+          require File.expand_path(path_or_require)
+        else
+          require path_or_require
+        end
+        [path_or_require]
+      rescue LoadError => e
+        warn "ollama_agent: plugin load failed (#{path_or_require}): #{e.message}" if debug?
+        []
+      rescue StandardError => e
+        warn "ollama_agent: plugin error (#{path_or_require}): #{e.message}"
+        []
+      end
+
+      private
+
+      def load_env_plugins
+        env_val = ENV.fetch("OLLAMA_AGENT_PLUGINS", "").strip
+        return [] if env_val.empty?
+
+        env_val.split(",").flat_map { |p| load_plugin(p.strip) }
+      end
+
+      def load_file_plugin(path)
+        return [] unless File.exist?(path)
+
+        load_plugin(path)
+      end
+
+      def load_gem_plugins
+        return [] unless defined?(Gem)
+
+        loaded = []
+        Gem::Specification.each do |spec|
+          next unless spec.name.start_with?(GEM_PLUGIN_PREFIX)
+
+          plugin_file = File.join(spec.gem_dir, "lib", "#{spec.name}.rb")
+          next unless File.exist?(plugin_file)
+
+          loaded.concat(load_plugin(plugin_file))
+        end
+        loaded
+      rescue StandardError
+        []
+      end
+
+      def project_plugins_path
+        File.join(@root, ".ollama_agent", "plugins.rb")
+      end
+
+      def debug?
+        ENV["OLLAMA_AGENT_DEBUG"] == "1"
+      end
+    end
+  end
+end

data/lib/ollama_agent/plugins/registry.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module Plugins
+    # Central plugin registry.
+    #
+    # A plugin is any object (module, class, or struct) that can register
+    # extensions at one or more extension points.
+    #
+    # Extension points:
+    #   :tools            — Array<Tools::Base subclass instances>
+    #   :prompts          — Array<Hash { name:, content: }>
+    #   :policies         — Array<Proc(tool, args, ctx) → nil | String>
+    #   :providers        — Array<Providers::Base instances>
+    #   :postprocessors   — Array<Proc(response) → response>
+    #   :memory_adapters  — Array<Memory::Base-like objects>
+    #   :command_handlers — Array<Hash { slash_command:, handler: Proc }>
+    #
+    # @example Register a plugin inline
+    #   OllamaAgent::Plugins::Registry.register(:my_plugin) do |r|
+    #     r.extend(:tools, MyTool.new)
+    #     r.extend(:prompts, name: "code_review", content: File.read("prompts/review.md"))
+    #   end
+    class Registry
+      EXTENSION_POINTS = %i[
+        tools prompts policies providers
+        postprocessors memory_adapters command_handlers
+      ].freeze
+
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        # Delegate class methods to the singleton.
+        def register(name, plugin = nil, &block) = instance.register(name, plugin, &block)
+        def extensions_for(point)                = instance.extensions_for(point)
+        def all_tools                            = instance.extensions_for(:tools)
+        def all_prompts                          = instance.extensions_for(:prompts)
+        def all_policies                         = instance.extensions_for(:policies)
+        def all_providers                        = instance.extensions_for(:providers)
+        def all_postprocessors                   = instance.extensions_for(:postprocessors)
+        def all_command_handlers                 = instance.extensions_for(:command_handlers)
+        def plugin_names                         = instance.plugin_names
+        def reset!                               = instance.reset!
+      end
+
+      def initialize
+        reset!
+      end
+
+      # Register a plugin by name.
+      # @param name   [Symbol, String]   unique plugin identifier
+      # @param plugin [Object, nil]      plugin object (must respond to #register(registry))
+      # @param block  [Proc]             alternative: inline registration block
+      def register(name, plugin = nil, &block)
+        name = name.to_sym
+        raise ArgumentError, "Plugin #{name} is already registered" if @plugins.key?(name)
+
+        @plugins[name] = plugin
+
+        if block
+          block.call(self)
+        elsif plugin.respond_to?(:register)
+          plugin.register(self)
+        end
+      end
+
+      # Add an extension at a specific extension point.
+      # @param point   [Symbol]  one of EXTENSION_POINTS
+      # @param handler [Object]  see per-point documentation above
+      def extend(point, handler)
+        point = point.to_sym
+        unless EXTENSION_POINTS.include?(point)
+          raise ArgumentError,
+                "Unknown extension point: #{point}. Valid: #{EXTENSION_POINTS.join(", ")}"
+        end
+
+        @extensions[point] << handler
+      end
+
+      # Shorthand helpers
+      def add_tool(tool)         = extend(:tools, tool)
+      def add_prompt(hash)       = extend(:prompts, hash)
+      def add_policy(&block)     = extend(:policies, block)
+      def add_provider(provider) = extend(:providers, provider)
+      def add_command(slash_command:, &handler) = extend(:command_handlers, { slash_command: slash_command, handler: handler })
+
+      def extensions_for(point)
+        @extensions[point.to_sym].dup
+      end
+
+      def plugin_names
+        @plugins.keys
+      end
+
+      def reset!
+        @plugins    = {}
+        @extensions = Hash.new { |h, k| h[k] = [] }
+      end
+    end
+  end
+end