scene-capability-engine 3.3.26 → 3.4.6

package/lib/commands/spec-domain.js

@@ -3,7 +3,8 @@ const path = require('path');
 const chalk = require('chalk');
 const {
   ensureSpecDomainArtifacts,
-  validateSpecDomainArtifacts
+  validateSpecDomainArtifacts,
+  analyzeSpecDomainCoverage
 } = require('../spec/domain-modeling');
 
 function normalizeText(value) {
@@ -109,18 +110,29 @@ async function runSpecDomainValidateCommand(options = {}, dependencies = {}) {
   await assertSpecExists(projectPath, specId, fileSystem);
 
   const validation = await validateSpecDomainArtifacts(projectPath, specId, fileSystem);
+  const coverage = await analyzeSpecDomainCoverage(projectPath, specId, fileSystem);
   const payload = {
     mode: 'spec-domain-validate',
     spec_id: specId,
     passed: validation.passed,
     ratio: validation.ratio,
     details: validation.details,
-    warnings: validation.warnings
+    warnings: validation.warnings,
+    coverage: {
+      passed: coverage.passed,
+      coverage_ratio: coverage.coverage_ratio,
+      covered_count: coverage.covered_count,
+      total_count: coverage.total_count,
+      uncovered: coverage.uncovered
+    }
   };
 
   if (options.failOnError && !validation.passed) {
     throw new Error(`spec domain validation failed: ${validation.warnings.join('; ')}`);
   }
+  if (options.failOnGap && !coverage.passed) {
+    throw new Error(`spec domain coverage has gaps: ${coverage.uncovered.join(', ')}`);
+  }
 
   if (options.json) {
     console.log(JSON.stringify(payload, null, 2));
@@ -138,6 +150,49 @@ async function runSpecDomainValidateCommand(options = {}, dependencies = {}) {
   return payload;
 }
 
+async function runSpecDomainCoverageCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const specId = resolveSpecId(options);
+  if (!specId) {
+    throw new Error('--spec is required');
+  }
+  await assertSpecExists(projectPath, specId, fileSystem);
+
+  const coverage = await analyzeSpecDomainCoverage(projectPath, specId, fileSystem);
+  const payload = {
+    mode: 'spec-domain-coverage',
+    spec_id: specId,
+    passed: coverage.passed,
+    coverage_ratio: coverage.coverage_ratio,
+    covered_count: coverage.covered_count,
+    total_count: coverage.total_count,
+    uncovered: coverage.uncovered,
+    items: coverage.items
+  };
+
+  if (options.failOnGap && !coverage.passed) {
+    throw new Error(`spec domain coverage has gaps: ${coverage.uncovered.join(', ')}`);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else if (!options.silent) {
+    if (coverage.passed) {
+      console.log(chalk.green('✓ Spec domain closed-loop coverage passed'));
+    } else {
+      console.log(chalk.red('✗ Spec domain closed-loop coverage has gaps'));
+      coverage.items
+        .filter((item) => !item.covered)
+        .forEach((item) => {
+          console.log(chalk.gray(`  - ${item.id}: ${item.label}`));
+        });
+    }
+  }
+
+  return payload;
+}
+
 function registerSpecDomainCommand(program) {
   const specDomain = program
     .command('spec-domain')
@@ -194,6 +249,7 @@ function registerSpecDomainCommand(program) {
     .description('Validate problem-domain artifacts for a Spec')
     .requiredOption('--spec <name>', 'Spec identifier')
     .option('--fail-on-error', 'Exit non-zero when validation fails')
+    .option('--fail-on-gap', 'Exit non-zero when closed-loop coverage is incomplete')
     .option('--json', 'Output machine-readable JSON')
     .action(async (options) => {
       try {
@@ -207,11 +263,31 @@ function registerSpecDomainCommand(program) {
         process.exit(1);
       }
     });
+
+  specDomain
+    .command('coverage')
+    .description('Analyze scene-closed-loop research coverage for a Spec')
+    .requiredOption('--spec <name>', 'Spec identifier')
+    .option('--fail-on-gap', 'Exit non-zero when closed-loop coverage is incomplete')
+    .option('--json', 'Output machine-readable JSON')
+    .action(async (options) => {
+      try {
+        await runSpecDomainCoverageCommand(options);
+      } catch (error) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+        } else {
+          console.error(chalk.red('❌ spec-domain coverage failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
 }
 
 module.exports = {
   runSpecDomainInitCommand,
   runSpecDomainRefreshCommand,
   runSpecDomainValidateCommand,
+  runSpecDomainCoverageCommand,
   registerSpecDomainCommand
 };