ollama-ruby 0.0.0

data/lib/ollama/commands/show.rb

@@ -0,0 +1,20 @@
+class Ollama::Commands::Show
+  include Ollama::DTO
+
+  def self.path
+    '/api/show'
+  end
+
+  def initialize(name:, verbose: nil)
+    @name, @verbose = name, verbose
+    @stream = false
+  end
+
+  attr_reader :name, :verbose, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/tags.rb

@@ -0,0 +1,19 @@
+class Ollama::Commands::Tags
+  def self.path
+    '/api/tags'
+  end
+
+  def initialize(**parameters)
+    parameters.empty? or raise ArgumentError,
+      "Invalid parameters: #{parameters.keys * ' '}"
+    @stream = false
+  end
+
+  attr_reader :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :get, path: self.class.path, stream:, handler:)
+  end
+end

data/lib/ollama/dto.rb

@@ -0,0 +1,42 @@
+module Ollama::DTO
+  extend Tins::Concern
+
+  included do
+    self.attributes = Set.new
+  end
+
+  module ClassMethods
+    attr_accessor :attributes
+
+    def json_create(object)
+      new(**object.transform_keys(&:to_sym))
+    end
+
+    def attr_reader(*names)
+      super
+      attributes.merge(names.map(&:to_sym))
+    end
+  end
+
+  def as_array_of_hashes(obj)
+    if obj.respond_to?(:to_hash)
+      [ obj.to_hash ]
+    elsif obj.respond_to?(:to_ary)
+      obj.to_ary.map(&:to_hash)
+    end
+  end
+
+  def as_json(*)
+    {
+      json_class: self.class.name
+    }.merge(
+      self.class.attributes.each_with_object({}) { |a, h| h[a] = send(a) }
+    ).reject { _2.nil? || _2.ask_and_send(:size) == 0 }
+  end
+
+  alias to_hash as_json
+
+  def to_json(*)
+    as_json.to_json(*)
+  end
+end

data/lib/ollama/errors.rb

@@ -0,0 +1,15 @@
+module Ollama
+  module Errors
+    class Error < StandardError
+    end
+
+    class NotFoundError < Error
+    end
+
+    class TimeoutError < Error
+    end
+
+    class SocketError < Error
+    end
+  end
+end

data/lib/ollama/handlers/collector.rb

@@ -0,0 +1,17 @@
+class Ollama::Handlers::Collector
+  include Ollama::Handlers::Concern
+
+  def initialize(output: $stdout)
+    super
+    @array = []
+  end
+
+  def call(response)
+    @array << response
+    self
+  end
+
+  def result
+    @array
+  end
+end

data/lib/ollama/handlers/concern.rb

@@ -0,0 +1,31 @@
+require 'tins/concern'
+require 'tins/implement'
+
+module Ollama::Handlers::Concern
+  extend Tins::Concern
+  extend Tins::Implement
+
+  def initialize(output: $stdout)
+    @output = output
+  end
+
+  attr_reader :output
+
+  attr_reader :result
+
+  implement :call
+
+  def to_proc
+    -> response { call(response) }
+  end
+
+  module ClassMethods
+    def call(response)
+      new.call(response)
+    end
+
+    def to_proc
+      new.to_proc
+    end
+  end
+end

data/lib/ollama/handlers/dump_json.rb

@@ -0,0 +1,8 @@
+class Ollama::Handlers::DumpJSON
+  include Ollama::Handlers::Concern
+
+  def call(response)
+    @output.puts JSON::pretty_generate(response, allow_nan: true, max_nesting: false)
+    self
+  end
+end

data/lib/ollama/handlers/dump_yaml.rb

@@ -0,0 +1,8 @@
+class Ollama::Handlers::DumpYAML
+  include Ollama::Handlers::Concern
+
+  def call(response)
+    @output.puts Psych.dump(response)
+    self
+  end
+end

data/lib/ollama/handlers/markdown.rb

@@ -0,0 +1,22 @@
+require 'term/ansicolor'
+
+class Ollama::Handlers::Markdown
+  include Ollama::Handlers::Concern
+  include Term::ANSIColor
+
+  def initialize(output: $stdout)
+    super
+    @output.sync = true
+    @content = ''
+  end
+
+  def call(response)
+    if content = response.response || response.message&.content
+      @content << content
+      markdown_content = Ollama::Utils::ANSIMarkdown.parse(@content)
+      @output.print clear_screen, move_home, markdown_content
+    end
+    response.done and @output.puts
+    self
+  end
+end

data/lib/ollama/handlers/nop.rb

@@ -0,0 +1,7 @@
+class Ollama::Handlers::NOP
+  include Ollama::Handlers::Concern
+
+  def call(response)
+    self
+  end
+end

data/lib/ollama/handlers/print.rb

@@ -0,0 +1,16 @@
+class Ollama::Handlers::Print
+  include Ollama::Handlers::Concern
+
+  def initialize(output: $stdout)
+    super
+    @output.sync = true
+  end
+
+  def call(response)
+    if content = response.response || response.message&.content
+      @output.print content
+    end
+    response.done and @output.puts
+    self
+  end
+end

data/lib/ollama/handlers/progress.rb

@@ -0,0 +1,36 @@
+require 'infobar'
+
+class Ollama::Handlers::Progress
+  include Ollama::Handlers::Concern
+  include Term::ANSIColor
+
+  def initialize(output: $stdout)
+    super
+    @current     = 0
+    @total       = nil
+    @last_status = nil
+  end
+
+  def call(response)
+    infobar.display.output = @output
+    status = response.status
+    if response.total && response.completed
+      if !@last_status or @last_status != status
+        @last_status and infobar.newline
+        @last_status = status
+        @current = 0
+        @total = response.total
+        infobar.counter.reset(total: @total, current: @current)
+      end
+      infobar.counter.progress(by: response.completed - @current)
+      @current = response.completed
+    end
+    if status
+      infobar.label = status
+      infobar.update(message: '%l %c/%t in %te, ETA %e @%E', force: true)
+    elsif error = response.error
+      infobar.puts bold { "Error: " } + red { error }
+    end
+    self
+  end
+end

data/lib/ollama/handlers/say.rb

@@ -0,0 +1,19 @@
+require 'shellwords'
+
+class Ollama::Handlers::Say
+  include Ollama::Handlers::Concern
+
+  def initialize(output: nil, voice: 'Samantha')
+    output ||= IO.popen(Shellwords.join([ 'say', '-v', voice ]), 'w')
+    super(output:)
+    @output.sync = true
+  end
+
+  def call(response)
+    if content = response.response || response.message&.content
+      @output.print content
+    end
+    response.done and @output.close
+    self
+  end
+end

data/lib/ollama/handlers/single.rb

@@ -0,0 +1,17 @@
+class Ollama::Handlers::Single
+  include Ollama::Handlers::Concern
+
+  def initialize(output: $stdout)
+    super
+    @array = []
+  end
+
+  def call(response)
+    @array << response
+    self
+  end
+
+  def result
+    @array.size <= 1 ? @array.first : @array
+  end
+end

data/lib/ollama/handlers.rb

@@ -0,0 +1,13 @@
+module Ollama::Handlers
+end
+
+require 'ollama/handlers/concern'
+require 'ollama/handlers/collector'
+require 'ollama/handlers/nop'
+require 'ollama/handlers/single'
+require 'ollama/handlers/markdown'
+require 'ollama/handlers/progress'
+require 'ollama/handlers/print'
+require 'ollama/handlers/dump_json'
+require 'ollama/handlers/dump_yaml'
+require 'ollama/handlers/say'

data/lib/ollama/image.rb

@@ -0,0 +1,31 @@
+require 'base64'
+
+class Ollama::Image
+  def initialize(data)
+    @data = data
+  end
+
+  class << self
+    def for_base64(data)
+      new(data)
+    end
+
+    def for_string(string)
+      for_base64(Base64.encode64(string))
+    end
+
+    def for_io(io)
+      for_string(io.read)
+    end
+
+    def for_filename(path)
+      File.open(path, 'rb') { |io| for_io(io) }
+    end
+
+    private :new
+  end
+
+  def to_s
+    @data
+  end
+end

data/lib/ollama/message.rb

@@ -0,0 +1,9 @@
+class Ollama::Message
+  include Ollama::DTO
+
+  attr_reader :role, :content, :images
+
+  def initialize(role:, content:, images: nil, **)
+    @role, @content, @images = role, content, (Array(images) if images)
+  end
+end

data/lib/ollama/options.rb

@@ -0,0 +1,68 @@
+# Options are explained in the parameters for the modelfile:
+# https://github.com/ollama/ollama/blob/main/docs/modelfile.md#parameter
+class Ollama::Options
+  include Ollama::DTO
+
+  @@types = {
+    numa:              [ false, true ],
+    num_ctx:           Integer,
+    num_batch:         Integer,
+    num_gpu:           Integer,
+    main_gpu:          Integer,
+    low_vram:          [ false, true ],
+    f16_kv:            [ false, true ],
+    logits_all:        [ false, true ],
+    vocab_only:        [ false, true ],
+    use_mmap:          [ false, true ],
+    use_mlock:         [ false, true ],
+    num_thread:        Integer,
+    num_keep:          Integer,
+    seed:              Integer,
+    num_predict:       Integer,
+    top_k:             Integer,
+    top_p:             Float,
+    min_p:             Float,
+    tfs_z:             Float,
+    typical_p:         Float,
+    repeat_last_n:     Integer,
+    temperature:       Float,
+    repeat_penalty:    Float,
+    presence_penalty:  Float,
+    frequency_penalty: Float,
+    mirostat:          Integer,
+    mirostat_tau:      Float,
+    mirostat_eta:      Float,
+    penalize_newline:  [ false, true ],
+    stop:              Array,
+  }
+
+  @@types.each do |name, type|
+    attr_reader name
+
+    define_method("#{name}=") do |value|
+      instance_variable_set(
+        "@#{name}",
+        if value.nil?
+          nil
+        else
+          case type
+          when Class
+            send(type.name, value)
+          when Array
+            if type.include?(value)
+              value
+            else
+              raise TypeError, "#{value} not in #{type * ?|}"
+            end
+          end
+        end
+      )
+    end
+  end
+
+  class_eval %{
+    def initialize(#{@@types.keys.map { "#{_1}: nil" }.join(', ') + ', **'})
+      #{@@types.keys.map { "self.#{_1} = #{_1}" }.join(?\n)}
+    end
+  }
+end

data/lib/ollama/response.rb

@@ -0,0 +1,5 @@
+class Ollama::Response < JSON::GenericObject
+  def as_json(*)
+    to_hash
+  end
+end

data/lib/ollama/tool/function/parameters/property.rb

@@ -0,0 +1,9 @@
+class Ollama::Tool::Function::Parameters::Property
+  include Ollama::DTO
+
+  attr_reader :type, :description, :enum
+
+  def initialize(type:, description:, enum: nil)
+    @type, @description, @enum = type, description, Array(enum)
+  end
+end

data/lib/ollama/tool/function/parameters.rb

@@ -0,0 +1,10 @@
+class Ollama::Tool::Function::Parameters
+  include Ollama::DTO
+
+  attr_reader :type, :properties, :required
+
+  def initialize(type:, properties:, required:)
+    @type, @properties, @required =
+      type, Hash(properties).transform_values(&:to_hash), Array(required)
+  end
+end

data/lib/ollama/tool/function.rb

@@ -0,0 +1,11 @@
+class Ollama::Tool::Function
+  include Ollama::DTO
+
+  attr_reader :name, :description, :parameters, :required
+
+  def initialize(name:, description:, parameters: nil, required: nil)
+    @name, @description, @parameters, @required =
+      name, description, (Hash(parameters) if parameters),
+      (Array(required) if required)
+  end
+end

data/lib/ollama/tool.rb

@@ -0,0 +1,9 @@
+class Ollama::Tool
+  include Ollama::DTO
+
+  attr_reader :type, :function
+
+  def initialize(type:, function:)
+    @type, @function = type, function.to_hash
+  end
+end

data/lib/ollama/utils/ansi_markdown.rb

@@ -0,0 +1,217 @@
+require 'kramdown'
+require 'kramdown-parser-gfm'
+require 'terminal-table'
+
+class Ollama::Utils::ANSIMarkdown < Kramdown::Converter::Base
+  include Term::ANSIColor
+  include Ollama::Utils::Width
+
+  class ::Kramdown::Parser::Mygfm <  ::Kramdown::Parser::GFM
+    def initialize(source, options)
+      options[:gfm_quirks] << :no_auto_typographic
+      super
+      @block_parsers -= %i[
+        definition_list block_html block_math
+        footnote_definition abbrev_definition
+      ]
+      @span_parsers -= %i[ footnote_marker inline_math ]
+    end
+  end
+
+  def self.parse(source)
+    @doc = Kramdown::Document.new(
+      source, input: :mygfm, auto_ids: false, entity_output: :as_char
+    ).to_ansi
+  end
+
+  def initialize(root, options)
+    super
+  end
+
+  def convert(el, opts = {})
+    send("convert_#{el.type}", el, opts)
+  end
+
+  def inner(el, opts, &block)
+    result = +''
+    options = opts.dup.merge(parent: el)
+    el.children.each_with_index do |inner_el, index|
+      options[:index] = index
+      options[:result] = result
+      begin
+        content = send("convert_#{inner_el.type}", inner_el, options)
+        result << (block&.(inner_el, index, content) || content)
+      rescue NameError => e
+        warning "Caught #{e.class} for #{inner_el.type}"
+      end
+    end
+    result
+  end
+
+  def convert_root(el, opts)
+    inner(el, opts)
+  end
+
+  def convert_blank(_el, opts)
+    opts[:result] =~ /\n\n\Z|\A\Z/ ? "" : "\n"
+  end
+
+  def convert_text(el, _opts)
+    el.value
+  end
+
+  def convert_header(el, opts)
+    newline bold { underline { inner(el, opts) } }
+  end
+
+  def convert_p(el, opts)
+    length = width(percentage: 90) - opts[:list_indent].to_i
+    length < 0 and return ''
+    newline wrap(inner(el, opts), length:)
+  end
+
+  def convert_strong(el, opts)
+    bold { inner(el, opts) }
+  end
+
+  def convert_em(el, opts)
+    italic { inner(el, opts) }
+  end
+
+  def convert_a(el, opts)
+    url = el.attr['href']
+    hyperlink(url) { inner(el, opts) }
+  end
+
+  def convert_codespan(el, _opts)
+    blue { el.value }
+  end
+
+  def convert_codeblock(el, _opts)
+    blue { el.value }
+  end
+
+  def convert_blockquote(el, opts)
+    newline ?“ + inner(el, opts).sub(/\n+\z/, '') + ?”
+  end
+
+  def convert_hr(_el, _opts)
+    newline ?─ * width(percentage: 100)
+  end
+
+  def convert_img(el, _opts)
+    url = el.attr['src']
+    alt = el.attr['alt']
+    alt.strip.size == 0 and alt = url
+    alt = '🖼 ' + alt
+    hyperlink(url) { alt }
+  end
+
+  def convert_ul(el, opts)
+    list_indent = opts[:list_indent].to_i
+    inner(el, opts) { |_inner_el, index, content|
+      result = '· %s' % content
+      result = newline(result, count: index <= el.children.size - 1 ? 1 : 2)
+      result.gsub(/^/, ' ' * list_indent)
+    }
+  end
+
+  def convert_ol(el, opts)
+    list_indent = opts[:list_indent].to_i
+    inner(el, opts) { |_inner_el, index, content|
+      result = '%u. %s' % [ index + 1, content ]
+      result = newline(result, count: index <= el.children.size - 1 ? 1 : 2)
+      result.gsub(/^/, ' ' * list_indent)
+    }
+  end
+
+  def convert_li(el, opts)
+    opts = opts.dup
+    opts[:list_indent] = 2 + opts[:list_indent].to_i
+    newline inner(el, opts).sub(/\n+\Z/, '')
+  end
+
+  def convert_html_element(el, opts)
+    if el.value == 'i' || el.value == 'em'
+      italic { inner(el, opts) }
+    elsif el.value == 'b' || el.value == 'strong'
+      bold { inner(el, opts) }
+    else
+      ''
+    end
+  end
+
+  def convert_table(el, opts)
+    table = Terminal::Table.new
+    table.style = {
+      all_separators: true,
+      border: :unicode_round,
+    }
+    opts[:table] = table
+    inner(el, opts)
+    el.options[:alignment].each_with_index do |a, i|
+      a == :default and next
+      opts[:table].align_column(i, a)
+    end
+    newline table.to_s
+  end
+
+  def convert_thead(el, opts)
+    rows = inner(el, opts)
+    rows = rows.split(/\s*\|\s*/)[1..].map(&:strip)
+    opts[:table].headings = rows
+    ''
+  end
+
+  def convert_tbody(el, opts)
+    res = +''
+    res << inner(el, opts)
+  end
+
+  def convert_tfoot(el, opts)
+    ''
+  end
+
+  def convert_tr(el, opts)
+    return '' if el.children.empty?
+    full_width = width(percentage: 90)
+    cols = el.children.map { |c| convert(c, opts).strip }
+    row_size = cols.sum(&:size)
+    return '' if row_size.zero?
+    opts[:table] << cols.map { |c|
+      length = (full_width * (c.size / row_size.to_f)).floor
+      wrap(c, length:)
+    }
+    ''
+  end
+
+  def convert_td(el, opts)
+    inner(el, opts)
+  end
+
+  def convert_entity(el, _opts)
+    el.value.char
+  end
+
+  def convert_xml_comment(*)
+    ''
+  end
+
+  def convert_xml_pi(*)
+    ''
+  end
+
+  def convert_br(_el, opts)
+    ''
+  end
+
+  def convert_smart_quote(el, _opts)
+    el.value.to_s =~ /[rl]dquo/ ? "\"" : "'"
+  end
+
+  def newline(text, count: 1)
+    text.gsub(/\n*\z/, ?\n * count)
+  end
+end
+
+Kramdown::Converter.const_set(:Ansi, Ollama::Utils::ANSIMarkdown)