word_smith 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7dc1f6956a9ee72a61859869da8f0413fe26fdc42ad306e68dbce28f184cbb55
+  data.tar.gz: 1c8563f63c8ed9febfb1a332d4fbf69400642590ed86b658675c233a58c4c4c9
+SHA512:
+  metadata.gz: 4888cd0c6ebabdd9ba9416aa6d4a8decc4647b89db7d2c5edcbb404b0670e773ed51717821c597d648a058d8b01bb3b53006f30f87405d9e3a9ba7cd12f48de9
+  data.tar.gz: 490683d03531c59041cecd173bf0b1b03c69136debd215e6b6bf2f022df3c2e87b8cddeeffbf508b0e8449994b6c9eaf706a5fb9786a888d2f5e5d7a8447da01

data/bin/ws

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/index.rb"
+
+WordSmith::run(ARGV)

data/lib/command_runner/index.rb

@@ -0,0 +1,156 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative '../../version'
+require_relative '../services/open_a_i'
+require_relative '../helpers/str'
+require_relative 'translation'
+require 'sorbet-runtime'
+
+module WordSmith
+  module CommandRunner
+    class ArgumentError < StandardError; end
+    class BadPermutationOfArgumentsError < ArgumentError; end
+
+    class << self
+      extend T::Sig
+
+      EXECUTABLE_NAME = 'ws'
+      OPENAI_API_KEY_COMMAND = '--set-openai-api-key'
+      OPENAI_ORG_ID_COMMAND = '--set-openai-org-id'
+
+      class Options < T::Struct
+        prop :no_cache, T::Boolean
+        prop :file_path, T.nilable(String)
+        prop :target_language, T.nilable(String)
+      end
+
+      sig { params(args: T::Array[String]).void }
+      def run(args)
+        args_clone = args.clone
+        options = Options.new(no_cache: false, file_path: nil, target_language: nil)
+
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: #{EXECUTABLE_NAME} [word] [options...]"
+
+          opts.on('-f', '--file [FILE_PATH]', 'Read words from a file') do |file_path|
+            options.file_path = file_path
+          end
+
+          opts.on('--target-language [LANGUAGE_CODE]',
+                  'If you want to translate the word to a specific language, specify the language. e.g: Spanish') do |target_language|
+            options.target_language = target_language
+          end
+
+          opts.on("#{OPENAI_API_KEY_COMMAND} [key]", 'Set the OpenAI API key') do |key|
+            store_open_a_i_api_key(key)
+
+            exit
+          end
+
+          opts.on("#{OPENAI_ORG_ID_COMMAND} [key]", 'Set the OpenAI Org ID') do |key|
+            store_open_a_i_org_id(key)
+
+            exit
+          end
+
+          opts.on('--no-cache', 'Translate word without using cache') do
+            options.no_cache = true
+          end
+
+          opts.on_tail('-h', '--help', 'Show help') do
+            print_help(opts)
+
+            exit
+          end
+
+          opts.on_tail('-v', '--version', 'Show version') do
+            print_version
+
+            exit
+          end
+        end
+
+        parser.parse!(args_clone)
+
+        input_text = args_clone.join(' ').chomp
+
+        if !input_text.empty? && !options.file_path.nil?
+          raise BadPermutationOfArgumentsError, 'Both word and file path cannot be provided'
+        end
+
+        raise ArgumentError, 'No word or file path provided' if input_text.empty? && options.file_path.nil?
+
+        translation_options = {
+          no_cache: options.no_cache,
+          target_language: options.target_language
+        }
+
+        unless options.file_path.nil?
+          raise ArgumentError, "File not found: #{options.file_path}" unless File.exist?(options.file_path)
+
+          File.readlines(T.must(options.file_path)).each_with_index do |line, index|
+            puts Rainbow('-' * 60).yellow.bright unless index.zero?
+
+            Translation.run(line, translation_options)
+          end
+
+          return
+        end
+
+        Translation.run(input_text, translation_options)
+      end
+
+      private
+
+      sig { params(opts: OptionParser).void }
+      def print_help(opts)
+        puts Helpers::Str.lstr_every_line("
+          Translate words, phrases and words in context of a sentence.
+
+          -> To translate a word or a phrase, just run:
+            #{Rainbow(EXECUTABLE_NAME + ' [word/phrase]').blue.bold}
+
+          -> To translate a word in context of a sentence, you should write the sentence and wrap the word in slashes:
+            #{Rainbow(EXECUTABLE_NAME + ' a /random/ sentence').blue.bold}
+            In this example, the word 'random' will be translated in context of the sentence.
+
+          #{Rainbow('----------------------------------------').yellow.bright}
+        ")
+
+        puts '', opts
+
+        return unless WordSmith::Services::OpenAI.api_key.nil?
+
+        return unless WordSmith::Services::OpenAI.api_key.nil?
+
+        open_a_i_message = T.let("
+                To use OpenAI, you need to set an API key and Org ID.
+                You can set the API key using '#{EXECUTABLE_NAME} #{OPENAI_API_KEY_COMMAND} <key>'
+                You can set the Org ID using '#{EXECUTABLE_NAME} #{OPENAI_ORG_ID_COMMAND} <key>'
+              ", String)
+        puts '', WordSmith::Helpers::Str.lstr_every_line(open_a_i_message)
+      end
+
+      sig { void }
+      def print_version
+        puts "Version #{WordSmith::VERSION}"
+      end
+
+      sig { params(key: String).void }
+      def store_open_a_i_api_key(key)
+        WordSmith::Services::OpenAI.store_api_key(key)
+
+        puts 'OpenAI API key set!'
+      end
+
+      sig { params(key: String).void }
+      def store_open_a_i_org_id(key)
+        WordSmith::Services::OpenAI.store_org_id(key)
+
+        puts 'OpenAI Org ID set!'
+      end
+    end
+  end
+end

data/lib/command_runner/translation.rb

@@ -0,0 +1,123 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require_relative '../services/open_a_i'
+require_relative '../models/word'
+require_relative '../services/logger'
+
+module WordSmith
+  module CommandRunner
+    module Translation
+      class << self
+        extend T::Sig
+
+        sig { params(input_text: String, options: { no_cache: T::Boolean, target_language: T.nilable(String) }).void }
+        def run(input_text, options)
+          is_contextual_translation = input_text.match?(%r{/[a-zA-Z]+/})
+
+          if is_contextual_translation
+            sentence = input_text.gsub(%r{/([a-zA-Z]+)/}, '\1')
+
+            literal_word_match = input_text.match(%r{/([a-zA-Z]+)/})
+            raise "Invalid word: #{input_text}" if literal_word_match.nil?
+
+            word = T.cast(literal_word_match.captures[0], String)
+
+            result = find_or_create_contextual_translation(word, sentence, **options)
+
+            puts '', "In context of \"#{Rainbow(sentence).blue.bold}\":"
+
+            print_common_parts(result)
+
+            return
+          end
+
+          word = input_text.chomp
+
+          result = find_or_create_word_translation(word, **options)
+
+          print_common_parts(result)
+        end
+
+        private
+
+        sig do
+          params(word: String, no_cache: T::Boolean, target_language: T.nilable(String)).returns(Models::Word)
+        end
+        def find_or_create_word_translation(word, no_cache: false, target_language: nil)
+          existing_word = Models::Word.find_by_word(word)
+
+          unless no_cache || existing_word.nil?
+            Services::Logger.debug_log("Found existing word: #{existing_word.word}")
+
+            return existing_word
+          end
+
+          Services::Logger.debug_log("Translating the word: #{word}")
+
+          result = Services::OpenAI.new.translate(text: word, target_language: target_language)
+
+          if existing_word.nil?
+            Services::Logger.debug_log("Creating new word: #{word}")
+
+            return Models::Word.create(word: word, pronunciation: result[:pronunciation], meaning: result[:meaning],
+                                       example: result[:example], target_language: target_language,
+                                       translation_to_target_language: result[:translation_to_target_language])
+          end
+
+          Services::Logger.debug_log("Updating existing word: #{word}")
+
+          existing_word.update(word: word, pronunciation: result[:pronunciation], meaning: result[:meaning],
+                               example: result[:example], target_language: target_language,
+                               translation_to_target_language: result[:translation_to_target_language])
+        end
+
+        sig do
+          params(word: String, sentence: String, no_cache: T::Boolean,
+                 target_language: T.nilable(String)).returns(Models::Word)
+        end
+        def find_or_create_contextual_translation(word, sentence, no_cache: false, target_language: nil)
+          existing_word = Models::Word.find_by_word(word)
+
+          unless no_cache || existing_word.nil?
+            Services::Logger.debug_log("Found existing word: #{existing_word.word}")
+
+            return existing_word
+          end
+
+          Services::Logger.debug_log("Translating the word: #{word}")
+
+          result = Services::OpenAI.new.translate_in_context_of_sentence(word: word, sentence: sentence,
+                                                                         target_language: target_language)
+
+          if existing_word.nil?
+            Services::Logger.debug_log("Creating new word: #{word}")
+
+            return Models::Word.create(word: word, pronunciation: result[:pronunciation], meaning: result[:meaning],
+                                       example: result[:example], target_language: target_language,
+                                       translation_to_target_language: result[:translation_to_target_language])
+          end
+
+          Services::Logger.debug_log("Updating existing word: #{word}")
+
+          existing_word.update(word: word, pronunciation: result[:pronunciation], meaning: result[:meaning],
+                               example: result[:example], target_language: target_language,
+                               translation_to_target_language: result[:translation_to_target_language])
+        end
+
+        sig { params(word: Models::Word).void }
+        def print_common_parts(word)
+          puts '', "#{Rainbow(word.word).green.bold}#{Rainbow(" (#{word.pronunciation})").blue}", "\n"
+          puts " #{Rainbow('Meaning:').bold}#{Rainbow(" #{word.meaning}").blue}", "\n"
+          puts " #{Rainbow('Example:').bold}#{Rainbow(" #{word.example}").blue}", "\n"
+
+          return if word.translation_to_target_language.nil?
+
+          puts " #{Rainbow('Translation to target language:').bold}#{Rainbow(" #{word.translation_to_target_language}").blue}",
+               "\n"
+        end
+      end
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,5 @@
+module WordSmith
+  module Config
+    DEBUG_MODE = ENV['DEBUG'] == 'true'
+  end
+end

data/lib/helpers/logo_visualizer.rb

@@ -0,0 +1,14 @@
+module WordSmith
+  module Helpers
+    module LogoVisualizer
+      def self.draw
+        puts Rainbow("
+        ▗▖ ▗▖ ▗▄▖ ▗▄▄▖ ▗▄▄▄      ▗▄▄▖▗▖  ▗▖▗▄▄▄▖▗▄▄▄▖▗▖ ▗▖
+        ▐▌ ▐▌▐▌ ▐▌▐▌ ▐▌▐▌  █    ▐▌   ▐▛▚▞▜▌  █    █  ▐▌ ▐▌
+        ▐▌ ▐▌▐▌ ▐▌▐▛▀▚▖▐▌  █     ▝▀▚▖▐▌  ▐▌  █    █  ▐▛▀▜▌
+        ▐▙█▟▌▝▚▄▞▘▐▌ ▐▌▐▙▄▄▀    ▗▄▄▞▘▐▌  ▐▌▗▄█▄▖  █  ▐▌ ▐▌
+        ").blue.bold
+      end
+    end
+  end
+end

data/lib/helpers/str.rb

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module WordSmith
+  module Helpers
+    module Str
+      extend T::Sig
+
+      sig { params(string: String).returns(String) }
+      def self.lstr_every_line(string)
+        string.split("\n").map(&:lstrip).join("\n")
+      end
+    end
+  end
+end

data/lib/index.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+require_relative 'command_runner/index'
+require_relative 'services/logger'
+require_relative 'migrations/index'
+require_relative 'helpers/logo_visualizer'
+module WordSmith
+  class << self
+    extend T::Sig
+
+    sig { params(args: T::Array[String]).void }
+    def run(args)
+      Helpers::LogoVisualizer.draw
+
+      run_migrations
+
+      CommandRunner.run(args)
+    rescue CommandRunner::ArgumentError => e
+      puts e.message
+
+      exit 1
+    end
+
+    private
+
+    def run_migrations
+      Services::Logger.debug_log('Running migrations...')
+
+      Migrations.run
+
+      Services::Logger.debug_log('Migrations complete.')
+    end
+  end
+end

data/lib/migrations/1_words.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative '../services/db'
+
+module WordSmith
+  module Migrations
+    class Words
+      def self.up
+        Services::DB.instance.execute <<-SQL
+          CREATE TABLE IF NOT EXISTS words (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            word TEXT NOT NULL,
+            pronunciation TEXT NOT NULL,
+            meaning TEXT NOT NULL,
+            example TEXT NOT NULL,
+            context TEXT DEFAULT NULL,
+            target_language TEXT DEFAULT NULL,
+            translation_to_target_language TEXT DEFAULT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          )
+        SQL
+      end
+    end
+  end
+end

data/lib/migrations/index.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module WordSmith
+  module Migrations
+    class << self
+      extend T::Sig
+
+      sig { void }
+      def run
+        Dir.glob(File.join(__dir__, './*.rb')).each do |file| # rubocop:disable Lint/NonDeterministicRequireOrder
+          next if file == __FILE__
+
+          require_relative file
+        end
+
+        WordSmith::Migrations.constants.each do |constant|
+          WordSmith::Migrations.const_get(constant).up
+        end
+      end
+    end
+  end
+end

data/lib/models/word.rb

@@ -0,0 +1,134 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative '../services/db'
+require 'sorbet-runtime'
+
+module WordSmith
+  module Models
+    class Word
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :id
+
+      sig { returns(String) }
+      attr_reader :word
+
+      sig { returns(String) }
+      attr_reader :pronunciation
+
+      sig { returns(String) }
+      attr_reader :meaning
+
+      sig { returns(String) }
+      attr_reader :example
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :context
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target_language
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :translation_to_target_language
+
+      sig do
+        params(id: Integer, word: String, pronunciation: String, meaning: String, example: String,
+               context: T.nilable(String), target_language: T.nilable(String),
+               translation_to_target_language: T.nilable(String)).void
+      end
+      def initialize(
+        id:,
+        word:,
+        pronunciation:,
+        meaning:,
+        example:,
+        context: nil,
+        target_language: nil,
+        translation_to_target_language: nil
+      )
+        @id = id
+        @word = word
+        @pronunciation = pronunciation
+        @meaning = meaning
+        @example = example
+        @context = context
+        @target_language = target_language
+        @translation_to_target_language = translation_to_target_language
+      end
+
+      sig { void }
+      def delete
+        Services::DB.instance.execute('DELETE FROM words WHERE id = ?', [@id])
+      end
+
+      sig do
+        params(word: String, pronunciation: String, meaning: String, example: String,
+               context: T.nilable(String), target_language: T.nilable(String),
+               translation_to_target_language: T.nilable(String)).returns(Word)
+      end
+      def update(word:, pronunciation:, meaning:, example:, context: nil, target_language: nil,
+                 translation_to_target_language: nil)
+        result = Services::DB.instance.execute('UPDATE words SET word = ?, pronunciation = ?, meaning = ?, example = ?, context = ?, target_language = ?, translation_to_target_language = ? WHERE id = ? RETURNING *',
+                                               [word, pronunciation, meaning, example, context, target_language,
+                                                translation_to_target_language, @id]).first
+
+        @word = result[1]
+        @pronunciation = result[2]
+        @meaning = result[3]
+        @example = result[4]
+        @context = result[5]
+        @target_language = result[6]
+        @translation_to_target_language = result[7]
+
+        self
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Array[Word]) }
+        def all
+          Services::DB.instance.execute('SELECT id, word, pronunciation, meaning, example, context, target_language, translation_to_target_language FROM words').map do |row|
+            new(id: row[0], word: row[1], pronunciation: row[2], meaning: row[3], example: row[4], context: row[5],
+                target_language: row[6], translation_to_target_language: row[7])
+          end
+        end
+
+        sig do
+          params(word: String, pronunciation: String, meaning: String, example: String,
+                 context: T.nilable(String), target_language: T.nilable(String),
+                 translation_to_target_language: T.nilable(String)).returns(Word)
+        end
+        def create(word:, pronunciation:, meaning:, example:, context: nil, target_language: nil,
+                   translation_to_target_language: nil)
+          result = Services::DB.instance.execute('INSERT INTO words (word, pronunciation, meaning, example, context, target_language, translation_to_target_language) VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING *',
+                                                 [word, pronunciation, meaning, example, context, target_language,
+                                                  translation_to_target_language]).first
+
+          new(id: result[0], word: result[1], pronunciation: result[2], meaning: result[3], example: result[4],
+              context: result[5], target_language: result[6], translation_to_target_language: result[7])
+        end
+
+        sig { params(id: Integer).returns(Word) }
+        def find(id)
+          Services::DB.instance.execute('SELECT id, word, pronunciation, meaning, example, context, target_language, translation_to_target_language FROM words WHERE id = ?',
+                                        [id]).map do |row|
+            new(id: row[0], word: row[1], pronunciation: row[2], meaning: row[3], example: row[4], context: row[5],
+                target_language: row[6], translation_to_target_language: row[7])
+          end.first
+        end
+
+        sig { params(word: String).returns(T.nilable(Word)) }
+        def find_by_word(word)
+          Services::DB.instance.execute('SELECT id, word, pronunciation, meaning, example, context, target_language, translation_to_target_language FROM words WHERE word = ?',
+                                        [word]).map do |row|
+            new(id: row[0], word: row[1], pronunciation: row[2], meaning: row[3], example: row[4], context: row[5],
+                target_language: row[6], translation_to_target_language: row[7])
+          end.first
+        end
+      end
+    end
+  end
+end

data/lib/services/db.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sqlite3'
+require 'sorbet-runtime'
+require 'singleton'
+
+module WordSmith
+  module Services
+    class DB < SQLite3::Database
+      extend T::Sig
+      include Singleton
+
+      DB_FILE = File.join(File.dirname(__FILE__), '../..', 'db', 'storage.db')
+
+      sig { void }
+      def initialize
+        Dir.mkdir(File.dirname(DB_FILE)) unless Dir.exist?(File.dirname(DB_FILE))
+
+        @db = super(DB_FILE)
+      end
+    end
+  end
+end

data/lib/services/logger.rb

@@ -0,0 +1,22 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'rainbow'
+
+module WordSmith
+  module Services
+    module Logger
+      class << self
+        extend T::Sig
+
+        sig { params(message: String).void }
+        def debug_log(message)
+          return unless Config::DEBUG_MODE
+
+          puts Rainbow('DEBUG:').white.bg(:yellow) + " #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/services/open_a_i.rb

@@ -0,0 +1,173 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'openai'
+require 'json'
+
+require_relative '../config'
+
+module WordSmith
+  module Services
+    class OpenAI
+      class << self
+        extend T::Sig
+
+        # Storage methods
+
+        OPEN_AI_API_KEY_FILE = File.join(File.dirname(__FILE__), '../../', '.openai_api_key')
+        OPEN_AI_ORG_ID_FILE = File.join(File.dirname(__FILE__), '../../', '.openai_org_id')
+
+        sig { params(key: String).void }
+        def store_api_key(key)
+          File.write(OPEN_AI_API_KEY_FILE, key)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def api_key
+          return nil unless File.exist?(OPEN_AI_API_KEY_FILE)
+
+          File.read(OPEN_AI_API_KEY_FILE)
+        end
+
+        sig { params(key: String).void }
+        def store_org_id(key)
+          File.write(OPEN_AI_ORG_ID_FILE, key)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def org_id
+          return nil unless File.exist?(OPEN_AI_ORG_ID_FILE)
+
+          File.read(OPEN_AI_ORG_ID_FILE)
+        end
+      end
+
+      extend T::Sig
+
+      class OpenAIKeyNotSetError < StandardError; end
+      class OpenAIOrgIDNotSetError < StandardError; end
+
+      def initialize
+        raise OpenAIKeyNotSetError if OpenAI.api_key.nil?
+        raise OpenAIOrgIDNotSetError if OpenAI.org_id.nil?
+
+        ::OpenAI.configure do |config|
+          config.access_token = OpenAI.api_key
+          config.organization_id = OpenAI.org_id
+          config.log_errors = Config::DEBUG_MODE
+        end
+
+        @client = ::OpenAI::Client.new
+      end
+
+      sig do
+        params(text: String, target_language: T.nilable(String)).returns({ word: String, pronunciation: String,
+                                                                           meaning: String, example: String,
+                                                                           translation_to_target_language: T.nilable(String) })
+      end
+      def translate(text:, target_language:)
+        response = @client.chat(
+          parameters: {
+            model: 'gpt-4o-mini',
+            response_format: { type: 'json_schema',
+                               json_schema: {
+                                 name: 'Translation',
+                                 strict: true,
+                                 schema: {
+                                   type: 'object',
+                                   properties: {
+                                     word: { type: 'string' },
+                                     pronunciation: { type: 'string' },
+                                     meaning: { type: 'string' },
+                                     example: { type: 'string' },
+                                     translation_to_target_language: { type: %w[string null] }
+                                   },
+                                   additionalProperties: false,
+                                   required: %w[word pronunciation meaning example translation_to_target_language]
+                                 }
+                               } },
+            messages: [
+              {
+                role: 'system', content: Helpers::Str.lstr_every_line("
+            You are a great translator. Give the user the meaning of the word in English.
+            Also give the user an example of the sentence using the word.
+            #{get_target_language_prompt(target_language)}
+            Do not hallucinate.
+            Be to the point and concise without an
+            ")
+              },
+              {
+                role: 'user', content: text
+              }
+            ],
+            temperature: 0.7
+          }
+        )
+
+        JSON.parse(response.dig('choices', 0, 'message', 'content'), { symbolize_names: true })
+      end
+
+      sig do
+        params(sentence: String,
+               word: String,
+               target_language: T.nilable(String)).returns({ word: String, pronunciation: String, meaning: String,
+                                                             example: String })
+      end
+      def translate_in_context_of_sentence(sentence:, word:, target_language:)
+        response = @client.chat(
+          parameters: {
+            model: 'gpt-4o-mini',
+            response_format: { type: 'json_schema',
+                               json_schema: {
+                                 name: 'Translation',
+                                 strict: true,
+                                 schema: {
+                                   type: 'object',
+                                   properties: {
+                                     word: { type: 'string' },
+                                     pronunciation: { type: 'string' },
+                                     meaning: { type: 'string' },
+                                     example: { type: 'string' },
+                                     translation_to_target_language: { type: %w[string null] }
+                                   },
+                                   additionalProperties: false,
+                                   required: %w[word pronunciation meaning example]
+                                 }
+                               } },
+            messages: [
+              {
+                role: 'system', content: Helpers::Str.lstr_every_line("
+            You are a great translator. Give the user the meaning of the word in context of the sentence in English.
+            Also give the user an example of the sentence using the meaning of the word in that context.
+            #{get_target_language_prompt(target_language)}
+            Do not hallucinate.
+            Be to the point and concise without an
+            ")
+              },
+              {
+                role: 'user', content: Helpers::Str.lstr_every_line("
+                Sentence: #{sentence}
+                Word: #{word}
+                ")
+              }
+            ],
+            temperature: 0.7
+          }
+        )
+
+        JSON.parse(response.dig('choices', 0, 'message', 'content'), { symbolize_names: true })
+      end
+
+      private
+
+      def get_target_language_prompt(target_language)
+        return '' if target_language.nil?
+
+        Helpers::Str.lstr_every_line("
+          Also, please give me the literal translation of the word in #{target_language} language.
+          ")
+      end
+    end
+  end
+end

data/version.rb

@@ -0,0 +1,3 @@
+module WordSmith
+  VERSION = '0.1.4'
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: word_smith
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Pouya Mozaffar Magham
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-13 00:00:00.000000000 Z
+dependencies: []
+description: Command-line tool for quick and easy English word lookup.
+email: pouya.mozafar@gmail.com
+executables:
+- ws
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ws
+- lib/command_runner/index.rb
+- lib/command_runner/translation.rb
+- lib/config.rb
+- lib/helpers/logo_visualizer.rb
+- lib/helpers/str.rb
+- lib/index.rb
+- lib/migrations/1_words.rb
+- lib/migrations/index.rb
+- lib/models/word.rb
+- lib/services/db.rb
+- lib/services/logger.rb
+- lib/services/open_a_i.rb
+- version.rb
+homepage: https://github.com/pmzi/WordSmith
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: MR Word Smith!
+test_files: []