agentf 0.3.0 → 0.4.1

data/lib/agentf/packs.rb

@@ -14,11 +14,11 @@ module Agentf
         "description" => "Thin models/controllers with services, queries, presenters, and policy reviews.",
         "keywords" => %w[rails activerecord rspec pundit viewcomponent hotwire turbo stimulus],
         "workflow_templates" => {
-          "feature" => %w[ARCHITECT EXPLORER SPECIALIST TESTER SECURITY REVIEWER DOCUMENTER],
-          "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER SECURITY REVIEWER],
-          "refactor" => %w[ARCHITECT EXPLORER SPECIALIST TESTER REVIEWER],
-          "quick_fix" => %w[SPECIALIST TESTER REVIEWER],
-          "exploration" => %w[EXPLORER]
+          "feature" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER KNOWLEDGE_MANAGER],
+          "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER],
+          "refactor" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER REVIEWER],
+          "quick_fix" => %w[ENGINEER QA_TESTER REVIEWER],
+          "exploration" => %w[RESEARCHER]
         }
       },
       "rails_37signals" => {
@@ -26,11 +26,11 @@ module Agentf
         "description" => "Resource-centric workflows favoring concerns, CRUD and model-rich patterns.",
         "keywords" => %w[rails concern crud closure model minitest hotwire],
         "workflow_templates" => {
-          "feature" => %w[ARCHITECT EXPLORER SPECIALIST TESTER REVIEWER DOCUMENTER],
-          "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER REVIEWER],
-          "refactor" => %w[ARCHITECT SPECIALIST TESTER REVIEWER],
-          "quick_fix" => %w[SPECIALIST REVIEWER],
-          "exploration" => %w[EXPLORER]
+          "feature" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER REVIEWER KNOWLEDGE_MANAGER],
+          "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER REVIEWER],
+          "refactor" => %w[PLANNER ENGINEER QA_TESTER REVIEWER],
+          "quick_fix" => %w[ENGINEER REVIEWER],
+          "exploration" => %w[RESEARCHER]
         }
       },
       "rails_feature_spec" => {
@@ -38,11 +38,11 @@ module Agentf
         "description" => "Feature-spec-first orchestration with planning and review emphasis.",
         "keywords" => %w[rails feature specification acceptance criteria],
         "workflow_templates" => {
-          "feature" => %w[ARCHITECT EXPLORER DESIGNER SPECIALIST TESTER REVIEWER DOCUMENTER],
-          "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER REVIEWER],
-          "refactor" => %w[ARCHITECT EXPLORER SPECIALIST TESTER REVIEWER],
-          "quick_fix" => %w[SPECIALIST REVIEWER],
-          "exploration" => %w[EXPLORER]
+          "feature" => %w[PLANNER RESEARCHER UI_ENGINEER ENGINEER QA_TESTER REVIEWER KNOWLEDGE_MANAGER],
+          "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER REVIEWER],
+          "refactor" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER REVIEWER],
+          "quick_fix" => %w[ENGINEER REVIEWER],
+          "exploration" => %w[RESEARCHER]
         }
       }
     }.freeze

data/lib/agentf/service/providers.rb

@@ -61,18 +61,18 @@ module Agentf
           return { "error" => "Agent #{agent_name} not found" } unless agent
 
           result = case agent_name
-                   when "ARCHITECT"
-                     agent.plan_task(task)
-                   when "EXPLORER"
-                     query = context["explore_query"] || "*.rb"
-                     files = commands.fetch("explorer").glob(query)
-                     response = agent.explore(query)
-                     response["files"] = files
-                     response
-                   when "TESTER"
-                      source_file = context["source_file"] || "app/models/application_record.rb"
-                      tester_commands = commands.fetch("tester")
-                      tdd_phase = context["tdd_phase"] || "normal"
+                   when Agentf::AgentRoles::PLANNER
+                      agent.plan_task(task)
+                   when Agentf::AgentRoles::RESEARCHER
+                      query = context["explore_query"] || "*.rb"
+                      files = commands.fetch("explorer").glob(query)
+                      response = agent.explore(query)
+                      response["files"] = files
+                      response
+                   when Agentf::AgentRoles::QA_TESTER
+                       source_file = context["source_file"] || "app/models/application_record.rb"
+                       tester_commands = commands.fetch("tester")
+                       tdd_phase = context["tdd_phase"] || "normal"
 
                       if tdd_phase == "red"
                         failure_signature = "expected-failure:#{File.basename(source_file)}:#{Time.now.to_i}"
@@ -92,32 +92,32 @@ module Agentf
                         response["failure_signature"] = context["tdd_failure_signature"]
                         response
                       end
-                    when "DEBUGGER"
-                     error = context["error"] || "No error provided"
-                     analysis = commands.fetch("debugger").parse_error(error)
-                     response = agent.diagnose(error, context: context["error_context"])
+                    when Agentf::AgentRoles::INCIDENT_RESPONDER
+                      error = context["error"] || "No error provided"
+                      analysis = commands.fetch("debugger").parse_error(error)
+                      response = agent.diagnose(error, context: context["error_context"])
                      response["analysis"] = {
                        "error_type" => analysis.error_type,
                        "root_cause" => analysis.possible_causes,
                        "suggested_fix" => analysis.suggested_fix
                      }
                      response
-                   when "DESIGNER"
-                     design_spec = context["design_spec"] || "Create a card component"
-                     spec = commands.fetch("designer").generate_component("GeneratedComponent", design_spec)
-                     response = agent.implement_design(design_spec)
-                     response["generated_code"] = spec.code
-                     response
-                   when "SPECIALIST"
-                     subtask = context["current_subtask"] || { "description" => task }
-                     agent.execute(subtask)
-                   when "SECURITY"
-                     agent.assess(task: task, context: context)
-                   when "REVIEWER"
-                     last_result = context["execution"] || {}
-                     agent.review(last_result)
-                   when "DOCUMENTER"
-                     agent.sync_docs("project")
+                    when Agentf::AgentRoles::UI_ENGINEER
+                      design_spec = context["design_spec"] || "Create a card component"
+                      spec = commands.fetch("designer").generate_component("GeneratedComponent", design_spec)
+                      response = agent.implement_design(design_spec)
+                      response["generated_code"] = spec.code
+                      response
+                    when Agentf::AgentRoles::ENGINEER
+                      subtask = context["current_subtask"] || { "description" => task }
+                      agent.execute(subtask)
+                    when Agentf::AgentRoles::SECURITY_REVIEWER
+                      agent.assess(task: task, context: context)
+                    when Agentf::AgentRoles::REVIEWER
+                      last_result = context["execution"] || {}
+                      agent.review(last_result)
+                    when Agentf::AgentRoles::KNOWLEDGE_MANAGER
+                      agent.sync_docs("project")
                    else
                      { "status" => "not_implemented" }
                    end
@@ -133,11 +133,11 @@ module Agentf
       class OpenCode < Base
         def workflow_templates
           {
-            "feature" => %w[ARCHITECT EXPLORER DESIGNER SPECIALIST TESTER SECURITY REVIEWER DOCUMENTER],
-            "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER SECURITY REVIEWER],
-            "quick_fix" => %w[SPECIALIST SECURITY REVIEWER],
-            "exploration" => %w[EXPLORER],
-            "refactor" => %w[ARCHITECT EXPLORER SPECIALIST TESTER SECURITY REVIEWER]
+            "feature" => %w[PLANNER RESEARCHER UI_ENGINEER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER KNOWLEDGE_MANAGER],
+            "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER],
+            "quick_fix" => %w[ENGINEER SECURITY_REVIEWER REVIEWER],
+            "exploration" => %w[RESEARCHER],
+            "refactor" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER]
           }
         end
       end
@@ -145,11 +145,11 @@ module Agentf
       class Copilot < Base
         def workflow_templates
           {
-            "feature" => %w[ARCHITECT SPECIALIST TESTER SECURITY REVIEWER DOCUMENTER],
-            "bugfix" => %w[DEBUGGER SPECIALIST TESTER SECURITY REVIEWER],
-            "quick_fix" => %w[SPECIALIST REVIEWER],
-            "exploration" => %w[EXPLORER],
-            "refactor" => %w[ARCHITECT SPECIALIST TESTER REVIEWER]
+            "feature" => %w[PLANNER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER KNOWLEDGE_MANAGER],
+            "bugfix" => %w[INCIDENT_RESPONDER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER],
+            "quick_fix" => %w[ENGINEER REVIEWER],
+            "exploration" => %w[RESEARCHER],
+            "refactor" => %w[PLANNER ENGINEER QA_TESTER REVIEWER]
           }
         end
       end

data/lib/agentf/version.rb

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

data/lib/agentf/workflow_engine.rb

@@ -18,7 +18,7 @@ module Agentf
     def initialize(memory: nil, base_path: nil, provider: :opencode)
       @memory = memory || Agentf::Memory::RedisMemory.new
       @base_path = base_path || Agentf.config.base_path
-      @name = "WORKFLOW_ENGINE"
+      @name = Agentf::AgentRoles::ORCHESTRATOR
       @provider_ref = provider
       @provider = build_provider(@provider_ref, pack: Agentf.config.default_pack)
 
@@ -37,15 +37,15 @@ module Agentf
       )
 
       @agents = {
-        "ARCHITECT" => Agents::Architect.new(@memory),
-        "SPECIALIST" => Agents::Specialist.new(@memory),
-        "REVIEWER" => Agents::Reviewer.new(@memory),
-        "DOCUMENTER" => Agents::Documenter.new(@memory),
-        "EXPLORER" => Agents::Explorer.new(@memory, commands: @explorer_commands),
-        "TESTER" => Agents::Tester.new(@memory, commands: @tester_commands),
-        "DEBUGGER" => Agents::Debugger.new(@memory, commands: @debugger_commands),
-        "DESIGNER" => Agents::Designer.new(@memory, commands: @designer_commands),
-        "SECURITY" => Agents::Security.new(@memory, commands: @security_commands)
+        Agentf::AgentRoles::PLANNER => Agents::Architect.new(@memory),
+        Agentf::AgentRoles::ENGINEER => Agents::Specialist.new(@memory),
+        Agentf::AgentRoles::REVIEWER => Agents::Reviewer.new(@memory),
+        Agentf::AgentRoles::KNOWLEDGE_MANAGER => Agents::Documenter.new(@memory),
+        Agentf::AgentRoles::RESEARCHER => Agents::Explorer.new(@memory, commands: @explorer_commands),
+        Agentf::AgentRoles::QA_TESTER => Agents::Tester.new(@memory, commands: @tester_commands),
+        Agentf::AgentRoles::INCIDENT_RESPONDER => Agents::Debugger.new(@memory, commands: @debugger_commands),
+        Agentf::AgentRoles::UI_ENGINEER => Agents::Designer.new(@memory, commands: @designer_commands),
+        Agentf::AgentRoles::SECURITY_REVIEWER => Agents::Security.new(@memory, commands: @security_commands)
       }
 
       @workflow_state = {}
@@ -91,7 +91,7 @@ module Agentf
       persist_feature_intent(task: task, workflow_type: plan["workflow_type"], context: @workflow_state["context"])
 
       plan["agents_needed"].each do |agent_name|
-        run_pre_specialist_tdd_cycle if agent_name == "SPECIALIST"
+        run_pre_specialist_tdd_cycle if agent_name == Agentf::AgentRoles::ENGINEER
         agent_result = execute_agent(agent_name)
         @workflow_state["results"] << { "agent" => agent_name, "result" => agent_result }
         @workflow_state["completed_agents"] << agent_name
@@ -156,12 +156,12 @@ module Agentf
         )
       )
 
-      if agent_name == "TESTER"
+      if agent_name == Agentf::AgentRoles::QA_TESTER
         enriched_context["tdd_phase"] = @workflow_state.dig("tdd", "phase")
         enriched_context["tdd_failure_signature"] = @workflow_state.dig("tdd", "failure_signature")
       end
 
-      if agent_name == "SPECIALIST"
+      if agent_name == Agentf::AgentRoles::ENGINEER
         enriched_context["tdd_phase"] = "green"
         enriched_context["expected_test_fix"] = @workflow_state.dig("tdd", "failure_signature")
       end
@@ -241,7 +241,7 @@ module Agentf
         return
       end
 
-      if agent_name == "TESTER" && result["tdd_phase"] == "red" && result["passed"] == false
+      if agent_name == Agentf::AgentRoles::QA_TESTER && result["tdd_phase"] == "red" && result["passed"] == false
         @memory.store_pitfall(
           title: "TDD red phase captured",
           description: result["failure_signature"] || "Intentional failing test captured",
@@ -253,7 +253,7 @@ module Agentf
         return
       end
 
-      if agent_name == "TESTER" && result["tdd_phase"] == "green" && result["passed"] == true
+      if agent_name == Agentf::AgentRoles::QA_TESTER && result["tdd_phase"] == "green" && result["passed"] == true
         @memory.store_success(
           title: "TDD green phase passed",
           description: "Resolved failing test signature: #{result['failure_signature']}",
@@ -280,7 +280,7 @@ module Agentf
     def summarize_workflow
       results = @workflow_state["results"]
       errors = results.select { |r| r["result"]["error"] }
-      reviews = results.select { |r| r["agent"] == "REVIEWER" }
+      reviews = results.select { |r| r["agent"] == Agentf::AgentRoles::REVIEWER }
       approved = reviews.any? { |r| r["result"]["approved"] }
       contract_blocked = @workflow_state.dig("workflow_contract", "blocked") == true
 
@@ -312,11 +312,11 @@ module Agentf
 
       red_context = @workflow_state["context"].merge(
         "tdd_phase" => "red",
-        "brain" => @context_builder.build(agent: "TESTER", workflow_state: @workflow_state, limit: 8)
+        "brain" => @context_builder.build(agent: Agentf::AgentRoles::QA_TESTER, workflow_state: @workflow_state, limit: 8)
       )
 
       red_result = @provider.execute_agent(
-        agent_name: "TESTER",
+        agent_name: Agentf::AgentRoles::QA_TESTER,
         task: @workflow_state["task"],
         context: red_context,
         agents: @agents,
@@ -326,8 +326,8 @@ module Agentf
 
       tdd["red_executed"] = true
       tdd["failure_signature"] = red_result["failure_signature"]
-      @workflow_state["results"] << { "agent" => "TESTER_TDD_RED", "result" => red_result }
-      persist_agent_learning(agent_name: "TESTER", result: red_result)
+      @workflow_state["results"] << { "agent" => "QA_TESTER_TDD_RED", "result" => red_result }
+      persist_agent_learning(agent_name: Agentf::AgentRoles::QA_TESTER, result: red_result)
     rescue StandardError => e
       log "TDD red phase skipped: #{e.message}"
     end
@@ -336,13 +336,13 @@ module Agentf
       tdd = @workflow_state["tdd"]
       return unless tdd["enabled"]
 
-      if agent_name == "SPECIALIST"
+      if agent_name == Agentf::AgentRoles::ENGINEER
         tdd["phase"] = "green"
-      elsif agent_name == "TESTER" && tdd["phase"] == "green"
+      elsif agent_name == Agentf::AgentRoles::QA_TESTER && tdd["phase"] == "green"
         tdd["green_executed"] = true
       end
 
-      return unless agent_name == "TESTER" && result["tdd_phase"] == "green"
+      return unless agent_name == Agentf::AgentRoles::QA_TESTER && result["tdd_phase"] == "green"
 
       tdd["failure_signature"] ||= result["failure_signature"]
     end

data/lib/agentf.rb

@@ -6,6 +6,7 @@ require "time"
 require "securerandom"
 require "pathname"
 require_relative "agentf/version"
+require_relative "agentf/agent_roles"
 
 module Agentf
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agentf
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Neal Deters
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-07 00:00:00.000000000 Z
+date: 2026-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -81,9 +81,11 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.9.0
 description: |2
-      A multi-agent system with Redis-backed memory for code execution,
-      testing, debugging, and design implementation. Designed for
-      frontend, backend, and API development workflows.
+      Agentf is a Ruby-native multi-agent workflow engine with an ORCHESTRATOR,
+      role-specialized agents, provider adapters (OpenCode/Copilot), and
+      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: 
 executables:
 - agentf
@@ -93,6 +95,7 @@ files:
 - bin/agentf
 - lib/agentf.rb
 - lib/agentf/agent_policy.rb
+- lib/agentf/agent_roles.rb
 - lib/agentf/agents.rb
 - lib/agentf/agents/architect.rb
 - lib/agentf/agents/base.rb
@@ -124,6 +127,7 @@ files:
 - lib/agentf/context_builder.rb
 - lib/agentf/installer.rb
 - lib/agentf/mcp/server.rb
+- lib/agentf/mcp/stub.rb
 - lib/agentf/memory.rb
 - lib/agentf/packs.rb
 - lib/agentf/service/providers.rb
@@ -160,5 +164,5 @@ requirements: []
 rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
-summary: A self-learning swarm of agents with shared memory
+summary: Ruby multi-agent workflow engine with Redis memory
 test_files: []