chati-dev 4.3.1 → 4.4.0

package/src/gates/circuit-breaker.js

@@ -1,151 +0,0 @@
-/**
- * @fileoverview Circuit Breaker pattern for quality gate evaluation.
- *
- * Prevents repeated failures from consuming resources by tracking
- * consecutive failures and temporarily stopping execution.
- *
- * States:
- *   CLOSED   — Normal operation, requests flow through
- *   OPEN     — Failures exceeded threshold, requests rejected immediately
- *   HALF_OPEN — After reset timeout, allows a single test request
- */
-
-import { track as telemetryTrack } from '../telemetry/collector.js';
-
-export const CIRCUIT_STATES = {
-  CLOSED: 'CLOSED',
-  OPEN: 'OPEN',
-  HALF_OPEN: 'HALF_OPEN',
-};
-
-export class CircuitBreaker {
-  /**
-   * @param {object} [options]
-   * @param {number} [options.failureThreshold=3] - Consecutive failures before opening
-   * @param {number} [options.resetTimeout=60000] - Milliseconds before trying recovery
-   */
-  constructor(options = {}) {
-    this.failureThreshold = options.failureThreshold ?? 3;
-    this.resetTimeout = options.resetTimeout ?? 60000;
-
-    this._state = CIRCUIT_STATES.CLOSED;
-    this._failures = 0;
-    this._successes = 0;
-    this._lastFailure = null;
-    this._lastSuccess = null;
-  }
-
-  /**
-   * Execute a function through the circuit breaker.
-   *
-   * @param {Function} fn - Function to execute (may be async)
-   * @returns {*} Result from fn
-   * @throws {Error} If circuit is OPEN and timeout has not elapsed
-   */
-  execute(fn) {
-    if (this._state === CIRCUIT_STATES.OPEN) {
-      // Check if reset timeout has elapsed
-      const elapsed = Date.now() - (this._lastFailure || 0);
-      if (elapsed >= this.resetTimeout) {
-        this._state = CIRCUIT_STATES.HALF_OPEN;
-      } else {
-        throw new Error('Circuit breaker is OPEN. Request rejected.');
-      }
-    }
-
-    try {
-      const result = fn();
-      this._onSuccess();
-      return result;
-    } catch (error) {
-      this._onFailure();
-      throw error;
-    }
-  }
-
-  /**
-   * Execute an async function through the circuit breaker.
-   * @param {Function} fn - Async function to execute
-   * @returns {Promise<*>} Result from fn
-   */
-  async executeAsync(fn) {
-    if (this._state === CIRCUIT_STATES.OPEN) {
-      const elapsed = Date.now() - (this._lastFailure || 0);
-      if (elapsed >= this.resetTimeout) {
-        this._state = CIRCUIT_STATES.HALF_OPEN;
-      } else {
-        throw new Error('Circuit breaker is OPEN. Request rejected.');
-      }
-    }
-
-    try {
-      const result = await fn();
-      this._onSuccess();
-      return result;
-    } catch (error) {
-      this._onFailure();
-      throw error;
-    }
-  }
-
-  /** @private */
-  _onSuccess() {
-    this._successes++;
-    this._lastSuccess = Date.now();
-
-    if (this._state === CIRCUIT_STATES.HALF_OPEN) {
-      // Recovery confirmed — close the circuit
-      this._state = CIRCUIT_STATES.CLOSED;
-      this._failures = 0;
-    }
-  }
-
-  /** @private */
-  _onFailure() {
-    this._failures++;
-    this._lastFailure = Date.now();
-
-    if (this._state === CIRCUIT_STATES.HALF_OPEN) {
-      // Recovery failed — reopen
-      this._state = CIRCUIT_STATES.OPEN;
-    } else if (this._failures >= this.failureThreshold) {
-      this._state = CIRCUIT_STATES.OPEN;
-      telemetryTrack('circuit_breaker_triggered', {
-        trigger: 'failure_threshold',
-        agent: 'unknown',
-        provider: 'unknown',
-      });
-    }
-  }
-
-  /**
-   * Get current circuit state.
-   * @returns {'CLOSED' | 'OPEN' | 'HALF_OPEN'}
-   */
-  getState() {
-    return this._state;
-  }
-
-  /**
-   * Get circuit statistics.
-   * @returns {{ state: string, failures: number, successes: number, lastFailure: number|null, lastSuccess: number|null }}
-   */
-  getStats() {
-    return {
-      state: this._state,
-      failures: this._failures,
-      successes: this._successes,
-      lastFailure: this._lastFailure,
-      lastSuccess: this._lastSuccess,
-    };
-  }
-
-  /**
-   * Manually reset the circuit breaker to CLOSED state.
-   */
-  reset() {
-    this._state = CIRCUIT_STATES.CLOSED;
-    this._failures = 0;
-    this._lastFailure = null;
-  }
-}

package/src/gates/g1-planning-complete.js

@@ -1,154 +0,0 @@
-/**
- * @fileoverview G1 — Plan Complete Gate
- *
- * Pre-BUILD gate that validates the PLAN phase is fully completed.
- * Checks that all required artifacts exist and QA-Planning has approved.
- */
-
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-import { GateBase } from './gate-base.js';
-import { loadSession } from '../orchestrator/session-manager.js';
-import { loadHandoff } from '../tasks/handoff.js';
-
-const REQUIRED_ARTIFACTS = [
-  { key: 'brief', dir: '1-Brief', label: 'Brief artifact' },
-  { key: 'prd', dir: '2-PRD', label: 'PRD artifact' },
-  { key: 'architecture', dir: '3-Architecture', label: 'Architecture artifact' },
-  { key: 'ux', dir: '4-UX', label: 'UX artifact' },
-  { key: 'phases', dir: '5-Phases', label: 'Phases artifact' },
-  { key: 'tasks', dir: '6-Tasks', label: 'Tasks artifact' },
-];
-
-export class PlanningCompleteGate extends GateBase {
-  constructor() {
-    super({
-      id: 'g1-planning-complete',
-      name: 'Planning Complete',
-      pipelinePoint: 'pre-build',
-      agent: 'qa-planning',
-    });
-  }
-
-  /**
-   * Collect evidence by checking filesystem for PLAN artifacts.
-   *
-   * @param {string} projectDir
-   * @returns {object} Evidence about artifact presence, session state, and handoff
-   */
-  _collectEvidence(projectDir) {
-    const artifactsBase = join(projectDir, resolveFrameworkDir(projectDir), 'artifacts');
-    const evidence = {
-      artifacts: {},
-      sessionState: null,
-      qaPlanningHandoff: null,
-    };
-
-    // Check each required artifact directory
-    for (const artifact of REQUIRED_ARTIFACTS) {
-      const dirPath = join(artifactsBase, artifact.dir);
-      const exists = existsSync(dirPath);
-      let hasContent = false;
-
-      if (exists) {
-        try {
-          const entries = readdirSync(dirPath);
-          hasContent = entries.length > 0;
-        } catch { /* expected: directory may not exist */
-          hasContent = false;
-        }
-      }
-
-      evidence.artifacts[artifact.key] = {
-        exists,
-        hasContent,
-        label: artifact.label,
-      };
-    }
-
-    // Check session state
-    const sessionResult = loadSession(projectDir);
-    if (sessionResult.loaded && sessionResult.session) {
-      evidence.sessionState = {
-        mode: sessionResult.session.mode,
-        completedAgents: sessionResult.session.completed_agents || [],
-        agents: sessionResult.session.agents || {},
-      };
-    }
-
-    // Check QA-Planning handoff
-    const handoffResult = loadHandoff(projectDir, 'qa-planning');
-    if (handoffResult.loaded && handoffResult.handoff) {
-      evidence.qaPlanningHandoff = {
-        score: handoffResult.handoff.score,
-        status: handoffResult.handoff.status,
-        blockers: handoffResult.handoff.blockers || [],
-      };
-    }
-
-    return evidence;
-  }
-
-  /**
-   * Validate evidence and produce a score.
-   *
-   * @param {object} evidence
-   * @returns {{ score: number, criteriaResults: string[], allCriteria: string[], warnings: string[] }}
-   */
-  _validateEvidence(evidence) {
-    const allCriteria = [
-      ...REQUIRED_ARTIFACTS.map(a => `${a.label} exists`),
-      'QA-Planning handoff with passing score',
-      'Session shows plan completed',
-    ];
-
-    const criteriaResults = [];
-    const warnings = [];
-
-    // Check artifacts
-    for (const artifact of REQUIRED_ARTIFACTS) {
-      const info = evidence.artifacts[artifact.key];
-      if (info && info.exists && info.hasContent) {
-        criteriaResults.push(`${artifact.label} exists`);
-      } else if (info && info.exists) {
-        warnings.push(`${artifact.label} directory exists but is empty`);
-      }
-    }
-
-    // Check QA-Planning handoff score
-    if (evidence.qaPlanningHandoff) {
-      if (evidence.qaPlanningHandoff.score >= 95) {
-        criteriaResults.push('QA-Planning handoff with passing score');
-      } else {
-        warnings.push(`QA-Planning score ${evidence.qaPlanningHandoff.score} below 95 threshold`);
-      }
-
-      if (evidence.qaPlanningHandoff.blockers.length > 0) {
-        warnings.push(`${evidence.qaPlanningHandoff.blockers.length} blocker(s) from QA-Planning`);
-      }
-    }
-
-    // Check session state
-    if (evidence.sessionState) {
-      const planAgents = ['brief', 'detail', 'architect', 'ux', 'phases', 'tasks', 'qa-planning'];
-      const completed = planAgents.filter(a =>
-        evidence.sessionState.completedAgents.includes(a)
-      );
-
-      if (completed.length === planAgents.length) {
-        criteriaResults.push('Session shows plan completed');
-      } else {
-        const missing = planAgents.filter(a => !completed.includes(a));
-        warnings.push(`Incomplete plan agents: ${missing.join(', ')}`);
-      }
-    }
-
-    // Calculate score
-    const score = allCriteria.length > 0
-      ? Math.round((criteriaResults.length / allCriteria.length) * 100)
-      : 0;
-
-    return { score, criteriaResults, allCriteria, warnings };
-  }
-}

package/src/gates/g2-qa-planning.js

@@ -1,156 +0,0 @@
-/**
- * @fileoverview G2 — QA Planning Gate
- *
- * Post-QA-Planning gate that validates the test strategy and
- * quality plan are properly defined before BUILD begins.
- */
-
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-import { GateBase, determineVerdict } from './gate-base.js';
-import { loadSession } from '../orchestrator/session-manager.js';
-import { loadHandoff } from '../tasks/handoff.js';
-
-export class QAPlanningGate extends GateBase {
-  constructor() {
-    super({
-      id: 'g2-qa-planning',
-      name: 'QA Planning',
-      pipelinePoint: 'post-qa-planning',
-      agent: 'qa-planning',
-    });
-  }
-
-  /**
-   * Collect evidence about QA planning artifacts.
-   *
-   * @param {string} projectDir
-   * @returns {object} Evidence about test strategy, coverage plan, risk assessment
-   */
-  _collectEvidence(projectDir) {
-    const artifactsBase = join(projectDir, resolveFrameworkDir(projectDir), 'artifacts');
-    const evidence = {
-      testStrategy: false,
-      coveragePlan: false,
-      riskAssessment: false,
-      qaPlanningHandoff: null,
-      sessionState: null,
-    };
-
-    // Check for QA-Planning artifacts (may be in a qa-planning folder or 7-QA-Planning)
-    const qaDirs = ['7-QA-Planning', 'qa-planning'];
-    for (const dir of qaDirs) {
-      const qaPath = join(artifactsBase, dir);
-      if (existsSync(qaPath)) {
-        try {
-          const entries = readdirSync(qaPath);
-          for (const entry of entries) {
-            const lower = entry.toLowerCase();
-            if (lower.includes('strategy') || lower.includes('test-plan')) {
-              evidence.testStrategy = true;
-            }
-            if (lower.includes('coverage')) {
-              evidence.coveragePlan = true;
-            }
-            if (lower.includes('risk')) {
-              evidence.riskAssessment = true;
-            }
-          }
-        } catch { /* expected: operation may fail gracefully */
-          // Directory read failed, leave as false
-        }
-      }
-    }
-
-    // Load QA-Planning handoff
-    const handoffResult = loadHandoff(projectDir, 'qa-planning');
-    if (handoffResult.loaded && handoffResult.handoff) {
-      evidence.qaPlanningHandoff = {
-        score: handoffResult.handoff.score,
-        status: handoffResult.handoff.status,
-        outputs: handoffResult.handoff.outputs || [],
-        criteriaUnmet: handoffResult.handoff.criteria_unmet || [],
-      };
-
-      // Handoff outputs may indicate strategy/coverage/risk exist
-      for (const output of evidence.qaPlanningHandoff.outputs) {
-        const lower = (typeof output === 'string' ? output : '').toLowerCase();
-        if (lower.includes('strategy') || lower.includes('test-plan')) {
-          evidence.testStrategy = true;
-        }
-        if (lower.includes('coverage')) {
-          evidence.coveragePlan = true;
-        }
-        if (lower.includes('risk')) {
-          evidence.riskAssessment = true;
-        }
-      }
-    }
-
-    // Load session state
-    const sessionResult = loadSession(projectDir);
-    if (sessionResult.loaded && sessionResult.session) {
-      evidence.sessionState = {
-        qaPlanningAgent: sessionResult.session.agents?.['qa-planning'] || null,
-        completedAgents: sessionResult.session.completed_agents || [],
-      };
-    }
-
-    return evidence;
-  }
-
-  /**
-   * Validate QA planning evidence.
-   *
-   * @param {object} evidence
-   * @returns {{ score: number, criteriaResults: string[], allCriteria: string[], warnings: string[] }}
-   */
-  _validateEvidence(evidence) {
-    const allCriteria = [
-      'Test strategy document exists',
-      'Coverage plan exists',
-      'Risk assessment documented',
-      'QA-Planning handoff with score >= 95',
-      'All QA-Planning criteria met',
-    ];
-
-    const criteriaResults = [];
-    const warnings = [];
-
-    if (evidence.testStrategy) {
-      criteriaResults.push('Test strategy document exists');
-    }
-
-    if (evidence.coveragePlan) {
-      criteriaResults.push('Coverage plan exists');
-    }
-
-    if (evidence.riskAssessment) {
-      criteriaResults.push('Risk assessment documented');
-    }
-
-    // Check handoff score
-    if (evidence.qaPlanningHandoff) {
-      if (evidence.qaPlanningHandoff.score >= 95) {
-        criteriaResults.push('QA-Planning handoff with score >= 95');
-      } else {
-        warnings.push(`QA-Planning score: ${evidence.qaPlanningHandoff.score} (need >= 95)`);
-      }
-
-      if (evidence.qaPlanningHandoff.criteriaUnmet.length === 0) {
-        criteriaResults.push('All QA-Planning criteria met');
-      } else {
-        warnings.push(`${evidence.qaPlanningHandoff.criteriaUnmet.length} unmet criteria`);
-      }
-    }
-
-    const score = allCriteria.length > 0
-      ? Math.round((criteriaResults.length / allCriteria.length) * 100)
-      : 0;
-
-    const verdict = determineVerdict(score, 95);
-
-    return { score, criteriaResults, allCriteria, warnings, verdict };
-  }
-}

package/src/gates/g3-implementation.js

@@ -1,215 +0,0 @@
-/**
- * @fileoverview G3 — Implementation Gate
- *
- * Post-Dev gate that validates implementation quality.
- * Checks that all dev tasks are completed, tests exist alongside
- * source files, lint passes, and no security issues are flagged.
- */
-
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-import { GateBase } from './gate-base.js';
-import { loadSession } from '../orchestrator/session-manager.js';
-import { loadHandoff } from '../tasks/handoff.js';
-
-export class ImplementationGate extends GateBase {
-  constructor() {
-    super({
-      id: 'g3-implementation',
-      name: 'Implementation Quality',
-      pipelinePoint: 'post-dev',
-      agent: 'dev',
-    });
-  }
-
-  /**
-   * Collect evidence about implementation completeness and quality.
-   *
-   * @param {string} projectDir
-   * @returns {object} Evidence about dev tasks, files, tests, lint, and security
-   */
-  _collectEvidence(projectDir) {
-    const evidence = {
-      devTasksCompleted: false,
-      sourceFilesCreated: false,
-      testFilesCreated: false,
-      lintPasses: null, // null = unknown, true/false = checked
-      securityClean: null,
-      devHandoff: null,
-      sessionState: null,
-    };
-
-    // Load session state for dev agent status
-    const sessionResult = loadSession(projectDir);
-    if (sessionResult.loaded && sessionResult.session) {
-      const devAgent = sessionResult.session.agents?.dev;
-      evidence.devTasksCompleted = devAgent?.status === 'completed';
-
-      evidence.sessionState = {
-        devStatus: devAgent?.status || 'pending',
-        devScore: devAgent?.score || 0,
-        completedAgents: sessionResult.session.completed_agents || [],
-      };
-    }
-
-    // Load dev handoff
-    const handoffResult = loadHandoff(projectDir, 'dev');
-    if (handoffResult.loaded && handoffResult.handoff) {
-      evidence.devHandoff = {
-        score: handoffResult.handoff.score,
-        status: handoffResult.handoff.status,
-        outputs: handoffResult.handoff.outputs || [],
-        blockers: handoffResult.handoff.blockers || [],
-        criteriaUnmet: handoffResult.handoff.criteria_unmet || [],
-      };
-
-      // Check if outputs indicate source and test files
-      const outputs = evidence.devHandoff.outputs;
-      evidence.sourceFilesCreated = outputs.some(o => {
-        const lower = (typeof o === 'string' ? o : '').toLowerCase();
-        return lower.includes('src/') || lower.includes('.js') || lower.includes('.ts');
-      });
-      evidence.testFilesCreated = outputs.some(o => {
-        const lower = (typeof o === 'string' ? o : '').toLowerCase();
-        return lower.includes('test') || lower.includes('.test.') || lower.includes('.spec.');
-      });
-    }
-
-    // Check for lint results file — parse content for real findings
-    const lintResultPath = join(projectDir, '.lint-result');
-    if (existsSync(lintResultPath)) {
-      try {
-        const content = readFileSync(lintResultPath, 'utf-8');
-        const hasErrors = /error|failed|failure|\d+\s+error/i.test(content);
-        const hasPassIndicator = /pass|clean|ok|no\s*(errors|issues|warnings)|0\s+errors|success/i.test(content);
-        if (hasErrors && !hasPassIndicator) {
-          evidence.lintPasses = false;
-        } else if (hasPassIndicator) {
-          evidence.lintPasses = true;
-        } else {
-          evidence.lintPasses = null; // Ambiguous — file exists but no clear verdict
-        }
-      } catch { /* expected: file may not exist */
-        evidence.lintPasses = null;
-      }
-    }
-
-    // Check for security scan results
-    const securityPaths = [
-      join(projectDir, '.security-scan'),
-      join(projectDir, resolveFrameworkDir(projectDir), 'artifacts', 'security-report.md'),
-    ];
-    for (const secPath of securityPaths) {
-      if (existsSync(secPath)) {
-        try {
-          const content = readFileSync(secPath, 'utf-8');
-          const hasBlockers = /blocker|critical|high\s*severity|vulnerability found|failed/i.test(content);
-          const hasPassIndicator = /pass|clean|no\s*(issues|vulnerabilities|findings)|score:\s*(9[5-9]|100)/i.test(content);
-          if (hasBlockers) {
-            evidence.securityClean = false;
-          } else if (hasPassIndicator) {
-            evidence.securityClean = true;
-          } else {
-            evidence.securityClean = null;
-          }
-        } catch { /* expected: file may not exist */
-          evidence.securityClean = null;
-        }
-        break;
-      }
-    }
-
-    // If no explicit source/test file indicators, check project src/ and test/ dirs
-    if (!evidence.sourceFilesCreated) {
-      const srcDir = join(projectDir, 'src');
-      if (existsSync(srcDir)) {
-        try {
-          const entries = readdirSync(srcDir, { recursive: false });
-          evidence.sourceFilesCreated = entries.length > 0;
-        } catch { /* expected: directory may not exist */
-          // Ignore
-        }
-      }
-    }
-
-    if (!evidence.testFilesCreated) {
-      const testDir = join(projectDir, 'test');
-      if (existsSync(testDir)) {
-        try {
-          const entries = readdirSync(testDir, { recursive: false });
-          evidence.testFilesCreated = entries.length > 0;
-        } catch { /* expected: directory may not exist */
-          // Ignore
-        }
-      }
-    }
-
-    return evidence;
-  }
-
-  /**
-   * Validate implementation evidence.
-   *
-   * @param {object} evidence
-   * @returns {{ score: number, criteriaResults: string[], allCriteria: string[], warnings: string[] }}
-   */
-  _validateEvidence(evidence) {
-    const allCriteria = [
-      'All dev tasks completed',
-      'Source files created',
-      'Test files created alongside source',
-      'Lint passes',
-      'No security issues flagged',
-      'Dev handoff score >= 90',
-    ];
-
-    const criteriaResults = [];
-    const warnings = [];
-
-    if (evidence.devTasksCompleted) {
-      criteriaResults.push('All dev tasks completed');
-    }
-
-    if (evidence.sourceFilesCreated) {
-      criteriaResults.push('Source files created');
-    }
-
-    if (evidence.testFilesCreated) {
-      criteriaResults.push('Test files created alongside source');
-    } else {
-      warnings.push('No test files detected');
-    }
-
-    if (evidence.lintPasses === true) {
-      criteriaResults.push('Lint passes');
-    } else if (evidence.lintPasses === null) {
-      warnings.push('Lint status unknown — no .lint-result found');
-    }
-
-    if (evidence.securityClean === true) {
-      criteriaResults.push('No security issues flagged');
-    } else if (evidence.securityClean === null) {
-      warnings.push('Security scan not found — consider running a scan');
-    }
-
-    // Check dev handoff score
-    if (evidence.devHandoff) {
-      if (evidence.devHandoff.score >= 90) {
-        criteriaResults.push('Dev handoff score >= 90');
-      } else {
-        warnings.push(`Dev handoff score: ${evidence.devHandoff.score} (need >= 90)`);
-      }
-
-      if (evidence.devHandoff.blockers.length > 0) {
-        warnings.push(`${evidence.devHandoff.blockers.length} blocker(s) from dev`);
-      }
-    }
-
-    const score = allCriteria.length > 0
-      ? Math.round((criteriaResults.length / allCriteria.length) * 100)
-      : 0;
-
-    return { score, criteriaResults, allCriteria, warnings };
-  }
-}