agentf 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 375fdc4ce17f8fe753e2f99a1ac35ee5a4ce2ac8b592812b924a4b755faf7827
-  data.tar.gz: 7d45fb33f315c8cd15fb4297556d063603d763fe3a0f9e79906a259f1dac6808
+  metadata.gz: 1a6b455ea4e8d08419665c731414589a39173932f0bdf70788b76cfbcc7c0380
+  data.tar.gz: 4552007bea3fbb27e4940f09542f76e557bdac18f06391dfcb7db6914adc9017
 SHA512:
-  metadata.gz: 4eb3d691ed13cae8b2780955eb4e059c878f1ad3f219ffe577d439b1695a7d5d3408d6770f2a7d1a3d45e78df678993a882eb130003e4bcc5c5e5759b7508051
-  data.tar.gz: 635accb75b7532c51cee21c02a5d54b9df35010e2db3c46efe3e788452cdaca5f9b35bfdc538969227dd0808cf4b3b37d1e0821f73f8c9431f2ec54dca12ea2e
+  metadata.gz: 37efe8cb9847156d5d0e93ee981c108fddab0940eab62fe60bb609e6fc68f799c14fd84f08214263ec4e98d05b617b5be7cd8d035d8a9352d7c639b4737947bb
+  data.tar.gz: c26f29b7059e1997f62b1a9b25c628c6ff25832309e8766ba2d076ebdf8333ca7ac3206145ae4e05f623c84aa6771c316970b5377e0b48de2980dff3e5c077df

data/lib/agentf/installer.rb

@@ -25,8 +25,8 @@ module Agentf
       "store_lesson" => { cli: "agentf memory add-lesson \"<title>\" \"<description>\" --agent=<AGENT> --tags=learning", tool: "agentf-memory-add-lesson" },
       "store_success" => { cli: "agentf memory add-success \"<title>\" \"<description>\" --agent=<AGENT> --tags=success", tool: "agentf-memory-add-success" },
       "store_pitfall" => { cli: "agentf memory add-pitfall \"<title>\" \"<description>\" --agent=<AGENT> --tags=pitfall", tool: "agentf-memory-add-pitfall" },
-      "store_business_intent" => { cli: "agentf memory add-business-intent \"<title>\" \"<description>\" --tags=strategy", tool: "agentf-memory-add-lesson" },
-      "store_feature_intent" => { cli: "agentf memory add-feature-intent \"<title>\" \"<description>\" --acceptance=\"<criteria>\"", tool: "agentf-memory-add-lesson" }
+      "store_business_intent" => { cli: "agentf memory add-business-intent \"<title>\" \"<description>\" --tags=strategy", tool: "agentf-memory-add-business-intent" },
+      "store_feature_intent" => { cli: "agentf memory add-feature-intent \"<title>\" \"<description>\" --acceptance=\"<criteria>\"", tool: "agentf-memory-add-feature-intent" }
     }.freeze
 
     PROVIDER_LAYOUTS = {
@@ -631,6 +631,165 @@ module Agentf
                   return runAgentfCli(context.directory, "memory", "search", [args.query, "-n", String(limit)]);
                 },
               }),
+              "agentf-memory-by-tag": tool({
+                description: "Get Agentf memories by tag.",
+                args: {
+                  tag: tool.schema.string().describe("Tag to filter by"),
+                  limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
+                },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "by-tag", [args.tag, "-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-by-agent": tool({
+                description: "Get Agentf memories by agent.",
+                args: {
+                  agent: tool.schema.string().describe("Agent name"),
+                  limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
+                },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "by-agent", [args.agent, "-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-by-type": tool({
+                description: "Get Agentf memories by type.",
+                args: {
+                  type: tool.schema.string().describe("Memory type (pitfall|lesson|success|business_intent|feature_intent)"),
+                  limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
+                },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "by-type", [args.type, "-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-tags": tool({
+                description: "List all unique memory tags.",
+                args: {},
+                async execute(_args, context) {
+                  return runAgentfCli(context.directory, "memory", "tags", []);
+                },
+              }),
+              "agentf-memory-pitfalls": tool({
+                description: "List pitfall memories.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "pitfalls", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-lessons": tool({
+                description: "List lesson memories.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "lessons", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-successes": tool({
+                description: "List success memories.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "successes", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-intents": tool({
+                description: "List intents (business, feature or both).",
+                args: { kind: tool.schema.string().optional(), limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  const kind = args.kind ? String(args.kind) : "";
+                  const cmdArgs = kind ? [kind, "-n", String(limit)] : ["-n", String(limit)];
+                  return runAgentfCli(context.directory, "memory", "intents", cmdArgs);
+                },
+              }),
+              "agentf-memory-business-intents": tool({
+                description: "List business intents.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "business-intents", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-feature-intents": tool({
+                description: "List feature intents.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "feature-intents", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-add-business-intent": tool({
+                description: "Store a business intent in Redis.",
+                args: {
+                  title: tool.schema.string(),
+                  description: tool.schema.string(),
+                  tags: tool.schema.array(tool.schema.string()).optional(),
+                  constraints: tool.schema.array(tool.schema.string()).optional(),
+                  priority: tool.schema.number().int().optional(),
+                },
+                async execute(args, context) {
+                  const commandArgs = [args.title, args.description];
+                  if (args.tags?.length) commandArgs.push(`--tags=${args.tags.join(",")}`);
+                  if (args.constraints?.length) commandArgs.push(`--constraints=${args.constraints.join(";")}`);
+                  if (Number.isInteger(args.priority)) commandArgs.push(`--priority=${String(args.priority)}`);
+                  return runAgentfCli(context.directory, "memory", "add-business-intent", commandArgs);
+                },
+              }),
+              "agentf-memory-add-feature-intent": tool({
+                description: "Store a feature intent in Redis.",
+                args: {
+                  title: tool.schema.string(),
+                  description: tool.schema.string(),
+                  tags: tool.schema.array(tool.schema.string()).optional(),
+                  acceptance: tool.schema.array(tool.schema.string()).optional(),
+                  non_goals: tool.schema.array(tool.schema.string()).optional(),
+                  related_task_id: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                  const commandArgs = [args.title, args.description];
+                  if (args.tags?.length) commandArgs.push(`--tags=${args.tags.join(",")}`);
+                  if (args.acceptance?.length) commandArgs.push(`--acceptance=${args.acceptance.join(";")}`);
+                  if (args.non_goals?.length) commandArgs.push(`--non-goals=${args.non_goals.join(";")}`);
+                  if (args.related_task_id) commandArgs.push(`--task=${args.related_task_id}`);
+                  return runAgentfCli(context.directory, "memory", "add-feature-intent", commandArgs);
+                },
+              }),
+              "agentf-memory-neighbors": tool({
+                description: "Get neighboring memory nodes by edge traversal.",
+                args: {
+                  node_id: tool.schema.string(),
+                  relation: tool.schema.string().optional(),
+                  depth: tool.schema.number().int().optional(),
+                  limit: tool.schema.number().int().optional(),
+                },
+                async execute(args, context) {
+                  const commandArgs = [args.node_id];
+                  if (args.relation) commandArgs.push(`--relation=${args.relation}`);
+                  if (Number.isInteger(args.depth)) commandArgs.push(`--depth=${String(args.depth)}`);
+                  if (Number.isInteger(args.limit)) commandArgs.push(`-n`, String(args.limit));
+                  return runAgentfCli(context.directory, "memory", "neighbors", commandArgs);
+                },
+              }),
+              "agentf-memory-subgraph": tool({
+                description: "Build a subgraph from seed ids.",
+                args: {
+                  seed_ids: tool.schema.array(tool.schema.string()),
+                  relation_filters: tool.schema.array(tool.schema.string()).optional(),
+                  depth: tool.schema.number().int().optional(),
+                  limit: tool.schema.number().int().optional(),
+                },
+                async execute(args, context) {
+                  const seeds = (args.seed_ids || []).join(",");
+                  const commandArgs = [seeds];
+                  if (args.relation_filters?.length) commandArgs.push(`--relation=${args.relation_filters.join(",")}`);
+                  if (Number.isInteger(args.depth)) commandArgs.push(`--depth=${String(args.depth)}`);
+                  if (Number.isInteger(args.limit)) commandArgs.push(`-n`, String(args.limit));
+                  return runAgentfCli(context.directory, "memory", "subgraph", commandArgs);
+                },
+              }),
               "agentf-memory-add-lesson": tool({
                 description: "Store a lesson memory in Redis.",
                 args: {

data/lib/agentf/mcp/server.rb

@@ -28,17 +28,31 @@ module Agentf
         agentf-architecture-analyze-layers
         agentf-memory-recent
         agentf-memory-search
+        agentf-memory-by-tag
+        agentf-memory-by-agent
+        agentf-memory-by-type
+        agentf-memory-tags
+        agentf-memory-pitfalls
+        agentf-memory-lessons
+        agentf-memory-successes
+        agentf-memory-intents
+        agentf-memory-business-intents
+        agentf-memory-feature-intents
         agentf-memory-neighbors
         agentf-memory-subgraph
         agentf-memory-add-lesson
         agentf-memory-add-success
         agentf-memory-add-pitfall
+        agentf-memory-add-business-intent
+        agentf-memory-add-feature-intent
       ].freeze
 
       WRITE_TOOLS = Set.new(%w[
         agentf-memory-add-lesson
         agentf-memory-add-success
         agentf-memory-add-pitfall
+        agentf-memory-add-business-intent
+        agentf-memory-add-feature-intent
       ]).freeze
 
       attr_reader :server, :guardrails
@@ -214,6 +228,160 @@ module Agentf
           end
         end
 
+        s.tool("agentf-memory-by-tag") do
+          description "Get memories by tag."
+          argument :tag, String, required: true, description: "Tag to filter"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-by-tag", **args)
+            result = reviewer.get_by_tag(args[:tag], limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-by-agent") do
+          description "Get memories by agent."
+          argument :agent, String, required: true, description: "Agent name"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-by-agent", **args)
+            result = reviewer.get_by_agent(args[:agent], limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-by-type") do
+          description "Get memories by type."
+          argument :type, String, required: true, description: "Memory type"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-by-type", **args)
+            result = reviewer.get_by_type(args[:type], limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-tags") do
+          description "List all unique memory tags."
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-tags", **args)
+            result = reviewer.get_all_tags
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-pitfalls") do
+          description "List pitfall memories."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-pitfalls", **args)
+            result = reviewer.get_pitfalls(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-lessons") do
+          description "List lesson memories."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-lessons", **args)
+            result = reviewer.get_lessons(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-successes") do
+          description "List success memories."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-successes", **args)
+            result = reviewer.get_successes(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-intents") do
+          description "List intents (business|feature)."
+          argument :kind, String, required: false, description: "Optional: business|feature"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-intents", **args)
+            kind = args[:kind]
+            limit = args[:limit] || 10
+            result = case kind
+                     when "business"
+                       reviewer.get_business_intents(limit: limit)
+                     when "feature"
+                       reviewer.get_feature_intents(limit: limit)
+                     else
+                       reviewer.get_intents(limit: limit)
+                     end
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-business-intents") do
+          description "List business intents."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-business-intents", **args)
+            result = reviewer.get_business_intents(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-feature-intents") do
+          description "List feature intents."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-feature-intents", **args)
+            result = reviewer.get_feature_intents(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-add-business-intent") do
+          description "Store a business intent in Redis."
+          argument :title, String, required: true, description: "Intent title"
+          argument :description, String, required: true, description: "Intent description"
+          argument :tags, Array, required: false, items: String, description: "Tags"
+          argument :constraints, Array, required: false, items: String, description: "Constraints"
+          argument :priority, Integer, required: false, description: "Priority"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-add-business-intent", **args)
+            id = memory.store_business_intent(
+              title: args[:title],
+              description: args[:description],
+              tags: args[:tags] || [],
+              constraints: args[:constraints] || [],
+              priority: args[:priority] || 1
+            )
+            JSON.generate(id: id, type: "business_intent", status: "stored")
+          end
+        end
+
+        s.tool("agentf-memory-add-feature-intent") do
+          description "Store a feature intent in Redis."
+          argument :title, String, required: true, description: "Intent title"
+          argument :description, String, required: true, description: "Intent description"
+          argument :tags, Array, required: false, items: String, description: "Tags"
+          argument :acceptance, Array, required: false, items: String, description: "Acceptance criteria"
+          argument :non_goals, Array, required: false, items: String, description: "Non-goals"
+          argument :related_task_id, String, required: false, description: "Related task id"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-add-feature-intent", **args)
+            id = memory.store_feature_intent(
+              title: args[:title],
+              description: args[:description],
+              tags: args[:tags] || [],
+              acceptance_criteria: args[:acceptance] || [],
+              non_goals: args[:non_goals] || [],
+              related_task_id: args[:related_task_id]
+            )
+            JSON.generate(id: id, type: "feature_intent", status: "stored")
+          end
+        end
+
         s.tool("agentf-memory-neighbors") do
           description "Get neighboring memory nodes by edge traversal."
           argument :node_id, String, required: true, description: "Starting node id"

data/lib/agentf/version.rb

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

metadata

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