ollama-ai 1.0.0

data/components/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ollama
+  module Errors
+    class OllamaError < StandardError
+      def initialize(message = nil)
+        super(message)
+      end
+    end
+
+    class BlockWithoutServerSentEventsError < OllamaError; end
+
+    class RequestError < OllamaError
+      attr_reader :request, :payload
+
+      def initialize(message = nil, request: nil, payload: nil)
+        @request = request
+        @payload = payload
+
+        super(message)
+      end
+    end
+  end
+end

data/controllers/client.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+require_relative '../ports/dsl/ollama-ai/errors'
+
+module Ollama
+  module Controllers
+    class Client
+      DEFAULT_ADDRESS = 'http://localhost:11434'
+
+      ALLOWED_REQUEST_OPTIONS = %i[timeout open_timeout read_timeout write_timeout].freeze
+
+      def initialize(config)
+        @server_sent_events = config.dig(:options, :server_sent_events)
+
+        @address = if config[:credentials][:address].nil? || config[:credentials][:address].to_s.strip.empty?
+                     "#{DEFAULT_ADDRESS}/"
+                   else
+                     "#{config[:credentials][:address].to_s.sub(%r{/$}, '')}/"
+                   end
+
+        @request_options = config.dig(:options, :connection, :request)
+
+        @request_options = if @request_options.is_a?(Hash)
+                             @request_options.select do |key, _|
+                               ALLOWED_REQUEST_OPTIONS.include?(key)
+                             end
+                           else
+                             {}
+                           end
+      end
+
+      def generate(payload, server_sent_events: nil, &callback)
+        request('api/generate', payload, server_sent_events:, &callback)
+      end
+
+      def chat(payload, server_sent_events: nil, &callback)
+        request('api/chat', payload, server_sent_events:, &callback)
+      end
+
+      def create(payload, server_sent_events: nil, &callback)
+        request('api/create', payload, server_sent_events:, &callback)
+      end
+
+      def tags(server_sent_events: nil, &callback)
+        request('api/tags', nil, server_sent_events:, request_method: 'GET', &callback)
+      end
+
+      def show(payload, server_sent_events: nil, &callback)
+        request('api/show', payload, server_sent_events:, &callback)
+      end
+
+      def copy(payload, server_sent_events: nil, &callback)
+        request('api/copy', payload, server_sent_events:, &callback)
+        true
+      end
+
+      def delete(payload, server_sent_events: nil, &callback)
+        request('api/delete', payload, server_sent_events:, request_method: 'DELETE', &callback)
+        true
+      end
+
+      def pull(payload, server_sent_events: nil, &callback)
+        request('api/pull', payload, server_sent_events:, &callback)
+      end
+
+      def push(payload, server_sent_events: nil, &callback)
+        request('api/push', payload, server_sent_events:, &callback)
+      end
+
+      def embeddings(payload, server_sent_events: nil, &callback)
+        request('api/embeddings', payload, server_sent_events:, &callback)
+      end
+
+      def request(path, payload = nil, server_sent_events: nil, request_method: 'POST', &callback)
+        server_sent_events_enabled = server_sent_events.nil? ? @server_sent_events : server_sent_events
+        url = "#{@address}#{path}"
+
+        if !callback.nil? && !server_sent_events_enabled
+          raise BlockWithoutServerSentEventsError,
+                'You are trying to use a block without Server Sent Events (SSE) enabled.'
+        end
+
+        results = []
+
+        method_to_call = request_method.to_s.strip.downcase.to_sym
+
+        partial_json = ''
+
+        response = Faraday.new(request: @request_options) do |faraday|
+          faraday.response :raise_error
+        end.send(method_to_call) do |request|
+          request.url url
+          request.headers['Content-Type'] = 'application/json'
+
+          request.body = payload.to_json unless payload.nil?
+
+          if server_sent_events_enabled
+            request.options.on_data = proc do |chunk, bytes, env|
+              if env && env.status != 200
+                raise_error = Faraday::Response::RaiseError.new
+                raise_error.on_complete(env.merge(body: chunk))
+              end
+
+              partial_json += chunk
+
+              parsed_json = safe_parse_json(partial_json)
+
+              if parsed_json
+                result = { event: parsed_json, raw: { chunk:, bytes:, env: } }
+
+                callback.call(result[:event], result[:raw]) unless callback.nil?
+
+                results << result
+
+                partial_json = ''
+              end
+            end
+          end
+        end
+
+        return safe_parse_jsonl(response.body) unless server_sent_events_enabled
+
+        results.map { |result| result[:event] }
+      rescue Faraday::Error => e
+        raise RequestError.new(e.message, request: e, payload:)
+      end
+
+      def safe_parse_json(raw)
+        raw.to_s.lstrip.start_with?('{', '[') ? JSON.parse(raw) : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      def safe_parse_jsonl(raw)
+        raw.to_s.lstrip.start_with?('{', '[') ? raw.split("\n").map { |line| JSON.parse(line) } : raw
+      rescue JSON::ParserError
+        raw
+      end
+    end
+  end
+end

data/ollama-ai.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'static/gem'
+
+Gem::Specification.new do |spec|
+  spec.name    = Ollama::GEM[:name]
+  spec.version = Ollama::GEM[:version]
+  spec.authors = [Ollama::GEM[:author]]
+
+  spec.summary = Ollama::GEM[:summary]
+  spec.description = Ollama::GEM[:description]
+
+  spec.homepage = Ollama::GEM[:github]
+
+  spec.license = Ollama::GEM[:license]
+
+  spec.required_ruby_version = Gem::Requirement.new(">= #{Ollama::GEM[:ruby]}")
+
+  spec.metadata['allowed_push_host'] = Ollama::GEM[:gem_server]
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = Ollama::GEM[:github]
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+
+  spec.require_paths = ['ports/dsl']
+
+  spec.add_dependency 'faraday', '~> 2.8'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/ports/dsl/ollama-ai/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../../../components/errors'
+
+include Ollama::Errors

data/ports/dsl/ollama-ai.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../static/gem'
+require_relative '../../controllers/client'
+
+module Ollama
+  def self.new(...)
+    Controllers::Client.new(...)
+  end
+
+  def self.version
+    Ollama::GEM[:version]
+  end
+end

data/static/gem.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ollama
+  GEM = {
+    name: 'ollama-ai',
+    version: '1.0.0',
+    author: 'gbaptista',
+    summary: 'Interact with Ollama API to run open source AI models locally.',
+    description: "A Ruby gem for interacting with Ollama's API that allows you to run open source AI LLMs (Large Language Models) locally.",
+    github: 'https://github.com/gbaptista/ollama-ai',
+    gem_server: 'https://rubygems.org',
+    license: 'MIT',
+    ruby: '3.1.0'
+  }.freeze
+end

data/tasks/generate-readme.clj

@@ -0,0 +1,39 @@
+(require '[clojure.string :as str])
+
+(defn slugify [text]
+  (-> text
+      (clojure.string/lower-case)
+      (clojure.string/replace " " "-")
+      (clojure.string/replace #"[^a-z0-9\-_]" "")))
+
+(defn remove-code-blocks [content]
+  (let [code-block-regex #"(?s)```.*?```"]
+    (clojure.string/replace content code-block-regex "")))
+
+(defn process-line [line]
+  (when-let [[_ hashes title] (re-find #"^(\#{2,}) (.+)" line)]
+    (let [link (slugify title)]
+      {:level (count hashes) :title title :link link})))
+
+(defn create-index [content]
+  (let [processed-content (remove-code-blocks content)
+        processed-lines (->> processed-content
+                             clojure.string/split-lines
+                             (map process-line)
+                             (remove nil?))]
+    (->> processed-lines
+         (map (fn [{:keys [level title link]}]
+                (str (apply str (repeat (* 4 (- level 2)) " "))
+                     "- ["
+                     title
+                     "](#"
+                     link
+                     ")")))
+         (clojure.string/join "\n"))))
+
+
+(let [content         (slurp "template.md")
+      index           (create-index content)
+      updated-content (clojure.string/replace content "{index}" index)]
+  (spit "README.md" updated-content)
+  (println "README.md successfully generated."))