@paths.design/caws-cli 3.1.0 → 3.2.0

package/dist/commands/tool.d.ts

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

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

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

package/dist/commands/tool.js

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Tool Command Handler
+ * Handles tool execution commands for CAWS CLI
+ * @author @darianrosebrook
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+
+// Import tool system
+const ToolLoader = require('../tool-loader');
+const ToolValidator = require('../tool-validator');
+
+// Tool system state
+let toolLoader = null;
+let toolValidator = null;
+
+/**
+ * Initialize tool system
+ * @returns {Promise<ToolLoader|null>} Initialized tool loader or null if failed
+ */
+async function initializeToolSystem() {
+  if (toolLoader) return toolLoader;
+
+  try {
+    toolLoader = new ToolLoader({
+      toolsDir: path.join(process.cwd(), 'apps/tools/caws'),
+    });
+
+    toolValidator = new ToolValidator();
+
+    // Set up event listeners for tool system
+    toolLoader.on('discovery:complete', ({ tools: _tools, count }) => {
+      if (count > 0) {
+        console.log(chalk.blue(`🔧 Discovered ${count} tools`));
+      }
+    });
+
+    toolLoader.on('tool:loaded', ({ id, metadata }) => {
+      console.log(chalk.gray(`  ✓ Loaded tool: ${metadata.name} (${id})`));
+    });
+
+    toolLoader.on('tool:error', ({ id, error }) => {
+      console.warn(chalk.yellow(`⚠️  Failed to load tool ${id}: ${error}`));
+    });
+
+    // Auto-discover tools on initialization
+    await toolLoader.discoverTools();
+
+    return toolLoader;
+  } catch (error) {
+    console.warn(chalk.yellow('⚠️  Tool system initialization failed:'), error.message);
+    console.warn(chalk.blue('💡 Continuing without dynamic tools'));
+    return null;
+  }
+}
+
+/**
+ * Execute tool command handler
+ * @param {string} toolId - ID of the tool to execute
+ * @param {Object} options - Command options
+ */
+async function executeTool(toolId, options) {
+  try {
+    // Initialize tool system
+    const loader = await initializeToolSystem();
+
+    if (!loader) {
+      console.error(chalk.red('❌ Tool system not available'));
+      process.exit(1);
+    }
+
+    // Load all tools first
+    await loader.loadAllTools();
+    const tool = loader.getTool(toolId);
+
+    if (!tool) {
+      console.error(chalk.red(`❌ Tool '${toolId}' not found`));
+      console.log(chalk.blue('💡 Available tools:'));
+      const tools = loader.getAllTools();
+      for (const [id, t] of tools) {
+        console.log(`   - ${id}: ${t.metadata.name}`);
+      }
+      process.exit(1);
+    }
+
+    // Validate tool before execution
+    const validation = await toolValidator.validateTool(tool);
+    if (!validation.valid) {
+      console.error(chalk.red('❌ Tool validation failed:'));
+      validation.errors.forEach((error) => {
+        console.error(`   ${chalk.red('✗')} ${error}`);
+      });
+      process.exit(1);
+    }
+
+    // Parse parameters
+    let params = {};
+    if (options.params) {
+      try {
+        params = JSON.parse(options.params);
+      } catch (error) {
+        console.error(chalk.red('❌ Invalid JSON parameters:'), error.message);
+        process.exit(1);
+      }
+    }
+
+    console.log(chalk.blue(`🚀 Executing tool: ${tool.metadata.name}`));
+
+    // Execute tool
+    const result = await tool.module.execute(params, {
+      workingDirectory: process.cwd(),
+      timeout: options.timeout,
+    });
+
+    // Display results
+    if (result.success) {
+      console.log(chalk.green('✅ Tool execution successful'));
+      if (result.output && typeof result.output === 'object') {
+        console.log(chalk.gray('Output:'), JSON.stringify(result.output, null, 2));
+      }
+    } else {
+      console.error(chalk.red('❌ Tool execution failed'));
+      result.errors.forEach((error) => {
+        console.error(`   ${chalk.red('✗')} ${error}`);
+      });
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ Error executing tool ${toolId}:`), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  initializeToolSystem,
+  executeTool,
+};

package/dist/commands/validate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validate command handler
+ * @param {string} specFile - Path to spec file
+ * @param {Object} options - Command options
+ */
+export function validateCommand(specFile: string, options: any): Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

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

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

package/dist/commands/validate.js

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Validate Command Handler
+ * Handles validation commands for CAWS CLI
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+
+// Import validation functionality
+const { validateWorkingSpecWithSuggestions } = require('../validation/spec-validation');
+
+/**
+ * Validate command handler
+ * @param {string} specFile - Path to spec file
+ * @param {Object} options - Command options
+ */
+async function validateCommand(specFile, options) {
+  try {
+    let specPath = specFile || path.join('.caws', 'working-spec.yaml');
+
+    if (!fs.existsSync(specPath)) {
+      console.error(chalk.red(`❌ Spec file not found: ${specPath}`));
+      console.error(chalk.blue('💡 Run "caws init" first to create a working spec'));
+      process.exit(1);
+    }
+
+    const specContent = fs.readFileSync(specPath, 'utf8');
+    const spec = yaml.load(specContent);
+
+    console.log(chalk.cyan('🔍 Validating CAWS working spec...'));
+
+    const result = validateWorkingSpecWithSuggestions(spec, {
+      autoFix: options.autoFix,
+      suggestions: !options.quiet,
+      checkBudget: true,
+      projectRoot: path.dirname(specPath),
+    });
+
+    if (result.valid) {
+      console.log(chalk.green('✅ Working spec validation passed'));
+      if (!options.quiet) {
+        console.log(chalk.gray(`   Risk tier: ${spec.risk_tier}`));
+        console.log(chalk.gray(`   Mode: ${spec.mode}`));
+        if (spec.title) {
+          console.log(chalk.gray(`   Title: ${spec.title}`));
+        }
+      }
+    } else {
+      console.log(chalk.red('❌ Working spec validation failed'));
+
+      // Show errors
+      result.errors.forEach((error, index) => {
+        console.log(`   ${index + 1}. ${chalk.red(error.message)}`);
+        if (error.suggestion) {
+          console.log(`      ${chalk.blue('💡 ' + error.suggestion)}`);
+        }
+      });
+
+      // Show warnings
+      if (result.warnings && result.warnings.length > 0) {
+        console.log(chalk.yellow('\n⚠️  Warnings:'));
+        result.warnings.forEach((warning, index) => {
+          console.log(`   ${index + 1}. ${chalk.yellow(warning.message)}`);
+        });
+      }
+
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk.red('❌ Error during validation:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  validateCommand,
+};

package/dist/config/index.d.ts

@@ -0,0 +1,29 @@
+import CLI_VERSION_1 = require("../../package.json");
+import CLI_VERSION = CLI_VERSION_1.version;
+/**
+ * Initialize global setup detection
+ * @returns {Object} Setup configuration
+ */
+export function initializeGlobalSetup(): any;
+/**
+ * Load provenance tools dynamically
+ * @returns {Object|null} Provenance tools or null if not available
+ */
+export function loadProvenanceTools(): any | null;
+/**
+ * Initialize language support tools
+ * @returns {Object|null} Language support tools or null if not available
+ */
+export function initializeLanguageSupport(): any | null;
+/**
+ * Get global CAWS setup
+ * @returns {Object} CAWS setup configuration
+ */
+export function getGlobalCAWSSetup(): any;
+/**
+ * Set global CAWS setup (for testing or override)
+ * @param {Object} setup - Setup configuration
+ */
+export function setGlobalCAWSSetup(setup: any): void;
+export { CLI_VERSION };
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.js"],"names":[],"mappings":";mCAakD,OAAO;AAOzD;;;GAGG;AACH,6CAkBC;AAED;;;GAGG;AACH,uCAFa,MAAO,IAAI,CAqBvB;AAED;;;GAGG;AACH,6CAFa,MAAO,IAAI,CAmCvB;AAED;;;GAGG;AACH,0CAEC;AAED;;;GAGG;AACH,qDAEC"}

package/dist/config/index.js

@@ -0,0 +1,132 @@
+/**
+ * @fileoverview CAWS Configuration Module
+ * Global configuration and provenance tools management
+ * @author @darianrosebrook
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+
+// Import detection utilities
+const { detectCAWSSetup } = require('../utils/detection');
+
+// CLI version from package.json
+const CLI_VERSION = require('../../package.json').version;
+
+// Global state
+let provenanceTools = null;
+let cawsSetup = null;
+let languageSupport = null;
+
+/**
+ * Initialize global setup detection
+ * @returns {Object} Setup configuration
+ */
+function initializeGlobalSetup() {
+  if (cawsSetup) return cawsSetup;
+
+  try {
+    cawsSetup = detectCAWSSetup();
+  } catch (error) {
+    console.warn(chalk.yellow('⚠️  Failed to detect CAWS setup:'), error.message);
+    cawsSetup = {
+      type: 'unknown',
+      hasCAWSDir: false,
+      cawsDir: null,
+      capabilities: [],
+      hasTemplateDir: false,
+      templateDir: null,
+    };
+  }
+
+  return cawsSetup;
+}
+
+/**
+ * Load provenance tools dynamically
+ * @returns {Object|null} Provenance tools or null if not available
+ */
+function loadProvenanceTools() {
+  if (provenanceTools) return provenanceTools; // Already loaded
+
+  try {
+    const setup = cawsSetup || initializeGlobalSetup();
+    if (setup?.hasTemplateDir && setup?.templateDir) {
+      const { generateProvenance, saveProvenance } = require(
+        path.join(setup.templateDir, 'apps/tools/caws/provenance.js')
+      );
+      provenanceTools = { generateProvenance, saveProvenance };
+      console.log('✅ Loaded provenance tools from:', setup.templateDir);
+    }
+  } catch (error) {
+    // Fallback for environments without template
+    provenanceTools = null;
+    console.warn('⚠️  Provenance tools not available:', error.message);
+  }
+
+  return provenanceTools;
+}
+
+/**
+ * Initialize language support tools
+ * @returns {Object|null} Language support tools or null if not available
+ */
+function initializeLanguageSupport() {
+  if (languageSupport) return languageSupport;
+
+  try {
+    // Try multiple possible locations for language support
+    const possiblePaths = [
+      path.join(__dirname, '../../../caws-template/apps/tools/caws/language-support.js'),
+      path.join(__dirname, '../../../../caws-template/apps/tools/caws/language-support.js'),
+      path.join(process.cwd(), 'packages/caws-template/apps/tools/caws/language-support.js'),
+      path.join(process.cwd(), 'caws-template/apps/tools/caws/language-support.js'),
+    ];
+
+    for (const testPath of possiblePaths) {
+      try {
+        languageSupport = require(testPath);
+        // Only log if not running version command
+        if (!process.argv.includes('--version') && !process.argv.includes('-V')) {
+          console.log(`✅ Loaded language support from: ${testPath}`);
+        }
+        break;
+      } catch (pathError) {
+        // Continue to next path
+      }
+    }
+  } catch (error) {
+    console.warn(chalk.yellow('⚠️  Language support tools not available'));
+    console.warn(chalk.blue('💡 This may limit language-specific configuration features'));
+    console.warn(
+      chalk.blue('💡 For full functionality, ensure caws-template package is available')
+    );
+  }
+
+  return languageSupport;
+}
+
+/**
+ * Get global CAWS setup
+ * @returns {Object} CAWS setup configuration
+ */
+function getGlobalCAWSSetup() {
+  return cawsSetup || initializeGlobalSetup();
+}
+
+/**
+ * Set global CAWS setup (for testing or override)
+ * @param {Object} setup - Setup configuration
+ */
+function setGlobalCAWSSetup(setup) {
+  cawsSetup = setup;
+}
+
+module.exports = {
+  CLI_VERSION,
+  initializeGlobalSetup,
+  loadProvenanceTools,
+  initializeLanguageSupport,
+  getGlobalCAWSSetup,
+  setGlobalCAWSSetup,
+};

package/dist/error-handler.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Enhanced error class with category and recovery suggestions
+ */
+export class CAWSError extends Error {
+    constructor(message: any, category?: any, suggestions?: any[]);
+    category: any;
+    suggestions: any[];
+}
+export namespace ERROR_CATEGORIES {
+    let VALIDATION: string;
+    let PERMISSION: string;
+    let FILESYSTEM: string;
+    let NETWORK: string;
+    let CONFIGURATION: string;
+    let USER_INPUT: string;
+    let DEPENDENCY: string;
+    let UNKNOWN: string;
+}
+/**
+ * Get error category from error object or message
+ * @param {Error|string} error - Error object or message
+ * @returns {string} Error category
+ */
+export function getErrorCategory(error: Error | string): string;
+/**
+ * Wrap async operations with consistent error handling
+ * @param {Function} operation - Async operation to wrap
+ * @param {string} context - Context for error messages
+ * @returns {Promise<any>} Operation result or throws handled error
+ */
+export function safeAsync(operation: Function, context?: string): Promise<any>;
+/**
+ * Handle CLI errors with consistent formatting and user guidance
+ * @param {Error} error - Error to handle
+ * @param {boolean} exit - Whether to exit the process (default: true)
+ */
+export function handleCliError(error: Error, exit?: boolean): void;
+/**
+ * Validate required environment and dependencies
+ * @returns {Object} Validation result with any errors
+ */
+export function validateEnvironment(): any;
+/**
+ * Get recovery suggestions based on error category
+ * @param {Error} error - Original error
+ * @param {string} category - Error category
+ * @returns {string[]} Array of recovery suggestions
+ */
+export function getRecoverySuggestions(error: Error, category: string): string[];
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../src/error-handler.js"],"names":[],"mappings":"AA0GA;;GAEG;AACH;IACE,+DAKC;IAFC,cAAqD;IACrD,mBAA2F;CAE9F;;;;;;;;;;;AA9ED;;;;GAIG;AACH,wCAHW,KAAK,GAAC,MAAM,GACV,MAAM,CA+DlB;AAcD;;;;;GAKG;AACH,yDAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAexB;AAkDD;;;;GAIG;AACH,sCAHW,KAAK,SACL,OAAO,QAyBjB;AAED;;;GAGG;AACH,2CAqBC;AAvGD;;;;;GAKG;AACH,8CAJW,KAAK,YACL,MAAM,GACJ,MAAM,EAAE,CA0CpB"}