@paths.design/caws-cli 8.1.0 → 8.2.1

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/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"}

package/dist/index.js

@@ -49,6 +49,7 @@ const { specsCommand } = require('./commands/specs');
 const { modeCommand } = require('./commands/mode');
 const { tutorialCommand } = require('./commands/tutorial');
 const { planCommand } = require('./commands/plan');
+const { worktreeCommand } = require('./commands/worktree');
 
 // Import scaffold functionality
 const { scaffoldProject, setScaffoldDependencies } = require('./scaffold');
@@ -105,6 +106,8 @@ program
   .option('-i, --interactive', 'Run interactive setup wizard', true)
   .option('--non-interactive', 'Skip interactive prompts (use defaults)', false)
   .option('--template <template>', 'Use specific project template')
+  .option('--mode <mode>', 'CAWS mode (lite, simple, standard, enterprise)')
+  .option('--ide <ides>', 'IDE integrations to install (comma-separated: cursor,claude,vscode,intellij,windsurf,copilot,all,none)')
   .action(initProject);
 
 // Scaffold command
@@ -116,6 +119,7 @@ program
   .option('--with-codemods', 'Include codemod scripts', false)
   .option('--with-oidc', 'Include OIDC trusted publisher setup', false)
   .option('--with-quality-gates', 'Install quality gates package and scripts', false)
+  .option('--ide <ides>', 'IDE integrations to install (comma-separated: cursor,claude,vscode,intellij,windsurf,copilot,all,none)')
   .action(scaffoldProject);
 
 // Validate command
@@ -343,6 +347,37 @@ program
   .option('--output <path>', 'Output file path for the plan')
   .action((action, options) => planCommand(action, options));
 
+// Worktree command group
+const worktreeCmd = program
+  .command('worktree')
+  .description('Manage git worktrees for agent scope isolation');
+
+worktreeCmd
+  .command('create <name>')
+  .description('Create a new isolated worktree')
+  .option('--scope <patterns>', 'Sparse checkout patterns (comma-separated, e.g., "src/auth/**")')
+  .option('--base-branch <branch>', 'Base branch to create from')
+  .option('--spec-id <id>', 'Associated spec ID')
+  .action((name, options) => worktreeCommand('create', { name, ...options }));
+
+worktreeCmd
+  .command('list')
+  .description('List all managed worktrees')
+  .action(() => worktreeCommand('list'));
+
+worktreeCmd
+  .command('destroy <name>')
+  .description('Destroy a worktree')
+  .option('--delete-branch', 'Also delete the associated branch', false)
+  .option('--force', 'Force removal even if worktree is dirty', false)
+  .action((name, options) => worktreeCommand('destroy', { name, ...options }));
+
+worktreeCmd
+  .command('prune')
+  .description('Clean up stale worktree entries')
+  .option('--max-age <days>', 'Remove entries older than N days', '30')
+  .action((options) => worktreeCommand('prune', options));
+
 // Templates command
 program
   .command('templates [subcommand]')
@@ -611,6 +646,7 @@ program.exitOverride((err) => {
       'hooks',
       'burnup',
       'tool',
+      'worktree',
     ];
     const similar = findSimilarCommand(commandName, validCommands);
 

package/dist/scaffold/claude-hooks.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Scaffold Claude Code hooks for a CAWS project
+ * Creates .claude/settings.json with hooks and .claude/hooks/ directory with scripts
+ *
+ * @param {string} projectDir - Project directory path
+ * @param {string[]} levels - Hook levels to enable: 'safety', 'quality', 'scope', 'audit'
+ */
+export function scaffoldClaudeHooks(projectDir: string, levels?: string[]): Promise<void>;
+/**
+ * Generate Claude Code settings with hooks configuration
+ * @param {string[]} levels - Enabled hook levels
+ * @param {Set<string>} enabledHooks - Set of enabled hook script names
+ * @returns {Object} Settings object for settings.json
+ */
+export function generateClaudeSettings(levels: string[], _enabledHooks: any): any;
+/**
+ * Check if Claude Code hooks are already configured
+ * @param {string} projectDir - Project directory
+ * @returns {boolean} True if hooks are configured
+ */
+export function hasClaudeHooks(projectDir: string): boolean;
+/**
+ * List configured Claude Code hooks
+ * @param {string} projectDir - Project directory
+ * @returns {Object} Hook configuration or null
+ */
+export function getClaudeHooksConfig(projectDir: string): any;
+//# sourceMappingURL=claude-hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claude-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/claude-hooks.js"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,gDAHW,MAAM,WACN,MAAM,EAAE,iBA6HlB;AAED;;;;;GAKG;AACH,+CAJW,MAAM,EAAE,2BAuJlB;AAED;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAcnB;AAED;;;;GAIG;AACH,iDAHW,MAAM,OAehB"}

package/dist/scaffold/claude-hooks.js

@@ -57,6 +57,7 @@ async function scaffoldClaudeHooks(projectDir, levels = ['safety', 'quality', 's
       quality: ['quality-check.sh', 'validate-spec.sh'],
       scope: ['scope-guard.sh', 'naming-check.sh'],
       audit: ['audit.sh'],
+      lite: ['block-dangerous.sh', 'scope-guard.sh', 'lite-sprawl-check.sh', 'simplification-guard.sh'],
     };
 
     // Determine which hooks to enable
@@ -80,6 +81,8 @@ async function scaffoldClaudeHooks(projectDir, levels = ['safety', 'quality', 's
       'block-dangerous.sh',
       'scope-guard.sh',
       'naming-check.sh',
+      'lite-sprawl-check.sh',
+      'simplification-guard.sh',
     ];
 
     for (const script of allHookScripts) {
@@ -229,6 +232,31 @@ function generateClaudeSettings(levels, _enabledHooks) {
     });
   }
 
+  if (levels.includes('lite')) {
+    // Lite mode: sprawl check on Write, simplification guard on Edit
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
+    settings.hooks.PreToolUse.push({
+      matcher: 'Write',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/lite-sprawl-check.sh',
+          timeout: 10,
+        },
+      ],
+    });
+    settings.hooks.PreToolUse.push({
+      matcher: 'Edit',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/simplification-guard.sh',
+          timeout: 10,
+        },
+      ],
+    });
+  }
+
   if (levels.includes('audit')) {
     // Session audit logging
     settings.hooks.SessionStart = settings.hooks.SessionStart || [];

package/dist/scaffold/index.d.ts

@@ -7,9 +7,11 @@ export function scaffoldIDEIntegrations(targetDir: any, options: any): Promise<{
     added: number;
     skipped: number;
 }>;
+import { scaffoldClaudeHooks } from "./claude-hooks";
 /**
  * Set dependencies for scaffold module
  * @param {Object} deps - Dependencies object
  */
 export function setScaffoldDependencies(deps: any): void;
+export { scaffoldClaudeHooks };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AA6LA;;;GAGG;AACH,6DA6jBC;AA3sBD;;;GA2HC;AAMD;;;GAGG;AACH,yDAGC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AA8MA;;;GAGG;AACH,6DA6jBC;AAztBD;;;GAyIC;;AAMD;;;GAGG;AACH,yDAGC"}