ollama_agent 0.3.0 → 1.0.0

data/lib/ollama_agent/indexing/diff_summarizer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  module Indexing
+    # Parses and summarizes unified diffs.
+    # Provides human-readable change summaries and statistics without
+    # needing the full file contents.
+    class DiffSummarizer
+      FileDiff = Data.define(:path, :additions, :deletions, :hunks, :is_new, :is_deleted, :is_rename)
+
+      # Parse a unified diff string and return structured FileDiff objects.
+      # @param diff [String] unified diff content
+      # @return [Array<FileDiff>]
+      def self.parse(diff)
+        new.parse(diff)
+      end
+
+      # Return a short human-readable summary of a diff.
+      # @param diff [String]
+      # @return [String]
+      def self.summarize(diff)
+        new.summarize(diff)
+      end
+
+      def parse(diff)
+        return [] if diff.nil? || diff.strip.empty?
+
+        file_diffs = []
+        current    = nil
+
+        diff.each_line do |line|
+          line = line.rstrip
+
+          if line.start_with?("diff --git ")
+            file_diffs << current if current
+            current = new_file_diff(line)
+
+          elsif line.start_with?("new file mode")
+            current[:is_new] = true if current
+
+          elsif line.start_with?("deleted file mode")
+            current[:is_deleted] = true if current
+
+          elsif line.start_with?("rename to ")
+            current[:is_rename] = true if current
+
+          elsif line.start_with?("--- ") || line.start_with?("+++ ")
+            next  # skip --- +++ headers
+
+          elsif line.start_with?("@@")
+            current[:hunks] += 1 if current
+
+          elsif line.start_with?("+") && !line.start_with?("+++")
+            current[:additions] += 1 if current
+
+          elsif line.start_with?("-") && !line.start_with?("---")
+            current[:deletions] += 1 if current
+          end
+        end
+
+        file_diffs << current if current
+        file_diffs.compact.map { |d| build_entry(d) }
+      end
+
+      # Human-readable multi-line summary.
+      def summarize(diff)
+        parsed = parse(diff)
+        return "Empty diff" if parsed.empty?
+
+        total_add = parsed.sum(&:additions)
+        total_del = parsed.sum(&:deletions)
+        header    = "#{parsed.size} file(s) changed: +#{total_add} -#{total_del}"
+
+        lines = [header]
+        parsed.each do |fd|
+          tag = if fd.is_new      then "[new]"
+                elsif fd.is_deleted then "[deleted]"
+                elsif fd.is_rename  then "[renamed]"
+                else                     ""
+                end
+
+          lines << "  #{fd.path} #{tag} +#{fd.additions} -#{fd.deletions}"
+        end
+
+        lines.join("\n")
+      end
+
+      # Brief one-liner for embedding in prompts.
+      def one_liner(diff)
+        parsed = parse(diff)
+        return "empty diff" if parsed.empty?
+
+        paths   = parsed.map(&:path).first(3).join(", ")
+        suffix  = parsed.size > 3 ? " (+#{parsed.size - 3} more)" : ""
+        total_a = parsed.sum(&:additions)
+        total_d = parsed.sum(&:deletions)
+
+        "#{paths}#{suffix} [+#{total_a}/-#{total_d}]"
+      end
+
+      private
+
+      def new_file_diff(header_line)
+        # "diff --git a/path/to/file b/path/to/file"
+        match = header_line.match(%r{diff --git a/(.+) b/})
+        path  = match ? match[1] : header_line.split.last
+
+        { path: path, additions: 0, deletions: 0, hunks: 0,
+          is_new: false, is_deleted: false, is_rename: false }
+      end
+
+      def build_entry(d)
+        FileDiff.new(
+          path:       d[:path],
+          additions:  d[:additions],
+          deletions:  d[:deletions],
+          hunks:      d[:hunks],
+          is_new:     d[:is_new],
+          is_deleted: d[:is_deleted],
+          is_rename:  d[:is_rename]
+        )
+      end
+    end
+  end
+end

data/lib/ollama_agent/indexing/file_indexer.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "repo_scanner"
+
+module OllamaAgent
+  module Indexing
+    # Builds a searchable in-memory index of files in the repository.
+    # Extracts: file paths, function/class names (Ruby), and word tokens.
+    # Used by ContextPacker to score files for relevance to a query.
+    class FileIndexer
+      IndexEntry = Data.define(:relative_path, :language, :symbols, :tokens, :size)
+
+      MAX_FILE_BYTES = 512_000   # 500 KB — skip larger files for indexing
+
+      def initialize(root:, scanner: nil)
+        @root    = File.expand_path(root)
+        @scanner = scanner || RepoScanner.new(root: @root)
+        @index   = nil
+      end
+
+      # Build or return the cached index.
+      # @param force [Boolean] rebuild even if cached
+      # @return [Array<IndexEntry>]
+      def build(force: false)
+        return @index if @index && !force
+
+        @index = @scanner.scan.filter_map { |entry| index_file(entry) }
+      end
+
+      # Search index for entries relevant to a query string.
+      # Returns entries sorted by score (highest first).
+      # @param query      [String]
+      # @param top_n      [Integer]
+      # @param languages  [Array<Symbol>, nil]
+      def search(query, top_n: 20, languages: nil)
+        idx = build
+
+        keywords = tokenize(query).uniq
+        return idx.first(top_n) if keywords.empty?
+
+        scored = idx.map do |entry|
+          next if languages && !languages.include?(entry.language)
+
+          score = score_entry(entry, keywords)
+          [entry, score]
+        end.compact
+
+        scored.sort_by { |_, s| -s }
+              .first(top_n)
+              .map(&:first)
+      end
+
+      # Invalidate and rebuild the index.
+      def refresh!
+        build(force: true)
+      end
+
+      def indexed_count
+        build.size
+      end
+
+      private
+
+      def index_file(file_entry)
+        return nil if file_entry.size > MAX_FILE_BYTES
+
+        content = File.read(file_entry.path, encoding: "utf-8", invalid: :replace)
+        symbols = extract_symbols(content, file_entry.language)
+        tokens  = tokenize(content + " " + file_entry.relative_path)
+
+        IndexEntry.new(
+          relative_path: file_entry.relative_path,
+          language:      file_entry.language,
+          symbols:       symbols,
+          tokens:        tokens,
+          size:          file_entry.size
+        )
+      rescue StandardError
+        nil
+      end
+
+      def extract_symbols(content, language)
+        case language
+        when :ruby       then extract_ruby_symbols(content)
+        when :javascript,
+             :typescript then extract_js_symbols(content)
+        when :python     then extract_python_symbols(content)
+        else []
+        end
+      end
+
+      def extract_ruby_symbols(content)
+        symbols = []
+        content.scan(/^\s*(?:def|class|module|attr_\w+)\s+(\w+)/) { |m| symbols << m[0] }
+        symbols
+      end
+
+      def extract_js_symbols(content)
+        symbols = []
+        content.scan(/(?:function\s+|class\s+|const\s+|let\s+|var\s+)(\w+)/) { |m| symbols << m[0] }
+        symbols
+      end
+
+      def extract_python_symbols(content)
+        symbols = []
+        content.scan(/^(?:def|class)\s+(\w+)/) { |m| symbols << m[0] }
+        symbols
+      end
+
+      def tokenize(text)
+        text.downcase
+            .scan(/[a-z][a-z0-9_]{2,}/)
+            .uniq
+      end
+
+      def score_entry(entry, keywords)
+        path_tokens = tokenize(entry.relative_path)
+        sym_tokens  = entry.symbols.map(&:downcase)
+
+        keywords.sum do |kw|
+          path_match   = path_tokens.any? { |t| t.include?(kw) } ? 3 : 0
+          symbol_match = sym_tokens.any?  { |s| s.include?(kw) } ? 2 : 0
+          token_match  = entry.tokens.any? { |t| t.include?(kw) } ? 1 : 0
+          path_match + symbol_match + token_match
+        end
+      end
+    end
+  end
+end

data/lib/ollama_agent/indexing/repo_scanner.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "find"
+
+module OllamaAgent
+  module Indexing
+    # Scans a repository and returns a file inventory with language tags.
+    # Language detection is extension-based (no external gems required).
+    # Used by ContextPacker to select relevant files for the agent context.
+    class RepoScanner
+      LANGUAGE_EXTENSIONS = {
+        ruby:        %w[.rb .rake .gemspec],
+        javascript:  %w[.js .jsx .mjs .cjs],
+        typescript:  %w[.ts .tsx],
+        python:      %w[.py .pyw],
+        go:          %w[.go],
+        rust:        %w[.rs],
+        java:        %w[.java],
+        kotlin:      %w[.kt .kts],
+        swift:       %w[.swift],
+        cpp:         %w[.cpp .cc .cxx .hpp .hh .h],
+        c:           %w[.c .h],
+        csharp:      %w[.cs],
+        php:         %w[.php],
+        elixir:      %w[.ex .exs],
+        erlang:      %w[.erl .hrl],
+        haskell:     %w[.hs .lhs],
+        scala:       %w[.scala],
+        clojure:     %w[.clj .cljs .cljc],
+        shell:       %w[.sh .bash .zsh .fish],
+        yaml:        %w[.yml .yaml],
+        json:        %w[.json .jsonc],
+        toml:        %w[.toml],
+        markdown:    %w[.md .mdx .markdown],
+        html:        %w[.html .htm .xhtml],
+        css:         %w[.css .scss .sass .less],
+        sql:         %w[.sql],
+        dockerfile:  %w[Dockerfile],
+        terraform:   %w[.tf .tfvars],
+        proto:       %w[.proto]
+      }.freeze
+
+      IGNORED_DIRS = %w[
+        .git .svn .hg .bzr
+        node_modules vendor .bundle
+        tmp log coverage .nyc_output dist build out target
+        __pycache__ .pytest_cache .mypy_cache .tox venv env .venv
+        .ollama_agent .idea .vscode .cursor
+      ].freeze
+
+      IGNORED_FILES = %w[
+        Gemfile.lock yarn.lock package-lock.json pnpm-lock.yaml
+        .DS_Store Thumbs.db *.min.js *.min.css
+      ].freeze
+
+      FileEntry = Data.define(:path, :relative_path, :language, :size, :modified_at)
+
+      def initialize(root:, exclude_dirs: nil, max_file_size: 1_048_576)
+        @root            = File.expand_path(root)
+        @exclude_dirs    = (exclude_dirs || []) + IGNORED_DIRS
+        @max_file_size   = max_file_size
+        @ext_map         = build_ext_map
+      end
+
+      # Scan the repository and return FileEntry objects.
+      # @param languages [Array<Symbol>, nil]  filter to specific languages
+      # @return [Array<FileEntry>]
+      def scan(languages: nil)
+        results = []
+
+        Find.find(@root) do |path|
+          basename = File.basename(path)
+
+          if File.directory?(path)
+            Find.prune if prune_dir?(path, basename)
+            next
+          end
+
+          next unless File.file?(path)
+          next if ignored_file?(basename)
+
+          size = File.size(path)
+          next if size > @max_file_size
+
+          lang = detect_language(path)
+          next if languages && !languages.map(&:to_sym).include?(lang)
+
+          rel = path.sub("#{@root}/", "")
+          results << FileEntry.new(
+            path:          path,
+            relative_path: rel,
+            language:      lang,
+            size:          size,
+            modified_at:   File.mtime(path)
+          )
+        rescue StandardError
+          next
+        end
+
+        results.sort_by(&:relative_path)
+      end
+
+      # Summary statistics about the repository.
+      def stats
+        files = scan
+        by_lang = files.group_by(&:language)
+
+        {
+          total_files:  files.size,
+          total_bytes:  files.sum(&:size),
+          root:         @root,
+          languages:    by_lang.transform_values { |fs| { files: fs.size, bytes: fs.sum(&:size) } }
+        }
+      end
+
+      # Files most recently modified.
+      def recently_modified(n: 20)
+        scan.max_by(n, &:modified_at)
+      end
+
+      private
+
+      def build_ext_map
+        map = {}
+        LANGUAGE_EXTENSIONS.each do |lang, exts|
+          exts.each { |ext| map[ext.downcase] = lang }
+        end
+        map
+      end
+
+      def detect_language(path)
+        base = File.basename(path)
+        return :dockerfile if base == "Dockerfile"
+        return :ruby if base.match?(/\A(Rakefile|Gemfile|Guardfile|Capfile|Brewfile)\z/)
+
+        ext = File.extname(path).downcase
+        @ext_map[ext] || :other
+      end
+
+      def prune_dir?(path, basename)
+        return true if basename.start_with?(".")
+        return true if @exclude_dirs.include?(basename)
+
+        @exclude_dirs.any? { |d| path.include?("/#{d}/") || path.end_with?("/#{d}") }
+      end
+
+      def ignored_file?(basename)
+        IGNORED_FILES.any? do |pattern|
+          if pattern.include?("*")
+            File.fnmatch(pattern, basename)
+          else
+            basename == pattern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ollama_agent/memory/long_term.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require "time"
+
+module OllamaAgent
+  module Memory
+    # Persistent cross-session, cross-project memory.
+    # Stores user preferences, project facts, and reusable summaries.
+    # Backed by YAML files in ~/.config/ollama_agent/memory/<namespace>.yml
+    class LongTerm
+      DEFAULT_BASE = File.join(Dir.home, ".config", "ollama_agent", "memory")
+
+      Entry = Data.define(:key, :value, :namespace, :created_at, :updated_at)
+
+      def initialize(base_path: DEFAULT_BASE)
+        @base_path = base_path
+      end
+
+      # Store a value under key in namespace.
+      # @param key       [String]
+      # @param value     [Object]   YAML-serialisable
+      # @param namespace [String]
+      def store(key, value, namespace: "default")
+        data = load_namespace(namespace)
+        now  = Time.now.iso8601
+
+        data[key.to_s] = {
+          "value"      => value,
+          "created_at" => data.dig(key.to_s, "created_at") || now,
+          "updated_at" => now
+        }
+
+        persist_namespace(namespace, data)
+        value
+      end
+
+      # Fetch a value. Returns nil if missing.
+      def fetch(key, namespace: "default")
+        load_namespace(namespace).dig(key.to_s, "value")
+      end
+
+      # All entries in namespace as {key => value} hash.
+      def all(namespace: "default")
+        load_namespace(namespace).transform_values { |v| v["value"] }
+      end
+
+      # Delete a key.
+      def delete(key, namespace: "default")
+        data = load_namespace(namespace)
+        removed = data.delete(key.to_s)
+        persist_namespace(namespace, data) if removed
+        removed
+      end
+
+      # List all keys in a namespace.
+      def keys(namespace: "default")
+        load_namespace(namespace).keys
+      end
+
+      # Search for entries whose key or value matches a pattern.
+      def search(pattern, namespace: "default")
+        data = load_namespace(namespace)
+        re   = Regexp.new(pattern, Regexp::IGNORECASE) rescue nil
+        return {} unless re
+
+        data.select { |k, v| re.match?(k) || re.match?(v["value"].to_s) }
+            .transform_values { |v| v["value"] }
+      end
+
+      # All namespace names that have been created.
+      def namespaces
+        return [] unless File.directory?(@base_path)
+
+        Dir.glob(File.join(@base_path, "*.yml"))
+           .map { |f| File.basename(f, ".yml") }
+      end
+
+      def clear_namespace!(namespace)
+        path = namespace_path(namespace)
+        File.delete(path) if File.exist?(path)
+      end
+
+      private
+
+      def namespace_path(namespace)
+        safe = namespace.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
+        File.join(@base_path, "#{safe}.yml")
+      end
+
+      def load_namespace(namespace)
+        path = namespace_path(namespace)
+        return {} unless File.exist?(path)
+
+        YAML.safe_load_file(path) || {}
+      rescue StandardError
+        {}
+      end
+
+      def persist_namespace(namespace, data)
+        FileUtils.mkdir_p(@base_path)
+        File.write(namespace_path(namespace), YAML.dump(data))
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/ollama_agent/memory/manager.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "short_term"
+require_relative "session_memory"
+require_relative "long_term"
+
+module OllamaAgent
+  module Memory
+    # Unified memory interface exposing all three tiers.
+    #
+    # Tier semantics:
+    #   :short_term  — sliding window of the current run; cleared at run end
+    #   :session     — key-value store for this session; persisted to YAML in project dir
+    #   :long_term   — global persistent store in ~/.config/ollama_agent/memory/
+    #
+    # @example
+    #   mem = OllamaAgent::Memory::Manager.new(root: Dir.pwd, session_id: "my-session")
+    #   mem.record_tool_call("read_file", { path: "lib/agent.rb" }, "content...")
+    #   mem.remember("project_lang", "Ruby", tier: :long_term)
+    #   mem.recall("project_lang")   # => "Ruby"
+    class Manager
+      attr_reader :short_term, :session, :long_term
+
+      def initialize(root:, session_id: nil, long_term_path: nil)
+        @short_term = ShortTerm.new
+        @session    = SessionMemory.new(root: root, session_id: session_id)
+        @long_term  = LongTerm.new(base_path: long_term_path || LongTerm::DEFAULT_BASE)
+      end
+
+      # ── Short-term recording ─────────────────────────────────────────────
+
+      def record_tool_call(tool_name, args, result = nil)
+        @short_term.record(:tool_call,   { tool: tool_name.to_s, args: args })
+        @short_term.record(:tool_result, { tool: tool_name.to_s, result: result.to_s[0, 500] }) if result
+      end
+
+      def record_observation(text)
+        @short_term.record(:observation, text)
+      end
+
+      def recent_context(n = 10)
+        @short_term.recent(n)
+      end
+
+      # ── Durable memory ────────────────────────────────────────────────────
+
+      # Store a fact at the specified tier.
+      # @param key       [String]
+      # @param value     [Object]
+      # @param tier      [Symbol]  :long_term or :session
+      # @param namespace [String]  only used by long_term
+      def remember(key, value, tier: :long_term, namespace: "default")
+        case tier.to_sym
+        when :long_term then @long_term.store(key.to_s, value, namespace: namespace)
+        when :session   then @session.set(key.to_s, value)
+        else raise ArgumentError, "Unknown memory tier: #{tier}"
+        end
+      end
+
+      # Retrieve a fact from the specified tier.
+      def recall(key, tier: :long_term, namespace: "default")
+        case tier.to_sym
+        when :long_term then @long_term.fetch(key.to_s, namespace: namespace)
+        when :session   then @session.get(key.to_s)
+        else nil
+        end
+      end
+
+      # Forget a fact from the specified tier.
+      def forget(key, tier: :long_term, namespace: "default")
+        case tier.to_sym
+        when :long_term then @long_term.delete(key.to_s, namespace: namespace)
+        when :session   then @session.delete(key.to_s)
+        end
+      end
+
+      # List all keys in a tier/namespace.
+      def list(tier: :long_term, namespace: "default")
+        case tier.to_sym
+        when :long_term then @long_term.all(namespace: namespace)
+        when :session   then @session.all
+        else {}
+        end
+      end
+
+      # Search long-term memory for entries matching a pattern.
+      def search(pattern, namespace: "default")
+        @long_term.search(pattern, namespace: namespace)
+      end
+
+      # ── Goal tracking ─────────────────────────────────────────────────────
+
+      def set_goal(description)
+        @session.set_goal(description)
+      end
+
+      def complete_goal(description)
+        @session.complete_goal(description)
+      end
+
+      def active_goals
+        @session.active_goals
+      end
+
+      # ── Lifecycle ─────────────────────────────────────────────────────────
+
+      # Call at the end of each run to clear short-term memory.
+      def flush_short_term!
+        @short_term.clear!
+      end
+
+      def summary
+        {
+          short_term_entries: @short_term.size,
+          session_keys:       @session.keys.size,
+          long_term_namespaces: @long_term.namespaces.size
+        }
+      end
+    end
+  end
+end