@paths.design/caws-cli 4.0.0 → 5.0.0

package/dist/commands/validate.js

@@ -1,12 +1,10 @@
 /**
  * @fileoverview Validate Command Handler
- * Handles validation commands for CAWS CLI
+ * Handles validation commands for CAWS CLI with multi-spec support
  * @author @darianrosebrook
  */
 
-const fs = require('fs-extra');
 const path = require('path');
-const yaml = require('js-yaml');
 const chalk = require('chalk');
 
 // Import validation functionality
@@ -15,47 +13,40 @@ const {
   getComplianceGrade,
 } = require('../validation/spec-validation');
 
+// Import spec resolution system
+const { resolveSpec, suggestMigration } = require('../utils/spec-resolver');
+
 /**
  * Validate command handler
- * Enhanced with JSON output format support
- * @param {string} specFile - Path to spec file
+ * Enhanced with multi-spec support and JSON output format
+ * @param {string} specFile - Path to spec file (optional, uses spec resolution)
  * @param {Object} options - Command options
+ * @param {string} [options.specId] - Feature-specific spec ID
+ * @param {boolean} [options.interactive] - Use interactive spec selection
+ * @param {boolean} [options.format] - Output format (json)
  */
-async function validateCommand(specFile, options) {
+async function validateCommand(specFile, options = {}) {
   try {
-    let specPath = specFile || path.join('.caws', 'working-spec.yaml');
-
-    if (!fs.existsSync(specPath)) {
-      if (options.format === 'json') {
-        console.log(
-          JSON.stringify(
-            {
-              passed: false,
-              verdict: 'fail',
-              errors: [
-                {
-                  field: 'spec_file',
-                  message: `Spec file not found: ${specPath}`,
-                  suggestion: 'Run "caws init" first to create a working spec',
-                },
-              ],
-            },
-            null,
-            2
-          )
-        );
-      } else {
-        console.error(chalk.red(`❌ Spec file not found: ${specPath}`));
-        console.error(chalk.blue('💡 Run "caws init" first to create a working spec'));
-      }
-      process.exit(1);
-    }
+    // Resolve spec using priority system
+    const resolved = await resolveSpec({
+      specId: options.specId,
+      specFile,
+      warnLegacy: options.format !== 'json',
+      interactive: options.interactive || false,
+    });
 
-    const specContent = fs.readFileSync(specPath, 'utf8');
-    const spec = yaml.load(specContent);
+    const { path: specPath, type: specType, spec } = resolved;
+
+    // Suggest migration if using legacy spec
+    if (specType === 'legacy' && options.format !== 'json') {
+      await suggestMigration();
+    }
 
     if (options.format !== 'json') {
-      console.log(chalk.cyan('🔍 Validating CAWS working spec...'));
+      console.log(
+        chalk.cyan(`🔍 Validating ${specType === 'feature' ? 'feature' : 'working'} spec...`)
+      );
+      console.log(chalk.gray(`   Spec: ${path.relative(process.cwd(), specPath)}`));
     }
 
     const result = validateWorkingSpecWithSuggestions(spec, {
@@ -64,16 +55,87 @@ async function validateCommand(specFile, options) {
       suggestions: !options.quiet,
       checkBudget: true,
       projectRoot: path.dirname(specPath),
+      specType,
     });
 
+    // Enhanced validation for multi-spec scenarios
+    const enhancedValidation = { ...result };
+
+    if (specType === 'feature') {
+      // Check for potential issues in feature specs
+      const featureIssues = [];
+
+      // Check scope conflicts (if multiple specs exist)
+      const { checkMultiSpecStatus } = require('../utils/spec-resolver');
+      const multiSpecStatus = await checkMultiSpecStatus();
+
+      if (multiSpecStatus.specCount > 1) {
+        const { checkScopeConflicts } = require('../utils/spec-resolver');
+        const conflicts = await checkScopeConflicts(
+          Object.keys(multiSpecStatus.registry?.specs || {})
+        );
+
+        if (conflicts.length > 0) {
+          const myConflicts = conflicts.filter((c) => c.spec1 === spec.id || c.spec2 === spec.id);
+
+          if (myConflicts.length > 0) {
+            featureIssues.push({
+              type: 'warning',
+              message: `Scope conflicts detected with other specs`,
+              details: myConflicts.map((c) => {
+                const otherSpec = c.spec1 === spec.id ? c.spec2 : c.spec1;
+                return `Conflict with ${otherSpec}: ${c.conflicts.join(', ')}`;
+              }),
+            });
+          }
+        }
+      }
+
+      // Check for missing contracts in feature specs
+      if (spec.contracts && spec.contracts.length === 0 && spec.mode === 'feature') {
+        featureIssues.push({
+          type: 'info',
+          message: 'Consider adding API contracts for better integration',
+          suggestion: 'Add contracts section to define API boundaries',
+        });
+      }
+
+      // Check for overly broad scopes
+      if (spec.scope && spec.scope.in) {
+        const broadPatterns = spec.scope.in.filter(
+          (pattern) => pattern === 'src/' || pattern === 'tests/' || pattern.includes('*')
+        );
+
+        if (broadPatterns.length > 0) {
+          featureIssues.push({
+            type: 'warning',
+            message: 'Broad scope patterns detected',
+            details: `Patterns like ${broadPatterns.join(', ')} may conflict with other features`,
+            suggestion: 'Use more specific scope.in paths',
+          });
+        }
+      }
+
+      // Add feature-specific issues to validation result
+      if (featureIssues.length > 0) {
+        enhancedValidation.issues = (enhancedValidation.issues || []).concat(featureIssues);
+        enhancedValidation.featureValidation = {
+          passed: featureIssues.filter((i) => i.type === 'error').length === 0,
+          issues: featureIssues,
+        };
+      }
+    }
+
+    const finalResult = enhancedValidation;
+
     // Format output based on requested format
     if (options.format === 'json') {
       // Structured JSON output matching CAWSValidationResult
       const jsonResult = {
-        passed: result.valid,
+        passed: finalResult.valid,
         cawsVersion: '3.4.0',
         timestamp: new Date().toISOString(),
-        verdict: result.valid ? 'pass' : 'fail',
+        verdict: finalResult.valid ? 'pass' : 'fail',
         spec: {
           id: spec.id,
           title: spec.title,
@@ -81,21 +143,29 @@ async function validateCommand(specFile, options) {
           mode: spec.mode,
         },
         validation: {
-          errors: result.errors || [],
-          warnings: result.warnings || [],
-          fixes: result.fixes || [],
+          errors: finalResult.errors || [],
+          warnings: finalResult.warnings || [],
+          fixes: finalResult.fixes || [],
         },
-        budgetCompliance: result.budget_check || null,
+        budgetCompliance: finalResult.budget_check || null,
+        specType,
+        specPath: path.relative(process.cwd(), specPath),
+        featureValidation: finalResult.featureValidation,
       };
 
       console.log(JSON.stringify(jsonResult, null, 2));
 
-      if (!result.valid) {
-        process.exit(1);
+      if (!finalResult.valid) {
+        // Don't call process.exit in test environment
+        if (process.env.NODE_ENV !== 'test' && !process.env.JEST_WORKER_ID) {
+          process.exit(1);
+        } else {
+          throw new Error('Validation failed');
+        }
       }
     } else {
       // Human-readable text output
-      if (result.valid) {
+      if (finalResult.valid) {
         console.log(chalk.green('✅ Working spec validation passed'));
         if (!options.quiet) {
           console.log(chalk.gray(`   Risk tier: ${spec.risk_tier}`));
@@ -103,10 +173,15 @@ async function validateCommand(specFile, options) {
           if (spec.title) {
             console.log(chalk.gray(`   Title: ${spec.title}`));
           }
-          if (result.complianceScore !== undefined) {
-            const grade = getComplianceGrade(result.complianceScore);
-            const scorePercent = (result.complianceScore * 100).toFixed(0);
-            const scoreColor = result.complianceScore >= 0.9 ? 'green' : result.complianceScore >= 0.7 ? 'yellow' : 'red';
+          if (finalResult.complianceScore !== undefined) {
+            const grade = getComplianceGrade(finalResult.complianceScore);
+            const scorePercent = (finalResult.complianceScore * 100).toFixed(0);
+            const scoreColor =
+              finalResult.complianceScore >= 0.9
+                ? 'green'
+                : finalResult.complianceScore >= 0.7
+                  ? 'yellow'
+                  : 'red';
             console.log(chalk[scoreColor](`   Compliance: ${scorePercent}% (Grade ${grade})`));
           }
         }
@@ -114,7 +189,7 @@ async function validateCommand(specFile, options) {
         console.log(chalk.red('❌ Working spec validation failed'));
 
         // Show errors
-        result.errors.forEach((error, index) => {
+        finalResult.errors.forEach((error, index) => {
           console.log(`   ${index + 1}. ${chalk.red(error.message)}`);
           if (error.suggestion) {
             console.log(`      ${chalk.blue('💡 ' + error.suggestion)}`);
@@ -122,14 +197,19 @@ async function validateCommand(specFile, options) {
         });
 
         // Show warnings
-        if (result.warnings && result.warnings.length > 0) {
+        if (finalResult.warnings && finalResult.warnings.length > 0) {
           console.log(chalk.yellow('\n⚠️  Warnings:'));
-          result.warnings.forEach((warning, index) => {
+          finalResult.warnings.forEach((warning, index) => {
             console.log(`   ${index + 1}. ${chalk.yellow(warning.message)}`);
           });
         }
 
-        process.exit(1);
+        // Don't call process.exit in test environment
+        if (process.env.NODE_ENV !== 'test' && !process.env.JEST_WORKER_ID) {
+          process.exit(1);
+        } else {
+          throw new Error('Validation failed');
+        }
       }
     }
   } catch (error) {
@@ -148,7 +228,10 @@ async function validateCommand(specFile, options) {
     } else {
       console.error(chalk.red('❌ Error during validation:'), error.message);
     }
-    process.exit(1);
+    // Don't call process.exit in test environment
+    if (process.env.NODE_ENV !== 'test' && !process.env.JEST_WORKER_ID) {
+      process.exit(1);
+    }
   }
 }
 

package/dist/commands/waivers.js

@@ -1,10 +1,10 @@
 /**
  * CAWS Waivers Command
- * 
+ *
  * Manage quality gate waivers for exceptional circumstances.
  * Waivers allow temporary exceptions to quality requirements
  * with proper documentation and approval.
- * 
+ *
  * @author @darianrosebrook
  */
 
@@ -13,12 +13,13 @@ const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
 const { initializeGlobalSetup } = require('../config');
+const WaiversManager = require('../waivers-manager');
 
 const WAIVER_DIR = '.caws/waivers';
 
 /**
  * Waivers command handler
- * 
+ *
  * @param {string} subcommand - create, list, show, revoke
  * @param {object} options - Command options
  */
@@ -26,7 +27,7 @@ async function waiversCommand(subcommand = 'list', options = {}) {
   try {
     console.log('🔍 Detecting CAWS setup...');
     const setup = initializeGlobalSetup();
-    
+
     if (setup.hasWorkingSpec) {
       console.log(`✅ Detected ${setup.setupType} CAWS setup`);
       console.log(`   Capabilities: ${setup.capabilities.join(', ')}`);
@@ -70,9 +71,18 @@ async function waiversCommand(subcommand = 'list', options = {}) {
  */
 async function createWaiver(options) {
   // Validate required fields
-  const required = ['title', 'reason', 'description', 'gates', 'expiresAt', 'approvedBy', 'impactLevel', 'mitigationPlan'];
-  const missing = required.filter(field => !options[field]);
-  
+  const required = [
+    'title',
+    'reason',
+    'description',
+    'gates',
+    'expiresAt',
+    'approvedBy',
+    'impactLevel',
+    'mitigationPlan',
+  ];
+  const missing = required.filter((field) => !options[field]);
+
   if (missing.length > 0) {
     console.error(chalk.red(`\n❌ Missing required fields: ${missing.join(', ')}`));
     console.log(chalk.yellow('\n💡 Example:'));
@@ -93,9 +103,10 @@ async function createWaiver(options) {
   const timestamp = new Date().toISOString();
 
   // Parse gates
-  const gates = typeof options.gates === 'string' 
-    ? options.gates.split(',').map(g => g.trim())
-    : options.gates;
+  const gates =
+    typeof options.gates === 'string'
+      ? options.gates.split(',').map((g) => g.trim())
+      : options.gates;
 
   // Create waiver object
   const waiver = {
@@ -112,10 +123,18 @@ async function createWaiver(options) {
     status: 'active',
   };
 
-  // Save waiver
+  // Save individual waiver file
   const waiverPath = path.join(process.cwd(), WAIVER_DIR, `${waiverId}.yaml`);
   fs.writeFileSync(waiverPath, yaml.dump(waiver, { lineWidth: -1 }));
 
+  // Also add to active waivers file
+  try {
+    await addToActiveWaivers(waiver);
+  } catch (error) {
+    console.error(`Failed to add waiver to active waivers: ${error.message}`);
+    console.error(error.stack);
+  }
+
   console.log(chalk.green(`\n✅ Waiver created: ${waiverId}`));
   console.log(`   Title: ${waiver.title}`);
   console.log(`   Reason: ${waiver.reason}`);
@@ -132,36 +151,42 @@ async function createWaiver(options) {
  */
 async function listWaivers(_options) {
   const waiversDir = path.join(process.cwd(), WAIVER_DIR);
-  
+
   if (!fs.existsSync(waiversDir)) {
     console.log(chalk.yellow('\nℹ️  No waivers found\n'));
     return;
   }
 
-  const waiverFiles = fs.readdirSync(waiversDir).filter(f => f.endsWith('.yaml'));
+  const waiverFiles = fs.readdirSync(waiversDir).filter((f) => f.endsWith('.yaml'));
 
   if (waiverFiles.length === 0) {
     console.log(chalk.yellow('\nℹ️  No waivers found\n'));
     return;
   }
 
-  const waivers = waiverFiles.map(file => {
+  const waivers = waiverFiles.map((file) => {
     const content = fs.readFileSync(path.join(waiversDir, file), 'utf8');
     return yaml.load(content);
   });
 
   // Filter by status
-  const activeWaivers = waivers.filter(w => w.status === 'active' && new Date(w.expires_at) > new Date());
-  const expiredWaivers = waivers.filter(w => w.status === 'active' && new Date(w.expires_at) <= new Date());
-  const revokedWaivers = waivers.filter(w => w.status === 'revoked');
+  const activeWaivers = waivers.filter(
+    (w) => w.status === 'active' && new Date(w.expires_at) > new Date()
+  );
+  const expiredWaivers = waivers.filter(
+    (w) => w.status === 'active' && new Date(w.expires_at) <= new Date()
+  );
+  const revokedWaivers = waivers.filter((w) => w.status === 'revoked');
 
   console.log(chalk.blue('\n🔖 CAWS Quality Gate Waivers\n'));
   console.log('─'.repeat(60));
 
   if (activeWaivers.length > 0) {
     console.log(chalk.green('\n✅ Active Waivers:\n'));
-    activeWaivers.forEach(waiver => {
-      const daysLeft = Math.ceil((new Date(waiver.expires_at) - new Date()) / (1000 * 60 * 60 * 24));
+    activeWaivers.forEach((waiver) => {
+      const daysLeft = Math.ceil(
+        (new Date(waiver.expires_at) - new Date()) / (1000 * 60 * 60 * 24)
+      );
       console.log(`🔖 ${chalk.bold(waiver.id)}: ${waiver.title}`);
       console.log(`   Reason: ${waiver.reason}`);
       console.log(`   Gates: ${waiver.gates.join(', ')}`);
@@ -173,7 +198,7 @@ async function listWaivers(_options) {
 
   if (expiredWaivers.length > 0) {
     console.log(chalk.yellow('\n⚠️  Expired Waivers:\n'));
-    expiredWaivers.forEach(waiver => {
+    expiredWaivers.forEach((waiver) => {
       console.log(`🔖 ${chalk.bold(waiver.id)}: ${waiver.title}`);
       console.log(`   Expired: ${waiver.expires_at}`);
       console.log();
@@ -182,7 +207,7 @@ async function listWaivers(_options) {
 
   if (revokedWaivers.length > 0) {
     console.log(chalk.red('\n❌ Revoked Waivers:\n'));
-    revokedWaivers.forEach(waiver => {
+    revokedWaivers.forEach((waiver) => {
       console.log(`🔖 ${chalk.bold(waiver.id)}: ${waiver.title}`);
       console.log(`   Revoked: ${waiver.revoked_at}`);
       console.log();
@@ -207,7 +232,7 @@ async function showWaiver(waiverId, _options) {
   }
 
   const waiverPath = path.join(process.cwd(), WAIVER_DIR, `${waiverId}.yaml`);
-  
+
   if (!fs.existsSync(waiverPath)) {
     console.error(chalk.red(`\n❌ Waiver not found: ${waiverId}\n`));
     process.exit(1);
@@ -222,7 +247,9 @@ async function showWaiver(waiverId, _options) {
 
   console.log(chalk.blue('\n🔖 Waiver Details\n'));
   console.log('─'.repeat(60));
-  console.log(`\n${statusIcon} Status: ${chalk.bold(isActive ? 'Active' : isExpired ? 'Expired' : waiver.status)}`);
+  console.log(
+    `\n${statusIcon} Status: ${chalk.bold(isActive ? 'Active' : isExpired ? 'Expired' : waiver.status)}`
+  );
   console.log(`\n📋 ${chalk.bold(waiver.title)}`);
   console.log(`   ID: ${waiver.id}`);
   console.log(`   Reason: ${waiver.reason}`);
@@ -230,7 +257,7 @@ async function showWaiver(waiverId, _options) {
   console.log(`\n📝 Description:`);
   console.log(`   ${waiver.description}`);
   console.log(`\n🔒 Waived Quality Gates:`);
-  waiver.gates.forEach(gate => {
+  waiver.gates.forEach((gate) => {
     console.log(`   • ${gate}`);
   });
   console.log(`\n🛡️ Mitigation Plan:`);
@@ -259,7 +286,7 @@ async function revokeWaiver(waiverId, options) {
   }
 
   const waiverPath = path.join(process.cwd(), WAIVER_DIR, `${waiverId}.yaml`);
-  
+
   if (!fs.existsSync(waiverPath)) {
     console.error(chalk.red(`\n❌ Waiver not found: ${waiverId}\n`));
     process.exit(1);
@@ -289,5 +316,53 @@ async function revokeWaiver(waiverId, options) {
   console.log(`   Reason: ${waiver.revocation_reason}\n`);
 }
 
-module.exports = { waiversCommand };
+/**
+ * Add waiver to active waivers file for quality gates integration
+ */
+async function addToActiveWaivers(waiver) {
+  try {
+    const waiversManager = new WaiversManager();
+
+    // Load existing active waivers
+    const activeWaivers = await waiversManager.loadActiveWaivers();
+
+    // Check if waiver already exists
+    const existingIndex = activeWaivers.findIndex((w) => w.id === waiver.id);
+
+    // Normalize waiver format
+    const normalizedWaiver = {
+      id: waiver.id,
+      title: waiver.title || waiver.description || waiver.id,
+      reason: waiver.reason || waiver.reason_code || 'unknown',
+      description: waiver.description || waiver.title || waiver.id,
+      gates: Array.isArray(waiver.gates) ? waiver.gates : [waiver.gates],
+      expires_at: waiver.expires_at,
+      approved_by: waiver.approved_by || waiver.risk_owner || 'unknown',
+      created_at: waiver.created_at || waiver.approved_at || new Date().toISOString(),
+      risk_assessment: waiver.risk_assessment || {
+        impact_level: waiver.impact_level || 'medium',
+        mitigation_plan: waiver.mitigation || waiver.mitigation_plan || 'Unknown mitigation',
+      },
+      metadata: waiver.metadata || {},
+    };
+
+    if (existingIndex >= 0) {
+      // Update existing waiver
+      activeWaivers[existingIndex] = normalizedWaiver;
+    } else {
+      // Add new waiver
+      activeWaivers.push(normalizedWaiver);
+    }
 
+    // Save updated active waivers
+    await waiversManager.saveActiveWaivers(activeWaivers);
+  } catch (error) {
+    // Enhanced error logging
+    console.error(`Error adding waiver to active waivers: ${error.message}`);
+    console.error(error.stack);
+    console.warn(`Warning: Could not add waiver to active waivers file: ${error.message}`);
+    // Don't fail the waiver creation if this fails
+  }
+}
+
+module.exports = { waiversCommand };