pumuki 6.3.7

package/scripts/adapter-session-status-verdict-lib.ts

@@ -0,0 +1,43 @@
+import {
+  determineAdapterSessionVerdict,
+  type AdapterSessionVerdict,
+} from './adapter-session-status-lib';
+import type { AdapterSessionStatusCommandExecution } from './adapter-session-status-contract';
+
+export const deriveAdapterSessionVerdictFromCommands = (
+  commands: ReadonlyArray<AdapterSessionStatusCommandExecution>
+): AdapterSessionVerdict => {
+  const verifyResult = commands.find(
+    (item) => item.label === 'verify-adapter-hooks-runtime'
+  );
+  const strictResult = commands.find(
+    (item) => item.label === 'assess-adapter-hooks-session'
+  );
+  const anyResult = commands.find(
+    (item) => item.label === 'assess-adapter-hooks-session:any'
+  );
+
+  if (!verifyResult || !strictResult || !anyResult) {
+    throw new Error('Missing required command execution results.');
+  }
+
+  return determineAdapterSessionVerdict({
+    verifyExitCode: verifyResult.exitCode,
+    strictOutput: strictResult.output,
+    anyOutput: anyResult.output,
+  });
+};
+
+export const exitCodeForAdapterSessionVerdict = (
+  verdict: AdapterSessionVerdict
+): number => {
+  if (verdict === 'PASS') {
+    return 0;
+  }
+
+  if (verdict === 'NEEDS_REAL_SESSION') {
+    return 2;
+  }
+
+  return 1;
+};

package/scripts/adapter-session-status-writes-log-filter-lib.ts

@@ -0,0 +1,25 @@
+import { isPathInsideRepo } from './adapter-session-status-log-utils-lib';
+
+export const filterWritesLogLinesForRepo = (params: {
+  content: string;
+  repoRoot: string;
+}): ReadonlyArray<string> => {
+  const allLines = params.content.split(/\r?\n/);
+  const filtered: string[] = [];
+
+  for (const line of allLines) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(line) as { file?: string };
+      const filePath = typeof parsed.file === 'string' ? parsed.file : '';
+      if (isPathInsideRepo({ repoRoot: params.repoRoot, filePath })) {
+        filtered.push(line);
+      }
+    } catch {}
+  }
+
+  return filtered;
+};

package/scripts/build-adapter-readiness.ts

@@ -0,0 +1,51 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import {
+  parseAdapterReadinessArgs,
+  readAdapterReadinessInput,
+} from './adapter-readiness-cli-lib';
+import {
+  buildAdapterReadinessMarkdown,
+  parseAdapterReport,
+  summarizeAdapterReadiness,
+} from './adapter-readiness-lib';
+
+const main = (): number => {
+  const cwd = process.cwd();
+  const options = parseAdapterReadinessArgs(process.argv.slice(2));
+  const adapterReport = readAdapterReadinessInput(cwd, options.adapterReportFile);
+
+  const parsedAdapter = adapterReport.content
+    ? parseAdapterReport(adapterReport.content)
+    : undefined;
+
+  const summary = summarizeAdapterReadiness({
+    hasAdapterReport: adapterReport.exists,
+    adapter: parsedAdapter,
+  });
+
+  const markdown = buildAdapterReadinessMarkdown({
+    generatedAt: new Date().toISOString(),
+    adapterReportPath: options.adapterReportFile,
+    hasAdapterReport: adapterReport.exists,
+    summary,
+  });
+
+  const outputPath = resolve(cwd, options.outFile);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, markdown, 'utf8');
+
+  process.stdout.write(
+    `adapter readiness report generated at ${outputPath} (verdict=${summary.verdict})\n`
+  );
+
+  return summary.verdict === 'READY' ? 0 : 1;
+};
+
+try {
+  process.exit(main());
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'unknown error';
+  process.stderr.write(`adapter readiness generation failed: ${message}\n`);
+  process.exit(1);
+}

package/scripts/build-adapter-real-session-report.ts

@@ -0,0 +1,58 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import {
+  loadAdapterAuditSnapshot,
+  loadAdapterHookConfigSnapshot,
+  readFileIfExists,
+  runGitOrUnknown,
+} from './adapter-real-session-context-lib';
+import {
+  buildAdapterRealSessionReportMarkdown,
+  parseAdapterRealSessionArgs,
+  parseAdapterRealSessionStatusReport,
+} from './adapter-real-session-report-lib';
+
+const main = (): number => {
+  const cwd = process.cwd();
+  const options = parseAdapterRealSessionArgs(process.argv.slice(2));
+  const statusReport = readFileIfExists(cwd, options.statusReportFile);
+  const parsedStatus = parseAdapterRealSessionStatusReport(statusReport);
+  const hookConfigSnapshot = loadAdapterHookConfigSnapshot({
+    cwd,
+    homeDir: process.env.HOME,
+  });
+  const auditSnapshot = loadAdapterAuditSnapshot({
+    cwd,
+    tailLines: options.tailLines,
+  });
+
+  const markdown = buildAdapterRealSessionReportMarkdown({
+    options,
+    nowIso: new Date().toISOString(),
+    branch: runGitOrUnknown(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']),
+    repository: runGitOrUnknown(cwd, ['config', '--get', 'remote.origin.url']),
+    nodeRuntime: process.version,
+    hookConfigPath: hookConfigSnapshot.hookConfigPath,
+    hookConfigContent: hookConfigSnapshot.hookConfigContent,
+    statusReportPath: options.statusReportFile,
+    statusReport,
+    parsedStatus,
+    ...auditSnapshot,
+    hookConfigExists: hookConfigSnapshot.hookConfigExists,
+  });
+
+  const outputPath = resolve(cwd, options.outFile);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, markdown, 'utf8');
+
+  process.stdout.write(`adapter real-session report generated at ${outputPath}\n`);
+  return 0;
+};
+
+try {
+  process.exit(main());
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'unknown error';
+  process.stderr.write(`adapter real-session report generation failed: ${message}\n`);
+  process.exit(1);
+}

package/scripts/build-adapter-session-status.ts

@@ -0,0 +1,42 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { collectAdapterSessionStatusTails } from './adapter-session-status-audit-tail-lib';
+import { runAdapterSessionStatusCommands } from './adapter-session-status-command-lib';
+import {
+  ADAPTER_SESSION_STATUS_COMMANDS,
+  buildAdapterSessionStatusMarkdown,
+  deriveAdapterSessionVerdictFromCommands,
+  exitCodeForAdapterSessionVerdict,
+  parseAdapterSessionStatusArgs,
+} from './adapter-session-status-report-lib';
+
+const main = (): number => {
+  const options = parseAdapterSessionStatusArgs(process.argv.slice(2));
+
+  const commands = runAdapterSessionStatusCommands(ADAPTER_SESSION_STATUS_COMMANDS);
+  const verdict = deriveAdapterSessionVerdictFromCommands(commands);
+  const repoRoot = resolve(process.cwd());
+
+  const markdown = buildAdapterSessionStatusMarkdown({
+    generatedAtIso: new Date().toISOString(),
+    options,
+    commands,
+    verdict,
+    tails: collectAdapterSessionStatusTails({
+      repoRoot,
+      tailLines: options.tailLines,
+    }),
+  });
+
+  const outputPath = resolve(process.cwd(), options.outFile);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, markdown, 'utf8');
+
+  process.stdout.write(
+    `adapter session status report generated at ${outputPath} (verdict=${verdict})\n`
+  );
+
+  return exitCodeForAdapterSessionVerdict(verdict);
+};
+
+process.exitCode = main();

package/scripts/build-consumer-startup-failure-support-bundle.ts

@@ -0,0 +1,22 @@
+import {
+  parseConsumerSupportBundleArgs,
+} from './consumer-startup-failure-support-bundle-lib';
+import {
+  buildConsumerSupportBundleReport,
+  writeConsumerSupportBundleReport,
+} from './consumer-support-bundle-runner-lib';
+
+const main = (): number => {
+  const options = parseConsumerSupportBundleArgs(process.argv.slice(2));
+  const markdown = buildConsumerSupportBundleReport(options);
+  const outputPath = writeConsumerSupportBundleReport({
+    markdown,
+    outFile: options.outFile,
+  });
+  process.stdout.write(
+    `consumer startup-failure support bundle generated at ${outputPath}\n`
+  );
+  return 0;
+};
+
+process.exitCode = main();

package/scripts/build-consumer-startup-triage-arg-flags-lib.ts

@@ -0,0 +1,26 @@
+import type { BuildConsumerStartupTriageCliOptions } from './build-consumer-startup-triage-contract';
+
+export type BuildConsumerStartupTriageFlagArg =
+  '--skip-workflow-lint'
+  | '--skip-auth-check'
+  | '--dry-run';
+
+export const isBuildConsumerStartupTriageFlagArg = (
+  arg: string
+): arg is BuildConsumerStartupTriageFlagArg =>
+  arg === '--skip-workflow-lint' || arg === '--skip-auth-check' || arg === '--dry-run';
+
+export const applyBuildConsumerStartupTriageFlagArg = (params: {
+  options: BuildConsumerStartupTriageCliOptions;
+  arg: BuildConsumerStartupTriageFlagArg;
+}): void => {
+  if (params.arg === '--skip-workflow-lint') {
+    params.options.runWorkflowLint = false;
+    return;
+  }
+  if (params.arg === '--skip-auth-check') {
+    params.options.includeAuthCheck = false;
+    return;
+  }
+  params.options.dryRun = true;
+};

package/scripts/build-consumer-startup-triage-arg-values-lib.ts

@@ -0,0 +1,45 @@
+import type { BuildConsumerStartupTriageCliOptions } from './build-consumer-startup-triage-contract';
+
+export type BuildConsumerStartupTriageValueArg =
+  | '--repo'
+  | '--limit'
+  | '--out-dir'
+  | '--repo-path'
+  | '--actionlint-bin';
+
+export const isBuildConsumerStartupTriageValueArg = (
+  arg: string
+): arg is BuildConsumerStartupTriageValueArg =>
+  arg === '--repo' ||
+  arg === '--limit' ||
+  arg === '--out-dir' ||
+  arg === '--repo-path' ||
+  arg === '--actionlint-bin';
+
+export const applyBuildConsumerStartupTriageValueArg = (params: {
+  options: BuildConsumerStartupTriageCliOptions;
+  arg: BuildConsumerStartupTriageValueArg;
+  value: string;
+}): void => {
+  if (params.arg === '--repo') {
+    params.options.repo = params.value;
+    return;
+  }
+  if (params.arg === '--limit') {
+    const parsed = Number.parseInt(params.value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(`Invalid --limit value: ${params.value}`);
+    }
+    params.options.limit = parsed;
+    return;
+  }
+  if (params.arg === '--out-dir') {
+    params.options.outDir = params.value;
+    return;
+  }
+  if (params.arg === '--repo-path') {
+    params.options.repoPath = params.value;
+    return;
+  }
+  params.options.actionlintBin = params.value;
+};

package/scripts/build-consumer-startup-triage-args-lib.ts

@@ -0,0 +1,59 @@
+import type { BuildConsumerStartupTriageCliOptions } from './build-consumer-startup-triage-contract';
+import { createDefaultBuildConsumerStartupTriageCliOptions } from './build-consumer-startup-triage-contract';
+import {
+  applyBuildConsumerStartupTriageFlagArg,
+  isBuildConsumerStartupTriageFlagArg,
+} from './build-consumer-startup-triage-arg-flags-lib';
+import {
+  applyBuildConsumerStartupTriageValueArg,
+  isBuildConsumerStartupTriageValueArg,
+} from './build-consumer-startup-triage-arg-values-lib';
+
+const readRequiredArgValue = (
+  args: ReadonlyArray<string>,
+  index: number,
+  option: string
+): string => {
+  const value = args[index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+};
+
+export const parseBuildConsumerStartupTriageArgs = (
+  args: ReadonlyArray<string>
+): BuildConsumerStartupTriageCliOptions => {
+  const options = createDefaultBuildConsumerStartupTriageCliOptions();
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (isBuildConsumerStartupTriageValueArg(arg)) {
+      const value = readRequiredArgValue(args, index, arg);
+      applyBuildConsumerStartupTriageValueArg({
+        options,
+        arg,
+        value,
+      });
+      index += 1;
+      continue;
+    }
+
+    if (isBuildConsumerStartupTriageFlagArg(arg)) {
+      applyBuildConsumerStartupTriageFlagArg({
+        options,
+        arg,
+      });
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (!options.repo) {
+    throw new Error('Missing required argument --repo <owner/repo>');
+  }
+
+  return options;
+};

package/scripts/build-consumer-startup-triage-contract.ts

@@ -0,0 +1,25 @@
+export type BuildConsumerStartupTriageCliOptions = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  includeAuthCheck: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+  dryRun: boolean;
+};
+
+export const DEFAULT_CONSUMER_STARTUP_TRIAGE_LIMIT = 20;
+export const DEFAULT_CONSUMER_STARTUP_TRIAGE_OUT_DIR = '.audit-reports/consumer-triage';
+
+export const createDefaultBuildConsumerStartupTriageCliOptions =
+  (): BuildConsumerStartupTriageCliOptions => {
+    return {
+      repo: '',
+      limit: DEFAULT_CONSUMER_STARTUP_TRIAGE_LIMIT,
+      outDir: DEFAULT_CONSUMER_STARTUP_TRIAGE_OUT_DIR,
+      runWorkflowLint: true,
+      includeAuthCheck: true,
+      dryRun: false,
+    };
+  };

package/scripts/build-consumer-startup-triage-runner-lib.ts

@@ -0,0 +1,59 @@
+import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import type {
+  ConsumerStartupTriageCommand,
+  ConsumerStartupTriageExecution,
+} from './consumer-startup-triage-lib';
+
+export const renderConsumerStartupTriageDryRunPlan = (
+  commands: ReadonlyArray<ConsumerStartupTriageCommand>
+): string => {
+  const lines = ['consumer startup triage dry-run plan:'];
+  for (const command of commands) {
+    lines.push(
+      `- ${command.id}: npx --yes tsx@4.21.0 ${command.script} ${command.args.join(' ')}`
+    );
+  }
+  return `${lines.join('\n')}\n`;
+};
+
+const resolveExecutionFailureStatus = (error: unknown): number => {
+  const status =
+    error && typeof error === 'object' && 'status' in error
+      ? Number((error as { status?: number }).status ?? 1)
+      : 1;
+  return Number.isFinite(status) ? status : 1;
+};
+
+const resolveExecutionFailureMessage = (error: unknown): string => {
+  return error instanceof Error ? error.message : 'unknown command failure';
+};
+
+export const executeConsumerStartupTriageCommands = (
+  commands: ReadonlyArray<ConsumerStartupTriageCommand>
+): ConsumerStartupTriageExecution[] => {
+  const executions: ConsumerStartupTriageExecution[] = [];
+
+  for (const command of commands) {
+    const scriptPath = resolve(process.cwd(), command.script);
+    try {
+      execFileSync('npx', ['--yes', 'tsx@4.21.0', scriptPath, ...command.args], {
+        stdio: 'inherit',
+      });
+      executions.push({
+        command,
+        exitCode: 0,
+        ok: true,
+      });
+    } catch (error) {
+      executions.push({
+        command,
+        exitCode: resolveExecutionFailureStatus(error),
+        ok: false,
+        error: resolveExecutionFailureMessage(error),
+      });
+    }
+  }
+
+  return executions;
+};

package/scripts/build-consumer-startup-triage.ts

@@ -0,0 +1,58 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseBuildConsumerStartupTriageArgs } from './build-consumer-startup-triage-args-lib';
+import {
+  executeConsumerStartupTriageCommands,
+  renderConsumerStartupTriageDryRunPlan,
+} from './build-consumer-startup-triage-runner-lib';
+import {
+  buildConsumerStartupTriageCommands,
+  buildConsumerStartupTriageReportMarkdown,
+  resolveConsumerStartupTriageOutputs,
+} from './consumer-startup-triage-lib';
+
+const main = (): number => {
+  const options = parseBuildConsumerStartupTriageArgs(process.argv.slice(2));
+  const commands = buildConsumerStartupTriageCommands({
+    repo: options.repo,
+    limit: options.limit,
+    outDir: options.outDir,
+    runWorkflowLint: options.runWorkflowLint,
+    includeAuthCheck: options.includeAuthCheck,
+    repoPath: options.repoPath,
+    actionlintBin: options.actionlintBin,
+  });
+
+  if (options.dryRun) {
+    process.stdout.write(renderConsumerStartupTriageDryRunPlan(commands));
+    return 0;
+  }
+
+  const executions = executeConsumerStartupTriageCommands(commands);
+  const outputs = resolveConsumerStartupTriageOutputs(options.outDir);
+  const report = buildConsumerStartupTriageReportMarkdown({
+    generatedAt: new Date().toISOString(),
+    repo: options.repo,
+    outDir: options.outDir,
+    commands,
+    executions,
+  });
+
+  const reportPath = resolve(process.cwd(), outputs.triageReport);
+  mkdirSync(dirname(reportPath), { recursive: true });
+  writeFileSync(reportPath, report, 'utf8');
+  process.stdout.write(`consumer startup triage report generated at ${reportPath}\n`);
+
+  const requiredFailures = executions.filter(
+    (execution) => execution.command.required && !execution.ok
+  );
+  return requiredFailures.length === 0 ? 0 : 1;
+};
+
+try {
+  process.exit(main());
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'unknown error';
+  process.stderr.write(`consumer startup triage failed: ${message}\n`);
+  process.exit(1);
+}

package/scripts/build-consumer-startup-unblock-status.ts

@@ -0,0 +1,34 @@
+import { parseConsumerStartupUnblockArgs } from './consumer-startup-unblock-cli-lib';
+import {
+  buildConsumerStartupUnblockReportFromOptions,
+  writeConsumerStartupUnblockReport,
+} from './consumer-startup-unblock-runner-lib';
+
+const main = (): number => {
+  const cwd = process.cwd();
+  const options = parseConsumerStartupUnblockArgs(process.argv.slice(2));
+
+  const report = buildConsumerStartupUnblockReportFromOptions({
+    cwd,
+    options,
+  });
+
+  const outputPath = writeConsumerStartupUnblockReport({
+    cwd,
+    outFile: options.outFile,
+    markdown: report.markdown,
+  });
+
+  process.stdout.write(
+    `consumer startup unblock status generated at ${outputPath} (verdict=${report.verdict})\n`
+  );
+  return 0;
+};
+
+try {
+  process.exit(main());
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'unknown error';
+  process.stderr.write(`consumer startup unblock status failed: ${message}\n`);
+  process.exit(1);
+}

package/scripts/build-consumer-support-ticket-draft.ts

@@ -0,0 +1,32 @@
+import { parseConsumerSupportTicketArgs } from './consumer-support-ticket-cli-lib';
+import {
+  buildConsumerSupportTicketDraftFromOptions,
+  writeConsumerSupportTicketDraft,
+} from './consumer-support-ticket-runner-lib';
+
+const main = (): number => {
+  const cwd = process.cwd();
+  const options = parseConsumerSupportTicketArgs(process.argv.slice(2));
+
+  const draft = buildConsumerSupportTicketDraftFromOptions({
+    cwd,
+    options,
+  });
+
+  const outputPath = writeConsumerSupportTicketDraft({
+    cwd,
+    outFile: options.outFile,
+    draft,
+  });
+
+  process.stdout.write(`consumer support ticket draft generated at ${outputPath}\n`);
+  return 0;
+};
+
+try {
+  process.exit(main());
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'unknown error';
+  process.stderr.write(`consumer support ticket draft failed: ${message}\n`);
+  process.exit(1);
+}

package/scripts/build-mock-consumer-ab-report.ts

@@ -0,0 +1,34 @@
+import { parseMockConsumerAbArgs } from './mock-consumer-ab-cli-lib';
+import {
+  buildMockConsumerAbReportFromOptions,
+  persistMockConsumerAbReport,
+} from './mock-consumer-ab-runner-lib';
+
+const main = (): number => {
+  try {
+    const options = parseMockConsumerAbArgs(process.argv.slice(2));
+    const report = buildMockConsumerAbReportFromOptions({
+      options,
+      generatedAt: new Date().toISOString(),
+    });
+
+    persistMockConsumerAbReport({
+      outFile: options.outFile,
+      markdown: report.markdown,
+      dryRun: options.dryRun,
+    });
+
+    const mode = options.dryRun ? 'dry-run' : 'write';
+    console.log(
+      `[build-mock-consumer-ab-report] ${mode} verdict=${report.verdict} out=${options.outFile}`
+    );
+
+    return report.verdict === 'READY' ? 0 : 1;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[build-mock-consumer-ab-report] error: ${message}`);
+    return 1;
+  }
+};
+
+process.exit(main());