llm-shell 0.9.2 → 0.11.0

data/lib/llm/shell/markdown.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require "redcarpet"
-require "coderay"
-
-class LLM::Shell
-  ##
-  # @api private
-  # @see redcarpet https://github.com/vmg/redcarpet/blob/master/ext/redcarpet/markdown.h#L69-L110
-  class Markdown < Redcarpet::Render::Base
-    ##
-    # Renders markdown text to a terminal-friendly format.
-    # @return [String
-    def self.render(text)
-      renderer = Redcarpet::Markdown.new(self, options)
-      renderer.render(wrap(p: text)).strip
-    end
-
-    ##
-    # @api private
-    def self.wrap(p:, width: 80)
-      in_code = false
-      p.lines.map do |line|
-        if line =~ /^(\s*)(```|~~~)/
-          in_code = !in_code
-          line
-        elsif in_code || line =~ /^\s{4}/
-          line
-        else
-          line.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
-        end
-      end.join.strip + "\n"
-    end
-
-    ##
-    # @api private
-    def self.options
-      {
-        autolink: false, no_intra_emphasis: true,
-        fenced_code_blocks: true, lax_spacing: true,
-        strikethrough: true, superscript: true,
-        tables: true, with_toc_data: true
-      }
-    end
-
-    def block_code(code, lang)
-      ["\n", Paint["#{lang}:", :blue, :bold],
-       "\n", coderay(code, lang),
-       "\n"].join
-    end
-
-    def header(text, level)
-      color = levels.fetch(level, :white)
-      "\n" + Paint[("#" * level) + " " + text, color] + "\n"
-    end
-
-    def paragraph(p) = "#{p.strip}\n\n"
-    def list(items, _type) = items
-    def list_item(item, _type) = "\n• #{item.strip}\n"
-    def emphasis(text) = Paint[text, :italic]
-    def double_emphasis(text) = Paint[text, :bold]
-    def codespan(code) = Paint[code, :yellow, :underline]
-    def block_quote(quote) = Paint[quote, :italic]
-    def normal_text(text) = text
-    def linebreak = "\n"
-
-    private
-
-    def coderay(code, lang)
-      CodeRay.scan(code, lang).terminal
-    rescue ArgumentError
-      lang = "text"
-      retry
-    end
-
-    def levels
-      {
-        1 => :green, 2 => :blue, 3 => :green,
-        4 => :yellow, 5 => :red, 6 => :purple
-      }
-    end
-  end
-end

data/lib/llm/shell/options.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Shell
-  ##
-  # The {LLM::Shell::Options LLM::Shell::Options} class represents
-  # the options provided to the shell at the command line, and the
-  # configuration file (if any). The command-line options take precedence
-  # over the configuration file.
-  class Options
-    ##
-    # @param [Hash] options
-    # @param [LLM::Shell::Default] default
-    # @return [LLM::Shell::Options]
-    def initialize(options, default)
-      @options  = options.transform_keys(&:to_sym)
-      @provider = @options.delete(:provider)
-      @tools    = @options.delete(:tools)
-      @prompt   = @options[:prompt] ? custom_prompt : default.prompt
-      @files    = Dir[*@options.delete(:files) || []].reject { File.directory?(_1) }
-      @bot_options = {model: @options.delete(:model)}.compact
-      @default  = default
-    end
-
-    def provider = @provider
-    def tools = @tools
-    def files = @files
-    def llm = @options
-    def bot = @bot_options
-    def default = @default
-    def prompt = File.read(@prompt)
-
-    private
-
-    def custom_prompt
-      prompt = @options.delete(:prompt)
-      File.join(LLM::Shell.home, "prompts", prompt)
-    end
-  end
-end

data/lib/llm/shell/renderer.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Shell
-  class Renderer
-    RenderError = Class.new(RuntimeError)
-    include Command::Utils
-
-    ##
-    # @param [LLM::Message] message
-    #  The message to render
-    # @return [LLM::Shell::MessageRenderer]
-    #  Returns an instance of the renderer
-    def initialize(message)
-      @message = message
-    end
-
-    def render
-      if message.user?
-        render_message(message, :yellow)
-      elsif message.assistant?
-        render_message(message, :green)
-      elsif message.system?
-        render_message(message, :red)
-      else
-        raise RenderError.new("no handler for message role '#{message.role}'")
-      end
-    end
-
-    private
-
-    attr_reader :message
-
-    def render_message(message, color)
-      role    = Paint[message.role, :bold, color]
-      title   = "#{role} says: "
-      content = message.content
-      if message.tool_call?
-        body = "Tool call(s) request"
-      elsif message.tool_return?
-        body = "Tool call(s) return"
-      elsif Array === content
-        body = content.map { |c| render_message(c, color) }.join("\n")
-      elsif content =~ file_pattern
-        path = content.match(file_pattern) ? Regexp.last_match[1] : nil
-        body = "<file path=#{path} />"
-      else
-        body = Markdown.render(content)
-      end
-      [title, "\n", body, "\n"].join
-    end
-  end
-end

data/lib/llm/shell/repl.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Shell
-  ##
-  # The {LLM::Shell::REPL LLM::Shell::REPL} class represents a loop
-  # that accepts user input, evaluates it via the LLM, and prints the
-  # response to stdout.
-  class REPL
-    ##
-    # @param [LLM::Chat] bot
-    # @param [LLM::Shell::Options] options
-    # @return [LLM::Shell::REPL]
-    def initialize(bot:, options:)
-      @bot = bot
-      @console = IO.console
-      @options = options
-      @io = IO::Line.new($stdout)
-    end
-
-    ##
-    # Performs initial setup
-    # @return [void]
-    def setup
-      LLM::Shell.commands.each { |file| require file }
-      Readline.completion_proc = Completion.to_proc
-      chat options.prompt, role: options.default.role
-      files.each { chat ["--- START: #{_1} ---", File.read(_1), "--- END: #{_1} ---"].join("\n") }
-      bot.messages.each(&:read!)
-      clear_screen
-    end
-
-    ##
-    # Enters the main loop
-    # @return [void]
-    def start
-      loop do
-        read
-        eval while functions.any?
-        emit
-      rescue LLM::ResponseError => ex
-        print Paint[ex.response.class, :red], "\n"
-        print ex.response.body, "\n"
-      rescue => ex
-        print Paint[ex.class, :red], "\n"
-        print ex.message, "\n"
-        print ex.backtrace[0..5].join("\n")
-      rescue Interrupt
-        throw(:exit, 0)
-      end
-    end
-
-    private
-
-    def read
-      input = Readline.readline("llm> ", true) || throw(:exit, 0)
-      words = input.split(" ")
-      if LLM.commands[words[0]]
-        cmd  = LLM.commands[words[0]]
-        argv = words[1..]
-        cmd.setup(bot, io)
-        cmd.call(*argv)
-      else
-        chat input.tap { clear_screen }
-        io.rewind.print(Paint["Thinking", :bold])
-        unread.tap { io.rewind }
-      end
-    end
-
-    def eval
-      callables = []
-      cancels = []
-      results = []
-      functions.each do |function|
-        print Paint["system", :bold, :red], " says: ", "\n"
-        print "function: ", function.name, "\n"
-        print "arguments: ", function.arguments.to_h.size, "\n"
-        input = Readline.readline("Do you want to call it ? ", true)
-        puts
-        if %w(y yes yep yeah ok).include?(input)
-          callables << function
-        else
-          cancels << function
-        end
-      end
-      results.concat callables.map(&:call)
-      results.concat cancels.map(&:cancel)
-      bot.chat(results)
-    end
-
-    def emit
-      LLM::Shell.pager do |io|
-        io.write formatter(unread).format!(:user), "\n"
-        io.write formatter(unread).format!(:assistant), "\n"
-      end unless unread.empty?
-    end
-
-    attr_reader :bot, :console, :io, :default, :options
-
-    def formatter(messages) = Formatter.new(messages)
-    def unread = bot.messages.unread
-    def functions = bot.functions
-    def files = @options.files
-    def clear_screen = console.clear_screen
-    def chat(...) = bot.chat(...)
-  end
-end

data/lib/llm/shell/version.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module LLM
-end unless defined?(LLM)
-
-class LLM::Shell
-  VERSION = "0.9.2"
-end

data/lib/llm/shell.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-require "readline"
-require "yaml"
-require "llm"
-require "paint"
-
-class LLM::Shell
-  require_relative "function"
-  require_relative "../io/line"
-  require_relative "shell/command"
-  require_relative "shell/command/extension"
-  require_relative "shell/markdown"
-  require_relative "shell/renderer"
-  require_relative "shell/formatter"
-  require_relative "shell/default"
-  require_relative "shell/options"
-  require_relative "shell/repl"
-  require_relative "shell/config"
-  require_relative "shell/completion"
-  require_relative "shell/version"
-
-  ##
-  # Load all commands
-  Dir[File.join(__dir__, "shell", "commands", "*.rb")].each { require(_1) }
-
-  ##
-  # Opens a pager
-  # @return [void]
-  def self.pager(...)
-    IO.popen("less -FRX", "w", ...)
-  end
-
-  ##
-  # @return [String]
-  def self.home
-    File.join Dir.home, ".llm-shell"
-  end
-
-  ##
-  # @return [Array<String>]
-  def self.tools
-    Dir[*TOOLGLOBS]
-  end
-
-  ##
-  # @return [Array<String>]
-  def self.commands
-    Dir[File.join(home, "commands", "*.rb")]
-  end
-
-  TOOLGLOBS = [
-    File.join(home, "tools", "*.rb"),
-    File.join(__dir__, "shell", "functions", "*.rb")
-  ].freeze
-  private_constant :TOOLGLOBS
-
-  ##
-  # @param [Hash] options
-  # @return [LLM::Shell]
-  def initialize(options)
-    @config  = Config.new(options[:provider])
-    @options = Options.new @config.merge(options), Default.new(options[:provider])
-    @bot  = LLM::Bot.new(llm, {tools:}.merge(@options.bot))
-    @repl = REPL.new(bot: @bot, options: @options)
-  end
-
-  ##
-  # Start the shell
-  # @return [void]
-  def start
-    repl.setup
-    repl.start
-  end
-
-  private
-
-  def tools
-    LLM::Shell.tools.map do |path|
-      eval File.read(path), TOPLEVEL_BINDING, path, 1
-    end.grep(LLM::Function)
-  end
-
-  attr_reader :options, :bot, :repl
-  def provider = LLM.method(options.provider)
-  def llm = provider.call(**options.llm)
-end

data/lib/llm-shell.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "llm/shell"

data/libexec/llm-shell/shell

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative "../../lib/llm/shell"
-
-def main(argv)
-  if argv.include?("-v") || argv.include?("--version")
-    puts LLM::Shell::VERSION
-  else
-    options = {tools: []}
-    option_parser.parse(argv, into: options)
-    if argv.empty? || options[:provider].nil?
-      warn option_parser.help
-      throw(:exit, 1)
-    else
-      LLM::Shell.new(options).start
-    end
-  end
-end
-
-def option_parser
-  OptionParser.new do |o|
-    o.banner = "Usage: llm-shell [OPTIONS]"
-    o.on("-p PROVIDER", "--provider NAME", "Required. Options: gemini, openai, anthropic, ollama or llamacpp.", String)
-    o.on("-k [KEY]", "--key [KEY]", "Optional. Required by gemini, openai, and anthropic.", String)
-    o.on("-m [MODEL]", "--model [MODEL]", "Optional. The name of a model.", Array)
-    o.on("-h [HOST]", "--host [HOST]", "Optional. Sometimes required by ollama.", String)
-    o.on("-o [PORT]", "--port [PORT]", "Optional. Sometimes required by ollama.", Integer)
-    o.on("-f [GLOB]", "--files [GLOB]", "Optional. Glob pattern(s) separated by a comma.", Array)
-    o.on("-r [PROMPT]", "--prompt [PROMPT]", "Optional. The prompt to use.", String)
-    o.on("-v", "--version", "Optional. Print the version and exit.")
-  end
-end
-
-excode = catch(:exit) do
-  main(ARGV)
-  0
-rescue => ex
-  print Paint[ex.class, :red, :bold], "\n"
-  print ex.message, "\n\n"
-  print Paint["Backtrace", :bold], "\n"
-  print ex.backtrace[0..5].join("\n"), "\n"
-  1
-end
-exit excode

data/share/llm-shell/prompts/default.txt

@@ -1,21 +0,0 @@
-## Task
-
-Your task is to provide helpful assistance to the user.
-
-## Context
-
-The user is talking to you from a terminal-based application.
-
-## Inputs
-
-The user might send you the content of file(s) from their filesystem.
-When the user sends you a file, it will be in this format:
-
-<file path="/path/to/file">
-  CONTENT
-</file>
-
-## Outputs
-
-Always respond in markdown.
-When the user sends a file, reply with "Got it" and nothing else.