@paths.design/caws-cli 8.0.1 → 8.2.0

package/dist/config/lite-scope.js

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview CAWS Lite-Mode Scope Configuration Loader
+ * Reads and validates .caws/scope.json for guardrails-only mode
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const micromatch = require('micromatch');
+
+const SCOPE_FILE = '.caws/scope.json';
+
+/**
+ * Default scope configuration for lite mode
+ * @returns {Object} Default scope.json contents
+ */
+function getLiteScopeDefaults() {
+  return {
+    version: 1,
+    allowedDirectories: ['src/', 'tests/', 'docs/'],
+    bannedPatterns: {
+      files: ['*-enhanced.*', '*-final.*', '*-v2.*', '*-copy.*'],
+      directories: ['*venv*', '.venv', 'm-venv', 'env/'],
+      docs: ['*-summary.md', '*-recap.md', '*-plan.md', 'sprint-*'],
+    },
+    maxNewFilesPerCommit: 10,
+    designatedVenvPath: '.venv',
+  };
+}
+
+/**
+ * Load lite scope configuration from .caws/scope.json
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {Object} Scope configuration (defaults if file not found)
+ */
+function loadLiteScope(projectRoot) {
+  const root = projectRoot || process.cwd();
+  const scopePath = path.join(root, SCOPE_FILE);
+
+  try {
+    if (!fs.existsSync(scopePath)) {
+      return getLiteScopeDefaults();
+    }
+
+    const raw = fs.readFileSync(scopePath, 'utf8');
+    const config = JSON.parse(raw);
+
+    // Merge with defaults for any missing fields
+    const defaults = getLiteScopeDefaults();
+    return {
+      version: config.version || defaults.version,
+      allowedDirectories: config.allowedDirectories || defaults.allowedDirectories,
+      bannedPatterns: {
+        files: config.bannedPatterns?.files || defaults.bannedPatterns.files,
+        directories: config.bannedPatterns?.directories || defaults.bannedPatterns.directories,
+        docs: config.bannedPatterns?.docs || defaults.bannedPatterns.docs,
+      },
+      maxNewFilesPerCommit: config.maxNewFilesPerCommit ?? defaults.maxNewFilesPerCommit,
+      designatedVenvPath: config.designatedVenvPath || defaults.designatedVenvPath,
+    };
+  } catch (error) {
+    // If file is malformed, return defaults
+    return getLiteScopeDefaults();
+  }
+}
+
+/**
+ * Check if a file path is allowed by the scope configuration
+ * @param {string} filePath - Relative file path to check
+ * @param {Object} [scope] - Scope configuration (loads from disk if not provided)
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {boolean} Whether the path is allowed
+ */
+function isPathAllowed(filePath, scope, projectRoot) {
+  const config = scope || loadLiteScope(projectRoot);
+  const dirs = config.allowedDirectories;
+
+  // If no allowed directories specified, everything is allowed
+  if (!dirs || dirs.length === 0) {
+    return true;
+  }
+
+  // Normalize the file path
+  const normalized = filePath.replace(/\\/g, '/');
+
+  // Check if file is within any allowed directory
+  for (const dir of dirs) {
+    const normalizedDir = dir.replace(/\\/g, '/').replace(/\/$/, '');
+    if (normalized.startsWith(normalizedDir + '/') || normalized === normalizedDir) {
+      return true;
+    }
+  }
+
+  // Also allow root-level config files (package.json, etc.)
+  if (!normalized.includes('/')) {
+    return true;
+  }
+
+  // Allow .caws/ directory itself
+  if (normalized.startsWith('.caws/')) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Check if a filename or path matches any banned pattern
+ * @param {string} filePath - File path to check
+ * @param {Object} [scope] - Scope configuration (loads from disk if not provided)
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {{ matched: boolean, pattern: string|null, category: string|null }} Match result
+ */
+function matchesBannedPattern(filePath, scope, projectRoot) {
+  const config = scope || loadLiteScope(projectRoot);
+  const banned = config.bannedPatterns;
+  const basename = path.basename(filePath);
+  const normalized = filePath.replace(/\\/g, '/');
+
+  // Check file patterns
+  if (banned.files && banned.files.length > 0) {
+    if (micromatch.isMatch(basename, banned.files, { dot: true })) {
+      const matched = banned.files.find((p) => micromatch.isMatch(basename, p, { dot: true }));
+      return { matched: true, pattern: matched, category: 'files' };
+    }
+  }
+
+  // Check directory patterns
+  if (banned.directories && banned.directories.length > 0) {
+    const parts = normalized.split('/');
+    for (const part of parts) {
+      if (micromatch.isMatch(part, banned.directories, { dot: true })) {
+        const matched = banned.directories.find((p) =>
+          micromatch.isMatch(part, p, { dot: true })
+        );
+        return { matched: true, pattern: matched, category: 'directories' };
+      }
+    }
+  }
+
+  // Check doc patterns
+  if (banned.docs && banned.docs.length > 0) {
+    if (micromatch.isMatch(basename, banned.docs, { dot: true })) {
+      const matched = banned.docs.find((p) => micromatch.isMatch(basename, p, { dot: true }));
+      return { matched: true, pattern: matched, category: 'docs' };
+    }
+  }
+
+  return { matched: false, pattern: null, category: null };
+}
+
+module.exports = {
+  loadLiteScope,
+  isPathAllowed,
+  matchesBannedPattern,
+  getLiteScopeDefaults,
+  SCOPE_FILE,
+};

package/dist/config/modes.d.ts

@@ -1,18 +1,16 @@
 export namespace COMPLEXITY_TIERS {
-    namespace simple {
+    namespace lite {
         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;
+            let destructiveCommandBlocking: boolean;
+            let fileSprawlDetection: boolean;
+            let scopeFence: boolean;
+            let simplificationGuard: boolean;
+            let worktreeIsolation: boolean;
         }
         namespace qualityRequirements {
             let testCoverage: number;
@@ -22,12 +20,11 @@ export namespace COMPLEXITY_TIERS {
         let riskTiers: string[];
         namespace commands {
             let init: boolean;
-            let validate: boolean;
             let status: boolean;
-            let specs: boolean;
+            let worktree: boolean;
         }
     }
-    namespace standard {
+    namespace simple {
         let name_1: string;
         export { name_1 as name };
         let description_1: string;
@@ -39,15 +36,13 @@ export namespace COMPLEXITY_TIERS {
         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 let basicValidation: boolean;
+            export let statusDisplay: boolean;
+            export let noQualityGates: boolean;
+            export let noProvenance: boolean;
+            export let noWaivers: boolean;
+            export let noChangeBudgets: boolean;
+            export let noMultiSpec: boolean;
         }
         export { features_1 as features };
         export namespace qualityRequirements_1 {
@@ -64,25 +59,14 @@ export namespace COMPLEXITY_TIERS {
         export namespace commands_1 {
             let init_1: boolean;
             export { init_1 as init };
-            let validate_1: boolean;
-            export { validate_1 as validate };
+            export let validate: boolean;
             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 let specs: boolean;
         }
         export { commands_1 as commands };
     }
-    namespace enterprise {
+    namespace standard {
         let name_2: string;
         export { name_2 as name };
         let description_2: string;
@@ -94,6 +78,61 @@ export namespace COMPLEXITY_TIERS {
         export namespace features_2 {
             let workingSpec_2: boolean;
             export { workingSpec_2 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_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_1: boolean;
+            export { validate_1 as validate };
+            let status_2: boolean;
+            export { status_2 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_2 as commands };
+    }
+    namespace enterprise {
+        let name_3: string;
+        export { name_3 as name };
+        let description_3: string;
+        export { description_3 as description };
+        let color_3: chalk.Chalk;
+        export { color_3 as color };
+        let icon_3: string;
+        export { icon_3 as icon };
+        export namespace features_3 {
+            let workingSpec_3: boolean;
+            export { workingSpec_3 as workingSpec };
             let fullValidation_1: boolean;
             export { fullValidation_1 as fullValidation };
             let statusDisplay_2: boolean;
@@ -114,25 +153,25 @@ export namespace COMPLEXITY_TIERS {
             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 { features_3 as features };
+        export namespace qualityRequirements_3 {
+            let testCoverage_3: number;
+            export { testCoverage_3 as testCoverage };
+            let mutationScore_3: number;
+            export { mutationScore_3 as mutationScore };
+            let contracts_3: string;
+            export { contracts_3 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 };
+        export { qualityRequirements_3 as qualityRequirements };
+        let riskTiers_3: string[];
+        export { riskTiers_3 as riskTiers };
+        export namespace commands_3 {
+            let init_3: boolean;
+            export { init_3 as init };
             let validate_2: boolean;
             export { validate_2 as validate };
-            let status_2: boolean;
-            export { status_2 as status };
+            let status_3: boolean;
+            export { status_3 as status };
             let specs_2: boolean;
             export { specs_2 as specs };
             let diagnose_1: boolean;
@@ -153,7 +192,7 @@ export namespace COMPLEXITY_TIERS {
             export let testAnalysis: boolean;
             export let qualityMonitor: boolean;
         }
-        export { commands_2 as commands };
+        export { commands_3 as commands };
     }
 }
 /**

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

@@ -1 +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"}
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../src/config/modes.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqJA;;;;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"}

package/dist/config/modes.js

@@ -10,6 +10,32 @@ const chalk = require('chalk');
  * CAWS Complexity Tiers
  */
 const COMPLEXITY_TIERS = {
+  lite: {
+    name: 'Lite',
+    description: 'Guardrails-only mode — no YAML specs required',
+    color: chalk.magenta,
+    icon: '🛡️',
+    features: {
+      workingSpec: false,
+      destructiveCommandBlocking: true,
+      fileSprawlDetection: true,
+      scopeFence: true,
+      simplificationGuard: true,
+      worktreeIsolation: true,
+    },
+    qualityRequirements: {
+      testCoverage: 0,
+      mutationScore: 0,
+      contracts: 'none',
+    },
+    riskTiers: ['T3'],
+    commands: {
+      init: true,
+      status: true,
+      worktree: true,
+    },
+  },
+
   simple: {
     name: 'Simple',
     description: 'Minimal CAWS for small projects and quick prototyping',

package/dist/error-handler.d.ts

@@ -8,16 +8,7 @@ export class CAWSError extends Error {
     timestamp: Date;
     executionTime: any;
 }
-export namespace ERROR_CATEGORIES {
-    let VALIDATION: string;
-    let PERMISSION: string;
-    let FILESYSTEM: string;
-    let NETWORK: string;
-    let CONFIGURATION: string;
-    let USER_INPUT: string;
-    let DEPENDENCY: string;
-    let UNKNOWN: string;
-}
+import { ERROR_CATEGORIES } from "./utils/error-categories";
 /**
  * Execution timing utilities
  */
@@ -29,12 +20,7 @@ export class ExecutionTimer {
     getDuration(): number;
     formatDuration(): string;
 }
-/**
- * Get error category from error object or message
- * @param {Error|string} error - Error object or message
- * @returns {string} Error category
- */
-export function getErrorCategory(error: Error | string): string;
+import { getErrorCategory } from "./utils/error-categories";
 /**
  * Wrap async operations with consistent error handling and timing
  * @param {Function} operation - Async operation to wrap
@@ -161,4 +147,5 @@ export function getAllTroubleshootingGuides(): any;
  * @returns {string|null} Issue key if match found, null otherwise
  */
 export function suggestTroubleshootingGuide(errorMessage: string): string | null;
+export { ERROR_CATEGORIES, getErrorCategory };
 //# sourceMappingURL=error-handler.d.ts.map

package/dist/error-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../src/error-handler.js"],"names":[],"mappings":"AA0GA;;GAEG;AACH;IACE,+DAOC;IAJC,cAAqD;IACrD,mBAA2F;IAC3F,gBAA2B;IAC3B,mBAAyB;CAE5B;;;;;;;;;;;AAED;;GAEG;AACH;IAEI,kBAAqB;IACrB,gBAAmB;IAGrB,cAEC;IAED,cAGC;IAED,sBAIC;IAED,yBAMC;CACF;AAjHD;;;;GAIG;AACH,wCAHW,KAAK,GAAC,MAAM,GACV,MAAM,CA+DlB;AAiDD;;;;;;GAMG;AACH,yDAJW,MAAM,kBACN,OAAO,GACL,OAAO,CAAC,GAAG,CAAC,CA8BxB;AAED;;;;;;GAMG;AACH,wDAJW,MAAM,kBACN,OAAO,GACL,GAAG,CA8Bf;AAgSD;;;;;GAKG;AACH,sCAJW,KAAK,wBAEL,OAAO,QAmDjB;AA0JD;;;GAGG;AACH,2CAqBC;AAnXD;;;;;;GAMG;AACH,8CALW,KAAK,YACL,MAAM,kBAEJ,MAAM,EAAE,CAwDpB;AAED;;;;;GAKG;AACH,+CAJW,MAAM,kBAEJ,MAAM,CA4BlB;AAxJD;;;;;GAKG;AACH,0CAJW,MAAM,iBACN,MAAM,EAAE,GACN,MAAM,GAAC,IAAI,CAiBvB;AAjHD;;GAEG;AACH;;;;;EAuFE;AA4JF;;;;GAIG;AACH,qDAFW,OAAO,UAIjB;AAED;;;GAGG;AACH,gCAFa,OAAO,CAQnB;AAED;;;;GAIG;AACH,kDAFW,OAAO,OAcjB;AA2DD;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0GE;AAEF;;;;GAIG;AACH,kDAHW,MAAM,GACJ,MAAO,IAAI,CAIvB;AAED;;;GAGG;AACH,mDAEC;AAED;;;;GAIG;AACH,0DAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB"}
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../src/error-handler.js"],"names":[],"mappings":"AAcA;;GAEG;AACH;IACE,+DAOC;IAJC,cAAqD;IACrD,mBAA2F;IAC3F,gBAA2B;IAC3B,mBAAyB;CAE5B;;AAED;;GAEG;AACH;IAEI,kBAAqB;IACrB,gBAAmB;IAGrB,cAEC;IAED,cAGC;IAED,sBAIC;IAED,yBAMC;CACF;;AAED;;;;;;GAMG;AACH,yDAJW,MAAM,kBACN,OAAO,GACL,OAAO,CAAC,GAAG,CAAC,CA8BxB;AAED;;;;;;GAMG;AACH,wDAJW,MAAM,kBACN,OAAO,GACL,GAAG,CA8Bf;AAgSD;;;;;GAKG;AACH,sCAJW,KAAK,wBAEL,OAAO,QAmDjB;AA0JD;;;GAGG;AACH,2CAqBC;AAnXD;;;;;;GAMG;AACH,8CALW,KAAK,YACL,MAAM,kBAEJ,MAAM,EAAE,CAwDpB;AAED;;;;;GAKG;AACH,+CAJW,MAAM,kBAEJ,MAAM,CA4BlB;AAxJD;;;;;GAKG;AACH,0CAJW,MAAM,iBACN,MAAM,EAAE,GACN,MAAM,GAAC,IAAI,CAiBvB;AAjHD;;GAEG;AACH;;;;;EAuFE;AA4JF;;;;GAIG;AACH,qDAFW,OAAO,UAIjB;AAED;;;GAGG;AACH,gCAFa,OAAO,CAQnB;AAED;;;;GAIG;AACH,kDAFW,OAAO,OAcjB;AA2DD;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0GE;AAEF;;;;GAIG;AACH,kDAHW,MAAM,GACJ,MAAO,IAAI,CAIvB;AAED;;;GAGG;AACH,mDAEC;AAED;;;;GAIG;AACH,0DAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB"}

package/dist/error-handler.js

@@ -5,104 +5,12 @@
  */
 
 const chalk = require('chalk');
-
-/**
- * Error categories for better user experience
- */
-const ERROR_CATEGORIES = {
-  VALIDATION: 'validation',
-  PERMISSION: 'permission',
-  FILESYSTEM: 'filesystem',
-  NETWORK: 'network',
-  CONFIGURATION: 'configuration',
-  USER_INPUT: 'user_input',
-  DEPENDENCY: 'dependency',
-  UNKNOWN: 'unknown',
-};
-
-/**
- * Error code mappings for common system errors
- */
-const ERROR_CODES = {
-  EACCES: ERROR_CATEGORIES.PERMISSION,
-  EPERM: ERROR_CATEGORIES.PERMISSION,
-  ENOENT: ERROR_CATEGORIES.FILESYSTEM,
-  ENOTFOUND: ERROR_CATEGORIES.NETWORK,
-  ECONNREFUSED: ERROR_CATEGORIES.NETWORK,
-  ETIMEDOUT: ERROR_CATEGORIES.NETWORK,
-  ENOSPC: ERROR_CATEGORIES.FILESYSTEM,
-  EEXIST: ERROR_CATEGORIES.FILESYSTEM,
-  EISDIR: ERROR_CATEGORIES.FILESYSTEM,
-  ENOTDIR: ERROR_CATEGORIES.FILESYSTEM,
-};
-
-/**
- * Get error category from error object or message
- * @param {Error|string} error - Error object or message
- * @returns {string} Error category
- */
-function getErrorCategory(error) {
-  const errorMessage = typeof error === 'string' ? error : error.message;
-  const errorCode = typeof error === 'object' && error.code ? error.code : null;
-
-  // Check error codes first
-  if (errorCode && ERROR_CODES[errorCode]) {
-    return ERROR_CODES[errorCode];
-  }
-
-  // Check message patterns
-  const lowerMessage = errorMessage.toLowerCase();
-
-  if (
-    lowerMessage.includes('validation') ||
-    lowerMessage.includes('invalid') ||
-    lowerMessage.includes('required')
-  ) {
-    return ERROR_CATEGORIES.VALIDATION;
-  }
-
-  if (
-    lowerMessage.includes('permission') ||
-    lowerMessage.includes('access') ||
-    lowerMessage.includes('denied')
-  ) {
-    return ERROR_CATEGORIES.PERMISSION;
-  }
-
-  if (
-    lowerMessage.includes('file') ||
-    lowerMessage.includes('directory') ||
-    lowerMessage.includes('path')
-  ) {
-    return ERROR_CATEGORIES.FILESYSTEM;
-  }
-
-  if (
-    lowerMessage.includes('network') ||
-    lowerMessage.includes('connection') ||
-    lowerMessage.includes('timeout')
-  ) {
-    return ERROR_CATEGORIES.NETWORK;
-  }
-
-  if (
-    lowerMessage.includes('config') ||
-    lowerMessage.includes('setting') ||
-    lowerMessage.includes('option')
-  ) {
-    return ERROR_CATEGORIES.CONFIGURATION;
-  }
-
-  if (
-    lowerMessage.includes('input') ||
-    lowerMessage.includes('prompt') ||
-    lowerMessage.includes('answer')
-  ) {
-    return ERROR_CATEGORIES.USER_INPUT;
-  }
-
-  return ERROR_CATEGORIES.UNKNOWN;
-}
+const {
+  ERROR_CATEGORIES,
+  ERROR_CODES,
+  getErrorCategory,
+  getCategorySuggestions,
+} = require('./utils/error-categories');
 
 /**
  * Enhanced error class with category and recovery suggestions

package/dist/generators/jest-config-generator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configure Jest for TypeScript project
+ * @param {string} projectDir - Project directory path
+ * @param {Object} options - Configuration options
+ * @returns {Promise<Object>} Configuration result
+ */
+export function configureJestForTypeScript(projectDir?: string, options?: any): Promise<any>;
+/**
+ * Generate Jest configuration for TypeScript project
+ * @param {Object} options - Configuration options
+ * @returns {string} Jest configuration content
+ */
+export function generateJestConfig(options?: any): string;
+/**
+ * Generate test setup file for TypeScript
+ * @returns {string} Setup file content
+ */
+export function generateTestSetup(): string;
+/**
+ * Install Jest and TypeScript dependencies
+ * @param {string} projectDir - Project directory
+ * @param {Object} packageJson - Existing package.json
+ * @returns {Promise<Object>} Installation result
+ */
+export function installJestDependencies(projectDir: string, packageJson: any): Promise<any>;
+/**
+ * Get Jest configuration recommendations
+ * @param {string} projectDir - Project directory path
+ * @returns {Object} Recommendations
+ */
+export function getJestRecommendations(projectDir?: string): any;
+//# sourceMappingURL=jest-config-generator.d.ts.map

package/dist/generators/jest-config-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-config-generator.d.ts","sourceRoot":"","sources":["../../src/generators/jest-config-generator.js"],"names":[],"mappings":"AA+GA;;;;;GAKG;AACH,wDAJW,MAAM,kBAEJ,OAAO,KAAQ,CAgE3B;AAzKD;;;;GAIG;AACH,mDAFa,MAAM,CA0ClB;AAED;;;GAGG;AACH,qCAFa,MAAM,CAiBlB;AAED;;;;;GAKG;AACH,oDAJW,MAAM,qBAEJ,OAAO,KAAQ,CA2B3B;AAwED;;;;GAIG;AACH,oDAHW,MAAM,OAkDhB"}