agileflow 3.4.2 → 4.0.0-alpha.1

package/lib/gate-runner.js

@@ -1,282 +0,0 @@
-/**
- * AgileFlow CLI - Shared Quality Gate Library
- *
- * Reusable quality gate evaluation used by:
- * - TeammateIdle hook (teammate-idle-gate.js)
- * - TaskCompleted hook (task-completed-gate.js)
- * - Ralph Loop (ralph-loop.js)
- * - /agileflow:verify command
- *
- * Each gate returns: { passed: boolean, message: string, duration: number }
- *
- * Usage:
- *   const { evaluateGate, evaluateGates } = require('../lib/quality-gates');
- *   const result = await evaluateGate('tests', rootDir, { timeout: 300000 });
- */
-
-const { execFileSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Default gate configuration
- */
-const DEFAULT_GATE_CONFIG = {
-  tests: { enabled: true, timeout: 300000, command: null },
-  lint: { enabled: false, timeout: 60000, command: null },
-  types: { enabled: false, timeout: 60000, command: null },
-  coverage: { enabled: false, timeout: 300000, threshold: 80, command: null },
-};
-
-/**
- * Detect the test command for the project.
- * @param {string} rootDir - Project root
- * @returns {string} Test command
- */
-function detectTestCommand(rootDir) {
-  try {
-    const pkgPath = path.join(rootDir, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.scripts?.test) return 'npm test';
-    }
-  } catch (e) {
-    // Fall through
-  }
-
-  // Check for common test runners
-  if (fs.existsSync(path.join(rootDir, 'jest.config.js'))) return 'npx jest';
-  if (fs.existsSync(path.join(rootDir, 'vitest.config.ts'))) return 'npx vitest run';
-  if (fs.existsSync(path.join(rootDir, 'pytest.ini'))) return 'pytest';
-
-  return 'npm test';
-}
-
-/**
- * Detect lint command for the project.
- * @param {string} rootDir - Project root
- * @returns {string|null} Lint command or null
- */
-function detectLintCommand(rootDir) {
-  try {
-    const pkgPath = path.join(rootDir, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.scripts?.lint) return 'npm run lint';
-      if (pkg.scripts?.['lint:all']) return 'npm run lint:all';
-    }
-  } catch (e) {
-    // Fall through
-  }
-  return null;
-}
-
-/**
- * Detect type-check command for the project.
- * @param {string} rootDir - Project root
- * @returns {string|null} Type check command or null
- */
-function detectTypeCheckCommand(rootDir) {
-  try {
-    const pkgPath = path.join(rootDir, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.scripts?.typecheck) return 'npm run typecheck';
-      if (pkg.scripts?.['type-check']) return 'npm run type-check';
-    }
-  } catch (e) {
-    // Fall through
-  }
-
-  if (fs.existsSync(path.join(rootDir, 'tsconfig.json'))) {
-    return 'npx tsc --noEmit';
-  }
-  return null;
-}
-
-/**
- * Run a shell command and capture results.
- * @param {string} command - Command to run
- * @param {string} rootDir - Working directory
- * @param {number} timeout - Timeout in ms
- * @returns {{ passed: boolean, output: string, duration: number }}
- */
-function runCommand(command, rootDir, timeout) {
-  const startTime = Date.now();
-  const result = { passed: false, output: '', duration: 0 };
-
-  try {
-    const output = execFileSync('bash', ['-c', command], {
-      cwd: rootDir,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout,
-    });
-    result.passed = true;
-    result.output = output;
-  } catch (e) {
-    result.passed = false;
-    result.output = (e.stdout || '') + '\n' + (e.stderr || '');
-  }
-
-  result.duration = Date.now() - startTime;
-  return result;
-}
-
-/**
- * Evaluate a single quality gate.
- *
- * @param {string} gateName - Gate name: 'tests', 'lint', 'types', 'coverage'
- * @param {string} rootDir - Project root directory
- * @param {object} [options] - Gate options
- * @param {number} [options.timeout] - Timeout in ms
- * @param {string} [options.command] - Custom command override
- * @param {number} [options.threshold] - Coverage threshold (for 'coverage' gate)
- * @returns {{ passed: boolean, message: string, duration: number, gate: string }}
- */
-function evaluateGate(gateName, rootDir, options = {}) {
-  const timeout = options.timeout || DEFAULT_GATE_CONFIG[gateName]?.timeout || 60000;
-  let command = options.command;
-
-  switch (gateName) {
-    case 'tests': {
-      command = command || detectTestCommand(rootDir);
-      const result = runCommand(command, rootDir, timeout);
-      return {
-        gate: 'tests',
-        passed: result.passed,
-        message: result.passed
-          ? 'All tests passing'
-          : `Tests failing: ${result.output.split('\n').slice(-3).join(' ').substring(0, 200)}`,
-        duration: result.duration,
-      };
-    }
-
-    case 'lint': {
-      command = command || detectLintCommand(rootDir);
-      if (!command) {
-        return {
-          gate: 'lint',
-          passed: true,
-          message: 'No lint command found (skipped)',
-          duration: 0,
-        };
-      }
-      const result = runCommand(command, rootDir, timeout);
-      return {
-        gate: 'lint',
-        passed: result.passed,
-        message: result.passed
-          ? 'Lint passing'
-          : `Lint errors: ${result.output.split('\n').slice(-3).join(' ').substring(0, 200)}`,
-        duration: result.duration,
-      };
-    }
-
-    case 'types': {
-      command = command || detectTypeCheckCommand(rootDir);
-      if (!command) {
-        return {
-          gate: 'types',
-          passed: true,
-          message: 'No type-check command found (skipped)',
-          duration: 0,
-        };
-      }
-      const result = runCommand(command, rootDir, timeout);
-      return {
-        gate: 'types',
-        passed: result.passed,
-        message: result.passed
-          ? 'Type check passing'
-          : `Type errors: ${result.output.split('\n').slice(-3).join(' ').substring(0, 200)}`,
-        duration: result.duration,
-      };
-    }
-
-    case 'coverage': {
-      command = command || detectTestCommand(rootDir) + ' -- --coverage';
-      const threshold = options.threshold || 80;
-      const result = runCommand(command, rootDir, timeout);
-      // Coverage check is a best-effort — if tests pass, consider it passing
-      return {
-        gate: 'coverage',
-        passed: result.passed,
-        message: result.passed
-          ? `Coverage check passed (threshold: ${threshold}%)`
-          : `Coverage check failed`,
-        duration: result.duration,
-      };
-    }
-
-    default:
-      return {
-        gate: gateName,
-        passed: false,
-        message: `Unknown gate: ${gateName}`,
-        duration: 0,
-      };
-  }
-}
-
-/**
- * Evaluate multiple quality gates.
- *
- * @param {object} gateConfig - Gate configuration { tests: true, lint: true, ... }
- * @param {string} rootDir - Project root
- * @param {object} [options] - Additional options per gate
- * @returns {{ allPassed: boolean, results: Array, totalDuration: number }}
- */
-function evaluateGates(gateConfig, rootDir, options = {}) {
-  const results = [];
-  let totalDuration = 0;
-
-  for (const [gateName, enabled] of Object.entries(gateConfig)) {
-    if (!enabled) continue;
-
-    const gateOptions = options[gateName] || {};
-    const result = evaluateGate(gateName, rootDir, gateOptions);
-    results.push(result);
-    totalDuration += result.duration;
-  }
-
-  return {
-    allPassed: results.every(r => r.passed),
-    results,
-    totalDuration,
-  };
-}
-
-/**
- * Load gate configuration from agileflow-metadata.json.
- *
- * @param {string} rootDir - Project root
- * @param {string} hookName - Hook context ('teammate_idle', 'task_completed', 'ralph_loop')
- * @returns {object} Gate configuration
- */
-function loadGateConfig(rootDir, hookName) {
-  try {
-    const metadataPath = path.join(rootDir, 'docs', '00-meta', 'agileflow-metadata.json');
-    if (fs.existsSync(metadataPath)) {
-      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-      const hookConfig = metadata.quality_gates?.[hookName];
-      if (hookConfig) return hookConfig;
-    }
-  } catch (e) {
-    // Fall through to defaults
-  }
-
-  // Return defaults for the given hook
-  return DEFAULT_GATE_CONFIG;
-}
-
-module.exports = {
-  evaluateGate,
-  evaluateGates,
-  loadGateConfig,
-  detectTestCommand,
-  detectLintCommand,
-  detectTypeCheckCommand,
-  runCommand,
-  DEFAULT_GATE_CONFIG,
-};

package/lib/generator-factory.js

@@ -1,333 +0,0 @@
-/**
- * GeneratorFactory - Dependency Injection for Content Generators
- *
- * Provides a centralized factory for creating content generators with:
- * - Shared PlaceholderRegistry built once
- * - Dependency injection for testability
- * - Generator registration pattern
- *
- * Usage:
- *   const factory = new GeneratorFactory();
- *   factory.registerGenerator('help', HelpGenerator);
- *   factory.registerGenerator('readme', ReadmeGenerator);
- *
- *   // Build registry once, pass to all generators
- *   const context = await factory.buildContext();
- *   await factory.runAll(context);
- */
-
-'use strict';
-
-const { PlaceholderRegistry, createDefaultRegistry } = require('./placeholder-registry');
-const { createContainer, createScannerFactory } = require('./registry-di');
-
-/**
- * Generator interface
- * @typedef {Object} IGenerator
- * @property {string} name - Generator name
- * @property {Function} register - Register placeholders: (registry) => void
- * @property {Function} generate - Generate content: (context) => Promise<void>
- */
-
-/**
- * GeneratorFactory - Factory for creating and running generators
- */
-class GeneratorFactory {
-  /**
-   * Create a new GeneratorFactory
-   * @param {Object} options - Factory options
-   * @param {Object} [options.container] - DI container (from registry-di.js)
-   * @param {PlaceholderRegistry} [options.registry] - Pre-built registry
-   * @param {Object} [options.paths] - Path configuration
-   */
-  constructor(options = {}) {
-    this._generators = new Map();
-    this._container = options.container || createContainer();
-    this._registry = options.registry || null;
-    this._paths = options.paths || {};
-    this._built = false;
-    this._context = null;
-  }
-
-  /**
-   * Register a generator with the factory
-   * @param {string} name - Generator name
-   * @param {IGenerator|Function} generator - Generator instance or class
-   * @returns {GeneratorFactory} this for chaining
-   */
-  registerGenerator(name, generator) {
-    if (!name || typeof name !== 'string') {
-      throw new Error('Generator name must be a non-empty string');
-    }
-
-    // Support both instances and classes
-    const instance = typeof generator === 'function' ? new generator() : generator;
-
-    if (!instance.register || typeof instance.register !== 'function') {
-      throw new Error(`Generator "${name}" must have a register(registry) method`);
-    }
-
-    if (!instance.generate || typeof instance.generate !== 'function') {
-      throw new Error(`Generator "${name}" must have a generate(context) method`);
-    }
-
-    this._generators.set(name, instance);
-
-    // Reset built state when new generator is added
-    this._built = false;
-    this._context = null;
-
-    return this;
-  }
-
-  /**
-   * Unregister a generator
-   * @param {string} name - Generator name
-   * @returns {boolean} True if removed
-   */
-  unregisterGenerator(name) {
-    const result = this._generators.delete(name);
-    if (result) {
-      this._built = false;
-      this._context = null;
-    }
-    return result;
-  }
-
-  /**
-   * Get list of registered generator names
-   * @returns {string[]}
-   */
-  getGeneratorNames() {
-    return Array.from(this._generators.keys());
-  }
-
-  /**
-   * Check if a generator is registered
-   * @param {string} name - Generator name
-   * @returns {boolean}
-   */
-  hasGenerator(name) {
-    return this._generators.has(name);
-  }
-
-  /**
-   * Get the shared registry instance
-   * @returns {PlaceholderRegistry}
-   */
-  getRegistry() {
-    if (!this._registry) {
-      this._registry = createDefaultRegistry();
-    }
-    return this._registry;
-  }
-
-  /**
-   * Build context by registering all generator placeholders
-   * Registry is built once and shared across all generators
-   * @param {Object} [baseContext={}] - Base context to merge
-   * @returns {Object} Built context
-   */
-  buildContext(baseContext = {}) {
-    if (this._built && this._context) {
-      return { ...this._context, ...baseContext };
-    }
-
-    const registry = this.getRegistry();
-
-    // Let each generator register its placeholders
-    for (const [name, generator] of this._generators) {
-      try {
-        generator.register(registry);
-      } catch (error) {
-        console.error(`Failed to register placeholders for "${name}":`, error.message);
-      }
-    }
-
-    // Build context with resolved values
-    this._context = {
-      registry,
-      container: this._container,
-      paths: this._paths,
-      scanner: createScannerFactory(this._container),
-      ...baseContext,
-    };
-
-    this._built = true;
-
-    return this._context;
-  }
-
-  /**
-   * Run a specific generator
-   * @param {string} name - Generator name
-   * @param {Object} [context] - Context override
-   * @returns {Promise<{success: boolean, error?: Error}>}
-   */
-  async runGenerator(name, context) {
-    const generator = this._generators.get(name);
-
-    if (!generator) {
-      return { success: false, error: new Error(`Generator not found: ${name}`) };
-    }
-
-    const ctx = context || this.buildContext();
-
-    try {
-      await generator.generate(ctx);
-      return { success: true };
-    } catch (error) {
-      return { success: false, error };
-    }
-  }
-
-  /**
-   * Run all registered generators
-   * @param {Object} [context] - Context override
-   * @returns {Promise<Map<string, {success: boolean, error?: Error}>>}
-   */
-  async runAll(context) {
-    const ctx = context || this.buildContext();
-    const results = new Map();
-
-    for (const name of this._generators.keys()) {
-      results.set(name, await this.runGenerator(name, ctx));
-    }
-
-    return results;
-  }
-
-  /**
-   * Run generators in parallel
-   * @param {Object} [context] - Context override
-   * @returns {Promise<Map<string, {success: boolean, error?: Error}>>}
-   */
-  async runParallel(context) {
-    const ctx = context || this.buildContext();
-    const results = new Map();
-
-    const promises = Array.from(this._generators.keys()).map(async name => {
-      const result = await this.runGenerator(name, ctx);
-      return { name, result };
-    });
-
-    const settled = await Promise.allSettled(promises);
-
-    for (const item of settled) {
-      if (item.status === 'fulfilled') {
-        results.set(item.value.name, item.value.result);
-      } else {
-        // Shouldn't happen since runGenerator catches errors
-        const name = 'unknown';
-        results.set(name, { success: false, error: item.reason });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Reset the factory state
-   */
-  reset() {
-    this._built = false;
-    this._context = null;
-    this._registry = null;
-  }
-
-  /**
-   * Get container (for testing)
-   * @returns {Object}
-   */
-  getContainer() {
-    return this._container;
-  }
-}
-
-/**
- * Base generator class with common utilities
- */
-class BaseGenerator {
-  constructor(options = {}) {
-    this.name = options.name || this.constructor.name;
-    this.placeholders = [];
-  }
-
-  /**
-   * Register placeholders - override in subclass
-   * @param {PlaceholderRegistry} registry
-   */
-  register(registry) {
-    // Subclasses should override this method
-    for (const placeholder of this.placeholders) {
-      registry.register(placeholder.name, placeholder.resolver, placeholder.config);
-    }
-  }
-
-  /**
-   * Generate content - override in subclass
-   * @param {Object} context
-   * @returns {Promise<void>}
-   */
-  async generate(context) {
-    throw new Error('Subclass must implement generate(context)');
-  }
-
-  /**
-   * Helper to add a placeholder definition
-   * @param {string} name - Placeholder name
-   * @param {Function} resolver - Resolver function
-   * @param {Object} [config] - Configuration
-   */
-  addPlaceholder(name, resolver, config = {}) {
-    this.placeholders.push({ name, resolver, config });
-  }
-}
-
-/**
- * Create a factory with standard generators
- * @param {Object} options - Factory options
- * @returns {GeneratorFactory}
- */
-function createGeneratorFactory(options = {}) {
-  const factory = new GeneratorFactory(options);
-
-  // Register standard generators if provided
-  if (options.generators) {
-    for (const [name, generator] of Object.entries(options.generators)) {
-      factory.registerGenerator(name, generator);
-    }
-  }
-
-  return factory;
-}
-
-// Singleton instance
-let _factoryInstance = null;
-
-/**
- * Get singleton factory instance
- * @param {Object} [options] - Factory options
- * @returns {GeneratorFactory}
- */
-function getGeneratorFactory(options = {}) {
-  if (!_factoryInstance || options.forceNew) {
-    _factoryInstance = createGeneratorFactory(options);
-  }
-  return _factoryInstance;
-}
-
-/**
- * Reset singleton (for testing)
- */
-function resetGeneratorFactory() {
-  _factoryInstance = null;
-}
-
-module.exports = {
-  GeneratorFactory,
-  BaseGenerator,
-  createGeneratorFactory,
-  getGeneratorFactory,
-  resetGeneratorFactory,
-};