gemini-ai 1.0.0

data/controllers/client.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'event_stream_parser'
+require 'faraday'
+require 'json'
+require 'googleauth'
+
+module Gemini
+  module Controllers
+    class Client
+      def initialize(config)
+        @authorizer = ::Google::Auth::ServiceAccountCredentials.make_creds(
+          json_key_io: File.open(config[:credentials][:file_path]),
+          scope: 'https://www.googleapis.com/auth/cloud-platform'
+        )
+
+        @address = "https://#{config[:credentials][:region]}-aiplatform.googleapis.com/v1/projects/#{config[:credentials][:project_id]}/locations/#{config[:credentials][:region]}/publishers/google/models/#{config[:settings][:model]}"
+
+        @stream = config[:settings][:stream]
+      end
+
+      def stream_generate_content(payload, stream: nil, &callback)
+        request('streamGenerateContent', payload, stream:, &callback)
+      end
+
+      def request(path, payload, stream: nil, &callback)
+        stream_enabled = stream.nil? ? @stream : stream
+        url = "#{@address}:#{path}"
+        url += '?alt=sse' if stream_enabled
+
+        if !callback.nil? && !stream_enabled
+          raise StandardError, 'You are trying to use a block without stream enabled."'
+        end
+
+        results = []
+
+        response = Faraday.new.post do |request|
+          request.url url
+          request.headers['Content-Type'] = 'application/json'
+          request.headers['Authorization'] = "Bearer #{@authorizer.fetch_access_token!['access_token']}"
+          request.body = payload.to_json
+
+          if stream_enabled
+            parser = EventStreamParser::Parser.new
+
+            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
+
+              parser.feed(chunk) do |type, data, id, reconnection_time|
+                parsed_data = safe_parse_json(data)
+                result = {
+                  event: safe_parse_json(data),
+                  parsed: { type:, data:, id:, reconnection_time: },
+                  raw: { chunk:, bytes:, env: }
+                }
+
+                callback.call(result[:event], result[:parsed], result[:raw]) unless callback.nil?
+
+                results << result
+
+                parsed_data['candidates'].find do |candidate|
+                  !candidate['finishReason'].nil? && candidate['finishReason'] != ''
+                end
+              end
+            end
+          end
+        end
+
+        return safe_parse_json(response.body) unless stream_enabled
+
+        results.map { |result| result[:event] }
+      end
+
+      def safe_parse_json(raw)
+        raw.start_with?('{', '[') ? JSON.parse(raw) : raw
+      rescue JSON::ParserError
+        raw
+      end
+    end
+  end
+end

data/gemini-ai.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'static/gem'
+
+Gem::Specification.new do |spec|
+  spec.name    = Gemini::GEM[:name]
+  spec.version = Gemini::GEM[:version]
+  spec.authors = [Gemini::GEM[:author]]
+
+  spec.summary = Gemini::GEM[:summary]
+  spec.description = Gemini::GEM[:description]
+
+  spec.homepage = Gemini::GEM[:github]
+
+  spec.license = Gemini::GEM[:license]
+
+  spec.required_ruby_version = Gem::Requirement.new(">= #{Gemini::GEM[:ruby]}")
+
+  spec.metadata['allowed_push_host'] = Gemini::GEM[:gem_server]
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = Gemini::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 'event_stream_parser', '~> 1.0'
+  spec.add_dependency 'faraday', '~> 2.7', '>= 2.7.12'
+  spec.add_dependency 'googleauth', '~> 1.9', '>= 1.9.1'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/ports/dsl/gemini-ai.rb

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

data/static/gem.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Gemini
+  GEM = {
+    name: 'gemini-ai',
+    version: '1.0.0',
+    author: 'gbaptista',
+    summary: "Interact with Google's Gemini AI.",
+    description: "A Ruby Gem for interacting with Gemini through Vertex AI, Google's generative AI service.",
+    github: 'https://github.com/gbaptista/gemini-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."))