scene-capability-engine 3.6.45 → 3.6.46

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);
+}

package/scripts/errorbook-registry-health-gate.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { runErrorbookRegistryHealthCommand } = require('../lib/commands/errorbook');
+
+function parseBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  const normalized = `${value || ''}`.trim().toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (['1', 'true', 'yes', 'on', 'y'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'off', 'n'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function parseArgs(argv = [], env = process.env) {
+  const options = {
+    strict: parseBoolean(env.SCE_REGISTRY_HEALTH_STRICT, false),
+    json: false,
+    projectPath: process.cwd(),
+    maxShards: 8,
+    shardSample: 2
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const next = argv[index + 1];
+
+    if (token === '--strict') {
+      options.strict = true;
+    } else if (token === '--no-strict') {
+      options.strict = false;
+    } else if (token === '--json') {
+      options.json = true;
+    } else if (token === '--project-path' && next) {
+      options.projectPath = path.resolve(next);
+      index += 1;
+    } else if (token === '--config' && next) {
+      options.config = next;
+      index += 1;
+    } else if (token === '--cache' && next) {
+      options.cache = next;
+      index += 1;
+    } else if (token === '--source' && next) {
+      options.source = next;
+      index += 1;
+    } else if (token === '--source-name' && next) {
+      options.sourceName = next;
+      index += 1;
+    } else if (token === '--index' && next) {
+      options.index = next;
+      index += 1;
+    } else if (token === '--max-shards' && next) {
+      options.maxShards = Number.parseInt(next, 10);
+      index += 1;
+    } else if (token === '--shard-sample' && next) {
+      options.shardSample = Number.parseInt(next, 10);
+      index += 1;
+    } else if (token === '--help' || token === '-h') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  const lines = [
+    'Usage: node scripts/errorbook-registry-health-gate.js [options]',
+    '',
+    'Options:',
+    '  --strict                Exit with code 2 when health check reports errors',
+    '  --no-strict             Force advisory mode even if env is strict',
+    '  --project-path <path>   Override project path (default: cwd)',
+    '  --config <path>         Registry config path override',
+    '  --cache <path>          Registry cache path override',
+    '  --source <url-or-path>  Override registry source JSON',
+    '  --source-name <name>    Override registry source label',
+    '  --index <url-or-path>   Override registry index JSON',
+    '  --max-shards <n>        Max index-resolved shards to validate (default: 8)',
+    '  --shard-sample <n>      Number of shard files to fetch for validation (default: 2)',
+    '  --json                  Print JSON payload',
+    '  -h, --help              Show this help',
+    '',
+    'Environment:',
+    '  SCE_REGISTRY_HEALTH_STRICT=1 enables strict mode by default'
+  ];
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+async function runErrorbookRegistryHealthGateScript(options = {}) {
+  const health = await runErrorbookRegistryHealthCommand({
+    config: options.config,
+    cache: options.cache,
+    source: options.source,
+    sourceName: options.sourceName,
+    index: options.index,
+    maxShards: options.maxShards,
+    shardSample: options.shardSample,
+    silent: true
+  }, {
+    projectPath: options.projectPath
+  });
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({
+      ...health,
+      mode: 'errorbook-registry-health-gate',
+      strict: options.strict === true
+    }, null, 2)}\n`);
+  } else if (health.passed) {
+    process.stdout.write('[errorbook-registry-health-gate] passed\n');
+    process.stdout.write(
+      `[errorbook-registry-health-gate] sources=${health.config.source_count} warnings=${health.warning_count} errors=0\n`
+    );
+  } else {
+    process.stdout.write('[errorbook-registry-health-gate] alert\n');
+    process.stdout.write(
+      `[errorbook-registry-health-gate] sources=${health.config.source_count} warnings=${health.warning_count} errors=${health.error_count}\n`
+    );
+    health.errors.slice(0, 20).forEach((message) => {
+      process.stdout.write(`[errorbook-registry-health-gate] error=${message}\n`);
+    });
+  }
+
+  const exitCode = options.strict && !health.passed ? 2 : 0;
+  return {
+    ...health,
+    mode: 'errorbook-registry-health-gate',
+    strict: options.strict === true,
+    exit_code: exitCode
+  };
+}
+
+if (require.main === module) {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  runErrorbookRegistryHealthGateScript(options)
+    .then((result) => {
+      process.exitCode = result.exit_code;
+    })
+    .catch((error) => {
+      const payload = {
+        mode: 'errorbook-registry-health-gate',
+        passed: false,
+        error: error.message
+      };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      } else {
+        process.stderr.write(`[errorbook-registry-health-gate] error=${error.message}\n`);
+      }
+      process.exitCode = 1;
+    });
+}
+
+module.exports = {
+  parseArgs,
+  runErrorbookRegistryHealthGateScript
+};

package/scripts/errorbook-release-gate.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { evaluateErrorbookReleaseGate } = require('../lib/commands/errorbook');
+
+function parseArgs(argv = []) {
+  const options = {
+    minRisk: 'high',
+    minQuality: 70,
+    includeVerified: false,
+    failOnBlock: false,
+    json: false,
+    projectPath: process.cwd()
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const next = argv[index + 1];
+
+    if (token === '--min-risk' && next) {
+      options.minRisk = `${next}`.trim().toLowerCase();
+      index += 1;
+    } else if (token === '--min-quality' && next) {
+      const parsed = Number.parseInt(`${next}`, 10);
+      if (Number.isFinite(parsed)) {
+        options.minQuality = Math.max(0, Math.min(100, parsed));
+      }
+      index += 1;
+    } else if (token === '--include-verified') {
+      options.includeVerified = true;
+    } else if (token === '--fail-on-block') {
+      options.failOnBlock = true;
+    } else if (token === '--json') {
+      options.json = true;
+    } else if (token === '--project-path' && next) {
+      options.projectPath = path.resolve(next);
+      index += 1;
+    } else if (token === '--help' || token === '-h') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  const lines = [
+    'Usage: node scripts/errorbook-release-gate.js [options]',
+    '',
+    'Options:',
+    '  --min-risk <level>      Risk threshold to block release (low|medium|high, default: high)',
+    '  --min-quality <0-100>   Minimum curation quality for unresolved entries (default: 70)',
+    '  --include-verified      Also inspect verified (non-promoted) entries for risk threshold',
+    '                          (temporary mitigation policy is always enforced for active entries)',
+    '  --fail-on-block         Exit with code 2 when gate is blocked',
+    '  --project-path <path>   Override project path (default: cwd)',
+    '  --json                  Print JSON payload',
+    '  -h, --help              Show this help'
+  ];
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+async function runErrorbookReleaseGateScript(options = {}) {
+  const payload = await evaluateErrorbookReleaseGate({
+    minRisk: options.minRisk,
+    minQuality: options.minQuality,
+    includeVerified: options.includeVerified
+  }, {
+    projectPath: options.projectPath
+  });
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else if (payload.passed) {
+    process.stdout.write('[errorbook-release-gate] passed\n');
+    process.stdout.write(`[errorbook-release-gate] inspected=${payload.inspected_count} blocked=0\n`);
+  } else {
+    process.stdout.write('[errorbook-release-gate] blocked\n');
+    process.stdout.write(
+      `[errorbook-release-gate] inspected=${payload.inspected_count} blocked=${payload.blocked_count} min-risk=${payload.gate.min_risk} min-quality=${payload.gate.min_quality}\n`
+    );
+    process.stdout.write(
+      `[errorbook-release-gate] risk-blocked=${payload.risk_blocked_count || 0} curation-blocked=${payload.curation_blocked_count || 0} mitigation-blocked=${payload.mitigation_blocked_count || 0}\n`
+    );
+    payload.blocked_entries.slice(0, 20).forEach((item) => {
+      const policy = Array.isArray(item.policy_violations) && item.policy_violations.length > 0
+        ? ` policy=${item.policy_violations.join('|')}`
+        : '';
+      process.stdout.write(
+        `[errorbook-release-gate] entry=${item.id} risk=${item.risk} status=${item.status} quality=${item.quality_score}${policy}\n`
+      );
+    });
+  }
+
+  const exitCode = options.failOnBlock && !payload.passed ? 2 : 0;
+  return {
+    ...payload,
+    exit_code: exitCode
+  };
+}
+
+if (require.main === module) {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  runErrorbookReleaseGateScript(options)
+    .then((result) => {
+      process.exitCode = result.exit_code;
+    })
+    .catch((error) => {
+      const payload = {
+        mode: 'errorbook-release-gate',
+        passed: false,
+        error: error.message
+      };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      } else {
+        process.stderr.write(`[errorbook-release-gate] error=${error.message}\n`);
+      }
+      process.exitCode = 1;
+    });
+}
+
+module.exports = {
+  parseArgs,
+  runErrorbookReleaseGateScript
+};