trickle-cli 0.1.206 → 0.1.208

package/dist/commands/mcp-server.js

@@ -796,6 +796,11 @@ const TOOLS = [
                 budget: { type: "number", description: "Optional budget in USD to check against" },
             } },
     },
+    {
+        name: "get_memory_operations",
+        description: "Get captured agent memory operations (Mem0 add/get/search/update/delete). Shows what was stored, what was retrieved, retrieval counts, and latency. Essential for debugging agent memory — understanding why an agent remembered or forgot something.",
+        inputSchema: { type: "object", properties: {} },
+    },
 ];
 async function handleRequest(req) {
     switch (req.method) {
@@ -1479,6 +1484,28 @@ async function handleRequest(req) {
                         }
                         break;
                     }
+                    case "get_memory_operations": {
+                        try {
+                            const memFile = require('path').join(findTrickleDir(), 'memory.jsonl');
+                            const fs = require('fs');
+                            if (!fs.existsSync(memFile)) {
+                                result = { operations: [], total: 0, message: "No memory data. Run an app that uses Mem0 with trickle." };
+                            }
+                            else {
+                                const ops = fs.readFileSync(memFile, 'utf-8').split('\n').filter(Boolean).map((l) => { try {
+                                    return JSON.parse(l);
+                                }
+                                catch {
+                                    return null;
+                                } }).filter((o) => o && o.kind === 'memory_op');
+                                result = { operations: ops, total: ops.length };
+                            }
+                        }
+                        catch (e) {
+                            result = { error: `Failed to read memory operations: ${e.message}` };
+                        }
+                        break;
+                    }
                     case "get_agent_trace": {
                         try {
                             const agentsFile = require('path').join(findTrickleDir(), 'agents.jsonl');

package/dist/commands/memory.d.ts

@@ -0,0 +1,6 @@
+/**
+ * trickle memory — Show captured agent memory operations (Mem0).
+ */
+export declare function memoryCommand(opts: {
+    json?: boolean;
+}): void;

package/dist/commands/memory.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * trickle memory — Show captured agent memory operations (Mem0).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryCommand = memoryCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function memoryCommand(opts) {
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    const memFile = path.join(dir, 'memory.jsonl');
+    if (!fs.existsSync(memFile)) {
+        console.log(chalk_1.default.yellow('  No memory data. Run an app that uses Mem0 with trickle.'));
+        return;
+    }
+    const events = fs.readFileSync(memFile, 'utf-8').split('\n').filter(Boolean)
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter((e) => e && e.kind === 'memory_op');
+    if (events.length === 0) {
+        console.log(chalk_1.default.yellow('  No memory operations captured.'));
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(events, null, 2));
+        return;
+    }
+    console.log('');
+    console.log(chalk_1.default.bold('  trickle memory'));
+    console.log(chalk_1.default.gray('  ' + '─'.repeat(60)));
+    const adds = events.filter((e) => e.operation === 'add');
+    const searches = events.filter((e) => e.operation === 'search');
+    const gets = events.filter((e) => e.operation === 'get' || e.operation === 'get_all');
+    const updates = events.filter((e) => e.operation === 'update');
+    const deletes = events.filter((e) => e.operation === 'delete');
+    const errors = events.filter((e) => e.error);
+    console.log(`  ${chalk_1.default.cyan(String(events.length))} operations: ${adds.length} add, ${searches.length} search, ${gets.length} get, ${updates.length} update, ${deletes.length} delete${errors.length > 0 ? chalk_1.default.red(`, ${errors.length} errors`) : ''}`);
+    console.log(chalk_1.default.gray('  ' + '─'.repeat(60)));
+    for (const e of events.slice(-15)) {
+        const op = e.operation;
+        const dur = e.durationMs ? chalk_1.default.gray(`${e.durationMs}ms`) : '';
+        const icon = op === 'add' ? chalk_1.default.green('+') : op === 'search' ? chalk_1.default.blue('?') : op === 'delete' ? chalk_1.default.red('-') : op === 'update' ? chalk_1.default.yellow('~') : chalk_1.default.gray('→');
+        let detail = '';
+        if (e.input)
+            detail = e.input.substring(0, 60);
+        if (e.query)
+            detail = `"${e.query.substring(0, 50)}"`;
+        if (e.memoryId)
+            detail = `id:${e.memoryId}`;
+        if (e.resultsCount !== undefined)
+            detail += ` → ${e.resultsCount} results`;
+        if (e.memoriesCount !== undefined)
+            detail += ` (${e.memoriesCount} memories)`;
+        if (e.error)
+            detail = chalk_1.default.red(e.error.substring(0, 50));
+        console.log(`  ${icon} ${chalk_1.default.bold(op.padEnd(10))} ${dur.padEnd(8)} ${detail}`);
+    }
+    if (events.length > 15)
+        console.log(chalk_1.default.gray(`  ... and ${events.length - 15} more`));
+    console.log('');
+}

package/dist/index.js

@@ -920,6 +920,15 @@ program
     const { whyCommand } = await Promise.resolve().then(() => __importStar(require("./commands/why")));
     whyCommand(query, opts);
 });
+// trickle memory
+program
+    .command("memory")
+    .description("Show captured agent memory operations (Mem0 add/get/search/update/delete)")
+    .option("--json", "Output raw JSON")
+    .action(async (opts) => {
+    const { memoryCommand } = await Promise.resolve().then(() => __importStar(require("./commands/memory")));
+    memoryCommand(opts);
+});
 // trickle benchmark
 program
     .command("benchmark [command...]")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-cli",
-  "version": "0.1.206",
+  "version": "0.1.208",
   "description": "Zero-code runtime observability for JS/Python + AI agent debugging. Traces LangChain, CrewAI, OpenAI, Anthropic, Gemini. Eval, security, compliance, cost tracking. Free, local-first.",
   "keywords": ["observability", "tracing", "llm", "openai", "anthropic", "langchain", "crewai", "agent", "mcp", "debugging", "typescript", "python", "security", "eval", "compliance"],
   "bin": {

package/src/commands/mcp-server.ts

@@ -805,6 +805,11 @@ const TOOLS = [
       budget: { type: "number", description: "Optional budget in USD to check against" },
     }},
   },
+  {
+    name: "get_memory_operations",
+    description: "Get captured agent memory operations (Mem0 add/get/search/update/delete). Shows what was stored, what was retrieved, retrieval counts, and latency. Essential for debugging agent memory — understanding why an agent remembered or forgot something.",
+    inputSchema: { type: "object", properties: {} },
+  },
 ];
 
 async function handleRequest(req: JsonRpcRequest): Promise<JsonRpcResponse> {
@@ -1392,6 +1397,21 @@ async function handleRequest(req: JsonRpcRequest): Promise<JsonRpcResponse> {
             }
             break;
           }
+          case "get_memory_operations": {
+            try {
+              const memFile = require('path').join(findTrickleDir(), 'memory.jsonl');
+              const fs = require('fs');
+              if (!fs.existsSync(memFile)) {
+                result = { operations: [], total: 0, message: "No memory data. Run an app that uses Mem0 with trickle." };
+              } else {
+                const ops = fs.readFileSync(memFile, 'utf-8').split('\n').filter(Boolean).map((l: string) => { try { return JSON.parse(l); } catch { return null; } }).filter((o: any) => o && o.kind === 'memory_op');
+                result = { operations: ops, total: ops.length };
+              }
+            } catch (e: any) {
+              result = { error: `Failed to read memory operations: ${e.message}` };
+            }
+            break;
+          }
           case "get_agent_trace": {
             try {
               const agentsFile = require('path').join(findTrickleDir(), 'agents.jsonl');

package/src/commands/memory.ts

@@ -0,0 +1,63 @@
+/**
+ * trickle memory — Show captured agent memory operations (Mem0).
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+
+export function memoryCommand(opts: { json?: boolean }): void {
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  const memFile = path.join(dir, 'memory.jsonl');
+
+  if (!fs.existsSync(memFile)) {
+    console.log(chalk.yellow('  No memory data. Run an app that uses Mem0 with trickle.'));
+    return;
+  }
+
+  const events = fs.readFileSync(memFile, 'utf-8').split('\n').filter(Boolean)
+    .map(l => { try { return JSON.parse(l); } catch { return null; } })
+    .filter((e: any) => e && e.kind === 'memory_op');
+
+  if (events.length === 0) {
+    console.log(chalk.yellow('  No memory operations captured.'));
+    return;
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(events, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold('  trickle memory'));
+  console.log(chalk.gray('  ' + '─'.repeat(60)));
+
+  const adds = events.filter((e: any) => e.operation === 'add');
+  const searches = events.filter((e: any) => e.operation === 'search');
+  const gets = events.filter((e: any) => e.operation === 'get' || e.operation === 'get_all');
+  const updates = events.filter((e: any) => e.operation === 'update');
+  const deletes = events.filter((e: any) => e.operation === 'delete');
+  const errors = events.filter((e: any) => e.error);
+
+  console.log(`  ${chalk.cyan(String(events.length))} operations: ${adds.length} add, ${searches.length} search, ${gets.length} get, ${updates.length} update, ${deletes.length} delete${errors.length > 0 ? chalk.red(`, ${errors.length} errors`) : ''}`);
+  console.log(chalk.gray('  ' + '─'.repeat(60)));
+
+  for (const e of events.slice(-15)) {
+    const op = (e as any).operation;
+    const dur = (e as any).durationMs ? chalk.gray(`${(e as any).durationMs}ms`) : '';
+    const icon = op === 'add' ? chalk.green('+') : op === 'search' ? chalk.blue('?') : op === 'delete' ? chalk.red('-') : op === 'update' ? chalk.yellow('~') : chalk.gray('→');
+    let detail = '';
+    if ((e as any).input) detail = (e as any).input.substring(0, 60);
+    if ((e as any).query) detail = `"${(e as any).query.substring(0, 50)}"`;
+    if ((e as any).memoryId) detail = `id:${(e as any).memoryId}`;
+    if ((e as any).resultsCount !== undefined) detail += ` → ${(e as any).resultsCount} results`;
+    if ((e as any).memoriesCount !== undefined) detail += ` (${(e as any).memoriesCount} memories)`;
+    if ((e as any).error) detail = chalk.red((e as any).error.substring(0, 50));
+
+    console.log(`  ${icon} ${chalk.bold(op.padEnd(10))} ${dur.padEnd(8)} ${detail}`);
+  }
+
+  if (events.length > 15) console.log(chalk.gray(`  ... and ${events.length - 15} more`));
+  console.log('');
+}

package/src/index.ts

@@ -953,6 +953,16 @@ program
     whyCommand(query, opts);
   });
 
+// trickle memory
+program
+  .command("memory")
+  .description("Show captured agent memory operations (Mem0 add/get/search/update/delete)")
+  .option("--json", "Output raw JSON")
+  .action(async (opts) => {
+    const { memoryCommand } = await import("./commands/memory");
+    memoryCommand(opts);
+  });
+
 // trickle benchmark
 program
   .command("benchmark [command...]")