pumuki 6.3.26 → 6.3.28

package/scripts/check-p9-ruralgo-baseline-versioned.ts

@@ -0,0 +1,198 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import {
+  evaluateP9RuralgoBaselineVersioned,
+  type P9RuralgoBaselineVersionedPolicy,
+} from './p9-ruralgo-baseline-versioned-lib';
+
+type CliOptions = {
+  repoPath: string;
+  json: boolean;
+  policy: P9RuralgoBaselineVersionedPolicy;
+};
+
+type GitRun = {
+  ok: boolean;
+  status: number;
+  stdout: string;
+  stderr: string;
+};
+
+const DEFAULT_REPO_PATH =
+  '/Users/juancarlosmerlosalbarracin/Developer/Projects/ruralgo-fork';
+
+const OPENSPEC_PROJECT = 'openspec/project.md';
+const OPENSPEC_ARCHIVE_GITKEEP = 'openspec/changes/archive/.gitkeep';
+const OPENSPEC_SPECS_GITKEEP = 'openspec/specs/.gitkeep';
+const AI_EVIDENCE_FILE = '.ai_evidence.json';
+
+const printHelp = (): void => {
+  process.stdout.write(
+    [
+      'Uso:',
+      '  node --import tsx scripts/check-p9-ruralgo-baseline-versioned.ts [opciones]',
+      '',
+      'Opciones:',
+      '  --repo=<path>                Ruta del repo ruralgo-fork (default: ~/Developer/Projects/ruralgo-fork)',
+      '  --allow-missing              Permite ausencia de artifacts baseline',
+      '  --allow-untracked            Permite artifacts sin trackear',
+      '  --json                       Salida JSON',
+      '  --help                       Muestra ayuda',
+      '',
+      'Exit code:',
+      '  0 => baseline versionado para F1.T4',
+      '  1 => baseline no versionado',
+      '',
+    ].join('\n'),
+  );
+};
+
+const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
+  const options: CliOptions = {
+    repoPath: DEFAULT_REPO_PATH,
+    json: false,
+    policy: {
+      requireExists: true,
+      requireTracked: true,
+    },
+  };
+
+  for (const arg of argv) {
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--allow-missing') {
+      options.policy.requireExists = false;
+      continue;
+    }
+    if (arg === '--allow-untracked') {
+      options.policy.requireTracked = false;
+      continue;
+    }
+    if (arg.startsWith('--repo=')) {
+      options.repoPath = arg.slice('--repo='.length);
+      continue;
+    }
+    throw new Error(`Argumento no soportado: ${arg}`);
+  }
+
+  return options;
+};
+
+const runGit = (repoPath: string, args: ReadonlyArray<string>): GitRun => {
+  try {
+    const stdout = execFileSync('git', ['-C', repoPath, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return { ok: true, status: 0, stdout, stderr: '' };
+  } catch (error) {
+    const err = error as {
+      status?: number;
+      stdout?: string | Buffer;
+      stderr?: string | Buffer;
+    };
+    return {
+      ok: false,
+      status: typeof err.status === 'number' ? err.status : 1,
+      stdout: String(err.stdout ?? '').trim(),
+      stderr: String(err.stderr ?? '').trim(),
+    };
+  }
+};
+
+const isTrackedByGit = (repoPath: string, relativePath: string): boolean =>
+  runGit(repoPath, ['ls-files', '--error-unmatch', '--', relativePath]).ok;
+
+const main = (): number => {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help')) {
+    printHelp();
+    return 0;
+  }
+
+  let options: CliOptions;
+  try {
+    options = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`[p9][baseline-versioned] ${(error as Error).message}\n`);
+    process.stderr.write('Usa --help para ver opciones.\n');
+    return 1;
+  }
+
+  const isGitRepo = runGit(options.repoPath, ['rev-parse', '--is-inside-work-tree']).stdout === 'true';
+
+  const openspecProjectExists = existsSync(join(options.repoPath, OPENSPEC_PROJECT));
+  const openspecArchiveGitkeepExists = existsSync(join(options.repoPath, OPENSPEC_ARCHIVE_GITKEEP));
+  const openspecSpecsGitkeepExists = existsSync(join(options.repoPath, OPENSPEC_SPECS_GITKEEP));
+  const aiEvidenceExists = existsSync(join(options.repoPath, AI_EVIDENCE_FILE));
+
+  const result = evaluateP9RuralgoBaselineVersioned(
+    {
+      isGitRepo,
+      openspecProjectExists,
+      openspecArchiveGitkeepExists,
+      openspecSpecsGitkeepExists,
+      aiEvidenceExists,
+      openspecProjectTracked: isGitRepo ? isTrackedByGit(options.repoPath, OPENSPEC_PROJECT) : false,
+      openspecArchiveGitkeepTracked: isGitRepo
+        ? isTrackedByGit(options.repoPath, OPENSPEC_ARCHIVE_GITKEEP)
+        : false,
+      openspecSpecsGitkeepTracked: isGitRepo
+        ? isTrackedByGit(options.repoPath, OPENSPEC_SPECS_GITKEEP)
+        : false,
+      aiEvidenceTracked: isGitRepo ? isTrackedByGit(options.repoPath, AI_EVIDENCE_FILE) : false,
+    },
+    options.policy,
+  );
+
+  const payload = {
+    ready: result.ready,
+    repoPath: options.repoPath,
+    policy: options.policy,
+    snapshot: {
+      isGitRepo,
+      openspecProjectExists,
+      openspecArchiveGitkeepExists,
+      openspecSpecsGitkeepExists,
+      aiEvidenceExists,
+      openspecProjectTracked: isGitRepo ? isTrackedByGit(options.repoPath, OPENSPEC_PROJECT) : false,
+      openspecArchiveGitkeepTracked: isGitRepo
+        ? isTrackedByGit(options.repoPath, OPENSPEC_ARCHIVE_GITKEEP)
+        : false,
+      openspecSpecsGitkeepTracked: isGitRepo
+        ? isTrackedByGit(options.repoPath, OPENSPEC_SPECS_GITKEEP)
+        : false,
+      aiEvidenceTracked: isGitRepo ? isTrackedByGit(options.repoPath, AI_EVIDENCE_FILE) : false,
+    },
+    issues: result.issues,
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write('[p9][baseline-versioned] PRECHECK\n');
+    process.stdout.write(`[p9][baseline-versioned] repo=${payload.repoPath}\n`);
+    process.stdout.write(
+      `[p9][baseline-versioned] openspec_exists(project/archive/specs)=${payload.snapshot.openspecProjectExists}/${payload.snapshot.openspecArchiveGitkeepExists}/${payload.snapshot.openspecSpecsGitkeepExists}\n`,
+    );
+    process.stdout.write(
+      `[p9][baseline-versioned] tracked(project/archive/specs/ai_evidence)=${payload.snapshot.openspecProjectTracked}/${payload.snapshot.openspecArchiveGitkeepTracked}/${payload.snapshot.openspecSpecsGitkeepTracked}/${payload.snapshot.aiEvidenceTracked}\n`,
+    );
+    process.stdout.write(
+      `[p9][baseline-versioned] status=${payload.ready ? 'READY' : 'NOT_READY'} issues=${payload.issues.length}\n`,
+    );
+    for (const issue of payload.issues) {
+      process.stdout.write(
+        `[p9][baseline-versioned][${issue.severity}] ${issue.code}: ${issue.message}\n`,
+      );
+    }
+  }
+
+  return payload.ready ? 0 : 1;
+};
+
+process.exitCode = main();

package/scripts/check-p9-ruralgo-branch-ready.ts

@@ -0,0 +1,215 @@
+import { execFileSync } from 'node:child_process';
+import process from 'node:process';
+import {
+  evaluateP9RuralgoBranchReadiness,
+  type P9RuralgoBranchReadinessPolicy,
+} from './p9-ruralgo-branch-ready-lib';
+
+type CliOptions = {
+  repoPath: string;
+  expectedBranch: string;
+  baseRef: string;
+  json: boolean;
+  policy: P9RuralgoBranchReadinessPolicy;
+};
+
+type GitRun = {
+  ok: boolean;
+  status: number;
+  stdout: string;
+  stderr: string;
+};
+
+const DEFAULT_REPO_PATH =
+  '/Users/juancarlosmerlosalbarracin/Developer/Projects/ruralgo-fork';
+
+const printHelp = (): void => {
+  process.stdout.write(
+    [
+      'Uso:',
+      '  node --import tsx scripts/check-p9-ruralgo-branch-ready.ts [opciones]',
+      '',
+      'Opciones:',
+      '  --repo=<path>                Ruta del repo ruralgo-fork (default: ~/Developer/Projects/ruralgo-fork)',
+      '  --expected-branch=<name>     Rama esperada (default: feature/p9-api-contact-contract)',
+      '  --base-ref=<git-ref>         Base esperada (default: origin/develop)',
+      '  --allow-upstream             Permite upstream ya configurado',
+      '  --allow-dirty                Permite worktree con cambios',
+      '  --allow-nonfeature-name      Permite nombres fuera de feature/<kebab-case>',
+      '  --json                       Salida JSON',
+      '  --help                       Muestra ayuda',
+      '',
+      'Exit code:',
+      '  0 => rama lista para P9.F0.T3.ST2',
+      '  1 => no lista (revisar issues)',
+      '',
+    ].join('\n'),
+  );
+};
+
+const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
+  const options: CliOptions = {
+    repoPath: DEFAULT_REPO_PATH,
+    expectedBranch: 'feature/p9-api-contact-contract',
+    baseRef: 'origin/develop',
+    json: false,
+    policy: {
+      requireNoUpstream: true,
+      requireCleanWorktree: true,
+      requireFeatureNaming: true,
+    },
+  };
+
+  for (const arg of argv) {
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--allow-upstream') {
+      options.policy.requireNoUpstream = false;
+      continue;
+    }
+    if (arg === '--allow-dirty') {
+      options.policy.requireCleanWorktree = false;
+      continue;
+    }
+    if (arg === '--allow-nonfeature-name') {
+      options.policy.requireFeatureNaming = false;
+      continue;
+    }
+    if (arg.startsWith('--repo=')) {
+      options.repoPath = arg.slice('--repo='.length);
+      continue;
+    }
+    if (arg.startsWith('--expected-branch=')) {
+      options.expectedBranch = arg.slice('--expected-branch='.length);
+      continue;
+    }
+    if (arg.startsWith('--base-ref=')) {
+      options.baseRef = arg.slice('--base-ref='.length);
+      continue;
+    }
+    throw new Error(`Argumento no soportado: ${arg}`);
+  }
+
+  return options;
+};
+
+const runGit = (repoPath: string, args: ReadonlyArray<string>): GitRun => {
+  try {
+    const stdout = execFileSync('git', ['-C', repoPath, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return { ok: true, status: 0, stdout, stderr: '' };
+  } catch (error) {
+    const err = error as {
+      status?: number;
+      stdout?: string | Buffer;
+      stderr?: string | Buffer;
+    };
+    return {
+      ok: false,
+      status: typeof err.status === 'number' ? err.status : 1,
+      stdout: String(err.stdout ?? '').trim(),
+      stderr: String(err.stderr ?? '').trim(),
+    };
+  }
+};
+
+const main = (): number => {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help')) {
+    printHelp();
+    return 0;
+  }
+
+  let options: CliOptions;
+  try {
+    options = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`[p9][branch-ready] ${(error as Error).message}\n`);
+    process.stderr.write('Usa --help para ver opciones.\n');
+    return 1;
+  }
+
+  const isGitRepoCheck = runGit(options.repoPath, ['rev-parse', '--is-inside-work-tree']);
+  const isGitRepo = isGitRepoCheck.ok && isGitRepoCheck.stdout === 'true';
+  const currentBranch = isGitRepo
+    ? runGit(options.repoPath, ['rev-parse', '--abbrev-ref', 'HEAD']).stdout || null
+    : null;
+
+  const upstreamCheck = isGitRepo
+    ? runGit(
+        options.repoPath,
+        ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'],
+      )
+    : { ok: false, status: 1, stdout: '', stderr: '' };
+  const upstreamRef = upstreamCheck.ok ? upstreamCheck.stdout : null;
+
+  const statusCheck = isGitRepo ? runGit(options.repoPath, ['status', '--porcelain']) : null;
+  const worktreeDirty = Boolean(statusCheck?.stdout);
+
+  const baseCheck = isGitRepo
+    ? runGit(options.repoPath, ['merge-base', '--is-ancestor', options.baseRef, 'HEAD'])
+    : { ok: false, status: 2, stdout: '', stderr: '' };
+  const baseReachable =
+    baseCheck.status === 0 ? true : baseCheck.status === 1 ? false : null;
+
+  const result = evaluateP9RuralgoBranchReadiness(
+    {
+      repoPath: options.repoPath,
+      expectedBranch: options.expectedBranch,
+      currentBranch,
+      upstreamRef,
+      baseRef: options.baseRef,
+      baseReachable,
+      worktreeDirty,
+      isGitRepo,
+    },
+    options.policy,
+  );
+
+  const payload = {
+    ready: result.ready,
+    repoPath: options.repoPath,
+    expectedBranch: options.expectedBranch,
+    currentBranch,
+    upstreamRef,
+    baseRef: options.baseRef,
+    baseReachable,
+    worktreeDirty,
+    policy: options.policy,
+    issues: result.issues,
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write('[p9][branch-ready] PRECHECK\n');
+    process.stdout.write(`[p9][branch-ready] repo=${payload.repoPath}\n`);
+    process.stdout.write(`[p9][branch-ready] expected_branch=${payload.expectedBranch}\n`);
+    process.stdout.write(`[p9][branch-ready] current_branch=${payload.currentBranch ?? 'n/a'}\n`);
+    process.stdout.write(`[p9][branch-ready] upstream=${payload.upstreamRef ?? 'none'}\n`);
+    process.stdout.write(`[p9][branch-ready] base_ref=${payload.baseRef}\n`);
+    process.stdout.write(
+      `[p9][branch-ready] base_reachable=${String(payload.baseReachable)} worktree_dirty=${String(
+        payload.worktreeDirty,
+      )}\n`,
+    );
+    process.stdout.write(
+      `[p9][branch-ready] status=${payload.ready ? 'READY' : 'NOT_READY'} issues=${
+        payload.issues.length
+      }\n`,
+    );
+    for (const issue of payload.issues) {
+      process.stdout.write(
+        `[p9][branch-ready][${issue.severity}] ${issue.code}: ${issue.message}\n`,
+      );
+    }
+  }
+
+  return payload.ready ? 0 : 1;
+};
+
+process.exitCode = main();

package/scripts/check-p9-ruralgo-install-health.ts

@@ -0,0 +1,288 @@
+import { execFileSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import process from 'node:process';
+import {
+  evaluateP9RuralgoInstallHealth,
+  type P9RuralgoInstallHealthPolicy,
+} from './p9-ruralgo-install-health-lib';
+
+type CliOptions = {
+  repoPath: string;
+  json: boolean;
+  policy: P9RuralgoInstallHealthPolicy;
+};
+
+type CommandResult = {
+  ok: boolean;
+  status: number;
+  stdout: string;
+  stderr: string;
+};
+
+type PumukiStatusPayload = {
+  lifecycleState?: {
+    installed?: string | boolean;
+  };
+  hookStatus?: {
+    'pre-commit'?: { exists?: boolean; managedBlockPresent?: boolean };
+    'pre-push'?: { exists?: boolean; managedBlockPresent?: boolean };
+  };
+};
+
+const DEFAULT_REPO_PATH =
+  '/Users/juancarlosmerlosalbarracin/Developer/Projects/ruralgo-fork';
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const localPumukiCliPath = resolve(scriptDir, '../bin/pumuki.js');
+
+const printHelp = (): void => {
+  process.stdout.write(
+    [
+      'Uso:',
+      '  node --import tsx scripts/check-p9-ruralgo-install-health.ts [opciones]',
+      '',
+      'Opciones:',
+      '  --repo=<path>                 Ruta del repo ruralgo-fork (default: ~/Developer/Projects/ruralgo-fork)',
+      '  --allow-not-installed         Permite lifecycle no instalado',
+      '  --allow-unmanaged-hooks       Permite hooks no gestionados',
+      '  --allow-doctor-fail           No exige doctor PASS',
+      '  --json                        Salida JSON',
+      '  --help                        Muestra ayuda',
+      '',
+      'Exit code:',
+      '  0 => instalación saludable para F1.T3',
+      '  1 => instalación no saludable',
+      '',
+    ].join('\n'),
+  );
+};
+
+const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
+  const options: CliOptions = {
+    repoPath: DEFAULT_REPO_PATH,
+    json: false,
+    policy: {
+      requireInstalled: true,
+      requireManagedHooks: true,
+      requireDoctorPass: true,
+    },
+  };
+
+  for (const arg of argv) {
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--allow-not-installed') {
+      options.policy.requireInstalled = false;
+      continue;
+    }
+    if (arg === '--allow-unmanaged-hooks') {
+      options.policy.requireManagedHooks = false;
+      continue;
+    }
+    if (arg === '--allow-doctor-fail') {
+      options.policy.requireDoctorPass = false;
+      continue;
+    }
+    if (arg.startsWith('--repo=')) {
+      options.repoPath = arg.slice('--repo='.length);
+      continue;
+    }
+    throw new Error(`Argumento no soportado: ${arg}`);
+  }
+
+  return options;
+};
+
+const runCommand = (
+  command: string,
+  args: ReadonlyArray<string>,
+  cwd: string,
+): CommandResult => {
+  try {
+    const stdout = execFileSync(command, args, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+      ok: true,
+      status: 0,
+      stdout: stdout.trim(),
+      stderr: '',
+    };
+  } catch (error) {
+    const err = error as {
+      status?: number;
+      stdout?: string | Buffer;
+      stderr?: string | Buffer;
+    };
+    return {
+      ok: false,
+      status: typeof err.status === 'number' ? err.status : 1,
+      stdout: String(err.stdout ?? '').trim(),
+      stderr: String(err.stderr ?? '').trim(),
+    };
+  }
+};
+
+const parseLifecycleInstalled = (value: string | boolean | undefined): boolean | null => {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'string') {
+    if (value === 'true') {
+      return true;
+    }
+    if (value === 'false') {
+      return false;
+    }
+  }
+  return null;
+};
+
+const parseDoctorVerdictPass = (stdout: string): boolean | null => {
+  if (!stdout) {
+    return null;
+  }
+  const maybeJson = stdout.trim();
+  if (maybeJson.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(maybeJson) as { verdict?: string; issues?: unknown[] };
+      if (typeof parsed.verdict === 'string') {
+        return parsed.verdict.toUpperCase() === 'PASS';
+      }
+      if (Array.isArray(parsed.issues)) {
+        return parsed.issues.length === 0;
+      }
+    } catch {
+      // fallback to regex text parsing
+    }
+  }
+  const match = stdout.match(/doctor verdict:\s*([A-Z]+)/i);
+  if (!match) {
+    return null;
+  }
+  return match[1]?.toUpperCase() === 'PASS';
+};
+
+const main = (): number => {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help')) {
+    printHelp();
+    return 0;
+  }
+
+  let options: CliOptions;
+  try {
+    options = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`[p9][install-health] ${(error as Error).message}\n`);
+    process.stderr.write('Usa --help para ver opciones.\n');
+    return 1;
+  }
+
+  const isGitRepoCheck = runCommand('git', ['rev-parse', '--is-inside-work-tree'], options.repoPath);
+  const isGitRepo = isGitRepoCheck.ok && isGitRepoCheck.stdout === 'true';
+
+  const statusCommand = isGitRepo
+    ? runCommand('node', [localPumukiCliPath, 'status', '--json'], options.repoPath)
+    : { ok: false, status: 1, stdout: '', stderr: '' };
+
+  let statusJsonValid = false;
+  let statusPayload: PumukiStatusPayload = {};
+  if (statusCommand.ok) {
+    try {
+      statusPayload = JSON.parse(statusCommand.stdout) as PumukiStatusPayload;
+      statusJsonValid = true;
+    } catch {
+      statusJsonValid = false;
+    }
+  }
+
+  const doctorCommand = isGitRepo
+    ? runCommand('node', [localPumukiCliPath, 'doctor', '--json'], options.repoPath)
+    : { ok: false, status: 1, stdout: '', stderr: '' };
+
+  const lifecycleInstalled = statusJsonValid
+    ? parseLifecycleInstalled(statusPayload.lifecycleState?.installed)
+    : null;
+  const preCommitManaged = statusJsonValid
+    ? statusPayload.hookStatus?.['pre-commit']?.managedBlockPresent === true
+    : null;
+  const prePushManaged = statusJsonValid
+    ? statusPayload.hookStatus?.['pre-push']?.managedBlockPresent === true
+    : null;
+  const doctorVerdictPass = doctorCommand.ok
+    ? parseDoctorVerdictPass(doctorCommand.stdout)
+    : null;
+
+  const result = evaluateP9RuralgoInstallHealth(
+    {
+      isGitRepo,
+      statusCommandOk: statusCommand.ok,
+      statusJsonValid,
+      lifecycleInstalled,
+      preCommitManaged,
+      prePushManaged,
+      doctorCommandOk: doctorCommand.ok,
+      doctorVerdictPass,
+    },
+    options.policy,
+  );
+
+  const payload = {
+    ready: result.ready,
+    repoPath: options.repoPath,
+    policy: options.policy,
+    snapshot: {
+      isGitRepo,
+      statusCommandOk: statusCommand.ok,
+      statusJsonValid,
+      lifecycleInstalled,
+      preCommitManaged,
+      prePushManaged,
+      doctorCommandOk: doctorCommand.ok,
+      doctorVerdictPass,
+    },
+    raw: {
+      status: {
+        exitCode: statusCommand.status,
+        stdout: statusCommand.stdout,
+        stderr: statusCommand.stderr,
+      },
+      doctor: {
+        exitCode: doctorCommand.status,
+        stdout: doctorCommand.stdout,
+        stderr: doctorCommand.stderr,
+      },
+    },
+    issues: result.issues,
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write('[p9][install-health] PRECHECK\n');
+    process.stdout.write(`[p9][install-health] repo=${payload.repoPath}\n`);
+    process.stdout.write(
+      `[p9][install-health] lifecycle_installed=${String(payload.snapshot.lifecycleInstalled)} managed_hooks(pre-commit/pre-push)=${String(
+        payload.snapshot.preCommitManaged,
+      )}/${String(payload.snapshot.prePushManaged)}\n`,
+    );
+    process.stdout.write(
+      `[p9][install-health] doctor_pass=${String(payload.snapshot.doctorVerdictPass)} status=${payload.ready ? 'READY' : 'NOT_READY'} issues=${payload.issues.length}\n`,
+    );
+    for (const issue of payload.issues) {
+      process.stdout.write(
+        `[p9][install-health][${issue.severity}] ${issue.code}: ${issue.message}\n`,
+      );
+    }
+  }
+
+  return payload.ready ? 0 : 1;
+};
+
+process.exitCode = main();