@paths.design/caws-cli 4.0.0 → 4.1.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/config/modes.d.ts

@@ -0,0 +1,225 @@
+export namespace COMPLEXITY_TIERS {
+    namespace simple {
+        let name: string;
+        let description: string;
+        let color: chalk.Chalk;
+        let icon: string;
+        namespace features {
+            let workingSpec: boolean;
+            let basicValidation: boolean;
+            let statusDisplay: boolean;
+            let noQualityGates: boolean;
+            let noProvenance: boolean;
+            let noWaivers: boolean;
+            let noChangeBudgets: boolean;
+            let noMultiSpec: boolean;
+        }
+        namespace qualityRequirements {
+            let testCoverage: number;
+            let mutationScore: number;
+            let contracts: string;
+        }
+        let riskTiers: string[];
+        namespace commands {
+            let init: boolean;
+            let validate: boolean;
+            let status: boolean;
+            let specs: boolean;
+        }
+    }
+    namespace standard {
+        let name_1: string;
+        export { name_1 as name };
+        let description_1: string;
+        export { description_1 as description };
+        let color_1: chalk.Chalk;
+        export { color_1 as color };
+        let icon_1: string;
+        export { icon_1 as icon };
+        export namespace features_1 {
+            let workingSpec_1: boolean;
+            export { workingSpec_1 as workingSpec };
+            export let fullValidation: boolean;
+            let statusDisplay_1: boolean;
+            export { statusDisplay_1 as statusDisplay };
+            export let qualityGates: boolean;
+            export let provenance: boolean;
+            export let waivers: boolean;
+            export let changeBudgets: boolean;
+            export let multiSpec: boolean;
+            export let changeFolders: boolean;
+        }
+        export { features_1 as features };
+        export namespace qualityRequirements_1 {
+            let testCoverage_1: number;
+            export { testCoverage_1 as testCoverage };
+            let mutationScore_1: number;
+            export { mutationScore_1 as mutationScore };
+            let contracts_1: string;
+            export { contracts_1 as contracts };
+        }
+        export { qualityRequirements_1 as qualityRequirements };
+        let riskTiers_1: string[];
+        export { riskTiers_1 as riskTiers };
+        export namespace commands_1 {
+            let init_1: boolean;
+            export { init_1 as init };
+            let validate_1: boolean;
+            export { validate_1 as validate };
+            let status_1: boolean;
+            export { status_1 as status };
+            let specs_1: boolean;
+            export { specs_1 as specs };
+            export let diagnose: boolean;
+            export let evaluate: boolean;
+            export let iterate: boolean;
+            let provenance_1: boolean;
+            export { provenance_1 as provenance };
+            let waivers_1: boolean;
+            export { waivers_1 as waivers };
+            export let hooks: boolean;
+            export let archive: boolean;
+        }
+        export { commands_1 as commands };
+    }
+    namespace enterprise {
+        let name_2: string;
+        export { name_2 as name };
+        let description_2: string;
+        export { description_2 as description };
+        let color_2: chalk.Chalk;
+        export { color_2 as color };
+        let icon_2: string;
+        export { icon_2 as icon };
+        export namespace features_2 {
+            let workingSpec_2: boolean;
+            export { workingSpec_2 as workingSpec };
+            let fullValidation_1: boolean;
+            export { fullValidation_1 as fullValidation };
+            let statusDisplay_2: boolean;
+            export { statusDisplay_2 as statusDisplay };
+            let qualityGates_1: boolean;
+            export { qualityGates_1 as qualityGates };
+            let provenance_2: boolean;
+            export { provenance_2 as provenance };
+            let waivers_2: boolean;
+            export { waivers_2 as waivers };
+            let changeBudgets_1: boolean;
+            export { changeBudgets_1 as changeBudgets };
+            let multiSpec_1: boolean;
+            export { multiSpec_1 as multiSpec };
+            let changeFolders_1: boolean;
+            export { changeFolders_1 as changeFolders };
+            export let auditTrails: boolean;
+            export let compliance: boolean;
+            export let advancedMonitoring: boolean;
+        }
+        export { features_2 as features };
+        export namespace qualityRequirements_2 {
+            let testCoverage_2: number;
+            export { testCoverage_2 as testCoverage };
+            let mutationScore_2: number;
+            export { mutationScore_2 as mutationScore };
+            let contracts_2: string;
+            export { contracts_2 as contracts };
+        }
+        export { qualityRequirements_2 as qualityRequirements };
+        let riskTiers_2: string[];
+        export { riskTiers_2 as riskTiers };
+        export namespace commands_2 {
+            let init_2: boolean;
+            export { init_2 as init };
+            let validate_2: boolean;
+            export { validate_2 as validate };
+            let status_2: boolean;
+            export { status_2 as status };
+            let specs_2: boolean;
+            export { specs_2 as specs };
+            let diagnose_1: boolean;
+            export { diagnose_1 as diagnose };
+            let evaluate_1: boolean;
+            export { evaluate_1 as evaluate };
+            let iterate_1: boolean;
+            export { iterate_1 as iterate };
+            let provenance_3: boolean;
+            export { provenance_3 as provenance };
+            let waivers_3: boolean;
+            export { waivers_3 as waivers };
+            let hooks_1: boolean;
+            export { hooks_1 as hooks };
+            let archive_1: boolean;
+            export { archive_1 as archive };
+            export let troubleshoot: boolean;
+            export let testAnalysis: boolean;
+            export let qualityMonitor: boolean;
+        }
+        export { commands_2 as commands };
+    }
+}
+/**
+ * Get tier information
+ * @param {string} tier - Tier name
+ * @returns {Object} Tier configuration
+ */
+export function getTier(tier: string): any;
+/**
+ * Get available tiers
+ * @returns {string[]} Array of tier names
+ */
+export function getAvailableTiers(): string[];
+/**
+ * Get current mode from configuration
+ * @returns {Promise<string>} Current mode
+ */
+export function getCurrentMode(): Promise<string>;
+/**
+ * Set current mode in configuration
+ * @param {string} mode - Mode to set
+ * @returns {Promise<boolean>} Success status
+ */
+export function setCurrentMode(mode: string): Promise<boolean>;
+/**
+ * Check if a command is available in the current tier
+ * @param {string} command - Command name
+ * @param {string} tier - Tier name
+ * @returns {boolean} Whether command is available
+ */
+export function isCommandAvailable(command: string, tier?: string): boolean;
+/**
+ * Check if a feature is enabled in the current tier
+ * @param {string} feature - Feature name
+ * @param {string} tier - Tier name
+ * @returns {boolean} Whether feature is enabled
+ */
+export function isFeatureEnabled(feature: string, tier?: string): boolean;
+/**
+ * Get quality requirements for a tier
+ * @param {string} tier - Tier name
+ * @returns {Object} Quality requirements
+ */
+export function getQualityRequirements(tier?: string): any;
+/**
+ * Get supported risk tiers for a complexity tier
+ * @param {string} tier - Tier name
+ * @returns {string[]} Supported risk tiers
+ */
+export function getSupportedRiskTiers(tier?: string): string[];
+/**
+ * Validate if a risk tier is supported in the current complexity tier
+ * @param {string} riskTier - Risk tier to validate
+ * @param {string} complexityTier - Complexity tier
+ * @returns {boolean} Whether risk tier is supported
+ */
+export function isRiskTierSupported(riskTier: string, complexityTier?: string): boolean;
+/**
+ * Display tier comparison
+ */
+export function displayTierComparison(): void;
+/**
+ * Get tier recommendation based on project characteristics
+ * @param {Object} projectInfo - Project information
+ * @returns {string} Recommended tier
+ */
+export function getTierRecommendation(projectInfo?: any): string;
+import chalk = require("chalk");
+//# sourceMappingURL=modes.d.ts.map

package/dist/config/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../src/config/modes.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HA;;;;GAIG;AACH,8BAHW,MAAM,OAKhB;AAED;;;GAGG;AACH,qCAFa,MAAM,EAAE,CAIpB;AA8FD;;;GAGG;AACH,kCAFa,OAAO,CAAC,MAAM,CAAC,CAgB3B;AAED;;;;GAIG;AACH,qCAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAuB5B;AA1ID;;;;;GAKG;AACH,4CAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAKnB;AAED;;;;;GAKG;AACH,0CAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAKnB;AAED;;;;GAIG;AACH,8CAHW,MAAM,OAMhB;AAED;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,EAAE,CAKpB;AAED;;;;;GAKG;AACH,8CAJW,MAAM,mBACN,MAAM,GACJ,OAAO,CAKnB;AAED;;GAEG;AACH,8CAkCC;AAkDD;;;;GAIG;AACH,0DAFa,MAAM,CAsBlB"}