taist 0.1.0

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,90 @@
+{
+  "name": "taist",
+  "version": "0.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",
+    "instrument.js",
+    "testing.js",
+    "LICENSE",
+    "README.md",
+    ".taistrc.json"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./instrument": "./instrument.js",
+    "./testing": "./testing.js",
+    "./module-patcher": "./lib/module-patcher.js",
+    "./trace-collector": "./lib/trace-collector.js",
+    "./trace-reporter": "./lib/trace-reporter.js",
+    "./trace-context": "./lib/trace-context.js",
+    "./instrument-all": "./lib/instrument-all.js",
+    "./config-loader": "./lib/config-loader.js",
+    "./lib/*": "./lib/*"
+  },
+  "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",
+    "example:integration": "node examples/integration-service/run-monitored-tests.js",
+    "example:integration:watch": "node examples/integration-service/run-monitored-tests.js --watch",
+    "example:integration:trace": "node examples/integration-service/run-monitored-tests.js --trace-deep",
+    "example:integration:json": "node examples/integration-service/run-monitored-tests.js --json",
+    "example:integration:compact": "node examples/integration-service/run-monitored-tests.js --compact",
+    "example:integration:enhanced": "node examples/integration-service/run-monitored-tests-enhanced.js",
+    "verify": "./verify-tracing.sh",
+    "verify:trace": "node examples/integration-service/test-traced.js",
+    "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": "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": "^2.1.8",
+    "chokidar": "^3.5.3",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}