ruby-claw 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e867d234a5c3796d4ac6d17161a1bdf78a14a34671d29fe47ebe55bd61ba678
-  data.tar.gz: 34f158692c424ed0fccebe37a88f7bd7502a4f0fed0270ab90f3a6cabed44b8f
+  metadata.gz: 14400b4f156bbcd289918bf982f233f7c1055a246df1efac571b2e4852ef5752
+  data.tar.gz: 6f9cb9cee99ae272c0605c80f2256686ac256d7fa8c2cf4a3e19bdb330beee92
 SHA512:
-  metadata.gz: 0c31c6b9b878c64691c986f550fa4d3a966e7666cf8a1e041c7b5a47b4ae2652fb7055496f78bd5461b5b073d1e27e9c09059d3641bbd360c15faa375056564c
-  data.tar.gz: 804149d4ab957dedcaea0b89e3a7e28b31c5acc9a50ac209a81e4e29a69c5c35e870f2c5042a0ea35dcfee5f87d361ac8415e4d3f181d8aec152046e635834ec
+  metadata.gz: 6e7401c9af8cbe84fff2d677d34b4aab9d939e2e89e6355815a67fee4a5fcbf293c55f892bf144c096a78c8979d2d1d2eb52308a2ce4a2264f3d8456cb42a53b
+  data.tar.gz: 80ddb09282da9a9ec07ea6eb6a2ca4aa2282c61e1c3dd4338545873eb8fbb2a145955422600ea1eaa4829508818743adb2bd86be50ad1a6a8e70211b858919b8

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## [0.1.2] - 2026-04-04
+
+### Changed
+- `Claw::Memory` is now fully independent (no longer inherits from `Mana::Memory`)
+- Conversation context uses `context.messages` (renamed from `short_term`)
+- Uses `Thread.current[:claw_memory]` instead of `:mana_memory`
+- Remember tool registered via `Mana.register_tool` interface (no longer built into mana)
+- Long-term memories injected into prompt via `Mana.register_prompt_section`
+
+### Added
+- `Claw::Memory.incognito?` / `Claw::Memory.incognito(&block)` — claw-owned incognito mode
+- `Claw.incognito(&block)` — convenience method
+- `Thread.current[:claw_incognito]` for incognito state
+
+### Removed
+- Dependency on `Mana::Context.incognito?` (incognito now self-contained in claw)
+
+## [0.1.1] - 2026-03-27
+
+### Added
+- Markdown-based memory architecture (MEMORY.md, session.md, daily logs)
+- Complete README with usage examples
+- GitHub Pages website
+
+## [0.1.0] - 2026-03-27
+
+### Added
+- Initial release: Chat REPL, persistent memory, compaction, session persistence
+- Knowledge provider, runtime serializer
+- Built on ruby-mana provider interfaces

data/README.md

@@ -1,40 +1,95 @@
-# ruby-claw
+# ruby-claw 🦀
 
-Agent framework for Ruby, built on [ruby-mana](https://github.com/twokidsCarl/ruby-mana).
+[![Gem Version](https://badge.fury.io/rb/ruby-claw.svg)](https://rubygems.org/gems/ruby-claw) · [GitHub](https://github.com/twokidsCarl/ruby-claw)
 
-Claw extends mana's LLM engine with interactive chat, persistent memory with compaction, session persistence, and runtime state serialization.
+AI Agent framework for Ruby. Built on [ruby-mana](https://github.com/twokidsCarl/ruby-mana).
 
-## Install
+## What is Claw?
+
+Claw turns ruby-mana's embedded LLM engine into a full agent with persistent memory, interactive chat, and session recovery. Think of it as the agent layer on top of mana's execution engine.
 
 ```ruby
-gem "ruby-claw"
+gem install ruby-claw
 ```
 
-## Usage
+## Features
 
+### Interactive Chat REPL
 ```ruby
 require "claw"
-
-# Start interactive chat
 Claw.chat
+```
+Or from command line: `claw`
 
-# Access enhanced memory
-Claw.memory.search("ruby")
-Claw.memory.save_session
+- Auto-detects Ruby code vs natural language
+- Streaming output with markdown rendering
+- `!` prefix forces Ruby eval
+- Session persists across restarts
 
-# Configure
+### Persistent Memory
+Claw stores memories as human-readable Markdown in `.mana/`:
+
+```
+.mana/
+  MEMORY.md       # Long-term facts (editable!)
+  session.md      # Conversation summary
+  values.json     # Variable snapshots
+  definitions.rb  # Method definitions
+  log/
+    2026-03-29.md  # Daily interaction log
+```
+
+The LLM can `remember` facts that persist across sessions:
+```ruby
+claw> remember that the API uses OAuth2
+claw> # ... next session ...
+claw> what auth does our API use?
+# => "OAuth2 — I remembered this from a previous session"
+```
+
+### Runtime Persistence
+Variables and method definitions survive across sessions:
+```ruby
+claw> a = 42
+claw> def greet(name) = "Hello #{name}"
+claw> exit
+
+$ claw  # restart
+claw> a        # => 42
+claw> greet("world")  # => "Hello world"
+```
+
+### Memory Compaction
+When conversation grows large, old messages are automatically summarized in the background.
+
+### Keyword Memory Search
+With many memories (>20), only the most relevant are injected into prompts.
+
+## Configuration
+
+```ruby
 Claw.configure do |c|
-  c.memory_pressure = 0.7
-  c.persist_session = true
+  c.memory_pressure = 0.7       # Compact when tokens > 70% of context window
+  c.memory_keep_recent = 4      # Keep last 4 conversation rounds during compaction
+  c.compact_model = nil          # nil = use main model for summarization
+  c.persist_session = true       # Save/restore session across restarts
+  c.memory_top_k = 10           # Max memories to inject when searching
+  c.on_compact = ->(summary) { puts summary }
+end
+
+# Mana config (inherited)
+Mana.configure do |c|
+  c.model = "claude-sonnet-4-6"
+  c.api_key = "sk-..."
 end
 ```
 
-## Components
+## Relationship with ruby-mana
+
+- **ruby-mana** = Embedded LLM engine (`~"..."` syntax, binding manipulation, tool calling)
+- **ruby-claw** = Agent framework (chat REPL, memory, persistence, knowledge)
 
-- **Claw::Chat** — interactive REPL with streaming markdown output
-- **Claw::Memory** — compaction, search, and session persistence on top of Mana::Memory
-- **Claw::Serializer** — save/restore runtime variables and method definitions
-- **Claw::Knowledge** — extended knowledge base with agent-specific topics
+Claw depends on mana. You can use mana standalone for embedding LLM in Ruby code, or add claw for interactive agent features.
 
 ## License
 

data/lib/claw/chat.rb

@@ -26,6 +26,8 @@ module Claw
     def self.start(caller_binding)
       require "reline"
       load_history
+      load_compiled_methods(caller_binding)
+      restore_runtime(caller_binding)
       puts "#{DIM}Claw agent · type 'exit' to quit#{RESET}"
       puts
 
@@ -45,7 +47,8 @@ module Claw
         puts
       end
 
-      # Save session on exit
+      # Save state on exit
+      save_runtime(caller_binding)
       Claw.memory&.save_session
       save_history
       puts "#{DIM}bye!#{RESET}"
@@ -62,6 +65,61 @@ module Claw
     end
     private_class_method :load_history
 
+    # Reload mana def compiled methods from .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
+      return unless Dir.exist?(cache_dir)
+
+      count = 0
+      Dir.glob(File.join(cache_dir, "*.rb")).each do |path|
+        code = File.read(path)
+        # Skip the header comment lines, eval the method definition
+        caller_binding.eval(code, path, 1)
+        count += 1
+      rescue => e
+        $stderr.puts "#{DIM}  ⚠ could not load #{File.basename(path)}: #{e.message}#{RESET}" if Mana.config.verbose
+      end
+      puts "#{DIM}  ✓ loaded #{count} compiled methods#{RESET}" if count > 0
+    rescue => e
+      # Don't crash on cache loading failure
+    end
+    private_class_method :load_compiled_methods
+
+    # Save Ruby runtime state (variables + method definitions) to .mana/
+    def self.save_runtime(caller_binding)
+      return unless Claw.config.persist_session
+      dir = File.join(Dir.pwd, ".mana")
+      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/
+    def self.restore_runtime(caller_binding)
+      return unless Claw.config.persist_session
+      dir = File.join(Dir.pwd, ".mana")
+      return unless File.exist?(File.join(dir, "values.json")) || File.exist?(File.join(dir, "definitions.rb"))
+
+      warnings = Claw::Serializer.restore(caller_binding, dir)
+      warnings.each { |w| puts "#{DIM}  ⚠ #{w}#{RESET}" } if warnings.any?
+      puts "#{DIM}  ✓ runtime restored#{RESET}"
+    rescue => e
+      puts "#{DIM}  ⚠ could not restore runtime: #{e.message}#{RESET}"
+    end
+    private_class_method :restore_runtime
+
+    # Track method definitions for session persistence
+    def self.track_definition(caller_binding, code, method_name)
+      receiver = caller_binding.receiver
+      defs = receiver.instance_variable_defined?(:@__claw_definitions__) ?
+        receiver.instance_variable_get(:@__claw_definitions__) : {}
+      defs[method_name.to_s] = code
+      receiver.instance_variable_set(:@__claw_definitions__, defs)
+    end
+    private_class_method :track_definition
+
     def self.save_history
       lines = Reline::HISTORY.to_a.last(HISTORY_MAX)
       File.write(HISTORY_FILE, lines.join("\n") + "\n")
@@ -102,9 +160,16 @@ module Claw
 
     def self.eval_ruby(caller_binding, code)
       result = caller_binding.eval(code)
+      # Track method definitions: `def method_name` returns a Symbol in Ruby 3+
+      track_definition(caller_binding, code, result) if result.is_a?(Symbol) && code.strip.match?(/\Adef\s/)
       puts "#{RUBY_PREFIX}#{result.inspect}"
     rescue NameError, NoMethodError => e
-      block_given? ? yield : puts("#{ERROR_COLOR}#{e.class}: #{e.message}#{RESET}")
+      # Fallback to LLM for natural language (multi-word or non-ASCII like Chinese)
+      if block_given? && (code.include?(" ") || code.match?(/[^\x00-\x7F]/))
+        yield
+      else
+        puts "#{ERROR_COLOR}#{e.class}: #{e.message}#{RESET}"
+      end
     rescue => e
       puts "#{ERROR_COLOR}#{e.class}: #{e.message}#{RESET}"
     end
@@ -164,6 +229,7 @@ module Claw
 
         # Schedule compaction after each exchange
         Claw.memory&.schedule_compaction
+        append_interaction_log(input, result)
       rescue Mana::LLMError, Mana::MaxIterationsError => e
         flush_line_buffer(line_buffer, in_code_block) if streaming_text
         puts "#{ERROR_COLOR}error: #{e.message}#{RESET}"
@@ -171,6 +237,18 @@ module Claw
     end
     private_class_method :run_claw
 
+    # --- Interaction logging ---
+
+    def self.append_interaction_log(input, result)
+      store = Claw::FileStore.new
+      title = input.length > 50 ? input[0..47] + "..." : input
+      detail = result ? "- Result: #{result.to_s[0..100]}" : "- (no result)"
+      store.append_log(title: title, detail: detail)
+    rescue => e
+      # Don't crash on log failure
+    end
+    private_class_method :append_interaction_log
+
     # --- Markdown rendering ---
 
     def self.render_line(line, in_code_block)

data/lib/claw/memory.rb

@@ -1,30 +1,109 @@
 # frozen_string_literal: true
 
 module Claw
-  # Enhanced memory with compaction, session persistence, and search.
-  # Inherits base memory management from Mana::Memory and adds agent-level features.
-  class Memory < Mana::Memory
+  # Standalone long-term memory with compaction, session persistence, and search.
+  # No longer inherits from Mana::Memory — reads/writes Mana::Context for conversation state.
+  class Memory
     SUMMARIZE_MAX_RETRIES = 3
 
+    attr_reader :long_term
+
     def initialize
-      super
+      @long_term = []
+      @next_id = 1
       @compact_mutex = Mutex.new
       @compact_thread = nil
+      load_long_term
       load_session if Claw.config.persist_session
     end
 
     # --- Class methods ---
 
     class << self
-      # Return the current thread's memory instance (lazy-initialized).
+      # Check if the current thread is in claw incognito mode
+      def incognito?
+        Thread.current[:claw_incognito] == true
+      end
+
+      # Run a block with claw memory disabled. Long-term memory won't be
+      # loaded or saved, and the remember tool will be inactive.
+      def incognito(&block)
+        prev_incognito = Thread.current[:claw_incognito]
+        prev_memory = Thread.current[:claw_memory]
+        Thread.current[:claw_incognito] = true
+        Thread.current[:claw_memory] = nil
+        block.call
+      ensure
+        Thread.current[:claw_incognito] = prev_incognito
+        Thread.current[:claw_memory] = prev_memory
+      end
+
+      # Return the current thread's Claw memory instance (lazy-initialized).
+      # Uses a separate thread-local from Mana::Context.
       # Returns nil in incognito mode.
       def current
-        return nil if Mana::Memory.incognito?
+        return nil if incognito?
 
-        Thread.current[:mana_memory] ||= new
+        Thread.current[:claw_memory] ||= new
       end
     end
 
+    # --- Token estimation ---
+
+    # Rough token estimate: ~4 characters per token
+    def estimate_tokens(text)
+      return 0 unless text.is_a?(String)
+
+      (text.length / 4.0).ceil
+    end
+
+    # Estimate total token count across long-term memories + context messages/summaries
+    def token_count
+      count = 0
+      @long_term.each { |m| count += estimate_tokens(m[:content]) }
+      context = Mana::Context.current
+      if context
+        context.messages.each do |msg|
+          content = msg[:content]
+          case content
+          when String then count += estimate_tokens(content)
+          when Array
+            content.each { |block| count += estimate_tokens(block[:text] || block[:content] || "") }
+          end
+        end
+        context.summaries.each { |s| count += estimate_tokens(s) }
+      end
+      count
+    end
+
+    # --- Long-term memory management ---
+
+    # Store a fact in long-term memory. Deduplicates by content.
+    # Persists to disk immediately after adding.
+    def remember(content)
+      existing = @long_term.find { |e| e[:content] == content }
+      return existing if existing
+
+      entry = { id: @next_id, content: content, created_at: Time.now.iso8601 }
+      @next_id += 1
+      @long_term << entry
+      store.write(namespace, @long_term)
+      claw_store.append_log(title: "Remembered", detail: "- #{content}")
+      entry
+    end
+
+    # Remove a specific long-term memory by ID and persist the change
+    def forget(id:)
+      @long_term.reject! { |m| m[:id] == id }
+      store.write(namespace, @long_term)
+    end
+
+    # Clear persistent memories from both in-memory array and disk
+    def clear_long_term!
+      @long_term.clear
+      store.clear(namespace)
+    end
+
     # --- Compaction ---
 
     # Synchronous compaction: wait for any background run, then compact immediately
@@ -67,9 +146,10 @@ module Claw
     def save_session
       return unless Claw.config.persist_session
 
+      context = Mana::Context.current
       data = {
-        short_term: short_term,
-        summaries: summaries,
+        short_term: context&.messages || [],
+        summaries: context&.summaries || [],
         saved_at: Time.now.iso8601
       }
       claw_store.write_session(namespace, data)
@@ -82,11 +162,12 @@ module Claw
       data = claw_store.read_session(namespace)
       return unless data
 
-      if data[:short_term].is_a?(Array)
-        @short_term.concat(data[:short_term])
+      context = Mana::Context.current
+      if data[:short_term].is_a?(Array) && context
+        context.messages.concat(data[:short_term])
       end
-      if data[:summaries].is_a?(Array)
-        @summaries.concat(data[:summaries])
+      if data[:summaries].is_a?(Array) && context
+        context.summaries.concat(data[:summaries])
       end
     end
 
@@ -102,9 +183,7 @@ module Claw
 
       scored = long_term.map do |entry|
         content = entry[:content].to_s.downcase
-        # Score: count of matching keywords + partial match bonus
         score = keywords.count { |kw| content.include?(kw) }
-        # Bonus for substring match of full query
         score += 2 if content.include?(query.downcase)
         { entry: entry, score: score }
       end
@@ -116,15 +195,18 @@ module Claw
         .map { |s| s[:entry] }
     end
 
-    # --- Overrides ---
+    # --- Clearing ---
 
-    # Clear also clears session data
+    # Clear all memory (long-term + context + session)
     def clear!
-      super
+      @long_term.clear
+      store.clear(namespace)
       claw_store.clear_session(namespace)
+      Mana::Context.current&.clear!
     end
 
-    # Human-readable summary
+    # --- Display ---
+
     def inspect
       "#<Claw::Memory long_term=#{long_term.size}, short_term=#{short_term_rounds} rounds, tokens=#{token_count}/#{context_window}>"
     end
@@ -132,19 +214,64 @@ module Claw
     private
 
     def short_term_rounds
-      short_term.count { |m| m[:role] == "user" && m[:content].is_a?(String) }
+      context = Mana::Context.current
+      return 0 unless context
+      context.messages.count { |m| m[:role] == "user" && m[:content].is_a?(String) }
+    end
+
+    def context_window
+      Mana.config.context_window
     end
 
-    # Claw uses its own FileStore for session support
+    # Claw uses its own FileStore for session/log support
     def claw_store
       @claw_store ||= Claw::FileStore.new
     end
 
+    # Resolve memory store: user config > default file-based store
+    def store
+      Mana.config.memory_store || default_store
+    end
+
+    # Lazy-initialized default FileStore singleton
+    def default_store
+      @default_store ||= Mana::FileStore.new
+    end
+
+    def namespace
+      ns = Mana.config.namespace
+      return ns if ns && !ns.to_s.empty?
+
+      dir = `git rev-parse --show-toplevel 2>/dev/null`.strip
+      return File.basename(dir) unless dir.empty?
+
+      d = Dir.pwd
+      loop do
+        return File.basename(d) if File.exist?(File.join(d, "Gemfile"))
+        parent = File.dirname(d)
+        break if parent == d
+        d = parent
+      end
+
+      File.basename(Dir.pwd)
+    end
+
+    # Load long-term memories from the persistent store on initialization.
+    def load_long_term
+      return if self.class.incognito?
+
+      @long_term = store.read(namespace)
+      @next_id = (@long_term.map { |m| m[:id] }.max || 0) + 1
+    end
+
     # Compact short-term memory: summarize old messages and keep only recent rounds.
-    # Merges existing summaries + old messages into a single new summary.
     def perform_compaction
+      context = Mana::Context.current
+      return unless context
+
       keep_recent = Claw.config.memory_keep_recent
-      user_indices = short_term.each_with_index
+      messages = context.messages
+      user_indices = messages.each_with_index
         .select { |msg, _| msg[:role] == "user" && msg[:content].is_a?(String) }
         .map(&:last)
 
@@ -152,7 +279,7 @@ module Claw
 
       keep = [keep_recent, user_indices.size].min
       cutoff_user_idx = user_indices[-keep]
-      old_messages = short_term[0...cutoff_user_idx]
+      old_messages = messages[0...cutoff_user_idx]
       return if old_messages.empty?
 
       text_parts = old_messages.map do |msg|
@@ -168,12 +295,12 @@ module Claw
       return if text_parts.empty?
 
       prior_context = ""
-      unless summaries.empty?
-        prior_context = "Previous summary:\n#{summaries.join("\n")}\n\nNew conversation:\n"
+      unless context.summaries.empty?
+        prior_context = "Previous summary:\n#{context.summaries.join("\n")}\n\nNew conversation:\n"
       end
 
       # Calculate tokens for kept content
-      kept_messages = short_term[cutoff_user_idx..]
+      kept_messages = messages[cutoff_user_idx..]
       keep_tokens = kept_messages.sum do |msg|
         content = msg[:content]
         case content
@@ -186,10 +313,11 @@ module Claw
 
       summary = summarize(prior_context + text_parts.join("\n"), keep_tokens: keep_tokens)
 
-      @short_term = kept_messages
-      @summaries = [summary]
+      context.messages.replace(kept_messages)
+      context.summaries.replace([summary])
 
       Claw.config.on_compact&.call(summary)
+      claw_store.append_log(title: "Memory compacted", detail: "- Summaries updated")
     end
 
     # Call the LLM to produce a concise summary of conversation text.

data/lib/claw/memory_store.rb

@@ -1,48 +1,178 @@
 # frozen_string_literal: true
 
-require "json"
 require "fileutils"
 
 module Claw
-  # Extends Mana::FileStore with session persistence.
-  # Sessions store conversation state (short-term memory, summaries) across restarts.
+  # Extends Mana::FileStore with Markdown-based persistence.
+  # Replaces JSON memory/session files with human-readable Markdown.
+  #
+  # Directory layout:
+  #   .mana/
+  #     MEMORY.md      — long-term memory
+  #     session.md     — session summary
+  #     values.json    — kept as-is (Marshal data)
+  #     definitions.rb — kept as-is
+  #     log/
+  #       YYYY-MM-DD.md — daily interaction log
   class FileStore < Mana::FileStore
-    # Read session data for a namespace. Returns nil if no session exists.
+    # Read long-term memories from MEMORY.md.
+    # Returns [{id:, content:, created_at:}, ...]
+    def read(namespace)
+      path = memory_md_path
+      return [] unless File.exist?(path)
+
+      parse_memory_md(File.read(path))
+    end
+
+    # Write long-term memories to MEMORY.md.
+    def write(namespace, memories)
+      FileUtils.mkdir_p(base_dir)
+      File.write(memory_md_path, generate_memory_md(memories))
+    end
+
+    # Delete MEMORY.md.
+    def clear(namespace)
+      File.delete(memory_md_path) if File.exist?(memory_md_path)
+    end
+
+    # Read session data from session.md. Returns {summaries: [...]} or nil.
     def read_session(namespace)
-      path = session_path(namespace)
+      path = session_md_path
       return nil unless File.exist?(path)
 
-      JSON.parse(File.read(path), symbolize_names: true)
-    rescue JSON::ParserError
-      nil
+      parse_session_md(File.read(path))
     end
 
-    # Write session data for a namespace to disk.
+    # Write session data to session.md.
     def write_session(namespace, data)
-      path = session_path(namespace)
-      FileUtils.mkdir_p(File.dirname(path))
-      File.write(path, JSON.pretty_generate(data))
+      FileUtils.mkdir_p(base_dir)
+      File.write(session_md_path, generate_session_md(data))
     end
 
-    # Delete session data for a namespace.
+    # Delete session.md.
     def clear_session(namespace)
-      path = session_path(namespace)
-      File.delete(path) if File.exist?(path)
+      File.delete(session_md_path) if File.exist?(session_md_path)
+    end
+
+    # Append an entry to the daily log file (log/YYYY-MM-DD.md).
+    def append_log(entry)
+      dir = File.join(base_dir, "log")
+      FileUtils.mkdir_p(dir)
+      date = Time.now.strftime("%Y-%m-%d")
+      path = File.join(dir, "#{date}.md")
+
+      unless File.exist?(path)
+        File.write(path, "# #{date}\n\n")
+      end
+
+      time = Time.now.strftime("%H:%M")
+      File.open(path, "a") { |f| f.puts "## #{time} — #{entry[:title]}\n#{entry[:detail]}\n" }
     end
 
     private
 
-    def session_path(namespace)
-      File.join(session_dir, "#{namespace}_session.json")
+    def base_dir
+      @base_path || Mana.config.memory_path || File.join(Dir.pwd, ".mana")
     end
 
-    def session_dir
-      File.join(base_dir, "sessions")
+    def memory_md_path
+      File.join(base_dir, "MEMORY.md")
     end
 
-    # Expose base_dir for session_dir — reuse parent's resolution logic
-    def base_dir
-      super
+    def session_md_path
+      File.join(base_dir, "session.md")
+    end
+
+    # Parse MEMORY.md: split on ## id:N | date headers
+    def parse_memory_md(text)
+      memories = []
+      current = nil
+      text.each_line do |line|
+        if line.match?(/^## id:(\d+) \| (.+)/)
+          if current
+            current[:content] = current[:content].strip
+            memories << current
+          end
+          md = line.match(/^## id:(\d+) \| (.+)/)
+          current = { id: md[1].to_i, content: "", created_at: md[2].strip }
+        elsif current
+          current[:content] += line
+        end
+      end
+      if current
+        current[:content] = current[:content].strip
+        memories << current
+      end
+      memories
+    end
+
+    # Generate MEMORY.md from array of memories
+    def generate_memory_md(memories)
+      lines = ["# Long-term Memory\n"]
+      memories.each do |m|
+        date = m[:created_at] || Time.now.iso8601
+        lines << "## id:#{m[:id]} | #{date}"
+        lines << m[:content].to_s
+        lines << ""
+      end
+      lines.join("\n")
+    end
+
+    # Parse session.md: extract summaries and short_term from sections
+    def parse_session_md(text)
+      summaries = []
+      short_term = []
+      in_summary = false
+      in_short_term = false
+      text.each_line do |line|
+        if line.strip == "## Summary"
+          in_summary = true
+          in_short_term = false
+          next
+        elsif line.strip == "## Short-term"
+          in_short_term = true
+          in_summary = false
+          next
+        elsif line.start_with?("## ")
+          in_summary = false
+          in_short_term = false
+        elsif in_summary && line.strip.start_with?("- ")
+          summaries << line.strip.sub(/^- /, "")
+        elsif in_short_term && line.strip.start_with?("- ")
+          # Format: "- role: content"
+          stripped = line.strip.sub(/^- /, "")
+          if (md = stripped.match(/\A(\w+): (.*)\z/m))
+            short_term << { role: md[1], content: md[2] }
+          end
+        end
+      end
+      { summaries: summaries, short_term: short_term }
+    end
+
+    # Generate session.md from session data hash
+    def generate_session_md(data)
+      return "" unless data
+      lines = ["# Session State\n"]
+      summaries = data[:summaries] || data["summaries"] || []
+      unless summaries.empty?
+        lines << "## Summary"
+        summaries.each { |s| lines << "- #{s}" }
+        lines << ""
+      end
+      short_term = data[:short_term] || data["short_term"] || []
+      unless short_term.empty?
+        lines << "## Short-term"
+        short_term.each do |msg|
+          role = msg[:role] || msg["role"]
+          content = msg[:content] || msg["content"]
+          lines << "- #{role}: #{content}" if content.is_a?(String)
+        end
+        lines << ""
+      end
+      lines << "## Last Updated"
+      lines << (data[:updated_at] || data["updated_at"] || data[:saved_at] || data["saved_at"] || Time.now.iso8601)
+      lines << ""
+      lines.join("\n")
     end
   end
 end

data/lib/claw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Claw
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/claw.rb

@@ -28,23 +28,50 @@ module Claw
       Memory.current
     end
 
+    def incognito(&block)
+      Memory.incognito(&block)
+    end
+
     def reset!
       @config = Config.new
-      Thread.current[:mana_memory] = nil
+      Thread.current[:claw_memory] = nil
+      Thread.current[:mana_context] = nil
     end
   end
 end
 
-# Override Mana::Memory.current to return Claw::Memory instances.
-# This is the key integration point — when claw is loaded, all memory is enhanced.
-class Mana::Memory
-  class << self
-    alias_method :_original_current, :current
+# Register Claw's remember tool via Mana's tool registration interface.
+Mana.register_tool(
+  {
+    name: "remember",
+    description: "Store a fact in long-term memory. This memory persists across script executions. Use when the user explicitly asks to remember something.",
+    input_schema: {
+      type: "object",
+      properties: { content: { type: "string", description: "The fact to remember" } },
+      required: ["content"]
+    }
+  }
+) do |input|
+  memory = Claw.memory  # nil when incognito
+  if memory
+    entry = memory.remember(input["content"])
+    "Remembered (id=#{entry[:id]}): #{input['content']}"
+  else
+    "Memory not available"
+  end
+end
 
-    def current
-      return nil if incognito?
+# Register prompt section to inject long-term memories into system prompt.
+Mana.register_prompt_section do
+  memory = Claw.memory
+  next nil unless memory && !memory.long_term.empty?
 
-      Thread.current[:mana_memory] ||= Claw::Memory.new
-    end
-  end
+  lines = ["Long-term memories (persistent background context):"]
+  memory.long_term.each { |m| lines << "- #{m[:content]}" }
+  lines << ""
+  lines << "You have a `remember` tool to store new facts in long-term memory when the user asks."
+  lines.join("\n")
 end
+
+# Register Claw's enhanced knowledge provider.
+Mana.config.knowledge_provider = Claw::Knowledge

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-claw
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Carl Li
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-29 00:00:00.000000000 Z
+date: 2026-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-mana
@@ -60,6 +60,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - exe/claw