llmemory 0.1.1

data/lib/llmemory/long_term/file_based/category.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      class Category
+        attr_reader :user_id, :name, :content, :updated_at
+
+        def initialize(user_id:, name:, content: "", updated_at: nil)
+          @user_id = user_id
+          @name = name
+          @content = content
+          @updated_at = updated_at || Time.now
+        end
+
+        def to_h
+          { user_id: user_id, name: name, content: content, updated_at: updated_at.iso8601 }
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/item.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      class Item
+        attr_reader :id, :user_id, :category, :content, :source_resource_id, :created_at
+
+        def initialize(id:, user_id:, category:, content:, source_resource_id: nil, created_at: nil)
+          @id = id
+          @user_id = user_id
+          @category = category
+          @content = content
+          @source_resource_id = source_resource_id
+          @created_at = created_at || Time.now
+        end
+
+        def to_h
+          {
+            id: id,
+            user_id: user_id,
+            category: category,
+            content: content,
+            source_resource_id: source_resource_id,
+            created_at: created_at.iso8601
+          }
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/memory.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "resource"
+require_relative "item"
+require_relative "category"
+require_relative "storage"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      class Memory
+        def initialize(user_id:, storage: nil, llm: nil, extractor: nil)
+          @user_id = user_id
+          @storage = storage || Storages.build
+          @llm = llm || Llmemory::LLM.client
+          @extractor = extractor || Llmemory::Extractors::FactExtractor.new(llm: @llm)
+        end
+
+        def memorize(conversation_text)
+          resource_id = save_resource(conversation_text)
+          items = @extractor.extract_items(conversation_text)
+          updates_by_category = {}
+
+          items.each do |item|
+            content = item.is_a?(Hash) ? (item["content"] || item[:content]) : item.to_s
+            cat = @extractor.classify_item(content)
+            updates_by_category[cat] ||= []
+            updates_by_category[cat] << content.to_s
+            save_item(category: cat, item: item, source_resource_id: resource_id)
+          end
+
+          updates_by_category.each do |category, new_memories|
+            existing_summary = @storage.load_category(@user_id, category)
+            updated_summary = @extractor.evolve_summary(existing: existing_summary, new_memories: new_memories)
+            @storage.save_category(@user_id, category, updated_summary)
+          end
+
+          true
+        end
+
+        def retrieve(query)
+          retrieval = Retrieval.new(user_id: @user_id, storage: @storage, llm: @llm)
+          retrieval.retrieve(query)
+        end
+
+        def search_candidates(query, user_id: nil, top_k: 20)
+          uid = user_id || @user_id
+          items = @storage.search_items(uid, query)
+          resources = @storage.search_resources(uid, query)
+          out = []
+          items.first(top_k).each do |i|
+            out << {
+              text: i[:content] || i["content"],
+              timestamp: i[:created_at] || i["created_at"],
+              score: 1.0
+            }
+          end
+          resources.first([top_k - out.size, 0].max).each do |r|
+            out << {
+              text: r[:text] || r["text"],
+              timestamp: r[:created_at] || r["created_at"],
+              score: 0.9
+            }
+          end
+          out
+        end
+
+        attr_reader :storage, :user_id
+
+        private
+
+        def save_resource(text)
+          @storage.save_resource(@user_id, text)
+        end
+
+        def save_item(category:, item:, source_resource_id:)
+          content = item.is_a?(Hash) ? item["content"] || item[:content] : item.to_s
+          @storage.save_item(@user_id, category: category, content: content, source_resource_id: source_resource_id)
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/resource.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      class Resource
+        attr_reader :id, :user_id, :text, :created_at
+
+        def initialize(id:, user_id:, text:, created_at: nil)
+          @id = id
+          @user_id = user_id
+          @text = text
+          @created_at = created_at || Time.now
+        end
+
+        def to_h
+          { id: id, user_id: user_id, text: text, created_at: created_at.iso8601 }
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/retrieval.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      class Retrieval
+        def initialize(user_id:, storage:, llm: nil)
+          @user_id = user_id
+          @storage = storage
+          @llm = llm || Llmemory::LLM.client
+        end
+
+        def retrieve(query)
+          all_categories = @storage.list_categories(@user_id)
+          return {} if all_categories.empty?
+
+          relevant_categories = select_relevant_categories(query, all_categories)
+          summaries = {}
+          relevant_categories.each { |cat| summaries[cat] = @storage.load_category(@user_id, cat) }
+
+          return summaries if is_sufficient?(query, summaries)
+
+          search_query = generate_search_query(query, summaries)
+          items = @storage.search_items(@user_id, search_query)
+          return format_items(items) if items.any?
+
+          resources = @storage.search_resources(@user_id, search_query)
+          format_resources(resources)
+        end
+
+        private
+
+        def select_relevant_categories(query, categories)
+          return categories if categories.size <= 3
+          prompt = <<~PROMPT
+            Query: #{query}
+            Available Categories: #{categories.join(', ')}
+
+            Return a JSON array of the categories most relevant to this query. Example: ["work_life", "preferences"]
+          PROMPT
+          response = @llm.invoke(prompt.strip)
+          parsed = parse_categories_response(response)
+          parsed.any? ? parsed : categories.first(3)
+        end
+
+        def parse_categories_response(response)
+          json = response.to_s.strip
+          start_idx = json.index("[")
+          return [] unless start_idx
+          end_idx = json.rindex("]")
+          return [] unless end_idx
+          arr = JSON.parse(json[start_idx..end_idx])
+          arr.is_a?(Array) ? arr.map(&:to_s) : []
+        rescue JSON::ParserError
+          []
+        end
+
+        def is_sufficient?(query, summaries)
+          return false if summaries.values.all?(&:empty?)
+          prompt = <<~PROMPT
+            Query: #{query}
+            Summaries: #{summaries.to_json}
+            Can you answer the query comprehensively with just these summaries? Reply with exactly YES or NO.
+          PROMPT
+          response = @llm.invoke(prompt.strip).upcase
+          response.include?("YES")
+        end
+
+        def generate_search_query(query, summaries)
+          prompt = <<~PROMPT
+            Query: #{query}
+            Existing summary context: #{summaries.values.join("\n")[0..500]}
+            Generate a short search phrase (3-6 words) to find specific facts. Return only the phrase.
+          PROMPT
+          @llm.invoke(prompt.strip).to_s.strip
+        end
+
+        def format_items(items)
+          items.map { |i| i[:content] || i["content"] }.compact
+        end
+
+        def format_resources(resources)
+          resources.map { |r| r[:text] || r["text"] }.compact
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/storage.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "storages/base"
+require_relative "storages/memory_storage"
+require_relative "storages/file_storage"
+require_relative "storages/database_storage"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      # Backward compatibility: Storage points to in-memory implementation.
+      # Use Storages::MemoryStorage, Storages::FileStorage, or Storages::DatabaseStorage explicitly,
+      # or build from config via Storages.build.
+      Storage = Storages::MemoryStorage
+
+      module Storages
+        def self.build(store: nil, base_path: nil, database_url: nil)
+          case (store || Llmemory.configuration.long_term_store).to_s.to_sym
+          when :memory
+            MemoryStorage.new
+          when :file
+            FileStorage.new(base_path: base_path || Llmemory.configuration.long_term_storage_path)
+          when :postgres, :database
+            DatabaseStorage.new(database_url: database_url || Llmemory.configuration.database_url)
+          when :active_record, :activerecord
+            require_relative "storages/active_record_storage"
+            ActiveRecordStorage.new
+          else
+            MemoryStorage.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/storages/active_record_models.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Models for ActiveRecordStorage. Loaded only when using store: :active_record.
+# In Rails, run: rails g llmemory:install (or create the migration manually).
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      module Storages
+        class LlmemoryResource < ::ActiveRecord::Base
+          self.table_name = "llmemory_resources"
+          self.primary_key = "id"
+        end
+
+        class LlmemoryItem < ::ActiveRecord::Base
+          self.table_name = "llmemory_items"
+          self.primary_key = "id"
+        end
+
+        class LlmemoryCategory < ::ActiveRecord::Base
+          self.table_name = "llmemory_categories"
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/storages/active_record_storage.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "base"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      module Storages
+        class ActiveRecordStorage < Base
+          def initialize
+            self.class.load_models!
+          end
+
+          def self.load_models!
+            return if @models_loaded
+            require "active_record"
+            require_relative "active_record_models"
+            @models_loaded = true
+          end
+
+          def save_resource(user_id, text)
+            id = "res_#{SecureRandom.hex(8)}"
+            LlmemoryResource.create!(
+              id: id,
+              user_id: user_id,
+              text: text,
+              created_at: Time.current
+            )
+            id
+          end
+
+          def save_item(user_id, category:, content:, source_resource_id:)
+            id = "item_#{SecureRandom.hex(8)}"
+            LlmemoryItem.create!(
+              id: id,
+              user_id: user_id,
+              category: category,
+              content: content,
+              source_resource_id: source_resource_id,
+              created_at: Time.current
+            )
+            id
+          end
+
+          def load_category(user_id, category_name)
+            rec = LlmemoryCategory.find_by(user_id: user_id, category_name: category_name)
+            rec ? rec.content.to_s : ""
+          end
+
+          def save_category(user_id, category_name, content)
+            rec = LlmemoryCategory.find_or_initialize_by(user_id: user_id, category_name: category_name)
+            rec.content = content
+            rec.updated_at = Time.current
+            rec.save!
+            true
+          end
+
+          def list_categories(user_id)
+            LlmemoryCategory.where(user_id: user_id).pluck(:category_name)
+          end
+
+          def search_items(user_id, query)
+            q = "%#{sanitize_like(query)}%"
+            LlmemoryItem.where(user_id: user_id).where("LOWER(content) LIKE LOWER(?)", q).map { |r| row_to_item(r) }
+          end
+
+          def search_resources(user_id, query)
+            q = "%#{sanitize_like(query)}%"
+            LlmemoryResource.where(user_id: user_id).where("LOWER(text) LIKE LOWER(?)", q).map { |r| row_to_resource(r) }
+          end
+
+          def get_resources_since(user_id, hours:)
+            cutoff = hours.hours.ago
+            LlmemoryResource.where(user_id: user_id).where("created_at >= ?", cutoff).order(:created_at).map { |r| row_to_resource(r) }
+          end
+
+          def get_items_older_than(user_id, days:)
+            cutoff = days.days.ago
+            LlmemoryItem.where(user_id: user_id).where("created_at < ?", cutoff).order(:created_at).map { |r| row_to_item(r) }
+          end
+
+          def get_all_items(user_id)
+            LlmemoryItem.where(user_id: user_id).order(:created_at).map { |r| row_to_item(r) }
+          end
+
+          def get_all_resources(user_id)
+            LlmemoryResource.where(user_id: user_id).order(:created_at).map { |r| row_to_resource(r) }
+          end
+
+          def get_items_since(user_id, hours:)
+            cutoff = hours.hours.ago
+            LlmemoryItem.where(user_id: user_id).where("created_at >= ?", cutoff).order(:created_at).map { |r| row_to_item(r) }
+          end
+
+          def replace_items(user_id, ids_to_remove, merged_item)
+            LlmemoryItem.where(user_id: user_id, id: ids_to_remove).destroy_all
+            created_at = merged_item[:created_at] || Time.current
+            LlmemoryItem.create!(
+              id: "item_#{SecureRandom.hex(8)}",
+              user_id: user_id,
+              category: merged_item[:category],
+              content: merged_item[:content],
+              source_resource_id: merged_item[:source_resource_id],
+              created_at: created_at
+            )
+          end
+
+          def archive_items(user_id, item_ids)
+            LlmemoryItem.where(user_id: user_id, id: item_ids).destroy_all
+          end
+
+          def archive_resources(user_id, resource_ids)
+            LlmemoryResource.where(user_id: user_id, id: resource_ids).destroy_all
+          end
+
+          private
+
+          def sanitize_like(str)
+            (str || "").to_s.gsub(/[%_\\]/) { |c| "\\#{c}" }
+          end
+
+          def row_to_item(r)
+            {
+              id: r.id,
+              category: r.category,
+              content: r.content,
+              source_resource_id: r.source_resource_id,
+              created_at: r.created_at
+            }
+          end
+
+          def row_to_resource(r)
+            {
+              id: r.id,
+              text: r.text,
+              created_at: r.created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based/storages/base.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      module Storages
+        class Base
+          def save_resource(user_id, text)
+            raise NotImplementedError, "#{self.class}#save_resource must be implemented"
+          end
+
+          def save_item(user_id, category:, content:, source_resource_id:)
+            raise NotImplementedError, "#{self.class}#save_item must be implemented"
+          end
+
+          def load_category(user_id, category_name)
+            raise NotImplementedError, "#{self.class}#load_category must be implemented"
+          end
+
+          def save_category(user_id, category_name, content)
+            raise NotImplementedError, "#{self.class}#save_category must be implemented"
+          end
+
+          def list_categories(user_id)
+            raise NotImplementedError, "#{self.class}#list_categories must be implemented"
+          end
+
+          def search_items(user_id, query)
+            raise NotImplementedError, "#{self.class}#search_items must be implemented"
+          end
+
+          def search_resources(user_id, query)
+            raise NotImplementedError, "#{self.class}#search_resources must be implemented"
+          end
+
+          def get_resources_since(user_id, hours:)
+            raise NotImplementedError, "#{self.class}#get_resources_since must be implemented"
+          end
+
+          def get_items_older_than(user_id, days:)
+            raise NotImplementedError, "#{self.class}#get_items_older_than must be implemented"
+          end
+
+          def get_all_items(user_id)
+            raise NotImplementedError, "#{self.class}#get_all_items must be implemented"
+          end
+
+          def get_all_resources(user_id)
+            raise NotImplementedError, "#{self.class}#get_all_resources must be implemented"
+          end
+
+          def get_items_since(user_id, hours:)
+            raise NotImplementedError, "#{self.class}#get_items_since must be implemented"
+          end
+
+          def replace_items(user_id, ids_to_remove, merged_item)
+            raise NotImplementedError, "#{self.class}#replace_items must be implemented"
+          end
+
+          def archive_items(user_id, item_ids)
+            raise NotImplementedError, "#{self.class}#archive_items must be implemented"
+          end
+
+          def archive_resources(user_id, resource_ids)
+            raise NotImplementedError, "#{self.class}#archive_resources must be implemented"
+          end
+        end
+      end
+    end
+  end
+end