ffast 0.2.2 → 0.2.4

data/lib/fast/cli.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fast'
+require 'fast/source'
 require 'fast/version'
 require 'fast/sql'
 require 'coderay'
@@ -11,18 +12,33 @@ require 'ostruct'
 # It defines #report and #highlight functions that can be used to pretty print
 # code and results from the search.
 module Fast
+  module SymbolExtension
+    def loc
+      OpenStruct.new(expression: OpenStruct.new(line: 0))
+    end
+  end
+
   module_function
 
   # Highligh some source code based on the node.
   # Useful for printing code with syntax highlight.
   # @param show_sexp [Boolean] prints node expression instead of code
   # @param colorize [Boolean] skips `CodeRay` processing when false.
-  def highlight(node, show_sexp: false, colorize: true, sql: false)
+  # @param level [Integer] defines the max depth to print the AST.
+  def highlight(node, show_sexp: false, colorize: true, sql: false, level: nil)
     output =
       if node.respond_to?(:loc) && !show_sexp
-        wrap_source_range(node).source
+        if level
+          Fast.fold_source(node, level: level)
+        else
+          wrap_source_range(node).source
+        end
+      elsif show_sexp && level && Fast.ast_node?(node)
+        Fast.fold_ast(node, level: level).to_s
+      elsif show_sexp
+        node.to_s
       else
-        node
+        node.to_s
       end
     return output unless colorize
 
@@ -33,7 +49,7 @@ module Fast
   # and fixes end of the expression including heredoc strings.
   def wrap_source_range(node)
     expression = node.loc.expression
-    Parser::Source::Range.new(
+    Fast::Source.range(
       expression.source_buffer,
       first_position_from_expression(node),
       last_position_from_expression(node) || expression.end_pos
@@ -50,7 +66,7 @@ module Fast
   # to show the proper whitespaces for identing the next lines of the code.
   def first_position_from_expression(node)
     expression = node.loc.expression
-    if node.parent && node.parent.loc.expression.line != expression.line
+    if node.respond_to?(:parent) && node.parent && node.parent.loc.expression.line != expression.line
       expression.begin_pos - expression.column
     else
       expression.begin_pos
@@ -59,15 +75,19 @@ module Fast
 
   # Combines {.highlight} with files printing file name in the head with the
   # source line.
-  # @param result [Astrolabe::Node]
+  # @param result [Fast::Node]
   # @param show_sexp [Boolean] Show string expression instead of source
   # @param file [String] Show the file name and result line before content
   # @param headless [Boolean] Skip printing the file name and line before content
+  # @param level [Integer] Skip exploring deep branches of AST when showing sexp
   # @example
   #   Fast.report(result, file: 'file.rb')
-  def report(result, show_link: false, show_permalink: false, show_sexp: false, file: nil, headless: false, bodyless: false, colorize: true) # rubocop:disable Metrics/ParameterLists
+  def report(result, show_link: false, show_permalink: false, show_sexp: false, file: nil, headless: false, bodyless: false, colorize: true, level: nil) # rubocop:disable Metrics/ParameterLists
     if file
-      line = result.loc.expression.line if result.is_a?(Parser::AST::Node)
+      if result.is_a?(Symbol) && !result.respond_to?(:loc)
+        result.extend(SymbolExtension)
+      end
+      line = result.loc.expression.line if Fast.ast_node?(result) && result.respond_to?(:loc)
       if show_link
         puts(result.link)
       elsif show_permalink
@@ -76,23 +96,20 @@ module Fast
         puts(highlight("# #{file}:#{line}", colorize: colorize))
       end
     end
-    puts(highlight(result, show_sexp: show_sexp, colorize: colorize)) unless bodyless
+    puts(highlight(result, show_sexp: show_sexp, colorize: colorize, level: level)) unless bodyless
   end
 
   # Command Line Interface for Fast
   class Cli # rubocop:disable Metrics/ClassLength
-    attr_reader :pattern, :show_sexp, :pry, :from_code, :similar, :help
+    attr_reader :pattern, :show_sexp, :pry, :from_code, :similar, :help, :level
     def initialize(args)
-      args = replace_args_with_shortcut(args) if args.first&.start_with?('.')
-
-      @pattern, *@files = args.reject { |arg| arg.start_with? '-' }
+      args = args.dup
+      args = replace_args_with_shortcut(args) if shortcut_name_from(args)
       @colorize = STDOUT.isatty
-
       option_parser.parse! args
+      @pattern, @files = extract_pattern_and_files(args)
 
-      @files = [*@files].reject { |arg| arg.start_with?('-') }
       @sql ||= @files.any? && @files.all? { |file| file.end_with?('.sql') }
-
       require 'fast/sql' if @sql
     end
 
@@ -103,6 +120,10 @@ module Fast
           @debug = true
         end
 
+        opts.on('-l', '--level LEVELS', 'Maximum depth to print the AST') do |level|
+          @level = level.to_i
+        end
+
         opts.on('--ast', 'Print AST instead of code') do
           @show_sexp = true
         end
@@ -154,6 +175,16 @@ module Fast
           @from_code = true
         end
 
+        opts.on('--validate-pattern PATTERN', 'Validate a node pattern') do |pattern|
+          begin
+            Fast.expression(pattern)
+            puts "Pattern is valid."
+          rescue StandardError => e
+            puts "Invalid pattern: #{e.message}"
+          end
+          exit
+        end
+
         opts.on_tail('--version', 'Show version') do
           puts Fast::VERSION
           exit
@@ -166,13 +197,14 @@ module Fast
     end
 
     def replace_args_with_shortcut(args)
-      shortcut = find_shortcut args.first[1..]
+      shortcut_name = shortcut_name_from(args)
+      shortcut = find_shortcut(shortcut_name)
 
       if shortcut.single_run_with_block?
         shortcut.run
         exit
       else
-        args.one? ? shortcut.args : shortcut.merge_args(args[1..])
+        shortcut.args
       end
     end
 
@@ -206,7 +238,7 @@ module Fast
 
       if @files.empty?
         ast ||= Fast.public_send( @sql ? :parse_sql : :ast, @pattern)
-        puts Fast.highlight(ast, show_sexp: @show_sexp, colorize: @colorize, sql: @sql)
+        puts Fast.highlight(ast, show_sexp: @show_sexp, colorize: @colorize, sql: @sql, level: @level)
       else
         search
       end
@@ -272,20 +304,39 @@ module Fast
                   show_sexp: @show_sexp,
                   headless: @headless,
                   bodyless: @bodyless,
-                  colorize: @colorize)
+                  colorize: @colorize,
+                  level: @level)
+    end
+
+    def shortcut_name_from(args)
+      command = args.find { |arg| !arg.start_with?('-') }
+      return unless command&.start_with?('.')
+
+      command[1..]
+    end
+
+    def extract_pattern_and_files(args)
+      return [nil, []] if args.empty?
+
+      files_start = args.index { |arg| File.exist?(arg) || File.directory?(arg) }
+      if files_start
+        [args[0...files_start].join(' '), args[files_start..]]
+      else
+        [args.join(' '), []]
+      end
     end
 
     # Find shortcut by name. Preloads all `Fastfiles` before start.
     # @param name [String]
-    # @return [Fast::Shortcut]
     def find_shortcut(name)
       unless defined? Fast::Shortcut
         require 'fast/shortcut'
         Fast.load_fast_files!
       end
 
-      shortcut = Fast.shortcuts[name] || Fast.shortcuts[name.to_sym]
-      shortcut || exit_shortcut_not_found(name)
+      shortcut = Fast.shortcuts[name.to_sym]
+      exit_shortcut_not_found(name) unless shortcut
+      shortcut
     end
 
     # Exit process with warning message bolding the shortcut that was not found.

data/lib/fast/experiment.rb

@@ -91,6 +91,7 @@ module Fast
   class Experiment
     attr_writer :files
     attr_reader :name, :replacement, :expression, :files_or_folders, :ok_if
+    attr_accessor :autoclean
 
     def initialize(name, &block)
       @name = name
@@ -137,6 +138,10 @@ module Fast
     def run
       files.map(&method(:run_with))
     end
+
+    def autoclean?
+      !!@autoclean
+    end
   end
 
   # Suggest possible combinations of occurrences to replace.
@@ -285,7 +290,7 @@ module Fast
       @fail_experiments << combination
     end
 
-    # @return [Array<Astrolabe::Node>]
+    # @return [Array<Fast::Node>]
     def search_cases
       Fast.search(experiment.expression, @ast) || []
     end
@@ -323,15 +328,25 @@ module Fast
       filename
     end
 
+    def cleanup_generated_files!
+      Dir.glob(File.join(File.dirname(@file), "experiment_*_#{File.basename(@file)}")).each do |generated_file|
+        File.delete(generated_file) if File.exist?(generated_file)
+      end
+    end
+
     def done!
       count_executed_combinations = @fail_experiments.size + @ok_experiments.size
       puts "Done with #{@file} after #{count_executed_combinations} combinations"
-      return unless perfect_combination = @ok_experiments.last # rubocop:disable Lint/AssignmentInCondition
+      unless perfect_combination = @ok_experiments.last # rubocop:disable Lint/AssignmentInCondition
+        cleanup_generated_files! if experiment.autoclean?
+        return
+      end
 
       puts 'The following changes were applied to the file:'
       `diff #{experimental_filename(perfect_combination)} #{@file}`
       puts "mv #{experimental_filename(perfect_combination)} #{@file}"
       `mv #{experimental_filename(perfect_combination)} #{@file}`
+      cleanup_generated_files! if experiment.autoclean?
     end
 
     # Increase the `@round` by 1 to {ExperimentCombinations#generate_combinations}.
@@ -346,6 +361,7 @@ module Fast
     end
 
     def run
+      cleanup_generated_files! if experiment.autoclean?
       while (combinations = build_combinations).any?
         if combinations.size > 1000
           puts "Ignoring #{@file} because it has #{combinations.size} possible combinations"
@@ -378,6 +394,7 @@ module Fast
       else
         failed_with(combination)
         puts "🔴 #{experimental_file} - Combination: #{combination}"
+        File.delete(experimental_file) if experiment.autoclean? && File.exist?(experimental_file)
       end
     end
   end

data/lib/fast/git.rb

@@ -8,7 +8,7 @@ module Fast
   #  @example
   #    require 'fast/git'
   #    Fast.ast_from_file('lib/fast.rb').git_log.first.author.name # => "Jonatas Davi Paganini"
-  class Node < Astrolabe::Node
+  class Node
     # @return [Git::Base] from current directory
     def git
       require 'git' unless defined? Git

data/lib/fast/mcp_server.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'stringio'
+require 'fast'
+require 'fast/version'
+require 'fast/cli'
+
+module Fast
+  # Implements the Model Context Protocol (MCP) server over STDIO.
+  class McpServer
+    TOOLS = [
+      {
+        name: 'validate_fast_pattern',
+        description: 'Validate a Fast AST pattern. Returns true if valid, or a specific syntax error message if invalid.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Fast AST pattern to validate.' }
+          },
+          required: ['pattern']
+        }
+      },
+      {
+        name: 'search_ruby_ast',
+        description: 'Search Ruby files using a Fast AST pattern. Returns file, line range, and source. Use show_ast=true only when you need the s-expression.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Fast AST pattern, e.g. "(def match?)" or "(send nil :raise ...)".' },
+            paths:   { type: 'array', items: { type: 'string' }, description: 'Files or directories to search.' },
+            show_ast: { type: 'boolean', description: 'Include s-expression AST in results (default: false).' }
+          },
+          required: ['pattern', 'paths']
+        }
+      },
+      {
+        name: 'ruby_method_source',
+        description: 'Extract source of a Ruby method by name across files. Optionally filter by class name.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            method_name: { type: 'string', description: 'Method name, e.g. "initialize".' },
+            paths:       { type: 'array', items: { type: 'string' }, description: 'Files or directories to search.' },
+            class_name:  { type: 'string', description: 'Optional class name to restrict results, e.g. "Matcher".' },
+            show_ast:    { type: 'boolean', description: 'Include s-expression AST in results (default: false).' }
+          },
+          required: ['method_name', 'paths']
+        }
+      },
+      {
+        name: 'ruby_class_source',
+        description: 'Extract the full source of a Ruby class by name.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            class_name: { type: 'string', description: 'Class name to extract, e.g. "Rewriter".' },
+            paths:      { type: 'array', items: { type: 'string' }, description: 'Files or directories to search.' },
+            show_ast:   { type: 'boolean', description: 'Include s-expression AST in results (default: false).' }
+          },
+          required: ['class_name', 'paths']
+        }
+      },
+      {
+        name: 'rewrite_ruby',
+        description: 'Apply a Fast pattern replacement to Ruby source code. Returns the rewritten source. Does NOT write to disk.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            source:      { type: 'string', description: 'Ruby source code to rewrite.' },
+            pattern:     { type: 'string', description: 'Fast AST pattern to match nodes for replacement.' },
+            replacement: { type: 'string', description: 'Ruby expression to replace matched node source with.' }
+          },
+          required: ['source', 'pattern', 'replacement']
+        }
+      },
+      {
+        name: 'rewrite_ruby_file',
+        description: 'Apply a Fast pattern replacement to a Ruby file in-place. Returns lines changed and a diff. Use rewrite_ruby first to preview.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file:        { type: 'string', description: 'Path to the Ruby file to rewrite.' },
+            pattern:     { type: 'string', description: 'Fast AST pattern to match nodes for replacement.' },
+            replacement: { type: 'string', description: 'Ruby expression to replace matched node source with.' }
+          },
+          required: ['file', 'pattern', 'replacement']
+        }
+      },
+      {
+        name: 'run_fast_experiment',
+        description: 'Propose and execute a Fast experiment to safely refactor code. The experiment is validated against a policy command (e.g. tests) and only successful rewrites are applied. Always use {file} in the policy command to refer to the modified test file.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Name of the experiment, e.g. "RSpec/UseBuildStubbed"' },
+            lookup: { type: 'string', description: 'Folder or file to target, e.g. "spec"' },
+            search: { type: 'string', description: 'Fast AST search pattern to find nodes.' },
+            edit: { type: 'string', description: 'Ruby code to evaluate in Rewriter context. Has access to `node` variable. Example: `replace(node.loc.expression, "build_stubbed")`' },
+            policy: { type: 'string', description: 'Shell command returning exit status 0 on success. Uses {file} for the temporary file created during the rewrite round. Example: `bin/spring rspec --fail-fast {file}`' }
+          },
+          required: ['name', 'lookup', 'search', 'edit', 'policy']
+        }
+      }
+    ].freeze
+
+
+    def self.run!
+      new.run
+    end
+
+    def run
+      STDOUT.sync = true
+
+      while (line = STDIN.gets)
+        line = line.strip
+        next if line.empty?
+
+        begin
+          request = JSON.parse(line)
+          handle_request(request)
+        rescue JSON::ParserError => e
+          write_error(nil, -32700, 'Parse error', e.message)
+        rescue StandardError => e
+          write_error(request&.fetch('id', nil), -32603, 'Internal error', e.message)
+        end
+      end
+    end
+
+    private
+
+    def handle_request(request)
+      id     = request['id']
+      method = request['method']
+      params = request['params'] || {}
+
+      case method
+      when 'initialize'
+        write_response(id, {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'fast-mcp', version: Fast::VERSION }
+        })
+      when 'tools/list'
+        write_response(id, { tools: TOOLS })
+      when 'tools/call'
+        handle_tool_call(id, params)
+      when 'notifications/initialized'
+        nil
+      else
+        write_error(id, -32601, 'Method not found', "#{method} not supported") if id
+      end
+    end
+
+    def handle_tool_call(id, params)
+      tool_name = params['name']
+      args      = params['arguments'] || {}
+      show_ast  = args['show_ast'] || false
+
+      if args['pattern'] && !args['pattern'].start_with?('(', '{', '[') && !args['pattern'].match?(/^[a-z_]+$/)
+        raise "Invalid Fast AST pattern: '#{args['pattern']}'. Did you mean to use an s-expression like '(#{args['pattern']})'?"
+      end
+
+      result =
+        case tool_name
+        when 'validate_fast_pattern'
+          execute_validate_pattern(args['pattern'])
+        when 'search_ruby_ast'
+          execute_search(args['pattern'], args['paths'], show_ast: show_ast)
+        when 'ruby_method_source'
+          execute_method_search(args['method_name'], args['paths'],
+                                class_name: args['class_name'], show_ast: show_ast)
+        when 'ruby_class_source'
+          execute_class_search(args['class_name'], args['paths'], show_ast: show_ast)
+        when 'rewrite_ruby'
+          execute_rewrite(args['source'], args['pattern'], args['replacement'])
+        when 'rewrite_ruby_file'
+          execute_rewrite_file(args['file'], args['pattern'], args['replacement'])
+        when 'run_fast_experiment'
+          execute_fast_experiment(args['name'], args['lookup'], args['search'], args['edit'], args['policy'])
+        else
+          raise "Unknown tool: #{tool_name}"
+        end
+
+      write_response(id, { content: [{ type: 'text', text: JSON.generate(result) }] })
+    rescue => e
+      write_error(id, -32603, 'Tool execution failed', e.message)
+    end
+
+    def execute_validate_pattern(pattern)
+      Fast.expression(pattern)
+      { valid: true }
+    rescue StandardError => e
+      { valid: false, error: e.message }
+    end
+
+    def execute_search(pattern, paths, show_ast: false)
+      results = []
+      on_result = ->(file, matches) do
+        matches.compact.each do |node|
+          next unless (exp = node_expression(node))
+
+          entry = {
+            file:       file,
+            line_start: exp.line,
+            line_end:   exp.last_line,
+            code:       Fast.highlight(node, colorize: false)
+          }
+          entry[:ast] = Fast.highlight(node, show_sexp: true, colorize: false) if show_ast
+          results << entry
+        end
+      end
+
+      Fast.search_all(pattern, paths, parallel: false, on_result: on_result)
+      results
+    end
+
+    def execute_method_search(method_name, paths, class_name: nil, show_ast: false)
+      pattern = "(def #{method_name})"
+      results = execute_search(pattern, paths, show_ast: show_ast)
+      return results unless class_name
+
+      # Filter: keep only methods whose file contains the class
+      results.select do |r|
+        class_defined_in_file?(class_name, r[:file])
+      end
+    end
+
+    def execute_class_search(class_name, paths, show_ast: false)
+      # Use simple (class ...) pattern then filter by name — avoids nil/superclass edge cases
+      results = []
+      on_result = ->(file, matches) do
+        matches.compact.each do |node|
+          next unless node.type == :class
+          next unless node.children.first&.children&.last&.to_s == class_name
+          next unless (exp = node_expression(node))
+
+          entry = {
+            file:       file,
+            line_start: exp.line,
+            line_end:   exp.last_line,
+            code:       Fast.highlight(node, colorize: false)
+          }
+          entry[:ast] = Fast.highlight(node, show_sexp: true, colorize: false) if show_ast
+          results << entry
+        end
+      end
+      Fast.search_all('(class ...)', paths, parallel: false, on_result: on_result)
+      results.select { |r| r[:file] } # already filtered above
+    end
+
+    def execute_rewrite(source, pattern, replacement)
+      ast    = Fast.ast(source)
+      result = Fast.replace(pattern, ast, source) do |node|
+        replace(node.loc.expression, replacement)
+      end
+      { original: source, rewritten: result, changed: result != source }
+    end
+
+    def execute_rewrite_file(file, pattern, replacement)
+      raise "File not found: #{file}" unless File.exist?(file)
+
+      original = File.read(file)
+      rewritten = Fast.replace_file(pattern, file) do |node|
+        replace(node.loc.expression, replacement)
+      end
+
+      return { file: file, changed: false } if rewritten.nil? || rewritten == original
+
+      # Build a compact line-level diff
+      orig_lines     = original.lines
+      rewritten_lines = rewritten.lines
+      diff = orig_lines.each_with_index.filter_map do |line, i|
+        new_line = rewritten_lines[i]
+        next if line == new_line
+
+        { line: i + 1, before: line.rstrip, after: (new_line&.rstrip || '') }
+      end
+
+      File.write(file, rewritten)
+      { file: file, changed: true, diff: diff }
+    end
+
+    def execute_fast_experiment(name, lookup_path, search_pattern, edit_code, policy_command)
+      require 'fast/experiment'
+      original_stdout = $stdout.dup
+      capture_output = StringIO.new
+      $stdout = capture_output
+
+      begin
+        experiment = Fast.experiment(name) do
+          lookup lookup_path
+          search search_pattern
+          edit do |node, *captures|
+            eval(edit_code)
+          end
+          policy do |new_file|
+            cmd = policy_command.gsub('{file}', new_file)
+            system(cmd)
+          end
+        end
+        experiment.run
+      ensure
+        $stdout = original_stdout
+      end
+
+      # Exclude any color from captured output
+      log = capture_output.string.gsub(/\e\[([;\d]+)?m/, '')
+      
+      { experiment: name, log: log }
+    end
+
+    # Returns loc.expression if available
+    def node_expression(node)
+      return unless node.respond_to?(:loc) && node.loc.respond_to?(:expression)
+
+      node.loc.expression
+    end
+
+    # Check whether a class is defined anywhere in the file's AST
+    def class_defined_in_file?(class_name, file)
+      Fast.search_file('(class ...)', file).any? do |node|
+        node.children.first&.children&.last&.to_s == class_name
+      end
+    rescue
+      false
+    end
+
+    def write_response(id, result)
+      STDOUT.puts({ jsonrpc: '2.0', id: id, result: result }.to_json)
+    end
+
+    def write_error(id, code, message, data = nil)
+      err      = { code: code, message: message }
+      err[:data] = data if data
+      response = { jsonrpc: '2.0', error: err }
+      response[:id] = id if id
+      STDOUT.puts response.to_json
+    end
+  end
+end