chati-dev 4.3.1 → 4.4.0

package/src/gates/g4-qa-implementation.js

@@ -1,240 +0,0 @@
-/**
- * @fileoverview G4 — QA Implementation Gate
- *
- * Post-QA-Implementation gate — the most critical gate in the pipeline.
- * Validates that all tests pass, no critical bugs remain, performance
- * benchmarks are met, and security scans are clean.
- *
- * Verdicts:
- *   PASS     — All criteria met, score >= 95%
- *   CONCERNS — Score 90-95%, minor issues noted
- *   FAIL     — Score < 90% or critical issues
- *   WAIVED   — Human explicitly overrode
- */
-
-import { existsSync, readFileSync } 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 const QA_IMPL_VERDICTS = {
-  PASS: 'pass',
-  CONCERNS: 'concerns',
-  FAIL: 'fail',
-  WAIVED: 'waived',
-};
-
-export class QAImplementationGate extends GateBase {
-  constructor() {
-    super({
-      id: 'g4-qa-implementation',
-      name: 'QA Implementation',
-      pipelinePoint: 'post-qa-impl',
-      agent: 'qa-implementation',
-    });
-  }
-
-  /**
-   * Collect evidence about QA implementation results.
-   *
-   * @param {string} projectDir
-   * @returns {object} Evidence about test results, bugs, performance, security
-   */
-  _collectEvidence(projectDir) {
-    const evidence = {
-      qaImplHandoff: null,
-      allTestCriteriaMet: false,
-      noCriticalBugs: true,
-      performanceBenchmarksMet: null, // null = not defined
-      securityScanClean: null,
-      sessionState: null,
-      verdict: null,
-    };
-
-    // Load QA-Implementation handoff
-    const handoffResult = loadHandoff(projectDir, 'qa-implementation');
-    if (handoffResult.loaded && handoffResult.handoff) {
-      const handoff = handoffResult.handoff;
-      evidence.qaImplHandoff = {
-        score: handoff.score,
-        status: handoff.status,
-        outputs: handoff.outputs || [],
-        blockers: handoff.blockers || [],
-        criteriaUnmet: handoff.criteria_unmet || [],
-        criteriaMet: handoff.criteria_met || [],
-      };
-
-      evidence.allTestCriteriaMet = evidence.qaImplHandoff.criteriaUnmet.length === 0;
-      evidence.noCriticalBugs = evidence.qaImplHandoff.blockers.length === 0;
-    }
-
-    // Check for performance benchmark results — parse content for real findings
-    const perfPaths = [
-      join(projectDir, resolveFrameworkDir(projectDir), 'artifacts', 'performance-report.md'),
-      join(projectDir, '.performance-benchmark'),
-    ];
-    for (const perfPath of perfPaths) {
-      if (existsSync(perfPath)) {
-        try {
-          const content = readFileSync(perfPath, 'utf-8');
-          const hasFailures = /fail|exceeded|timeout|regression|degradation|below\s*threshold/i.test(content);
-          const hasPassIndicator = /pass|met|within\s*budget|no\s*(regressions|issues)|acceptable/i.test(content);
-          if (hasFailures && !hasPassIndicator) {
-            evidence.performanceBenchmarksMet = false;
-          } else if (hasPassIndicator) {
-            evidence.performanceBenchmarksMet = true;
-          } else {
-            evidence.performanceBenchmarksMet = null; // Ambiguous
-          }
-        } catch { /* expected: file may not exist */
-          evidence.performanceBenchmarksMet = null;
-        }
-        break;
-      }
-    }
-
-    // Check for security scan — parse content for real findings
-    const secPaths = [
-      join(projectDir, resolveFrameworkDir(projectDir), 'artifacts', 'security-report.md'),
-      join(projectDir, '.security-scan'),
-    ];
-    for (const secPath of secPaths) {
-      if (existsSync(secPath)) {
-        try {
-          const content = readFileSync(secPath, 'utf-8').toLowerCase();
-          // Look for indicators of security failures
-          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.securityScanClean = false;
-          } else if (hasPassIndicator) {
-            evidence.securityScanClean = true;
-          } else {
-            // File exists but has no clear pass/fail indicators — ambiguous — not clean by default
-            evidence.securityScanClean = null;
-          }
-        } catch { /* expected: operation may fail gracefully */
-          // File exists but cannot be read — treat as not available
-          evidence.securityScanClean = null;
-        }
-        break;
-      }
-    }
-
-    // Load session state
-    const sessionResult = loadSession(projectDir);
-    if (sessionResult.loaded && sessionResult.session) {
-      const qaAgent = sessionResult.session.agents?.['qa-implementation'];
-      evidence.sessionState = {
-        qaImplStatus: qaAgent?.status || 'pending',
-        qaImplScore: qaAgent?.score || 0,
-        completedAgents: sessionResult.session.completed_agents || [],
-      };
-    }
-
-    // Determine verdict
-    evidence.verdict = this._determineVerdict(evidence);
-
-    return evidence;
-  }
-
-  /**
-   * Determine the QA verdict based on evidence.
-   *
-   * @param {object} evidence
-   * @returns {string} One of QA_IMPL_VERDICTS
-   */
-  _determineVerdict(evidence) {
-    if (!evidence.qaImplHandoff) {
-      return QA_IMPL_VERDICTS.FAIL;
-    }
-
-    const score = evidence.qaImplHandoff.score ?? 0;
-
-    if (!evidence.noCriticalBugs) {
-      return QA_IMPL_VERDICTS.FAIL;
-    }
-
-    if (score >= 95 && evidence.allTestCriteriaMet) {
-      return QA_IMPL_VERDICTS.PASS;
-    }
-
-    if (score >= 90) {
-      return QA_IMPL_VERDICTS.CONCERNS;
-    }
-
-    return QA_IMPL_VERDICTS.FAIL;
-  }
-
-  /**
-   * Validate QA implementation evidence.
-   *
-   * @param {object} evidence
-   * @returns {{ score: number, criteriaResults: string[], allCriteria: string[], warnings: string[] }}
-   */
-  _validateEvidence(evidence) {
-    const allCriteria = [
-      'QA-Implementation handoff exists',
-      'All test criteria met',
-      'No critical bugs open',
-      'Performance benchmarks met',
-      'Security scan clean',
-      'QA-Implementation score >= 95',
-    ];
-
-    const criteriaResults = [];
-    const warnings = [];
-
-    // Check handoff exists
-    if (evidence.qaImplHandoff) {
-      criteriaResults.push('QA-Implementation handoff exists');
-    }
-
-    // Check test criteria
-    if (evidence.allTestCriteriaMet) {
-      criteriaResults.push('All test criteria met');
-    } else if (evidence.qaImplHandoff) {
-      warnings.push(`${evidence.qaImplHandoff.criteriaUnmet.length} test criteria unmet`);
-    }
-
-    // Check bugs
-    if (evidence.noCriticalBugs) {
-      criteriaResults.push('No critical bugs open');
-    } else {
-      warnings.push('Critical bugs remain open');
-    }
-
-    // Check performance
-    if (evidence.performanceBenchmarksMet === true) {
-      criteriaResults.push('Performance benchmarks met');
-    } else if (evidence.performanceBenchmarksMet === null) {
-      // Not defined is not a failure — just a warning
-      warnings.push('Performance benchmarks not defined');
-    }
-
-    // Check security
-    if (evidence.securityScanClean === true) {
-      criteriaResults.push('Security scan clean');
-    } else if (evidence.securityScanClean === null) {
-      warnings.push('Security scan not found');
-    }
-
-    // Check score
-    if (evidence.qaImplHandoff && evidence.qaImplHandoff.score >= 95) {
-      criteriaResults.push('QA-Implementation score >= 95');
-    } else if (evidence.qaImplHandoff) {
-      warnings.push(`QA-Impl score: ${evidence.qaImplHandoff.score} (need >= 95)`);
-    }
-
-    const score = allCriteria.length > 0
-      ? Math.round((criteriaResults.length / allCriteria.length) * 100)
-      : 0;
-
-    const hasCriticalBlocker = !evidence.noCriticalBugs;
-    const verdict = determineVerdict(score, 95, hasCriticalBlocker);
-
-    return { score, criteriaResults, allCriteria, warnings, verdict };
-  }
-}

package/src/gates/g5-deploy-ready.js

@@ -1,181 +0,0 @@
-/**
- * @fileoverview G5 — Deploy Ready Gate
- *
- * Pre-Deploy gate that validates everything is ready for deployment.
- * Checks that QA-Implementation passed, documentation is updated,
- * release notes exist, all tasks are complete, and no blockers remain.
- */
-
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { GateBase } from './gate-base.js';
-import { loadSession } from '../orchestrator/session-manager.js';
-import { loadHandoff } from '../tasks/handoff.js';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-
-export class DeployReadyGate extends GateBase {
-  constructor() {
-    super({
-      id: 'g5-deploy-ready',
-      name: 'Deploy Ready',
-      pipelinePoint: 'pre-deploy',
-      agent: 'devops',
-    });
-  }
-
-  /**
-   * Collect evidence about deployment readiness.
-   *
-   * @param {string} projectDir
-   * @returns {object} Evidence about QA status, docs, release notes, blockers
-   */
-  _collectEvidence(projectDir) {
-    const evidence = {
-      qaImplPassed: false,
-      readmeUpdated: false,
-      changelogUpdated: false,
-      releaseNotesPrepared: false,
-      allTasksCompleted: false,
-      noOpenBlockers: true,
-      sessionState: null,
-    };
-
-    // Check QA-Implementation status
-    const qaHandoff = loadHandoff(projectDir, 'qa-implementation');
-    if (qaHandoff.loaded && qaHandoff.handoff) {
-      evidence.qaImplPassed = qaHandoff.handoff.score >= 90 &&
-        qaHandoff.handoff.status === 'complete';
-    }
-
-    // Check README exists
-    const readmePaths = [
-      join(projectDir, 'README.md'),
-      join(projectDir, 'readme.md'),
-    ];
-    for (const readmePath of readmePaths) {
-      if (existsSync(readmePath)) {
-        evidence.readmeUpdated = true;
-        break;
-      }
-    }
-
-    // Check CHANGELOG exists
-    const changelogPaths = [
-      join(projectDir, 'CHANGELOG.md'),
-      join(projectDir, 'docs', 'CHANGELOG.md'),
-      join(projectDir, 'changelog.md'),
-      join(projectDir, 'CHANGES.md'),
-    ];
-    for (const clPath of changelogPaths) {
-      if (existsSync(clPath)) {
-        evidence.changelogUpdated = true;
-        break;
-      }
-    }
-
-    // Check release notes
-    const releaseNotePaths = [
-      join(projectDir, 'RELEASE.md'),
-      join(projectDir, resolveFrameworkDir(projectDir), 'artifacts', 'release-notes.md'),
-    ];
-    for (const rnPath of releaseNotePaths) {
-      if (existsSync(rnPath)) {
-        evidence.releaseNotesPrepared = true;
-        break;
-      }
-    }
-
-    // Load session state
-    const sessionResult = loadSession(projectDir);
-    if (sessionResult.loaded && sessionResult.session) {
-      const agents = sessionResult.session.agents || {};
-      const completedAgents = sessionResult.session.completed_agents || [];
-
-      // Check all required agents are completed
-      const requiredAgents = Object.keys(agents).filter(
-        a => agents[a].status !== 'skipped'
-      );
-      const allComplete = requiredAgents.every(
-        a => completedAgents.includes(a) || agents[a].status === 'completed'
-      );
-
-      evidence.allTasksCompleted = allComplete;
-
-      // Check for open blockers in any handoff
-      for (const agentName of completedAgents) {
-        const agentHandoff = loadHandoff(projectDir, agentName);
-        if (agentHandoff.loaded && agentHandoff.handoff) {
-          const blockers = agentHandoff.handoff.blockers || [];
-          if (blockers.length > 0) {
-            evidence.noOpenBlockers = false;
-            break;
-          }
-        }
-      }
-
-      evidence.sessionState = {
-        mode: sessionResult.session.mode,
-        completedCount: completedAgents.length,
-        totalAgents: Object.keys(agents).length,
-      };
-    }
-
-    return evidence;
-  }
-
-  /**
-   * Validate deployment readiness evidence.
-   *
-   * @param {object} evidence
-   * @returns {{ score: number, criteriaResults: string[], allCriteria: string[], warnings: string[] }}
-   */
-  _validateEvidence(evidence) {
-    const allCriteria = [
-      'QA-Implementation passed',
-      'README updated',
-      'CHANGELOG updated',
-      'Release notes prepared',
-      'All tasks completed',
-      'No open blockers',
-    ];
-
-    const criteriaResults = [];
-    const warnings = [];
-
-    if (evidence.qaImplPassed) {
-      criteriaResults.push('QA-Implementation passed');
-    } else {
-      warnings.push('QA-Implementation has not passed');
-    }
-
-    if (evidence.readmeUpdated) {
-      criteriaResults.push('README updated');
-    }
-
-    if (evidence.changelogUpdated) {
-      criteriaResults.push('CHANGELOG updated');
-    }
-
-    if (evidence.releaseNotesPrepared) {
-      criteriaResults.push('Release notes prepared');
-    }
-
-    if (evidence.allTasksCompleted) {
-      criteriaResults.push('All tasks completed');
-    } else {
-      warnings.push('Not all tasks are completed');
-    }
-
-    if (evidence.noOpenBlockers) {
-      criteriaResults.push('No open blockers');
-    } else {
-      warnings.push('Open blockers remain from agent handoffs');
-    }
-
-    const score = allCriteria.length > 0
-      ? Math.round((criteriaResults.length / allCriteria.length) * 100)
-      : 0;
-
-    return { score, criteriaResults, allCriteria, warnings };
-  }
-}

package/src/gates/gate-base.js

@@ -1,185 +0,0 @@
-/**
- * @fileoverview GateBase — Template Method pattern base class for quality gates.
- *
- * Provides the abstract skeleton for all pipeline quality gates.
- * Subclasses implement _collectEvidence() and _validateEvidence()
- * while this base class handles evaluation orchestration.
- */
-
-import { evaluateGate, getGateThreshold, resolveGateAction } from '../autonomy/autonomous-gate.js';
-import { track as telemetryTrack } from '../telemetry/collector.js';
-
-/**
- * Gate verdict constants (v3.0.0).
- * APPROVED: Score >= threshold — proceed to next pipeline stage.
- * NEEDS_REVISION: Score within 5 points below threshold — return to agent for fixes.
- * BLOCKED: Score significantly below threshold or critical blocker — halt pipeline.
- */
-export const GateVerdict = {
-  APPROVED: 'approved',
-  NEEDS_REVISION: 'needs_revision',
-  BLOCKED: 'blocked',
-};
-
-/**
- * Determine the gate verdict from a score and threshold.
- *
- * @param {number} score - Gate evaluation score (0-100)
- * @param {number} threshold - Minimum score to pass
- * @param {boolean} [hasCriticalBlocker=false] - Whether a critical blocker exists
- * @returns {string} One of GateVerdict values
- */
-export function determineVerdict(score, threshold, hasCriticalBlocker = false) {
-  if (hasCriticalBlocker) return GateVerdict.BLOCKED;
-  if (score >= threshold) return GateVerdict.APPROVED;
-  if (score >= threshold - 5) return GateVerdict.NEEDS_REVISION;
-  return GateVerdict.BLOCKED;
-}
-
-/**
- * Abstract base class for quality gates.
- *
- * Uses the Template Method pattern: evaluate() is the template that
- * calls _collectEvidence() and _validateEvidence() which subclasses implement.
- */
-export class GateBase {
-  /**
-   * @param {object} config
-   * @param {string} config.id - Unique gate identifier (e.g. 'g1-planning-complete')
-   * @param {string} config.name - Human-readable gate name
-   * @param {string} config.pipelinePoint - Pipeline point this gate guards
-   * @param {string} config.agent - Agent whose output this gate evaluates
-   */
-  constructor(config) {
-    if (new.target === GateBase) {
-      throw new Error('GateBase is abstract and cannot be instantiated directly.');
-    }
-
-    const { id, name, pipelinePoint, agent } = config;
-
-    if (!id || !name || !pipelinePoint || !agent) {
-      throw new Error('GateBase requires id, name, pipelinePoint, and agent in config.');
-    }
-
-    this.id = id;
-    this.name = name;
-    this.pipelinePoint = pipelinePoint;
-    this.agent = agent;
-  }
-
-  /**
-   * Evaluate the quality gate.
-   *
-   * Template Method: collects evidence, validates it, then either runs
-   * autonomous evaluation or returns recommendation for human review.
-   *
-   * @param {string} projectDir - Project root directory
-   * @param {string} [mode='autonomous'] - 'autonomous' or 'human-in-the-loop'
-   * @returns {object} GateResult: { result, score, evidence, recommendation, canProceed }
-   */
-  evaluate(projectDir, mode = 'autonomous') {
-    // Step 1: Collect evidence (subclass implements)
-    const evidence = this._collectEvidence(projectDir);
-
-    // Step 2: Validate evidence (subclass implements)
-    const validation = this._validateEvidence(evidence);
-
-    const { score, criteriaResults, allCriteria, warnings = [] } = validation;
-
-    if (mode === 'autonomous') {
-      // Step 3a: Autonomous evaluation via autonomous-gate module
-      const gateResult = evaluateGate({
-        agent: this.agent,
-        score,
-        criteriaResults,
-        allCriteria,
-        warnings,
-      });
-
-      const action = resolveGateAction(gateResult.result, mode);
-
-      const threshold = getGateThreshold(this.agent);
-      const hasCriticalBlocker = warnings.some(w => w.toLowerCase().includes('critical'));
-      const verdict = determineVerdict(gateResult.score, threshold, hasCriticalBlocker);
-
-      // Track telemetry
-      telemetryTrack('gate_evaluated', {
-        gate: this.id,
-        result: verdict,
-        score: gateResult.score,
-        blockers: warnings.filter(w => w.toLowerCase().includes('critical')),
-      });
-
-      return {
-        gateId: this.id,
-        gateName: this.name,
-        result: gateResult.result,
-        verdict,
-        score: gateResult.score,
-        evidence,
-        recommendation: action.action,
-        canProceed: verdict === GateVerdict.APPROVED,
-        details: gateResult.details,
-        warnings,
-      };
-    }
-
-    // Step 3b: Human-in-the-loop — return evidence + recommendation
-    const threshold = getGateThreshold(this.agent);
-    const recommendation = score >= threshold
-      ? 'Recommend approval — criteria met.'
-      : `Recommend review — score ${score} below threshold ${threshold}.`;
-
-    return {
-      gateId: this.id,
-      gateName: this.name,
-      result: 'review',
-      score,
-      evidence,
-      recommendation,
-      canProceed: false, // Human must explicitly approve
-      details: {
-        criteriaResults,
-        allCriteria,
-        threshold,
-      },
-      warnings,
-    };
-  }
-
-  /**
-   * Collect evidence from the project filesystem.
-   * ABSTRACT — subclass MUST implement.
-   *
-   * @param {string} _projectDir
-   * @returns {object} Evidence data
-   */
-  _collectEvidence(_projectDir) {
-    throw new Error(`${this.constructor.name} must implement _collectEvidence()`);
-  }
-
-  /**
-   * Validate collected evidence and produce a score.
-   * ABSTRACT — subclass MUST implement.
-   *
-   * @param {object} _evidence
-   * @returns {{ score: number, criteriaResults: string[], allCriteria: string[], warnings: string[] }}
-   */
-  _validateEvidence(_evidence) {
-    throw new Error(`${this.constructor.name} must implement _validateEvidence()`);
-  }
-
-  /**
-   * Get gate metadata.
-   *
-   * @returns {{ id: string, name: string, pipelinePoint: string, threshold: number }}
-   */
-  getInfo() {
-    return {
-      id: this.id,
-      name: this.name,
-      pipelinePoint: this.pipelinePoint,
-      threshold: getGateThreshold(this.agent),
-    };
-  }
-}

package/src/gates/index.js

@@ -1,46 +0,0 @@
-/**
- * @fileoverview Quality Gates barrel exports and registry.
- *
- * Provides all gate classes and a registry function to look up
- * the appropriate gate for a given pipeline point.
- */
-
-export { GateBase } from './gate-base.js';
-export { CircuitBreaker, CIRCUIT_STATES } from './circuit-breaker.js';
-export { PlanningCompleteGate } from './g1-planning-complete.js';
-export { QAPlanningGate } from './g2-qa-planning.js';
-export { ImplementationGate } from './g3-implementation.js';
-export { QAImplementationGate, QA_IMPL_VERDICTS } from './g4-qa-implementation.js';
-export { DeployReadyGate } from './g5-deploy-ready.js';
-
-import { PlanningCompleteGate as _G1 } from './g1-planning-complete.js';
-import { QAPlanningGate as _G2 } from './g2-qa-planning.js';
-import { ImplementationGate as _G3 } from './g3-implementation.js';
-import { QAImplementationGate as _G4 } from './g4-qa-implementation.js';
-import { DeployReadyGate as _G5 } from './g5-deploy-ready.js';
-
-/**
- * Pipeline point to gate class mapping.
- */
-const PIPELINE_POINT_MAP = {
-  'pre-build': _G1,
-  'post-qa-planning': _G2,
-  'post-dev': _G3,
-  'post-qa-impl': _G4,
-  'pre-deploy': _G5,
-};
-
-/**
- * Get the gate instance for a specific pipeline point.
- *
- * @param {string} point - Pipeline point identifier
- * @returns {import('./gate-base.js').GateBase} Gate instance
- * @throws {Error} If no gate is registered for the given point
- */
-export function getGateForPipelinePoint(point) {
-  const GateClass = PIPELINE_POINT_MAP[point];
-  if (!GateClass) {
-    throw new Error(`No gate registered for pipeline point: ${point}`);
-  }
-  return new GateClass();
-}