taist 0.2.8 → 0.2.10

package/lib/toon-formatter.js

@@ -392,16 +392,20 @@ export class ToonFormatter {
     const maxGroups = options.maxGroups ?? 10;
     const showHeader = options.showHeader !== false;
     const debug = process.env.TAIST_DEBUG === 'true';
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
     const lines = [];
 
     if (!traces || traces.length === 0) {
       return 'No traces collected';
     }
 
-    if (debug) {
-      console.log('[formatter] Total traces:', traces.length);
-      for (const t of traces) {
-        console.log('[formatter] trace:', t.name, 'depth:', t.depth, 'correlationId:', t.correlationId);
+    if (debug || lifecycleDebug) {
+      console.log('[LIFECYCLE formatter] Total traces:', traces.length);
+      // Show all depth 0-2 traces (likely the missing resolver and intermediate calls)
+      const lowDepthTraces = traces.filter(t => t.depth <= 2);
+      console.log('[LIFECYCLE formatter] Traces with depth 0-2:', lowDepthTraces.length);
+      for (const t of lowDepthTraces) {
+        console.log('[LIFECYCLE formatter]   depth', t.depth, ':', t.name, 'correlationId:', t.correlationId);
       }
     }
 
@@ -411,12 +415,12 @@ export class ToonFormatter {
     // Group by traceId
     const groups = this.groupTracesByRequest(sorted);
 
-    if (debug) {
-      console.log('[formatter] Groups:', groups.size);
+    if (debug || lifecycleDebug) {
+      console.log('[LIFECYCLE formatter] Groups:', groups.size);
       for (const [id, groupTraces] of groups) {
-        console.log('[formatter] Group', id, ':', groupTraces.length, 'traces');
         const root = groupTraces.find(t => t.depth === 0);
-        console.log('[formatter]   root:', root?.name || 'none (using "Request")');
+        const minDepth = Math.min(...groupTraces.map(t => t.depth));
+        console.log('[LIFECYCLE formatter] Group', id, ':', groupTraces.length, 'traces, minDepth:', minDepth, 'root:', root?.name || 'none');
       }
     }
 

package/lib/trace-collector.js

@@ -121,27 +121,30 @@ export class TraceCollector extends EventEmitter {
 
   _addTrace(trace) {
     const debug = process.env.TAIST_DEBUG === 'true';
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
 
     // Generate trace ID for deduplication
     const traceId =
       trace.id || `${trace.name}-${trace.timestamp}-${trace.type}`;
 
     if (this.traceIds.has(traceId)) {
-      if (debug) {
-        console.log('[collector] DUPLICATE:', trace.name, 'id:', traceId);
+      if (debug || lifecycleDebug) {
+        console.log('[LIFECYCLE collector] DUPLICATE:', trace.name, 'id:', traceId);
       }
       return; // Duplicate
     }
 
     // Apply filter
     if (!this.filter(trace)) {
-      if (debug) {
-        console.log('[collector] FILTERED:', trace.name);
+      if (debug || lifecycleDebug) {
+        console.log('[LIFECYCLE collector] FILTERED:', trace.name);
       }
       return; // Filtered out
     }
 
-    if (debug) {
+    if (lifecycleDebug) {
+      console.log('[LIFECYCLE collector] RECEIVED:', trace.name, 'depth:', trace.depth, 'correlationId:', trace.correlationId);
+    } else if (debug) {
       console.log('[collector] RECEIVED:', trace.name, 'depth:', trace.depth, 'correlationId:', trace.correlationId);
     }
 

package/lib/trace-reporter.js

@@ -245,7 +245,13 @@ export class TraceReporter extends EventEmitter {
    * Report a single trace event
    */
   report(trace) {
-    if (this.closed) return;
+    // Use TAIST_TRACE_LIFECYCLE for detailed lifecycle logging (always via console.log)
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
+
+    if (this.closed) {
+      if (lifecycleDebug) console.log('[LIFECYCLE reporter] REJECTED (closed):', trace.name);
+      return;
+    }
 
     // Update socketPath from env if not set (env may be set after construction)
     // This handles the case where vitest-reporter sets TAIST_COLLECTOR_SOCKET
@@ -256,6 +262,10 @@ export class TraceReporter extends EventEmitter {
       this._setupExitHandlers();
     }
 
+    if (lifecycleDebug) {
+      console.log('[LIFECYCLE reporter] BUFFERED:', trace.name, 'depth:', trace.depth, 'correlationId:', trace.correlationId, 'socketPath:', this.socketPath, 'connected:', this.connected);
+    }
+
     logger.debug("[reporter] report() called:", trace.name, trace.type);
 
     this.buffer.push(trace);
@@ -280,26 +290,39 @@ export class TraceReporter extends EventEmitter {
    * Async flush - sends buffered traces to collector
    */
   async flush() {
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
+
     if (this.buffer.length === 0 || this.closed) {
+      if (lifecycleDebug && this.closed) console.log('[LIFECYCLE reporter] flush() skipped - reporter closed');
       return;
     }
 
     // Ensure connected
     if (!this.connected && this.socketPath) {
       try {
+        if (lifecycleDebug) console.log('[LIFECYCLE reporter] flush() connecting to:', this.socketPath);
         await this.connect();
-      } catch {
+      } catch (e) {
+        if (lifecycleDebug) console.log('[LIFECYCLE reporter] flush() connect failed:', e.message);
         // Connection failed, keep traces buffered
         return;
       }
     }
 
     if (!this.connected) {
+      if (lifecycleDebug) console.log('[LIFECYCLE reporter] flush() skipped - not connected, no socketPath');
       return;
     }
 
     const traces = this.buffer.splice(0, this.buffer.length);
 
+    if (lifecycleDebug) {
+      console.log('[LIFECYCLE reporter] SENDING', traces.length, 'traces to collector');
+      for (const t of traces) {
+        console.log('[LIFECYCLE reporter]   -', t.name, 'depth:', t.depth);
+      }
+    }
+
     const message = JSON.stringify({
       type: "batch",
       workerId: this.workerId,
@@ -309,6 +332,7 @@ export class TraceReporter extends EventEmitter {
     return new Promise((resolve, reject) => {
       this.socket.write(message + "\n", (err) => {
         if (err) {
+          if (lifecycleDebug) console.log('[LIFECYCLE reporter] SEND FAILED:', err.message);
           // Put traces back in buffer on failure
           this.buffer.unshift(...traces);
           reject(err);

package/lib/transform.js

@@ -317,6 +317,27 @@ const __taist_module = "${moduleName}";
   // This avoids TDZ issues with circular dependencies
   // We'll add __taist_instrumentClass() calls at the end instead of re-exporting
 
+  // For OBJECTS: Rename and re-export wrapped version (BUILD-TIME instrumentation)
+  // This is critical for GraphQL resolvers and similar nested object patterns.
+  // Runtime instrumentation doesn't work because bundlers capture the original reference.
+  for (const exp of objectExports) {
+    if (exp.declaration === "inline") {
+      // Inline exports: export const resolver = { ... }
+      // Rename: export const resolver -> const __taist_orig_resolver
+      transformed = transformed.replace(
+        new RegExp(`export\\s+const\\s+${exp.name}\\s*=\\s*\\{`, "g"),
+        `const __taist_orig_${exp.name} = {`
+      );
+    } else if (exp.declaration === "named") {
+      // Named exports: const resolver = { ... }; export { resolver }
+      // Rename: const resolver -> const __taist_orig_resolver
+      transformed = transformed.replace(
+        new RegExp(`\\b(const|let|var)\\s+${exp.name}\\s*=\\s*\\{`, "g"),
+        `$1 __taist_orig_${exp.name} = {`
+      );
+    }
+  }
+
   // For FUNCTIONS: Rename and re-export (original behavior)
   for (const exp of functionExports) {
     if (exp.declaration === "inline") {
@@ -354,10 +375,12 @@ const __taist_module = "${moduleName}";
     }
   }
 
-  // Remove named export statements for FUNCTIONS we're replacing (not classes)
+  // Remove named export statements for FUNCTIONS and OBJECTS we're replacing (not classes)
   // Match: export { Name1, Name2 } and remove names we're wrapping
   const namedFunctionExportNames = functionExports.filter(e => e.declaration === "named").map(e => e.name);
-  if (namedFunctionExportNames.length > 0) {
+  const namedObjectExportNames = objectExports.filter(e => e.declaration === "named").map(e => e.name);
+  const allNamedExportsToReplace = [...namedFunctionExportNames, ...namedObjectExportNames];
+  if (allNamedExportsToReplace.length > 0) {
     transformed = transformed.replace(
       /export\s*\{([^}]+)\}/g,
       (match, names) => {
@@ -365,7 +388,7 @@ const __taist_module = "${moduleName}";
           .map(n => n.trim())
           .filter(n => {
             const name = n.split(/\s+as\s+/)[0].trim();
-            return !namedFunctionExportNames.includes(name);
+            return !allNamedExportsToReplace.includes(name);
           });
         if (remaining.length === 0) {
           return '// export moved to end';
@@ -418,12 +441,13 @@ const __taist_module = "${moduleName}";
     })
     .join("\n");
 
-  // Add in-place instrumentation for OBJECT LITERALS (wraps nested methods)
-  // __taist_instrumentObject recursively wraps function properties
-  const objectInstrumentations = objectExports
+  // Add wrapped re-exports for OBJECTS at the end (BUILD-TIME instrumentation)
+  // This wraps nested methods like GraphQL resolvers: resolver.Mutation.upsertOrder
+  // Runtime instrumentation doesn't work because bundlers capture original references
+  const objectReexports = objectExports
     .map((exp) => {
       const nameExpr = `(__taist_module === "${exp.name}" ? "${exp.name}" : __taist_module + ".${exp.name}")`;
-      return `__taist_instrumentObject(${exp.name}, ${nameExpr});`;
+      return `export const ${exp.name} = __taist_instrumentObject(__taist_orig_${exp.name}, ${nameExpr});`;
     })
     .join("\n");
 
@@ -433,12 +457,12 @@ const __taist_module = "${moduleName}";
     transformed += `// Wrapped function exports\n${functionReexports}\n`;
   }
 
-  if (classInstrumentations) {
-    transformed += `// In-place class instrumentation (preserves hoisting)\n${classInstrumentations}\n`;
+  if (objectReexports) {
+    transformed += `// Wrapped object exports (build-time instrumentation for nested methods)\n${objectReexports}\n`;
   }
 
-  if (objectInstrumentations) {
-    transformed += `// In-place object literal instrumentation (wraps nested methods)\n${objectInstrumentations}\n`;
+  if (classInstrumentations) {
+    transformed += `// In-place class instrumentation (preserves hoisting)\n${classInstrumentations}\n`;
   }
 
   // Add default exports at the end (after the wrapped versions are defined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taist",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Token-Optimized Testing Framework for AI-Assisted Development",
   "main": "index.js",
   "type": "module",