scene-capability-engine 3.3.22 → 3.3.24

package/lib/commands/spec-bootstrap.js

@@ -11,6 +11,7 @@ const { ContextCollector } = require('../spec/bootstrap/context-collector');
 const { QuestionnaireEngine } = require('../spec/bootstrap/questionnaire-engine');
 const { DraftGenerator } = require('../spec/bootstrap/draft-generator');
 const { TraceEmitter } = require('../spec/bootstrap/trace-emitter');
+const { ensureSpecDomainArtifacts } = require('../spec/domain-modeling');
 const { SessionStore } = require('../runtime/session-store');
 const { resolveSpecSceneBinding } = require('../runtime/scene-session-binding');
 const { bindMultiSpecSceneSession } = require('../runtime/multi-spec-scene-session');
@@ -114,6 +115,14 @@ async function runSpecBootstrap(options = {}, dependencies = {}) {
       await fs.writeFile(files.tasks, draft.tasks, 'utf8');
     }
 
+    const domainArtifacts = await ensureSpecDomainArtifacts(projectPath, specName, {
+      dryRun: !!options.dryRun,
+      sceneId: sceneBinding.scene_id,
+      problemStatement: answers.problemStatement,
+      primaryFlow: answers.primaryFlow,
+      verificationPlan: answers.verificationPlan
+    });
+
     const result = {
       success: true,
       specName,
@@ -122,7 +131,10 @@ async function runSpecBootstrap(options = {}, dependencies = {}) {
       files: {
         requirements: path.relative(projectPath, files.requirements),
         design: path.relative(projectPath, files.design),
-        tasks: path.relative(projectPath, files.tasks)
+        tasks: path.relative(projectPath, files.tasks),
+        domain_map: path.relative(projectPath, domainArtifacts.paths.domain_map),
+        scene_spec: path.relative(projectPath, domainArtifacts.paths.scene_spec),
+        domain_chain: path.relative(projectPath, domainArtifacts.paths.domain_chain)
       },
       trace: {
         template: options.template || 'default',
@@ -141,7 +153,10 @@ async function runSpecBootstrap(options = {}, dependencies = {}) {
       preview: {
         requirements: draft.requirements,
         design: draft.design,
-        tasks: draft.tasks
+        tasks: draft.tasks,
+        domain_map: domainArtifacts.preview.domain_map,
+        scene_spec: domainArtifacts.preview.scene_spec,
+        domain_chain: domainArtifacts.preview.domain_chain
       },
       scene_session: sceneBinding
         ? {

package/lib/commands/spec-domain.js

@@ -0,0 +1,217 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const {
+  ensureSpecDomainArtifacts,
+  validateSpecDomainArtifacts
+} = require('../spec/domain-modeling');
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function resolveSpecId(options = {}) {
+  return normalizeText(options.spec || options.name);
+}
+
+async function assertSpecExists(projectPath, specId, fileSystem = fs) {
+  const specPath = path.join(projectPath, '.sce', 'specs', specId);
+  if (!await fileSystem.pathExists(specPath)) {
+    throw new Error(`Spec not found: ${specId}`);
+  }
+  return specPath;
+}
+
+async function runSpecDomainInitCommand(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 result = await ensureSpecDomainArtifacts(projectPath, specId, {
+    fileSystem,
+    dryRun: options.dryRun === true,
+    force: false,
+    sceneId: options.scene,
+    problemStatement: options.problem,
+    primaryFlow: options.primaryFlow,
+    verificationPlan: options.verificationPlan
+  });
+
+  const payload = {
+    mode: 'spec-domain-init',
+    spec_id: specId,
+    dry_run: options.dryRun === true,
+    created: result.created,
+    files: result.paths
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else if (!options.silent) {
+    console.log(chalk.green('✓ Spec domain artifacts initialized'));
+    console.log(chalk.gray(`  spec: ${specId}`));
+  }
+
+  return payload;
+}
+
+async function runSpecDomainRefreshCommand(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 result = await ensureSpecDomainArtifacts(projectPath, specId, {
+    fileSystem,
+    dryRun: options.dryRun === true,
+    force: true,
+    sceneId: options.scene,
+    problemStatement: options.problem,
+    primaryFlow: options.primaryFlow,
+    verificationPlan: options.verificationPlan
+  });
+
+  const payload = {
+    mode: 'spec-domain-refresh',
+    spec_id: specId,
+    dry_run: options.dryRun === true,
+    refreshed: result.created,
+    files: result.paths
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else if (!options.silent) {
+    console.log(chalk.green('✓ Spec domain artifacts refreshed'));
+    console.log(chalk.gray(`  spec: ${specId}`));
+  }
+
+  return payload;
+}
+
+async function runSpecDomainValidateCommand(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 validation = await validateSpecDomainArtifacts(projectPath, specId, fileSystem);
+  const payload = {
+    mode: 'spec-domain-validate',
+    spec_id: specId,
+    passed: validation.passed,
+    ratio: validation.ratio,
+    details: validation.details,
+    warnings: validation.warnings
+  };
+
+  if (options.failOnError && !validation.passed) {
+    throw new Error(`spec domain validation failed: ${validation.warnings.join('; ')}`);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else if (!options.silent) {
+    if (validation.passed) {
+      console.log(chalk.green('✓ Spec domain validation passed'));
+    } else {
+      console.log(chalk.red('✗ Spec domain validation failed'));
+      validation.warnings.forEach((message) => {
+        console.log(chalk.gray(`  - ${message}`));
+      });
+    }
+  }
+
+  return payload;
+}
+
+function registerSpecDomainCommand(program) {
+  const specDomain = program
+    .command('spec-domain')
+    .description('Manage problem-domain modeling artifacts (use: sce spec domain)');
+
+  specDomain
+    .command('init')
+    .description('Create missing problem-domain artifacts for a Spec')
+    .requiredOption('--spec <name>', 'Spec identifier')
+    .option('--scene <scene-id>', 'Scene id used in generated chain/model')
+    .option('--problem <text>', 'Problem statement seed')
+    .option('--primary-flow <text>', 'Primary flow seed')
+    .option('--verification-plan <text>', 'Verification plan seed')
+    .option('--dry-run', 'Preview output without writing files')
+    .option('--json', 'Output machine-readable JSON')
+    .action(async (options) => {
+      try {
+        await runSpecDomainInitCommand(options);
+      } catch (error) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+        } else {
+          console.error(chalk.red('❌ spec-domain init failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+
+  specDomain
+    .command('refresh')
+    .description('Force-refresh problem-domain artifacts for a Spec')
+    .requiredOption('--spec <name>', 'Spec identifier')
+    .option('--scene <scene-id>', 'Scene id used in generated chain/model')
+    .option('--problem <text>', 'Problem statement seed')
+    .option('--primary-flow <text>', 'Primary flow seed')
+    .option('--verification-plan <text>', 'Verification plan seed')
+    .option('--dry-run', 'Preview output without writing files')
+    .option('--json', 'Output machine-readable JSON')
+    .action(async (options) => {
+      try {
+        await runSpecDomainRefreshCommand(options);
+      } catch (error) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+        } else {
+          console.error(chalk.red('❌ spec-domain refresh failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+
+  specDomain
+    .command('validate')
+    .description('Validate problem-domain artifacts for a Spec')
+    .requiredOption('--spec <name>', 'Spec identifier')
+    .option('--fail-on-error', 'Exit non-zero when validation fails')
+    .option('--json', 'Output machine-readable JSON')
+    .action(async (options) => {
+      try {
+        await runSpecDomainValidateCommand(options);
+      } catch (error) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+        } else {
+          console.error(chalk.red('❌ spec-domain validate failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = {
+  runSpecDomainInitCommand,
+  runSpecDomainRefreshCommand,
+  runSpecDomainValidateCommand,
+  registerSpecDomainCommand
+};