@paths.design/caws-cli 8.0.0 → 8.1.0

package/dist/budget-derivation.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Derive budget for a working spec based on policy and waivers
+ * Enhanced to use PolicyManager for caching
+ * @param {Object} spec - Working spec object
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Derivation options
+ * @param {boolean} options.useCache - Use cached policy (default: true)
+ * @returns {Object} Derived budget with baseline and effective limits
+ */
+export function deriveBudget(spec: any, projectRoot?: string, options?: {
+    useCache: boolean;
+}): any;
+/**
+ * Load a waiver by ID
+ * Enhanced with structure validation and detailed error reporting
+ * @param {string} waiverId - Waiver ID (e.g., WV-0001)
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object|null} Waiver object or null if not found
+ */
+export function loadWaiver(waiverId: string, projectRoot: string): any | null;
+/**
+ * Check if a waiver is currently valid
+ * Enhanced with proper expiry and approval validation
+ * @param {Object} waiver - Waiver object
+ * @param {Object} policy - Policy configuration (optional)
+ * @returns {boolean} Whether waiver is valid and active
+ */
+export function isWaiverValid(waiver: any, policy?: any): boolean;
+/**
+ * Check if current changes exceed derived budget
+ * @param {Object} derivedBudget - Budget from deriveBudget()
+ * @param {Object} currentStats - Current change statistics
+ * @returns {Object} Budget check result
+ */
+export function checkBudgetCompliance(derivedBudget: any, currentStats: any): any;
+/**
+ * Generate burn-up report for scope visibility
+ * Enhanced with utilization metrics and warnings
+ * @param {Object} derivedBudget - Budget from deriveBudget()
+ * @param {Object} currentStats - Current change statistics
+ * @returns {string} Human-readable burn-up report
+ */
+export function generateBurnupReport(derivedBudget: any, currentStats: any): string;
+/**
+ * Calculate budget utilization percentages
+ * @param {Object} budgetCompliance - Budget compliance result
+ * @returns {Object} Utilization percentages
+ */
+export function calculateBudgetUtilization(budgetCompliance: any): any;
+/**
+ * Check if changes are approaching budget limit
+ * @param {Object} budgetCompliance - Budget compliance result
+ * @param {number} threshold - Warning threshold (default 80)
+ * @returns {boolean} Whether approaching limit
+ */
+export function isApproachingBudgetLimit(budgetCompliance: any, threshold?: number): boolean;
+/**
+ * Validate policy structure and content
+ * @param {Object} policy - Policy object from policy.yaml
+ * @throws {Error} If policy is invalid
+ */
+export function validatePolicy(policy: any): void;
+/**
+ * Get default policy as fallback
+ * @returns {Object} Default CAWS policy
+ */
+export function getDefaultPolicy(): any;
+/**
+ * Validate waiver document structure
+ * @param {Object} waiver - Waiver document to validate
+ * @throws {Error} If waiver structure is invalid
+ */
+export function validateWaiverStructure(waiver: any): void;
+//# sourceMappingURL=budget-derivation.d.ts.map

package/dist/budget-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-derivation.d.ts","sourceRoot":"","sources":["../src/budget-derivation.js"],"names":[],"mappings":"AA8JA;;;;;;;;GAQG;AACH,sDALW,MAAM,YAEd;IAAyB,QAAQ,EAAzB,OAAO;CACf,OAgGF;AA4FD;;;;;;GAMG;AACH,qCAJW,MAAM,eACN,MAAM,GACJ,MAAO,IAAI,CAuCvB;AAED;;;;;;GAMG;AACH,0DAFa,OAAO,CAgDnB;AAED;;;;;GAKG;AACH,kFA8BC;AAqCD;;;;;;GAMG;AACH,6EAFa,MAAM,CA8ClB;AAtFD;;;;GAIG;AACH,uEAiBC;AAED;;;;;GAKG;AACH,4EAHW,MAAM,GACJ,OAAO,CAKnB;AAjgBD;;;;GAIG;AACH,kDA+FC;AAED;;;GAGG;AACH,wCAsCC;AA2GD;;;;GAIG;AACH,2DAmFC"}

package/dist/cicd-optimizer.d.ts

@@ -0,0 +1,142 @@
+export = CICDOptimizer;
+declare class CICDOptimizer {
+    constructor(options?: {});
+    projectRoot: any;
+    cacheDir: string;
+    optimizationConfig: string;
+    /**
+     * Analyze project and generate CI/CD optimization recommendations
+     */
+    analyzeProject(specPath?: string): Promise<{
+        project_tier: string;
+        recommended_optimizations: any[];
+        cache_strategy: {};
+        parallel_groups: any[];
+        conditional_execution: {};
+        estimated_savings: {};
+    }>;
+    /**
+     * Generate tier-based conditional execution rules
+     */
+    generateConditionalExecutionRules(tier: any): {
+        coverage_required: boolean;
+        mutation_required: boolean;
+        contract_testing: boolean;
+        accessibility_check: boolean;
+        performance_budget: boolean;
+        security_scan: boolean;
+        lint_strict: boolean;
+    };
+    /**
+     * Analyze what optimizations are beneficial for this tier
+     */
+    analyzeOptimizationOpportunities(tier: any): Promise<{
+        type: string;
+        description: string;
+        impact: string;
+        effort: string;
+    }[]>;
+    /**
+     * Generate intelligent caching strategy
+     */
+    generateCacheStrategy(): Promise<{
+        node_modules: {
+            key: string;
+            paths: string[];
+            restore_keys: string[];
+        };
+        build_artifacts: {
+            key: string;
+            paths: string[];
+            restore_keys: any[];
+        };
+        test_cache: {
+            key: string;
+            paths: string[];
+            restore_keys: string[];
+        };
+    }>;
+    /**
+     * Create parallel execution groups for quality gates
+     */
+    createParallelGroups(): Promise<{
+        name: string;
+        description: string;
+        jobs: string[];
+        max_parallel: number;
+        timeout: number;
+    }[]>;
+    /**
+     * Analyze changed files to determine what tests to run
+     */
+    analyzeChangedFiles(changedFiles?: any[]): Promise<{
+        unit: any[];
+        integration: any[];
+        contract: any[];
+        e2e: any[];
+    }>;
+    /**
+     * Estimate time savings from optimizations
+     */
+    estimateTimeSavings(analysis: any): {
+        original_minutes: any;
+        optimized_minutes: number;
+        savings_percent: number;
+        monthly_savings_hours: number;
+    };
+    /**
+     * Generate optimized CI/CD configuration
+     */
+    generateOptimizedConfig(platform?: string): Promise<string | {
+        name: string;
+        on: {
+            push: {
+                branches: string[];
+            };
+            pull_request: {
+                branches: string[];
+            };
+        };
+        jobs: {};
+    } | {
+        stages: string[];
+        cache: {
+            key: string;
+            paths: string[];
+        };
+    }>;
+    /**
+     * Generate optimized GitHub Actions workflow
+     */
+    generateGitHubActionsConfig(analysis: any): {
+        name: string;
+        on: {
+            push: {
+                branches: string[];
+            };
+            pull_request: {
+                branches: string[];
+            };
+        };
+        jobs: {};
+    };
+    /**
+     * Generate GitLab CI configuration
+     */
+    generateGitLabCIConfig(analysis: any): {
+        stages: string[];
+        cache: {
+            key: string;
+            paths: string[];
+        };
+    };
+    /**
+     * Generate Jenkins pipeline configuration
+     */
+    generateJenkinsConfig(analysis: any): string;
+    /**
+     * Create hash for cache invalidation
+     */
+    createCacheHash(files: any): string;
+}
+//# sourceMappingURL=cicd-optimizer.d.ts.map

package/dist/cicd-optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cicd-optimizer.d.ts","sourceRoot":"","sources":["../src/cicd-optimizer.js"],"names":[],"mappings":";AAaA;IACE,0BASC;IARC,iBAAuD;IACvD,iBAA6D;IAC7D,2BAAkF;IAQpF;;OAEG;IACH;;;;;;;OAyCC;IAED;;OAEG;IACH;;;;;;;;MAyBC;IAED;;OAEG;IACH;;;;;SA6CC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;OA8CC;IAED;;OAEG;IACH;;;;;;SA0BC;IAED;;OAEG;IACH;;;;;OA2BC;IAED;;OAEG;IACH;;;;;MA+BC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;;OAYC;IAED;;OAEG;IACH;;;;;;;;;;;MA4EC;IAED;;OAEG;IACH;;;;;;MAiCC;IAED;;OAEG;IACH,6CA+CC;IAED;;OAEG;IACH,oCAQC;CACF"}

package/dist/commands/archive.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Archive command handler
+ * @param {string} changeId - Change identifier to archive
+ * @param {Object} options - Command options
+ */
+export function archiveCommand(changeId: string, options?: any): Promise<any>;
+/**
+ * Load change folder structure
+ * @param {string} changeId - Change identifier
+ * @returns {Promise<Object|null>} Change data or null
+ */
+export function loadChange(changeId: string): Promise<any | null>;
+/**
+ * Validate all acceptance criteria are met
+ * @param {Object} workingSpec - Working specification
+ * @returns {Promise<Object>} Validation result
+ */
+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: string): Promise<any>;
+/**
+ * Generate change summary for archival
+ * @param {Object} change - Change data
+ * @returns {Promise<string>} Summary text
+ */
+export function generateChangeSummary(change: any): Promise<string>;
+/**
+ * Archive change folder to archive directory
+ * @param {Object} change - Change data
+ * @returns {Promise<void>}
+ */
+export function archiveChange(change: any): Promise<void>;
+/**
+ * Update provenance with completion
+ * @param {Object} change - Change data
+ * @returns {Promise<void>}
+ */
+export function updateProvenance(change: any): Promise<void>;
+/**
+ * Display archive results
+ * @param {Object} change - Change data
+ * @param {Object} validation - Validation result
+ * @param {Object} qualityGates - Quality gates result
+ */
+export function displayArchiveResults(change: any, validation: any, qualityGates: any): void;
+//# sourceMappingURL=archive.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,6 @@
+/**
+ * Burn-up command handler
+ * @param {string} specFile - Path to spec file
+ */
+export function burnupCommand(specFile: string): Promise<void>;
+//# sourceMappingURL=burnup.d.ts.map

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

@@ -0,0 +1 @@
+{"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.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Diagnose command handler
+ * @param {Object} options - Command options
+ */
+export function diagnoseCommand(options?: any): Promise<void>;
+/**
+ * Run all health checks
+ * @returns {Promise<Object>} Diagnosis results
+ */
+export function runDiagnosis(): Promise<any>;
+/**
+ * Display diagnosis results
+ * @param {Object[]} results - Diagnosis results
+ */
+export function displayResults(results: any[]): void;
+/**
+ * Apply automatic fixes
+ * @param {Object[]} results - Diagnosis results
+ * @returns {Promise<Object>} Fix results
+ */
+export function applyAutoFixes(results: any[]): Promise<any>;
+/**
+ * Health check: Working spec validity
+ * @returns {Promise<Object>} Check result
+ */
+export function checkWorkingSpec(): Promise<any>;
+/**
+ * Health check: Git repository
+ * @returns {Promise<Object>} Check result
+ */
+export function checkGitSetup(): Promise<any>;
+/**
+ * Health check: Git hooks
+ * @returns {Promise<Object>} Check result
+ */
+export function checkGitHooks(): Promise<any>;
+/**
+ * Health check: TypeScript configuration
+ * @returns {Promise<Object>} Check result
+ */
+export function checkTypeScriptConfig(): Promise<any>;
+/**
+ * Health check: Test files exist
+ * @returns {Promise<Object>} Check result
+ */
+export function checkTestFiles(): Promise<any>;
+/**
+ * Health check: CAWS tools directory
+ * @returns {Promise<Object>} Check result
+ */
+export function checkCAWSTools(): Promise<any>;
+//# sourceMappingURL=diagnose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diagnose.d.ts","sourceRoot":"","sources":["../../src/commands/diagnose.js"],"names":[],"mappings":"AA0bA;;;GAGG;AACH,8DAoDC;AAvND;;;GAGG;AACH,gCAFa,OAAO,KAAQ,CAkD3B;AAED;;;GAGG;AACH,wCAFW,KAAQ,QA4ClB;AAED;;;;GAIG;AACH,wCAHW,KAAQ,GACN,OAAO,KAAQ,CAoD3B;AAzaD;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA2C3B;AAED;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAiB3B;AAED;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CA0C3B;AAED;;;GAGG;AACH,yCAFa,OAAO,KAAQ,CAgE3B;AAED;;;GAGG;AACH,kCAFa,OAAO,KAAQ,CAoC3B;AAED;;;GAGG;AACH,kCAFa,OAAO,KAAQ,CA0C3B"}

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/evaluate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Evaluate command handler
+ *
+ * @param {string} specFile - Path to working spec file
+ * @param {object} options - Command options
+ */
+export function evaluateCommand(specFile?: string, options?: object): Promise<void>;
+//# sourceMappingURL=evaluate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/commands/evaluate.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,2CAHW,MAAM,YACN,MAAM,iBA0QhB"}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Initialize a new project with CAWS
+ */
+export function initProject(projectName: any, options: any): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,2EAwiBC"}

package/dist/commands/iterate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Iterate command handler
+ *
+ * @param {string} specFile - Path to working spec file
+ * @param {object} options - Command options
+ */
+export function iterateCommand(specFile?: string, options?: object): Promise<void>;
+//# sourceMappingURL=iterate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iterate.d.ts","sourceRoot":"","sources":["../../src/commands/iterate.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,0CAHW,MAAM,YACN,MAAM,iBAgLhB"}