llm-shell 0.10.0 → 0.11.0

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_data, "prompts", prompt)
-    end
-  end
-end

data/lib/llm/shell/renderer.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Shell
-  class Renderer
-    RenderError = Class.new(RuntimeError)
-
-    ##
-    # @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 =~ LLM::Shell.pattern
-        path = content.match(LLM::Shell.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,111 +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
-      Reline.completion_proc = Completion.to_proc
-      chat(options.prompt, role: options.default.role).flush
-      unread.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 = Reline.readline("llm> ", true) || throw(:exit, 0)
-      words = input.split(" ")
-      if cmd = LLM::Shell.find_command(words[0])
-        argv = words[1..]
-        cmd.new(bot, io).call(*argv)
-      else
-        chat(input.tap { clear_screen }, tools:)
-        io.rewind.print(Paint["Thinking", :bold])
-        unread.tap { io.rewind }
-      end
-    end
-
-    def eval
-      callables = []
-      cancels = []
-      results = []
-      functions.each do |function|
-        args = function.arguments.to_json
-        print Paint["system", :bold, :red], " says: ", "\n"
-        print "function ".ljust(20), function.name, "\n"
-        print "arguments ".ljust(20), ((args.size >= 80) ? "#{args[0..79]} ...}" : args), "\n"
-        print "argument count".ljust(20), function.arguments.to_h.size, "\n\n"
-        input = Reline.readline("Should we proceed? ", 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).flush
-    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
-
-    ##
-    # @return [Array<LLM::Tool>]
-    def tools
-      LLM::Shell
-        .tools
-        .select(&:enabled?)
-    end
-
-    attr_reader :bot, :console, :io, :default, :options
-
-    def formatter(messages) = Formatter.new(messages)
-    def unread = bot.messages.unread
-    def functions = bot.functions
-    def clear_screen = console.clear_screen
-    def chat(...) = bot.chat(...)
-  end
-end

data/lib/llm/shell/tool.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Tool
-  module Patch
-    ##
-    # Returns true for an enabled tool
-    # @return [Boolean]
-    def enabled?
-      @enabled
-    end
-
-    ##
-    # Enable the tool
-    # @return [void]
-    def enable!
-      @enabled = true
-    end
-
-    ##
-    # Disable the tool
-    # @return [void]
-    def disable!
-      @enabled = false
-    end
-
-    ##
-    # @return [Boolean]
-    def builtin?
-      path, _ = instance_method(:call).source_location
-      path&.include?(LLM::Shell.root)
-    end
-  end
-
-  m = method(:inherited)
-  define_singleton_method(:inherited) do |tool|
-    LLM::Shell.tools << tool
-    m.call(tool)
-    tool.enable!
-  end
-
-  extend Patch
-end

data/lib/llm/shell/tools/read_file.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module LLM::Shell::Tools
-  class ReadFile < LLM::Tool
-    name "read-file"
-    description "Read the contents of a file"
-    param :path, String, "The path to a file", required: true
-
-    def call(path:)
-      {ok: true, content: File.read(path)}
-    rescue => ex
-      {ok: false, error: {class: ex.class.to_s, message: ex.message}}
-    end
-  end
-end

data/lib/llm/shell/tools/system.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module LLM::Shell::Tools
-  class System < LLM::Tool
-    name "system"
-    description "Run a system command"
-    param :command, String, "The command to execute", required: true
-
-    def call(command:)
-      ro, wo = IO.pipe
-      re, we = IO.pipe
-      Process.wait Process.spawn(command, out: wo, err: we)
-      [wo, we].each(&:close)
-      {stderr: re.read, stdout: ro.read}
-    end
-  end
-end

data/lib/llm/shell/tools/write_file.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module LLM::Shell::Tools
-  class WriteFile < LLM::Tool
-    name "write-file"
-    description "Write the contents of a file"
-    param :path, String, "The path to a file", required: true
-    param :content, String, "The contents of a file", required: true
-
-    def call(path:, content:)
-      {ok: true, content: File.binwrite(path, content)}
-    rescue => ex
-      {ok: false, error: {class: ex.class.to_s, message: ex.message}}
-    end
-  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.10.0"
-end

data/lib/llm/shell.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module LLM
-  $:.unshift(*Dir[File.join(__dir__, "shell", "internal", "*", "lib")])
-  require "optparse"
-  require "io/line"
-  require "paint"
-  require "reline"
-  require "coderay"
-  require "llm"
-  require "tomlrb"
-end
-
-class LLM::Shell
-  require_relative "shell/tool"
-  require_relative "shell/command"
-  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"
-
-  ##
-  # Returns the lib/ directory
-  # @return [String]
-  def self.root
-    __dir__
-  end
-
-  ##
-  # Returns the directory where configuration files are kept
-  # @return [String]
-  def self.home_config
-    if ENV.key?("XDG_CONFIG_HOME")
-      ENV["XDG_CONFIG_HOME"]
-    else
-      File.join Dir.home, ".config"
-    end
-  end
-
-  ##
-  # Returns the directory where commands and tools are kept
-  # @return [String]
-  def self.home_data
-    if ENV.key?("XDG_DATA_HOME")
-      File.join ENV["XDG_DATA_HOME"], ".llm-shell"
-    else
-      File.join Dir.home, ".local", "share", ".llm-shell"
-    end
-  end
-
-  ##
-  # @return [Array<LLM::Command>]
-  def self.commands
-    @commands ||= []
-  end
-
-  ##
-  # @return [Array<LLM::Tool>]
-  def self.tools
-    @tools ||= []
-  end
-
-  ##
-  # Returns an instance of {LLM::Command LLM::Command}, or nil.
-  # @return [LLM::Command, nil]
-  def self.find_command(name)
-    commands.find { _1.name == name }
-  end
-
-  ##
-  # @return [Regexp]
-  def self.pattern
-    /\A<file path=(.+?)>/
-  end
-
-  ##
-  # Opens a pager
-  # @return [void]
-  def self.pager(...)
-    IO.popen("less -FRX", "w", ...)
-  end
-
-  ##
-  # Load commands & tools
-  Dir[File.join(home_data, "commands", "*.rb")].each { require(_1) }
-  Dir[File.join(home_data, "tools", "*.rb")].each { require(_1) }
-  Dir[File.join(root, "shell", "commands", "*.rb")].each { require(_1) }
-  Dir[File.join(root, "shell", "tools", "*.rb")].each { require(_1) }
-
-  ##
-  # @param [Hash] opts
-  # @return [LLM::Shell]
-  def initialize(opts)
-    @config  = Config.new(opts[:provider])
-    @options = Options.new @config.merge(opts), Default.new(opts[:provider])
-    @bot  = LLM::Bot.new(llm, options.bot)
-    @repl = REPL.new(bot:, options:)
-  end
-
-  ##
-  # Start the shell
-  # @return [void]
-  def start
-    repl.setup
-    repl.start
-  end
-
-  private
-
-  attr_reader :options, :bot, :repl
-
-  ##
-  # @return [Method]
-  def provider
-    LLM.method(options.provider)
-  end
-
-  ##
-  # @return [LLM::Provider]
-  def llm
-    provider.call(**options.llm)
-  end
-end
-
-module LLM
-  Command = LLM::Shell::Command
-end

data/lib/llm-shell.rb

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

data/libexec/llm-shell/shell

@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-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("-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
-  require_relative "../../lib/llm/shell"
-  main(ARGV)
-  throw(:exit, 0)
-rescue => ex
-  print Paint[ex.class, :red, :bold], "\n"
-  print ex.message, "\n\n"
-  print Paint["Backtrace", :bold], "\n"
-  print ex.backtrace[0..7].join("\n"), "\n"
-  throw(:exit, 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.