anki_generator 1.1.0 → 1.4.0

data/lib/anki_cli.rb

@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-
-require 'thor'
-require 'dotenv/load'
-require_relative 'anki_generator'
-require_relative 'file_processor'
-
-class AnkiCLI < Thor
-  desc 'generate DECK_NAME YAML_FILE OUTPUT_FILE', 'Generate an Anki .apkg deck from a YAML file'
-  option :api_key, type: :string, desc: 'OpenRouter API key (or set OPENROUTER_API_KEY env var)'
-  option :model, type: :string, default: 'openai/gpt-3.5-turbo', desc: 'AI model to use'
-  option :sync_with, type: :string, desc: 'Existing YAML file to sync with'
-  def generate(deck_name, yaml_file, output_file)
-    anki_generator = AnkiGenerator.new(
-      name: deck_name, 
-      deck_file: yaml_file,
-      api_key: options[:api_key],
-      model: options[:model]
-    )
-    
-    anki_generator.sync_with_existing_deck(options[:sync_with]) if options[:sync_with]
-    anki_generator.generate_apkg(output_path: output_file)
-    
-    puts "Anki deck '#{deck_name}' has been successfully created as #{output_file}!"
-    puts "Total cards: #{anki_generator.cards.length}"
-  end
-
-  desc 'generate_yaml PROMPT OUTPUT_YAML', 'Generate a YAML file from a prompt using AI'
-  option :api_key, type: :string, desc: 'OpenRouter API key (or set OPENROUTER_API_KEY env var)'
-  option :model, type: :string, default: 'openai/gpt-3.5-turbo', desc: 'AI model to use'
-  option :difficulty, type: :string, default: 'medium', desc: 'Difficulty level (easy, medium, hard)'
-  option :count, type: :numeric, default: 10, desc: 'Number of flashcards to generate'
-  option :context, type: :string, desc: 'Additional context for better generation'
-  option :attach, type: :array, desc: 'Attach files or directories for context'
-  option :prompt_file, type: :boolean, default: false, desc: 'Treat PROMPT as a file path to read from'
-  def generate_yaml(prompt, output_yaml)
-    begin
-      require_relative 'openrouter_client'
-      client = OpenRouterClient.new(api_key: options[:api_key], model: options[:model])
-      
-      # Handle prompt from file
-      actual_prompt = if options[:prompt_file]
-        puts "📄 Reading prompt from file: #{prompt}"
-        FileProcessor.read_prompt_from_file(prompt)
-      else
-        prompt
-      end
-      
-      # Process attachments
-      attachments = nil
-      if options[:attach]
-        puts "📎 Processing attachments..."
-        attachments = FileProcessor.process_attachments(options[:attach])
-      end
-      
-      puts "Generating flashcards for: #{actual_prompt[0..100]}#{'...' if actual_prompt.length > 100}"
-      puts "Model: #{client.model}"
-      puts "Difficulty: #{options[:difficulty]}"
-      puts "Count: #{options[:count]}"
-      puts "Attachments: #{attachments&.length || 0} file(s)" if attachments
-      puts "Generating..."
-      
-      # Generate flashcards using the prompt as topics
-      cards = client.generate_multiple_flashcards(
-        topics: [actual_prompt],
-        context: options[:context],
-        difficulty: options[:difficulty],
-        count: options[:count],
-        attachments: attachments
-      )
-      
-      # Create YAML structure
-      yaml_content = {
-        'ai_generation' => {
-          'topics' => [actual_prompt],
-          'context' => options[:context],
-          'difficulty' => options[:difficulty],
-          'count' => options[:count],
-          'save_generated' => false
-        },
-        'cards' => cards
-      }
-      
-      # Write to file
-      File.open(output_yaml, 'w') do |file|
-        file.write(yaml_content.to_yaml)
-      end
-      
-      puts "✅ Generated #{cards.length} flashcards!"
-      puts "YAML file created: #{output_yaml}"
-      puts ""
-      puts "Preview of generated cards:"
-      cards.first(3).each_with_index do |card, index|
-        puts "#{index + 1}. #{card['front']}"
-        puts "   → #{card['back'][0..100]}#{'...' if card['back'].length > 100}"
-        puts ""
-      end
-      
-      puts "To create an Anki deck, run:"
-      puts "  anki_generator generate \"My Deck\" #{output_yaml} my_deck.apkg"
-      
-    rescue => e
-      puts "❌ Error generating flashcards: #{e.message}"
-      exit 1
-    end
-  end
-
-  desc 'prompt_to_deck PROMPT DECK_NAME OUTPUT_FILE', 'Generate flashcards from prompt and create deck in one step'
-  option :api_key, type: :string, desc: 'OpenRouter API key (or set OPENROUTER_API_KEY env var)'
-  option :model, type: :string, default: 'openai/gpt-3.5-turbo', desc: 'AI model to use'
-  option :difficulty, type: :string, default: 'medium', desc: 'Difficulty level (easy, medium, hard)'
-  option :count, type: :numeric, default: 10, desc: 'Number of flashcards to generate'
-  option :context, type: :string, desc: 'Additional context for better generation'
-  option :save_yaml, type: :boolean, default: false, desc: 'Save intermediate YAML file'
-  option :attach, type: :array, desc: 'Attach files or directories for context'
-  option :prompt_file, type: :boolean, default: false, desc: 'Treat PROMPT as a file path to read from'
-  def prompt_to_deck(prompt, deck_name, output_file)
-    begin
-      require_relative 'openrouter_client'
-      client = OpenRouterClient.new(api_key: options[:api_key], model: options[:model])
-      
-      # Handle prompt from file
-      actual_prompt = if options[:prompt_file]
-        puts "📄 Reading prompt from file: #{prompt}"
-        FileProcessor.read_prompt_from_file(prompt)
-      else
-        prompt
-      end
-      
-      # Process attachments
-      attachments = nil
-      if options[:attach]
-        puts "📎 Processing attachments..."
-        attachments = FileProcessor.process_attachments(options[:attach])
-      end
-      
-      puts "🚀 Generating Anki deck from prompt: #{actual_prompt[0..100]}#{'...' if actual_prompt.length > 100}"
-      puts "Model: #{client.model}"
-      puts "Difficulty: #{options[:difficulty]}"
-      puts "Count: #{options[:count]}"
-      puts "Attachments: #{attachments&.length || 0} file(s)" if attachments
-      puts ""
-      
-      # Generate flashcards
-      puts "Generating flashcards..."
-      cards = client.generate_multiple_flashcards(
-        topics: [actual_prompt],
-        context: options[:context],
-        difficulty: options[:difficulty],
-        count: options[:count],
-        attachments: attachments
-      )
-      
-      puts "✅ Generated #{cards.length} flashcards!"
-      
-      # Create temporary YAML file
-      temp_yaml = "temp_#{Time.now.to_i}.yaml"
-      yaml_content = {
-        'ai_generation' => {
-          'topics' => [actual_prompt],
-          'context' => options[:context],
-          'difficulty' => options[:difficulty],
-          'count' => options[:count],
-          'save_generated' => false
-        },
-        'cards' => cards
-      }
-      
-      File.open(temp_yaml, 'w') do |file|
-        file.write(yaml_content.to_yaml)
-      end
-      
-      # Generate Anki deck
-      puts "Creating Anki deck..."
-      anki_generator = AnkiGenerator.new(
-        name: deck_name,
-        deck_file: temp_yaml,
-        api_key: options[:api_key],
-        model: options[:model]
-      )
-      
-      anki_generator.generate_apkg(output_path: output_file)
-      
-      # Clean up or save YAML
-      if options[:save_yaml]
-        yaml_file = output_file.gsub('.apkg', '.yaml')
-        File.rename(temp_yaml, yaml_file)
-        puts "YAML file saved: #{yaml_file}"
-      else
-        File.delete(temp_yaml)
-      end
-      
-      puts "🎉 Anki deck '#{deck_name}' created successfully!"
-      puts "File: #{output_file}"
-      puts "Total cards: #{cards.length}"
-      puts ""
-      puts "Preview of generated cards:"
-      cards.first(3).each_with_index do |card, index|
-        puts "#{index + 1}. #{card['front']}"
-        puts "   → #{card['back'][0..100]}#{'...' if card['back'].length > 100}"
-        puts ""
-      end
-      
-    rescue => e
-      puts "❌ Error: #{e.message}"
-      exit 1
-    end
-  end
-
-  desc 'create_ai_template TEMPLATE_FILE', 'Create a template YAML file for AI generation'
-  def create_ai_template(template_file)
-    template_content = {
-      'ai_generation' => {
-        'topics' => ['Example Topic 1', 'Example Topic 2'],
-        'context' => 'Additional context for generating flashcards',
-        'difficulty' => 'medium',
-        'count' => 5,
-        'save_generated' => true
-      },
-      'cards' => [
-        {
-          'front' => 'Example manual card front',
-          'back' => 'Example manual card back'
-        }
-      ]
-    }
-
-    File.open(template_file, 'w') do |file|
-      file.write(template_content.to_yaml)
-    end
-
-    puts "AI generation template created: #{template_file}"
-    puts "Edit the file and run 'anki_generator generate' to create your deck!"
-  end
-
-  desc 'test_api', 'Test OpenRouter API connection'
-  option :api_key, type: :string, desc: 'OpenRouter API key (or set OPENROUTER_API_KEY env var)'
-  option :model, type: :string, default: 'openai/gpt-3.5-turbo', desc: 'AI model to use'
-  def test_api
-    begin
-      require_relative 'openrouter_client'
-      client = OpenRouterClient.new(api_key: options[:api_key], model: options[:model])
-      
-      puts "Testing OpenRouter API connection..."
-      puts "Model: #{client.model}"
-      
-      card = client.generate_flashcard(topic: 'Ruby programming', difficulty: 'easy')
-      
-      puts "✅ API connection successful!"
-      puts "Sample generated card:"
-      puts "Front: #{card['front']}"
-      puts "Back: #{card['back']}"
-      
-    rescue => e
-      puts "❌ API test failed: #{e.message}"
-      exit 1
-    end
-  end
-end

data/lib/file_processor.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-
-# FileProcessor -> Handles file and directory processing for attachments
-class FileProcessor
-  # Supported text file extensions
-  TEXT_EXTENSIONS = %w[.txt .md .rb .py .js .ts .java .cpp .c .h .hpp .css .html .xml .json .yaml .yml .sql .sh .bat .ps1 .php .go .rs .swift .kt .scala .clj .hs .elm .ex .exs .erl .pl .r .m .tex .org .rst .adoc].freeze
-  
-  # Maximum file size in bytes (1MB)
-  MAX_FILE_SIZE = 1_048_576
-  
-  # Maximum total content size (5MB)
-  MAX_TOTAL_SIZE = 5_242_880
-
-  def self.process_attachments(paths)
-    return [] if paths.nil? || paths.empty?
-    
-    attachments = []
-    total_size = 0
-    
-    paths.each do |path_str|
-      path = Pathname.new(path_str)
-      
-      unless path.exist?
-        puts "⚠️  Warning: Path does not exist: #{path_str}"
-        next
-      end
-      
-      if path.directory?
-        dir_attachments = process_directory(path)
-        dir_attachments.each do |attachment|
-          if total_size + attachment[:content].bytesize > MAX_TOTAL_SIZE
-            puts "⚠️  Warning: Total attachment size limit reached. Skipping remaining files."
-            break
-          end
-          attachments << attachment
-          total_size += attachment[:content].bytesize
-        end
-      elsif path.file?
-        attachment = process_file(path)
-        if attachment
-          if total_size + attachment[:content].bytesize > MAX_TOTAL_SIZE
-            puts "⚠️  Warning: Total attachment size limit reached. Skipping #{path_str}"
-          else
-            attachments << attachment
-            total_size += attachment[:content].bytesize
-          end
-        end
-      else
-        puts "⚠️  Warning: Path is neither file nor directory: #{path_str}"
-      end
-    end
-    
-    puts "📎 Processed #{attachments.length} file(s) (#{format_size(total_size)})" if attachments.any?
-    attachments
-  end
-
-  def self.process_directory(dir_path)
-    attachments = []
-    
-    # Find all text files in directory (non-recursive for now)
-    dir_path.children.each do |child|
-      next unless child.file?
-      
-      attachment = process_file(child)
-      attachments << attachment if attachment
-    end
-    
-    attachments
-  end
-
-  def self.process_file(file_path)
-    # Check file size
-    if file_path.size > MAX_FILE_SIZE
-      puts "⚠️  Warning: File too large, skipping: #{file_path} (#{format_size(file_path.size)})"
-      return nil
-    end
-    
-    # Check if it's a text file
-    unless text_file?(file_path)
-      puts "⚠️  Warning: Non-text file, skipping: #{file_path}"
-      return nil
-    end
-    
-    begin
-      content = file_path.read(encoding: 'UTF-8')
-      
-      # Truncate if too long
-      if content.bytesize > MAX_FILE_SIZE
-        content = content.byteslice(0, MAX_FILE_SIZE) + "\n... [truncated]"
-      end
-      
-      {
-        filename: file_path.basename.to_s,
-        path: file_path.to_s,
-        content: content
-      }
-    rescue => e
-      puts "⚠️  Warning: Could not read file #{file_path}: #{e.message}"
-      nil
-    end
-  end
-
-  def self.text_file?(file_path)
-    # Check extension
-    ext = file_path.extname.downcase
-    return true if TEXT_EXTENSIONS.include?(ext)
-    
-    # For files without extension, try to detect if it's text
-    return false if file_path.extname.empty? && file_path.basename.to_s !~ /^[A-Z_]+$/
-    
-    # Try to read first few bytes to detect binary files
-    begin
-      sample = file_path.read(512, encoding: 'BINARY')
-      # If it contains null bytes, it's likely binary
-      !sample.include?("\x00")
-    rescue
-      false
-    end
-  end
-
-  def self.format_size(bytes)
-    if bytes < 1024
-      "#{bytes} B"
-    elsif bytes < 1024 * 1024
-      "#{(bytes / 1024.0).round(1)} KB"
-    else
-      "#{(bytes / (1024.0 * 1024)).round(1)} MB"
-    end
-  end
-
-  def self.read_prompt_from_file(file_path)
-    path = Pathname.new(file_path)
-    
-    unless path.exist?
-      raise "Prompt file does not exist: #{file_path}"
-    end
-    
-    unless path.file?
-      raise "Prompt path is not a file: #{file_path}"
-    end
-    
-    begin
-      content = path.read(encoding: 'UTF-8').strip
-      
-      if content.empty?
-        raise "Prompt file is empty: #{file_path}"
-      end
-      
-      content
-    rescue => e
-      raise "Could not read prompt file #{file_path}: #{e.message}"
-    end
-  end
-end

data/lib/openrouter_client.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'json'
-require 'dotenv/load'
-
-# OpenRouterClient -> API client for OpenRouter
-class OpenRouterClient
-  BASE_URL = 'https://openrouter.ai/api/v1'
-  
-  attr_reader :api_key, :model
-
-  def initialize(api_key: nil, model: 'openai/gpt-3.5-turbo')
-    @api_key = api_key || ENV['OPENROUTER_API_KEY']
-    @model = model
-    
-    raise ArgumentError, 'API key is required' if @api_key.nil? || @api_key.empty?
-  end
-
-  def generate_flashcard(topic:, context: nil, difficulty: 'medium', attachments: nil)
-    prompt = build_flashcard_prompt(topic: topic, context: context, difficulty: difficulty, attachments: attachments)
-    
-    response = make_request(prompt)
-    parse_flashcard_response(response)
-  end
-
-  def generate_multiple_flashcards(topics:, context: nil, difficulty: 'medium', count: 5, attachments: nil)
-    prompt = build_multiple_flashcards_prompt(
-      topics: topics, 
-      context: context, 
-      difficulty: difficulty, 
-      count: count,
-      attachments: attachments
-    )
-    
-    response = make_request(prompt)
-    parse_multiple_flashcards_response(response)
-  end
-
-  private
-
-  def connection
-    @connection ||= Faraday.new(url: BASE_URL) do |conn|
-      conn.request :json
-      conn.response :json
-      conn.adapter Faraday.default_adapter
-      conn.headers['Authorization'] = "Bearer #{@api_key}"
-      conn.headers['Content-Type'] = 'application/json'
-    end
-  end
-
-  def make_request(prompt)
-    response = connection.post('/chat/completions') do |req|
-      req.body = {
-        model: @model,
-        messages: [
-          {
-            role: 'user',
-            content: prompt
-          }
-        ],
-        temperature: 0.7,
-        max_tokens: 1000
-      }
-    end
-
-    handle_response(response)
-  end
-
-  def handle_response(response)
-    unless response.success?
-      raise "OpenRouter API error: #{response.status} - #{response.body}"
-    end
-
-    response.body.dig('choices', 0, 'message', 'content')
-  end
-
-  def build_flashcard_prompt(topic:, context:, difficulty:, attachments:)
-    base_prompt = <<~PROMPT
-      Create a single flashcard for the topic: "#{topic}"
-      Difficulty level: #{difficulty}
-      #{context ? "Additional context: #{context}" : ''}
-      
-      #{build_attachments_section(attachments) if attachments}
-      
-      Format your response as JSON with exactly this structure:
-      {
-        "front": "Question or prompt",
-        "back": "Answer or explanation"
-      }
-      
-      Make the flashcard educational and appropriate for the #{difficulty} difficulty level.
-      For the back side, provide a clear, concise explanation.
-      #{attachments ? "Use the provided file content to create more accurate and detailed flashcards." : ""}
-    PROMPT
-
-    base_prompt.strip
-  end
-
-  def build_multiple_flashcards_prompt(topics:, context:, difficulty:, count:, attachments:)
-    topics_list = topics.is_a?(Array) ? topics.join(', ') : topics.to_s
-    
-    base_prompt = <<~PROMPT
-      Create #{count} flashcards covering these topics: #{topics_list}
-      Difficulty level: #{difficulty}
-      #{context ? "Additional context: #{context}" : ''}
-      
-      #{build_attachments_section(attachments) if attachments}
-      
-      Format your response as JSON with exactly this structure:
-      [
-        {
-          "front": "Question or prompt 1",
-          "back": "Answer or explanation 1"
-        },
-        {
-          "front": "Question or prompt 2", 
-          "back": "Answer or explanation 2"
-        }
-      ]
-      
-      Make the flashcards educational, diverse, and appropriate for the #{difficulty} difficulty level.
-      Ensure each flashcard covers different aspects of the topics.
-      #{attachments ? "Use the provided file content to create more accurate and detailed flashcards based on the specific information in the files." : ""}
-    PROMPT
-
-    base_prompt.strip
-  end
-
-  def parse_flashcard_response(response)
-    JSON.parse(response)
-  rescue JSON::ParserError => e
-    raise "Failed to parse OpenRouter response as JSON: #{e.message}"
-  end
-
-  def parse_multiple_flashcards_response(response)
-    parsed = JSON.parse(response)
-    
-    # Ensure we return an array
-    parsed.is_a?(Array) ? parsed : [parsed]
-  rescue JSON::ParserError => e
-    raise "Failed to parse OpenRouter response as JSON: #{e.message}"
-  end
-
-  def build_attachments_section(attachments)
-    return "" unless attachments && !attachments.empty?
-    
-    section = "=== ATTACHED FILE CONTENT ===\n\n"
-    
-    attachments.each do |attachment|
-      section += "--- #{attachment[:filename]} ---\n"
-      section += "#{attachment[:content]}\n\n"
-    end
-    
-    section += "=== END ATTACHED CONTENT ===\n"
-    section
-  end
-end