ruby-claw 0.1.2 → 0.2.0

data/lib/claw/console/server.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+require "json"
+
+module Claw
+  module Console
+    # Local web server for agent observability and operations.
+    # Serves the console UI and provides API endpoints.
+    class Server < Sinatra::Base
+      set :views, File.join(__dir__, "views")
+      set :public_folder, File.join(__dir__, "public")
+      set :bind, "127.0.0.1"
+      set :port, 4567
+      set :server, :webrick
+
+      # Allow all hosts in development/testing (console is localhost-only)
+      set :host_authorization, { permitted_hosts: [] }
+
+      # Shared state — configured before starting
+      class << self
+        attr_accessor :event_logger, :runtime, :memory_instance, :claw_dir
+      end
+
+      # Configure the server with runtime references.
+      def self.setup(claw_dir:, runtime: nil, memory: nil, port: 4567)
+        self.claw_dir = claw_dir
+        self.runtime = runtime
+        self.memory_instance = memory
+        self.event_logger = EventLogger.new(File.join(claw_dir, "log"))
+        set :port, port
+      end
+
+      # --- Pages ---
+
+      get "/" do
+        erb :index
+      end
+
+      get "/prompt" do
+        erb :prompt
+      end
+
+      get "/monitor" do
+        erb :monitor
+      end
+
+      get "/traces" do
+        erb :traces
+      end
+
+      get "/memory" do
+        erb :memory
+      end
+
+      get "/tools" do
+        erb :tools
+      end
+
+      get "/snapshots" do
+        erb :snapshots
+      end
+
+      get "/experiments" do
+        erb :experiments
+      end
+
+      # --- API Endpoints ---
+
+      get "/api/status" do
+        content_type :json
+        {
+          version: Claw::VERSION,
+          state: self.class.runtime&.state,
+          snapshot_count: self.class.runtime&.snapshots&.size || 0,
+          memory_count: self.class.memory_instance&.long_term&.size || 0,
+          tool_count: Mana.registered_tools.size,
+          event_count: self.class.event_logger&.count || 0
+        }.to_json
+      end
+
+      get "/api/events" do
+        content_type "text/event-stream"
+        cache_control :no_cache
+
+        stream(:keep_open) do |out|
+          SSE.stream_events(out, self.class.event_logger)
+        end
+      end
+
+      get "/api/traces" do
+        content_type :json
+        traces_dir = File.join(self.class.claw_dir, "traces")
+        unless Dir.exist?(traces_dir)
+          return [].to_json
+        end
+
+        files = Dir.glob(File.join(traces_dir, "*.md")).sort.reverse.first(50)
+        files.map do |f|
+          { id: File.basename(f, ".md"), filename: File.basename(f),
+            size: File.size(f), modified: File.mtime(f).iso8601 }
+        end.to_json
+      end
+
+      get "/api/traces/:id" do
+        content_type :json
+        halt 400, { error: "Invalid trace ID" }.to_json unless params[:id] =~ /\A[a-zA-Z0-9_\-]+\z/
+
+        path = File.join(self.class.claw_dir, "traces", "#{params[:id]}.md")
+        halt 404, { error: "Trace not found" }.to_json unless File.exist?(path)
+
+        { id: params[:id], content: File.read(path) }.to_json
+      end
+
+      get "/api/memory" do
+        content_type :json
+        mem = self.class.memory_instance
+        unless mem
+          return [].to_json
+        end
+
+        mem.long_term.to_json
+      end
+
+      get "/api/prompt" do
+        content_type :json
+        prompt_path = File.join(self.class.claw_dir, "system_prompt.md")
+        content = File.exist?(prompt_path) ? File.read(prompt_path) : ""
+
+        sections = Mana.instance_variable_get(:@prompt_sections)&.filter_map(&:call) || []
+
+        { template: content, sections: sections }.to_json
+      end
+
+      get "/api/prompt/sections" do
+        content_type :json
+        sections = Mana.instance_variable_get(:@prompt_sections)&.filter_map(&:call) || []
+        sections.to_json
+      end
+
+      get "/api/tools" do
+        content_type :json
+        registry = Claw.tool_registry
+        core_tools = Mana.registered_tools.map { |t| { name: t[:name], description: t[:description], source: "core" } }
+
+        project_tools = registry ? registry.index.entries.map do |e|
+          { name: e.name, description: e.description, source: "project",
+            loaded: registry.loaded?(e.name) }
+        end : []
+
+        { core: core_tools, project: project_tools }.to_json
+      end
+
+      # --- Helpers ---
+
+      helpers do
+        def parse_json!
+          data = JSON.parse(request.body.read, symbolize_names: true)
+          data
+        rescue JSON::ParserError
+          halt 400, { error: "Invalid JSON" }.to_json
+        end
+
+        def require_field!(data, field)
+          halt 400, { error: "Missing field: #{field}" }.to_json unless data[field]
+        end
+      end
+
+      # --- Mutation API ---
+
+      post "/api/memory" do
+        content_type :json
+        data = parse_json!
+        require_field!(data, :content)
+        mem = self.class.memory_instance
+        halt 400, { error: "Memory not available" }.to_json unless mem
+
+        entry = mem.remember(data[:content])
+        { success: true, entry: entry }.to_json
+      end
+
+      delete "/api/memory/:id" do
+        content_type :json
+        halt 400, { error: "Invalid ID" }.to_json unless params[:id] =~ /\A\d+\z/
+        mem = self.class.memory_instance
+        halt 400, { error: "Memory not available" }.to_json unless mem
+
+        mem.forget(id: params[:id].to_i)
+        { success: true }.to_json
+      end
+
+      post "/api/prompt" do
+        content_type :json
+        data = parse_json!
+        require_field!(data, :content)
+        path = File.join(self.class.claw_dir, "system_prompt.md")
+        File.write(path, data[:content])
+        { success: true }.to_json
+      end
+
+      post "/api/tools/load" do
+        content_type :json
+        data = parse_json!
+        require_field!(data, :name)
+        registry = Claw.tool_registry
+        halt 400, { error: "Tool registry not available" }.to_json unless registry
+
+        msg = registry.load(data[:name])
+        { success: true, message: msg }.to_json
+      end
+
+      post "/api/tools/unload" do
+        content_type :json
+        data = parse_json!
+        require_field!(data, :name)
+        registry = Claw.tool_registry
+        halt 400, { error: "Tool registry not available" }.to_json unless registry
+
+        msg = registry.unload(data[:name])
+        { success: true, message: msg }.to_json
+      end
+
+      post "/api/snapshots" do
+        content_type :json
+        runtime = self.class.runtime
+        halt 400, { error: "Runtime not available" }.to_json unless runtime
+
+        id = runtime.snapshot!(label: "console")
+        { success: true, id: id }.to_json
+      end
+
+      post "/api/snapshots/:id/rollback" do
+        content_type :json
+        halt 400, { error: "Invalid ID" }.to_json unless params[:id] =~ /\A\d+\z/
+        runtime = self.class.runtime
+        halt 400, { error: "Runtime not available" }.to_json unless runtime
+
+        runtime.rollback!(params[:id].to_i)
+        { success: true }.to_json
+      end
+
+      get "/api/snapshots" do
+        content_type :json
+        runtime = self.class.runtime
+        return [].to_json unless runtime
+
+        runtime.snapshots.map do |s|
+          { id: s.id, label: s.label, timestamp: s.timestamp }
+        end.to_json
+      end
+    end
+  end
+end

data/lib/claw/console/sse.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Claw
+  module Console
+    # Server-Sent Events helper for streaming events to the browser.
+    module SSE
+      # Stream events from the event logger to a Sinatra stream block.
+      #
+      # @param stream [Object] Sinatra stream object (responds to <<)
+      # @param logger [EventLogger] the event source
+      # @param poll_interval [Float] seconds between polls
+      def self.stream_events(stream, logger, poll_interval: 0.5)
+        last_timestamp = nil
+
+        loop do
+          events = logger.tail(since: last_timestamp)
+          events.each do |event|
+            stream << "data: #{JSON.generate(event)}\n\n"
+            last_timestamp = event[:timestamp]
+          end
+          sleep(poll_interval)
+        end
+      rescue IOError
+        # Client disconnected
+      end
+    end
+  end
+end

data/lib/claw/console/views/experiments.erb

@@ -0,0 +1,8 @@
+<h1>Experiments</h1>
+<p class="muted">Experiment platform allows forking runtime state, running prompt variations, and comparing results.</p>
+<div class="experiment-controls">
+  <button class="btn" id="new-experiment" onclick="newExperiment()">New Experiment</button>
+</div>
+<div id="experiments-list">
+  <p class="muted">No experiments yet.</p>
+</div>

data/lib/claw/console/views/index.erb

@@ -0,0 +1,27 @@
+<h1>Dashboard</h1>
+<div class="cards" id="dashboard-cards">
+  <div class="card">
+    <div class="card-label">Version</div>
+    <div class="card-value" id="stat-version">—</div>
+  </div>
+  <div class="card">
+    <div class="card-label">Tools</div>
+    <div class="card-value" id="stat-tools">—</div>
+  </div>
+  <div class="card">
+    <div class="card-label">Memories</div>
+    <div class="card-value" id="stat-memories">—</div>
+  </div>
+  <div class="card">
+    <div class="card-label">Snapshots</div>
+    <div class="card-value" id="stat-snapshots">—</div>
+  </div>
+  <div class="card">
+    <div class="card-label">Events</div>
+    <div class="card-value" id="stat-events">—</div>
+  </div>
+</div>
+<h2>Recent Events</h2>
+<div class="event-feed" id="dashboard-events">
+  <p class="muted">No events yet.</p>
+</div>

data/lib/claw/console/views/layout.erb

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Claw Console</title>
+  <link rel="stylesheet" href="/style.css">
+</head>
+<body>
+  <header>
+    <div class="logo">claw</div>
+    <nav>
+      <a href="/" class="nav-link">Dashboard</a>
+      <a href="/prompt" class="nav-link">Prompt</a>
+      <a href="/monitor" class="nav-link">Monitor</a>
+      <a href="/traces" class="nav-link">Traces</a>
+      <a href="/memory" class="nav-link">Memory</a>
+      <a href="/tools" class="nav-link">Tools</a>
+      <a href="/snapshots" class="nav-link">Snapshots</a>
+      <a href="/experiments" class="nav-link">Experiments</a>
+    </nav>
+    <div class="header-status" id="header-status"></div>
+  </header>
+  <main>
+    <%= yield %>
+  </main>
+  <script src="/app.js"></script>
+</body>
+</html>

data/lib/claw/console/views/memory.erb

@@ -0,0 +1,13 @@
+<h1>Memory</h1>
+<div class="memory-controls">
+  <input type="text" id="memory-input" placeholder="Add a new memory..." class="text-input">
+  <button class="btn" onclick="addMemory()">Remember</button>
+</div>
+<table class="data-table" id="memory-table">
+  <thead>
+    <tr><th>ID</th><th>Content</th><th>Created</th><th></th></tr>
+  </thead>
+  <tbody id="memory-body">
+    <tr><td colspan="4" class="muted">Loading...</td></tr>
+  </tbody>
+</table>

data/lib/claw/console/views/monitor.erb

@@ -0,0 +1,15 @@
+<h1>LLM Monitor</h1>
+<div class="monitor-controls">
+  <label><input type="checkbox" id="auto-scroll" checked> Auto-scroll</label>
+  <select id="event-filter">
+    <option value="">All events</option>
+    <option value="llm_call">LLM calls</option>
+    <option value="tool_call">Tool calls</option>
+    <option value="snapshot">Snapshots</option>
+    <option value="trace">Traces</option>
+  </select>
+  <span class="muted" id="event-count">0 events</span>
+</div>
+<div class="event-stream" id="event-stream">
+  <p class="muted">Connecting to event stream...</p>
+</div>

data/lib/claw/console/views/prompt.erb

@@ -0,0 +1,15 @@
+<h1>Prompt Inspector</h1>
+<div class="prompt-section">
+  <h2>System Prompt Template</h2>
+  <div class="prompt-editor">
+    <textarea id="prompt-template" rows="15" spellcheck="false"></textarea>
+    <button class="btn" id="save-prompt" onclick="savePrompt()">Save</button>
+    <span id="prompt-status" class="muted"></span>
+  </div>
+</div>
+<div class="prompt-section">
+  <h2>Dynamic Sections</h2>
+  <div id="prompt-sections" class="section-list">
+    <p class="muted">Loading...</p>
+  </div>
+</div>

data/lib/claw/console/views/snapshots.erb

@@ -0,0 +1,12 @@
+<h1>Snapshots</h1>
+<div class="snapshot-controls">
+  <button class="btn" onclick="createSnapshot()">Take Snapshot</button>
+</div>
+<table class="data-table" id="snapshot-table">
+  <thead>
+    <tr><th>ID</th><th>Label</th><th>Timestamp</th><th></th></tr>
+  </thead>
+  <tbody id="snapshot-body">
+    <tr><td colspan="4" class="muted">Loading...</td></tr>
+  </tbody>
+</table>

data/lib/claw/console/views/tools.erb

@@ -0,0 +1,13 @@
+<h1>Tools</h1>
+<div class="tools-section">
+  <h2>Core Tools</h2>
+  <div id="core-tools" class="tool-grid">
+    <p class="muted">Loading...</p>
+  </div>
+</div>
+<div class="tools-section">
+  <h2>Project Tools</h2>
+  <div id="project-tools" class="tool-grid">
+    <p class="muted">Loading...</p>
+  </div>
+</div>

data/lib/claw/console/views/traces.erb

@@ -0,0 +1,9 @@
+<h1>Trace Explorer</h1>
+<div class="trace-layout">
+  <div class="trace-list" id="trace-list">
+    <p class="muted">Loading traces...</p>
+  </div>
+  <div class="trace-detail" id="trace-detail">
+    <p class="muted">Select a trace to view its content.</p>
+  </div>
+</div>

data/lib/claw/console.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "console/event_logger"
+require_relative "console/sse"
+require_relative "console/server"

data/lib/claw/evolution.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+
+module Claw
+  # Self-evolution loop: reads execution traces, uses LLM to diagnose
+  # improvements, forks runtime to apply changes, scores via test suite,
+  # and keeps or discards the change atomically.
+  #
+  # Depends on:
+  #   - v3 Runtime (fork/rollback)
+  #   - v5.1 Traces (.ruby-claw/traces/)
+  #   - v5.2 claw init (.ruby-claw/gems/ editable source)
+  class Evolution
+    class RejectError < StandardError; end
+
+    DIAGNOSIS_SYSTEM = "You are a code improvement agent. Analyze execution traces and propose precise code changes. Respond only with valid JSON."
+
+    DIAGNOSIS_PROMPT = <<~PROMPT
+      Review these execution traces from a Ruby agent framework and propose ONE specific code change that would improve:
+      - Response quality (better tool use, fewer iterations)
+      - Performance (fewer tokens, lower latency)
+      - Robustness (better error handling, edge cases)
+
+      Respond with a JSON object:
+      {
+        "summary": "Brief description of the change",
+        "gem": "ruby-claw or ruby-mana",
+        "file": "relative/path/to/file.rb",
+        "old_code": "exact existing code to replace (copy-paste from source)",
+        "new_code": "replacement code",
+        "rationale": "why this improves the agent"
+      }
+
+      If no meaningful improvements can be made, respond with:
+      {"summary": "no changes needed"}
+
+      IMPORTANT: old_code must be an exact substring of the file. Be precise.
+    PROMPT
+
+    attr_reader :results
+
+    # @param runtime [Claw::Runtime] the reversible runtime
+    # @param claw_dir [String] path to .ruby-claw/
+    # @param config [Mana::Config] LLM configuration
+    def initialize(runtime:, claw_dir:, config: Mana.config)
+      @runtime = runtime
+      @claw_dir = claw_dir
+      @gems_dir = File.join(claw_dir, "gems")
+      @config = config
+      @results = []
+    end
+
+    # Run one evolution cycle: diagnose → propose → test → keep/discard.
+    # Returns a result hash with :status, :proposal, :reason.
+    def evolve
+      traces = load_recent_traces
+      if traces.empty?
+        return log_result(status: :skip, reason: "no traces found")
+      end
+
+      unless Dir.exist?(@gems_dir)
+        return log_result(status: :skip, reason: "no gems/ directory — run `claw init` first")
+      end
+
+      proposal = diagnose(traces)
+      if proposal[:file].nil?
+        return log_result(status: :skip, reason: proposal[:summary])
+      end
+
+      try_proposal(proposal)
+    end
+
+    # Load recent trace files as strings.
+    def load_recent_traces(limit: 5)
+      dir = File.join(@claw_dir, "traces")
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, "*.md"))
+        .sort_by { |f| File.mtime(f) }
+        .last(limit)
+        .map { |f| File.read(f) }
+    end
+
+    # Send traces to LLM for diagnosis. Returns a proposal hash.
+    def diagnose(traces)
+      prompt = DIAGNOSIS_PROMPT + "\n\n## Recent Traces\n\n" + traces.join("\n\n---\n\n")
+
+      backend = Mana::Backends::Base.for(@config)
+      response = backend.chat(
+        system: DIAGNOSIS_SYSTEM,
+        messages: [{ role: "user", content: prompt }],
+        tools: [],
+        model: @config.model
+      )
+
+      text = extract_text(response[:content])
+      parse_proposal(text)
+    rescue => e
+      { summary: "diagnosis failed: #{e.message}" }
+    end
+
+    # Attempt to apply a proposal inside a runtime fork.
+    def try_proposal(proposal)
+      gem_name = proposal[:gem] || "ruby-claw"
+      file_path = File.join(@gems_dir, gem_name, proposal[:file])
+
+      unless File.exist?(file_path)
+        return log_result(status: :reject, proposal: proposal[:summary],
+                          reason: "file not found: #{proposal[:file]}")
+      end
+
+      content = File.read(file_path)
+      unless content.include?(proposal[:old_code])
+        return log_result(status: :reject, proposal: proposal[:summary],
+                          reason: "old_code not found in #{proposal[:file]}")
+      end
+
+      success, result = @runtime.fork(label: "evolve: #{proposal[:summary]}") do
+        # Apply the change
+        modified = content.sub(proposal[:old_code], proposal[:new_code])
+        File.write(file_path, modified)
+
+        # Score: run tests
+        score = run_tests(gem_name)
+        unless score[:passed]
+          raise RejectError, "tests failed:\n#{score[:output].to_s[0, 500]}"
+        end
+
+        score
+      end
+
+      if success
+        # Write evolution log
+        write_evolution_log(proposal, :accept, result)
+        log_result(status: :accept, proposal: proposal[:summary],
+                   rationale: proposal[:rationale])
+      else
+        write_evolution_log(proposal, :reject, result)
+        log_result(status: :reject, proposal: proposal[:summary],
+                   reason: result.is_a?(Exception) ? result.message : result.to_s)
+      end
+    end
+
+    private
+
+    def extract_text(content)
+      return content.to_s unless content.is_a?(Array)
+      content.filter_map { |b| b[:text] || b["text"] }.join
+    end
+
+    def parse_proposal(text)
+      json_match = text.match(/\{[\s\S]*\}/)
+      return { summary: "no JSON in response" } unless json_match
+
+      parsed = JSON.parse(json_match[0], symbolize_names: true)
+      parsed
+    rescue JSON::ParserError
+      { summary: "failed to parse proposal JSON" }
+    end
+
+    def run_tests(gem_name)
+      gem_dir = File.join(@gems_dir, gem_name)
+      return { passed: true, output: "no gem directory" } unless Dir.exist?(gem_dir)
+
+      # Check if rspec is available
+      gemfile = File.join(gem_dir, "Gemfile")
+      unless File.exist?(gemfile)
+        return { passed: true, output: "no Gemfile — skipping tests" }
+      end
+
+      out, status = Open3.capture2e(
+        "bundle", "exec", "rspec", "--format", "progress",
+        chdir: gem_dir
+      )
+      { passed: status.success?, output: out }
+    rescue Errno::ENOENT
+      # bundle/rspec not found
+      { passed: true, output: "rspec not available — skipping" }
+    end
+
+    def write_evolution_log(proposal, status, result)
+      log_dir = File.join(@claw_dir, "evolution")
+      FileUtils.mkdir_p(log_dir)
+
+      timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+      path = File.join(log_dir, "#{timestamp}_#{status}.md")
+
+      lines = []
+      lines << "# Evolution: #{proposal[:summary]}"
+      lines << ""
+      lines << "- Status: #{status}"
+      lines << "- Gem: #{proposal[:gem]}"
+      lines << "- File: #{proposal[:file]}"
+      lines << "- Rationale: #{proposal[:rationale]}"
+      lines << "- Timestamp: #{Time.now.iso8601}"
+      lines << ""
+      lines << "## Old Code"
+      lines << "```ruby"
+      lines << proposal[:old_code].to_s
+      lines << "```"
+      lines << ""
+      lines << "## New Code"
+      lines << "```ruby"
+      lines << proposal[:new_code].to_s
+      lines << "```"
+
+      if result.is_a?(Hash) && result[:output]
+        lines << ""
+        lines << "## Test Output"
+        lines << "```"
+        lines << result[:output].to_s[0, 2000]
+        lines << "```"
+      end
+
+      File.write(path, lines.join("\n"))
+    rescue => e
+      # Don't crash on log failure
+    end
+
+    def log_result(result)
+      @results << result
+      result
+    end
+  end
+end