trickle-observe 0.2.88 → 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/observe-esm-hooks.mjs

@@ -236,6 +236,10 @@ function findVarDeclarationsESM(source) {
     const restOfLine = source.slice(match.index + match[0].length - 1, match.index + match[0].length + 200);
     if (/^\s*require\s*\(/.test(restOfLine)) continue;
 
+    // Skip variable declarations inside for-loop headers
+    const beforeDecl = source.slice(Math.max(0, match.index - 50), match.index);
+    if (/\bfor\s*\(\s*$/.test(beforeDecl)) continue;
+
     // Calculate line number where the declaration starts
     let lineNo = 1;
     for (let i = 0; i < match.index; i++) {
@@ -260,6 +264,19 @@ function findVarDeclarationsESM(source) {
       } else if (ch === '\n' && depth === 0) {
         const nextNonWs = source.slice(pos + 1).match(/^\s*(\S)/);
         if (nextNonWs && !'.+=-|&?:,'.includes(nextNonWs[1])) {
+          // Check if a recent non-empty line ends with an operator (continuation across empty lines)
+          let checkPos = pos;
+          let lastCh = '';
+          for (let back = 0; back < 5; back++) {
+            const prevNL = source.lastIndexOf('\n', checkPos - 1);
+            const prevLine = source.slice(prevNL + 1, checkPos).trimEnd();
+            if (prevLine.length > 0) { lastCh = prevLine[prevLine.length - 1]; break; }
+            checkPos = prevNL;
+            if (prevNL <= 0) break;
+          }
+          if (lastCh && '=+-*/%&|^~<>?:,({['.includes(lastCh)) {
+            pos++; continue;
+          }
           foundEnd = pos;
           break;
         }
@@ -270,6 +287,21 @@ function findVarDeclarationsESM(source) {
           else if (source[pos] === quote) break;
           pos++;
         }
+      } else if (ch === '/' && pos + 1 < source.length && source[pos + 1] !== '/' && source[pos + 1] !== '*') {
+        // Possible regex literal
+        let rp = pos - 1;
+        while (rp >= 0 && (source[rp] === ' ' || source[rp] === '\t')) rp--;
+        const rpCh = rp >= 0 ? source[rp] : '';
+        if ('=(!,;:?[{&|^~+-><%'.includes(rpCh) || source.slice(Math.max(0, rp - 5), rp + 1).match(/\b(return|typeof|instanceof|in|of|void|delete|throw|new|case)\s*$/)) {
+          pos++;
+          while (pos < source.length) {
+            if (source[pos] === '\\') pos++;
+            else if (source[pos] === '[') { pos++; while (pos < source.length && source[pos] !== ']') { if (source[pos] === '\\') pos++; pos++; } }
+            else if (source[pos] === '/') break;
+            pos++;
+          }
+          while (pos + 1 < source.length && /[gimsuy]/.test(source[pos + 1])) pos++;
+        }
       } else if (ch === '/' && pos + 1 < source.length && source[pos + 1] === '/') {
         while (pos < source.length && source[pos] !== '\n') pos++;
         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.88",
+  "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);
+  });
 }