ruby-mana 0.5.1 → 0.5.7

data/lib/mana/backends/registry.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Mana
-  module Backends
-    ANTHROPIC_PATTERNS = /^(claude-)/i
-    OPENAI_PATTERNS = /^(gpt-|o1-|o3-|chatgpt-|dall-e|tts-|whisper-)/i
-
-    def self.for(config)
-      return config.backend if config.backend.is_a?(Base)
-
-      case config.backend&.to_s
-      when "openai" then OpenAI.new(config)
-      when "anthropic" then Anthropic.new(config)
-      else
-        # Auto-detect from model name
-        case config.model
-        when ANTHROPIC_PATTERNS then Anthropic.new(config)
-        else OpenAI.new(config) # Default to OpenAI (most compatible)
-        end
-      end
-    end
-  end
-end

data/lib/mana/context_window.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Mana
-  module ContextWindow
-    SIZES = {
-      /claude-3-5-sonnet/ => 200_000,
-      /claude-sonnet-4/ => 200_000,
-      /claude-3-5-haiku/ => 200_000,
-      /claude-3-opus/ => 200_000,
-      /claude-opus-4/ => 200_000,
-      /gpt-4o/ => 128_000,
-      /gpt-4-turbo/ => 128_000,
-      /gpt-3\.5/ => 16_385
-    }.freeze
-
-    DEFAULT = 128_000
-
-    def self.detect(model_name)
-      return DEFAULT unless model_name
-
-      SIZES.each do |pattern, size|
-        return size if model_name.match?(pattern)
-      end
-
-      DEFAULT
-    end
-  end
-end

data/lib/mana/effect_registry.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-module Mana
-  # Registry for custom effect handlers.
-  #
-  # Users define effects that become LLM tools automatically:
-  #
-  #   Mana.define_effect :query_db,
-  #     description: "Execute a SQL query" do |sql:|
-  #       DB.execute(sql)
-  #     end
-  #
-  # The block's keyword parameters become the tool's input schema.
-  # The block's return value is serialized and sent back to the LLM.
-  module EffectRegistry
-    class EffectDefinition
-      attr_reader :name, :description, :handler, :params
-
-      def initialize(name, description: nil, &handler)
-        @name = name.to_s
-        @description = description || @name
-        @handler = handler
-        @params = extract_params(handler)
-      end
-
-      # Convert to LLM tool definition
-      def to_tool
-        properties = {}
-        required = []
-
-        @params.each do |param|
-          properties[param[:name]] = {
-            type: infer_type(param[:default]),
-            description: param[:name]
-          }
-          required << param[:name] if param[:required]
-        end
-
-        tool = {
-          name: @name,
-          description: @description,
-          input_schema: {
-            type: "object",
-            properties: properties
-          }
-        }
-        tool[:input_schema][:required] = required unless required.empty?
-        tool
-      end
-
-      # Call the handler with LLM-provided input
-      def call(input)
-        kwargs = {}
-        @params.each do |param|
-          key = param[:name]
-          if input.key?(key)
-            kwargs[key.to_sym] = input[key]
-          elsif param[:default] != :__mana_no_default__
-            # Use block's default
-          elsif param[:required]
-            raise Mana::Error, "missing required parameter: #{key}"
-          end
-        end
-
-        if kwargs.empty? && @params.empty?
-          @handler.call
-        else
-          @handler.call(**kwargs)
-        end
-      end
-
-      private
-
-      def extract_params(block)
-        return [] unless block
-
-        block.parameters.map do |(type, name)|
-          case type
-          when :keyreq
-            { name: name.to_s, required: true, default: :__mana_no_default__ }
-          when :key
-            # Try to get default value — not possible via reflection,
-            # so we mark it as optional with unknown default
-            { name: name.to_s, required: false, default: nil }
-          when :keyrest
-            # **kwargs — skip, can't generate schema
-            nil
-          else
-            # Positional args — treat as required string params
-            { name: name.to_s, required: true, default: :__mana_no_default__ } if name
-          end
-        end.compact
-      end
-
-      def infer_type(default)
-        case default
-        when Integer then "integer"
-        when Float then "number"
-        when TrueClass, FalseClass then "boolean"
-        when Array then "array"
-        when Hash then "object"
-        else "string"
-        end
-      end
-    end
-
-    RESERVED_EFFECTS = %w[read_var write_var read_attr write_attr call_func done remember].freeze
-
-    class << self
-      def registry
-        @registry ||= {}
-      end
-
-      def define(name, description: nil, &handler)
-        name_s = name.to_s
-        if RESERVED_EFFECTS.include?(name_s)
-          raise Mana::Error, "cannot override built-in effect: #{name_s}"
-        end
-
-        registry[name_s] = EffectDefinition.new(name, description: description, &handler)
-      end
-
-      def undefine(name)
-        registry.delete(name.to_s)
-      end
-
-      def defined?(name)
-        registry.key?(name.to_s)
-      end
-
-      def get(name)
-        registry[name.to_s]
-      end
-
-      # Generate tool definitions for all registered effects
-      def tool_definitions
-        registry.values.map(&:to_tool)
-      end
-
-      def clear!
-        @registry = {}
-      end
-
-      # Handle a tool call if it matches a registered effect
-      # Returns [handled, result] — handled is true if we processed it
-      def handle(name, input)
-        effect = get(name)
-        return [false, nil] unless effect
-
-        result = effect.call(input)
-        [true, result]
-      end
-    end
-  end
-end

data/lib/mana/engines/base.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Mana
-  module Engines
-    class Base
-      attr_reader :config, :binding
-
-      def initialize(caller_binding, config = Mana.config)
-        @binding = caller_binding
-        @config = config
-      end
-
-      # --- Capability queries ---
-      # Subclasses override to declare what they support.
-
-      # Is this an execution engine (Ruby/JS/Python) or a reasoning engine (LLM)?
-      # Execution engines can execute code, hold state, and be called bidirectionally.
-      # Reasoning engines process natural language but cannot hold references or state.
-      def execution_engine?
-        true
-      end
-
-      # Can this engine hold remote references to objects in other engines?
-      # Derived from execution_engine? — only execution engines support remote refs.
-      def supports_remote_ref?
-        execution_engine?
-      end
-
-      # Can code in this engine call back into another engine (bidirectional)?
-      # Derived from execution_engine? — only execution engines support bidirectional calls.
-      def supports_bidirectional?
-        execution_engine?
-      end
-
-      # Does this engine maintain mutable state across calls?
-      # Derived from execution_engine? — only execution engines maintain state.
-      def supports_state?
-        execution_engine?
-      end
-
-      # Execute code/prompt in this engine, return the result
-      # Subclasses must implement this
-      def execute(code)
-        raise NotImplementedError, "#{self.class}#execute not implemented"
-      end
-
-      # Read a variable from the Ruby binding
-      def read_var(name)
-        if @binding.local_variables.include?(name.to_sym)
-          @binding.local_variable_get(name.to_sym)
-        elsif @binding.receiver.respond_to?(name.to_sym, true)
-          @binding.receiver.send(name.to_sym)
-        else
-          raise NameError, "undefined variable: #{name}"
-        end
-      end
-
-      # Write a variable to the Ruby binding
-      def write_var(name, value)
-        @binding.local_variable_set(name.to_sym, value)
-      end
-
-      # Serialize a Ruby value for cross-language transfer
-      # Simple types: copy. Complex objects: will be remote refs (future)
-      def serialize(value)
-        case value
-        when Numeric, String, Symbol, TrueClass, FalseClass, NilClass
-          value
-        when Array
-          value.map { |v| serialize(v) }
-        when Hash
-          value.transform_values { |v| serialize(v) }
-        else
-          value.to_s
-        end
-      end
-    end
-  end
-end

data/lib/mana/engines/detect.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module Mana
-  module Engines
-    RULES_PATH = File.join(__dir__, "..", "..", "..", "data", "lang-rules.yml")
-
-    class Detector
-      attr_reader :rules
-
-      def initialize(rules_path = RULES_PATH)
-        @rules = YAML.safe_load(File.read(rules_path))["languages"]
-      end
-
-      # Detect language, return engine class
-      # context: previous detection result (for context inference)
-      def detect(code, context: nil)
-        scores = {}
-        @rules.each do |lang, rule_set|
-          scores[lang] = score(code, rule_set)
-        end
-
-        # Context inference: boost previous language slightly
-        # Only boost if there's already some evidence (score > 0)
-        if context && scores[context] && scores[context] > 0
-          scores[context] += 2
-        end
-
-        best = scores.max_by { |_, v| v }
-
-        # If best score is very low, default to natural_language (LLM)
-        if best[1] <= 0
-          return engine_for("natural_language")
-        end
-
-        engine_for(best[0])
-      end
-
-      private
-
-      def score(code, rule_set)
-        s = 0
-        # Strong signals: +3 each
-        (rule_set["strong"] || []).each { |token| s += 3 if code.include?(token) }
-        # Weak signals: +1 each
-        (rule_set["weak"] || []).each { |token| s += 1 if code.include?(token) }
-        # Anti signals: -5 each (strong negative)
-        (rule_set["anti"] || []).each { |token| s -= 5 if code.include?(token) }
-        # Pattern signals: +4 each
-        (rule_set["patterns"] || []).each do |pattern|
-          s += 4 if code.match?(Regexp.new(pattern))
-        end
-        s
-      end
-
-      def engine_for(lang)
-        case lang
-        when "javascript" then load_js_engine
-        when "python" then load_py_engine
-        when "ruby" then Engines::Ruby
-        else Engines::LLM
-        end
-      end
-
-      def load_js_engine
-        require_relative "javascript"
-        Engines::JavaScript
-      rescue LoadError => e
-        warn "Mana: JavaScript engine unavailable (#{e.message}), falling back to LLM"
-        Engines::LLM
-      end
-
-      def load_py_engine
-        require_relative "python"
-        Engines::Python
-      rescue LoadError => e
-        warn "Mana: Python engine unavailable (#{e.message}), falling back to LLM"
-        Engines::LLM
-      end
-    end
-
-    # Module-level convenience method
-    def self.detect(code, context: nil)
-      @detector ||= Detector.new
-      @detector.detect(code, context: context)
-    end
-
-    def self.reset_detector!
-      @detector = nil
-    end
-  end
-end

data/lib/mana/engines/javascript.rb

@@ -1,314 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "mini_racer"
-rescue LoadError
-  raise LoadError, "mini_racer gem is required for JavaScript support. Add `gem 'mini_racer'` to your Gemfile."
-end
-
-require "json"
-require "set"
-
-module Mana
-  module Engines
-    class JavaScript < Base
-      # JS helper code that creates Proxy wrappers for remote Ruby objects.
-      # Injected once per V8 context.
-      JS_PROXY_HELPER = <<~JS
-        (function() {
-          if (typeof __mana_create_proxy !== 'undefined') return;
-
-          // FinalizationRegistry for automatic GC of remote refs.
-          // When a JS proxy is garbage collected, notify Ruby to release the original object.
-          if (typeof FinalizationRegistry !== 'undefined') {
-            globalThis.__mana_ref_gc = new FinalizationRegistry(function(refId) {
-              try { ruby.__ref_release(refId); } catch(e) {}
-            });
-          }
-
-          globalThis.__mana_create_proxy = function(refId, typeName) {
-            var proxy = new Proxy({ __mana_ref: refId, __mana_type: typeName }, {
-              get: function(target, prop) {
-                if (prop === '__mana_ref') return target.__mana_ref;
-                if (prop === '__mana_type') return target.__mana_type;
-                if (prop === '__mana_alive') return ruby.__ref_alive(refId);
-                if (prop === 'release') return function() { ruby.__ref_release(refId); };
-                if (prop === 'toString' || prop === Symbol.toPrimitive) {
-                  return function() { return ruby.__ref_to_s(refId); };
-                }
-                if (prop === 'inspect') {
-                  return function() { return 'RemoteRef<' + typeName + '#' + refId + '>'; };
-                }
-                if (typeof prop === 'symbol') return undefined;
-                return function() {
-                  var args = Array.prototype.slice.call(arguments);
-                  return ruby.__ref_call(refId, prop, JSON.stringify(args));
-                };
-              }
-            });
-
-            // Register with FinalizationRegistry so GC triggers release
-            if (globalThis.__mana_ref_gc) {
-              globalThis.__mana_ref_gc.register(proxy, refId);
-            }
-
-            return proxy;
-          };
-        })();
-      JS
-
-      # Thread-local persistent V8 context (lazy-loaded, long-running)
-      def self.context
-        Thread.current[:mana_js_context] ||= create_context
-      end
-
-      def self.create_context
-        MiniRacer::Context.new
-      end
-
-      def self.reset!
-        ctx = Thread.current[:mana_js_context]
-        ctx&.dispose
-        Thread.current[:mana_js_context] = nil
-        Thread.current[:mana_js_callbacks_attached] = nil
-        ObjectRegistry.reset!
-      end
-
-      def execute(code)
-        ctx = self.class.context
-
-        # 1. Attach Ruby callbacks (methods + effects + ref operations)
-        attach_ruby_callbacks(ctx)
-
-        # 2. Inject Ruby variables into JS scope
-        inject_ruby_vars(ctx, code)
-
-        # 3. Execute the JS code
-        result = ctx.eval(code)
-
-        # 4. Extract any new/modified variables back to Ruby binding
-        extract_js_vars(ctx, code)
-
-        result
-      end
-
-      private
-
-      def attach_ruby_callbacks(ctx)
-        attached = Thread.current[:mana_js_callbacks_attached] ||= Set.new
-
-        # Install the JS Proxy helper (once per context)
-        unless attached.include?("__proxy_helper")
-          ctx.eval(JS_PROXY_HELPER)
-          attached << "__proxy_helper"
-        end
-
-        # ruby.read / ruby.write -- variable bridge
-        unless attached.include?("ruby.read")
-          bnd = @binding
-          ctx.attach("ruby.read", proc { |name|
-            sym = name.to_sym
-            if bnd.local_variables.include?(sym)
-              val = bnd.local_variable_get(sym)
-              json_safe(val)
-            else
-              nil
-            end
-          })
-          attached << "ruby.read"
-        end
-
-        unless attached.include?("ruby.write")
-          bnd = @binding
-          ctx.attach("ruby.write", proc { |name, value|
-            bnd.local_variable_set(name.to_sym, value)
-            value
-          })
-          attached << "ruby.write"
-        end
-
-        # Remote reference operations
-        attach_ref_callbacks(ctx, attached)
-
-        # Attach methods from the caller's receiver
-        attach_receiver_methods(ctx, attached)
-
-        # Attach registered Mana effects
-        attach_effects(ctx, attached)
-      end
-
-      # Attach callbacks for operating on remote Ruby object references from JS.
-      def attach_ref_callbacks(ctx, attached)
-        registry = ObjectRegistry.current
-
-        unless attached.include?("ruby.__ref_call")
-          ctx.attach("ruby.__ref_call", proc { |ref_id, method_name, args_json|
-            obj = registry.get(ref_id)
-            raise "Remote reference #{ref_id} has been released" unless obj
-
-            args = args_json ? JSON.parse(args_json) : []
-            result = obj.public_send(method_name.to_sym, *args)
-            json_safe(result)
-          })
-          attached << "ruby.__ref_call"
-        end
-
-        unless attached.include?("ruby.__ref_release")
-          ctx.attach("ruby.__ref_release", proc { |ref_id|
-            registry.release(ref_id)
-            nil
-          })
-          attached << "ruby.__ref_release"
-        end
-
-        unless attached.include?("ruby.__ref_alive")
-          ctx.attach("ruby.__ref_alive", proc { |ref_id|
-            registry.registered?(ref_id)
-          })
-          attached << "ruby.__ref_alive"
-        end
-
-        unless attached.include?("ruby.__ref_to_s")
-          ctx.attach("ruby.__ref_to_s", proc { |ref_id|
-            obj = registry.get(ref_id)
-            obj ? obj.to_s : "released"
-          })
-          attached << "ruby.__ref_to_s"
-        end
-      end
-
-      def attach_receiver_methods(ctx, attached)
-        receiver = @binding.receiver
-        user_methods = receiver.class.instance_methods(false) -
-                       Object.instance_methods -
-                       [:~@]
-
-        user_methods.each do |method_name|
-          key = "ruby.#{method_name}"
-          next if attached.include?(key)
-
-          recv = receiver
-          ctx.attach(key, proc { |*args| json_safe(recv.public_send(method_name, *args)) })
-          attached << key
-        end
-      end
-
-      def attach_effects(ctx, attached)
-        Mana::EffectRegistry.registry.each do |name, effect|
-          key = "ruby.#{name}"
-          next if attached.include?(key)
-
-          eff = effect
-          ctx.attach(key, proc { |*args|
-            input = if args.length == 1 && args[0].is_a?(Hash)
-                      args[0]
-                    elsif eff.params.length == args.length
-                      eff.params.zip(args).to_h { |p, v| [p[:name], v] }
-                    else
-                      {}
-                    end
-            json_safe(eff.call(input))
-          })
-          attached << key
-        end
-      end
-
-      def inject_ruby_vars(ctx, code)
-        @binding.local_variables.each do |var_name|
-          next unless code.match?(/\b#{Regexp.escape(var_name.to_s)}\b/)
-
-          value = @binding.local_variable_get(var_name)
-          inject_value(ctx, var_name.to_s, value)
-        rescue => e
-          next
-        end
-      end
-
-      # Inject a single value into the JS context.
-      # Simple types are serialized to JSON. Complex objects become remote ref proxies.
-      def inject_value(ctx, name, value)
-        case value
-        when Numeric, String, TrueClass, FalseClass, NilClass
-          ctx.eval("var #{name} = #{JSON.generate(value)}")
-        when Symbol
-          ctx.eval("var #{name} = #{JSON.generate(value.to_s)}")
-        when Array
-          ctx.eval("var #{name} = #{JSON.generate(serialize_array(value))}")
-        when Hash
-          ctx.eval("var #{name} = #{JSON.generate(serialize_hash(value))}")
-        else
-          # Complex object → register and create JS Proxy
-          ref_id = ObjectRegistry.current.register(value)
-          ctx.eval("var #{name} = __mana_create_proxy(#{ref_id}, #{JSON.generate(value.class.name)})")
-        end
-      end
-
-      def serialize_array(arr)
-        arr.map { |v| simple_value?(v) ? serialize_simple(v) : v.to_s }
-      end
-
-      def serialize_hash(hash)
-        hash.transform_keys(&:to_s).transform_values { |v|
-          simple_value?(v) ? serialize_simple(v) : v.to_s
-        }
-      end
-
-      def simple_value?(value)
-        case value
-        when Numeric, String, Symbol, TrueClass, FalseClass, NilClass, Array, Hash
-          true
-        else
-          false
-        end
-      end
-
-      def serialize_simple(value)
-        case value
-        when Symbol then value.to_s
-        when Array then serialize_array(value)
-        when Hash then serialize_hash(value)
-        else value
-        end
-      end
-
-      def extract_js_vars(ctx, code)
-        declared_vars = extract_declared_vars(code)
-        declared_vars.each do |var_name|
-          begin
-            value = ctx.eval(var_name)
-            deserialized = deserialize(value)
-            write_var(var_name, deserialized)
-          rescue MiniRacer::RuntimeError
-            next
-          end
-        end
-      end
-
-      def extract_declared_vars(code)
-        vars = []
-        code.scan(/\b(?:const|let|var)\s+(\w+)\s*=/).each { |m| vars << m[0] }
-        code.scan(/^(\w+)\s*=[^=>]/).each { |m| vars << m[0] }
-        vars.uniq
-      end
-
-      def deserialize(value)
-        value
-      end
-
-      def json_safe(value)
-        case value
-        when Numeric, String, TrueClass, FalseClass, NilClass
-          value
-        when Symbol
-          value.to_s
-        when Array
-          value.map { |v| json_safe(v) }
-        when Hash
-          value.transform_keys(&:to_s).transform_values { |v| json_safe(v) }
-        else
-          value.to_s
-        end
-      end
-    end
-  end
-end