@paths.design/caws-cli 8.0.0 → 8.0.1

package/dist/tool-interface.d.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * Standard tool execution result
+ */
+export type ToolExecutionResult = {
+    /**
+     * - Whether execution succeeded
+     */
+    success: boolean;
+    /**
+     * - Execution duration in milliseconds
+     */
+    duration: number;
+    /**
+     * - Tool-specific output data
+     */
+    output: any;
+    /**
+     * - Error messages if execution failed
+     */
+    errors: Array<string>;
+    /**
+     * - Additional execution metadata
+     */
+    metadata: any;
+};
+/**
+ * Tool metadata structure
+ */
+export type ToolMetadata = {
+    /**
+     * - Unique tool identifier
+     */
+    id: string;
+    /**
+     * - Human-readable tool name
+     */
+    name: string;
+    /**
+     * - Tool version (semver)
+     */
+    version: string;
+    /**
+     * - Tool description
+     */
+    description: string;
+    /**
+     * - Tool capabilities (e.g., ['validation', 'security'])
+     */
+    capabilities: Array<string>;
+    /**
+     * - Tool author
+     */
+    author: string;
+    /**
+     * - Tool license
+     */
+    license: string;
+    /**
+     * - Required Node.js dependencies
+     */
+    dependencies: Array<string>;
+};
+/**
+ * Tool execution context
+ */
+export type ToolExecutionContext = {
+    /**
+     * - Current working directory
+     */
+    workingDirectory: string;
+    /**
+     * - Environment variables
+     */
+    environment: any;
+    /**
+     * - CAWS configuration
+     */
+    config: any;
+    /**
+     * - Current working specification
+     */
+    workingSpec: any;
+    /**
+     * - Execution timeout in milliseconds
+     */
+    timeout: number;
+};
+/**
+ * @fileoverview CAWS Tool Interface - Base classes and contracts for tool implementation
+ * Defines the standard interface that all CAWS tools must implement
+ * @author @darianrosebrook
+ */
+/**
+ * Standard tool execution result
+ * @typedef {Object} ToolExecutionResult
+ * @property {boolean} success - Whether execution succeeded
+ * @property {number} duration - Execution duration in milliseconds
+ * @property {Object} output - Tool-specific output data
+ * @property {Array<string>} errors - Error messages if execution failed
+ * @property {Object} metadata - Additional execution metadata
+ */
+/**
+ * Tool metadata structure
+ * @typedef {Object} ToolMetadata
+ * @property {string} id - Unique tool identifier
+ * @property {string} name - Human-readable tool name
+ * @property {string} version - Tool version (semver)
+ * @property {string} description - Tool description
+ * @property {Array<string>} capabilities - Tool capabilities (e.g., ['validation', 'security'])
+ * @property {string} author - Tool author
+ * @property {string} license - Tool license
+ * @property {Array<string>} dependencies - Required Node.js dependencies
+ */
+/**
+ * Tool execution context
+ * @typedef {Object} ToolExecutionContext
+ * @property {string} workingDirectory - Current working directory
+ * @property {Object} environment - Environment variables
+ * @property {Object} config - CAWS configuration
+ * @property {Object} workingSpec - Current working specification
+ * @property {number} timeout - Execution timeout in milliseconds
+ */
+/**
+ * Base Tool class - All CAWS tools should extend this class
+ */
+export class BaseTool {
+    metadata: ToolMetadata;
+    /**
+     * Execute the tool with given parameters
+     * @param {Object} parameters - Tool-specific execution parameters
+     * @param {ToolExecutionContext} context - Execution context
+     * @returns {Promise<ToolExecutionResult>} Execution result
+     */
+    execute(parameters?: any, context?: ToolExecutionContext): Promise<ToolExecutionResult>;
+    /**
+     * Get tool metadata
+     * @returns {ToolMetadata} Tool metadata
+     */
+    getMetadata(): ToolMetadata;
+    /**
+     * Validate tool parameters
+     * @param {Object} _parameters - Parameters to validate
+     * @throws {Error} If parameters are invalid
+     */
+    validateParameters(_parameters: any): boolean;
+    /**
+     * Execute tool implementation (must be overridden by subclasses)
+     * @param {Object} _parameters - Tool parameters
+     * @param {ToolExecutionContext} _context - Execution context
+     * @returns {Promise<Object>} Tool-specific result
+     */
+    executeImpl(_parameters: any, _context: ToolExecutionContext): Promise<any>;
+    /**
+     * Normalize execution result to standard format
+     * @private
+     * @param {Object} result - Raw tool result
+     * @param {number} duration - Execution duration
+     * @returns {ToolExecutionResult} Normalized result
+     */
+    private normalizeResult;
+    /**
+     * Create error result
+     * @private
+     * @param {Error} error - Execution error
+     * @param {number} duration - Execution duration
+     * @returns {ToolExecutionResult} Error result
+     */
+    private createErrorResult;
+}
+/**
+ * Validation Tool base class - For tools that perform validation checks
+ */
+export class ValidationTool extends BaseTool {
+    capabilities: string[];
+    /**
+     * Execute validation
+     * @param {Object} parameters - Validation parameters
+     * @param {ToolExecutionContext} context - Execution context
+     * @returns {Promise<ToolExecutionResult>} Validation result
+     */
+    executeImpl(parameters: any, context: ToolExecutionContext): Promise<ToolExecutionResult>;
+    /**
+     * Perform validation (must be implemented by subclasses)
+     * @param {Object} parameters - Validation parameters
+     * @param {ToolExecutionContext} context - Execution context
+     * @returns {Promise<Object>} Validation result
+     */
+    validate(_parameters: any, _context: any): Promise<any>;
+}
+/**
+ * Quality Gate Tool base class - For tools that enforce quality standards
+ */
+export class QualityGateTool extends ValidationTool {
+    /**
+     * Get quality gate thresholds for current tier
+     * @param {number} tier - Risk tier (1-3)
+     * @returns {Object} Threshold configuration
+     */
+    getTierThresholds(tier: number): any;
+}
+/**
+ * Security Tool base class - For tools that perform security checks
+ */
+export class SecurityTool extends ValidationTool {
+    /**
+     * Check for security violations
+     * @param {Object} target - Target to check (file, code, etc.)
+     * @returns {Promise<Array<Object>>} Array of security violations
+     */
+    checkSecurityViolations(target: any): Promise<Array<any>>;
+}
+export namespace ToolUtils {
+    /**
+     * Create standardized success result
+     * @param {Object} output - Tool output
+     * @param {Object} metadata - Additional metadata
+     * @returns {ToolExecutionResult} Success result
+     */
+    function createSuccessResult(output?: any, metadata?: any): ToolExecutionResult;
+    /**
+     * Create standardized error result
+     * @param {string} message - Error message
+     * @param {string} errorType - Error type
+     * @returns {ToolExecutionResult} Error result
+     */
+    function createErrorResult(message: string, errorType?: string): ToolExecutionResult;
+    /**
+     * Validate required parameters
+     * @param {Object} _params - Parameters object
+     * @param {Array<string>} _required - Required parameter names
+     * @throws {Error} If required parameters are missing
+     */
+    function validateRequired(_params: any, _required: Array<string>): void;
+}
+//# sourceMappingURL=tool-interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-interface.d.ts","sourceRoot":"","sources":["../src/tool-interface.js"],"names":[],"mappings":";;;;;;;;aAWc,OAAO;;;;cACP,MAAM;;;;;;;;YAEN,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;;QAOb,MAAM;;;;UACN,MAAM;;;;aACN,MAAM;;;;iBACN,MAAM;;;;kBACN,KAAK,CAAC,MAAM,CAAC;;;;YACb,MAAM;;;;aACN,MAAM;;;;kBACN,KAAK,CAAC,MAAM,CAAC;;;;;;;;;sBAMb,MAAM;;;;;;;;;;;;;;;;aAIN,MAAM;;AApCpB;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AACH;IAEI,uBAAkC;IAGpC;;;;;OAKG;IACH,oCAHW,oBAAoB,GAClB,OAAO,CAAC,mBAAmB,CAAC,CAmBxC;IAED;;;OAGG;IACH,eAFa,YAAY,CAIxB;IAED;;;;OAIG;IACH,8CAGC;IAED;;;;;OAKG;IACH,wCAHW,oBAAoB,GAClB,OAAO,KAAQ,CAI3B;IAED;;;;;;OAMG;IACH,wBAQC;IAED;;;;;;OAMG;IACH,0BAWC;CACF;AAED;;GAEG;AACH;IAGI,uBAAkC;IAGpC;;;;;OAKG;IACH,sCAHW,oBAAoB,GAClB,OAAO,CAAC,mBAAmB,CAAC,CAcxC;IAED;;;;;OAKG;IACH,2CAFa,OAAO,KAAQ,CAI3B;CACF;AAED;;GAEG;AACH;IAME;;;;OAIG;IACH,wBAHW,MAAM,OA6BhB;CACF;AAED;;GAEG;AACH;IAME;;;;OAIG;IACH,sCAFa,OAAO,CAAC,KAAK,KAAQ,CAAC,CAmBlC;CACF;;IAMC;;;;;OAKG;IACH,4DAFa,mBAAmB,CAU/B;IAED;;;;;OAKG;IACH,oCAJW,MAAM,cACN,MAAM,GACJ,mBAAmB,CAU/B;IAED;;;;;OAKG;IACH,mDAHW,KAAK,CAAC,MAAM,CAAC,QAQvB"}

package/dist/tool-loader.d.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+export = ToolLoader;
+/**
+ * Tool Loader - Discovers, validates, and loads CAWS tools dynamically
+ * @extends EventEmitter
+ */
+declare class ToolLoader extends EventEmitter<[never]> {
+    constructor(options?: {});
+    options: {
+        toolsDir: any;
+        cacheEnabled: boolean;
+        timeout: any;
+        maxTools: any;
+    };
+    loadedTools: Map<any, any>;
+    discoveredTools: Set<any>;
+    loadingState: string;
+    /**
+     * Discover available tools in the tools directory
+     * @returns {Promise<Array<string>>} Array of tool file paths
+     */
+    discoverTools(): Promise<Array<string>>;
+    /**
+     * Load a specific tool module
+     * @param {string} toolPath - Path to tool file
+     * @returns {Promise<Object>} Loaded tool module
+     */
+    loadTool(toolPath: string): Promise<any>;
+    /**
+     * Load all discovered tools
+     * @returns {Promise<Map<string, Object>>} Map of loaded tools
+     */
+    loadAllTools(): Promise<Map<string, any>>;
+    /**
+     * Get a loaded tool by ID
+     * @param {string} toolId - Tool identifier
+     * @returns {Object|null} Tool object or null if not found
+     */
+    getTool(toolId: string): any | null;
+    /**
+     * Get all loaded tools
+     * @returns {Map<string, Object>} Map of loaded tools
+     */
+    getAllTools(): Map<string, any>;
+    /**
+     * Unload a tool (remove from cache)
+     * @param {string} toolId - Tool identifier
+     * @returns {boolean} True if tool was unloaded
+     */
+    unloadTool(toolId: string): boolean;
+    /**
+     * Validate tool file before loading
+     * @private
+     * @param {string} toolPath - Path to tool file
+     */
+    private validateToolFile;
+    /**
+     * Load module with timeout protection
+     * @private
+     * @param {string} toolPath - Path to tool file
+     */
+    private loadModuleWithTimeout;
+    /**
+     * Validate tool interface compliance
+     * @private
+     * @param {Object} toolModule - Loaded tool module
+     * @param {string} toolId - Tool identifier
+     */
+    private validateToolInterface;
+    /**
+     * Get loader statistics
+     * @returns {Object} Statistics object
+     */
+    getStats(): any;
+}
+import { EventEmitter } from "events";
+//# sourceMappingURL=tool-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-loader.d.ts","sourceRoot":"","sources":["../src/tool-loader.js"],"names":[],"mappings":";;AAcA;;;GAGG;AACH;IACE,0BAkBC;IAXC;;;;;MAMC;IAED,2BAA4B;IAC5B,0BAAgC;IAChC,qBAA0B;IAG5B;;;OAGG;IACH,iBAFa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAkDlC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,KAAQ,CAmC3B;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,GAAG,CAAC,MAAM,MAAS,CAAC,CAuBxC;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAO,IAAI,CAIvB;IAED;;;OAGG;IACH,eAFa,GAAG,CAAC,MAAM,MAAS,CAI/B;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,yBAgCC;IAED;;;;OAIG;IACH,8BAkBC;IAED;;;;;OAKG;IACH,8BAyBC;IAED;;;OAGG;IACH,gBAQC;CACF"}

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,0BAiBC;IATC;;;;MAKC;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/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/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"}