agentf 0.3.0

data/lib/agentf/workflow_engine.rb

@@ -0,0 +1,424 @@
+# frozen_string_literal: true
+
+require_relative "agents"
+require_relative "commands"
+require_relative "context_builder"
+require_relative "workflow_contract"
+require_relative "agent_policy"
+
+module Agentf
+  class WorkflowEngine
+    PROVIDERS = {
+      opencode: Agentf::Service::Providers::OpenCode,
+      copilot: Agentf::Service::Providers::Copilot
+    }.freeze
+
+    attr_reader :memory, :base_path, :provider
+
+    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"
+      @provider_ref = provider
+      @provider = build_provider(@provider_ref, pack: Agentf.config.default_pack)
+
+      @explorer_commands = Commands::Explorer.new(base_path: @base_path)
+      @tester_commands = Commands::Tester.new(base_path: @base_path)
+      @debugger_commands = Commands::Debugger.new(base_path: @base_path)
+      @designer_commands = Commands::Designer.new(base_path: @base_path)
+      @security_commands = Commands::SecurityScanner.new
+      @architecture_commands = Commands::Architecture.new(base_path: @base_path)
+      @metrics_commands = Agentf.config.metrics_enabled ? Commands::Metrics.new(memory: @memory) : nil
+      @context_builder = ContextBuilder.new(memory: @memory)
+      @agent_policy = Agentf::AgentPolicy.new
+      @workflow_contract = Agentf::WorkflowContract.new(
+        enabled: Agentf.config.workflow_contract_enabled,
+        mode: Agentf.config.workflow_contract_mode
+      )
+
+      @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)
+      }
+
+      @workflow_state = {}
+    end
+
+    def execute(task, context: nil)
+      log "=" * 60
+      log "EXECUTING #{provider.name} WORKFLOW"
+      log "=" * 60
+
+      resolved_context = context || {}
+      selected_pack = resolve_pack(task: task, context: resolved_context)
+      @provider = build_provider(@provider_ref, pack: selected_pack)
+
+      @workflow_state = {
+        "task" => task,
+        "provider" => @provider.name,
+        "pack" => selected_pack,
+        "workflow_contract" => {
+          "enabled" => @workflow_contract.enabled?,
+          "mode" => @workflow_contract.mode,
+          "events" => [],
+          "blocked" => false
+        },
+        "context" => resolved_context,
+        "results" => [],
+        "completed_agents" => []
+      }
+
+      return @workflow_state if run_contract_stage("spec").fetch("blocked")
+
+      plan = provider.build_plan(task: task, context: resolved_context, logger: method(:log))
+      return @workflow_state if run_contract_stage("plan", plan: plan).fetch("blocked")
+
+      @workflow_state.merge!(
+        "provider" => plan["provider"],
+        "workflow_type" => plan["workflow_type"],
+        "tdd" => initialize_tdd_state(plan["workflow_type"]),
+        "plan" => plan
+      )
+
+      attach_initial_brain_context
+      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"
+        agent_result = execute_agent(agent_name)
+        @workflow_state["results"] << { "agent" => agent_name, "result" => agent_result }
+        @workflow_state["completed_agents"] << agent_name
+      end
+
+      return @workflow_state if run_contract_stage("execute").fetch("blocked")
+
+      architecture_review = perform_architecture_review
+      @workflow_state["architecture_review"] = architecture_review
+
+      return @workflow_state if run_contract_stage("review").fetch("blocked")
+
+      run_contract_stage("finalize")
+      summary = summarize_workflow
+      @workflow_state["summary"] = summary
+      record_workflow_metrics
+
+      log ""
+      log "=" * 60
+      log "WORKFLOW COMPLETE"
+      log "=" * 60
+      log "Provider: #{plan['provider']}"
+      log "Workflow type: #{plan['workflow_type']}"
+      log "Agents executed: #{@workflow_state['completed_agents'].size}"
+      log "Overall status: #{summary['status']}"
+
+      @workflow_state
+    end
+
+    private
+
+    def build_provider(provider, pack:)
+      return provider if provider.respond_to?(:build_plan)
+
+      klass = PROVIDERS[provider.to_sym]
+      raise ArgumentError, "Unknown provider: #{provider}. Valid providers: #{PROVIDERS.keys.join(', ')}" unless klass
+
+      klass.new(pack: pack)
+    end
+
+    def resolve_pack(task:, context:)
+      requested = context["pack"].to_s.strip
+      return requested.downcase unless requested.empty?
+
+      default_pack = Agentf.config.default_pack.to_s.strip
+      return default_pack.downcase unless default_pack.empty? || default_pack.casecmp("generic").zero?
+
+      Agentf::Packs.infer(context.merge("task" => task))
+    end
+
+    def log(message)
+      puts "\n[#{@name}] #{message}"
+    end
+
+    def execute_agent(agent_name)
+      context = @workflow_state["context"]
+      enriched_context = context.merge(
+        "brain" => @context_builder.build(
+          agent: agent_name,
+          workflow_state: @workflow_state,
+          limit: 8
+        )
+      )
+
+      if agent_name == "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"
+        enriched_context["tdd_phase"] = "green"
+        enriched_context["expected_test_fix"] = @workflow_state.dig("tdd", "failure_signature")
+      end
+
+      result = @provider.execute_agent(
+        agent_name: agent_name,
+        task: @workflow_state["task"],
+        context: enriched_context,
+        agents: @agents,
+        commands: command_registry,
+        logger: method(:log)
+      )
+
+      policy_violations = @agent_policy.validate(
+        agent_name: agent_name,
+        boundaries: @agents.fetch(agent_name).class.policy_boundaries,
+        context: enriched_context,
+        result: result
+      )
+      append_policy_violations(policy_violations)
+
+      persist_agent_learning(agent_name: agent_name, result: result)
+      transition_tdd_phase(agent_name: agent_name, result: result)
+      result
+    end
+
+    def command_registry
+      {
+        "explorer" => @explorer_commands,
+        "tester" => @tester_commands,
+        "debugger" => @debugger_commands,
+        "designer" => @designer_commands,
+        "security" => @security_commands,
+        "architecture" => @architecture_commands
+      }
+    end
+
+    def attach_initial_brain_context
+      @workflow_state["context"]["brain"] = @context_builder.build(
+        agent: @name,
+        workflow_state: @workflow_state,
+        limit: 8
+      )
+    rescue StandardError
+      @workflow_state["context"]["brain"] = {}
+    end
+
+    def persist_feature_intent(task:, workflow_type:, context:)
+      acceptance_criteria = Array(context["acceptance_criteria"])
+      non_goals = Array(context["non_goals"])
+      tags = [workflow_type, @provider.name.downcase]
+
+      @memory.store_feature_intent(
+        title: task,
+        description: "Workflow intent captured by workflow engine",
+        acceptance_criteria: acceptance_criteria,
+        non_goals: non_goals,
+        tags: tags,
+        agent: @name
+      )
+    rescue StandardError => e
+      log "Intent capture skipped: #{e.message}"
+    end
+
+    def persist_agent_learning(agent_name:, result:)
+      return unless result.is_a?(Hash)
+
+      if result["error"]
+        @memory.store_pitfall(
+          title: "#{agent_name} execution failure",
+          description: result["error"],
+          context: @workflow_state["task"],
+          tags: [@workflow_state["workflow_type"], "workflow_error"],
+          agent: agent_name,
+          code_snippet: ""
+        )
+        return
+      end
+
+      if agent_name == "TESTER" && result["tdd_phase"] == "red" && result["passed"] == false
+        @memory.store_pitfall(
+          title: "TDD red phase captured",
+          description: result["failure_signature"] || "Intentional failing test captured",
+          context: @workflow_state["task"],
+          tags: [@workflow_state["workflow_type"], "tdd_red"],
+          agent: agent_name,
+          code_snippet: ""
+        )
+        return
+      end
+
+      if agent_name == "TESTER" && result["tdd_phase"] == "green" && result["passed"] == true
+        @memory.store_success(
+          title: "TDD green phase passed",
+          description: "Resolved failing test signature: #{result['failure_signature']}",
+          context: @workflow_state["task"],
+          tags: [@workflow_state["workflow_type"], "tdd_green"],
+          agent: agent_name,
+          code_snippet: ""
+        )
+        return
+      end
+
+      @memory.store_lesson(
+        title: "#{agent_name} completed workflow step",
+        description: "Agent step completed for #{@workflow_state['workflow_type']} workflow",
+        context: @workflow_state["task"],
+        tags: [@workflow_state["workflow_type"], "workflow_step"],
+        agent: agent_name,
+        code_snippet: ""
+      )
+    rescue StandardError => e
+      log "Learning persistence skipped: #{e.message}"
+    end
+
+    def summarize_workflow
+      results = @workflow_state["results"]
+      errors = results.select { |r| r["result"]["error"] }
+      reviews = results.select { |r| r["agent"] == "REVIEWER" }
+      approved = reviews.any? { |r| r["result"]["approved"] }
+      contract_blocked = @workflow_state.dig("workflow_contract", "blocked") == true
+
+      {
+        "status" => contract_blocked ? "blocked" : (errors.any? ? "failed" : (approved ? "approved" : "completed")),
+        "total_agents" => results.size,
+        "errors" => errors.size,
+        "approved" => approved,
+        "tdd" => @workflow_state["tdd"],
+        "contract_blocked" => contract_blocked
+      }
+    end
+
+    def initialize_tdd_state(workflow_type)
+      enabled = %w[feature bugfix refactor].include?(workflow_type)
+      {
+        "enabled" => enabled,
+        "phase" => enabled ? "red" : "disabled",
+        "failure_signature" => nil,
+        "red_executed" => false,
+        "green_executed" => false
+      }
+    end
+
+    def run_pre_specialist_tdd_cycle
+      tdd = @workflow_state["tdd"]
+      return unless tdd["enabled"]
+      return if tdd["red_executed"]
+
+      red_context = @workflow_state["context"].merge(
+        "tdd_phase" => "red",
+        "brain" => @context_builder.build(agent: "TESTER", workflow_state: @workflow_state, limit: 8)
+      )
+
+      red_result = @provider.execute_agent(
+        agent_name: "TESTER",
+        task: @workflow_state["task"],
+        context: red_context,
+        agents: @agents,
+        commands: command_registry,
+        logger: method(:log)
+      )
+
+      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)
+    rescue StandardError => e
+      log "TDD red phase skipped: #{e.message}"
+    end
+
+    def transition_tdd_phase(agent_name:, result:)
+      tdd = @workflow_state["tdd"]
+      return unless tdd["enabled"]
+
+      if agent_name == "SPECIALIST"
+        tdd["phase"] = "green"
+      elsif agent_name == "TESTER" && tdd["phase"] == "green"
+        tdd["green_executed"] = true
+      end
+
+      return unless agent_name == "TESTER" && result["tdd_phase"] == "green"
+
+      tdd["failure_signature"] ||= result["failure_signature"]
+    end
+
+    def record_workflow_metrics
+      return unless @metrics_commands
+
+      result = @metrics_commands.record_workflow(@workflow_state)
+      return if result["status"] == "recorded"
+
+      log "Metrics capture skipped: #{result['error']}"
+    rescue StandardError => e
+      log "Metrics capture skipped: #{e.message}"
+    end
+
+    def perform_architecture_review
+      result = @architecture_commands.review_layer_violations
+      @memory.store_lesson(
+        title: "Architecture review completed",
+        description: "Layer violations: #{Array(result['violations']).length}",
+        context: @workflow_state["task"],
+        tags: [@workflow_state["workflow_type"], "architecture_review"],
+        agent: @name
+      )
+      result
+    rescue StandardError => e
+      { "error" => e.message, "violations" => [] }
+    end
+
+    def run_contract_stage(stage, plan: nil)
+      evaluation = @workflow_contract.check(stage: stage, workflow_state: @workflow_state, plan: plan)
+      @workflow_state["workflow_contract"]["events"] << evaluation
+      persist_contract_event(evaluation)
+
+      if evaluation["blocked"]
+        @workflow_state["workflow_contract"]["blocked"] = true
+        log "Workflow blocked by contract at #{stage}: #{evaluation['violations'].map { |v| v['code'] }.join(', ')}"
+      elsif evaluation["violations"].any?
+        log "Workflow contract warnings at #{stage}: #{evaluation['violations'].map { |v| v['code'] }.join(', ')}"
+      end
+
+      evaluation
+    end
+
+    def persist_contract_event(evaluation)
+      @memory.store_episode(
+        type: "lesson",
+        title: "Workflow contract #{evaluation['stage']} #{evaluation['ok'] ? 'passed' : 'violated'}",
+        description: "mode=#{evaluation['mode']} blocked=#{evaluation['blocked']}",
+        context: JSON.generate(evaluation),
+        tags: ["workflow_contract", evaluation["stage"], evaluation["ok"] ? "pass" : "violation"],
+        agent: @name,
+        metadata: { "workflow_contract_event" => true }
+      )
+    rescue StandardError => e
+      log "Contract event persistence skipped: #{e.message}"
+    end
+
+    def append_policy_violations(policy_violations)
+      return if policy_violations.empty?
+
+      @workflow_state["policy_violations"] ||= []
+      @workflow_state["policy_violations"].concat(policy_violations)
+      policy_violations.each do |violation|
+        @memory.store_episode(
+          type: "pitfall",
+          title: "Agent policy violation: #{violation['code']}",
+          description: violation["message"],
+          context: @workflow_state["task"],
+          tags: ["agent_policy", violation["agent"].to_s.downcase],
+          agent: @name,
+          metadata: { "policy_violation" => true, "severity" => violation["severity"] }
+        )
+      end
+    rescue StandardError => e
+      log "Policy violation persistence skipped: #{e.message}"
+    end
+  end
+end

data/lib/agentf.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+require "json"
+require "time"
+require "securerandom"
+require "pathname"
+require_relative "agentf/version"
+
+module Agentf
+  class Error < StandardError; end
+
+  # Global configuration
+  class Config
+    attr_reader :redis_url
+    attr_accessor :project_name, :base_path, :metrics_enabled, :workflow_contract_enabled,
+                  :workflow_contract_mode, :default_pack, :gem_path
+
+    def initialize
+      @redis_url = normalize_redis_url(ENV.fetch("REDIS_URL", "redis://localhost:6379"))
+      @project_name = ENV.fetch("AGENTF_PROJECT_NAME", "default")
+      @base_path = Dir.pwd
+      @metrics_enabled = parse_boolean(ENV.fetch("AGENTF_METRICS_ENABLED", "true"), default: true)
+      @workflow_contract_enabled = parse_boolean(
+        ENV.fetch("AGENTF_WORKFLOW_CONTRACT_ENABLED", "true"),
+        default: true
+      )
+      @workflow_contract_mode = normalize_contract_mode(
+        ENV.fetch("AGENTF_WORKFLOW_CONTRACT_MODE", "advisory")
+      )
+      @default_pack = ENV.fetch("AGENTF_DEFAULT_PACK", "generic").to_s.strip.downcase
+      @gem_path = ENV.fetch("AGENTF_GEM_PATH", nil)
+    end
+
+    def redis_url=(value)
+      @redis_url = normalize_redis_url(value)
+    end
+
+    private
+
+    def normalize_redis_url(value)
+      url = value.to_s.strip
+      return "redis://localhost:6379" if url.empty?
+
+      return url if url.match?(/\A[a-z][a-z0-9+\-.]*:\/\//i)
+
+      "redis://#{url}"
+    end
+
+    def parse_boolean(value, default:)
+      normalized = value.to_s.strip.downcase
+      return true if %w[1 true yes on].include?(normalized)
+      return false if %w[0 false no off].include?(normalized)
+
+      default
+    end
+
+    def normalize_contract_mode(value)
+      mode = value.to_s.strip.downcase
+      return mode if %w[advisory enforcing off].include?(mode)
+
+      "advisory"
+    end
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield(config) if block_given?
+  end
+end
+
+# Load submodules
+require_relative "agentf/memory"
+require_relative "agentf/tools"
+require_relative "agentf/commands"
+require_relative "agentf/service/providers"
+require_relative "agentf/context_builder"
+require_relative "agentf/packs"
+require_relative "agentf/agent_policy"
+require_relative "agentf/workflow_contract"
+require_relative "agentf/workflow_engine"
+require_relative "agentf/installer"
+require_relative "agentf/agents"
+require_relative "agentf/cli/router"

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: agentf
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Neal Deters
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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.
+email: 
+executables:
+- agentf
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/agentf
+- lib/agentf.rb
+- lib/agentf/agent_policy.rb
+- lib/agentf/agents.rb
+- lib/agentf/agents/architect.rb
+- lib/agentf/agents/base.rb
+- lib/agentf/agents/debugger.rb
+- lib/agentf/agents/designer.rb
+- lib/agentf/agents/documenter.rb
+- lib/agentf/agents/explorer.rb
+- lib/agentf/agents/reviewer.rb
+- lib/agentf/agents/security.rb
+- lib/agentf/agents/specialist.rb
+- lib/agentf/agents/tester.rb
+- lib/agentf/cli/architecture.rb
+- lib/agentf/cli/arg_parser.rb
+- lib/agentf/cli/code.rb
+- lib/agentf/cli/install.rb
+- lib/agentf/cli/memory.rb
+- lib/agentf/cli/metrics.rb
+- lib/agentf/cli/router.rb
+- lib/agentf/cli/update.rb
+- lib/agentf/commands.rb
+- lib/agentf/commands/architecture.rb
+- lib/agentf/commands/debugger.rb
+- lib/agentf/commands/designer.rb
+- lib/agentf/commands/explorer.rb
+- lib/agentf/commands/memory_reviewer.rb
+- lib/agentf/commands/metrics.rb
+- lib/agentf/commands/security_scanner.rb
+- lib/agentf/commands/tester.rb
+- lib/agentf/context_builder.rb
+- lib/agentf/installer.rb
+- lib/agentf/mcp/server.rb
+- lib/agentf/memory.rb
+- lib/agentf/packs.rb
+- lib/agentf/service/providers.rb
+- lib/agentf/tools.rb
+- lib/agentf/tools/component_spec.rb
+- lib/agentf/tools/error_analysis.rb
+- lib/agentf/tools/file_match.rb
+- lib/agentf/tools/test_template.rb
+- lib/agentf/version.rb
+- lib/agentf/workflow_contract.rb
+- lib/agentf/workflow_engine.rb
+homepage: https://github.com/nealdeters/agentf
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nealdeters/agentf
+  source_code_uri: https://github.com/nealdeters/agentf
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: A self-learning swarm of agents with shared memory
+test_files: []