smart_brain 0.1.2 → 0.2.0

data/lib/smart_brain/memory_store/in_memory.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require_relative '../governance/tiers'
+require_relative '../retrievers/exact_retriever'
 
 module SmartBrain
   module MemoryStore
@@ -8,8 +10,12 @@ module SmartBrain
       OVERWRITE_TYPES = %w[preferences goals tasks].freeze
 
       def initialize
-        @by_session = Hash.new { |h, k| h[k] = [] }
+        @by_scope = Hash.new { |h, k| h[k] = [] }
         @entities_index = Hash.new { |h, k| h[k] = [] }
+        @summaries = {}
+        @events = []
+        @edges = []
+        @exact = Retrievers::ExactRetriever.new
       end
 
       def upsert(extracted)
@@ -19,7 +25,9 @@ module SmartBrain
         conflicts = []
 
         items.each do |item|
-          existing = active_item(session_id: session_id, type: item[:type], key: item[:key])
+          scope_id = item[:scope_id] || legacy_scope_id(session_id)
+          scope = item[:scope] || { type: 'session', id: session_id }
+          existing = active_item(scope_id: scope_id, type: item[:type], key: item[:key])
 
           if existing && item[:status] == 'retracted'
             existing[:status] = 'retracted'
@@ -32,47 +40,224 @@ module SmartBrain
             conflicts << { type: 'overwrite', key: item[:key], previous_memory_item_id: existing[:id] }
           end
 
-          record = item.merge(id: SecureRandom.uuid, status: item[:status] || 'active')
-          by_session[session_id] << record
-          update_entities(session_id: session_id, record: record)
-          written << record.slice(:id, :type, :key, :status, :confidence)
+          record = item.merge(
+            id: SecureRandom.uuid, status: item[:status] || 'active', session_id: session_id,
+            source_session_id: item[:source_session_id] || session_id, scope_id: scope_id, scope: scope
+          )
+          by_scope[scope_id] << record
+          update_entities(scope_id: scope_id, record: record)
+          written << record.slice(:id, :type, :key, :status, :confidence, :scope_id, :scope, :source_session_id)
         end
 
         { count: written.size, items: written, conflicts: conflicts }
       end
 
-      def active_items(session_id:)
-        by_session[session_id].select { |item| item[:status] == 'active' }
+      def active_items(session_id: nil, scope_ids: nil)
+        selected_scope_ids = normalize_scope_ids(session_id, scope_ids)
+        selected_scope_ids.flat_map { |scope_id| by_scope[scope_id] }
+                          .select { |item| item[:status] == 'active' && included_lifecycle?(item) }
       end
 
-      def entities(session_id:)
-        entities_index[session_id]
+      def entities(session_id: nil, scope_ids: nil)
+        normalize_scope_ids(session_id, scope_ids).flat_map { |scope_id| entities_index[scope_id] }
+      end
+
+      # Substring/exact search over active memory_items. Mirrors the FTS path of
+      # MemoryStore::Postgres#search_memory so MemoryRetriever is backend-agnostic.
+      def search_memory(query:, session_id: nil, scope_ids: nil, limit:)
+        @exact.retrieve(
+          query: query, memory_items: active_items(session_id: session_id, scope_ids: scope_ids), recent_turns: [], limit: limit
+        )
+      end
+
+      def save_summary(session_id:, summary:)
+        summaries[session_id] = summary
+        summary
+      end
+
+      def latest_summary(session_id:)
+        summaries[session_id]
+      end
+
+      def all_summaries
+        summaries.each_with_object({}) { |(sid, s), h| h[sid] = s }
+      end
+
+      # --- knowledge lifecycle -------------------------------------------------
+      def create_item(session_id:, item:, scope_id: nil, scope: nil)
+        resolved_scope_id = scope_id || item[:scope_id] || legacy_scope_id(session_id)
+        record = item.merge(
+          id: SecureRandom.uuid, session_id: session_id, source_session_id: item[:source_session_id] || session_id,
+          scope_id: resolved_scope_id, scope: scope || item[:scope] || { type: 'session', id: session_id }
+        )
+        by_scope[resolved_scope_id] << record
+        update_entities(scope_id: resolved_scope_id, record: record)
+        record
+      end
+
+      def find_item(id:)
+        by_scope.values.flatten.find { |i| i[:id] == id }
+      end
+
+      def set_lifecycle(id:, lifecycle_status:, merge_value: nil)
+        item = find_item(id: id)
+        return nil unless item
+
+        item[:lifecycle_status] = lifecycle_status
+        item[:value_json] = (item[:value_json] || {}).merge(merge_value || {})
+        item[:updated_at] = Time.now.utc.iso8601
+        item
+      end
+
+      def set_status(id:, status:, merge_value: nil)
+        item = find_item(id: id)
+        return nil unless item
+
+        item[:status] = status
+        item[:value_json] = (item[:value_json] || {}).merge(merge_value || {})
+        item[:updated_at] = Time.now.utc.iso8601
+        item
+      end
+
+      def record_event(memory_item_id:, event_type:, from_lifecycle: nil, to_lifecycle: nil,
+                       reason: nil, reason_type: nil, reviewer: nil, evidence_refs: [])
+        event = {
+          id: SecureRandom.uuid,
+          memory_item_id: memory_item_id,
+          event_type: event_type,
+          from_lifecycle: from_lifecycle,
+          to_lifecycle: to_lifecycle,
+          reason: reason,
+          reason_type: reason_type,
+          reviewer: reviewer,
+          evidence_refs: Array(evidence_refs),
+          created_at: Time.now.utc.iso8601
+        }
+        events << event
+        event
+      end
+
+      def events_for(memory_item_id:)
+        events.select { |e| e[:memory_item_id] == memory_item_id }
+      end
+
+      # --- knowledge graph -----------------------------------------------------
+      def add_edge(session_id:, edge:, scope_id: nil, scope: nil, source_session_id: nil)
+        resolved_scope_id = scope_id || edge[:scope_id] || legacy_scope_id(session_id)
+        record = {
+          id: SecureRandom.uuid,
+          session_id: session_id,
+          source_session_id: source_session_id || edge[:source_session_id] || session_id,
+          scope_id: resolved_scope_id,
+          scope: scope || edge[:scope] || { type: 'session', id: session_id },
+          subject: edge[:subject].to_s,
+          predicate: edge[:predicate].to_s,
+          object: edge[:object].to_s,
+          subject_entity_id: resolve_entity_id(nil, edge[:subject], scope_ids: [resolved_scope_id]),
+          object_entity_id: resolve_entity_id(nil, edge[:object], scope_ids: [resolved_scope_id]),
+          valid_from: edge[:valid_from] || Time.now.utc.iso8601,
+          valid_to: edge[:valid_to],
+          source_turn_id: edge[:source_turn_id],
+          source_memory_item_id: edge[:source_memory_item_id],
+          confidence: edge[:confidence] || 0.6,
+          status: edge[:status] || 'active',
+          meta: edge[:meta] || {},
+          created_at: Time.now.utc.iso8601
+        }
+        edges << record
+        record
+      end
+
+      def query_edges(session_id: nil, scope_ids: nil, subject: nil, predicate: nil, object: nil, include_invalid: false)
+        selected_scope_ids = normalize_scope_ids(session_id, scope_ids)
+        edges.select do |e|
+          next false unless selected_scope_ids.include?(e[:scope_id])
+          next false if !include_invalid && e[:status] != 'active'
+          next false if subject && e[:subject].downcase != subject.to_s.downcase
+          next false if predicate && e[:predicate].downcase != predicate.to_s.downcase
+          next false if object && e[:object].downcase != object.to_s.downcase
+
+          true
+        end.sort_by { |e| e[:valid_from].to_s }
+      end
+
+      def edges_for_subject(session_id: nil, scope_ids: nil, subject:)
+        query_edges(session_id: session_id, scope_ids: scope_ids, subject: subject, include_invalid: true)
+      end
+
+      def invalidate_edge(id:, reason: nil)
+        edge = edges.find { |e| e[:id] == id }
+        return nil unless edge
+
+        edge[:valid_to] = Time.now.utc.iso8601
+        edge[:status] = 'invalidated'
+        edge[:meta] = (edge[:meta] || {}).merge(invalidated_reason: reason)
+        edge
+      end
+
+      def find_edge(id:)
+        edges.find { |edge| edge[:id] == id }
+      end
+
+      def edge_stats(session_id: nil, scope_ids: nil)
+        selected_scope_ids = normalize_scope_ids(session_id, scope_ids)
+        scoped = edges.select { |e| selected_scope_ids.include?(e[:scope_id]) }
+        { total: scoped.size,
+          active: scoped.count { |e| e[:status] == 'active' },
+          invalidated: scoped.count { |e| e[:status] == 'invalidated' } }
+      end
+
+      def resolve_entity_id(session_id, name, scope_ids: nil)
+        return nil if name.nil? || name.to_s.empty?
+
+        match = entities(session_id: session_id, scope_ids: scope_ids).find do |e|
+          e[:canonical].to_s.downcase == name.to_s.downcase ||
+            e[:name].to_s.downcase == name.to_s.downcase
+        end
+        match && match[:id]
       end
 
       private
 
-      attr_reader :by_session, :entities_index
+      attr_reader :by_scope, :entities_index, :summaries, :events, :edges
 
-      def active_item(session_id:, type:, key:)
-        by_session[session_id].find { |row| row[:type] == type && row[:key] == key && row[:status] == 'active' }
+      def active_item(scope_id:, type:, key:)
+        by_scope[scope_id].find { |row| row[:type] == type && row[:key] == key && row[:status] == 'active' }
       end
 
-      def update_entities(session_id:, record:)
+      def included_lifecycle?(item)
+        Governance::Tiers::CONTEXT_LIFECYCLE.include?(item[:lifecycle_status] || 'raw')
+      end
+
+      def update_entities(scope_id:, record:)
         return unless record[:type] == 'entities'
 
         value = record[:value_json]
         canonical = value[:canonical] || value[:name]
-        existing = entities_index[session_id].find { |e| e[:canonical] == canonical && e[:kind] == value[:kind] }
+        existing = entities_index[scope_id].find { |e| e[:canonical] == canonical && e[:kind] == value[:kind] }
         return if existing
 
-        entities_index[session_id] << {
+        entities_index[scope_id] << {
           id: SecureRandom.uuid,
           name: value[:name] || canonical,
           kind: value[:kind] || 'other',
           canonical: canonical,
-          memory_item_id: record[:id]
+          memory_item_id: record[:id],
+          scope_id: record[:scope_id],
+          scope: record[:scope],
+          source_session_id: record[:source_session_id]
         }
       end
+
+      def normalize_scope_ids(session_id, scope_ids)
+        ids = Array(scope_ids).compact
+        ids = [legacy_scope_id(session_id)] if ids.empty? && session_id
+        ids
+      end
+
+      def legacy_scope_id(session_id)
+        "legacy:session:#{session_id}"
+      end
     end
   end
 end