scene-capability-engine 3.6.45 → 3.6.47

package/scripts/capability-mapping-report.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+function parseArgs(argv = []) {
+  const options = {
+    input: '',
+    inputFile: '',
+    changesFile: '',
+    templatesFile: '',
+    ontologyFile: '',
+    out: '',
+    json: false
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const next = argv[index + 1];
+    if (token === '--input' && next) {
+      options.input = next;
+      index += 1;
+      continue;
+    }
+    if (token === '--input-file' && next) {
+      options.inputFile = next;
+      index += 1;
+      continue;
+    }
+    if (token === '--changes-file' && next) {
+      options.changesFile = next;
+      index += 1;
+      continue;
+    }
+    if (token === '--templates-file' && next) {
+      options.templatesFile = next;
+      index += 1;
+      continue;
+    }
+    if (token === '--ontology-file' && next) {
+      options.ontologyFile = next;
+      index += 1;
+      continue;
+    }
+    if (token === '--out' && next) {
+      options.out = next;
+      index += 1;
+      continue;
+    }
+    if (token === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (token === '--help' || token === '-h') {
+      printHelpAndExit(0);
+    }
+  }
+
+  return options;
+}
+
+function printHelpAndExit(code) {
+  const lines = [
+    'Usage: node scripts/capability-mapping-report.js [options]',
+    '',
+    'Options:',
+    '  --input <json>            Inline input payload (changes/templates/ontology)',
+    '  --input-file <path>       Input JSON file (changes/templates/ontology)',
+    '  --changes-file <path>     Changes JSON file (array)',
+    '  --templates-file <path>   Template catalog JSON file (array)',
+    '  --ontology-file <path>    Ontology model JSON file',
+    '  --out <path>              Output report path',
+    '  --json                    Print JSON payload',
+    '  -h, --help                Show this help'
+  ];
+  console.log(lines.join('\n'));
+  process.exit(code);
+}
+
+async function readJsonIfExists(filePath) {
+  if (!filePath) {
+    return null;
+  }
+  const resolved = path.resolve(process.cwd(), filePath);
+  if (!(await fs.pathExists(resolved))) {
+    throw new Error(`file not found: ${filePath}`);
+  }
+  return fs.readJson(resolved);
+}
+
+function normalizeChanges(changes) {
+  const array = Array.isArray(changes) ? changes : [];
+  return array
+    .filter((item) => item && typeof item === 'object')
+    .map((item) => {
+      const type = `${item.type || item.node_type || ''}`.trim().toLowerCase();
+      const name = `${item.name || item.ref || item.id || ''}`.trim();
+      const changeId = `${item.change_id || item.id || (type && name ? `${type}:${name}` : name || type || 'unknown')}`;
+      return {
+        change_id: changeId,
+        type: type || 'unknown',
+        name: name || changeId,
+        operation: `${item.operation || item.action || 'update'}`.trim().toLowerCase()
+      };
+    });
+}
+
+function normalizeTemplates(templates) {
+  const array = Array.isArray(templates) ? templates : [];
+  return array
+    .filter((item) => item && typeof item === 'object')
+    .map((item) => ({
+      id: `${item.id || item.template_id || item.name || 'unknown-template'}`.trim(),
+      capabilities: Array.isArray(item.capabilities)
+        ? item.capabilities.map((capability) => `${capability}`.trim().toLowerCase()).filter(Boolean)
+        : []
+    }));
+}
+
+function normalizeOntology(ontology = {}) {
+  const pickNames = (values) => {
+    if (!Array.isArray(values)) {
+      return new Set();
+    }
+    return new Set(
+      values
+        .map((value) => {
+          if (typeof value === 'string') {
+            return value.trim().toLowerCase();
+          }
+          if (value && typeof value === 'object') {
+            return `${value.name || value.ref || value.id || ''}`.trim().toLowerCase();
+          }
+          return '';
+        })
+        .filter(Boolean)
+    );
+  };
+
+  return {
+    entities: pickNames(ontology.entities),
+    business_rules: pickNames(ontology.business_rules),
+    decision_strategies: pickNames(ontology.decision_strategies),
+    relations: Array.isArray(ontology.relations) ? ontology.relations : []
+  };
+}
+
+function normalizeCapability(type, name) {
+  const loweredName = `${name || ''}`.trim().toLowerCase();
+  if (!loweredName) {
+    return 'unknown:unknown';
+  }
+  if (type === 'entity') {
+    return `entity:${loweredName}`;
+  }
+  if (type === 'business_rule' || type === 'rule') {
+    return `rule:${loweredName}`;
+  }
+  if (type === 'decision_strategy' || type === 'decision') {
+    return `decision:${loweredName}`;
+  }
+  if (type === 'service') {
+    return `service:${loweredName}`;
+  }
+  if (type === 'scene') {
+    return `scene:${loweredName}`;
+  }
+  return `${type || 'unknown'}:${loweredName}`;
+}
+
+function capabilityMatches(capability, templateCapability) {
+  if (!capability || !templateCapability) {
+    return false;
+  }
+  if (templateCapability === capability) {
+    return true;
+  }
+  if (templateCapability.endsWith('*')) {
+    const prefix = templateCapability.slice(0, -1);
+    return capability.startsWith(prefix);
+  }
+  return false;
+}
+
+function findMappedTemplates(capability, templates) {
+  const mapped = [];
+  for (const template of templates) {
+    if (template.capabilities.some((item) => capabilityMatches(capability, item))) {
+      mapped.push(template.id);
+    }
+  }
+  return mapped;
+}
+
+function checkOntologyCoverage(type, name, ontology) {
+  const loweredName = `${name || ''}`.trim().toLowerCase();
+  if (!loweredName) {
+    return false;
+  }
+  if (type === 'entity') {
+    return ontology.entities.has(loweredName);
+  }
+  if (type === 'business_rule' || type === 'rule') {
+    return ontology.business_rules.has(loweredName);
+  }
+  if (type === 'decision_strategy' || type === 'decision') {
+    return ontology.decision_strategies.has(loweredName);
+  }
+  return true;
+}
+
+function buildMappingReport({ changes, templates, ontology }) {
+  const mappingReport = [];
+  const missingCapabilities = [];
+  const recommendedTemplates = new Set();
+  const ontologyGaps = [];
+
+  for (const change of changes) {
+    const capability = normalizeCapability(change.type, change.name);
+    const mappedTemplates = findMappedTemplates(capability, templates);
+    const ontologyCovered = checkOntologyCoverage(change.type, change.name, ontology);
+
+    for (const templateId of mappedTemplates) {
+      recommendedTemplates.add(templateId);
+    }
+
+    if (mappedTemplates.length === 0) {
+      missingCapabilities.push(capability);
+    }
+    if (!ontologyCovered) {
+      ontologyGaps.push({
+        change_id: change.change_id,
+        type: change.type,
+        name: change.name,
+        capability
+      });
+    }
+
+    const status = mappedTemplates.length > 0
+      ? 'mapped'
+      : (ontologyCovered ? 'missing_template' : 'missing_template_and_ontology_gap');
+
+    mappingReport.push({
+      change_id: change.change_id,
+      capability,
+      mapped_templates: mappedTemplates,
+      ontology_status: ontologyCovered ? 'covered' : 'gap',
+      status
+    });
+  }
+
+  const totalChanges = mappingReport.length;
+  const mappedChanges = mappingReport.filter((item) => item.mapped_templates.length > 0).length;
+  const coveragePercent = totalChanges === 0
+    ? 100
+    : Number(((mappedChanges / totalChanges) * 100).toFixed(2));
+
+  return {
+    mode: 'capability-mapping-report',
+    generated_at: new Date().toISOString(),
+    mapping_report: mappingReport,
+    missing_capabilities: [...new Set(missingCapabilities)],
+    recommended_templates: [...recommendedTemplates],
+    ontology_gaps: ontologyGaps,
+    summary: {
+      total_changes: totalChanges,
+      mapped_changes: mappedChanges,
+      missing_capabilities: [...new Set(missingCapabilities)].length,
+      ontology_gaps: ontologyGaps.length,
+      coverage_percent: coveragePercent
+    }
+  };
+}
+
+async function loadInput(options) {
+  const inline = options.input ? JSON.parse(options.input) : null;
+  const inputFilePayload = options.inputFile ? await readJsonIfExists(options.inputFile) : null;
+  const changesPayload = options.changesFile ? await readJsonIfExists(options.changesFile) : null;
+  const templatesPayload = options.templatesFile ? await readJsonIfExists(options.templatesFile) : null;
+  const ontologyPayload = options.ontologyFile ? await readJsonIfExists(options.ontologyFile) : null;
+
+  const source = inline || inputFilePayload || {};
+  const changes = normalizeChanges(
+    changesPayload || source.changes || source.change_set || source.mapping_input
+  );
+  const templates = normalizeTemplates(
+    templatesPayload || source.templates || source.template_catalog || source.scene_templates
+  );
+  const ontology = normalizeOntology(
+    ontologyPayload || source.ontology || source.ontology_model || {}
+  );
+
+  return {
+    changes,
+    templates,
+    ontology
+  };
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const input = await loadInput(options);
+  const payload = buildMappingReport(input);
+
+  if (options.out) {
+    const outPath = path.resolve(process.cwd(), options.out);
+    await fs.ensureDir(path.dirname(outPath));
+    await fs.writeJson(outPath, payload, { spaces: 2 });
+  }
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write(`capability mapping coverage=${payload.summary.coverage_percent}%\n`);
+    process.stdout.write(`missing_capabilities=${payload.summary.missing_capabilities}\n`);
+    process.stdout.write(`ontology_gaps=${payload.summary.ontology_gaps}\n`);
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`capability-mapping-report failed: ${error.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  parseArgs,
+  normalizeChanges,
+  normalizeTemplates,
+  normalizeOntology,
+  normalizeCapability,
+  capabilityMatches,
+  findMappedTemplates,
+  checkOntologyCoverage,
+  buildMappingReport,
+  loadInput
+};

package/scripts/check-branding-consistency.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const LEGACY_PATTERNS = [
+  {
+    label: 'legacy CLI alias',
+    regex: /\bkse\b/gi
+  },
+  {
+    label: 'legacy social handle',
+    regex: /@kse_dev/gi
+  },
+  {
+    label: 'legacy GitHub repository URL',
+    regex: /https:\/\/github\.com\/heguangyong\/kiro-spec-engine/gi
+  },
+  {
+    label: 'legacy template repository name',
+    regex: /\bkse-spec-templates\b/gi
+  },
+  {
+    label: 'legacy product naming',
+    regex: /\bKiro Spec Engine\b|\bScene Capability Orchestrator\b|场景能力编排引擎/g
+  },
+  {
+    label: 'legacy Kiro IDE wording',
+    regex: /\bKiro IDE\b/gi
+  },
+  {
+    label: 'legacy npm package name',
+    regex: /\bsco-engine\b/gi
+  }
+];
+
+const EXCLUDE_PREFIXES = [
+  '.sce/',
+  'tests/fixtures/',
+  'node_modules/'
+];
+
+const EXCLUDE_FILES = new Set([
+  'scripts/check-branding-consistency.js'
+]);
+
+const HISTORY_ALLOW_PREFIXES = [
+  'docs/releases/',
+  'docs/zh/releases/'
+];
+
+const HISTORY_ALLOW_FILES = new Set([
+  'CHANGELOG.md'
+]);
+
+const TEXT_EXTENSIONS = new Set([
+  '.js', '.json', '.md', '.txt', '.yml', '.yaml'
+]);
+
+function getTrackedFiles() {
+  const output = execSync('git ls-files', { encoding: 'utf8' });
+  return output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function shouldScan(filePath) {
+  if (EXCLUDE_FILES.has(filePath)) {
+    return false;
+  }
+
+  if (EXCLUDE_PREFIXES.some((prefix) => filePath.startsWith(prefix))) {
+    return false;
+  }
+
+  const ext = path.extname(filePath).toLowerCase();
+  return TEXT_EXTENSIONS.has(ext);
+}
+
+function isHistoryDocument(filePath) {
+  return HISTORY_ALLOW_FILES.has(filePath)
+    || HISTORY_ALLOW_PREFIXES.some((prefix) => filePath.startsWith(prefix));
+}
+
+function scanFile(filePath) {
+  let content = '';
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch (_error) {
+    return [];
+  }
+
+  const hits = [];
+
+  for (const pattern of LEGACY_PATTERNS) {
+    const matches = content.match(pattern.regex);
+    if (matches && matches.length > 0) {
+      if (isHistoryDocument(filePath)) {
+        continue;
+      }
+      hits.push({
+        label: pattern.label,
+        count: matches.length
+      });
+    }
+  }
+
+  return hits;
+}
+
+function main() {
+  const files = getTrackedFiles().filter(shouldScan);
+  const violations = [];
+
+  for (const filePath of files) {
+    const hits = scanFile(filePath);
+    if (hits.length > 0) {
+      violations.push({ filePath, hits });
+    }
+  }
+
+  if (violations.length === 0) {
+    console.log('Branding consistency check passed: no legacy naming references found.');
+    return;
+  }
+
+  console.error('Branding consistency check failed. Found legacy naming references:');
+  for (const violation of violations) {
+    const summary = violation.hits
+      .map((hit) => `${hit.label} x${hit.count}`)
+      .join(', ');
+    console.error(`- ${violation.filePath}: ${summary}`);
+  }
+
+  process.exit(1);
+}
+
+main();

package/scripts/check-sce-tracking.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+const { auditSceTracking } = require('../lib/workspace/sce-tracking-audit');
+
+function printTextReport(report) {
+  if (report.passed) {
+    console.log('SCE tracking audit passed.');
+    console.log(`Fixture tracked specs: ${report.summary.fixture_spec_files}`);
+    console.log(`Fixture tracked templates: ${report.summary.fixture_template_files}`);
+    return;
+  }
+
+  console.error('SCE tracking audit failed.');
+  if (report.missing_required_files.length > 0) {
+    console.error('Missing required tracked files:');
+    for (const filePath of report.missing_required_files) {
+      console.error(`  - ${filePath}`);
+    }
+  }
+  if (report.summary.fixture_spec_files === 0) {
+    console.error('No tracked fixture spec files were found under tests/fixtures/.../.sce/specs.');
+  }
+  if (report.summary.fixture_template_files === 0) {
+    console.error('No tracked fixture template files were found under tests/fixtures/.../.sce/templates.');
+  }
+  if (report.fixture.disallowed_tracked_files.length > 0) {
+    console.error('Disallowed tracked fixture runtime files found:');
+    for (const filePath of report.fixture.disallowed_tracked_files) {
+      console.error(`  - ${filePath}`);
+    }
+  }
+}
+
+function main() {
+  const json = process.argv.includes('--json');
+  const report = auditSceTracking(process.cwd());
+
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    printTextReport(report);
+  }
+
+  if (!report.passed) {
+    process.exit(1);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`SCE tracking audit error: ${error.message}`);
+  process.exit(1);
+}

package/scripts/check-skip-allowlist.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.resolve(__dirname, '..');
+const testsRoot = path.join(repoRoot, 'tests');
+const allowlistPath = path.join(repoRoot, 'tests', 'skip-allowlist.txt');
+
+function walkFiles(dirPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const absolutePath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFiles(absolutePath));
+      continue;
+    }
+
+    if (entry.isFile() && (entry.name.endsWith('.test.js') || entry.name.endsWith('.spec.js'))) {
+      files.push(absolutePath);
+    }
+  }
+
+  return files;
+}
+
+function loadAllowlist(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Allowlist file not found: ${filePath}`);
+  }
+
+  return fs.readFileSync(filePath, 'utf8')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(line => line.length > 0 && !line.startsWith('#'));
+}
+
+function collectSkippedTests() {
+  const testFiles = walkFiles(testsRoot);
+  const skipPattern = /\b(?:test|it|describe)\.skip\(\s*(['"`])([^'"`]+)\1/g;
+  const skipped = [];
+
+  for (const filePath of testFiles) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const relativePath = path.relative(repoRoot, filePath).replace(/\\/g, '/');
+    let match = skipPattern.exec(content);
+
+    while (match) {
+      skipped.push(`${relativePath}::${match[2]}`);
+      match = skipPattern.exec(content);
+    }
+  }
+
+  return skipped.sort();
+}
+
+function main() {
+  const allowlist = loadAllowlist(allowlistPath);
+  const skipped = collectSkippedTests();
+
+  const allowSet = new Set(allowlist);
+  const skippedSet = new Set(skipped);
+
+  const unexpected = skipped.filter(item => !allowSet.has(item));
+  const stale = allowlist.filter(item => !skippedSet.has(item));
+
+  console.log(`Skip audit: ${skipped.length} skipped tests, ${allowlist.length} allowlisted entries`);
+
+  if (stale.length > 0) {
+    console.log('Stale allowlist entries (safe to remove):');
+    for (const item of stale) {
+      console.log(`  - ${item}`);
+    }
+  }
+
+  if (unexpected.length > 0) {
+    console.error('Unexpected skipped tests found:');
+    for (const item of unexpected) {
+      console.error(`  - ${item}`);
+    }
+    process.exit(1);
+  }
+
+  console.log('Skip audit passed.');
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`Skip audit failed: ${error.message}`);
+  process.exit(1);
+}