@paths.design/caws-cli 6.0.0 → 7.0.1

package/dist/tool-validator.d.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+export = ToolValidator;
+/**
+ * Tool Validator - Security validation and allowlist enforcement
+ */
+declare class ToolValidator {
+    constructor(options?: {});
+    options: {
+        allowlistPath: any;
+        strictMode: boolean;
+        maxFileSize: any;
+    };
+    allowlist: any;
+    validationCache: Map<any, any>;
+    /**
+     * Load and parse the tools allowlist
+     * @returns {Promise<Array<string>>} Array of allowed commands/patterns
+     */
+    loadAllowlist(): Promise<Array<string>>;
+    /**
+     * Validate a tool against security requirements
+     * @param {Object} tool - Tool object with module and metadata
+     * @returns {Promise<Object>} Validation result
+     */
+    validateTool(tool: any): Promise<any>;
+    /**
+     * Check file-level security
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkFileSecurity;
+    /**
+     * Check code-level security
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkCodeSecurity;
+    /**
+     * Check interface compliance
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkInterfaceCompliance;
+    /**
+     * Check metadata validity
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkMetadataValidity;
+    /**
+     * Check dependency safety
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkDependencySafety;
+    /**
+     * Validate a command against the allowlist
+     * @param {string} command - Command to validate
+     * @returns {boolean} True if command is allowed
+     */
+    validateCommand(command: string): boolean;
+    /**
+     * Clear validation cache
+     */
+    clearCache(): void;
+    /**
+     * Get validator statistics
+     * @returns {Object} Statistics object
+     */
+    getStats(): any;
+}
+//# sourceMappingURL=tool-validator.d.ts.map

package/dist/tool-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-validator.d.ts","sourceRoot":"","sources":["../src/tool-validator.js"],"names":[],"mappings":";;AAYA;;GAEG;AACH;IACE,0BAWC;IAVC;;;;MAMC;IAED,eAAqB;IACrB,+BAAgC;IAGlC;;;OAGG;IACH,iBAFa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAqBlC;IAED;;;;OAIG;IACH,yBAFa,OAAO,KAAQ,CAsF3B;IAED;;;;OAIG;IACH,0BAgCC;IAED;;;;OAIG;IACH,0BA8CC;IAED;;;;OAIG;IACH,iCAkBC;IAED;;;;OAIG;IACH,8BAqCC;IAED;;;;OAIG;IACH,8BA4BC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAmBnB;IAED;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,gBAOC;CACF"}

package/dist/utils/detection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Detect CAWS setup in a directory
+ * @param {string} cwd - Current working directory
+ * @returns {Object} Setup information
+ */
+export function detectCAWSSetup(cwd?: string): any;
+//# sourceMappingURL=detection.d.ts.map

package/dist/utils/detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection.d.ts","sourceRoot":"","sources":["../../src/utils/detection.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,sCAHW,MAAM,OA6JhB"}

package/dist/utils/finalization.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Generate provenance manifest and git initialization (for both modes)
+ * @param {string} projectName - Project name
+ * @param {Object} options - Command options
+ * @param {Object} answers - User answers
+ */
+export function finalizeProject(projectName: string, options: any, answers: any): Promise<void>;
+/**
+ * Display success message after project initialization
+ */
+export function continueToSuccess(): void;
+/**
+ * Set dependencies for finalization utilities
+ * @param {Object} deps - Dependencies object
+ */
+export function setFinalizationDependencies(deps: any): void;
+//# sourceMappingURL=finalization.d.ts.map

package/dist/utils/finalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalization.d.ts","sourceRoot":"","sources":["../../src/utils/finalization.js"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,6CAJW,MAAM,6CAgKhB;AAED;;GAEG;AACH,0CA0BC;AA1MD;;;GAGG;AACH,6DAGC"}

package/dist/utils/project-analysis.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Detect project type from existing files and structure
+ * @param {string} cwd - Current working directory
+ * @returns {string} Project type
+ */
+export function detectProjectType(cwd?: string): string;
+/**
+ * Detect if current directory appears to be a project that should be initialized directly
+ * @param {string} projectName - Project name from command line
+ * @param {string} currentDir - Current directory path
+ * @returns {boolean} Whether to init in current directory
+ */
+export function shouldInitInCurrentDirectory(projectName: string, currentDir: string): boolean;
+//# sourceMappingURL=project-analysis.d.ts.map

package/dist/utils/project-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-analysis.d.ts","sourceRoot":"","sources":["../../src/utils/project-analysis.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,wCAHW,MAAM,GACJ,MAAM,CAmDlB;AAED;;;;;GAKG;AACH,0DAJW,MAAM,cACN,MAAM,GACJ,OAAO,CA8BnB"}

package/dist/utils/project-analysis.js

@@ -99,7 +99,110 @@ function shouldInitInCurrentDirectory(projectName, currentDir) {
   return hasProjectIndicators;
 }
 
+/**
+ * Detect if project publishes packages to registries
+ * Checks for publishing configuration in package.json, pyproject.toml, etc.
+ * @param {string} cwd - Current working directory
+ * @returns {boolean} Whether project appears to publish packages
+ */
+function detectsPublishing(cwd = process.cwd()) {
+  const files = fs.readdirSync(cwd);
+
+  // Check package.json for npm publishing
+  if (files.includes('package.json')) {
+    try {
+      const packageJson = JSON.parse(
+        fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')
+      );
+
+      // Indicators of publishing:
+      // - Has publishConfig
+      // - Has scripts that include "publish"
+      // - Has name that suggests it's a published package
+      // - Has repository field (often indicates published package)
+      const hasPublishConfig = packageJson.publishConfig;
+      const hasPublishScript =
+        packageJson.scripts &&
+        Object.keys(packageJson.scripts).some((key) =>
+          key.toLowerCase().includes('publish')
+        );
+      const hasScopedName = packageJson.name && packageJson.name.startsWith('@');
+      const hasRepository = packageJson.repository;
+
+      if (hasPublishConfig || hasPublishScript || (hasScopedName && hasRepository)) {
+        return true;
+      }
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  // Check pyproject.toml for PyPI publishing
+  if (files.includes('pyproject.toml')) {
+    try {
+      const pyprojectContent = fs.readFileSync(
+        path.join(cwd, 'pyproject.toml'),
+        'utf8'
+      );
+
+      // Check for build system and project metadata (indicates publishable package)
+      const hasBuildSystem = pyprojectContent.includes('[build-system]');
+      const hasProjectMetadata = pyprojectContent.includes('[project]');
+      const hasToolPublish = pyprojectContent.includes('[tool.publish]') ||
+                            pyprojectContent.includes('[tool.twine]');
+
+      if ((hasBuildSystem && hasProjectMetadata) || hasToolPublish) {
+        return true;
+      }
+    } catch (e) {
+      // Ignore read errors
+    }
+  }
+
+  // Check for Maven publishing (pom.xml)
+  if (files.includes('pom.xml')) {
+    return true; // Maven projects typically publish
+  }
+
+  // Check for .csproj (NuGet publishing)
+  const csprojFiles = files.filter((f) => f.endsWith('.csproj'));
+  if (csprojFiles.length > 0) {
+    return true; // .NET projects typically publish
+  }
+
+  // Check for GitHub Actions workflows that publish
+  const workflowsPath = path.join(cwd, '.github', 'workflows');
+  if (fs.existsSync(workflowsPath)) {
+    try {
+      const workflowFiles = fs.readdirSync(workflowsPath);
+      for (const workflowFile of workflowFiles) {
+        if (workflowFile.endsWith('.yml') || workflowFile.endsWith('.yaml')) {
+          const workflowContent = fs.readFileSync(
+            path.join(workflowsPath, workflowFile),
+            'utf8'
+          );
+          // Check for common publishing actions/commands
+          if (
+            workflowContent.includes('npm publish') ||
+            workflowContent.includes('pypa/gh-action-pypi-publish') ||
+            workflowContent.includes('publish-to-npm') ||
+            workflowContent.includes('semantic-release') ||
+            workflowContent.includes('publish')
+          ) {
+            return true;
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore read errors
+    }
+  }
+
+  return false;
+}
+
 module.exports = {
   detectProjectType,
   shouldInitInCurrentDirectory,
+  detectsPublishing,
 };

package/dist/utils/quality-gates.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Get staged files from git
+ * @returns {string[]} Array of staged file paths
+ */
+export function getStagedFiles(): string[];
+/**
+ * Check for god objects in staged files
+ * @param {string[]} stagedFiles - Array of staged file paths
+ * @param {string} language - Language to check ('rust', 'typescript', etc.)
+ * @returns {Object} God object analysis results
+ */
+export function checkGodObjects(stagedFiles: string[], language?: string): any;
+/**
+ * Check for hidden TODOs in staged files
+ * @param {string[]} stagedFiles - Array of staged file paths
+ * @returns {Object} TODO analysis results
+ */
+export function checkHiddenTodos(stagedFiles: string[]): any;
+/**
+ * Check if a waiver applies to the given gate
+ * @param {string} gate - Gate name to check
+ * @returns {Object} Waiver check result
+ */
+export function checkWaiver(gate: string): any;
+/**
+ * Detect if project is in crisis response mode
+ * @returns {boolean} True if in crisis mode
+ */
+export function detectCrisisMode(): boolean;
+/**
+ * Run comprehensive quality gates on staged files
+ * @param {Object} options - Options for quality gates
+ * @returns {Object} Quality gate results
+ */
+export function runQualityGates(options?: any): any;
+export namespace CONFIG {
+    namespace godObjectThresholds {
+        let warning: number;
+        let critical: number;
+    }
+    let todoConfidenceThreshold: number;
+    let supportedExtensions: string[];
+    namespace crisisResponseThresholds {
+        export let godObjectCritical: number;
+        let todoConfidenceThreshold_1: number;
+        export { todoConfidenceThreshold_1 as todoConfidenceThreshold };
+    }
+}
+//# sourceMappingURL=quality-gates.d.ts.map

package/dist/utils/quality-gates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-gates.d.ts","sourceRoot":"","sources":["../../src/utils/quality-gates.js"],"names":[],"mappings":"AAyGA;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAcpB;AAED;;;;;GAKG;AACH,6CAJW,MAAM,EAAE,aACR,MAAM,OAqDhB;AAED;;;;GAIG;AACH,8CAHW,MAAM,EAAE,OA2ClB;AApMD;;;;GAIG;AACH,kCAHW,MAAM,OAiChB;AAED;;;GAGG;AACH,oCAFa,OAAO,CAkCnB;AA6HD;;;;GAIG;AACH,oDAqHC"}

package/dist/utils/spec-resolver.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Resolve spec file path based on priority
+ * @param {Object} options - Resolution options
+ * @param {string} [options.specId] - Feature-specific spec ID (e.g., 'user-auth', 'FEAT-001')
+ * @param {string} [options.specFile] - Explicit file path override
+ * @param {boolean} [options.warnLegacy=true] - Warn when falling back to legacy spec
+ * @param {boolean} [options.interactive=false] - Use interactive spec selection for multiple specs
+ * @returns {Promise<{path: string, type: 'feature' | 'legacy', spec: Object}>}
+ */
+export function resolveSpec(options?: {
+    specId?: string;
+    specFile?: string;
+    warnLegacy?: boolean;
+    interactive?: boolean;
+}): Promise<{
+    path: string;
+    type: "feature" | "legacy";
+    spec: any;
+}>;
+/**
+ * List all available specs
+ * @returns {Promise<Array<{id: string, path: string, type: string}>>}
+ */
+export function listAvailableSpecs(): Promise<Array<{
+    id: string;
+    path: string;
+    type: string;
+}>>;
+/**
+ * Check if project is using multi-spec architecture
+ * @returns {Promise<{isMultiSpec: boolean, specCount: number, needsMigration: boolean}>}
+ */
+export function checkMultiSpecStatus(): Promise<{
+    isMultiSpec: boolean;
+    specCount: number;
+    needsMigration: boolean;
+}>;
+/**
+ * Check for scope conflicts between specs
+ * @param {string[]} specIds - Array of spec IDs to check
+ * @returns {Promise<Array<{spec1: string, spec2: string, conflicts: string[]}>>} Array of conflicts
+ */
+export function checkScopeConflicts(specIds: string[]): Promise<Array<{
+    spec1: string;
+    spec2: string;
+    conflicts: string[];
+}>>;
+/**
+ * Suggest migration from legacy to multi-spec
+ * @returns {Promise<void>}
+ */
+export function suggestMigration(): Promise<void>;
+/**
+ * Interactive spec selection using readline
+ * @param {string[]} specIds - Available spec IDs
+ * @returns {Promise<string>} Selected spec ID
+ */
+export function interactiveSpecSelection(specIds: string[]): Promise<string>;
+/**
+ * Load specs registry
+ * @returns {Promise<Object>} Registry data
+ */
+export function loadSpecsRegistry(): Promise<any>;
+export function suggestFeatureBreakdown(legacySpec: any): {
+    id: string;
+    title: any;
+    criteria: any;
+    scope: {
+        in: string[];
+        out: any[];
+    };
+}[];
+/**
+ * Check if two paths overlap (simplified implementation)
+ * @param {string} path1 - First path
+ * @param {string} path2 - Second path
+ * @returns {boolean} True if paths overlap
+ */
+export function pathsOverlap(path1: string, path2: string): boolean;
+/**
+ * Spec resolution priority:
+ * 1. .caws/specs/<spec-id>.yaml (feature-specific, multi-agent safe)
+ * 2. .caws/working-spec.yaml (legacy, single-agent only)
+ */
+export const SPECS_DIR: ".caws/specs";
+export const LEGACY_SPEC: ".caws/working-spec.yaml";
+export const SPECS_REGISTRY: ".caws/specs/registry.json";
+//# sourceMappingURL=spec-resolver.d.ts.map

package/dist/utils/spec-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/spec-resolver.js"],"names":[],"mappings":"AAwBA;;;;;;;;GAQG;AACH,sCANG;IAAyB,MAAM,GAAvB,MAAM;IACW,QAAQ,GAAzB,MAAM;IACY,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;CACf,GAAU,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAAC,IAAI,MAAQ;CAAC,CAAC,CAwK7E;AA6BD;;;GAGG;AACH,sCAFa,OAAO,CAAC,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,CAoDpE;AAgDD;;;GAGG;AACH,wCAFa,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAAC,CAAC,CAavF;AAED;;;;GAIG;AACH,6CAHW,MAAM,EAAE,GACN,OAAO,CAAC,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CAAC,CA2D/E;AA+DD;;;GAGG;AACH,oCAFa,OAAO,CAAC,IAAI,CAAC,CAczB;AA5MD;;;;GAIG;AACH,kDAHW,MAAM,EAAE,GACN,OAAO,CAAC,MAAM,CAAC,CAyC3B;AA/HD;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAuB3B;AAyQD;;;;;;;;IA+FC;AA/KD;;;;;GAKG;AACH,oCAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAuDnB;AAvcD;;;;GAIG;AACH,wBAAkB,aAAa,CAAC;AAChC,0BAAoB,yBAAyB,CAAC;AAC9C,6BAAuB,2BAA2B,CAAC"}

package/dist/utils/typescript-detector.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Detect if project is using TypeScript
+ * @param {string} projectDir - Project directory path
+ * @returns {Object} TypeScript detection result
+ */
+export function detectTypeScript(projectDir?: string): any;
+/**
+ * Detect testing framework in use
+ * @param {string} projectDir - Project directory path
+ * @param {Object} packageJson - Parsed package.json (optional)
+ * @returns {Object} Testing framework detection result
+ */
+export function detectTestFramework(projectDir?: string, packageJson?: any): any;
+export function getWorkspaceDirectories(projectDir?: string): string[];
+/**
+ * Get workspace directories from package.json
+ * @param {string} projectDir - Project directory path
+ * @returns {string[]} Array of workspace directories
+ */
+/**
+ * Get workspace directories from npm/yarn package.json workspaces
+ * @param {string} projectDir - Project directory path
+ * @returns {string[]} Array of workspace directories
+ */
+export function getNpmWorkspaces(projectDir: string): string[];
+/**
+ * Get workspace directories from pnpm-workspace.yaml
+ * @param {string} projectDir - Project directory path
+ * @returns {string[]} Array of workspace directories
+ */
+export function getPnpmWorkspaces(projectDir: string): string[];
+/**
+ * Get workspace directories from lerna.json
+ * @param {string} projectDir - Project directory path
+ * @returns {string[]} Array of workspace directories
+ */
+export function getLernaWorkspaces(projectDir: string): string[];
+/**
+ * Check if a dependency exists in hoisted node_modules
+ * @param {string} depName - Dependency name to check
+ * @param {string} projectDir - Project directory path
+ * @returns {boolean} True if dependency found in hoisted node_modules
+ */
+export function checkHoistedDependency(depName: string, projectDir: string): boolean;
+/**
+ * Check if TypeScript project needs test configuration
+ * @param {string} projectDir - Project directory path
+ * @returns {Object} Configuration status
+ */
+export function checkTypeScriptTestConfig(projectDir?: string): any;
+/**
+ * Generate configuration recommendations
+ * @param {Object} tsDetection - TypeScript detection result
+ * @param {Object} testDetection - Test framework detection result
+ * @returns {string[]} Array of recommendations
+ */
+export function generateRecommendations(tsDetection: any, testDetection: any): string[];
+/**
+ * Display TypeScript detection results
+ * @param {Object} detection - Detection result from checkTypeScriptTestConfig
+ */
+export function displayTypeScriptDetection(detection: any): void;
+//# sourceMappingURL=typescript-detector.d.ts.map

package/dist/utils/typescript-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-detector.d.ts","sourceRoot":"","sources":["../../src/utils/typescript-detector.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,8CAHW,MAAM,OAkChB;AAED;;;;;GAKG;AACH,iDAJW,MAAM,0BAkDhB;AAuKD,uEASC;AA9KD;;;;GAIG;AACH;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,EAAE,CA6CpB;AAED;;;;GAIG;AACH,8CAHW,MAAM,GACJ,MAAM,EAAE,CA6CpB;AAED;;;;GAIG;AACH,+CAHW,MAAM,GACJ,MAAM,EAAE,CA4CpB;AAED;;;;;GAKG;AACH,gDAJW,MAAM,cACN,MAAM,GACJ,OAAO,CAKnB;AAaD;;;;GAIG;AACH,uDAHW,MAAM,OA0EhB;AAED;;;;;GAKG;AACH,+EAFa,MAAM,EAAE,CAuBpB;AAED;;;GAGG;AACH,iEAoBC"}

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,kFAyWC;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/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,6 +1,6 @@
 {
   "name": "@paths.design/caws-cli",
-  "version": "6.0.0",
+  "version": "7.0.1",
   "description": "CAWS CLI - Coding Agent Workflow System command line tools",
   "main": "dist/index.js",
   "bin": {