trickle-observe 0.2.89 → 0.2.90

package/dist/trace-var.js

@@ -238,4 +238,61 @@ if (typeof process !== 'undefined' && process.on) {
     process.on('beforeExit', exitFlush);
     process.on('SIGTERM', exitFlush);
     process.on('SIGINT', exitFlush);
+    // Capture uncaught exceptions with variable context for agent debugging.
+    // Write error + nearby variable values to errors.jsonl before the process exits.
+    process.on('uncaughtException', (err) => {
+        flushVarBuffer();
+        try {
+            const dir = varsFilePath
+                ? path.dirname(varsFilePath)
+                : process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch { }
+            const errorsFile = path.join(dir, 'errors.jsonl');
+            // Extract file and line from stack trace
+            const stackLines = (err.stack || '').split('\n');
+            let errorFile;
+            let errorLine;
+            for (const sl of stackLines.slice(1)) {
+                const m = sl.match(/\((.+):(\d+):\d+\)/) || sl.match(/at (.+):(\d+):\d+/);
+                if (m && !m[1].includes('node_modules') && !m[1].includes('node:') && !m[1].includes('trickle')) {
+                    errorFile = m[1];
+                    errorLine = parseInt(m[2]);
+                    break;
+                }
+            }
+            // Find nearby variable values from the cache
+            const nearbyVars = {};
+            if (errorFile && errorLine) {
+                for (const [key, entry] of varCache) {
+                    const parts = key.split(':');
+                    const file = parts[0];
+                    const line = parseInt(parts[1]);
+                    const varName = parts.slice(2).join(':');
+                    if (file === errorFile && Math.abs(line - errorLine) <= 10) {
+                        nearbyVars[`L${parts[1]} ${varName}`] = entry.fp;
+                    }
+                }
+            }
+            const record = {
+                kind: 'error',
+                error: err.message,
+                type: err.constructor.name,
+                file: errorFile,
+                line: errorLine,
+                stack: stackLines.slice(0, 6).join('\n'),
+                nearbyVariables: Object.keys(nearbyVars).length > 0 ? nearbyVars : undefined,
+                timestamp: new Date().toISOString(),
+            };
+            fs.appendFileSync(errorsFile, JSON.stringify(record) + '\n');
+        }
+        catch {
+            // Never suppress the original error
+        }
+        // Print the original error and exit (don't re-throw to preserve original stack)
+        console.error(err.stack || err.message);
+        process.exit(1);
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.89",
+  "version": "0.2.90",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/trace-var.ts

@@ -221,4 +221,61 @@ if (typeof process !== 'undefined' && process.on) {
   process.on('beforeExit', exitFlush);
   process.on('SIGTERM', exitFlush);
   process.on('SIGINT', exitFlush);
+
+  // Capture uncaught exceptions with variable context for agent debugging.
+  // Write error + nearby variable values to errors.jsonl before the process exits.
+  process.on('uncaughtException', (err: Error) => {
+    flushVarBuffer();
+    try {
+      const dir = varsFilePath
+        ? path.dirname(varsFilePath)
+        : process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+      try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+      const errorsFile = path.join(dir, 'errors.jsonl');
+
+      // Extract file and line from stack trace
+      const stackLines = (err.stack || '').split('\n');
+      let errorFile: string | undefined;
+      let errorLine: number | undefined;
+      for (const sl of stackLines.slice(1)) {
+        const m = sl.match(/\((.+):(\d+):\d+\)/) || sl.match(/at (.+):(\d+):\d+/);
+        if (m && !m[1].includes('node_modules') && !m[1].includes('node:') && !m[1].includes('trickle')) {
+          errorFile = m[1];
+          errorLine = parseInt(m[2]);
+          break;
+        }
+      }
+
+      // Find nearby variable values from the cache
+      const nearbyVars: Record<string, string> = {};
+      if (errorFile && errorLine) {
+        for (const [key, entry] of varCache) {
+          const parts = key.split(':');
+          const file = parts[0];
+          const line = parseInt(parts[1]);
+          const varName = parts.slice(2).join(':');
+          if (file === errorFile && Math.abs(line - errorLine) <= 10) {
+            nearbyVars[`L${parts[1]} ${varName}`] = entry.fp;
+          }
+        }
+      }
+
+      const record = {
+        kind: 'error',
+        error: err.message,
+        type: err.constructor.name,
+        file: errorFile,
+        line: errorLine,
+        stack: stackLines.slice(0, 6).join('\n'),
+        nearbyVariables: Object.keys(nearbyVars).length > 0 ? nearbyVars : undefined,
+        timestamp: new Date().toISOString(),
+      };
+      fs.appendFileSync(errorsFile, JSON.stringify(record) + '\n');
+    } catch {
+      // Never suppress the original error
+    }
+    // Print the original error and exit (don't re-throw to preserve original stack)
+    console.error(err.stack || err.message);
+    process.exit(1);
+  });
 }