scaffold-engine 0.1.0

package/tools/run-requirement.cjs

@@ -0,0 +1,672 @@
+#!/usr/bin/env node
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { analyzeRequirement, parseArgs, readRequirementText, renderMarkdown, writeSuggestedSpec } = require('./analyze-requirement.cjs');
+const { loadRuntimeConfig, resolveScaffoldPath, validateModelFile } = require('./lib/model-toolkit.cjs');
+const { resolveGeneratedSpecPath } = require('./lib/runtime-config.cjs');
+
+const options = parseRunnerArgs(process.argv.slice(2));
+
+class PipelineError extends Error {
+  constructor(stage, code, message, details = {}, exitCode = 1) {
+    super(message);
+    this.name = 'PipelineError';
+    this.stage = stage;
+    this.code = code;
+    this.details = details;
+    this.exitCode = exitCode;
+  }
+}
+
+(async () => {
+  try {
+    const runtimeConfig = loadRuntimeConfig({ configPath: options.configPath });
+    const requirementText = readRequirementText(options);
+    const analysis = analyzeRequirement(requirementText, { configPath: options.configPath });
+
+    if (analysis.decision === 'not_extendable') {
+      console.log(renderMarkdown(analysis));
+      process.exit(2);
+    }
+
+    if (analysis.decision === 'need_more_info') {
+      if (!analysis.suggestedModel) {
+        console.log(renderMarkdown(analysis));
+        process.exit(3);
+      }
+
+      const fallbackSpecPath = options.writeSpec
+        ? path.resolve(options.writeSpec)
+        : buildDefaultSpecPath(analysis, runtimeConfig);
+
+      writeSuggestedSpec(analysis.suggestedModel, fallbackSpecPath);
+      const fallbackValidation = validateModelFile(fallbackSpecPath, runtimeConfig);
+
+      if (options.format === 'json') {
+        console.log(JSON.stringify({
+          decision: analysis.decision,
+          nextAction: analysis.nextAction,
+          requirement: analysis.requirement,
+          specPath: fallbackSpecPath,
+          inferred: analysis.inferred,
+          missingInfo: analysis.missingInfo || [],
+          reason: analysis.reason || [],
+          validation: {
+            valid: fallbackValidation.valid,
+            schemaErrors: fallbackValidation.schemaErrors || [],
+            boundaryErrors: fallbackValidation.boundaryErrors || [],
+            governanceErrors: fallbackValidation.governanceErrors || [],
+            warnings: fallbackValidation.warnings || [],
+            location: fallbackValidation.location || null,
+          },
+        }, null, 2));
+      } else {
+        console.log(renderFallbackMarkdown({
+          ...analysis,
+          generatedSpecPath: fallbackSpecPath,
+          validation: fallbackValidation,
+        }));
+      }
+      process.exit(0);
+    }
+
+    const specPath = options.writeSpec
+      ? path.resolve(options.writeSpec)
+      : buildDefaultSpecPath(analysis, runtimeConfig);
+
+    writeSuggestedSpec(analysis.suggestedModel, specPath);
+
+    const validation = validateModelFile(specPath, runtimeConfig);
+    if (!validation.valid) {
+      throw new PipelineError(
+        'validate',
+        'MODEL_VALIDATION_FAILED',
+        '模型校验未通过',
+        {
+          specPath,
+          validation: {
+            valid: validation.valid,
+            schemaErrors: validation.schemaErrors || [],
+            boundaryErrors: validation.boundaryErrors || [],
+            governanceErrors: validation.governanceErrors || [],
+            warnings: validation.warnings || [],
+            location: validation.location || null,
+          },
+          analysis,
+        }
+      );
+    }
+
+    const pipeline = [];
+    const generateResult = runGenerate(specPath, options.force, options.configPath, runtimeConfig);
+    pipeline.push({
+      step: 'generate',
+      status: 'passed',
+      summary: `已生成 ${generateResult.files.length} 个文件`,
+    });
+
+    if (!options.skipCodegen) {
+      const codegenResult = runPnpmCommand(['-F', '@scaffold/api', 'codegen'], 'API client codegen', runtimeConfig);
+      pipeline.push({
+        step: 'codegen',
+        status: 'passed',
+        summary: 'API client 已更新',
+        output: codegenResult.stdout,
+      });
+    }
+
+    if (!options.skipInitDb) {
+      const initDbResult = runPnpmCommand(['--dir', 'scaffold', 'init-db'], '数据库初始化', runtimeConfig);
+      pipeline.push({
+        step: 'init-db',
+        status: 'passed',
+        summary: '数据库初始化完成',
+        output: initDbResult.stdout,
+      });
+    }
+
+    let smokeResult = null;
+    if (!options.skipSmoke) {
+      smokeResult = await runSmokeCheck(analysis, options, runtimeConfig);
+      pipeline.push({
+        step: 'smoke',
+        status: 'passed',
+        summary: `接口冒烟通过: ${smokeResult.endpoint}`,
+        output: JSON.stringify(smokeResult.response, null, 2),
+      });
+    }
+
+    const summary = {
+      ...analysis,
+      generatedSpecPath: specPath,
+      generatedFiles: generateResult.files,
+      generateOutput: generateResult.stdout,
+      pipeline,
+      smokeResult,
+    };
+
+    if (options.format === 'json') {
+      console.log(JSON.stringify({
+        decision: summary.decision,
+        nextAction: 'implement',
+        requirement: summary.requirement,
+        specPath: summary.generatedSpecPath,
+        inferred: summary.inferred,
+        generatedFiles: summary.generatedFiles,
+        pipeline: summary.pipeline,
+        smoke: summary.smokeResult,
+        warnings: summary.warnings || [],
+      }, null, 2));
+    } else {
+      console.log(renderRunMarkdown(summary));
+    }
+  } catch (error) {
+    const normalized = normalizeRunError(error);
+    if (options.format === 'json') {
+      console.log(JSON.stringify(normalized, null, 2));
+    } else {
+      console.error(renderRunFailureMarkdown(normalized));
+    }
+    process.exit(normalized.exitCode);
+  }
+})();
+
+function parseRunnerArgs(argv) {
+  const parsed = parseArgs(stripRunnerFlags(argv));
+  return {
+    ...parsed,
+    configPath: readStringArg(argv, '--config'),
+    force: !argv.includes('--no-force'),
+    skipCodegen: argv.includes('--skip-codegen'),
+    skipInitDb: argv.includes('--skip-init-db'),
+    skipSmoke: argv.includes('--skip-smoke'),
+    seedSmoke: argv.includes('--seed-smoke'),
+    smokePort: readNumberArg(argv, '--smoke-port') || 3011,
+  };
+}
+
+function buildDefaultSpecPath(analysis, runtimeConfig) {
+  const domain = analysis.inferred.domain || 'custom';
+  const object = analysis.inferred.object || analysis.inferred.pattern || 'suggested-model';
+  return resolveGeneratedSpecPath(runtimeConfig, `${domain}-${object}.yaml`);
+}
+
+function runGenerate(specPath, force, configPath, runtimeConfig) {
+  const commandArgs = [path.join(resolveScaffoldPath('tools'), 'generate-module.cjs'), specPath];
+  if (force) {
+    commandArgs.push('--force');
+  }
+  if (configPath) {
+    commandArgs.push('--config', path.resolve(configPath));
+  }
+
+  const result = spawnSync(process.execPath, commandArgs, {
+    cwd: runtimeConfig.targets.toolCwd,
+    encoding: 'utf8',
+  });
+
+  if (result.status !== 0) {
+    throw new PipelineError('generate', 'MODULE_GENERATE_FAILED', result.stderr || result.stdout || '模块生成失败', {
+      specPath,
+      stdout: result.stdout || '',
+      stderr: result.stderr || '',
+    });
+  }
+
+  const files = String(result.stdout || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('- ['))
+    .map((line) => line.replace(/^- \[[^\]]+\]\s+/, ''));
+
+  return {
+    stdout: result.stdout || '',
+    files,
+  };
+}
+
+function runPnpmCommand(args, label, runtimeConfig) {
+  const result = spawnSync('pnpm', args, {
+    cwd: runtimeConfig.targets.pnpmCwd,
+    encoding: 'utf8',
+  });
+
+  if (result.status !== 0) {
+    const stage = resolvePnpmStage(args);
+    throw new PipelineError(stage, `${stage.toUpperCase()}_FAILED`, `${label}失败`, {
+      command: ['pnpm', ...args].join(' '),
+      stdout: result.stdout || '',
+      stderr: result.stderr || '',
+    });
+  }
+
+  return {
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+  };
+}
+
+async function runSmokeCheck(analysis, options, runtimeConfig) {
+  const apiDir = runtimeConfig.targets.apiPackageDir;
+  const port = options.smokePort;
+  const baseUrl = `http://127.0.0.1:${port}/api/${analysis.inferred.domain}/${analysis.inferred.object}`;
+  const endpoint = `http://127.0.0.1:${port}/api/${analysis.inferred.domain}/${analysis.inferred.object}/page?pageNo=1&pageSize=1`;
+  const env = {
+    ...process.env,
+    PORT: String(port),
+  };
+  const server = spawn(process.execPath, ['--import', '@swc-node/register/esm-register', 'src/server.ts'], {
+    cwd: apiDir,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  const logs = [];
+  const collectLogs = (chunk) => {
+    if (chunk) {
+      logs.push(String(chunk));
+    }
+  };
+
+  server.stdout.on('data', collectLogs);
+  server.stderr.on('data', collectLogs);
+
+  try {
+    await waitForServer(endpoint, server, logs);
+    let seededRecord = null;
+    if (options.seedSmoke) {
+      seededRecord = await createSmokeSeed(baseUrl, analysis);
+    }
+    const response = await fetchJson(endpoint);
+    return { port, endpoint, response, seededRecord };
+  } finally {
+    server.kill('SIGTERM');
+    await waitForExit(server, 2000);
+  }
+}
+
+function readStringArg(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) {
+    return '';
+  }
+  return argv[index + 1] || '';
+}
+
+async function waitForServer(endpoint, server, logs) {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    if (server.exitCode !== null) {
+      throw new PipelineError('smoke', 'SMOKE_SERVER_START_FAILED', '冒烟服务启动失败', {
+        endpoint,
+        logs: logs.join(''),
+      });
+    }
+
+    try {
+      await fetchJson(endpoint);
+      return;
+    } catch (error) {
+      await sleep(300);
+    }
+  }
+
+  throw new PipelineError('smoke', 'SMOKE_TIMEOUT', '冒烟启动超时', {
+    endpoint,
+    logs: logs.join(''),
+  });
+}
+
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${url}`);
+  }
+  return response.json();
+}
+
+async function postJson(url, body) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`HTTP ${response.status} ${url}\n${text}`.trim());
+  }
+
+  return response.json();
+}
+
+function waitForExit(child, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (!settled) {
+        settled = true;
+        resolve();
+      }
+    };
+    child.once('exit', finish);
+    setTimeout(finish, timeoutMs);
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readNumberArg(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index < 0) {
+    return 0;
+  }
+  const next = argv[index + 1];
+  return next ? Number(next) : 0;
+}
+
+function renderRunMarkdown(result) {
+  const lines = [];
+  lines.push(`需求: ${result.requirement}`);
+  lines.push('');
+  lines.push('decision: extendable');
+  lines.push('nextAction: implement');
+  lines.push('');
+  lines.push('识别结果:');
+  lines.push(`- domain: ${result.inferred.domain}`);
+  lines.push(`- object: ${result.inferred.object}`);
+  lines.push(`- label: ${result.inferred.label}`);
+  lines.push(`- actions: ${(result.inferred.actions || []).join(', ') || '-'}`);
+  lines.push('');
+  lines.push('结果:');
+  lines.push(`- specPath: ${result.generatedSpecPath}`);
+  lines.push(`- generatedFiles: ${result.generatedFiles.length}`);
+  for (const file of result.generatedFiles) {
+    lines.push(`- ${file}`);
+  }
+
+  if (result.pipeline && result.pipeline.length > 0) {
+    lines.push('');
+    lines.push('流水线:');
+    for (const item of result.pipeline) {
+      lines.push(`- ${item.step}: ${item.status} (${item.summary})`);
+    }
+  }
+
+  if (result.smokeResult) {
+    const smokeSummary = summarizeSmokeResponse(result.smokeResult.response);
+    lines.push('');
+    lines.push('冒烟结果:');
+    lines.push(`- endpoint: ${result.smokeResult.endpoint}`);
+    if (result.smokeResult.seededRecord) {
+      lines.push(`- seeded: yes`);
+    }
+    lines.push(`- records: ${smokeSummary.records}`);
+    lines.push(`- total: ${smokeSummary.total}`);
+  }
+
+  if (result.warnings && result.warnings.length > 0) {
+    lines.push('');
+    lines.push('提示:');
+    for (const item of result.warnings) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function renderFallbackMarkdown(result) {
+  const lines = [];
+  lines.push(`需求: ${result.requirement}`);
+  lines.push('');
+  lines.push(`decision: ${result.decision}`);
+  lines.push(`nextAction: ${result.nextAction}`);
+  lines.push('');
+  lines.push('识别结果:');
+  lines.push(`- domain: ${result.inferred?.domain || '-'}`);
+  lines.push(`- object: ${result.inferred?.object || '-'}`);
+  lines.push(`- label: ${result.inferred?.label || '-'}`);
+  lines.push(`- pattern: ${result.inferred?.pattern || '-'}`);
+  lines.push(`- actions: ${(result.inferred?.actions || []).join(', ') || '-'}`);
+  lines.push('');
+  lines.push('结果:');
+  lines.push(`- specPath: ${result.generatedSpecPath}`);
+  lines.push(`- validation: ${result.validation?.valid ? 'passed' : 'failed'}`);
+  if (result.validation?.location) {
+    lines.push(`- scope: ${result.validation.location.scope}`);
+  }
+
+  if (result.reason && result.reason.length > 0) {
+    lines.push('');
+    lines.push('原因:');
+    for (const item of result.reason) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  if (result.missingInfo && result.missingInfo.length > 0) {
+    lines.push('');
+    lines.push('缺失信息:');
+    for (const item of result.missingInfo) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  const schemaErrors = result.validation?.schemaErrors || [];
+  const boundaryErrors = result.validation?.boundaryErrors || [];
+  const governanceErrors = result.validation?.governanceErrors || [];
+  if (schemaErrors.length > 0 || boundaryErrors.length > 0 || governanceErrors.length > 0) {
+    lines.push('');
+    lines.push('校验问题:');
+    for (const item of [...schemaErrors, ...boundaryErrors, ...governanceErrors]) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  const warnings = [
+    ...((result.warnings || [])),
+    ...((result.validation?.warnings || [])),
+  ];
+  if (warnings.length > 0) {
+    lines.push('');
+    lines.push('提示:');
+    for (const item of warnings) {
+      lines.push(`- ${item}`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function stripRunnerFlags(argv) {
+  const result = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index];
+    if (['--no-force', '--skip-codegen', '--skip-init-db', '--skip-smoke', '--seed-smoke'].includes(item)) {
+      continue;
+    }
+    if (item === '--smoke-port' || item === '--config') {
+      index += 1;
+      continue;
+    }
+    result.push(item);
+  }
+  return result;
+}
+
+function summarizeSmokeResponse(response) {
+  const payload = response && typeof response === 'object' && response.data && typeof response.data === 'object'
+    ? response.data
+    : response;
+
+  return {
+    records: Array.isArray(payload?.records) ? payload.records.length : '-',
+    total: payload?.total ?? '-',
+  };
+}
+
+function resolvePnpmStage(args) {
+  const joined = args.join(' ');
+  if (joined.includes('codegen')) {
+    return 'codegen';
+  }
+  if (joined.includes('init-db')) {
+    return 'init-db';
+  }
+  return 'pipeline';
+}
+
+function normalizeRunError(error) {
+  if (error instanceof PipelineError) {
+    return {
+      contractVersion: '1.0.0',
+      stage: 'run',
+      status: 'failed',
+      errorStage: error.stage,
+      code: error.code,
+      message: error.message,
+      details: error.details || {},
+      exitCode: error.exitCode ?? 1,
+    };
+  }
+
+  return {
+    contractVersion: '1.0.0',
+    stage: 'run',
+    status: 'failed',
+    errorStage: 'unknown',
+    code: 'UNEXPECTED_ERROR',
+    message: error?.message || '一键执行失败',
+    details: {},
+    exitCode: 1,
+  };
+}
+
+function renderRunFailureMarkdown(error) {
+  const lines = [];
+  lines.push(`❌ 一键执行失败: ${error.message}`);
+  lines.push('');
+  lines.push(`- stage: ${error.errorStage}`);
+  lines.push(`- code: ${error.code}`);
+  if (error.details?.specPath) {
+    lines.push(`- specPath: ${error.details.specPath}`);
+  }
+  const validation = error.details?.validation;
+  if (validation) {
+    const issues = [
+      ...(validation.schemaErrors || []),
+      ...(validation.boundaryErrors || []),
+      ...(validation.governanceErrors || []),
+    ];
+    if (issues.length > 0) {
+      lines.push('');
+      lines.push('校验问题:');
+      for (const item of issues) {
+        lines.push(`- ${item}`);
+      }
+    }
+  }
+  if (error.details?.command) {
+    lines.push(`- command: ${error.details.command}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+async function createSmokeSeed(baseUrl, analysis) {
+  const payload = buildSeedPayload(analysis);
+  const response = await postJson(baseUrl, payload);
+  return {
+    request: payload,
+    response,
+  };
+}
+
+function buildSeedPayload(analysis) {
+  const model = analysis.suggestedModel || {};
+  const fields = Array.isArray(model?.data?.fields) ? model.data.fields : [];
+  const children = Array.isArray(model?.data?.children) ? model.data.children : [];
+  const timestamp = formatSeedTimestamp(new Date());
+  const payload = {};
+
+  for (const field of fields) {
+    payload[field.name] = buildSeedValue(field, analysis, timestamp);
+  }
+
+  for (const child of children) {
+    payload[child.name] = [buildSeedChildRow(child, analysis, timestamp)];
+  }
+
+  return payload;
+}
+
+function buildSeedChildRow(child, analysis, timestamp) {
+  const row = {};
+  for (const field of child.fields || []) {
+    row[field.name] = buildSeedValue(field, analysis, timestamp, child.label || child.name);
+  }
+  return row;
+}
+
+function buildSeedValue(field, analysis, timestamp, parentLabel) {
+  const name = String(field.name || '');
+  const label = String(field.label || parentLabel || analysis?.inferred?.label || '对象');
+  const type = String(field.type || 'string');
+
+  if (type === 'enum') {
+    if (field.default !== undefined) {
+      return String(field.default);
+    }
+    return Array.isArray(field.options) && field.options.length > 0 ? String(field.options[0]) : '';
+  }
+
+  if (type === 'boolean') {
+    return field.default !== undefined ? Boolean(field.default) : false;
+  }
+
+  if (['integer', 'number', 'decimal'].includes(type)) {
+    return field.default !== undefined ? Number(field.default) : 1;
+  }
+
+  if (name.toLowerCase().includes('code')) {
+    return `${String(analysis.inferred.object || 'OBJ').toUpperCase()}-${timestamp}`;
+  }
+
+  if (name.toLowerCase().endsWith('name')) {
+    return `${label}示例${timestamp.slice(-4)}`;
+  }
+
+  if (name.toLowerCase().includes('phone') || name.toLowerCase().includes('mobile')) {
+    return `1380000${timestamp.slice(-4)}`;
+  }
+
+  if (name.toLowerCase().includes('email')) {
+    return `seed-${timestamp}@example.com`;
+  }
+
+  if (name.toLowerCase().includes('owner')) {
+    return '系统验证';
+  }
+
+  return field.required ? `${label}示例` : `${label}补充`;
+}
+
+function formatSeedTimestamp(date) {
+  const parts = [
+    date.getFullYear(),
+    padSeedPart(date.getMonth() + 1),
+    padSeedPart(date.getDate()),
+    padSeedPart(date.getHours()),
+    padSeedPart(date.getMinutes()),
+    padSeedPart(date.getSeconds()),
+  ];
+  return parts.join('');
+}
+
+function padSeedPart(value) {
+  return String(value).padStart(2, '0');
+}

package/tools/validate-draft.cjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+const { loadDraft, saveDraft, validateDraft } = require('./lib/draft-toolkit.cjs');
+const { loadRuntimeConfig } = require('./lib/model-toolkit.cjs');
+
+const args = process.argv.slice(2);
+const draftReference = args.find((item) => !item.startsWith('--'));
+const configPath = readArgValue(args, '--config');
+
+try {
+  const runtimeConfig = loadRuntimeConfig({ configPath });
+  if (!draftReference) {
+    throw new Error('请提供 draft 引用，例如: node ./tools/validate-draft.cjs <draft-path|draft-id>');
+  }
+  const draft = loadDraft(draftReference, { draftRoot: runtimeConfig.drafts.rootDir });
+  const nextDraft = validateDraft(draft, { configPath });
+  const savedDraft = saveDraft(nextDraft, {
+    draftRoot: draft.storage?.draftRoot || runtimeConfig.drafts.rootDir,
+    fileName: draft.storage?.fileName,
+  });
+  console.log(JSON.stringify(savedDraft, null, 2));
+} catch (error) {
+  console.error(`\n❌ Draft 校验失败: ${error.message}`);
+  process.exit(1);
+}
+
+function readArgValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) {
+    return '';
+  }
+  return argv[index + 1] || '';
+}