jasper-recall 0.1.0

package/README.md

@@ -0,0 +1,145 @@
+# Jasper Recall 🦊
+
+Local RAG (Retrieval-Augmented Generation) system for AI agent memory. Gives your agent the ability to remember and search past conversations using ChromaDB and sentence-transformers.
+
+## Features
+
+- **Semantic search** over session logs and memory files
+- **Local embeddings** — no API keys needed
+- **Incremental indexing** — only processes changed files
+- **Session digests** — automatically extracts key info from chat logs
+- **OpenClaw integration** — works seamlessly with OpenClaw agents
+
+## Quick Start
+
+```bash
+# One-command setup
+npx jasper-recall setup
+
+# Search your memory
+recall "what did we decide about the API"
+
+# Index your files
+index-digests
+
+# Process new session logs
+digest-sessions
+```
+
+## What Gets Indexed
+
+By default, indexes markdown files from `~/.openclaw/workspace/memory/`:
+
+- Daily notes (`*.md`)
+- Session digests (`session-digests/*.md`)
+- Project docs (`repos/*.md`)
+- SOPs (`sops/*.md`)
+
+## How It Works
+
+```
+┌────────────────┐     ┌──────────────┐     ┌───────────┐
+│ Session Logs   │────▶│ digest-      │────▶│ Markdown  │
+│ (.jsonl)       │     │ sessions     │     │ Digests   │
+└────────────────┘     └──────────────┘     └─────┬─────┘
+                                                  │
+                                                  ▼
+┌────────────────┐     ┌──────────────┐     ┌───────────┐
+│ Memory Files   │────▶│ index-       │────▶│ ChromaDB  │
+│ (*.md)         │     │ digests      │     │ Vectors   │
+└────────────────┘     └──────────────┘     └─────┬─────┘
+                                                  │
+                                                  ▼
+                       ┌──────────────┐     ┌───────────┐
+                       │ recall       │◀────│ Query     │
+                       │ "query"      │     │           │
+                       └──────────────┘     └───────────┘
+```
+
+## CLI Reference
+
+### recall
+
+Search your indexed memory:
+
+```bash
+recall "query"              # Basic search
+recall "query" -n 10        # More results
+recall "query" --json       # JSON output
+recall "query" -v           # Show similarity scores
+```
+
+### index-digests
+
+Index markdown files into ChromaDB:
+
+```bash
+index-digests               # Index all files
+```
+
+### digest-sessions
+
+Extract summaries from session logs:
+
+```bash
+digest-sessions             # Process new sessions only
+digest-sessions --all       # Reprocess everything
+digest-sessions --dry-run   # Preview without writing
+```
+
+## Configuration
+
+Set environment variables to customize paths:
+
+```bash
+export RECALL_WORKSPACE=~/.openclaw/workspace
+export RECALL_CHROMA_DB=~/.openclaw/chroma-db
+export RECALL_SESSIONS_DIR=~/.openclaw/agents/main/sessions
+export RECALL_VENV=~/.openclaw/rag-env
+```
+
+## OpenClaw Integration
+
+Add to your agent's HEARTBEAT.md for automatic memory maintenance:
+
+```markdown
+## Memory Maintenance
+- [ ] New sessions? → `digest-sessions`
+- [ ] Files updated? → `index-digests`
+```
+
+Or schedule via cron:
+
+```json
+{
+  "schedule": { "kind": "cron", "expr": "0 */6 * * *" },
+  "payload": {
+    "kind": "agentTurn",
+    "message": "Run index-digests to update memory index"
+  },
+  "sessionTarget": "isolated"
+}
+```
+
+## Technical Details
+
+- **Embedding model**: `sentence-transformers/all-MiniLM-L6-v2` (384 dimensions, ~80MB)
+- **Vector store**: ChromaDB (persistent, local)
+- **Chunking**: 500 chars with 100 char overlap
+- **Deduplication**: Content hash check skips unchanged files
+
+## Requirements
+
+- Python 3.10+
+- Node.js 18+ (for setup CLI)
+- ~500MB disk space (model + dependencies)
+
+## License
+
+MIT
+
+## Links
+
+- [GitHub](https://github.com/E-x-O-Entertainment-Studios-Inc/jasper-recall)
+- [ClawHub](https://clawhub.ai/skills/jasper-recall)
+- [Documentation](https://exohaven.online/products/jasper-recall)

package/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: jasper-recall
+description: Local RAG system for agent memory using ChromaDB and sentence-transformers. Provides semantic search over session logs, daily notes, and memory files. Use when you need persistent memory across sessions, want to search past conversations, or build agents that remember context. Commands: recall "query", index-digests, digest-sessions.
+---
+
+# Jasper Recall
+
+Local RAG (Retrieval-Augmented Generation) system for AI agent memory. Gives your agent the ability to remember and search past conversations.
+
+## When to Use
+
+- **Memory recall**: Search past sessions for context before answering
+- **Continuous learning**: Index daily notes and decisions for future reference
+- **Session continuity**: Remember what happened across restarts
+- **Knowledge base**: Build searchable documentation from your agent's experience
+
+## Quick Start
+
+### Setup
+
+One command installs everything:
+
+```bash
+npx jasper-recall setup
+```
+
+This creates:
+- Python venv at `~/.openclaw/rag-env`
+- ChromaDB database at `~/.openclaw/chroma-db`
+- CLI scripts in `~/.local/bin/`
+
+### Basic Usage
+
+**Search your memory:**
+```bash
+recall "what did we decide about the API design"
+recall "hopeIDS patterns" --limit 10
+recall "meeting notes" --json
+```
+
+**Index your files:**
+```bash
+index-digests  # Index memory files into ChromaDB
+```
+
+**Create session digests:**
+```bash
+digest-sessions          # Process new sessions
+digest-sessions --dry-run  # Preview what would be processed
+```
+
+## How It Works
+
+### Three Components
+
+1. **digest-sessions** — Extracts key info from session logs (topics, tools used)
+2. **index-digests** — Chunks and embeds markdown files into ChromaDB
+3. **recall** — Semantic search across your indexed memory
+
+### What Gets Indexed
+
+By default, indexes files from `~/.openclaw/workspace/memory/`:
+
+- `*.md` — Daily notes, MEMORY.md
+- `session-digests/*.md` — Session summaries
+- `repos/*.md` — Project documentation
+- `founder-logs/*.md` — Development logs (if present)
+
+### Embedding Model
+
+Uses `sentence-transformers/all-MiniLM-L6-v2`:
+- 384-dimensional embeddings
+- ~80MB download on first run
+- Runs locally, no API needed
+
+## Agent Integration
+
+### Memory-Augmented Responses
+
+```python
+# Before answering questions about past work
+results = exec("recall 'project setup decisions' --json")
+# Include relevant context in your response
+```
+
+### Automated Indexing (Heartbeat)
+
+Add to HEARTBEAT.md:
+```markdown
+## Memory Maintenance
+- [ ] New session logs? → `digest-sessions`
+- [ ] Memory files updated? → `index-digests`
+```
+
+### Cron Job
+
+Schedule regular indexing:
+```json
+{
+  "schedule": { "kind": "cron", "expr": "0 */6 * * *" },
+  "payload": {
+    "kind": "agentTurn",
+    "message": "Run index-digests to update the memory index"
+  },
+  "sessionTarget": "isolated"
+}
+```
+
+## CLI Reference
+
+### recall
+
+```
+recall "query" [OPTIONS]
+
+Options:
+  -n, --limit N     Number of results (default: 5)
+  --json            Output as JSON
+  -v, --verbose     Show similarity scores
+```
+
+### index-digests
+
+```
+index-digests
+
+Indexes markdown files from:
+  ~/.openclaw/workspace/memory/*.md
+  ~/.openclaw/workspace/memory/session-digests/*.md
+  ~/.openclaw/workspace/memory/repos/*.md
+  ~/.openclaw/workspace/memory/founder-logs/*.md
+
+Skips files that haven't changed (content hash check).
+```
+
+### digest-sessions
+
+```
+digest-sessions [OPTIONS]
+
+Options:
+  --dry-run    Preview without writing
+  --all        Process all sessions (not just new)
+  --recent N   Process only N most recent sessions
+```
+
+## Configuration
+
+### Custom Paths
+
+Set environment variables:
+
+```bash
+export RECALL_WORKSPACE=~/.openclaw/workspace
+export RECALL_CHROMA_DB=~/.openclaw/chroma-db
+export RECALL_SESSIONS_DIR=~/.openclaw/agents/main/sessions
+```
+
+### Chunking
+
+Default settings in index-digests:
+- Chunk size: 500 characters
+- Overlap: 100 characters
+
+## Troubleshooting
+
+**"No index found"**
+```bash
+index-digests  # Create the index first
+```
+
+**"Collection not found"**
+```bash
+rm -rf ~/.openclaw/chroma-db  # Clear and rebuild
+index-digests
+```
+
+**Model download slow**
+First run downloads ~80MB model. Subsequent runs are instant.
+
+## Links
+
+- **GitHub**: https://github.com/E-x-O-Entertainment-Studios-Inc/jasper-recall
+- **npm**: https://www.npmjs.com/package/jasper-recall
+- **ClawHub**: https://clawhub.ai/skills/jasper-recall

package/cli/jasper-recall.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * Jasper Recall CLI
+ * Local RAG system for AI agent memory
+ * 
+ * Usage:
+ *   npx jasper-recall setup     # Install dependencies and create scripts
+ *   npx jasper-recall recall    # Run a query (alias)
+ *   npx jasper-recall index     # Index files (alias)
+ *   npx jasper-recall digest    # Digest sessions (alias)
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const VERSION = '0.1.0';
+const VENV_PATH = path.join(os.homedir(), '.openclaw', 'rag-env');
+const CHROMA_PATH = path.join(os.homedir(), '.openclaw', 'chroma-db');
+const BIN_PATH = path.join(os.homedir(), '.local', 'bin');
+const SCRIPTS_DIR = path.join(__dirname, '..', 'scripts');
+
+function log(msg) {
+  console.log(`🦊 ${msg}`);
+}
+
+function error(msg) {
+  console.error(`❌ ${msg}`);
+}
+
+function run(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { stdio: opts.silent ? 'pipe' : 'inherit', ...opts });
+  } catch (e) {
+    if (!opts.ignoreError) {
+      error(`Command failed: ${cmd}`);
+      process.exit(1);
+    }
+    return null;
+  }
+}
+
+function setup() {
+  log('Jasper Recall — Setup');
+  console.log('=' .repeat(40));
+  
+  // Check Python
+  log('Checking Python...');
+  let python = 'python3';
+  try {
+    const version = execSync(`${python} --version`, { encoding: 'utf8' });
+    console.log(`  ✓ ${version.trim()}`);
+  } catch {
+    error('Python 3 is required. Install it first.');
+    process.exit(1);
+  }
+  
+  // Create venv
+  log('Creating Python virtual environment...');
+  fs.mkdirSync(path.dirname(VENV_PATH), { recursive: true });
+  if (!fs.existsSync(VENV_PATH)) {
+    run(`${python} -m venv ${VENV_PATH}`);
+    console.log(`  ✓ Created: ${VENV_PATH}`);
+  } else {
+    console.log(`  ✓ Already exists: ${VENV_PATH}`);
+  }
+  
+  // Install Python dependencies
+  log('Installing Python dependencies (this may take a minute)...');
+  const pip = path.join(VENV_PATH, 'bin', 'pip');
+  run(`${pip} install --quiet chromadb sentence-transformers`);
+  console.log('  ✓ Installed: chromadb, sentence-transformers');
+  
+  // Create bin directory
+  fs.mkdirSync(BIN_PATH, { recursive: true });
+  
+  // Copy scripts
+  log('Installing CLI scripts...');
+  
+  const scripts = [
+    { src: 'recall.py', dest: 'recall', shebang: `#!${path.join(VENV_PATH, 'bin', 'python3')}` },
+    { src: 'index-digests.py', dest: 'index-digests', shebang: `#!${path.join(VENV_PATH, 'bin', 'python3')}` },
+    { src: 'digest-sessions.sh', dest: 'digest-sessions', shebang: '#!/bin/bash' }
+  ];
+  
+  for (const script of scripts) {
+    const srcPath = path.join(SCRIPTS_DIR, script.src);
+    const destPath = path.join(BIN_PATH, script.dest);
+    
+    let content = fs.readFileSync(srcPath, 'utf8');
+    
+    // Replace generic shebang with specific one for Python scripts
+    if (script.src.endsWith('.py')) {
+      content = content.replace(/^#!.*python3?\n/, script.shebang + '\n');
+    }
+    
+    fs.writeFileSync(destPath, content);
+    fs.chmodSync(destPath, 0o755);
+    console.log(`  ✓ Installed: ${destPath}`);
+  }
+  
+  // Create chroma directory
+  fs.mkdirSync(CHROMA_PATH, { recursive: true });
+  
+  // Verify PATH
+  const pathEnv = process.env.PATH || '';
+  if (!pathEnv.includes(BIN_PATH)) {
+    console.log('');
+    log('Add to your PATH (add to ~/.bashrc or ~/.zshrc):');
+    console.log(`  export PATH="$HOME/.local/bin:$PATH"`);
+  }
+  
+  console.log('');
+  console.log('=' .repeat(40));
+  log('Setup complete!');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. index-digests     # Index your memory files');
+  console.log('  2. recall "query"    # Search your memory');
+  console.log('  3. digest-sessions   # Process session logs');
+}
+
+function showHelp() {
+  console.log(`
+Jasper Recall v${VERSION}
+Local RAG system for AI agent memory
+
+USAGE:
+  npx jasper-recall <command>
+
+COMMANDS:
+  setup       Install dependencies and CLI scripts
+  recall      Search your memory (alias for the recall command)
+  index       Index memory files (alias for index-digests)
+  digest      Process session logs (alias for digest-sessions)
+  help        Show this help message
+
+EXAMPLES:
+  npx jasper-recall setup
+  recall "what did we discuss yesterday"
+  index-digests
+  digest-sessions --dry-run
+`);
+}
+
+// Main
+const command = process.argv[2];
+
+switch (command) {
+  case 'setup':
+    setup();
+    break;
+  case 'recall':
+    // Pass through to recall script
+    const recallScript = path.join(BIN_PATH, 'recall');
+    if (fs.existsSync(recallScript)) {
+      const args = process.argv.slice(3);
+      spawn(recallScript, args, { stdio: 'inherit' });
+    } else {
+      error('Run "npx jasper-recall setup" first');
+    }
+    break;
+  case 'index':
+    const indexScript = path.join(BIN_PATH, 'index-digests');
+    if (fs.existsSync(indexScript)) {
+      spawn(indexScript, [], { stdio: 'inherit' });
+    } else {
+      error('Run "npx jasper-recall setup" first');
+    }
+    break;
+  case 'digest':
+    const digestScript = path.join(BIN_PATH, 'digest-sessions');
+    if (fs.existsSync(digestScript)) {
+      const args = process.argv.slice(3);
+      spawn(digestScript, args, { stdio: 'inherit' });
+    } else {
+      error('Run "npx jasper-recall setup" first');
+    }
+    break;
+  case '--version':
+  case '-v':
+    console.log(VERSION);
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    showHelp();
+    break;
+  default:
+    error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "jasper-recall",
+  "version": "0.1.0",
+  "description": "Local RAG system for AI agent memory using ChromaDB and sentence-transformers",
+  "main": "src/index.js",
+  "bin": {
+    "jasper-recall": "./cli/jasper-recall.js"
+  },
+  "scripts": {
+    "test": "node cli/jasper-recall.js --version"
+  },
+  "keywords": [
+    "rag",
+    "chromadb",
+    "embeddings",
+    "memory",
+    "ai-agent",
+    "openclaw",
+    "semantic-search",
+    "vector-database"
+  ],
+  "author": "E.x.O. Entertainment Studios Inc.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/E-x-O-Entertainment-Studios-Inc/jasper-recall.git"
+  },
+  "homepage": "https://exohaven.online/products/jasper-recall",
+  "bugs": {
+    "url": "https://github.com/E-x-O-Entertainment-Studios-Inc/jasper-recall/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "cli/",
+    "scripts/",
+    "src/",
+    "SKILL.md",
+    "README.md"
+  ]
+}

package/scripts/digest-sessions.sh

@@ -0,0 +1,131 @@
+#!/bin/bash
+# digest-sessions — Extract learnings from session logs
+# Usage: digest-sessions [--all | --recent N | --dry-run]
+
+set -e
+
+# Support custom paths via environment
+WORKSPACE="${RECALL_WORKSPACE:-$HOME/.openclaw/workspace}"
+SESSIONS_DIR="${RECALL_SESSIONS_DIR:-$HOME/.openclaw/agents/main/sessions}"
+MEMORY_DIR="$WORKSPACE/memory"
+DIGEST_DIR="$MEMORY_DIR/session-digests"
+STATE_FILE="$MEMORY_DIR/.digest-state.json"
+
+DRY_RUN=false
+RECENT=""
+ALL=false
+
+# Parse args
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --dry-run) DRY_RUN=true; shift ;;
+        --all) ALL=true; shift ;;
+        --recent) RECENT="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+# Create directories
+mkdir -p "$DIGEST_DIR"
+
+# Initialize state file if missing
+if [[ ! -f "$STATE_FILE" ]]; then
+    echo '{"processed":[],"lastRun":0}' > "$STATE_FILE"
+fi
+
+# Check if sessions dir exists
+if [[ ! -d "$SESSIONS_DIR" ]]; then
+    echo "⚠ Sessions directory not found: $SESSIONS_DIR"
+    exit 0
+fi
+
+# Get already processed sessions
+processed=$(jq -r '.processed[]' "$STATE_FILE" 2>/dev/null || echo "")
+
+# Find sessions to process
+if [[ -n "$(ls -A "$SESSIONS_DIR"/*.jsonl 2>/dev/null)" ]]; then
+    all_sessions=$(ls -1 "$SESSIONS_DIR"/*.jsonl 2>/dev/null | xargs -I{} basename {} .jsonl)
+else
+    echo "No session files found in $SESSIONS_DIR"
+    exit 0
+fi
+
+new_sessions=""
+
+if [[ "$ALL" == "true" ]]; then
+    new_sessions="$all_sessions"
+else
+    for s in $all_sessions; do
+        if ! echo "$processed" | grep -q "^${s}$"; then
+            new_sessions="$new_sessions $s"
+        fi
+    done
+fi
+
+# Apply --recent limit
+if [[ -n "$RECENT" ]]; then
+    new_sessions=$(echo "$new_sessions" | tr ' ' '\n' | tail -n "$RECENT" | tr '\n' ' ')
+fi
+
+if [[ -z "$(echo $new_sessions | tr -d ' ')" ]]; then
+    echo "✓ No new sessions to digest."
+    exit 0
+fi
+
+echo "🦊 Jasper Recall — Session Digester"
+echo "=" * 40
+echo "Sessions to process: $(echo $new_sessions | wc -w)"
+echo ""
+
+# Process each session
+for session_id in $new_sessions; do
+    session_file="$SESSIONS_DIR/${session_id}.jsonl"
+    [[ ! -f "$session_file" ]] && continue
+    
+    size=$(du -h "$session_file" | cut -f1)
+    msgs=$(wc -l < "$session_file")
+    date=$(stat -c %y "$session_file" 2>/dev/null | cut -d' ' -f1 || stat -f %Sm -t %Y-%m-%d "$session_file" 2>/dev/null || echo "unknown")
+    
+    echo "Processing: ${session_id:0:8}... ($size, $msgs messages)"
+    
+    # Extract key info using jq
+    topics=$(jq -r 'select(.message.role == "user") | .message.content | 
+        if type == "array" then 
+            map(select(.type == "text") | .text) | join(" ") 
+        else . end' "$session_file" 2>/dev/null | \
+        grep -v "^\[message_id:" | \
+        grep -v "^System:" | \
+        grep -v "^{" | \
+        head -10 || echo "")
+    
+    tools=$(jq -r '.message.content[]? | select(.type == "toolCall") | .name' "$session_file" 2>/dev/null | \
+        sort | uniq -c | sort -rn | head -5 | awk '{print $2 " (" $1 "x)"}' | tr '\n' ', ' | sed 's/, $//' || echo "")
+    
+    # Create digest file for this session
+    digest_file="$DIGEST_DIR/${session_id:0:8}-$date.md"
+    
+    if [[ "$DRY_RUN" == "false" ]]; then
+        cat > "$digest_file" << EOF
+# Session ${session_id:0:8} — $date
+
+**Size:** $size | **Messages:** $msgs
+**Tools:** ${tools:-none}
+
+## Topics
+
+$(echo "$topics" | head -5 | sed 's/^/- /' | grep -v "^- $" || echo "- (no topics extracted)")
+
+---
+*Full session: $session_file*
+EOF
+        
+        # Update state
+        jq --arg s "$session_id" '.processed += [$s] | .lastRun = now' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+        echo "  ✓ Created: $(basename $digest_file)"
+    else
+        echo "  [dry-run] Would create: $(basename $digest_file)"
+    fi
+done
+
+echo ""
+echo "✓ Digests saved to: $DIGEST_DIR"

package/scripts/index-digests.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Index markdown files into ChromaDB for RAG retrieval.
+Reads from memory/, session-digests/, repos/, and founder-logs/.
+"""
+
+import os
+import sys
+import glob
+import hashlib
+from pathlib import Path
+
+# Support custom paths via environment
+WORKSPACE = os.environ.get("RECALL_WORKSPACE", os.path.expanduser("~/.openclaw/workspace"))
+CHROMA_DIR = os.environ.get("RECALL_CHROMA_DB", os.path.expanduser("~/.openclaw/chroma-db"))
+VENV_PATH = os.environ.get("RECALL_VENV", os.path.expanduser("~/.openclaw/rag-env"))
+
+MEMORY_DIR = os.path.join(WORKSPACE, "memory")
+DIGESTS_DIR = os.path.join(MEMORY_DIR, "session-digests")
+
+# Chunking config
+CHUNK_SIZE = 500  # characters
+CHUNK_OVERLAP = 100
+
+# Activate the venv
+sys.path.insert(0, os.path.join(VENV_PATH, "lib/python3.12/site-packages"))
+for pyver in ["python3.11", "python3.10"]:
+    alt_path = os.path.join(VENV_PATH, f"lib/{pyver}/site-packages")
+    if os.path.exists(alt_path):
+        sys.path.insert(0, alt_path)
+
+try:
+    import chromadb
+    from sentence_transformers import SentenceTransformer
+except ImportError as e:
+    print(f"❌ Missing dependency: {e}", file=sys.stderr)
+    print("Run 'npx jasper-recall setup' to install dependencies.", file=sys.stderr)
+    sys.exit(1)
+
+
+def chunk_text(text: str, chunk_size: int = CHUNK_SIZE, overlap: int = CHUNK_OVERLAP) -> list:
+    """Split text into overlapping chunks."""
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + chunk_size
+        chunk = text[start:end]
+        if chunk.strip():
+            chunks.append(chunk.strip())
+        start = end - overlap
+    return chunks
+
+
+def get_file_hash(content: str) -> str:
+    """Get MD5 hash of content."""
+    return hashlib.md5(content.encode()).hexdigest()
+
+
+def main():
+    print("🦊 Jasper Recall — RAG Indexer")
+    print("=" * 40)
+    
+    # Check if memory dir exists
+    if not os.path.exists(MEMORY_DIR):
+        print(f"⚠ Memory directory not found: {MEMORY_DIR}")
+        print("Create some markdown files there first.")
+        sys.exit(1)
+    
+    # Initialize embedding model (will download on first run)
+    print("Loading embedding model...")
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    print("✓ Model loaded")
+    
+    # Initialize ChromaDB
+    os.makedirs(CHROMA_DIR, exist_ok=True)
+    client = chromadb.PersistentClient(path=CHROMA_DIR)
+    
+    # Get or create collection
+    collection = client.get_or_create_collection(
+        name="jasper_memory",
+        metadata={"description": "Agent session digests and memory files"}
+    )
+    
+    # Gather files to index
+    files_to_index = []
+    
+    # Session digests
+    if os.path.exists(DIGESTS_DIR):
+        files_to_index.extend(glob.glob(os.path.join(DIGESTS_DIR, "*.md")))
+    
+    # Daily notes and other memory files (but not subdirs)
+    files_to_index.extend(glob.glob(os.path.join(MEMORY_DIR, "*.md")))
+    
+    # Repos documentation
+    repos_dir = os.path.join(MEMORY_DIR, "repos")
+    if os.path.exists(repos_dir):
+        files_to_index.extend(glob.glob(os.path.join(repos_dir, "*.md")))
+    
+    # Founder Logs
+    for logs_dir_name in ["founder-logs", "founderLogs"]:
+        logs_dir = os.path.join(MEMORY_DIR, logs_dir_name)
+        if os.path.exists(logs_dir):
+            files_to_index.extend(glob.glob(os.path.join(logs_dir, "*.md")))
+    
+    # SOPs
+    sops_dir = os.path.join(MEMORY_DIR, "sops")
+    if os.path.exists(sops_dir):
+        files_to_index.extend(glob.glob(os.path.join(sops_dir, "*.md")))
+    
+    print(f"Found {len(files_to_index)} files to index")
+    
+    # Track stats
+    total_chunks = 0
+    indexed_files = 0
+    skipped_files = 0
+    
+    for filepath in files_to_index:
+        filename = os.path.basename(filepath)
+        rel_path = os.path.relpath(filepath, WORKSPACE)
+        
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            print(f"  ⚠ Error reading {filename}: {e}")
+            continue
+        
+        if not content.strip():
+            continue
+        
+        # Check if already indexed with same hash
+        file_hash = get_file_hash(content)
+        
+        # Check for existing chunks from this file
+        existing = collection.get(
+            where={"source": rel_path},
+            include=[]
+        )
+        
+        if existing['ids']:
+            # Check if hash matches (stored in first chunk's metadata)
+            existing_meta = collection.get(
+                ids=[existing['ids'][0]],
+                include=["metadatas"]
+            )
+            if existing_meta['metadatas'] and existing_meta['metadatas'][0].get('file_hash') == file_hash:
+                skipped_files += 1
+                continue
+            
+            # File changed, delete old chunks
+            collection.delete(ids=existing['ids'])
+        
+        # Chunk the content
+        chunks = chunk_text(content)
+        
+        if not chunks:
+            continue
+        
+        # Generate embeddings
+        embeddings = model.encode(chunks).tolist()
+        
+        # Create IDs and metadata
+        ids = [f"{rel_path}::{i}" for i in range(len(chunks))]
+        metadatas = [
+            {
+                "source": rel_path,
+                "chunk_index": i,
+                "file_hash": file_hash,
+                "filename": filename
+            }
+            for i in range(len(chunks))
+        ]
+        
+        # Add to collection
+        collection.add(
+            ids=ids,
+            embeddings=embeddings,
+            documents=chunks,
+            metadatas=metadatas
+        )
+        
+        total_chunks += len(chunks)
+        indexed_files += 1
+        print(f"  ✓ {filename}: {len(chunks)} chunks")
+    
+    print("=" * 40)
+    print(f"✓ Indexed {indexed_files} files ({total_chunks} chunks)")
+    print(f"  Skipped {skipped_files} unchanged files")
+    print(f"  Database: {CHROMA_DIR}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/recall.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+RAG recall: Search agent memory for relevant context.
+Usage: recall "query" [--limit N] [--json] [--verbose]
+"""
+
+import os
+import sys
+import argparse
+import json
+
+# Support custom paths via environment
+CHROMA_DIR = os.environ.get("RECALL_CHROMA_DB", os.path.expanduser("~/.openclaw/chroma-db"))
+VENV_PATH = os.environ.get("RECALL_VENV", os.path.expanduser("~/.openclaw/rag-env"))
+
+# Activate the venv
+sys.path.insert(0, os.path.join(VENV_PATH, "lib/python3.12/site-packages"))
+# Also try python3.11, 3.10 for compatibility
+for pyver in ["python3.11", "python3.10"]:
+    alt_path = os.path.join(VENV_PATH, f"lib/{pyver}/site-packages")
+    if os.path.exists(alt_path):
+        sys.path.insert(0, alt_path)
+
+try:
+    import chromadb
+    from sentence_transformers import SentenceTransformer
+except ImportError as e:
+    print(f"❌ Missing dependency: {e}", file=sys.stderr)
+    print("Run 'npx jasper-recall setup' to install dependencies.", file=sys.stderr)
+    sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Search agent memory")
+    parser.add_argument("query", help="Search query")
+    parser.add_argument("-n", "--limit", type=int, default=5, help="Number of results (default: 5)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Show similarity scores")
+    args = parser.parse_args()
+    
+    if not os.path.exists(CHROMA_DIR):
+        print("❌ No index found. Run 'index-digests' first.", file=sys.stderr)
+        sys.exit(1)
+    
+    # Load model and database
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    client = chromadb.PersistentClient(path=CHROMA_DIR)
+    
+    try:
+        collection = client.get_collection("jasper_memory")
+    except Exception:
+        print("❌ Collection not found. Run 'index-digests' first.", file=sys.stderr)
+        sys.exit(1)
+    
+    # Embed query
+    query_embedding = model.encode([args.query])[0].tolist()
+    
+    # Search
+    results = collection.query(
+        query_embeddings=[query_embedding],
+        n_results=args.limit,
+        include=["documents", "metadatas", "distances"]
+    )
+    
+    if not results['documents'][0]:
+        if args.json:
+            print("[]")
+        else:
+            print(f"🔍 No results for: \"{args.query}\"")
+        return
+    
+    if args.json:
+        output = []
+        for i, (doc, meta, dist) in enumerate(zip(
+            results['documents'][0],
+            results['metadatas'][0],
+            results['distances'][0]
+        )):
+            output.append({
+                "rank": i + 1,
+                "source": meta.get('source', 'unknown'),
+                "similarity": round(1 - dist, 3),  # Convert distance to similarity
+                "content": doc
+            })
+        print(json.dumps(output, indent=2))
+    else:
+        print(f"🔍 Results for: \"{args.query}\"\n")
+        
+        for i, (doc, meta, dist) in enumerate(zip(
+            results['documents'][0],
+            results['metadatas'][0],
+            results['distances'][0]
+        )):
+            similarity = 1 - dist
+            score_str = f" ({similarity:.1%})" if args.verbose else ""
+            source = meta.get('source', 'unknown')
+            
+            print(f"━━━ [{i+1}] {source}{score_str} ━━━")
+            # Truncate long content
+            content = doc[:500] + "..." if len(doc) > 500 else doc
+            print(content)
+            print()
+
+
+if __name__ == "__main__":
+    main()

package/src/index.js

@@ -0,0 +1,63 @@
+/**
+ * Jasper Recall
+ * Local RAG system for AI agent memory
+ * 
+ * This module exports utilities for programmatic access.
+ * For CLI usage, use the `jasper-recall` command.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+const BIN_PATH = path.join(os.homedir(), '.local', 'bin');
+
+/**
+ * Search the memory index
+ * @param {string} query - Search query
+ * @param {Object} options - Options { limit, json, verbose }
+ * @returns {Array|string} - Search results
+ */
+function recall(query, options = {}) {
+  const args = [query];
+  if (options.limit) args.push('-n', options.limit);
+  if (options.json) args.push('--json');
+  if (options.verbose) args.push('-v');
+  
+  const recallPath = path.join(BIN_PATH, 'recall');
+  const result = execSync(`${recallPath} ${args.map(a => `"${a}"`).join(' ')}`, {
+    encoding: 'utf8'
+  });
+  
+  return options.json ? JSON.parse(result) : result;
+}
+
+/**
+ * Index memory files
+ * @returns {string} - Index output
+ */
+function indexDigests() {
+  const scriptPath = path.join(BIN_PATH, 'index-digests');
+  return execSync(scriptPath, { encoding: 'utf8' });
+}
+
+/**
+ * Process session logs into digests
+ * @param {Object} options - Options { dryRun, all, recent }
+ * @returns {string} - Digest output
+ */
+function digestSessions(options = {}) {
+  const args = [];
+  if (options.dryRun) args.push('--dry-run');
+  if (options.all) args.push('--all');
+  if (options.recent) args.push('--recent', options.recent);
+  
+  const scriptPath = path.join(BIN_PATH, 'digest-sessions');
+  return execSync(`${scriptPath} ${args.join(' ')}`, { encoding: 'utf8' });
+}
+
+module.exports = {
+  recall,
+  indexDigests,
+  digestSessions
+};