@paths.design/caws-cli 8.0.1 → 8.1.0

package/dist/commands/archive.d.ts

@@ -18,10 +18,11 @@ export function loadChange(changeId: string): Promise<any | null>;
 export function validateAcceptanceCriteria(workingSpec: any): Promise<any>;
 /**
  * Validate change meets quality gates
+ * Runs the actual quality gates runner and checks for violations
  * @param {string} changeId - Change identifier
  * @returns {Promise<Object>} Quality gate result
  */
-export function validateQualityGates(_changeId: any): Promise<any>;
+export function validateQualityGates(changeId: string): Promise<any>;
 /**
  * Generate change summary for archival
  * @param {Object} change - Change data

package/dist/commands/archive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../src/commands/archive.js"],"names":[],"mappings":"AA8OA;;;;GAIG;AACH,yCAHW,MAAM,+BAqGhB;AAtUD;;;;GAIG;AACH,qCAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAgChC;AAED;;;;GAIG;AACH,8DAFa,OAAO,KAAQ,CA8B3B;AAED;;;;GAIG;AACH,sDAFa,OAAO,KAAQ,CAS3B;AAED;;;;GAIG;AACH,oDAFa,OAAO,CAAC,MAAM,CAAC,CAgC3B;AAED;;;;GAIG;AACH,4CAFa,OAAO,CAAC,IAAI,CAAC,CAazB;AAED;;;;GAIG;AACH,+CAFa,OAAO,CAAC,IAAI,CAAC,CAoCzB;AAED;;;;;GAKG;AACH,6FAiCC"}
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../src/commands/archive.js"],"names":[],"mappings":"AA0VA;;;;GAIG;AACH,yCAHW,MAAM,+BAqGhB;AAjbD;;;;GAIG;AACH,qCAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAgChC;AAED;;;;GAIG;AACH,8DAFa,OAAO,KAAQ,CA8B3B;AAED;;;;;GAKG;AACH,+CAHW,MAAM,GACJ,OAAO,KAAQ,CAmH3B;AAED;;;;GAIG;AACH,oDAFa,OAAO,CAAC,MAAM,CAAC,CAgC3B;AAED;;;;GAIG;AACH,4CAFa,OAAO,CAAC,IAAI,CAAC,CAazB;AAED;;;;GAIG;AACH,+CAFa,OAAO,CAAC,IAAI,CAAC,CAoCzB;AAED;;;;;GAKG;AACH,6FAiCC"}

package/dist/commands/archive.js

@@ -8,6 +8,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
+const { execSync } = require('child_process');
 const { safeAsync, outputResult } = require('../error-handler');
 
 // Import spec resolution system
@@ -87,16 +88,123 @@ async function validateAcceptanceCriteria(workingSpec) {
 
 /**
  * Validate change meets quality gates
+ * Runs the actual quality gates runner and checks for violations
  * @param {string} changeId - Change identifier
  * @returns {Promise<Object>} Quality gate result
  */
 async function validateQualityGates(_changeId) {
-  // For now, return success - in full implementation would run actual gate checks
-  return {
-    valid: true,
-    message: 'Quality gates passed (implementation pending)',
-    gates: ['test-coverage', 'linting', 'type-checking'],
-  };
+  const gates = [];
+  const violations = [];
+  const warnings = [];
+
+  try {
+    // Try to run the quality gates runner
+    const qualityGatesPath = path.join(
+      __dirname,
+      '..',
+      '..',
+      '..',
+      'quality-gates',
+      'run-quality-gates.mjs'
+    );
+
+    // Check if quality gates runner exists
+    if (await fs.pathExists(qualityGatesPath)) {
+      try {
+        // Run quality gates in CI mode (checks all files, not just staged)
+        const result = execSync(`node "${qualityGatesPath}" --context=ci --json 2>&1`, {
+          encoding: 'utf8',
+          timeout: 60000, // 60 second timeout
+          cwd: process.cwd(),
+        });
+
+        // Try to parse JSON output
+        try {
+          const jsonMatch = result.match(/\{[\s\S]*\}$/);
+          if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (parsed.violations) {
+              violations.push(...parsed.violations);
+            }
+            if (parsed.warnings) {
+              warnings.push(...parsed.warnings);
+            }
+            gates.push(...(parsed.gates || []));
+          }
+        } catch {
+          // JSON parsing failed, check for error indicators in output
+          if (result.includes('❌') || result.includes('FAIL')) {
+            violations.push({ message: 'Quality gates reported failures', output: result });
+          }
+        }
+      } catch (execError) {
+        // Command failed - check exit code and output
+        if (execError.status !== 0) {
+          const output = execError.stdout || execError.message;
+          if (output.includes('violations') || output.includes('❌')) {
+            violations.push({ message: 'Quality gates failed', output: output.substring(0, 500) });
+          }
+        }
+      }
+    }
+
+    // Also check for active waivers that might cover violations
+    const waiversPath = path.join(process.cwd(), '.caws', 'waivers', 'active-waivers.yaml');
+    let hasActiveWaivers = false;
+    if (await fs.pathExists(waiversPath)) {
+      const waiversContent = await fs.readFile(waiversPath, 'utf8');
+      const waivers = yaml.load(waiversContent);
+      if (waivers && waivers.waivers) {
+        const activeWaiverCount = Object.keys(waivers.waivers).length;
+        if (activeWaiverCount > 0) {
+          hasActiveWaivers = true;
+          gates.push(`${activeWaiverCount} active waiver(s)`);
+        }
+      }
+    }
+
+    // Determine overall validity
+    const hasBlockingViolations = violations.some(
+      (v) => v.severity === 'block' || v.severity === 'fail'
+    );
+
+    if (violations.length === 0) {
+      return {
+        valid: true,
+        message: 'All quality gates passed',
+        gates: gates.length > 0 ? gates : ['naming', 'duplication', 'god-objects', 'hidden-todo'],
+        violations: [],
+        warnings,
+      };
+    } else if (hasActiveWaivers && !hasBlockingViolations) {
+      return {
+        valid: true,
+        message: `Quality gates passed with ${violations.length} waived violation(s)`,
+        gates,
+        violations,
+        warnings,
+        waived: true,
+      };
+    } else {
+      return {
+        valid: false,
+        message: `${violations.length} quality gate violation(s) found`,
+        gates,
+        violations,
+        warnings,
+      };
+    }
+  } catch (error) {
+    // If quality gates can't be run, warn but don't block
+    return {
+      valid: true,
+      message: `Quality gates check skipped: ${error.message}`,
+      gates: [],
+      violations: [],
+      warnings: [{ message: `Could not run quality gates: ${error.message}` }],
+      skipped: true,
+    };
+  }
 }
 
 /**

package/dist/commands/burnup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"burnup.d.ts","sourceRoot":"","sources":["../../src/commands/burnup.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,wCAFW,MAAM,iBAsEhB"}
+{"version":3,"file":"burnup.d.ts","sourceRoot":"","sources":["../../src/commands/burnup.js"],"names":[],"mappings":"AAsFA;;;GAGG;AACH,wCAFW,MAAM,iBAgGhB"}

package/dist/commands/burnup.js

@@ -8,9 +8,82 @@ const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
+const { execSync } = require('child_process');
 
 const { deriveBudget, generateBurnupReport } = require('../budget-derivation');
 
+/**
+ * Get actual git change statistics from the repository
+ * Analyzes changes since the last tag or initial commit
+ * @param {string} specDir - Directory containing the spec file
+ * @returns {Object} Stats with files_changed, lines_added, lines_removed, lines_changed
+ */
+function getGitChangeStats(specDir) {
+  try {
+    const cwd = specDir || process.cwd();
+
+    // Find the base reference - prefer last tag, fall back to first commit
+    let baseRef;
+    try {
+      baseRef = execSync('git describe --tags --abbrev=0 2>/dev/null', {
+        cwd,
+        encoding: 'utf8',
+      }).trim();
+    } catch {
+      // No tags, use first commit
+      try {
+        baseRef = execSync('git rev-list --max-parents=0 HEAD', {
+          cwd,
+          encoding: 'utf8',
+        }).trim();
+      } catch {
+        // Not a git repo or no commits
+        return null;
+      }
+    }
+
+    // Get file change count
+    const filesOutput = execSync(`git diff --name-only ${baseRef}..HEAD`, {
+      cwd,
+      encoding: 'utf8',
+    });
+    const filesChanged = filesOutput.trim().split('\n').filter(Boolean).length;
+
+    // Get line statistics using --numstat
+    const numstatOutput = execSync(`git diff --numstat ${baseRef}..HEAD`, {
+      cwd,
+      encoding: 'utf8',
+    });
+
+    let linesAdded = 0;
+    let linesRemoved = 0;
+
+    numstatOutput
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .forEach((line) => {
+        const [added, removed] = line.split('\t');
+        // Skip binary files (shown as '-')
+        if (added !== '-' && removed !== '-') {
+          linesAdded += parseInt(added, 10) || 0;
+          linesRemoved += parseInt(removed, 10) || 0;
+        }
+      });
+
+    return {
+      files_changed: filesChanged,
+      lines_added: linesAdded,
+      lines_removed: linesRemoved,
+      lines_changed: linesAdded + linesRemoved,
+      base_ref: baseRef,
+    };
+  } catch (error) {
+    // Return null if git analysis fails
+    return null;
+  }
+}
+
 /**
  * Burn-up command handler
  * @param {string} specFile - Path to spec file
@@ -32,15 +105,34 @@ async function burnupCommand(specFile) {
     // Derive budget
     const derivedBudget = deriveBudget(spec, path.dirname(specPath));
 
-    // Mock current stats - in real implementation this would analyze actual git changes
-    const mockStats = {
-      files_changed: 50, // This would be calculated from actual changes
-      lines_changed: 5000,
-      risk_tier: spec.risk_tier,
-    };
+    // Get actual git change statistics
+    const gitStats = getGitChangeStats(path.dirname(specPath));
+
+    let currentStats;
+    if (gitStats) {
+      currentStats = {
+        files_changed: gitStats.files_changed,
+        lines_changed: gitStats.lines_changed,
+        lines_added: gitStats.lines_added,
+        lines_removed: gitStats.lines_removed,
+        risk_tier: spec.risk_tier,
+        base_ref: gitStats.base_ref,
+      };
+      console.log(chalk.gray(`   Analyzing changes since: ${gitStats.base_ref}`));
+    } else {
+      // Fallback if git analysis fails (not in a repo or no commits)
+      console.log(chalk.yellow('   ⚠️  Could not analyze git history, using zero values'));
+      currentStats = {
+        files_changed: 0,
+        lines_changed: 0,
+        lines_added: 0,
+        lines_removed: 0,
+        risk_tier: spec.risk_tier,
+      };
+    }
 
     // Generate report
-    const report = generateBurnupReport(derivedBudget, mockStats);
+    const report = generateBurnupReport(derivedBudget, currentStats);
 
     console.log(report);
 
@@ -63,15 +155,22 @@ async function burnupCommand(specFile) {
 
     console.log(
       chalk.gray(
-        `   Current Usage: ${mockStats.files_changed} files, ${mockStats.lines_changed} LOC`
+        `   Current Usage: ${currentStats.files_changed} files, ${currentStats.lines_changed} LOC`
       )
     );
+    if (currentStats.lines_added !== undefined) {
+      console.log(
+        chalk.gray(
+          `   Breakdown: +${currentStats.lines_added} added, -${currentStats.lines_removed} removed`
+        )
+      );
+    }
 
     const filePercent = Math.round(
-      (mockStats.files_changed / derivedBudget.effective.max_files) * 100
+      (currentStats.files_changed / derivedBudget.effective.max_files) * 100
     );
     const locPercent = Math.round(
-      (mockStats.lines_changed / derivedBudget.effective.max_loc) * 100
+      (currentStats.lines_changed / derivedBudget.effective.max_loc) * 100
     );
 
     if (filePercent > 90 || locPercent > 90) {

package/dist/commands/diagnose.js

@@ -11,7 +11,7 @@ const chalk = require('chalk');
 
 // Import utilities
 const { checkTypeScriptTestConfig } = require('../utils/typescript-detector');
-const { configureJestForTypeScript } = require('../generators/jest-config');
+const { configureJestForTypeScript } = require('../generators/jest-config-generator');
 
 /**
  * Health check: Working spec validity

package/dist/commands/mode.js

@@ -18,13 +18,32 @@ const {
 
 /**
  * Display current mode status
+ * @param {string} currentMode - The current mode to display
  */
-function displayCurrentMode() {
+function displayCurrentMode(currentMode) {
+  const tier = getTier(currentMode);
+
   console.log(chalk.bold.cyan('\n🔧 CAWS Current Mode'));
   console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
 
-  // This will be implemented when we load the current mode
-  console.log(chalk.yellow('Mode display will be implemented...'));
+  console.log(chalk.bold(`Active Mode: ${tier.icon} ${tier.color(currentMode)}`));
+  console.log(chalk.gray(`Description: ${tier.description}`));
+  console.log('');
+
+  // Quality requirements
+  console.log(chalk.bold('Quality Requirements:'));
+  console.log(chalk.gray(`   Test Coverage: ≥${tier.qualityRequirements.testCoverage}%`));
+  console.log(chalk.gray(`   Mutation Score: ≥${tier.qualityRequirements.mutationScore}%`));
+  console.log(chalk.gray(`   Contracts: ${tier.qualityRequirements.contracts}`));
+  console.log('');
+
+  // Risk tiers supported
+  console.log(chalk.bold('Supported Risk Tiers:'));
+  tier.riskTiers.forEach((riskTier) => {
+    const riskColor =
+      riskTier === 'T1' ? chalk.red : riskTier === 'T2' ? chalk.yellow : chalk.green;
+    console.log(chalk.gray(`   ${riskColor(riskTier)}`));
+  });
   console.log('');
 }
 
@@ -128,21 +147,12 @@ async function modeCommand(action, options = {}) {
       switch (action) {
         case 'current': {
           const currentMode = await getCurrentMode();
-          displayCurrentMode();
-
-          const tier = getTier(currentMode);
-          console.log(chalk.bold(`Current Mode: ${tier.icon} ${tier.color(currentMode)}`));
-          console.log(chalk.gray(`Description: ${tier.description}`));
-          console.log(
-            chalk.gray(
-              `Quality: ${tier.qualityRequirements.testCoverage}% coverage, ${tier.qualityRequirements.mutationScore}% mutation`
-            )
-          );
+          displayCurrentMode(currentMode);
 
           return outputResult({
             command: 'mode current',
             mode: currentMode,
-            tier: tier,
+            tier: getTier(currentMode),
           });
         }