pumuki 6.3.7

package/scripts/framework-menu-runners-consumer-auth-lib.ts

@@ -0,0 +1,11 @@
+import type { ConsumerCiAuthCheckParams } from './framework-menu-runners-consumer-contract';
+import { runConsumerMenuScript } from './framework-menu-runners-consumer-exec-lib';
+
+export const runConsumerCiAuthCheck = async (
+  params: ConsumerCiAuthCheckParams
+): Promise<void> => {
+  runConsumerMenuScript({
+    relativeScriptPath: 'scripts/check-consumer-ci-auth.ts',
+    args: ['--repo', params.repo, '--out', params.outFile],
+  });
+};

package/scripts/framework-menu-runners-consumer-contract.ts

@@ -0,0 +1,55 @@
+export type ConsumerCiArtifactsScanParams = {
+  repo: string;
+  limit: number;
+  outFile: string;
+};
+
+export type ConsumerCiAuthCheckParams = {
+  repo: string;
+  outFile: string;
+};
+
+export type ConsumerWorkflowLintScanParams = {
+  repoPath: string;
+  actionlintBin: string;
+  outFile: string;
+};
+
+export type ConsumerSupportBundleParams = {
+  repo: string;
+  limit: number;
+  outFile: string;
+};
+
+export type ConsumerSupportTicketDraftParams = {
+  repo: string;
+  supportBundleFile: string;
+  authReportFile: string;
+  outFile: string;
+};
+
+export type ConsumerStartupUnblockStatusParams = {
+  repo: string;
+  supportBundleFile: string;
+  authReportFile: string;
+  workflowLintReportFile: string;
+  outFile: string;
+};
+
+export type ConsumerStartupTriageParams = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+};
+
+export type MockConsumerAbReportParams = {
+  repo: string;
+  outFile: string;
+  blockSummaryFile: string;
+  minimalSummaryFile: string;
+  blockEvidenceFile: string;
+  minimalEvidenceFile: string;
+};

package/scripts/framework-menu-runners-consumer-exec-lib.ts

@@ -0,0 +1,13 @@
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runConsumerMenuScript = (params: {
+  relativeScriptPath: string;
+  args: string[];
+}): void => {
+  const scriptPath = resolveScriptOrReportMissing(params.relativeScriptPath);
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(['--yes', 'tsx@4.21.0', scriptPath, ...params.args]);
+};

package/scripts/framework-menu-runners-consumer-mock-ab-lib.ts

@@ -0,0 +1,24 @@
+import { buildMockConsumerAbReportCommandArgs } from './framework-menu-builders';
+import type { MockConsumerAbReportParams } from './framework-menu-runners-consumer-contract';
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runMockConsumerAbReport = async (
+  params: MockConsumerAbReportParams
+): Promise<void> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/build-mock-consumer-ab-report.ts');
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(
+    buildMockConsumerAbReportCommandArgs({
+      scriptPath,
+      repo: params.repo,
+      outFile: params.outFile,
+      blockSummaryFile: params.blockSummaryFile,
+      minimalSummaryFile: params.minimalSummaryFile,
+      blockEvidenceFile: params.blockEvidenceFile,
+      minimalEvidenceFile: params.minimalEvidenceFile,
+    })
+  );
+};

package/scripts/framework-menu-runners-consumer-startup-triage-lib.ts

@@ -0,0 +1,24 @@
+import { buildConsumerStartupTriageCommandArgs } from './framework-menu-builders';
+import type { ConsumerStartupTriageParams } from './framework-menu-runners-consumer-contract';
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runConsumerStartupTriage = async (
+  params: ConsumerStartupTriageParams
+): Promise<void> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/build-consumer-startup-triage.ts');
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(
+    buildConsumerStartupTriageCommandArgs({
+      scriptPath,
+      repo: params.repo,
+      limit: params.limit,
+      outDir: params.outDir,
+      runWorkflowLint: params.runWorkflowLint,
+      repoPath: params.repoPath,
+      actionlintBin: params.actionlintBin,
+    })
+  );
+};

package/scripts/framework-menu-runners-consumer-support-bundle-lib.ts

@@ -0,0 +1,11 @@
+import type { ConsumerSupportBundleParams } from './framework-menu-runners-consumer-contract';
+import { runConsumerMenuScript } from './framework-menu-runners-consumer-exec-lib';
+
+export const runConsumerSupportBundle = async (
+  params: ConsumerSupportBundleParams
+): Promise<void> => {
+  runConsumerMenuScript({
+    relativeScriptPath: 'scripts/build-consumer-startup-failure-support-bundle.ts',
+    args: ['--repo', params.repo, '--limit', String(params.limit), '--out', params.outFile],
+  });
+};

package/scripts/framework-menu-runners-consumer-support-ticket-lib.ts

@@ -0,0 +1,20 @@
+import type { ConsumerSupportTicketDraftParams } from './framework-menu-runners-consumer-contract';
+import { runConsumerMenuScript } from './framework-menu-runners-consumer-exec-lib';
+
+export const runConsumerSupportTicketDraft = async (
+  params: ConsumerSupportTicketDraftParams
+): Promise<void> => {
+  runConsumerMenuScript({
+    relativeScriptPath: 'scripts/build-consumer-support-ticket-draft.ts',
+    args: [
+      '--repo',
+      params.repo,
+      '--support-bundle',
+      params.supportBundleFile,
+      '--auth-report',
+      params.authReportFile,
+      '--out',
+      params.outFile,
+    ],
+  });
+};

package/scripts/framework-menu-runners-consumer-unblock-lib.ts

@@ -0,0 +1,22 @@
+import type { ConsumerStartupUnblockStatusParams } from './framework-menu-runners-consumer-contract';
+import { runConsumerMenuScript } from './framework-menu-runners-consumer-exec-lib';
+
+export const runConsumerStartupUnblockStatus = async (
+  params: ConsumerStartupUnblockStatusParams
+): Promise<void> => {
+  runConsumerMenuScript({
+    relativeScriptPath: 'scripts/build-consumer-startup-unblock-status.ts',
+    args: [
+      '--repo',
+      params.repo,
+      '--support-bundle',
+      params.supportBundleFile,
+      '--auth-report',
+      params.authReportFile,
+      '--workflow-lint-report',
+      params.workflowLintReportFile,
+      '--out',
+      params.outFile,
+    ],
+  });
+};

package/scripts/framework-menu-runners-consumer-workflow-lib.ts

@@ -0,0 +1,18 @@
+import type { ConsumerWorkflowLintScanParams } from './framework-menu-runners-consumer-contract';
+import { runConsumerMenuScript } from './framework-menu-runners-consumer-exec-lib';
+
+export const runConsumerWorkflowLintScan = async (
+  params: ConsumerWorkflowLintScanParams
+): Promise<void> => {
+  runConsumerMenuScript({
+    relativeScriptPath: 'scripts/lint-consumer-workflows.ts',
+    args: [
+      '--repo-path',
+      params.repoPath,
+      '--actionlint-bin',
+      params.actionlintBin,
+      '--out',
+      params.outFile,
+    ],
+  });
+};

package/scripts/framework-menu-runners-consumer.ts

@@ -0,0 +1,21 @@
+export type {
+  ConsumerCiArtifactsScanParams,
+  ConsumerCiAuthCheckParams,
+  ConsumerStartupTriageParams,
+  ConsumerStartupUnblockStatusParams,
+  ConsumerSupportBundleParams,
+  ConsumerSupportTicketDraftParams,
+  ConsumerWorkflowLintScanParams,
+  MockConsumerAbReportParams,
+} from './framework-menu-runners-consumer-contract';
+
+export { runConsumerCiArtifactsScan } from './framework-menu-runners-consumer-artifacts-lib';
+export { runConsumerCiAuthCheck } from './framework-menu-runners-consumer-auth-lib';
+export { runConsumerWorkflowLintScan } from './framework-menu-runners-consumer-workflow-lib';
+
+export { runConsumerSupportBundle } from './framework-menu-runners-consumer-support-bundle-lib';
+export { runConsumerSupportTicketDraft } from './framework-menu-runners-consumer-support-ticket-lib';
+export { runConsumerStartupUnblockStatus } from './framework-menu-runners-consumer-unblock-lib';
+
+export { runConsumerStartupTriage } from './framework-menu-runners-consumer-startup-triage-lib';
+export { runMockConsumerAbReport } from './framework-menu-runners-consumer-mock-ab-lib';

package/scripts/framework-menu-runners-phase5-blockers-lib.ts

@@ -0,0 +1,18 @@
+import { buildPhase5BlockersReadinessCommandArgs } from './framework-menu-builders';
+import type { Phase5BlockersReadinessRunnerParams } from './framework-menu-runners-phase5-contract';
+import { runPhase5BuiltCommand } from './framework-menu-runners-phase5-exec-lib';
+
+export const runPhase5BlockersReadiness = async (
+  params: Phase5BlockersReadinessRunnerParams
+): Promise<void> => {
+  runPhase5BuiltCommand({
+    relativeScriptPath: 'scripts/build-phase5-blockers-readiness.ts',
+    buildArgs: (scriptPath) =>
+      buildPhase5BlockersReadinessCommandArgs({
+        scriptPath,
+        adapterReportFile: params.adapterReportFile,
+        consumerTriageReportFile: params.consumerTriageReportFile,
+        outFile: params.outFile,
+      }),
+  });
+};

package/scripts/framework-menu-runners-phase5-closure-lib.ts

@@ -0,0 +1,25 @@
+import { buildPhase5ExecutionClosureCommandArgs } from './framework-menu-builders';
+import type { Phase5ExecutionClosureRunnerParams } from './framework-menu-runners-phase5-contract';
+import { runPhase5BuiltCommand } from './framework-menu-runners-phase5-exec-lib';
+
+export const runPhase5ExecutionClosure = async (
+  params: Phase5ExecutionClosureRunnerParams
+): Promise<void> => {
+  runPhase5BuiltCommand({
+    relativeScriptPath: 'scripts/run-phase5-execution-closure.ts',
+    buildArgs: (scriptPath) =>
+      buildPhase5ExecutionClosureCommandArgs({
+        scriptPath,
+        repo: params.repo,
+        limit: params.limit,
+        outDir: params.outDir,
+        runWorkflowLint: params.runWorkflowLint,
+        includeAuthPreflight: params.includeAuthPreflight,
+        repoPath: params.repoPath,
+        actionlintBin: params.actionlintBin,
+        includeAdapter: params.includeAdapter,
+        requireAdapterReadiness: params.requireAdapterReadiness,
+        useMockConsumerTriage: params.useMockConsumerTriage,
+      }),
+  });
+};

package/scripts/framework-menu-runners-phase5-contract.ts

@@ -0,0 +1,39 @@
+export type Phase5BlockersReadinessRunnerParams = {
+  adapterReportFile: string;
+  consumerTriageReportFile: string;
+  outFile: string;
+};
+
+export type Phase5ExecutionClosureStatusRunnerParams = {
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  adapterReadinessReportFile: string;
+  outFile: string;
+  requireAdapterReadiness: boolean;
+};
+
+export type Phase5ExternalHandoffRunnerParams = {
+  repo: string;
+  phase5StatusReportFile: string;
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  mockAbReportFile: string;
+  runReportFile: string;
+  outFile: string;
+  artifactUrls: ReadonlyArray<string>;
+  requireArtifactUrls: boolean;
+  requireMockAbReport: boolean;
+};
+
+export type Phase5ExecutionClosureRunnerParams = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  includeAuthPreflight: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+  includeAdapter: boolean;
+  requireAdapterReadiness: boolean;
+  useMockConsumerTriage: boolean;
+};

package/scripts/framework-menu-runners-phase5-exec-lib.ts

@@ -0,0 +1,25 @@
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runPhase5MenuScript = (params: {
+  relativeScriptPath: string;
+  args: string[];
+}): void => {
+  const scriptPath = resolveScriptOrReportMissing(params.relativeScriptPath);
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(['--yes', 'tsx@4.21.0', scriptPath, ...params.args]);
+};
+
+export const runPhase5BuiltCommand = (params: {
+  relativeScriptPath: string;
+  buildArgs: (scriptPath: string) => string[];
+}): void => {
+  const scriptPath = resolveScriptOrReportMissing(params.relativeScriptPath);
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(params.buildArgs(scriptPath));
+};

package/scripts/framework-menu-runners-phase5-handoff-lib.ts

@@ -0,0 +1,25 @@
+import { buildPhase5ExternalHandoffCommandArgs } from './framework-menu-builders';
+import type { Phase5ExternalHandoffRunnerParams } from './framework-menu-runners-phase5-contract';
+import { runPhase5BuiltCommand } from './framework-menu-runners-phase5-exec-lib';
+
+export const runPhase5ExternalHandoff = async (
+  params: Phase5ExternalHandoffRunnerParams
+): Promise<void> => {
+  runPhase5BuiltCommand({
+    relativeScriptPath: 'scripts/build-phase5-external-handoff.ts',
+    buildArgs: (scriptPath) =>
+      buildPhase5ExternalHandoffCommandArgs({
+        scriptPath,
+        repo: params.repo,
+        phase5StatusReportFile: params.phase5StatusReportFile,
+        phase5BlockersReportFile: params.phase5BlockersReportFile,
+        consumerUnblockReportFile: params.consumerUnblockReportFile,
+        mockAbReportFile: params.mockAbReportFile,
+        runReportFile: params.runReportFile,
+        outFile: params.outFile,
+        artifactUrls: params.artifactUrls,
+        requireArtifactUrls: params.requireArtifactUrls,
+        requireMockAbReport: params.requireMockAbReport,
+      }),
+  });
+};

package/scripts/framework-menu-runners-phase5-status-lib.ts

@@ -0,0 +1,20 @@
+import { buildPhase5ExecutionClosureStatusCommandArgs } from './framework-menu-builders';
+import type { Phase5ExecutionClosureStatusRunnerParams } from './framework-menu-runners-phase5-contract';
+import { runPhase5BuiltCommand } from './framework-menu-runners-phase5-exec-lib';
+
+export const runPhase5ExecutionClosureStatus = async (
+  params: Phase5ExecutionClosureStatusRunnerParams
+): Promise<void> => {
+  runPhase5BuiltCommand({
+    relativeScriptPath: 'scripts/build-phase5-execution-closure-status.ts',
+    buildArgs: (scriptPath) =>
+      buildPhase5ExecutionClosureStatusCommandArgs({
+        scriptPath,
+        phase5BlockersReportFile: params.phase5BlockersReportFile,
+        consumerUnblockReportFile: params.consumerUnblockReportFile,
+        adapterReadinessReportFile: params.adapterReadinessReportFile,
+        outFile: params.outFile,
+        requireAdapterReadiness: params.requireAdapterReadiness,
+      }),
+  });
+};

package/scripts/framework-menu-runners-phase5.ts

@@ -0,0 +1,12 @@
+export type {
+  Phase5BlockersReadinessRunnerParams,
+  Phase5ExecutionClosureRunnerParams,
+  Phase5ExecutionClosureStatusRunnerParams,
+  Phase5ExternalHandoffRunnerParams,
+} from './framework-menu-runners-phase5-contract';
+
+export { runPhase5BlockersReadiness } from './framework-menu-runners-phase5-blockers-lib';
+export { runPhase5ExecutionClosureStatus } from './framework-menu-runners-phase5-status-lib';
+export { runPhase5ExternalHandoff } from './framework-menu-runners-phase5-handoff-lib';
+
+export { runPhase5ExecutionClosure } from './framework-menu-runners-phase5-closure-lib';

package/scripts/framework-menu-runners-validation-cleanup-lib.ts

@@ -0,0 +1,31 @@
+export type ValidationArtifactsCleanupRunnerParams = {
+  dryRun: boolean;
+};
+
+import { buildCleanValidationArtifactsCommandArgs } from './framework-menu-builders';
+import {
+  getExitCode,
+  resolveScriptOrReportMissing,
+  runNpx,
+} from './framework-menu-runner-common';
+
+export const runValidationArtifactsCleanup = async (
+  params: ValidationArtifactsCleanupRunnerParams
+): Promise<number> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/clean-validation-artifacts.ts');
+  if (!scriptPath) {
+    return 1;
+  }
+
+  try {
+    runNpx(
+      buildCleanValidationArtifactsCommandArgs({
+        scriptPath,
+        dryRun: params.dryRun,
+      })
+    );
+    return 0;
+  } catch (error) {
+    return getExitCode(error);
+  }
+};

package/scripts/framework-menu-runners-validation-docs-lib.ts

@@ -0,0 +1,20 @@
+import { buildValidationDocsHygieneCommandArgs } from './framework-menu-builders';
+import {
+  getExitCode,
+  resolveScriptOrReportMissing,
+  runNpx,
+} from './framework-menu-runner-common';
+
+export const runValidationDocsHygiene = async (): Promise<number> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/check-validation-docs-hygiene.ts');
+  if (!scriptPath) {
+    return 1;
+  }
+
+  try {
+    runNpx(buildValidationDocsHygieneCommandArgs({ scriptPath }));
+    return 0;
+  } catch (error) {
+    return getExitCode(error);
+  }
+};

package/scripts/framework-menu-runners-validation-skills-lib.ts

@@ -0,0 +1,11 @@
+import { buildSkillsLockCheckCommandArgs } from './framework-menu-builders';
+import { getExitCode, runNpm } from './framework-menu-runner-common';
+
+export const runSkillsLockCheck = async (): Promise<number> => {
+  try {
+    runNpm(buildSkillsLockCheckCommandArgs());
+    return 0;
+  } catch (error) {
+    return getExitCode(error);
+  }
+};

package/scripts/framework-menu-runners-validation.ts

@@ -0,0 +1,4 @@
+export type { ValidationArtifactsCleanupRunnerParams } from './framework-menu-runners-validation-cleanup-lib';
+export { runValidationDocsHygiene } from './framework-menu-runners-validation-docs-lib';
+export { runValidationArtifactsCleanup } from './framework-menu-runners-validation-cleanup-lib';
+export { runSkillsLockCheck } from './framework-menu-runners-validation-skills-lib';

package/scripts/framework-menu-runners.ts

@@ -0,0 +1,37 @@
+export {
+  DEFAULT_ACTIONLINT_BIN,
+  DEFAULT_CONSUMER_REPO_PATH,
+  printEvidence,
+  resolveDefaultRangeFrom,
+  runAndPrintExitCode,
+} from './framework-menu-runner-common';
+
+export {
+  runAdapterReadiness,
+  runAdapterRealSessionReport,
+  runAdapterSessionStatusReport,
+} from './framework-menu-runners-adapter';
+
+export {
+  runConsumerCiArtifactsScan,
+  runConsumerCiAuthCheck,
+  runConsumerStartupTriage,
+  runConsumerStartupUnblockStatus,
+  runConsumerSupportBundle,
+  runConsumerSupportTicketDraft,
+  runConsumerWorkflowLintScan,
+  runMockConsumerAbReport,
+} from './framework-menu-runners-consumer';
+
+export {
+  runPhase5BlockersReadiness,
+  runPhase5ExecutionClosure,
+  runPhase5ExecutionClosureStatus,
+  runPhase5ExternalHandoff,
+} from './framework-menu-runners-phase5';
+
+export {
+  runSkillsLockCheck,
+  runValidationArtifactsCleanup,
+  runValidationDocsHygiene,
+} from './framework-menu-runners-validation';

package/scripts/framework-menu-skills-lib.ts

@@ -0,0 +1,26 @@
+import { type SkillsLockBundle, loadSkillsLock } from '../integrations/config/skillsLock';
+
+export const formatActiveSkillsBundles = (
+  bundles: ReadonlyArray<Pick<SkillsLockBundle, 'name' | 'version' | 'hash'>>
+): string => {
+  if (bundles.length === 0) {
+    return 'No active skills bundles found. Run `npm run skills:compile` to generate skills.lock.json.';
+  }
+
+  const lines = [...bundles]
+    .sort((left, right) => {
+      const byName = left.name.localeCompare(right.name);
+      if (byName !== 0) {
+        return byName;
+      }
+      return left.version.localeCompare(right.version);
+    })
+    .map((bundle) => `- ${bundle.name}@${bundle.version} hash=${bundle.hash}`);
+
+  return ['Active skills bundles:', ...lines].join('\n');
+};
+
+export const loadAndFormatActiveSkillsBundles = (repoRoot: string): string => {
+  const lock = loadSkillsLock(repoRoot);
+  return formatActiveSkillsBundles(lock?.bundles ?? []);
+};

package/scripts/framework-menu.cli.ts

@@ -0,0 +1,3 @@
+import { runFrameworkMenu } from './framework-menu';
+
+void runFrameworkMenu();

package/scripts/framework-menu.ts

@@ -0,0 +1,67 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { createFrameworkMenuActions, type MenuAction } from './framework-menu-actions';
+import { runRangeGate, runStagedGate } from './framework-menu-gate-lib';
+import { createFrameworkMenuPrompts } from './framework-menu-prompts';
+import { resolveDefaultRangeFrom } from './framework-menu-runners';
+import {
+  formatActiveSkillsBundles,
+  loadAndFormatActiveSkillsBundles,
+} from './framework-menu-skills-lib';
+
+export * from './framework-menu-builders';
+export { buildMenuGateParams } from './framework-menu-gate-lib';
+export { formatActiveSkillsBundles } from './framework-menu-skills-lib';
+
+const printActiveSkillsBundles = (): void => {
+  const rendered = loadAndFormatActiveSkillsBundles(process.cwd());
+  output.write(`\n${rendered}\n`);
+};
+
+const menu = async (): Promise<void> => {
+  const rl = createInterface({ input, output });
+
+  try {
+    const prompts = createFrameworkMenuPrompts(rl);
+    const actions: ReadonlyArray<MenuAction> = createFrameworkMenuActions({
+      prompts,
+      runStaged: runStagedGate,
+      runRange: runRangeGate,
+      resolveDefaultRangeFrom,
+      printActiveSkillsBundles,
+    });
+
+    while (true) {
+      output.write('\nPumuki Framework Menu\n');
+      for (const action of actions) {
+        output.write(`${action.id}. ${action.label}\n`);
+      }
+
+      const option = (await rl.question('\nSelect option: ')).trim();
+      const selected = actions.find((action) => action.id === option);
+
+      if (!selected) {
+        output.write('Invalid option.\n');
+        continue;
+      }
+
+      if (selected.id === '27') {
+        break;
+      }
+
+      try {
+        await selected.execute();
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : 'Unexpected menu execution error.';
+        output.write(`Error: ${message}\n`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+};
+
+export const runFrameworkMenu = async (): Promise<void> => {
+  await menu();
+};

package/scripts/lint-consumer-workflows.ts

@@ -0,0 +1,29 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseConsumerWorkflowLintArgs } from './consumer-workflow-lint-args-lib';
+import { buildConsumerWorkflowLintMarkdown } from './consumer-workflow-lint-markdown-lib';
+import {
+  assertConsumerWorkflowLintBinary,
+  runConsumerWorkflowLint,
+} from './consumer-workflow-lint-runner-lib';
+
+const main = (): number => {
+  const options = parseConsumerWorkflowLintArgs(process.argv.slice(2));
+  assertConsumerWorkflowLintBinary(options.actionlintBin, process.cwd());
+
+  const lintResult = runConsumerWorkflowLint(options);
+  const report = buildConsumerWorkflowLintMarkdown({
+    options,
+    lintResult,
+  });
+
+  const outPath = resolve(process.cwd(), options.outFile);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, report, 'utf8');
+
+  process.stdout.write(`consumer workflow lint report generated at ${outPath}\n`);
+
+  return lintResult.exitCode === 0 ? 0 : 1;
+};
+
+process.exitCode = main();