@paths.design/caws-cli 8.0.1 → 8.1.0

package/dist/commands/status.js

@@ -8,6 +8,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
+// child_process removed - execSync no longer used directly
 const { safeAsync, outputResult } = require('../error-handler');
 const { parallel } = require('../utils/async-utils');
 
@@ -181,14 +182,114 @@ async function loadWaiverStatus() {
  * @returns {Promise<Object>} Quality gates status
  */
 async function checkQualityGates() {
-  // For now, return a placeholder
-  // Quality gates are available via CLI or MCP
   return {
     checked: false,
     message: 'Run: caws quality-gates or use MCP tool caws_quality_gates_run for full gate status',
   };
 }
 
+/**
+ * Get test coverage from coverage reports
+ * Looks for common coverage report locations and formats
+ * @returns {Promise<Object>} Coverage data with percentage and details
+ */
+async function getTestCoverage() {
+  const coverageLocations = [
+    // Jest/Istanbul coverage
+    { path: 'coverage/coverage-summary.json', type: 'istanbul' },
+    { path: 'coverage/lcov-report/index.html', type: 'lcov-html' },
+    { path: 'coverage/coverage-final.json', type: 'istanbul-final' },
+    // NYC coverage
+    { path: '.nyc_output/coverage-summary.json', type: 'nyc' },
+    // C8 coverage
+    { path: 'coverage/c8/coverage-summary.json', type: 'c8' },
+  ];
+
+  try {
+    for (const loc of coverageLocations) {
+      const coveragePath = path.join(process.cwd(), loc.path);
+      if (await fs.pathExists(coveragePath)) {
+        if (loc.type === 'istanbul' || loc.type === 'nyc' || loc.type === 'c8') {
+          const content = await fs.readFile(coveragePath, 'utf8');
+          const data = JSON.parse(content);
+
+          // Istanbul/NYC format has a "total" key with coverage percentages
+          if (data.total) {
+            const lines = data.total.lines?.pct || 0;
+            const statements = data.total.statements?.pct || 0;
+            const branches = data.total.branches?.pct || 0;
+            const functions = data.total.functions?.pct || 0;
+
+            return {
+              available: true,
+              percentage: Math.round((lines + statements + branches + functions) / 4),
+              lines: Math.round(lines),
+              statements: Math.round(statements),
+              branches: Math.round(branches),
+              functions: Math.round(functions),
+              source: loc.path,
+            };
+          }
+        } else if (loc.type === 'istanbul-final') {
+          // coverage-final.json has per-file data, need to aggregate
+          const content = await fs.readFile(coveragePath, 'utf8');
+          const data = JSON.parse(content);
+
+          let totalStatements = 0;
+          let coveredStatements = 0;
+
+          for (const file of Object.values(data)) {
+            const s = file.s || {};
+            for (const count of Object.values(s)) {
+              totalStatements++;
+              if (count > 0) coveredStatements++;
+            }
+          }
+
+          if (totalStatements > 0) {
+            const percentage = Math.round((coveredStatements / totalStatements) * 100);
+            return {
+              available: true,
+              percentage,
+              source: loc.path,
+            };
+          }
+        }
+      }
+    }
+
+    // Try running test coverage command if no reports found
+    try {
+      // Check if package.json has a coverage script
+      const pkgPath = path.join(process.cwd(), 'package.json');
+      if (await fs.pathExists(pkgPath)) {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+        if (pkg.scripts && (pkg.scripts.coverage || pkg.scripts['test:coverage'])) {
+          return {
+            available: false,
+            percentage: null,
+            message: 'Run npm run coverage to generate coverage report',
+          };
+        }
+      }
+    } catch {
+      // Ignore package.json errors
+    }
+
+    return {
+      available: false,
+      percentage: null,
+      message: 'No coverage report found',
+    };
+  } catch (error) {
+    return {
+      available: false,
+      percentage: null,
+      message: `Error reading coverage: ${error.message}`,
+    };
+  }
+}
+
 /**
  * Get time since last update
  * @param {string} timestamp - ISO timestamp
@@ -388,7 +489,7 @@ function getProgressColor(percentage) {
  * @param {Object} data - Status data
  * @param {string} currentMode - Current CAWS mode
  */
-function displayVisualStatus(data, currentMode) {
+async function displayVisualStatus(data, currentMode) {
   const { spec, specs, hooks, provenance, waivers, gates } = data;
   const modes = require('../config/modes');
   const tierConfig = modes.getTier(currentMode);
@@ -497,12 +598,35 @@ function displayVisualStatus(data, currentMode) {
       );
     }
 
-    // Test Coverage (placeholder for now)
-    console.log(
-      chalk.gray(
-        `   Test Coverage: ${chalk.blue('Calculating...')} ${createProgressBar(0, 100)} 0%`
-      )
-    );
+    // Test Coverage
+    const coverage = await getTestCoverage();
+    if (coverage.available && coverage.percentage !== null) {
+      const coverageColor =
+        coverage.percentage >= 80
+          ? chalk.green
+          : coverage.percentage >= 50
+            ? chalk.yellow
+            : chalk.red;
+      const coverageBar = createProgressBar(coverage.percentage, 100);
+      console.log(
+        chalk.gray(
+          `   Test Coverage: ${coverageColor(`${coverage.percentage}%`)} ${coverageBar}`
+        )
+      );
+      if (coverage.lines !== undefined) {
+        console.log(
+          chalk.gray(
+            `                  Lines: ${coverage.lines}% | Branches: ${coverage.branches}% | Functions: ${coverage.functions}%`
+          )
+        );
+      }
+    } else {
+      console.log(
+        chalk.gray(
+          `   Test Coverage: ${chalk.yellow('N/A')} ${createProgressBar(0, 100)} ${chalk.gray(coverage.message || 'No report')}`
+        )
+      );
+    }
 
     // Risk Tier Indicator
     const riskColor =
@@ -839,7 +963,7 @@ async function statusCommand(options = {}) {
           console.log(JSON.stringify(result, null, 2));
         } else {
           // Visual output
-          displayVisualStatus(
+          await displayVisualStatus(
             {
               spec,
               specs,

package/dist/commands/templates.js

@@ -149,7 +149,7 @@ function listTemplates() {
   const totalTemplates = Object.keys(templates).length;
 
   if (totalAvailable < totalTemplates) {
-    console.log(chalk.yellow(`\n⏳ ${totalTemplates - totalAvailable} templates coming soon`));
+    console.log(chalk.yellow(`\n⏳ ${totalTemplates - totalAvailable} additional templates in development`));
   }
 
   console.log(chalk.blue('\n📚 Learn more:'));
@@ -181,7 +181,7 @@ function showTemplateInfo(templateId) {
   console.log(chalk.white(`Risk Tier: ${template.tier}`));
   console.log(
     chalk.white(
-      `Status: ${template.available ? chalk.green('Available') : chalk.yellow('Coming Soon')}`
+      `Status: ${template.available ? chalk.green('Available') : chalk.yellow('In Development')}`
     )
   );
 

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/index.js

@@ -2,7 +2,8 @@
 
 /**
  * @fileoverview CAWS CLI - Scaffolding tool for Coding Agent Workflow System
- * Provides commands to initialize new projects and scaffold existing ones with CAWS
+ * Provides commands to initialize new projects and scaffold existing ones with CAWS.
+ * Includes spec management, quality gates, and AI-assisted development workflows.
  * @author @darianrosebrook
  */
 
@@ -435,12 +436,8 @@ program
   .option('-v, --verbose', 'Show detailed error information', false)
   .action(qualityMonitorCommand);
 
-// Troubleshoot command - temporarily disabled due to registration issue
-// program
-//   .command('troubleshoot [guide]')
-//   .description('Display troubleshooting guides for common CAWS issues')
-//   .option('-l, --list', 'List all available troubleshooting guides', false)
-//   .action(troubleshootCommand);
+// Troubleshoot command available via: caws diagnose --troubleshoot <guide>
+// The standalone command was consolidated into the diagnose command.
 
 // Tool command
 program

package/dist/minimal-cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * @fileoverview Minimal CAWS CLI to test Chalk functionality
+ * @fileoverview Minimal CAWS CLI for testing and development
+ * Provides a lightweight CLI structure with version and help commands
+ * for quick verification of CLI functionality.
  * @author @darianrosebrook
  */