desiru 0.1.0

data/lib/desiru/registry.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Desiru
+  # Module registry for managing and discovering Desiru modules
+  # Implements service locator pattern for module management
+  class Registry
+    include Singleton
+
+    def initialize
+      @modules = {}
+      @module_versions = Hash.new { |h, k| h[k] = {} }
+      @module_metadata = {}
+    end
+
+    def register(name, klass, version: '1.0.0', metadata: {})
+      validate_module!(klass)
+
+      name = name.to_sym
+      @modules[name] = klass
+      @module_versions[name][version] = klass
+      @module_metadata[name] = metadata.merge(
+        registered_at: Time.now,
+        version: version,
+        class: klass.name
+      )
+
+      Desiru.configuration.logger&.info("Registered module: #{name} v#{version}")
+    end
+
+    def get(name, version: nil)
+      name = name.to_sym
+
+      if version
+        @module_versions[name][version] || raise(ModuleError, "Module #{name} v#{version} not found")
+      else
+        @modules[name] || raise(ModuleError, "Module #{name} not found")
+      end
+    end
+
+    def list
+      @modules.keys
+    end
+
+    def metadata(name)
+      @module_metadata[name.to_sym]
+    end
+
+    def unregister(name)
+      name = name.to_sym
+      @modules.delete(name)
+      @module_versions.delete(name)
+      @module_metadata.delete(name)
+    end
+
+    def clear!
+      @modules.clear
+      @module_versions.clear
+      @module_metadata.clear
+    end
+
+    private
+
+    def validate_module!(klass)
+      raise ModuleError, 'Module must be a class' unless klass.respond_to?(:new)
+
+      # Check if it's a Desiru module
+      return if klass.ancestors.include?(Desiru::Module)
+
+      raise ModuleError, 'Module must inherit from Desiru::Module'
+    end
+  end
+end

data/lib/desiru/signature.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Desiru
+  # Represents input/output specifications for modules
+  # Supports DSL-style signature strings like "question -> answer"
+  class Signature
+    # FieldHash allows access by both string and symbol keys
+    class FieldHash < Hash
+      def [](key)
+        super(key.to_sym)
+      end
+
+      def []=(key, value)
+        super(key.to_sym, value)
+      end
+
+      def keys
+        super.map(&:to_s)
+      end
+
+      def has_key?(key)
+        super(key.to_sym)
+      end
+
+      alias include? has_key?
+      alias key? has_key?
+    end
+
+    attr_reader :raw_signature
+
+    def input_fields
+      @input_fields_wrapper
+    end
+
+    def output_fields
+      @output_fields_wrapper
+    end
+
+    # Aliases for test compatibility
+    alias inputs input_fields
+    alias outputs output_fields
+
+    def initialize(signature_string, descriptions: {})
+      @raw_signature = signature_string
+      @descriptions = descriptions
+      @input_fields = {}
+      @output_fields = {}
+      @input_fields_wrapper = FieldHash.new
+      @output_fields_wrapper = FieldHash.new
+
+      parse_signature!
+    end
+
+    def validate_inputs(inputs)
+      missing = required_input_fields - inputs.keys.map(&:to_sym)
+      raise SignatureError, "Missing required inputs: #{missing.join(', ')}" if missing.any?
+
+      inputs.each do |name, value|
+        field = @input_fields[name.to_sym]
+        next unless field
+
+        # Field.validate will raise ValidationError if validation fails
+        field.validate(value)
+      end
+
+      true
+    end
+
+    def validate_outputs(outputs)
+      missing = required_output_fields - outputs.keys.map(&:to_sym)
+      raise ValidationError, "Missing required outputs: #{missing.join(', ')}" if missing.any?
+
+      outputs.each do |name, value|
+        field = @output_fields[name.to_sym]
+        next unless field
+
+        # Field.validate will raise ValidationError if validation fails
+        field.validate(value)
+      end
+
+      true
+    end
+
+    def coerce_inputs(inputs)
+      result = {}
+
+      @input_fields.each do |name, field|
+        value = inputs[name] || inputs[name.to_s]
+        result[name] = field.coerce(value)
+      end
+
+      result
+    end
+
+    def coerce_outputs(outputs)
+      result = {}
+
+      @output_fields.each do |name, field|
+        value = outputs[name] || outputs[name.to_s]
+        result[name] = field.coerce(value)
+      end
+
+      result
+    end
+
+    def to_h
+      {
+        signature: raw_signature,
+        inputs: @input_fields.transform_values(&:to_h),
+        outputs: @output_fields.transform_values(&:to_h)
+      }
+    end
+
+    def to_s
+      raw_signature
+    end
+
+    private
+
+    def parse_signature!
+      parts = raw_signature.split('->').map(&:strip)
+      raise ArgumentError, "Invalid signature format: #{raw_signature}" unless parts.size == 2
+
+      parse_fields(parts[0], @input_fields)
+      parse_fields(parts[1], @output_fields)
+    end
+
+    def parse_fields(fields_string, target_hash)
+      return if fields_string.empty?
+
+      # Split fields properly, handling commas inside brackets
+      fields = []
+      current_field = String.new
+      bracket_count = 0
+
+      fields_string.chars.each do |char|
+        if char == '['
+          bracket_count += 1
+        elsif char == ']'
+          bracket_count -= 1
+        elsif char == ',' && bracket_count == 0
+          fields << current_field.strip
+          current_field = String.new
+          next
+        end
+        current_field << char
+      end
+      fields << current_field.strip unless current_field.empty?
+
+      fields.each do |field_str|
+        # Parse field with type annotation
+        if field_str.include?(':')
+          name, type_info = field_str.split(':', 2).map(&:strip)
+          # Check for optional marker on field name or type
+          optional = name.end_with?('?') || type_info.include?('?')
+          # Clean field name by removing trailing ?
+          name = name.gsub(/\?$/, '')
+          # Remove optional marker before parsing type
+          clean_type_info = type_info.gsub('?', '').strip
+          type_data = parse_type(clean_type_info)
+        else
+          name = field_str
+          # Check if field name ends with ?
+          optional = name.end_with?('?')
+          name = name.gsub(/\?$/, '')
+          type_data = { type: :string }
+        end
+
+        description = @descriptions[name.to_sym] || @descriptions[name.to_s]
+
+        # Create field with parsed type data
+        field_args = {
+          description: description,
+          optional: optional
+        }
+
+        # Add literal values if present
+        field_args[:literal_values] = type_data[:literal_values] if type_data[:literal_values]
+
+        # Add element type for typed arrays
+        field_args[:element_type] = type_data[:element_type] if type_data[:element_type]
+
+        field = Field.new(
+          name,
+          type_data[:type],
+          **field_args
+        )
+
+        target_hash[name.to_sym] = field
+
+        # Also add to wrapper for dual access
+        if target_hash == @input_fields
+          @input_fields_wrapper[name.to_sym] = field
+        elsif target_hash == @output_fields
+          @output_fields_wrapper[name.to_sym] = field
+        end
+      end
+    end
+
+    def parse_type(type_string)
+      # Handle Literal types - need to match balanced brackets
+      if type_string.start_with?('Literal[')
+        # Find the matching closing bracket
+        bracket_count = 0
+        end_index = 0
+
+        type_string.chars.each_with_index do |char, index|
+          if char == '['
+            bracket_count += 1
+          elsif char == ']'
+            bracket_count -= 1
+            if bracket_count == 0
+              end_index = index
+              break
+            end
+          end
+        end
+
+        if end_index > 0
+          literal_content = type_string[8...end_index] # Extract content between 'Literal[' and ']'
+          values = parse_literal_values(literal_content)
+          return { type: :literal, literal_values: values }
+        end
+      end
+
+      # Handle List/Array types with element types
+      if type_string.start_with?('List[', 'Array[')
+        # Find the matching closing bracket
+        bracket_count = 0
+        end_index = 0
+        start_index = type_string.index('[')
+
+        type_string.chars.each_with_index do |char, index|
+          next if index < start_index
+
+          if char == '['
+            bracket_count += 1
+          elsif char == ']'
+            bracket_count -= 1
+            if bracket_count == 0
+              end_index = index
+              break
+            end
+          end
+        end
+
+        if end_index > 0
+          element_type_str = type_string[(start_index + 1)...end_index]
+          element_type_data = parse_type(element_type_str) # Recursive for nested types
+          return { type: :list, element_type: element_type_data }
+        end
+      end
+
+      # Handle Union types (for future implementation)
+      if type_string.start_with?('Union[')
+        # Placeholder for union type parsing
+        return { type: :union, union_types: [] } # To be implemented
+      end
+
+      # Handle basic types
+      # First check if it's a list/array with simple element type (e.g., list[str])
+      if type_string.downcase.start_with?('list[', 'array[')
+        # Even if we couldn't parse the brackets properly above, it's still a list
+        return { type: :list }
+      end
+
+      clean_type = type_string.gsub(/[?\[\]]/, '').downcase
+      type_sym = case clean_type
+                 when 'str', 'string' then :string
+                 when 'int', 'integer' then :int
+                 when 'float', 'number', 'double' then :float
+                 when 'bool', 'boolean' then :bool
+                 when 'list', 'array' then :list
+                 when 'hash', 'dict', 'dictionary' then :hash
+                 else clean_type.to_sym
+                 end
+
+      { type: type_sym }
+    end
+
+    def parse_literal_values(literal_content)
+      # Parse comma-separated values, handling quoted strings
+      values = []
+      current_value = String.new
+      in_quotes = false
+      quote_char = nil
+
+      literal_content.each_char.with_index do |char, index|
+        if !in_quotes && ['"', "'"].include?(char)
+          in_quotes = true
+          quote_char = char
+        elsif in_quotes && char == quote_char
+          # Check if it's escaped
+          if index > 0 && literal_content[index - 1] != '\\'
+            in_quotes = false
+            quote_char = nil
+          else
+            current_value << char
+          end
+        elsif !in_quotes && char == ','
+          values << current_value.strip.gsub(/^['"]|['"]$/, '')
+          current_value = String.new
+        else
+          current_value << char
+        end
+      end
+
+      # Add the last value
+      values << current_value.strip.gsub(/^['"]|['"]$/, '') unless current_value.empty?
+
+      values
+    end
+
+    def required_input_fields
+      @input_fields.reject { |_, field| field.optional }.keys
+    end
+
+    def required_output_fields
+      @output_fields.reject { |_, field| field.optional }.keys
+    end
+  end
+end

data/lib/desiru/version.rb

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

data/lib/desiru.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'singleton'
+
+# Main namespace for Desiru - Declarative Self-Improving Ruby
+module Desiru
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class SignatureError < Error; end
+  class ModuleError < Error; end
+  class ValidationError < Error; end
+  class TimeoutError < Error; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+# Core components
+require_relative 'desiru/version'
+require_relative 'desiru/configuration'
+require_relative 'desiru/field'
+require_relative 'desiru/signature'
+require_relative 'desiru/module'
+require_relative 'desiru/program'
+require_relative 'desiru/registry'
+require_relative 'desiru/cache'
+
+# Model adapters
+require_relative 'desiru/models/base'
+require_relative 'desiru/models/raix_adapter'
+
+# Built-in modules
+require_relative 'desiru/modules/predict'
+require_relative 'desiru/modules/chain_of_thought'
+require_relative 'desiru/modules/retrieve'
+
+# Optimizers
+require_relative 'desiru/optimizers/base'
+require_relative 'desiru/optimizers/bootstrap_few_shot'
+
+# Background jobs
+require_relative 'desiru/jobs/base'
+require_relative 'desiru/jobs/async_predict'
+require_relative 'desiru/jobs/batch_processor'
+require_relative 'desiru/jobs/optimizer_job'
+
+# GraphQL integration (optional, requires 'graphql' gem)
+begin
+  require 'graphql'
+  require_relative 'desiru/graphql/schema_generator'
+rescue LoadError
+  # GraphQL integration is optional
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: desiru
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Obie Fernandez
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: forwardable
+  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: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: singleton
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Desiru brings DSPy's declarative programming paradigm for language models
+  to Ruby, enabling reliable, maintainable, and portable AI programming.
+email:
+- obiefernandez@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- desiru.gemspec
+- examples/README.md
+- examples/async_processing.rb
+- examples/few_shot_learning.rb
+- examples/graphql_api.rb
+- examples/graphql_integration.rb
+- examples/rag_retrieval.rb
+- examples/simple_qa.rb
+- examples/typed_signatures.rb
+- lib/desiru.rb
+- lib/desiru/async_capable.rb
+- lib/desiru/cache.rb
+- lib/desiru/configuration.rb
+- lib/desiru/field.rb
+- lib/desiru/graphql/data_loader.rb
+- lib/desiru/graphql/executor.rb
+- lib/desiru/graphql/schema_generator.rb
+- lib/desiru/jobs/async_predict.rb
+- lib/desiru/jobs/base.rb
+- lib/desiru/jobs/batch_processor.rb
+- lib/desiru/jobs/optimizer_job.rb
+- lib/desiru/models/base.rb
+- lib/desiru/models/raix_adapter.rb
+- lib/desiru/module.rb
+- lib/desiru/modules/chain_of_thought.rb
+- lib/desiru/modules/predict.rb
+- lib/desiru/modules/retrieve.rb
+- lib/desiru/optimizers/base.rb
+- lib/desiru/optimizers/bootstrap_few_shot.rb
+- lib/desiru/program.rb
+- lib/desiru/registry.rb
+- lib/desiru/signature.rb
+- lib/desiru/version.rb
+homepage: https://github.com/obie/desiru
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/obie/desiru
+  source_code_uri: https://github.com/obie/desiru
+  changelog_uri: https://github.com/obie/desiru/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'false'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Declarative Self-Improving Ruby - A Ruby port of DSPy
+test_files: []