fantasy-cli 1.2.6

data/lib/gsd/tools/glob.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+
+module Gsd
+  module Tools
+    # GlobTool - Busca arquivos por patterns glob
+    #
+    # Uso:
+    #   tool = GlobTool.new(cwd: '/path')
+    #   result = tool.execute(pattern: '**/*.rb', path: 'src/')
+    class GlobTool < Base
+      class << self
+        tool_name('glob')
+        tool_description('Find files matching glob patterns (e.g., **/*.rb)')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+              description: 'Glob pattern to match (e.g., "**/*.rb", "src/**/*.js")'
+            },
+            path: {
+              type: 'string',
+              description: 'Base directory to search in (default: cwd)'
+            },
+            file_type: {
+              type: 'string',
+              description: 'Filter by file type: file, directory, or both',
+              enum: ['file', 'directory', 'both'],
+              default: 'file'
+            },
+            max_results: {
+              type: 'integer',
+              description: 'Maximum number of results (default: 1000)',
+              default: 1000
+            },
+            sort: {
+              type: 'string',
+              description: 'Sort order: name, mtime, size',
+              enum: ['name', 'mtime', 'size'],
+              default: 'name'
+            },
+            include_hidden: {
+              type: 'boolean',
+              description: 'Include hidden files (default: false)',
+              default: false
+            }
+          },
+          required: ['pattern']
+        })
+      end
+
+      # Executa busca glob
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Arquivos encontrados
+      def execute(args)
+        pattern = args[:pattern] || args['pattern']
+        path = args[:path] || args['path'] || '.'
+        file_type = args[:file_type] || args['file_type'] || 'file'
+        max_results = args[:max_results] || args['max_results'] || 1000
+        sort_order = args[:sort] || args['sort'] || 'name'
+        include_hidden = args[:include_hidden] || args['include_hidden'] || false
+
+        raise ArgumentError, 'Pattern is required' unless pattern
+
+        log_debug("Searching for: #{pattern}")
+        log_debug("Path: #{path}, Type: #{file_type}")
+
+        # Normaliza path
+        search_path = File.expand_path(path, @cwd)
+
+        # Verifica se path existe
+        unless File.directory?(search_path)
+          return {
+            success: false,
+            error: 'directory_not_found',
+            message: "Directory not found: #{path}"
+          }
+        end
+
+        # Constrói pattern completo
+        full_pattern = File.join(search_path, pattern)
+
+        # Executa glob
+        files = Dir.glob(full_pattern, File::FNM_PATHNAME | (include_hidden ? 0 : File::FNM_DOTMATCH))
+
+        # Filtra por tipo
+        files = filter_by_type(files, file_type)
+
+        # Exclui hidden se necessário
+        unless include_hidden
+          files = exclude_hidden(files)
+        end
+
+        # Ordena
+        files = sort_files(files, sort_order)
+
+        # Limita resultados
+        limited = files.count > max_results
+        files = files.first(max_results)
+
+        # Coleta metadados
+        file_info = files.map { |f| collect_file_info(f, search_path) }
+
+        {
+          success: true,
+          pattern: pattern,
+          path: path,
+          search_path: search_path,
+          files: file_info,
+          total_found: files.count,
+          limited: limited,
+          max_results: max_results
+        }
+      end
+
+      # Verifica se é safe (read-only)
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.safe?(args)
+        true
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.read_only?(args)
+        true
+      end
+
+      private
+
+      # Filtra arquivos por tipo
+      #
+      # @param files [Array] Lista de arquivos
+      # @param file_type [String] Tipo desejado
+      # @return [Array] Arquivos filtrados
+      def filter_by_type(files, file_type)
+        case file_type
+        when 'file'
+          files.select { |f| File.file?(f) }
+        when 'directory'
+          files.select { |f| File.directory?(f) }
+        else
+          files
+        end
+      end
+
+      # Exclui arquivos hidden
+      #
+      # @param files [Array] Lista de arquivos
+      # @return [Array] Arquivos sem hidden
+      def exclude_hidden(files)
+        files.reject { |f| File.basename(f).start_with?('.') }
+      end
+
+      # Ordena arquivos
+      #
+      # @param files [Array] Lista de arquivos
+      # @param sort_order [String] Ordem de sorted
+      # @return [Array] Arquivos ordenados
+      def sort_files(files, sort_order)
+        case sort_order
+        when 'name'
+          files.sort
+        when 'mtime'
+          files.sort_by { |f| File.mtime(f) }
+        when 'size'
+          files.sort_by { |f| File.size(f) rescue 0 }
+        else
+          files
+        end
+      end
+
+      # Coleta informações do arquivo
+      #
+      # @param file [String] Caminho do arquivo
+      # @param base_path [String] Path base
+      # @return [Hash] Informações do arquivo
+      def collect_file_info(file, base_path)
+        relative_path = file.sub("#{base_path}/", '')
+
+        {
+          path: file,
+          relative_path: relative_path,
+          filename: File.basename(file),
+          directory: File.dirname(relative_path),
+          type: File.file?(file) ? 'file' : 'directory',
+          size: File.file?(file) ? File.size(file) : nil,
+          mtime: File.mtime(file).iso8601
+        }
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('glob', Gsd::Tools::GlobTool, category: :search)

data/lib/gsd/tools/grep.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+
+module Gsd
+  module Tools
+    # GrepTool - Busca por padrões em arquivos usando grep
+    #
+    # Uso:
+    #   tool = GrepTool.new(cwd: '/path')
+    #   result = tool.execute(pattern: 'def initialize', path: 'src/')
+    class GrepTool < Base
+      class << self
+        tool_name('grep')
+        tool_description('Search for patterns in files using grep with regex support')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+              description: 'Pattern to search for (regex supported)'
+            },
+            path: {
+              type: 'string',
+              description: 'Directory or file to search in (default: cwd)'
+            },
+            case_sensitive: {
+              type: 'boolean',
+              description: 'Case sensitive search (default: false)',
+              default: false
+            },
+            include: {
+              type: 'string',
+              description: 'File pattern to include (e.g., "*.rb")'
+            },
+            exclude: {
+              type: 'string',
+              description: 'File pattern to exclude (e.g., "*.test.rb")'
+            },
+            max_results: {
+              type: 'integer',
+              description: 'Maximum number of results to return (default: 100)',
+              default: 100
+            },
+            context_lines: {
+              type: 'integer',
+              description: 'Number of context lines to show (default: 0)',
+              default: 0
+            }
+          },
+          required: ['pattern']
+        })
+      end
+
+      # Executa busca grep
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultados da busca
+      def execute(args)
+        pattern = args[:pattern] || args['pattern']
+        path = args[:path] || args['path'] || '.'
+        case_sensitive = args[:case_sensitive] || args['case_sensitive'] || false
+        include_pattern = args[:include] || args['include']
+        exclude_pattern = args[:exclude] || args['exclude']
+        max_results = args[:max_results] || args['max_results'] || 100
+        context_lines = args[:context_lines] || args['context_lines'] || 0
+
+        raise ArgumentError, 'Pattern is required' unless pattern
+
+        log_debug("Searching for: #{pattern}")
+        log_debug("Path: #{path}, Case sensitive: #{case_sensitive}")
+
+        # Normaliza path
+        search_path = File.expand_path(path, @cwd)
+
+        # Verifica se path existe
+        unless File.exist?(search_path)
+          return {
+            success: false,
+            error: 'path_not_found',
+            message: "Path not found: #{path}"
+          }
+        end
+
+        # Constrói comando grep
+        grep_cmd = build_grep_command(pattern, case_sensitive, include_pattern, exclude_pattern, context_lines)
+
+        # Executa grep
+        result = run_shell_command("#{grep_cmd} #{escape_path(search_path)}")
+
+        if result[:success]
+          matches = parse_grep_output(result[:stdout], pattern)
+
+          # Limita resultados
+          matches = matches.first(max_results) if matches.count > max_results
+
+          {
+            success: true,
+            pattern: pattern,
+            path: path,
+            search_path: search_path,
+            matches: matches,
+            total_matches: matches.count,
+            limited: result[:stdout].lines.count > max_results,
+            command: result[:command]
+          }
+        else
+          # grep retorna 1 quando não encontra nada (não é erro)
+          if result[:status] == 1
+            {
+              success: true,
+              pattern: pattern,
+              path: path,
+              search_path: search_path,
+              matches: [],
+              total_matches: 0,
+              message: 'No matches found'
+            }
+          else
+            {
+              success: false,
+              error: 'grep_error',
+              message: result[:stderr]
+            }
+          end
+        end
+      end
+
+      # Verifica se é safe (read-only)
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.safe?(args)
+        true
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.read_only?(args)
+        true
+      end
+
+      private
+
+      # Constrói comando grep
+      #
+      # @param pattern [String] Padrão de busca
+      # @param case_sensitive [Boolean] Case sensitive
+      # @param include [String] Pattern para incluir
+      # @param exclude [String] Pattern para excluir
+      # @param context [Integer] Linhas de contexto
+      # @return [String] Comando grep
+      def build_grep_command(pattern, case_sensitive, include, exclude, context)
+        cmd = ['grep']
+
+        # Case insensitive
+        cmd << '-i' unless case_sensitive
+
+        # Extended regex
+        cmd << '-E'
+
+        # Context lines
+        cmd << "-C #{context}" if context > 0
+
+        # Include pattern
+        if include
+          cmd << '--include' << include
+        end
+
+        # Exclude pattern
+        if exclude
+          cmd << '--exclude' << exclude
+        end
+
+        # Line numbers and color (disabled for parsing)
+        cmd << '-n'
+
+        # Pattern
+        cmd << '-e' << pattern
+
+        cmd.join(' ')
+      end
+
+      # Parseia output do grep
+      #
+      # @param output [String] Output do grep
+      # @param pattern [String] Padrão buscado
+      # @return [Array] Matches formatados
+      def parse_grep_output(output, pattern)
+        matches = []
+
+        output.each_line do |line|
+          # Formato: path/to/file.rb:line_number:content
+          parts = line.split(':', 3)
+          next if parts.count < 3
+
+          file_path = parts[0]
+          line_number = parts[1].to_i
+          content = parts[2].strip
+
+          matches << {
+            file: file_path,
+            line_number: line_number,
+            content: content,
+            pattern: pattern
+          }
+        end
+
+        matches
+      end
+
+      # Escapa path para shell
+      #
+      # @param path [String] Path
+      # @return [String] Path escapado
+      def escape_path(path)
+        # Simples: usa aspas se tiver espaços
+        path.include?(' ') ? "'#{path}'" : path
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('grep', Gsd::Tools::GrepTool, category: :search)

data/lib/gsd/tools/gsd_frontmatter.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+
+module Gsd
+  module Tools
+    # GsdFrontmatterTool - Operações de Frontmatter via Go bridge
+    #
+    # Uso:
+    #   tool = GsdFrontmatterTool.new(cwd: '/path')
+    #   result = tool.execute(operation: 'get', file: 'STATE.md')
+    class GsdFrontmatterTool < Base
+      class << self
+        tool_name('gsd_frontmatter')
+        tool_description('GSD Frontmatter operations: get, set, merge, validate, extract')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            operation: {
+              type: 'string',
+              description: 'Operation: get, set, merge, validate, extract',
+              enum: ['get', 'set', 'merge', 'validate', 'extract']
+            },
+            file: {
+              type: 'string',
+              description: 'File path with frontmatter'
+            },
+            field: {
+              type: 'string',
+              description: 'Field name (for get/set operations)'
+            },
+            value: {
+              type: 'string',
+              description: 'Field value (for set operation, JSON format)'
+            },
+            data: {
+              type: 'object',
+              description: 'Data to merge (for merge operation)'
+            },
+            schema: {
+              type: 'string',
+              description: 'Schema type: plan, summary, verification (for validate)'
+            },
+            fields: {
+              type: 'array',
+              description: 'Fields to extract (for extract operation)',
+              items: {
+                type: 'string'
+              }
+            }
+          },
+          required: ['operation', 'file']
+        })
+      end
+
+      # Executa operação de Frontmatter
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da operação
+      def execute(args)
+        operation = args[:operation] || args['operation']
+        file = args[:file] || args['file']
+        field = args[:field] || args['field']
+        value = args[:value] || args['value']
+        data = args[:data] || args['data']
+        schema = args[:schema] || args['schema']
+        fields = args[:fields] || args['fields']
+
+        raise ArgumentError, 'Operation is required' unless operation
+        raise ArgumentError, 'File is required' unless file
+
+        log_debug("Frontmatter operation: #{operation}, file: #{file}")
+
+        # Chama Go bridge
+        result = case operation
+                 when 'get'
+                   params = { 'get' => true, 'file' => file }
+                   params['field'] = field if field
+                   Gsd::Go::Bridge.call('frontmatter', params, cwd: @cwd)
+                 when 'set'
+                   raise ArgumentError, 'Field and value required' unless field && value
+                   Gsd::Go::Bridge.call('frontmatter', {
+                     'set' => true,
+                     'file' => file,
+                     'field' => field,
+                     'value' => value
+                   }, cwd: @cwd)
+                 when 'merge'
+                   raise ArgumentError, 'Data required' unless data
+                   Gsd::Go::Bridge.call('frontmatter', {
+                     'merge' => true,
+                     'file' => file,
+                     'data' => data
+                   }, cwd: @cwd)
+                 when 'validate'
+                   params = { 'validate' => true, 'file' => file }
+                   params['schema'] = schema if schema
+                   Gsd::Go::Bridge.call('frontmatter', params, cwd: @cwd)
+                 when 'extract'
+                   params = { 'extract' => true, 'file' => file }
+                   params['fields'] = fields if fields
+                   Gsd::Go::Bridge.call('frontmatter', params, cwd: @cwd)
+                 else
+                   { 'success' => false, 'error' => "Invalid operation: #{operation}" }
+                 end
+
+        # Parseia resultado
+        if result['success']
+          {
+            success: true,
+            operation: operation,
+            file: file,
+            data: result['data'],
+            cwd: @cwd
+          }
+        else
+          {
+            success: false,
+            error: result['error'] || 'unknown_error',
+            message: result['message'],
+            operation: operation
+          }
+        end
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          success: false,
+          error: 'bridge_error',
+          message: e.message,
+          operation: operation
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para get/validate/extract
+      def self.safe?(args)
+        operation = args[:operation] || args['operation']
+        ['get', 'validate', 'extract'].include?(operation)
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true apenas para get/validate/extract
+      def self.read_only?(args)
+        safe?(args)
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true para set/merge
+      def self.destructive?(args)
+        operation = args[:operation] || args['operation']
+        ['set', 'merge'].include?(operation)
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('gsd_frontmatter', Gsd::Tools::GsdFrontmatterTool, category: :gsd)