scaffold-engine 0.1.0

package/tools/validate-model.cjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+const path = require('path');
+const { resolveScaffoldPath, validateModelFile } = require('./lib/model-toolkit.cjs');
+
+const args = process.argv.slice(2);
+const options = parseArgs(args);
+const inputArg = options.file;
+const specPath = inputArg
+  ? resolveInputPath(inputArg)
+  : resolveScaffoldPath('specs', 'projects', 'crm-pilot', 'customer.yaml');
+
+try {
+  const result = validateModelFile(specPath);
+  if (options.format === 'json') {
+    console.log(JSON.stringify(buildValidationReport(result), null, 2));
+    process.exit(result.valid ? 0 : 1);
+  }
+
+  console.log(`\n📘 模型文件: ${result.absolutePath}`);
+  console.log(`📦 对象: ${result.model.meta.domain}/${result.model.meta.object} (${result.model.meta.label})`);
+  if (result.location) {
+    console.log(`🧭 范围: ${result.location.scope} (${result.location.relativePath})`);
+  }
+
+  if (result.schemaErrors.length > 0) {
+    console.error('\n❌ Schema 校验失败:');
+    for (const error of result.schemaErrors) {
+      console.error(`- ${error}`);
+    }
+  }
+
+  if (result.boundaryErrors.length > 0) {
+    console.error('\n❌ 业务边界校验失败:');
+    for (const error of result.boundaryErrors) {
+      console.error(`- ${error}`);
+    }
+  }
+
+  if ((result.governanceErrors || []).length > 0) {
+    console.error('\n❌ 治理边界校验失败:');
+    for (const error of result.governanceErrors) {
+      console.error(`- ${error}`);
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    console.warn('\n⚠️  提示:');
+    for (const warning of result.warnings) {
+      console.warn(`- ${warning}`);
+    }
+  }
+
+  if (!result.valid) {
+    process.exit(1);
+  }
+
+  console.log('\n✅ 模型校验通过');
+} catch (error) {
+  console.error(`\n❌ 模型校验失败: ${error.message}`);
+  process.exit(1);
+}
+
+function resolveInputPath(filePath) {
+  if (path.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const normalized = String(filePath).replace(/\\/g, '/');
+  if (normalized.startsWith('scaffold/')) {
+    return path.resolve(process.cwd(), normalized.slice('scaffold/'.length));
+  }
+  if (normalized.startsWith('specs/')) {
+    return resolveScaffoldPath(...normalized.split('/'));
+  }
+  return path.resolve(filePath);
+}
+
+function parseArgs(argv) {
+  const options = {
+    file: '',
+    format: 'markdown',
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index];
+    if (item === '--format') {
+      options.format = argv[index + 1] || 'markdown';
+      index += 1;
+      continue;
+    }
+    if (!options.file) {
+      options.file = item;
+    }
+  }
+
+  return options;
+}
+
+function buildValidationReport(result) {
+  const schemaErrors = result.schemaErrors || [];
+  const boundaryErrors = result.boundaryErrors || [];
+  const governanceErrors = result.governanceErrors || [];
+  const warnings = result.warnings || [];
+  const errors = [
+    ...schemaErrors.map((message) => ({ stage: 'schema', message })),
+    ...boundaryErrors.map((message) => ({ stage: 'boundary', message })),
+    ...governanceErrors.map((message) => ({ stage: 'governance', message })),
+  ];
+
+  return {
+    file: result.absolutePath,
+    scope: result.location?.scope || 'unknown',
+    object: {
+      domain: result.model?.meta?.domain || '',
+      object: result.model?.meta?.object || '',
+      label: result.model?.meta?.label || '',
+      pattern: result.model?.meta?.pattern || '',
+    },
+    status: result.valid ? 'passed' : 'failed',
+    nextAction: result.valid ? 'generate' : 'clarify',
+    stages: [
+      {
+        stage: 'schema',
+        status: schemaErrors.length === 0 ? 'passed' : 'failed',
+        errors: schemaErrors,
+      },
+      {
+        stage: 'boundary',
+        status: boundaryErrors.length === 0 ? 'passed' : 'failed',
+        errors: boundaryErrors,
+      },
+      {
+        stage: 'governance',
+        status: governanceErrors.length === 0 ? 'passed' : 'failed',
+        errors: governanceErrors,
+      },
+    ],
+    errors,
+    warnings,
+  };
+}

package/tools/verify-patterns.cjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { resolveScaffoldPath, validateModelFile } = require('./lib/model-toolkit.cjs');
+
+const patternSpecs = [
+  'specs/projects/pattern-examples/document-lines-demo.yaml',
+  'specs/projects/pattern-examples/tree-entity-demo.yaml',
+];
+
+const objectSpecs = [
+  'specs/projects/crm-pilot/customer.yaml',
+  'specs/projects/crm-pilot/lead.yaml',
+];
+
+const targets = [...patternSpecs, ...objectSpecs].map((item) => resolveScaffoldPath(...item.split('/')));
+const failures = [];
+
+for (const specPath of targets) {
+  const validation = validateModelFile(specPath);
+  if (!validation.valid) {
+    failures.push({
+      specPath,
+      stage: 'validate',
+      message: [
+        ...(validation.schemaErrors || []),
+        ...(validation.boundaryErrors || []),
+        ...(validation.governanceErrors || []),
+      ].join('\n'),
+    });
+    continue;
+  }
+
+  const generateResult = spawnSync(process.execPath, [
+    path.join(resolveScaffoldPath('tools'), 'generate-module.cjs'),
+    specPath,
+    '--force',
+    '--dry-run',
+  ], {
+    cwd: resolveScaffoldPath(),
+    encoding: 'utf8',
+  });
+
+  if (generateResult.status !== 0) {
+    failures.push({
+      specPath,
+      stage: 'generate',
+      message: generateResult.stderr || generateResult.stdout || 'dry-run generation failed',
+    });
+    continue;
+  }
+
+  console.log(`✅ ${path.relative(resolveScaffoldPath(), specPath)} (${validation.location?.scope || 'unknown'})`);
+}
+
+if (failures.length > 0) {
+  console.error('\n❌ 模式回归失败:');
+  for (const item of failures) {
+    console.error(`- [${item.stage}] ${path.relative(resolveScaffoldPath(), item.specPath)}`);
+    if (item.message) {
+      console.error(item.message.trim());
+    }
+  }
+  process.exit(1);
+}
+
+console.log('\n✅ 模式回归通过');