ruby-mana 0.4.0 → 0.5.0

data/lib/mana/engines/python.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+begin
+  require "pycall"
+rescue LoadError
+  raise LoadError, "pycall gem is required for Python support. Add `gem 'pycall'` to your Gemfile."
+end
+
+require "json"
+
+module Mana
+  module Engines
+    class Python < Base
+      # Thread-local persistent Python state
+      # PyCall shares a single Python interpreter per process,
+      # but we track our own variable namespace
+      def self.namespace
+        Thread.current[:mana_py_namespace] ||= create_namespace
+      end
+
+      def self.create_namespace
+        PyCall.eval("dict()")
+      end
+
+      def self.reset!
+        ns = Thread.current[:mana_py_namespace]
+        if ns
+          PyCall.exec("pass") # ensure interpreter is alive
+          Thread.current[:mana_py_namespace] = nil
+        end
+      end
+
+      def execute(code)
+        ns = self.class.namespace
+
+        # 1. Inject Ruby variables into Python namespace
+        inject_ruby_vars(ns, code)
+
+        # 2. Inject the Ruby bridge for Python->Ruby callbacks
+        inject_ruby_bridge(ns)
+
+        # 3. Execute Python code in the namespace
+        PyCall.exec(code, locals: ns)
+
+        # 4. Extract declared variables back to Ruby
+        extract_py_vars(ns, code)
+
+        # Return the last expression value if possible
+        begin
+          ns["result"]
+        rescue
+          nil
+        end
+      rescue PyCall::PyError => e
+        raise Mana::Error, "Python execution error: #{e.message}"
+      rescue ArgumentError => e
+        raise Mana::Error, "Python execution error: #{e.message}"
+      end
+
+      private
+
+      def inject_ruby_vars(ns, code)
+        @binding.local_variables.each do |var_name|
+          value = @binding.local_variable_get(var_name)
+          serialized = serialize_for_py(value)
+          begin
+            ns[var_name.to_s] = serialized
+          rescue => e
+            next
+          end
+        end
+      end
+
+      # Inject a `ruby` bridge into the Python namespace.
+      #
+      # The bridge is a Ruby object with method_missing that proxies calls
+      # back to the Ruby binding. PyCall automatically wraps it so Python
+      # can call methods directly:
+      #
+      #   ruby.method_name(arg1, arg2)  -- call a Ruby method on the receiver
+      #   ruby.read("var")              -- read a Ruby local variable
+      #   ruby.write("var", value)      -- write a Ruby local variable
+      #   ruby.call_proc("name", args)  -- call a local proc/lambda by name
+      #
+      # Ruby objects (including the binding receiver) can also be injected
+      # directly and called from Python -- PyCall handles the wrapping.
+      def inject_ruby_bridge(ns)
+        ns["ruby"] = RubyBridge.new(@binding)
+      end
+
+      def extract_py_vars(ns, code)
+        declared_vars = extract_declared_vars(code)
+        declared_vars.each do |var_name|
+          next if var_name == "ruby" # skip the bridge object
+          begin
+            value = ns[var_name]
+            deserialized = deserialize_py(value)
+            write_var(var_name, deserialized)
+          rescue => e
+            next
+          end
+        end
+      end
+
+      def extract_declared_vars(code)
+        vars = []
+        # Match Python assignments: x = ..., but not x == ... or x += ...
+        code.scan(/^(\w+)\s*=[^=]/).each { |m| vars << m[0] }
+        # Also match augmented assignments: x += ..., x -= ...
+        code.scan(/^(\w+)\s*[+\-*\/]?=/).each { |m| vars << m[0] }
+        vars.uniq
+      end
+
+      # Serialize Ruby values for Python injection.
+      # Procs/lambdas and Ruby objects are passed directly --
+      # PyCall wraps them so Python can call their methods.
+      def serialize_for_py(value)
+        case value
+        when Numeric, String, TrueClass, FalseClass, NilClass
+          value
+        when Symbol
+          value.to_s
+        when Array
+          value.map { |v| serialize_for_py(v) }
+        when Hash
+          value.each_with_object({}) do |(k, v), h|
+            key = k.is_a?(Symbol) ? k.to_s : k
+            h[key] = serialize_for_py(v)
+          end
+        when Proc, Method
+          # Pass callables directly -- PyCall wraps them as Python callables
+          value
+        else
+          # Pass Ruby objects directly -- Python can call their methods via PyCall
+          value
+        end
+      end
+
+      def deserialize_py(value)
+        if defined?(PyCall::PyObjectWrapper) && value.is_a?(PyCall::PyObjectWrapper)
+          begin
+            value.to_a rescue value.to_s
+          rescue
+            value.to_s
+          end
+        else
+          value
+        end
+      end
+    end
+
+    # Bridge object injected as `ruby` in the Python namespace.
+    # Enables Python->Ruby callbacks via method_missing.
+    #
+    # Python usage:
+    #   ruby.some_method(arg1, arg2)  -- calls method on binding receiver
+    #   ruby.read("var_name")         -- reads a Ruby local variable
+    #   ruby.write("var_name", val)   -- writes a Ruby local variable
+    #   ruby.call_proc("name", args)  -- calls a local proc/lambda by name
+    class RubyBridge
+      def initialize(caller_binding)
+        @binding = caller_binding
+        @receiver = caller_binding.receiver
+      end
+
+      # Read a Ruby local variable
+      def read(name)
+        name = name.to_s.to_sym
+        if @binding.local_variables.include?(name)
+          @binding.local_variable_get(name)
+        else
+          raise NameError, "undefined Ruby variable '#{name}'"
+        end
+      end
+
+      # Write a Ruby local variable
+      def write(name, value)
+        @binding.local_variable_set(name.to_s.to_sym, value)
+      end
+
+      # Explicitly call a local proc/lambda by name
+      def call_proc(name, *args)
+        name = name.to_s.to_sym
+        if @binding.local_variables.include?(name)
+          val = @binding.local_variable_get(name)
+          if val.respond_to?(:call)
+            return val.call(*args)
+          end
+        end
+        raise NoMethodError, "no callable '#{name}' in Ruby scope"
+      end
+
+      # Proxy unknown method calls to the binding receiver.
+      # This lets Python do: ruby.some_method(args)
+      def method_missing(name, *args)
+        name_s = name.to_s
+
+        # First check local procs/lambdas
+        name_sym = name_s.to_sym
+        if @binding.local_variables.include?(name_sym)
+          val = @binding.local_variable_get(name_sym)
+          return val.call(*args) if val.respond_to?(:call)
+        end
+
+        # Then try the receiver (public methods only)
+        if @receiver.respond_to?(name_s)
+          return @receiver.public_send(name_s, *args)
+        end
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        name_s = name.to_s
+        name_sym = name_s.to_sym
+
+        # Check local callables
+        if @binding.local_variables.include?(name_sym)
+          val = @binding.local_variable_get(name_sym)
+          return true if val.respond_to?(:call)
+        end
+
+        # Check receiver (public methods only, matching method_missing)
+        return true if @receiver.respond_to?(name_s)
+
+        super
+      end
+    end
+  end
+end

data/lib/mana/engines/ruby_eval.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mana
+  module Engines
+    class Ruby < Base
+      def execute(code)
+        eval(code, @binding)
+      end
+    end
+  end
+end

data/lib/mana/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mana
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/mana.rb

@@ -11,6 +11,10 @@ require_relative "mana/namespace"
 require_relative "mana/memory_store"
 require_relative "mana/context_window"
 require_relative "mana/memory"
+require_relative "mana/engines/base"
+require_relative "mana/engines/llm"
+require_relative "mana/engines/ruby_eval"
+require_relative "mana/engines/detect"
 require_relative "mana/engine"
 require_relative "mana/introspect"
 require_relative "mana/compiler"
@@ -44,8 +48,12 @@ module Mana
     def reset!
       @config = Config.new
       EffectRegistry.clear!
+      Engines.reset_detector!
+      Engines::JavaScript.reset! if defined?(Engines::JavaScript)
+      Engines::Python.reset! if defined?(Engines::Python)
       Thread.current[:mana_memory] = nil
       Thread.current[:mana_mock] = nil
+      Thread.current[:mana_last_engine] = nil
     end
 
     # Define a custom effect that becomes an LLM tool

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mana
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Carl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mini_racer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 description: |
   Mana lets you write natural language strings in Ruby that execute via LLM
   with full access to your program's live state. Read/write variables, call
@@ -36,6 +50,7 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- data/lang-rules.yml
 - lib/mana.rb
 - lib/mana/backends/anthropic.rb
 - lib/mana/backends/base.rb
@@ -46,6 +61,12 @@ files:
 - lib/mana/context_window.rb
 - lib/mana/effect_registry.rb
 - lib/mana/engine.rb
+- lib/mana/engines/base.rb
+- lib/mana/engines/detect.rb
+- lib/mana/engines/javascript.rb
+- lib/mana/engines/llm.rb
+- lib/mana/engines/python.rb
+- lib/mana/engines/ruby_eval.rb
 - lib/mana/introspect.rb
 - lib/mana/memory.rb
 - lib/mana/memory_store.rb