ruby-mana 0.5.8 → 0.5.10

data/lib/mana/knowledge.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Mana
+  # Runtime knowledge base — assembles information about ruby-mana from live code.
+  # No static files to maintain; the code IS the source of truth.
+  module Knowledge
+    class << self
+      # Query a topic using a cascading lookup strategy.
+      # Priority: mana docs > ruby env > ri (external docs) > runtime introspection > dump all.
+      # The fallback chain ensures we always return something useful.
+      def query(topic)
+        topic_key = topic.to_s.strip.downcase
+        sections = all_sections
+
+        # 1. Match mana's own sections (bidirectional substring match for flexibility)
+        match = sections.find { |k, _| topic_key.include?(k) || k.include?(topic_key) }
+        return "[source: mana]\n#{match.last}" if match
+
+        # 2. Ruby environment info
+        return "[source: ruby runtime]\n#{ruby_environment}" if topic_key == "ruby"
+
+        # 3. Try ri (official Ruby documentation)
+        ri_result = query_ri(topic.to_s.strip)
+        return "[source: ri (Ruby official docs)]\n#{ri_result}" if ri_result
+
+        # 4. Try runtime introspection
+        introspect_result = query_introspect(topic.to_s.strip)
+        return "[source: ruby introspection]\n#{introspect_result}" if introspect_result
+
+        # 5. Fallback: dump all mana sections so the LLM has full context
+        "[source: mana]\n#{sections.values.join("\n\n")}"
+      end
+
+      private
+
+      # Query Ruby's ri documentation tool (runs outside bundler to access rdoc).
+      # Must escape bundler env because ri needs access to system-wide rdoc files
+      # that bundler's isolated gem path would hide.
+      def query_ri(topic)
+        output = if defined?(Bundler)
+          Bundler.with_unbundled_env { `ri --format=markdown #{topic.shellescape} 2>&1` }
+        else
+          `ri --format=markdown #{topic.shellescape} 2>&1`
+        end
+        return nil unless $?.success?
+        # Truncate long docs to avoid flooding the LLM's context window
+        output.length > 3000 ? "#{output[0, 3000]}\n\n... (truncated, #{output.length} chars total)" : output
+      rescue
+        nil
+      end
+
+      # Runtime introspection: resolve as a Ruby constant and inspect it.
+      # This gives the LLM live information about classes/modules that may not
+      # appear in ri docs (e.g. user-defined or gem classes loaded at runtime).
+      def query_introspect(topic)
+        const = Object.const_get(topic)
+        lines = []
+        if const.is_a?(Module)
+          lines << "#{const.name} (#{const.is_a?(Class) ? "class" : "module"})"
+          # Limit ancestors/methods to avoid overwhelming the LLM context
+          lines << "Ancestors: #{const.ancestors.first(8).map(&:name).compact.join(' < ')}" if const.is_a?(Class)
+          pub = const.public_instance_methods(false).sort
+          lines << "Instance methods (#{pub.size}): #{pub.first(30).join(', ')}#{"..." if pub.size > 30}"
+          if const.is_a?(Class)
+            class_methods = (const.methods - Object.methods).sort
+            lines << "Class methods (#{class_methods.size}): #{class_methods.first(20).join(', ')}#{"..." if class_methods.size > 20}" unless class_methods.empty?
+          end
+        end
+        lines.empty? ? nil : lines.join("\n")
+      rescue NameError
+        nil
+      end
+
+      # Ruby runtime environment info
+      def ruby_environment
+        <<~TEXT
+          Ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})
+          RUBY_ENGINE: #{RUBY_ENGINE} #{RUBY_ENGINE_VERSION}
+          Loaded gems: #{Gem.loaded_specs.keys.sort.join(", ")}
+        TEXT
+      end
+
+      # All knowledge sections are generated dynamically from live code/config,
+      # so they're always up-to-date without maintaining separate doc files.
+      def all_sections
+        {
+          "overview"      => overview,
+          "tools"         => tools,
+          "memory"        => memory,
+          "execution"     => execution,
+          "configuration" => configuration,
+          "backends"      => backends,
+          "functions"     => functions
+        }
+      end
+
+      def overview
+        <<~TEXT
+          ruby-mana v#{Mana::VERSION} is a hybrid execution engine for Ruby.
+          The LLM handles reasoning and decision-making; Ruby handles actual code execution.
+          The operator ~"..." turns a natural-language string into an LLM prompt that can
+          read/write live Ruby variables, call Ruby methods, and return values — all within
+          the caller's binding.
+        TEXT
+      end
+
+      def tools
+        # Extract tool info directly from Engine's tool definitions
+        tool_list = Engine.all_tools.map { |t|
+          desc = t[:description]
+          props = t[:input_schema][:properties] || {}
+          params = props.map { |k, v| "#{k}: #{v[:description] || v['description'] || k}" }.join(", ")
+          "- #{t[:name]}(#{params}): #{desc}"
+        }
+
+        "Built-in tools:\n#{tool_list.join("\n")}"
+      end
+
+      def memory
+        store_class = Mana.config.memory_store&.class&.name || "Mana::FileStore (default)"
+        path = if Mana.config.memory_path
+                 Mana.config.memory_path
+               else
+                 "~/.mana/memory/<namespace>.json"
+               end
+
+        <<~TEXT
+          ruby-mana has two types of memory:
+          - Short-term memory: conversation history within the current process. Each ~"..."
+            call appends to it, so consecutive calls share context. Cleared when the process exits.
+          - Long-term memory: persistent facts stored on disk as JSON files.
+            Default path: #{path}
+            Current store: #{store_class}
+            Namespace is auto-detected from the git repo name, Gemfile directory, or cwd.
+            Configurable via: Mana.configure { |c| c.memory_path = "/custom/path" }
+            Or provide a custom MemoryStore subclass for Redis, DB, etc.
+          - Background compaction: when short-term memory exceeds the token pressure threshold
+            (currently #{Mana.config.memory_pressure}), old messages are summarized in a background thread.
+          - Incognito mode: Mana.incognito { ~"..." } disables all memory.
+          The LLM can store facts via the `remember` tool. These persist across script executions.
+        TEXT
+      end
+
+      def execution
+        <<~TEXT
+          How ~"..." works step by step:
+          1. ~"..." triggers String#~@ — captures the caller's Binding via binding_of_caller.
+          2. Build context — parses <var> references, reads their values, discovers functions via Prism AST.
+          3. Build system prompt — assembles rules, memory, variable values, and function signatures.
+          4. LLM tool-calling loop — sends prompt to LLM with built-in tools. LLM responds with
+             tool calls, Mana executes them against the live Ruby binding, sends results back.
+             Loops until done() is called or max_iterations (#{Mana.config.max_iterations}) is reached.
+          5. Return value — single write_var returns the value directly; multiple writes return a Hash.
+        TEXT
+      end
+
+      def configuration
+        c = Mana.config
+        <<~TEXT
+          Current configuration:
+          - model: #{c.model}
+          - backend: #{c.backend || 'auto-detect'}
+          - base_url: #{c.effective_base_url}
+          - timeout: #{c.timeout}s
+          - max_iterations: #{c.max_iterations}
+          - context_window: #{c.context_window}
+          - memory_pressure: #{c.memory_pressure}
+          - memory_keep_recent: #{c.memory_keep_recent}
+          - verbose: #{c.verbose}
+          All options can be set via Mana.configure { |c| ... } or environment variables
+          (MANA_MODEL, MANA_BACKEND, MANA_TIMEOUT, MANA_VERBOSE, ANTHROPIC_API_KEY, OPENAI_API_KEY).
+        TEXT
+      end
+
+      def backends
+        <<~TEXT
+          ruby-mana supports multiple LLM backends:
+          - Anthropic (Claude) — default, native format
+          - OpenAI (GPT) — auto-translated
+          - Any OpenAI-compatible API (Gemini, local models, etc.) via custom base_url
+          Currently using: #{Mana.config.backend || 'auto-detect'} with model #{Mana.config.model}
+          Configure via:
+            Mana.configure { |c| c.backend = :openai; c.model = "gpt-4o" }
+          Or set environment variables: MANA_BACKEND, MANA_MODEL
+        TEXT
+      end
+
+      def functions
+        <<~TEXT
+          Function discovery in ruby-mana:
+          - Prism AST parser auto-discovers methods from the caller's source file.
+          - YARD-style comments are extracted as descriptions.
+          - Methods on the receiver (minus Ruby builtins) are also discovered.
+          - No registration or JSON schema needed — just define normal Ruby methods.
+          - LLM-compiled methods: `mana def method_name` lets the LLM generate the implementation
+            on first call, then caches it on disk (.mana_cache/).
+        TEXT
+      end
+    end
+  end
+end

data/lib/mana/logger.rb

@@ -66,6 +66,16 @@ module Mana
       end
     end
 
+    # Log think tool content — full text in distinct italic cyan
+    def vlog_think(content)
+      return unless @config.verbose
+
+      $stderr.puts "\e[2m[mana]\e[0m \e[3;36m💭 Think:\e[0m"
+      content.each_line do |line|
+        $stderr.puts "\e[2m[mana]\e[0m \e[3;36m  #{line.rstrip}\e[0m"
+      end
+    end
+
     # Summarize tool input for compact logging.
     # Multi-line string values are replaced with a brief summary.
     def summarize_input(input)

data/lib/mana/prompt_builder.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Mana
+  # Assembles system prompts and extracts variable context from user prompts.
+  # Mixed into Engine as private methods.
+  module PromptBuilder
+    private
+
+    # Extract <var> references from the prompt and read their current values.
+    # Variables that don't exist yet are silently skipped (LLM will create them).
+    def build_context(prompt)
+      var_names = prompt.scan(/<(\w+)>/).flatten.uniq
+      ctx = {}
+      var_names.each do |name|
+        val = resolve(name)
+        ctx[name] = serialize_value(val)
+      rescue NameError
+        # Variable doesn't exist yet — will be created by LLM
+      end
+      ctx
+    end
+
+    # Assemble the system prompt with rules, memory, variables, available functions, and custom effects
+    def build_system_prompt(context)
+      parts = [
+        "You are Mana, an AI assistant embedded in a Ruby program. Your name is Mana — never use any other name for yourself.",
+        "ALWAYS respond in the same language as the user's message. If the user writes in Chinese, respond in Chinese. If in English, respond in English.",
+        "You interact with live Ruby state using the provided tools. When unsure about your capabilities, use the knowledge tool to check.",
+        "",
+        "Rules:",
+        "- read_var / read_attr to read, write_var / write_attr to write.",
+        "- call_func to call ANY Ruby method — including Net::HTTP, File, system libraries, gems, etc. You have Ruby's full power. Use local_variables to discover variables in scope.",
+        "- NEVER refuse a task by saying you can't do it. Always try using call_func first. If it fails, the error will tell you why.",
+        "- done(result: ...) to return a value. error(message: ...) only after you have tried and failed.",
+        "- <var> references point to variables in scope; create with write_var if missing.",
+        "- Match types precisely: numbers for numeric values, arrays for lists, strings for text.",
+        "- Current prompt overrides conversation history and memories.",
+      ]
+
+      if @incognito
+        parts << ""
+        parts << "You are in incognito mode. The remember tool is disabled. No memories will be loaded or saved."
+      else
+        memory = Memory.current
+        # Inject memory context when available
+        if memory
+          # Add compaction summaries from prior conversations
+          unless memory.summaries.empty?
+            parts << ""
+            parts << "Previous conversation summary:"
+            memory.summaries.each { |s| parts << "  #{s}" }
+          end
+
+          # Add persistent long-term facts
+          unless memory.long_term.empty?
+            parts << ""
+            parts << "Long-term memories (persistent background context):"
+            memory.long_term.each { |m| parts << "- #{m[:content]}" }
+          end
+
+          unless memory.long_term.empty?
+            parts << ""
+            parts << "You have a `remember` tool to store new facts in long-term memory when the user asks."
+          end
+        end
+      end
+
+      # Inject current variable values referenced in the prompt
+      unless context.empty?
+        parts << ""
+        parts << "Current variable values:"
+        context.each { |k, v| parts << "  #{k} = #{v}" }
+      end
+
+      # Discover available functions from two sources:
+      # 1. AST scan of the caller's source file (gets parameter signatures)
+      # 2. Receiver's methods minus Ruby builtins (catches require'd functions)
+      file_methods = begin
+        Mana::Introspect.methods_from_file(@caller_path)
+      rescue => _e
+        []
+      end
+      file_method_names = file_methods.map { |m| m[:name] }
+
+      # Methods on the receiver not from Object/Kernel (user-defined or require'd)
+      receiver = @binding.receiver
+      receiver_methods = (receiver.methods - Object.methods - Kernel.methods - [:~@, :mana])
+        .select { |m| receiver.method(m).owner != Object && receiver.method(m).owner != Kernel }
+        .reject { |m| file_method_names.include?(m.to_s) }  # avoid duplicates with AST scan
+        .map { |m|
+          meth = receiver.method(m)
+          params = meth.parameters.map { |(type, name)|
+            case type
+            when :req then name.to_s
+            when :opt then "#{name}=..."
+            when :rest then "*#{name}"
+            when :keyreq then "#{name}:"
+            when :key then "#{name}: ..."
+            when :keyrest then "**#{name}"
+            when :block then "&#{name}"
+            else name.to_s
+            end
+          }
+          { name: m.to_s, params: params }
+        }
+
+      all_methods = file_methods + receiver_methods
+      # Append available function signatures so the LLM knows what it can call
+      unless all_methods.empty?
+        parts << ""
+        parts << Mana::Introspect.format_for_prompt(all_methods)
+      end
+
+      # Inject Ruby runtime environment snapshot
+      parts << ""
+      parts << ruby_environment
+
+      parts.join("\n")
+    end
+
+    # Build a concise snapshot of the Ruby runtime environment
+    def ruby_environment
+      lines = ["Environment:"]
+      lines << "  Ruby #{RUBY_VERSION} | #{RUBY_PLATFORM} | pwd: #{Dir.pwd}"
+
+      # Loaded gems (top-level, skip bundler internals)
+      specs = Gem.loaded_specs.values
+        .reject { |s| %w[bundler rubygems].include?(s.name) }
+        .sort_by(&:name)
+      if specs.any?
+        gem_list = specs.map { |s| "#{s.name} #{s.version}" }.first(20)
+        gem_list << "... (#{specs.size} total)" if specs.size > 20
+        lines << "  Gems: #{gem_list.join(', ')}"
+      end
+
+      # User-defined classes/modules (skip Ruby internals)
+      skip = [Object, Kernel, BasicObject, Module, Class, Mana, Mana::Engine,
+              Mana::Memory, Mana::Config, Mana::Chat]
+      user_classes = ObjectSpace.each_object(Class)
+        .reject { |c| c.name.nil? || c.name.start_with?("Mana::") || c.name.start_with?("#<") }
+        .reject { |c| skip.include?(c) }
+        .reject { |c| c.name.match?(/\A(Net|URI|IO|Gem|Bundler|RubyVM|RbConfig|Reline|JSON|YAML|Psych|Prism|Encoding|Errno|Signal|Thread|Fiber|Ractor|Process|GC|RDoc|IRB|Readline|StringIO|Monitor|PP|DidYouMean|ErrorHighlight|SyntaxSuggest|Coverage|SimpleCov|RSpec|WebMock)/) }
+        .map(&:name).sort
+      if user_classes.any?
+        class_list = user_classes.first(20)
+        class_list << "... (#{user_classes.size} total)" if user_classes.size > 20
+        lines << "  Classes: #{class_list.join(', ')}"
+      end
+
+      # Local variables in scope
+      vars = @binding.local_variables.map(&:to_s).sort
+      lines << "  Local vars: #{vars.join(', ')}" if vars.any?
+
+      lines.join("\n")
+    end
+  end
+end

data/lib/mana/tool_handler.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Mana
+  # Dispatches LLM tool calls to their respective handlers.
+  # Mixed into Engine as a private method.
+  module ToolHandler
+    private
+
+    # Dispatch a single tool call from the LLM.
+    def handle_effect(tool_use, memory = nil)
+      name = tool_use[:name]
+      input = tool_use[:input] || {}
+      # Normalize keys to strings for consistent access
+      input = input.transform_keys(&:to_s) if input.is_a?(Hash)
+
+      case name
+      when "read_var"
+        # Read a variable from the caller's binding and return its serialized value
+        val = serialize_value(resolve(input["name"]))
+        vlog_value("   ↩ #{input['name']} =", val)
+        val
+
+      when "write_var"
+        # Write a value to the caller's binding and track it for the return value
+        var_name = input["name"]
+        value = input["value"]
+        write_local(var_name, value)
+        @written_vars[var_name] = value
+        vlog_value("   ✅ #{var_name} =", value)
+        "ok: #{var_name} = #{value.inspect}"
+
+      when "read_attr"
+        # Read an attribute (public method) from a Ruby object in scope
+        obj = resolve(input["obj"])
+        validate_name!(input["attr"])
+        serialize_value(obj.public_send(input["attr"]))
+
+      when "write_attr"
+        # Set an attribute (public setter) on a Ruby object in scope
+        obj = resolve(input["obj"])
+        validate_name!(input["attr"])
+        obj.public_send("#{input['attr']}=", input["value"])
+        "ok: #{input['obj']}.#{input['attr']} = #{input['value'].inspect}"
+
+      when "call_func"
+        handle_call_func(input)
+
+      when "knowledge"
+        # Look up information about ruby-mana from the knowledge base
+        self.class.knowledge(input["topic"])
+
+      when "remember"
+        # Store a fact in long-term memory (persistent across executions)
+        if @incognito
+          "Memory not saved (incognito mode)"
+        elsif memory
+          entry = memory.remember(input["content"])
+          "Remembered (id=#{entry[:id]}): #{input['content']}"
+        else
+          "Memory not available"
+        end
+
+      when "done"
+        # Signal task completion; the result becomes the return value
+        done_val = input["result"]
+        vlog_value("🏁 Done:", done_val)
+        vlog("═" * 60)
+        input["result"].to_s
+
+      when "error"
+        # LLM signals it cannot complete the task — raise as exception
+        msg = input["message"] || "LLM reported an error"
+        vlog("❌ Error: #{msg}")
+        vlog("═" * 60)
+        raise Mana::LLMError, msg
+
+      when "eval"
+        result = @binding.eval(input["code"])
+        vlog_value("   ↩ eval →", result)
+        serialize_value(result)
+
+      else
+        "error: unknown tool #{name}"
+      end
+    rescue LLMError
+      # LLMError must propagate to the caller (e.g. from the error tool)
+      raise
+    rescue SyntaxError => e
+      # Catch syntax errors from body eval so the LLM can retry with corrected code
+      "error: #{e.class}: #{e.message}"
+    rescue => e
+      # Return errors as strings so the LLM can see and react to them
+      "error: #{e.class}: #{e.message}"
+    end
+
+    # Handle call_func tool: chained calls, block bodies, simple calls
+    def handle_call_func(input)
+      func = input["name"]
+      args = input["args"] || []
+      kwargs = (input["kwargs"] || {}).transform_keys(&:to_sym)
+      body_code = input["body"]
+      block = @binding.eval("proc { #{body_code} }") if body_code
+
+      # Handle chained calls (e.g. Time.now, Array.new, File.read)
+      if func.include?(".")
+        return handle_chained_call(func, args, block)
+      end
+
+      # Handle body parameter for simple (non-chained) function calls
+      if body_code
+        validate_name!(func)
+        receiver = @binding.receiver
+        result = receiver.send(func.to_sym, *args, &block)
+        vlog("   ↩ #{func}(#{args.inspect}) with body → #{result.inspect}")
+        return serialize_value(result)
+      end
+
+      # Simple (non-chained) function call
+      validate_name!(func)
+
+      # Binding-sensitive method: local_variables returns scope-dependent results
+      if func == "local_variables"
+        return handle_local_variables
+      end
+
+      # Try local variable (lambdas/procs) first, then receiver methods
+      callable = if @binding.local_variables.include?(func.to_sym)
+                   @binding.local_variable_get(func.to_sym)
+                 elsif @binding.receiver.respond_to?(func.to_sym, true)
+                   @binding.receiver.method(func.to_sym)
+                 else
+                   raise NameError, "undefined function '#{func}'"
+                 end
+      result = kwargs.empty? ? callable.call(*args) : callable.call(*args, **kwargs)
+      call_desc = args.map(&:inspect).concat(kwargs.map { |k, v| "#{k}: #{v.inspect}" }).join(", ")
+      vlog_value("   ↩ #{func}(#{call_desc}) →", result)
+      serialize_value(result)
+    end
+
+    # Handle chained method calls like Time.now, Array.new(10) { rand }
+    def handle_chained_call(func, args, block)
+      first_dot = func.index(".")
+      receiver_name = func[0...first_dot]
+      rest = func[(first_dot + 1)..]
+      methods_chain = rest.split(".")
+      first_method = methods_chain.first
+
+      # Validate receiver is a simple constant name (e.g. "Time", "File", "Math")
+      unless receiver_name.match?(/\A[A-Z][A-Za-z0-9_]*(::[A-Z][A-Za-z0-9_]*)*\z/)
+        raise NameError, "'#{receiver_name}' is not a valid constant name"
+      end
+
+      begin
+        receiver = @binding.eval(receiver_name)
+      rescue => e
+        raise NameError, "cannot resolve '#{receiver_name}': #{e.message}"
+      end
+      result = receiver.public_send(first_method.to_sym, *args, &block)
+
+      # Chain remaining methods without args (e.g. .to_s, .strftime)
+      methods_chain[1..].each do |m|
+        result = result.public_send(m.to_sym)
+      end
+
+      vlog_value("   ↩ #{func}(#{args.map(&:inspect).join(', ')}) →", result)
+      serialize_value(result)
+    end
+
+    # Handle local_variables call with Mana-created singleton method tracking
+    def handle_local_variables
+      result = @binding.local_variables.map(&:to_s)
+      receiver = @binding.receiver
+      if receiver.instance_variable_defined?(:@__mana_vars__)
+        result = (result + receiver.instance_variable_get(:@__mana_vars__).map(&:to_s)).uniq
+      end
+      vlog("   ↩ local_variables() → #{result.size} variables")
+      serialize_value(result)
+    end
+  end
+end

data/lib/mana/version.rb

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

data/lib/mana.rb

@@ -2,18 +2,22 @@
 
 require_relative "mana/version"
 require_relative "mana/config"
-require_relative "mana/security_policy"
 require_relative "mana/backends/base"
 require_relative "mana/backends/anthropic"
 require_relative "mana/backends/openai"
 require_relative "mana/memory_store"
 require_relative "mana/memory"
 require_relative "mana/logger"
+require_relative "mana/knowledge"
+require_relative "mana/binding_helpers"
+require_relative "mana/prompt_builder"
+require_relative "mana/tool_handler"
 require_relative "mana/engine"
 require_relative "mana/introspect"
 require_relative "mana/compiler"
 require_relative "mana/string_ext"
 require_relative "mana/mixin"
+require_relative "mana/chat"
 
 module Mana
   class Error < StandardError; end
@@ -65,6 +69,11 @@ module Mana
     def cache_dir=(dir)
       Compiler.cache_dir = dir
     end
+
+    # Enter interactive chat mode. Mana will have access to the caller's binding.
+    def chat
+      Chat.start(binding.of_caller(1))
+    end
   end
 end
 

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mana
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.10
 platform: ruby
 authors:
 - Carl Li
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
@@ -24,33 +24,67 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: reline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
 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
   functions, manipulate objects — all from a simple ~"..." syntax.
 email:
-executables: []
+executables:
+- mana
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- exe/mana
 - lib/mana.rb
 - lib/mana/backends/anthropic.rb
 - lib/mana/backends/base.rb
 - lib/mana/backends/openai.rb
+- lib/mana/binding_helpers.rb
+- lib/mana/chat.rb
 - lib/mana/compiler.rb
 - lib/mana/config.rb
 - lib/mana/engine.rb
 - lib/mana/introspect.rb
+- lib/mana/knowledge.rb
 - lib/mana/logger.rb
 - lib/mana/memory.rb
 - lib/mana/memory_store.rb
 - lib/mana/mixin.rb
 - lib/mana/mock.rb
-- lib/mana/security_policy.rb
+- lib/mana/prompt_builder.rb
 - lib/mana/string_ext.rb
+- lib/mana/tool_handler.rb
 - lib/mana/version.rb
 homepage: https://github.com/twokidsCarl/ruby-mana
 licenses: