trickle-cli 0.1.194 → 0.1.195

package/dist/commands/cleanup.d.ts

@@ -0,0 +1,12 @@
+/**
+ * trickle cleanup — Smart data management for .trickle/ files.
+ *
+ * Prunes old data, compacts JSONL files, and manages retention.
+ * Essential for heavy workloads where agents produce 10-100x more data.
+ */
+export declare function cleanupCommand(opts: {
+    retainDays?: string;
+    retainLines?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}): void;

package/dist/commands/cleanup.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * trickle cleanup — Smart data management for .trickle/ files.
+ *
+ * Prunes old data, compacts JSONL files, and manages retention.
+ * Essential for heavy workloads where agents produce 10-100x more data.
+ */
+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.cleanupCommand = cleanupCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function cleanupCommand(opts) {
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    if (!fs.existsSync(dir)) {
+        console.log(chalk_1.default.yellow('  No .trickle/ directory found.'));
+        return;
+    }
+    const retainDays = opts.retainDays ? parseInt(opts.retainDays, 10) : 7;
+    const retainLines = opts.retainLines ? parseInt(opts.retainLines, 10) : 0;
+    const cutoffMs = Date.now() - retainDays * 24 * 60 * 60 * 1000;
+    const dryRun = opts.dryRun || false;
+    const jsonlFiles = [
+        'observations.jsonl', 'variables.jsonl', 'calltrace.jsonl',
+        'queries.jsonl', 'errors.jsonl', 'llm.jsonl', 'agents.jsonl',
+        'mcp.jsonl', 'logs.jsonl', 'console.jsonl', 'traces.jsonl',
+        'alerts.jsonl', 'profile.jsonl',
+    ];
+    let totalBefore = 0;
+    let totalAfter = 0;
+    let totalLinesRemoved = 0;
+    let filesProcessed = 0;
+    const details = [];
+    for (const file of jsonlFiles) {
+        const filePath = path.join(dir, file);
+        if (!fs.existsSync(filePath))
+            continue;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const beforeSize = Buffer.byteLength(content);
+        totalBefore += beforeSize;
+        const lines = content.split('\n').filter(Boolean);
+        let kept;
+        if (retainLines > 0) {
+            // Keep only the last N lines
+            kept = lines.slice(-retainLines);
+        }
+        else {
+            // Keep lines with timestamp newer than cutoff
+            kept = lines.filter(line => {
+                try {
+                    const obj = JSON.parse(line);
+                    const ts = obj.timestamp || 0;
+                    // If timestamp is in seconds (< 2000000000), convert to ms
+                    const tsMs = ts < 2_000_000_000 ? ts * 1000 : ts;
+                    // Keep if no timestamp (can't determine age) or if newer than cutoff
+                    return !ts || tsMs > cutoffMs;
+                }
+                catch {
+                    return true; // Keep unparseable lines
+                }
+            });
+        }
+        const removed = lines.length - kept.length;
+        totalLinesRemoved += removed;
+        const newContent = kept.length > 0 ? kept.join('\n') + '\n' : '';
+        const afterSize = Buffer.byteLength(newContent);
+        totalAfter += afterSize;
+        filesProcessed++;
+        details.push({ file, before: beforeSize, after: afterSize, removed });
+        if (!dryRun && removed > 0) {
+            fs.writeFileSync(filePath, newContent, 'utf-8');
+        }
+    }
+    // Also clean up snapshot directory if it exists and is old
+    const snapshotDir = path.join(dir, 'snapshot');
+    if (fs.existsSync(snapshotDir)) {
+        try {
+            const stat = fs.statSync(snapshotDir);
+            if (stat.mtimeMs < cutoffMs && !dryRun) {
+                fs.rmSync(snapshotDir, { recursive: true });
+                details.push({ file: 'snapshot/', before: 0, after: 0, removed: -1 });
+            }
+        }
+        catch { }
+    }
+    // Clean up CSV export directory
+    const csvDir = path.join(dir, 'csv');
+    if (fs.existsSync(csvDir) && !dryRun) {
+        try {
+            const stat = fs.statSync(csvDir);
+            if (stat.mtimeMs < cutoffMs) {
+                fs.rmSync(csvDir, { recursive: true });
+            }
+        }
+        catch { }
+    }
+    const result = {
+        filesProcessed,
+        linesRemoved: totalLinesRemoved,
+        bytesBefore: totalBefore,
+        bytesAfter: totalAfter,
+        bytesSaved: totalBefore - totalAfter,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify({ ...result, details, dryRun, retainDays }, null, 2));
+        return;
+    }
+    console.log('');
+    console.log(chalk_1.default.bold(`  trickle cleanup${dryRun ? ' (dry run)' : ''}`));
+    console.log(chalk_1.default.gray('  ' + '─'.repeat(50)));
+    console.log(`  Retention: ${retainLines > 0 ? `last ${retainLines} lines per file` : `${retainDays} days`}`);
+    console.log(`  Files scanned: ${filesProcessed}`);
+    if (totalLinesRemoved === 0) {
+        console.log(chalk_1.default.green('  No data to prune — all data is within retention window.'));
+    }
+    else {
+        console.log(`  Lines removed: ${chalk_1.default.yellow(String(totalLinesRemoved))}`);
+        console.log(`  Space: ${formatBytes(totalBefore)} → ${formatBytes(totalAfter)} (${chalk_1.default.green('saved ' + formatBytes(result.bytesSaved))})`);
+        if (dryRun) {
+            console.log(chalk_1.default.yellow('\n  Dry run — no files modified. Remove --dry-run to apply.'));
+        }
+        else {
+            for (const d of details.filter(d => d.removed > 0)) {
+                console.log(chalk_1.default.gray(`    ${d.file}: ${d.removed} lines removed`));
+            }
+        }
+    }
+    console.log(chalk_1.default.gray('  ' + '─'.repeat(50)));
+    console.log('');
+}
+function formatBytes(bytes) {
+    if (bytes >= 1_000_000)
+        return (bytes / 1_000_000).toFixed(1) + 'MB';
+    if (bytes >= 1_000)
+        return (bytes / 1_000).toFixed(1) + 'KB';
+    return bytes + 'B';
+}

package/dist/index.js

@@ -920,6 +920,18 @@ program
     const { whyCommand } = await Promise.resolve().then(() => __importStar(require("./commands/why")));
     whyCommand(query, opts);
 });
+// trickle cleanup
+program
+    .command("cleanup")
+    .description("Prune old .trickle/ data — manage retention for heavy workloads")
+    .option("--retain-days <days>", "Keep data from last N days (default: 7)")
+    .option("--retain-lines <lines>", "Keep only last N lines per file (overrides --retain-days)")
+    .option("--dry-run", "Show what would be removed without modifying files")
+    .option("--json", "Output structured JSON")
+    .action(async (opts) => {
+    const { cleanupCommand } = await Promise.resolve().then(() => __importStar(require("./commands/cleanup")));
+    cleanupCommand(opts);
+});
 // trickle eval
 program
     .command("eval")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-cli",
-  "version": "0.1.194",
+  "version": "0.1.195",
   "description": "CLI for trickle runtime type observability",
   "bin": {
     "trickle": "dist/index.js"

package/src/commands/cleanup.ts

@@ -0,0 +1,162 @@
+/**
+ * trickle cleanup — Smart data management for .trickle/ files.
+ *
+ * Prunes old data, compacts JSONL files, and manages retention.
+ * Essential for heavy workloads where agents produce 10-100x more data.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+
+interface CleanupResult {
+  filesProcessed: number;
+  linesRemoved: number;
+  bytesBefore: number;
+  bytesAfter: number;
+  bytesSaved: number;
+}
+
+export function cleanupCommand(opts: {
+  retainDays?: string;
+  retainLines?: string;
+  dryRun?: boolean;
+  json?: boolean;
+}): void {
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+
+  if (!fs.existsSync(dir)) {
+    console.log(chalk.yellow('  No .trickle/ directory found.'));
+    return;
+  }
+
+  const retainDays = opts.retainDays ? parseInt(opts.retainDays, 10) : 7;
+  const retainLines = opts.retainLines ? parseInt(opts.retainLines, 10) : 0;
+  const cutoffMs = Date.now() - retainDays * 24 * 60 * 60 * 1000;
+  const dryRun = opts.dryRun || false;
+
+  const jsonlFiles = [
+    'observations.jsonl', 'variables.jsonl', 'calltrace.jsonl',
+    'queries.jsonl', 'errors.jsonl', 'llm.jsonl', 'agents.jsonl',
+    'mcp.jsonl', 'logs.jsonl', 'console.jsonl', 'traces.jsonl',
+    'alerts.jsonl', 'profile.jsonl',
+  ];
+
+  let totalBefore = 0;
+  let totalAfter = 0;
+  let totalLinesRemoved = 0;
+  let filesProcessed = 0;
+
+  const details: Array<{ file: string; before: number; after: number; removed: number }> = [];
+
+  for (const file of jsonlFiles) {
+    const filePath = path.join(dir, file);
+    if (!fs.existsSync(filePath)) continue;
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const beforeSize = Buffer.byteLength(content);
+    totalBefore += beforeSize;
+
+    const lines = content.split('\n').filter(Boolean);
+    let kept: string[];
+
+    if (retainLines > 0) {
+      // Keep only the last N lines
+      kept = lines.slice(-retainLines);
+    } else {
+      // Keep lines with timestamp newer than cutoff
+      kept = lines.filter(line => {
+        try {
+          const obj = JSON.parse(line);
+          const ts = obj.timestamp || 0;
+          // If timestamp is in seconds (< 2000000000), convert to ms
+          const tsMs = ts < 2_000_000_000 ? ts * 1000 : ts;
+          // Keep if no timestamp (can't determine age) or if newer than cutoff
+          return !ts || tsMs > cutoffMs;
+        } catch {
+          return true; // Keep unparseable lines
+        }
+      });
+    }
+
+    const removed = lines.length - kept.length;
+    totalLinesRemoved += removed;
+
+    const newContent = kept.length > 0 ? kept.join('\n') + '\n' : '';
+    const afterSize = Buffer.byteLength(newContent);
+    totalAfter += afterSize;
+    filesProcessed++;
+
+    details.push({ file, before: beforeSize, after: afterSize, removed });
+
+    if (!dryRun && removed > 0) {
+      fs.writeFileSync(filePath, newContent, 'utf-8');
+    }
+  }
+
+  // Also clean up snapshot directory if it exists and is old
+  const snapshotDir = path.join(dir, 'snapshot');
+  if (fs.existsSync(snapshotDir)) {
+    try {
+      const stat = fs.statSync(snapshotDir);
+      if (stat.mtimeMs < cutoffMs && !dryRun) {
+        fs.rmSync(snapshotDir, { recursive: true });
+        details.push({ file: 'snapshot/', before: 0, after: 0, removed: -1 });
+      }
+    } catch {}
+  }
+
+  // Clean up CSV export directory
+  const csvDir = path.join(dir, 'csv');
+  if (fs.existsSync(csvDir) && !dryRun) {
+    try {
+      const stat = fs.statSync(csvDir);
+      if (stat.mtimeMs < cutoffMs) {
+        fs.rmSync(csvDir, { recursive: true });
+      }
+    } catch {}
+  }
+
+  const result: CleanupResult = {
+    filesProcessed,
+    linesRemoved: totalLinesRemoved,
+    bytesBefore: totalBefore,
+    bytesAfter: totalAfter,
+    bytesSaved: totalBefore - totalAfter,
+  };
+
+  if (opts.json) {
+    console.log(JSON.stringify({ ...result, details, dryRun, retainDays }, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold(`  trickle cleanup${dryRun ? ' (dry run)' : ''}`));
+  console.log(chalk.gray('  ' + '─'.repeat(50)));
+  console.log(`  Retention: ${retainLines > 0 ? `last ${retainLines} lines per file` : `${retainDays} days`}`);
+  console.log(`  Files scanned: ${filesProcessed}`);
+
+  if (totalLinesRemoved === 0) {
+    console.log(chalk.green('  No data to prune — all data is within retention window.'));
+  } else {
+    console.log(`  Lines removed: ${chalk.yellow(String(totalLinesRemoved))}`);
+    console.log(`  Space: ${formatBytes(totalBefore)} → ${formatBytes(totalAfter)} (${chalk.green('saved ' + formatBytes(result.bytesSaved))})`);
+
+    if (dryRun) {
+      console.log(chalk.yellow('\n  Dry run — no files modified. Remove --dry-run to apply.'));
+    } else {
+      for (const d of details.filter(d => d.removed > 0)) {
+        console.log(chalk.gray(`    ${d.file}: ${d.removed} lines removed`));
+      }
+    }
+  }
+
+  console.log(chalk.gray('  ' + '─'.repeat(50)));
+  console.log('');
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes >= 1_000_000) return (bytes / 1_000_000).toFixed(1) + 'MB';
+  if (bytes >= 1_000) return (bytes / 1_000).toFixed(1) + 'KB';
+  return bytes + 'B';
+}

package/src/index.ts

@@ -953,6 +953,19 @@ program
     whyCommand(query, opts);
   });
 
+// trickle cleanup
+program
+  .command("cleanup")
+  .description("Prune old .trickle/ data — manage retention for heavy workloads")
+  .option("--retain-days <days>", "Keep data from last N days (default: 7)")
+  .option("--retain-lines <lines>", "Keep only last N lines per file (overrides --retain-days)")
+  .option("--dry-run", "Show what would be removed without modifying files")
+  .option("--json", "Output structured JSON")
+  .action(async (opts) => {
+    const { cleanupCommand } = await import("./commands/cleanup");
+    cleanupCommand(opts);
+  });
+
 // trickle eval
 program
   .command("eval")