agentf 0.3.0

data/lib/agentf/agents/tester.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../commands"
+
+module Agentf
+  module Agents
+    # Tester Agent - Test generation and execution
+    class Tester < Base
+      DESCRIPTION = "Automated test generation and execution."
+      COMMANDS = %w[detect_framework generate_unit_tests run_tests].freeze
+      MEMORY_CONCEPTS = {
+        "reads" => [],
+        "writes" => ["store_success"],
+        "policy" => "Persist test generation outcomes for future reuse."
+      }.freeze
+
+      def self.description
+        DESCRIPTION
+      end
+
+      def self.commands
+        COMMANDS
+      end
+
+      def self.memory_concepts
+        MEMORY_CONCEPTS
+      end
+
+      def self.policy_boundaries
+        {
+          "always" => ["Produce framework-aware tests", "Verify red/green state when TDD enabled"],
+          "ask_first" => ["Changing test framework conventions"],
+          "never" => ["Mark passing when command output is uncertain"],
+          "required_inputs" => [],
+          "required_outputs" => ["test_file"]
+        }
+      end
+
+      def initialize(memory, commands: nil)
+        super(memory)
+        @commands = commands || Agentf::Commands::Tester.new
+      end
+
+      def generate_tests(code_file, test_type: "unit")
+        log "Generating #{test_type} tests for: #{code_file}"
+
+        template = @commands.generate_unit_tests(code_file)
+
+        memory.store_success(
+          title: "Generated #{test_type} tests for #{code_file}",
+          description: "Created #{template.test_file} with #{test_type} tests",
+          context: "Test framework: #{template.framework}",
+          tags: ["testing", test_type, code_file.split(".").last],
+          agent: name
+        )
+
+        log "Created: #{template.test_file}"
+
+        {
+          "source_file" => code_file,
+          "test_file" => template.test_file,
+          "test_type" => test_type,
+          "generated_code" => template.test_code
+        }
+      end
+
+      def run_tests(test_file)
+        log "Running tests: #{test_file}"
+
+        result = @commands.run_tests(test_file: test_file)
+
+        log "Tests passed: #{result['passed']}"
+
+        { "test_file" => test_file, "passed" => result["passed"] }
+      end
+    end
+  end
+end

data/lib/agentf/agents.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Load all agents
+require_relative "agents/base"
+require_relative "agents/architect"
+require_relative "agents/specialist"
+require_relative "agents/reviewer"
+require_relative "agents/documenter"
+require_relative "agents/explorer"
+require_relative "agents/tester"
+require_relative "agents/debugger"
+require_relative "agents/designer"
+require_relative "agents/security"
+
+module Agentf
+  module Agents
+    # All agents are loaded above
+  end
+end

data/lib/agentf/cli/architecture.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Agentf
+  module CLI
+    class Architecture
+      include ArgParser
+
+      def initialize(architecture: nil)
+        @architecture = architecture || Commands::Architecture.new
+        @json_output = false
+      end
+
+      def run(args)
+        @json_output = !args.delete("--json").nil?
+        command = args.shift || "help"
+
+        payload = case command
+                  when "analyze"
+                    @architecture.analyze_layers
+                  when "callbacks"
+                    @architecture.analyze_callbacks(limit: extract_limit(args))
+                  when "gods"
+                    @architecture.find_god_objects(limit: extract_limit(args))
+                  when "review"
+                    @architecture.review_layer_violations(limit: extract_limit(args))
+                  when "gradual"
+                    goal = args.join(" ").strip
+                    @architecture.plan_gradual_adoption(goal: goal.empty? ? "improve architecture boundaries" : goal)
+                  when "help", "--help", "-h"
+                    show_help
+                    return
+                  else
+                    emit_error("Unknown architecture command: #{command}")
+                  end
+
+        emit(payload)
+      end
+
+      private
+
+      def emit(payload)
+        if @json_output
+          puts JSON.generate(payload)
+          return
+        end
+
+        puts JSON.pretty_generate(payload)
+      end
+
+      def emit_error(message)
+        if @json_output
+          puts JSON.generate({ "error" => message })
+        else
+          $stderr.puts "Error: #{message}"
+        end
+        exit 1
+      end
+
+      def show_help
+        puts <<~HELP
+          Usage: agentf architecture <command> [options]
+
+          Commands:
+            analyze               Analyze layer distribution
+            callbacks             Find callback-heavy model files
+            gods                  Find likely god objects
+            review                Review layer violations
+            gradual [goal]        Generate gradual adoption plan
+
+          Options:
+            -n <count>           Result limit for callbacks/gods/review (default: 10)
+            --json               Output in JSON format
+
+          Examples:
+            agentf architecture analyze
+            agentf architecture callbacks -n 20
+            agentf architecture review --json
+            agentf architecture gradual "adopt layered rails patterns"
+        HELP
+      end
+    end
+  end
+end

data/lib/agentf/cli/arg_parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Agentf
+  module CLI
+    # Shared argument parsing helpers used by all CLI subcommands.
+    module ArgParser
+      # Extracts a -n <value> flag from args, removes both entries,
+      # and returns the integer value. Returns default if not found.
+      def extract_limit(args, default: 10)
+        idx = args.index("-n")
+        return default unless idx && args[idx + 1]
+
+        limit = args[idx + 1].to_i
+        args.delete_at(idx + 1)
+        args.delete_at(idx)
+        limit
+      end
+
+      # Extracts --prefix=value from args, removes the entry,
+      # and returns the value string. Returns nil if not found.
+      def parse_single_option(args, prefix)
+        idx = args.index { |arg| arg.start_with?(prefix) }
+        return nil unless idx
+
+        args.delete_at(idx).delete_prefix(prefix)
+      end
+
+      # Extracts --prefix=a,b,c from args, removes it,
+      # and returns an array of strings. Supports semicolons as delimiters.
+      def parse_list_option(args, prefix)
+        raw = parse_single_option(args, prefix)
+        return [] if raw.to_s.empty?
+
+        delimiter = raw.include?(";") ? ";" : ","
+        raw.split(delimiter).map(&:strip).reject(&:empty?)
+      end
+
+      # Extracts --prefix=N from args, removes it,
+      # and returns the integer. Returns default on missing/invalid.
+      def parse_integer_option(args, prefix, default: 0)
+        raw = parse_single_option(args, prefix)
+        return default if raw.to_s.empty?
+
+        Integer(raw)
+      rescue ArgumentError
+        default
+      end
+    end
+  end
+end

data/lib/agentf/cli/code.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Agentf
+  module CLI
+    # CLI subcommand for code exploration operations.
+    # Refactored from bin/agentf-code with fixes:
+    #   - Human-readable output now shows actual results, not just counts (finding #13)
+    #   - Argument parsing uses shared ArgParser module
+    class Code
+      include ArgParser
+
+      def initialize(explorer: nil)
+        @explorer = explorer || Commands::Explorer.new
+        @json_output = false
+      end
+
+      def run(args)
+        @json_output = !args.delete("--json").nil?
+        command = args.shift || "help"
+
+        case command
+        when "glob"
+          run_glob(args)
+        when "grep"
+          run_grep(args)
+        when "tree"
+          run_tree(args)
+        when "related"
+          run_related(args)
+        when "help", "--help", "-h"
+          show_help
+        else
+          emit_error("Unknown code command: #{command}")
+        end
+      end
+
+      private
+
+      def run_glob(args)
+        pattern = args.shift
+        return emit_error("glob requires a pattern") if pattern.to_s.empty?
+
+        file_types = parse_list_option(args, "--types=")
+        file_types = nil if file_types.empty?
+
+        results = @explorer.glob(pattern, file_types: file_types)
+        emit_success("glob", { "pattern" => pattern, "matches" => results, "count" => results.length })
+      end
+
+      def run_grep(args)
+        pattern = args.shift
+        return emit_error("grep requires a pattern") if pattern.to_s.empty?
+
+        file_pattern = parse_single_option(args, "--file-pattern=")
+        context_lines = parse_integer_option(args, "--context=", default: 2)
+
+        matches = @explorer.grep(pattern, file_pattern: file_pattern, context_lines: context_lines)
+        serialized = matches.map { |match| match.respond_to?(:to_h) ? match.to_h : match }
+        emit_success("grep", { "pattern" => pattern, "matches" => serialized, "count" => serialized.length })
+      end
+
+      def run_tree(args)
+        max_depth = parse_integer_option(args, "--depth=", default: 3)
+        tree = @explorer.get_file_tree(max_depth: max_depth)
+        emit_success("tree", { "max_depth" => max_depth, "tree" => tree })
+      end
+
+      def run_related(args)
+        target_file = args.shift
+        return emit_error("related requires a target file") if target_file.to_s.empty?
+
+        related = @explorer.find_related_files(target_file)
+        emit_success("related", { "target_file" => target_file, "related" => related })
+      end
+
+      def emit_success(command, payload)
+        if @json_output
+          puts JSON.generate(payload.merge("command" => command))
+        else
+          format_human_output(command, payload)
+        end
+      end
+
+      def format_human_output(command, payload)
+        count = payload["count"] || 1
+        puts "#{command} -> #{count} results"
+
+        case command
+        when "glob"
+          payload["matches"]&.each { |f| puts "  #{f}" }
+        when "grep"
+          payload["matches"]&.each do |m|
+            if m.is_a?(Hash)
+              puts "  #{m["path"]}:#{m["line_number"]}  #{m["content"]}"
+            else
+              puts "  #{m}"
+            end
+          end
+        when "tree"
+          tree = payload["tree"]
+          if tree.is_a?(Hash)
+            print_tree(tree)
+          else
+            puts tree
+          end
+        when "related"
+          related = payload["related"]
+          if related.is_a?(Hash)
+            related.each do |key, values|
+              next unless values.is_a?(Array) && !values.empty?
+
+              puts "  #{key}:"
+              values.each { |v| puts "    #{v}" }
+            end
+          end
+        end
+      end
+
+      def print_tree(tree, indent: "")
+        tree.each do |name, subtree|
+          if subtree.is_a?(Hash)
+            puts "#{indent}#{name}/"
+            print_tree(subtree, indent: "#{indent}  ")
+          else
+            puts "#{indent}#{name}"
+          end
+        end
+      end
+
+      def emit_error(message)
+        if @json_output
+          puts JSON.generate({ "error" => message })
+        else
+          $stderr.puts "Error: #{message}"
+        end
+        exit 1
+      end
+
+      def show_help
+        puts <<~HELP
+          Usage: agentf code <command> [options]
+
+          Commands:
+            glob <pattern>                 Find files matching glob pattern
+            grep <pattern>                 Search file contents with regex
+            tree                           Print directory tree
+            related <file>                 Find related/imported files
+
+          Options:
+            --json                         Output in JSON format
+            --types=rb,py                  Filter glob by file extensions
+            --file-pattern=*.rb            Grep include pattern
+            --context=2                    Grep context lines
+            --depth=3                      Tree max depth
+
+          Examples:
+            agentf code glob "lib/**/*.rb"
+            agentf code grep "WorkflowEngine" --file-pattern=*.rb --json
+            agentf code tree --depth=2
+            agentf code related lib/agentf/workflow_engine.rb
+        HELP
+      end
+    end
+  end
+end

data/lib/agentf/cli/install.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Agentf
+  module CLI
+    # CLI subcommand for generating provider manifests.
+    # Wraps the existing Agentf::Installer with CLI argument parsing.
+    class Install
+      include ArgParser
+
+      def initialize
+        @options = {
+          providers: ["opencode"],
+          scope: "all",
+          global_root: Dir.home,
+          local_root: Dir.pwd,
+          dry_run: false,
+          only_agents: nil,
+          only_commands: nil
+        }
+      end
+
+      def run(args)
+        parse_args(args)
+
+        if args.include?("help") || args.include?("--help") || args.include?("-h")
+          show_help
+          return
+        end
+
+        installer = Agentf::Installer.new(
+          global_root: @options[:global_root],
+          local_root: @options[:local_root],
+          dry_run: @options[:dry_run]
+        )
+
+        results = installer.install(
+          providers: @options[:providers],
+          scope: @options[:scope],
+          only_agents: @options[:only_agents],
+          only_commands: @options[:only_commands]
+        )
+
+        results.each do |result|
+          puts "#{result.fetch("status").upcase}: #{Pathname.new(result.fetch("path")).cleanpath}"
+        end
+
+        puts "\nCompleted #{results.size} manifest operations."
+      end
+
+      private
+
+      def parse_args(args)
+        # Extract --dry-run flag
+        @options[:dry_run] = !args.delete("--dry-run").nil?
+
+        # Extract --provider
+        provider_val = parse_single_option(args, "--provider=") || parse_single_option(args, "-p=")
+        if provider_val
+          providers = provider_val.split(",").map { |item| item.strip.downcase }.reject(&:empty?)
+          @options[:providers] = providers == ["all"] ? Agentf::Installer::PROVIDER_LAYOUTS.keys : providers
+        end
+
+        # Extract --scope
+        scope_val = parse_single_option(args, "--scope=") || parse_single_option(args, "-s=")
+        @options[:scope] = scope_val.downcase if scope_val
+
+        # 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
+
+        local_root = parse_single_option(args, "--local-root=")
+        @options[:local_root] = File.expand_path(local_root) if local_root
+
+        # Extract --agent and --command filters
+        agent_val = parse_single_option(args, "--agent=")
+        if agent_val
+          @options[:only_agents] = agent_val.split(",").map { |item| item.strip.downcase }.reject(&:empty?)
+        end
+
+        command_val = parse_single_option(args, "--command=")
+        if command_val
+          @options[:only_commands] = command_val.split(",").map { |item| item.strip.downcase }.reject(&:empty?)
+        end
+      end
+
+      def show_help
+        puts <<~HELP
+          Usage: agentf install [options]
+
+          Generates provider-specific agent and command manifests.
+
+          Options:
+            --provider=LIST        Providers: opencode,copilot,all (default: opencode)
+            --scope=SCOPE          Install scope: global|local|all (default: all)
+            --global-root=PATH     Root for global installs (default: $HOME)
+            --local-root=PATH      Root for local installs (default: current directory)
+            --agent=LIST           Only install specific agents (comma-separated)
+            --command=LIST         Only install specific commands (comma-separated)
+            --dry-run              Show planned writes without writing files
+
+          Examples:
+            agentf install
+            agentf install --provider=opencode,copilot --scope=local
+            agentf install --provider=copilot --dry-run
+            agentf install --agent=architect,specialist
+        HELP
+      end
+    end
+  end
+end