translation_api 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 370f25cdc53d4030c0928031a07c102a659bd73e5896d5a03e6e094981ad76b7
-  data.tar.gz: 676027c41756226cfe1ae91fb4a7f56edc5df58db1fa0a3a9299cec729247b8e
+  metadata.gz: c9c1c9798882d3591828278748d1aa763227e85a2c37be0d7583859c78fc0013
+  data.tar.gz: ac5378596044a829e4f653e258ade5074e023b2ca0d3ccb1a55b603c8e707c5d
 SHA512:
-  metadata.gz: 4b3bd44c26896be44baa467a1cfe7a1dbd7b83ba30ea6dc0fdafb9e0a1001296a34724a5e243902e05435f431285f0aa8a5e9af2bf0fa4e653129d9db432ca4b
-  data.tar.gz: cdcbf2fd3bf73d6bcddb51488c1123d4ed79b76d137b6e64a8a05b183487a789340db5dffe6c1a215a7064c2bf3f79cc92c6f4146a35970cfb6560aeced046bd
+  metadata.gz: 94379f1ffbd3741c72fc87289b7887b434eb65e3bb8fb55438a98fdede95e4220f473aae4f56aeed5a126099d95fdc7abde0d2b9fd05f53d8ec7286bb03af54a
+  data.tar.gz: 17d351d60dc25125577f5a9c8a43490e86a91a8d77420d795131c17de6c7b1a33e3f9050c5d836272fd87ec825846a25379fd44d42f1725580bde08b4fe5c06a

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.4
   NewCops: enable
 
 Style/StringLiterals:
@@ -16,7 +16,7 @@ Style/ParallelAssignment:
 
 Metrics/MethodLength:
   CountComments: true
-  Max: 20
+  Max: 30
 
 Lint/ScriptPermission:
   Enabled: false
@@ -29,4 +29,4 @@ RSpec/ExampleLength:
 
 require:
   - rubocop-rake
-  - rubocop-rspec
+  - rubocop-rspec

data/CHANGELOG.md

@@ -29,4 +29,13 @@
 ## [0.1.2] - 2025-03-31
 
 - deeplを使用可能に
-- gemspecにdeepl-rbを書き忘れていたのを修正
+- gemspecにdeepl-rbを書き忘れていたのを修正
+
+## [0.2.0] - 2025-07-26
+
+- いろいろバージョン更新
+- OpenAIのモデル追加
+
+## [1.0.0] - 2025-11-10
+- 全体的な設計を刷新
+- よりシンプルなインターフェースに変更

data/README.md

@@ -7,14 +7,14 @@ Requires api key.
 
 1. `touch .env`
 2. Add `OPENAI_API_KEY=YOUR_API_KEY`  
-3. Optional: `ENV["OPENAI_MODEL"]`(default: gpt-4o-mini)
-4. `TranslationAPI::Mediator.new.translate("text")`
+3. Optional: `ENV["OPENAI_MODEL"]`
+4. `TranslationAPI.translate("text")`
 
-### Init Options
+### Configuration Options
 
 * output_logs (default: true)  
 * language (default: "japanese")  
-* agent (default: :openai)  
+* provider (default: :openai)  
 * except_words (default: [])  
 
 ### Output
@@ -26,3 +26,14 @@ Requires api key.
 ## Example
 
 Exec `ruby example.rb "text"`
+
+```ruby
+TranslationAPI.configure do |config|
+  config.language     = "english"
+  config.provider     = :deepl
+  config.output_logs  = false
+  config.except_words = %w[hoge fuga]
+end
+
+TranslationAPI.translate("text")
+```

data/example.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "lib/translation_api/mediator"
+require_relative "lib/translation_api"
 
 if ARGV.empty?
   puts "引数が必要です: ruby example.rb \"text\""
@@ -8,12 +8,11 @@ if ARGV.empty?
 end
 
 text = ARGV.join(" ")
-translator =
-  TranslationAPI::Mediator.new(
-    output_logs: true,
-    language: "japanese",
-    agent: :deepl,
-    except_words: %w[hoge fuga]
-  )
-translated_text = translator.translate(text)
+TranslationAPI.configure do |config|
+  config.language     = "english"
+  config.provider     = :deepl
+  config.except_words = %w[hoge fuga]
+end
+
+translated_text = TranslationAPI.translate(text)
 p translated_text

data/lib/translation_api/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+class TranslationAPI
+  class Config
+    include Singleton
+
+    attr_accessor :language, :provider, :output_logs, :except_words, :deepl_pro
+
+    def self.configure(&block)
+      block.call(instance)
+    end
+
+    def initialize
+      @language     = "japanese"
+      @provider     = :openai
+      @output_logs  = true
+      @except_words = []
+      @deepl_pro    = false
+    end
+  end
+end

data/lib/translation_api/provider/deepl.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "dotenv"
+require "deepl"
+
+class TranslationAPI
+  module Provider
+    class DeepL
+      SYSTEM_PROMPT_BASE = <<~TEXT
+        Keep symbols
+      TEXT
+
+      API_KEY_ERROR_MESSAGE = "API key is not found."
+
+      LANGUAGE_UNSUPPORTED_MESSAGE = "This language is unsupported by DeepL."
+
+      def initialize(pro:, except_words: [], language: "japanese")
+        @pro = pro
+        @language = language
+
+        setup_deepl_config!
+        validate_supported_language!
+
+        @system_content = SYSTEM_PROMPT_BASE + except_option_text(except_words)
+        @language = supported_languages[language.to_sym]
+      end
+
+      def translate(text)
+        return text if text.strip.empty?
+
+        ::DeepL.translate(text, nil, @language, context: @system_content).text
+      end
+
+      private
+
+      def setup_deepl_config!
+        validate_api_key!
+
+        ::DeepL.configure do |config|
+          config.auth_key = ENV["DEEPL_API_KEY"] || ENV["DEEPL_AUTH_KEY"]
+          config.host = @pro ? "https://api.deepl.com" : "https://api-free.deepl.com"
+        end
+      end
+
+      def validate_api_key!
+        raise API_KEY_ERROR_MESSAGE unless ENV["DEEPL_API_KEY"] || ENV["DEEPL_AUTH_KEY"]
+      end
+
+      def validate_supported_language!
+        raise LANGUAGE_UNSUPPORTED_MESSAGE unless supported_language?
+      end
+
+      def supported_languages
+        @supported_languages ||=
+          ::DeepL.languages.to_h { [it.name.downcase.to_sym, it.code] }
+      end
+
+      def supported_language?
+        supported_languages.key?(@language.to_sym)
+      end
+
+      def except_option_text(except_words)
+        return "" if except_words.empty?
+
+        <<~TEXT
+          Words listed next are not translated: [#{except_words.join(", ")}]
+        TEXT
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai/cost.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class TranslationAPI
+  module Provider
+    class OpenAI
+      class Cost
+        BASE_MODEL_NAME = "gpt-5"
+        ONE_MILLION = 1_000_000
+        BASE_MODEL_COST = 1.25 / ONE_MILLION
+
+        def initialize(provider)
+          @provider = provider
+        end
+
+        def input_cost(used_tokens)
+          calculate_cost(used_tokens, :input)
+        end
+
+        def output_cost(used_tokens)
+          calculate_cost(used_tokens, :output)
+        end
+
+        private
+
+        def calculate_cost(used_tokens, type)
+          used_tokens * token_rates[@provider.using_model][type]
+        end
+
+        def token_rates
+          normal_models = base_model.merge(mini_model).merge(nano_model)
+          normal_models.merge(other_models)
+        end
+
+        def base_model
+          {
+            BASE_MODEL_NAME => {
+              input: BASE_MODEL_COST,
+              output: BASE_MODEL_COST * normal_io_ratio[:output]
+            }
+          }
+        end
+
+        def mini_model
+          {
+            "#{BASE_MODEL_NAME}-mini" => {
+              input: BASE_MODEL_COST / normal_cost_diff_ratio,
+              output: (BASE_MODEL_COST * normal_io_ratio[:output]) / normal_cost_diff_ratio
+            }
+          }
+        end
+
+        def nano_model
+          mini_model_cost = mini_model.values[0][:input]
+
+          {
+            "#{BASE_MODEL_NAME}-nano" => {
+              input: mini_model_cost / normal_cost_diff_ratio,
+              output: (mini_model_cost * normal_io_ratio[:output]) / normal_cost_diff_ratio
+            }
+          }
+        end
+
+        def other_models
+          {
+            "#{BASE_MODEL_NAME}-chat-latest" => {
+              input: 1.25 / ONE_MILLION,
+              output: (1.25 * normal_io_ratio[:output]) / ONE_MILLION
+            }
+          }
+        end
+
+        def normal_io_ratio
+          {
+            input: 1.0,
+            output: 8.0
+          }
+        end
+
+        def normal_cost_diff_ratio
+          5.0
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai/log.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "cost"
+
+class TranslationAPI
+  module Provider
+    class OpenAI
+      class Log
+        def initialize(provider)
+          @provider = provider
+          @cost = Cost.new(@provider)
+        end
+
+        def write
+          write_translated_text
+          write_used_tokens
+          write_total_cost
+        end
+
+        private
+
+        def write_translated_text
+          log_file_path = text_path("translated_text.txt")
+
+          File.open(log_file_path, "a") do |file|
+            file.puts(@provider.translated_text)
+          end
+        end
+
+        def write_used_tokens
+          log_file_path = text_path("tokens.txt")
+
+          existing_input_tokens, existing_output_tokens = read_existing_tokens
+          tokens => { input_tokens:, output_tokens: }
+
+          total_input_tokens  = existing_input_tokens + input_tokens
+          total_output_tokens = existing_output_tokens + output_tokens
+
+          File.open(log_file_path, "w") do |file|
+            file.puts("input: #{total_input_tokens}")
+            file.puts("output: #{total_output_tokens}")
+          end
+        end
+
+        def read_existing_tokens
+          log_file_path = text_path("tokens.txt")
+          input_tokens, output_tokens = 0, 0
+
+          if File.exist?(log_file_path)
+            File.readlines(log_file_path).each do |line|
+              tokens = line.split(":").last.strip.to_i
+              input_tokens  = tokens if line.start_with?("input:")
+              output_tokens = tokens if line.start_with?("output:")
+            end
+          end
+
+          [input_tokens, output_tokens]
+        end
+
+        def write_total_cost
+          log_file_path = text_path("cost.txt")
+          tokens => { input_tokens:, output_tokens: }
+
+          this_cost = @cost.input_cost(input_tokens) + @cost.output_cost(output_tokens)
+          total_cost = this_cost + existing_cost
+
+          File.open(log_file_path, "w") do |file|
+            file.puts(format_cost(total_cost))
+          end
+        end
+
+        def format_cost(cost)
+          "$#{format("%.8f", cost)}"
+        end
+
+        def existing_cost
+          log_file_path = text_path("cost.txt")
+
+          File.exist?(log_file_path) ? File.read(log_file_path).gsub("$", "").to_f : 0.0
+        end
+
+        def tokens
+          {
+            input_tokens: @provider.dig_used_tokens(type: :input),
+            output_tokens: @provider.dig_used_tokens(type: :output)
+          }
+        end
+
+        def text_path(under_logs_path)
+          output_dir = "translator_logs/openai"
+          FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
+
+          File.join(output_dir, under_logs_path)
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "openai"
+require_relative "openai/log"
+
+class TranslationAPI
+  module Provider
+    class OpenAI
+      SYSTEM_PROMPT_BASE = <<~TEXT
+        Translate only.
+        Return result only, no extra info
+        Keep symbols
+      TEXT
+
+      API_KEY_ERROR_MESSAGE = "API key is not found."
+
+      MODEL_ERROR_MESSAGE =
+        "Specified model is not supported. Please check the model name."
+
+      def initialize(output_logs:, except_words:, language:)
+        validate_api_key!
+
+        @client = init_client
+        @output_logs   = output_logs
+        @system_prompt = SYSTEM_PROMPT_BASE + except_option_text(except_words)
+        @user_prompt   = user_prompt_text(language)
+      end
+
+      def translate(text)
+        return text if text.strip.empty?
+
+        @response = chat_to_api(text)
+        Log.new(self).write if @output_logs
+
+        translated_text
+      end
+
+      def translated_text
+        @response["choices"][0]["message"]["content"]
+      end
+
+      def using_model
+        ENV["OPENAI_MODEL"] || "gpt-5-mini"
+      end
+
+      def dig_used_tokens(type:)
+        case type
+        when :input
+          @response["usage"]["prompt_tokens"]
+        when :output
+          @response["usage"]["completion_tokens"]
+        else
+          raise ArgumentError, "Invalid token type: #{type}"
+        end
+      end
+
+      private
+
+      def validate_api_key!
+        raise API_KEY_ERROR_MESSAGE unless ENV["OPENAI_API_KEY"]
+      end
+
+      def init_client
+        ::OpenAI::Client.new(
+          access_token: ENV["OPENAI_API_KEY"],
+          log_errors: true
+        )
+      end
+
+      def chat_to_api(text)
+        @client.chat(
+          parameters: {
+            model: using_model,
+            messages: [
+              { role: "system", content: @system_prompt },
+              { role: "user", content: @user_prompt + text }
+            ]
+          }
+        )
+      end
+
+      def except_option_text(except_words)
+        return "" if except_words.empty?
+
+        <<~TEXT
+          Words listed next are not translated: [#{except_words.join(", ")}]
+        TEXT
+      end
+
+      def user_prompt_text(language)
+        <<~TEXT
+          Please translate this text to #{language}:
+        TEXT
+      end
+    end
+  end
+end

data/lib/translation_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module TranslationAPI
-  VERSION = "0.1.2"
+class TranslationAPI
+  VERSION = "1.0.0"
 end

data/lib/translation_api.rb

@@ -1,6 +1,66 @@
 # frozen_string_literal: true
 
+require "dotenv"
 require_relative "translation_api/version"
-require_relative "translation_api/mediator"
+require_relative "translation_api/config"
+require_relative "translation_api/provider/openai"
+require_relative "translation_api/provider/deepl"
 
-module TranslationAPI; end
+class TranslationAPI
+  UNSUPPORTED_PROVIDER_MESSAGE = "This provider is unsupported."
+
+  Dotenv.load
+
+  def self.config
+    Config.instance
+  end
+
+  def self.configure(&)
+    Config.configure(&)
+  end
+
+  def self.translate(text, **)
+    new(**).translate(text)
+  end
+
+  def initialize(
+    language:     config.language,
+    provider:     config.provider,
+    output_logs:  config.output_logs,
+    except_words: config.except_words
+  )
+    @language     = language
+    @output_logs  = output_logs
+    @except_words = except_words
+    @provider     = init_provider(provider)
+  end
+
+  def config
+    self.class.config
+  end
+
+  def translate(text)
+    @provider.translate(text)
+  end
+
+  private
+
+  def init_provider(provider)
+    case provider
+    when :openai
+      Provider::OpenAI.new(
+        output_logs: @output_logs,
+        except_words: @except_words,
+        language: @language
+      )
+    when :deepl
+      Provider::DeepL.new(
+        pro: config.deepl_pro,
+        except_words: @except_words,
+        language: @language
+      )
+    else
+      raise UNSUPPORTED_PROVIDER_MESSAGE
+    end
+  end
+end

metadata

@@ -1,56 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: translation_api
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - milkeclair
 bindir: exe
 cert_chain: []
-date: 2025-03-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deepl-rb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.3
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.3
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.4
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.4
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: '0'
 description: translate
 email:
 - milkeclair.noreply@gmail.com
@@ -67,14 +67,13 @@ files:
 - example.rb
 - how_to_publish.txt
 - lib/translation_api.rb
-- lib/translation_api/calculator.rb
-- lib/translation_api/deepl.rb
-- lib/translation_api/mediator.rb
-- lib/translation_api/openai.rb
+- lib/translation_api/config.rb
+- lib/translation_api/provider/deepl.rb
+- lib/translation_api/provider/openai.rb
+- lib/translation_api/provider/openai/cost.rb
+- lib/translation_api/provider/openai/log.rb
 - lib/translation_api/version.rb
-- lib/translation_api/writer.rb
 - rake_helper.rb
-- sig/translation_api.rbs
 homepage: https://github.com/milkeclair/translation_api
 licenses:
 - MIT
@@ -90,14 +89,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.4.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: translate
 test_files: []

data/lib/translation_api/calculator.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "writer"
-
-module TranslationAPI
-  class Calculator
-    class ArgumentError < StandardError; end
-    MODEL_ERROR_MESSAGE =
-      "設定に無いモデルです。.envを確認してください。"
-
-    # トークン数から利用料金を計算する
-    #
-    # @param [Integer] used_tokens 使用したトークン数
-    # @param [String] token_type トークンの種類
-    # @return [Float] 利用料金
-    def self.calc_total_cost(used_tokens, token_type)
-      model = ENV["OPENAI_MODEL"] || "gpt-4o-mini"
-      rate = get_token_rate(model, token_type)
-      used_tokens * rate
-    end
-
-    # モデルとトークンの種類からトークンの単価を取得する
-    # モデルが設定に無い場合はエラーを投げる
-    #
-    # @param [String] model モデル名
-    # @param [String] token_type トークンの種類
-    # @return [Float] トークンの単価
-    def self.get_token_rate(model, token_type)
-      token_rate = token_rate_hash
-      validate_model(model, token_rate)
-      token_rate[model][token_type.to_sym]
-    end
-
-    # トークン単価のハッシュを返す
-    #
-    # @return [Hash] トークン単価のハッシュ
-    def self.token_rate_hash
-      one_million = 1_000_000
-      {
-        "gpt-4o" => {
-          input: 5.0 / one_million,
-          output: 15.0 / one_million
-        },
-        "gpt-4o-2024-08-06" => {
-          input: 2.5 / one_million,
-          output: 10.0 / one_million
-        },
-        "gpt-4o-mini" => {
-          input: 0.15 / one_million,
-          output: 0.6 / one_million
-        }
-      }
-    end
-
-    # モデルが存在するかどうかを確認する
-    #
-    # @param [String] model モデル名
-    # @param [Hash] token_rate トークンレートのハッシュ
-    # @raise [Calculator::ArgumentError] モデルが存在しない場合
-    def self.validate_model(model, token_rate)
-      return if token_rate.key?(model)
-
-      raise Calculator::ArgumentError, MODEL_ERROR_MESSAGE
-    end
-  end
-end

data/lib/translation_api/deepl.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "dotenv"
-require "deepl"
-
-module TranslationAPI
-  class DeepL
-    SYSTEM_CONTENT_BASE = <<~TEXT
-      Keep symbols
-    TEXT
-
-    def initialize(output_logs: true, except_words: [], language: "japanese", pro: false)
-      Dotenv.load
-      setup_deepl_config!(pro: pro)
-      @supported_languages = fetch_supported_languages
-      validate_supported!(language)
-      @system_content = SYSTEM_CONTENT_BASE + except_option_text(except_words)
-      @language = @supported_languages[language.to_sym]
-    end
-
-    def translate(text)
-      return text if text.strip.empty?
-
-      ::DeepL.translate(text, nil, @language, context: @system_content).text
-    end
-
-    private
-
-    def setup_deepl_config!(pro:)
-      validate_api_key!
-
-      ::DeepL.configure do |config|
-        config.auth_key = ENV["DEEPL_API_KEY"] || ENV["DEEPL_AUTH_KEY"]
-        config.host = pro ? "https://api.deepl.com" : "https://api-free.deepl.com"
-      end
-    end
-
-    def validate_supported!(lang)
-      raise "This language is unsupported by DeepL" unless supported?(lang)
-    end
-
-    def validate_api_key!
-      raise "API key is not found" unless ENV["DEEPL_API_KEY"] || ENV["DEEPL_AUTH_KEY"]
-    end
-
-    def fetch_supported_languages
-      ::DeepL.languages.to_h { |lang| [lang.name.downcase.to_sym, lang.code] }
-    end
-
-    def supported?(lang)
-      @supported_languages.key?(lang.to_sym)
-    end
-
-    def except_option_text(except_words)
-      return "" if except_words.empty?
-
-      <<~TEXT
-        Words listed next are not translated: [#{except_words.join(", ")}]
-      TEXT
-    end
-  end
-end

data/lib/translation_api/mediator.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "writer"
-require_relative "openai"
-require_relative "deepl"
-
-module TranslationAPI
-  class Mediator
-    # @param [Boolean] output_logs ログを出力するかどうか
-    # @param [String] language 翻訳先の言語
-    # @param [Symbol] agent 翻訳エージェント
-    # @param [Array<String>] except_words 除外する単語のリスト
-    # @return [TranslationAPI::Mediator]
-    def initialize(
-      output_logs: true, language: "japanese", agent: :openai, except_words: []
-    )
-      @output_logs = output_logs
-      @language = language
-      @agent = agent
-      @except_words = except_words
-    end
-
-    # テキストを翻訳する
-    #
-    # @param [String] text 翻訳するテキスト
-    # @return [String] 翻訳されたテキスト
-    def translate(text)
-      agent = init_agent
-      agent.translate(text)
-    end
-
-    # エージェントのインスタンスを初期化する
-    #
-    # @return [Object] 翻訳エージェントのインスタンス
-    def init_agent
-      agent_class.new(
-        output_logs: @output_logs, except_words: @except_words, language: @language
-      )
-    end
-
-    # エージェントのクラスを返す
-    #
-    # @return [Class] エージェントのクラス
-    def agent_class
-      case @agent
-      when :openai
-        OpenAI
-      when :deepl
-        DeepL
-      else
-        class_name = camelize(@agent.to_s)
-        Object.const_get("TranslationAPI::#{class_name}")
-      end
-    end
-
-    # スネークケースの文字列をキャメルケースに変換する
-    #
-    # @param [String] str スネークケースの文字列
-    # @return [String] キャメルケースの文字列
-    def camelize(str)
-      str.split("_").map(&:capitalize).join
-    end
-  end
-end

data/lib/translation_api/openai.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "dotenv"
-require "openai"
-require_relative "writer"
-
-module TranslationAPI
-  class OpenAI
-    SYSTEM_CONTENT_BASE = <<~TEXT
-      Translate only.
-      Return result only, no extra info
-      Keep symbols
-    TEXT
-
-    # OpenAI APIを使用してテキストを翻訳する
-    #
-    # @param [Boolean] output_logs ログを出力するかどうか
-    # @param [Array<String>] except_words 除外する単語のリスト
-    # @param [String] language 翻訳先の言語
-    # @return [void]
-    def initialize(output_logs: true, except_words: [], language: "japanese")
-      # 環境変数の読み込み
-      Dotenv.load
-      raise "API key is not found" unless ENV["OPENAI_API_KEY"]
-
-      @client = ::OpenAI::Client.new(
-        access_token: ENV["OPENAI_API_KEY"],
-        log_errors: true # 好み
-      )
-      @output_logs = output_logs
-      @system_content = SYSTEM_CONTENT_BASE + except_option_text(except_words)
-      @language = language
-    end
-
-    # テキストを日本語に翻訳し、結果をファイルに書き込む
-    #
-    # @param [String] text 翻訳するテキスト
-    # @return [void]
-    def translate(text)
-      # 空白文字は翻訳する必要がない
-      return text if text.strip.empty?
-
-      response = chat_to_api(text)
-      Writer.write_logs(self, response) if @output_logs
-
-      response["choices"][0]["message"]["content"]
-    end
-
-    # レスポンスから使用したトークン数を取得する
-    #
-    # @param [Hash] response OpenAI APIからのレスポンス
-    # @param [String] token_type トークンの種類 (input or output)
-    # @return [Integer] 使用したトークン数
-    def self.dig_used_tokens(response, token_type)
-      if token_type == "input"
-        response["usage"]["prompt_tokens"]
-      elsif token_type == "output"
-        response["usage"]["completion_tokens"]
-      end
-    end
-
-    private
-
-    # OpenAI APIにテキストを送信し、翻訳結果を取得する
-    #
-    # @param [String] text 翻訳するテキスト
-    # @return [Hash] OpenAI APIからのレスポンス
-    def chat_to_api(text)
-      @client.chat(
-        parameters: {
-          model: ENV["OPENAI_MODEL"] || "gpt-4o-mini",
-          messages: [
-            { role: "system", content: @system_content },
-            { role: "user", content: user_prompt_text(text) }
-          ]
-        }
-      )
-    end
-
-    # 除外する単語を指定するプロンプト
-    #
-    # @param [Array<String>] except_words 除外する単語のリスト
-    # @return [String] 除外する単語を指定するテキスト
-    def except_option_text(except_words)
-      return "" if except_words.empty?
-
-      <<~TEXT
-        Words listed next are not translated: [#{except_words.join(", ")}]
-      TEXT
-    end
-
-    # ユーザー入力のプロンプト
-    #
-    # @param [String] text テキスト
-    # @return [String] ユーザー入力のプロンプト
-    def user_prompt_text(text)
-      <<~TEXT
-        Please translate this text to #{@language}: #{text}
-      TEXT
-    end
-  end
-end

data/lib/translation_api/writer.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require_relative "calculator"
-require_relative "openai"
-
-module TranslationAPI
-  class Writer
-    @agent = nil
-
-    # ログをファイルに書き込む
-    #
-    # @param [Object] agent 翻訳エージェントのインスタンス
-    # @param [Hash] response 翻訳した結果
-    # @return [void]
-    def self.write_logs(agent, response)
-      # 例: "Hoge::Fuga" => "fuga"
-      @agent = agent.class.to_s.split("::").last.downcase
-      handle_agent(response)
-    end
-
-    # エージェントに対応したログ書き込み用メソッドを呼び出す
-    #
-    # @param [Hash] response 翻訳した結果
-    # @return [void]
-    def self.handle_agent(response)
-      method_name = "write_#{@agent}_logs"
-      send(method_name, response)
-    end
-
-    # OpenAIのログをファイルに書き込む
-    #
-    # @param [Hash] response OpenAI APIからのレスポンス
-    # @return [void]
-    def self.write_openai_logs(response)
-      input_tokens = OpenAI.dig_used_tokens(response, "input")
-      output_tokens = OpenAI.dig_used_tokens(response, "output")
-
-      write_translated_text(response["choices"][0]["message"]["content"])
-      write_used_tokens(input_tokens, output_tokens)
-      write_total_cost(input_tokens, output_tokens)
-    end
-
-    # 出力先のテキストファイルのパスを返す
-    # example.rbから見たパスで指定している
-    #
-    # @param [String] under_logs_path translator_logsディレクトリ配下のパス
-    # @return [String] 出力先のテキストファイルのパス
-    def self.text_path(under_logs_path)
-      output_dir = "translator_logs/#{@agent}"
-      FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
-      File.join(output_dir, under_logs_path)
-    end
-
-    # 翻訳されたテキストをファイルに書き込み、ターミナルに出力する
-    # テキストはファイルの末尾に追記される
-    #
-    # @param [Hash] translated_text 翻訳されたテキスト
-    # @return [void]
-    def self.write_translated_text(translated_text)
-      log_file_path = text_path("translated_text.txt")
-      File.open(log_file_path, "a") do |file|
-        file.puts(translated_text)
-      end
-    end
-
-    # 使用したトークン数をファイルに書き込む
-    # ファイルのテキストは上書きされる
-    #
-    # @param [Integer] input_tokens 入力トークン数
-    # @param [Integer] output_tokens 出力トークン数
-    # @return [void]
-    def self.write_used_tokens(input_tokens, output_tokens)
-      log_file_path = text_path("tokens.txt")
-      existing_input_tokens, existing_output_tokens = read_existing_tokens(log_file_path)
-
-      total_input_tokens = existing_input_tokens + input_tokens
-      total_output_tokens = existing_output_tokens + output_tokens
-
-      File.open(log_file_path, "w") do |file|
-        file.puts("input: #{total_input_tokens}")
-        file.puts("output: #{total_output_tokens}")
-      end
-    end
-
-    # ファイルにあるトークン数を読み込む
-    #
-    # @param [String] log_file_path トークン数が書かれたファイルのパス
-    # @return [Array<Integer>] 入力トークン数と出力トークン数
-    def self.read_existing_tokens(log_file_path)
-      existing_input_tokens, existing_output_tokens = 0, 0
-
-      if File.exist?(log_file_path)
-        File.readlines(log_file_path).each do |line|
-          existing_input_tokens = line.split(":").last.strip.to_i if line.start_with?("input:")
-          existing_output_tokens = line.split(":").last.strip.to_i if line.start_with?("output:")
-        end
-      end
-
-      [existing_input_tokens, existing_output_tokens]
-    end
-
-    # トークン数から利用料金を計算し、ファイルにある合計金額に加算して書き込む
-    # ファイルのテキストは上書きされる
-    #
-    # @param [Integer] input_tokens 入力トークン数
-    # @param [Integer] output_tokens 出力トークン数
-    # @return [void]
-    def self.write_total_cost(input_tokens, output_tokens)
-      log_file_path = text_path("cost.txt")
-      this_cost =
-        Calculator.calc_total_cost(input_tokens, "input") + Calculator.calc_total_cost(output_tokens, "output")
-      existing_cost =
-        if File.exist?(log_file_path)
-          File.read(log_file_path).gsub("$", "").to_f
-        else
-          0.0
-        end
-      total_cost = this_cost + existing_cost
-
-      File.open(log_file_path, "w") do |file|
-        # 小数点以下8桁まで表示
-        file.puts("$#{format("%.8f", total_cost)}")
-      end
-    end
-  end
-end

data/sig/translation_api.rbs

@@ -1,4 +0,0 @@
-module TranslationAPI
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end