ollama_agent 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73ed8cb32bcabdd008dee785606c96aefc9bf626a3c3a1187b7bab8ef68c9627
-  data.tar.gz: 150f32efcba0bd8602cd571654bcfc8f42b99af56873a57d792202bb957b4701
+  metadata.gz: cfef6ceb699a061d21e17bf98b94cd78ae9f25b9a0560aebdc8157bc09f87bb8
+  data.tar.gz: b9fbbc92044a421304822f26f25fdb502dbf860686c3e576aa65ec5cf488bae8
 SHA512:
-  metadata.gz: 18ce5ec435f2b8330e2684dd116bd33b9e399d93857a5469365902a19a3f99b61bf7d227df746b5bbe82d7b77c4f952b3e2ad8ac61b204498e4d07f469978de0
-  data.tar.gz: fd59f660457f2de80e949a098283b38eeccb94cb9daa757158d76d3f457a1f0926ef30f5f5e98ba864ef7504470842775c971ed0a373f48ba8e26b6b0ecdc129
+  metadata.gz: f7ca6e5d68e52c682c33503f49629a9709b23238387b8b7cc5dc2622e3f809db08c8e21a43dc80df55aae025895e9485701a03a19f9dcfbc920807bc4f551e92
+  data.tar.gz: f4aa8a0a648f42e2b2ad6f4a4adf180d5a7a42b8bb99af279d3c7aa407c96fe0ca7e59234da0ba172a3e1f132c13cad6110ea435ca9b6f8026dc559fd7541f43

data/README.md

@@ -11,13 +11,23 @@ Ruby gem that runs a **CLI coding agent** against a local [Ollama](https://ollam
 - Tool `search_code` – search code with ripgrep or grep.
 - Tool `edit_file` – apply unified diffs safely.
 - CLI built with Thor, entry point `exe/ollama_agent`.
+- **`self_review`** – self-review / improvement with a **`--mode`**:
+  - **`analysis`** (default, alias `1`) — read-only tools; report only; no writes.
+  - **`interactive`** (alias `2`, `fix`) — full tools on `--root`; you confirm each patch (like `ask`); optional `-y` / `--semi`.
+  - **`automated`** (alias `3`, `sandbox`) — temp copy, agent edits, **`bundle exec rspec`** in the sandbox, optional **`--apply`** to merge into your checkout.
+- **`improve`** — same as **`self_review --mode automated`** (you can pass **`--mode automated`** explicitly; other modes belong on **`self_review`**).
 
 ## Requirements
 
-- Ruby ≥ 3.2
+- Ruby ≥ 3.2 (enforced in the gemspec as `required_ruby_version`)
 - **Local:** Ollama running and a capable tool-calling model, **or**
 - **Ollama Cloud:** API key and a cloud-capable model name (see below)
 
+### Prerequisites (external tools)
+
+- **`patch`** — required for `edit_file` (GNU `patch` on `PATH`). On Windows, use Git Bash, WSL, GnuWin32, or another environment that provides `patch`.
+- **`rg` (ripgrep) or `grep`** — text mode for `search_code` needs at least one of these on `PATH` (ripgrep is preferred when present).
+
 ## Installation
 
 From RubyGems (when published) or from this repository:
@@ -54,6 +64,23 @@ Interactive REPL:
 bundle exec ruby exe/ollama_agent ask --interactive
 ```
 
+Self-review modes (default project root is the loaded gem tree unless you set `--root` or `OLLAMA_AGENT_ROOT`):
+
+```bash
+# Mode 1 — analysis only (default)
+bundle exec ruby exe/ollama_agent self_review
+bundle exec ruby exe/ollama_agent self_review --mode analysis
+
+# Mode 2 — optional fixes in the working tree (confirm each patch, or -y / --semi)
+bundle exec ruby exe/ollama_agent self_review --mode interactive
+
+# Mode 3 — sandbox + tests + optional merge back (same as `improve`)
+bundle exec ruby exe/ollama_agent self_review --mode automated
+bundle exec ruby exe/ollama_agent improve --apply
+```
+
+For mode 3, `-y` skips all patch prompts; `--no-semi` prompts for every patch when not using `-y`.
+
 With a **thinking-capable** model, enable reasoning output:
 
 ```bash
@@ -97,6 +124,7 @@ bundle exec ruby exe/ollama_agent ask "Your task"
 | `OLLAMA_AGENT_MARKDOWN` | Set to `0` to disable Markdown formatting of assistant replies (plain text only) |
 | `OLLAMA_AGENT_THINKING_MARKDOWN` | Set to `1` to render **thinking** text with Markdown (muted); default is plain dim text inside the Thinking frame |
 | `OLLAMA_AGENT_THINK` | Model **thinking** mode for compatible models: `true` / `false`, or `high` / `medium` / `low` (see ollama-client `think:`). Empty = omit (server default). |
+| `OLLAMA_AGENT_PATCH_RISK_MAX_DIFF_LINES` | Max changed-line count before a diff is treated as "large" for semi-auto patch risk (default **80**) |
 | `OLLAMA_AGENT_INDEX_REBUILD` | Set to `1` to drop the cached Prism Ruby index before the next symbol search in this process |
 | `OLLAMA_AGENT_RUBY_INDEX_MAX_FILES` | Max `.rb` files to parse per index build (default **5000**) |
 | `OLLAMA_AGENT_RUBY_INDEX_MAX_FILE_BYTES` | Skip Ruby files larger than this many bytes (default **512000**) |

data/lib/ollama_agent/agent.rb

@@ -11,6 +11,7 @@ require_relative "tool_content_parser"
 
 module OllamaAgent
   # Runs a tool-calling loop against Ollama: read files, search, apply unified diffs.
+  # rubocop:disable Metrics/ClassLength -- Facade for chat loop, tools, and HTTP client wiring
   class Agent
     include SandboxedTools
 
@@ -21,10 +22,13 @@ module OllamaAgent
     attr_reader :client, :root
 
     # rubocop:disable Metrics/ParameterLists -- CLI and tests pass explicit dependencies
-    def initialize(client: nil, model: nil, root: nil, confirm_patches: true, http_timeout: nil, think: nil)
+    def initialize(client: nil, model: nil, root: nil, confirm_patches: true, http_timeout: nil, think: nil,
+                   read_only: false, patch_policy: nil)
       @model = model || default_model
       @root = File.expand_path(root || ENV.fetch("OLLAMA_AGENT_ROOT", Dir.pwd))
       @confirm_patches = confirm_patches
+      @read_only = read_only
+      @patch_policy = patch_policy
       @http_timeout_override = http_timeout
       @think = think
       @client = client || build_default_client
@@ -82,7 +86,7 @@ module OllamaAgent
     def chat_request_args(messages)
       args = {
         messages: messages,
-        tools: TOOLS,
+        tools: @read_only ? READ_ONLY_TOOLS : TOOLS,
         model: @model,
         options: { temperature: 0.2 }
       }
@@ -122,6 +126,8 @@ module OllamaAgent
     end
 
     def system_prompt
+      return AgentPrompt.self_review_text if @read_only
+
       AgentPrompt.text
     end
 
@@ -143,4 +149,5 @@ module OllamaAgent
       msg
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ollama_agent/agent_prompt.rb

@@ -40,5 +40,20 @@ module OllamaAgent
         them as the assistant message.
       PROMPT
     end
+
+    def self.self_review_text
+      <<~PROMPT
+        You are reviewing the ollama_agent Ruby gem. Tools available: list_files, read_file, search_code only.
+        Do not call edit_file and do not output unified diffs—this run is analysis-only.
+
+        Work only under the project root. Briefly state your plan, then use tools.
+
+        Large Ruby trees: use search_code with mode "method", "class", "module", or "constant" to locate definitions
+        via the Prism index, then read_file with start_line/end_line for only the lines you need.
+
+        Final reply: strengths, risks, and concrete suggestions with file paths (and line numbers when clear).
+        Do not paste JSON tool calls in prose; tools run only via native tool calls from the API.
+      PROMPT
+    end
   end
 end

data/lib/ollama_agent/cli.rb

@@ -6,7 +6,12 @@ require_relative "agent"
 
 module OllamaAgent
   # Thor CLI for single-shot and interactive agent sessions.
+  # rubocop:disable Metrics/ClassLength -- Thor commands and shared helpers
   class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
     desc "ask [QUERY]", "Run a natural-language task (reads, search, patch)"
     method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
     method_option :interactive, type: :boolean, aliases: "-i", desc: "Interactive REPL"
@@ -27,12 +32,164 @@ module OllamaAgent
       end
     end
 
+    desc "self_review", "Self-review / improvement: --mode analysis | interactive | automated (see help)"
+    method_option :mode, type: :string, default: "analysis",
+                         desc: "analysis (1)=read-only report; interactive (2)=confirm patches in tree; " \
+                               "automated (3)=sandbox+RSpec+optional --apply"
+    long_desc <<~HELP
+      Modes:
+        analysis     Read-only tools; prints a report; no writes (default).
+        interactive  Full tools on --root; you confirm each patch (like `ask`); optional -y / --semi.
+        automated    Temp sandbox, agent edits, `bundle exec rspec`; optional --apply to merge back.
+
+      Aliases: 1/2/3, readonly, fix, confirm, sandbox, full.
+    HELP
+    method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
+    method_option :root, type: :string, desc: "Project root (default: OLLAMA_AGENT_ROOT or gem root)"
+    method_option :timeout, type: :numeric, aliases: "-t", desc: "HTTP timeout seconds (default 120)"
+    method_option :think, type: :string, desc: "Thinking mode: true|false|high|medium|low (see OLLAMA_AGENT_THINK)"
+    method_option :yes, type: :boolean, aliases: "-y",
+                        desc: "interactive/automated: apply patches without confirmation"
+    method_option :semi, type: :boolean, default: true,
+                         desc: "interactive/automated: auto-approve obvious patches; prompt for risky (default: true)"
+    method_option :apply, type: :boolean, default: false,
+                          desc: "automated only: after green tests, copy changed files from sandbox into --root"
+    def self_review
+      dispatch_self_review_mode(SelfImprovement::Modes.normalize(options[:mode]))
+    end
+
+    desc "improve", "Shortcut for: self_review --mode automated"
+    method_option :mode, type: :string, default: "automated",
+                         desc: "Optional; must be automated (or 3, sandbox, full). Other modes: use self_review --mode"
+    method_option :model, type: :string, desc: "Ollama model (default: OLLAMA_AGENT_MODEL or ollama-client default)"
+    method_option :root, type: :string, desc: "Source tree to copy and test (default: OLLAMA_AGENT_ROOT or gem root)"
+    method_option :timeout, type: :numeric, aliases: "-t", desc: "HTTP timeout seconds (default 120)"
+    method_option :think, type: :string, desc: "Thinking mode: true|false|high|medium|low (see OLLAMA_AGENT_THINK)"
+    method_option :yes, type: :boolean, aliases: "-y", desc: "Apply all patches without confirmation"
+    method_option :semi, type: :boolean, default: true,
+                         desc: "Without -y: auto-approve obvious patches; prompt for risky (default: true)"
+    method_option :apply, type: :boolean, default: false,
+                          desc: "After green tests, copy changed files from sandbox into --root"
+    def improve
+      ensure_improve_mode_only_automated!
+      dispatch_self_review_mode("automated")
+    end
+
     private
 
+    def ensure_improve_mode_only_automated!
+      m = SelfImprovement::Modes.normalize(options[:mode])
+      return if m == "automated"
+
+      warn Console.error_line(improve_mode_error_message(m))
+      exit 1
+    end
+
+    def improve_mode_error_message(normalized_mode)
+      return invalid_improve_mode_message unless SelfImprovement::Modes.valid?(normalized_mode)
+
+      "Command \"improve\" only runs automated (sandbox) mode. For other modes use: " \
+        "ollama_agent self_review --mode analysis | interactive"
+    end
+
+    def invalid_improve_mode_message
+      "Invalid --mode for improve: use automated (or 3, sandbox, full). Got: #{options[:mode].inspect}"
+    end
+
+    def dispatch_self_review_mode(mode)
+      validate_self_review_mode!(mode)
+      send(:"run_mode_#{mode}")
+    end
+
+    def validate_self_review_mode!(mode)
+      return if SelfImprovement::Modes.valid?(mode)
+
+      warn Console.error_line(
+        "Invalid --mode: use analysis, interactive, or automated (or 1, 2, 3). Got: #{options[:mode].inspect}"
+      )
+      exit 1
+    end
+
+    def run_mode_analysis
+      agent = Agent.new(
+        model: options[:model],
+        root: resolved_root_for_self_review,
+        read_only: true,
+        confirm_patches: false,
+        http_timeout: options[:timeout],
+        think: options[:think]
+      )
+      SelfImprovement::Analyzer.new(agent).run
+    end
+
+    def run_mode_interactive
+      agent = Agent.new(**interactive_agent_keywords)
+      SelfImprovement::Analyzer.new(agent).run(SelfImprovement::Analyzer::INTERACTIVE_PROMPT)
+    end
+
+    def interactive_agent_keywords
+      semi = options[:semi] != false
+      {
+        model: options[:model],
+        root: resolved_root_for_self_review,
+        read_only: false,
+        confirm_patches: !options[:yes],
+        patch_policy: semi ? PatchRisk.method(:assess).to_proc : nil,
+        http_timeout: options[:timeout],
+        think: options[:think]
+      }
+    end
+
+    def run_mode_automated
+      result = SelfImprovement::Improver.new.run(**improve_run_options)
+      report_improve_result(result)
+    end
+
+    def resolved_root_for_self_review
+      raw = options[:root] || ENV.fetch("OLLAMA_AGENT_ROOT", nil)
+      base = raw.to_s.strip.empty? ? OllamaAgent.gem_root : raw
+      File.expand_path(base)
+    end
+
+    def improve_run_options
+      {
+        model: options[:model],
+        root: options[:root] || ENV.fetch("OLLAMA_AGENT_ROOT", nil),
+        yes: options[:yes],
+        semi: options[:semi] != false,
+        apply: options[:apply],
+        http_timeout: options[:timeout],
+        think: options[:think]
+      }
+    end
+
+    def report_improve_result(result)
+      unless result[:success]
+        warn Console.error_line("Tests failed in sandbox.")
+        puts result[:test_output]
+        exit 1
+      end
+
+      root = result[:source_root]
+      puts "ollama_agent: tests passed in sandbox (#{root})"
+      copied = result[:copied_to_source]
+      report_improve_copied_files(copied, root)
+      puts "ollama_agent: no changed files to copy from sandbox" if options[:apply] && copied.empty?
+    end
+
+    def report_improve_copied_files(copied, root)
+      return if copied.empty?
+
+      puts "ollama_agent: copied #{copied.size} file(s) to #{root}"
+      copied.sort.each { |rel| puts "  #{rel}" }
+    end
+
+    # Build an Agent for the `ask` command.
+    # Use the same root resolution as other commands, falling back to the gem root.
     def build_agent
       Agent.new(
         model: options[:model],
-        root: options[:root],
+        root: resolved_root_for_self_review,
         confirm_patches: !options[:yes],
         http_timeout: options[:timeout],
         think: options[:think]
@@ -70,4 +227,5 @@ module OllamaAgent
       end
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ollama_agent/diff_path_validator.rb

@@ -77,7 +77,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
 

data/lib/ollama_agent/patch_risk.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  # Classifies a proposed unified diff for semi-automatic patch approval (obvious vs risky).
+  module PatchRisk
+    FORBIDDEN_PATTERNS = [
+      /\beval\s*\(/,
+      /`rm\s+-rf/,
+      /system\s*\(\s*["']sudo/,
+      /\bFile\.delete\b/,
+      /\bKernel\.exec\b/
+    ].freeze
+
+    LARGE_DIFF_LINES = 80
+
+    module_function
+
+    def large_diff_line_limit
+      v = ENV.fetch("OLLAMA_AGENT_PATCH_RISK_MAX_DIFF_LINES", nil)
+      return LARGE_DIFF_LINES if v.nil? || v.to_s.strip.empty?
+
+      Integer(v)
+    rescue ArgumentError, TypeError
+      LARGE_DIFF_LINES
+    end
+
+    def forbidden?(diff)
+      FORBIDDEN_PATTERNS.any? { |pattern| diff.match?(pattern) }
+    end
+
+    # Returns :auto_approve (no prompt) or :require_confirmation (prompt when confirm_patches is on).
+    def assess(path, diff)
+      relative = path.to_s.tr("\\", "/")
+
+      return :require_confirmation if risky?(relative, diff)
+
+      return :auto_approve if obvious_path?(relative)
+      return :auto_approve if safe_spec_change?(relative, diff)
+
+      :require_confirmation
+    end
+
+    def risky?(relative, diff)
+      forbidden?(diff) ||
+        critical_path?(relative) ||
+        large_diff?(diff) ||
+        critical_lib_file?(relative)
+    end
+
+    def large_diff?(diff, limit: nil)
+      max = limit.nil? ? large_diff_line_limit : limit
+      diff.scan(/^[-+][^-+]/).size > max
+    end
+
+    def obvious_path?(relative)
+      relative.end_with?(".md") || relative.start_with?("docs/")
+    end
+
+    def safe_spec_change?(relative, diff)
+      relative.start_with?("spec/") && !large_diff?(diff, limit: 40)
+    end
+
+    def critical_lib_file?(relative)
+      return false unless relative.start_with?("lib/")
+
+      relative.include?("sandboxed_tools") ||
+        relative.include?("patch_support") ||
+        relative.end_with?("ollama_agent/agent.rb") ||
+        relative.end_with?("ollama_agent/tools_schema.rb")
+    end
+
+    def critical_path?(relative)
+      return true if relative.match?(/\A(Gemfile|Gemfile\.lock)\z/)
+      return true if relative.end_with?(".gemspec")
+      return true if relative == "lib/ollama_agent/version.rb"
+      return true if relative.start_with?("exe/")
+
+      false
+    end
+  end
+end

data/lib/ollama_agent/patch_support.rb

@@ -8,6 +8,8 @@ module OllamaAgent
     private
 
     def patch_dry_run(diff)
+      return patch_missing_tool_message unless patch_available?
+
       output, status = Open3.capture2e(
         "patch", "-p1", "-f", "-d", @root, "--dry-run",
         stdin_data: diff
@@ -65,6 +67,8 @@ module OllamaAgent
     end
 
     def apply_patch(diff)
+      return patch_missing_tool_message unless patch_available?
+
       output, status = Open3.capture2e(
         "patch", "-p1", "-f", "-d", @root,
         stdin_data: diff
@@ -74,5 +78,26 @@ module OllamaAgent
 
       patch_failure_message(output, dry_run: false)
     end
+
+    def patch_available?
+      return @patch_available if defined?(@patch_available)
+
+      @patch_available = patch_binary_usable?
+    end
+
+    def patch_binary_usable?
+      _, status = Open3.capture2e("patch", "--version")
+      return true if status.success?
+
+      _, which_status = Open3.capture2e("which", "patch")
+      which_status.success?
+    end
+
+    def patch_missing_tool_message
+      <<~MSG.strip
+        Error: ollama_agent: the `patch` program was not found or is not usable on PATH. edit_file requires GNU patch.
+        Install it (e.g. apt install patch, brew install gpatch), or on Windows use Git Bash, WSL, or GnuWin32.
+      MSG
+    end
   end
 end

data/lib/ollama_agent/repo_list.rb

@@ -21,7 +21,10 @@ module OllamaAgent
       paths = collect_relative_paths(base, cap)
       return "(no files listed)" if paths.empty?
 
-      paths.sort.join("\n")
+      body = paths.sort.join("\n")
+      return body unless paths.size >= cap
+
+      "#{body}\n(list truncated at #{cap} entries; pass max_entries or narrow directory)"
     end
 
     def collect_relative_paths(base, cap)

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/sandboxed_tools.rb

@@ -5,6 +5,7 @@ require "pathname"
 
 require_relative "console"
 require_relative "diff_path_validator"
+require_relative "patch_risk"
 require_relative "patch_support"
 require_relative "repo_list"
 require_relative "ruby_index_tool_support"
@@ -48,10 +49,10 @@ module OllamaAgent
       pattern = tool_arg(args, "pattern").to_s
       mode = (tool_arg(args, "mode") || "text").to_s.downcase
 
-      return search_code_ruby(pattern, mode) if ruby_search_mode?(mode)
-
       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
 
@@ -84,7 +85,8 @@ module OllamaAgent
 
     def read_file_too_large(abs)
       n = max_read_file_bytes
-      "Error reading file: file exceeds max size (#{n} bytes): #{abs}"
+      "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
@@ -137,38 +139,60 @@ module OllamaAgent
       dir = directory.to_s.empty? ? "." : directory
       return disallowed_path_message(dir) unless path_allowed?(dir)
 
-      search_with_ripgrep(pattern, dir) || search_with_grep(pattern, 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)
-      return nil unless rg_available?
-
       stdout, = Open3.capture2("rg", "-n", "--", pattern, resolve_path(directory))
       stdout.to_s
     end
 
-    def search_with_grep(pattern, directory)
+    def search_with_grep!(pattern, directory)
       stdout, = Open3.capture2("grep", "-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?
       system("which", "rg", out: File::NULL, err: File::NULL)
     end
 
+    def grep_available?
+      system("which", "grep", out: File::NULL, err: File::NULL)
+    end
+
     def edit_file(path, diff)
       return disallowed_path_message(path) unless path_allowed?(path)
+      return "edit_file is disabled in read-only mode." if @read_only
 
       diff = DiffPathValidator.normalize_diff(diff)
 
       validation = validate_edit_diff(path, diff)
       return validation if validation
 
-      return "Cancelled by user" if @confirm_patches && !user_confirms_patch?(path, diff)
+      return "Rejected: diff matches a forbidden pattern (unsafe)." if PatchRisk.forbidden?(diff)
+
+      return "Cancelled by user" if patch_confirmation_needed?(path, diff) && !user_confirms_patch?(path, diff)
 
       apply_patch(diff)
     end
 
+    def patch_confirmation_needed?(path, diff)
+      return false unless @confirm_patches
+      return true unless @patch_policy
+
+      @patch_policy.call(path, diff) == :require_confirmation
+    end
+
     def validate_edit_diff(path, diff)
       mismatch = DiffPathValidator.call(diff, @root, path)
       return log_tool_message(mismatch) if mismatch

data/lib/ollama_agent/self_improvement/analyzer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../agent"
+
+module OllamaAgent
+  module SelfImprovement
+    # Runs a read-only agent pass to review the gem (no edits).
+    class Analyzer
+      DEFAULT_PROMPT = <<~PROMPT
+        Perform a self-review of this gem: architecture, tests, clarity, and risks.
+        Use tools to inspect real files; finish with prioritized, actionable recommendations.
+      PROMPT
+
+      # Mode 2 (interactive): full tool loop on the real tree; user confirms each patch like `ask`.
+      INTERACTIVE_PROMPT = <<~PROMPT
+        You are improving the ollama_agent gem in this working tree (not a sandbox).
+        Use list_files, search_code, and read_file, then apply small unified diffs with edit_file.
+        Keep changes reviewable; prefer tests, docs, and clarity fixes.
+        When finished, summarize what you changed or suggested next.
+      PROMPT
+
+      def initialize(agent)
+        @agent = agent
+      end
+
+      def run(prompt = DEFAULT_PROMPT)
+        @agent.run(prompt)
+      end
+    end
+  end
+end

data/lib/ollama_agent/self_improvement/improver.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "pathname"
+
+require_relative "../agent"
+require_relative "../patch_risk"
+
+module OllamaAgent
+  module SelfImprovement
+    # Copies the project into a temp directory, runs the agent with optional semi-auto patch policy,
+    # runs the test suite in the sandbox, and optionally merges changed files back to the source tree.
+    # rubocop:disable Metrics/ClassLength -- orchestration + restore + merge helpers
+    class Improver
+      SANDBOX_EXCLUDE = %w[.git vendor coverage tmp .bundle .cursor node_modules .rspec_status].freeze
+
+      # Basenames never merged back from the sandbox (test runs create these; they are gitignored).
+      MERGE_SKIP_BASENAMES = %w[.rspec_status].freeze
+
+      FIX_PROMPT = <<~PROMPT
+        You are improving the ollama_agent Ruby gem in this temporary sandbox copy.
+        Use list_files, search_code, and read_file to understand the code, then edit_file with valid unified diffs.
+        Prefer small, reviewable changes: fixes, tests, docs, and clarity.
+        Minimal diffs only: fewest lines per edit_file, exact @@ counts—no whole-method or mega-hunks.
+        Do not delete Gemfile, Gemfile.lock, the gemspec, or exe/; the improve run restores those from the source
+        tree before tests, but deleting them breaks the session.
+        Do not add or rely on .rspec_status or other ignored test-artifact files; RSpec may create them during the test step.
+
+        When finished, summarize what you changed in plain language.
+      PROMPT
+
+      # rubocop:disable Metrics/ParameterLists -- mirrors CLI; keeps call sites explicit
+      # rubocop:disable Metrics/MethodLength
+      def run(model: nil, root: nil, yes: false, semi: true, apply: false, http_timeout: nil, think: nil, client: nil)
+        source_root = resolve_source_root(root)
+        sandbox_root = Dir.mktmpdir("ollama_agent_improve_")
+        policy = semi ? PatchRisk.method(:assess).to_proc : nil
+
+        begin
+          copy_project_into_sandbox(source_root, sandbox_root)
+          run_agent_session(
+            sandbox_root,
+            client: client,
+            model: model,
+            confirm_patches: !yes,
+            patch_policy: policy,
+            http_timeout: http_timeout,
+            think: think
+          )
+          restore_build_essentials_from_source(source_root, sandbox_root)
+          missing = missing_gemfile_failure(source_root, sandbox_root)
+          return build_run_result(missing, [], source_root) if missing
+
+          test_result = run_test_suite(sandbox_root)
+          copied = copy_back_if_requested(test_result, apply, sandbox_root, source_root)
+          build_run_result(test_result, copied, source_root)
+        ensure
+          FileUtils.remove_entry(sandbox_root) if sandbox_root && Dir.exist?(sandbox_root)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/ParameterLists
+
+      private
+
+      def run_agent_session(sandbox_root, **)
+        agent = Agent.new(root: sandbox_root, **)
+        agent.run(FIX_PROMPT)
+      end
+
+      def copy_back_if_requested(test_result, apply, sandbox_root, source_root)
+        return [] unless test_result[:success] && apply
+
+        merge_sandbox_into_source(sandbox_root, source_root)
+      end
+
+      def build_run_result(test_result, copied, source_root)
+        {
+          success: test_result[:success],
+          test_output: test_result[:output],
+          copied_to_source: copied,
+          source_root: source_root
+        }
+      end
+
+      def copy_project_into_sandbox(source, dest)
+        Dir.children(source).each do |entry|
+          next if SANDBOX_EXCLUDE.include?(entry)
+
+          FileUtils.cp_r(File.join(source, entry), File.join(dest, entry))
+        end
+      end
+
+      def resolve_source_root(root)
+        start_dir = normalize_improve_root(root)
+        nearest = nearest_directory_with_gemfile(start_dir)
+        nearest || start_dir
+      end
+
+      def normalize_improve_root(root)
+        return default_improve_source_root if root.nil? || root.to_s.strip.empty?
+
+        File.expand_path(root)
+      end
+
+      # Installed gems omit Gemfile (see gemspec); gem_root may not contain one. Prefer cwd / env from CLI.
+      def default_improve_source_root
+        from_cwd = nearest_directory_with_gemfile(Dir.pwd)
+        return from_cwd if from_cwd
+
+        from_gem = nearest_directory_with_gemfile(OllamaAgent.gem_root)
+        return from_gem if from_gem
+
+        OllamaAgent.gem_root
+      end
+
+      def nearest_directory_with_gemfile(start_dir)
+        dir = File.expand_path(start_dir)
+        loop do
+          return dir if File.file?(File.join(dir, "Gemfile"))
+
+          parent = File.dirname(dir)
+          return nil if parent == dir
+
+          dir = parent
+        end
+      end
+
+      def missing_gemfile_failure(source_root, sandbox_root)
+        return nil if File.file?(File.join(sandbox_root, "Gemfile"))
+
+        msg = <<~MSG
+          Cannot run tests: Gemfile is missing in the sandbox after restore from #{source_root}.
+          Run `improve` from your project checkout, set OLLAMA_AGENT_ROOT, or pass --root to a tree that contains a Gemfile.
+          (The packaged gem does not ship a Gemfile; cwd is used when gem_root has none.)
+        MSG
+        { success: false, output: msg.strip }
+      end
+
+      # The model may delete or corrupt Gemfile / lock / gemspec during edit_file; bundle needs them in the sandbox.
+      def restore_build_essentials_from_source(source, sandbox)
+        %w[Gemfile Gemfile.lock Rakefile .ruby-version].each do |name|
+          src = File.join(source, name)
+          next unless File.file?(src)
+
+          FileUtils.cp(src, File.join(sandbox, name))
+        end
+
+        Dir.glob(File.join(source, "*.gemspec")).each do |src|
+          FileUtils.cp(src, File.join(sandbox, File.basename(src)))
+        end
+      end
+
+      def run_test_suite(dir)
+        output, status = bundle_exec(dir, "rspec", "spec/")
+        return { success: true, output: output } if status.success?
+
+        install_out, install_status = bundle_install(dir)
+        combined = "#{install_out}\n#{output}"
+        return { success: false, output: combined } unless install_status.success?
+
+        output2, status2 = bundle_exec(dir, "rspec", "spec/")
+        { success: status2.success?, output: "#{combined}\n#{output2}" }
+      end
+
+      def bundle_env(dir)
+        { "BUNDLE_GEMFILE" => File.expand_path(File.join(dir, "Gemfile")) }
+      end
+
+      def bundle_exec(dir, *)
+        Open3.capture2e(bundle_env(dir), "bundle", "exec", *, chdir: dir)
+      end
+
+      def bundle_install(dir)
+        Open3.capture2e(bundle_env(dir), "bundle", "install", chdir: dir)
+      end
+
+      # rubocop:disable Metrics/MethodLength -- straight-line file copy loop
+      def merge_sandbox_into_source(sandbox, source)
+        paths = []
+        each_relative_file(sandbox) do |rel|
+          next if MERGE_SKIP_BASENAMES.include?(File.basename(rel))
+
+          src = File.join(sandbox, rel)
+          dst = File.join(source, rel)
+          next unless File.file?(src)
+          next unless file_differs?(src, dst)
+
+          FileUtils.mkdir_p(File.dirname(dst))
+          FileUtils.cp(src, dst)
+          paths << rel
+        end
+        paths
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def each_relative_file(base)
+        base_path = Pathname.new(base)
+        Dir.glob(File.join(base, "**", "*"), File::FNM_DOTMATCH).each do |abs|
+          next if File.directory?(abs)
+          next if abs.include?("#{File::SEPARATOR}vendor#{File::SEPARATOR}")
+          next if abs.include?("#{File::SEPARATOR}.git#{File::SEPARATOR}")
+
+          rel = Pathname(abs).relative_path_from(base_path).to_s
+          yield rel
+        end
+      end
+
+      def file_differs?(sandbox_file, target_file)
+        return true unless File.file?(target_file)
+
+        File.binread(sandbox_file) != File.binread(target_file)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ollama_agent/self_improvement/modes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module SelfImprovement
+    # CLI modes for self_review / improve (analysis-only, interactive fixes, automated sandbox).
+    module Modes
+      VALID = %w[analysis interactive automated].freeze
+
+      module_function
+
+      def normalize(mode)
+        case mode.to_s.strip.downcase
+        when "", "analysis", "1", "readonly", "read-only" then "analysis"
+        when "interactive", "2", "fix", "confirm" then "interactive"
+        when "automated", "3", "sandbox", "full" then "automated"
+        else mode.to_s.strip.downcase
+        end
+      end
+
+      def valid?(mode)
+        VALID.include?(mode)
+      end
+    end
+  end
+end

data/lib/ollama_agent/self_improvement.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "self_improvement/modes"
+require_relative "self_improvement/analyzer"
+require_relative "self_improvement/improver"

data/lib/ollama_agent/tool_arguments.rb

@@ -12,7 +12,18 @@ module OllamaAgent
       inner = h["parameters"] || h[:parameters]
       return h unless inner.is_a?(Hash)
 
-      inner.merge(h.except("parameters", :parameters))
+      outer = h.except("parameters", :parameters)
+      merge_parameters_with_outer(inner, outer)
+    end
+
+    def merge_parameters_with_outer(inner, outer)
+      inner.merge(outer) do |_key, inner_val, outer_val|
+        if inner_val.is_a?(Hash) && outer_val.is_a?(Hash)
+          merge_parameters_with_outer(inner_val, outer_val)
+        else
+          outer_val
+        end
+      end
     end
 
     def blank_tool_value?(value)

data/lib/ollama_agent/tools_schema.rb

@@ -75,4 +75,6 @@ module OllamaAgent
       }
     }
   ].freeze
+
+  READ_ONLY_TOOLS = TOOLS.reject { |t| t.dig(:function, :name) == "edit_file" }.freeze
 end

data/lib/ollama_agent/version.rb

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

data/lib/ollama_agent.rb

@@ -6,6 +6,13 @@ require_relative "ollama_agent/console"
 require_relative "ollama_agent/agent"
 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
+
+  def self.gem_root
+    File.expand_path("..", __dir__)
+  end
 end
+
+require_relative "ollama_agent/self_improvement"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ollama_agent
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Shubham Taywade
@@ -134,6 +134,7 @@ files:
 - lib/ollama_agent/console.rb
 - lib/ollama_agent/diff_path_validator.rb
 - lib/ollama_agent/ollama_connection.rb
+- lib/ollama_agent/patch_risk.rb
 - lib/ollama_agent/patch_support.rb
 - lib/ollama_agent/repo_list.rb
 - lib/ollama_agent/ruby_index.rb
@@ -145,6 +146,10 @@ files:
 - lib/ollama_agent/ruby_index_tool_support.rb
 - lib/ollama_agent/ruby_search_modes.rb
 - lib/ollama_agent/sandboxed_tools.rb
+- lib/ollama_agent/self_improvement.rb
+- lib/ollama_agent/self_improvement/analyzer.rb
+- lib/ollama_agent/self_improvement/improver.rb
+- lib/ollama_agent/self_improvement/modes.rb
 - lib/ollama_agent/think_param.rb
 - lib/ollama_agent/timeout_param.rb
 - lib/ollama_agent/tool_arguments.rb