taist 0.1.1 → 0.1.3

package/instrument.js

@@ -49,6 +49,14 @@ import {
   instrumentClassWithContext
 } from './lib/instrument-all.js';
 
+// Initialize global reporter for cross-process trace collection
+// This must happen BEFORE any instrumentation so traces are sent to collector
+const reporter = getGlobalReporter();
+if (process.env.TAIST_COLLECTOR_SOCKET) {
+  logger.log(`Connecting to trace collector: ${process.env.TAIST_COLLECTOR_SOCKET}`);
+  reporter.connectEager();
+}
+
 // Initialize global tracer from environment variables
 const tracer = new ServiceTracer({
   enabled: process.env.TAIST_ENABLED !== 'false',
@@ -62,7 +70,18 @@ const tracer = new ServiceTracer({
 });
 
 // Export for manual instrumentation
-export { tracer, autoInstrument };
+export { tracer, autoInstrument, reporter };
+
+/**
+ * Flush any buffered traces to the collector.
+ * Call this before process exit if you want to ensure all traces are sent.
+ * @returns {Promise<void>}
+ */
+export async function flushTraces() {
+  if (reporter) {
+    await reporter.flush();
+  }
+}
 
 // Log initialization
 if (tracer.options.enabled) {

package/lib/toon-formatter.js

@@ -45,10 +45,22 @@ export class ToonFormatter {
    */
   format(results) {
     const lines = [];
+    const total = results.stats?.total || 0;
+    const tests = results.tests || [];
 
     // Header
     lines.push(this.formatHeader(results));
 
+    // Show passing tests when running small batches (≤10 tests)
+    if (total > 0 && total <= 10) {
+      const passingTests = tests.filter(t => t.state === 'pass');
+      for (const test of passingTests) {
+        const duration = Math.round(test.duration);
+        const shortName = this.shortenTestName(test.name);
+        lines.push(`✓ ${shortName} (${duration}ms)`);
+      }
+    }
+
     // Failures
     if (results.failures && results.failures.length > 0) {
       lines.push('');
@@ -76,8 +88,19 @@ export class ToonFormatter {
     return lines.join('\n');
   }
 
+  /**
+   * Shorten a test name for display
+   * "Suite > Nested > actual test name" -> "actual test name"
+   */
+  shortenTestName(name) {
+    if (!name) return '';
+    const parts = name.split(' > ');
+    return parts[parts.length - 1] || name;
+  }
+
   /**
    * Format test result header
+   * Note: total represents tests that actually ran, not discovered
    */
   formatHeader(results) {
     const passed = results.stats?.passed || 0;

package/lib/vitest-reporter.js

@@ -59,6 +59,7 @@ export class TaistReporter {
     this.taskResults = new Map(); // Map task id to result
     this.results = {
       stats: { total: 0, passed: 0, failed: 0, skipped: 0 },
+      tests: [], // Individual test results for enhanced output
       failures: [],
       duration: 0,
       trace: []
@@ -117,6 +118,7 @@ export class TaistReporter {
 
     // Reset stats
     this.results.stats = { total: 0, passed: 0, failed: 0, skipped: 0 };
+    this.results.tests = [];
     this.results.failures = [];
 
     // Process all test files
@@ -181,17 +183,30 @@ export class TaistReporter {
    */
   _processTask(task, file) {
     if (task.type === 'test') {
-      this.results.stats.total++;
-
       const state = task.result?.state;
+
+      // Only count tests that actually ran (have a pass/fail result)
       if (state === 'pass') {
+        this.results.stats.total++;
         this.results.stats.passed++;
+        this.results.tests.push({
+          name: this._getTestName(task),
+          duration: task.result?.duration || 0,
+          state: 'pass'
+        });
       } else if (state === 'fail') {
+        this.results.stats.total++;
         this.results.stats.failed++;
         this.results.failures.push(this._formatFailure(task, file));
+        this.results.tests.push({
+          name: this._getTestName(task),
+          duration: task.result?.duration || 0,
+          state: 'fail'
+        });
       } else if (state === 'skip') {
         this.results.stats.skipped++;
       }
+      // Tests without state (filtered out) are not counted
     } else if (task.type === 'suite' && task.tasks) {
       // Process nested tasks
       for (const subtask of task.tasks) {

package/package.json

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

package/types/instrument.d.ts

@@ -13,6 +13,7 @@
  */
 
 import type { Application as ExpressApp } from 'express';
+import type { TraceReporter } from './trace-collector';
 
 export interface TraceContext {
   /** Call depth (0 = root) */
@@ -85,6 +86,19 @@ export declare class ServiceTracer {
  */
 export declare const tracer: ServiceTracer;
 
+/**
+ * Global reporter instance for cross-process trace collection.
+ * Automatically connects to TAIST_COLLECTOR_SOCKET if set.
+ */
+export declare const reporter: TraceReporter;
+
+/**
+ * Flush any buffered traces to the collector.
+ * Call this before process exit to ensure all traces are sent.
+ * @returns Promise that resolves when flush completes
+ */
+export declare function flushTraces(): Promise<void>;
+
 /**
  * Auto-instrument a module's exports
  * @param moduleExports Module exports object

package/types/trace-collector.d.ts

@@ -126,3 +126,89 @@ export declare function createDefaultFilter(
 ): (trace: TraceObject) => boolean;
 
 export default TraceCollector;
+
+/**
+ * TraceReporter Options
+ */
+export interface TraceReporterOptions {
+  /** Socket path to connect to (defaults to TAIST_COLLECTOR_SOCKET env var) */
+  socketPath?: string;
+  /** Number of traces to buffer before auto-flush (default: 100) */
+  batchSize?: number;
+  /** Flush interval in ms (default: 1000) */
+  flushInterval?: number;
+  /** Max connection retries (default: 3) */
+  maxRetries?: number;
+  /** Retry delay in ms (default: 100) */
+  retryDelay?: number;
+  /** Worker ID for identifying trace source */
+  workerId?: string | number;
+}
+
+/**
+ * TraceReporter - Client that runs in worker processes to send traces to the collector.
+ *
+ * Features:
+ * - Connects to collector via Unix domain socket
+ * - Buffers traces locally for batched sending
+ * - Auto-flushes on process exit
+ * - Handles connection failures gracefully
+ */
+export declare class TraceReporter extends EventEmitter {
+  constructor(options?: TraceReporterOptions);
+
+  /**
+   * Connect to the collector socket
+   */
+  connect(): Promise<void>;
+
+  /**
+   * Start connection eagerly (call at module init time)
+   */
+  connectEager(): this;
+
+  /**
+   * Report a single trace event
+   */
+  report(trace: TraceObject): void;
+
+  /**
+   * Async flush - sends buffered traces to collector
+   */
+  flush(): Promise<void>;
+
+  /**
+   * Synchronous flush for process exit - best effort
+   */
+  flushSync(): void;
+
+  /**
+   * Close the reporter connection
+   */
+  close(): void;
+
+  /**
+   * Check if connected to collector
+   */
+  isConnected(): boolean;
+
+  /**
+   * Get current buffer size
+   */
+  getBufferSize(): number;
+}
+
+/**
+ * Get or create the global reporter instance
+ */
+export declare function getGlobalReporter(options?: TraceReporterOptions): TraceReporter;
+
+/**
+ * Report a trace using the global reporter
+ */
+export declare function report(trace: TraceObject): void;
+
+/**
+ * Flush the global reporter
+ */
+export declare function flush(): Promise<void>;