trickle-cli 0.1.215 → 0.1.218

package/dist/commands/hints.d.ts

@@ -12,5 +12,6 @@
  */
 export interface HintsOptions {
     values?: boolean;
+    errors?: boolean;
 }
 export declare function hintsCommand(targetFile: string | undefined, opts: HintsOptions): Promise<void>;

package/dist/commands/hints.js

@@ -137,19 +137,35 @@ async function hintsCommand(targetFile, opts) {
         console.error("  trickle run node app.js");
         process.exit(1);
     }
-    // Load and deduplicate variable observations (last wins per file:line:varName)
+    // Load observations from variables.jsonl
     const obsMap = new Map();
+    const errorSnaps = [];
+    const targetKinds = opts.errors ? ["error_snapshot"] : ["variable"];
     for (const line of fs.readFileSync(varsFile, "utf-8").split("\n").filter(Boolean)) {
         try {
             const v = JSON.parse(line);
-            if (v.kind !== "variable")
-                continue;
-            const key = `${v.file}:${v.line}:${v.varName}`;
-            obsMap.set(key, v);
+            if (v.kind === "variable") {
+                const key = `${v.file}:${v.line}:${v.varName}`;
+                obsMap.set(key, v);
+            }
+            if (v.kind === "error_snapshot") {
+                errorSnaps.push(v);
+            }
         }
         catch { }
     }
-    const vars = [...obsMap.values()];
+    // In error mode, use error snapshots; look up original assignment lines from regular vars
+    let vars;
+    if (opts.errors) {
+        if (errorSnaps.length === 0) {
+            console.error("No error snapshots found. Run code that produces an error first.");
+            process.exit(1);
+        }
+        vars = errorSnaps;
+    }
+    else {
+        vars = [...obsMap.values()];
+    }
     // Filter by target file
     let filtered = vars;
     if (targetFile) {
@@ -163,6 +179,19 @@ async function hintsCommand(targetFile, opts) {
         console.error(targetFile ? `No observations found for "${targetFile}".` : "No observations found.");
         process.exit(1);
     }
+    // In error mode, resolve each snapshot var to its original assignment line
+    // by looking up the regular variable observations
+    if (opts.errors) {
+        for (const snap of filtered) {
+            // Find matching regular observation to get original line
+            for (const [, obs] of obsMap) {
+                if (obs.file === snap.file && obs.varName === snap.varName) {
+                    snap.line = obs.line; // use original assignment line
+                    break;
+                }
+            }
+        }
+    }
     // Group by file
     const byFile = new Map();
     for (const v of filtered) {
@@ -231,14 +260,26 @@ async function hintsCommand(targetFile, opts) {
                         lineObs.set(v.line, new Map());
                     lineObs.get(v.line).set(v.varName, v);
                 }
-                console.log(`# ${relPath}`);
+                // Print header with error info if in error mode
+                const errorMsg = fileVars.find(v => v.error)?.error;
+                const errorLine = fileVars.find(v => v.errorLine)?.errorLine;
+                if (opts.errors && errorMsg) {
+                    console.log(`# ${relPath} — ERROR`);
+                    console.log(`# ${errorMsg}${errorLine ? ` (line ${errorLine})` : ""}`);
+                    console.log(`# Variables at crash time:`);
+                }
+                else {
+                    console.log(`# ${relPath}`);
+                }
                 console.log("```python");
                 for (const [lineNo, obs] of [...lineObs.entries()].sort((a, b) => a[0] - b[0])) {
                     for (const v of obs.values()) {
                         const typeStr = typeToString(v.type);
                         const scope = v.funcName ? ` (in ${v.funcName})` : "";
-                        if (opts.values && v.sample !== undefined) {
-                            console.log(`${v.varName}: ${typeStr} = ${formatSample(v.sample)}${scope}`);
+                        const sampleStr = formatSample(v.sample);
+                        // In error mode, always show values (crash-time state)
+                        if ((opts.errors || opts.values) && v.sample !== undefined) {
+                            console.log(`${v.varName}: ${typeStr} = ${sampleStr}${scope}`);
                         }
                         else {
                             console.log(`${v.varName}: ${typeStr}${scope}`);
@@ -263,7 +304,17 @@ async function hintsCommand(targetFile, opts) {
                 lineObs.set(v.line, new Map());
             lineObs.get(v.line).set(v.varName, v);
         }
-        console.log(`# ${relPath}`);
+        // Print header with error info if in error mode
+        const errMsg = fileVars.find(v => v.error)?.error;
+        const errLine = fileVars.find(v => v.errorLine)?.errorLine;
+        if (opts.errors && errMsg) {
+            console.log(`# ${relPath} — ERROR`);
+            console.log(`# ${errMsg}${errLine ? ` (line ${errLine})` : ""}`);
+            console.log(`# Variables at crash time:`);
+        }
+        else {
+            console.log(`# ${relPath}`);
+        }
         console.log("```python");
         for (let i = 0; i < sourceLines.length; i++) {
             const lineNo = i + 1;
@@ -271,6 +322,12 @@ async function hintsCommand(targetFile, opts) {
             const obs = lineObs.get(lineNo);
             if (!obs || obs.size === 0) {
                 console.log(src);
+                // Show error underline on the error line
+                if (opts.errors && errLine && lineNo === errLine) {
+                    const indent = src.match(/^(\s*)/)?.[1] || "";
+                    const contentLen = src.trimEnd().length - indent.length;
+                    console.log(indent + "~".repeat(Math.max(contentLen, 1)) + `  ← ${errMsg}`);
+                }
                 continue;
             }
             // Insert type hints inline after variable names
@@ -314,9 +371,9 @@ async function hintsCommand(targetFile, opts) {
                     if (isFuncParam && afterVar.startsWith(":"))
                         continue;
                 }
-                // Build the hint string
+                // Build the hint string — error mode always shows values (crash-time state)
                 let hint;
-                if (opts.values && v.sample !== undefined && v.sample !== null) {
+                if ((opts.errors || opts.values) && v.sample !== undefined && v.sample !== null) {
                     const sampleStr = formatSample(v.sample);
                     hint = sampleStr ? `: ${typeStr} = ${sampleStr}` : `: ${typeStr}`;
                 }
@@ -327,6 +384,12 @@ async function hintsCommand(targetFile, opts) {
                 annotated = annotated.substring(0, varEnd) + hint + annotated.substring(varEnd);
             }
             console.log(annotated);
+            // Show error underline on the error line
+            if (opts.errors && errLine && lineNo === errLine) {
+                const indent = src.match(/^(\s*)/)?.[1] || "";
+                const contentLen = src.trimEnd().length - indent.length;
+                console.log(indent + "~".repeat(Math.max(contentLen, 1)) + `  ← ${errMsg}`);
+            }
         }
         console.log("```");
         console.log("");

package/dist/index.js

@@ -539,6 +539,7 @@ program
     .command("hints [file]")
     .description("Output source code with inline type hints from runtime observations (for AI agents)")
     .option("--values", "Include sample values alongside types")
+    .option("--errors", "Show error mode — variables at crash time with values that caused the error")
     .action(async (file, opts) => {
     await (0, hints_1.hintsCommand)(file, opts);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-cli",
-  "version": "0.1.215",
+  "version": "0.1.218",
   "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",

package/src/commands/hints.ts

@@ -16,6 +16,7 @@ import * as path from "path";
 
 export interface HintsOptions {
   values?: boolean;
+  errors?: boolean;
 }
 
 interface TypeNode {
@@ -38,6 +39,8 @@ interface VarObservation {
   type: TypeNode;
   sample?: unknown;
   funcName?: string;
+  error?: string;
+  errorLine?: number;
 }
 
 function typeToString(node: TypeNode): string {
@@ -124,17 +127,35 @@ export async function hintsCommand(
     process.exit(1);
   }
 
-  // Load and deduplicate variable observations (last wins per file:line:varName)
+  // Load observations from variables.jsonl
   const obsMap = new Map<string, VarObservation>();
+  const errorSnaps: VarObservation[] = [];
+  const targetKinds = opts.errors ? ["error_snapshot"] : ["variable"];
+
   for (const line of fs.readFileSync(varsFile, "utf-8").split("\n").filter(Boolean)) {
     try {
       const v = JSON.parse(line) as VarObservation;
-      if (v.kind !== "variable") continue;
-      const key = `${v.file}:${v.line}:${v.varName}`;
-      obsMap.set(key, v);
+      if (v.kind === "variable") {
+        const key = `${v.file}:${v.line}:${v.varName}`;
+        obsMap.set(key, v);
+      }
+      if (v.kind === "error_snapshot") {
+        errorSnaps.push(v);
+      }
     } catch {}
   }
-  const vars = [...obsMap.values()];
+
+  // In error mode, use error snapshots; look up original assignment lines from regular vars
+  let vars: VarObservation[];
+  if (opts.errors) {
+    if (errorSnaps.length === 0) {
+      console.error("No error snapshots found. Run code that produces an error first.");
+      process.exit(1);
+    }
+    vars = errorSnaps;
+  } else {
+    vars = [...obsMap.values()];
+  }
 
   // Filter by target file
   let filtered = vars;
@@ -151,6 +172,20 @@ export async function hintsCommand(
     process.exit(1);
   }
 
+  // In error mode, resolve each snapshot var to its original assignment line
+  // by looking up the regular variable observations
+  if (opts.errors) {
+    for (const snap of filtered) {
+      // Find matching regular observation to get original line
+      for (const [, obs] of obsMap) {
+        if (obs.file === snap.file && obs.varName === snap.varName) {
+          snap.line = obs.line; // use original assignment line
+          break;
+        }
+      }
+    }
+  }
+
   // Group by file
   const byFile = new Map<string, VarObservation[]>();
   for (const v of filtered) {
@@ -217,14 +252,25 @@ export async function hintsCommand(
           if (!lineObs.has(v.line)) lineObs.set(v.line, new Map());
           lineObs.get(v.line)!.set(v.varName, v);
         }
-        console.log(`# ${relPath}`);
+        // Print header with error info if in error mode
+        const errorMsg = fileVars.find(v => v.error)?.error;
+        const errorLine = fileVars.find(v => v.errorLine)?.errorLine;
+        if (opts.errors && errorMsg) {
+          console.log(`# ${relPath} — ERROR`);
+          console.log(`# ${errorMsg}${errorLine ? ` (line ${errorLine})` : ""}`);
+          console.log(`# Variables at crash time:`);
+        } else {
+          console.log(`# ${relPath}`);
+        }
         console.log("```python");
         for (const [lineNo, obs] of [...lineObs.entries()].sort((a, b) => a[0] - b[0])) {
           for (const v of obs.values()) {
             const typeStr = typeToString(v.type);
             const scope = v.funcName ? ` (in ${v.funcName})` : "";
-            if (opts.values && v.sample !== undefined) {
-              console.log(`${v.varName}: ${typeStr} = ${formatSample(v.sample)}${scope}`);
+            const sampleStr = formatSample(v.sample);
+            // In error mode, always show values (crash-time state)
+            if ((opts.errors || opts.values) && v.sample !== undefined) {
+              console.log(`${v.varName}: ${typeStr} = ${sampleStr}${scope}`);
             } else {
               console.log(`${v.varName}: ${typeStr}${scope}`);
             }
@@ -247,7 +293,16 @@ export async function hintsCommand(
       lineObs.get(v.line)!.set(v.varName, v);
     }
 
-    console.log(`# ${relPath}`);
+    // Print header with error info if in error mode
+    const errMsg = fileVars.find(v => v.error)?.error;
+    const errLine = fileVars.find(v => v.errorLine)?.errorLine;
+    if (opts.errors && errMsg) {
+      console.log(`# ${relPath} — ERROR`);
+      console.log(`# ${errMsg}${errLine ? ` (line ${errLine})` : ""}`);
+      console.log(`# Variables at crash time:`);
+    } else {
+      console.log(`# ${relPath}`);
+    }
     console.log("```python");
 
     for (let i = 0; i < sourceLines.length; i++) {
@@ -257,6 +312,12 @@ export async function hintsCommand(
 
       if (!obs || obs.size === 0) {
         console.log(src);
+        // Show error underline on the error line
+        if (opts.errors && errLine && lineNo === errLine) {
+          const indent = src.match(/^(\s*)/)?.[1] || "";
+          const contentLen = src.trimEnd().length - indent.length;
+          console.log(indent + "~".repeat(Math.max(contentLen, 1)) + `  ← ${errMsg}`);
+        }
         continue;
       }
 
@@ -302,9 +363,9 @@ export async function hintsCommand(
           if (isFuncParam && afterVar.startsWith(":")) continue;
         }
 
-        // Build the hint string
+        // Build the hint string — error mode always shows values (crash-time state)
         let hint: string;
-        if (opts.values && v.sample !== undefined && v.sample !== null) {
+        if ((opts.errors || opts.values) && v.sample !== undefined && v.sample !== null) {
           const sampleStr = formatSample(v.sample);
           hint = sampleStr ? `: ${typeStr} = ${sampleStr}` : `: ${typeStr}`;
         } else {
@@ -316,6 +377,12 @@ export async function hintsCommand(
       }
 
       console.log(annotated);
+      // Show error underline on the error line
+      if (opts.errors && errLine && lineNo === errLine) {
+        const indent = src.match(/^(\s*)/)?.[1] || "";
+        const contentLen = src.trimEnd().length - indent.length;
+        console.log(indent + "~".repeat(Math.max(contentLen, 1)) + `  ← ${errMsg}`);
+      }
     }
 
     console.log("```");

package/src/index.ts

@@ -540,7 +540,8 @@ program
   .command("hints [file]")
   .description("Output source code with inline type hints from runtime observations (for AI agents)")
   .option("--values", "Include sample values alongside types")
-  .action(async (file: string | undefined, opts: { values?: boolean }) => {
+  .option("--errors", "Show error mode — variables at crash time with values that caused the error")
+  .action(async (file: string | undefined, opts: { values?: boolean; errors?: boolean }) => {
     await hintsCommand(file, opts);
   });