agentf 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31fbac11988e521fb26969fc26f2da9c434541fb0ada47c1b681a6717c4ee018
-  data.tar.gz: 761c50541fc3b7207089b22ac710f07b3fd004ae984a1d46b548e92277290196
+  metadata.gz: 289cd869806a950c6bb25a92b56cc05d5f90481f3bbe61af65d97af23768d321
+  data.tar.gz: 8f16969b26684677f01d01821c541d14a338b924a310ad9cdd83435e7b7896b3
 SHA512:
-  metadata.gz: 348d7d27eae2dddac25859f79c3b8fd99b5be0ebbd7d1447308c146155bb70908519e5ece270fd67255aaa2c313d5f689ce2b1ca46442789c6c229fc8ef47561
-  data.tar.gz: 3064ce1fc1f05c85b4d88e3f415202193427dcf21ad57827571eeda79a7975555390a6c506eca05ed36fce9c00d10fda3d9b357ab97930243f83b9934d1dca15
+  metadata.gz: 230df28afb68ed450b76c16185dc14227342cfc3048ed5ab25183a99aebb57c79833180d6185c3d35d33e89dac9d9a514b8ee6ebbeef8ecf64d3822f34db0b0f
+  data.tar.gz: 9347250f29a7402d17ed0784c16387e268461785c02aa1d3f94024bdab6a89f2022a065169b1055f6b168d4a0472a193000e88f5c428ea8ce4757ed2843ff066

data/lib/agentf/cli/memory.rb

@@ -54,6 +54,8 @@ module Agentf
           list_tags
         when "search"
           search_memories(args)
+        when "delete"
+          delete_memories(args)
         when "neighbors"
           neighbors(args)
         when "subgraph"
@@ -315,6 +317,65 @@ module Agentf
         output_graph(result)
       end
 
+      def delete_memories(args)
+        mode = args.shift.to_s
+        case mode
+        when "id"
+          delete_by_id(args)
+        when "last"
+          delete_last(args)
+        when "all"
+          delete_all(args)
+        else
+          $stderr.puts "Error: delete requires one of: id|last|all"
+          exit 1
+        end
+      end
+
+      def delete_by_id(args)
+        id = args.shift.to_s
+        if id.empty?
+          $stderr.puts "Error: delete id requires a memory id"
+          exit 1
+        end
+
+        scope = parse_scope_option(args)
+        dry_run = parse_boolean_flag(args, "--dry-run")
+        result = @memory.delete_memory_by_id(id: id, scope: scope, dry_run: dry_run)
+        output_delete(result)
+      end
+
+      def delete_last(args)
+        limit = extract_limit(args)
+        if limit <= 0
+          $stderr.puts "Error: delete last requires -n with value > 0"
+          exit 1
+        end
+
+        scope = parse_scope_option(args)
+        type = parse_single_option(args, "--type=")
+        agent = parse_single_option(args, "--agent=")
+        dry_run = parse_boolean_flag(args, "--dry-run")
+        result = @memory.delete_recent(limit: limit, scope: scope, type: type, agent: agent, dry_run: dry_run)
+        output_delete(result)
+      end
+
+      def delete_all(args)
+        scope = parse_scope_option(args)
+        type = parse_single_option(args, "--type=")
+        agent = parse_single_option(args, "--agent=")
+        dry_run = parse_boolean_flag(args, "--dry-run")
+        confirmed = parse_boolean_flag(args, "--yes")
+
+        if !dry_run && !confirmed
+          $stderr.puts "Error: delete all requires --yes (or use --dry-run)"
+          exit 1
+        end
+
+        result = @memory.delete_all(scope: scope, type: type, agent: agent, dry_run: dry_run)
+        output_delete(result)
+      end
+
       def subgraph(args)
         seeds = args.shift.to_s.split(",").map(&:strip).reject(&:empty?)
         if seeds.empty?
@@ -363,6 +424,43 @@ module Agentf
         end
       end
 
+      def output_delete(result)
+        if result["error"]
+          if @json_output
+            puts JSON.generate({ "error" => result["error"] })
+          else
+            $stderr.puts "Error: #{result['error']}"
+          end
+          exit 1
+        end
+
+        if @json_output
+          puts JSON.generate(result)
+          return
+        end
+
+        action = result["dry_run"] ? "Planned" : "Deleted"
+        puts "#{action} #{result['deleted_count']} keys (candidates: #{result['candidate_count']})"
+        puts "Mode: #{result['mode']} | Scope: #{result['scope']}"
+        filters = result["filters"] || {}
+        puts "Filters: type=#{filters['type'] || 'any'}, agent=#{filters['agent'] || 'any'}"
+        ids = Array(result["deleted_ids"])
+        puts "Memory ids: #{ids.join(', ')}" unless ids.empty?
+      end
+
+      def parse_scope_option(args)
+        scope = parse_single_option(args, "--scope=") || "project"
+        unless %w[project all].include?(scope)
+          $stderr.puts "Error: --scope must be project or all"
+          exit 1
+        end
+        scope
+      end
+
+      def parse_boolean_flag(args, flag)
+        !args.delete(flag).nil?
+      end
+
       def output_graph(result)
         if result["error"]
           if @json_output
@@ -420,6 +518,9 @@ module Agentf
             add-pitfall               Store pitfall memory
             tags                      List all unique tags
             search <query>            Search memories by keyword
+            delete id <memory_id>     Delete one memory and related edges
+            delete last -n <count>    Delete most recent memories
+            delete all                Delete memories and graph/task keys
             neighbors <id>            Traverse graph edges from a memory id
             subgraph <ids>            Build graph from comma-separated seed ids
             summary, stats            Show summary statistics
@@ -440,6 +541,9 @@ module Agentf
             agentf memory add-lesson "Refactor strategy" "Extracted adapter seam" --agent=PLANNER --tags=architecture
             agentf memory add-success "Provider install works" "Installed copilot + opencode manifests" --agent=ENGINEER
             agentf memory search "react"
+            agentf memory delete id episode_abcd
+            agentf memory delete last -n 10 --scope=project
+            agentf memory delete all --scope=all --yes
             agentf memory neighbors episode_abcd --depth=2
             agentf memory by-tag "performance"
             agentf memory summary

data/lib/agentf/memory.rb

@@ -312,6 +312,68 @@ 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 = {
@@ -617,6 +679,134 @@ module Agentf
         { 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)

data/lib/agentf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Agentf
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agentf
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Neal Deters