taist 0.1.10 → 0.1.12

package/lib/config-loader.js

@@ -77,12 +77,14 @@ export function shouldInstrument(modulePath, config) {
  * Simple glob matching (supports * and **)
  */
 export function matchGlob(str, pattern) {
-  // Convert glob pattern to regex
+  // Convert glob pattern to regex using placeholders to prevent double-replacement
   const regexPattern = pattern
     .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special chars
-    .replace(/\*\*\//g, "(?:.*\\/)?") // **/ matches zero or more directories
-    .replace(/\*\*/g, ".*") // ** matches anything
-    .replace(/\*/g, "[^/]*"); // * matches any chars except /
+    .replace(/\*\*\//g, "\0ANYDIR\0")     // Placeholder for **/
+    .replace(/\*\*/g, "\0ANY\0")           // Placeholder for **
+    .replace(/\*/g, "[^/]*")               // * matches any chars except /
+    .replace(/\0ANYDIR\0/g, "(?:.*\\/)?")  // Restore **/ - matches zero or more directories
+    .replace(/\0ANY\0/g, ".*");            // Restore ** - matches anything
 
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(str);

package/lib/toon-formatter.js

@@ -70,15 +70,6 @@ export class ToonFormatter {
       });
     }
 
-    // Trace
-    if (results.trace && results.trace.length > 0) {
-      lines.push('');
-      lines.push('TRACE:');
-      results.trace.forEach(entry => {
-        lines.push(this.formatTraceEntry(entry));
-      });
-    }
-
     // Coverage
     if (results.coverage) {
       lines.push('');
@@ -154,46 +145,6 @@ export class ToonFormatter {
     return lines;
   }
 
-  /**
-   * Format trace entry with depth-based indentation for execution tree
-   */
-  formatTraceEntry(entry) {
-    const parts = [];
-
-    // Function name
-    parts.push(`fn:${this.abbreviateFunctionName(entry.name)}`);
-
-    // Duration
-    if (entry.duration !== undefined) {
-      parts.push(`ms:${Math.round(entry.duration)}`);
-    }
-
-    // Arguments (if present)
-    if (entry.args && entry.args.length > 0) {
-      const args = entry.args
-        .slice(0, this.options.maxArrayItems)
-        .map(arg => this.formatValue(arg))
-        .join(',');
-      parts.push(`args:[${args}]`);
-    }
-
-    // Return value (if present and not undefined)
-    if (entry.result !== undefined) {
-      parts.push(`ret:${this.formatValue(entry.result)}`);
-    }
-
-    // Error (if present)
-    if (entry.error) {
-      parts.push(`err:${this.cleanErrorMessage(entry.error)}`);
-    }
-
-    // Calculate indentation based on depth (2 spaces base + 2 per depth level)
-    const depth = entry.depth || 0;
-    const indent = '  ' + '  '.repeat(depth);
-
-    return `${indent}${parts.join(' ')}`;
-  }
-
   /**
    * Abbreviate function name for compact output
    */

package/lib/transform.js

@@ -30,7 +30,7 @@ export function hasExports(code) {
 /**
  * Find all exports in the source code
  * @param {string} source - Source code
- * @returns {Array<{name: string, type: 'function'|'const'|'class', declaration: string|null}>}
+ * @returns {Array<{name: string, type: 'function'|'const'|'class'|'object', declaration: string|null}>}
  */
 export function findExports(source) {
   const exports = [];
@@ -49,6 +49,16 @@ export function findExports(source) {
     exports.push({ name: match[1], type: "const", declaration: "inline" });
   }
 
+  // Match: export const name = { - object literal exports
+  // Negative lookahead to avoid matching functions/arrows already caught above
+  const objectExportRegex = /export\s+const\s+(\w+)\s*=\s*\{/g;
+  while ((match = objectExportRegex.exec(source)) !== null) {
+    const name = match[1];
+    // Skip if already found as a function/const export
+    if (exports.some(e => e.name === name)) continue;
+    exports.push({ name, type: "object", declaration: "inline" });
+  }
+
   // Match: export class ClassName
   const classExportRegex = /export\s+class\s+(\w+)/g;
   while ((match = classExportRegex.exec(source)) !== null) {
@@ -66,13 +76,14 @@ export function findExports(source) {
       const isFunction = new RegExp(`function\\s+${name}\\s*\\(`).test(source) ||
                          new RegExp(`(const|let|var)\\s+${name}\\s*=\\s*(async\\s*)?\\(`).test(source) ||
                          new RegExp(`(const|let|var)\\s+${name}\\s*=\\s*(async\\s+)?function`).test(source);
+      const isObject = new RegExp(`(const|let|var)\\s+${name}\\s*=\\s*\\{`).test(source);
 
       // Skip if already found as inline export
       if (exports.some(e => e.name === name)) continue;
 
       exports.push({
         name,
-        type: isClass ? "class" : isFunction ? "function" : "unknown",
+        type: isClass ? "class" : isFunction ? "function" : isObject ? "object" : "unknown",
         declaration: "named"
       });
     }
@@ -134,6 +145,10 @@ export function transformSource(source, moduleNameOrOptions, tracerImportPath) {
 import { getGlobalReporter as __taist_getReporter } from "${reporterPath}";
 import { getContext as __taist_getContext, runWithContext as __taist_runWithContext, generateId as __taist_generateId } from "${traceContextPath}";
 const __taist_reporter = __taist_getReporter();
+// Eagerly connect to collector if socket path is set (build-time instrumentation)
+if (process.env.TAIST_COLLECTOR_SOCKET && !__taist_reporter.isConnected()) {
+  __taist_reporter.connectEager();
+}
 const __taist_wrap = (fn, name) => {
   if (typeof fn !== 'function') return fn;
   const wrapped = function(...args) {
@@ -201,6 +216,19 @@ const __taist_instrumentClass = (cls, name) => {
   }
   return cls;
 };
+const __taist_instrumentObject = (obj, name, visited = new WeakSet()) => {
+  if (!obj || typeof obj !== 'object' || visited.has(obj)) return obj;
+  visited.add(obj);
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === 'function') {
+      obj[key] = __taist_wrap(value, name + '.' + key);
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      __taist_instrumentObject(value, name + '.' + key, visited);
+    }
+  }
+  return obj;
+};
 const __taist_module = "${moduleName}";
 // --- END TAIST ---
 
@@ -223,6 +251,20 @@ const __taist_instrumentClass = (cls, name) => {
   __taist.instrument(cls, name);
   return cls;
 };
+const __taist_instrumentObject = (obj, name, visited = new WeakSet()) => {
+  if (!__taist?.options?.enabled) return obj;
+  if (!obj || typeof obj !== 'object' || visited.has(obj)) return obj;
+  visited.add(obj);
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === 'function') {
+      obj[key] = __taist_wrap(value, name + '.' + key);
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      __taist_instrumentObject(value, name + '.' + key, visited);
+    }
+  }
+  return obj;
+};
 const __taist_module = "${moduleName}";
 // --- END TAIST ---
 
@@ -242,9 +284,10 @@ const __taist_module = "${moduleName}";
 
   let transformed = shebang + injection + sourceWithoutShebang;
 
-  // Separate classes from functions - classes need different handling to preserve hoisting
+  // Separate exports by type - each needs different handling
   const classExports = exports.filter(e => e.type === "class");
-  const functionExports = exports.filter(e => e.type !== "class");
+  const objectExports = exports.filter(e => e.type === "object");
+  const functionExports = exports.filter(e => e.type !== "class" && e.type !== "object");
 
   // For CLASSES: Keep original export, instrument in-place (preserves hoisting)
   // This avoids TDZ issues with circular dependencies
@@ -351,6 +394,15 @@ 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
+    .map((exp) => {
+      const nameExpr = `(__taist_module === "${exp.name}" ? "${exp.name}" : __taist_module + ".${exp.name}")`;
+      return `__taist_instrumentObject(${exp.name}, ${nameExpr});`;
+    })
+    .join("\n");
+
   transformed += `\n\n// --- TAIST INSTRUMENTATION ---\n`;
 
   if (functionReexports) {
@@ -361,6 +413,10 @@ const __taist_module = "${moduleName}";
     transformed += `// In-place class instrumentation (preserves hoisting)\n${classInstrumentations}\n`;
   }
 
+  if (objectInstrumentations) {
+    transformed += `// In-place object literal instrumentation (wraps nested methods)\n${objectInstrumentations}\n`;
+  }
+
   // Add default exports at the end (after the wrapped versions are defined)
   for (const name of defaultExports) {
     transformed += `export default ${name};\n`;

package/package.json

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