effect-analyzer 0.1.0

package/scripts/diff-effect-scans.ts

@@ -0,0 +1,87 @@
+import { readFileSync } from 'fs';
+import { basename } from 'path';
+import type { ScanReport, ScanRow } from './effect-scan-utils';
+
+interface RowDelta {
+  readonly file: string;
+  readonly before?: string;
+  readonly after?: string;
+}
+
+function readJson(path: string): ScanReport {
+  return JSON.parse(readFileSync(path, 'utf8')) as ScanReport;
+}
+
+function rowMap(rows: readonly ScanRow[]): Map<string, ScanRow> {
+  return new Map(rows.map((r) => [r.file, r]));
+}
+
+function classifyDelta(before?: ScanRow, after?: ScanRow): 'added' | 'removed' | 'changed' | 'same' {
+  if (!before && after) return 'added';
+  if (before && !after) return 'removed';
+  if (!before || !after) return 'same';
+  return before.tag === after.tag ? 'same' : 'changed';
+}
+
+function main(): void {
+  const [beforePath, afterPath] = process.argv.slice(2);
+  if (!beforePath || !afterPath) {
+    console.error('usage: pnpm exec tsx scripts/diff-effect-scans.ts <before.json> <after.json>');
+    process.exit(1);
+  }
+
+  const before = readJson(beforePath);
+  const after = readJson(afterPath);
+  const beforeMap = rowMap(before.rows);
+  const afterMap = rowMap(after.rows);
+  const files = Array.from(new Set([...beforeMap.keys(), ...afterMap.keys()])).sort();
+
+  const added: RowDelta[] = [];
+  const removed: RowDelta[] = [];
+  const changed: RowDelta[] = [];
+  let improved = 0;
+  let regressed = 0;
+
+  for (const file of files) {
+    const b = beforeMap.get(file);
+    const a = afterMap.get(file);
+    const kind = classifyDelta(b, a);
+    if (kind === 'same') continue;
+    const delta: RowDelta = { file, before: b?.tag, after: a?.tag };
+    if (kind === 'added') added.push(delta);
+    else if (kind === 'removed') removed.push(delta);
+    else changed.push(delta);
+
+    if (b && a) {
+      if (b.tag.startsWith('FAIL:') && a.tag.startsWith('OK:')) improved++;
+      if (b.tag.startsWith('OK:') && a.tag.startsWith('FAIL:')) regressed++;
+    }
+  }
+
+  console.log(`before: ${basename(beforePath)} total=${before.summary.total} ok=${before.summary.ok} fail=${before.summary.fail} throw=${before.summary.throwCount}`);
+  console.log(`after:  ${basename(afterPath)} total=${after.summary.total} ok=${after.summary.ok} fail=${after.summary.fail} throw=${after.summary.throwCount}`);
+  console.log(`changed=${changed.length} added=${added.length} removed=${removed.length} improved=${improved} regressed=${regressed}`);
+
+  const limit = 40;
+  if (changed.length > 0) {
+    console.log('changed rows (sample):');
+    for (const d of changed.slice(0, limit)) {
+      console.log(`- ${basename(d.file)}: ${d.before} -> ${d.after}`);
+    }
+  }
+  if (added.length > 0) {
+    console.log('added rows (sample):');
+    for (const d of added.slice(0, 20)) {
+      console.log(`- ${basename(d.file)}: ${d.after}`);
+    }
+  }
+  if (removed.length > 0) {
+    console.log('removed rows (sample):');
+    for (const d of removed.slice(0, 20)) {
+      console.log(`- ${basename(d.file)}: ${d.before}`);
+    }
+  }
+}
+
+main();
+

package/scripts/effect-scan-utils.ts

@@ -0,0 +1,275 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { basename, join, resolve } from 'path';
+import { Effect } from 'effect';
+import { analyze } from '../src/analyze';
+
+export interface ScanRow {
+  readonly file: string;
+  readonly tag: string;
+  readonly info?: string;
+  readonly contains_effect_imports?: boolean;
+  readonly contains_effect_calls?: boolean;
+  readonly contains_top_level_program_candidate?: boolean;
+  readonly zeroProgramsReason?: ZeroProgramsReason;
+}
+
+export interface ScanSummary {
+  readonly total: number;
+  readonly ok: number;
+  readonly fail: number;
+  readonly throwCount: number;
+}
+
+export type ZeroProgramsReason =
+  | 'reexport_only_module'
+  | 'type_only_or_utility_module'
+  | 'state_adt_module'
+  | 'helper_functions_without_effect_program_roots'
+  | 'effect_family_type_references_only'
+  | 'unsupported_pattern'
+  | 'unknown';
+
+export interface ScanReport {
+  readonly effectRepoPath: string;
+  readonly summary: ScanSummary;
+  readonly rows: readonly ScanRow[];
+  readonly srcRoot?: string;
+  readonly internalsRoot?: string;
+  readonly filteredByEffectFamilyCalls?: boolean;
+}
+
+export const DEFAULT_EFFECT_REPO_PATH = '/Users/jagreehal/dev/js/awaitly/__temp/effect';
+
+export function getEffectRepoPath(): string {
+  return resolve(process.env.EFFECT_REPO_PATH ?? DEFAULT_EFFECT_REPO_PATH);
+}
+
+export function getEffectSrcRoot(effectRepoPath: string): string {
+  return join(effectRepoPath, 'packages', 'effect', 'src');
+}
+
+export function getEffectInternalsRoot(effectRepoPath: string): string {
+  return join(getEffectSrcRoot(effectRepoPath), 'internal');
+}
+
+export function listTopLevelTsFiles(dir: string): readonly string[] {
+  return readdirSync(dir)
+    .filter((name) => name.endsWith('.ts'))
+    .map((name) => join(dir, name))
+    .sort();
+}
+
+export function listTsFilesRecursive(dir: string): readonly string[] {
+  const out: string[] = [];
+  const visit = (current: string): void => {
+    for (const entry of readdirSync(current)) {
+      const full = join(current, entry);
+      const st = statSync(full);
+      if (st.isDirectory()) {
+        visit(full);
+      } else if (entry.endsWith('.ts')) {
+        out.push(full);
+      }
+    }
+  };
+  visit(dir);
+  out.sort();
+  return out;
+}
+
+export function containsEffectFamilyCalls(source: string): boolean {
+  return /\b(Effect|STM|Layer|Schedule|Stream|Channel|Sink|Cause|Exit|Fiber|Runtime)\./.test(source);
+}
+
+export function containsEffectFamilyImports(source: string): boolean {
+  return (
+    /\bfrom\s+["'](?:effect(?:["'/])|@effect\/)/.test(source) ||
+    /\bfrom\s+["'][^"']*(?:^|\/)(?:Effect|STM|Layer|Schedule|Stream|Channel|Sink|Cause|Exit|Fiber|Runtime)(?:\.[jt]sx?)?["']/.test(source)
+  );
+}
+
+export function containsEffectFamilyInvocations(source: string): boolean {
+  return /\b(Effect|STM|Layer|Schedule|Stream|Channel|Sink|Cause|Exit|Fiber|Runtime)\.[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(source);
+}
+
+export function containsProgramRootFamilyInvocations(source: string): boolean {
+  return /\b(Effect|STM|Layer|Schedule|Stream|Channel|Sink)\.[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(source);
+}
+
+function classifyZeroProgramsReason(source: string): ZeroProgramsReason {
+  const hasReexportFrom =
+    /export\s+\*\s+from\s+["'][^"']+["']/.test(source) ||
+    /export\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["']/.test(source);
+  const hasReexportOnly =
+    hasReexportFrom &&
+    !/export\s+const\s+/.test(source) &&
+    !/export\s+function\s+/.test(source) &&
+    !/export\s+class\s+/.test(source) &&
+    !/export\s+(interface|type)\s+/.test(source);
+  if (hasReexportOnly) return 'reexport_only_module';
+
+  const hasExportConst = /export\s+const\s+/.test(source);
+  const hasExportFn = /export\s+function\s+/.test(source);
+  const hasExportClass = /export\s+class\s+/.test(source);
+  const hasExportTypeLike = /export\s+(interface|type)\s+/.test(source);
+  const hasEffectCalls = containsEffectFamilyCalls(source);
+  const hasEffectInvocations = containsEffectFamilyInvocations(source);
+  const hasProgramRootInvocations = containsProgramRootFamilyInvocations(source);
+  const hasClassOrInterface = /\b(class|interface)\s+[A-Za-z_]/.test(source);
+  const hasPrototypeOrMethods =
+    /\b(readonly\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*.*=>)|\b[A-Za-z_][A-Za-z0-9_]*\s*\([^)]*\)\s*\{/.test(source);
+
+  if (!hasEffectCalls) {
+    if (hasExportTypeLike || /import\s+type\s+/.test(source)) {
+      return 'type_only_or_utility_module';
+    }
+    if (hasExportConst || hasExportFn || hasExportClass) {
+      return 'helper_functions_without_effect_program_roots';
+    }
+    return 'unknown';
+  }
+
+  if (!hasEffectInvocations) {
+    if (hasClassOrInterface || hasExportTypeLike) {
+      return 'state_adt_module';
+    }
+    return 'effect_family_type_references_only';
+  }
+
+  if (!hasProgramRootInvocations) {
+    if (hasClassOrInterface || hasExportTypeLike) {
+      return 'state_adt_module';
+    }
+    return 'helper_functions_without_effect_program_roots';
+  }
+
+  if (hasExportTypeLike && !hasExportConst && !hasExportFn && !hasExportClass) {
+    return 'state_adt_module';
+  }
+
+  if (hasClassOrInterface || hasPrototypeOrMethods) {
+    return 'unsupported_pattern';
+  }
+
+  if (hasExportConst || hasExportFn || hasExportClass) {
+    return 'unsupported_pattern';
+  }
+
+  return 'unknown';
+}
+
+export async function analyzeFileToRow(
+  filePath: string,
+  knownEffectInternalsRoot: string,
+  maxNames = 8,
+): Promise<ScanRow> {
+  const source = readFileUtf8(filePath);
+  const fileSignals = {
+    contains_effect_imports: containsEffectFamilyImports(source),
+    contains_effect_calls: containsEffectFamilyInvocations(source),
+    contains_top_level_program_candidate: containsProgramRootFamilyInvocations(source),
+  } as const;
+
+  try {
+    const res = await Effect.runPromiseExit(
+      analyze(filePath, { knownEffectInternalsRoot }).all(),
+    );
+
+    if (res._tag === 'Failure') {
+      const cause = res.cause as unknown as {
+        _tag?: string;
+        error?: { code?: string };
+        failure?: { code?: string };
+      };
+      const code =
+        cause?._tag === 'Fail'
+          ? (cause.error?.code ?? cause.failure?.code ?? 'unknown')
+          : (cause?._tag ?? 'unknown');
+      const tag = `FAIL:${String(code)}`;
+      if (tag === 'FAIL:NO_EFFECTS_FOUND') {
+        return {
+          file: filePath,
+          tag,
+          ...fileSignals,
+          zeroProgramsReason: classifyZeroProgramsReason(source),
+        };
+      }
+      return { file: filePath, tag, ...fileSignals };
+    }
+
+    const names = res.value.map((ir) => ir.root.programName);
+    return {
+      file: filePath,
+      tag: `OK:${res.value.length}`,
+      info: names.slice(0, maxNames).join(','),
+      ...fileSignals,
+    };
+  } catch (error) {
+    return {
+      file: filePath,
+      tag: 'THROW',
+      info: String(error),
+      ...fileSignals,
+    };
+  }
+}
+
+export function summarizeRows(rows: readonly ScanRow[]): ScanSummary {
+  let ok = 0;
+  let fail = 0;
+  let throwCount = 0;
+  for (const row of rows) {
+    if (row.tag.startsWith('OK:')) ok++;
+    else if (row.tag.startsWith('FAIL:')) fail++;
+    else if (row.tag === 'THROW') throwCount++;
+  }
+  return {
+    total: rows.length,
+    ok,
+    fail,
+    throwCount,
+  };
+}
+
+export function printHumanSummary(label: string, rows: readonly ScanRow[]): void {
+  const summary = summarizeRows(rows);
+  console.log(`${label}: total=${summary.total} ok=${summary.ok} fail=${summary.fail} throw=${summary.throwCount}`);
+  const reasonCounts = new Map<string, number>();
+  for (const row of rows) {
+    if (!row.zeroProgramsReason) continue;
+    reasonCounts.set(row.zeroProgramsReason, (reasonCounts.get(row.zeroProgramsReason) ?? 0) + 1);
+  }
+  if (reasonCounts.size > 0) {
+    const ordered = Array.from(reasonCounts.entries()).sort((a, b) => b[1] - a[1]);
+    console.log(`${label} zeroProgramsReason counts:`);
+    for (const [reason, count] of ordered) {
+      console.log(`- ${reason}: ${count}`);
+    }
+  }
+  const examples = rows.filter((r) => !r.tag.startsWith('OK:')).slice(0, 15);
+  if (examples.length > 0) {
+    console.log(`${label} failures (sample):`);
+    for (const row of examples) {
+      const reason = row.zeroProgramsReason ? ` (${row.zeroProgramsReason})` : '';
+      console.log(`- ${basename(row.file)} ${row.tag}${reason}`);
+    }
+  }
+}
+
+export function readFileUtf8(path: string): string {
+  return readFileSync(path, 'utf8');
+}
+
+export function writeJsonFile(path: string, value: unknown): void {
+  const resolved = resolve(path);
+  mkdirSync(resolve(resolved, '..'), { recursive: true });
+  writeFileSync(resolved, JSON.stringify(value, null, 2));
+}
+
+export function getArgValue(flag: string): string | undefined {
+  const idx = process.argv.indexOf(flag);
+  if (idx === -1) return undefined;
+  const next = process.argv[idx + 1];
+  if (!next || next.startsWith('--')) return undefined;
+  return next;
+}

package/scripts/eslint-rules/no-inline-type-import.js

@@ -0,0 +1,39 @@
+/**
+ * ESLint rule: ban inline type assertions like `x as import('module').Type`.
+ * Use a named type import at the top instead.
+ */
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        "Disallow inline type assertions using import() (e.g. `x as import('ts-morph').Node`). Use a named type import at the top of the file instead.",
+    },
+    schema: [],
+    messages: {
+      useNamedImport:
+        "Use a named type import instead of inline 'as import(...)'. Example: import type { TypeName } from 'module'; ... x as TypeName",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      Program(node) {
+        const text = sourceCode.getText(node);
+        const pattern = /\s+as\s+import\s*\(/g;
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+          const index = match.index;
+          const line = text.slice(0, index).split('\n').length;
+          const lineStart = text.lastIndexOf('\n', index);
+          const column = index - lineStart - 1;
+          context.report({
+            node,
+            loc: { start: { line, column }, end: { line, column: column + match[0].length } },
+            messageId: 'useNamedImport',
+          });
+        }
+      },
+    };
+  },
+};

package/scripts/fetch-effect-repo.ts

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { execFileSync } from 'child_process';
+
+const DEFAULT_REPO_URL = 'https://github.com/Effect-TS/effect.git';
+const DEFAULT_DEST = resolve('.cache/effect-repo');
+const DEFAULT_REF = 'main';
+
+function getArgValue(flag: string): string | undefined {
+  const idx = process.argv.indexOf(flag);
+  if (idx === -1) return undefined;
+  const next = process.argv[idx + 1];
+  if (!next || next.startsWith('--')) return undefined;
+  return next;
+}
+
+function hasFlag(flag: string): boolean {
+  return process.argv.includes(flag);
+}
+
+function runGit(args: readonly string[]): void {
+  execFileSync('git', [...args], { stdio: 'inherit' });
+}
+
+function main(): void {
+  const repoUrl = getArgValue('--repo-url') ?? process.env.EFFECT_REPO_URL ?? DEFAULT_REPO_URL;
+  const dest = resolve(getArgValue('--dir') ?? process.env.EFFECT_REPO_PATH ?? DEFAULT_DEST);
+  const ref = getArgValue('--ref') ?? process.env.EFFECT_REPO_REF ?? DEFAULT_REF;
+  const force = hasFlag('--force');
+
+  if (force && existsSync(dest)) {
+    rmSync(dest, { recursive: true, force: true });
+  }
+
+  mkdirSync(dirname(dest), { recursive: true });
+
+  if (!existsSync(dest)) {
+    runGit(['clone', '--depth', '1', '--branch', ref, repoUrl, dest]);
+  } else if (existsSync(resolve(dest, '.git'))) {
+    runGit(['-C', dest, 'fetch', '--depth', '1', 'origin', ref]);
+    runGit(['-C', dest, 'checkout', '--force', 'FETCH_HEAD']);
+  } else {
+    throw new Error(`Destination exists and is not a git repo: ${dest}`);
+  }
+
+  // Print export hints so callers can reuse the fetched clone.
+  console.log(`EFFECT_REPO_PATH=${dest}`);
+  console.log(`EFFECT_AUDIT_DIR=${resolve(dest, 'packages')}`);
+  console.log(`KNOWN_EFFECT_INTERNALS_ROOT=${resolve(dest, 'packages/effect/src/internal')}`);
+}
+
+main();

package/scripts/openapi-runtime-runner.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Runtime OpenAPI generator - runs OpenApi.fromApi on a user's HttpApi.
+ * Usage: npx tsx openapi-runtime-runner.mjs <entrypoint> [exportName] [--output file.json]
+ *
+ * Requires: @effect/platform, tsx (for .ts files)
+ * Run with: npx tsx openapi-runtime-runner.mjs ./src/api.ts TodoApi
+ *
+ * Must be run with cwd = project root (so @effect/platform resolves from project's node_modules).
+ */
+
+import { resolve, join } from 'path';
+import { pathToFileURL } from 'url';
+import { createRequire } from 'module';
+import { writeFileSync } from 'fs';
+
+const args = process.argv.slice(2);
+const outputIdx = args.indexOf('--output');
+const outputFile = outputIdx >= 0 ? args[outputIdx + 1] : null;
+if (outputIdx >= 0) args.splice(outputIdx, 2);
+const [entrypoint, exportName = 'default'] = args;
+
+if (!entrypoint) {
+  console.error('Usage: npx tsx openapi-runtime-runner.mjs <entrypoint> [exportName] [--output file.json]');
+  console.error('Example: npx tsx openapi-runtime-runner.mjs ./src/api.ts TodoApi -o openapi.json');
+  process.exit(1);
+}
+
+async function main() {
+  let OpenApi;
+  try {
+    const require = createRequire(join(process.cwd(), 'package.json'));
+    const platform = require('@effect/platform');
+    OpenApi = platform.OpenApi;
+  } catch (e) {
+    console.error('Error: @effect/platform is required for runtime OpenAPI generation.');
+    console.error('Install it: pnpm add @effect/platform');
+    if (e?.message) console.error('Details:', e.message);
+    process.exit(1);
+  }
+
+  const absPath = entrypoint.startsWith('/') || /^[A-Za-z]:/.test(entrypoint)
+    ? entrypoint
+    : resolve(process.cwd(), entrypoint);
+  const mod = await import(pathToFileURL(absPath).href);
+  const api = mod[exportName] ?? mod.default;
+  if (!api) {
+    console.error(`Error: No export "${exportName}" found in ${entrypoint}`);
+    process.exit(1);
+  }
+
+  const spec = OpenApi.fromApi(api);
+  const json = JSON.stringify(spec, null, 2);
+
+  if (outputFile) {
+    writeFileSync(outputFile, json, 'utf8');
+    console.error(`Wrote OpenAPI spec to ${outputFile}`);
+  } else {
+    console.log(json);
+  }
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/scripts/scan-effect-internals.ts

@@ -0,0 +1,53 @@
+import {
+  analyzeFileToRow,
+  containsEffectFamilyCalls,
+  getArgValue,
+  getEffectInternalsRoot,
+  getEffectRepoPath,
+  listTsFilesRecursive,
+  printHumanSummary,
+  readFileUtf8,
+  summarizeRows,
+  writeJsonFile,
+} from './effect-scan-utils';
+
+async function main(): Promise<void> {
+  const effectRepoPath = getEffectRepoPath();
+  const internalsRoot = getEffectInternalsRoot(effectRepoPath);
+  const allFiles = listTsFilesRecursive(internalsRoot);
+  const files = allFiles.filter((file) => containsEffectFamilyCalls(readFileUtf8(file)));
+
+  const rows = [];
+  for (const file of files) {
+    rows.push(await analyzeFileToRow(file, internalsRoot, 4));
+  }
+
+  const report = {
+    effectRepoPath,
+    internalsRoot,
+    filteredByEffectFamilyCalls: true,
+    summary: summarizeRows(rows),
+    rows,
+  } as const;
+
+  if (process.argv.includes('--human')) {
+    printHumanSummary('effect-internals', rows);
+  }
+
+  const jsonOut = getArgValue('--json-out');
+  if (jsonOut) {
+    writeJsonFile(jsonOut, report);
+    if (process.argv.includes('--human')) {
+      console.log(`wrote ${jsonOut}`);
+      return;
+    }
+  }
+
+  if (process.argv.includes('--human')) {
+    return;
+  }
+
+  console.log(JSON.stringify(report, null, 2));
+}
+
+void main();

package/scripts/scan-effect-top-level.ts

@@ -0,0 +1,52 @@
+import {
+  analyzeFileToRow,
+  getArgValue,
+  getEffectInternalsRoot,
+  getEffectRepoPath,
+  getEffectSrcRoot,
+  listTopLevelTsFiles,
+  printHumanSummary,
+  summarizeRows,
+  writeJsonFile,
+} from './effect-scan-utils';
+
+async function main(): Promise<void> {
+  const effectRepoPath = getEffectRepoPath();
+  const srcRoot = getEffectSrcRoot(effectRepoPath);
+  const internalsRoot = getEffectInternalsRoot(effectRepoPath);
+  const files = listTopLevelTsFiles(srcRoot);
+
+  const rows = [];
+  for (const file of files) {
+    rows.push(await analyzeFileToRow(file, internalsRoot, 8));
+  }
+
+  const report = {
+    effectRepoPath,
+    srcRoot,
+    internalsRoot,
+    summary: summarizeRows(rows),
+    rows,
+  } as const;
+
+  if (process.argv.includes('--human')) {
+    printHumanSummary('effect-top-level', rows);
+  }
+
+  const jsonOut = getArgValue('--json-out');
+  if (jsonOut) {
+    writeJsonFile(jsonOut, report);
+    if (process.argv.includes('--human')) {
+      console.log(`wrote ${jsonOut}`);
+      return;
+    }
+  }
+
+  if (process.argv.includes('--human')) {
+    return;
+  }
+
+  console.log(JSON.stringify(report, null, 2));
+}
+
+void main();

package/scripts/summarize-scan.ts

@@ -0,0 +1,47 @@
+import { readFileSync } from 'fs';
+import { basename } from 'path';
+import type { ScanReport } from './effect-scan-utils';
+
+function main(): void {
+  const reportPath = process.argv[2];
+  if (!reportPath) {
+    console.error('usage: pnpm exec tsx scripts/summarize-scan.ts <scan.json> [--limit N]');
+    process.exit(1);
+  }
+
+  const limitArgIndex = process.argv.indexOf('--limit');
+  const limit =
+    limitArgIndex >= 0 && process.argv[limitArgIndex + 1]
+      ? Number.parseInt(process.argv[limitArgIndex + 1]!, 10)
+      : 15;
+
+  const report = JSON.parse(readFileSync(reportPath, 'utf8')) as ScanReport;
+
+  console.log(
+    `${basename(reportPath)} total=${report.summary.total} ok=${report.summary.ok} fail=${report.summary.fail} throw=${report.summary.throwCount}`,
+  );
+
+  const reasonCounts = new Map<string, number>();
+  for (const row of report.rows) {
+    if (!row.zeroProgramsReason) continue;
+    reasonCounts.set(row.zeroProgramsReason, (reasonCounts.get(row.zeroProgramsReason) ?? 0) + 1);
+  }
+
+  if (reasonCounts.size > 0) {
+    console.log('zeroProgramsReason counts:');
+    for (const [reason, count] of Array.from(reasonCounts.entries()).sort((a, b) => b[1] - a[1])) {
+      console.log(`- ${reason}: ${count}`);
+    }
+  }
+
+  const nonOk = report.rows.filter((row) => !row.tag.startsWith('OK:'));
+  if (nonOk.length > 0) {
+    console.log(`non-OK rows (sample ${Math.min(limit, nonOk.length)}):`);
+    for (const row of nonOk.slice(0, Math.max(1, limit))) {
+      const reason = row.zeroProgramsReason ? ` (${row.zeroProgramsReason})` : '';
+      console.log(`- ${basename(row.file)} ${row.tag}${reason}`);
+    }
+  }
+}
+
+main();