@wundr.io/cli 1.0.0

package/src/utils/error-handler.ts

@@ -0,0 +1,192 @@
+import chalk from 'chalk';
+import { WundrError } from '../types';
+import { logger } from './logger';
+
+/**
+ * Centralized error handling system
+ */
+class ErrorHandler {
+  private errorCodes: Map<string, string> = new Map([
+    ['ENOENT', 'File or directory not found'],
+    ['EACCES', 'Permission denied'],
+    ['EEXIST', 'File or directory already exists'],
+    ['ENOTDIR', 'Not a directory'],
+    ['EISDIR', 'Is a directory'],
+    ['EMFILE', 'Too many open files'],
+    ['ENOTFOUND', 'Command or resource not found'],
+    ['WUNDR_CONFIG_INVALID', 'Invalid configuration file'],
+    ['WUNDR_PLUGIN_LOAD_FAILED', 'Failed to load plugin'],
+    ['WUNDR_COMMAND_FAILED', 'Command execution failed'],
+    ['WUNDR_ANALYSIS_FAILED', 'Analysis operation failed'],
+    ['WUNDR_NETWORK_ERROR', 'Network operation failed'],
+  ]);
+
+  /**
+   * Handle various types of errors with appropriate formatting
+   */
+  handle(error: Error | WundrError): void {
+    const wundrError = error as WundrError;
+
+    // Log the raw error in debug mode
+    logger.debug('Raw error:', error);
+
+    if (this.isKnownError(wundrError)) {
+      this.handleKnownError(wundrError);
+    } else if (this.isSystemError(error)) {
+      this.handleSystemError(error);
+    } else {
+      this.handleUnknownError(error);
+    }
+  }
+
+  /**
+   * Check if error is a known Wundr error
+   */
+  private isKnownError(error: WundrError): boolean {
+    return !!error.code && error.code.startsWith('WUNDR_');
+  }
+
+  /**
+   * Check if error is a system/Node.js error
+   */
+  private isSystemError(error: Error): boolean {
+    return 'code' in error && typeof (error as any).code === 'string';
+  }
+
+  /**
+   * Handle known Wundr errors
+   */
+  private handleKnownError(error: WundrError): void {
+    const description =
+      this.errorCodes.get(error.code || '') || 'Unknown error';
+
+    console.error(chalk.red('✖ Wundr Error'));
+    console.error(chalk.red(`  Code: ${error.code}`));
+    console.error(chalk.red(`  Message: ${error.message}`));
+    console.error(chalk.gray(`  Description: ${description}`));
+
+    if (error.context) {
+      console.error(chalk.gray('  Context:'));
+      Object.entries(error.context).forEach(([key, value]) => {
+        console.error(chalk.gray(`    ${key}: ${value}`));
+      });
+    }
+
+    if (error.recoverable) {
+      console.error(chalk.yellow('\n💡 This error might be recoverable. Try:'));
+      this.suggestRecoveryActions(error.code || '');
+    }
+  }
+
+  /**
+   * Handle system errors
+   */
+  private handleSystemError(error: any): void {
+    const description = this.errorCodes.get(error.code) || 'System error';
+
+    console.error(chalk.red('✖ System Error'));
+    console.error(chalk.red(`  Code: ${error.code}`));
+    console.error(chalk.red(`  Message: ${error.message}`));
+    console.error(chalk.gray(`  Description: ${description}`));
+
+    if (error.path) {
+      console.error(chalk.gray(`  Path: ${error.path}`));
+    }
+
+    if (error.syscall) {
+      console.error(chalk.gray(`  System Call: ${error.syscall}`));
+    }
+  }
+
+  /**
+   * Handle unknown errors
+   */
+  private handleUnknownError(error: Error): void {
+    console.error(chalk.red('✖ Unexpected Error'));
+    console.error(chalk.red(`  Message: ${error.message}`));
+
+    if (error.stack) {
+      console.error(chalk.gray('  Stack Trace:'));
+      error.stack.split('\n').forEach(line => {
+        console.error(chalk.gray(`    ${line}`));
+      });
+    }
+
+    console.error(chalk.yellow('\n💡 This appears to be an unexpected error.'));
+    console.error(
+      chalk.yellow('   Please report this issue with the above details.')
+    );
+  }
+
+  /**
+   * Suggest recovery actions based on error code
+   */
+  private suggestRecoveryActions(code: string): void {
+    const suggestions: Record<string, string[]> = {
+      WUNDR_CONFIG_INVALID: [
+        '• Check your wundr.config.json syntax',
+        '• Run `wundr init` to create a new configuration',
+        '• Validate your configuration with `wundr config validate`',
+      ],
+      WUNDR_PLUGIN_LOAD_FAILED: [
+        '• Check if the plugin is properly installed',
+        '• Verify plugin compatibility with current Wundr version',
+        '• Run `wundr plugins list` to see available plugins',
+      ],
+      WUNDR_COMMAND_FAILED: [
+        '• Check command syntax and arguments',
+        '• Verify you have necessary permissions',
+        '• Run with --verbose for more details',
+      ],
+      ENOENT: [
+        '• Verify the file or directory path',
+        "• Check if you're in the correct directory",
+        '• Run `wundr init` if in a new project',
+      ],
+      EACCES: [
+        '• Check file permissions',
+        '• Run with appropriate user privileges',
+        '• Verify directory access rights',
+      ],
+    };
+
+    const actions = suggestions[code];
+    if (actions) {
+      actions.forEach(action => {
+        console.error(chalk.yellow(action));
+      });
+    }
+  }
+
+  /**
+   * Create a standardized Wundr error
+   */
+  createError(
+    code: string,
+    message: string,
+    context?: Record<string, any>,
+    recoverable = false
+  ): WundrError {
+    const error = new Error(message) as WundrError;
+    error.code = code;
+    error.context = context;
+    error.recoverable = recoverable;
+    return error;
+  }
+
+  /**
+   * Wrap async operations with error handling
+   */
+  async wrap<T>(operation: () => Promise<T>, context?: string): Promise<T> {
+    try {
+      return await operation();
+    } catch (error) {
+      if (context) {
+        logger.error(`Error in ${context}:`, error);
+      }
+      throw error;
+    }
+  }
+}
+
+export const errorHandler = new ErrorHandler();

package/src/utils/logger.ts

@@ -0,0 +1,104 @@
+import chalk from 'chalk';
+import { Logger } from '../types';
+
+/**
+ * Enhanced logger with multiple levels and colored output
+ */
+class WundrLogger implements Logger {
+  private level: 'debug' | 'info' | 'warn' | 'error' = 'info';
+  private silent = false;
+
+  setLevel(level: 'debug' | 'info' | 'warn' | 'error'): void {
+    this.level = level;
+  }
+
+  setSilent(silent: boolean): void {
+    this.silent = silent;
+  }
+
+  private shouldLog(level: string): boolean {
+    if (this.silent) return false;
+
+    const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+    return levels[level as keyof typeof levels] >= levels[this.level];
+  }
+
+  private formatMessage(
+    level: string,
+    message: string,
+    ...args: any[]
+  ): string {
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+    const fullMessage =
+      args.length > 0 ? `${message} ${args.join(' ')}` : message;
+    return `${prefix} ${fullMessage}`;
+  }
+
+  debug(message: string, ...args: any[]): void {
+    if (!this.shouldLog('debug')) return;
+    console.log(chalk.gray(this.formatMessage('debug', message, ...args)));
+  }
+
+  info(message: string, ...args: any[]): void {
+    if (!this.shouldLog('info')) return;
+    console.log(chalk.blue(this.formatMessage('info', message, ...args)));
+  }
+
+  warn(message: string, ...args: any[]): void {
+    if (!this.shouldLog('warn')) return;
+    console.warn(chalk.yellow(this.formatMessage('warn', message, ...args)));
+  }
+
+  error(message: string, ...args: any[]): void {
+    if (!this.shouldLog('error')) return;
+    console.error(chalk.red(this.formatMessage('error', message, ...args)));
+  }
+
+  success(message: string, ...args: any[]): void {
+    if (!this.shouldLog('info')) return;
+    console.log(chalk.green(this.formatMessage('success', message, ...args)));
+  }
+
+  // Utility methods for structured logging
+  table(data: any[]): void {
+    if (this.silent) return;
+    console.table(data);
+  }
+
+  json(data: any): void {
+    if (this.silent) return;
+    console.log(JSON.stringify(data, null, 2));
+  }
+
+  group(label: string): void {
+    if (this.silent) return;
+    console.group(chalk.cyan(label));
+  }
+
+  groupEnd(): void {
+    if (this.silent) return;
+    console.groupEnd();
+  }
+
+  // Progress logging
+  progress(current: number, total: number, message?: string): void {
+    if (this.silent) return;
+    const percentage = Math.round((current / total) * 100);
+    const bar = '█'.repeat(Math.round(percentage / 2));
+    const empty = '░'.repeat(50 - Math.round(percentage / 2));
+    const progress = `[${bar}${empty}] ${percentage}%`;
+
+    const output = message
+      ? `${chalk.cyan(progress)} ${message}`
+      : chalk.cyan(progress);
+
+    process.stdout.write(`\r${output}`);
+
+    if (current === total) {
+      process.stdout.write('\n');
+    }
+  }
+}
+
+export const logger = new WundrLogger();

package/templates/batch/ci-cd.yaml

@@ -0,0 +1,62 @@
+# CI/CD Batch Job Template
+# Generated with Wundr CLI
+
+name: ci-cd-pipeline
+description: Continuous Integration and Deployment pipeline
+
+# Global settings
+parallel: false
+continueOnError: false
+timeout: 1800000  # 30 minutes
+
+# Environment variables
+variables:
+  NODE_VERSION: "18"
+  BUILD_OUTPUT: "dist"
+
+# Job steps
+commands:
+  # Setup
+  - command: "echo 'Starting CI/CD pipeline...'"
+    condition: "always"
+
+  # Install dependencies
+  - command: "npm ci"
+    retry: 2
+    timeout: 300000  # 5 minutes
+
+  # Code quality checks
+  - command: "npm run lint"
+    condition: "test-files"
+
+  - command: "npm run typecheck"
+    condition: "typescript-files"
+
+  # Testing
+  - command: "npm run test"
+    timeout: 600000  # 10 minutes
+
+  - command: "npm run test:e2e"
+    condition: "e2e-tests-exist"
+    timeout: 900000  # 15 minutes
+
+  # Security audit
+  - command: "npm audit --audit-level high"
+    continueOnError: true
+
+  # Build
+  - command: "npm run build"
+    timeout: 300000  # 5 minutes
+
+  # Package
+  - command: "npm pack"
+    condition: "production"
+
+  # Deploy (conditional)
+  - command: "npm run deploy"
+    condition: "production"
+    timeout: 600000  # 10 minutes
+
+  # Cleanup
+  - command: "echo 'CI/CD pipeline completed'"
+    condition: "always"

package/templates/component/{{fileName}}.test.tsx

@@ -0,0 +1,17 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { {{className}} } from './{{fileName}}';
+
+describe('{{className}}', () => {
+  it('renders without crashing', () => {
+    render(<{{className}} />);
+  });
+
+  it('displays the component name', () => {
+    render(<{{className}} />);
+    expect(screen.getByText('{{className}}')).toBeInTheDocument();
+  });
+
+  // Add more tests here
+});

package/templates/component/{{fileName}}.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+
+interface {{className}}Props {
+  // Define props here
+}
+
+/**
+ * {{className}} component
+ * Generated with Wundr CLI
+ */
+export const {{className}}: React.FC<{{className}}Props> = (props) => {
+  return (
+    <div className="{{fileName}}">
+      <h1>{{className}}</h1>
+      {/* Component implementation */}
+    </div>
+  );
+};
+
+const {{className}}Component = {{className}};
+export default {{className}}Component;

package/templates/service/{{fileName}}.ts

@@ -0,0 +1,98 @@
+import express, { Request, Response, Router } from 'express';
+
+/**
+ * {{className}} Service
+ * Generated with Wundr CLI on {{timestamp}}
+ */
+export class {{className}}Service {
+  private router: Router;
+
+  constructor() {
+    this.router = express.Router();
+    this.initializeRoutes();
+  }
+
+  /**
+   * Initialize service routes
+   */
+  private initializeRoutes(): void {
+    this.router.get('/{{fileName}}', this.getItems.bind(this));
+    this.router.post('/{{fileName}}', this.createItem.bind(this));
+    this.router.get('/{{fileName}}/:id', this.getItem.bind(this));
+    this.router.put('/{{fileName}}/:id', this.updateItem.bind(this));
+    this.router.delete('/{{fileName}}/:id', this.deleteItem.bind(this));
+  }
+
+  /**
+   * Get all items
+   */
+  private async getItems(req: Request, res: Response): Promise<void> {
+    try {
+      // Implementation here
+      res.json({ message: '{{className}} items retrieved' });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to get items' });
+    }
+  }
+
+  /**
+   * Create new item
+   */
+  private async createItem(req: Request, res: Response): Promise<void> {
+    try {
+      // Implementation here
+      res.status(201).json({ message: '{{className}} item created' });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to create item' });
+    }
+  }
+
+  /**
+   * Get single item by ID
+   */
+  private async getItem(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      // Implementation here
+      res.json({ message: `{{className}} item ${id} retrieved` });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to get item' });
+    }
+  }
+
+  /**
+   * Update item by ID
+   */
+  private async updateItem(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      // Implementation here
+      res.json({ message: `{{className}} item ${id} updated` });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to update item' });
+    }
+  }
+
+  /**
+   * Delete item by ID
+   */
+  private async deleteItem(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      // Implementation here
+      res.json({ message: `{{className}} item ${id} deleted` });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to delete item' });
+    }
+  }
+
+  /**
+   * Get router instance
+   */
+  public getRouter(): Router {
+    return this.router;
+  }
+}
+
+const {{className}}ServiceClass = {{className}}Service;
+export default {{className}}ServiceClass;

package/test-suites/api/health.spec.ts

@@ -0,0 +1,134 @@
+import { test, expect } from '@playwright/test';
+
+/**
+ * Portable API health checks
+ * These tests work with common API patterns
+ */
+
+test.describe('API Health Checks', () => {
+  test('health endpoint responds', async ({ request, baseURL }) => {
+    // Try common health check endpoints
+    const healthEndpoints = [
+      '/health',
+      '/api/health',
+      '/healthz',
+      '/status',
+      '/api/status',
+      '/_health',
+      '/ping'
+    ];
+
+    let healthyEndpoint = null;
+    
+    for (const endpoint of healthEndpoints) {
+      try {
+        const response = await request.get(`${baseURL}${endpoint}`);
+        if (response.ok()) {
+          healthyEndpoint = endpoint;
+          break;
+        }
+      } catch {
+        // Continue to next endpoint
+      }
+    }
+
+    // At least one health endpoint should work
+    expect(healthyEndpoint).toBeTruthy();
+  });
+
+  test('API returns proper content types', async ({ request, baseURL }) => {
+    // Try to find an API endpoint
+    const apiEndpoints = [
+      '/api',
+      '/api/v1',
+      '/api/v2',
+      '/graphql'
+    ];
+
+    for (const endpoint of apiEndpoints) {
+      try {
+        const response = await request.get(`${baseURL}${endpoint}`);
+        if (response.ok() || response.status() === 404) {
+          const contentType = response.headers()['content-type'];
+          
+          // Should return JSON or HTML
+          expect(
+            contentType?.includes('application/json') ||
+            contentType?.includes('text/html')
+          ).toBeTruthy();
+        }
+      } catch {
+        // Continue to next endpoint
+      }
+    }
+  });
+
+  test('API handles errors gracefully', async ({ request, baseURL }) => {
+    // Test 404 handling
+    const response = await request.get(`${baseURL}/api/nonexistent-endpoint-${Date.now()}`);
+    
+    // Should return appropriate status code
+    expect([404, 400, 401, 403]).toContain(response.status());
+    
+    // Should not expose sensitive information
+    const body = await response.text();
+    expect(body).not.toContain('stack');
+    expect(body).not.toContain('traceback');
+  });
+
+  test('API responds within acceptable time', async ({ request, baseURL }) => {
+    const startTime = Date.now();
+    
+    // Make a simple request
+    await request.get(`${baseURL}/`);
+    
+    const responseTime = Date.now() - startTime;
+    
+    // Should respond within 5 seconds
+    expect(responseTime).toBeLessThan(5000);
+  });
+
+  test('CORS headers are properly configured', async ({ request, baseURL }) => {
+    try {
+      const response = await request.get(`${baseURL}/api`, {
+        headers: {
+          'Origin': 'https://example.com'
+        }
+      });
+
+      const headers = response.headers();
+      
+      // Check for CORS headers if API exists
+      if (response.status() !== 404) {
+        const hasCorsHeaders = 
+          headers['access-control-allow-origin'] !== undefined ||
+          headers['access-control-allow-methods'] !== undefined;
+        
+        // Log CORS configuration
+        console.log('CORS configured:', hasCorsHeaders);
+      }
+    } catch {
+      // API might not exist, which is okay for generic tests
+    }
+  });
+
+  test('API supports common HTTP methods', async ({ request, baseURL }) => {
+    const methods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'];
+    const results: Record<string, number> = {};
+
+    for (const method of methods) {
+      try {
+        const response = await request.fetch(`${baseURL}/api`, {
+          method
+        });
+        results[method] = response.status();
+      } catch {
+        results[method] = 0;
+      }
+    }
+
+    // At least GET and OPTIONS should be supported
+    expect(results['GET']).toBeGreaterThan(0);
+    expect(results['OPTIONS']).toBeGreaterThan(0);
+  });
+});