@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/chunk-4PEODTHY.js

@@ -0,0 +1,278 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput,
+  humanLine
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-release-readiness.ts
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+async function runCheck(name, cmd, args, cwd) {
+  const { spawnSync } = await import("node:child_process");
+  const start = Date.now();
+  const result = spawnSync(cmd, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd
+  });
+  const durationMs = Date.now() - start;
+  const passed = result.status === 0;
+  return {
+    name,
+    status: passed ? "pass" : "fail",
+    exitCode: result.status,
+    durationMs,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim()
+  };
+}
+var doctorReleaseReadinessCommand = defineCommand({
+  meta: {
+    name: "release-readiness",
+    description: "Pre-flight release readiness check \u2014 lint matrix + changelog + changeset + npm OIDC + tag-trigger sanity (T10458)"
+  },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const repoRoot = resolve(process.cwd());
+    const startTotal = Date.now();
+    const checks = [];
+    const biomePath = join(repoRoot, "node_modules", ".bin", "biome");
+    const biomeAvailable = existsSync(biomePath);
+    if (biomeAvailable) {
+      checks.push(await runCheck("biome-lint", biomePath, ["ci", "."], repoRoot));
+    } else {
+      checks.push({
+        name: "biome-lint",
+        status: "skip",
+        exitCode: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: "biome not found in node_modules/.bin \u2014 skipping"
+      });
+    }
+    const changesetLintScript = join(repoRoot, "scripts", "lint-changesets.mjs");
+    if (existsSync(changesetLintScript)) {
+      checks.push(await runCheck("changeset-lint", "node", [changesetLintScript], repoRoot));
+    } else {
+      checks.push({
+        name: "changeset-lint",
+        status: "skip",
+        exitCode: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: "scripts/lint-changesets.mjs not found \u2014 skipping"
+      });
+    }
+    const changelogPath = join(repoRoot, "CHANGELOG.md");
+    const changelogExists = existsSync(changelogPath);
+    const changelogCheck = {
+      name: "changelog-exists",
+      status: changelogExists ? "pass" : "fail",
+      exitCode: changelogExists ? 0 : 1,
+      durationMs: 0,
+      stdout: changelogExists ? `Found ${changelogPath}` : "",
+      stderr: changelogExists ? "" : `CHANGELOG.md not found at ${changelogPath}`
+    };
+    checks.push(changelogCheck);
+    const packageJsonPath = join(repoRoot, "package.json");
+    let oidcCheck;
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(
+          await import("node:fs").then((m) => m.readFileSync(packageJsonPath, "utf8"))
+        );
+        if (pkg.private === true) {
+          oidcCheck = {
+            name: "npm-oidc-sanity",
+            status: "pass",
+            exitCode: 0,
+            durationMs: 0,
+            stdout: "root package.json is private \u2014 skipping (per-package check applies at publish time)",
+            stderr: ""
+          };
+        } else {
+          const hasPublishConfig = typeof pkg.publishConfig === "object" && pkg.publishConfig !== null;
+          const accessPublic = hasPublishConfig && pkg.publishConfig.access === "public";
+          oidcCheck = {
+            name: "npm-oidc-sanity",
+            status: accessPublic ? "pass" : "fail",
+            exitCode: accessPublic ? 0 : 1,
+            durationMs: 0,
+            stdout: accessPublic ? "package.json has publishConfig.access=public" : "",
+            stderr: accessPublic ? "" : "package.json missing publishConfig.access=public \u2014 required for npm OIDC Trusted Publishing"
+          };
+        }
+      } catch {
+        oidcCheck = {
+          name: "npm-oidc-sanity",
+          status: "fail",
+          exitCode: 1,
+          durationMs: 0,
+          stdout: "",
+          stderr: "Failed to parse package.json"
+        };
+      }
+    } else {
+      oidcCheck = {
+        name: "npm-oidc-sanity",
+        status: "fail",
+        exitCode: 1,
+        durationMs: 0,
+        stdout: "",
+        stderr: "package.json not found"
+      };
+    }
+    checks.push(oidcCheck);
+    const tagWorkflowPath = join(repoRoot, ".github", "workflows", "auto-tag-on-release-merge.yml");
+    const tagWorkflowExists = existsSync(tagWorkflowPath);
+    let tagTriggerCheck;
+    if (tagWorkflowExists) {
+      try {
+        const content = await import("node:fs").then(
+          (m) => m.readFileSync(tagWorkflowPath, "utf8")
+        );
+        const hasName = content.includes("name:");
+        const hasOnTrigger = content.includes("on:") || content.includes("pull_request:");
+        const valid = hasName && hasOnTrigger;
+        tagTriggerCheck = {
+          name: "tag-trigger-sanity",
+          status: valid ? "pass" : "fail",
+          exitCode: valid ? 0 : 1,
+          durationMs: 0,
+          stdout: valid ? `Valid workflow at ${tagWorkflowPath}` : "",
+          stderr: valid ? "" : "auto-tag-on-release-merge.yml appears malformed"
+        };
+      } catch {
+        tagTriggerCheck = {
+          name: "tag-trigger-sanity",
+          status: "fail",
+          exitCode: 1,
+          durationMs: 0,
+          stdout: "",
+          stderr: "Failed to read auto-tag-on-release-merge.yml"
+        };
+      }
+    } else {
+      tagTriggerCheck = {
+        name: "tag-trigger-sanity",
+        status: "fail",
+        exitCode: 1,
+        durationMs: 0,
+        stdout: "",
+        stderr: `.github/workflows/auto-tag-on-release-merge.yml not found`
+      };
+    }
+    checks.push(tagTriggerCheck);
+    const tsconfigPath = join(repoRoot, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      const tscPath = join(repoRoot, "node_modules", ".bin", "tsc");
+      if (existsSync(tscPath)) {
+        checks.push(await runCheck("typecheck", tscPath, ["--noEmit"], repoRoot));
+      } else {
+        checks.push({
+          name: "typecheck",
+          status: "skip",
+          exitCode: null,
+          durationMs: 0,
+          stdout: "",
+          stderr: "tsc not found in node_modules/.bin \u2014 skipping"
+        });
+      }
+    } else {
+      checks.push({
+        name: "typecheck",
+        status: "skip",
+        exitCode: null,
+        durationMs: 0,
+        stdout: "",
+        stderr: "tsconfig.json not found \u2014 skipping"
+      });
+    }
+    const fastLintScripts = [
+      { name: "contracts-dep-lint", script: "scripts/lint-contracts-dep.mjs" },
+      { name: "format-error-lint", script: "scripts/lint-format-error-misuse.mjs" },
+      { name: "json-stream-lint", script: "scripts/lint-json-stream-hygiene.mjs" }
+    ];
+    for (const lint of fastLintScripts) {
+      const scriptPath = join(repoRoot, lint.script);
+      if (existsSync(scriptPath)) {
+        checks.push(await runCheck(lint.name, "node", [scriptPath], repoRoot));
+      } else {
+        checks.push({
+          name: lint.name,
+          status: "skip",
+          exitCode: null,
+          durationMs: 0,
+          stdout: "",
+          stderr: `${lint.script} not found \u2014 skipping`
+        });
+      }
+    }
+    const passCount = checks.filter((c) => c.status === "pass").length;
+    const failCount = checks.filter((c) => c.status === "fail").length;
+    const skipCount = checks.filter((c) => c.status === "skip").length;
+    const totalDurationMs = Date.now() - startTotal;
+    const ready = failCount === 0;
+    const result = {
+      ready,
+      checks,
+      summary: {
+        pass: passCount,
+        fail: failCount,
+        skip: skipCount,
+        total: checks.length,
+        durationMs: totalDurationMs
+      }
+    };
+    if (isHuman && args.json !== true) {
+      humanLine("\nRelease Readiness Check (T10458)\n");
+      humanLine(`${"\u2500".repeat(60)}`);
+      for (const c of checks) {
+        const icon = c.status === "pass" ? "PASS" : c.status === "fail" ? "FAIL" : "SKIP";
+        humanLine(`  [${icon}] ${c.name} (${c.durationMs}ms)`);
+        if (c.status === "fail" && c.stderr) {
+          const lines = c.stderr.split("\n").slice(0, 3);
+          for (const line of lines) {
+            humanLine(`         ${line}`);
+          }
+        }
+      }
+      humanLine(`${"\u2500".repeat(60)}`);
+      humanLine(`  Result: ${passCount} passed, ${failCount} failed, ${skipCount} skipped`);
+      humanLine(`  Total time: ${totalDurationMs}ms`);
+      humanLine(`  Ready: ${ready ? "YES" : "NO"}
+`);
+    }
+    cliOutput(result, { command: "doctor", operation: "doctor.release-readiness" });
+    if (!ready) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorReleaseReadinessCommand
+};
+//# sourceMappingURL=chunk-4PEODTHY.js.map