jasper-recall 0.2.0 → 0.2.2

package/README.md

@@ -17,6 +17,12 @@ Local RAG (Retrieval-Augmented Generation) system for AI agent memory. Gives you
 - **Shared memory sync** — Bidirectional learning between main and sandboxed agents
 - **Privacy checker** — Scan content for sensitive data before sharing
 
+### New in v0.2.1: Recall Server
+
+- **HTTP API server** — `npx jasper-recall serve` for Docker-isolated agents
+- **Public-only by default** — Secure API access for untrusted callers
+- **CORS enabled** — Works from browsers and agent containers
+
 ## Quick Start
 
 ```bash
@@ -154,6 +160,49 @@ index-digests
 recall "product info" --public-only
 ```
 
+## Recall Server (v0.2.1+)
+
+For **Docker-isolated agents** that can't run the CLI directly, start an HTTP API server:
+
+```bash
+npx jasper-recall serve              # Default: localhost:3458
+npx jasper-recall serve --port 8080  # Custom port
+npx jasper-recall serve --host 0.0.0.0  # Allow external access
+```
+
+### API Endpoints
+
+```
+GET /recall?q=search+query&limit=5
+GET /health
+```
+
+### Example
+
+```bash
+# Query from Docker container
+curl "http://host.docker.internal:3458/recall?q=product+info"
+```
+
+Response:
+```json
+{
+  "ok": true,
+  "query": "product info",
+  "public_only": true,
+  "count": 3,
+  "results": [
+    { "content": "...", "file": "memory/shared/product-updates.md", "score": 0.85 }
+  ]
+}
+```
+
+### Security
+
+- **`public_only=true` is enforced by default** — API callers only see public content
+- To allow private queries (dangerous!), set `RECALL_ALLOW_PRIVATE=true`
+- Bind to `127.0.0.1` (default) to prevent external access
+
 ## Configuration
 
 Set environment variables to customize paths:

package/SKILL.md

@@ -1,12 +1,17 @@
 ---
 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.
+version: 0.2.1
+description: Local RAG system for agent memory using ChromaDB and sentence-transformers. Provides semantic search over session logs, daily notes, and memory files. v0.2.1 adds HTTP server for Docker-isolated agents. Commands: recall, index-digests, digest-sessions, privacy-check, sync-shared, serve.
 ---
 
-# Jasper Recall
+# Jasper Recall v0.2.1
 
 Local RAG (Retrieval-Augmented Generation) system for AI agent memory. Gives your agent the ability to remember and search past conversations.
 
+**New in v0.2.1:** Recall Server — HTTP API for Docker-isolated agents that can't run CLI directly.
+
+**New in v0.2.0:** Shared Agent Memory — bidirectional learning between main and sandboxed agents with privacy controls.
+
 ## When to Use
 
 - **Memory recall**: Search past sessions for context before answering
@@ -106,6 +111,44 @@ Schedule regular indexing:
 }
 ```
 
+## Shared Agent Memory (v0.2.0)
+
+For multi-agent setups where sandboxed agents need access to some memories:
+
+### Memory Tagging
+
+Tag entries in daily notes:
+
+```markdown
+## 2026-02-05 [public] - Feature shipped
+This is visible to all agents.
+
+## 2026-02-05 [private] - Personal note
+This is main agent only (default if untagged).
+```
+
+### Sandboxed Agent Access
+
+```bash
+# Sandboxed agents use --public-only
+recall "product info" --public-only
+
+# Main agent can see everything
+recall "product info"
+```
+
+### Privacy Workflow
+
+```bash
+# Check for sensitive data before sharing
+privacy-check "text to scan"
+privacy-check --file notes.md
+
+# Extract [public] entries to shared directory
+sync-shared
+sync-shared --dry-run  # Preview first
+```
+
 ## CLI Reference
 
 ### recall
@@ -117,6 +160,53 @@ Options:
   -n, --limit N     Number of results (default: 5)
   --json            Output as JSON
   -v, --verbose     Show similarity scores
+  --public-only     Only search shared/public content (v0.2.0+)
+```
+
+### serve (v0.2.1+)
+
+```
+npx jasper-recall serve [OPTIONS]
+
+Options:
+  --port, -p N    Port to listen on (default: 3458)
+  --host, -h H    Host to bind (default: 127.0.0.1)
+
+Starts HTTP API server for Docker-isolated agents.
+
+Endpoints:
+  GET /recall?q=query&limit=5    Search memories
+  GET /health                    Health check
+
+Security: public_only=true enforced by default.
+Set RECALL_ALLOW_PRIVATE=true to allow private queries.
+```
+
+**Example (from Docker container):**
+```bash
+curl "http://host.docker.internal:3458/recall?q=product+info"
+```
+
+### privacy-check (v0.2.0+)
+
+```
+privacy-check "text"     # Scan inline text
+privacy-check --file X   # Scan a file
+
+Detects: emails, API keys, internal IPs, home paths, credentials.
+Returns: CLEAN or list of violations.
+```
+
+### sync-shared (v0.2.0+)
+
+```
+sync-shared [OPTIONS]
+
+Options:
+  --dry-run    Preview without writing
+  --all        Process all daily notes
+
+Extracts [public] tagged entries to memory/shared/.
 ```
 
 ### index-digests

package/cli/jasper-recall.js

@@ -15,7 +15,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const VERSION = '0.1.0';
+const VERSION = '0.2.2';
 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');
@@ -134,6 +134,7 @@ COMMANDS:
   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)
+  serve       Start HTTP API server (for sandboxed agents)
   help        Show this help message
 
 EXAMPLES:
@@ -141,6 +142,7 @@ EXAMPLES:
   recall "what did we discuss yesterday"
   index-digests
   digest-sessions --dry-run
+  npx jasper-recall serve --port 3458
 `);
 }
 
@@ -178,6 +180,12 @@ switch (command) {
       error('Run "npx jasper-recall setup" first');
     }
     break;
+  case 'serve':
+  case 'server':
+    // Start the HTTP server for sandboxed agents
+    const { runCLI } = require('./server');
+    runCLI(process.argv.slice(3));
+    break;
   case '--version':
   case '-v':
     console.log(VERSION);

package/cli/server.js

@@ -0,0 +1,234 @@
+/**
+ * Jasper Recall Server
+ * HTTP API for memory search - designed for sandboxed agents
+ * 
+ * Security: public_only is enforced by default
+ */
+
+const http = require('http');
+const { execSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const url = require('url');
+
+const BIN_PATH = path.join(os.homedir(), '.local', 'bin');
+const RECALL_SCRIPT = path.join(BIN_PATH, 'recall');
+
+/**
+ * Execute recall query
+ */
+function executeRecall(query, options = {}) {
+  const { publicOnly = true, limit = 5 } = options;
+  
+  let cmd = `${RECALL_SCRIPT} "${query.replace(/"/g, '\\"')}"`;
+  
+  // Security: always add --public-only unless explicitly disabled
+  if (publicOnly) {
+    cmd += ' --public-only';
+  }
+  
+  cmd += ` --limit ${parseInt(limit) || 5}`;
+  
+  try {
+    const output = execSync(cmd, {
+      encoding: 'utf8',
+      timeout: 30000,
+      env: { ...process.env, HOME: os.homedir() }
+    });
+    return { ok: true, output };
+  } catch (err) {
+    // Check if it's just "no results"
+    if (err.stdout?.includes('No results') || err.status === 0) {
+      return { ok: true, output: err.stdout || 'No results found' };
+    }
+    return { ok: false, error: err.message, stderr: err.stderr };
+  }
+}
+
+/**
+ * Parse recall output into structured results
+ */
+function parseResults(output) {
+  const results = [];
+  
+  // Try to parse structured output
+  const blocks = output.split(/={3,}\s*(?:Result\s+\d+|---)/i);
+  
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    
+    const result = {};
+    
+    const scoreMatch = block.match(/score:\s*([\d.]+)/i);
+    if (scoreMatch) result.score = parseFloat(scoreMatch[1]);
+    
+    const fileMatch = block.match(/File:\s*(.+)/i);
+    if (fileMatch) result.file = fileMatch[1].trim();
+    
+    const linesMatch = block.match(/Lines?:\s*(\d+(?:-\d+)?)/i);
+    if (linesMatch) result.lines = linesMatch[1];
+    
+    // Content is everything else
+    let content = block
+      .replace(/score:\s*[\d.]+/gi, '')
+      .replace(/File:\s*.+/gi, '')
+      .replace(/Lines?:\s*\d+(?:-\d+)?/gi, '')
+      .trim();
+    
+    if (content) {
+      result.content = content.substring(0, 1000);
+      results.push(result);
+    }
+  }
+  
+  // Fallback for unparseable output
+  if (results.length === 0 && output.trim()) {
+    results.push({ content: output.trim().substring(0, 2000), raw: true });
+  }
+  
+  return results;
+}
+
+/**
+ * Handle HTTP request
+ */
+function handleRequest(req, res) {
+  // CORS headers for browser/agent access
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+  res.setHeader('Content-Type', 'application/json');
+  
+  if (req.method === 'OPTIONS') {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+  
+  const parsedUrl = url.parse(req.url, true);
+  const pathname = parsedUrl.pathname;
+  const query = parsedUrl.query;
+  
+  // Health check
+  if (pathname === '/health' || pathname === '/') {
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true, service: 'jasper-recall', version: '0.2.1' }));
+    return;
+  }
+  
+  // Recall endpoint
+  if (pathname === '/recall' || pathname === '/api/recall') {
+    const searchQuery = query.q || query.query;
+    
+    if (!searchQuery) {
+      res.writeHead(400);
+      res.end(JSON.stringify({ ok: false, error: 'q or query parameter required' }));
+      return;
+    }
+    
+    // Security: public_only defaults to true
+    // Only allow disabling if explicitly set AND RECALL_ALLOW_PRIVATE=true
+    let publicOnly = true;
+    if (query.public_only === 'false' && process.env.RECALL_ALLOW_PRIVATE === 'true') {
+      publicOnly = false;
+    }
+    
+    const result = executeRecall(searchQuery, {
+      publicOnly,
+      limit: query.limit || 5
+    });
+    
+    if (result.ok) {
+      const parsed = parseResults(result.output);
+      res.writeHead(200);
+      res.end(JSON.stringify({
+        ok: true,
+        query: searchQuery,
+        public_only: publicOnly,
+        count: parsed.length,
+        results: parsed,
+        raw: result.output
+      }));
+    } else {
+      res.writeHead(500);
+      res.end(JSON.stringify({
+        ok: false,
+        error: result.error,
+        stderr: result.stderr?.substring(0, 500)
+      }));
+    }
+    return;
+  }
+  
+  // 404
+  res.writeHead(404);
+  res.end(JSON.stringify({ ok: false, error: 'Not found' }));
+}
+
+/**
+ * Start the server
+ */
+function startServer(port = 3458, host = '127.0.0.1') {
+  const server = http.createServer(handleRequest);
+  
+  server.listen(port, host, () => {
+    console.log(`🦊 Jasper Recall Server running on http://${host}:${port}`);
+    console.log('');
+    console.log('Endpoints:');
+    console.log(`  GET /recall?q=query     Search memories (public-only by default)`);
+    console.log(`  GET /health             Health check`);
+    console.log('');
+    console.log('Security: public_only=true is enforced by default');
+    console.log('Press Ctrl+C to stop');
+  });
+  
+  return server;
+}
+
+/**
+ * Parse CLI args and start server
+ */
+function runCLI(args) {
+  let port = 3458;
+  let host = '127.0.0.1';
+  
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--port' || args[i] === '-p') {
+      port = parseInt(args[++i]) || 3458;
+    }
+    if (args[i] === '--host' || args[i] === '-h') {
+      host = args[++i] || '127.0.0.1';
+    }
+    if (args[i] === '--help') {
+      console.log(`
+Jasper Recall Server
+HTTP API for memory search
+
+Usage: npx jasper-recall serve [options]
+
+Options:
+  --port, -p  Port to listen on (default: 3458)
+  --host, -h  Host to bind to (default: 127.0.0.1)
+  --help      Show this help
+
+Environment:
+  RECALL_ALLOW_PRIVATE=true  Allow public_only=false queries (dangerous!)
+
+Examples:
+  npx jasper-recall serve
+  npx jasper-recall serve --port 8080
+  npx jasper-recall serve --host 0.0.0.0
+`);
+      process.exit(0);
+    }
+  }
+  
+  startServer(port, host);
+}
+
+// Export for programmatic use
+module.exports = { startServer, executeRecall, parseResults, runCLI };
+
+// CLI entry point
+if (require.main === module) {
+  runCLI(process.argv.slice(2));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jasper-recall",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Local RAG system for AI agent memory using ChromaDB and sentence-transformers",
   "main": "src/index.js",
   "bin": {