@paths.design/caws-cli 5.0.1 → 5.1.0

package/dist/test-analysis.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Main Test Analysis CLI handler
+ */
+export function testAnalysisCommand(subcommand: any, options?: any[]): Promise<void>;
+/**
+ * Waiver Pattern Learning Engine
+ * Analyzes waiver history to find systematic patterns in budget overruns
+ */
+export class WaiverPatternLearner {
+    constructor(projectRoot?: string);
+    projectRoot: string;
+    /**
+     * Analyze waiver patterns from historical data
+     */
+    analyzePatterns(): {
+        status: string;
+        patterns: {
+            total_waivers: number;
+            budget_overruns: {
+                average_overrun_files: number;
+                average_overrun_loc: number;
+                common_patterns: any[];
+                total_budget_waivers?: undefined;
+            } | {
+                total_budget_waivers: any;
+                average_overrun_files: number;
+                average_overrun_loc: number;
+                common_patterns: {
+                    reason: string;
+                    frequency: number;
+                    avg_overrun_files: number;
+                    avg_overrun_loc: number;
+                }[];
+            };
+            common_reasons: {
+                reason: string;
+                count: any;
+                frequency: number;
+            }[];
+            risk_factors: {
+                factor: string;
+                description: string;
+                risk_level: string;
+            }[];
+            generated_at: string;
+        };
+        message?: undefined;
+    } | {
+        status: string;
+        message: any;
+        patterns: {};
+    };
+    /**
+     * Load all waiver files from .caws/waivers/
+     */
+    loadWaivers(): any[];
+    /**
+     * Load historical working specs (mock implementation)
+     */
+    loadHistoricalSpecs(): any[];
+    /**
+     * Analyze budget overrun patterns
+     */
+    analyzeBudgetOverruns(waivers: any, specs: any): {
+        average_overrun_files: number;
+        average_overrun_loc: number;
+        common_patterns: any[];
+        total_budget_waivers?: undefined;
+    } | {
+        total_budget_waivers: any;
+        average_overrun_files: number;
+        average_overrun_loc: number;
+        common_patterns: {
+            reason: string;
+            frequency: number;
+            avg_overrun_files: number;
+            avg_overrun_loc: number;
+        }[];
+    };
+    /**
+     * Analyze most common waiver reasons
+     */
+    analyzeCommonReasons(waivers: any): {
+        reason: string;
+        count: any;
+        frequency: number;
+    }[];
+    /**
+     * Identify risk factors from waiver patterns
+     */
+    identifyRiskFactors(waivers: any, specs: any): {
+        factor: string;
+        description: string;
+        risk_level: string;
+    }[];
+}
+/**
+ * Project Similarity Matcher
+ * Finds historical projects similar to current work
+ */
+export class ProjectSimilarityMatcher {
+    constructor(projectRoot?: string);
+    projectRoot: string;
+    /**
+     * Find projects similar to the current spec
+     */
+    findSimilarProjects(currentSpec: any): {
+        project: string;
+        similarity_score: number;
+        budget_accuracy: number;
+        waiver_count: number;
+        details: {
+            id: string;
+            title: string;
+            risk_tier: number;
+            mode: string;
+            tech_stack: string;
+            feature_type: string;
+            actual_budget: {
+                files: number;
+                loc: number;
+            };
+            allocated_budget: {
+                files: number;
+                loc: number;
+            };
+            waivers: string[];
+        };
+    }[];
+    /**
+     * Calculate similarity score between two specs/projects
+     */
+    calculateSimilarity(spec1: any, spec2: any): number;
+}
+/**
+ * Budget Predictor using statistical analysis
+ */
+export class BudgetPredictor {
+    constructor(projectRoot?: string);
+    projectRoot: string;
+    patternLearner: WaiverPatternLearner;
+    similarityMatcher: ProjectSimilarityMatcher;
+    /**
+     * Assess budget for a working spec
+     */
+    assessBudget(spec: any): {
+        status: string;
+        assessment: {
+            similar_projects_analyzed: number;
+            recommended_budget: {
+                files: number;
+                loc: number;
+            };
+            baseline_budget: {
+                files: number;
+                loc: number;
+            };
+            buffer_applied: {
+                files_percent: number;
+                loc_percent: number;
+            };
+            rationale: string[];
+            risk_factors: any;
+            confidence: number;
+        };
+        message?: undefined;
+        recommendation?: undefined;
+    } | {
+        status: string;
+        message: any;
+        recommendation: {
+            use_default_tier: boolean;
+            confidence: number;
+        };
+        assessment?: undefined;
+    };
+    /**
+     * Generate human-readable rationale for the recommendation
+     */
+    generateRationale(spec: any, similarProjects: any, patterns: any): string[];
+}
+//# sourceMappingURL=test-analysis.d.ts.map

package/dist/test-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-analysis.d.ts","sourceRoot":"","sources":["../src/test-analysis.js"],"names":[],"mappings":"AAiZA;;GAEG;AACH,qFAsBC;AAhaD;;;GAGG;AACH;IACE,kCAEC;IADC,oBAA8B;IAGhC;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgCC;IAED;;OAEG;IACH,qBAsBC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;MA6CC;IAED;;OAEG;IACH;;;;QAaC;IAED;;OAEG;IACH;;;;QAeC;CACF;AAED;;;GAGG;AACH;IACE,kCAEC;IADC,oBAA8B;IAGhC;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;QAkEC;IAED;;OAEG;IACH,oDA6BC;CACF;AAED;;GAEG;AACH;IACE,kCAIC;IAHC,oBAA8B;IAC9B,qCAA2D;IAC3D,4CAAkE;IAGpE;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DC;IAED;;OAEG;IACH,4EAsBC;CACF"}

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,0BAaC;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,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"}