agentf 0.3.0 → 0.4.1

data/lib/agentf/memory.rb

@@ -10,6 +10,8 @@ module Agentf
   module Memory
     # Redis-backed memory system for agent learning
     class RedisMemory
+      EDGE_INDEX = "edge:links"
+
       attr_reader :project
 
       def initialize(redis_url: nil, project: nil)
@@ -21,7 +23,7 @@ module Agentf
         ensure_indexes if @search_supported
       end
 
-      def store_task(content:, embedding: [], language: nil, task_type: nil, success: true, agent: "ARCHITECT")
+      def store_task(content:, embedding: [], language: nil, task_type: nil, success: true, agent: Agentf::AgentRoles::PLANNER)
         task_id = "task_#{SecureRandom.hex(4)}"
 
         data = {
@@ -42,9 +44,19 @@ module Agentf
         task_id
       end
 
-      def store_episode(type:, title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST", related_task_id: nil,
-                        metadata: {})
+      def store_episode(type:, title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER,
+                        related_task_id: nil, metadata: {}, entity_ids: [], relationships: [], parent_episode_id: nil, causal_from: nil)
         episode_id = "episode_#{SecureRandom.hex(4)}"
+        normalized_metadata = enrich_metadata(
+          metadata: metadata,
+          agent: agent,
+          type: type,
+          tags: tags,
+          entity_ids: entity_ids,
+          relationships: relationships,
+          parent_episode_id: parent_episode_id,
+          causal_from: causal_from
+        )
 
         data = {
           "id" => episode_id,
@@ -58,7 +70,11 @@ module Agentf
           "created_at" => Time.now.to_i,
           "agent" => agent,
           "related_task_id" => related_task_id || "",
-          "metadata" => metadata
+          "entity_ids" => entity_ids,
+          "relationships" => relationships,
+          "parent_episode_id" => parent_episode_id.to_s,
+          "causal_from" => causal_from.to_s,
+          "metadata" => normalized_metadata
         }
 
         key = "episodic:#{episode_id}"
@@ -79,10 +95,19 @@ module Agentf
           @client.set(key, payload)
         end
 
+        persist_relationship_edges(
+          episode_id: episode_id,
+          related_task_id: related_task_id,
+          relationships: relationships,
+          metadata: normalized_metadata,
+          tags: tags,
+          agent: agent
+        )
+
         episode_id
       end
 
-      def store_success(title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST")
+      def store_success(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
         store_episode(
           type: "success",
           title: title,
@@ -94,7 +119,7 @@ module Agentf
         )
       end
 
-      def store_pitfall(title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST")
+      def store_pitfall(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
         store_episode(
           type: "pitfall",
           title: title,
@@ -106,7 +131,7 @@ module Agentf
         )
       end
 
-      def store_lesson(title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST")
+      def store_lesson(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
         store_episode(
           type: "lesson",
           title: title,
@@ -118,7 +143,7 @@ module Agentf
         )
       end
 
-      def store_business_intent(title:, description:, constraints: [], tags: [], agent: "WORKFLOW_ENGINE", priority: 1)
+      def store_business_intent(title:, description:, constraints: [], tags: [], agent: Agentf::AgentRoles::ORCHESTRATOR, priority: 1)
         context = constraints.any? ? "Constraints: #{constraints.join('; ')}" : ""
 
         store_episode(
@@ -136,7 +161,8 @@ module Agentf
         )
       end
 
-      def store_feature_intent(title:, description:, acceptance_criteria: [], non_goals: [], tags: [], agent: "ARCHITECT", related_task_id: nil)
+      def store_feature_intent(title:, description:, acceptance_criteria: [], non_goals: [], tags: [], agent: Agentf::AgentRoles::PLANNER,
+                               related_task_id: nil)
         context_parts = []
         context_parts << "Acceptance: #{acceptance_criteria.join('; ')}" if acceptance_criteria.any?
         context_parts << "Non-goals: #{non_goals.join('; ')}" if non_goals.any?
@@ -157,7 +183,8 @@ module Agentf
         )
       end
 
-      def store_incident(title:, description:, root_cause: "", resolution: "", tags: [], agent: "DEBUGGER", business_capability: nil)
+      def store_incident(title:, description:, root_cause: "", resolution: "", tags: [], agent: Agentf::AgentRoles::INCIDENT_RESPONDER,
+                         business_capability: nil)
         store_episode(
           type: "incident",
           title: title,
@@ -174,7 +201,7 @@ module Agentf
         )
       end
 
-      def store_playbook(title:, description:, steps: [], tags: [], agent: "ARCHITECT", feature_area: nil)
+      def store_playbook(title:, description:, steps: [], tags: [], agent: Agentf::AgentRoles::PLANNER, feature_area: nil)
         store_episode(
           type: "playbook",
           title: title,
@@ -226,7 +253,7 @@ module Agentf
           query = "@type:#{type} @project:{#{@project}}"
           search_episodic(query: query, limit: limit)
         else
-          fetch_memories_without_search(limit: [limit * 4, 100].min).select { |mem| mem["type"] == type }.first(limit)
+          fetch_memories_without_search(limit: 100).select { |mem| mem["type"] == type }.first(limit)
         end
       end
 
@@ -285,6 +312,112 @@ module Agentf
         all_tags.to_a
       end
 
+      def delete_memory_by_id(id:, scope: "project", dry_run: false)
+        normalized_scope = normalize_scope(scope)
+        episode_id = normalize_episode_id(id)
+        episode_key = "episodic:#{episode_id}"
+        memory = load_episode(episode_key)
+
+        return delete_result(mode: "id", scope: normalized_scope, dry_run: dry_run, error: "Memory not found: #{id}") unless memory
+        if normalized_scope == "project" && memory["project"].to_s != @project.to_s
+          return delete_result(mode: "id", scope: normalized_scope, dry_run: dry_run, error: "Memory not in current project")
+        end
+
+        keys = [episode_key]
+        keys.concat(collect_related_edge_keys(episode_ids: [episode_id], scope: normalized_scope))
+        result = delete_keys(keys.uniq, dry_run: dry_run)
+        result.merge(
+          "mode" => "id",
+          "scope" => normalized_scope,
+          "deleted_ids" => [episode_id],
+          "filters" => {}
+        )
+      end
+
+      def delete_recent(limit: 10, scope: "project", type: nil, agent: nil, dry_run: false)
+        normalized_scope = normalize_scope(scope)
+        count = [limit.to_i, 0].max
+        return delete_result(mode: "last", scope: normalized_scope, dry_run: dry_run, deleted_ids: [], filters: { "type" => type, "agent" => agent }) if count.zero?
+
+        episodes = collect_episode_records(scope: normalized_scope, type: type, agent: agent)
+        selected = episodes.sort_by { |mem| -(mem["created_at"] || 0) }.first(count)
+        episode_ids = selected.map { |mem| mem["id"].to_s }
+        keys = selected.map { |mem| "episodic:#{mem['id']}" }
+        keys.concat(collect_related_edge_keys(episode_ids: episode_ids, scope: normalized_scope))
+        result = delete_keys(keys.uniq, dry_run: dry_run)
+        result.merge(
+          "mode" => "last",
+          "scope" => normalized_scope,
+          "deleted_ids" => episode_ids,
+          "filters" => { "type" => type, "agent" => agent }
+        )
+      end
+
+      def delete_all(scope: "project", type: nil, agent: nil, dry_run: false)
+        normalized_scope = normalize_scope(scope)
+        episodic_records = collect_episode_records(scope: normalized_scope, type: type, agent: agent)
+        episode_ids = episodic_records.map { |mem| mem["id"].to_s }
+        keys = episodic_records.map { |mem| "episodic:#{mem['id']}" }
+        keys.concat(collect_related_edge_keys(episode_ids: episode_ids, scope: normalized_scope))
+
+        if type.to_s.empty? && agent.to_s.empty?
+          keys.concat(collect_edge_keys(scope: normalized_scope))
+          keys.concat(collect_semantic_keys(scope: normalized_scope))
+        end
+
+        result = delete_keys(keys.uniq, dry_run: dry_run)
+        result.merge(
+          "mode" => "all",
+          "scope" => normalized_scope,
+          "deleted_ids" => episode_ids,
+          "filters" => { "type" => type, "agent" => agent }
+        )
+      end
+
+      def store_edge(source_id:, target_id:, relation:, weight: 1.0, tags: [], agent: Agentf::AgentRoles::ORCHESTRATOR, metadata: {})
+        edge_id = "edge_#{SecureRandom.hex(5)}"
+        data = {
+          "id" => edge_id,
+          "source_id" => source_id,
+          "target_id" => target_id,
+          "relation" => relation,
+          "weight" => weight.to_f,
+          "tags" => tags,
+          "project" => @project,
+          "agent" => agent,
+          "metadata" => metadata,
+          "created_at" => Time.now.to_i
+        }
+
+        key = "edge:#{edge_id}"
+        payload = JSON.generate(data)
+
+        if @json_supported
+          begin
+            @client.call("JSON.SET", key, ".", payload)
+          rescue Redis::CommandError => e
+            if missing_json_module?(e)
+              @json_supported = false
+              @client.set(key, payload)
+            else
+              raise
+            end
+          end
+        else
+          @client.set(key, payload)
+        end
+
+        edge_id
+      end
+
+      def neighbors(node_id:, relation: nil, depth: 1, limit: 50)
+        traverse_edges(seed_ids: [node_id], relation_filters: relation ? [relation] : nil, depth: depth, limit: limit)
+      end
+
+      def subgraph(seed_ids:, depth: 2, relation_filters: nil, limit: 200)
+        traverse_edges(seed_ids: seed_ids, relation_filters: relation_filters, depth: depth, limit: limit)
+      end
+
       def close
         @client.close
       end
@@ -295,8 +428,9 @@ module Agentf
         return unless @search_supported
 
         create_episodic_index
+        create_edge_index
       rescue Redis::CommandError => e
-        raise Redis::CommandError, "Failed to create episodic index: #{e.message}. Ensure Redis Stack with RediSearch is available." unless index_already_exists?(e)
+        raise Redis::CommandError, "Failed to create indexes: #{e.message}. Ensure Redis Stack with RediSearch is available." unless index_already_exists?(e)
       end
 
       def create_episodic_index
@@ -320,7 +454,31 @@ module Agentf
           "$.metadata.priority", "AS", "priority", "NUMERIC",
           "$.metadata.confidence", "AS", "confidence", "NUMERIC",
           "$.metadata.business_capability", "AS", "business_capability", "TAG",
-          "$.metadata.feature_area", "AS", "feature_area", "TAG"
+          "$.metadata.feature_area", "AS", "feature_area", "TAG",
+          "$.metadata.agent_role", "AS", "agent_role", "TAG",
+          "$.metadata.division", "AS", "division", "TAG",
+          "$.metadata.specialty", "AS", "specialty", "TAG",
+          "$.entity_ids[*]", "AS", "entity_ids", "TAG",
+          "$.parent_episode_id", "AS", "parent_episode_id", "TEXT",
+          "$.causal_from", "AS", "causal_from", "TEXT"
+        )
+      end
+
+      def create_edge_index
+        @client.call(
+          "FT.CREATE", EDGE_INDEX,
+          "ON", "JSON",
+          "PREFIX", "1", "edge:",
+          "SCHEMA",
+          "$.id", "AS", "id", "TEXT",
+          "$.source_id", "AS", "source_id", "TAG",
+          "$.target_id", "AS", "target_id", "TAG",
+          "$.relation", "AS", "relation", "TAG",
+          "$.project", "AS", "project", "TAG",
+          "$.agent", "AS", "agent", "TAG",
+          "$.weight", "AS", "weight", "NUMERIC",
+          "$.created_at", "AS", "created_at", "NUMERIC",
+          "$.tags", "AS", "tags", "TAG"
         )
       end
 
@@ -432,15 +590,15 @@ module Agentf
 
       def context_profile(agent)
         case agent.to_s.upcase
-        when "ARCHITECT"
+        when Agentf::AgentRoles::PLANNER
           { "preferred_types" => %w[business_intent feature_intent lesson playbook pitfall], "pitfall_penalty" => 0.1 }
-        when "SPECIALIST"
+        when Agentf::AgentRoles::ENGINEER
           { "preferred_types" => %w[playbook success lesson pitfall], "pitfall_penalty" => 0.05 }
-        when "TESTER"
+        when Agentf::AgentRoles::QA_TESTER
           { "preferred_types" => %w[lesson pitfall incident success], "pitfall_penalty" => 0.0 }
-        when "DEBUGGER"
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
           { "preferred_types" => %w[incident pitfall lesson], "pitfall_penalty" => 0.0 }
-        when "SECURITY"
+        when Agentf::AgentRoles::SECURITY_REVIEWER
           { "preferred_types" => %w[pitfall lesson incident], "pitfall_penalty" => 0.0 }
         else
           { "preferred_types" => %w[lesson pitfall success business_intent feature_intent], "pitfall_penalty" => 0.05 }
@@ -461,7 +619,7 @@ module Agentf
             confidence = 1.0 if confidence > 1.0
 
             type_score = preferred_types.include?(type) ? 1.0 : 0.25
-            agent_score = (memory["agent"] == agent || memory["agent"] == "WORKFLOW_ENGINE") ? 1.0 : 0.2
+            agent_score = (memory["agent"] == agent || memory["agent"] == Agentf::AgentRoles::ORCHESTRATOR) ? 1.0 : 0.2
             age_seconds = [now - memory.fetch("created_at", now).to_i, 0].max
             recency_score = 1.0 / (1.0 + (age_seconds / 86_400.0))
 
@@ -520,6 +678,363 @@ module Agentf
       def client_options
         { url: @redis_url }
       end
+
+      def normalize_scope(scope)
+        value = scope.to_s.strip.downcase
+        return "all" if value == "all"
+
+        "project"
+      end
+
+      def normalize_episode_id(id)
+        value = id.to_s.strip
+        value = value.sub("episodic:", "") if value.start_with?("episodic:")
+        value
+      end
+
+      def collect_episode_records(scope:, type: nil, agent: nil)
+        memories = []
+        cursor = "0"
+        loop do
+          cursor, batch = @client.scan(cursor, match: "episodic:*", count: 100)
+          batch.each do |key|
+            mem = load_episode(key)
+            next unless mem.is_a?(Hash)
+            next if scope == "project" && mem["project"].to_s != @project.to_s
+            next unless type.to_s.empty? || mem["type"].to_s == type.to_s
+            next unless agent.to_s.empty? || mem["agent"].to_s == agent.to_s
+
+            memories << mem
+          end
+          break if cursor == "0"
+        end
+        memories
+      end
+
+      def collect_related_edge_keys(episode_ids:, scope:)
+        ids = episode_ids.map(&:to_s).reject(&:empty?).to_set
+        return [] if ids.empty?
+
+        keys = []
+        cursor = "0"
+        loop do
+          cursor, batch = @client.scan(cursor, match: "edge:*", count: 100)
+          batch.each do |key|
+            edge = load_episode(key)
+            next unless edge.is_a?(Hash)
+            next if scope == "project" && edge["project"].to_s != @project.to_s
+
+            source = edge["source_id"].to_s
+            target = edge["target_id"].to_s
+            keys << key if ids.include?(source) || ids.include?(target)
+          end
+          break if cursor == "0"
+        end
+        keys
+      end
+
+      def collect_edge_keys(scope:)
+        keys = []
+        cursor = "0"
+        loop do
+          cursor, batch = @client.scan(cursor, match: "edge:*", count: 100)
+          batch.each do |key|
+            if scope == "all"
+              keys << key
+              next
+            end
+
+            edge = load_episode(key)
+            keys << key if edge.is_a?(Hash) && edge["project"].to_s == @project.to_s
+          end
+          break if cursor == "0"
+        end
+        keys
+      end
+
+      def collect_semantic_keys(scope:)
+        keys = []
+        cursor = "0"
+        loop do
+          cursor, batch = @client.scan(cursor, match: "semantic:*", count: 100)
+          batch.each do |key|
+            if scope == "all"
+              keys << key
+              next
+            end
+
+            task = @client.hgetall(key)
+            keys << key if task.is_a?(Hash) && task["project"].to_s == @project.to_s
+          end
+          break if cursor == "0"
+        end
+        keys
+      end
+
+      def delete_keys(keys, dry_run:)
+        if dry_run
+          {
+            "dry_run" => true,
+            "candidate_count" => keys.length,
+            "deleted_count" => 0,
+            "deleted_keys" => [],
+            "planned_keys" => keys
+          }
+        else
+          deleted = keys.empty? ? 0 : @client.del(*keys)
+          {
+            "dry_run" => false,
+            "candidate_count" => keys.length,
+            "deleted_count" => deleted,
+            "deleted_keys" => keys,
+            "planned_keys" => []
+          }
+        end
+      end
+
+      def delete_result(mode:, scope:, dry_run:, deleted_ids: [], filters: {}, error: nil)
+        {
+          "mode" => mode,
+          "scope" => scope,
+          "dry_run" => dry_run,
+          "candidate_count" => 0,
+          "deleted_count" => 0,
+          "deleted_keys" => [],
+          "planned_keys" => [],
+          "deleted_ids" => deleted_ids,
+          "filters" => filters,
+          "error" => error
+        }
+      end
+
+      def persist_relationship_edges(episode_id:, related_task_id:, relationships:, metadata:, tags:, agent:)
+        if related_task_id && !related_task_id.to_s.strip.empty?
+          store_edge(source_id: episode_id, target_id: related_task_id, relation: "relates_to", tags: tags, agent: agent)
+        end
+
+        Array(relationships).each do |relation|
+          next unless relation.is_a?(Hash)
+
+          target = relation["to"] || relation[:to]
+          relation_type = relation["type"] || relation[:type] || "related"
+          next if target.to_s.strip.empty?
+
+          store_edge(
+            source_id: episode_id,
+            target_id: target,
+            relation: relation_type,
+            weight: (relation["weight"] || relation[:weight] || 1.0).to_f,
+            tags: tags,
+            agent: agent,
+            metadata: { "source_metadata" => extract_metadata_slice(metadata, %w[intent_kind agent_role division]) }
+          )
+        end
+
+        parent = metadata["parent_episode_id"].to_s
+        unless parent.empty?
+          store_edge(source_id: episode_id, target_id: parent, relation: "child_of", tags: tags, agent: agent)
+        end
+
+        causal_from = metadata["causal_from"].to_s
+        unless causal_from.empty?
+          store_edge(source_id: episode_id, target_id: causal_from, relation: "caused_by", tags: tags, agent: agent)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def enrich_metadata(metadata:, agent:, type:, tags:, entity_ids:, relationships:, parent_episode_id:, causal_from:)
+        base = metadata.is_a?(Hash) ? metadata.dup : {}
+        base["agent_role"] = agent
+        base["division"] = infer_division(agent)
+        base["specialty"] = infer_specialty(agent)
+        base["capabilities"] = infer_capabilities(agent)
+        base["episode_type"] = type
+        base["tag_count"] = Array(tags).length
+        base["relationship_count"] = Array(relationships).length
+        base["entity_ids"] = Array(entity_ids)
+        base["parent_episode_id"] = parent_episode_id.to_s unless parent_episode_id.to_s.empty?
+        base["causal_from"] = causal_from.to_s unless causal_from.to_s.empty?
+        base
+      end
+
+      def infer_division(agent)
+        case agent
+        when Agentf::AgentRoles::PLANNER, Agentf::AgentRoles::ORCHESTRATOR, Agentf::AgentRoles::KNOWLEDGE_MANAGER
+          "strategy"
+        when Agentf::AgentRoles::ENGINEER, Agentf::AgentRoles::RESEARCHER, Agentf::AgentRoles::UI_ENGINEER
+          "engineering"
+        when Agentf::AgentRoles::QA_TESTER, Agentf::AgentRoles::REVIEWER, Agentf::AgentRoles::SECURITY_REVIEWER
+          "quality"
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
+          "operations"
+        else
+          "general"
+        end
+      end
+
+      def infer_specialty(agent)
+        case agent
+        when Agentf::AgentRoles::PLANNER
+          "planning"
+        when Agentf::AgentRoles::ENGINEER
+          "implementation"
+        when Agentf::AgentRoles::RESEARCHER
+          "discovery"
+        when Agentf::AgentRoles::QA_TESTER
+          "testing"
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
+          "debugging"
+        when Agentf::AgentRoles::UI_ENGINEER
+          "design-implementation"
+        when Agentf::AgentRoles::SECURITY_REVIEWER
+          "security"
+        when Agentf::AgentRoles::KNOWLEDGE_MANAGER
+          "documentation"
+        when Agentf::AgentRoles::REVIEWER
+          "review"
+        when Agentf::AgentRoles::ORCHESTRATOR
+          "orchestration"
+        else
+          "general"
+        end
+      end
+
+      def infer_capabilities(agent)
+        case agent
+        when Agentf::AgentRoles::PLANNER
+          %w[decompose prioritize plan]
+        when Agentf::AgentRoles::ENGINEER
+          %w[implement execute modify]
+        when Agentf::AgentRoles::RESEARCHER
+          %w[search map discover]
+        when Agentf::AgentRoles::QA_TESTER
+          %w[test validate report]
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
+          %w[triage diagnose remediate]
+        when Agentf::AgentRoles::UI_ENGINEER
+          %w[design implement-ui validate-ui]
+        when Agentf::AgentRoles::SECURITY_REVIEWER
+          %w[scan assess harden]
+        when Agentf::AgentRoles::KNOWLEDGE_MANAGER
+          %w[summarize document synthesize]
+        when Agentf::AgentRoles::REVIEWER
+          %w[review approve reject]
+        else
+          %w[coordinate]
+        end
+      end
+
+      def traverse_edges(seed_ids:, relation_filters:, depth:, limit:)
+        current = Array(seed_ids).compact.map(&:to_s).reject(&:empty?).uniq
+        visited_nodes = Set.new(current)
+        visited_edges = Set.new
+        layers = []
+        edges = []
+
+        depth.to_i.times do |hop|
+          break if current.empty?
+
+          next_nodes = []
+          layer_edges = []
+          current.each do |node_id|
+            fetch_edges_for(node_id: node_id, relation_filters: relation_filters, limit: limit).each do |edge|
+              edge_id = edge["id"].to_s
+              next if edge_id.empty? || visited_edges.include?(edge_id)
+
+              visited_edges << edge_id
+              layer_edges << edge
+              target = edge["target_id"].to_s
+              next if target.empty? || visited_nodes.include?(target)
+
+              visited_nodes << target
+              next_nodes << target
+            end
+          end
+          layers << { "depth" => hop + 1, "count" => layer_edges.length }
+          edges.concat(layer_edges)
+          current = next_nodes.uniq
+          break if edges.length >= limit
+        end
+
+        {
+          "seed_ids" => seed_ids,
+          "nodes" => visited_nodes.to_a,
+          "edges" => edges.first(limit),
+          "layers" => layers,
+          "count" => [edges.length, limit].min
+        }
+      end
+
+      def fetch_edges_for(node_id:, relation_filters:, limit:)
+        if @search_supported
+          query = ["@source_id:{#{escape_tag(node_id)}}", "@project:{#{escape_tag(@project)}}"]
+          if relation_filters && relation_filters.any?
+            relations = relation_filters.map { |item| escape_tag(item.to_s) }.join("|")
+            query << "@relation:{#{relations}}"
+          end
+          search_json_index(index: EDGE_INDEX, query: query.join(" "), limit: limit)
+        else
+          fetch_edges_without_search(node_id: node_id, relation_filters: relation_filters, limit: limit)
+        end
+      end
+
+      def search_json_index(index:, query:, limit:)
+        results = @client.call(
+          "FT.SEARCH", index,
+          query,
+          "SORTBY", "created_at", "DESC",
+          "LIMIT", "0", limit.to_s
+        )
+        return [] unless results && results[0] > 0
+
+        records = []
+        (2...results.length).step(2) do |i|
+          item = results[i]
+          next unless item.is_a?(Array)
+
+          item.each_with_index do |part, j|
+            next unless part == "$" && j + 1 < item.length
+
+            begin
+              records << JSON.parse(item[j + 1])
+            rescue JSON::ParserError
+              nil
+            end
+          end
+        end
+        records
+      end
+
+      def fetch_edges_without_search(node_id:, relation_filters:, limit:)
+        edges = []
+        cursor = "0"
+        loop do
+          cursor, batch = @client.scan(cursor, match: "edge:*", count: 100)
+          batch.each do |key|
+            edge = load_episode(key)
+            next unless edge.is_a?(Hash)
+            next unless edge["source_id"].to_s == node_id.to_s
+            next unless edge["project"].to_s == @project.to_s
+            next if relation_filters && relation_filters.any? && !relation_filters.include?(edge["relation"])
+
+            edges << edge
+            return edges.first(limit) if edges.length >= limit
+          end
+          break if cursor == "0"
+        end
+        edges
+      end
+
+      def escape_tag(value)
+        value.to_s.gsub(/[\-{}\[\]|\\]/) { |m| "\\#{m}" }
+      end
+
+      def extract_metadata_slice(metadata, keys)
+        keys.each_with_object({}) do |key, acc|
+          acc[key] = metadata[key] if metadata.key?(key)
+        end
+      end
     end
 
     # Convenience method