ruby_llm-agents 0.5.0 → 1.0.0.beta.1

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

data/lib/generators/ruby_llm_agents/image_pipeline_generator.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RubyLlmAgents
+  # ImagePipeline generator for creating new image pipelines
+  #
+  # Usage:
+  #   rails generate ruby_llm_agents:image_pipeline Product
+  #   rails generate ruby_llm_agents:image_pipeline Ecommerce --steps generate,upscale,remove_background
+  #   rails generate ruby_llm_agents:image_pipeline Content --steps generate,analyze
+  #   rails generate ruby_llm_agents:image_pipeline Product --root=ai
+  #
+  # This will create:
+  #   - app/{root}/image/pipelines/product_pipeline.rb
+  #
+  class ImagePipelineGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :steps, type: :string, default: "generate,upscale",
+                 desc: "Pipeline steps (comma-separated: generate,upscale,transform,analyze,remove_background)"
+    class_option :stop_on_error, type: :boolean, default: true,
+                 desc: "Stop pipeline on first error"
+    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"
+      pipelines_dir = "app/#{root_directory}/image/pipelines"
+
+      # Create directory if needed
+      empty_directory pipelines_dir
+
+      # Create base class if it doesn't exist
+      base_class_path = "#{pipelines_dir}/application_image_pipeline.rb"
+      unless File.exist?(File.join(destination_root, base_class_path))
+        template "application_image_pipeline.rb.tt", base_class_path
+      end
+
+      # Create skill file if it doesn't exist
+      skill_file_path = "#{pipelines_dir}/IMAGE_PIPELINES.md"
+      unless File.exist?(File.join(destination_root, skill_file_path))
+        template "skills/IMAGE_PIPELINES.md.tt", skill_file_path
+      end
+    end
+
+    def create_image_pipeline_file
+      @root_namespace = root_namespace
+      @image_namespace = "#{root_namespace}::Image"
+      pipeline_path = name.underscore
+      template "image_pipeline.rb.tt", "app/#{root_directory}/image/pipelines/#{pipeline_path}_pipeline.rb"
+    end
+
+    def create_step_classes
+      # Create stub classes for referenced steps if they don't exist
+      parsed_steps.each do |step|
+        create_step_stub(step) if should_create_stub?(step)
+      end
+    end
+
+    def show_usage
+      pipeline_class_name = name.split("/").map(&:camelize).join("::")
+      full_class_name = "#{root_namespace}::Image::#{pipeline_class_name}Pipeline"
+      say ""
+      say "Image pipeline #{full_class_name} created!", :green
+      say ""
+      say "Usage:"
+      say "  # Run the pipeline"
+      say "  result = #{full_class_name}.call(prompt: 'Product photo')"
+      say "  result.final_image   # => The processed image"
+      say "  result.total_cost    # => Combined cost of all steps"
+      say "  result.step_count    # => Number of steps executed"
+      say ""
+      say "  # Access individual step results"
+      say "  result.step(:generate)  # => ImageGenerationResult"
+      say "  result.step(:upscale)   # => ImageUpscaleResult"
+      say "  result.analysis         # => ImageAnalysisResult (if analyzer step)"
+      say ""
+      say "  # Save the final image"
+      say "  result.save('output.png')"
+      say ""
+      say "  # With tenant tracking"
+      say "  result = #{full_class_name}.call("
+      say "    prompt: 'Product photo',"
+      say "    tenant: current_organization"
+      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)
+      return "AI" if str.downcase == "ai"
+      return "ML" if str.downcase == "ml"
+      return "LLM" if str.downcase == "llm"
+      str.split(/[-_]/).map(&:capitalize).join
+    end
+
+    def parsed_steps
+      options[:steps].to_s.split(",").map(&:strip).map(&:to_sym)
+    end
+
+    def should_create_stub?(step)
+      case step
+      when :generate
+        !File.exist?("app/#{root_directory}/image/generators/#{name.underscore}_generator.rb")
+      when :upscale
+        !File.exist?("app/#{root_directory}/image/upscalers/#{name.underscore}_upscaler.rb")
+      when :transform
+        !File.exist?("app/#{root_directory}/image/transformers/#{name.underscore}_transformer.rb")
+      when :analyze
+        !File.exist?("app/#{root_directory}/image/analyzers/#{name.underscore}_analyzer.rb")
+      when :remove_background
+        !File.exist?("app/#{root_directory}/image/background_removers/#{name.underscore}_background_remover.rb")
+      else
+        false
+      end
+    end
+
+    def create_step_stub(step)
+      # Just show a note - don't auto-create stubs
+      case step
+      when :generate
+        say "  Note: You may want to create #{name}Generator with:", :yellow
+        say "    rails generate ruby_llm_agents:image_generator #{name}"
+      when :upscale
+        say "  Note: You may want to create #{name}Upscaler with:", :yellow
+        say "    rails generate ruby_llm_agents:image_upscaler #{name}"
+      when :transform
+        say "  Note: You may want to create #{name}Transformer with:", :yellow
+        say "    rails generate ruby_llm_agents:image_transformer #{name}"
+      when :analyze
+        say "  Note: You may want to create #{name}Analyzer with:", :yellow
+        say "    rails generate ruby_llm_agents:image_analyzer #{name}"
+      when :remove_background
+        say "  Note: You may want to create #{name}BackgroundRemover with:", :yellow
+        say "    rails generate ruby_llm_agents:background_remover #{name}"
+      end
+    end
+
+    def step_classes
+      @step_classes ||= parsed_steps.map do |step|
+        class_base = name.split("/").map(&:camelize).join("::")
+        case step
+        when :generate
+          { step: step, type: :generator, class_name: "#{@image_namespace}::#{class_base}Generator" }
+        when :upscale
+          { step: step, type: :upscaler, class_name: "#{@image_namespace}::#{class_base}Upscaler" }
+        when :transform
+          { step: step, type: :transformer, class_name: "#{@image_namespace}::#{class_base}Transformer" }
+        when :analyze
+          { step: step, type: :analyzer, class_name: "#{@image_namespace}::#{class_base}Analyzer" }
+        when :remove_background
+          { step: step, type: :remover, class_name: "#{@image_namespace}::#{class_base}BackgroundRemover" }
+        else
+          { step: step, type: step, class_name: "#{@image_namespace}::#{class_base}#{step.to_s.camelize}" }
+        end
+      end
+    end
+  end
+end