taist 0.1.7 → 0.1.9

package/README.md

@@ -1,7 +1,7 @@
 # Taist - AI Test Runner
 ## Token-Optimized Testing Framework for AI-Assisted Development
 
-Version: 0.1.0 | January 2025 | [Technical Specification](./SPEC.md)
+Version: 0.1.8 | January 2025 | [Technical Specification](./SPEC.md)
 
 ---
 
@@ -294,6 +294,33 @@ const service = new DynamicService();
 const traced = instrumentService(service, 'DynamicService');
 ```
 
+#### Module-Level Instrumentation
+
+When you have a module with multiple exported functions or classes, use `instrumentModule` to wrap all exports at once:
+
+```javascript
+import { instrumentModule } from 'taist/instrument';
+import * as orderServices from './services/order.js';
+
+// Wrap all exports from the module
+export const Order = instrumentModule(orderServices, 'Order');
+
+// Now all functions in Order are traced:
+// Order.createOrder() → traced as "Order.createOrder"
+// Order.getOrder()    → traced as "Order.getOrder"
+// Order.updateOrder() → traced as "Order.updateOrder"
+```
+
+This is particularly useful for:
+- **GraphQL resolvers** - Instrument all resolver functions in a module
+- **Service layers** - Wrap entire service modules without individual instrumentation
+- **Utility modules** - Trace helper functions across a module
+
+**How it works:**
+- Functions are wrapped with context-aware tracing
+- Classes are wrapped so new instances are automatically instrumented
+- Non-function exports are passed through unchanged
+
 ---
 
 ## Test Integration

package/instrument.js

@@ -46,7 +46,8 @@ import {
   instrumentDirectory,
   instrumentModules,
   wrapWithContext,
-  instrumentClassWithContext
+  instrumentClassWithContext,
+  instrumentModule
 } from './lib/instrument-all.js';
 
 // Initialize global reporter for cross-process trace collection
@@ -277,6 +278,7 @@ export {
   instrumentAll,
   instrumentDirectory,
   instrumentModules,
+  instrumentModule,
   wrapWithContext,
   startTrace,
   getContext,

package/lib/rollup-plugin.js

@@ -0,0 +1,120 @@
+/**
+ * Taist Rollup Plugin - Build-time instrumentation for bundled code
+ *
+ * Transforms source files during build to add tracing, BEFORE bundling
+ * collapses them into a single file. This enables deep tracing of internal
+ * functions within bundled applications.
+ *
+ * Usage:
+ *   import taistPlugin from 'taist/rollup-plugin';
+ *
+ *   export default {
+ *     plugins: [
+ *       taistPlugin({
+ *         include: ['src/**\/*.js'],
+ *         exclude: ['**\/*.test.js']
+ *       })
+ *     ]
+ *   };
+ */
+
+import { transformSource } from './transform.js';
+import { shouldInstrument, matchGlob, loadConfig } from './config-loader.js';
+import path from 'node:path';
+
+/**
+ * Create a Taist Rollup plugin
+ * @param {Object} options - Plugin options
+ * @param {string[]} [options.include] - Glob patterns for files to instrument
+ * @param {string[]} [options.exclude] - Glob patterns for files to skip
+ * @param {boolean} [options.enabled] - Enable/disable plugin (default: true, or TAIST_ENABLED env)
+ * @returns {import('rollup').Plugin}
+ */
+export function taistPlugin(options = {}) {
+  // Determine if enabled
+  const enabled = options.enabled ?? (process.env.TAIST_ENABLED !== 'false');
+
+  if (!enabled) {
+    return {
+      name: 'taist',
+      // No-op plugin when disabled
+    };
+  }
+
+  // Build config from options or load from file
+  let config;
+
+  return {
+    name: 'taist',
+
+    async buildStart() {
+      if (options.include || options.exclude) {
+        // Use provided options
+        config = {
+          include: options.include || ['**/*.js', '**/*.ts'],
+          exclude: options.exclude || ['**/node_modules/**', '**/*.test.*', '**/*.spec.*'],
+        };
+      } else {
+        // Load from .taistrc.json
+        config = await loadConfig();
+        if (config.include.length === 0) {
+          // Default to instrumenting src/ if no config
+          config.include = ['src/**/*.js', 'src/**/*.ts'];
+        }
+      }
+    },
+
+    transform(code, id) {
+      // Skip if no config yet
+      if (!config) {
+        return null;
+      }
+
+      // Skip node_modules
+      if (id.includes('node_modules')) {
+        return null;
+      }
+
+      // Skip non-JS/TS files
+      if (!id.match(/\.[jt]sx?$/)) {
+        return null;
+      }
+
+      // Get relative path for matching
+      const relativePath = path.relative(process.cwd(), id);
+
+      // Check include patterns
+      const included = config.include.some(pattern => matchGlob(relativePath, pattern));
+      if (!included) {
+        return null;
+      }
+
+      // Check exclude patterns
+      const excluded = config.exclude.some(pattern => matchGlob(relativePath, pattern));
+      if (excluded) {
+        return null;
+      }
+
+      try {
+        // Transform the source
+        const transformed = transformSource(code, {
+          filename: id,
+          useReporter: true,
+          // Use package paths - these should be externalized or bundled with the app
+          traceReporterPath: null, // Uses default 'taist/lib/trace-reporter.js'
+          traceContextPath: null,  // Uses default 'taist/lib/trace-context.js'
+        });
+
+        return {
+          code: transformed,
+          map: null, // TODO: Add sourcemap support
+        };
+      } catch (err) {
+        this.warn(`Failed to transform ${relativePath}: ${err.message}`);
+        return null;
+      }
+    },
+  };
+}
+
+export default taistPlugin;

package/lib/vite-plugin.js

@@ -0,0 +1,22 @@
+/**
+ * Taist Vite Plugin - Build-time instrumentation for bundled code
+ *
+ * Vite uses Rollup under the hood, so this re-exports the Rollup plugin.
+ *
+ * Usage:
+ *   import taistPlugin from 'taist/vite-plugin';
+ *
+ *   export default defineConfig({
+ *     plugins: [
+ *       taistPlugin({
+ *         include: ['src/**\/*.js'],
+ *         exclude: ['**\/*.test.js']
+ *       })
+ *     ]
+ *   });
+ */
+
+import { taistPlugin } from './rollup-plugin.js';
+
+export { taistPlugin };
+export default taistPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taist",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Token-Optimized Testing Framework for AI-Assisted Development",
   "main": "index.js",
   "type": "module",
@@ -46,6 +46,14 @@
     "./trace-context": "./lib/trace-context.js",
     "./instrument-all": "./lib/instrument-all.js",
     "./config-loader": "./lib/config-loader.js",
+    "./rollup-plugin": {
+      "types": "./types/rollup-plugin.d.ts",
+      "default": "./lib/rollup-plugin.js"
+    },
+    "./vite-plugin": {
+      "types": "./types/vite-plugin.d.ts",
+      "default": "./lib/vite-plugin.js"
+    },
     "./lib/*": "./lib/*"
   },
   "scripts": {

package/types/instrument.d.ts

@@ -199,6 +199,28 @@ export declare function instrumentModules(
   options?: InstrumentAllOptions
 ): Promise<Record<string, unknown>>;
 
+/**
+ * Instrument all exports from a module object
+ *
+ * Wraps all function exports with context-aware tracing.
+ * Classes are wrapped so new instances are automatically instrumented.
+ *
+ * @param moduleExports Module exports object (e.g., from `import * as mod from './mod.js'`)
+ * @param moduleName Module name prefix for trace names
+ * @returns Object with same keys but instrumented values
+ *
+ * @example
+ * import { instrumentModule } from 'taist/instrument';
+ * import * as orderServices from './services/order.js';
+ *
+ * export const Order = instrumentModule(orderServices, 'Order');
+ * // All functions in Order will now be traced
+ */
+export declare function instrumentModule<T extends Record<string, unknown>>(
+  moduleExports: T,
+  moduleName: string
+): T;
+
 /**
  * Wrap a function with trace context
  * @param fn Function to wrap

package/types/rollup-plugin.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Taist Rollup Plugin Type Definitions
+ */
+
+import type { Plugin } from 'rollup';
+
+/**
+ * Options for the Taist Rollup/Vite plugin
+ */
+export interface TaistPluginOptions {
+  /**
+   * Glob patterns for files to instrument.
+   * If not provided, loads from .taistrc.json or defaults to ['src/**\/*.js', 'src/**\/*.ts']
+   */
+  include?: string[];
+
+  /**
+   * Glob patterns for files to skip.
+   * Defaults to ['**\/node_modules/**', '**\/*.test.*', '**\/*.spec.*']
+   */
+  exclude?: string[];
+
+  /**
+   * Enable/disable the plugin.
+   * Defaults to true, or respects TAIST_ENABLED environment variable.
+   */
+  enabled?: boolean;
+}
+
+/**
+ * Create a Taist Rollup plugin for build-time instrumentation.
+ *
+ * Transforms source files during build to add tracing, BEFORE bundling
+ * collapses them into a single file. This enables deep tracing of internal
+ * functions within bundled applications like Directus extensions.
+ *
+ * @param options - Plugin options
+ * @returns Rollup plugin
+ *
+ * @example
+ * // rollup.config.js
+ * import taistPlugin from 'taist/rollup-plugin';
+ *
+ * export default {
+ *   input: 'src/index.js',
+ *   output: { file: 'dist/bundle.js', format: 'es' },
+ *   plugins: [
+ *     taistPlugin({
+ *       include: ['src/**\/*.js'],
+ *       exclude: ['**\/*.test.js']
+ *     })
+ *   ]
+ * };
+ */
+export function taistPlugin(options?: TaistPluginOptions): Plugin;
+
+export default taistPlugin;

package/types/vite-plugin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Taist Vite Plugin Type Definitions
+ *
+ * Re-exports the Rollup plugin types since Vite uses Rollup internally.
+ */
+
+import type { Plugin } from 'vite';
+import type { TaistPluginOptions } from './rollup-plugin';
+
+export type { TaistPluginOptions };
+
+/**
+ * Create a Taist Vite plugin for build-time instrumentation.
+ *
+ * Transforms source files during build to add tracing, BEFORE bundling
+ * collapses them into a single file. This enables deep tracing of internal
+ * functions within bundled applications like Directus extensions.
+ *
+ * @param options - Plugin options
+ * @returns Vite plugin
+ *
+ * @example
+ * // vite.config.js
+ * import { defineConfig } from 'vite';
+ * import taistPlugin from 'taist/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     taistPlugin({
+ *       include: ['src/**\/*.js'],
+ *       exclude: ['**\/*.test.js']
+ *     })
+ *   ]
+ * });
+ */
+export function taistPlugin(options?: TaistPluginOptions): Plugin;
+
+export default taistPlugin;