llm_gateway 0.2.0 → 0.4.0

data/sample/claude_code_clone/tools/bash_tool.rb

@@ -1,54 +0,0 @@
-class BashTool < LlmGateway::Tool
-  name 'Bash'
-  description 'Execute shell commands'
-  input_schema({
-    type: 'object',
-    properties: {
-      command: { type: 'string', description: 'Shell command to execute' },
-      description: { type: 'string', description: 'Human-readable description' },
-      timeout: { type: 'integer', description: 'Timeout in milliseconds' }
-    },
-    required: [ 'command' ]
-  })
-
-  def execute(input)
-    command = input[:command]
-    description = input[:description]
-    timeout = input[:timeout] || 120000 # Default 2 minutes
-
-    if description
-      puts "Executing: #{command}"
-      puts "Description: #{description}\n\n"
-    else
-      puts "Executing: #{command}\n\n"
-    end
-
-    begin
-      # Convert timeout from milliseconds to seconds
-      timeout_seconds = timeout / 1000.0
-
-      # Use timeout command if available, otherwise use Ruby's timeout
-      if system('which timeout > /dev/null 2>&1')
-        result = `timeout #{timeout_seconds}s #{command} 2>&1`
-        exit_status = $?
-      else
-        require 'timeout'
-        result = Timeout.timeout(timeout_seconds) do
-          `#{command} 2>&1`
-        end
-        exit_status = $?
-      end
-
-      if exit_status.success?
-        result.empty? ? "Command completed successfully (no output)" : result
-      else
-        "Command failed with exit code #{exit_status.exitstatus}:\n#{result}"
-      end
-
-    rescue Timeout::Error
-      "Command timed out after #{timeout_seconds} seconds"
-    rescue => e
-      "Error executing command: #{e.message}"
-    end
-  end
-end

data/sample/claude_code_clone/tools/edit_tool.rb

@@ -1,61 +0,0 @@
-class EditTool < LlmGateway::Tool
-  name 'Edit'
-  description 'Modify existing files by replacing specific text strings'
-  input_schema({
-    type: 'object',
-    properties: {
-      file_path: { type: 'string', description: 'Absolute path to file to modify' },
-      old_string: { type: 'string', description: 'Exact text to replace' },
-      new_string: { type: 'string', description: 'Replacement text' },
-      replace_all: { type: 'boolean', description: 'Replace all occurrences (default: false)' }
-    },
-    required: [ 'file_path', 'old_string', 'new_string' ]
-  })
-
-  def execute(input)
-    file_path = input[:file_path]
-    old_string = input[:old_string]
-    new_string = input[:new_string]
-    replace_all = input[:replace_all] || false
-
-    # Validate file exists
-    unless File.exist?(file_path)
-      return "Error: File not found at #{file_path}"
-    end
-
-    # Read file content
-    begin
-      content = File.read(file_path)
-    rescue => e
-      return "Error reading file: #{e.message}"
-    end
-
-    # Check if old_string exists in file
-    unless content.include?(old_string)
-      return "Error: Text '#{old_string}' not found in file"
-    end
-
-    # Perform replacement
-    if replace_all
-      updated_content = content.gsub(old_string, new_string)
-      occurrences = content.scan(old_string).length
-    else
-      # Replace only first occurrence
-      updated_content = content.sub(old_string, new_string)
-      occurrences = 1
-    end
-
-    # Check if replacement would result in same content
-    if content == updated_content
-      return "Error: old_string and new_string are identical, no changes made"
-    end
-
-    # Write updated content back to file
-    begin
-      File.write(file_path, updated_content)
-      "Successfully replaced #{occurrences} occurrence(s) in #{file_path}"
-    rescue => e
-      "Error writing file: #{e.message}"
-    end
-  end
-end

data/sample/claude_code_clone/tools/grep_tool.rb

@@ -1,113 +0,0 @@
-class GrepTool < LlmGateway::Tool
-  name 'Grep'
-  description 'Search for patterns in files using regex'
-  input_schema({
-    type: 'object',
-    properties: {
-      pattern: { type: 'string', description: 'Regex pattern to search for' },
-      path: { type: 'string', description: 'File or directory path' },
-      output_mode: {
-        type: 'string',
-        enum: [ 'content', 'files_with_matches', 'count' ],
-        description: 'Output mode: content, files_with_matches, or count'
-      },
-      glob: { type: 'string', description: 'File pattern filter (e.g., "*.rb")' },
-      '-n': { type: 'boolean', description: 'Show line numbers' },
-      '-i': { type: 'boolean', description: 'Case insensitive search' },
-      '-C': { type: 'integer', description: 'Context lines around matches' }
-    },
-    required: [ 'pattern' ]
-  })
-
-  def execute(input)
-    pattern = input[:pattern]
-    path = input[:path] || '.'
-    output_mode = input[:output_mode] || 'files_with_matches'
-    glob = input[:glob]
-    show_line_numbers = input['-n'] || false
-    case_insensitive = input['-i'] || false
-    context_lines = input['-C'] || 0
-
-    # Build grep command
-    cmd_parts = [ 'grep' ]
-
-    # Add flags
-    cmd_parts << '-r' unless File.file?(path) # Recursive for directories
-    cmd_parts << '-n' if show_line_numbers && output_mode == 'content'
-    cmd_parts << '-i' if case_insensitive
-    cmd_parts << "-C#{context_lines}" if context_lines > 0 && output_mode == 'content'
-
-    # Output mode flags
-    case output_mode
-    when 'files_with_matches'
-      cmd_parts << '-l'
-    when 'count'
-      cmd_parts << '-c'
-    end
-
-    # Add pattern and path
-    cmd_parts << "'#{pattern}'"
-
-    # Handle glob pattern
-    if glob
-      if File.directory?(path)
-        cmd_parts << "#{path}/**/*"
-        # Use shell globbing with find for better glob support
-        find_cmd = "find #{path} -name '#{glob}' -type f"
-        files_result = `#{find_cmd} 2>/dev/null`
-        if files_result.empty?
-          return "No files found matching pattern '#{glob}' in #{path}"
-        end
-
-        # Run grep on each matching file
-        files = files_result.strip.split("\n")
-        results = []
-
-        files.each do |file|
-          grep_cmd = cmd_parts[0..-2].join(' ') + " '#{pattern}' '#{file}'"
-          result = `#{grep_cmd} 2>/dev/null`
-          results << result unless result.empty?
-        end
-
-        return results.empty? ? "No matches found" : results.join("\n")
-      else
-        cmd_parts << path
-      end
-    else
-      cmd_parts << path
-    end
-
-    command = cmd_parts.join(' ')
-
-    begin
-      puts "Executing: #{command}"
-      result = `#{command} 2>&1`
-      exit_status = $?
-
-      if exit_status.success?
-        if result.empty?
-          "No matches found"
-        else
-          case output_mode
-          when 'content'
-            result
-          when 'files_with_matches'
-            result
-          when 'count'
-            result
-          else
-            result
-          end
-        end
-      elsif exit_status.exitstatus == 1
-        # grep returns 1 when no matches found, which is normal
-        "No matches found"
-      else
-        "Error: #{result}"
-      end
-
-    rescue => e
-      "Error executing grep: #{e.message}"
-    end
-  end
-end

data/sample/claude_code_clone/tools/read_tool.rb

@@ -1,61 +0,0 @@
-class ReadTool < LlmGateway::Tool
-  name 'Read'
-  description 'Read file contents with optional pagination'
-  input_schema({
-    type: 'object',
-    properties: {
-      file_path: { type: 'string', description: 'Absolute path to file' },
-      limit: { type: 'integer', description: 'Number of lines to read' },
-      offset: { type: 'integer', description: 'Starting line number' }
-    },
-    required: [ 'file_path' ]
-  })
-
-  def execute(input)
-    file_path = input[:file_path]
-    limit = input[:limit]
-    offset = input[:offset] || 0
-
-    # Validate file exists
-    unless File.exist?(file_path)
-      return "Error: File not found at #{file_path}"
-    end
-
-    # Check if it's a directory
-    if File.directory?(file_path)
-      return "Error: #{file_path} is a directory, not a file"
-    end
-
-    begin
-      lines = File.readlines(file_path, chomp: true)
-
-      # Apply offset
-      if offset > 0
-        if offset >= lines.length
-          return "Error: Offset #{offset} exceeds file length (#{lines.length} lines)"
-        end
-        lines = lines[offset..-1]
-      end
-
-      # Apply limit
-      if limit && limit > 0
-        lines = lines[0, limit]
-      end
-
-      # Format output with line numbers (similar to cat -n)
-      output = lines.each_with_index.map do |line, index|
-        line_number = offset + index + 1
-        "#{line_number.to_s.rjust(6)}→#{line}"
-      end
-
-      if output.empty?
-        "File is empty or no lines in specified range"
-      else
-        output.join("\n")
-      end
-
-    rescue => e
-      "Error reading file: #{e.message}"
-    end
-  end
-end

data/sample/claude_code_clone/tools/todowrite_tool.rb

@@ -1,98 +0,0 @@
-require 'json'
-
-class TodoWriteTool < LlmGateway::Tool
-  name 'TodoWrite'
-  description 'Create and manage structured task lists'
-  input_schema({
-    type: 'object',
-    properties: {
-      todos: {
-        type: 'array',
-        description: 'Array of todo objects',
-        items: {
-          type: 'object',
-          properties: {
-            id: { type: 'string', description: 'Unique identifier' },
-            content: { type: 'string', description: 'Task description' },
-            status: {
-              type: 'string',
-              enum: [ 'pending', 'in_progress', 'completed' ],
-              description: 'Task status'
-            },
-            priority: {
-              type: 'string',
-              enum: [ 'high', 'medium', 'low' ],
-              description: 'Task priority'
-            }
-          },
-          required: [ 'id', 'content', 'status', 'priority' ]
-        }
-      }
-    },
-    required: [ 'todos' ]
-  })
-
-  def execute(input)
-    todos = input[:todos]
-
-    # Validate todos structure
-    todos.each_with_index do |todo, index|
-      unless todo.is_a?(Hash)
-        return "Error: Todo at index #{index} is not a hash"
-      end
-
-      required_fields = [ 'id', 'content', 'status', 'priority' ]
-      missing_fields = required_fields - todo.keys.map(&:to_s)
-      unless missing_fields.empty?
-        return "Error: Todo at index #{index} missing required fields: #{missing_fields.join(', ')}"
-      end
-
-      valid_statuses = [ 'pending', 'in_progress', 'completed' ]
-      unless valid_statuses.include?(todo['status'])
-        return "Error: Invalid status '#{todo['status']}' in todo #{todo['id']}. Must be one of: #{valid_statuses.join(', ')}"
-      end
-
-      valid_priorities = [ 'high', 'medium', 'low' ]
-      unless valid_priorities.include?(todo['priority'])
-        return "Error: Invalid priority '#{todo['priority']}' in todo #{todo['id']}. Must be one of: #{valid_priorities.join(', ')}"
-      end
-    end
-
-    # Store todos (in practice, this might be saved to a file or database)
-    @todos = todos
-
-    # Generate summary
-    total = todos.length
-    pending = todos.count { |t| t['status'] == 'pending' }
-    in_progress = todos.count { |t| t['status'] == 'in_progress' }
-    completed = todos.count { |t| t['status'] == 'completed' }
-
-    summary = "Todo list updated successfully:\n"
-    summary += "Total tasks: #{total}\n"
-    summary += "Pending: #{pending}, In Progress: #{in_progress}, Completed: #{completed}\n\n"
-
-    # List current todos
-    summary += "Current tasks:\n"
-    todos.each do |todo|
-      status_icon = case todo['status']
-      when 'pending' then '⏳'
-      when 'in_progress' then '🔄'
-      when 'completed' then '✅'
-      end
-
-      priority_icon = case todo['priority']
-      when 'high' then '🔴'
-      when 'medium' then '🟡'
-      when 'low' then '🟢'
-      end
-
-      summary += "#{status_icon} #{priority_icon} [#{todo['id']}] #{todo['content']}\n"
-    end
-
-    summary
-  end
-
-  def self.current_todos
-    @todos || []
-  end
-end