llmemory 0.1.1

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require_relative "base"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      module Storages
+        class DatabaseStorage < Base
+          def initialize(database_url: nil)
+            @database_url = database_url || Llmemory.configuration.database_url
+            @connection = nil
+          end
+
+          def save_resource(user_id, text)
+            ensure_tables!
+            id = "res_#{SecureRandom.hex(8)}"
+            conn.exec_params(
+              "INSERT INTO llmemory_resources (id, user_id, text, created_at) VALUES ($1, $2, $3, $4)",
+              [id, user_id, text, Time.now.utc.iso8601]
+            )
+            id
+          end
+
+          def save_item(user_id, category:, content:, source_resource_id:)
+            ensure_tables!
+            id = "item_#{SecureRandom.hex(8)}"
+            conn.exec_params(
+              "INSERT INTO llmemory_items (id, user_id, category, content, source_resource_id, created_at) VALUES ($1, $2, $3, $4, $5, $6)",
+              [id, user_id, category, content, source_resource_id, Time.now.utc.iso8601]
+            )
+            id
+          end
+
+          def load_category(user_id, category_name)
+            ensure_tables!
+            result = conn.exec_params(
+              "SELECT content FROM llmemory_categories WHERE user_id = $1 AND category_name = $2",
+              [user_id, category_name]
+            )
+            result.any? ? result.first["content"].to_s : ""
+          end
+
+          def save_category(user_id, category_name, content)
+            ensure_tables!
+            conn.exec_params(
+              <<~SQL,
+                INSERT INTO llmemory_categories (user_id, category_name, content, updated_at)
+                VALUES ($1, $2, $3, $4)
+                ON CONFLICT (user_id, category_name)
+                DO UPDATE SET content = $3, updated_at = $4
+              SQL
+              [user_id, category_name, content, Time.now.utc.iso8601]
+            )
+            true
+          end
+
+          def list_categories(user_id)
+            ensure_tables!
+            conn.exec_params("SELECT category_name FROM llmemory_categories WHERE user_id = $1", [user_id])
+              .map { |r| r["category_name"] }
+          end
+
+          def search_items(user_id, query)
+            ensure_tables!
+            pattern = "%#{conn.escape_string(query.to_s.downcase)}%"
+            rows = conn.exec_params(
+              "SELECT id, category, content, source_resource_id, created_at FROM llmemory_items WHERE user_id = $1 AND LOWER(content) LIKE $2",
+              [user_id, pattern]
+            )
+            rows_to_items(rows)
+          end
+
+          def search_resources(user_id, query)
+            ensure_tables!
+            pattern = "%#{conn.escape_string(query.to_s.downcase)}%"
+            rows = conn.exec_params(
+              "SELECT id, text, created_at FROM llmemory_resources WHERE user_id = $1 AND LOWER(text) LIKE $2",
+              [user_id, pattern]
+            )
+            rows_to_resources(rows)
+          end
+
+          def get_resources_since(user_id, hours:)
+            ensure_tables!
+            cutoff = (Time.now - (hours * 3600)).utc.iso8601
+            rows = conn.exec_params(
+              "SELECT id, text, created_at FROM llmemory_resources WHERE user_id = $1 AND created_at >= $2 ORDER BY created_at",
+              [user_id, cutoff]
+            )
+            rows_to_resources(rows)
+          end
+
+          def get_items_older_than(user_id, days:)
+            ensure_tables!
+            cutoff = (Time.now - (days * 86400)).utc.iso8601
+            rows = conn.exec_params(
+              "SELECT id, category, content, source_resource_id, created_at FROM llmemory_items WHERE user_id = $1 AND created_at < $2 ORDER BY created_at",
+              [user_id, cutoff]
+            )
+            rows_to_items(rows)
+          end
+
+          def get_all_items(user_id)
+            ensure_tables!
+            rows = conn.exec_params(
+              "SELECT id, category, content, source_resource_id, created_at FROM llmemory_items WHERE user_id = $1 ORDER BY created_at",
+              [user_id]
+            )
+            rows_to_items(rows)
+          end
+
+          def get_all_resources(user_id)
+            ensure_tables!
+            rows = conn.exec_params(
+              "SELECT id, text, created_at FROM llmemory_resources WHERE user_id = $1 ORDER BY created_at",
+              [user_id]
+            )
+            rows_to_resources(rows)
+          end
+
+          def get_items_since(user_id, hours:)
+            ensure_tables!
+            cutoff = (Time.now - (hours * 3600)).utc.iso8601
+            rows = conn.exec_params(
+              "SELECT id, category, content, source_resource_id, created_at FROM llmemory_items WHERE user_id = $1 AND created_at >= $2 ORDER BY created_at",
+              [user_id, cutoff]
+            )
+            rows_to_items(rows)
+          end
+
+          def replace_items(user_id, ids_to_remove, merged_item)
+            ensure_tables!
+            ids_to_remove.each do |id|
+              conn.exec_params("DELETE FROM llmemory_items WHERE user_id = $1 AND id = $2", [user_id, id])
+            end
+            created_at = merged_item[:created_at] || Time.now
+            created_at = created_at.utc.iso8601 if created_at.respond_to?(:utc)
+            id = "item_#{SecureRandom.hex(8)}"
+            conn.exec_params(
+              "INSERT INTO llmemory_items (id, user_id, category, content, source_resource_id, created_at) VALUES ($1, $2, $3, $4, $5, $6)",
+              [
+                id,
+                user_id,
+                merged_item[:category],
+                merged_item[:content],
+                merged_item[:source_resource_id],
+                created_at
+              ]
+            )
+          end
+
+          def archive_items(user_id, item_ids)
+            ensure_tables!
+            item_ids.each { |id| conn.exec_params("DELETE FROM llmemory_items WHERE user_id = $1 AND id = $2", [user_id, id]) }
+          end
+
+          def archive_resources(user_id, resource_ids)
+            ensure_tables!
+            resource_ids.each { |id| conn.exec_params("DELETE FROM llmemory_resources WHERE user_id = $1 AND id = $2", [user_id, id]) }
+          end
+
+          private
+
+          def conn
+            @connection ||= begin
+              require "pg"
+              PG.connect(@database_url)
+            end
+          end
+
+          def ensure_tables!
+            conn.exec(<<~SQL)
+              CREATE TABLE IF NOT EXISTS llmemory_resources (
+                id TEXT NOT NULL PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                text TEXT NOT NULL,
+                created_at TIMESTAMPTZ NOT NULL
+              );
+              CREATE INDEX IF NOT EXISTS idx_llmemory_resources_user_id ON llmemory_resources(user_id);
+            SQL
+            conn.exec(<<~SQL)
+              CREATE TABLE IF NOT EXISTS llmemory_items (
+                id TEXT NOT NULL PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                category TEXT NOT NULL,
+                content TEXT NOT NULL,
+                source_resource_id TEXT,
+                created_at TIMESTAMPTZ NOT NULL
+              );
+              CREATE INDEX IF NOT EXISTS idx_llmemory_items_user_id ON llmemory_items(user_id);
+            SQL
+            conn.exec(<<~SQL)
+              CREATE TABLE IF NOT EXISTS llmemory_categories (
+                user_id TEXT NOT NULL,
+                category_name TEXT NOT NULL,
+                content TEXT NOT NULL,
+                updated_at TIMESTAMPTZ NOT NULL,
+                PRIMARY KEY (user_id, category_name)
+              );
+            SQL
+          end
+
+          def rows_to_items(rows)
+            rows.map do |r|
+              {
+                id: r["id"],
+                category: r["category"],
+                content: r["content"],
+                source_resource_id: r["source_resource_id"],
+                created_at: Time.parse(r["created_at"])
+              }
+            end
+          end
+
+          def rows_to_resources(rows)
+            rows.map do |r|
+              {
+                id: r["id"],
+                text: r["text"],
+                created_at: Time.parse(r["created_at"])
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require_relative "base"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      module Storages
+        class FileStorage < Base
+          def initialize(base_path: nil)
+            @base_path = base_path || Llmemory.configuration.long_term_storage_path || "./llmemory_data"
+            @base_path = File.expand_path(@base_path)
+          end
+
+          def save_resource(user_id, text)
+            ensure_user_dir(user_id)
+            seq = next_seq(user_id, "resource_id_seq")
+            id = "res_#{seq}"
+            path = resource_path(user_id, id)
+            data = { text: text, created_at: Time.now.iso8601 }
+            File.write(path, JSON.generate(data))
+            id
+          end
+
+          def save_item(user_id, category:, content:, source_resource_id:)
+            ensure_user_dir(user_id)
+            seq = next_seq(user_id, "item_id_seq")
+            id = "item_#{seq}"
+            path = item_path(user_id, id)
+            data = {
+              id: id,
+              category: category,
+              content: content,
+              source_resource_id: source_resource_id,
+              created_at: Time.now.iso8601
+            }
+            File.write(path, JSON.generate(data))
+            id
+          end
+
+          def load_category(user_id, category_name)
+            path = category_path(user_id, category_name)
+            return "" unless File.file?(path)
+            File.read(path)
+          end
+
+          def save_category(user_id, category_name, content)
+            ensure_user_dir(user_id, "categories")
+            path = category_path(user_id, category_name)
+            File.write(path, content)
+            true
+          end
+
+          def list_categories(user_id)
+            dir = user_path(user_id, "categories")
+            return [] unless Dir.exist?(dir)
+            Dir.children(dir).select { |f| f.end_with?(".md") }.map { |f| File.basename(f, ".md") }
+          end
+
+          def search_items(user_id, query)
+            query_lower = query.downcase
+            get_all_items(user_id).select { |i| (i[:content] || i["content"]).to_s.downcase.include?(query_lower) }
+          end
+
+          def search_resources(user_id, query)
+            query_lower = query.downcase
+            get_all_resources(user_id).select { |r| (r[:text] || r["text"]).to_s.downcase.include?(query_lower) }
+          end
+
+          def get_resources_since(user_id, hours:)
+            cutoff = Time.now - (hours * 3600)
+            get_all_resources(user_id).select { |r| parse_time(r[:created_at] || r["created_at"]) >= cutoff }
+          end
+
+          def get_items_older_than(user_id, days:)
+            cutoff = Time.now - (days * 86400)
+            get_all_items(user_id).select { |i| parse_time(i[:created_at] || i["created_at"]) < cutoff }
+          end
+
+          def get_all_items(user_id)
+            dir = user_path(user_id, "items")
+            return [] unless Dir.exist?(dir)
+            Dir.children(dir).select { |f| f.end_with?(".json") }.map do |f|
+              data = JSON.parse(File.read(File.join(dir, f)), symbolize_names: true)
+              data[:created_at] = parse_time(data[:created_at])
+              data
+            end.sort_by { |i| i[:created_at] }
+          end
+
+          def get_all_resources(user_id)
+            dir = user_path(user_id, "resources")
+            return [] unless Dir.exist?(dir)
+            Dir.children(dir).select { |f| f.end_with?(".json") }.map do |f|
+              data = JSON.parse(File.read(File.join(dir, f)), symbolize_names: true)
+              id = File.basename(f, ".json")
+              data[:id] = id
+              data[:created_at] = parse_time(data[:created_at])
+              data
+            end.sort_by { |r| r[:created_at] }
+          end
+
+          def get_items_since(user_id, hours:)
+            cutoff = Time.now - (hours * 3600)
+            get_all_items(user_id).select { |i| parse_time(i[:created_at]) >= cutoff }
+          end
+
+          def replace_items(user_id, ids_to_remove, merged_item)
+            ids_to_remove.each { |id| File.delete(item_path(user_id, id)) if File.file?(item_path(user_id, id)) }
+            merged_item = merged_item.merge(created_at: Time.now) unless merged_item.key?(:created_at)
+            seq = next_seq(user_id, "item_id_seq")
+            id = "item_#{seq}"
+            path = item_path(user_id, id)
+            data = merged_item.merge(id: id).transform_values { |v| v.respond_to?(:iso8601) ? v.iso8601 : v }
+            File.write(path, JSON.generate(data))
+          end
+
+          def archive_items(user_id, item_ids)
+            item_ids.each { |id| File.delete(item_path(user_id, id)) if File.file?(item_path(user_id, id)) }
+          end
+
+          def archive_resources(user_id, resource_ids)
+            resource_ids.each { |id| File.delete(resource_path(user_id, id)) if File.file?(resource_path(user_id, id)) }
+          end
+
+          private
+
+          def user_path(user_id, *parts)
+            safe = user_id.to_s.gsub(%r{[^\w\-.]}, "_")
+            File.join(@base_path, safe, *parts)
+          end
+
+          def resource_path(user_id, id)
+            ensure_user_dir(user_id, "resources")
+            File.join(user_path(user_id, "resources"), "#{id}.json")
+          end
+
+          def item_path(user_id, id)
+            ensure_user_dir(user_id, "items")
+            File.join(user_path(user_id, "items"), "#{id}.json")
+          end
+
+          def category_path(user_id, category_name)
+            safe = category_name.to_s.gsub(%r{[^\w\-.]}, "_")
+            File.join(user_path(user_id, "categories"), "#{safe}.md")
+          end
+
+          def ensure_user_dir(user_id, *subdirs)
+            dir = user_path(user_id, *subdirs)
+            FileUtils.mkdir_p(dir)
+          end
+
+          def meta_path(user_id)
+            File.join(user_path(user_id), "meta.json")
+          end
+
+          def next_seq(user_id, key)
+            ensure_user_dir(user_id)
+            path = meta_path(user_id)
+            meta = if File.file?(path)
+              JSON.parse(File.read(path))
+            else
+              {}
+            end
+            meta[key] = (meta[key] || 0) + 1
+            File.write(path, JSON.generate(meta))
+            meta[key]
+          end
+
+          def parse_time(val)
+            return val if val.is_a?(Time)
+            return Time.parse(val.to_s) if val
+            Time.now
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+      module Storages
+        class MemoryStorage < Base
+          def initialize
+            @resources = Hash.new { |h, k| h[k] = [] }
+            @items = Hash.new { |h, k| h[k] = [] }
+            @categories = Hash.new { |h, k| h[k] = {} }
+            @resource_id_seq = 0
+            @item_id_seq = 0
+          end
+
+          def save_resource(user_id, text)
+            @resource_id_seq += 1
+            id = "res_#{@resource_id_seq}"
+            @resources[user_id] << { id: id, text: text, created_at: Time.now }
+            id
+          end
+
+          def save_item(user_id, category:, content:, source_resource_id:)
+            @item_id_seq += 1
+            id = "item_#{@item_id_seq}"
+            @items[user_id] << {
+              id: id,
+              category: category,
+              content: content,
+              source_resource_id: source_resource_id,
+              created_at: Time.now
+            }
+            id
+          end
+
+          def load_category(user_id, category_name)
+            @categories[user_id][category_name].to_s
+          end
+
+          def save_category(user_id, category_name, content)
+            @categories[user_id][category_name] = content
+            true
+          end
+
+          def list_categories(user_id)
+            @categories[user_id].keys
+          end
+
+          def search_items(user_id, query)
+            query_lower = query.downcase
+            @items[user_id].select { |i| i[:content].to_s.downcase.include?(query_lower) }
+          end
+
+          def search_resources(user_id, query)
+            query_lower = query.downcase
+            @resources[user_id].select { |r| r[:text].to_s.downcase.include?(query_lower) }
+          end
+
+          def get_resources_since(user_id, hours:)
+            cutoff = Time.now - (hours * 3600)
+            @resources[user_id].select { |r| r[:created_at] >= cutoff }
+          end
+
+          def get_items_older_than(user_id, days:)
+            cutoff = Time.now - (days * 86400)
+            @items[user_id].select { |i| i[:created_at] < cutoff }
+          end
+
+          def get_all_items(user_id)
+            @items[user_id].dup
+          end
+
+          def get_all_resources(user_id)
+            @resources[user_id].dup
+          end
+
+          def get_items_since(user_id, hours:)
+            cutoff = Time.now - (hours * 3600)
+            @items[user_id].select { |i| i[:created_at] >= cutoff }
+          end
+
+          def replace_items(user_id, ids_to_remove, merged_item)
+            @items[user_id].reject! { |i| ids_to_remove.include?(i[:id]) }
+            @items[user_id] << merged_item.merge(created_at: Time.now)
+          end
+
+          def archive_items(user_id, item_ids)
+            @items[user_id].reject! { |i| item_ids.include?(i[:id]) }
+          end
+
+          def archive_resources(user_id, resource_ids)
+            @resources[user_id].reject! { |r| resource_ids.include?(r[:id]) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/file_based.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "file_based/resource"
+require_relative "file_based/item"
+require_relative "file_based/category"
+require_relative "file_based/storage"
+require_relative "file_based/memory"
+require_relative "file_based/retrieval"
+
+module Llmemory
+  module LongTerm
+    module FileBased
+    end
+  end
+end

data/lib/llmemory/long_term/graph_based/conflict_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "edge"
+
+module Llmemory
+  module LongTerm
+    module GraphBased
+      class ConflictResolver
+        EXCLUSIVE_PREDICATES = %w[works_at lives_in current_job current_city employer residence].freeze
+
+        def initialize(knowledge_graph)
+          @graph = knowledge_graph
+        end
+
+        def resolve(new_edge)
+          return [] unless exclusive_predicate?(new_edge.predicate)
+
+          subject_id = new_edge.subject_id
+          existing = @graph.find_edges(subject: subject_id, predicate: new_edge.predicate, include_archived: false)
+          to_archive = existing.reject { |e| e.object_id == new_edge.object_id }
+          to_archive.each do |e|
+            @graph.archive_edge(e.id, reason: "replaced by #{new_edge.object_id}")
+          end
+          to_archive.map(&:id)
+        end
+
+        def exclusive_predicate?(predicate)
+          EXCLUSIVE_PREDICATES.include?(predicate.to_s.downcase)
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/long_term/graph_based/edge.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module LongTerm
+    module GraphBased
+      Edge = Struct.new(
+        :id,
+        :user_id,
+        :subject_id,
+        :predicate,
+        :object_id,
+        :properties,
+        :created_at,
+        :archived_at,
+        keyword_init: true
+      ) do
+        def self.from_h(hash)
+          new(
+            id: hash[:id] || hash["id"],
+            user_id: hash[:user_id] || hash["user_id"],
+            subject_id: hash[:subject_id] || hash["subject_id"],
+            predicate: (hash[:predicate] || hash["predicate"]).to_s,
+            object_id: hash[:object_id] || hash["object_id"],
+            properties: hash[:properties] || hash["properties"] || {},
+            created_at: hash[:created_at] || hash["created_at"],
+            archived_at: hash[:archived_at] || hash["archived_at"]
+          )
+        end
+
+        def archived?
+          !archived_at.nil?
+        end
+
+        def to_h
+          {
+            id: id,
+            user_id: user_id,
+            subject_id: subject_id,
+            predicate: predicate,
+            object_id: object_id,
+            properties: properties || {},
+            created_at: created_at,
+            archived_at: archived_at
+          }
+        end
+      end
+    end
+  end
+end