honyaku 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c4deb596d588ecdc949ec04c2c139bdd0c8d886c365aa9e5f980f21ffd0b986a
+  data.tar.gz: 42749082904b0c7cfd8ce08b038c776a7e3c57cf22b37878a1e3145cf5878c7a
+SHA512:
+  metadata.gz: 0bab4819f367a8144255b85f6b1c5aa0b23b132d4dc02fe6cb2c7bad6bfbdc09f6904c833ee37849ad739275d4c03f6ee65fa7917de1e95c5c249ef562d82d28
+  data.tar.gz: 8178c8117039fcb339476be232b109695d787a64346af4d64eb8bf3375c735494e563f1a44871acd01b534822de3cf9111b93b79a014100d9eab1033dc0ffba0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Andrew Culver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,169 @@
+# Honyaku 翻訳
+
+A Ruby gem for quickly, reliably, and accurately translating your Rails application using OpenAI. Created because it replaced a $34K/year SaaS contract and streamlined our deploy process.
+
+Honyaku was built using [Cursor Composer](https://docs.cursor.com/composer) with [claude-3.5-sonnet](https://www.anthropic.com/news/claude-35-sonnet), prompted by [Andrew Culver](https://x.com/andrewculver) at [ClickFunnels](https://www.clickfunnels.com).
+
+## Features
+
+- Uses GPT-4 for high-quality translations (GPT-3.5-turbo optional for faster processing)
+- Preserves YAML structure, references, and interpolation variables
+- Supports translation rules via `.honyakurules` files
+- Handles large files through automatic chunking
+- Automatically fixes YAML formatting issues caused by the GPT
+- Supports backup creation before modifications
+- Smart file skipping to avoid unnecessary retranslation
+
+# Example Output
+
+```
+$ honyaku translate ja --path config/locales/en/affiliates             
+📋 Found 2 translation rule file(s):
+   📝 /Users/andrewculver/Sites/admin/.honyakurules
+   🌐 /Users/andrewculver/Sites/admin/.honyakurules.ja
+🌏 Translating from en to ja...
+📂 Processing files in config/locales/en/affiliates...
+📝 Processing config/locales/en/affiliates/active_referrals_report.en.yml...
+📦 Splitting file into 3 chunks...
+🔄 Translating chunk 1 of 3...
+🔄 Translating chunk 2 of 3...
+🔄 Translating chunk 3 of 3...
+✨ Created config/locales/ja/affiliates/active_referrals_report.ja.yml
+🔧 Checking for YAML issues...
+✅ No more YAML errors found
+📝 Processing config/locales/en/affiliates/add_tag_actions.en.yml...
+✨ Created config/locales/ja/affiliates/add_tag_actions.ja.yml
+🔧 Checking for YAML issues...
+🔧 Found YAML error on line 5: (<unknown>): found character that cannot start any token while scanning for the next token at line 5 column 13
+   zero: %{count}アフィリエイトにコミッションプランアクションを追加する
+🔧 Found YAML error on line 6: (<unknown>): found character that cannot start any token while scanning for the next token at line 6 column 12
+   one: %{count}アフィリエイトにコミッションプランアクションを追加する
+🔧 Found YAML error on line 7: (<unknown>): found character that cannot start any token while scanning for the next token at line 7 column 14
+   other: %{count}アフィリエイトにコミッションプランアクションを追加する
+✅ No more YAML errors found
+✨ Fixed YAML formatting issues
+⏭️  Skipping config/locales/en/affiliates/applied_tags.en.yml - translation is up to date
+⏭️  Skipping config/locales/en/affiliates/approve_actions.en.yml - translation is up to date
+...
+```
+
+## Installation
+
+Add to your Gemfile:
+```ruby
+gem 'honyaku'
+```
+
+Or install directly:
+```bash
+gem install honyaku
+```
+
+## Configuration
+
+Set your OpenAI API key:
+```bash
+export OPENAI_API_KEY=your-api-key
+```
+
+Or if you've already got that configured for another purpose and you want to specify a different key for Honyaku, you can set this and we'll use it instead:
+```bash
+export HONYAKU_OPENAI_API_KEY=your-api-key
+```
+
+## Usage
+
+### Basic Translation
+
+```bash
+# Translate a file
+honyaku translate ja --path config/locales/en.yml
+
+# Translate a directory
+honyaku translate es --path config/locales
+
+# Create backups before modifying
+honyaku translate ja --backup --path config/locales/en.yml
+
+# Use GPT-3.5-turbo for faster processing
+honyaku translate fr --model gpt-3.5-turbo --path config/locales/en.yml
+
+# Force retranslation of files even if they're up to date
+honyaku translate ja --force --path config/locales/en.yml
+```
+
+### Smart File Skipping
+
+Honyaku tracks file modification times to avoid unnecessary retranslation:
+
+- Checks both git history and filesystem timestamps
+- Uses the newer of the two dates for comparison
+- Skips translation if target file is newer than source
+- Shows "⏭️  Skipping" message for up-to-date files
+
+You can override this behavior with `--force` to retranslate all files regardless of their timestamps.
+
+### Translation Rules
+
+Honyaku supports two types of rule files:
+- `.honyakurules` - General rules for all translations
+- `.honyakurules.{locale}` - Language-specific rules (e.g., `.honyakurules.ja`)
+
+Example `.honyakurules`:
+```yaml
+Don't translate the term "ClickFunnels", that's our brand name.
+```
+
+Example `.honyakurules.ja`:
+```yaml
+When translating to Japanese, do not insert a space between particles like `%{site_name} に`... that should be `%{site_name}に`
+```
+
+Rules can be used for:
+- Preserving brand names
+- Enforcing locale-specific formatting
+- Maintaining consistent terminology
+
+### YAML Fixing
+
+Fix formatting issues in translated files:
+```bash
+# Fix a single file
+honyaku fix config/locales/ja/application.ja.yml
+
+# Fix all files in a directory
+honyaku fix config/locales/ja --backup
+```
+
+## Technical Details
+
+### Large File Handling
+
+Files over 250 lines are automatically split into chunks for translation. Each chunk maintains proper YAML structure to ensure accurate translations.
+
+### Error Recovery
+
+When invalid YAML is detected:
+1. Automatic formatting fixes are attempted
+2. Translation is retried if necessary
+3. Original file is preserved if fixes fail
+
+### Model Selection
+
+- Default: GPT-4 (higher quality, slower)
+- Alternative: GPT-3.5-turbo (faster, less accurate)
+
+## Development
+
+After checking out the repo:
+1. Run `bin/setup` to install dependencies
+2. Run `rake test` to run the tests
+3. Run `bin/console` for an interactive prompt
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/andrewculver/honyaku.
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE.txt) for details.

data/exe/honyaku

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "honyaku"
+Honyaku::CLI.start(ARGV)

data/lib/honyaku/cli.rb

@@ -0,0 +1,323 @@
+require "thor"
+require "yaml"
+require "honyaku/translator"
+
+module Honyaku
+  class CLI < Thor
+    desc "translate LOCALE", "Translate your application into the specified locale"
+    long_desc <<-LONGDESC
+      Translates YAML files from one locale to another using OpenAI.
+
+      Examples:
+        # Translate a specific file from English to Japanese
+        $ honyaku translate ja --path config/locales/en.yml
+
+        # Translate all files in a directory from English to Spanish
+        $ honyaku translate es --path config/locales
+
+        # Translate using GPT-4 for higher accuracy
+        $ honyaku translate de --model gpt-4 --path config/locales/en.yml
+    LONGDESC
+    method_option :from, aliases: "-f", desc: "Source locale (defaults to en)"
+    method_option :path, aliases: "-p", desc: "Path to YAML file or directory (defaults to config/locales)"
+    method_option :model, 
+                 aliases: "-m", 
+                 desc: "Specify which AI model to use (defaults to gpt-4, use gpt-3.5-turbo for faster but less accurate translations)"
+    method_option :backup, aliases: "-b", type: :boolean, desc: "Create .bak files before modifying"
+    method_option :force, type: :boolean, desc: "Retranslate files even if target is newer than source"
+    def translate(locale)
+      api_key = ENV["HONYAKU_OPENAI_API_KEY"] || ENV["OPENAI_API_KEY"]
+      unless api_key
+        puts "❌ Please set either HONYAKU_OPENAI_API_KEY or OPENAI_API_KEY environment variable"
+        exit 1
+      end
+
+      source_locale = options[:from] || "en"
+      path = options[:path] || "config/locales"
+      model = options[:model] || "gpt-4"
+
+      # Check if the source path exists
+      unless File.exist?(path)
+        puts "❌ Source path not found: #{path}"
+        puts "   Please check that the file or directory exists"
+        exit 1
+      end
+
+      # Find all .honyakurules files from root to current path
+      rules = find_translation_rules(path, locale)
+      if rules.any?
+        puts "📋 Found #{rules.length} translation rule file(s):"
+        rules.each do |rule|
+          prefix = rule[:locale_specific] ? "🌐" : "📝"
+          puts "   #{prefix} #{rule[:path]}"
+        end
+      end
+
+      puts "🌏 Translating from #{source_locale} to #{locale}..."
+      puts "📂 Processing files in #{path}..."
+
+      translator = Translator.new(model: model, translation_rules: rules)
+      
+      if File.file?(path)
+        process_file(path, translator, source_locale, locale)
+      else
+        files = Dir.glob("#{path}/**/*.yml")
+        if files.empty?
+          puts "❌ No YAML files found in: #{path}"
+          puts "   Make sure your path contains .yml files"
+          exit 1
+        end
+        files.each do |file|
+          process_file(file, translator, source_locale, locale)
+        end
+      end
+
+      puts "✅ Translation complete!"
+    end
+
+    desc "fix PATH", "Fix YAML formatting issues in translated files"
+    long_desc <<-LONGDESC
+      Fixes common YAML formatting issues in translated files, such as:
+      - Adding quotes around values that start with %{variable}
+      - Fixing spacing in interpolation variables
+      - Preserving YAML references and anchors
+      - Maintaining proper indentation
+
+      Examples:
+        # Fix a specific file
+        $ honyaku fix config/locales/ja/courses.ja.yml
+
+        # Fix all YAML files in a directory
+        $ honyaku fix config/locales/ja
+    LONGDESC
+    method_option :model, aliases: "-m", desc: "Specify which AI model to use (defaults to gpt-3.5-turbo)"
+    method_option :backup, aliases: "-b", type: :boolean, desc: "Create .bak files before modifying"
+    def fix(path)
+      api_key = ENV["HONYAKU_OPENAI_API_KEY"] || ENV["OPENAI_API_KEY"]
+      unless api_key
+        puts "❌ Please set either HONYAKU_OPENAI_API_KEY or OPENAI_API_KEY environment variable"
+        exit 1
+      end
+
+      model = options[:model] || "gpt-3.5-turbo"
+      
+      puts "🔧 Fixing YAML formatting issues..."
+      puts "📂 Processing files in #{path}..."
+
+      fixer = Translator.new(model: model)
+      
+      if File.file?(path)
+        fix_file(path, fixer)
+      else
+        Dir.glob("#{path}/**/*.yml").each do |file|
+          fix_file(file, fixer)
+        end
+      end
+
+      puts "✅ Fixes complete!"
+    end
+
+    private
+
+    def find_translation_rules(start_path, target_locale = nil)
+      rules = []
+      
+      # Start from the directory containing the YAML file/directory
+      current_path = File.expand_path(start_path)
+      
+      # First check the current working directory
+      if File.exist?('.honyakurules')
+        rules << {
+          path: File.expand_path('.honyakurules'),
+          content: File.read('.honyakurules').strip
+        }
+      end
+      
+      # Check for locale-specific rules in current directory
+      if target_locale && File.exist?(".honyakurules.#{target_locale}")
+        rules << {
+          path: File.expand_path(".honyakurules.#{target_locale}"),
+          content: File.read(".honyakurules.#{target_locale}").strip,
+          locale_specific: true
+        }
+      end
+      
+      # Walk up the directory tree from the YAML path
+      while current_path != '/' && current_path != Dir.pwd
+        # Check for general rules
+        rules_file = File.join(current_path, '.honyakurules')
+        if File.exist?(rules_file)
+          rules << {
+            path: rules_file,
+            content: File.read(rules_file).strip
+          }
+        end
+        
+        # Check for locale-specific rules
+        if target_locale
+          locale_rules_file = File.join(current_path, ".honyakurules.#{target_locale}")
+          if File.exist?(locale_rules_file)
+            rules << {
+              path: locale_rules_file,
+              content: File.read(locale_rules_file).strip,
+              locale_specific: true
+            }
+          end
+        end
+        
+        current_path = File.dirname(current_path)
+      end
+      
+      # Reverse to maintain root-to-local order, but ensure locale-specific rules come after general rules
+      rules.reverse.partition { |r| !r[:locale_specific] }.flatten
+    end
+
+    def process_file(file_path, translator, source_locale, target_locale)
+      # Check if this is a source locale file we should translate
+      source_pattern = /#{source_locale}(\/|\.yml)/
+      return unless file_path =~ source_pattern
+
+      # Generate the target filename
+      target_file = file_path.gsub(source_pattern, "#{target_locale}\\1")
+
+      # Only skip if target exists AND is newer (unless --force is used)
+      if File.exist?(target_file) && !options[:force]
+        source_time = get_last_modified_time(file_path)
+        target_time = get_last_modified_time(target_file)
+
+        if target_time && source_time && target_time > source_time
+          puts "⏭️  Skipping #{file_path} - translation is up to date"
+          return
+        end
+      end
+
+      puts "📝 Processing #{file_path}..."
+      
+      begin
+        attempts = 0
+        max_attempts = 3
+        
+        loop do
+          attempts += 1
+          begin
+            translated_content = translator.translate_hash(file_path, source_locale, target_locale)
+          rescue => e
+            puts "❌ Translation failed: #{e.message}"
+            break
+          end
+          
+          # Don't proceed if translation failed
+          if !translated_content || translated_content.strip.empty?
+            puts "❌ Translation failed - no content generated"
+            break
+          end
+
+          # Create directory and write file only if we have valid content
+          FileUtils.mkdir_p(File.dirname(target_file))
+          
+          # Backup if requested
+          if options[:backup] && File.exist?(target_file)
+            backup_path = "#{target_file}.bak"
+            FileUtils.cp(target_file, backup_path)
+          end
+          
+          # Write the translated content
+          File.write(target_file, translated_content)
+          puts "✨ Created #{target_file}"
+          
+          # Automatically fix any YAML issues
+          puts "🔧 Checking for YAML issues..."
+          begin
+            fixed_content = translator.fix_yaml(target_file)
+            if fixed_content != translated_content
+              if options[:backup] && !File.exist?("#{target_file}.bak")
+                FileUtils.cp(target_file, "#{target_file}.bak")
+              end
+              
+              File.write(target_file, fixed_content)
+              puts "✨ Fixed YAML formatting issues"
+            end
+            break # Success! Exit the loop
+          rescue => e
+            if e.message.include?("needs retranslation") && attempts < max_attempts
+              puts "⚠️  Translation attempt #{attempts} produced invalid YAML, retrying..."
+              # Clean up the file before retrying
+              File.unlink(target_file) if File.exist?(target_file)
+              next
+            else
+              # Clean up and re-raise
+              File.unlink(target_file) if File.exist?(target_file)
+              raise e
+            end
+          end
+        end
+      rescue => e
+        puts "❌ Error processing #{file_path}: #{e.message}"
+        # Ensure file is cleaned up if it was created
+        File.unlink(target_file) if File.exist?(target_file)
+      end
+    end
+
+    def fix_file(file_path, fixer)
+      puts "🔧 Fixing #{file_path}..."
+      
+      begin
+        # Backup if requested
+        if options[:backup]
+          backup_path = "#{file_path}.bak"
+          FileUtils.cp(file_path, backup_path)
+          puts "📑 Created backup at #{backup_path}"
+        end
+
+        fixed_content = fixer.fix_yaml(file_path)
+        File.write(file_path, fixed_content)
+        puts "✨ Fixed #{file_path}"
+      rescue => e
+        puts "❌ Error fixing #{file_path}: #{e.message}"
+      end
+    end
+
+    def get_last_modified_time(file_path)
+      times = []
+      
+      # Get git timestamp if available
+      if git_time = get_git_modified_time(file_path)
+        times << git_time
+      end
+      
+      # Get filesystem timestamp
+      if File.exist?(file_path)
+        times << File.mtime(file_path)
+      end
+      
+      # Return the newest timestamp (or nil if no timestamps found)
+      times.max
+    end
+
+    def get_git_modified_time(file_path)
+      return nil unless system("git rev-parse --is-inside-work-tree > /dev/null 2>&1")
+      
+      time_str = `git log -1 --format=%cd --date=iso -- #{file_path} 2>/dev/null`.strip
+      return nil if time_str.empty?
+      
+      Time.parse(time_str)
+    rescue
+      nil
+    end
+
+    desc "status", "Show translation status for all locales"
+    def status
+      puts "📊 Translation Status:"
+      # Status reporting logic will go here
+    end
+
+    desc "version", "Show Honyaku version"
+    def version
+      puts "Honyaku v#{Honyaku::VERSION}"
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+  end
+end 

data/lib/honyaku/translator.rb

@@ -0,0 +1,241 @@
+require "openai"
+require "yaml"
+
+module Honyaku
+  class Translator
+    LINES_PER_CHUNK = 250
+
+    def initialize(api_key: nil, model: "gpt-4", translation_rules: [])
+      api_key ||= ENV["HONYAKU_OPENAI_API_KEY"] || ENV["OPENAI_API_KEY"]
+      @client = OpenAI::Client.new(access_token: api_key)
+      @model = model
+      @translation_rules = translation_rules
+    end
+
+    def translate_hash(file_path, from_locale, to_locale)
+      yaml_content = File.read(file_path)
+      lines = yaml_content.lines
+      
+      # If the file is small enough, translate it all at once
+      if lines.size <= LINES_PER_CHUNK
+        result = translate_chunk(yaml_content, from_locale, to_locale)
+        raise "Translation failed" unless result
+        return result
+      end
+      
+      # Otherwise, split into chunks and translate each
+      chunks = split_into_chunks(lines)
+      puts "📦 Splitting file into #{chunks.size} chunks..."
+      
+      translated_chunks = []
+      
+      chunks.each_with_index do |chunk, i|
+        puts "🔄 Translating chunk #{i + 1} of #{chunks.size}..."
+        result = translate_chunk(chunk, from_locale, to_locale)
+        
+        # If any chunk fails, abort the whole translation
+        raise "Translation failed for chunk #{i + 1}" unless result
+        translated_chunks << result
+      end
+      
+      translated_chunks.join("\n")
+    end
+
+    def fix_yaml(file_path)
+      content = File.read(file_path)
+      fixed_any = false
+      
+      loop do
+        begin
+          YAML.load(content)
+          puts "✅ No more YAML errors found"
+          return content
+        rescue Psych::SyntaxError => e
+          # If OpenAI returned invalid YAML structure, signal that we need to retranslate
+          if e.message.include?("did not find expected key while parsing a block mapping")
+            raise "Translation resulted in invalid YAML structure - needs retranslation"
+          end
+
+          lines = content.lines
+          line_number = e.line - 1  # YAML errors are 1-based
+          problematic_line = lines[line_number]
+          
+          puts "🔧 Found YAML error on line #{e.line}: #{e.message}"
+          puts "   #{problematic_line.strip}"
+          
+          # Only try to fix common syntax issues
+          if e.message.include?("cannot start any token")
+            fixed = false
+
+            # Fix case 1: Values starting with %{var} need quotes
+            if problematic_line.include?("%{") && problematic_line =~ /^(\s*[^:]+:\s*)(?:(&\w+)\s+)?(%\{.+)$/
+              prefix, reference, value = $1, $2, $3
+              fixed_line = if reference
+                "#{prefix}#{reference} \"#{value}\""
+              else
+                "#{prefix}\"#{value}\""
+              end
+              fixed = true
+            # Fix case 2: Fix incorrect spacing in %{ var }
+            elsif problematic_line.include?("% {")
+              fixed_line = problematic_line.gsub("% {", "%{")
+              fixed = true
+            end
+
+            if fixed
+              # Update the line
+              lines[line_number] = "#{fixed_line}\n"
+              content = lines.join
+              fixed_any = true
+              next # Continue to the next iteration to find more errors
+            end
+          end
+          
+          # If we get here, we couldn't fix this error
+          if fixed_any
+            puts "❌ Unable to fix remaining YAML errors"
+          else
+            puts "❌ Unable to fix any YAML errors"
+          end
+          return content
+        end
+      end
+    end
+
+    private
+
+    def split_into_chunks(lines)
+      chunks = []
+      current_chunk = []
+      current_indent = 0
+      line_count = 0
+
+      lines.each do |line|
+        # Calculate the indentation level of the current line
+        indent = line[/\A */].length
+        
+        # Start a new chunk if we hit the line limit and we're at the root level
+        if line_count >= LINES_PER_CHUNK && indent <= current_indent
+          chunks << current_chunk.join
+          current_chunk = []
+          line_count = 0
+        end
+        
+        current_chunk << line
+        line_count += 1
+        current_indent = indent
+      end
+      
+      # Add the last chunk if there's anything left
+      chunks << current_chunk.join if current_chunk.any?
+      
+      chunks
+    end
+
+    def translate_chunk(content, from_locale, to_locale)
+      max_retries = 3
+      attempts = 0
+      
+      begin
+        attempts += 1
+        response = @client.chat(
+          parameters: {
+            model: @model,
+            messages: [
+              {
+                role: "system",
+                content: build_system_prompt
+              },
+              {
+                role: "user",
+                content: "Translate this YAML content from #{from_locale} to #{to_locale}. Keep all structure and special characters exactly the same:\n\n#{content}"
+              }
+            ],
+            temperature: 0.7
+          }
+        )
+
+        # Clean up any markdown code block markers
+        response_text = response.dig("choices", 0, "message", "content")
+        response_text.gsub(/^```ya?ml\s*\n/, '').gsub(/\n```\s*$/, '')
+      rescue => e
+        # Don't retry if it's a billing/credits issue
+        if e.message.include?("insufficient_quota") || e.message.include?("billing")
+          puts "❌ OpenAI API error: #{e.message}"
+          raise e
+        end
+
+        if attempts < max_retries
+          puts "⚠️  OpenAI API error, retrying (attempt #{attempts}/#{max_retries}): #{e.message}"
+          sleep(attempts) # Exponential backoff
+          retry
+        else
+          puts "❌ OpenAI API error after #{max_retries} attempts: #{e.message}"
+          raise e
+        end
+      end
+    end
+
+    def fix_line(line, error)
+      response = @client.chat(
+        parameters: {
+          model: @model,
+          messages: [
+            {
+              role: "system",
+              content: "You are a YAML expert. Fix the provided line to be valid YAML. Common issues include:
+              - Values starting with % need to be quoted
+              - Proper escaping of special characters
+              Return only the fixed line, no explanation needed."
+            },
+            {
+              role: "user",
+              content: "Fix this YAML line that generated this error: #{error}\n\nLine: #{line}"
+            }
+          ],
+          temperature: 0.3
+        }
+      )
+
+      response.dig("choices", 0, "message", "content").strip
+    rescue => e
+      puts "⚠️  Error getting fix suggestion: #{e.message}"
+      line
+    end
+
+    def build_system_prompt
+      base_prompt = <<~PROMPT
+        You are a professional translator. You will be translating YAML files.
+        
+        CRITICAL REQUIREMENTS:
+        1. Only translate text values after the colon (:)
+        2. Never modify, translate, or remove:
+           - YAML keys (text before the colon)
+           - Interpolation variables (like %{name})
+           - YAML references and anchors
+           - Comments
+           - Empty lines
+        3. Keep all special characters exactly as they appear
+        4. Maintain the exact same line count
+        5. Never add or remove lines
+        6. Never change the structure of the file
+      PROMPT
+
+      if @translation_rules.any?
+        general_rules, locale_rules = @translation_rules.partition { |r| !r[:locale_specific] }
+        
+        if general_rules.any?
+          base_prompt += "\n\nGeneral translation rules:\n" + 
+                        general_rules.map { |rule| rule[:content] }.join("\n\n")
+        end
+        
+        if locale_rules.any?
+          base_prompt += "\n\nTarget language specific rules:\n" + 
+                        locale_rules.map { |rule| rule[:content] }.join("\n\n")
+        end
+      end
+
+      base_prompt
+    end
+  end
+end 

data/lib/honyaku/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Honyaku
+  VERSION = "0.1.0"
+end

data/lib/honyaku.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "honyaku/version"
+require "honyaku/cli"
+require "honyaku/translator"
+
+module Honyaku
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: honyaku
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Culver
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description:
+email:
+- andrew.culver@gmail.com
+executables:
+- honyaku
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/honyaku
+- lib/honyaku.rb
+- lib/honyaku/cli.rb
+- lib/honyaku/translator.rb
+- lib/honyaku/version.rb
+homepage: https://github.com/andrewculver/honyaku
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/andrewculver/honyaku
+  source_code_uri: https://github.com/andrewculver/honyaku
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Translate your Rails application using OpenAI
+test_files: []