ollama_agent 0.1.0 → 0.3.0

data/lib/ollama_agent/tool_runtime/json_extractor.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+
+module OllamaAgent
+  module ToolRuntime
+    # Pulls the first top-level JSON object from text using brace matching (strings respected).
+    module JsonExtractor
+      class << self
+        def extract_object(text)
+          raise ArgumentError, "text must be a String" unless text.is_a?(String)
+
+          start_idx = text.index("{")
+          raise JsonParseError, "no JSON object found" if start_idx.nil?
+
+          slice = extract_balanced_object(text, start_idx)
+          JSON.parse(slice)
+        rescue JSON::ParserError => e
+          raise JsonParseError, "invalid JSON: #{e.message}"
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength -- brace scanner with string/escape states
+        def extract_balanced_object(str, start_idx)
+          depth = 0
+          i = start_idx
+          in_string = false
+          escape = false
+
+          while i < str.length
+            c = str[i]
+            if escape
+              escape = false
+            elsif in_string
+              case c
+              when "\\"
+                escape = true
+              when '"'
+                in_string = false
+              end
+            else
+              case c
+              when '"'
+                in_string = true
+              when "{"
+                depth += 1
+              when "}"
+                depth -= 1
+                return str[start_idx..i] if depth.zero?
+              end
+            end
+            i += 1
+          end
+
+          raise JsonParseError, "unbalanced braces in JSON object"
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      end
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime/loop.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module ToolRuntime
+    # Think → resolve tool → execute → observe (memory); stops when a tool returns `status: "done"` or max_steps.
+    # {#run} returns the last tool result (the object returned from {Executor#execute} on the final step).
+    class Loop
+      attr_reader :max_steps, :plan_extractor
+
+      alias planner plan_extractor
+
+      # rubocop:disable Metrics/ParameterLists -- runtime wiring matches plan (planner, registry, executor, memory, logger)
+      def initialize(registry:, executor:, memory:, logger: nil, max_steps: 10, plan_extractor: nil, planner: nil)
+        @plan_extractor = plan_extractor || planner
+        raise ArgumentError, "plan_extractor or planner is required" if @plan_extractor.nil?
+
+        @registry = registry
+        @executor = executor
+        @memory = memory
+        @logger = logger
+        @max_steps = Integer(max_steps)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def run(context:)
+        steps = 0
+        final_result = nil
+        Kernel.loop do
+          raise MaxStepsExceeded, "max_steps=#{@max_steps} exceeded" if steps >= @max_steps
+
+          thought, action, final_result = plan_and_execute(context)
+          record_step(thought: thought, action: action, result: final_result)
+          break if terminated?(final_result)
+
+          steps += 1
+        end
+        final_result
+      end
+
+      private
+
+      def plan_and_execute(context)
+        thought = @plan_extractor.next_step(context: context, memory: @memory, registry: @registry)
+        action = @registry.resolve(thought)
+        raise InvalidPlanError, "invalid tool plan: #{thought.inspect}" unless action
+
+        result = @executor.execute(action)
+        [thought, action, result]
+      end
+
+      def record_step(thought:, action:, result:)
+        log_step(thought: thought, action: action, result: result)
+        @memory.append(thought: thought, action: action, result: result)
+      end
+
+      def terminated?(result)
+        return false unless result.is_a?(Hash)
+
+        status = result["status"] || result[:status]
+        status.to_s == "done"
+      end
+
+      def log_step(thought:, action:, result:)
+        return unless @logger.respond_to?(:info)
+
+        tool = action[:tool]
+        tool_name = tool.respond_to?(:name) ? tool.name : "?"
+        @logger.info("tool_runtime thought=#{thought.inspect} tool=#{tool_name} result=#{result.inspect}")
+      end
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime/memory.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module ToolRuntime
+    # Short-term transcript of planner output, resolved actions, and tool results.
+    class Memory
+      # @return [String, nil] optional text injected into planner prompts (e.g. registry descriptions)
+      attr_accessor :tool_descriptions
+
+      def initialize(limit: 10)
+        @steps = []
+        @limit = [Integer(limit), 1].max
+        @tool_descriptions = nil
+      end
+
+      def append(thought:, action:, result:)
+        @steps << { thought: thought, action: action, result: result }
+        @steps.shift while @steps.size > @limit
+      end
+
+      def recent(last_n = nil)
+        return @steps.dup if last_n.nil?
+
+        @steps.last(Integer(last_n))
+      end
+
+      def tool_descriptions_for_prompt
+        @tool_descriptions.to_s
+      end
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime/ollama_json_planner.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require "ollama_client"
+require_relative "../model_env"
+require_relative "plan_extractor"
+
+module OllamaAgent
+  module ToolRuntime
+    # Asks an Ollama chat model for the next tool call as a single JSON object.
+    class OllamaJsonPlanner
+      include PlanExtractor
+
+      # @param model [String, nil] when nil or blank, uses {OllamaAgent::ModelEnv.default_chat_model}
+      def initialize(client:, model: nil, chat_options: nil)
+        @client = client
+        @model = resolve_model(model)
+        @chat_options = chat_options || { temperature: 0.2 }
+      end
+
+      def next_step(context:, memory:, registry:)
+        prompt = build_prompt(context: context, memory: memory, registry: registry)
+        response = @client.chat(
+          model: @model,
+          messages: [{ role: "user", content: prompt }],
+          options: @chat_options
+        )
+        content = assistant_content(response)
+        JsonExtractor.extract_object(content)
+      end
+
+      private
+
+      def resolve_model(explicit)
+        s = explicit.to_s.strip
+        return s unless s.empty?
+
+        ModelEnv.default_chat_model
+      end
+
+      def build_prompt(context:, memory:, registry:)
+        ctx = context.is_a?(String) ? context : JSON.generate(context)
+        tools_block = merged_tool_descriptions(memory, registry)
+        <<~PROMPT.strip
+          You are an agent step planner. Reply with exactly one JSON object and no other text.
+          Keys: "tool" (string, required) and "args" (object, optional, default {}).
+          Use only tool names listed under Available tools.
+
+          Available tools:
+          #{tools_block}
+
+          Context:
+          #{ctx}
+
+          Prior steps (JSON):
+          #{memory_json(memory)}
+        PROMPT
+      end
+
+      def merged_tool_descriptions(memory, registry)
+        base = registry.descriptions_for_prompt
+        extra = memory.tool_descriptions_for_prompt
+        extra.empty? ? base : "#{extra}\n#{base}"
+      end
+
+      def memory_json(memory)
+        JSON.generate(memory.recent.map { |step| memory_step_row(step) })
+      end
+
+      def memory_step_row(step)
+        row = { "thought" => step[:thought], "result" => step[:result] }
+        attach_action_to_row(row, step[:action])
+        row
+      end
+
+      def attach_action_to_row(row, action)
+        return unless action.is_a?(Hash)
+
+        tool = action[:tool]
+        row["tool"] = tool.respond_to?(:name) ? tool.name : nil
+        row["args"] = action[:args]
+      end
+
+      def assistant_content(response)
+        msg = response.message
+        return "" if msg.nil?
+
+        if msg.respond_to?(:content)
+          c = msg.content
+          return c.to_s unless c.nil?
+        end
+        return msg["content"].to_s if msg.is_a?(Hash)
+
+        msg.to_s
+      end
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime/plan_extractor.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module ToolRuntime
+    # Strategy protocol for {Loop}: produce the next plan hash from context and memory.
+    #
+    # @example Contract
+    #   def next_step(context:, memory:, registry:) -> Hash
+    module PlanExtractor
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime/registry.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "json"
+
+module OllamaAgent
+  module ToolRuntime
+    # Per-run tool lookup and prompt text for available tools.
+    class Registry
+      def initialize(tools = [])
+        @tools = {}
+        Array(tools).each { |tool| register(tool) }
+      end
+
+      def register(tool)
+        raise ArgumentError, "tool must respond to #name" unless tool.respond_to?(:name)
+
+        key = tool.name.to_s
+        raise ArgumentError, "duplicate tool name: #{key}" if @tools.key?(key)
+
+        @tools[key] = tool
+      end
+
+      # @param plan [Hash] must include "tool" (or :tool); optional "args" / :args
+      # @return [Hash, nil] `{ tool: Tool instance, args: Hash }` or nil if unknown
+      def resolve(plan)
+        return nil unless plan.is_a?(Hash)
+
+        tool_name = tool_name_from(plan)
+        return nil if tool_name.nil? || tool_name.to_s.strip.empty?
+
+        tool = @tools[tool_name.to_s]
+        return nil unless tool
+
+        { tool: tool, args: normalize_args(plan) }
+      end
+
+      def descriptions_for_prompt
+        @tools.values.map do |t|
+          "#{t.name}: #{t.description} schema=#{JSON.generate(t.schema)}"
+        end.join("\n")
+      end
+
+      private
+
+      def tool_name_from(plan)
+        plan["tool"] || plan[:tool]
+      end
+
+      def normalize_args(plan)
+        args = plan["args"] || plan[:args] || {}
+        args = {} unless args.is_a?(Hash)
+        stringify_keys(args)
+      end
+
+      def stringify_keys(hash)
+        hash.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime/tool.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module ToolRuntime
+    # Plugin contract for tools used with {Registry}, {Executor}, and {Loop}.
+    class Tool
+      def name
+        raise NotImplementedError, "#{self.class} must implement #name"
+      end
+
+      def description
+        raise NotImplementedError, "#{self.class} must implement #description"
+      end
+
+      def schema
+        raise NotImplementedError, "#{self.class} must implement #schema"
+      end
+
+      def call(args)
+        raise NotImplementedError, "#{self.class} must implement #call"
+      end
+    end
+  end
+end

data/lib/ollama_agent/tool_runtime.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Generic think → act → observe loop for JSON-shaped tool plans (plugin tools).
+# Distinct from {OllamaAgent::Agent}, which uses Ollama native /api/chat tool_calls for coding.
+module OllamaAgent
+  module ToolRuntime
+    class Error < OllamaAgent::Error; end
+
+    class JsonParseError < Error; end
+
+    class InvalidPlanError < Error; end
+
+    class MaxStepsExceeded < Error; end
+  end
+end
+
+require_relative "tool_runtime/tool"
+require_relative "tool_runtime/memory"
+require_relative "tool_runtime/registry"
+require_relative "tool_runtime/executor"
+require_relative "tool_runtime/json_extractor"
+require_relative "tool_runtime/plan_extractor"
+require_relative "tool_runtime/ollama_json_planner"
+require_relative "tool_runtime/loop"

data/lib/ollama_agent/tools/registry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  # Provides tool registration and execution helpers for OllamaAgent.
+  module Tools
+    # Delegate class-methods so consumers call OllamaAgent::Tools.register(...)
+    def self.register(name, schema:, &)     = Registry.register(name, schema: schema, &)
+    def self.custom_tool?(name)             = Registry.custom_tool?(name)
+
+    def self.execute_custom(name, args, root:, read_only:)
+      Registry.execute_custom(name, args, root: root, read_only: read_only)
+    end
+
+    def self.custom_schemas                 = Registry.custom_schemas
+    def self.reset!                         = Registry.reset!
+
+    # Stores and executes custom tool definitions registered by users.
+    module Registry
+      @custom_tools = {}
+
+      class << self
+        def register(name, schema:, &handler)
+          raise ArgumentError, "handler block required" unless block_given?
+          raise ArgumentError, "schema must be a Hash" unless schema.is_a?(Hash)
+
+          @custom_tools[name.to_s] = { schema: schema, handler: handler }
+        end
+
+        def custom_tool?(name)
+          @custom_tools.key?(name.to_s)
+        end
+
+        def execute_custom(name, args, root:, read_only:)
+          entry = @custom_tools[name.to_s]
+          return "Unknown custom tool: #{name}" unless entry
+
+          entry[:handler].call(args, root: root, read_only: read_only)
+        end
+
+        def custom_schemas
+          @custom_tools.map do |name, entry|
+            {
+              type: "function",
+              function: entry[:schema].merge(name: name)
+            }
+          end
+        end
+
+        def reset!
+          @custom_tools = {}
+        end
+      end
+    end
+  end
+end

data/lib/ollama_agent/tools_schema.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-module OllamaAgent
+# Tool JSON schemas for Ollama /api/chat (base + optional orchestrator tools).
+module OllamaAgent # rubocop:disable Metrics/ModuleLength -- schema tables; splitting would scatter definitions
   # JSON tool definitions passed to Ollama /api/chat.
   TOOLS = [
     {
@@ -73,6 +74,78 @@ module OllamaAgent
           required: %w[path diff]
         }
       }
+    },
+    {
+      type: "function",
+      function: {
+        name: "write_file",
+        description: "Create or overwrite a file under the project root with full UTF-8 content. " \
+                     "Use for new files or complete rewrites. Prefer edit_file for surgical changes.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "File path relative to project root" },
+            content: { type: "string", description: "Full file content to write" }
+          },
+          required: %w[path content]
+        }
+      }
     }
   ].freeze
+
+  READ_ONLY_TOOLS = TOOLS.reject { |t| %w[edit_file write_file].include?(t.dig(:function, :name)) }.freeze
+
+  ORCHESTRATOR_LIST_TOOL = {
+    type: "function",
+    function: {
+      name: "list_external_agents",
+      description: "List configured external CLI agents (Claude, Gemini, Codex, Cursor, etc.): availability, " \
+                   "path, version, capabilities. Call before delegate_to_agent to choose an agent_id.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }
+  }.freeze
+
+  ORCHESTRATOR_DELEGATE_TOOL = {
+    type: "function",
+    function: {
+      name: "delegate_to_agent",
+      description: "Run a task via an external CLI agent (non-interactive argv only). Use after " \
+                   "list_external_agents; pass a concise task and context_summary; prefer exploring the repo " \
+                   "with read_file/search_code first to save tokens.",
+      parameters: {
+        type: "object",
+        properties: {
+          agent_id: { type: "string", description: "Registry id (e.g. claude_cli, gemini_cli)" },
+          task: { type: "string", description: "What the external agent should do" },
+          context_summary: { type: "string", description: "Short context from your own exploration" },
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional relative paths under project root to mention in the handoff"
+          },
+          timeout_seconds: {
+            type: "integer",
+            description: "Optional timeout (defaults from registry or 600)"
+          }
+        },
+        required: %w[agent_id task]
+      }
+    }
+  }.freeze
+
+  ORCHESTRATOR_TOOLS = [ORCHESTRATOR_LIST_TOOL, ORCHESTRATOR_DELEGATE_TOOL].freeze
+  ORCHESTRATOR_READ_ONLY_TOOLS = [ORCHESTRATOR_LIST_TOOL].freeze
+  ORCHESTRATOR_TOOLS_SCHEMA_VERSION = "1"
+
+  def self.tools_for(read_only:, orchestrator:)
+    base = read_only ? READ_ONLY_TOOLS : TOOLS
+    base += OllamaAgent::Tools::Registry.custom_schemas
+    return base unless orchestrator
+
+    base + (read_only ? ORCHESTRATOR_READ_ONLY_TOOLS : ORCHESTRATOR_TOOLS)
+  end
 end

data/lib/ollama_agent/user_prompt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  # Injectable stdin/stdout for patch/write/delegate confirmations (tests use StringIO).
+  # rubocop:disable Naming/PredicateMethod -- confirm_* are interactive prompts returning bool
+  class UserPrompt
+    def initialize(stdin: $stdin, stdout: $stdout)
+      @stdin = stdin
+      @stdout = stdout
+    end
+
+    def confirm_patch(path, diff)
+      @stdout.puts Console.patch_title("Proposed diff for #{path}:")
+      @stdout.puts diff
+      @stdout.print Console.apply_prompt("Apply? (y/n) ")
+      @stdin.gets.to_s.chomp.casecmp("y").zero?
+    end
+
+    def confirm_write_file(path, content_preview)
+      @stdout.puts Console.patch_title("Proposed write_file for #{path}:")
+      @stdout.puts content_preview
+      @stdout.print Console.apply_prompt("Write file? (y/n) ")
+      @stdin.gets.to_s.chomp.casecmp("y").zero?
+    end
+
+    def confirm_delegate(agent_id, task)
+      @stdout.puts Console.patch_title("Delegate to #{agent_id}:")
+      @stdout.puts task.to_s[0, 2000]
+      @stdout.puts "..." if task.to_s.length > 2000
+      @stdout.print Console.apply_prompt("Run external agent? (y/n) ")
+      @stdin.gets.to_s.chomp.casecmp("y").zero?
+    end
+  end
+  # rubocop:enable Naming/PredicateMethod
+end

data/lib/ollama_agent/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OllamaAgent
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/ollama_agent.rb

@@ -1,11 +1,36 @@
 # frozen_string_literal: true
 
 require_relative "ollama_agent/version"
+
+env_before_ollama_client = ENV.to_hash
 require "ollama_client"
+require_relative "ollama_agent/global_dotenv"
+OllamaAgent::GlobalDotenv.reconcile_after_ollama_client!(env_before_ollama_client)
+require_relative "ollama_agent/ollama_chat_thinking_stream"
 require_relative "ollama_agent/console"
+require_relative "ollama_agent/tools/registry"
+require_relative "ollama_agent/streaming/hooks"
+require_relative "ollama_agent/streaming/console_streamer"
+require_relative "ollama_agent/resilience/retry_middleware"
+require_relative "ollama_agent/resilience/audit_logger"
+require_relative "ollama_agent/context/token_counter"
+require_relative "ollama_agent/context/manager"
+require_relative "ollama_agent/session/session"
+require_relative "ollama_agent/session/store"
 require_relative "ollama_agent/agent"
+require_relative "ollama_agent/runner"
 require_relative "ollama_agent/cli"
 
+# Public namespace for the Ollama-backed coding agent gem (CLI, Agent, tools, self-improvement helpers).
 module OllamaAgent
   class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  def self.gem_root
+    File.expand_path("..", __dir__)
+  end
 end
+
+require_relative "ollama_agent/tool_runtime"
+require_relative "ollama_agent/self_improvement"

data/reproduce_429.rb

@@ -0,0 +1,40 @@
+
+require "ollama_client"
+require_relative "lib/ollama_agent"
+
+# Mock the client to raise Ollama::HTTPError
+class MockClient
+  def chat(**args)
+    # Simulate HTTP 429 error from ollama-client
+    # In ollama-client 1.1.0, handle_http_error raises HTTPError with message
+    # status is not a separate attribute in the error itself usually, 
+    # but let's see how it looks in the backtrace: 
+    # "HTTP 429: you (shubhamtaywade82) have reached your weekly usage limit"
+    raise Ollama::HTTPError.new("HTTP 429: you (shubhamtaywade82) have reached your weekly usage limit")
+  end
+end
+
+# We need to mock Ollama::Config as well because Agent calls it
+module Ollama
+  class Config
+    attr_accessor :model, :timeout
+    def initialize
+      @model = "llama3"
+      @timeout = 30
+    end
+  end
+end
+
+# Initialize agent with mock client wrapped in RetryMiddleware
+mock_client = MockClient.new
+retry_wrapped = OllamaAgent::Resilience::RetryMiddleware.new(client: mock_client, max_attempts: 2)
+agent = OllamaAgent::Agent.new(client: retry_wrapped)
+
+begin
+  agent.run("hello")
+rescue => e
+  puts "Caught error: #{e.class}: #{e.message}"
+  puts "Responds to status? #{e.respond_to?(:status)}"
+  puts "Status: #{e.status}" if e.respond_to?(:status)
+  puts e.backtrace.first(5).join("\n")
+end