taist 1.1.0

package/lib/vitest-runner.js

@@ -0,0 +1,326 @@
+/**
+ * Vitest Runner - Execute tests and collect results
+ * Custom runner and reporter for Vitest integration
+ */
+
+import { Writable } from 'node:stream';
+import { writeFileSync, readFileSync, existsSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { startVitest } from 'vitest/node';
+import { ExecutionTracer } from './execution-tracer.js';
+import { taistPlugin } from './vitest-plugin.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Null writable stream that discards all output
+ * Used to suppress Vitest's stdout/stderr when not in verbose mode
+ */
+class NullWritable extends Writable {
+  _write(chunk, encoding, callback) {
+    callback();
+  }
+}
+
+export class VitestRunner {
+  constructor(options = {}) {
+    this.options = options;
+    this.tracer = options.tracer || new ExecutionTracer(options.trace || {});
+    this.results = null;
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Run tests
+   * @param {Object} config - Test configuration
+   * @returns {Object} Test results
+   */
+  async run(config = {}) {
+    const vitestConfig = this.buildVitestConfig(config);
+
+    // Set up trace file for cross-process trace collection
+    let traceFilePath = null;
+    if (this.options.trace?.enabled) {
+      traceFilePath = join(tmpdir(), `taist-traces-${Date.now()}.json`);
+      writeFileSync(traceFilePath, '[]');
+      process.env.TAIST_TRACE_FILE = traceFilePath;
+    }
+
+    try {
+      if (this.options.trace?.enabled) {
+        this.tracer.start();
+      }
+
+      // Create VitestOptions with stream redirection when not in verbose mode
+      const vitestOptions = {};
+      if (!this.verbose) {
+        vitestOptions.stdout = new NullWritable();
+        vitestOptions.stderr = new NullWritable();
+      }
+
+      // Add the taist plugin and setup files when tracing is enabled
+      const viteOverrides = {};
+      if (this.options.trace?.enabled) {
+        viteOverrides.plugins = [
+          taistPlugin({
+            enabled: true,
+            depth: this.options.trace?.depth || 2
+          })
+        ];
+        // Add setup file to inject tracer into test workers
+        vitestConfig.setupFiles = [
+          ...(vitestConfig.setupFiles || []),
+          join(__dirname, 'tracer-setup.js')
+        ];
+      }
+
+      const vitest = await startVitest(
+        'test',
+        [],
+        vitestConfig,
+        viteOverrides,  // Vite config with our instrumentation plugin
+        vitestOptions   // stdout/stderr stream redirection
+      );
+
+      if (!vitest) {
+        throw new Error('Failed to start Vitest');
+      }
+
+      // Wait for tests to complete
+      await vitest.close();
+
+      // Collect results
+      this.results = this.collectResults(vitest);
+
+      // Add trace data if enabled - read from trace file written by workers
+      if (this.options.trace?.enabled && traceFilePath) {
+        try {
+          if (existsSync(traceFilePath)) {
+            const traceContent = readFileSync(traceFilePath, 'utf-8');
+            this.results.trace = JSON.parse(traceContent);
+            // Clean up trace file
+            unlinkSync(traceFilePath);
+          }
+        } catch (e) {
+          // If reading traces fails, continue without them
+          this.results.trace = [];
+        }
+        this.tracer.stop();
+      }
+
+      return this.results;
+    } catch (error) {
+      return {
+        stats: {
+          total: 0,
+          passed: 0,
+          failed: 1,
+          skipped: 0
+        },
+        failures: [{
+          test: 'Test execution',
+          error: error.message,
+          stack: error.stack
+        }],
+        duration: 0
+      };
+    }
+  }
+
+  /**
+   * Build Vitest configuration
+   */
+  buildVitestConfig(config) {
+    const include = config.tests || config.test || ['**/*.test.js', '**/*.spec.js'];
+    const includeArray = Array.isArray(include) ? include : [include];
+
+    const vitestConfig = {
+      include: includeArray,
+      watch: false,
+      reporters: [],  // No reporters to suppress output
+      ui: false,
+      outputFile: false,
+      logHeapUsage: false,
+      maxConcurrency: 1,
+      silent: true,
+      // When tracing is enabled, run tests in main thread to share globalThis
+      ...(this.options.trace?.enabled ? {
+        pool: 'forks',
+        poolOptions: {
+          forks: {
+            singleFork: true
+          }
+        },
+        isolate: false
+      } : {}),
+      ...config
+    };
+
+    // Only add coverage if explicitly enabled
+    if (this.options.coverage === true) {
+      vitestConfig.coverage = {
+        enabled: true,
+        reporter: ['json-summary'],
+        all: true,
+        ...this.options.coverage
+      };
+    }
+
+    return vitestConfig;
+  }
+
+  /**
+   * Collect results from Vitest
+   */
+  collectResults(vitest) {
+    const state = vitest.state;
+    const files = state.getFiles();
+
+    const stats = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0
+    };
+
+    const failures = [];
+    let totalDuration = 0;
+
+    // Process all test files
+    for (const file of files) {
+      const tasks = this.getAllTasks(file);
+
+      for (const task of tasks) {
+        if (task.type !== 'test') continue;
+
+        stats.total++;
+
+        if (task.result?.state === 'pass') {
+          stats.passed++;
+        } else if (task.result?.state === 'fail') {
+          stats.failed++;
+          failures.push(this.formatFailure(task, file));
+        } else if (task.result?.state === 'skip') {
+          stats.skipped++;
+        }
+
+        if (task.result?.duration) {
+          totalDuration += task.result.duration;
+        }
+      }
+    }
+
+    const results = {
+      stats,
+      failures,
+      duration: totalDuration
+    };
+
+    // Add coverage if available
+    if (vitest.coverageProvider) {
+      results.coverage = this.extractCoverage(vitest);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get all tasks from a file recursively
+   */
+  getAllTasks(file) {
+    const tasks = [];
+
+    const collect = (task) => {
+      tasks.push(task);
+      if (task.tasks) {
+        task.tasks.forEach(collect);
+      }
+    };
+
+    collect(file);
+    return tasks;
+  }
+
+  /**
+   * Format a test failure
+   */
+  formatFailure(task, file) {
+    const error = task.result?.errors?.[0] || task.result?.error;
+
+    const failure = {
+      test: this.getTestName(task),
+      location: this.getLocation(task, file)
+    };
+
+    if (error) {
+      failure.error = error.message || String(error);
+      failure.stack = error.stack;
+
+      // Extract diff if available
+      if (error.actual !== undefined || error.expected !== undefined) {
+        failure.diff = {
+          expected: error.expected,
+          actual: error.actual
+        };
+      }
+    }
+
+    return failure;
+  }
+
+  /**
+   * Get full test name
+   */
+  getTestName(task) {
+    const names = [];
+    let current = task;
+
+    while (current) {
+      if (current.name && current.type !== 'file') {
+        names.unshift(current.name);
+      }
+      current = current.suite;
+    }
+
+    return names.join(' > ') || task.name;
+  }
+
+  /**
+   * Get test location
+   */
+  getLocation(task, file) {
+    if (task.location) {
+      return {
+        file: file.filepath || file.name,
+        line: task.location.line,
+        column: task.location.column
+      };
+    }
+
+    return file.filepath || file.name;
+  }
+
+  /**
+   * Extract coverage information
+   */
+  extractCoverage(vitest) {
+    // This would extract coverage from vitest.coverageProvider
+    // For now, return placeholder
+    return {
+      percent: 0,
+      covered: 0,
+      total: 0
+    };
+  }
+
+  /**
+   * Get results
+   */
+  getResults() {
+    return this.results;
+  }
+}
+
+export default VitestRunner;

package/lib/watch-handler.js

@@ -0,0 +1,300 @@
+/**
+ * Watch Handler - File watching and incremental test runs
+ * Enables iterative development with AI tools
+ */
+
+import chokidar from 'chokidar';
+import { EventEmitter } from 'events';
+
+export class WatchHandler extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.options = {
+      ignore: options.ignore || ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+      delay: options.delay || 500,
+      maxHistory: options.maxHistory || 10,
+      ...options
+    };
+
+    this.watcher = null;
+    this.history = [];
+    this.iteration = 0;
+    this.isRunning = false;
+    this.debounceTimer = null;
+    this.changedFiles = new Set();
+    this.lastResults = null;
+  }
+
+  /**
+   * Start watching files
+   * @param {Array} paths - Paths to watch
+   * @param {Function} onRun - Callback to run tests
+   */
+  async start(paths, onRun) {
+    if (this.watcher) {
+      throw new Error('Watch handler already started');
+    }
+
+    this.onRun = onRun;
+
+    const watchPaths = Array.isArray(paths) ? paths : [paths];
+
+    this.watcher = chokidar.watch(watchPaths, {
+      ignored: this.options.ignore,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 100
+      }
+    });
+
+    this.watcher
+      .on('change', (path) => this.handleChange(path))
+      .on('add', (path) => this.handleChange(path))
+      .on('unlink', (path) => this.handleChange(path))
+      .on('error', (error) => this.emit('error', error));
+
+    // Run initial tests
+    await this.runTests([]);
+
+    this.emit('ready');
+  }
+
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+
+  /**
+   * Handle file change
+   */
+  handleChange(path) {
+    this.changedFiles.add(path);
+
+    // Debounce test runs
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(() => {
+      const changes = Array.from(this.changedFiles);
+      this.changedFiles.clear();
+      this.runTests(changes);
+    }, this.options.delay);
+  }
+
+  /**
+   * Run tests
+   */
+  async runTests(changes) {
+    if (this.isRunning) {
+      return;
+    }
+
+    this.isRunning = true;
+    this.iteration++;
+
+    const startTime = Date.now();
+
+    try {
+      this.emit('run-start', { iteration: this.iteration, changes });
+
+      const results = await this.onRun();
+
+      const duration = Date.now() - startTime;
+
+      // Create history entry
+      const entry = this.createHistoryEntry(results, changes, duration);
+      this.addToHistory(entry);
+
+      // Store results for comparison
+      this.lastResults = results;
+
+      this.emit('run-complete', {
+        iteration: this.iteration,
+        results,
+        changes,
+        duration,
+        history: entry
+      });
+    } catch (error) {
+      this.emit('run-error', {
+        iteration: this.iteration,
+        error,
+        changes
+      });
+    } finally {
+      this.isRunning = false;
+    }
+  }
+
+  /**
+   * Create history entry
+   */
+  createHistoryEntry(results, changes, duration) {
+    const summary = {
+      pass: results.stats?.passed || 0,
+      fail: results.stats?.failed || 0,
+      total: results.stats?.total || 0
+    };
+
+    // Compare with previous results
+    if (this.lastResults) {
+      summary.new_failures = this.findNewFailures(results, this.lastResults);
+      summary.fixed = this.findFixedTests(results, this.lastResults);
+    } else {
+      summary.new_failures = [];
+      summary.fixed = [];
+    }
+
+    // Extract key errors (top 3)
+    summary.key_errors = (results.failures || [])
+      .slice(0, 3)
+      .map(f => this.extractErrorMessage(f));
+
+    return {
+      iteration: this.iteration,
+      timestamp: new Date().toISOString(),
+      changes,
+      summary,
+      duration
+    };
+  }
+
+  /**
+   * Find new failures
+   */
+  findNewFailures(current, previous) {
+    const currentFailures = new Set(
+      (current.failures || []).map(f => f.test)
+    );
+    const previousFailures = new Set(
+      (previous.failures || []).map(f => f.test)
+    );
+
+    return Array.from(currentFailures).filter(test => !previousFailures.has(test));
+  }
+
+  /**
+   * Find fixed tests
+   */
+  findFixedTests(current, previous) {
+    const currentFailures = new Set(
+      (current.failures || []).map(f => f.test)
+    );
+    const previousFailures = new Set(
+      (previous.failures || []).map(f => f.test)
+    );
+
+    return Array.from(previousFailures).filter(test => !currentFailures.has(test));
+  }
+
+  /**
+   * Extract error message
+   */
+  extractErrorMessage(failure) {
+    if (failure.error) {
+      if (typeof failure.error === 'string') return failure.error;
+      if (failure.error.message) return failure.error.message;
+      return String(failure.error);
+    }
+    return 'Unknown error';
+  }
+
+  /**
+   * Add entry to history
+   */
+  addToHistory(entry) {
+    this.history.push(entry);
+
+    // Keep only recent history
+    if (this.history.length > this.options.maxHistory) {
+      this.history.shift();
+    }
+  }
+
+  /**
+   * Get history
+   */
+  getHistory() {
+    return this.history;
+  }
+
+  /**
+   * Get summary of recent iterations
+   */
+  getSummary(count = 5) {
+    const recent = this.history.slice(-count);
+
+    return {
+      iterations: recent.length,
+      current: recent[recent.length - 1],
+      trend: this.analyzeTrend(recent)
+    };
+  }
+
+  /**
+   * Analyze trend in test results
+   */
+  analyzeTrend(entries) {
+    if (entries.length < 2) {
+      return 'stable';
+    }
+
+    const first = entries[0].summary.fail;
+    const last = entries[entries.length - 1].summary.fail;
+
+    if (last < first) return 'improving';
+    if (last > first) return 'degrading';
+    return 'stable';
+  }
+
+  /**
+   * Get formatted history for output
+   */
+  formatHistory(count = 3) {
+    const recent = this.history.slice(-count);
+
+    return recent.map(entry => {
+      const lines = [];
+      lines.push(`[${entry.iteration}] ${entry.summary.pass}/${entry.summary.total}`);
+
+      if (entry.summary.new_failures.length > 0) {
+        lines.push(`  New: ${entry.summary.new_failures.join(', ')}`);
+      }
+
+      if (entry.summary.fixed.length > 0) {
+        lines.push(`  Fixed: ${entry.summary.fixed.join(', ')}`);
+      }
+
+      if (entry.summary.key_errors.length > 0) {
+        lines.push(`  Errors: ${entry.summary.key_errors[0]}`);
+      }
+
+      return lines.join('\n');
+    }).join('\n\n');
+  }
+
+  /**
+   * Clear history
+   */
+  clearHistory() {
+    this.history = [];
+    this.iteration = 0;
+    this.lastResults = null;
+  }
+}
+
+export default WatchHandler;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "taist",
+  "version": "1.1.0",
+  "description": "Token-Optimized Testing Framework for AI-Assisted Development",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "taist": "taist.js"
+  },
+  "files": [
+    "lib/",
+    "index.js",
+    "taist.js",
+    "LICENSE",
+    "README.md",
+    ".taistrc.json"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run test/unit",
+    "test:integration": "vitest run test/integration",
+    "test:coverage": "vitest run --coverage",
+    "test:ai": "node taist.js test --format toon",
+    "test:ai:watch": "node taist.js watch",
+    "test:ai:trace": "node taist.js test --trace --depth 3",
+    "demo": "node taist.js test -t ./examples/calculator.test.js",
+    "demo:json": "node taist.js test -t ./examples/calculator.test.js --format json",
+    "demo:compact": "node taist.js test -t ./examples/calculator.test.js --format compact",
+    "demo:failing": "node taist.js test -t ./examples/failing.test.js || true",
+    "prepublishOnly": "npm run test"
+  },
+  "keywords": [
+    "testing",
+    "ai",
+    "tdd",
+    "vitest",
+    "token-optimized",
+    "llm",
+    "claude",
+    "copilot",
+    "ai-testing",
+    "test-runner",
+    "toon"
+  ],
+  "author": "David Purkiss",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidpurkiss/taist.git"
+  },
+  "bugs": {
+    "url": "https://github.com/davidpurkiss/taist/issues"
+  },
+  "homepage": "https://github.com/davidpurkiss/taist#readme",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "vitest": "^1.0.4",
+    "chokidar": "^3.5.3",
+    "picocolors": "^1.0.0",
+    "acorn": "^8.11.0",
+    "estree-walker": "^3.0.3",
+    "magic-string": "^0.30.5"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^1.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}