ruby-mana 0.5.8 → 0.5.10

data/lib/mana/binding_helpers.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Mana
+  # Binding manipulation utilities: read/write variables, validate names, serialize values.
+  # Mixed into Engine as private methods.
+  module BindingHelpers
+    VALID_IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+    private
+
+    # Ensure a name is a valid Ruby identifier (prevents injection)
+    def validate_name!(name)
+      raise Mana::Error, "invalid identifier: #{name.inspect}" unless name.match?(VALID_IDENTIFIER)
+    end
+
+    # Resolve a name to a value: try local variable first, then receiver method
+    def resolve(name)
+      validate_name!(name)
+      if @binding.local_variable_defined?(name.to_sym)
+        # Found as a local variable in the caller's binding
+        @binding.local_variable_get(name.to_sym)
+      elsif @binding.receiver.respond_to?(name.to_sym)
+        # Found as a public method on the caller's self
+        @binding.receiver.public_send(name.to_sym)
+      else
+        raise NameError, "undefined variable or method '#{name}'"
+      end
+    end
+
+    # Write a value into the caller's binding, with Ruby 4.0+ singleton method fallback.
+    # Only defines a singleton method when the variable doesn't already exist as a local
+    # AND the receiver doesn't already have a real method with that name.
+    def write_local(name, value)
+      validate_name!(name)
+      sym = name.to_sym
+
+      # Check if the variable already exists before setting
+      existed = @binding.local_variable_defined?(sym)
+      @binding.local_variable_set(sym, value)
+
+      # Ruby 4.0+: local_variable_set can no longer create new locals visible
+      # in the caller's scope. Define a singleton method ONLY for new variables
+      # that don't conflict with existing methods on the receiver.
+      unless existed
+        receiver = @binding.eval("self")
+        # Don't overwrite real instance methods — only add if no method exists
+        unless receiver.class.method_defined?(sym) || receiver.class.private_method_defined?(sym)
+          old_verbose, $VERBOSE = $VERBOSE, nil
+          receiver.define_singleton_method(sym) { value }
+          $VERBOSE = old_verbose
+          # Track Mana-created singleton method variables so local_variables can include them
+          mana_vars = receiver.instance_variable_defined?(:@__mana_vars__) ? receiver.instance_variable_get(:@__mana_vars__) : Set.new
+          mana_vars << sym
+          receiver.instance_variable_set(:@__mana_vars__, mana_vars)
+        end
+      end
+    end
+
+    # Find the user's source file by walking up the call stack.
+    # Used for introspecting available methods in the caller's code.
+    def caller_source_path
+      # Try binding's source_location first (most direct)
+      loc = @binding.source_location
+      return loc[0] if loc.is_a?(Array)
+
+      # Fallback: scan caller_locations, skip frames inside the mana gem itself
+      caller_locations(4, 20)&.each do |frame|
+        path = frame.absolute_path || frame.path
+        next if path.nil? || path.include?("mana/")
+        return path
+      end
+      nil
+    end
+
+    # Serialize a Ruby value to a string representation the LLM can understand.
+    # Handles primitives, collections, and arbitrary objects (via ivar inspection).
+    def serialize_value(val)
+      case val
+      when Time
+        # Format Time as a human-readable timestamp string
+        val.strftime("%Y-%m-%d %H:%M:%S %z").inspect
+      when String, Integer, Float, TrueClass, FalseClass, NilClass
+        # Primitives: use Ruby's built-in inspect
+        val.inspect
+      when Symbol
+        # Convert symbol to string for LLM readability
+        val.to_s.inspect
+      when Array
+        # Recursively serialize each element
+        "[#{val.map { |v| serialize_value(v) }.join(', ')}]"
+      when Hash
+        # Recursively serialize key-value pairs
+        pairs = val.map { |k, v| "#{serialize_value(k)} => #{serialize_value(v)}" }
+        "{#{pairs.join(', ')}}"
+      else
+        # Arbitrary object: show class name and instance variables
+        ivars = val.instance_variables
+        obj_repr = ivars.map do |ivar|
+          attr_name = ivar.to_s.delete_prefix("@")
+          "#{attr_name}: #{val.instance_variable_get(ivar).inspect}" rescue nil
+        end.compact.join(", ")
+        "#<#{val.class} #{obj_repr}>"
+      end
+    end
+  end
+end

data/lib/mana/chat.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module Mana
+  # Interactive chat mode — enter with Mana.chat to talk to Mana in your Ruby runtime.
+  # Supports streaming output, colored prompts, and full access to the caller's binding.
+  # Auto-detects Ruby code vs natural language. Use '!' prefix to force Ruby execution.
+  module Chat
+    USER_PROMPT  = "\e[36mmana>\e[0m "    # cyan
+    MANA_PREFIX  = "\e[33mmana>\e[0m "   # yellow
+    RUBY_PREFIX  = "\e[35m=>\e[0m "      # magenta
+    THINK_COLOR  = "\e[3;36m"            # italic cyan
+    TOOL_COLOR   = "\e[2;33m"            # dim yellow
+    RESULT_COLOR = "\e[2;32m"            # dim green
+    CODE_COLOR   = "\e[36m"              # cyan for code
+    BOLD         = "\e[1m"               # bold
+    ERROR_COLOR  = "\e[31m"              # red
+    DIM          = "\e[2m"               # dim
+    RESET        = "\e[0m"
+
+    CONT_PROMPT  = "\e[2m  \e[0m"
+    EXIT_COMMANDS = /\A(exit|quit|bye|q)\z/i
+
+    # Entry point — starts the REPL loop with Reline for readline support.
+    # Reline is required lazily so chat mode doesn't penalize non-interactive usage.
+    HISTORY_FILE = File.join(Dir.home, ".mana_history")
+    HISTORY_MAX  = 1000
+
+    def self.start(caller_binding)
+      require "reline"
+      load_history
+      puts "#{DIM}Mana chat · type 'exit' to quit#{RESET}"
+      puts
+
+      loop do
+        input = read_input
+        break if input.nil?
+        next if input.strip.empty?
+        break if input.strip.match?(EXIT_COMMANDS)
+
+        # Three-tier dispatch:
+        # "!" prefix — force Ruby eval (bypass ambiguity detection)
+        # Valid Ruby syntax — try Ruby first, fall back to LLM if NameError
+        # Everything else — send directly to the LLM
+        if input.start_with?("!")
+          eval_ruby(caller_binding, input[1..].strip)
+        elsif ruby_syntax?(input)
+          eval_ruby(caller_binding, input) { run_mana(caller_binding, input) }
+        else
+          run_mana(caller_binding, input)
+        end
+        puts
+      end
+
+      save_history
+      puts "#{DIM}bye!#{RESET}"
+    end
+
+    def self.load_history
+      return unless File.exist?(HISTORY_FILE)
+
+      File.readlines(HISTORY_FILE, chomp: true).last(HISTORY_MAX).each do |line|
+        Reline::HISTORY << line
+      end
+    rescue StandardError
+      # ignore corrupt history
+    end
+    private_class_method :load_history
+
+    def self.save_history
+      lines = Reline::HISTORY.to_a.last(HISTORY_MAX)
+      File.write(HISTORY_FILE, lines.join("\n") + "\n")
+    rescue StandardError
+      # ignore write failures
+    end
+    private_class_method :save_history
+
+    # Reads input with multi-line support — keeps prompting with continuation
+    # markers while the buffer contains incomplete Ruby (unclosed blocks, strings, etc.)
+    def self.read_input
+      # Second arg to readline: true = add to history, false = don't
+      buffer = Reline.readline(USER_PROMPT, true)
+      return nil if buffer.nil?
+
+      while incomplete_ruby?(buffer)
+        line = Reline.readline(CONT_PROMPT, false)
+        break if line.nil?
+        buffer += "\n" + line
+      end
+      buffer
+    end
+    private_class_method :read_input
+
+    # Heuristic: if RubyVM can compile it, treat as Ruby code.
+    # This lets users type `x = 1 + 2` without needing the "!" prefix.
+    def self.ruby_syntax?(input)
+      RubyVM::InstructionSequence.compile(input)
+      true
+    rescue SyntaxError
+      false
+    end
+    private_class_method :ruby_syntax?
+
+    # Distinguishes incomplete code (needs more input) from invalid code (syntax error).
+    # Only "unexpected end-of-input" and "unterminated" indicate the user is still typing;
+    # other SyntaxErrors mean the code is complete but malformed.
+    def self.incomplete_ruby?(code)
+      RubyVM::InstructionSequence.compile(code)
+      false
+    rescue SyntaxError => e
+      e.message.include?("unexpected end-of-input") ||
+        e.message.include?("unterminated")
+    end
+    private_class_method :incomplete_ruby?
+
+    # Eval Ruby in the caller's binding. On NameError/NoMethodError, yields to the
+    # fallback block (which sends to the LLM) — this is how ambiguous input like
+    # "sort this list" gets routed: Ruby rejects it, then the LLM handles it.
+    def self.eval_ruby(caller_binding, code)
+      result = caller_binding.eval(code)
+      puts "#{RUBY_PREFIX}#{result.inspect}"
+    rescue NameError, NoMethodError => e
+      block_given? ? yield : puts("#{ERROR_COLOR}#{e.class}: #{e.message}#{RESET}")
+    rescue => e
+      puts "#{ERROR_COLOR}#{e.class}: #{e.message}#{RESET}"
+    end
+    private_class_method :eval_ruby
+
+    # --- Mana LLM execution with streaming + markdown rendering ---
+
+    # Executes a prompt via the LLM engine with streaming output.
+    # Uses a line buffer to render complete lines with markdown formatting
+    # while the LLM streams tokens incrementally.
+    def self.run_mana(caller_binding, input)
+      streaming_text = false
+      in_code_block = false
+      line_buffer = +""       # mutable string — accumulates partial lines until \n
+      engine = Engine.new(caller_binding)
+
+      begin
+        result = engine.execute(input) do |type, *args|
+          case type
+          when :text
+            unless streaming_text
+              print MANA_PREFIX
+              streaming_text = true
+            end
+
+            # Buffer text and flush complete lines with markdown rendering
+            line_buffer << args[0].to_s
+            while (idx = line_buffer.index("\n"))
+              line = line_buffer.slice!(0, idx + 1)
+              in_code_block = render_line(line.chomp, in_code_block)
+              puts
+            end
+
+          when :tool_start
+            flush_line_buffer(line_buffer, in_code_block) if streaming_text
+            streaming_text = false
+            in_code_block = false
+            line_buffer.clear
+            name, input_data = args
+            detail = format_tool_call(name, input_data)
+            puts "#{TOOL_COLOR}  ⚡ #{detail}#{RESET}"
+
+          when :tool_end
+            name, result_str = args
+            summary = truncate(result_str.to_s, 120)
+            puts "#{RESULT_COLOR}  ↩ #{summary}#{RESET}" unless summary.start_with?("ok:")
+          end
+        end
+
+        # Flush any remaining buffered text
+        flush_line_buffer(line_buffer, in_code_block) if streaming_text
+
+        # Non-streaming fallback: if no text was streamed (e.g. tool-only response),
+        # render the final result as a single block
+        unless streaming_text
+          display = case result
+                    when Hash then result.inspect
+                    when nil then nil
+                    when String then render_markdown(result)
+                    else result.inspect
+                    end
+          puts "#{MANA_PREFIX}#{display}" if display
+        end
+      rescue LLMError, MaxIterationsError => e
+        flush_line_buffer(line_buffer, in_code_block) if streaming_text
+        puts "#{ERROR_COLOR}error: #{e.message}#{RESET}"
+      end
+    end
+    private_class_method :run_mana
+
+    # --- Markdown → ANSI rendering ---
+
+    # Render a single line, handling code block state.
+    # Returns the new in_code_block state.
+    def self.render_line(line, in_code_block)
+      if line.strip.start_with?("```")
+        if in_code_block
+          # End of code block — don't print the closing ```
+          return false
+        else
+          # Start of code block — don't print the opening ```
+          return true
+        end
+      end
+
+      if in_code_block
+        print "  #{CODE_COLOR}#{line}#{RESET}"
+      else
+        print render_markdown_inline(line)
+      end
+      in_code_block
+    end
+    private_class_method :render_line
+
+    # Flush remaining text in the line buffer
+    def self.flush_line_buffer(buffer, in_code_block)
+      return if buffer.empty?
+      text = buffer.dup
+      buffer.clear
+      if in_code_block
+        print "  #{CODE_COLOR}#{text}#{RESET}"
+      else
+        print render_markdown_inline(text)
+      end
+      puts
+    end
+    private_class_method :flush_line_buffer
+
+    # Convert inline markdown to ANSI codes.
+    # Handles **bold**, `inline code` (with negative lookbehind to skip ```),
+    # and # headings. Intentionally minimal — just enough for readable terminal output.
+    def self.render_markdown_inline(text)
+      text
+        .gsub(/\*\*(.+?)\*\*/, "#{BOLD}\\1#{RESET}")
+        .gsub(/(?<!`)`([^`]+)`(?!`)/, "#{CODE_COLOR}\\1#{RESET}")
+        .gsub(/^\#{1,3}\s+(.+)/) { BOLD + $1 + RESET }
+    end
+    private_class_method :render_markdown_inline
+
+    # Render a complete block of markdown text (for non-streaming results)
+    def self.render_markdown(text)
+      lines = text.lines
+      result = +""
+      in_code = false
+      lines.each do |line|
+        stripped = line.strip
+        if stripped.start_with?("```")
+          in_code = !in_code
+          next
+        end
+        if in_code
+          result << "  #{CODE_COLOR}#{line.rstrip}#{RESET}\n"
+        else
+          result << render_markdown_inline(line.rstrip) << "\n"
+        end
+      end
+      result.chomp
+    end
+    private_class_method :render_markdown
+
+    # --- Tool formatting helpers ---
+
+    def self.format_tool_call(name, input)
+      case name
+      when "call_func"
+        func = input[:name] || input["name"]
+        args = input[:args] || input["args"] || []
+        body = input[:body] || input["body"]
+        desc = func.to_s
+        desc += "(#{args.map(&:inspect).join(', ')})" if args.any?
+        desc += " { #{truncate(body, 40)} }" if body
+        desc
+      # Display read_var as just the name, write_var as an assignment
+      when "read_var", "write_var"
+        var = input[:name] || input["name"]
+        val = input[:value] || input["value"]
+        val ? "#{var} = #{truncate(val.inspect, 60)}" : var.to_s
+      when "read_attr", "write_attr"
+        obj = input[:obj] || input["obj"]
+        attr = input[:attr] || input["attr"]
+        "#{obj}.#{attr}"
+      when "remember"
+        content = input[:content] || input["content"]
+        "remember: #{truncate(content.to_s, 60)}"
+      when "knowledge"
+        topic = input[:topic] || input["topic"]
+        "knowledge(#{topic})"
+      else
+        name.to_s
+      end
+    end
+    private_class_method :format_tool_call
+
+    def self.truncate(str, max)
+      str.length > max ? "#{str[0, max]}..." : str
+    end
+    private_class_method :truncate
+  end
+end

data/lib/mana/config.rb

@@ -34,8 +34,6 @@ module Mana
       self.timeout = (ENV["MANA_TIMEOUT"] || 120).to_i
       @verbose = %w[1 true yes].include?(ENV["MANA_VERBOSE"]&.downcase)
       @backend = ENV["MANA_BACKEND"]&.to_sym
-      sec = ENV["MANA_SECURITY"]
-      @security = SecurityPolicy.new(sec ? sec.to_sym : :standard)
       @namespace = nil
       @memory_store = nil
       @memory_path = nil
@@ -55,23 +53,6 @@ module Mana
       @timeout = value
     end
 
-    # Read the current security policy
-    def security
-      @security
-    end
-
-    # Accept Symbol (:strict), Integer (1), or SecurityPolicy instance
-    def security=(value)
-      case value
-      when SecurityPolicy
-        @security = value
-      when Symbol, Integer
-        @security = SecurityPolicy.new(value)
-      else
-        raise ArgumentError, "security must be a Symbol, Integer, or SecurityPolicy, got #{value.class}"
-      end
-    end
-
     # Resolve the effective base URL based on the configured or auto-detected backend.
     # Falls back to the appropriate default when no explicit URL is set.
     def effective_base_url