agentf 0.5.0 → 0.7.0

data/lib/agentf/cli/memory.rb

@@ -12,8 +12,9 @@ module Agentf
     #   - by_type accepts business_intent and feature_intent (finding #11)
     class Memory
       include ArgParser
+      include Agentf::Memory::ConfirmationHandler
 
-      VALID_EPISODE_TYPES = %w[pitfall lesson success business_intent feature_intent].freeze
+      VALID_EPISODE_TYPES = %w[episode lesson playbook business_intent feature_intent incident].freeze
 
       def initialize(reviewer: nil, memory: nil)
         @reviewer = reviewer || Commands::MemoryReviewer.new
@@ -28,30 +29,28 @@ module Agentf
         case command
         when "recent", "list"
           list_memories(args)
-        when "pitfalls"
-          list_pitfalls(args)
+        when "episodes"
+          list_episodes(args)
         when "lessons"
           list_lessons(args)
-        when "successes"
-          list_successes(args)
         when "intents"
           list_intents(args)
         when "business-intents"
           list_business_intents(args)
         when "feature-intents"
           list_feature_intents(args)
+        when "add-intent"
+          add_intent(args)
+        when "add-episode"
+          add_episode_direct(args)
         when "add-business-intent"
           add_business_intent(args)
         when "add-feature-intent"
           add_feature_intent(args)
+        when "add-playbook"
+          add_playbook(args)
         when "add-lesson"
           add_episode("lesson", args)
-        when "add-success"
-          add_episode("success", args)
-        when "add-pitfall"
-          add_episode("pitfall", args)
-        when "tags"
-          list_tags
         when "search"
           search_memories(args)
         when "delete"
@@ -62,8 +61,6 @@ module Agentf
           subgraph(args)
         when "summary", "stats"
           show_summary
-        when "by-tag"
-          by_tag(args)
         when "by-agent"
           by_agent(args)
         when "by-type"
@@ -86,9 +83,10 @@ module Agentf
         output(result)
       end
 
-      def list_pitfalls(args)
+      def list_episodes(args)
         limit = extract_limit(args)
-        result = @reviewer.get_pitfalls(limit: limit)
+        outcome = parse_single_option(args, "--outcome=")
+        result = @reviewer.get_episodes(limit: limit, outcome: outcome)
         output(result)
       end
 
@@ -98,12 +96,6 @@ module Agentf
         output(result)
       end
 
-      def list_successes(args)
-        limit = extract_limit(args)
-        result = @reviewer.get_successes(limit: limit)
-        output(result)
-      end
-
       def list_intents(args)
         limit = extract_limit(args)
         kind = args.shift
@@ -132,6 +124,24 @@ module Agentf
         output(@reviewer.get_feature_intents(limit: limit))
       end
 
+      def add_intent(args)
+        kind = args.shift.to_s.downcase
+        unless %w[business feature].include?(kind)
+          $stderr.puts "Error: add-intent requires kind (business|feature) as first argument"
+          exit 1
+        end
+        kind == "business" ? add_business_intent(args) : add_feature_intent(args)
+      end
+
+      def add_episode_direct(args)
+        type = args.shift.to_s
+        unless VALID_EPISODE_TYPES.include?(type)
+          $stderr.puts "Error: add-episode requires type as first argument (#{VALID_EPISODE_TYPES.join('|')})"
+          exit 1
+        end
+        add_episode(type, args)
+      end
+
       def add_business_intent(args)
         title = args.shift
         description = args.shift
@@ -141,16 +151,14 @@ module Agentf
           exit 1
         end
 
-        tags = parse_list_option(args, "--tags=")
         constraints = parse_list_option(args, "--constraints=")
         priority = parse_integer_option(args, "--priority=", default: 1)
 
         id = nil
-        res = safe_cli_memory_write(@memory, attempted: { command: "add-business-intent", args: { title: title, description: description, tags: tags, constraints: constraints, priority: priority } }) do
+        res = safe_memory_write(@memory, attempted: { command: "add-business-intent", args: { title: title, description: description, constraints: constraints, priority: priority } }) do
           id = @memory.store_business_intent(
             title: title,
             description: description,
-            tags: tags,
             constraints: constraints,
             priority: priority
           )
@@ -181,17 +189,15 @@ module Agentf
           exit 1
         end
 
-        tags = parse_list_option(args, "--tags=")
         acceptance_criteria = parse_list_option(args, "--acceptance=")
         non_goals = parse_list_option(args, "--non-goals=")
         related_task_id = parse_single_option(args, "--task=")
 
         id = nil
-        res = safe_cli_memory_write(@memory, attempted: { command: "add-feature-intent", args: { title: title, description: description, tags: tags, acceptance: acceptance_criteria, non_goals: non_goals, related_task_id: related_task_id } }) do
+        res = safe_memory_write(@memory, attempted: { command: "add-feature-intent", args: { title: title, description: description, acceptance: acceptance_criteria, non_goals: non_goals, related_task_id: related_task_id } }) do
           id = @memory.store_feature_intent(
             title: title,
             description: description,
-            tags: tags,
             acceptance_criteria: acceptance_criteria,
             non_goals: non_goals,
             related_task_id: related_task_id
@@ -214,6 +220,46 @@ module Agentf
         end
       end
 
+      def add_playbook(args)
+        title = args.shift
+        description = args.shift
+
+        if title.to_s.empty? || description.to_s.empty?
+          $stderr.puts "Error: add-playbook requires <title> <description>"
+          exit 1
+        end
+
+        steps = parse_list_option(args, "--steps=")
+        feature_area = parse_single_option(args, "--feature-area=")
+        agent = parse_single_option(args, "--agent=") || Agentf::AgentRoles::PLANNER
+
+        id = nil
+        res = safe_memory_write(@memory, attempted: { command: "add-playbook", args: { title: title, description: description, steps: steps, feature_area: feature_area, agent: agent } }) do
+          id = @memory.store_playbook(
+            title: title,
+            description: description,
+            steps: steps,
+            feature_area: feature_area,
+            agent: agent
+          )
+        end
+
+        if res.is_a?(Hash) && res["confirmation_required"]
+          if @json_output
+            puts JSON.generate(res)
+          else
+            $stderr.puts "Confirmation required to store playbook: #{res['confirmation_details'].inspect}"
+          end
+          return
+        end
+
+        if @json_output
+          puts JSON.generate({ "id" => id, "type" => "playbook", "status" => "stored" })
+        else
+          puts "Stored playbook: #{id}"
+        end
+      end
+
       def add_episode(type, args)
         title = args.shift
         description = args.shift
@@ -223,21 +269,21 @@ module Agentf
           exit 1
         end
 
-        tags = parse_list_option(args, "--tags=")
         context = parse_single_option(args, "--context=").to_s
         agent = parse_single_option(args, "--agent=") || Agentf::AgentRoles::ENGINEER
         code_snippet = parse_single_option(args, "--code=").to_s
+        outcome = parse_single_option(args, "--outcome=")
 
         id = nil
-        res = safe_cli_memory_write(@memory, attempted: { command: "add-#{type}", args: { title: title, description: description, tags: tags, context: context, agent: agent, code: code_snippet } }) do
+        res = safe_memory_write(@memory, attempted: { command: "add-#{type}", args: { title: title, description: description, context: context, agent: agent, code: code_snippet, outcome: outcome } }) do
           id = @memory.store_episode(
             type: type,
             title: title,
             description: description,
             context: context,
-            tags: tags,
             agent: agent,
-            code_snippet: code_snippet
+            code_snippet: code_snippet,
+            outcome: outcome
           )
         end
 
@@ -257,37 +303,6 @@ module Agentf
         end
       end
 
-      # Helper to standardize CLI memory write confirmation handling.
-      def safe_cli_memory_write(memory, attempted: {})
-        begin
-          yield
-          nil
-        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
-          {
-            "confirmation_required" => true,
-            "confirmation_details" => e.details,
-            "attempted" => attempted,
-            "confirmed_write_token" => "confirmed",
-            "confirmation_prompt" => "Ask the user whether to save this memory. If they approve, rerun the same command with confirmation enabled. If they decline, do not retry."
-          }
-        end
-      end
-
-      def list_tags
-        result = @reviewer.get_all_tags
-        if @json_output
-          puts JSON.generate(result)
-          return
-        end
-
-        if result["tags"].empty?
-          puts "No tags found."
-        else
-          puts "Tags (#{result["count"]}):"
-          result["tags"].each { |tag| puts "  - #{tag}" }
-        end
-      end
-
       def search_memories(args)
         # Extract limit BEFORE joining remaining args as query (fixes finding #7)
         limit = extract_limit(args)
@@ -318,19 +333,12 @@ module Agentf
         puts ""
         puts "By agent:"
         result["by_agent"].each { |agent, count| puts "  #{agent}: #{count}" }
-        puts ""
-        puts "Unique tags: #{result["unique_tags"]}"
-      end
 
-      def by_tag(args)
-        tag = args.shift
-        if tag.nil? || tag.empty?
-          $stderr.puts "Error: by-tag requires a tag name"
-          exit 1
+        if result["by_outcome"].is_a?(Hash)
+          puts ""
+          puts "By outcome:"
+          result["by_outcome"].each { |outcome, count| puts "  #{outcome}: #{count}" }
         end
-        limit = extract_limit(args)
-        result = @reviewer.get_by_tag(tag, limit: limit)
-        output(result)
       end
 
       def by_agent(args)
@@ -540,8 +548,8 @@ module Agentf
           [#{mem["type"]&.upcase}] #{mem["title"]}
           #{mem["created_at"]} by #{mem["agent"]}
           #{mem["description"]}
+          #{"Outcome: #{mem['outcome']}" unless mem["outcome"].to_s.empty?}
           #{format_code(mem["code_snippet"]) unless mem["code_snippet"].to_s.empty?}
-          Tags: #{mem["tags"]&.join(", ") || "none"}
         OUTPUT
       end
 
@@ -557,26 +565,20 @@ module Agentf
 
           Commands:
             recent, list              List recent memories (default: 10)
-            pitfalls                  List pitfalls (things that went wrong)
+            episodes                  List episode memories
             lessons                   List lessons learned
-            successes                 List successes
             intents [kind]            List intents (kind: business|feature)
-            business-intents          List business intents
-            feature-intents           List feature intents
-            add-business-intent       Store business intent
-            add-feature-intent        Store feature intent
+            add-intent <kind>         Store intent (kind: business|feature)
+            add-episode <type>        Store episode (type: #{VALID_EPISODE_TYPES.join("|")}) with --outcome=
+            add-playbook              Store playbook memory
             add-lesson                Store lesson memory
-            add-success               Store success memory
-            add-pitfall               Store pitfall memory
-            tags                      List all unique tags
-            search <query>            Search memories by keyword
+            search <query>            Search memories semantically
             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
-            by-tag <tag>              Get memories with specific tag
             by-agent <agent>          Get memories from specific agent
             by-type <type>            Get memories by type (#{VALID_EPISODE_TYPES.join("|")})
 
@@ -586,18 +588,19 @@ module Agentf
 
           Examples:
             agentf memory recent -n 5
-            agentf memory pitfalls
+            agentf memory episodes --outcome=negative
             agentf memory intents business -n 5
-            agentf memory add-business-intent "Reliability" "Prioritize uptime" --tags=ops,platform --constraints="No downtime;No vendor lock-in"
-            agentf memory add-feature-intent "Agent handoff" "Improve orchestrator continuity" --acceptance="Keeps context;Preserves task state"
-            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 add-intent business "Reliability" "Prioritize uptime" --constraints="No downtime;No vendor lock-in"
+            agentf memory add-intent feature "Agent handoff" "Improve continuity" --acceptance="Keeps context;Preserves task state"
+            agentf memory add-episode lesson "Refactor strategy" "Extracted adapter seam" --agent=PLANNER --outcome=positive
+            agentf memory add-episode incident "Auth regression" "JWT expiry not checked" --outcome=negative
+            agentf memory add-playbook "Release rollout" "Safe deploy sequence" --steps="deploy canary;monitor;promote"
+            agentf memory add-lesson "Refactor strategy" "Extracted adapter seam" --agent=PLANNER
+            agentf memory search "react" --type=lesson --outcome=positive
             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
         HELP
       end

data/lib/agentf/cli/router.rb

@@ -75,7 +75,7 @@ module Agentf
           Usage: agentf <command> [subcommand] [options]
 
           Commands:
-            memory       Manage agent memory (lessons, pitfalls, successes, intents)
+            memory       Manage agent memory (episodes, lessons, playbooks, intents)
             code         Explore codebase (glob, grep, tree, related files)
             metrics      Show workflow success and provider parity metrics
             architecture Analyze architecture layers and violations

data/lib/agentf/commands/memory_reviewer.rb

@@ -12,16 +12,14 @@ module Agentf
       def self.manifest
         {
           "name" => NAME,
-          "description" => "Review and query Redis-stored memories, pitfalls, and learnings.",
+          "description" => "Review and query Redis-stored memories, episodes, and learnings.",
           "commands" => [
             { "name" => "get_recent_memories", "type" => "function" },
-            { "name" => "get_pitfalls", "type" => "function" },
+            { "name" => "get_episodes", "type" => "function" },
             { "name" => "get_lessons", "type" => "function" },
-            { "name" => "get_successes", "type" => "function" },
-            { "name" => "get_all_tags", "type" => "function" },
-            { "name" => "get_by_tag", "type" => "function" },
             { "name" => "get_by_type", "type" => "function" },
             { "name" => "get_by_agent", "type" => "function" },
+            { "name" => "get_intents", "type" => "function" },
             { "name" => "search", "type" => "function" },
             { "name" => "get_summary", "type" => "function" },
             { "name" => "neighbors", "type" => "function" },
@@ -44,10 +42,9 @@ module Agentf
         { "error" => e.message }
       end
 
-      # Get all pitfalls (things that went wrong)
-      def get_pitfalls(limit: 10)
-        pitfalls = @memory.get_pitfalls(limit: limit)
-        format_memories(pitfalls)
+      def get_episodes(limit: 10, outcome: nil)
+        episodes = @memory.get_episodes(limit: limit, outcome: outcome)
+        format_memories(episodes)
       rescue => e
         { "error" => e.message }
       end
@@ -60,14 +57,6 @@ module Agentf
         { "error" => e.message }
       end
 
-      # Get all successes
-      def get_successes(limit: 10)
-        successes = @memory.get_memories_by_type(type: "success", limit: limit)
-        format_memories(successes)
-      rescue => e
-        { "error" => e.message }
-      end
-
       def get_business_intents(limit: 10)
         intents = @memory.get_intents(kind: "business", limit: limit)
         format_memories(intents)
@@ -89,51 +78,25 @@ module Agentf
         { "error" => e.message }
       end
 
-      # Get all unique tags from memories
-      def get_all_tags
-        tags = @memory.get_all_tags
-        { "tags" => tags.sort, "count" => tags.length }
-      rescue => e
-        { "error" => e.message }
-      end
-
-      # Get memories by tag
-      def get_by_tag(tag, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        filtered = memories.select { |m| m["tags"]&.include?(tag) }
-        format_memories(filtered.first(limit))
-      rescue => e
-        { "error" => e.message }
-      end
-
       # Get memories by type (pitfall, lesson, success)
       def get_by_type(type, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        filtered = memories.select { |m| m["type"] == type }
-        format_memories(filtered.first(limit))
+        memories = @memory.get_memories_by_type(type: type, limit: limit)
+        format_memories(memories)
       rescue => e
         { "error" => e.message }
       end
 
       # Get memories by agent
       def get_by_agent(agent, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        filtered = memories.select { |m| m["agent"] == agent }
-        format_memories(filtered.first(limit))
+        memories = @memory.get_memories_by_agent(agent: agent, limit: limit)
+        format_memories(memories)
       rescue => e
         { "error" => e.message }
       end
 
-      # Search memories by keyword in title or description
-      def search(query, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        q = query.downcase
-        filtered = memories.select do |m|
-          m["title"]&.downcase&.include?(q) ||
-            m["description"]&.downcase&.include?(q) ||
-            m["context"]&.downcase&.include?(q)
-        end
-        format_memories(filtered.first(limit))
+      # Search memories semantically with optional type, agent, and outcome filters
+      def search(query, limit: 10, type: nil, agent: nil, outcome: nil)
+        format_memories(@memory.search_memories(query: query, limit: limit, type: type, agent: agent, outcome: outcome))
       rescue => e
         { "error" => e.message }
       end
@@ -141,19 +104,22 @@ module Agentf
       # Get summary statistics
       def get_summary
         memories = @memory.get_recent_memories(limit: 100)
-        tags = @memory.get_all_tags
 
         {
           "total_memories" => memories.length,
           "by_type" => {
-            "pitfall" => memories.count { |m| m["type"] == "pitfall" },
+            "episode" => memories.count { |m| m["type"] == "episode" },
             "lesson" => memories.count { |m| m["type"] == "lesson" },
-            "success" => memories.count { |m| m["type"] == "success" },
+            "playbook" => memories.count { |m| m["type"] == "playbook" },
             "business_intent" => memories.count { |m| m["type"] == "business_intent" },
             "feature_intent" => memories.count { |m| m["type"] == "feature_intent" }
           },
+          "by_outcome" => {
+            "positive" => memories.count { |m| m["outcome"] == "positive" },
+            "negative" => memories.count { |m| m["outcome"] == "negative" },
+            "neutral" => memories.count { |m| m["outcome"] == "neutral" }
+          },
           "by_agent" => memories.each_with_object(Hash.new(0)) { |m, h| h[m["agent"]] += 1 },
-          "unique_tags" => tags.length,
           "project" => @project
         }
       rescue => e
@@ -189,7 +155,7 @@ module Agentf
           "description" => m["description"],
           "context" => m["context"],
           "code_snippet" => m["code_snippet"],
-          "tags" => m["tags"],
+          "outcome" => m["outcome"],
           "agent" => m["agent"],
           "metadata" => m["metadata"],
           "entity_ids" => m["entity_ids"],

data/lib/agentf/commands/metrics.rb

@@ -7,8 +7,6 @@ module Agentf
     class Metrics
       NAME = "metrics"
 
-      WORKFLOW_METRICS_TAG = "workflow_metric"
-
       def self.manifest
         {
           "name" => NAME,
@@ -30,12 +28,13 @@ module Agentf
         metrics = extract_metrics(workflow_state)
         begin
           @memory.store_episode(
-            type: "success",
+            type: "episode",
             title: metric_title(metrics),
             description: metric_description(metrics),
             context: metric_context(metrics),
-            tags: metric_tags(metrics),
             agent: Agentf::AgentRoles::ORCHESTRATOR,
+            outcome: "positive",
+            metadata: { "workflow_metric" => true },
             code_snippet: ""
           )
           { "status" => "recorded", "metrics" => metrics }
@@ -171,14 +170,6 @@ module Agentf
         }.to_json
       end
 
-      def metric_tags(metrics)
-        [
-          WORKFLOW_METRICS_TAG,
-          "provider:#{metrics['provider'].to_s.downcase}",
-          "workflow:#{metrics['workflow_type']}"
-        ]
-      end
-
       def top_contract_violations(records)
         counts = Hash.new(0)
         records.each do |record|
@@ -191,7 +182,7 @@ module Agentf
         memories = @memory.get_recent_memories(limit: limit)
 
         memories
-          .select { |m| Array(m["tags"]).include?(WORKFLOW_METRICS_TAG) }
+          .select { |m| m.dig("metadata", "workflow_metric") == true }
           .map do |m|
             context = parse_context_json(m["context"])
             context

data/lib/agentf/context_builder.rb

@@ -2,8 +2,9 @@
 
 module Agentf
   class ContextBuilder
-    def initialize(memory:)
+    def initialize(memory:, embedding_provider: Agentf::EmbeddingProvider.new)
       @memory = memory
+      @embedding_provider = embedding_provider
     end
 
     def build(agent:, workflow_state:, limit: 8)
@@ -13,23 +14,12 @@ module Agentf
       @memory.get_agent_context(
         agent: agent,
         task_type: task_type,
-        query_embedding: simple_embedding(task),
+        query_text: task,
+        query_embedding: @embedding_provider.embed(task),
         limit: limit
       )
     rescue StandardError
       { "agent" => agent, "intent" => [], "memories" => [], "similar_tasks" => [] }
     end
-
-    private
-
-    def simple_embedding(text)
-      normalized = text.to_s.downcase
-      [
-        normalized.include?("fix") || normalized.include?("bug") ? 1.0 : 0.0,
-        normalized.include?("feature") || normalized.include?("add") ? 1.0 : 0.0,
-        normalized.include?("security") ? 1.0 : 0.0,
-        normalized.length.to_f / 100.0
-      ]
-    end
   end
 end

data/lib/agentf/embedding_provider.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Agentf
+  class EmbeddingProvider
+    DIMENSIONS = 64
+
+    def initialize(dimensions: DIMENSIONS)
+      @dimensions = dimensions
+    end
+
+    def embed(text)
+      tokens = tokenize(text)
+      return [] if tokens.empty?
+
+      vector = Array.new(@dimensions, 0.0)
+      tokens.each do |token|
+        hash = Digest::SHA256.hexdigest(token)[0, 8].to_i(16)
+        vector[hash % @dimensions] += 1.0
+      end
+
+      magnitude = Math.sqrt(vector.sum { |value| value * value })
+      return vector if magnitude.zero?
+
+      vector.map { |value| (value / magnitude).round(8) }
+    end
+
+    private
+
+    def tokenize(text)
+      text.to_s.downcase.scan(/[a-z0-9_]+/).reject { |token| token.length < 2 }
+    end
+  end
+end