@paths.design/caws-cli 6.0.0 → 7.0.1

package/dist/spec/SpecFileManager.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Spec File Manager - Handles WorkingSpec file operations and YAML conversion
+ *
+ * Features:
+ * - Bidirectional WorkingSpec ↔ YAML conversion
+ * - Temporary file support for validation workflows
+ * - Backup/restore capabilities
+ * - Automatic cleanup of old temporary files
+ */
+export class SpecFileManager {
+    constructor(config?: {});
+    projectRoot: any;
+    useTemporaryFiles: any;
+    tempDir: any;
+    /**
+     * Convert WorkingSpec object to YAML string
+     *
+     * @param {Object} spec - WorkingSpec to convert
+     * @returns {string} YAML string representation
+     */
+    specToYaml(spec: any): string;
+    /**
+     * Parse YAML string to WorkingSpec object
+     *
+     * @param {string} yamlContent - YAML string to parse
+     * @returns {Object} Parsed WorkingSpec object
+     * @throws {Error} If YAML is invalid or doesn't match WorkingSpec schema
+     */
+    yamlToSpec(yamlContent: string): any;
+    /**
+     * Get path to .caws/working-spec.yaml in project
+     *
+     * @returns {string} Absolute path to working spec file
+     */
+    getSpecFilePath(): string;
+    /**
+     * Check if working spec file exists
+     *
+     * @returns {Promise<boolean>} True if file exists
+     */
+    specFileExists(): Promise<boolean>;
+    /**
+     * Read working spec from .caws/working-spec.yaml
+     *
+     * @returns {Promise<Object>} Parsed WorkingSpec object
+     * @throws {Error} If file doesn't exist or is invalid
+     */
+    readSpecFile(): Promise<any>;
+    /**
+     * Write WorkingSpec to file
+     *
+     * Writes to .caws/working-spec.yaml or a temporary file based on configuration.
+     *
+     * @param {Object} spec - WorkingSpec to write
+     * @param {Object} options - Write options
+     * @param {boolean} options.useTemp - Override temp file usage
+     * @param {boolean} options.backup - Create backup before writing
+     * @returns {Promise<Object>} Write result with file path and cleanup function
+     */
+    writeSpecFile(spec: any, options?: {
+        useTemp: boolean;
+        backup: boolean;
+    }): Promise<any>;
+    /**
+     * Update existing working spec file
+     *
+     * Reads current spec, merges changes, and writes back.
+     *
+     * @param {Object} updates - Partial WorkingSpec with fields to update
+     * @returns {Promise<Object>} Updated WorkingSpec
+     */
+    updateSpecFile(updates: any): Promise<any>;
+    /**
+     * Create backup of working spec
+     *
+     * @returns {Promise<string>} Path to backup file
+     */
+    backupSpecFile(): Promise<string>;
+    /**
+     * Restore working spec from backup
+     *
+     * @param {string} backupPath - Path to backup file
+     * @returns {Promise<void>}
+     */
+    restoreSpecFile(backupPath: string): Promise<void>;
+    /**
+     * List all backup files
+     *
+     * @returns {Promise<string[]>} Array of backup file paths
+     */
+    listBackups(): Promise<string[]>;
+    /**
+     * Delete old backup files
+     *
+     * @param {Object} options - Cleanup options
+     * @param {number} options.maxAge - Maximum age in milliseconds (default: 7 days)
+     * @param {number} options.keep - Minimum number of backups to keep (default: 5)
+     * @returns {Promise<number>} Number of backups deleted
+     */
+    cleanupBackups(options?: {
+        maxAge: number;
+        keep: number;
+    }): Promise<number>;
+    /**
+     * Validate spec file exists and is parseable
+     *
+     * @returns {Promise<Object>} Validation result
+     */
+    validateSpecFile(): Promise<any>;
+    /**
+     * Clean up old temporary spec files
+     *
+     * Removes temp files older than specified age.
+     *
+     * @param {number} maxAge - Maximum age in milliseconds (default: 1 hour)
+     * @returns {Promise<number>} Number of files cleaned up
+     */
+    cleanupTempFiles(maxAge?: number): Promise<number>;
+    /**
+     * Get spec file stats (size, modified date, etc.)
+     *
+     * @returns {Promise<Object>} File stats
+     */
+    getSpecFileStats(): Promise<any>;
+    /**
+     * Create a new SpecFileManager instance with different configuration
+     *
+     * @param {Object} config - New configuration
+     * @returns {SpecFileManager} New instance
+     */
+    withConfig(config: any): SpecFileManager;
+}
+export const defaultSpecFileManager: SpecFileManager;
+/**
+ * Create a SpecFileManager instance with default configuration
+ *
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Additional options
+ * @returns {SpecFileManager} SpecFileManager instance
+ */
+export function createSpecFileManager(projectRoot: string, options?: any): SpecFileManager;
+export declare function specToYaml(spec: any): string;
+export declare function yamlToSpec(yaml: any): any;
+export declare function readSpecFile(projectRoot: any): Promise<any>;
+export declare function writeSpecFile(spec: any, projectRoot: any, options: any): Promise<any>;
+//# sourceMappingURL=SpecFileManager.d.ts.map

package/dist/spec/SpecFileManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecFileManager.d.ts","sourceRoot":"","sources":["../../src/spec/SpecFileManager.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH;IACE,yBAIC;IAHC,iBAAsD;IACtD,uBAA0D;IAC1D,aAA4C;IAG9C;;;;;OAKG;IACH,uBAFa,MAAM,CASlB;IAED;;;;;;OAMG;IACH,wBAJW,MAAM,OAqBhB;IAED;;;;OAIG;IACH,mBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;;;OAKG;IACH,gBAHa,OAAO,KAAQ,CAe3B;IAED;;;;;;;;;;OAUG;IACH,mCAJG;QAAyB,OAAO,EAAxB,OAAO;QACU,MAAM,EAAvB,OAAO;KACf,GAAU,OAAO,KAAQ,CA2C3B;IAED;;;;;;;OAOG;IACH,8BAFa,OAAO,KAAQ,CAa3B;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;OAIG;IACH,eAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7B;IAED;;;;;;;OAOG;IACH,yBAJG;QAAwB,MAAM,EAAtB,MAAM;QACU,IAAI,EAApB,MAAM;KACd,GAAU,OAAO,CAAC,MAAM,CAAC,CA+B3B;IAED;;;;OAIG;IACH,oBAFa,OAAO,KAAQ,CAe3B;IAED;;;;;;;OAOG;IACH,0BAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CA6B3B;IAED;;;;OAIG;IACH,oBAFa,OAAO,KAAQ,CA0B3B;IAED;;;;;OAKG;IACH,yBAFa,eAAe,CAS3B;CACF;AAiBD,qDAAqD;AAfrD;;;;;;GAMG;AACH,mDAJW,MAAM,kBAEJ,eAAe,CAO3B;AAWa,sDAAiD;AACjD,mDAAiD;AAC/C,qEAKb;AACc,+FAKd"}

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"}