@paths.design/caws-cli 10.2.0 → 11.0.0

package/dist/commands/templates.js

@@ -1,237 +0,0 @@
-/**
- * @fileoverview CAWS Templates Command
- * Discover and manage project templates
- * @author @darianrosebrook
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-const { findPackageRoot } = require('../utils/detection');
-
-/**
- * Built-in template definitions
- */
-const BUILTIN_TEMPLATES = {
-  'typescript-library': {
-    name: 'TypeScript Library',
-    description: 'Production-ready TypeScript library with Jest testing',
-    category: 'TypeScript',
-    tier: 2,
-    features: ['TypeScript', 'Jest', 'ESLint', 'Prettier', 'Publishing'],
-    path: 'templates/typescript/library',
-  },
-  'typescript-api': {
-    name: 'TypeScript API',
-    description: 'REST API with Express and TypeScript',
-    category: 'TypeScript',
-    tier: 1,
-    features: ['TypeScript', 'Express', 'Jest', 'OpenAPI', 'Docker'],
-    path: 'templates/typescript/api',
-  },
-  'typescript-monorepo': {
-    name: 'TypeScript Monorepo',
-    description: 'Multi-package TypeScript monorepo with Turbo',
-    category: 'TypeScript',
-    tier: 2,
-    features: ['TypeScript', 'Turborepo', 'Jest', 'Changesets'],
-    path: 'templates/typescript/monorepo',
-  },
-  'javascript-package': {
-    name: 'JavaScript Package',
-    description: 'NPM package with modern JavaScript',
-    category: 'JavaScript',
-    tier: 3,
-    features: ['JavaScript', 'Jest', 'ESLint', 'Publishing'],
-    path: 'templates/javascript/package',
-  },
-  'react-component-lib': {
-    name: 'React Component Library',
-    description: 'Reusable React component library with Storybook',
-    category: 'React',
-    tier: 2,
-    features: ['React', 'TypeScript', 'Storybook', 'Jest', 'Publishing'],
-    path: 'templates/react/component-library',
-  },
-};
-
-/**
- * Get template directory path
- * Works in both development and global install scenarios
- * @returns {string|null} Template directory path or null
- */
-function getTemplateDir() {
-  // Find package root using shared utility
-  const packageRoot = findPackageRoot(__dirname);
-  
-  const possiblePaths = [
-    // First: Try templates relative to package root (works in dev and global install)
-    path.join(packageRoot, 'templates'),
-    // Fallback: Try relative to current file location (for development)
-    path.join(__dirname, '../../templates'),
-    path.join(__dirname, '../templates'),
-    // Legacy fallbacks
-    path.join(process.cwd(), 'packages/caws-cli/templates'),
-    path.join(process.cwd(), 'templates'),
-  ];
-
-  for (const testPath of possiblePaths) {
-    if (fs.existsSync(testPath)) {
-      return testPath;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Check which templates actually exist
- * @returns {Object} Available templates
- */
-function getAvailableTemplates() {
-  const templateDir = getTemplateDir();
-  const available = {};
-
-  for (const [id, template] of Object.entries(BUILTIN_TEMPLATES)) {
-    const templatePath = templateDir
-      ? path.join(templateDir, template.path.replace('templates/', ''))
-      : null;
-
-    available[id] = {
-      ...template,
-      available: templatePath ? fs.existsSync(templatePath) : false,
-      fullPath: templatePath,
-    };
-  }
-
-  return available;
-}
-
-/**
- * List all available templates
- */
-function listTemplates() {
-  const templates = getAvailableTemplates();
-  const categories = {};
-
-  // Group by category
-  for (const [id, template] of Object.entries(templates)) {
-    if (!categories[template.category]) {
-      categories[template.category] = [];
-    }
-    categories[template.category].push({ id, ...template });
-  }
-
-  console.log(chalk.bold.cyan('\nAvailable CAWS Templates\n'));
-
-  // Display by category
-  for (const [category, categoryTemplates] of Object.entries(categories)) {
-    console.log(chalk.bold.white(`${category}:`));
-
-    for (const template of categoryTemplates) {
-      const status = template.available ? chalk.green('') : chalk.gray('');
-      console.log(`${status} ${chalk.bold(template.id.padEnd(25))} - ${template.description}`);
-      console.log(chalk.gray(`   Usage: caws init --template=${template.id} my-project`));
-      console.log(chalk.gray(`   Features: ${template.features.join(', ')}`));
-      console.log('');
-    }
-  }
-
-  const totalAvailable = Object.values(templates).filter((t) => t.available).length;
-  const totalTemplates = Object.keys(templates).length;
-
-  if (totalAvailable < totalTemplates) {
-    console.log(chalk.yellow(`\n${totalTemplates - totalAvailable} additional templates in development`));
-  }
-
-  console.log(chalk.blue('\nLearn more:'));
-  console.log(chalk.blue('   caws templates --help'));
-  console.log(chalk.blue('   docs/guides/template-usage.md'));
-
-  console.log('');
-}
-
-/**
- * Show detailed template information
- * @param {string} templateId - Template ID
- */
-function showTemplateInfo(templateId) {
-  const templates = getAvailableTemplates();
-  const template = templates[templateId];
-
-  if (!template) {
-    console.error(chalk.red(`\nTemplate not found: ${templateId}`));
-    console.error(chalk.yellow('\nAvailable templates:'));
-    console.error(chalk.yellow(`   ${Object.keys(templates).join(', ')}`));
-    console.error(chalk.yellow('\nTry: caws templates list'));
-    process.exit(1);
-  }
-
-  console.log(chalk.bold.cyan(`\nTemplate: ${template.name}\n`));
-  console.log(chalk.white(`Description: ${template.description}`));
-  console.log(chalk.white(`Category: ${template.category}`));
-  console.log(chalk.white(`Risk Tier: ${template.tier}`));
-  console.log(
-    chalk.white(
-      `Status: ${template.available ? chalk.green('Available') : chalk.yellow('In Development')}`
-    )
-  );
-
-  console.log(chalk.bold.white('\nFeatures:'));
-  template.features.forEach((feature) => {
-    console.log(chalk.gray(`   - ${feature}`));
-  });
-
-  console.log(chalk.bold.white('\nUsage:'));
-  console.log(chalk.cyan(`   caws init --template=${templateId} my-project`));
-  console.log(chalk.cyan(`   cd my-project`));
-  console.log(chalk.cyan(`   npm install`));
-  console.log(chalk.cyan(`   npm test`));
-
-  if (template.available && template.fullPath) {
-    console.log(chalk.bold.white('\nTemplate Location:'));
-    console.log(chalk.gray(`   ${template.fullPath}`));
-  }
-
-  console.log('');
-}
-
-/**
- * Templates command handler
- * @param {string} subcommand - Subcommand (list, info)
- * @param {Object} options - Command options
- */
-async function templatesCommand(subcommand = 'list', options = {}) {
-  try {
-    switch (subcommand) {
-      case 'list':
-        listTemplates();
-        break;
-
-      case 'info':
-        if (!options.name) {
-          console.error(chalk.red('\nTemplate name required'));
-          console.error(chalk.yellow('Usage: caws templates info <template-name>'));
-          console.error(chalk.yellow('Try: caws templates list to see available templates'));
-          process.exit(1);
-        }
-        showTemplateInfo(options.name);
-        break;
-
-      default:
-        listTemplates();
-    }
-  } catch (error) {
-    console.error(chalk.red('\nError:'), error.message);
-    console.error(chalk.yellow('\nTry: caws templates list'));
-    process.exit(1);
-  }
-}
-
-module.exports = {
-  templatesCommand,
-  listTemplates,
-  showTemplateInfo,
-  getAvailableTemplates,
-  BUILTIN_TEMPLATES,
-};

package/dist/commands/tool.js

@@ -1,136 +0,0 @@
-/**
- * @fileoverview Tool Command Handler
- * Handles tool execution commands for CAWS CLI
- * @author @darianrosebrook
- */
-
-const { commandWrapper, Output } = require('../utils/command-wrapper');
-
-// 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 now checks .caws/tools first, then falls back to legacy location
-    toolLoader = new ToolLoader();
-
-    toolValidator = new ToolValidator();
-
-    // Set up event listeners for tool system
-    toolLoader.on('discovery:complete', ({ tools: _tools, count }) => {
-      if (count > 0) {
-        Output.info(`Discovered ${count} tools`);
-      }
-    });
-
-    toolLoader.on('tool:loaded', ({ id, metadata }) => {
-      // Only log in verbose mode or when not using JSON output
-      if (!process.env.CAWS_OUTPUT_FORMAT || process.env.CAWS_OUTPUT_FORMAT !== 'json') {
-        console.log(`  [ok] Loaded tool: ${metadata.name} (${id})`);
-      }
-    });
-
-    toolLoader.on('tool:error', ({ id, error }) => {
-      Output.warning(`Failed to load tool ${id}: ${error}`);
-    });
-
-    // Auto-discover tools on initialization
-    await toolLoader.discoverTools();
-
-    return toolLoader;
-  } catch (error) {
-    Output.warning(
-      `Tool system initialization failed: ${error.message}`,
-      '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) {
-  return commandWrapper(
-    async () => {
-      // Initialize tool system
-      const loader = await initializeToolSystem();
-
-      if (!loader) {
-        throw new Error('Tool system not available');
-      }
-
-      // Load all tools first
-      await loader.loadAllTools();
-      const tool = loader.getTool(toolId);
-
-      if (!tool) {
-        const tools = loader.getAllTools();
-        const availableTools = Array.from(tools, ([id, t]) => `${id}: ${t.metadata.name}`).join(
-          ', '
-        );
-        throw new Error(`Tool '${toolId}' not found.\n` + `Available tools: ${availableTools}`);
-      }
-
-      // Validate tool before execution
-      const validation = await toolValidator.validateTool(tool);
-      if (!validation.valid) {
-        throw new Error(
-          `Tool validation failed:\n` + validation.errors.map((e) => `  - ${e}`).join('\n')
-        );
-      }
-
-      // Parse parameters
-      let params = {};
-      if (options.params) {
-        try {
-          params = JSON.parse(options.params);
-        } catch (error) {
-          throw new Error(`Invalid JSON parameters: ${error.message}`);
-        }
-      }
-
-      Output.progress(`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) {
-        Output.success('Tool execution successful', {
-          output: result.output,
-        });
-        return result;
-      } else {
-        throw new Error(
-          `Tool execution failed:\n` + result.errors.map((e) => `  - ${e}`).join('\n')
-        );
-      }
-    },
-    {
-      commandName: `tool ${toolId}`,
-      context: { toolId, options },
-    }
-  );
-}
-
-module.exports = {
-  initializeToolSystem,
-  executeTool,
-};