@paths.design/caws-cli 4.0.0 → 4.1.0

package/dist/scaffold/git-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/git-hooks.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,6CAHW,MAAM;;;GAwGhB;AAoOD;;;GAGG;AACH,2CAFW,MAAM,iBAkChB;AAED;;;GAGG;AACH,gDAFW,MAAM,iBAgDhB"}
+{"version":3,"file":"git-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/git-hooks.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,6CAHW,MAAM;;;GAwGhB;AAwND;;;GAGG;AACH,2CAFW,MAAM,iBAkChB;AAED;;;GAGG;AACH,gDAFW,MAAM,iBAgDhB"}

package/dist/scaffold/git-hooks.js

@@ -116,10 +116,10 @@ async function scaffoldGitHooks(projectDir, options = {}) {
 }
 
 /**
- * Generate pre-commit hook content
+ * Generate pre-commit hook content with staged file quality gates
  */
 function generatePreCommitHook(options) {
-  const { qualityGates = true } = options;
+  const { qualityGates = true, stagedOnly = true } = options;
 
   return `#!/bin/bash
 # CAWS Pre-commit Hook
@@ -127,8 +127,8 @@ function generatePreCommitHook(options) {
 
 set -e
 
-echo "🔍 CAWS Pre-commit Validation"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🚦 Running CAWS Quality Gates${qualityGates ? ' (Crisis Response Mode)' : ''}..."
+echo "📁 Analyzing ${stagedOnly ? 'staged files only' : 'all files'}..."
 
 # Check if CAWS is initialized
 if [ ! -d ".caws" ]; then
@@ -136,55 +136,43 @@ if [ ! -d ".caws" ]; then
   exit 0
 fi
 
-# Run CAWS validation if available
-if command -v caws >/dev/null 2>&1; then
-  echo "📋 Running CAWS validation..."
-  if caws validate --quiet; then
-    echo "✅ CAWS validation passed"
+# Run quality gates
+if command -v node >/dev/null 2>&1; then
+  if node scripts/quality-gates/run-quality-gates.js; then
+    echo "✅ Quality gates passed"
   else
-    echo "❌ CAWS validation failed"
-    echo "💡 Fix issues or skip with: git commit --no-verify (allowed)"
+    echo "❌ Quality gates failed - commit blocked"
+    echo "💡 Fix the violations above before committing"
+    echo "📖 See docs/refactoring.md for crisis response plan"
     exit 1
   fi
 else
-  echo "⚠️  CAWS CLI not found - install with: npm install -g @paths.design/caws-cli"
+  echo "⚠️  Node.js not found - skipping quality gates"
+  echo "💡 Install Node.js to enable automatic quality checking"
+  exit 0
 fi
 
-# Run quality gates if enabled
-${
-  qualityGates
-    ? `
-echo "🎯 Running quality gates..."
-if [ -f "package.json" ]; then
-  # Run linting if available
-  if [ -f "node_modules/.bin/eslint" ] || command -v eslint >/dev/null 2>&1; then
-    echo "🔍 Running ESLint..."
-    if npx eslint . --quiet; then
-      echo "✅ ESLint passed"
-    else
-      echo "❌ ESLint failed"
-      echo "💡 Fix issues or skip with: git commit --no-verify (allowed)"
-      exit 1
-    fi
-  fi
-
-  # Run tests if available
-  if [ -f "package.json" ] && grep -q '"test"' package.json; then
-    echo "🧪 Running tests..."
-    if npm test; then
-      echo "✅ Tests passed"
-    else
-      echo "❌ Tests failed"
-      echo "💡 Fix issues or skip with: git commit --no-verify (allowed)"
-      exit 1
-    fi
+# Run hidden TODO analysis on staged files only
+echo "🔍 Checking for hidden TODOs in staged files..."
+if command -v python3 >/dev/null 2>&1; then
+  if python3 scripts/v3/analysis/todo_analyzer.py --staged-only --ci-mode --min-confidence 0.8 >/dev/null 2>&1; then
+    echo "✅ No critical hidden TODOs found in staged files"
+  else
+    echo "❌ Critical hidden TODOs detected in staged files - commit blocked"
+    echo "💡 Fix stub implementations and placeholder code before committing"
+    echo "📖 See docs/PLACEHOLDER-DETECTION-GUIDE.md for classification"
+    echo ""
+    echo "🔍 Running detailed analysis on staged files..."
+    python3 scripts/v3/analysis/todo_analyzer.py --staged-only --min-confidence 0.8
+    exit 1
   fi
+else
+  echo "⚠️  Python3 not found - skipping hidden TODO analysis"
+  echo "💡 Install Python3 to enable automatic TODO checking"
 fi
-`
-    : ''
-}
 
-echo "🎉 Pre-commit checks passed!"
+echo "✅ All quality checks passed - proceeding with commit"
+exit 0
 `;
 }
 

package/dist/scaffold/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,6DA0UC;AA7dD;;;;GAIG;AACH,mDAHW,MAAM;;;GA8HhB;AAMD;;;GAGG;AACH,yDAGC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,6DA6VC;AAhfD;;;;GAIG;AACH,mDAHW,MAAM;;;GA8HhB;AAMD;;;GAGG;AACH,yDAGC"}

package/dist/scaffold/index.js

@@ -311,6 +311,25 @@ async function scaffoldProject(options) {
       },
     });
 
+    // Add quality gates scripts for staged file analysis
+    enhancements.push({
+      name: 'scripts/quality-gates/run-quality-gates.js',
+      description: 'Quality gates runner for staged files',
+      required: false,
+    });
+
+    enhancements.push({
+      name: 'scripts/quality-gates/check-god-objects.js',
+      description: 'God object detector for staged files',
+      required: false,
+    });
+
+    enhancements.push({
+      name: 'scripts/v3/analysis/todo_analyzer.py',
+      description: 'Advanced hidden TODO analyzer with dependency resolution',
+      required: false,
+    });
+
     // Add commit conventions for setups that don't have them
     if (!setup.hasTemplates || !fs.existsSync(path.join(currentDir, 'COMMIT_CONVENTIONS.md'))) {
       enhancements.push({

package/dist/utils/quality-gates-errors.js

@@ -0,0 +1,520 @@
+/**
+ * @fileoverview Quality Gates Error Taxonomy
+ * Comprehensive error handling for CAWS quality gates with structured error types,
+ * recovery strategies, and audit trails.
+ *
+ * @author @darianrosebrook
+ * @ts-nocheck
+ */
+
+const crypto = require('crypto');
+
+/**
+ * Quality Gates Error Categories
+ */
+const ERROR_CATEGORIES = {
+  VALIDATION: 'validation',
+  CONFIGURATION: 'configuration',
+  EXECUTION: 'execution',
+  NETWORK: 'network',
+  SECURITY: 'security',
+  PERFORMANCE: 'performance',
+  BUSINESS_LOGIC: 'business_logic',
+  INFRASTRUCTURE: 'infrastructure',
+  DATA: 'data',
+  TIMEOUT: 'timeout',
+  INTERNAL: 'internal',
+};
+
+/**
+ * Error Severity Levels
+ */
+const ERROR_SEVERITY = {
+  DEBUG: 'debug',
+  INFO: 'info',
+  WARNING: 'warning',
+  ERROR: 'error',
+  CRITICAL: 'critical',
+  FATAL: 'fatal',
+};
+
+/**
+ * Recovery Strategies
+ */
+const RECOVERY_STRATEGIES = {
+  RETRY: 'retry',
+  FALLBACK: 'fallback',
+  SKIP: 'skip',
+  ESCALATE: 'escalate',
+  MANUAL_INTERVENTION: 'manual_intervention',
+  AUTO_FIX: 'auto_fix',
+  WAIVER: 'waiver',
+};
+
+/**
+ * Quality Gates Error Class
+ * @typedef {Object} QualityGatesErrorOptions
+ * @property {string} category
+ * @property {string} code
+ * @property {string} message
+ * @property {string} [severity]
+ * @property {string} [component]
+ * @property {string} [operation]
+ * @property {Object} [context]
+ * @property {string[]} [recoveryStrategies]
+ * @property {boolean} [retryable]
+ * @property {string|null} [correlationId]
+ * @property {string[]} [errorChain]
+ */
+class QualityGatesError extends Error {
+  /**
+   * @param {QualityGatesErrorOptions} options
+   */
+  constructor(options) {
+    const {
+      category,
+      code,
+      message,
+      severity = ERROR_SEVERITY.ERROR,
+      component = 'quality-gates',
+      operation = 'unknown',
+      context = {},
+      recoveryStrategies = [],
+      retryable = false,
+      correlationId = null,
+      errorChain = [],
+    } = options;
+
+    super(message);
+
+    this.name = 'QualityGatesError';
+    this.errorId = `qg-err-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+    this.category = category;
+    this.code = code;
+    this.severity = severity;
+    this.component = component;
+    this.operation = operation;
+    this.context = context;
+    this.recoveryStrategies = recoveryStrategies;
+    this.retryable = retryable;
+    this.correlationId = correlationId;
+    this.errorChain = errorChain;
+    this.timestamp = new Date().toISOString();
+    this.stack = this.stack || new Error().stack;
+  }
+
+  /**
+   * Add context to the error
+   */
+  withContext(key, value) {
+    this.context[key] = value;
+    return this;
+  }
+
+  /**
+   * Add a recovery strategy
+   */
+  withRecoveryStrategy(strategy) {
+    this.recoveryStrategies.push(strategy);
+    return this;
+  }
+
+  /**
+   * Mark as retryable
+   */
+  retryable(retryable) {
+    this.retryable = retryable;
+    return this;
+  }
+
+  /**
+   * Set correlation ID for tracing
+   */
+  withCorrelationId(correlationId) {
+    this.correlationId = correlationId;
+    return this;
+  }
+
+  /**
+   * Add to error chain
+   */
+  withErrorChain(previousError) {
+    this.errorChain.push(previousError);
+    return this;
+  }
+
+  /**
+   * Convert to JSON for logging
+   */
+  toJSON() {
+    return {
+      errorId: this.errorId,
+      name: this.name,
+      category: this.category,
+      code: this.code,
+      message: this.message,
+      severity: this.severity,
+      component: this.component,
+      operation: this.operation,
+      context: this.context,
+      recoveryStrategies: this.recoveryStrategies,
+      retryable: this.retryable,
+      correlationId: this.correlationId,
+      errorChain: this.errorChain,
+      timestamp: this.timestamp,
+      stack: this.stack,
+    };
+  }
+
+  /**
+   * Get human-readable error summary
+   */
+  getSummary() {
+    return `[${this.category.toUpperCase()}] ${this.code}: ${this.message}`;
+  }
+
+  /**
+   * Check if error requires human intervention
+   */
+  requiresHumanIntervention() {
+    return (
+      this.recoveryStrategies.includes(RECOVERY_STRATEGIES.MANUAL_INTERVENTION) ||
+      this.recoveryStrategies.includes(RECOVERY_STRATEGIES.ESCALATE) ||
+      this.severity === ERROR_SEVERITY.FATAL
+    );
+  }
+
+  /**
+   * Check if error can be auto-recovered
+   */
+  canAutoRecover() {
+    return (
+      this.recoveryStrategies.includes(RECOVERY_STRATEGIES.AUTO_FIX) ||
+      this.recoveryStrategies.includes(RECOVERY_STRATEGIES.RETRY) ||
+      this.recoveryStrategies.includes(RECOVERY_STRATEGIES.FALLBACK)
+    );
+  }
+}
+
+/**
+ * Specific Error Types for Quality Gates
+ */
+
+/**
+ * God Object Detection Errors
+ */
+class GodObjectError extends QualityGatesError {
+  constructor(file, lineCount, threshold, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.BUSINESS_LOGIC,
+      code: 'GOD_OBJECT_DETECTED',
+      message: `God object detected: ${file} has ${lineCount} lines (threshold: ${threshold})`,
+      severity: lineCount > threshold * 1.5 ? ERROR_SEVERITY.CRITICAL : ERROR_SEVERITY.ERROR,
+      component: 'god-object-detector',
+      operation: 'analyze_file_size',
+      context: {
+        file,
+        lineCount,
+        threshold,
+        fileSizeKB: options.fileSizeKB,
+        relativePath: options.relativePath,
+      },
+      recoveryStrategies: [RECOVERY_STRATEGIES.MANUAL_INTERVENTION, RECOVERY_STRATEGIES.WAIVER],
+      retryable: false,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Hidden TODO Detection Errors
+ */
+class HiddenTodoError extends QualityGatesError {
+  constructor(file, todoCount, confidence, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.BUSINESS_LOGIC,
+      code: 'HIDDEN_TODOS_DETECTED',
+      message: `Hidden TODOs detected: ${file} has ${todoCount} TODOs (confidence: ${confidence})`,
+      severity: confidence > 0.9 ? ERROR_SEVERITY.CRITICAL : ERROR_SEVERITY.ERROR,
+      component: 'todo-analyzer',
+      operation: 'analyze_hidden_todos',
+      context: {
+        file,
+        todoCount,
+        confidence,
+        blockingTodos: options.blockingTodos || 0,
+        nonBlockingTodos: options.nonBlockingTodos || 0,
+      },
+      recoveryStrategies: [
+        RECOVERY_STRATEGIES.MANUAL_INTERVENTION,
+        RECOVERY_STRATEGIES.WAIVER,
+        RECOVERY_STRATEGIES.AUTO_FIX,
+      ],
+      retryable: false,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Configuration Errors
+ */
+class ConfigurationError extends QualityGatesError {
+  constructor(configKey, expectedType, actualValue, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.CONFIGURATION,
+      code: 'INVALID_CONFIGURATION',
+      message: `Invalid configuration: ${configKey} expected ${expectedType}, got ${typeof actualValue}`,
+      severity: ERROR_SEVERITY.ERROR,
+      component: 'config-manager',
+      operation: 'validate_config',
+      context: {
+        configKey,
+        expectedType,
+        actualValue,
+        configFile: options.configFile,
+      },
+      recoveryStrategies: [RECOVERY_STRATEGIES.MANUAL_INTERVENTION, RECOVERY_STRATEGIES.FALLBACK],
+      retryable: false,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Waiver Validation Errors
+ */
+class WaiverError extends QualityGatesError {
+  constructor(waiverId, reason, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.VALIDATION,
+      code: 'INVALID_WAIVER',
+      message: `Invalid waiver: ${waiverId} - ${reason}`,
+      severity: ERROR_SEVERITY.WARNING,
+      component: 'waiver-manager',
+      operation: 'validate_waiver',
+      context: {
+        waiverId,
+        reason,
+        expiresAt: options.expiresAt,
+        gates: options.gates,
+      },
+      recoveryStrategies: [RECOVERY_STRATEGIES.MANUAL_INTERVENTION, RECOVERY_STRATEGIES.SKIP],
+      retryable: false,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Execution Errors
+ */
+class ExecutionError extends QualityGatesError {
+  constructor(command, exitCode, stderr, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.EXECUTION,
+      code: 'COMMAND_FAILED',
+      message: `Command failed: ${command} (exit code: ${exitCode})`,
+      severity: ERROR_SEVERITY.ERROR,
+      component: 'command-executor',
+      operation: 'execute_command',
+      context: {
+        command,
+        exitCode,
+        stderr,
+        stdout: options.stdout,
+        workingDirectory: options.workingDirectory,
+      },
+      recoveryStrategies: [RECOVERY_STRATEGIES.RETRY, RECOVERY_STRATEGIES.MANUAL_INTERVENTION],
+      retryable: true,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Network/External Service Errors
+ */
+class NetworkError extends QualityGatesError {
+  constructor(url, statusCode, response, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.NETWORK,
+      code: 'NETWORK_REQUEST_FAILED',
+      message: `Network request failed: ${url} (status: ${statusCode})`,
+      severity: statusCode >= 500 ? ERROR_SEVERITY.ERROR : ERROR_SEVERITY.WARNING,
+      component: 'network-client',
+      operation: 'make_request',
+      context: {
+        url,
+        statusCode,
+        response,
+        method: options.method,
+        headers: options.headers,
+      },
+      recoveryStrategies: [RECOVERY_STRATEGIES.RETRY, RECOVERY_STRATEGIES.FALLBACK],
+      retryable: true,
+      ...options,
+    });
+  }
+}
+
+/**
+ * File System Errors
+ */
+class FileSystemError extends QualityGatesError {
+  constructor(operation, filePath, originalError, options = {}) {
+    super({
+      category: ERROR_CATEGORIES.INFRASTRUCTURE,
+      code: 'FILE_SYSTEM_ERROR',
+      message: `File system error: ${operation} failed for ${filePath}`,
+      severity: ERROR_SEVERITY.ERROR,
+      component: 'file-system',
+      operation,
+      context: {
+        filePath,
+        originalError: originalError.message,
+        errorCode: originalError.code,
+        permissions: options.permissions,
+      },
+      recoveryStrategies: [RECOVERY_STRATEGIES.RETRY, RECOVERY_STRATEGIES.MANUAL_INTERVENTION],
+      retryable: true,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Error Factory Functions
+ */
+
+/**
+ * Create a god object error
+ */
+function createGodObjectError(file, lineCount, threshold, options = {}) {
+  return new GodObjectError(file, lineCount, threshold, options);
+}
+
+/**
+ * Create a hidden TODO error
+ */
+function createHiddenTodoError(file, todoCount, confidence, options = {}) {
+  return new HiddenTodoError(file, todoCount, confidence, options);
+}
+
+/**
+ * Create a configuration error
+ */
+function createConfigurationError(configKey, expectedType, actualValue, options = {}) {
+  return new ConfigurationError(configKey, expectedType, actualValue, options);
+}
+
+/**
+ * Create a waiver error
+ */
+function createWaiverError(waiverId, reason, options = {}) {
+  return new WaiverError(waiverId, reason, options);
+}
+
+/**
+ * Create an execution error
+ */
+function createExecutionError(command, exitCode, stderr, options = {}) {
+  return new ExecutionError(command, exitCode, stderr, options);
+}
+
+/**
+ * Create a network error
+ */
+function createNetworkError(url, statusCode, response, options = {}) {
+  return new NetworkError(url, statusCode, response, options);
+}
+
+/**
+ * Create a file system error
+ */
+function createFileSystemError(operation, filePath, originalError, options = {}) {
+  return new FileSystemError(operation, filePath, originalError, options);
+}
+
+/**
+ * Error Classification Utilities
+ */
+
+/**
+ * Classify an error by its properties
+ */
+function classifyError(error) {
+  const classification = {
+    category: ERROR_CATEGORIES.INTERNAL,
+    severity: ERROR_SEVERITY.ERROR,
+    retryable: false,
+    requiresHumanIntervention: false,
+    canAutoRecover: false,
+  };
+
+  if (error instanceof QualityGatesError) {
+    classification.category = error.category;
+    classification.severity = error.severity;
+    classification.retryable = error.retryable;
+    classification.requiresHumanIntervention = error.requiresHumanIntervention();
+    classification.canAutoRecover = error.canAutoRecover();
+  }
+
+  return classification;
+}
+
+/**
+ * Get error statistics from a collection of errors
+ */
+function getErrorStatistics(errors) {
+  const stats = {
+    total: errors.length,
+    byCategory: {},
+    bySeverity: {},
+    retryable: 0,
+    requiresHumanIntervention: 0,
+    canAutoRecover: 0,
+  };
+
+  errors.forEach((error) => {
+    const classification = classifyError(error);
+
+    // Count by category
+    stats.byCategory[classification.category] =
+      (stats.byCategory[classification.category] || 0) + 1;
+
+    // Count by severity
+    stats.bySeverity[classification.severity] =
+      (stats.bySeverity[classification.severity] || 0) + 1;
+
+    // Count flags
+    if (classification.retryable) stats.retryable++;
+    if (classification.requiresHumanIntervention) stats.requiresHumanIntervention++;
+    if (classification.canAutoRecover) stats.canAutoRecover++;
+  });
+
+  return stats;
+}
+
+module.exports = {
+  QualityGatesError,
+  GodObjectError,
+  HiddenTodoError,
+  ConfigurationError,
+  WaiverError,
+  ExecutionError,
+  NetworkError,
+  FileSystemError,
+  ERROR_CATEGORIES,
+  ERROR_SEVERITY,
+  RECOVERY_STRATEGIES,
+  createGodObjectError,
+  createHiddenTodoError,
+  createConfigurationError,
+  createWaiverError,
+  createExecutionError,
+  createNetworkError,
+  createFileSystemError,
+  classifyError,
+  getErrorStatistics,
+};