ruby_llm-agents 0.4.0 → 1.0.0.beta.1

data/lib/generators/ruby_llm_agents/background_remover_generator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLlmAgents
+  # BackgroundRemover generator for creating new background removers
+  #
+  # Usage:
+  #   rails generate ruby_llm_agents:background_remover Product
+  #   rails generate ruby_llm_agents:background_remover Portrait --model segment-anything --alpha_matting
+  #   rails generate ruby_llm_agents:background_remover Photo --refine_edges --return_mask
+  #   rails generate ruby_llm_agents:background_remover Product --root=ai
+  #
+  # This will create:
+  #   - app/{root}/image/background_removers/product_background_remover.rb
+  #
+  class BackgroundRemoverGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :model, type: :string, default: "rembg",
+                 desc: "The segmentation model to use"
+    class_option :output_format, type: :string, default: "png",
+                 desc: "Output format (png, webp)"
+    class_option :refine_edges, type: :boolean, default: false,
+                 desc: "Enable edge refinement"
+    class_option :alpha_matting, type: :boolean, default: false,
+                 desc: "Enable alpha matting for better edges"
+    class_option :return_mask, type: :boolean, default: false,
+                 desc: "Also return the segmentation mask"
+    class_option :cache, type: :string, default: nil,
+                 desc: "Cache TTL (e.g., '1.hour', '1.day')"
+    class_option :root,
+                 type: :string,
+                 default: nil,
+                 desc: "Root directory name (default: uses config or 'llm')"
+    class_option :namespace,
+                 type: :string,
+                 default: nil,
+                 desc: "Root namespace (default: camelized root or config)"
+
+    def ensure_base_class_and_skill_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      removers_dir = "app/#{root_directory}/image/background_removers"
+
+      # Create directory if needed
+      empty_directory removers_dir
+
+      # Create base class if it doesn't exist
+      base_class_path = "#{removers_dir}/application_background_remover.rb"
+      unless File.exist?(File.join(destination_root, base_class_path))
+        template "application_background_remover.rb.tt", base_class_path
+      end
+
+      # Create skill file if it doesn't exist
+      skill_file_path = "#{removers_dir}/BACKGROUND_REMOVERS.md"
+      unless File.exist?(File.join(destination_root, skill_file_path))
+        template "skills/BACKGROUND_REMOVERS.md.tt", skill_file_path
+      end
+    end
+
+    def create_background_remover_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      remover_path = name.underscore
+      template "background_remover.rb.tt", "app/#{root_directory}/image/background_removers/#{remover_path}_background_remover.rb"
+    end
+
+    def show_usage
+      remover_class_name = name.split("/").map(&:camelize).join("::")
+      full_class_name = "#{root_namespace}::Image::#{remover_class_name}BackgroundRemover"
+      say ""
+      say "Background remover #{full_class_name} created!", :green
+      say ""
+      say "Usage:"
+      say "  # Remove background from an image"
+      say "  result = #{full_class_name}.call(image: 'photo.jpg')"
+      say "  result.url        # => 'https://...' (transparent PNG)"
+      say "  result.has_alpha? # => true"
+      say ""
+      say "  # Override settings at runtime"
+      say "  result = #{full_class_name}.call("
+      say "    image: 'portrait.jpg',"
+      say "    alpha_matting: true,"
+      say "    return_mask: true"
+      say "  )"
+      say ""
+      say "  # Access the segmentation mask"
+      say "  result.mask_url  # => 'https://...' (if return_mask was enabled)"
+      say ""
+    end
+
+    private
+
+    def root_directory
+      @root_directory ||= options[:root] || RubyLLM::Agents.configuration.root_directory
+    end
+
+    def root_namespace
+      @root_namespace ||= options[:namespace] || camelize(root_directory)
+    end
+
+    def camelize(str)
+      return "AI" if str.downcase == "ai"
+      return "ML" if str.downcase == "ml"
+      return "LLM" if str.downcase == "llm"
+      str.split(/[-_]/).map(&:capitalize).join
+    end
+  end
+end

data/lib/generators/ruby_llm_agents/embedder_generator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLlmAgents
+  # Embedder generator for creating new embedders
+  #
+  # Usage:
+  #   rails generate ruby_llm_agents:embedder Document
+  #   rails generate ruby_llm_agents:embedder Document --model text-embedding-3-large
+  #   rails generate ruby_llm_agents:embedder Document --dimensions 512
+  #   rails generate ruby_llm_agents:embedder Document --root=ai
+  #
+  # This will create:
+  #   - app/{root}/text/embedders/document_embedder.rb
+  #
+  class EmbedderGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :model, type: :string, default: "text-embedding-3-small",
+                 desc: "The embedding model to use"
+    class_option :dimensions, type: :numeric, default: nil,
+                 desc: "Vector dimensions (nil for model default)"
+    class_option :batch_size, type: :numeric, default: 100,
+                 desc: "Texts per API call for batch processing"
+    class_option :cache, type: :string, default: nil,
+                 desc: "Cache TTL (e.g., '1.week', '1.day')"
+    class_option :root,
+                 type: :string,
+                 default: nil,
+                 desc: "Root directory name (default: uses config or 'llm')"
+    class_option :namespace,
+                 type: :string,
+                 default: nil,
+                 desc: "Root namespace (default: camelized root or config)"
+
+    def ensure_base_class_and_skill_file
+      @root_namespace = root_namespace
+      @text_namespace = "#{root_namespace}::Text"
+      embedders_dir = "app/#{root_directory}/text/embedders"
+
+      # Create directory if needed
+      empty_directory embedders_dir
+
+      # Create base class if it doesn't exist
+      base_class_path = "#{embedders_dir}/application_embedder.rb"
+      unless File.exist?(File.join(destination_root, base_class_path))
+        template "application_embedder.rb.tt", base_class_path
+      end
+
+      # Create skill file if it doesn't exist
+      skill_file_path = "#{embedders_dir}/EMBEDDERS.md"
+      unless File.exist?(File.join(destination_root, skill_file_path))
+        template "skills/EMBEDDERS.md.tt", skill_file_path
+      end
+    end
+
+    def create_embedder_file
+      # Support nested paths: "search/document" -> "app/{root}/text/embedders/search/document_embedder.rb"
+      @root_namespace = root_namespace
+      @text_namespace = "#{root_namespace}::Text"
+      embedder_path = name.underscore
+      template "embedder.rb.tt", "app/#{root_directory}/text/embedders/#{embedder_path}_embedder.rb"
+    end
+
+    def show_usage
+      # Build full class name from path
+      embedder_class_name = name.split("/").map(&:camelize).join("::")
+      full_class_name = "#{root_namespace}::Text::#{embedder_class_name}Embedder"
+      say ""
+      say "Embedder #{full_class_name} created!", :green
+      say ""
+      say "Usage:"
+      say "  # Single text"
+      say "  #{full_class_name}.call(text: \"Hello world\")"
+      say ""
+      say "  # Multiple texts (batch)"
+      say "  #{full_class_name}.call(texts: [\"Hello\", \"World\"])"
+      say ""
+      say "  # With progress tracking"
+      say "  #{full_class_name}.call(texts: large_array) do |batch, idx|"
+      say "    puts \"Processed batch \#{idx}\""
+      say "  end"
+      say ""
+    end
+
+    private
+
+    def root_directory
+      @root_directory ||= options[:root] || RubyLLM::Agents.configuration.root_directory
+    end
+
+    def root_namespace
+      @root_namespace ||= options[:namespace] || camelize(root_directory)
+    end
+
+    def camelize(str)
+      # Handle special cases for common abbreviations
+      return "AI" if str.downcase == "ai"
+      return "ML" if str.downcase == "ml"
+      return "LLM" if str.downcase == "llm"
+
+      # Standard camelization
+      str.split(/[-_]/).map(&:capitalize).join
+    end
+  end
+end

data/lib/generators/ruby_llm_agents/image_analyzer_generator.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLlmAgents
+  # ImageAnalyzer generator for creating new image analyzers
+  #
+  # Usage:
+  #   rails generate ruby_llm_agents:image_analyzer Product
+  #   rails generate ruby_llm_agents:image_analyzer Content --model gpt-4o --analysis_type detailed
+  #   rails generate ruby_llm_agents:image_analyzer Photo --extract_colors --detect_objects
+  #   rails generate ruby_llm_agents:image_analyzer Product --root=ai
+  #
+  # This will create:
+  #   - app/{root}/image/analyzers/product_analyzer.rb
+  #
+  class ImageAnalyzerGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :model, type: :string, default: "gpt-4o",
+                 desc: "The vision model to use"
+    class_option :analysis_type, type: :string, default: "detailed",
+                 desc: "Analysis type (caption, detailed, tags, objects, colors, all)"
+    class_option :extract_colors, type: :boolean, default: false,
+                 desc: "Enable color extraction"
+    class_option :detect_objects, type: :boolean, default: false,
+                 desc: "Enable object detection"
+    class_option :extract_text, type: :boolean, default: false,
+                 desc: "Enable text extraction (OCR)"
+    class_option :max_tags, type: :string, default: "10",
+                 desc: "Maximum number of tags to return"
+    class_option :cache, type: :string, default: nil,
+                 desc: "Cache TTL (e.g., '1.hour', '1.day')"
+    class_option :root,
+                 type: :string,
+                 default: nil,
+                 desc: "Root directory name (default: uses config or 'llm')"
+    class_option :namespace,
+                 type: :string,
+                 default: nil,
+                 desc: "Root namespace (default: camelized root or config)"
+
+    def ensure_base_class_and_skill_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      analyzers_dir = "app/#{root_directory}/image/analyzers"
+
+      # Create directory if needed
+      empty_directory analyzers_dir
+
+      # Create base class if it doesn't exist
+      base_class_path = "#{analyzers_dir}/application_image_analyzer.rb"
+      unless File.exist?(File.join(destination_root, base_class_path))
+        template "application_image_analyzer.rb.tt", base_class_path
+      end
+
+      # Create skill file if it doesn't exist
+      skill_file_path = "#{analyzers_dir}/IMAGE_ANALYZERS.md"
+      unless File.exist?(File.join(destination_root, skill_file_path))
+        template "skills/IMAGE_ANALYZERS.md.tt", skill_file_path
+      end
+    end
+
+    def create_image_analyzer_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      analyzer_path = name.underscore
+      template "image_analyzer.rb.tt", "app/#{root_directory}/image/analyzers/#{analyzer_path}_analyzer.rb"
+    end
+
+    def show_usage
+      analyzer_class_name = name.split("/").map(&:camelize).join("::")
+      full_class_name = "#{root_namespace}::Image::#{analyzer_class_name}Analyzer"
+      say ""
+      say "Image analyzer #{full_class_name} created!", :green
+      say ""
+      say "Usage:"
+      say "  # Analyze an image"
+      say "  result = #{full_class_name}.call(image: 'photo.jpg')"
+      say "  result.caption      # => 'A sunset over mountains'"
+      say "  result.tags         # => ['sunset', 'mountains', 'nature']"
+      say "  result.description  # => 'Detailed description...'"
+      say ""
+      say "  # Override settings at runtime"
+      say "  result = #{full_class_name}.call("
+      say "    image: 'product.jpg',"
+      say "    analysis_type: :all,"
+      say "    extract_colors: true,"
+      say "    detect_objects: true"
+      say "  )"
+      say ""
+      say "  # Access detected objects and colors"
+      say "  result.objects  # => [{name: 'laptop', location: 'center', confidence: 'high'}]"
+      say "  result.colors   # => [{hex: '#C0C0C0', name: 'silver', percentage: 45}]"
+      say ""
+    end
+
+    private
+
+    def root_directory
+      @root_directory ||= options[:root] || RubyLLM::Agents.configuration.root_directory
+    end
+
+    def root_namespace
+      @root_namespace ||= options[:namespace] || camelize(root_directory)
+    end
+
+    def camelize(str)
+      return "AI" if str.downcase == "ai"
+      return "ML" if str.downcase == "ml"
+      return "LLM" if str.downcase == "llm"
+      str.split(/[-_]/).map(&:capitalize).join
+    end
+  end
+end

data/lib/generators/ruby_llm_agents/image_editor_generator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLlmAgents
+  # ImageEditor generator for creating new image editors
+  #
+  # Usage:
+  #   rails generate ruby_llm_agents:image_editor Product
+  #   rails generate ruby_llm_agents:image_editor Background --model gpt-image-1 --size 1024x1024
+  #   rails generate ruby_llm_agents:image_editor Photo --content_policy strict
+  #   rails generate ruby_llm_agents:image_editor Product --root=ai
+  #
+  # This will create:
+  #   - app/{root}/image/editors/product_editor.rb
+  #
+  class ImageEditorGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :model, type: :string, default: "gpt-image-1",
+                 desc: "The image model to use"
+    class_option :size, type: :string, default: "1024x1024",
+                 desc: "Output image size (e.g., 1024x1024)"
+    class_option :content_policy, type: :string, default: "standard",
+                 desc: "Content policy level (none, standard, moderate, strict)"
+    class_option :cache, type: :string, default: nil,
+                 desc: "Cache TTL (e.g., '1.hour', '1.day')"
+    class_option :root,
+                 type: :string,
+                 default: nil,
+                 desc: "Root directory name (default: uses config or 'llm')"
+    class_option :namespace,
+                 type: :string,
+                 default: nil,
+                 desc: "Root namespace (default: camelized root or config)"
+
+    def ensure_base_class_and_skill_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      editors_dir = "app/#{root_directory}/image/editors"
+
+      # Create directory if needed
+      empty_directory editors_dir
+
+      # Create base class if it doesn't exist
+      base_class_path = "#{editors_dir}/application_image_editor.rb"
+      unless File.exist?(File.join(destination_root, base_class_path))
+        template "application_image_editor.rb.tt", base_class_path
+      end
+
+      # Create skill file if it doesn't exist
+      skill_file_path = "#{editors_dir}/IMAGE_EDITORS.md"
+      unless File.exist?(File.join(destination_root, skill_file_path))
+        template "skills/IMAGE_EDITORS.md.tt", skill_file_path
+      end
+    end
+
+    def create_image_editor_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      editor_path = name.underscore
+      template "image_editor.rb.tt", "app/#{root_directory}/image/editors/#{editor_path}_editor.rb"
+    end
+
+    def show_usage
+      editor_class_name = name.split("/").map(&:camelize).join("::")
+      full_class_name = "#{root_namespace}::Image::#{editor_class_name}Editor"
+      say ""
+      say "Image editor #{full_class_name} created!", :green
+      say ""
+      say "Usage:"
+      say "  # Edit an image with a mask"
+      say "  result = #{full_class_name}.call("
+      say "    image: 'photo.png',"
+      say "    mask: 'mask.png',"
+      say "    prompt: 'Replace the background with a beach scene'"
+      say "  )"
+      say "  result.url  # => 'https://...'"
+      say ""
+      say "  # Generate multiple edit variations"
+      say "  result = #{full_class_name}.call("
+      say "    image: 'photo.png',"
+      say "    mask: 'mask.png',"
+      say "    prompt: 'Add a sunset',"
+      say "    count: 3"
+      say "  )"
+      say "  result.urls  # => ['https://...', ...]"
+      say ""
+    end
+
+    private
+
+    def root_directory
+      @root_directory ||= options[:root] || RubyLLM::Agents.configuration.root_directory
+    end
+
+    def root_namespace
+      @root_namespace ||= options[:namespace] || camelize(root_directory)
+    end
+
+    def camelize(str)
+      return "AI" if str.downcase == "ai"
+      return "ML" if str.downcase == "ml"
+      return "LLM" if str.downcase == "llm"
+      str.split(/[-_]/).map(&:capitalize).join
+    end
+  end
+end

data/lib/generators/ruby_llm_agents/image_generator_generator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLlmAgents
+  # ImageGenerator generator for creating new image generators
+  #
+  # Usage:
+  #   rails generate ruby_llm_agents:image_generator Logo
+  #   rails generate ruby_llm_agents:image_generator Product --model gpt-image-1 --size 1024x1024
+  #   rails generate ruby_llm_agents:image_generator Avatar --quality hd --style vivid
+  #   rails generate ruby_llm_agents:image_generator Logo --root=ai
+  #
+  # This will create:
+  #   - app/{root}/image/generators/logo_generator.rb
+  #
+  class ImageGeneratorGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :model, type: :string, default: "gpt-image-1",
+                 desc: "The image generation model to use"
+    class_option :size, type: :string, default: "1024x1024",
+                 desc: "Image size (e.g., 1024x1024, 1792x1024)"
+    class_option :quality, type: :string, default: "standard",
+                 desc: "Image quality (standard, hd)"
+    class_option :style, type: :string, default: "vivid",
+                 desc: "Image style (vivid, natural)"
+    class_option :content_policy, type: :string, default: "standard",
+                 desc: "Content policy level (none, standard, moderate, strict)"
+    class_option :cache, type: :string, default: nil,
+                 desc: "Cache TTL (e.g., '1.hour', '1.day')"
+    class_option :root,
+                 type: :string,
+                 default: nil,
+                 desc: "Root directory name (default: uses config or 'llm')"
+    class_option :namespace,
+                 type: :string,
+                 default: nil,
+                 desc: "Root namespace (default: camelized root or config)"
+
+    def ensure_base_class_and_skill_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      generators_dir = "app/#{root_directory}/image/generators"
+
+      # Create directory if needed
+      empty_directory generators_dir
+
+      # Create base class if it doesn't exist
+      base_class_path = "#{generators_dir}/application_image_generator.rb"
+      unless File.exist?(File.join(destination_root, base_class_path))
+        template "application_image_generator.rb.tt", base_class_path
+      end
+
+      # Create skill file if it doesn't exist
+      skill_file_path = "#{generators_dir}/IMAGE_GENERATORS.md"
+      unless File.exist?(File.join(destination_root, skill_file_path))
+        template "skills/IMAGE_GENERATORS.md.tt", skill_file_path
+      end
+    end
+
+    def create_image_generator_file
+      # Support nested paths: "product/hero" -> "app/{root}/image/generators/product/hero_generator.rb"
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      generator_path = name.underscore
+      template "image_generator.rb.tt", "app/#{root_directory}/image/generators/#{generator_path}_generator.rb"
+    end
+
+    def show_usage
+      # Build full class name from path
+      generator_class_name = name.split("/").map(&:camelize).join("::")
+      full_class_name = "#{root_namespace}::Image::#{generator_class_name}Generator"
+      say ""
+      say "Image generator #{full_class_name} created!", :green
+      say ""
+      say "Usage:"
+      say "  # Generate a single image"
+      say "  result = #{full_class_name}.call(prompt: \"A beautiful sunset\")"
+      say "  result.url        # => \"https://...\""
+      say "  result.save(\"sunset.png\")"
+      say ""
+      say "  # Generate multiple images"
+      say "  result = #{full_class_name}.call(prompt: \"Logos\", count: 4)"
+      say "  result.urls       # => [\"https://...\", ...]"
+      say ""
+      say "  # Override settings at runtime"
+      say "  result = #{full_class_name}.call("
+      say "    prompt: \"High quality portrait\","
+      say "    quality: \"hd\","
+      say "    size: \"1792x1024\""
+      say "  )"
+      say ""
+    end
+
+    private
+
+    def root_directory
+      @root_directory ||= options[:root] || RubyLLM::Agents.configuration.root_directory
+    end
+
+    def root_namespace
+      @root_namespace ||= options[:namespace] || camelize(root_directory)
+    end
+
+    def camelize(str)
+      # Handle special cases for common abbreviations
+      return "AI" if str.downcase == "ai"
+      return "ML" if str.downcase == "ml"
+      return "LLM" if str.downcase == "llm"
+
+      # Standard camelization
+      str.split(/[-_]/).map(&:capitalize).join
+    end
+  end
+end