llm_gateway 0.3.0 → 0.4.0

data/sample/claude_code_clone/claude_code_clone.rb

@@ -1,40 +0,0 @@
-require_relative 'prompt'
-require_relative 'agent'
-require 'debug'
-
-# Bash File Search Assistant using LlmGateway architecture
-
-class ClaudeCloneClone
-  def initialize(model, api_key)
-    @agent = Agent.new(Prompt, model, api_key)
-  end
-
-  def query(input)
-    begin
-      @agent.run(input) do |message|
-        case message[:type]
-        when 'text'
-          puts "\n\e[32m•\e[0m #{message[:text]}"
-        when 'tool_use'
-          puts "\n\e[33m•\e[0m \e[36m#{message[:name]}\e[0m"
-          if message[:input] && !message[:input].empty?
-            puts "  \e[90m#{message[:input]}\e[0m"
-          end
-        when 'tool_result'
-          if message[:content] && !message[:content].empty?
-            content_preview = message[:content].to_s.split("\n").first(3).join("\n")
-            if content_preview.length > 100
-              content_preview = content_preview[0..97] + "..."
-            end
-            puts "  \e[90m#{content_preview}\e[0m"
-          end
-        when 'error'
-          puts "\n\e[31m•\e[0m \e[91mError: #{message[:message]}\e[0m"
-        end
-      end
-    rescue => e
-      puts "\n\e[31m•\e[0m \e[91mError: #{e.message}\e[0m"
-      puts "\e[90m  #{e.backtrace.first}\e[0m" if e.backtrace&.first
-    end
-  end
-end

data/sample/claude_code_clone/prompt.rb

@@ -1,79 +0,0 @@
-require_relative 'tools/edit_tool'
-require_relative 'tools/read_tool'
-require_relative 'tools/todowrite_tool'
-require_relative 'tools/bash_tool'
-require_relative 'tools/grep_tool'
-
-class Prompt < LlmGateway::Prompt
-  def initialize(model, transcript, api_key)
-    super(model)
-    @transcript = transcript
-    @api_key = api_key
-  end
-
-  def prompt
-    @transcript
-  end
-
-  def system_prompt
-    <<~SYSTEM
-      You are Claude Code Clone, an interactive CLI tool that assists with software engineering tasks.
-
-      # Core Capabilities
-
-      I provide assistance with:
-      - Code analysis and debugging
-      - Feature implementation
-      - File editing and creation
-      - Running tests and builds
-      - Git operations
-      - Web browsing and research
-      - Task planning and management
-
-      ## Available Tools
-
-      You have access to these specialized tools:
-      - `Edit` - Modify existing files by replacing specific text strings
-      - `Read` - Read file contents with optional pagination
-      - `TodoWrite` - Create and manage structured task lists
-      - `Bash` - Execute shell commands with timeout support
-      - `Grep` - Search for patterns in files using regex
-
-      ## Core Instructions
-
-      I am designed to:
-      - Be concise and direct (minimize output tokens)
-      - Follow existing code conventions and patterns
-      - Use defensive security practices only
-      - Plan tasks with the TodoWrite tool for complex work
-      - Run linting/typechecking after making changes
-      - Never commit unless explicitly asked
-
-      ## Process
-
-      1. **Understand the Request**: Parse what the user needs accomplished
-      2. **Plan if Complex**: Use TodoWrite for multi-step tasks
-      3. **Execute Tools**: Use appropriate tools to complete the work
-      4. **Validate**: Run tests/linting when applicable
-      5. **Report**: Provide concise status updates
-
-      Always use the available tools to perform actions rather than just suggesting commands.
-
-      Before starting any task, build a todo list of what you need to do, ensuring each item is actionable and prioritized. Then, execute the tasks one by one, using the TodoWrite tool to track progress and completion.
-
-      After completing each task, update the TodoWrite list to reflect the status and any necessary follow-up actions.
-    SYSTEM
-  end
-
-  def self.tools
-    [ EditTool, ReadTool, TodoWriteTool, BashTool, GrepTool ]
-  end
-
-  def tools
-    self.class.tools.map(&:definition)
-  end
-
-  def post
-    LlmGateway::Client.chat(model, prompt, tools: tools, system: system_prompt, api_key: @api_key)
-  end
-end

data/sample/claude_code_clone/run.rb

@@ -1,47 +0,0 @@
-require 'tty-prompt'
-require_relative '../../lib/llm_gateway'
-require_relative 'claude_code_clone.rb'
-
-# Terminal Runner for FileSearchBot
-class FileSearchTerminalRunner
-  def initialize
-    @prompt = TTY::Prompt.new
-  end
-
-  def start
-    puts "First, let's configure your LLM settings:\n\n"
-
-    model, api_key = setup_configuration
-    bot = ClaudeCloneClone.new(model, api_key)
-
-    puts "Type 'quit' or 'exit' to stop.\n\n"
-
-    loop do
-      user_input = @prompt.ask("What can i do for you?")
-
-      break if [ 'quit', 'exit' ].include?(user_input.downcase)
-
-      bot.query(user_input)
-    end
-  end
-
-  private
-
-  def setup_configuration
-    model = @prompt.ask("Enter model (default: claude-3-7-sonnet-20250219):") do |q|
-      q.default 'claude-3-7-sonnet-20250219'
-    end
-
-    api_key = @prompt.mask("Enter your API key:") do |q|
-      q.required true
-    end
-
-    [ model, api_key ]
-  end
-end
-
-# Start the bot
-if __FILE__ == $0
-  runner = FileSearchTerminalRunner.new
-  runner.start
-end

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