clacky 0.5.0

data/lib/clacky/tools/edit.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    class Edit < Base
+      self.tool_name = "edit"
+      self.tool_description = "Make precise edits to existing files by replacing old text with new text. " \
+                              "The old_string must match exactly (including whitespace and indentation)."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "The path of the file to edit (absolute or relative)"
+          },
+          old_string: {
+            type: "string",
+            description: "The exact string to find and replace (must match exactly including whitespace)"
+          },
+          new_string: {
+            type: "string",
+            description: "The new string to replace the old string with"
+          },
+          replace_all: {
+            type: "boolean",
+            description: "If true, replace all occurrences. If false (default), replace only the first occurrence",
+            default: false
+          }
+        },
+        required: %w[path old_string new_string]
+      }
+
+      def execute(path:, old_string:, new_string:, replace_all: false)
+        # Validate path
+        unless File.exist?(path)
+          return { error: "File not found: #{path}" }
+        end
+
+        unless File.file?(path)
+          return { error: "Path is not a file: #{path}" }
+        end
+
+        begin
+          # Read current content
+          content = File.read(path)
+          original_content = content.dup
+
+          # Check if old_string exists
+          unless content.include?(old_string)
+            return { error: "String to replace not found in file" }
+          end
+
+          # Count occurrences
+          occurrences = content.scan(old_string).length
+
+          # If not replace_all and multiple occurrences, warn about ambiguity
+          if !replace_all && occurrences > 1
+            return {
+              error: "String appears #{occurrences} times in the file. Use replace_all: true to replace all occurrences, " \
+                     "or provide a more specific string that appears only once."
+            }
+          end
+
+          # Perform replacement
+          if replace_all
+            content = content.gsub(old_string, new_string)
+          else
+            content = content.sub(old_string, new_string)
+          end
+
+          # Write modified content
+          File.write(path, content)
+
+          {
+            path: File.expand_path(path),
+            replacements: replace_all ? occurrences : 1,
+            error: nil
+          }
+        rescue Errno::EACCES => e
+          { error: "Permission denied: #{e.message}" }
+        rescue StandardError => e
+          { error: "Failed to edit file: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        path = args[:file_path] || args['file_path'] || args[:path] || args['path']
+        "Edit(#{Utils::PathHelper.safe_basename(path)})"
+      end
+
+      def format_result(result)
+        return result[:error] if result[:error]
+
+        replacements = result[:replacements] || result['replacements'] || 1
+        "Modified #{replacements} occurrence#{replacements > 1 ? 's' : ''}"
+      end
+    end
+  end
+end

data/lib/clacky/tools/file_reader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Clacky
+  module Tools
+    class FileReader < Base
+      self.tool_name = "file_reader"
+      self.tool_description = "Read contents of a file from the filesystem"
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Absolute or relative path to the file"
+          },
+          max_lines: {
+            type: "integer",
+            description: "Maximum number of lines to read (optional)",
+            default: 1000
+          }
+        },
+        required: ["path"]
+      }
+
+      def execute(path:, max_lines: 1000)
+        unless File.exist?(path)
+          return {
+            path: path,
+            content: nil,
+            error: "File not found: #{path}"
+          }
+        end
+
+        unless File.file?(path)
+          return {
+            path: path,
+            content: nil,
+            error: "Path is not a file: #{path}"
+          }
+        end
+
+        begin
+          lines = File.readlines(path).first(max_lines)
+          content = lines.join
+          truncated = File.readlines(path).size > max_lines
+
+          {
+            path: path,
+            content: content,
+            lines_read: lines.size,
+            truncated: truncated,
+            error: nil
+          }
+        rescue StandardError => e
+          {
+            path: path,
+            content: nil,
+            error: "Error reading file: #{e.message}"
+          }
+        end
+      end
+
+      def format_call(args)
+        path = args[:path] || args['path']
+        "Read(#{Utils::PathHelper.safe_basename(path)})"
+      end
+
+      def format_result(result)
+        return result[:error] if result[:error]
+
+        lines = result[:lines_read] || result['lines_read'] || 0
+        truncated = result[:truncated] || result['truncated']
+        "Read #{lines} lines#{truncated ? ' (truncated)' : ''}"
+      end
+    end
+  end
+end

data/lib/clacky/tools/glob.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Clacky
+  module Tools
+    class Glob < Base
+      self.tool_name = "glob"
+      self.tool_description = "Find files matching a glob pattern (e.g., '**/*.rb', 'src/**/*.js'). " \
+                              "Returns file paths sorted by modification time."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "The glob pattern to match files (e.g., '**/*.rb', 'lib/**/*.rb', '*.txt')"
+          },
+          base_path: {
+            type: "string",
+            description: "The base directory to search in (defaults to current directory)",
+            default: "."
+          },
+          limit: {
+            type: "integer",
+            description: "Maximum number of results to return (default: 100)",
+            default: 100
+          }
+        },
+        required: %w[pattern]
+      }
+
+      def execute(pattern:, base_path: ".", limit: 100)
+        # Validate pattern
+        if pattern.nil? || pattern.strip.empty?
+          return { error: "Pattern cannot be empty" }
+        end
+
+        # Validate base_path
+        unless Dir.exist?(base_path)
+          return { error: "Base path does not exist: #{base_path}" }
+        end
+
+        begin
+          # Change to base path and find matches
+          full_pattern = File.join(base_path, pattern)
+          matches = Dir.glob(full_pattern, File::FNM_DOTMATCH)
+                       .reject { |path| File.directory?(path) }
+                       .reject { |path| path.end_with?(".", "..") }
+
+          # Sort by modification time (most recent first)
+          matches = matches.sort_by { |path| -File.mtime(path).to_i }
+
+          # Apply limit
+          total_matches = matches.length
+          matches = matches.take(limit)
+
+          # Convert to relative or absolute paths
+          matches = matches.map { |path| File.expand_path(path) }
+
+          {
+            matches: matches,
+            total_matches: total_matches,
+            returned: matches.length,
+            truncated: total_matches > limit,
+            error: nil
+          }
+        rescue StandardError => e
+          { error: "Failed to glob files: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        pattern = args[:pattern] || args['pattern'] || ''
+        base_path = args[:base_path] || args['base_path'] || '.'
+        
+        display_base = base_path == '.' ? '' : " in #{base_path}"
+        "glob(\"#{pattern}\"#{display_base})"
+      end
+
+      def format_result(result)
+        if result[:error]
+          "✗ #{result[:error]}"
+        else
+          count = result[:returned] || 0
+          total = result[:total_matches] || 0
+          truncated = result[:truncated] ? " (truncated)" : ""
+          "✓ Found #{count}/#{total} files#{truncated}"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/tools/grep.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    class Grep < Base
+      self.tool_name = "grep"
+      self.tool_description = "Search file contents using regular expressions. Returns matching lines with context."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "The regular expression pattern to search for"
+          },
+          path: {
+            type: "string",
+            description: "File or directory to search in (defaults to current directory)",
+            default: "."
+          },
+          file_pattern: {
+            type: "string",
+            description: "Glob pattern to filter files (e.g., '*.rb', '**/*.js')",
+            default: "**/*"
+          },
+          case_insensitive: {
+            type: "boolean",
+            description: "Perform case-insensitive search",
+            default: false
+          },
+          context_lines: {
+            type: "integer",
+            description: "Number of context lines to show before and after each match",
+            default: 0
+          },
+          max_matches: {
+            type: "integer",
+            description: "Maximum number of matching files to return",
+            default: 50
+          }
+        },
+        required: %w[pattern]
+      }
+
+      def execute(pattern:, path: ".", file_pattern: "**/*", case_insensitive: false, context_lines: 0, max_matches: 50)
+        # Validate pattern
+        if pattern.nil? || pattern.strip.empty?
+          return { error: "Pattern cannot be empty" }
+        end
+
+        # Validate path
+        unless File.exist?(path)
+          return { error: "Path does not exist: #{path}" }
+        end
+
+        begin
+          # Compile regex
+          regex_options = case_insensitive ? Regexp::IGNORECASE : 0
+          regex = Regexp.new(pattern, regex_options)
+
+          results = []
+          total_matches = 0
+
+          # Get files to search
+          files = if File.file?(path)
+                    [path]
+                  else
+                    Dir.glob(File.join(path, file_pattern))
+                       .select { |f| File.file?(f) }
+                       .reject { |f| binary_file?(f) }
+                  end
+
+          # Search each file
+          files.each do |file|
+            break if results.length >= max_matches
+
+            matches = search_file(file, regex, context_lines)
+            next if matches.empty?
+
+            results << {
+              file: File.expand_path(file),
+              matches: matches
+            }
+            total_matches += matches.length
+          end
+
+          {
+            results: results,
+            total_matches: total_matches,
+            files_searched: files.length,
+            files_with_matches: results.length,
+            truncated: results.length >= max_matches,
+            error: nil
+          }
+        rescue RegexpError => e
+          { error: "Invalid regex pattern: #{e.message}" }
+        rescue StandardError => e
+          { error: "Failed to search files: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        pattern = args[:pattern] || args['pattern'] || ''
+        path = args[:path] || args['path'] || '.'
+
+        # Truncate pattern if too long
+        display_pattern = pattern.length > 30 ? "#{pattern[0..27]}..." : pattern
+        display_path = path == '.' ? 'current dir' : (path.length > 20 ? "...#{path[-17..]}" : path)
+
+        "grep(\"#{display_pattern}\" in #{display_path})"
+      end
+
+      def format_result(result)
+        if result[:error]
+          "✗ #{result[:error]}"
+        else
+          matches = result[:total_matches] || 0
+          files = result[:files_with_matches] || 0
+          "✓ Found #{matches} matches in #{files} files"
+        end
+      end
+
+      private
+
+      def search_file(file, regex, context_lines)
+        matches = []
+        lines = File.readlines(file, chomp: true)
+
+        lines.each_with_index do |line, index|
+          next unless line.match?(regex)
+
+          # Get context
+          start_line = [0, index - context_lines].max
+          end_line = [lines.length - 1, index + context_lines].min
+
+          context = []
+          (start_line..end_line).each do |i|
+            context << {
+              line_number: i + 1,
+              content: lines[i],
+              is_match: i == index
+            }
+          end
+
+          matches << {
+            line_number: index + 1,
+            line: line,
+            context: context_lines > 0 ? context : nil
+          }
+        end
+
+        matches
+      rescue StandardError
+        []
+      end
+
+      def binary_file?(file)
+        # Simple heuristic: check if file contains null bytes in first 8KB
+        return false unless File.exist?(file)
+        return false if File.size(file).zero?
+
+        sample = File.read(file, 8192, encoding: "ASCII-8BIT")
+        sample.include?("\x00")
+      rescue StandardError
+        true
+      end
+    end
+  end
+end