agentf 0.3.0

data/lib/agentf/cli/update.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "fileutils"
+
+module Agentf
+  module CLI
+    # CLI subcommand for updating provider manifests when the gem version changes.
+    #
+    # Compares a `.agentf-version` stamp file in each provider directory against
+    # `Agentf::VERSION`. If the stamp is missing or outdated, re-runs the
+    # installer and writes the new stamp. Skips when already current unless
+    # `--force` is given.
+    #
+    # Usage:
+    #   agentf update
+    #   agentf update --force
+    #   agentf update --provider=opencode,copilot --scope=local
+    class Update
+      include ArgParser
+
+      # Maps each provider to the directory where its stamp file lives.
+      STAMP_DIRS = {
+        "opencode" => ".opencode",
+        "copilot"  => ".github"
+      }.freeze
+
+      STAMP_FILENAME = ".agentf-version"
+
+      def initialize(installer_class: Agentf::Installer)
+        @installer_class = installer_class
+        @options = {
+          providers: ["opencode"],
+          scope: "all",
+          global_root: Dir.home,
+          local_root: Dir.pwd,
+          force: false
+        }
+      end
+
+      def run(args)
+        if args.include?("help") || args.include?("--help") || args.include?("-h")
+          show_help
+          return
+        end
+
+        parse_args(args)
+
+        roots = roots_for(@options[:scope])
+        any_updated = false
+
+        @options[:providers].each do |provider|
+          roots.each do |root|
+            updated = update_provider(provider: provider, root: root)
+            any_updated = true if updated
+          end
+        end
+
+        puts "\nAlready up to date." unless any_updated
+      end
+
+      private
+
+      def parse_args(args)
+        @options[:force] = !args.delete("--force").nil?
+
+        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
+
+        scope_val = parse_single_option(args, "--scope=") || parse_single_option(args, "-s=")
+        @options[:scope] = scope_val.downcase if scope_val
+
+        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
+      end
+
+      def roots_for(scope)
+        case scope
+        when "global"
+          [@options[:global_root]]
+        when "local"
+          [@options[:local_root]]
+        else
+          [@options[:global_root], @options[:local_root]]
+        end
+      end
+
+      def update_provider(provider:, root:)
+        stamp_dir = STAMP_DIRS.fetch(provider) do
+          $stderr.puts "Unknown provider: #{provider}"
+          return false
+        end
+
+        stamp_path = File.join(root, stamp_dir, STAMP_FILENAME)
+        installed_version = read_stamp(stamp_path)
+
+        if installed_version == Agentf::VERSION && !@options[:force]
+          puts "#{provider} (#{shorten(root)}): up to date (v#{Agentf::VERSION})"
+          return false
+        end
+
+        migrate_old_files(root, provider) if @options[:force]
+
+        action = installed_version ? "Updating #{installed_version} -> #{Agentf::VERSION}" : "Installing v#{Agentf::VERSION}"
+        action = "Force reinstalling v#{Agentf::VERSION}" if @options[:force] && installed_version == Agentf::VERSION
+        puts "#{provider} (#{shorten(root)}): #{action}"
+
+        installer = @installer_class.new(
+          global_root: root,
+          local_root: root
+        )
+
+        results = installer.install(
+          providers: [provider],
+          scope: "local"
+        )
+
+        results.each do |result|
+          puts "  #{result.fetch('status').upcase}: #{Pathname.new(result.fetch('path')).cleanpath}"
+        end
+
+        write_stamp(stamp_path, Agentf::VERSION)
+        puts "  Stamp: #{Agentf::VERSION} -> #{shorten(stamp_path)}"
+        true
+      end
+
+      def migrate_old_files(root, provider)
+        return unless provider == "opencode"
+
+        opencode_dir = File.join(root, ".opencode")
+        return unless Dir.exist?(opencode_dir)
+
+        old_files = [
+          File.join(opencode_dir, "tools", "agentf-tools.ts"),
+          File.join(opencode_dir, "agents", "WORKFLOW_ENGINE.md"),
+          File.join(opencode_dir, "memory", "REDIS_SCHEMA.md")
+        ]
+
+        old_agent_names = %w[EXPLORER ARCHITECT DESIGNER DEBUGGER REVIEWER TESTER DOCUMENTER SECURITY SPECIALIST]
+        old_files.concat(old_agent_names.map { |name| File.join(opencode_dir, "agents", "#{name}.md") })
+
+        old_command_names = %w[explorer tester metrics security_scanner memory_reviewer designer debugger architecture]
+        old_files.concat(old_command_names.map { |name| File.join(opencode_dir, "commands", "#{name}.md") })
+
+        removed_count = 0
+        old_files.each do |file|
+          next unless File.exist?(file)
+
+          File.delete(file)
+          puts "  REMOVED: #{shorten(file)}"
+          removed_count += 1
+        end
+
+        puts "  Migration: removed #{removed_count} old files" if removed_count > 0
+      end
+
+      def read_stamp(path)
+        return nil unless File.exist?(path)
+
+        File.read(path).strip
+      rescue SystemCallError
+        nil
+      end
+
+      def write_stamp(path, version)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, "#{version}\n")
+      end
+
+      def shorten(path)
+        home = Dir.home
+        path.start_with?(home) ? path.sub(home, "~") : path
+      end
+
+      def show_help
+        puts <<~HELP
+          Usage: agentf update [options]
+
+          Regenerates provider manifests when the agentf gem version changes.
+          Compares a .agentf-version stamp file against the current version.
+          Skips providers that are already up to date unless --force is used.
+
+          Options:
+            --provider=LIST        Providers: opencode,copilot,all (default: opencode)
+            --scope=SCOPE          Update 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)
+            --force                Regenerate even if version matches
+
+          Examples:
+            agentf update
+            agentf update --force
+            agentf update --provider=opencode,copilot --scope=local
+        HELP
+      end
+    end
+  end
+end

data/lib/agentf/commands/architecture.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Agentf
+  module Commands
+    class Architecture
+      NAME = "architecture"
+
+      def self.manifest
+        {
+          "name" => NAME,
+          "description" => "Analyze architecture layers, callback risks, and incremental adoption opportunities.",
+          "commands" => [
+            { "name" => "analyze_layers", "type" => "function" },
+            { "name" => "analyze_callbacks", "type" => "function" },
+            { "name" => "find_god_objects", "type" => "function" },
+            { "name" => "review_layer_violations", "type" => "function" },
+            { "name" => "plan_gradual_adoption", "type" => "function" }
+          ]
+        }
+      end
+
+      def initialize(base_path: nil)
+        @base_path = Pathname.new(base_path || Agentf.config.base_path)
+      end
+
+      def analyze_layers
+        files = @base_path.glob("**/*.rb").select(&:file?)
+        buckets = {
+          "models" => 0,
+          "controllers" => 0,
+          "services" => 0,
+          "queries" => 0,
+          "presenters" => 0,
+          "concerns" => 0,
+          "other" => 0
+        }
+
+        files.each do |file|
+          rel = file.relative_path_from(@base_path).to_s
+          bucket = classify_layer(rel)
+          buckets[bucket] += 1
+        end
+
+        {
+          "total_files" => files.length,
+          "layers" => buckets,
+          "layer_balance_score" => layer_balance_score(buckets)
+        }
+      end
+
+      def analyze_callbacks(limit: 20)
+        files = @base_path.glob("app/models/**/*.rb").select(&:file?)
+        findings = []
+
+        files.each do |file|
+          text = safe_read(file)
+          count = text.scan(/\b(before|after|around)_(save|create|update|validation|commit|destroy)\b/).length
+          next if count.zero?
+
+          findings << {
+            "file" => file.relative_path_from(@base_path).to_s,
+            "callbacks" => count,
+            "risk" => count >= 4 ? "high" : (count >= 2 ? "medium" : "low")
+          }
+        end
+
+        sorted = findings.sort_by { |item| -item["callbacks"] }.first(limit)
+        { "count" => sorted.length, "findings" => sorted }
+      end
+
+      def find_god_objects(limit: 20)
+        files = @base_path.glob("app/**/*.rb").select(&:file?)
+        findings = files.map do |file|
+          text = safe_read(file)
+          methods = text.scan(/^\s*def\s+/).length
+          lines = text.lines.length
+          score = (methods * lines).to_i
+
+          {
+            "file" => file.relative_path_from(@base_path).to_s,
+            "methods" => methods,
+            "lines" => lines,
+            "score" => score
+          }
+        end
+
+        top = findings.sort_by { |item| -item["score"] }.first(limit)
+        { "count" => top.length, "findings" => top }
+      end
+
+      def review_layer_violations(limit: 50)
+        files = @base_path.glob("app/**/*.rb").select(&:file?)
+        violations = []
+
+        files.each do |file|
+          rel = file.relative_path_from(@base_path).to_s
+          text = safe_read(file)
+
+          if rel.start_with?("app/models/") && text.include?("render ")
+            violations << violation(rel, "model_renders_view", "Model references rendering concerns")
+          end
+
+          if rel.start_with?("app/controllers/") && text.include?("ActiveRecord::Base")
+            violations << violation(rel, "controller_raw_active_record", "Controller references ActiveRecord::Base directly")
+          end
+
+          if rel.start_with?("app/services/") && text.include?("params[")
+            violations << violation(rel, "service_params_coupling", "Service appears tightly coupled to controller params")
+          end
+        end
+
+        {
+          "count" => [violations.length, limit].min,
+          "violations" => violations.first(limit)
+        }
+      end
+
+      def plan_gradual_adoption(goal: "improve architecture boundaries")
+        layer_report = analyze_layers
+        callback_report = analyze_callbacks(limit: 5)
+        god_report = find_god_objects(limit: 5)
+
+        steps = [
+          "Baseline current architecture metrics and annotate high-risk hotspots.",
+          "Prioritize top callback-heavy models and extract one concern/service seam at a time.",
+          "Refactor top god objects behind explicit boundaries with tests per extraction.",
+          "Add review gate checks to prevent reintroduction of known violations.",
+          "Track trend metrics weekly and iterate toward target layer balance."
+        ]
+
+        {
+          "goal" => goal,
+          "baseline" => {
+            "layers" => layer_report,
+            "callbacks" => callback_report,
+            "god_objects" => god_report
+          },
+          "steps" => steps
+        }
+      end
+
+      private
+
+      def classify_layer(path)
+        return "models" if path.start_with?("app/models/")
+        return "controllers" if path.start_with?("app/controllers/")
+        return "services" if path.start_with?("app/services/")
+        return "queries" if path.include?("/queries/")
+        return "presenters" if path.include?("/presenters/")
+        return "concerns" if path.include?("/concerns/")
+
+        "other"
+      end
+
+      def layer_balance_score(buckets)
+        core = %w[models controllers services queries presenters concerns]
+        values = core.map { |key| buckets[key] }
+        max = values.max.to_f
+        min = values.min.to_f
+        return 1.0 if max.zero?
+
+        (1.0 - ((max - min) / max)).round(4)
+      end
+
+      def safe_read(path)
+        path.read
+      rescue StandardError
+        ""
+      end
+
+      def violation(file, code, message)
+        {
+          "file" => file,
+          "code" => code,
+          "message" => message,
+          "severity" => "warn"
+        }
+      end
+    end
+  end
+end

data/lib/agentf/commands/debugger.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Agentf
+  module Commands
+    class Debugger
+      NAME = "debugger"
+
+      def self.manifest
+        {
+          "name" => NAME,
+          "description" => "Parse errors, analyze logs, and suggest fixes for bugs.",
+          "commands" => [
+            { "name" => "parse_error", "type" => "function" },
+            { "name" => "analyze_logs", "type" => "function" },
+            { "name" => "suggest_fix", "type" => "function" },
+            { "name" => "cluster_errors", "type" => "function" }
+          ]
+        }
+      end
+
+      ERROR_PATTERNS = {
+        "ImportError" => {
+          "possible_causes" => [
+            "Module not installed",
+            "Wrong import path",
+            "Circular import",
+            "Missing __init__.py"
+          ],
+          "fix_template" => "Check package installation and import path"
+        },
+        "TypeError" => {
+          "possible_causes" => [
+            "Passing wrong type to function",
+            "Undefined variable",
+            "Calling non-callable"
+          ],
+          "fix_template" => "Verify argument types match function signature"
+        },
+        "NoMethodError" => {
+          "possible_causes" => [
+            "Method not defined",
+            "Typo in method name",
+            "Wrong object type"
+          ],
+          "fix_template" => "Check method exists on object"
+        },
+        "NameError" => {
+          "possible_causes" => [
+            "Variable not defined",
+            "Using before declaration",
+            "Scope issue"
+          ],
+          "fix_template" => "Check variable is defined before use"
+        },
+        "SyntaxError" => {
+          "possible_causes" => [
+            "Missing bracket/parenthesis",
+            "Invalid syntax",
+            "Indentation error"
+          ],
+          "fix_template" => "Check syntax at error location"
+        },
+        "NetworkError" => {
+          "possible_causes" => [
+            "API endpoint down",
+            "Network connectivity",
+            "CORS issue",
+            "Timeout"
+          ],
+          "fix_template" => "Verify API endpoint and network connectivity"
+        }
+      }.freeze
+
+      def initialize(base_path: nil)
+        @base_path = base_path || Agentf.config.base_path
+      end
+
+      # Parse error text and extract structured information
+      def parse_error(error_text)
+        error_type = "Unknown"
+        message = error_text
+        location = "unknown"
+
+        # Try Ruby pattern
+        if (match = error_text.match(/(?<type>\w+(?:Error|Exception)):\s*(?<message>[^\n]+?)(?:\s+from\s+(?<file>[^:]+):(?<line>\d+))?$/m))
+          error_type = match[:type]
+          message = match[:message].strip
+          location = "#{match[:file]}:#{match[:line]}" if match[:file]
+        end
+
+        # Try Python pattern
+        if error_type == "Unknown" && (match = error_text.match(/(\w+Error):\s*([^\n]+?)(?:\s+File\s+"([^"]+)",\s+line\s+(\d+))?$/m))
+          error_type = match[1]
+          message = match[2].strip
+          location = "#{match[3]}:#{match[4]}" if match[3]
+        end
+
+        # Try JS pattern
+        if error_type == "Unknown" && (match = error_text.match(/(\w+Error):\s*([^\n]+?)(?:\s+at\s+.+?\s+\((.+?):(\d+):(\d+)\))?$/m))
+          error_type = match[1]
+          message = match[2].strip
+          location = "#{match[3]}:#{match[4]}" if match[3]
+        end
+
+        error_info = ERROR_PATTERNS[error_type] || {
+          "possible_causes" => ["Unknown error source"],
+          "fix_template" => "Investigate error context"
+        }
+
+        stack_trace = parse_stack_trace(error_text)
+
+        Agentf::Tools::ErrorAnalysis.new(
+          error_type: error_type,
+          message: message[0..199],
+          location: location,
+          possible_causes: error_info["possible_causes"],
+          suggested_fix: error_info["fix_template"],
+          stack_trace: stack_trace
+        )
+      end
+
+      # Analyze log files for errors/warnings
+      def analyze_logs(log_file: nil, num_lines: 100)
+        errors = []
+        warnings = []
+
+        log_paths = []
+        if log_file
+          log_paths << Pathname.new(@base_path) + log_file
+        else
+          log_paths << Pathname.new(@base_path).join("logs", "app.log")
+          log_paths << Pathname.new(@base_path).join("log", "app.log")
+          log_paths << Pathname.new(@base_path).join("app.log")
+        end
+
+        content = ""
+        log_paths.each do |path|
+          if path.exist?
+            lines = path.read.split("\n").last(num_lines)
+            content = lines.join("\n")
+            break
+          end
+        end
+
+        return { "errors" => [], "warnings" => [], "summary" => "No log file found" } if content.empty?
+
+        content.lines.each do |line|
+          errors << line.strip if line =~ /\b(ERROR|Exception|Failed)\b/i
+          warnings << line.strip if line =~ /\b(WARN|WARNING)\b/i
+        end
+
+        {
+          "errors" => errors.last(20),
+          "warnings" => warnings.last(20),
+          "summary" => "Found #{errors.size} errors and #{warnings.size} warnings in recent logs"
+        }
+      end
+
+      # Generate fix suggestion based on error analysis
+      def suggest_fix(analysis, source_code: nil)
+        suggestions = []
+
+        suggestions << analysis.suggested_fix
+
+        msg_lower = analysis.message.downcase
+        suggestions << "Check for nil values before use" if msg_lower.include?("nil") || msg_lower.include?("none")
+        suggestions << "Verify variable is defined before access" if msg_lower.include?("undefined") || msg_lower.include?("not defined")
+        suggestions << "Consider increasing timeout or checking service availability" if msg_lower.include?("timeout")
+
+        suggestions << "Review code at #{analysis.location}" if source_code && analysis.location != "unknown"
+
+        historical = historical_fix_hints(analysis)
+        suggestions.concat(historical) unless historical.empty?
+
+        suggestions.map { |s| "- #{s}" }.join("\n")
+      end
+
+      def cluster_errors(errors)
+        clusters = Hash.new { |h, k| h[k] = { "count" => 0, "examples" => [] } }
+
+        Array(errors).each do |error_text|
+          analysis = parse_error(error_text.to_s)
+          key = analysis.error_type
+          clusters[key]["count"] += 1
+          clusters[key]["examples"] << analysis.message if clusters[key]["examples"].length < 3
+        end
+
+        clusters
+      end
+
+      private
+
+      def parse_stack_trace(error_text)
+        frames = []
+
+        # Ruby stack trace
+        error_text.scan(/from\s+([^:]+):(\d+):in\s+`(.+?)'/) do |file, line, func|
+          frames << { "file" => file, "line" => line, "function" => func }
+        end
+
+        # Python stack trace
+        error_text.scan(/File\s+"([^"]+)",\s+line\s+(\d+),\s+in\s+(\w+)/) do |file, line, func|
+          frames << { "file" => file, "line" => line, "function" => func }
+        end
+
+        # JS stack trace
+        error_text.scan(/at\s+(?:(\w+)\s+)?\(?(.+?):(\d+):(\d+)\)?/) do |func, file, line, _col|
+          frames << { "function" => func || "anonymous", "file" => file, "line" => line }
+        end
+
+        frames
+      end
+
+      def historical_fix_hints(analysis)
+        memory = Agentf::Memory::RedisMemory.new(project: Agentf.config.project_name)
+        incidents = memory.get_memories_by_type(type: "incident", limit: 25)
+        return [] if incidents.empty?
+
+        matched = incidents.select do |incident|
+          haystack = [incident["title"], incident["description"], incident["context"]].compact.join(" ").downcase
+          haystack.include?(analysis.error_type.downcase)
+        end
+
+        return [] if matched.empty?
+
+        matched.first(2).map do |incident|
+          "Try prior incident fix: #{incident['title']}"
+        end
+      rescue StandardError
+        []
+      ensure
+        memory&.close
+      end
+    end
+  end
+end