agentf 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc86ebb30ccffc8b338dd6e728947f87886c302046e81c01e10d739aac78095f
+  data.tar.gz: dda17a3643259253dac2b299e8b45c4f016f4e01f381e6b81956f54633eebcd3
+SHA512:
+  metadata.gz: ff8dd589ee31f74de1a35b0fc8122292b7b78747eb3d45338cc4f9fdcff4f8956f69ad0935aa0cc9b3d7bc3395b607b98d5143e1563c786f83eae44902153bb3
+  data.tar.gz: 4334dabaf36eabfdfbfeac1b7ff4bda60f1f2b17361df549ef641a85479c2b80b82806a5c18ffacfcba1ee0f7d618c13d55e0ffef8d7e66d0164aade58298a86

data/bin/agentf

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "agentf"
+require "agentf/cli/router"
+
+Agentf::CLI::Router.new.run(ARGV.dup)

data/lib/agentf/agent_policy.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Agentf
+  class AgentPolicy
+    REQUIRED_KEYS = %w[always ask_first never].freeze
+
+    def validate(agent_name:, boundaries:, context: {}, result: nil)
+      errors = []
+      boundaries = normalize(boundaries)
+
+      required_inputs = Array(boundaries["required_inputs"])
+      missing_inputs = required_inputs.reject { |key| context.key?(key) }
+      unless missing_inputs.empty?
+        errors << violation(
+          code: "missing_required_inputs",
+          severity: "error",
+          message: "#{agent_name} missing required inputs: #{missing_inputs.join(', ')}",
+          agent: agent_name
+        )
+      end
+
+      if result.is_a?(Hash) && result["error"]
+        errors << violation(
+          code: "agent_result_error",
+          severity: "warn",
+          message: "#{agent_name} returned an error: #{result['error']}",
+          agent: agent_name
+        )
+      end
+
+      errors
+    end
+
+    def normalize(boundaries)
+      payload = (boundaries || {}).transform_keys(&:to_s)
+      REQUIRED_KEYS.each { |key| payload[key] = Array(payload[key]) }
+      payload["required_inputs"] = Array(payload["required_inputs"])
+      payload["required_outputs"] = Array(payload["required_outputs"])
+      payload
+    end
+
+    private
+
+    def violation(code:, severity:, message:, agent:)
+      {
+        "code" => code,
+        "severity" => severity,
+        "message" => message,
+        "agent" => agent,
+        "type" => "agent_policy"
+      }
+    end
+  end
+end

data/lib/agentf/agents/architect.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Agentf
+  module Agents
+    # Architect Agent - Strategy, task decomposition
+    class Architect < Base
+      DESCRIPTION = "Strategy, task decomposition, and memory retrieval."
+      COMMANDS = %w[glob read_file memory].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => ["get_recent_memories", "get_pitfalls"],
+        "writes" => [],
+        "policy" => "Retrieve relevant memories before planning; do not duplicate runtime memory into static markdown."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Capture constraints before decomposition", "Use recent memories and pitfalls in planning"],
+          "ask_first" => ["Changing architectural style from project defaults"],
+          "never" => ["Skip task decomposition for non-trivial workflows"],
+          "required_inputs" => [],
+          "required_outputs" => ["subtasks", "context"]
+        }
+      end
+
+      def plan_task(task)
+        log "Planning: #{task}"
+
+        # Retrieve relevant memories before planning
+        recent = memory.get_recent_memories(limit: 5)
+        pitfalls = memory.get_pitfalls(limit: 3)
+
+        context = {
+          "task" => task,
+          "relevant_memories" => recent,
+          "pitfalls_to_avoid" => pitfalls
+        }
+
+        # Decompose into subtasks
+        subtasks = [
+          { "id" => 1, "description" => "Research and gather requirements" },
+          { "id" => 2, "description" => "Implement the solution" },
+          { "id" => 3, "description" => "Review and test" }
+        ]
+
+        log "Found #{recent.size} relevant memories"
+        log "Avoiding #{pitfalls.size} known pitfalls"
+        log "Created #{subtasks.size} subtasks"
+
+        { "subtasks" => subtasks, "context" => context }
+      end
+    end
+  end
+end

data/lib/agentf/agents/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Agents
+    # Base agent class
+    class Base
+      attr_reader :memory, :name
+
+      def self.typed_name
+        name.split("::").last.upcase
+      end
+
+      def self.description
+        "Agent for #{typed_name.downcase}"
+      end
+
+      def self.commands
+        []
+      end
+
+      def self.memory_concepts
+        {
+          "reads" => ["RedisMemory#get_recent_memories", "RedisMemory#get_pitfalls"],
+          "writes" => ["RedisMemory#store_lesson", "RedisMemory#store_success", "RedisMemory#store_pitfall"],
+          "policy" => "Memory is runtime state in Redis and should not be embedded as raw data in manifest markdown."
+        }
+      end
+
+      def self.prompt
+        "You are the #{typed_name} agent."
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => [],
+          "ask_first" => [],
+          "never" => [],
+          "required_inputs" => [],
+          "required_outputs" => []
+        }
+      end
+
+      def initialize(memory)
+        @memory = memory
+        @name = self.class.typed_name
+      end
+
+      def log(message)
+        puts "\n[#{@name}] #{message}"
+      end
+    end
+  end
+end

data/lib/agentf/agents/debugger.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../commands"
+
+module Agentf
+  module Agents
+    # Debugger Agent - Error analysis and diagnosis
+    class Debugger < Base
+      DESCRIPTION = "Error analysis, diagnosis, and remediation guidance."
+      COMMANDS = %w[parse_error analyze_logs suggest_fix].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => [],
+        "writes" => ["store_episode"],
+        "policy" => "Persist debugging lessons with root cause and proposed fixes."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Return analysis with root causes and suggested fix", "Persist debugging lesson"],
+          "ask_first" => ["Applying speculative fixes without reproducible error"],
+          "never" => ["Discard stack trace context when available"],
+          "required_inputs" => [],
+          "required_outputs" => ["analysis"]
+        }
+      end
+
+      def initialize(memory, commands: nil)
+        super(memory)
+        @commands = commands || Agentf::Commands::Debugger.new
+      end
+
+      def diagnose(error, context: nil)
+        log "Diagnosing error"
+        log "  Error: #{error[0..100]}..."
+
+        analysis = @commands.parse_error(error)
+
+        memory.store_episode(
+          type: "lesson",
+          title: "Debugged: #{error[0..50]}...",
+          description: "Root cause: #{analysis.possible_causes.first}. Fix: #{analysis.suggested_fix}",
+          context: context.to_s,
+          tags: ["debugging", "error", "fix"],
+          agent: name
+        )
+
+        log "Root cause: #{analysis.possible_causes.first}"
+        log "Suggested fix: #{analysis.suggested_fix}"
+
+        {
+          "error" => error,
+          "analysis" => {
+            "error_type" => analysis.error_type,
+            "possible_causes" => analysis.possible_causes,
+            "suggested_fix" => analysis.suggested_fix,
+            "stack_trace" => analysis.stack_trace
+          }
+        }
+      end
+    end
+  end
+end

data/lib/agentf/agents/designer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../commands"
+
+module Agentf
+  module Agents
+    # Designer Agent - Design specs to implementation
+    class Designer < Base
+      DESCRIPTION = "UI/UX implementation from design specs."
+      COMMANDS = %w[generate_component validate_design_system].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => [],
+        "writes" => ["store_success"],
+        "policy" => "Capture successful design implementation patterns."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Return generated component details", "Persist successful implementation pattern"],
+          "ask_first" => ["Changing primary UI framework"],
+          "never" => ["Return empty generated code for successful design task"],
+          "required_inputs" => [],
+          "required_outputs" => ["component", "generated_code"]
+        }
+      end
+
+      def initialize(memory, commands: nil)
+        super(memory)
+        @commands = commands || Agentf::Commands::Designer.new
+      end
+
+      def implement_design(design_spec, framework: "react")
+        log "Implementing design: #{design_spec}"
+
+        spec = @commands.generate_component("GeneratedComponent", design_spec)
+
+        memory.store_success(
+          title: "Implemented design: #{design_spec}",
+          description: "Created #{spec.name} in #{spec.framework}",
+          context: "Framework: #{framework}",
+          tags: ["design", "ui", framework],
+          agent: name
+        )
+
+        log "Created component: #{spec.name}"
+
+        {
+          "design_spec" => design_spec,
+          "component" => spec.name,
+          "framework" => framework,
+          "generated_code" => spec.code
+        }
+      end
+    end
+  end
+end

data/lib/agentf/agents/documenter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Agentf
+  module Agents
+    # Documenter Agent - Sync Redis memory with local Markdown docs
+    class Documenter < Base
+      DESCRIPTION = "Syncs Redis memory with local Markdown summaries."
+      COMMANDS = %w[read_file write_file memory].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => ["get_recent_memories"],
+        "writes" => [],
+        "policy" => "Summarize memory trends into docs without storing raw secrets."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Summarize recent successes and pitfalls"],
+          "ask_first" => ["Publishing docs to external destinations"],
+          "never" => ["Leak sensitive context in summaries"],
+          "required_inputs" => [],
+          "required_outputs" => ["successes", "pitfalls", "total_memories"]
+        }
+      end
+
+      def sync_docs(project_name)
+        log "Syncing documentation"
+
+        memories = memory.get_recent_memories(limit: 20)
+
+        successes = memories.select { |m| m["type"] == "success" }
+        pitfalls = memories.select { |m| m["type"] == "pitfall" }
+
+        log "Found #{successes.size} successes"
+        log "Found #{pitfalls.size} pitfalls"
+
+        {
+          "successes" => successes,
+          "pitfalls" => pitfalls,
+          "total_memories" => memories.size
+        }
+      end
+    end
+  end
+end

data/lib/agentf/agents/explorer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../commands"
+
+module Agentf
+  module Agents
+    # Explorer Agent - Codebase exploration
+    class Explorer < Base
+      DESCRIPTION = "Rapid codebase exploration and context gathering."
+      COMMANDS = %w[glob grep read_file].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => [],
+        "writes" => ["store_episode"],
+        "policy" => "Store exploration breadcrumbs as episodic memories."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Return concrete file evidence", "Persist exploration breadcrumbs"],
+          "ask_first" => ["Scanning outside configured base path"],
+          "never" => ["Mutate project files during exploration"],
+          "required_inputs" => [],
+          "required_outputs" => ["files", "context_gathered"]
+        }
+      end
+
+      def initialize(memory, commands: nil)
+        super(memory)
+        @commands = commands || Agentf::Commands::Explorer.new
+      end
+
+      def explore(query, file_pattern: nil)
+        log "Exploring: #{query}"
+
+        files = @commands.glob(query, file_types: nil)
+
+        memory.store_episode(
+          type: "exploration",
+          title: "Explored: #{query}",
+          description: "Found #{files.size} relevant files",
+          context: "Search pattern: #{file_pattern || 'all files'}",
+          tags: ["exploration", "context"],
+          agent: name
+        )
+
+        log "Found #{files.size} files"
+
+        { "query" => query, "files" => files, "context_gathered" => true }
+      end
+    end
+  end
+end

data/lib/agentf/agents/reviewer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Agentf
+  module Agents
+    # Reviewer Agent - Quality assurance
+    class Reviewer < Base
+      DESCRIPTION = "Quality assurance and regression checking against memory."
+      COMMANDS = %w[read_file memory].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => ["get_pitfalls", "get_recent_memories"],
+        "writes" => [],
+        "policy" => "Validate outputs against known pitfalls before approval."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Report approval decision", "Highlight known pitfalls in review findings"],
+          "ask_first" => ["Approving with unresolved critical security issues"],
+          "never" => ["Approve without any review evidence"],
+          "required_inputs" => [],
+          "required_outputs" => ["approved", "issues"]
+        }
+      end
+
+      def review(subtask_result)
+        log "Reviewing subtask #{subtask_result['subtask_id']}"
+
+        pitfalls = memory.get_pitfalls(limit: 5)
+        memories = memory.get_recent_memories(limit: 5)
+
+        issues = []
+
+        pitfalls.each do |pitfall|
+          issues << "Warning: Known pitfall - #{pitfall['title']}" if pitfall["type"] == "pitfall"
+        end
+
+        approved = issues.empty?
+
+        if approved
+          log "Approved (no issues found)"
+        else
+          log "Issues found: #{issues.size}"
+          issues.each { |issue| log "  - #{issue}" }
+        end
+
+        { "approved" => approved, "issues" => issues }
+      end
+    end
+  end
+end

data/lib/agentf/agents/security.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../commands"
+
+module Agentf
+  module Agents
+    # Security Agent - Performs lightweight security assessments during workflows
+    class Security < Base
+      DESCRIPTION = "Security scanning for secret leaks and prompt injection."
+      COMMANDS = %w[scan best_practices].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => [],
+        "writes" => ["store_success", "store_pitfall"],
+        "policy" => "Record findings while redacting sensitive values."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Return issue list and best practices", "Persist outcome as success or pitfall"],
+          "ask_first" => ["Allowing known secret patterns in context"],
+          "never" => ["Echo raw secrets in output"],
+          "required_inputs" => [],
+          "required_outputs" => ["issues", "best_practices"]
+        }
+      end
+
+      def initialize(memory, commands: nil)
+        super(memory)
+        @commands = commands || Agentf::Commands::SecurityScanner.new
+      end
+
+      def assess(task:, context: {})
+        log "Running security assessment"
+
+        findings = @commands.scan(task: task, context: context)
+        summary = summarize_findings(findings)
+
+        if findings["issues"].empty?
+          memory.store_success(
+            title: "Security review passed",
+            description: summary,
+            context: task,
+            tags: ["security", "pass"],
+            agent: name
+          )
+        else
+          memory.store_pitfall(
+            title: "Security findings detected",
+            description: summary,
+            context: task,
+            tags: ["security", "warning"],
+            agent: name
+          )
+        end
+
+        findings.merge("best_practices" => @commands.best_practices)
+      end
+
+      private
+
+      def summarize_findings(findings)
+        if findings["issues"].empty?
+          "No potential secrets or prompt-injection attempts detected."
+        else
+          issues = findings["issues"].map { |issue| "- #{issue['issue']}: #{issue['detail']}" }
+          "Identified #{findings['issues'].size} potential issue(s):\n#{issues.join('\n')}"
+        end
+      end
+    end
+  end
+end

data/lib/agentf/agents/specialist.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Agentf
+  module Agents
+    # Specialist Agent - Code execution
+    class Specialist < Base
+      DESCRIPTION = "Code execution and lesson-learning persistence."
+      COMMANDS = %w[read_file write_file run_command].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => [],
+        "writes" => ["store_success", "store_pitfall"],
+        "policy" => "Persist execution outcomes as lessons for downstream agents."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Persist execution outcome", "Return deterministic success boolean"],
+          "ask_first" => ["Applying architecture style changes across unrelated modules"],
+          "never" => ["Claim implementation complete without execution result"],
+          "required_inputs" => [],
+          "required_outputs" => ["subtask_id", "success"]
+        }
+      end
+
+      def execute(subtask)
+        log "Executing: #{subtask['description']}"
+
+        success = subtask.fetch("success", true)
+
+        if success
+          memory.store_success(
+            title: "Completed: #{subtask['description']}",
+            description: "Successfully executed subtask #{subtask['id']}",
+            context: "Working on #{subtask.fetch('task', 'unknown task')}",
+            tags: ["implementation", subtask.fetch("language", "general")],
+            agent: name
+          )
+          log "Stored success memory"
+        else
+          memory.store_pitfall(
+            title: "Failed: #{subtask['description']}",
+            description: "Subtask #{subtask['id']} failed",
+            context: "Working on #{subtask.fetch('task', 'unknown task')}",
+            tags: ["failure", "implementation"],
+            agent: name
+          )
+          log "Stored pitfall memory"
+        end
+
+        { "subtask_id" => subtask["id"], "success" => success, "result" => "Code executed" }
+      end
+    end
+  end
+end