llm_gateway 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fc0c0030bd149c9e3130d1f8e6fe2ccd0bfec5d87931534e4fc29d8808ad0c7
-  data.tar.gz: 1c9bf69153cfc502b41ef27305fcba114908a9debcdc34e9e2023fef257b4968
+  metadata.gz: 8e5e5bb04da32e9a1af4ad9dea6e8bf5af8785fc58d890fcb903739e89bc1a50
+  data.tar.gz: c23364222e72a72eaf2754bf775cff9709004db2007ab210c6440a0a2cb99cdc
 SHA512:
-  metadata.gz: 27ee426f1d8c3b97054e44b0d270d4eb8dd6d263fdf0717b1a47d655758ae634d1e25c12a850e468f4d360ca00beecfc430c9bfd3ed7a0a287bd0a48febcb110
-  data.tar.gz: fbc9b70052a776a99962b173842ede5016f4398504fca58d163a60f3eda52c58b2434c91d060bec3334c8c38e083c313692fb6b5442792943fcd3008ee44a08a
+  metadata.gz: 9f028198b6ed363a858dc0d409943d117d7c6c538ba81f21797a3dde55de4ada0fcf5e4814776873b5e35db0e3c3f87b938019cc9330fedcdae2469a746db1c4
+  data.tar.gz: df939b1f9dea8204e3ae87d1050056ea79014e29917475d4131dce7162dfec28f225f39bb5419c3327bf01f3a32d23634e612983d67c85fc581140c03da50697

data/CHANGELOG.md

@@ -1,8 +1,19 @@
 # Changelog
 
-## [Unreleased](https://github.com/Hyper-Unearthing/llm_gateway/tree/HEAD)
+## [v0.1.5](https://github.com/Hyper-Unearthing/llm_gateway/tree/v0.1.5) (2025-08-05)
 
-[Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.1.3...HEAD)
+[Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.1.4...v0.1.5)
+
+**Merged pull requests:**
+
+- burn: login from tool base class [\#11](https://github.com/Hyper-Unearthing/llm_gateway/pull/11) ([billybonks](https://github.com/billybonks))
+- improve sample [\#10](https://github.com/Hyper-Unearthing/llm_gateway/pull/10) ([billybonks](https://github.com/billybonks))
+- ci: mark latest change log as a version [\#9](https://github.com/Hyper-Unearthing/llm_gateway/pull/9) ([billybonks](https://github.com/billybonks))
+- ci: improve rake release task, so i get burnt less [\#8](https://github.com/Hyper-Unearthing/llm_gateway/pull/8) ([billybonks](https://github.com/billybonks))
+
+## [v0.1.4](https://github.com/Hyper-Unearthing/llm_gateway/tree/v0.1.4) (2025-08-04)
+
+[Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.1.3...v0.1.4)
 
 **Merged pull requests:**
 

data/README.md

@@ -45,7 +45,7 @@ result = LlmGateway::Client.chat(
 
 ### Sample Application
 
-See the [file search bot example](sample/directory_bot/) for a complete working application that demonstrates:
+See the [file search bot example](sample/claude_code_clone/) for a complete working application that demonstrates:
 - Creating reusable Prompt and Tool classes
 - Handling conversation transcripts with tool execution
 - Building an interactive terminal interface
@@ -53,7 +53,7 @@ See the [file search bot example](sample/directory_bot/) for a complete working
 To run the sample:
 
 ```bash
-cd sample/directory_bot
+cd sample/claude_code_clone
 ruby run.rb
 ```
 

data/Rakefile

@@ -14,12 +14,29 @@ begin
 
   desc "Release with changelog"
   task :gem_release do
-    # Generate changelog first
-    sh "bundle exec github_changelog_generator  -u Hyper-Unearthing -p llm_gateway"
-    sh "git add CHANGELOG.md"
-    sh "git commit -m 'Update changelog' || echo 'No changelog changes'"
+    # Safety checks: ensure we're on main and up-to-date
+    current_branch = `git branch --show-current`.strip
+    unless current_branch == "main"
+      puts "Error: You must be on the main branch to release. Current branch: #{current_branch}"
+      exit 1
+    end
+
+    # Check if branch is up-to-date with remote
+    sh "git fetch origin"
+    local_commit = `git rev-parse HEAD`.strip
+    remote_commit = `git rev-parse origin/main`.strip
+    unless local_commit == remote_commit
+      puts "Error: Your main branch is not in sync with origin/main. Please pull the latest changes."
+      exit 1
+    end
+
+    # Check for uncommitted changes
+    unless `git status --porcelain`.strip.empty?
+      puts "Error: You have uncommitted changes. Please commit or stash them before releasing."
+      exit 1
+    end
 
-    # Ask for version bump type
+    # Ask for version bump type first
     print "What type of version bump? (major/minor/patch): "
     version_type = $stdin.gets.chomp.downcase
 
@@ -28,8 +45,29 @@ begin
       exit 1
     end
 
-    # Release
-    sh "gem bump --version #{version_type} --tag --push --release"
+    # Bump version without committing yet to get new version
+    sh "gem bump --version #{version_type} --no-commit"
+
+    # Get the new version
+    new_version = `ruby -e "puts Gem::Specification.load('llm_gateway.gemspec').version"`.strip
+
+    # Generate changelog with proper version
+    sh "bundle exec github_changelog_generator " \
+       "-u Hyper-Unearthing -p llm_gateway --future-release v#{new_version}"
+
+    # Bundle to update Gemfile.lock
+    sh "bundle"
+
+    # Add all changes and commit in one go
+    sh "git add ."
+    sh "git commit -m 'Bump llm_gateway to $(ruby -e \"puts Gem::Specification.load('llm_gateway.gemspec').version\")'"
+
+    # Tag and push
+    sh "git tag v$(ruby -e \"puts Gem::Specification.load('llm_gateway.gemspec').version\")"
+    sh "git push origin main --tags"
+
+    # Release the gem
+    sh "gem push $(gem build llm_gateway.gemspec | grep 'File:' | awk '{print $2}')"
   end
 rescue LoadError
   # gem-release not available in this environment

data/lib/llm_gateway/tool.rb

@@ -39,7 +39,7 @@ module LlmGateway
         definition[:name]
       end
 
-      def execute(input, login)
+      def execute(input)
         raise NotImplementedError, "Subclasses must implement execute"
       end
   end

data/lib/llm_gateway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmGateway
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/sample/claude_code_clone/agent.rb

@@ -0,0 +1,65 @@
+class Agent
+  def initialize(prompt_class, model, api_key)
+    @prompt_class = prompt_class
+    @model = model
+    @api_key = api_key
+    @transcript = []
+  end
+
+  def run(user_input, &block)
+    @transcript << { role: 'user', content: [ { type: 'text', text: user_input } ] }
+
+    begin
+      prompt = @prompt_class.new(@model, @transcript, @api_key)
+      result = prompt.post
+      process_response(result[:choices][0][:content], &block)
+    rescue => e
+      yield({ type: 'error', message: e.message }) if block_given?
+      raise e
+    end
+  end
+
+  private
+
+  def process_response(response, &block)
+    @transcript << { role: 'assistant', content: response }
+
+    response.each do |message|
+      yield(message) if block_given?
+
+      if message[:type] == 'text'
+        # Text response processed
+      elsif message[:type] == 'tool_use'
+        result = handle_tool_use(message)
+
+        tool_result = {
+          type: 'tool_result',
+          tool_use_id: message[:id],
+          content: result
+        }
+        @transcript << { role: 'user', content: [ tool_result ] }
+
+        yield(tool_result) if block_given?
+
+        follow_up_prompt = @prompt_class.new(@model, @transcript, @api_key)
+        follow_up = follow_up_prompt.post
+
+        process_response(follow_up[:choices][0][:content], &block) if follow_up[:choices][0][:content]
+      end
+    end
+
+    response
+  end
+
+  def handle_tool_use(message)
+    tool_class = @prompt_class.find_tool(message[:name])
+    if tool_class
+      tool = tool_class.new
+      tool.execute(message[:input])
+    else
+      "Unknown tool: #{message[:name]}"
+    end
+  rescue StandardError => e
+    "Error executing tool: #{e.message}"
+  end
+end

data/sample/claude_code_clone/claude_code_clone.rb

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,79 @@
+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/{directory_bot → claude_code_clone}/run.rb

@@ -1,6 +1,6 @@
 require 'tty-prompt'
 require_relative '../../lib/llm_gateway'
-require_relative 'file_search_bot'
+require_relative 'claude_code_clone.rb'
 
 # Terminal Runner for FileSearchBot
 class FileSearchTerminalRunner
@@ -9,17 +9,15 @@ class FileSearchTerminalRunner
   end
 
   def start
-    puts "File Search Assistant - I can help you find files and search through directories."
     puts "First, let's configure your LLM settings:\n\n"
 
     model, api_key = setup_configuration
-    bot = FileSearchBot.new(model, api_key)
+    bot = ClaudeCloneClone.new(model, api_key)
 
-    puts "\nGreat! Now you can start searching."
     puts "Type 'quit' or 'exit' to stop.\n\n"
 
     loop do
-      user_input = @prompt.ask("What would you like to find?")
+      user_input = @prompt.ask("What can i do for you?")
 
       break if [ 'quit', 'exit' ].include?(user_input.downcase)
 

data/sample/claude_code_clone/tools/bash_tool.rb

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,98 @@
+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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-04 00:00:00.000000000 Z
+date: 2025-08-05 00:00:00.000000000 Z
 dependencies: []
 description: LlmGateway provides a consistent Ruby interface for multiple LLM providers
   including Claude, OpenAI, and Groq. Features include unified response formatting,
@@ -43,10 +43,15 @@ files:
 - lib/llm_gateway/tool.rb
 - lib/llm_gateway/utils.rb
 - lib/llm_gateway/version.rb
-- sample/directory_bot/file_search_bot.rb
-- sample/directory_bot/file_search_prompt.rb
-- sample/directory_bot/file_search_tool.rb
-- sample/directory_bot/run.rb
+- sample/claude_code_clone/agent.rb
+- sample/claude_code_clone/claude_code_clone.rb
+- sample/claude_code_clone/prompt.rb
+- sample/claude_code_clone/run.rb
+- sample/claude_code_clone/tools/bash_tool.rb
+- sample/claude_code_clone/tools/edit_tool.rb
+- sample/claude_code_clone/tools/grep_tool.rb
+- sample/claude_code_clone/tools/read_tool.rb
+- sample/claude_code_clone/tools/todowrite_tool.rb
 - sig/llm_gateway.rbs
 homepage: https://github.com/Hyper-Unearthing/llm_gateway
 licenses:

data/sample/directory_bot/file_search_bot.rb

@@ -1,72 +0,0 @@
-require_relative 'file_search_tool'
-require_relative 'file_search_prompt'
-require 'debug'
-
-# Bash File Search Assistant using LlmGateway architecture
-
-class FileSearchBot
-  def initialize(model, api_key)
-    @transcript = []
-    @model = model
-    @api_key = api_key
-  end
-
-  def query(input)
-    process_query(input)
-  end
-
-  private
-
-  def process_query(query)
-    # Add user message to transcript
-    @transcript << { role: 'user', content: [ { type: 'text', text: query } ] }
-
-    begin
-      prompt = FileSearchPrompt.new(@model, @transcript, @api_key)
-      result = prompt.post
-      process_response(result[:choices][0][:content])
-    rescue => e
-      puts "Error: #{e.message}"
-      puts "Backtrace: #{e.backtrace.join("\n")}"
-      puts "I give up as bot"
-    end
-  end
-
-  def process_response(response)
-    # Add assistant response to transcript
-    @transcript << { role: 'assistant', content: response }
-
-    response.each do |message|
-      if message[:type] == 'text'
-        puts "\nBot: #{message[:text]}\n"
-      elsif message[:type] == 'tool_use'
-        result = handle_tool_use(message)
-
-        # Add tool result to transcript
-        tool_result = {
-          type: 'tool_result',
-          tool_use_id: message[:id],
-          content: result
-        }
-        @transcript << { role: 'user', content: [ tool_result ] }
-
-        # Continue conversation with tool result
-        follow_up_prompt = FileSearchPrompt.new(@model, @transcript, @api_key)
-        follow_up = follow_up_prompt.post
-
-        process_response(follow_up[:choices][0][:content]) if follow_up[:choices][0][:content]
-      end
-    end
-  end
-
-  def handle_tool_use(message)
-    if message[:name] == 'execute_bash_command'
-      tool = FileSearchTool.new
-      tool.execute(message[:input])
-    else
-      "Unknown tool: #{message[:name]}"
-    end
-  rescue StandardError => e
-    "Error executing tool: #{e.message}"
-  end
-end

data/sample/directory_bot/file_search_prompt.rb

@@ -1,56 +0,0 @@
-require_relative 'file_search_tool'
-
-class FileSearchPrompt < 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 a helpful assistant that can find things for them in directories.
-
-      # Bash File Search Assistant
-
-      You are a bash command-line assistant specialized in helping users find information in files and directories. Your role is to translate natural language queries into effective bash commands using search and file inspection tools.
-
-      ## Available Commands
-
-      You have access to these bash commands:
-      - `find` - Locate files and directories by name, type, size, date, etc.
-      - `grep` - Search for text patterns within files
-      - `cat` - Display entire file contents
-      - `head` - Show first lines of files
-      - `tail` - Show last lines of files
-      - `ls` - List directory contents with various options
-      - `wc` - Count lines, words, characters
-      - `sort` - Sort file contents
-      - `uniq` - Remove duplicate lines
-      - `awk` - Text processing and pattern extraction
-      - `sed` - Stream editing and text manipulation
-
-      ## Your Process
-
-      1. **Understand the Query**: Parse what the user is looking for
-      2. **Choose Strategy**: Determine the best combination of commands
-      3. **Execute Commands**: Use the execute_bash_command tool with exact bash commands
-      4. **Explain**: Briefly explain what each command does
-      5. **Suggest Refinements**: Offer ways to narrow or expand the search if needed
-
-      Always use the execute_bash_command tool to run commands rather than just suggesting them.
-    SYSTEM
-  end
-
-  def tools
-    [ FileSearchTool.definition ]
-  end
-
-  def post
-    LlmGateway::Client.chat(model, prompt, tools: tools, system: system_prompt, api_key: @api_key)
-  end
-end

data/sample/directory_bot/file_search_tool.rb

@@ -1,32 +0,0 @@
-
-class FileSearchTool < LlmGateway::Tool
-  name 'execute_bash_command'
-  description 'Execute bash commands for file searching and directory exploration'
-  input_schema({
-    type: 'object',
-    properties: {
-      command: { type: 'string', description: 'The bash command to execute' },
-      explanation: { type: 'string', description: 'Explanation of what the command does' }
-    },
-    required: [ 'command', 'explanation' ]
-  })
-
-  def execute(input, login = nil)
-    command = input[:command]
-    explanation = input[:explanation]
-
-    puts "Executing: #{command}"
-    puts "Purpose: #{explanation}\n\n"
-
-    begin
-      result = `#{command} 2>&1`
-      if $?.success?
-        result.empty? ? "Command completed successfully (no output)" : result
-      else
-        "Error: #{result}"
-      end
-    rescue => e
-      "Error executing command: #{e.message}"
-    end
-  end
-end