ruby-claw 0.1.2 → 0.2.0

data/lib/claw/chat.rb

@@ -19,6 +19,7 @@ module Claw
 
     CONT_PROMPT  = "\e[2m  \e[0m"
     EXIT_COMMANDS = /\A(exit|quit|bye|q)\z/i
+    SLASH_COMMANDS = %w[snapshot rollback diff history status evolve].freeze
 
     HISTORY_FILE = File.join(Dir.home, ".claw_history")
     HISTORY_MAX  = 1000
@@ -28,6 +29,7 @@ module Claw
       load_history
       load_compiled_methods(caller_binding)
       restore_runtime(caller_binding)
+      @runtime = init_reversible_runtime(caller_binding)
       puts "#{DIM}Claw agent · type 'exit' to quit#{RESET}"
       puts
 
@@ -37,7 +39,9 @@ module Claw
         next if input.strip.empty?
         break if input.strip.match?(EXIT_COMMANDS)
 
-        if input.start_with?("!")
+        if input.start_with?("/")
+          handle_slash_command(input.strip)
+        elsif input.start_with?("!")
           eval_ruby(caller_binding, input[1..].strip)
         elsif ruby_syntax?(input)
           eval_ruby(caller_binding, input) { run_claw(caller_binding, input) }
@@ -65,7 +69,7 @@ module Claw
     end
     private_class_method :load_history
 
-    # Reload mana def compiled methods from .mana_cache/ on session start.
+    # Reload mana def compiled methods from .ruby-mana/cache/ on session start.
     # These are pre-compiled Ruby methods that don't need LLM calls.
     def self.load_compiled_methods(caller_binding)
       cache_dir = Mana::Compiler.cache_dir
@@ -86,20 +90,20 @@ module Claw
     end
     private_class_method :load_compiled_methods
 
-    # Save Ruby runtime state (variables + method definitions) to .mana/
+    # Save Ruby runtime state (variables + method definitions) to .ruby-claw/
     def self.save_runtime(caller_binding)
       return unless Claw.config.persist_session
-      dir = File.join(Dir.pwd, ".mana")
+      dir = File.join(Dir.pwd, ".ruby-claw")
       Claw::Serializer.save(caller_binding, dir)
     rescue => e
       $stderr.puts "#{DIM}  ⚠ could not save runtime: #{e.message}#{RESET}" if Mana.config.verbose
     end
     private_class_method :save_runtime
 
-    # Restore Ruby runtime state from .mana/
+    # Restore Ruby runtime state from .ruby-claw/
     def self.restore_runtime(caller_binding)
       return unless Claw.config.persist_session
-      dir = File.join(Dir.pwd, ".mana")
+      dir = File.join(Dir.pwd, ".ruby-claw")
       return unless File.exist?(File.join(dir, "values.json")) || File.exist?(File.join(dir, "definitions.rb"))
 
       warnings = Claw::Serializer.restore(caller_binding, dir)
@@ -110,6 +114,100 @@ module Claw
     end
     private_class_method :restore_runtime
 
+    # --- Reversible Runtime ---
+
+    # Initialize the reversible runtime with all resource types.
+    def self.init_reversible_runtime(caller_binding)
+      runtime = Claw::Runtime.new
+
+      # Register context (mana conversation state)
+      context = Mana::Context.current
+      runtime.register("context", Claw::Resources::ContextResource.new(context))
+
+      # Register memory (claw long-term facts)
+      memory = Claw.memory
+      runtime.register("memory", Claw::Resources::MemoryResource.new(memory)) if memory
+
+      # Register binding (local variables)
+      runtime.register("binding", Claw::Resources::BindingResource.new(
+        caller_binding,
+        on_exclude: ->(name, e) {
+          puts "#{DIM}  ⚠ #{name} excluded from runtime: #{e.message}#{RESET}"
+        }
+      ))
+
+      # Register filesystem (.ruby-claw/ directory)
+      claw_dir = File.join(Dir.pwd, ".ruby-claw")
+      if File.directory?(claw_dir)
+        runtime.register("filesystem", Claw::Resources::FilesystemResource.new(claw_dir))
+      end
+
+      # Initial snapshot
+      runtime.snapshot!(label: "session_start")
+      puts "#{DIM}  ✓ runtime initialized (#{runtime.resources.size} resources)#{RESET}"
+      runtime
+    rescue => e
+      puts "#{DIM}  ⚠ runtime init failed: #{e.message}#{RESET}"
+      nil
+    end
+    private_class_method :init_reversible_runtime
+
+    # Handle /command inputs — delegates to Claw::Commands and renders output.
+    def self.handle_slash_command(input)
+      cmd, *args = input.sub(/\A\//, "").split(" ", 2)
+      arg = args.first
+
+      result = Claw::Commands.dispatch(cmd, arg, runtime: @runtime)
+      render_command_result(result, cmd)
+    end
+    private_class_method :handle_slash_command
+
+    # Render a Commands result Hash to the terminal.
+    def self.render_command_result(result, cmd)
+      case result[:type]
+      when :success
+        puts "#{DIM}  ✓ #{result[:message]}#{RESET}"
+      when :error
+        puts "#{ERROR_COLOR}#{result[:message]}#{RESET}"
+        if result[:data].is_a?(Hash) && result[:data][:available]
+          puts "#{DIM}Available: #{result[:data][:available].join(', ')}#{RESET}"
+        end
+      when :info
+        puts "#{DIM}#{result[:message]}#{RESET}"
+      when :data
+        case cmd
+        when "diff"
+          data = result[:data]
+          puts "#{DIM}Diff ##{data[:from]} → ##{data[:to]}:#{RESET}"
+          data[:diffs].each do |name, d|
+            puts "#{BOLD}  #{name}:#{RESET}"
+            d.each_line { |l| puts "    #{l.rstrip}" }
+          end
+        when "history"
+          result[:data][:snapshots].each do |s|
+            puts "#{DIM}  ##{s[:id]} #{s[:label] || '(unlabeled)'} — #{s[:timestamp]}#{RESET}"
+          end
+        when "status"
+          puts result[:data][:markdown]
+        when "evolve"
+          evo = result[:data]
+          case evo[:status]
+          when :accept
+            puts "#{RESULT_COLOR}  ✓ accepted: #{evo[:proposal]}#{RESET}"
+            puts "#{DIM}    #{evo[:rationale]}#{RESET}" if evo[:rationale]
+          when :reject
+            puts "#{TOOL_COLOR}  ✗ rejected: #{evo[:proposal] || 'n/a'}#{RESET}"
+            puts "#{DIM}    #{evo[:reason]}#{RESET}"
+          when :skip
+            puts "#{DIM}  · skipped: #{evo[:reason]}#{RESET}"
+          end
+        else
+          puts "#{DIM}#{result[:message]}#{RESET}"
+        end
+      end
+    end
+    private_class_method :render_command_result
+
     # Track method definitions for session persistence
     def self.track_definition(caller_binding, code, method_name)
       receiver = caller_binding.receiver
@@ -227,6 +325,9 @@ module Claw
           puts "#{CLAW_PREFIX}#{display}" if display
         end
 
+        # Write execution trace
+        write_trace(engine.trace_data) if engine.trace_data
+
         # Schedule compaction after each exchange
         Claw.memory&.schedule_compaction
         append_interaction_log(input, result)
@@ -237,6 +338,18 @@ module Claw
     end
     private_class_method :run_claw
 
+    # --- Trace writing ---
+
+    def self.write_trace(trace_data)
+      claw_dir = File.join(Dir.pwd, ".ruby-claw")
+      return unless File.directory?(claw_dir)
+
+      Claw::Trace.write(trace_data, claw_dir)
+    rescue => e
+      $stderr.puts "#{DIM}  ⚠ trace write failed: #{e.message}#{RESET}" if Mana.config.verbose
+    end
+    private_class_method :write_trace
+
     # --- Interaction logging ---
 
     def self.append_interaction_log(input, result)

data/lib/claw/child_runtime.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Claw
+  # A child agent that runs in isolation and can merge results back to parent.
+  #
+  # Lifecycle: created → running → completed/failed/cancelled
+  # Isolation: separate binding (deep-copied vars), separate memory (copied facts),
+  # optional git worktree for filesystem.
+  class ChildRuntime
+    STATES = %i[created running completed failed cancelled].freeze
+
+    CancelledError = Class.new(StandardError)
+
+    attr_reader :id, :state, :result, :error, :runtime, :prompt
+
+    def initialize(parent:, prompt:, vars: {}, role: nil, model: nil)
+      @id = SecureRandom.hex(4)
+      @parent = parent
+      @prompt = prompt
+      @vars = vars
+      @role = role
+      @model = model
+      @state = :created
+      @result = nil
+      @error = nil
+      @thread = nil
+      @cancelled = false
+      @mutex = Mutex.new
+    end
+
+    # Start execution in a background thread.
+    def start!
+      raise "Already started" unless @state == :created
+
+      @state = :running
+      @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @thread = Thread.new { execute }
+      self
+    end
+
+    # Block until the child completes (or timeout).
+    #
+    # @param timeout [Numeric, nil] seconds to wait
+    # @return [ChildRuntime] self
+    def join(timeout: nil)
+      @thread&.join(timeout)
+      self
+    end
+
+    # Request cancellation. The child checks this flag between iterations.
+    def cancel!
+      @mutex.synchronize do
+        @cancelled = true
+        @state = :cancelled
+      end
+    end
+
+    # Elapsed time in milliseconds since start.
+    def elapsed_ms
+      return 0 unless @started_at
+
+      t = @finished_at || Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      ((t - @started_at) * 1000).round
+    end
+
+    # Compare child's current state against its initial snapshot.
+    # Only callable after the child has completed.
+    #
+    # @return [Hash] resource diffs
+    def diff
+      raise "Cannot diff while child is running" if @state == :running
+      return {} unless @runtime
+
+      initial = @runtime.snapshots.first&.id
+      return {} unless initial
+
+      current_id = @runtime.snapshot!(label: "diff_check")
+      @runtime.diff(initial, current_id)
+    end
+
+    # Merge child resource changes back to parent.
+    #
+    # @param only [Array<Symbol>, nil] resource names to merge (nil = all)
+    def merge!(only: nil)
+      raise "Child not completed" unless @state == :completed
+      raise "No child runtime" unless @runtime
+
+      targets = if only
+        @runtime.resources.select { |n, _| only.include?(n.to_sym) }
+      else
+        @runtime.resources
+      end
+
+      targets.each do |name, child_res|
+        parent_res = @parent.resources[name]
+        next unless parent_res
+
+        parent_res.merge_from!(child_res)
+      end
+
+      @parent.record_event(
+        action: "child_merged",
+        target: @id,
+        detail: "merged #{targets.keys.join(', ')}"
+      )
+    end
+
+    # Is the child still running?
+    def running?
+      @state == :running
+    end
+
+    # Is the child done (completed, failed, or cancelled)?
+    def done?
+      %i[completed failed cancelled].include?(@state)
+    end
+
+    private
+
+    def execute
+      # 1. Create isolated binding with deep-copied variables
+      child_binding = Object.new.instance_eval { binding }
+      @vars.each do |k, v|
+        copied = begin
+          Marshal.load(Marshal.dump(v))
+        rescue TypeError
+          v # fallback for non-marshalable objects (procs, etc.)
+        end
+        child_binding.local_variable_set(k, copied)
+      end
+
+      # 2. Create child runtime with isolated resources
+      @runtime = Claw::Runtime.new
+
+      # Binding resource
+      @runtime.register("binding", Resources::BindingResource.new(child_binding))
+
+      # Context resource (fresh for child thread)
+      context = Mana::Context.new
+      @runtime.register("context", Resources::ContextResource.new(context))
+
+      # Memory resource (copy parent's long-term facts)
+      parent_memory_res = @parent.resources["memory"]
+      if parent_memory_res
+        child_memory = Claw::Memory.new
+        parent_mem = parent_memory_res.instance_variable_get(:@memory)
+        if parent_mem
+          parent_mem.long_term.each do |fact|
+            child_memory.remember(fact[:content])
+          end
+        end
+        @runtime.register("memory", Resources::MemoryResource.new(child_memory))
+      end
+
+      # Filesystem resource (worktree if parent has filesystem)
+      parent_fs = @parent.resources["filesystem"]
+      if parent_fs && parent_fs.is_a?(Resources::FilesystemResource)
+        worktree = Resources::WorktreeResource.new(
+          parent_path: parent_fs.path,
+          branch_name: "child-#{@id}"
+        )
+        @runtime.register("filesystem", worktree)
+      end
+
+      @runtime.snapshot!(label: "child_start")
+
+      # 3. Configure role
+      if @role
+        Claw::Roles.switch!(@role)
+      end
+
+      # 4. Execute via Mana engine
+      engine = Mana::Engine.new(child_binding)
+      raise CancelledError if @cancelled
+
+      raw = engine.execute(@prompt) do |_type, *_args|
+        raise CancelledError if @cancelled
+      end
+
+      @result = raw
+      @mutex.synchronize { @state = :completed unless @cancelled }
+    rescue CancelledError
+      @mutex.synchronize { @state = :cancelled }
+    rescue => e
+      @error = e
+      @mutex.synchronize { @state = :failed unless @cancelled }
+    ensure
+      @finished_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      # Cleanup worktree if created
+      fs = @runtime&.resources&.dig("filesystem")
+      fs.cleanup! if fs.respond_to?(:cleanup!)
+    end
+  end
+end

data/lib/claw/cli.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Claw
+  # Headless CLI execution for non-interactive subcommands.
+  # Shares command logic with TUI via Claw::Commands.
+  module CLI
+    # Run a CLI subcommand without entering TUI.
+    #
+    # @param cmd [Symbol] command name
+    # @param args [Array<String>] arguments
+    def self.run(cmd, *args)
+      case cmd
+      when :status
+        runtime = init_headless_runtime
+        result = Commands.dispatch("status", nil, runtime: runtime)
+        render(result, "status")
+
+      when :history
+        runtime = init_headless_runtime
+        result = Commands.dispatch("history", nil, runtime: runtime)
+        render(result, "history")
+
+      when :rollback
+        runtime = init_headless_runtime
+        result = Commands.dispatch("rollback", args.first, runtime: runtime)
+        render(result, "rollback")
+
+      when :trace
+        render_trace(args.first)
+
+      when :evolve
+        runtime = init_headless_runtime
+        result = Commands.dispatch("evolve", nil, runtime: runtime)
+        render(result, "evolve")
+
+      when :benchmark
+        run_benchmark(args)
+
+      when :console
+        run_console(args)
+
+      else
+        $stderr.puts "Unknown command: #{cmd}"
+        exit 1
+      end
+    end
+
+    # --- Headless runtime ---
+
+    def self.init_headless_runtime
+      binding_obj = Object.new.instance_eval { binding }
+      runtime = Claw::Runtime.new
+
+      context = Mana::Context.current
+      runtime.register("context", Claw::Resources::ContextResource.new(context))
+
+      memory = Claw.memory
+      runtime.register("memory", Claw::Resources::MemoryResource.new(memory)) if memory
+
+      runtime.register("binding", Claw::Resources::BindingResource.new(binding_obj))
+
+      claw_dir = File.join(Dir.pwd, ".ruby-claw")
+      if File.directory?(claw_dir)
+        runtime.register("filesystem", Claw::Resources::FilesystemResource.new(claw_dir))
+      end
+
+      runtime.snapshot!(label: "cli_start")
+      runtime
+    end
+    private_class_method :init_headless_runtime
+
+    # --- Output rendering ---
+
+    def self.render(result, cmd)
+      case result[:type]
+      when :success
+        puts "✓ #{result[:message]}"
+      when :error
+        $stderr.puts "error: #{result[:message]}"
+        exit 1
+      when :info
+        puts result[:message]
+      when :data
+        case cmd
+        when "status"
+          render_markdown(result[:data][:markdown])
+        when "history"
+          result[:data][:snapshots].each do |s|
+            puts "  ##{s[:id]} #{s[:label] || '(unlabeled)'} — #{s[:timestamp]}"
+          end
+        when "evolve"
+          evo = result[:data]
+          case evo[:status]
+          when :accept then puts "✓ accepted: #{evo[:proposal]}"
+          when :reject then puts "✗ rejected: #{evo[:proposal] || 'n/a'}"
+          when :skip then puts "· skipped: #{evo[:reason]}"
+          end
+        else
+          puts result[:message]
+        end
+      end
+    end
+    private_class_method :render
+
+    def self.render_trace(task_id)
+      claw_dir = File.join(Dir.pwd, ".ruby-claw")
+      traces_dir = File.join(claw_dir, "traces")
+      unless Dir.exist?(traces_dir)
+        $stderr.puts "No traces directory"
+        exit 1
+      end
+
+      files = Dir.glob(File.join(traces_dir, "*.md")).sort
+      if task_id
+        file = files.find { |f| File.basename(f).include?(task_id) }
+        unless file
+          $stderr.puts "Trace not found: #{task_id}"
+          exit 1
+        end
+        render_markdown(File.read(file))
+      else
+        files.last(10).each { |f| puts File.basename(f) }
+      end
+    end
+    private_class_method :render_trace
+
+    def self.render_markdown(text)
+      begin
+        require "glamour"
+        puts Glamour.render(text)
+      rescue LoadError
+        puts text
+      end
+    end
+    private_class_method :render_markdown
+
+    def self.run_benchmark(args)
+      subcmd = args.first
+      case subcmd
+      when "run"
+        require_relative "benchmark/benchmark"
+        Claw::Benchmark.run!
+      when "diff"
+        require_relative "benchmark/benchmark"
+        Claw::Benchmark.diff!(args[1], args[2])
+      else
+        puts "Usage: claw benchmark run | claw benchmark diff <a> <b>"
+      end
+    end
+    private_class_method :run_benchmark
+
+    def self.run_console(args)
+      claw_dir = File.join(Dir.pwd, ".ruby-claw")
+      unless File.directory?(claw_dir)
+        $stderr.puts "No .ruby-claw/ directory — run `claw init` first"
+        exit 1
+      end
+
+      port = Claw.config.console_port
+      args.each_with_index { |a, i| port = args[i + 1].to_i if a == "--port" && args[i + 1] }
+
+      runtime = init_headless_runtime
+      FileUtils.mkdir_p(File.join(claw_dir, "log"))
+
+      Console::Server.setup(
+        claw_dir: claw_dir,
+        runtime: runtime,
+        memory: Claw.memory,
+        port: port
+      )
+
+      puts "Claw Console starting on http://127.0.0.1:#{port}"
+      Console::Server.run!
+    end
+    private_class_method :run_console
+  end
+end

data/lib/claw/commands.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Claw
+  # Pure-function slash commands. Each method returns a structured result Hash
+  # instead of printing directly, making commands testable and reusable
+  # across TUI, CLI, and tests.
+  #
+  # Result format: { type: :success | :error | :info | :data, message: String, data: Any }
+  module Commands
+    COMMANDS = %w[snapshot rollback diff history status evolve role forge].freeze
+
+    # Dispatch a slash command by name. Returns a result Hash.
+    #
+    # @param cmd [String] command name (without /)
+    # @param arg [String, nil] argument string
+    # @param runtime [Claw::Runtime] the runtime instance
+    # @param claw_dir [String, nil] path to .ruby-claw/ directory
+    # @return [Hash] { type:, message:, data: }
+    def self.dispatch(cmd, arg, runtime:, claw_dir: nil)
+      unless COMMANDS.include?(cmd)
+        return { type: :error, message: "Unknown command: /#{cmd}",
+                 data: { available: COMMANDS.map { |c| "/#{c}" } } }
+      end
+
+      unless runtime
+        return { type: :error, message: "Runtime not initialized" }
+      end
+
+      send("cmd_#{cmd}", arg, runtime: runtime, claw_dir: claw_dir)
+    rescue => e
+      { type: :error, message: "#{e.class}: #{e.message}" }
+    end
+
+    # --- Individual commands ---
+
+    def self.cmd_snapshot(arg, runtime:, **)
+      id = runtime.snapshot!(label: arg || "manual")
+      { type: :success, message: "snapshot ##{id} created#{arg ? " (#{arg})" : ""}", data: { id: id } }
+    end
+
+    def self.cmd_rollback(arg, runtime:, **)
+      unless arg
+        return { type: :error, message: "Usage: /rollback <id>" }
+      end
+      snap_id = arg.to_i
+      runtime.rollback!(snap_id)
+      { type: :success, message: "rolled back to snapshot ##{snap_id}", data: { id: snap_id } }
+    end
+
+    def self.cmd_diff(arg, runtime:, **)
+      snaps = runtime.snapshots
+      if snaps.size < 2 && !arg
+        return { type: :error, message: "Need at least 2 snapshots to diff" }
+      end
+
+      ids = arg ? arg.split.map(&:to_i) : [snaps[-2].id, snaps[-1].id]
+      if ids.size < 2
+        return { type: :error, message: "Usage: /diff <id_a> <id_b>" }
+      end
+
+      diffs = runtime.diff(ids[0], ids[1])
+      { type: :data, message: "Diff ##{ids[0]} → ##{ids[1]}",
+        data: { from: ids[0], to: ids[1], diffs: diffs } }
+    end
+
+    def self.cmd_history(_, runtime:, **)
+      snaps = runtime.snapshots
+      if snaps.empty?
+        return { type: :info, message: "No snapshots" }
+      end
+
+      items = snaps.map { |s| { id: s.id, label: s.label, timestamp: s.timestamp } }
+      { type: :data, message: "#{items.size} snapshots", data: { snapshots: items } }
+    end
+
+    def self.cmd_status(_, runtime:, **)
+      { type: :data, message: "Runtime status", data: { markdown: runtime.to_md } }
+    end
+
+    def self.cmd_evolve(_, runtime:, claw_dir: nil, **)
+      claw_dir ||= File.join(Dir.pwd, ".ruby-claw")
+      unless File.directory?(claw_dir)
+        return { type: :error, message: "No .ruby-claw/ directory — run `claw init` first" }
+      end
+
+      evo = Claw::Evolution.new(runtime: runtime, claw_dir: claw_dir)
+      result = evo.evolve
+      { type: :data, message: "Evolution cycle completed", data: result }
+    end
+
+    def self.cmd_role(arg, runtime:, claw_dir: nil, **)
+      claw_dir ||= File.join(Dir.pwd, ".ruby-claw")
+
+      unless arg
+        current = Claw::Roles.current
+        available = Claw::Roles.list(claw_dir)
+        return { type: :data, message: "Roles",
+                 data: { current: current&.dig(:name), available: available } }
+      end
+
+      Claw::Roles.switch!(arg, claw_dir)
+      { type: :success, message: "Switched to role: #{arg}" }
+    end
+
+    def self.cmd_forge(arg, runtime:, claw_dir: nil, **)
+      unless arg && !arg.strip.empty?
+        return { type: :error, message: "Usage: /forge <method_name>" }
+      end
+
+      claw_dir ||= File.join(Dir.pwd, ".ruby-claw")
+      # Get binding from runtime's binding resource
+      binding_res = runtime.resources["binding"]
+      unless binding_res
+        return { type: :error, message: "No binding resource available" }
+      end
+
+      caller_binding = binding_res.instance_variable_get(:@binding)
+      result = Claw::Forge.promote(arg.strip, binding: caller_binding, claw_dir: claw_dir)
+
+      if result[:success]
+        { type: :success, message: result[:message] }
+      else
+        { type: :error, message: result[:message] }
+      end
+    end
+
+    # Make individual commands private from external dispatch
+    private_class_method :cmd_snapshot, :cmd_rollback, :cmd_diff,
+                         :cmd_history, :cmd_status, :cmd_evolve, :cmd_role, :cmd_forge
+  end
+end