agentf 0.4.4 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ba903d323be3e277a84ea8320af5b84a93456ad44b5d5aca0eb05e4c4ba29ae
-  data.tar.gz: 9a7125925e3a3fbf85b382b5ea278e3b39390c618dc9a571c1657acef86ec82d
+  metadata.gz: 1a6b455ea4e8d08419665c731414589a39173932f0bdf70788b76cfbcc7c0380
+  data.tar.gz: 4552007bea3fbb27e4940f09542f76e557bdac18f06391dfcb7db6914adc9017
 SHA512:
-  metadata.gz: 7c5703863b0d31aa5318c124d690eb0dccb93839935e07155a6bd6265267741183c38475761d597b15bfa8f18ea3b7a515b7613c7d31a9327eb0e6162a186d09
-  data.tar.gz: d5b4072ee13a2e40d07f93c25c147298d63e8e782bfb75a66a03b10b90c4c8b844da396271fa0ed00f695be42067c009934ef3b4f8f5a01ad86d8272807abaf6
+  metadata.gz: 37efe8cb9847156d5d0e93ee981c108fddab0940eab62fe60bb609e6fc68f799c14fd84f08214263ec4e98d05b617b5be7cd8d035d8a9352d7c639b4737947bb
+  data.tar.gz: c26f29b7059e1997f62b1a9b25c628c6ff25832309e8766ba2d076ebdf8333ca7ac3206145ae4e05f623c84aa6771c316970b5377e0b48de2980dff3e5c077df

data/lib/agentf/agents/debugger.rb

@@ -80,6 +80,7 @@ module Agentf
 
           {
             "success" => true,
+            "error" => nil,
             "analysis" => {
               "error_type" => analysis.error_type,
               "possible_causes" => analysis.possible_causes,

data/lib/agentf/cli/install.rb

@@ -16,6 +16,7 @@ module Agentf
           global_root: Dir.home,
           local_root: Dir.pwd,
           dry_run: false,
+          install_deps: true,
           only_agents: nil,
           only_commands: nil
         }
@@ -32,7 +33,9 @@ module Agentf
         installer = Agentf::Installer.new(
           global_root: @options[:global_root],
           local_root: @options[:local_root],
-          dry_run: @options[:dry_run]
+          dry_run: @options[:dry_run],
+          install_deps: @options[:install_deps],
+          verbose: @options.fetch(:verbose, false)
         )
 
         results = installer.install(
@@ -66,6 +69,9 @@ module Agentf
         scope_val = parse_single_option(args, "--scope=") || parse_single_option(args, "-s=")
         @options[:scope] = scope_val.downcase if scope_val
 
+        # Extract --install-deps flag
+        @options[:install_deps] = !args.delete("--install-deps").nil?
+
         # Extract --global-root and --local-root
         global_root = parse_single_option(args, "--global-root=")
         @options[:global_root] = File.expand_path(global_root) if global_root
@@ -83,6 +89,9 @@ module Agentf
         if command_val
           @options[:only_commands] = command_val.split(",").map { |item| item.strip.downcase }.reject(&:empty?)
         end
+
+        # Extract --verbose flag
+        @options[:verbose] = !args.delete("--verbose").nil?
       end
 
       def show_help

data/lib/agentf/installer.rb

@@ -2,6 +2,8 @@
 
 require "fileutils"
 require "yaml"
+require "open3"
+require "json"
 
 module Agentf
   class Installer
@@ -23,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 = {
@@ -44,10 +46,12 @@ module Agentf
       }
     }.freeze
 
-    def initialize(global_root: Dir.home, local_root: Dir.pwd, dry_run: false)
+    def initialize(global_root: Dir.home, local_root: Dir.pwd, dry_run: false, verbose: false, install_deps: true)
       @global_root = global_root
       @local_root = local_root
       @dry_run = dry_run
+      @verbose = verbose
+      @install_deps = install_deps
     end
 
     def install(
@@ -74,14 +78,62 @@ module Agentf
       end
 
       writes = []
-      roots_for(scope).each do |root|
+      roots = roots_for(scope)
+      roots.each do |root|
         writes.concat(write_agents(root: root, layout: layout, provider: provider, only_agents: only_agents))
         writes.concat(write_commands(root: root, layout: layout, provider: provider, only_commands: only_commands))
         writes.concat(write_opencode_helpers(root: root)) if provider.to_s == "opencode"
       end
+
+      # Optionally install dependencies for opencode helper package.json
+      if provider.to_s == "opencode" && @install_deps
+        roots.each do |root|
+          package_json_path = File.join(root, ".opencode/package.json")
+          if @dry_run
+            # In dry-run, report that package.json would be written/installed
+            writes << write_manifest(package_json_path, render_opencode_package_json)
+          else
+            result = install_deps_in(root)
+            writes << result if result
+          end
+        end
+      end
+
       writes
     end
 
+    def install_deps_in(root)
+      pkg_dir = File.join(root, ".opencode")
+      pkg_json = File.join(pkg_dir, "package.json")
+      unless File.exist?(pkg_json)
+        warn "No .opencode/package.json at #{pkg_json}, skipping install" if @verbose
+        return { "path" => pkg_json, "status" => "skipped", "reason" => "missing package.json" }
+      end
+
+      managers = [
+        { cmd: ["bun", "install"], check: ["bun", "--version"] },
+        { cmd: ["npm", "install"], check: ["npm", "--version"] },
+        { cmd: ["yarn", "install"], check: ["yarn", "--version"] }
+      ]
+
+      managers.each do |m|
+        stdout, stderr, status = Open3.capture3(*m[:check])
+        next unless status.success?
+
+        puts "Running #{m[:cmd].first} install in #{pkg_dir}" if @verbose
+        out, err, st = Open3.capture3(*m[:cmd], chdir: pkg_dir)
+        if st.success?
+          puts out if @verbose && !out.to_s.strip.empty?
+          return { "path" => pkg_dir, "status" => "installed", "manager" => m[:cmd].first }
+        else
+          warn "Install with #{m[:cmd].first} failed: #{err}" unless @verbose
+          return { "path" => pkg_dir, "status" => "error", "manager" => m[:cmd].first, "error" => err }
+        end
+      end
+
+      { "path" => pkg_dir, "status" => "no_manager_found" }
+    end
+
     def roots_for(scope)
       case scope
       when "global"
@@ -124,13 +176,15 @@ module Agentf
         render_opencode_plugin
       )
       writes << write_manifest(
-        File.join(root, ".opencode/memory/agentf-redis-schema.md"),
-        render_opencode_memory_schema
+        File.join(root, ".opencode/tsconfig.json"),
+        render_opencode_tsconfig
       )
+      writes << write_package_json(root)
       writes << write_manifest(
-        File.join(root, "opencode.json"),
-        render_opencode_json
+        File.join(root, ".opencode/memory/agentf-redis-schema.md"),
+        render_opencode_memory_schema
       )
+      writes << write_opencode_json(root)
       writes
     end
 
@@ -151,11 +205,21 @@ module Agentf
     end
 
     def write_manifest(path, payload)
-      return { "path" => path, "status" => "planned" } if @dry_run
+      if @dry_run
+        return { "path" => path, "status" => "planned" }
+      end
 
       FileUtils.mkdir_p(File.dirname(path))
-      File.write(path, payload)
-      { "path" => path, "status" => "written" }
+      begin
+        File.write(path, payload)
+        if @verbose
+          puts "WROTE: #{path}"
+        end
+        { "path" => path, "status" => "written" }
+      rescue StandardError => e
+        warn "ERROR writing #{path}: #{e.message}"
+        { "path" => path, "status" => "error", "error" => e.message }
+      end
     end
 
     def render_agent_manifest(klass, provider:)
@@ -354,11 +418,12 @@ module Agentf
 
     def render_opencode_plugin
       <<~'TYPESCRIPT'
-        import { execFile } from "node:child_process";
-        import { promisify } from "node:util";
-        import path from "node:path";
-        import { type Plugin, tool } from "@opencode-ai/plugin/tool";
-        import fs from "node:fs";
+        // tools:
+        import { execFile } from "child_process";
+        import { promisify } from "util";
+        import path from "path";
+        import { type Plugin, tool } from "@opencode-ai/plugin";
+        import fs from "fs";
 
         const execFileAsync = promisify(execFile);
 
@@ -495,7 +560,7 @@ module Agentf
           await ensureAgentfPreflight(process.env.PWD || process.cwd());
 
           return {
-            tools: {
+            tool: {
               "agentf-code-glob": tool({
                 description: "Find files using project glob patterns via Agentf code CLI.",
                 args: {
@@ -566,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: {
@@ -632,11 +856,81 @@ module Agentf
       <<~JSON
         {
           "$schema": "https://opencode.ai/config.json",
-          "plugin": ["./opencode/plugins/agentf-plugin"]
+          "plugin": ["./.opencode/plugins/agentf-plugin"]
         }
       JSON
     end
 
+    def write_opencode_json(root)
+      path = File.join(root, "opencode.json")
+      new_content = JSON.parse(render_opencode_json)
+
+      return write_manifest(path, JSON.pretty_generate(new_content)) unless File.exist?(path)
+
+      begin
+        existing = JSON.parse(File.read(path))
+      rescue StandardError => e
+        warn "Failed to parse existing opencode.json: #{e.message}"
+        return write_manifest(path, JSON.pretty_generate(new_content))
+      end
+
+      merged = existing.dup
+      merged_plugins = Array(existing["plugin"]) + Array(new_content["plugin"])
+      merged["plugin"] = merged_plugins.uniq
+
+      write_manifest(path, JSON.pretty_generate(merged))
+    end
+
+    def render_opencode_tsconfig
+      <<~JSON
+        {
+          "compilerOptions": {
+            "target": "ESNext",
+            "module": "ESNext",
+            "moduleResolution": "bundler",
+            "types": ["node"],
+            "strict": true,
+            "skipLibCheck": true,
+            "baseUrl": ".",
+            "paths": {
+              "@opencode-ai/plugin": ["./node_modules/@opencode-ai/plugin"]
+            }
+          },
+          "include": ["plugins/**/*.ts"]
+        }
+      JSON
+    end
+
+    def render_opencode_package_json
+      <<~JSON
+        {
+          "name": "agentf-opencode-helpers",
+          "private": true,
+          "dependencies": {
+            "@opencode-ai/plugin": "^1.2.24"
+          },
+          "devDependencies": {
+            "@types/node": "^25.4.0"
+          }
+        }
+      JSON
+    end
+
+    def write_package_json(root)
+      package_json_path = File.join(root, ".opencode/package.json")
+      new_content = render_opencode_package_json
+      return write_manifest(package_json_path, new_content) unless File.exist?(package_json_path)
+
+      existing = JSON.parse(File.read(package_json_path))
+      new_package_json = JSON.parse(new_content)
+
+      merged = existing.dup
+      merged["dependencies"] = (existing["dependencies"] || {}).merge(new_package_json["dependencies"] || {})
+      merged["devDependencies"] = (existing["devDependencies"] || {}).merge(new_package_json["devDependencies"] || {})
+
+      write_manifest(package_json_path, JSON.pretty_generate(merged))
+    end
+
     def render_opencode_memory_schema
       <<~MARKDOWN
         # Redis Memory Schema

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.4"
+  VERSION = "0.4.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agentf
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: ruby
 authors:
 - Neal Deters
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-09 00:00:00.000000000 Z
+date: 2026-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -86,7 +86,7 @@ description: |2
       Redis-backed semantic, episodic, and graph-style memory. It includes a
       unified CLI, MCP server tools, and install/update workflows for generated
       agent/command manifests.
-email: 
+email:
 executables:
 - agentf
 extensions: []
@@ -147,7 +147,7 @@ metadata:
   homepage_uri: https://github.com/nealdeters/agentf
   source_code_uri: https://github.com/nealdeters/agentf
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -162,8 +162,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Ruby multi-agent workflow engine with Redis memory
 test_files: []