大海
395 lines
17 KiB
JavaScript
395 lines
17 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
/**
|
|
* Release Benchmark — SF-07
|
|
*
|
|
* 验证完整链路：Frontend → Backend → Fullstack → Electron → Release
|
|
* 对 PetCare / CRM / Inventory 三个领域执行，输出 release-benchmark-report.md
|
|
*/
|
|
|
|
import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
|
|
import { resolve, dirname, join } from "node:path";
|
|
import { execSync } from "node:child_process";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const __dirname = dirname(resolve(fileURLToPath(import.meta.url)));
|
|
const WORKSPACE = resolve(__dirname, "..");
|
|
const BENCH_ROOT = resolve(WORKSPACE, ".benchmark");
|
|
const SCRIPTS = resolve(WORKSPACE, "scripts");
|
|
const REPORT_PATH = resolve(WORKSPACE, "release-benchmark-report.md");
|
|
|
|
const DOMAINS = [
|
|
{ id: "petcare", input: "做一个宠物护理管理平台，宠物主人可以管理宠物档案、健康日程、日常记录和成长相册" },
|
|
{ id: "crm", input: "做一个客户关系管理系统，支持客户管理、销售漏斗、跟进记录和数据分析仪表盘" },
|
|
{ id: "inventory", input: "做一个库存管理系统，支持商品入库出库、库存盘点、供应商管理和库存预警" },
|
|
];
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// Helpers
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
function cmd(c, opts = {}) {
|
|
try {
|
|
return execSync(c, { cwd: WORKSPACE, encoding: "utf8", ...opts, stdio: opts.stdio ?? "pipe" });
|
|
} catch (e) {
|
|
return { error: e.message, stderr: e.stderr?.toString() || "", stdout: e.stdout?.toString() || "" };
|
|
}
|
|
}
|
|
|
|
function runAgent(agentPath, args) {
|
|
const result = cmd(`node ${agentPath} ${args}`);
|
|
if (result.error) {
|
|
try { return JSON.parse(result.stdout?.trim() || "{}"); } catch { return { error: result.error, stderr: result.stderr }; }
|
|
}
|
|
try { return JSON.parse(result.trim()); } catch { return { raw: result }; }
|
|
}
|
|
|
|
function countFiles(dir) {
|
|
try {
|
|
const r = execSync(`find ${dir} -type f 2>/dev/null | wc -l`, { encoding: "utf8", cwd: WORKSPACE });
|
|
return parseInt(r.trim(), 10);
|
|
} catch { return 0; }
|
|
}
|
|
|
|
function loadJSON(path) {
|
|
try { return JSON.parse(readFileSync(path, "utf8")); } catch { return {}; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// Step 1-4: Full Pipeline (reuse existing agents)
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
function generateRequirementPackage(domain) {
|
|
console.log(`\n📋 [${domain.id}] Generating RequirementPackage...`);
|
|
const t0 = Date.now();
|
|
|
|
const prdOut = join(BENCH_ROOT, domain.id, "prd.json");
|
|
const archOut = join(BENCH_ROOT, domain.id, "arch.json");
|
|
mkdirSync(dirname(prdOut), { recursive: true });
|
|
|
|
runAgent(join(SCRIPTS, "project-intake-agent.mjs"), `--input "${domain.input}" --output "${prdOut}"`);
|
|
runAgent(join(SCRIPTS, "architecture-agent.mjs"), `--input "${prdOut}" --output "${archOut}"`);
|
|
|
|
const prd = loadJSON(prdOut);
|
|
const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
|
|
console.log(` ✅ PRD + Architecture (${elapsed}s) — ${prd.projectName || "?"}`);
|
|
return { prd, prdPath: prdOut, archPath: archOut, elapsed: parseFloat(elapsed) };
|
|
}
|
|
|
|
function generateFrontend(domain, prdPath, archPath) {
|
|
console.log(` 🎨 Generating Frontend...`);
|
|
const t0 = Date.now();
|
|
const outDir = join(BENCH_ROOT, domain.id, "frontend");
|
|
runAgent(join(SCRIPTS, "frontend-builder-agent.mjs"), `--prd "${prdPath}" --arch "${archPath}" --output "${outDir}"`);
|
|
const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
|
|
const fc = countFiles(outDir);
|
|
console.log(` ✅ Frontend (${elapsed}s, ${fc} files)`);
|
|
return { elapsed: parseFloat(elapsed), fileCount: fc };
|
|
}
|
|
|
|
function generateBackend(domain, prdPath, archPath) {
|
|
console.log(` ⚙️ Generating Backend...`);
|
|
const t0 = Date.now();
|
|
const outDir = join(BENCH_ROOT, domain.id, "backend");
|
|
runAgent(join(SCRIPTS, "backend-builder-agent.mjs"), `--prd "${prdPath}" --arch "${archPath}" --output "${outDir}"`);
|
|
const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
|
|
const fc = countFiles(outDir);
|
|
console.log(` ✅ Backend (${elapsed}s, ${fc} files)`);
|
|
return { elapsed: parseFloat(elapsed), fileCount: fc };
|
|
}
|
|
|
|
function generateFullstack(domain, prdPath, archPath) {
|
|
console.log(` 🔗 Composing Fullstack...`);
|
|
const t0 = Date.now();
|
|
const outDir = join(BENCH_ROOT, domain.id, "fullstack");
|
|
runAgent(join(SCRIPTS, "fullstack-composer-agent.mjs"), `--prd "${prdPath}" --arch "${archPath}" --output "${outDir}"`);
|
|
const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
|
|
const fc = countFiles(outDir);
|
|
console.log(` ✅ Fullstack (${elapsed}s, ${fc} files)`);
|
|
return { elapsed: parseFloat(elapsed), fileCount: fc };
|
|
}
|
|
|
|
function generateElectron(domain, prdPath) {
|
|
console.log(` 🖥️ Generating Electron...`);
|
|
const t0 = Date.now();
|
|
const fullstackDir = join(BENCH_ROOT, domain.id, "fullstack");
|
|
const outDir = join(BENCH_ROOT, domain.id, "electron");
|
|
runAgent(join(SCRIPTS, "electron-builder-agent.mjs"), `--input "${fullstackDir}" --output "${outDir}" --prd "${prdPath}"`);
|
|
const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
|
|
const fc = countFiles(outDir);
|
|
console.log(` ✅ Electron (${elapsed}s, ${fc} files)`);
|
|
return { elapsed: parseFloat(elapsed), fileCount: fc };
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// Step 5: Release Builder
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
function generateRelease(domain) {
|
|
console.log(` 📦 Generating Release...`);
|
|
const t0 = Date.now();
|
|
const fullstackDir = join(BENCH_ROOT, domain.id, "fullstack");
|
|
const outDir = join(BENCH_ROOT, domain.id, "release");
|
|
|
|
const result = runAgent(join(SCRIPTS, "release-builder-agent.mjs"), `--input "${fullstackDir}" --output "${outDir}"`);
|
|
const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
|
|
const fc = countFiles(outDir);
|
|
console.log(` ✅ Release (${elapsed}s, ${fc} files)`);
|
|
return { elapsed: parseFloat(elapsed), fileCount: fc, result };
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// Validation
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
function validateRelease(domain) {
|
|
const releaseDir = join(BENCH_ROOT, domain.id, "release");
|
|
const checks = {
|
|
hasVersionJson: existsSync(join(releaseDir, "release", "version.json")),
|
|
hasManifestJson: existsSync(join(releaseDir, "release", "manifests", "manifest.json")),
|
|
hasChecksums: existsSync(join(releaseDir, "release", "checksums", "checksums.txt")),
|
|
hasReleaseNotes: existsSync(join(releaseDir, "release", "release-notes", "release-notes.md")),
|
|
hasBuildInfo: existsSync(join(releaseDir, "release", "build-info.json")),
|
|
hasReadme: existsSync(join(releaseDir, "release", "README.md")),
|
|
hasWindowsDir: existsSync(join(releaseDir, "release", "windows")),
|
|
hasMacosDir: existsSync(join(releaseDir, "release", "macos")),
|
|
hasLinuxDir: existsSync(join(releaseDir, "release", "linux")),
|
|
};
|
|
|
|
// Validate version.json
|
|
if (checks.hasVersionJson) {
|
|
try {
|
|
const v = JSON.parse(readFileSync(join(releaseDir, "release", "version.json"), "utf8"));
|
|
checks.versionValid = !!(v.name && v.version && v.platforms);
|
|
} catch { checks.versionValid = false; }
|
|
}
|
|
|
|
// Validate manifest
|
|
if (checks.hasManifestJson) {
|
|
try {
|
|
const m = JSON.parse(readFileSync(join(releaseDir, "release", "manifests", "manifest.json"), "utf8"));
|
|
checks.manifestValid = !!(m.project && m.version && m.files && m.files.length > 0);
|
|
checks.manifestFileCount = m.files?.length || 0;
|
|
} catch { checks.manifestValid = false; }
|
|
}
|
|
|
|
// Validate checksums
|
|
if (checks.hasChecksums) {
|
|
const content = readFileSync(join(releaseDir, "release", "checksums", "checksums.txt"), "utf8");
|
|
const lines = content.trim().split("\n").filter(l => l.length > 0);
|
|
checks.checksumCount = lines.length;
|
|
checks.checksumsValid = lines.every(l => {
|
|
const parts = l.split(/\s+/);
|
|
return parts[0]?.length === 64 && parts[1]?.length > 0;
|
|
});
|
|
}
|
|
|
|
// Validate release notes
|
|
if (checks.hasReleaseNotes) {
|
|
const notes = readFileSync(join(releaseDir, "release", "release-notes", "release-notes.md"), "utf8");
|
|
checks.releaseNotesValid = notes.includes("Version") && notes.includes("Features") && notes.includes("Installation");
|
|
}
|
|
|
|
// Validate build-info
|
|
if (checks.hasBuildInfo) {
|
|
try {
|
|
const bi = JSON.parse(readFileSync(join(releaseDir, "release", "build-info.json"), "utf8"));
|
|
checks.buildInfoValid = !!(bi.nodeVersion && bi.generatorVersion && bi.buildTime);
|
|
} catch { checks.buildInfoValid = false; }
|
|
}
|
|
|
|
// Platform placeholder counts
|
|
if (checks.hasWindowsDir) {
|
|
try { checks.windowsFileCount = readdirSync(join(releaseDir, "release", "windows")).length; } catch { checks.windowsFileCount = 0; }
|
|
}
|
|
if (checks.hasMacosDir) {
|
|
try { checks.macosFileCount = readdirSync(join(releaseDir, "release", "macos")).length; } catch { checks.macosFileCount = 0; }
|
|
}
|
|
if (checks.hasLinuxDir) {
|
|
try { checks.linuxFileCount = readdirSync(join(releaseDir, "release", "linux")).length; } catch { checks.linuxFileCount = 0; }
|
|
}
|
|
|
|
checks.allPassed = checks.hasVersionJson && checks.hasManifestJson && checks.hasChecksums &&
|
|
checks.hasReleaseNotes && checks.hasBuildInfo && checks.hasWindowsDir &&
|
|
checks.hasMacosDir && checks.hasLinuxDir && checks.versionValid &&
|
|
checks.manifestValid && checks.checksumsValid && checks.releaseNotesValid && checks.buildInfoValid;
|
|
|
|
return checks;
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// Report
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
function generateReport(allResults) {
|
|
const lines = [];
|
|
const h = (t) => { lines.push(t); return lines; };
|
|
|
|
h(`# Release Benchmark Report — SF-07`);
|
|
h(``);
|
|
h(`> Generated: ${new Date().toISOString()}`);
|
|
h(`> Pipeline: Frontend → Backend → Fullstack → Electron → Release`);
|
|
h(``);
|
|
|
|
// ── Domain Results ──
|
|
h(`## Domain Results`);
|
|
h(``);
|
|
h(`| Domain | Release | Manifest | Notes | Result |`);
|
|
h(`|--------|---------|----------|-------|--------|`);
|
|
|
|
for (const r of allResults) {
|
|
const rel = r.releaseChecks?.allPassed ? "✅" : "❌";
|
|
const man = r.releaseChecks?.manifestValid ? "✅" : "❌";
|
|
const notes = r.releaseChecks?.releaseNotesValid ? "✅" : "❌";
|
|
const result = r.releaseChecks?.allPassed ? "PASS" : "FAIL";
|
|
h(`| ${r.id} | ${rel} | ${man} | ${notes} | **${result}** |`);
|
|
}
|
|
h(``);
|
|
|
|
// ── Release Artifacts ──
|
|
h(`## Release Artifacts`);
|
|
h(``);
|
|
h(`| Domain | Files | Manifest Files | Checksum Lines | Release Notes |`);
|
|
h(`|--------|-------|----------------|----------------|---------------|`);
|
|
|
|
for (const r of allResults) {
|
|
const rc = r.releaseChecks || {};
|
|
h(`| ${r.id} | ${r.release?.fileCount || 0} | ${rc.manifestFileCount || 0} | ${rc.checksumCount || 0} | ${rc.hasReleaseNotes ? "✅" : "❌"} |`);
|
|
}
|
|
h(``);
|
|
|
|
// ── Pipeline Timing ──
|
|
h(`## Pipeline Timing`);
|
|
h(``);
|
|
h(`| Domain | Frontend | Backend | Fullstack | Electron | Release | Total |`);
|
|
h(`|--------|----------|---------|-----------|----------|---------|-------|`);
|
|
|
|
for (const r of allResults) {
|
|
h(`| ${r.id} | ${r.frontend?.elapsed || 0}s | ${r.backend?.elapsed || 0}s | ${r.fullstack?.elapsed || 0}s | ${r.electron?.elapsed || 0}s | ${r.release?.elapsed || 0}s | ${r.totalTime || 0}s |`);
|
|
}
|
|
h(``);
|
|
|
|
// ── Validation Details ──
|
|
h(`## Validation Details`);
|
|
h(``);
|
|
|
|
for (const r of allResults) {
|
|
h(`### ${r.id}`);
|
|
h(``);
|
|
const rc = r.releaseChecks || {};
|
|
h(`| Check | Status |`);
|
|
h(`|-------|--------|`);
|
|
h(`| version.json | ${rc.hasVersionJson ? "✅" : "❌"} |`);
|
|
h(`| version.json valid | ${rc.versionValid ? "✅" : "❌"} |`);
|
|
h(`| manifest.json | ${rc.hasManifestJson ? "✅" : "❌"} |`);
|
|
h(`| manifest valid | ${rc.manifestValid ? "✅" : "❌"} |`);
|
|
h(`| checksums.txt | ${rc.hasChecksums ? "✅" : "❌"} |`);
|
|
h(`| checksums valid | ${rc.checksumsValid ? "✅" : "❌"} |`);
|
|
h(`| release-notes.md | ${rc.hasReleaseNotes ? "✅" : "❌"} |`);
|
|
h(`| release notes valid | ${rc.releaseNotesValid ? "✅" : "❌"} |`);
|
|
h(`| build-info.json | ${rc.hasBuildInfo ? "✅" : "❌"} |`);
|
|
h(`| build-info valid | ${rc.buildInfoValid ? "✅" : "❌"} |`);
|
|
h(`| windows/ | ${rc.hasWindowsDir ? "✅" : "❌"} (${rc.windowsFileCount || 0} files) |`);
|
|
h(`| macos/ | ${rc.hasMacosDir ? "✅" : "❌"} (${rc.macosFileCount || 0} files) |`);
|
|
h(`| linux/ | ${rc.hasLinuxDir ? "✅" : "❌"} (${rc.linuxFileCount || 0} files) |`);
|
|
h(``);
|
|
}
|
|
|
|
// ── Final Status ──
|
|
h(`## Final Status`);
|
|
h(``);
|
|
|
|
const passCount = allResults.filter(r => r.releaseChecks?.allPassed).length;
|
|
const total = allResults.length;
|
|
|
|
h(`| Metric | Value |`);
|
|
h(`|--------|-------|`);
|
|
h(`| Domains Tested | ${total} |`);
|
|
h(`| Release PASS | ${passCount}/${total} |`);
|
|
h(`| Release FAIL | ${total - passCount}/${total} |`);
|
|
h(``);
|
|
|
|
if (passCount === total) {
|
|
h(`🎉 **Release Builder Agent — PASS** (${passCount}/${total})`);
|
|
h(``);
|
|
h(`All domains successfully generated complete release packages.`);
|
|
} else {
|
|
h(`⚠️ **Release Builder Agent — FAIL** (${passCount}/${total})`);
|
|
h(``);
|
|
const failed = allResults.filter(r => !r.releaseChecks?.allPassed);
|
|
h(`Failed domains: ${failed.map(r => r.id).join(", ")}`);
|
|
}
|
|
h(``);
|
|
|
|
h(`---`);
|
|
h(`*Report generated by Release Benchmark — SF-07*`);
|
|
|
|
return lines.join("\n");
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// Main
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
async function main() {
|
|
console.log(`\n🧪 Release Benchmark — SF-07`);
|
|
console.log(` Testing ${DOMAINS.length} domains`);
|
|
console.log(` Pipeline: Frontend → Backend → Fullstack → Electron → Release\n`);
|
|
|
|
const allResults = [];
|
|
|
|
for (const domain of DOMAINS) {
|
|
console.log(`\n${"=".repeat(60)}`);
|
|
console.log(`🏗️ Domain: ${domain.id}`);
|
|
console.log(`${"=".repeat(60)}`);
|
|
|
|
const tTotal = Date.now();
|
|
|
|
// Steps 1-4: Generate full pipeline
|
|
const { prd, prdPath, archPath, elapsed: reqTime } = generateRequirementPackage(domain);
|
|
const frontend = generateFrontend(domain, prdPath, archPath);
|
|
const backend = generateBackend(domain, prdPath, archPath);
|
|
const fullstack = generateFullstack(domain, prdPath, archPath);
|
|
const electron = generateElectron(domain, prdPath);
|
|
|
|
// Step 5: Release
|
|
const release = generateRelease(domain);
|
|
|
|
// Validate
|
|
const releaseChecks = validateRelease(domain);
|
|
|
|
const totalTime = ((Date.now() - tTotal) / 1000).toFixed(1);
|
|
|
|
allResults.push({
|
|
id: domain.id,
|
|
input: domain.input,
|
|
projectName: prd.projectName,
|
|
reqTime,
|
|
frontend,
|
|
backend,
|
|
fullstack,
|
|
electron,
|
|
release,
|
|
releaseChecks,
|
|
totalTime: parseFloat(totalTime),
|
|
});
|
|
|
|
console.log(` ⏱️ Total: ${totalTime}s | Release: ${releaseChecks.allPassed ? "✅ PASS" : "❌ FAIL"}`);
|
|
}
|
|
|
|
// Generate report
|
|
const report = generateReport(allResults);
|
|
writeFileSync(REPORT_PATH, report, "utf8");
|
|
console.log(`\n📄 Report written to: ${REPORT_PATH}`);
|
|
|
|
// Summary
|
|
const passCount = allResults.filter(r => r.releaseChecks?.allPassed).length;
|
|
console.log(`\n📊 Summary: ${passCount}/${DOMAINS.length} domains PASS`);
|
|
console.log(` Release Builder: ${passCount === DOMAINS.length ? "✅ PASS" : "❌ FAIL"}`);
|
|
}
|
|
|
|
main().catch(e => {
|
|
console.error("Benchmark failed:", e);
|
|
process.exit(1);
|
|
});
|