trickle-cli 0.1.3 → 0.1.5

package/dist/api-client.js

@@ -157,7 +157,7 @@ async function fetchFunctionSamples() {
     const samples = [];
     for (const fn of functions) {
         try {
-            const data = await fetchJson(`/api/types/${encodeURIComponent(fn.function_name)}`);
+            const data = await fetchJson(`/api/types/${fn.id}`);
             if (data.snapshots && data.snapshots.length > 0) {
                 const snap = data.snapshots[0];
                 if (snap.sample_input || snap.sample_output) {

package/dist/commands/init.js

@@ -67,11 +67,13 @@ function detectProject(dir, forcePython) {
     if (fs.existsSync(tsPath)) {
         info.hasTsConfig = true;
         try {
-            // Strip comments (simple approach: remove // and /* */ comments)
+            // Strip comments but preserve glob patterns like /**/*.ts
             const raw = fs.readFileSync(tsPath, "utf-8");
+            // Only strip // comments that are NOT inside strings
+            // And /* */ comments that are NOT inside strings (careful with globs)
             const cleaned = raw
                 .replace(/\/\/.*$/gm, "")
-                .replace(/\/\*[\s\S]*?\*\//g, "");
+                .replace(/("[^"]*")|\/\*[\s\S]*?\*\//g, (match, str) => str || "");
             info.tsConfig = JSON.parse(cleaned);
         }
         catch {
@@ -205,7 +207,7 @@ function writeInitialTypes(trickleDir, isPython) {
 }
 function updateTsConfig(dir, info) {
     const tsConfigPath = path.join(dir, "tsconfig.json");
-    if (!info.hasTsConfig || !info.tsConfig) {
+    if (!info.hasTsConfig) {
         // No tsconfig — create a minimal one that includes .trickle
         if (!info.isPython) {
             const newConfig = {
@@ -225,23 +227,52 @@ function updateTsConfig(dir, info) {
         }
         return false;
     }
-    // Read the raw file to preserve formatting as much as possible
+    // Use text-based insertion to preserve formatting and glob patterns
+    // (JSON.parse + stringify corrupts /**/ globs by treating them as comments)
     const raw = fs.readFileSync(tsConfigPath, "utf-8");
-    const config = info.tsConfig;
     // Check if .trickle is already included
-    const include = config.include;
-    if (include && include.some((p) => p === ".trickle" || p.startsWith(".trickle/"))) {
-        return false; // Already configured
-    }
-    // Add .trickle to include array
-    if (include) {
-        include.push(".trickle");
-    }
-    else {
-        config.include = ["src", ".trickle"];
+    if (raw.includes(".trickle"))
+        return false;
+    // Find the "include" array and insert ".trickle" at the end
+    const includeMatch = raw.match(/"include"\s*:\s*\[([^\]]*)\]/);
+    if (includeMatch) {
+        const bracket = includeMatch.index + includeMatch[0].length - 1; // position of ]
+        const inside = includeMatch[1];
+        // Detect if it's single-line or multi-line
+        if (inside.includes("\n")) {
+            // Multi-line — add before the closing bracket with same indentation
+            const lastEntry = inside.match(/.*\S[^\n]*/g);
+            const indent = lastEntry ? lastEntry[lastEntry.length - 1].match(/^(\s*)/)?.[1] || "        " : "        ";
+            const updated = raw.slice(0, bracket) + `,\n${indent}".trickle"` + raw.slice(bracket);
+            fs.writeFileSync(tsConfigPath, updated, "utf-8");
+        }
+        else {
+            // Single-line: ["src/**/*.ts", "tmp/**/*.ts"] → add ".trickle"
+            const updated = raw.slice(0, bracket) + ', ".trickle"' + raw.slice(bracket);
+            fs.writeFileSync(tsConfigPath, updated, "utf-8");
+        }
+        return true;
+    }
+    // No include array — add one after compilerOptions closing brace
+    const compilerEnd = raw.match(/"compilerOptions"\s*:\s*\{/);
+    if (compilerEnd) {
+        // Find the closing brace of compilerOptions
+        const startBrace = raw.indexOf("{", compilerEnd.index + compilerEnd[0].length - 1);
+        let depth = 1;
+        let pos = startBrace + 1;
+        while (pos < raw.length && depth > 0) {
+            if (raw[pos] === "{")
+                depth++;
+            else if (raw[pos] === "}")
+                depth--;
+            pos++;
+        }
+        // pos is now right after the closing brace of compilerOptions
+        const updated = raw.slice(0, pos) + `,\n    "include": ["src", ".trickle"]` + raw.slice(pos);
+        fs.writeFileSync(tsConfigPath, updated, "utf-8");
+        return true;
     }
-    fs.writeFileSync(tsConfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-    return true;
+    return false;
 }
 function updatePackageJson(dir, info) {
     if (!info.hasPackageJson || !info.packageJson) {
@@ -291,6 +322,93 @@ function updatePackageJson(dir, info) {
     }
     return { scriptsAdded: added };
 }
+function updateVitestConfig(dir) {
+    // Look for vitest.config.ts, vitest.config.js, vitest.config.mts, vite.config.ts, vite.config.js
+    const candidates = [
+        "vitest.config.ts",
+        "vitest.config.js",
+        "vitest.config.mts",
+        "vite.config.ts",
+        "vite.config.js",
+    ];
+    let configFile = null;
+    for (const c of candidates) {
+        if (fs.existsSync(path.join(dir, c))) {
+            configFile = c;
+            break;
+        }
+    }
+    if (!configFile)
+        return false;
+    const configPath = path.join(dir, configFile);
+    const content = fs.readFileSync(configPath, "utf-8");
+    // Already has tricklePlugin
+    if (content.includes("tricklePlugin"))
+        return false;
+    // Find the import section end and plugins array
+    const lines = content.split("\n");
+    let lastImportLine = -1;
+    let pluginsLine = -1;
+    let pluginsArrayContent = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^\s*import\s/.test(line)) {
+            // Track multi-line imports
+            lastImportLine = i;
+            if (!line.includes(";") && !line.includes("from")) {
+                // Multi-line import — find the closing line
+                for (let j = i + 1; j < lines.length; j++) {
+                    if (lines[j].includes("from")) {
+                        lastImportLine = j;
+                        break;
+                    }
+                }
+            }
+        }
+        if (/plugins\s*:\s*\[/.test(line)) {
+            pluginsLine = i;
+            pluginsArrayContent = line;
+        }
+    }
+    if (lastImportLine === -1)
+        return false;
+    // Add import after last import
+    const importLine = `import { tricklePlugin } from "trickle-observe/vite-plugin";`;
+    lines.splice(lastImportLine + 1, 0, importLine);
+    // Adjust pluginsLine index since we inserted a line
+    if (pluginsLine > lastImportLine) {
+        pluginsLine += 1;
+    }
+    // Add tricklePlugin() to plugins array
+    if (pluginsLine !== -1) {
+        const line = lines[pluginsLine];
+        // Check if plugins array is on one line: plugins: [something()],
+        if (/plugins\s*:\s*\[.*\]/.test(line)) {
+            // Insert tricklePlugin() before the closing bracket
+            lines[pluginsLine] = line.replace(/\]/, ", tricklePlugin()]");
+        }
+        else {
+            // Multi-line plugins — add after the opening bracket line
+            const indent = line.match(/^(\s*)/)?.[1] || "";
+            const innerIndent = indent + "    ";
+            lines.splice(pluginsLine + 1, 0, `${innerIndent}tricklePlugin(),`);
+        }
+    }
+    else {
+        // No plugins array found — need to add one
+        // Find defineConfig({ and add plugins after it
+        for (let i = 0; i < lines.length; i++) {
+            if (/defineConfig\s*\(\s*\{/.test(lines[i])) {
+                const indent = lines[i].match(/^(\s*)/)?.[1] || "";
+                const innerIndent = indent + "    ";
+                lines.splice(i + 1, 0, `${innerIndent}plugins: [tricklePlugin()],`);
+                break;
+            }
+        }
+    }
+    fs.writeFileSync(configPath, lines.join("\n"), "utf-8");
+    return true;
+}
 function updateGitignore(dir) {
     const giPath = path.join(dir, ".gitignore");
     let content = "";
@@ -359,7 +477,14 @@ async function initCommand(opts) {
             console.log(`  ${chalk_1.default.gray("-")} tsconfig.json already includes .trickle`);
         }
     }
-    // Step 5: Update package.json scripts
+    // Step 5: Update vitest/vite config with tricklePlugin
+    if (!info.isPython) {
+        const vitestUpdated = updateVitestConfig(dir);
+        if (vitestUpdated) {
+            console.log(`  ${chalk_1.default.green("~")} Updated ${chalk_1.default.bold("vitest.config.ts")} — added tricklePlugin() for variable tracing`);
+        }
+    }
+    // Step 6: Update package.json scripts
     if (info.hasPackageJson) {
         const { scriptsAdded } = updatePackageJson(dir, info);
         if (scriptsAdded.length > 0) {
@@ -368,12 +493,12 @@ async function initCommand(opts) {
             }
         }
     }
-    // Step 6: Update .gitignore
+    // Step 7: Update .gitignore
     const giUpdated = updateGitignore(dir);
     if (giUpdated) {
         console.log(`  ${chalk_1.default.green("~")} Updated ${chalk_1.default.bold(".gitignore")} — added .trickle/`);
     }
-    // Step 7: Print next steps
+    // Step 8: Print next steps
     console.log("");
     console.log(chalk_1.default.bold("  Next steps:"));
     console.log("");
@@ -389,6 +514,7 @@ async function initCommand(opts) {
     console.log("");
     console.log(chalk_1.default.gray("  Other commands:"));
     console.log(chalk_1.default.gray("     trickle functions         — list observed functions"));
+    console.log(chalk_1.default.gray("     trickle vars              — list captured variable types + values"));
     console.log(chalk_1.default.gray("     trickle types <name>      — see types + sample data"));
     console.log(chalk_1.default.gray("     trickle annotate src/     — add type annotations to source files"));
     console.log("");

package/dist/commands/run.js

@@ -150,10 +150,15 @@ function autoDetectCommand(input) {
     }
 }
 function findTsRunner() {
+    const { execSync } = require("child_process");
+    // Add node_modules/.bin to PATH so local binaries are found
+    const binPath = path.join(process.cwd(), "node_modules", ".bin");
+    const currentPath = process.env.PATH || "";
+    const augmentedPath = currentPath.includes(binPath) ? currentPath : `${binPath}${path.delimiter}${currentPath}`;
+    const execOpts = { stdio: "ignore", env: { ...process.env, PATH: augmentedPath } };
     // Check for tsx (fastest, most compatible)
     try {
-        const { execSync } = require("child_process");
-        execSync("tsx --version", { stdio: "ignore" });
+        execSync("tsx --version", execOpts);
         return "tsx";
     }
     catch {
@@ -161,8 +166,7 @@ function findTsRunner() {
     }
     // Check for ts-node
     try {
-        const { execSync } = require("child_process");
-        execSync("ts-node --version", { stdio: "ignore" });
+        execSync("ts-node --version", execOpts);
         return "ts-node";
     }
     catch {
@@ -170,8 +174,7 @@ function findTsRunner() {
     }
     // Check for bun (supports TS natively)
     try {
-        const { execSync } = require("child_process");
-        execSync("bun --version", { stdio: "ignore" });
+        execSync("bun --version", execOpts);
         return "bun";
     }
     catch {
@@ -388,6 +391,17 @@ async function executeSingleRun(instrumentedCommand, env, opts, singleFile, loca
             console.log(chalk_1.default.green(`  Types written to ${chalk_1.default.bold(relPath)}`));
         }
     }
+    // Show variable/tensor summary if variables.jsonl exists
+    const varsJsonlPath = path.join(localDir, "variables.jsonl");
+    if (fs.existsSync(varsJsonlPath)) {
+        try {
+            const { showVarsSummary } = await Promise.resolve().then(() => __importStar(require("./vars")));
+            showVarsSummary(varsJsonlPath);
+        }
+        catch {
+            // vars module not available, skip
+        }
+    }
     console.log(chalk_1.default.gray("  " + "─".repeat(50)));
     console.log("");
     return exitCode;
@@ -471,14 +485,19 @@ function startLiveBackendTypes(sourceFile) {
     const baseName = path.basename(sourceFile, ext);
     const sidecarName = isPython ? `${baseName}.pyi` : `${baseName}.d.ts`;
     const sidecarPath = path.join(dir, sidecarName);
+    // Also check .trickle/types/ where auto-codegen now writes
+    const trickleDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    const trickleTypesPath = path.join(trickleDir, 'types', `${baseName}.d.ts`);
     const poll = async () => {
         if (stopped)
             return;
         try {
             const { stubsCommand } = await Promise.resolve().then(() => __importStar(require("./stubs")));
             await stubsCommand(dir, { silent: true });
-            if (fs.existsSync(sidecarPath)) {
-                const content = fs.readFileSync(sidecarPath, "utf-8");
+            // Check both old sidecar path and new .trickle/types/ path
+            const effectivePath = fs.existsSync(trickleTypesPath) ? trickleTypesPath : sidecarPath;
+            if (fs.existsSync(effectivePath)) {
+                const content = fs.readFileSync(effectivePath, "utf-8");
                 const funcCount = (content.match(/export declare function/g) || []).length;
                 if (funcCount > lastFunctionCount) {
                     const newCount = funcCount - lastFunctionCount;
@@ -552,11 +571,15 @@ async function autoGenerateSidecar(filePath) {
         // Use the stubs command to generate stubs for the file's directory
         const { stubsCommand } = await Promise.resolve().then(() => __importStar(require("./stubs")));
         await stubsCommand(dir, { silent: true });
-        // Check if the sidecar was generated
-        if (fs.existsSync(sidecarPath)) {
-            const stats = fs.statSync(sidecarPath);
+        // Check if types were generated (either sidecar or .trickle/types/)
+        const tDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+        const tTypesPath = path.join(tDir, 'types', `${baseName}.d.ts`);
+        const effectiveSidecar = fs.existsSync(tTypesPath) ? tTypesPath : sidecarPath;
+        const displayName = fs.existsSync(tTypesPath) ? `${baseName}.d.ts` : sidecarName;
+        if (fs.existsSync(effectiveSidecar)) {
+            const stats = fs.statSync(effectiveSidecar);
             if (stats.size > 0) {
-                console.log(chalk_1.default.green(`\n  Types written to ${chalk_1.default.bold(sidecarName)}`));
+                console.log(chalk_1.default.green(`\n  Types written to ${chalk_1.default.bold(displayName)}`));
             }
         }
     }
@@ -828,7 +851,13 @@ function injectObservation(command, backendUrl, opts) {
         const runner = nodeMatch[1];
         const useEsm = isEsmFile(command) && observeEsmPath;
         if (useEsm) {
-            const modified = command.replace(new RegExp(`^${runner}\\s`), `${runner} --import ${observeEsmPath} `);
+            // Use both ESM hooks (for exported functions) and CJS hook (for Express auto-detection)
+            const modified = command.replace(new RegExp(`^${runner}\\s`), `${runner} -r ${observePath} --import ${observeEsmPath} `);
+            return { instrumentedCommand: modified, env };
+        }
+        else if (runner === "tsx") {
+            // tsx always uses ESM internally — inject both CJS and ESM hooks
+            const modified = command.replace(new RegExp(`^${runner}\\s`), `${runner} -r ${observePath} --import ${observeEsmPath} `);
             return { instrumentedCommand: modified, env };
         }
         else {
@@ -907,10 +936,14 @@ function resolveObserveEsmPath() {
 }
 function runProcess(command, env) {
     return new Promise((resolve) => {
+        // Add node_modules/.bin to PATH so local binaries (tsx, ts-node, etc.) are found
+        const binPath = path.join(process.cwd(), "node_modules", ".bin");
+        const currentPath = process.env.PATH || "";
+        const augmentedPath = currentPath.includes(binPath) ? currentPath : `${binPath}${path.delimiter}${currentPath}`;
         const proc = (0, child_process_1.spawn)(command, [], {
             stdio: "inherit",
             shell: true,
-            env: { ...process.env, ...env },
+            env: { ...process.env, ...env, PATH: augmentedPath },
         });
         proc.on("error", (err) => {
             console.error(chalk_1.default.red(`\n  Failed to start: ${err.message}\n`));

package/dist/commands/vars.d.ts

@@ -0,0 +1,12 @@
+export interface VarsOptions {
+    file?: string;
+    module?: string;
+    json?: boolean;
+    tensors?: boolean;
+}
+export declare function varsCommand(opts: VarsOptions): Promise<void>;
+/**
+ * Show a brief post-run summary of traced variables (especially tensors).
+ * Called by `trickle run` after the user's command finishes.
+ */
+export declare function showVarsSummary(varsFile: string): void;

package/dist/commands/vars.js

@@ -0,0 +1,305 @@
+"use strict";
+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.varsCommand = varsCommand;
+exports.showVarsSummary = showVarsSummary;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function renderType(node, depth = 0) {
+    if (depth > 3)
+        return "...";
+    switch (node.kind) {
+        case "primitive":
+            return node.name || "unknown";
+        case "array":
+            return `${renderType(node.element, depth + 1)}[]`;
+        case "object": {
+            const props = node.properties || {};
+            const keys = Object.keys(props);
+            if (keys.length === 0)
+                return node.class_name || "{}";
+            // Special types
+            if (keys.length === 1 && keys[0].startsWith("__")) {
+                if (keys[0] === "__date")
+                    return "Date";
+                if (keys[0] === "__regexp")
+                    return "RegExp";
+                if (keys[0] === "__error")
+                    return "Error";
+                if (keys[0] === "__buffer")
+                    return "Buffer";
+            }
+            // Tensor / ndarray — show as "Tensor[1, 16, 32] float32"
+            if (node.class_name === "Tensor" || node.class_name === "ndarray") {
+                return renderTensorType(node.class_name, props);
+            }
+            // Named class — show as "ClassName(field=type, ...)"
+            if (node.class_name) {
+                if (keys.length > 4) {
+                    const shown = keys.slice(0, 3).map((k) => `${k}=${renderType(props[k], depth + 1)}`);
+                    return `${node.class_name}(${shown.join(", ")}, ...)`;
+                }
+                const entries = keys.map((k) => `${k}=${renderType(props[k], depth + 1)}`);
+                return `${node.class_name}(${entries.join(", ")})`;
+            }
+            if (keys.length > 4) {
+                const shown = keys.slice(0, 3).map((k) => `${k}: ${renderType(props[k], depth + 1)}`);
+                return `{ ${shown.join(", ")}, ... }`;
+            }
+            const entries = keys.map((k) => `${k}: ${renderType(props[k], depth + 1)}`);
+            return `{ ${entries.join(", ")} }`;
+        }
+        case "union":
+            return (node.members || []).map((m) => renderType(m, depth + 1)).join(" | ");
+        case "tuple":
+            return `[${(node.elements || []).map((e) => renderType(e, depth + 1)).join(", ")}]`;
+        case "promise":
+            return `Promise<${renderType(node.resolved, depth + 1)}>`;
+        case "function":
+            if (node.name && node.name !== "anonymous")
+                return `${node.name}(...)`;
+            return "Function";
+        case "map":
+            return `Map<${renderType(node.key, depth + 1)}, ${renderType(node.value, depth + 1)}>`;
+        case "set":
+            return `Set<${renderType(node.element, depth + 1)}>`;
+        default:
+            return "unknown";
+    }
+}
+/** Format a tensor type as "Tensor[1, 16, 32] float32 @cuda:0" */
+function renderTensorType(className, properties) {
+    const parts = [className];
+    const shapeProp = properties["shape"];
+    if (shapeProp?.kind === "primitive" && shapeProp.name) {
+        parts[0] = `${className}${shapeProp.name}`;
+    }
+    const dtypeProp = properties["dtype"];
+    if (dtypeProp?.kind === "primitive" && dtypeProp.name) {
+        let dtype = dtypeProp.name;
+        dtype = dtype.replace("torch.", "").replace("numpy.", "");
+        parts.push(dtype);
+    }
+    const deviceProp = properties["device"];
+    if (deviceProp?.kind === "primitive" && deviceProp.name && deviceProp.name !== "cpu") {
+        parts.push(`@${deviceProp.name}`);
+    }
+    return parts.join(" ");
+}
+/** Check if a TypeNode represents a tensor type */
+function isTensorType(node) {
+    return node.kind === "object" && (node.class_name === "Tensor" || node.class_name === "ndarray");
+}
+function renderSample(sample) {
+    if (sample === null)
+        return "null";
+    if (sample === undefined)
+        return "undefined";
+    const str = JSON.stringify(sample);
+    if (str.length > 60)
+        return str.substring(0, 57) + "...";
+    return str;
+}
+async function varsCommand(opts) {
+    const trickleDir = path.join(process.cwd(), ".trickle");
+    const varsFile = path.join(trickleDir, "variables.jsonl");
+    if (!fs.existsSync(varsFile)) {
+        console.log(chalk_1.default.yellow("\n  No variable observations found."));
+        console.log(chalk_1.default.gray("  Run your code with: trickle run <command>\n"));
+        return;
+    }
+    const content = fs.readFileSync(varsFile, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    const observations = [];
+    for (const line of lines) {
+        try {
+            const obs = JSON.parse(line);
+            if (obs.kind === "variable")
+                observations.push(obs);
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    if (observations.length === 0) {
+        console.log(chalk_1.default.yellow("\n  No variable observations found.\n"));
+        return;
+    }
+    // Filter
+    let filtered = observations;
+    if (opts.file) {
+        const fileFilter = opts.file;
+        filtered = filtered.filter((o) => o.file.includes(fileFilter) || o.module.includes(fileFilter));
+    }
+    if (opts.module) {
+        filtered = filtered.filter((o) => o.module === opts.module);
+    }
+    if (opts.tensors) {
+        filtered = filtered.filter((o) => isTensorType(o.type));
+    }
+    if (filtered.length === 0) {
+        console.log(chalk_1.default.yellow("\n  No matching variables found.\n"));
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+    // Group by file
+    const byFile = new Map();
+    for (const obs of filtered) {
+        const key = obs.file;
+        if (!byFile.has(key))
+            byFile.set(key, []);
+        byFile.get(key).push(obs);
+    }
+    // Sort each file's vars by line number
+    for (const [, vars] of byFile) {
+        vars.sort((a, b) => a.line - b.line);
+    }
+    console.log("");
+    for (const [file, vars] of byFile) {
+        // Show relative path
+        const relPath = path.relative(process.cwd(), file);
+        console.log(chalk_1.default.cyan.bold(`  ${relPath}`));
+        console.log("");
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.gray("Line"),
+                chalk_1.default.gray("Variable"),
+                chalk_1.default.gray("Type"),
+                chalk_1.default.gray("Sample Value"),
+            ],
+            style: { head: [], border: ["gray"] },
+            colWidths: [8, 20, 35, 40],
+            wordWrap: true,
+            chars: {
+                top: "─",
+                "top-mid": "┬",
+                "top-left": "┌",
+                "top-right": "┐",
+                bottom: "─",
+                "bottom-mid": "┴",
+                "bottom-left": "└",
+                "bottom-right": "┘",
+                left: "│",
+                "left-mid": "├",
+                mid: "─",
+                "mid-mid": "┼",
+                right: "│",
+                "right-mid": "┤",
+                middle: "│",
+            },
+        });
+        for (const v of vars) {
+            table.push([
+                chalk_1.default.gray(String(v.line)),
+                chalk_1.default.white.bold(v.varName),
+                chalk_1.default.green(renderType(v.type)),
+                chalk_1.default.gray(renderSample(v.sample)),
+            ]);
+        }
+        console.log(table.toString());
+        console.log("");
+    }
+    // Summary
+    const totalVars = filtered.length;
+    const totalFiles = byFile.size;
+    const tensorCount = filtered.filter((o) => isTensorType(o.type)).length;
+    const summaryParts = [`${totalVars} variable(s) across ${totalFiles} file(s)`];
+    if (tensorCount > 0) {
+        summaryParts.push(`${tensorCount} tensor(s)`);
+    }
+    console.log(chalk_1.default.gray(`  ${summaryParts.join(", ")}\n`));
+}
+/**
+ * Show a brief post-run summary of traced variables (especially tensors).
+ * Called by `trickle run` after the user's command finishes.
+ */
+function showVarsSummary(varsFile) {
+    if (!fs.existsSync(varsFile))
+        return;
+    const content = fs.readFileSync(varsFile, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    const observations = [];
+    for (const line of lines) {
+        try {
+            const obs = JSON.parse(line);
+            if (obs.kind === "variable")
+                observations.push(obs);
+        }
+        catch {
+            // skip
+        }
+    }
+    if (observations.length === 0)
+        return;
+    const tensorObs = observations.filter((o) => isTensorType(o.type));
+    const byFile = new Map();
+    for (const obs of tensorObs) {
+        if (!byFile.has(obs.file))
+            byFile.set(obs.file, []);
+        byFile.get(obs.file).push(obs);
+    }
+    // Sort by line within each file
+    for (const [, vars] of byFile) {
+        vars.sort((a, b) => a.line - b.line);
+    }
+    console.log(`  Variables traced: ${chalk_1.default.bold(String(observations.length))}`);
+    if (tensorObs.length > 0) {
+        console.log(`  Tensor variables: ${chalk_1.default.bold(String(tensorObs.length))}`);
+        console.log("");
+        // Show up to 15 most interesting tensor variables
+        const shown = [];
+        for (const [, vars] of byFile) {
+            shown.push(...vars);
+        }
+        const toShow = shown.slice(0, 15);
+        for (const obs of toShow) {
+            const relPath = path.relative(process.cwd(), obs.file);
+            const typeStr = renderType(obs.type);
+            console.log(`    ${chalk_1.default.gray(`${relPath}:${obs.line}`)} ${chalk_1.default.white.bold(obs.varName)} ${chalk_1.default.green(typeStr)}`);
+        }
+        if (shown.length > 15) {
+            console.log(chalk_1.default.gray(`    ... and ${shown.length - 15} more`));
+        }
+    }
+    console.log(chalk_1.default.gray(`  Run ${chalk_1.default.white("trickle vars")} for full details`));
+}