trickle-cli 0.1.205 → 0.1.207

package/dist/commands/cost-report.js

@@ -301,12 +301,33 @@ function costReportCommand(opts) {
                 }
             }
         }
-        if (cacheDetected) {
+        // Provider-reported cache tokens (Anthropic cache_read/cache_creation)
+        const cacheReadTotal = calls.reduce((s, c) => s + (c.cacheReadTokens || 0), 0);
+        const cacheWriteTotal = calls.reduce((s, c) => s + (c.cacheWriteTokens || 0), 0);
+        const callsWithCache = calls.filter((c) => c.cacheReadTokens > 0 || c.cacheWriteTokens > 0);
+        if (callsWithCache.length > 0 || cacheDetected) {
             console.log(chalk_1.default.gray('\n  ' + '─'.repeat(60)));
-            console.log(chalk_1.default.bold('  Cache Analysis') + chalk_1.default.gray(' (detected from latency bimodality)'));
-            for (const ca of cacheAnalysis) {
-                const speedup = (ca.slowAvg / Math.max(1, ca.fastAvg)).toFixed(0);
-                console.log(`  ${chalk_1.default.cyan(ca.model.padEnd(25))} hit rate: ${chalk_1.default.green(ca.hitRate + '%')} (${ca.fastCalls} fast, ${ca.slowCalls} slow)  ${speedup}x speedup  fast=${ca.fastAvg}ms slow=${ca.slowAvg}ms`);
+            console.log(chalk_1.default.bold('  Cache Analysis'));
+            if (callsWithCache.length > 0) {
+                const cacheHitCalls = calls.filter((c) => c.cacheReadTokens > 0);
+                const hitRate = calls.length > 0 ? Math.round((cacheHitCalls.length / calls.length) * 100) : 0;
+                // Estimate savings: cached tokens cost ~90% less
+                const savedTokens = cacheReadTotal;
+                const avgInputPrice = totalCost > 0 && totalTokens > 0 ? (totalCost / totalTokens) : 0.000003;
+                const estimatedSavings = savedTokens * avgInputPrice * 0.9;
+                console.log(chalk_1.default.gray('  Provider-reported cache tokens:'));
+                console.log(`  Hit rate: ${chalk_1.default.green(hitRate + '%')} (${cacheHitCalls.length}/${calls.length} calls used cache)`);
+                console.log(`  Cache read: ${formatTokens(cacheReadTotal)} tokens | Cache write: ${formatTokens(cacheWriteTotal)} tokens`);
+                if (estimatedSavings > 0) {
+                    console.log(`  Estimated savings: ${chalk_1.default.green('~$' + estimatedSavings.toFixed(4))} from cached tokens`);
+                }
+            }
+            if (cacheDetected) {
+                console.log(chalk_1.default.gray('  Latency-based detection:'));
+                for (const ca of cacheAnalysis) {
+                    const speedup = (ca.slowAvg / Math.max(1, ca.fastAvg)).toFixed(0);
+                    console.log(`  ${chalk_1.default.cyan(ca.model.padEnd(25))} hit rate: ${chalk_1.default.green(ca.hitRate + '%')} (${ca.fastCalls} fast, ${ca.slowCalls} slow)  ${speedup}x speedup`);
+                }
             }
         }
     }

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.205",
+  "version": "0.1.207",
   "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/cost-report.ts

@@ -281,12 +281,36 @@ export function costReportCommand(opts: { json?: boolean; budget?: string }): vo
       }
     }
 
-    if (cacheDetected) {
+    // Provider-reported cache tokens (Anthropic cache_read/cache_creation)
+    const cacheReadTotal = calls.reduce((s: number, c: any) => s + (c.cacheReadTokens || 0), 0);
+    const cacheWriteTotal = calls.reduce((s: number, c: any) => s + (c.cacheWriteTokens || 0), 0);
+    const callsWithCache = calls.filter((c: any) => c.cacheReadTokens > 0 || c.cacheWriteTokens > 0);
+
+    if (callsWithCache.length > 0 || cacheDetected) {
       console.log(chalk.gray('\n  ' + '─'.repeat(60)));
-      console.log(chalk.bold('  Cache Analysis') + chalk.gray(' (detected from latency bimodality)'));
-      for (const ca of cacheAnalysis) {
-        const speedup = (ca.slowAvg / Math.max(1, ca.fastAvg)).toFixed(0);
-        console.log(`  ${chalk.cyan(ca.model.padEnd(25))} hit rate: ${chalk.green(ca.hitRate + '%')} (${ca.fastCalls} fast, ${ca.slowCalls} slow)  ${speedup}x speedup  fast=${ca.fastAvg}ms slow=${ca.slowAvg}ms`);
+      console.log(chalk.bold('  Cache Analysis'));
+
+      if (callsWithCache.length > 0) {
+        const cacheHitCalls = calls.filter((c: any) => c.cacheReadTokens > 0);
+        const hitRate = calls.length > 0 ? Math.round((cacheHitCalls.length / calls.length) * 100) : 0;
+        // Estimate savings: cached tokens cost ~90% less
+        const savedTokens = cacheReadTotal;
+        const avgInputPrice = totalCost > 0 && totalTokens > 0 ? (totalCost / totalTokens) : 0.000003;
+        const estimatedSavings = savedTokens * avgInputPrice * 0.9;
+        console.log(chalk.gray('  Provider-reported cache tokens:'));
+        console.log(`  Hit rate: ${chalk.green(hitRate + '%')} (${cacheHitCalls.length}/${calls.length} calls used cache)`);
+        console.log(`  Cache read: ${formatTokens(cacheReadTotal)} tokens | Cache write: ${formatTokens(cacheWriteTotal)} tokens`);
+        if (estimatedSavings > 0) {
+          console.log(`  Estimated savings: ${chalk.green('~$' + estimatedSavings.toFixed(4))} from cached tokens`);
+        }
+      }
+
+      if (cacheDetected) {
+        console.log(chalk.gray('  Latency-based detection:'));
+        for (const ca of cacheAnalysis) {
+          const speedup = (ca.slowAvg / Math.max(1, ca.fastAvg)).toFixed(0);
+          console.log(`  ${chalk.cyan(ca.model.padEnd(25))} hit rate: ${chalk.green(ca.hitRate + '%')} (${ca.fastCalls} fast, ${ca.slowCalls} slow)  ${speedup}x speedup`);
+        }
       }
     }
   }

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...]")