@paths.design/caws-cli 8.0.0 → 8.1.0

package/dist/utils/typescript-detector.js

@@ -101,10 +101,40 @@ function detectTestFramework(projectDir = process.cwd(), packageJson = null) {
 }
 
 /**
- * Get workspace directories from package.json
+ * Expand workspace glob patterns to actual directories
+ * Shared helper for npm, pnpm, and lerna workspace resolution
+ * @param {string[]} patterns - Workspace patterns (may include globs like "packages/*")
  * @param {string} projectDir - Project directory path
- * @returns {string[]} Array of workspace directories
+ * @returns {string[]} Array of resolved workspace directory paths
  */
+function expandWorkspacePatterns(patterns, projectDir) {
+  const workspaceDirs = [];
+  for (const pattern of patterns) {
+    if (pattern.includes('*')) {
+      const baseDir = pattern.split('*')[0];
+      const fullBaseDir = path.join(projectDir, baseDir);
+
+      if (fs.existsSync(fullBaseDir)) {
+        const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const wsPath = path.join(fullBaseDir, entry.name);
+            if (fs.existsSync(path.join(wsPath, 'package.json'))) {
+              workspaceDirs.push(wsPath);
+            }
+          }
+        }
+      }
+    } else {
+      const wsPath = path.join(projectDir, pattern);
+      if (fs.existsSync(path.join(wsPath, 'package.json'))) {
+        workspaceDirs.push(wsPath);
+      }
+    }
+  }
+  return workspaceDirs;
+}
+
 /**
  * Get workspace directories from npm/yarn package.json workspaces
  * @param {string} projectDir - Project directory path
@@ -120,36 +150,7 @@ function getNpmWorkspaces(projectDir) {
   try {
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
     const workspaces = packageJson.workspaces || [];
-
-    // Convert glob patterns to actual directories (simple implementation)
-    const workspaceDirs = [];
-    for (const ws of workspaces) {
-      // Handle simple patterns like "packages/*" or "iterations/*"
-      if (ws.includes('*')) {
-        const baseDir = ws.split('*')[0];
-        const fullBaseDir = path.join(projectDir, baseDir);
-
-        if (fs.existsSync(fullBaseDir)) {
-          const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              const wsPath = path.join(fullBaseDir, entry.name);
-              if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-                workspaceDirs.push(wsPath);
-              }
-            }
-          }
-        }
-      } else {
-        // Direct path
-        const wsPath = path.join(projectDir, ws);
-        if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-          workspaceDirs.push(wsPath);
-        }
-      }
-    }
-
-    return workspaceDirs;
+    return expandWorkspacePatterns(workspaces, projectDir);
   } catch (error) {
     return [];
   }
@@ -171,35 +172,7 @@ function getPnpmWorkspaces(projectDir) {
     const yaml = require('js-yaml');
     const config = yaml.load(fs.readFileSync(pnpmFile, 'utf8'));
     const workspacePatterns = config.packages || [];
-
-    // Convert glob patterns to actual directories
-    const workspaceDirs = [];
-    for (const pattern of workspacePatterns) {
-      if (pattern.includes('*')) {
-        const baseDir = pattern.split('*')[0];
-        const fullBaseDir = path.join(projectDir, baseDir);
-
-        if (fs.existsSync(fullBaseDir)) {
-          const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              const wsPath = path.join(fullBaseDir, entry.name);
-              if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-                workspaceDirs.push(wsPath);
-              }
-            }
-          }
-        }
-      } else {
-        // Direct path
-        const wsPath = path.join(projectDir, pattern);
-        if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-          workspaceDirs.push(wsPath);
-        }
-      }
-    }
-
-    return workspaceDirs;
+    return expandWorkspacePatterns(workspacePatterns, projectDir);
   } catch (error) {
     return [];
   }
@@ -220,35 +193,7 @@ function getLernaWorkspaces(projectDir) {
   try {
     const config = JSON.parse(fs.readFileSync(lernaFile, 'utf8'));
     const workspacePatterns = config.packages || ['packages/*'];
-
-    // Convert glob patterns to actual directories
-    const workspaceDirs = [];
-    for (const pattern of workspacePatterns) {
-      if (pattern.includes('*')) {
-        const baseDir = pattern.split('*')[0];
-        const fullBaseDir = path.join(projectDir, baseDir);
-
-        if (fs.existsSync(fullBaseDir)) {
-          const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              const wsPath = path.join(fullBaseDir, entry.name);
-              if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-                workspaceDirs.push(wsPath);
-              }
-            }
-          }
-        }
-      } else {
-        // Direct path
-        const wsPath = path.join(projectDir, pattern);
-        if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-          workspaceDirs.push(wsPath);
-        }
-      }
-    }
-
-    return workspaceDirs;
+    return expandWorkspacePatterns(workspacePatterns, projectDir);
   } catch (error) {
     return [];
   }
@@ -416,6 +361,7 @@ module.exports = {
   getNpmWorkspaces,
   getPnpmWorkspaces,
   getLernaWorkspaces,
+  expandWorkspacePatterns,
   checkHoistedDependency,
   checkTypeScriptTestConfig,
   generateRecommendations,

package/dist/utils/yaml-validation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Validate YAML syntax for a file
+ * @param {string} filePath - Path to YAML file
+ * @returns {Object} Validation result with valid flag and error details
+ */
+export function validateYamlSyntax(filePath: string): any;
+/**
+ * Validate YAML syntax for multiple files
+ * @param {string[]} filePaths - Array of file paths to validate
+ * @returns {Object} Validation results with summary
+ */
+export function validateYamlFiles(filePaths: string[]): any;
+/**
+ * Find all YAML files in .caws directory
+ * @param {string} projectRoot - Project root directory
+ * @returns {string[]} Array of YAML file paths
+ */
+export function findCawsYamlFiles(projectRoot: string): string[];
+/**
+ * Validate all CAWS YAML files in project
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Validation results
+ */
+export function validateAllCawsYamlFiles(projectRoot: string): any;
+/**
+ * Format validation error for display
+ * @param {Object} error - Error object from validateYamlSyntax
+ * @param {string} filePath - File path
+ * @returns {string} Formatted error message
+ */
+export function formatYamlError(error: any, filePath: string): string;
+//# sourceMappingURL=yaml-validation.d.ts.map

package/dist/utils/yaml-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-validation.d.ts","sourceRoot":"","sources":["../../src/utils/yaml-validation.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,6CAHW,MAAM,OA2BhB;AAED;;;;GAIG;AACH,6CAHW,MAAM,EAAE,OAgClB;AAED;;;;GAIG;AACH,+CAHW,MAAM,GACJ,MAAM,EAAE,CA6BpB;AAED;;;;GAIG;AACH,sDAHW,MAAM,OAMhB;AAED;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAoBlB"}

package/dist/validation/spec-validation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Basic validation of working spec
+ * @param {Object} spec - Working spec object
+ * @param {Object} options - Validation options
+ * @returns {Object} Validation result
+ */
+export function validateWorkingSpec(spec: any, _options?: {}): any;
+/**
+ * Enhanced validation with suggestions and auto-fix
+ * @param {Object} spec - Working spec object
+ * @param {Object} options - Validation options
+ * @returns {Object} Enhanced validation result
+ */
+export function validateWorkingSpecWithSuggestions(spec: any, options?: any): any;
+/**
+ * Get suggestion for a missing field
+ * @param {string} field - Field name
+ * @param {Object} _spec - Spec object (for context)
+ * @returns {string} Suggestion text
+ */
+export function getFieldSuggestion(field: string, _spec: any): string;
+/**
+ * Check if a field can be auto-fixed
+ * @param {string} field - Field name
+ * @param {Object} _spec - Spec object (for context)
+ * @returns {boolean} Whether field can be auto-fixed
+ */
+export function canAutoFixField(field: string, _spec: any): boolean;
+/**
+ * Calculate compliance score based on errors and warnings
+ * Score ranges from 0 (many issues) to 1 (perfect)
+ * @param {Array} errors - Validation errors
+ * @param {Array} warnings - Validation warnings
+ * @returns {number} Compliance score (0-1)
+ */
+export function calculateComplianceScore(errors: any[], warnings: any[]): number;
+/**
+ * Get compliance grade from score
+ * @param {number} score - Compliance score (0-1)
+ * @returns {string} Grade (A, B, C, D, F)
+ */
+export function getComplianceGrade(score: number): string;
+//# sourceMappingURL=spec-validation.d.ts.map

package/dist/validation/spec-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-validation.d.ts","sourceRoot":"","sources":["../../src/validation/spec-validation.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,mEA8HC;AAED;;;;;GAKG;AACH,kFAgdC;AAoCD;;;;;GAKG;AACH,0CAJW,MAAM,eAEJ,MAAM,CAkBlB;AAED;;;;;GAKG;AACH,uCAJW,MAAM,eAEJ,OAAO,CAKnB;AAnED;;;;;;GAMG;AACH,0EAFa,MAAM,CAclB;AAED;;;;GAIG;AACH,0CAHW,MAAM,GACJ,MAAM,CAQlB"}

package/dist/validation/spec-validation.js

@@ -5,6 +5,59 @@
  */
 
 const { deriveBudget, checkBudgetCompliance } = require('../budget-derivation');
+const { execSync } = require('child_process');
+
+/**
+ * Get actual budget statistics from git history
+ * Analyzes changes since last tag or initial commit
+ * @param {string} specDir - Project directory
+ * @returns {Object|null} Budget stats or null on failure
+ */
+function getActualBudgetStats(specDir) {
+  const cwd = specDir || process.cwd();
+  try {
+    // Get base ref (last tag or initial commit)
+    let baseRef;
+    try {
+      baseRef = execSync('git describe --tags --abbrev=0 2>/dev/null', {
+        cwd,
+        encoding: 'utf8'
+      }).trim();
+    } catch {
+      // No tags found, use initial commit
+      baseRef = execSync('git rev-list --max-parents=0 HEAD', {
+        cwd,
+        encoding: 'utf8'
+      }).trim();
+    }
+
+    // Count files changed since base ref
+    const filesOutput = execSync(`git diff --name-only ${baseRef}..HEAD`, {
+      cwd,
+      encoding: 'utf8'
+    });
+    const files_changed = filesOutput.trim().split('\n').filter(Boolean).length;
+
+    // Count lines changed (added + removed)
+    const numstatOutput = execSync(`git diff --numstat ${baseRef}..HEAD`, {
+      cwd,
+      encoding: 'utf8'
+    });
+    let lines_changed = 0;
+    for (const line of numstatOutput.trim().split('\n').filter(Boolean)) {
+      const [added, removed] = line.split('\t');
+      // Handle binary files (shown as '-')
+      const addedNum = added === '-' ? 0 : parseInt(added, 10) || 0;
+      const removedNum = removed === '-' ? 0 : parseInt(removed, 10) || 0;
+      lines_changed += addedNum + removedNum;
+    }
+
+    return { files_changed, lines_changed };
+  } catch {
+    // Git not available or not a repository
+    return null;
+  }
+}
 
 /**
  * Basic validation of working spec
@@ -511,14 +564,14 @@ function validateWorkingSpecWithSuggestions(spec, options = {}) {
       try {
         const derivedBudget = deriveBudget(spec, projectRoot);
 
-        // Mock current stats for now - in real implementation this would analyze git changes
-        const mockStats = {
-          files_changed: 50, // This would be calculated from actual changes
-          lines_changed: 5000,
-          risk_tier: spec.risk_tier,
+        // Get actual stats from git history
+        const actualStats = getActualBudgetStats(projectRoot) || {
+          files_changed: 0,
+          lines_changed: 0,
         };
+        actualStats.risk_tier = spec.risk_tier;
 
-        budgetCheck = checkBudgetCompliance(derivedBudget, mockStats);
+        budgetCheck = checkBudgetCompliance(derivedBudget, actualStats);
 
         if (!budgetCheck.compliant) {
           for (const violation of budgetCheck.violations) {

package/dist/waivers-manager.d.ts

@@ -0,0 +1,167 @@
+export = WaiversManager;
+/**
+ * Waiver Manager Class
+ * Handles waiver creation, validation, expiration, and audit logging
+ */
+declare class WaiversManager {
+    constructor(options?: {});
+    projectRoot: any;
+    waiversDir: string;
+    waiversFile: string;
+    auditLogFile: string;
+    /**
+     * Waiver Schema Definition
+     */
+    getWaiverSchema(): {
+        type: string;
+        required: string[];
+        properties: {
+            id: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            reason: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            description: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            gates: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                minItems: number;
+                description: string;
+            };
+            risk_assessment: {
+                type: string;
+                properties: {
+                    impact_level: {
+                        type: string;
+                        enum: string[];
+                    };
+                    mitigation_plan: {
+                        type: string;
+                        minLength: number;
+                    };
+                    review_required: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+            expires_at: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            approved_by: {
+                type: string;
+                description: string;
+            };
+            created_at: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            metadata: {
+                type: string;
+                properties: {
+                    related_pr: {
+                        type: string;
+                    };
+                    related_issue: {
+                        type: string;
+                    };
+                    environment: {
+                        type: string;
+                        enum: string[];
+                    };
+                    urgency: {
+                        type: string;
+                        enum: string[];
+                    };
+                };
+            };
+        };
+    };
+    /**
+     * Create a new waiver
+     */
+    createWaiver(waiverData: any): Promise<{
+        id: string;
+        title: any;
+        reason: any;
+        description: any;
+        gates: any;
+        risk_assessment: any;
+        expires_at: any;
+        approved_by: any;
+        created_at: string;
+        metadata: any;
+    }>;
+    /**
+     * Check if waiver applies to specific gates
+     */
+    checkWaiverCoverage(gatesToCheck: any, context?: {}): Promise<{
+        coveredGates: any[];
+        waiverDetails: {
+            gate: any;
+            waiver_id: any;
+            reason: any;
+            expires_at: any;
+            approved_by: any;
+        }[];
+        allCovered: boolean;
+    }>;
+    /**
+     * Get all active waivers
+     */
+    getActiveWaivers(): Promise<any[]>;
+    /**
+     * Revoke a waiver
+     */
+    revokeWaiver(waiverId: any, reason?: string): Promise<any>;
+    /**
+     * Extend waiver expiration
+     */
+    extendWaiver(waiverId: any, newExpiryDate: any, approvedBy: any): Promise<any>;
+    /**
+     * Get waiver statistics and health metrics
+     */
+    getWaiverStats(): Promise<{
+        total_active: number;
+        by_reason: {};
+        by_risk_level: {};
+        expiring_soon: any[];
+        high_risk: any[];
+        total_gates_waived: number;
+        average_lifespan_days: number;
+    }>;
+    generateWaiverId(): Promise<string>;
+    validateWaiver(waiver: any): {
+        valid: boolean;
+        errors: string[];
+    };
+    checkWaiverConflicts(newWaiver: any): Promise<string[]>;
+    waiverAppliesToContext(waiver: any, context: any): boolean;
+    loadActiveWaivers(): Promise<any[]>;
+    saveActiveWaivers(waivers: any): Promise<void>;
+    auditLog(action: any, waiverId: any, details: any): Promise<void>;
+    flagForReview(waiver: any): Promise<void>;
+}
+//# sourceMappingURL=waivers-manager.d.ts.map

package/dist/waivers-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waivers-manager.d.ts","sourceRoot":"","sources":["../src/waivers-manager.js"],"names":[],"mappings":";AAaA;;;GAGG;AACH;IACE,0BAUC;IATC,iBAAuD;IACvD,mBAAiE;IACjE,oBAAoE;IACpE,qBAAkE;IAQpE;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiGC;IAED;;OAEG;IACH;;;;;;;;;;;OA4DC;IAED;;OAEG;IACH;;;;;;;;;;OA+BC;IAED;;OAEG;IACH,mCAgBC;IAED;;OAEG;IACH,2DAeC;IAED;;OAEG;IACH,+EAuBC;IAED;;OAEG;IACH;;;;;;;;OA2DC;IAID,oCAUC;IAED;;;MAkDC;IAED,wDAkBC;IAED,2DAUC;IAED,oCAyCC;IAED,+CAuBC;IAED,kEAaC;IAED,0CA2CC;CACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@paths.design/caws-cli",
-  "version": "8.0.0",
-  "description": "CAWS CLI - Coding Agent Workflow System command line tools",
+  "version": "8.1.0",
+  "description": "CAWS CLI - Coding Agent Workflow System command-line tools for spec management, quality gates, and AI-assisted development",
   "main": "dist/index.js",
   "bin": {
     "caws": "dist/index.js"
@@ -33,7 +33,8 @@
     "format": "prettier --write src/**/*.js tests/**/*.js",
     "validate": "echo 'CLI package validation not required'",
     "caws:validate": "node ../../.caws/validate.js ../../.caws/working-spec.yaml",
-    "clean": "rm -rf dist test-caws-project .agent && npm run test:cleanup"
+    "clean": "rm -rf dist test-caws-project .agent && npm run test:cleanup",
+    "prepare": "husky"
   },
   "keywords": [
     "caws",
@@ -69,6 +70,7 @@
     "ajv": "8.17.1",
     "esbuild": "0.25.10",
     "eslint": "^9.0.0",
+    "husky": "9.1.7",
     "jest": "30.1.3",
     "js-yaml": "4.1.0",
     "lint-staged": "15.5.2",