@paths.design/caws-cli 5.0.1 → 5.1.0

package/dist/commands/quality-monitor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quality monitor command handler
+ *
+ * @param {string} action - Type of action to monitor
+ * @param {object} options - Command options
+ */
+export function qualityMonitorCommand(action: string, options?: object): Promise<void>;
+/**
+ * Analyze quality impact of an action
+ *
+ * @param {string} action - Type of action (file_saved, code_edited, test_run)
+ * @param {array} files - Files affected by the action
+ * @param {object} context - Additional context information
+ * @returns {object} Quality analysis
+ */
+export function analyzeQualityImpact(action: string, files?: any[], context?: object): object;
+//# sourceMappingURL=quality-monitor.d.ts.map

package/dist/commands/quality-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-monitor.d.ts","sourceRoot":"","sources":["../../src/commands/quality-monitor.js"],"names":[],"mappings":"AAoIA;;;;;GAKG;AACH,8CAHW,MAAM,YACN,MAAM,iBA2HhB;AArPD;;;;;;;GAOG;AACH,6CALW,MAAM,2BAEN,MAAM,GACJ,MAAM,CA8GlB"}

package/dist/commands/specs.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Specs command handler
+ * @param {string} action - Action to perform (list, create, show, update, delete, conflicts, migrate)
+ * @param {Object} options - Command options
+ */
+export function specsCommand(action: string, options?: any): Promise<any>;
+/**
+ * Load specs registry
+ * @returns {Promise<Object>} Registry data
+ */
+export function loadSpecsRegistry(): Promise<any>;
+/**
+ * Save specs registry
+ * @param {Object} registry - Registry data
+ * @returns {Promise<void>}
+ */
+export function saveSpecsRegistry(registry: any): Promise<void>;
+/**
+ * List all spec files in the specs directory
+ * @returns {Promise<Array>} Array of spec file info
+ */
+export function listSpecFiles(): Promise<any[]>;
+/**
+ * Create a new spec file
+ * @param {string} id - Spec identifier
+ * @param {Object} options - Creation options
+ * @returns {Promise<Object>} Created spec info
+ */
+export function createSpec(id: string, options?: any): Promise<any>;
+/**
+ * Load a specific spec file
+ * @param {string} id - Spec identifier
+ * @returns {Promise<Object|null>} Spec data or null
+ */
+export function loadSpec(id: string): Promise<any | null>;
+/**
+ * Update a spec file
+ * @param {string} id - Spec identifier
+ * @param {Object} updates - Updates to apply
+ * @returns {Promise<boolean>} Success status
+ */
+export function updateSpec(id: string, updates?: any): Promise<boolean>;
+/**
+ * Delete a spec file
+ * @param {string} id - Spec identifier
+ * @returns {Promise<boolean>} Success status
+ */
+export function deleteSpec(id: string): Promise<boolean>;
+/**
+ * Display specs in a formatted table
+ * @param {Array} specs - Array of spec objects
+ */
+export function displaySpecsTable(specs: any[]): void;
+/**
+ * Display detailed spec information
+ * @param {Object} spec - Spec object
+ */
+export function displaySpecDetails(spec: any): void;
+/**
+ * Ask user how to resolve spec creation conflicts
+ * @returns {Promise<string>} User's choice: 'cancel', 'rename', 'merge', 'override'
+ */
+export function askConflictResolution(): Promise<string>;
+/**
+ * Specs directory structure
+ */
+export const SPECS_DIR: ".caws/specs";
+export const SPECS_REGISTRY: ".caws/specs/registry.json";
+import { SPEC_TYPES } from "../constants/spec-types";
+export { SPEC_TYPES };
+//# sourceMappingURL=specs.d.ts.map

package/dist/commands/specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specs.d.ts","sourceRoot":"","sources":["../../src/commands/specs.js"],"names":[],"mappings":"AAghBA;;;;GAIG;AACH,qCAHW,MAAM,+BA2LhB;AAvrBD;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAqB3B;AAED;;;;GAIG;AACH,kDAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;AAED;;;GAGG;AACH,iCAFa,OAAO,OAAO,CAmC1B;AAED;;;;;GAKG;AACH,+BAJW,MAAM,kBAEJ,OAAO,KAAQ,CA8H3B;AAED;;;;GAIG;AACH,6BAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAiBhC;AAED;;;;;GAKG;AACH,+BAJW,MAAM,kBAEJ,OAAO,CAAC,OAAO,CAAC,CA6B5B;AAED;;;;GAIG;AACH,+BAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAmB5B;AAED;;;GAGG;AACH,sDA2CC;AAED;;;GAGG;AACH,oDAoCC;AAsFD;;;GAGG;AACH,yCAFa,OAAO,CAAC,MAAM,CAAC,CAuC3B;AA9fD;;GAEG;AACH,wBAAkB,aAAa,CAAC;AAChC,6BAAuB,2BAA2B,CAAC"}

package/dist/commands/specs.js

@@ -9,6 +9,7 @@ const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
 const { safeAsync, outputResult } = require('../error-handler');
+const { question, closeReadline } = require('../utils/promise-utils');
 const { SPEC_TYPES } = require('../constants/spec-types');
 
 // Import suggestFeatureBreakdown from spec-resolver
@@ -488,42 +489,40 @@ async function migrateFromLegacy(options = {}) {
  * @returns {Promise<string>} User's choice: 'cancel', 'rename', 'merge', 'override'
  */
 async function askConflictResolution() {
-  return new Promise((resolve) => {
-    const readline = require('readline');
-
-    console.log(chalk.blue('\n🔄 Conflict Resolution Options:'));
-    console.log(chalk.gray("   1. Cancel - Don't create the spec"));
-    console.log(chalk.gray('   2. Rename - Create with auto-generated name'));
-    console.log(chalk.gray('   3. Merge - Merge with existing spec (not implemented)'));
-    console.log(chalk.gray('   4. Override - Replace existing spec (use --force)'));
-
-    console.log(chalk.yellow('\nEnter your choice (1-4) or the option name:'));
-
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    rl.question('> ', (answer) => {
-      rl.close();
-
-      const trimmed = answer.trim().toLowerCase();
-
-      // Handle numeric choices
-      if (trimmed === '1' || trimmed === 'cancel') {
-        resolve('cancel');
-      } else if (trimmed === '2' || trimmed === 'rename') {
-        resolve('rename');
-      } else if (trimmed === '3' || trimmed === 'merge') {
-        resolve('merge');
-      } else if (trimmed === '4' || trimmed === 'override') {
-        resolve('override');
-      } else {
-        console.log(chalk.red('❌ Invalid choice. Defaulting to cancel.'));
-        resolve('cancel');
-      }
-    });
+  const readline = require('readline');
+
+  console.log(chalk.blue('\n🔄 Conflict Resolution Options:'));
+  console.log(chalk.gray("   1. Cancel - Don't create the spec"));
+  console.log(chalk.gray('   2. Rename - Create with auto-generated name'));
+  console.log(chalk.gray('   3. Merge - Merge with existing spec (not implemented)'));
+  console.log(chalk.gray('   4. Override - Replace existing spec (use --force)'));
+  console.log(chalk.yellow('\nEnter your choice (1-4) or the option name:'));
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
   });
+
+  try {
+    const answer = await question(rl, '> ');
+    const trimmed = answer.trim().toLowerCase();
+
+    // Handle numeric choices
+    if (trimmed === '1' || trimmed === 'cancel') {
+      return 'cancel';
+    } else if (trimmed === '2' || trimmed === 'rename') {
+      return 'rename';
+    } else if (trimmed === '3' || trimmed === 'merge') {
+      return 'merge';
+    } else if (trimmed === '4' || trimmed === 'override') {
+      return 'override';
+    } else {
+      console.log(chalk.red('❌ Invalid choice. Defaulting to cancel.'));
+      return 'cancel';
+    }
+  } finally {
+    await closeReadline(rl);
+  }
 }
 
 /**

package/dist/commands/status.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Status command handler
+ * @param {Object} options - Command options
+ */
+export function statusCommand(options?: any): Promise<any>;
+/**
+ * Load working specification (legacy single file approach)
+ * @param {string} specPath - Path to working spec
+ * @returns {Promise<Object|null>} Parsed spec or null
+ */
+export function loadWorkingSpec(specPath?: string): Promise<any | null>;
+/**
+ * Check Git hooks status
+ * @returns {Promise<Object>} Hooks status
+ */
+export function checkGitHooks(): Promise<any>;
+/**
+ * Load provenance chain
+ * @returns {Promise<Object>} Provenance status
+ */
+export function loadProvenanceChain(): Promise<any>;
+/**
+ * Load waiver status
+ * @returns {Promise<Object>} Waiver status
+ */
+export function loadWaiverStatus(): Promise<any>;
+/**
+ * Check quality gates status (simplified)
+ * @returns {Promise<Object>} Quality gates status
+ */
+export function checkQualityGates(): Promise<any>;
+/**
+ * Display project status
+ * @param {Object} data - Status data
+ */
+export function displayStatus(data: any): void;
+/**
+ * Generate actionable suggestions based on status and mode
+ * @param {Object} data - Status data
+ * @param {string} currentMode - Current CAWS mode
+ * @returns {string[]} Array of suggestions
+ */
+export function generateSuggestions(data: any, currentMode: string): string[];
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.js"],"names":[],"mappings":"AA6uBA;;;GAGG;AACH,2DA6IC;AAl3BD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAahC;AAgBD;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAgC3B;AAED;;;GAGG;AACH,uCAFa,OAAO,KAAQ,CA+B3B;AAED;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA0D3B;AAED;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAS3B;AAwBD;;;GAGG;AACH,+CAgGC;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,EAAE,CAoCpB"}

package/dist/commands/status.js

@@ -9,6 +9,7 @@ const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
 const { safeAsync, outputResult } = require('../error-handler');
+const { parallel } = require('../utils/async-utils');
 
 /**
  * Load working specification (legacy single file approach)
@@ -758,13 +759,15 @@ async function statusCommand(options = {}) {
       const modes = require('../config/modes');
       const currentMode = await modes.getCurrentMode();
 
-      // Load all status data
-      const spec = await loadWorkingSpec(options.spec || '.caws/working-spec.yaml');
-      const specs = await loadSpecsFromMultiSpec();
-      const hooks = await checkGitHooks();
-      const provenance = await loadProvenanceChain();
-      const waivers = await loadWaiverStatus();
-      const gates = await checkQualityGates();
+      // Load all status data in parallel for better performance
+      const [spec, specs, hooks, provenance, waivers, gates] = await parallel([
+        () => loadWorkingSpec(options.spec || '.caws/working-spec.yaml'),
+        () => loadSpecsFromMultiSpec(),
+        () => checkGitHooks(),
+        () => loadProvenanceChain(),
+        () => loadWaiverStatus(),
+        () => checkQualityGates(),
+      ]);
 
       // Display status (visual mode if requested)
       if (options.visual || options.json) {

package/dist/commands/templates.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Templates command handler
+ * @param {string} subcommand - Subcommand (list, info)
+ * @param {Object} options - Command options
+ */
+export function templatesCommand(subcommand?: string, options?: any): Promise<void>;
+/**
+ * List all available templates
+ */
+export function listTemplates(): void;
+/**
+ * Show detailed template information
+ * @param {string} templateId - Template ID
+ */
+export function showTemplateInfo(templateId: string): void;
+/**
+ * Check which templates actually exist
+ * @returns {Object} Available templates
+ */
+export function getAvailableTemplates(): any;
+/**
+ * Built-in template definitions
+ */
+export const BUILTIN_TEMPLATES: {
+    'typescript-library': {
+        name: string;
+        description: string;
+        category: string;
+        tier: number;
+        features: string[];
+        path: string;
+    };
+    'typescript-api': {
+        name: string;
+        description: string;
+        category: string;
+        tier: number;
+        features: string[];
+        path: string;
+    };
+    'typescript-monorepo': {
+        name: string;
+        description: string;
+        category: string;
+        tier: number;
+        features: string[];
+        path: string;
+    };
+    'javascript-package': {
+        name: string;
+        description: string;
+        category: string;
+        tier: number;
+        features: string[];
+        path: string;
+    };
+    'react-component-lib': {
+        name: string;
+        description: string;
+        category: string;
+        tier: number;
+        features: string[];
+        path: string;
+    };
+    'vscode-extension': {
+        name: string;
+        description: string;
+        category: string;
+        tier: number;
+        features: string[];
+        path: string;
+    };
+};
+//# sourceMappingURL=templates.d.ts.map

package/dist/commands/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/commands/templates.js"],"names":[],"mappings":"AAoMA;;;;GAIG;AACH,8CAHW,MAAM,gCA4BhB;AAvHD;;GAEG;AACH,sCAuCC;AAED;;;GAGG;AACH,6CAFW,MAAM,QAyChB;AA9GD;;;GAGG;AACH,6CAiBC;AA/FD;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDE"}

package/dist/commands/tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Initialize tool system
+ * @returns {Promise<ToolLoader|null>} Initialized tool loader or null if failed
+ */
+export function initializeToolSystem(): Promise<ToolLoader | null>;
+/**
+ * Execute tool command handler
+ * @param {string} toolId - ID of the tool to execute
+ * @param {Object} options - Command options
+ */
+export function executeTool(toolId: string, options: any): Promise<void>;
+import ToolLoader = require("../tool-loader");
+//# sourceMappingURL=tool.d.ts.map

package/dist/commands/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/commands/tool.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,wCAFa,OAAO,CAAC,UAAU,GAAC,IAAI,CAAC,CAoCpC;AAED;;;;GAIG;AACH,oCAHW,MAAM,+BAyEhB"}

package/dist/commands/tool.js

@@ -5,7 +5,7 @@
  */
 
 const path = require('path');
-const chalk = require('chalk');
+const { commandWrapper, Output } = require('../utils/command-wrapper');
 
 // Import tool system
 const ToolLoader = require('../tool-loader');
@@ -32,16 +32,19 @@ async function initializeToolSystem() {
     // Set up event listeners for tool system
     toolLoader.on('discovery:complete', ({ tools: _tools, count }) => {
       if (count > 0) {
-        console.log(chalk.blue(`🔧 Discovered ${count} tools`));
+        Output.info(`Discovered ${count} tools`);
       }
     });
 
     toolLoader.on('tool:loaded', ({ id, metadata }) => {
-      console.log(chalk.gray(`  ✓ Loaded tool: ${metadata.name} (${id})`));
+      // Only log in verbose mode or when not using JSON output
+      if (!process.env.CAWS_OUTPUT_FORMAT || process.env.CAWS_OUTPUT_FORMAT !== 'json') {
+        console.log(`  ✓ Loaded tool: ${metadata.name} (${id})`);
+      }
     });
 
     toolLoader.on('tool:error', ({ id, error }) => {
-      console.warn(chalk.yellow(`⚠️  Failed to load tool ${id}: ${error}`));
+      Output.warning(`Failed to load tool ${id}: ${error}`);
     });
 
     // Auto-discover tools on initialization
@@ -49,8 +52,10 @@ async function initializeToolSystem() {
 
     return toolLoader;
   } catch (error) {
-    console.warn(chalk.yellow('⚠️  Tool system initialization failed:'), error.message);
-    console.warn(chalk.blue('💡 Continuing without dynamic tools'));
+    Output.warning(
+      `Tool system initialization failed: ${error.message}`,
+      'Continuing without dynamic tools'
+    );
     return null;
   }
 }
@@ -61,75 +66,70 @@ async function initializeToolSystem() {
  * @param {Object} options - Command options
  */
 async function executeTool(toolId, options) {
-  try {
-    // Initialize tool system
-    const loader = await initializeToolSystem();
+  return commandWrapper(
+    async () => {
+      // Initialize tool system
+      const loader = await initializeToolSystem();
 
-    if (!loader) {
-      console.error(chalk.red('❌ Tool system not available'));
-      process.exit(1);
-    }
+      if (!loader) {
+        throw new Error('Tool system not available');
+      }
 
-    // Load all tools first
-    await loader.loadAllTools();
-    const tool = loader.getTool(toolId);
+      // Load all tools first
+      await loader.loadAllTools();
+      const tool = loader.getTool(toolId);
 
-    if (!tool) {
-      console.error(chalk.red(`❌ Tool '${toolId}' not found`));
-      console.log(chalk.blue('💡 Available tools:'));
-      const tools = loader.getAllTools();
-      for (const [id, t] of tools) {
-        console.log(`   - ${id}: ${t.metadata.name}`);
+      if (!tool) {
+        const tools = loader.getAllTools();
+        const availableTools = Array.from(tools, ([id, t]) => `${id}: ${t.metadata.name}`).join(
+          ', '
+        );
+        throw new Error(`Tool '${toolId}' not found.\n` + `Available tools: ${availableTools}`);
       }
-      process.exit(1);
-    }
 
-    // Validate tool before execution
-    const validation = await toolValidator.validateTool(tool);
-    if (!validation.valid) {
-      console.error(chalk.red('❌ Tool validation failed:'));
-      validation.errors.forEach((error) => {
-        console.error(`   ${chalk.red('✗')} ${error}`);
-      });
-      process.exit(1);
-    }
+      // Validate tool before execution
+      const validation = await toolValidator.validateTool(tool);
+      if (!validation.valid) {
+        throw new Error(
+          `Tool validation failed:\n` + validation.errors.map((e) => `  - ${e}`).join('\n')
+        );
+      }
 
-    // Parse parameters
-    let params = {};
-    if (options.params) {
-      try {
-        params = JSON.parse(options.params);
-      } catch (error) {
-        console.error(chalk.red('❌ Invalid JSON parameters:'), error.message);
-        process.exit(1);
+      // Parse parameters
+      let params = {};
+      if (options.params) {
+        try {
+          params = JSON.parse(options.params);
+        } catch (error) {
+          throw new Error(`Invalid JSON parameters: ${error.message}`);
+        }
       }
-    }
 
-    console.log(chalk.blue(`🚀 Executing tool: ${tool.metadata.name}`));
+      Output.progress(`Executing tool: ${tool.metadata.name}`);
 
-    // Execute tool
-    const result = await tool.module.execute(params, {
-      workingDirectory: process.cwd(),
-      timeout: options.timeout,
-    });
+      // Execute tool
+      const result = await tool.module.execute(params, {
+        workingDirectory: process.cwd(),
+        timeout: options.timeout,
+      });
 
-    // Display results
-    if (result.success) {
-      console.log(chalk.green('✅ Tool execution successful'));
-      if (result.output && typeof result.output === 'object') {
-        console.log(chalk.gray('Output:'), JSON.stringify(result.output, null, 2));
+      // Display results
+      if (result.success) {
+        Output.success('Tool execution successful', {
+          output: result.output,
+        });
+        return result;
+      } else {
+        throw new Error(
+          `Tool execution failed:\n` + result.errors.map((e) => `  - ${e}`).join('\n')
+        );
       }
-    } else {
-      console.error(chalk.red('❌ Tool execution failed'));
-      result.errors.forEach((error) => {
-        console.error(`   ${chalk.red('✗')} ${error}`);
-      });
-      process.exit(1);
+    },
+    {
+      commandName: `tool ${toolId}`,
+      context: { toolId, options },
     }
-  } catch (error) {
-    console.error(chalk.red(`❌ Error executing tool ${toolId}:`), error.message);
-    process.exit(1);
-  }
+  );
 }
 
 module.exports = {

package/dist/commands/troubleshoot.d.ts

@@ -0,0 +1,8 @@
+export = troubleshootCommand;
+/**
+ * Troubleshoot command handler
+ * @param {string} guide - Guide key argument
+ * @param {Object} options - Command options
+ */
+declare function troubleshootCommand(guide: string, options: any): void;
+//# sourceMappingURL=troubleshoot.d.ts.map

package/dist/commands/troubleshoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"troubleshoot.d.ts","sourceRoot":"","sources":["../../src/commands/troubleshoot.js"],"names":[],"mappings":";AAqFA;;;;GAIG;AACH,4CAHW,MAAM,sBAchB"}

package/dist/commands/tutorial.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Tutorial command handler
+ * @param {string} tutorialType - Type of tutorial to run
+ * @param {Object} options - Command options
+ */
+export function tutorialCommand(tutorialType: string, _options?: {}): Promise<any>;
+export namespace TUTORIALS {
+    namespace agent {
+        let name: string;
+        let description: string;
+        let icon: string;
+        let steps: ({
+            id: string;
+            title: string;
+            content: string;
+            action: string;
+            verify?: undefined;
+        } | {
+            id: string;
+            title: string;
+            content: string;
+            action: string;
+            verify: string;
+        })[];
+    }
+    namespace developer {
+        let name_1: string;
+        export { name_1 as name };
+        let description_1: string;
+        export { description_1 as description };
+        let icon_1: string;
+        export { icon_1 as icon };
+        let steps_1: ({
+            id: string;
+            title: string;
+            content: string;
+            action: string;
+            verify?: undefined;
+        } | {
+            id: string;
+            title: string;
+            content: string;
+            action: string;
+            verify: string;
+        })[];
+        export { steps_1 as steps };
+    }
+}
+/**
+ * Interactive tutorial session
+ * @param {string} tutorialType - Type of tutorial (agent, developer)
+ * @returns {Promise<void>}
+ */
+export function runInteractiveTutorial(tutorialType: string): Promise<void>;
+//# sourceMappingURL=tutorial.d.ts.map

package/dist/commands/tutorial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tutorial.d.ts","sourceRoot":"","sources":["../../src/commands/tutorial.js"],"names":[],"mappings":"AA4aA;;;;GAIG;AACH,8CAHW,MAAM,+BA4ChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA/FD;;;;GAIG;AACH,qDAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CA4CzB"}

package/dist/commands/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validate command handler
+ * Enhanced with multi-spec support and JSON output format
+ * @param {string} specFile - Path to spec file (optional, uses spec resolution)
+ * @param {Object} options - Command options
+ * @param {string} [options.specId] - Feature-specific spec ID
+ * @param {boolean} [options.interactive] - Use interactive spec selection
+ * @param {boolean} [options.format] - Output format (json)
+ */
+export function validateCommand(specFile: string, options?: {
+    specId?: string;
+    interactive?: boolean;
+    format?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.js"],"names":[],"mappings":"AAkBA;;;;;;;;GAQG;AACH,0CANW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;IACY,WAAW,GAA7B,OAAO;IACW,MAAM,GAAxB,OAAO;CACjB,iBAiNA"}

package/dist/commands/waivers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Waivers command handler
+ *
+ * @param {string} subcommand - create, list, show, revoke
+ * @param {object} options - Command options
+ */
+export function waiversCommand(subcommand?: string, options?: object): Promise<void>;
+//# sourceMappingURL=waivers.d.ts.map

package/dist/commands/waivers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waivers.d.ts","sourceRoot":"","sources":["../../src/commands/waivers.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,4CAHW,MAAM,YACN,MAAM,iBA2ChB"}