@paths.design/caws-cli 8.0.0 → 8.1.0

package/dist/utils/async-utils.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Async Operation Utilities
+ * Provides consistent patterns for async operations, parallel execution, and resource cleanup
+ * @author @darianrosebrook
+ */
+/**
+ * Execute multiple async operations in parallel
+ * @param {Array<Promise>} promises - Array of promises to execute
+ * @param {Object} options - Options
+ * @param {boolean} [options.failFast=true] - Stop on first error
+ * @returns {Promise<Array>} Array of results
+ */
+export function parallel(promises: Array<Promise<any>>, options?: {
+    failFast?: boolean;
+}): Promise<any[]>;
+/**
+ * Execute async operations sequentially
+ * @param {Array<Function>} operations - Array of async functions to execute
+ * @param {Object} options - Options
+ * @param {boolean} [options.stopOnError=true] - Stop on first error
+ * @returns {Promise<Array>} Array of results
+ */
+export function sequential(operations: Array<Function>, options?: {
+    stopOnError?: boolean;
+}): Promise<any[]>;
+/**
+ * Retry an async operation with exponential backoff
+ * @param {Function} operation - Async function to retry
+ * @param {Object} options - Retry options
+ * @param {number} [options.maxRetries=3] - Maximum number of retries
+ * @param {number} [options.initialDelay=1000] - Initial delay in ms
+ * @param {number} [options.maxDelay=10000] - Maximum delay in ms
+ * @param {Function} [options.shouldRetry] - Function to determine if error should be retried
+ * @returns {Promise<any>} Operation result
+ */
+export function retry(operation: Function, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    shouldRetry?: Function;
+}): Promise<any>;
+/**
+ * Execute operation with timeout
+ * @param {Promise} promise - Promise to execute
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @param {string} [errorMessage] - Custom error message
+ * @returns {Promise<any>} Operation result
+ */
+export function withTimeout(promise: Promise<any>, timeoutMs: number, errorMessage?: string): Promise<any>;
+/**
+ * Execute operation with resource cleanup
+ * @param {Function} operation - Async operation to execute
+ * @param {Function} cleanup - Cleanup function (called in finally)
+ * @returns {Promise<any>} Operation result
+ */
+export function withCleanup(operation: Function, cleanup: Function): Promise<any>;
+/**
+ * Execute multiple operations and collect all errors
+ * @param {Array<Function>} operations - Array of async functions
+ * @returns {Promise<{successes: Array, errors: Array}>} Results and errors
+ */
+export function collectResults(operations: Array<Function>): Promise<{
+    successes: any[];
+    errors: any[];
+}>;
+/**
+ * Execute operation with cancellation support
+ * @param {Function} operation - Async operation to execute
+ * @param {AbortSignal} signal - Abort signal for cancellation
+ * @returns {Promise<any>} Operation result
+ */
+export function withCancellation(operation: Function, signal: AbortSignal): Promise<any>;
+//# sourceMappingURL=async-utils.d.ts.map

package/dist/utils/async-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-utils.d.ts","sourceRoot":"","sources":["../../src/utils/async-utils.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,mCALW,KAAK,cAAS,YAEtB;IAA0B,QAAQ,GAA1B,OAAO;CACf,GAAU,OAAO,OAAO,CAmB1B;AAED;;;;;;GAMG;AACH,uCALW,KAAK,UAAU,YAEvB;IAA0B,WAAW,GAA7B,OAAO;CACf,GAAU,OAAO,OAAO,CAmB1B;AAED;;;;;;;;;GASG;AACH,qDANG;IAAyB,UAAU,GAA3B,MAAM;IACW,YAAY,GAA7B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACa,WAAW;CACtC,GAAU,OAAO,CAAC,GAAG,CAAC,CA+BxB;AAED;;;;;;GAMG;AACH,8DAJW,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qEAFa,OAAO,CAAC,GAAG,CAAC,CAQxB;AAED;;;;GAIG;AACH,2CAHW,KAAK,UAAU,GACb,OAAO,CAAC;IAAC,SAAS,QAAQ;IAAC,MAAM,QAAO;CAAC,CAAC,CAmBtD;AAED;;;;;GAKG;AACH,8DAHW,WAAW,GACT,OAAO,CAAC,GAAG,CAAC,CAgBxB"}

package/dist/utils/command-wrapper.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Unified command wrapper that provides:
+ * - Consistent error handling
+ * - Standardized output formatting
+ * - Execution timing
+ * - JSON output support
+ *
+ * @param {Function} commandFn - Async command function to execute
+ * @param {Object} options - Command options
+ * @param {string} options.commandName - Name of the command (for error context)
+ * @param {boolean} [options.includeTiming=true] - Include execution timing
+ * @param {boolean} [options.exitOnError=true] - Exit process on error
+ * @param {Object} [options.context={}] - Additional context for error handling
+ * @returns {Promise<any>} Command result
+ */
+export function commandWrapper(commandFn: Function, options?: {
+    commandName: string;
+    includeTiming?: boolean;
+    exitOnError?: boolean;
+    context?: any;
+}): Promise<any>;
+export namespace Output {
+    /**
+     * Output success message
+     * @param {string} message - Success message
+     * @param {Object} [data] - Additional data to output
+     */
+    function success(message: string, data?: any): void;
+    /**
+     * Output error message
+     * @param {string} message - Error message
+     * @param {string[]} [suggestions] - Recovery suggestions
+     */
+    function error(message: string, suggestions?: string[]): void;
+    /**
+     * Output warning message
+     * @param {string} message - Warning message
+     * @param {string} [suggestion] - Optional suggestion
+     */
+    function warning(message: string, suggestion?: string): void;
+    /**
+     * Output info message
+     * @param {string} message - Info message
+     * @param {Object} [data] - Additional data
+     */
+    function info(message: string, data?: any): void;
+    /**
+     * Output data in JSON format
+     * @param {Object} data - Data to output
+     * @param {boolean} [success=true] - Whether operation was successful
+     */
+    function json(data: any, success?: boolean): void;
+    /**
+     * Output progress message
+     * @param {string} message - Progress message
+     */
+    function progress(message: string): void;
+    /**
+     * Output section header
+     * @param {string} title - Section title
+     */
+    function section(title: string): void;
+}
+import { isJsonOutput } from "../error-handler";
+export { isJsonOutput };
+//# sourceMappingURL=command-wrapper.d.ts.map

package/dist/utils/command-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/command-wrapper.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,8DANG;IAAwB,WAAW,EAA3B,MAAM;IACY,aAAa,GAA/B,OAAO;IACW,WAAW,GAA7B,OAAO;IACU,OAAO;CAChC,GAAU,OAAO,CAAC,GAAG,CAAC,CAuCxB;;IAMC;;;;OAIG;IACH,0BAHW,MAAM,oBAmBhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,gBACN,MAAM,EAAE,QAuBlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,eACN,MAAM,QAkBhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,oBAmBhB;IAED;;;;OAIG;IACH,mCAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAOhB"}

package/dist/utils/detection.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Detect CAWS setup in a directory
+ * @param {string} cwd - Current working directory
+ * @returns {Object} Setup information
+ */
+export function detectCAWSSetup(cwd?: string): any;
+/**
+ * Find the package root directory by looking for package.json
+ * Works in both development (src/) and production (dist/) scenarios
+ * @param {string} startDir - Directory to start searching from (defaults to __dirname)
+ * @returns {string} Package root directory path
+ */
+export function findPackageRoot(startDir?: string): string;
+//# 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":"AA6BA;;;;GAIG;AACH,sCAHW,MAAM,OAqKhB;AA1LD;;;;;GAKG;AACH,2CAHW,MAAM,GACJ,MAAM,CAalB"}

package/dist/utils/error-categories.js

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview Centralized Error Categories
+ * Shared error categorization for consistent error handling across CAWS packages
+ * @author @darianrosebrook
+ */
+
+/**
+ * Error categories for better user experience
+ */
+const ERROR_CATEGORIES = {
+  VALIDATION: 'validation',
+  PERMISSION: 'permission',
+  FILESYSTEM: 'filesystem',
+  NETWORK: 'network',
+  CONFIGURATION: 'configuration',
+  USER_INPUT: 'user_input',
+  DEPENDENCY: 'dependency',
+  UNKNOWN: 'unknown',
+};
+
+/**
+ * Error code mappings for common system errors
+ */
+const ERROR_CODES = {
+  EACCES: ERROR_CATEGORIES.PERMISSION,
+  EPERM: ERROR_CATEGORIES.PERMISSION,
+  ENOENT: ERROR_CATEGORIES.FILESYSTEM,
+  ENOTFOUND: ERROR_CATEGORIES.NETWORK,
+  ECONNREFUSED: ERROR_CATEGORIES.NETWORK,
+  ETIMEDOUT: ERROR_CATEGORIES.NETWORK,
+  ENOSPC: ERROR_CATEGORIES.FILESYSTEM,
+  EEXIST: ERROR_CATEGORIES.FILESYSTEM,
+  EISDIR: ERROR_CATEGORIES.FILESYSTEM,
+  ENOTDIR: ERROR_CATEGORIES.FILESYSTEM,
+};
+
+/**
+ * Get error category from error object or message
+ * @param {Error|string} error - Error object or message
+ * @returns {string} Error category
+ */
+function getErrorCategory(error) {
+  const errorMessage = typeof error === 'string' ? error : (error?.message || '');
+  const errorCode = typeof error === 'object' && error?.code ? error.code : null;
+
+  // Check error codes first
+  if (errorCode && ERROR_CODES[errorCode]) {
+    return ERROR_CODES[errorCode];
+  }
+
+  // Check message patterns
+  const lowerMessage = errorMessage.toLowerCase();
+
+  if (
+    lowerMessage.includes('validation') ||
+    lowerMessage.includes('invalid') ||
+    lowerMessage.includes('required') ||
+    lowerMessage.includes('malformed') ||
+    lowerMessage.includes('syntax')
+  ) {
+    return ERROR_CATEGORIES.VALIDATION;
+  }
+
+  if (
+    lowerMessage.includes('permission') ||
+    lowerMessage.includes('access') ||
+    lowerMessage.includes('denied') ||
+    lowerMessage.includes('forbidden')
+  ) {
+    return ERROR_CATEGORIES.PERMISSION;
+  }
+
+  if (
+    lowerMessage.includes('file') ||
+    lowerMessage.includes('directory') ||
+    lowerMessage.includes('path') ||
+    lowerMessage.includes('not found') ||
+    lowerMessage.includes('does not exist') ||
+    lowerMessage.includes('enoent')
+  ) {
+    return ERROR_CATEGORIES.FILESYSTEM;
+  }
+
+  if (
+    lowerMessage.includes('network') ||
+    lowerMessage.includes('connection') ||
+    lowerMessage.includes('timeout')
+  ) {
+    return ERROR_CATEGORIES.NETWORK;
+  }
+
+  if (
+    lowerMessage.includes('config') ||
+    lowerMessage.includes('setting') ||
+    lowerMessage.includes('option') ||
+    lowerMessage.includes('missing') ||
+    lowerMessage.includes('empty')
+  ) {
+    return ERROR_CATEGORIES.CONFIGURATION;
+  }
+
+  if (
+    lowerMessage.includes('input') ||
+    lowerMessage.includes('prompt') ||
+    lowerMessage.includes('answer')
+  ) {
+    return ERROR_CATEGORIES.USER_INPUT;
+  }
+
+  if (
+    lowerMessage.includes('dependency') ||
+    lowerMessage.includes('module not found')
+  ) {
+    return ERROR_CATEGORIES.DEPENDENCY;
+  }
+
+  return ERROR_CATEGORIES.UNKNOWN;
+}
+
+/**
+ * Get user-friendly error message based on category
+ * @param {string} category - Error category
+ * @param {string} originalMessage - Original error message
+ * @returns {string} User-friendly message
+ */
+function getFriendlyMessage(category, originalMessage) {
+  const messages = {
+    [ERROR_CATEGORIES.PERMISSION]:
+      'Permission denied. Check file permissions or run with elevated privileges.',
+    [ERROR_CATEGORIES.FILESYSTEM]:
+      'File system error. Check if the file/directory exists and is accessible.',
+    [ERROR_CATEGORIES.NETWORK]: 'Network error. Check your connection and try again.',
+    [ERROR_CATEGORIES.VALIDATION]:
+      'Data validation failed. Check your input format and requirements.',
+    [ERROR_CATEGORIES.CONFIGURATION]:
+      'Configuration error. Check your settings and required fields.',
+    [ERROR_CATEGORIES.USER_INPUT]: 'Invalid user input. Check the command syntax and parameters.',
+    [ERROR_CATEGORIES.DEPENDENCY]: 'Missing dependency. Install required packages.',
+    [ERROR_CATEGORIES.UNKNOWN]: 'An unexpected error occurred.',
+  };
+
+  return messages[category] || originalMessage;
+}
+
+/**
+ * Get recovery suggestions based on error category
+ * @param {string} category - Error category
+ * @returns {Array<string>} Array of recovery suggestions
+ */
+function getCategorySuggestions(category) {
+  const suggestions = {
+    [ERROR_CATEGORIES.PERMISSION]: [
+      'Try running with sudo/admin privileges',
+      'Check file/directory permissions with chmod/chown',
+      'Verify user has write access to the target directory',
+    ],
+    [ERROR_CATEGORIES.FILESYSTEM]: [
+      'Verify the file/directory path is correct',
+      'Check if the file is not corrupted',
+      'Ensure sufficient disk space is available',
+      'Check if the file is not being used by another process',
+    ],
+    [ERROR_CATEGORIES.NETWORK]: [
+      'Check your internet connection',
+      'Verify network configuration and firewall settings',
+      'Try again in a few moments',
+      'Check if the remote service is available',
+    ],
+    [ERROR_CATEGORIES.VALIDATION]: [
+      'Review the input format and requirements',
+      'Check for typos in file paths or values',
+      'Validate against the schema documentation',
+      'Use the --help flag to see correct syntax',
+    ],
+    [ERROR_CATEGORIES.CONFIGURATION]: [
+      'Check that all required configuration files exist',
+      'Verify configuration values are in the correct format',
+      'Review the setup documentation',
+      'Ensure environment variables are set correctly',
+    ],
+    [ERROR_CATEGORIES.USER_INPUT]: [
+      'Check the command syntax with --help',
+      'Verify all required arguments are provided',
+      'Ensure arguments are in the correct order',
+      'Check for typos in command names or options',
+    ],
+    [ERROR_CATEGORIES.DEPENDENCY]: [
+      'Install missing dependencies with npm install',
+      'Check if all peer dependencies are installed',
+      'Verify Node.js version compatibility',
+      'Clear npm cache and try again',
+    ],
+    [ERROR_CATEGORIES.UNKNOWN]: [
+      'Check the logs for more detailed information',
+      'Try restarting the process',
+      'Verify system resources (memory, disk space)',
+      'Report the issue with full error details',
+    ],
+  };
+
+  return suggestions[category] || suggestions[ERROR_CATEGORIES.UNKNOWN];
+}
+
+module.exports = {
+  ERROR_CATEGORIES,
+  ERROR_CODES,
+  getErrorCategory,
+  getFriendlyMessage,
+  getCategorySuggestions,
+};

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/git-lock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Check for git lock files
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Lock status information
+ */
+export function checkGitLock(projectRoot: string): any;
+/**
+ * Format git lock error message
+ * @param {Object} lockStatus - Lock status from checkGitLock
+ * @returns {string} Formatted error message
+ */
+export function formatGitLockError(lockStatus: any): string;
+//# sourceMappingURL=git-lock.d.ts.map

package/dist/utils/git-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-lock.d.ts","sourceRoot":"","sources":["../../src/utils/git-lock.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,0CAHW,MAAM,OA+DhB;AAED;;;;GAIG;AACH,qDAFa,MAAM,CAgClB"}

package/dist/utils/gitignore-updater.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Update .gitignore to include CAWS runtime file exclusions
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Options
+ * @param {boolean} options.force - Force update even if entries exist
+ * @returns {Promise<boolean>} Whether .gitignore was updated
+ */
+export function updateGitignore(projectRoot: string, options?: {
+    force: boolean;
+}): Promise<boolean>;
+/**
+ * Verify .gitignore has proper CAWS entries
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<boolean>} Whether .gitignore has CAWS entries
+ */
+export function verifyGitignore(projectRoot: string): Promise<boolean>;
+/**
+ * CAWS .gitignore entries
+ *
+ * Strategy: Track shared/collaborative files, ignore local-only runtime data
+ *
+ * TRACKED (shared with team):
+ * - .caws/working-spec.yaml (main spec)
+ * - .caws/specs/*.yaml (feature specs)
+ * - .caws/policy.yaml (team policy)
+ * - .caws/waivers/*.yaml (project-wide waivers)
+ * - .caws/provenance/ (audit trails for compliance)
+ * - .caws/changes/ (change tracking for team visibility)
+ * - .caws/archive/ (archived changes for history)
+ * - .caws/plans/*.md (implementation plans)
+ *
+ * IGNORED (local-only):
+ * - .agent/ (agent runtime tracking, local to each developer)
+ * - Temporary files (*.tmp, *.bak)
+ * - Logs (caws.log, debug logs)
+ * - Local overrides (caws.local.*)
+ */
+export const CAWS_GITIGNORE_ENTRIES: "\n# CAWS Local Runtime Data (developer-specific, should not be tracked)\n# ====================================================================\n# Note: Specs, policy, waivers, provenance, and plans ARE tracked for team collaboration\n# Only local agent tracking, generated tools, and temporary files are ignored\n\n# Agent runtime tracking (local to each developer)\n.agent/\n\n# CAWS tools (now in .caws/tools/)\n.caws/tools/\n# Legacy location (for backward compatibility)\napps/tools/caws/\n\n# Temporary CAWS files\n**/*.caws.tmp\n**/*.working-spec.bak\n.caws/*.tmp\n.caws/*.bak\n\n# CAWS logs (local debugging)\ncaws-debug.log*\n**/caws.log\n.caws/*.log\n\n# Local development overrides (developer-specific)\ncaws.local.*\n.caws/local.*\n";
+//# sourceMappingURL=gitignore-updater.d.ts.map

package/dist/utils/gitignore-updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitignore-updater.d.ts","sourceRoot":"","sources":["../../src/utils/gitignore-updater.js"],"names":[],"mappings":"AA6DA;;;;;;GAMG;AACH,6CALW,MAAM,YAEd;IAAyB,KAAK,EAAtB,OAAO;CACf,GAAU,OAAO,CAAC,OAAO,CAAC,CA2D5B;AAED;;;;GAIG;AACH,6CAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAW5B;AAnID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,gxBA4BE"}

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

@@ -0,0 +1,34 @@
+/**
+ * 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;
+/**
+ * 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
+ */
+export function detectsPublishing(cwd?: string): boolean;
+/**
+ * Detect primary programming language(s) used in project
+ * @param {string} cwd - Current working directory
+ * @returns {Object} Language detection result with primary language and indicators
+ */
+export function detectProjectLanguage(cwd?: string): any;
+/**
+ * Get language-agnostic suggestion for TODO analyzer installation
+ * Focuses on runtime availability (Node.js/npx) rather than project language
+ * @param {string} cwd - Current working directory
+ * @returns {string} Installation suggestion message
+ */
+export function getTodoAnalyzerSuggestion(cwd?: string): string;
+//# 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;AAED;;;;;GAKG;AACH,wCAHW,MAAM,GACJ,OAAO,CAsFnB;AAED;;;;GAIG;AACH,4CAHW,MAAM,OAiHhB;AAED;;;;;GAKG;AACH,gDAHW,MAAM,GACJ,MAAM,CA6ClB"}

package/dist/utils/promise-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Promise Utilities
+ * Utilities for converting callback-based APIs to promises
+ * @author @darianrosebrook
+ */
+/**
+ * Convert readline question to promise
+ * @param {readline.Interface} rl - Readline interface
+ * @param {string} question - Question to ask
+ * @returns {Promise<string>} User's answer
+ */
+export function question(rl: readline.Interface, questionText: any): Promise<string>;
+/**
+ * Close readline interface and return promise
+ * @param {readline.Interface} rl - Readline interface
+ * @returns {Promise<void>}
+ */
+export function closeReadline(rl: readline.Interface): Promise<void>;
+/**
+ * Create a promise that resolves when event fires
+ * @param {EventEmitter} emitter - Event emitter
+ * @param {string} event - Event name
+ * @param {Object} options - Options
+ * @param {number} [options.timeout] - Timeout in ms
+ * @returns {Promise<any>} Event data
+ */
+export function once(emitter: EventEmitter, event: string, options?: {
+    timeout?: number;
+}): Promise<any>;
+//# sourceMappingURL=promise-utils.d.ts.map

package/dist/utils/promise-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-utils.d.ts","sourceRoot":"","sources":["../../src/utils/promise-utils.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,6BAJW,QAAQ,CAAC,SAAS,sBAEhB,OAAO,CAAC,MAAM,CAAC,CAQ3B;AAED;;;;GAIG;AACH,kCAHW,QAAQ,CAAC,SAAS,GAChB,OAAO,CAAC,IAAI,CAAC,CAOzB;AAED;;;;;;;GAOG;AACH,8BANW,YAAY,SACZ,MAAM,YAEd;IAAyB,OAAO,GAAxB,MAAM;CACd,GAAU,OAAO,CAAC,GAAG,CAAC,CAyBxB"}