wehub-resource-sync
526 lines
22 KiB
JavaScript
526 lines
22 KiB
JavaScript
/**
|
||
* --------------------------------------------------------------------
|
||
* docmd : the zero-config documentation generator.
|
||
*
|
||
* @package @docmd/core (and ecosystem)
|
||
* @website https://docmd.io
|
||
* @repository https://github.com/docmd-io/docmd
|
||
* @license MIT
|
||
* @copyright (c) 2025-present docmd.io
|
||
*
|
||
* [docmd-source] - Please do not remove this header.
|
||
* --------------------------------------------------------------------
|
||
*
|
||
* Release preparation pipeline. Runs the full dev suite in five
|
||
* clear category sections:
|
||
*
|
||
* 1. Setup - stop running servers, wipe global binaries,
|
||
* clean the monorepo
|
||
* 2. Lint - eslint over the entire repo, summarised
|
||
* 3. Build - pnpm install + pnpm -r run build, so the
|
||
* test sections have dist files to run
|
||
* against (clean wipes dist, this rebuilds it)
|
||
* 4. Docker - optional Docker availability check
|
||
* 5. Tests - categorised test suite (tests/runner.js,
|
||
* 365+ assertions covering Phase 1 security
|
||
* CVEs + Phase 2 container parser + Phase 3
|
||
* CLI contracts + OKF/LLMS plugin tests +
|
||
* Mega Integration Test for workspaces,
|
||
* i18n, versioning, and plugin combinations)
|
||
* followed by per-package unit tests
|
||
* (parser, utils, mermaid, okf) via
|
||
* `pnpm -r run test --if-present` so a local
|
||
* regression fails the release pipeline
|
||
* 6. Link - optional global npm link
|
||
*
|
||
* Each step inside a section shows [WAIT] (dim) when it starts
|
||
* and [DONE] (green) when it finishes. No emojis.
|
||
*
|
||
* Default output is intentionally minimal: every step collapses to
|
||
* one line, and every count (passed tests, lint errors, package
|
||
* totals, Docker version, ...) accumulates into a single trailing
|
||
* Summary block at the end of the pipeline. A fully-green run prints
|
||
* a green `┌─ Summary` listing each section with its stat; a run
|
||
* with any failure replaces that block with a red `┌─ Issues` listing
|
||
* every failure with file:line detail.
|
||
*
|
||
* Pass --verbose (or --full) to stream the full test output as the
|
||
* suite runs — useful when actively iterating on a test that just
|
||
* started failing and you want to see the assertion text inline.
|
||
*
|
||
* Run: pnpm prep
|
||
* pnpm prep --link (skip tests, install globally)
|
||
* pnpm prep --skip-tests (skip both test suites)
|
||
* pnpm prep --only=exit-codes (run a single test section)
|
||
* pnpm prep --verbose (stream full test output inline)
|
||
* pnpm prep --full (alias for --verbose)
|
||
* --------------------------------------------------------------------
|
||
*/
|
||
|
||
const { execSync } = require('child_process');
|
||
const fs = require('fs');
|
||
|
||
const args = process.argv.slice(2);
|
||
|
||
// --verbose / --full streams every step's raw output as it runs.
|
||
// Default mode keeps the pipeline minimal: each step collapses to
|
||
// one line and a final Issues section appears only if something failed.
|
||
const verbose = args.includes('--verbose') || args.includes('--full');
|
||
|
||
// Issue accumulator — populated by every section so a single trailing
|
||
// "Issues" block can show the operator everything that needs fixing.
|
||
const issues = [];
|
||
function addIssue(severity, section, message, details = []) {
|
||
issues.push({ severity, section, message, details });
|
||
}
|
||
|
||
// Stat accumulator — every section contributes a one-line entry that
|
||
// prints in the trailing Summary block. Lets the per-step line stay
|
||
// minimal ("[ DONE ] 28s") while still surfacing the actual numbers
|
||
// (passed counts, lint counts, etc.) at the end.
|
||
const stats = [];
|
||
function addStat(label, value, severity = 'ok') {
|
||
stats.push({ label, value, severity });
|
||
}
|
||
|
||
// ── TUI design tokens (no emojis, only [WAIT] / [DONE] / [ FAIL ]) ──
|
||
const C = {
|
||
reset: '\x1b[0m',
|
||
bold: '\x1b[1m',
|
||
dim: '\x1b[2m',
|
||
blue: '\x1b[34m',
|
||
cyan: '\x1b[36m',
|
||
green: '\x1b[32m',
|
||
yellow: '\x1b[33m',
|
||
red: '\x1b[31m'
|
||
};
|
||
|
||
// ── TUI primitives ────────────────────────────────────────────────────
|
||
// section() and footer() pair up to produce exactly one blank line
|
||
// between groups: footer ends with \n, section starts without \n.
|
||
function section(label, color) {
|
||
console.log(`${color}${C.bold}┌─ ${label}${C.reset}`);
|
||
}
|
||
|
||
function footer(color) {
|
||
console.log(`${color}└${'─'.repeat(50)}${C.reset}`);
|
||
}
|
||
|
||
function startStep(label) {
|
||
// Print the [WAIT] sign and return a handle to update on completion.
|
||
const bar = `${C.cyan}│${C.reset}`;
|
||
const text = `${C.dim}${label}${C.reset}`;
|
||
process.stdout.write(`${bar} ${text.padEnd(52)}${C.dim}[ WAIT ]${C.reset}\n`);
|
||
return { label, startMs: Date.now(), bar, text };
|
||
}
|
||
|
||
function finishStep(s, status, summary) {
|
||
// Rewrite the same line with [DONE] / [ WARN ] / [ FAIL ] + elapsed time.
|
||
// Default status is 'done' — the common case.
|
||
const effectiveStatus = status || 'done';
|
||
const ms = Date.now() - s.startMs;
|
||
const t = ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
|
||
const tag = effectiveStatus === 'done'
|
||
? `${C.green}[ DONE ]${C.reset}`
|
||
: effectiveStatus === 'warn'
|
||
? `${C.yellow}[ WARN ]${C.reset}`
|
||
: `${C.red}[ FAIL ]${C.reset}`;
|
||
const sumTxt = summary ? ` ${C.dim}${summary}${C.reset}` : '';
|
||
// Move cursor up 1 line, clear it, rewrite.
|
||
process.stdout.write('\x1b[1A\x1b[2K');
|
||
process.stdout.write(
|
||
`${s.bar} ${s.text.padEnd(52)}${tag} ${C.dim}${t}${C.reset}${sumTxt}\n`
|
||
);
|
||
}
|
||
|
||
function run(cmd, opts = {}) {
|
||
// opts.silent — when true (default), suppress output unless cmd failed.
|
||
// opts.capture — return stdout/stderr as strings; never stream to the TUI.
|
||
// Used by collapsed-mode test steps so we can parse a
|
||
// summary line instead of dumping hundreds of test logs.
|
||
// The function never calls process.exit; callers inspect `result.ok`.
|
||
const silent = opts.silent !== false;
|
||
const capture = opts.capture === true;
|
||
try {
|
||
const out = execSync(cmd, {
|
||
stdio: capture
|
||
? ['ignore', 'pipe', 'pipe']
|
||
: (silent ? 'ignore' : 'inherit'),
|
||
maxBuffer: 64 * 1024 * 1024,
|
||
});
|
||
return {
|
||
ok: true,
|
||
stdout: capture ? out.toString() : '',
|
||
stderr: '',
|
||
status: 0,
|
||
};
|
||
} catch (e) {
|
||
return {
|
||
ok: false,
|
||
stdout: capture ? (e.stdout ? e.stdout.toString() : '') : '',
|
||
stderr: capture ? (e.stderr ? e.stderr.toString() : '') : '',
|
||
status: e.status,
|
||
};
|
||
}
|
||
}
|
||
|
||
// ── Step helpers ──────────────────────────────────────────────────────
|
||
function deepWipe() {
|
||
const bins = ['docmd', 'docmd-live'];
|
||
for (const bin of bins) {
|
||
try {
|
||
const paths = execSync(`which -a ${bin}`, { stdio: 'pipe' })
|
||
.toString().split('\n').filter(Boolean);
|
||
for (const p of paths) {
|
||
try { if (fs.existsSync(p)) fs.unlinkSync(p); }
|
||
catch {
|
||
try { execSync(`rm -f "${p}"`, { stdio: 'ignore' }); } catch { /* ignore */ }
|
||
}
|
||
}
|
||
} catch { /* ignore which failure */ }
|
||
}
|
||
}
|
||
|
||
function runLint() {
|
||
const s = startStep('Running eslint over monorepo');
|
||
// eslint exits non-zero on errors — JSON is still on stdout. run()
|
||
// never exits the process, so we can collect the lint output cleanly.
|
||
const result = run('pnpm -s exec eslint . --format json', { capture: true });
|
||
|
||
let errors = 0, warnings = 0;
|
||
const details = [];
|
||
try {
|
||
const results = JSON.parse(result.stdout || '[]');
|
||
for (const file of results) {
|
||
for (const msg of file.messages || []) {
|
||
if (msg.severity === 2) errors++;
|
||
else if (msg.severity === 1) warnings++;
|
||
if (msg.severity >= 1) {
|
||
const relPath = (file.filePath || '')
|
||
.replace(process.cwd() + '/', '')
|
||
.replace(/^.*\/docmd\//, '');
|
||
details.push(`${relPath}:${msg.line} — ${msg.message}`);
|
||
}
|
||
}
|
||
}
|
||
} catch (_) { /* malformed output */ }
|
||
|
||
const status = errors > 0 ? 'fail' : (warnings > 0 ? 'warn' : 'done');
|
||
finishStep(s, status);
|
||
|
||
const summary = `${errors} error${errors === 1 ? '' : 's'}, ${warnings} warning${warnings === 1 ? '' : 's'}`;
|
||
addStat('Lint', summary, errors > 0 ? 'fail' : (warnings > 0 ? 'warn' : 'ok'));
|
||
|
||
if (errors > 0) addIssue('error', 'Lint', `${errors} lint error(s)`, details);
|
||
else if (warnings > 0) addIssue('warning', 'Lint', `${warnings} lint warning(s)`, details);
|
||
}
|
||
|
||
// ── Collapsed-mode test runner ────────────────────────────────────────
|
||
// Captures test output, parses pass/fail counts and any failure
|
||
// titles, then renders a one-line summary. Verbose mode bypasses
|
||
// the capture and streams raw output as it arrives instead.
|
||
function summariseTests(stdout) {
|
||
// tests/runner.js emits a single aggregate line at the end.
|
||
// Pattern: "Test summary: 367 passed, 0 failed across 9 files"
|
||
let m = stdout.match(/Test summary:\s+(\d+)\s+passed,\s+(\d+)\s+failed\s+across\s+(\d+)\s+files?/i);
|
||
if (m) {
|
||
return {
|
||
tests: parseInt(m[1]) + parseInt(m[2]),
|
||
pass: parseInt(m[1]),
|
||
fail: parseInt(m[2]),
|
||
units: parseInt(m[3]),
|
||
unitLabel: 'files',
|
||
failures: extractFailures(stdout),
|
||
};
|
||
}
|
||
|
||
// Per-package output (pnpm -r run test): each suite prints its own
|
||
// ℹ tests N / ℹ pass N / ℹ fail N block, so we sum them all up.
|
||
let tests = 0, pass = 0, fail = 0, pkgs = 0;
|
||
for (const t of stdout.matchAll(/ℹ\s+tests\s+(\d+)/g)) tests += parseInt(t[1]);
|
||
for (const p of stdout.matchAll(/ℹ\s+pass\s+(\d+)/g)) pass += parseInt(p[1]);
|
||
for (const f of stdout.matchAll(/ℹ\s+fail\s+(\d+)/g)) fail += parseInt(f[1]);
|
||
// Count distinct packages that reported a result. Look for the
|
||
// pnpm-recursive "Done" line which marks each package's end.
|
||
for (const _ of stdout.matchAll(/\bDone$/gm)) pkgs++;
|
||
// Fallback when no "Done" markers are present: count `ℹ tests` lines.
|
||
if (pkgs === 0) {
|
||
for (const _ of stdout.matchAll(/ℹ\s+tests\s+\d+/g)) pkgs++;
|
||
}
|
||
return {
|
||
tests, pass, fail,
|
||
units: pkgs,
|
||
unitLabel: pkgs === 1 ? 'package' : 'packages',
|
||
failures: extractFailures(stdout),
|
||
};
|
||
}
|
||
|
||
function extractFailures(stdout) {
|
||
// node:test prints "not ok N - <name>" lines on failure. Trim
|
||
// surrounding ANSI noise and keep the title only — full diagnostics
|
||
// remain in --verbose output.
|
||
const out = [];
|
||
// Build the ANSI-stripping regex at runtime so the static linter
|
||
// doesn't flag the embedded ESC (\x1b) control character.
|
||
const ANSI_RE = new RegExp(`${String.fromCharCode(0x1b)}\\[[0-9;]*m`, 'g');
|
||
for (const m of stdout.matchAll(/not ok \d+ - (.+)/g)) {
|
||
const t = m[1].replace(ANSI_RE, '').trim();
|
||
if (t) out.push(t);
|
||
if (out.length >= 20) break;
|
||
}
|
||
return out;
|
||
}
|
||
|
||
function runTestStep(label, cmd, statLabel = label) {
|
||
const s = startStep(label);
|
||
|
||
// Verbose mode: stream the raw output as before. The finish line
|
||
// rewrites with [DONE] / [FAIL] depending on the exit code.
|
||
if (verbose) {
|
||
const result = run(cmd, { silent: false });
|
||
if (result.ok) finishStep(s);
|
||
else {
|
||
finishStep(s, 'fail');
|
||
addIssue('error', label, 'test step failed', []);
|
||
}
|
||
addStat(statLabel, result.ok ? 'passed (see --verbose output for details)' : 'failed', result.ok ? 'ok' : 'fail');
|
||
return;
|
||
}
|
||
|
||
// Default (collapsed) mode: capture output, summarise, render one line.
|
||
const result = run(cmd, { capture: true });
|
||
const sum = summariseTests(result.stdout + result.stderr);
|
||
|
||
if (result.ok && sum.fail === 0 && sum.tests > 0) {
|
||
finishStep(s, 'done');
|
||
addStat(statLabel, `${sum.pass} passed across ${sum.units} ${sum.unitLabel}`, 'ok');
|
||
} else if (result.ok && sum.tests === 0) {
|
||
// No tests ran at all (e.g. --only matched nothing). Be honest
|
||
// about that rather than printing a misleading "0 passed".
|
||
finishStep(s, 'warn');
|
||
addStat(statLabel, 'no tests ran', 'warn');
|
||
} else {
|
||
const statValue = sum.fail > 0
|
||
? `${sum.fail} of ${sum.tests} failed across ${sum.units} ${sum.unitLabel}`
|
||
: `command exited with status ${result.status}`;
|
||
finishStep(s, 'fail');
|
||
addStat(statLabel, statValue, 'fail');
|
||
addIssue('error', label,
|
||
sum.fail > 0 ? `${sum.fail} test failure(s)` : 'test command failed',
|
||
sum.failures);
|
||
}
|
||
}
|
||
|
||
// ── Final Summary / Issues section ───────────────────────────────────
|
||
// Single trailing block. When nothing failed, it renders as a green
|
||
// Summary listing every stat (one line per section). When issues were
|
||
// collected, it flips to a red Issues block with the same group /
|
||
// bullet layout used elsewhere in the TUI. Either way it lives in the
|
||
// same slot at the end of the pipeline, so the operator always knows
|
||
// where to look for the verdict.
|
||
function printSummary() {
|
||
if (issues.length === 0) {
|
||
// Green Summary — every stat in one tidy list. Pad the label
|
||
// column to the longest label so values align regardless of
|
||
// how many sections contributed.
|
||
section('Summary', C.green);
|
||
const pad = Math.max(...stats.map(s => s.label.length)) + 2;
|
||
for (const s of stats) {
|
||
const tag = s.severity === 'warn'
|
||
? `${C.yellow}[ WARN ]${C.reset}`
|
||
: `${C.green}[ DONE ]${C.reset}`;
|
||
const label = `${s.label}`.padEnd(pad);
|
||
console.log(`${C.green}│${C.reset} ${tag} ${C.bold}${label}${C.reset}${s.value}`);
|
||
}
|
||
footer(C.green);
|
||
return;
|
||
}
|
||
|
||
// Failure case: render the Issues block.
|
||
const errors = issues.filter(i => i.severity === 'error').length;
|
||
const warnings = issues.filter(i => i.severity === 'warning').length;
|
||
const color = errors > 0 ? C.red : C.yellow;
|
||
const head = `Issues — ${errors} error${errors === 1 ? '' : 's'}, ${warnings} warning${warnings === 1 ? '' : 's'}`;
|
||
section(head, color);
|
||
|
||
// Group by section so two issues from the same source don't repeat
|
||
// the section header; the operator reads the section once and then
|
||
// scans the bullets.
|
||
const bySection = new Map();
|
||
for (const i of issues) {
|
||
if (!bySection.has(i.section)) bySection.set(i.section, []);
|
||
bySection.get(i.section).push(i);
|
||
}
|
||
for (const [name, items] of bySection) {
|
||
const tag = items.some(i => i.severity === 'error')
|
||
? `${C.red}[ FAIL ]${C.reset}`
|
||
: `${C.yellow}[ WARN ]${C.reset}`;
|
||
console.log(`${color}│${C.reset} ${tag} ${C.bold}${name}${C.reset}`);
|
||
for (const item of items) {
|
||
console.log(`${color}│${C.reset} ${item.message}`);
|
||
const detailCap = 8;
|
||
for (const detail of item.details.slice(0, detailCap)) {
|
||
console.log(`${color}│${C.reset} ${C.dim}${detail}${C.reset}`);
|
||
}
|
||
if (item.details.length > detailCap) {
|
||
console.log(`${color}│${C.reset} ${C.dim}… ${item.details.length - detailCap} more (re-run with --verbose for full output)${C.reset}`);
|
||
}
|
||
}
|
||
}
|
||
footer(color);
|
||
}
|
||
|
||
function runDockerCheck() {
|
||
const s = startStep('Checking Docker availability');
|
||
let hasDocker = '';
|
||
try {
|
||
hasDocker = execSync('which docker 2>/dev/null', {
|
||
encoding: 'utf8',
|
||
stdio: ['pipe', 'pipe', 'pipe']
|
||
}).trim();
|
||
} catch { /* not installed */ }
|
||
|
||
if (!hasDocker && !process.env.DOCKER_HOST) {
|
||
finishStep(s, 'warn');
|
||
addStat('Docker', 'not installed — skipped', 'warn');
|
||
return;
|
||
}
|
||
try {
|
||
const version = execSync('docker --version', { encoding: 'utf8', stdio: ['pipe', 'pipe'] }).trim();
|
||
finishStep(s, 'done');
|
||
addStat('Docker', version.replace('Docker version ', 'Docker '), 'ok');
|
||
} catch {
|
||
finishStep(s, 'warn');
|
||
addStat('Docker', 'binary not functional', 'warn');
|
||
}
|
||
}
|
||
|
||
// ── Main pipeline ────────────────────────────────────────────────────
|
||
|
||
// Header — banner + "Maintenance Pipeline" subtitle. Inlined here
|
||
// (rather than calling `node tools/status.js start:reset`) because
|
||
// that helper opens a section frame which we don't want prep.js
|
||
// to inherit. prep.js owns its own section boundaries.
|
||
const LOGO = '\n'
|
||
+ ' _ _ \n'
|
||
+ ' _| |___ ___ _____ _| |\n'
|
||
+ ' | . | . | _| | . |\n'
|
||
+ ' |___|___|___|_|_|_|___|\n';
|
||
console.log(`${C.blue}${LOGO}${C.reset}`);
|
||
console.log(`${C.dim} Monorepo Maintenance Pipeline ${C.reset}\n`);
|
||
|
||
// Section 1: Setup
|
||
section('Setup', C.blue);
|
||
{
|
||
const s = startStep('Stopping active servers');
|
||
const r = run('pnpm -s stop');
|
||
if (r.ok) finishStep(s);
|
||
else { finishStep(s, 'fail', `exit ${r.status}`); addIssue('error', 'Setup', `pnpm stop failed (exit ${r.status})`, []); }
|
||
}
|
||
{
|
||
const s = startStep('Wiping global docmd binaries');
|
||
const pkgs = ['@docmd/core', '@docmd/monorepo', 'docmd', 'docmd-live'];
|
||
for (const pkg of pkgs) {
|
||
try { execSync('npm uninstall -g ' + pkg + ' -s', { stdio: 'ignore' }); } catch { /* ignore */ }
|
||
try { execSync('pnpm uninstall -g ' + pkg + ' -s', { stdio: 'ignore' }); } catch { /* ignore */ }
|
||
}
|
||
deepWipe();
|
||
finishStep(s);
|
||
}
|
||
{
|
||
const s = startStep('Cleaning monorepo');
|
||
const r = run('pnpm -s clean');
|
||
if (r.ok) finishStep(s);
|
||
else { finishStep(s, 'fail', `exit ${r.status}`); addIssue('error', 'Setup', `pnpm clean failed (exit ${r.status})`, []); }
|
||
}
|
||
{
|
||
// pnpm clean wipes node_modules; reinstall before lint so the eslint
|
||
// binary is on PATH. Without this step the lint section silently exits
|
||
// 0 with no output because `pnpm exec eslint` can't find the binary.
|
||
const s = startStep('Installing monorepo dependencies');
|
||
const r = run('pnpm install --frozen-lockfile');
|
||
if (r.ok) finishStep(s);
|
||
else { finishStep(s, 'fail', `exit ${r.status}`); addIssue('error', 'Setup', `pnpm install failed (exit ${r.status})`, []); }
|
||
}
|
||
addStat('Setup', 'cleaned + installed dependencies', 'ok');
|
||
footer(C.blue);
|
||
|
||
// Section 2: Lint — runs after Setup reinstalls deps so eslint is available.
|
||
section('Lint', C.cyan);
|
||
runLint();
|
||
footer(C.cyan);
|
||
|
||
// Section 3: Build — required so tests have dist files to run against.
|
||
// `pnpm clean` (called in Setup) wipes every package's dist directory;
|
||
// deps are already restored by Setup's install step.
|
||
section('Build', C.cyan);
|
||
{
|
||
const s = startStep('Building all packages (pnpm -r run build)');
|
||
const r = run('pnpm -r run build');
|
||
if (r.ok) finishStep(s);
|
||
else { finishStep(s, 'fail', `exit ${r.status}`); addIssue('error', 'Build', `pnpm -r run build failed (exit ${r.status})`, []); }
|
||
}
|
||
addStat('Build', 'built all packages', 'ok');
|
||
footer(C.cyan);
|
||
|
||
// Section 4: Docker (optional)
|
||
section('Docker', C.blue);
|
||
runDockerCheck();
|
||
footer(C.blue);
|
||
|
||
// Section 5: Tests
|
||
section('Tests', C.blue);
|
||
if (args.includes('--skip-tests')) {
|
||
const s = startStep('Skipping test suite (--skip-tests)');
|
||
finishStep(s, 'done');
|
||
addStat('Tests', 'skipped by user request', 'ok');
|
||
} else {
|
||
const only = args.find((a) => a.startsWith('--only='));
|
||
const runnerArgs = only ? ' ' + only : '';
|
||
// The categorised runner now includes the Mega Integration Test
|
||
// (workspaces + i18n + versioning + plugins), which used to live
|
||
// in `tests/failsafe.test.mjs`. The old failsafe was removed because
|
||
// it duplicated Setup / Build work that `pnpm prep` already does.
|
||
// runTestStep() collapses to a one-line summary by default; pass
|
||
// --verbose to stream the full output.
|
||
// The shortLabel is what shows in the Summary block; the longer
|
||
// stepLabel stays in the per-step line.
|
||
runTestStep('Categorised test suite (tests/runner.js)',
|
||
'node tests/runner.js' + runnerArgs, 'Tests · runner.js');
|
||
|
||
// Per-package unit tests (parser, utils, mermaid, okf). Packages
|
||
// without a `test` script are skipped by `--if-present`. Wired in
|
||
// here so a regression in any plugin's local suite fails the
|
||
// release pipeline just like a regression in tests/runner.js.
|
||
runTestStep('Per-package unit tests (pnpm -r run test)',
|
||
'pnpm -r run test --if-present', 'Tests · per-package units');
|
||
}
|
||
footer(C.blue);
|
||
|
||
// Section 6: Link (optional)
|
||
if (args.includes('--link')) {
|
||
section('Link', C.blue);
|
||
const s = startStep('Linking @docmd/core globally');
|
||
try {
|
||
execSync('npm link --silent', {
|
||
cwd: require('path').join(process.cwd(), 'packages/core'),
|
||
stdio: 'ignore'
|
||
});
|
||
finishStep(s, 'done', 'docmd command available globally');
|
||
} catch {
|
||
finishStep(s, 'fail', 'npm link failed');
|
||
addIssue('error', 'Link', 'npm link failed', []);
|
||
}
|
||
footer(C.blue);
|
||
}
|
||
|
||
// Section 7: Summary / Issues — single trailing block. Renders a
|
||
// green Summary on a clean run, or a red Issues block on failure.
|
||
// Either way it lives in the same slot at the end of the pipeline
|
||
// so the operator always knows where to look for the verdict.
|
||
printSummary();
|
||
|
||
// Exit code: any error-level issue is fatal. Warnings alone keep the
|
||
// pipeline green so the operator can decide whether to act on them.
|
||
const hasErrors = issues.some(i => i.severity === 'error');
|
||
if (hasErrors) process.exit(1); |