agentf 0.3.0

data/lib/agentf/service/providers.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Service
+    module Providers
+      class Base
+        attr_reader :pack
+
+        def initialize(pack: "generic")
+          @pack = pack.to_s.downcase
+        end
+
+        def name
+          self.class.name.split("::").last.upcase
+        end
+
+        def build_plan(task:, context: {}, logger: nil)
+          logger&.call("[#{name}] Analyzing task: #{task}")
+
+          workflow_type = classify_task(task)
+          agents_needed = pack_workflow_templates.fetch(workflow_type) { workflow_templates.fetch(workflow_type) }
+
+          logger&.call("[#{name}] Workflow type: #{workflow_type}")
+          logger&.call("[#{name}] Agents needed: #{agents_needed.join(', ')}")
+
+          {
+            "provider" => name,
+            "pack" => @pack,
+            "task" => task,
+            "context" => context,
+            "workflow_type" => workflow_type,
+            "agents_needed" => agents_needed
+          }
+        end
+
+        def classify_task(task)
+          task_lower = task.downcase
+
+          case
+          when task_lower =~ /quick|small|simple/ then "quick_fix"
+          when task_lower =~ /fix|bug|error|issue|broken/ then "bugfix"
+          when task_lower =~ /explore|find|search|where/ then "exploration"
+          when task_lower =~ /refactor|improve|cleanup/ then "refactor"
+          else
+            "feature"
+          end
+        end
+
+        def workflow_templates
+          raise NotImplementedError, "#{self.class} must implement #workflow_templates"
+        end
+
+        def pack_workflow_templates
+          Agentf::Packs.fetch(@pack).fetch("workflow_templates")
+        end
+
+        def execute_agent(agent_name:, task:, context:, agents:, commands:, logger: nil)
+          logger&.call("→ Calling #{agent_name}")
+
+          agent = agents[agent_name]
+          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"
+
+                      if tdd_phase == "red"
+                        failure_signature = "expected-failure:#{File.basename(source_file)}:#{Time.now.to_i}"
+                        {
+                          "source_file" => source_file,
+                          "test_file" => source_file.sub(/\.rb$/, "_spec.rb"),
+                          "tdd_phase" => "red",
+                          "passed" => false,
+                          "failure_signature" => failure_signature,
+                          "stdout" => "Intentional TDD red failure captured"
+                        }
+                      else
+                        template = tester_commands.generate_unit_tests(source_file)
+                        response = agent.generate_tests(source_file)
+                        response["generated_code"] = template.test_code
+                        response["tdd_phase"] = tdd_phase
+                        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"])
+                     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")
+                   else
+                     { "status" => "not_implemented" }
+                   end
+
+          logger&.call("→ #{agent_name} Complete")
+          result
+        rescue StandardError => e
+          logger&.call("→ #{agent_name} Error: #{e.message}")
+          { "error" => e.message, "agent" => agent_name }
+        end
+      end
+
+      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]
+          }
+        end
+      end
+
+      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]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/agentf/tools/component_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Tools
+    # Simple data object describing a generated component
+    class ComponentSpec
+      attr_reader :name, :code, :framework, :style, :props
+
+      def initialize(name:, code:, framework:, style:, props: [])
+        @name = name
+        @code = code
+        @framework = framework
+        @style = style
+        @props = props
+      end
+
+      def to_h
+        {
+          "name" => name,
+          "code" => code,
+          "framework" => framework,
+          "style" => style,
+          "props" => props
+        }
+      end
+    end
+  end
+end

data/lib/agentf/tools/error_analysis.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Tools
+    # Data class for error analysis
+    class ErrorAnalysis
+      attr_reader :error_type, :message, :location, :possible_causes, :suggested_fix, :stack_trace
+
+      def initialize(error_type:, message:, location:, possible_causes:, suggested_fix:, stack_trace: [])
+        @error_type = error_type
+        @message = message
+        @location = location
+        @possible_causes = possible_causes
+        @suggested_fix = suggested_fix
+        @stack_trace = stack_trace
+      end
+    end
+  end
+end

data/lib/agentf/tools/file_match.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Tools
+    # Data class for file matches
+    class FileMatch
+      attr_reader :path, :line_number, :content, :match_type
+
+      def initialize(path:, line_number:, content:, match_type:)
+        @path = path
+        @line_number = line_number
+        @content = content
+        @match_type = match_type
+      end
+
+      def to_h
+        { path: @path, line_number: @line_number, content: @content, match_type: @match_type }
+      end
+    end
+  end
+end

data/lib/agentf/tools/test_template.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Tools
+    # Data class for test templates
+    class TestTemplate
+      attr_reader :test_file, :test_code, :framework, :dependencies
+
+      def initialize(test_file:, test_code:, framework:, dependencies: [])
+        @test_file = test_file
+        @test_code = test_code
+        @framework = framework
+        @dependencies = dependencies
+      end
+    end
+  end
+end

data/lib/agentf/tools.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "tools/file_match"
+require_relative "tools/test_template"
+require_relative "tools/error_analysis"
+require_relative "tools/component_spec"
+
+module Agentf
+  module Tools
+    # All tool primitives are loaded above.
+  end
+end

data/lib/agentf/version.rb

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

data/lib/agentf/workflow_contract.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Agentf
+  class WorkflowContract
+    STAGES = %w[spec plan execute review finalize].freeze
+
+    def initialize(enabled:, mode:)
+      @enabled = enabled
+      @mode = normalize_mode(mode)
+    end
+
+    def enabled?
+      @enabled && @mode != "off"
+    end
+
+    def mode
+      @mode
+    end
+
+    def enforcing?
+      enabled? && @mode == "enforcing"
+    end
+
+    def check(stage:, workflow_state:, plan: nil)
+      return pass(stage) unless enabled?
+
+      violations = case stage
+                   when "spec" then check_spec(workflow_state)
+                   when "plan" then check_plan(plan)
+                   when "execute" then check_execute(workflow_state)
+                   when "review" then check_review(workflow_state)
+                   when "finalize" then check_finalize(workflow_state)
+                   else []
+                   end
+
+      {
+        "stage" => stage,
+        "mode" => @mode,
+        "ok" => violations.empty?,
+        "blocked" => enforcing? && violations.any?,
+        "violations" => violations
+      }
+    end
+
+    private
+
+    def normalize_mode(value)
+      mode = value.to_s.strip.downcase
+      return mode if %w[advisory enforcing off].include?(mode)
+
+      "advisory"
+    end
+
+    def pass(stage)
+      {
+        "stage" => stage,
+        "mode" => @mode,
+        "ok" => true,
+        "blocked" => false,
+        "violations" => []
+      }
+    end
+
+    def check_spec(workflow_state)
+      context = workflow_state["context"] || {}
+      violations = []
+
+      if context["design_spec"].to_s.strip.empty? && context["error"].to_s.strip.empty?
+        violations << violation(
+          stage: "spec",
+          code: "missing_spec_context",
+          severity: "warn",
+          message: "Expected design_spec or error context before planning"
+        )
+      end
+
+      violations
+    end
+
+    def check_plan(plan)
+      violations = []
+      agents = Array(plan && plan["agents_needed"])
+      if agents.empty?
+        violations << violation(
+          stage: "plan",
+          code: "missing_agent_plan",
+          severity: "error",
+          message: "Provider plan did not include any agents"
+        )
+      end
+      violations
+    end
+
+    def check_execute(workflow_state)
+      violations = []
+      tdd = workflow_state["tdd"] || {}
+
+      if tdd["enabled"] && !tdd["red_executed"]
+        violations << violation(
+          stage: "execute",
+          code: "tdd_red_not_executed",
+          severity: "error",
+          message: "TDD red phase must execute before implementation"
+        )
+      end
+
+      if tdd["enabled"] && tdd["phase"] == "green" && !tdd["green_executed"]
+        violations << violation(
+          stage: "execute",
+          code: "tdd_green_not_verified",
+          severity: "warn",
+          message: "TDD green verification has not completed"
+        )
+      end
+
+      violations
+    end
+
+    def check_review(workflow_state)
+      reviewer_result = Array(workflow_state["results"]).find { |item| item["agent"] == "REVIEWER" }
+      return [violation(stage: "review", code: "missing_reviewer", severity: "warn", message: "Reviewer step missing")] unless reviewer_result
+
+      return [] if [true, false].include?(reviewer_result.dig("result", "approved"))
+
+      [
+        violation(
+          stage: "review",
+          code: "invalid_reviewer_result",
+          severity: "warn",
+          message: "Reviewer result did not contain approved boolean"
+        )
+      ]
+    end
+
+    def check_finalize(workflow_state)
+      errors = Array(workflow_state["results"]).count { |item| item.dig("result", "error") }
+      return [] if errors.zero?
+
+      [
+        violation(
+          stage: "finalize",
+          code: "workflow_errors_present",
+          severity: "error",
+          message: "Workflow has #{errors} error result(s)"
+        )
+      ]
+    end
+
+    def violation(stage:, code:, severity:, message:)
+      {
+        "stage" => stage,
+        "code" => code,
+        "severity" => severity,
+        "message" => message
+      }
+    end
+  end
+end