@paths.design/caws-cli 3.3.1 → 3.5.0

package/templates/apps/tools/caws/shared/gate-checker.ts

@@ -60,6 +60,146 @@ export class CawsGateChecker extends CawsBaseTool {
     }
   }
 
+  /**
+   * Auto-detect the correct working directory for coverage/mutation reports in monorepos
+   */
+  private findReportDirectory(startPath: string = this.getWorkingDirectory()): string {
+    // Priority 1: Check if the current directory has the reports or test results
+    if (
+      this.hasCoverageReports(startPath) ||
+      this.hasMutationReports(startPath) ||
+      this.hasTestResults(startPath)
+    ) {
+      return startPath;
+    }
+
+    // Priority 2: Check for npm workspaces configuration
+    const packageJsonPath = path.join(startPath, 'package.json');
+    if (this.pathExists(packageJsonPath)) {
+      try {
+        const packageJson = this.readJsonFile<any>(packageJsonPath);
+        if (packageJson?.workspaces) {
+          const workspaces = packageJson.workspaces;
+
+          // Handle workspace patterns (e.g., ["packages/*", "iterations/*"])
+          for (const wsPattern of workspaces) {
+            if (wsPattern.includes('*')) {
+              const baseDir = wsPattern.split('*')[0];
+              const fullBaseDir = path.join(startPath, baseDir);
+
+              if (this.pathExists(fullBaseDir)) {
+                const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (entry.isDirectory()) {
+                    const wsPath = path.join(fullBaseDir, entry.name);
+                    if (
+                      this.hasCoverageReports(wsPath) ||
+                      this.hasMutationReports(wsPath) ||
+                      this.hasTestResults(wsPath)
+                    ) {
+                      return wsPath;
+                    }
+                  }
+                }
+              }
+            } else {
+              // Direct workspace path
+              const wsPath = path.join(startPath, wsPattern);
+              if (
+                this.hasCoverageReports(wsPath) ||
+                this.hasMutationReports(wsPath) ||
+                this.hasTestResults(wsPath)
+              ) {
+                return wsPath;
+              }
+            }
+          }
+        }
+
+        // Priority 3: If no reports found in workspaces, look for workspaces with test scripts
+        if (packageJson?.workspaces) {
+          for (const wsPattern of workspaces) {
+            if (wsPattern.includes('*')) {
+              const baseDir = wsPattern.split('*')[0];
+              const fullBaseDir = path.join(startPath, baseDir);
+
+              if (this.pathExists(fullBaseDir)) {
+                const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (entry.isDirectory()) {
+                    const wsPath = path.join(fullBaseDir, entry.name);
+                    if (this.hasTestScript(wsPath)) {
+                      // Found a workspace with tests, prefer this even without reports
+                      return wsPath;
+                    }
+                  }
+                }
+              }
+            } else {
+              const wsPath = path.join(startPath, wsPattern);
+              if (this.hasTestScript(wsPath)) {
+                return wsPath;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        // Ignore workspace parsing errors
+      }
+    }
+
+    // Fall back to original working directory
+    return startPath;
+  }
+
+  /**
+   * Check if a directory has coverage reports
+   */
+  private hasCoverageReports(dirPath: string): boolean {
+    const coveragePath = path.join(dirPath, 'coverage', 'coverage-final.json');
+    return this.pathExists(coveragePath);
+  }
+
+  /**
+   * Check if a directory has mutation reports
+   */
+  private hasMutationReports(dirPath: string): boolean {
+    const mutationPath = path.join(dirPath, 'reports', 'mutation', 'mutation.json');
+    return this.pathExists(mutationPath);
+  }
+
+  /**
+   * Check if a directory has test results
+   */
+  private hasTestResults(dirPath: string): boolean {
+    const testResultsPath = path.join(dirPath, 'test-results');
+    if (this.pathExists(testResultsPath)) {
+      try {
+        const entries = fs.readdirSync(testResultsPath);
+        return entries.some((entry) => entry.endsWith('.json') || entry.endsWith('.xml'));
+      } catch (error) {
+        // Ignore read errors
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check if a directory has a package.json with test scripts
+   */
+  private hasTestScript(dirPath: string): boolean {
+    const packageJsonPath = path.join(dirPath, 'package.json');
+    if (this.pathExists(packageJsonPath)) {
+      try {
+        const packageJson = this.readJsonFile<any>(packageJsonPath);
+        return !!packageJson?.scripts?.test;
+      } catch (error) {
+        // Ignore parse errors
+      }
+    }
+    return false;
+  }
+
   /**
    * Check if a waiver applies to the given gate
    */
@@ -223,10 +363,11 @@ export class CawsGateChecker extends CawsBaseTool {
         };
       }
 
-      const coveragePath = path.join(
-        options.workingDirectory || this.getWorkingDirectory(),
-        'coverage/coverage-final.json'
+      // Auto-detect the correct directory for coverage reports
+      const reportDir = this.findReportDirectory(
+        options.workingDirectory || this.getWorkingDirectory()
       );
+      const coveragePath = path.join(reportDir, 'coverage', 'coverage-final.json');
 
       if (!this.pathExists(coveragePath)) {
         return {
@@ -234,8 +375,55 @@ export class CawsGateChecker extends CawsBaseTool {
           score: 0,
           details: {
             error: 'Coverage report not found. Run tests with coverage first.',
+            searched_paths: [
+              path.join(reportDir, 'coverage', 'coverage-final.json'),
+              path.join(this.getWorkingDirectory(), 'coverage', 'coverage-final.json'),
+            ],
+            expected_format: 'Istanbul coverage format (coverage-final.json)',
+            expected_schema: {
+              description: 'JSON object with coverage data by file',
+              example: {
+                '/path/to/file.js': {
+                  statementMap: {
+                    /* ... */
+                  },
+                  fnMap: {
+                    /* ... */
+                  },
+                  branchMap: {
+                    /* ... */
+                  },
+                  s: {
+                    /* hit counts */
+                  },
+                  f: {
+                    /* function hits */
+                  },
+                  b: {
+                    /* branch hits */
+                  },
+                },
+              },
+            },
+            run_command: 'npm test -- --coverage --coverageReporters=json',
+            alternative_commands: [
+              'npm run test:coverage',
+              'jest --coverage --coverageReporters=json',
+              'vitest run --coverage',
+            ],
+            workspace_hint:
+              reportDir !== this.getWorkingDirectory()
+                ? `Auto-detected workspace: ${path.relative(this.getWorkingDirectory(), reportDir)}`
+                : 'Run from workspace directory if using monorepo',
+            waiver_available: true,
+            waiver_suggestion:
+              'If this is an exceptional case, consider creating a coverage waiver',
+            waiver_command:
+              'caws waivers create --title="Coverage waiver" --reason=emergency_hotfix --gates=coverage',
           },
-          errors: ['Coverage report not found'],
+          errors: [
+            `Coverage report not found at ${path.relative(this.getWorkingDirectory(), coveragePath)}`,
+          ],
         };
       }
 
@@ -356,10 +544,11 @@ export class CawsGateChecker extends CawsBaseTool {
         };
       }
 
-      const mutationPath = path.join(
-        options.workingDirectory || this.getWorkingDirectory(),
-        'reports/mutation/mutation.json'
+      // Auto-detect the correct directory for mutation reports
+      const reportDir = this.findReportDirectory(
+        options.workingDirectory || this.getWorkingDirectory()
       );
+      const mutationPath = path.join(reportDir, 'reports', 'mutation', 'mutation.json');
 
       if (!this.pathExists(mutationPath)) {
         return {
@@ -367,8 +556,49 @@ export class CawsGateChecker extends CawsBaseTool {
           score: 0,
           details: {
             error: 'Mutation report not found. Run mutation tests first.',
+            searched_paths: [
+              path.join(reportDir, 'reports', 'mutation', 'mutation.json'),
+              path.join(this.getWorkingDirectory(), 'reports', 'mutation', 'mutation.json'),
+            ],
+            expected_format: 'Stryker mutation testing JSON report',
+            expected_schema: {
+              description: 'JSON object with mutation testing results',
+              example: {
+                files: {
+                  /* file-specific results */
+                },
+                testFiles: {
+                  /* test file results */
+                },
+                mutants: [
+                  {
+                    /* mutant details */
+                  },
+                ],
+                metrics: {
+                  killed: 85,
+                  survived: 5,
+                  timeout: 2,
+                  totalDetected: 92,
+                  totalUndetected: 0,
+                  totalValid: 92,
+                },
+              },
+            },
+            run_command: 'npx stryker run',
+            alternative_commands: [
+              'npm run test:mutation',
+              'npx stryker run --configFile stryker.conf.json',
+              'yarn mutation:test',
+            ],
+            workspace_hint:
+              reportDir !== this.getWorkingDirectory()
+                ? `Auto-detected workspace: ${path.relative(this.getWorkingDirectory(), reportDir)}`
+                : 'Run from workspace directory if using monorepo',
           },
-          errors: ['Mutation report not found'],
+          errors: [
+            `Mutation report not found at ${path.relative(this.getWorkingDirectory(), mutationPath)}`,
+          ],
         };
       }
 
@@ -439,17 +669,39 @@ export class CawsGateChecker extends CawsBaseTool {
         };
       }
 
-      const contractResultsPath = path.join(
-        options.workingDirectory || this.getWorkingDirectory(),
-        'test-results/contract-results.json'
+      // Auto-detect the correct directory for contract test results
+      const reportDir = this.findReportDirectory(
+        options.workingDirectory || this.getWorkingDirectory()
       );
+      const contractResultsPath = path.join(reportDir, 'test-results', 'contract-results.json');
 
       if (!this.pathExists(contractResultsPath)) {
         return {
           passed: false,
           score: 0,
-          details: { error: 'Contract test results not found' },
-          errors: ['Contract tests not run or results not found'],
+          details: {
+            error: 'Contract test results not found',
+            searched_paths: [
+              path.join(reportDir, 'test-results', 'contract-results.json'),
+              path.join(this.getWorkingDirectory(), 'test-results', 'contract-results.json'),
+              path.join(reportDir, '.caws', 'contract-results.json'),
+              path.join(this.getWorkingDirectory(), '.caws', 'contract-results.json'),
+            ],
+            expected_format:
+              'JSON with { tests: [], passed: boolean, numPassed: number, numTotal: number }',
+            example_command:
+              'npm run test:contract -- --json --outputFile=test-results/contract-results.json',
+          },
+          errors: [
+            `Contract test results not found. Searched in: ${[
+              path.relative(
+                this.getWorkingDirectory(),
+                path.join(reportDir, 'test-results', 'contract-results.json')
+              ),
+              'test-results/contract-results.json',
+              '.caws/contract-results.json',
+            ].join(', ')}`,
+          ],
         };
       }
 

package/templates/apps/tools/caws/templates/working-spec.template.yml

@@ -15,10 +15,24 @@ acceptance:
     given: '{{GIVEN_CONDITION}}'
     when: '{{WHEN_ACTION}}'
     then: '{{THEN_OUTCOME}}'
+    status: pending # pending | in_progress | completed
+    # Optional: detailed progress tracking
+    # tests:
+    #   written: 0
+    #   passing: 0
+    # coverage: 0.0
+    # last_updated: '2025-10-09T14:30:00Z'
   - id: A2
     given: '{{GIVEN_CONDITION_2}}'
     when: '{{WHEN_ACTION_2}}'
     then: '{{THEN_OUTCOME_2}}'
+    status: pending # pending | in_progress | completed
+    # Optional: detailed progress tracking
+    # tests:
+    #   written: 0
+    #   passing: 0
+    # coverage: 0.0
+    # last_updated: '2025-10-09T14:30:00Z'
 non_functional:
   a11y:
     - '{{ACCESSIBILITY_REQUIREMENT}}'

package/dist/index-new.d.ts

@@ -1,5 +0,0 @@
-#!/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

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

package/dist/index-new.js

@@ -1,317 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * @fileoverview CAWS CLI - Scaffolding tool for Coding Agent Workflow System
- * Provides commands to initialize new projects and scaffold existing ones with CAWS
- * @author @darianrosebrook
- */
-
-const { Command } = require('commander');
-const fs = require('fs-extra');
-const path = require('path');
-const yaml = require('js-yaml');
-const chalk = require('chalk');
-
-// Import configuration and utilities
-const {
-  CLI_VERSION,
-  initializeGlobalSetup,
-  loadProvenanceTools,
-  initializeLanguageSupport,
-} = require('./config');
-
-// Import command handlers
-const { initProject } = require('./commands/init');
-
-// Import scaffold functionality
-const { scaffoldProject, setScaffoldDependencies } = require('./scaffold');
-
-// Import validation functionality
-const { validateWorkingSpecWithSuggestions } = require('./validation/spec-validation');
-
-// Import finalization utilities
-const {
-  finalizeProject,
-  continueToSuccess,
-  setFinalizationDependencies,
-} = require('./utils/finalization');
-
-// Import generators
-const { generateWorkingSpec, validateGeneratedSpec } = require('./generators/working-spec');
-
-// Import tool system
-const ToolLoader = require('./tool-loader');
-const ToolValidator = require('./tool-validator');
-
-// Initialize global configuration
-const program = new Command();
-
-// Initialize global state
-const cawsSetup = initializeGlobalSetup();
-const languageSupport = initializeLanguageSupport();
-
-// Set up dependencies for modules that need them
-setScaffoldDependencies({
-  cawsSetup,
-  loadProvenanceTools,
-});
-
-setFinalizationDependencies({
-  languageSupport,
-  loadProvenanceTools,
-});
-
-// Tool system state
-let toolLoader = null;
-let toolValidator = null;
-
-/**
- * Initialize tool system
- */
-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;
-  }
-}
-
-/**
- * Validate command handler
- */
-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,
-    });
-
-    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);
-  }
-}
-
-/**
- * Tool execution command handler
- */
-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);
-  }
-}
-
-// Setup CLI program
-program.name('caws').description('CAWS - Coding Agent Workflow System CLI').version(CLI_VERSION);
-
-// Init command
-program
-  .command('init')
-  .description('Initialize a new project with CAWS')
-  .argument('[project-name]', 'Name of the project to create (use "." for current directory)')
-  .option('-i, --interactive', 'Run interactive setup wizard', true)
-  .option('--non-interactive', 'Skip interactive prompts (use defaults)', false)
-  .option('--template <template>', 'Use specific project template')
-  .action(initProject);
-
-// Scaffold command
-program
-  .command('scaffold')
-  .description('Add CAWS components to existing project')
-  .option('-f, --force', 'Overwrite existing files', false)
-  .option('--minimal', 'Only essential components', false)
-  .option('--with-codemods', 'Include codemod scripts', false)
-  .option('--with-oidc', 'Include OIDC trusted publisher setup', false)
-  .action(scaffoldProject);
-
-// Validate command
-program
-  .command('validate')
-  .description('Validate CAWS working spec with suggestions')
-  .argument('[spec-file]', 'Path to working spec file (default: .caws/working-spec.yaml)')
-  .option('-q, --quiet', 'Suppress suggestions and warnings', false)
-  .option('--auto-fix', 'Automatically fix safe validation issues', false)
-  .action(validateCommand);
-
-// Tool command
-program
-  .command('tool')
-  .description('Execute CAWS tools programmatically')
-  .argument('<tool-id>', 'ID of the tool to execute')
-  .option('-p, --params <json>', 'Parameters as JSON string', '{}')
-  .option('-t, --timeout <ms>', 'Execution timeout in milliseconds', parseInt, 30000)
-  .action(executeTool);
-
-// Error handling
-program.exitOverride((err) => {
-  if (
-    err.code === 'commander.help' ||
-    err.code === 'commander.version' ||
-    err.message.includes('outputHelp')
-  ) {
-    process.exit(0);
-  }
-  console.error(chalk.red('❌ Error:'), err.message);
-  process.exit(1);
-});
-
-// Parse and run
-if (require.main === module) {
-  try {
-    program.parse();
-  } catch (error) {
-    if (
-      error.code === 'commander.help' ||
-      error.code === 'commander.version' ||
-      error.message.includes('outputHelp')
-    ) {
-      process.exit(0);
-    } else {
-      console.error(chalk.red('❌ Error:'), error.message);
-      process.exit(1);
-    }
-  }
-}
-
-// Export functions for testing
-module.exports = {
-  generateWorkingSpec,
-  validateGeneratedSpec,
-};