@paths.design/caws-cli 8.0.0 → 8.1.0

package/dist/error-handler.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Enhanced error class with category and recovery suggestions
+ */
+export class CAWSError extends Error {
+    constructor(message: any, category?: any, suggestions?: any[]);
+    category: any;
+    suggestions: any[];
+    timestamp: Date;
+    executionTime: 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;
+}
+/**
+ * Execution timing utilities
+ */
+export class ExecutionTimer {
+    startTime: bigint;
+    endTime: bigint;
+    start(): void;
+    end(): number;
+    getDuration(): number;
+    formatDuration(): 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 and timing
+ * @param {Function} operation - Async operation to wrap
+ * @param {string} context - Context for error messages
+ * @param {boolean} includeTiming - Whether to include timing in results
+ * @returns {Promise<any>} Operation result or throws handled error
+ */
+export function safeAsync(operation: Function, context?: string, includeTiming?: boolean): Promise<any>;
+/**
+ * Wrap sync operations with timing
+ * @param {Function} operation - Sync operation to wrap
+ * @param {string} context - Context for error messages
+ * @param {boolean} includeTiming - Whether to include timing in results
+ * @returns {any} Operation result or throws handled error
+ */
+export function safeSync(operation: Function, context?: string, includeTiming?: boolean): any;
+/**
+ * Handle CLI errors with consistent formatting and user guidance
+ * @param {Error} error - Error to handle
+ * @param {Object} context - Error context (command, option, etc.)
+ * @param {boolean} exit - Whether to exit the process (default: true)
+ */
+export function handleCliError(error: Error, context?: any, 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
+ * @param {Object} context - Additional context (command, options, etc.)
+ * @returns {string[]} Array of recovery suggestions
+ */
+export function getRecoverySuggestions(error: Error, category: string, context?: any): string[];
+/**
+ * Get documentation link for error category
+ * @param {string} category - Error category
+ * @param {Object} context - Additional context
+ * @returns {string} Documentation URL
+ */
+export function getDocumentationLink(category: string, context?: any): string;
+/**
+ * Find similar command using Levenshtein distance
+ * @param {string} input - User's input command
+ * @param {string[]} validCommands - List of valid commands
+ * @returns {string|null} Most similar command or null
+ */
+export function findSimilarCommand(input: string, validCommands: string[]): string | null;
+/**
+ * Command-specific error suggestions
+ */
+export const COMMAND_SUGGESTIONS: {
+    'unknown option': (option: any, command: any) => any[];
+    'unknown command': (command: any) => string[];
+    'template not found': () => string[];
+    'not a caws project': () => string[];
+};
+/**
+ * JSON output formatter for programmatic use
+ * @param {Object} data - Data to format as JSON
+ * @param {boolean} pretty - Whether to pretty-print (default: true)
+ */
+export function formatJsonOutput(data: any, pretty?: boolean): string;
+/**
+ * Check if user requested JSON output
+ * @returns {boolean} True if --json flag is present
+ */
+export function isJsonOutput(): boolean;
+/**
+ * Output data in appropriate format (JSON or human-readable)
+ * @param {Object} data - Data to output
+ * @param {boolean} success - Whether this is a success response
+ */
+export function outputResult(data: any, success?: boolean): any;
+/**
+ * Troubleshooting guide system
+ */
+export const TROUBLESHOOTING_GUIDES: {
+    'coverage-report-not-found': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+    'mutation-report-not-found': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+    'working-spec-validation': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+    'monorepo-detection': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+};
+/**
+ * Get troubleshooting guide for a specific issue
+ * @param {string} issueKey - Key for the troubleshooting guide
+ * @returns {Object|null} Troubleshooting guide or null if not found
+ */
+export function getTroubleshootingGuide(issueKey: string): any | null;
+/**
+ * Get all available troubleshooting guides
+ * @returns {Object} All troubleshooting guides
+ */
+export function getAllTroubleshootingGuides(): any;
+/**
+ * Suggest troubleshooting guide based on error message
+ * @param {string} errorMessage - Error message to analyze
+ * @returns {string|null} Issue key if match found, null otherwise
+ */
+export function suggestTroubleshootingGuide(errorMessage: string): string | null;
+//# 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,+DAOC;IAJC,cAAqD;IACrD,mBAA2F;IAC3F,gBAA2B;IAC3B,mBAAyB;CAE5B;;;;;;;;;;;AAED;;GAEG;AACH;IAEI,kBAAqB;IACrB,gBAAmB;IAGrB,cAEC;IAED,cAGC;IAED,sBAIC;IAED,yBAMC;CACF;AAjHD;;;;GAIG;AACH,wCAHW,KAAK,GAAC,MAAM,GACV,MAAM,CA+DlB;AAiDD;;;;;;GAMG;AACH,yDAJW,MAAM,kBACN,OAAO,GACL,OAAO,CAAC,GAAG,CAAC,CA8BxB;AAED;;;;;;GAMG;AACH,wDAJW,MAAM,kBACN,OAAO,GACL,GAAG,CA8Bf;AAgSD;;;;;GAKG;AACH,sCAJW,KAAK,wBAEL,OAAO,QAmDjB;AA0JD;;;GAGG;AACH,2CAqBC;AAnXD;;;;;;GAMG;AACH,8CALW,KAAK,YACL,MAAM,kBAEJ,MAAM,EAAE,CAwDpB;AAED;;;;;GAKG;AACH,+CAJW,MAAM,kBAEJ,MAAM,CA4BlB;AAxJD;;;;;GAKG;AACH,0CAJW,MAAM,iBACN,MAAM,EAAE,GACN,MAAM,GAAC,IAAI,CAiBvB;AAjHD;;GAEG;AACH;;;;;EAuFE;AA4JF;;;;GAIG;AACH,qDAFW,OAAO,UAIjB;AAED;;;GAGG;AACH,gCAFa,OAAO,CAQnB;AAED;;;;GAIG;AACH,kDAFW,OAAO,OAcjB;AA2DD;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0GE;AAEF;;;;GAIG;AACH,kDAHW,MAAM,GACJ,MAAO,IAAI,CAIvB;AAED;;;GAGG;AACH,mDAEC;AAED;;;;GAIG;AACH,0DAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB"}

package/dist/error-handler.js

@@ -5,104 +5,12 @@
  */
 
 const chalk = require('chalk');
-
-/**
- * Error categories for better user experience
- */
-const ERROR_CATEGORIES = {
-  VALIDATION: 'validation',
-  PERMISSION: 'permission',
-  FILESYSTEM: 'filesystem',
-  NETWORK: 'network',
-  CONFIGURATION: 'configuration',
-  USER_INPUT: 'user_input',
-  DEPENDENCY: 'dependency',
-  UNKNOWN: 'unknown',
-};
-
-/**
- * Error code mappings for common system errors
- */
-const ERROR_CODES = {
-  EACCES: ERROR_CATEGORIES.PERMISSION,
-  EPERM: ERROR_CATEGORIES.PERMISSION,
-  ENOENT: ERROR_CATEGORIES.FILESYSTEM,
-  ENOTFOUND: ERROR_CATEGORIES.NETWORK,
-  ECONNREFUSED: ERROR_CATEGORIES.NETWORK,
-  ETIMEDOUT: ERROR_CATEGORIES.NETWORK,
-  ENOSPC: ERROR_CATEGORIES.FILESYSTEM,
-  EEXIST: ERROR_CATEGORIES.FILESYSTEM,
-  EISDIR: ERROR_CATEGORIES.FILESYSTEM,
-  ENOTDIR: ERROR_CATEGORIES.FILESYSTEM,
-};
-
-/**
- * Get error category from error object or message
- * @param {Error|string} error - Error object or message
- * @returns {string} Error category
- */
-function getErrorCategory(error) {
-  const errorMessage = typeof error === 'string' ? error : error.message;
-  const errorCode = typeof error === 'object' && error.code ? error.code : null;
-
-  // Check error codes first
-  if (errorCode && ERROR_CODES[errorCode]) {
-    return ERROR_CODES[errorCode];
-  }
-
-  // Check message patterns
-  const lowerMessage = errorMessage.toLowerCase();
-
-  if (
-    lowerMessage.includes('validation') ||
-    lowerMessage.includes('invalid') ||
-    lowerMessage.includes('required')
-  ) {
-    return ERROR_CATEGORIES.VALIDATION;
-  }
-
-  if (
-    lowerMessage.includes('permission') ||
-    lowerMessage.includes('access') ||
-    lowerMessage.includes('denied')
-  ) {
-    return ERROR_CATEGORIES.PERMISSION;
-  }
-
-  if (
-    lowerMessage.includes('file') ||
-    lowerMessage.includes('directory') ||
-    lowerMessage.includes('path')
-  ) {
-    return ERROR_CATEGORIES.FILESYSTEM;
-  }
-
-  if (
-    lowerMessage.includes('network') ||
-    lowerMessage.includes('connection') ||
-    lowerMessage.includes('timeout')
-  ) {
-    return ERROR_CATEGORIES.NETWORK;
-  }
-
-  if (
-    lowerMessage.includes('config') ||
-    lowerMessage.includes('setting') ||
-    lowerMessage.includes('option')
-  ) {
-    return ERROR_CATEGORIES.CONFIGURATION;
-  }
-
-  if (
-    lowerMessage.includes('input') ||
-    lowerMessage.includes('prompt') ||
-    lowerMessage.includes('answer')
-  ) {
-    return ERROR_CATEGORIES.USER_INPUT;
-  }
-
-  return ERROR_CATEGORIES.UNKNOWN;
-}
+const {
+  ERROR_CATEGORIES,
+  ERROR_CODES,
+  getErrorCategory,
+  getCategorySuggestions,
+} = require('./utils/error-categories');
 
 /**
  * Enhanced error class with category and recovery suggestions

package/dist/generators/jest-config-generator.js

@@ -0,0 +1,242 @@
+/**
+ * @fileoverview Jest Configuration Generator
+ * Generates Jest configuration for TypeScript projects
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Generate Jest configuration for TypeScript project
+ * @param {Object} options - Configuration options
+ * @returns {string} Jest configuration content
+ */
+function generateJestConfig(options = {}) {
+  const {
+    preset = 'ts-jest',
+    testEnvironment = 'node',
+    rootDir = '.',
+    testMatch = ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
+    moduleFileExtensions = ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+    collectCoverageFrom = ['src/**/*.ts', '!src/**/*.d.ts', '!src/**/*.test.ts'],
+    coverageThreshold = {
+      global: {
+        branches: 80,
+        functions: 80,
+        lines: 80,
+        statements: 80,
+      },
+    },
+  } = options;
+
+  const config = {
+    preset,
+    testEnvironment,
+    rootDir,
+    testMatch,
+    moduleFileExtensions,
+    collectCoverageFrom,
+    coverageThreshold,
+    transform: {
+      '^.+\\.tsx?$': [
+        'ts-jest',
+        {
+          tsconfig: 'tsconfig.json',
+        },
+      ],
+    },
+    moduleNameMapper: {
+      '^@/(.*)$': '<rootDir>/src/$1',
+    },
+  };
+
+  return `module.exports = ${JSON.stringify(config, null, 2)};\n`;
+}
+
+/**
+ * Generate test setup file for TypeScript
+ * @returns {string} Setup file content
+ */
+function generateTestSetup() {
+  return `/**
+ * Jest setup file for TypeScript tests
+ * @author @darianrosebrook
+ */
+
+// Add custom matchers or global test setup here
+beforeAll(() => {
+  // Global setup
+});
+
+afterAll(() => {
+  // Global teardown
+});
+`;
+}
+
+/**
+ * Install Jest and TypeScript dependencies
+ * @param {string} projectDir - Project directory
+ * @param {Object} packageJson - Existing package.json
+ * @returns {Promise<Object>} Installation result
+ */
+async function installJestDependencies(projectDir, packageJson) {
+  const dependencies = ['jest', '@types/jest', 'ts-jest'];
+
+  // Check which dependencies are already installed
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+  };
+
+  const toInstall = dependencies.filter((dep) => !(dep in allDeps));
+
+  if (toInstall.length === 0) {
+    return {
+      installed: false,
+      message: 'All Jest dependencies already installed',
+      dependencies: [],
+    };
+  }
+
+  return {
+    installed: false,
+    needsInstall: true,
+    dependencies: toInstall,
+    installCommand: `npm install --save-dev ${toInstall.join(' ')}`,
+  };
+}
+
+/**
+ * Configure Jest for TypeScript project
+ * @param {string} projectDir - Project directory path
+ * @param {Object} options - Configuration options
+ * @returns {Promise<Object>} Configuration result
+ */
+async function configureJestForTypeScript(projectDir = process.cwd(), options = {}) {
+  const { force = false, quiet = false } = options;
+
+  // Check if Jest config already exists
+  const jestConfigPath = path.join(projectDir, 'jest.config.js');
+  if (fs.existsSync(jestConfigPath) && !force) {
+    return {
+      configured: false,
+      skipped: true,
+      message: 'Jest configuration already exists',
+      path: jestConfigPath,
+    };
+  }
+
+  // Generate Jest config
+  const jestConfig = generateJestConfig();
+  await fs.writeFile(jestConfigPath, jestConfig);
+
+  if (!quiet) {
+    console.log(chalk.green('✅ Created jest.config.js'));
+  }
+
+  // Generate test setup file
+  const setupPath = path.join(projectDir, 'tests', 'setup.ts');
+  await fs.ensureDir(path.join(projectDir, 'tests'));
+  await fs.writeFile(setupPath, generateTestSetup());
+
+  if (!quiet) {
+    console.log(chalk.green('✅ Created tests/setup.ts'));
+  }
+
+  // Update package.json with test script if needed
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+
+    if (!packageJson.scripts.test) {
+      packageJson.scripts.test = 'jest';
+      packageJson.scripts['test:coverage'] = 'jest --coverage';
+      packageJson.scripts['test:watch'] = 'jest --watch';
+
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+
+      if (!quiet) {
+        console.log(chalk.green('✅ Added test scripts to package.json'));
+      }
+    }
+  }
+
+  return {
+    configured: true,
+    files: [jestConfigPath, setupPath],
+    nextSteps: [
+      'Install dependencies: npm install --save-dev jest @types/jest ts-jest',
+      'Run tests: npm test',
+      'Run with coverage: npm run test:coverage',
+    ],
+  };
+}
+
+/**
+ * Get Jest configuration recommendations
+ * @param {string} projectDir - Project directory path
+ * @returns {Object} Recommendations
+ */
+function getJestRecommendations(projectDir = process.cwd()) {
+  const recommendations = [];
+  const hasJestConfig = fs.existsSync(path.join(projectDir, 'jest.config.js'));
+  const packageJsonPath = path.join(projectDir, 'package.json');
+
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+    };
+
+    if (!hasJestConfig && !('jest' in allDeps)) {
+      recommendations.push({
+        type: 'missing_framework',
+        severity: 'high',
+        message: 'No testing framework detected',
+        fix: 'Install Jest: npm install --save-dev jest @types/jest ts-jest',
+        autoFixable: false,
+      });
+    }
+
+    if ('typescript' in allDeps && 'jest' in allDeps && !('ts-jest' in allDeps)) {
+      recommendations.push({
+        type: 'missing_ts_jest',
+        severity: 'high',
+        message: 'TypeScript project with Jest but missing ts-jest',
+        fix: 'Install ts-jest: npm install --save-dev ts-jest',
+        autoFixable: false,
+      });
+    }
+
+    if (!hasJestConfig && 'jest' in allDeps) {
+      recommendations.push({
+        type: 'missing_config',
+        severity: 'medium',
+        message: 'Jest installed but not configured',
+        fix: 'Run: caws scaffold to generate Jest configuration',
+        autoFixable: true,
+      });
+    }
+  }
+
+  return {
+    hasIssues: recommendations.length > 0,
+    recommendations,
+  };
+}
+
+module.exports = {
+  configureJestForTypeScript,
+  generateJestConfig,
+  generateTestSetup,
+  installJestDependencies,
+  getJestRecommendations,
+};

package/dist/generators/jest-config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configure Jest for TypeScript project
+ * @param {string} projectDir - Project directory path
+ * @param {Object} options - Configuration options
+ * @returns {Promise<Object>} Configuration result
+ */
+export function configureJestForTypeScript(projectDir?: string, options?: any): Promise<any>;
+/**
+ * Generate Jest configuration for TypeScript project
+ * @param {Object} options - Configuration options
+ * @returns {string} Jest configuration content
+ */
+export function generateJestConfig(options?: any): string;
+/**
+ * Generate test setup file for TypeScript
+ * @returns {string} Setup file content
+ */
+export function generateTestSetup(): string;
+/**
+ * Install Jest and TypeScript dependencies
+ * @param {string} projectDir - Project directory
+ * @param {Object} packageJson - Existing package.json
+ * @returns {Promise<Object>} Installation result
+ */
+export function installJestDependencies(projectDir: string, packageJson: any): Promise<any>;
+/**
+ * Get Jest configuration recommendations
+ * @param {string} projectDir - Project directory path
+ * @returns {Object} Recommendations
+ */
+export function getJestRecommendations(projectDir?: string): any;
+//# sourceMappingURL=jest-config.d.ts.map

package/dist/generators/jest-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-config.d.ts","sourceRoot":"","sources":["../../src/generators/jest-config.js"],"names":[],"mappings":"AA+GA;;;;;GAKG;AACH,wDAJW,MAAM,kBAEJ,OAAO,KAAQ,CAgE3B;AAzKD;;;;GAIG;AACH,mDAFa,MAAM,CA0ClB;AAED;;;GAGG;AACH,qCAFa,MAAM,CAiBlB;AAED;;;;;GAKG;AACH,oDAJW,MAAM,qBAEJ,OAAO,KAAQ,CA2B3B;AAwED;;;;GAIG;AACH,oDAHW,MAAM,OAkDhB"}

package/dist/generators/working-spec.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generate working spec YAML with user input
+ * @param {Object} answers - User responses
+ * @returns {string} - Generated YAML content
+ */
+export function generateWorkingSpec(answers: any): string;
+/**
+ * Validate generated working spec against JSON schema
+ * @param {string} specContent - YAML spec content
+ * @param {Object} answers - User responses for error context
+ */
+export function validateGeneratedSpec(specContent: string, _answers: any): void;
+//# sourceMappingURL=working-spec.d.ts.map

package/dist/generators/working-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"working-spec.d.ts","sourceRoot":"","sources":["../../src/generators/working-spec.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,mDAFa,MAAM,CAsLlB;AAED;;;;GAIG;AACH,mDAHW,MAAM,uBA8BhB"}

package/dist/index-new.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { generateWorkingSpec } from "./generators/working-spec";
+import { validateGeneratedSpec } from "./generators/working-spec";
+export { generateWorkingSpec, validateGeneratedSpec };
+//# sourceMappingURL=index-new.d.ts.map

package/dist/index-new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-new.d.ts","sourceRoot":"","sources":["../src/index-new.js"],"names":[],"mappings":""}