@jamie-tam/forge 6.0.0

package/skills/support-runtime-reachability/scripts/check.mjs

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+// Runtime reachability check (v5.0).
+// Walks the slice-diff files, identifies top-level exports, and searches the
+// codebase for production callers + escape-hatch annotations. Outputs JSON to
+// stdout. Manifest cross-check (validating gated-pending against slice_graph)
+// is the agent's job, not the script's.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ---- Defaults --------------------------------------------------------------
+
+const DEFAULT_TEST_GLOBS = [
+  '**/*.test.*',
+  '**/*.spec.*',
+  '**/__tests__/**',
+  '**/tests/**',
+  '**/e2e/**',
+  '**/cypress/**',
+  '**/__fixtures__/**',
+];
+
+const DEFAULT_IGNORE_DIRS = new Set([
+  'node_modules',
+  'dist',
+  'build',
+  '.git',
+  'coverage',
+  '.next',
+  '.nuxt',
+  '.svelte-kit',
+  '.cache',
+  '.turbo',
+]);
+
+const TSJS_EXT = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+const PY_EXT = /\.py$/;
+
+// ---- Public API ------------------------------------------------------------
+
+export function check({ files, root, testGlobs }) {
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new Error('files must be a non-empty array');
+  }
+  if (typeof root !== 'string') throw new Error('root must be a string');
+
+  const tg = testGlobs ?? DEFAULT_TEST_GLOBS;
+  const exports = [];
+
+  // Index codebase files once (reused across all exports).
+  const codebaseFiles = [...walkFiles(root)];
+
+  for (const relFile of files) {
+    const absFile = path.join(root, relFile);
+    if (!fs.existsSync(absFile)) continue;
+    const content = readSafe(absFile);
+    const lang = detectLanguage(relFile);
+    if (!lang) continue;
+
+    const fileExports = parseExports(content, lang, relFile);
+    for (const exp of fileExports) {
+      const annotation = findAnnotation(content, exp.line, lang);
+      const callers = findCallers({
+        name: exp.name,
+        kind: exp.kind,
+        lang,
+        ownerFile: relFile,
+        codebaseFiles,
+        root,
+      });
+      const production = callers.filter((c) => !isTestFile(c.file, tg));
+      const test = callers.filter((c) => isTestFile(c.file, tg));
+      exports.push({
+        name: exp.name,
+        file: relFile,
+        line: exp.line,
+        kind: exp.kind,
+        annotation,
+        production_callers: production,
+        test_callers: test,
+      });
+    }
+  }
+
+  const stats = {
+    files_checked: files.length,
+    exports_found: exports.length,
+    orphans_unannotated: exports.filter(
+      (e) => e.production_callers.length === 0 && e.annotation === null,
+    ).length,
+    annotated: exports.filter((e) => e.annotation !== null).length,
+  };
+
+  return { exports, stats };
+}
+
+// ---- Language detection ----------------------------------------------------
+
+function detectLanguage(file) {
+  if (TSJS_EXT.test(file)) return 'tsjs';
+  if (PY_EXT.test(file)) return 'py';
+  return null;
+}
+
+// ---- Export parsing --------------------------------------------------------
+
+function parseExports(content, lang, file) {
+  const lines = content.split('\n');
+  const out = [];
+
+  if (lang === 'tsjs') {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Skip type-only exports.
+      if (/^\s*export\s+(type|interface|enum)\s/.test(line)) continue;
+
+      let m;
+      // export (async) function NAME
+      if ((m = /^\s*export\s+(?:async\s+)?function\s+(\w+)/.exec(line))) {
+        out.push({ name: m[1], line: i + 1, kind: 'function' });
+        continue;
+      }
+      // export (abstract) class NAME
+      if ((m = /^\s*export\s+(?:abstract\s+)?class\s+(\w+)/.exec(line))) {
+        // Skip if this is "export default class NAME" (handled below).
+        if (/^\s*export\s+default\s/.test(line)) continue;
+        out.push({ name: m[1], line: i + 1, kind: 'class' });
+        continue;
+      }
+      // export const|let|var NAME =
+      if ((m = /^\s*export\s+(?:const|let|var)\s+(\w+)/.exec(line))) {
+        out.push({ name: m[1], line: i + 1, kind: 'const' });
+        continue;
+      }
+      // export default function NAME
+      if ((m = /^\s*export\s+default\s+(?:async\s+)?function\s+(\w+)/.exec(line))) {
+        out.push({ name: m[1], line: i + 1, kind: 'default' });
+        continue;
+      }
+      // export default class NAME
+      if ((m = /^\s*export\s+default\s+(?:abstract\s+)?class\s+(\w+)/.exec(line))) {
+        out.push({ name: m[1], line: i + 1, kind: 'default' });
+        continue;
+      }
+      // export default <anonymous expression> — name from filename
+      if (/^\s*export\s+default\s/.test(line)) {
+        const stem = path.basename(file).replace(/\.[^.]+$/, '');
+        out.push({ name: stem, line: i + 1, kind: 'default' });
+        continue;
+      }
+
+      // export { foo, bar as baz, qux } [from '...']
+      if ((m = /^\s*export\s+\{\s*([^}]+)\s*\}/.exec(line))) {
+        for (const item of m[1].split(',')) {
+          const parts = item.trim().split(/\s+as\s+/);
+          // Externally-visible name is the alias (right side of `as`) or the only token.
+          const externalName = (parts[1] ?? parts[0]).trim();
+          if (!externalName || !/^\w+$/.test(externalName)) continue;
+          out.push({ name: externalName, line: i + 1, kind: 'reexport' });
+        }
+        continue;
+      }
+    }
+  } else if (lang === 'py') {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let m;
+      // Top-level def NAME (no leading whitespace)
+      if ((m = /^(?:async\s+)?def\s+(\w+)\s*\(/.exec(line))) {
+        if (m[1].startsWith('_')) continue;
+        out.push({ name: m[1], line: i + 1, kind: 'def' });
+        continue;
+      }
+      // Top-level class NAME
+      if ((m = /^class\s+(\w+)/.exec(line))) {
+        if (m[1].startsWith('_')) continue;
+        out.push({ name: m[1], line: i + 1, kind: 'pyclass' });
+        continue;
+      }
+    }
+  }
+
+  return out;
+}
+
+// ---- Annotation parsing ----------------------------------------------------
+
+const ANNOTATION_PATTERN = /(gated-pending|untraceable)\s*:\s*(.*)$/;
+
+function findAnnotation(content, exportLine, lang) {
+  const lines = content.split('\n');
+  const exportIdx = exportLine - 1;
+  const lineCommentPrefix = lang === 'py' ? '#' : '//';
+
+  // Trailing comment on the export line itself.
+  const trailingMatch = matchInComment(lines[exportIdx], lineCommentPrefix);
+  if (trailingMatch) return trailingMatch;
+
+  // Walk preceding consecutive comment lines.
+  for (let i = exportIdx - 1; i >= 0; i--) {
+    const line = lines[i].trimEnd();
+    if (line === '') return null; // blank line breaks the comment block
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith(lineCommentPrefix)) return null;
+    const m = matchInComment(line, lineCommentPrefix);
+    if (m) return m;
+  }
+  return null;
+}
+
+function matchInComment(line, prefix) {
+  if (!line) return null;
+  const idx = line.indexOf(prefix);
+  if (idx < 0) return null;
+  const tail = line.slice(idx + prefix.length).trim();
+  const m = ANNOTATION_PATTERN.exec(tail);
+  if (!m) return null;
+  return { kind: m[1], value: m[2].trim(), raw: line.slice(idx).trim() };
+}
+
+// ---- Caller search ---------------------------------------------------------
+
+function findCallers({ name, kind, lang, ownerFile, codebaseFiles, root }) {
+  const callers = [];
+  const ownerAbs = path.resolve(root, ownerFile);
+  const ownerStem = path.basename(ownerFile).replace(/\.[^.]+$/, '');
+
+  // For "default" exports, we treat the name as the file stem; production callers
+  // are import-default lines (`import X from '...'`) plus subsequent invocations.
+  // The script reports any "import default from ownerFile" caller as a usage hit.
+
+  for (const candidate of codebaseFiles) {
+    if (path.resolve(candidate) === ownerAbs) continue;
+    const candLang = detectLanguage(candidate);
+    if (!candLang) continue;
+    if (lang !== candLang) continue; // don't mix TS callers with Python exports
+
+    const content = readSafe(candidate);
+    if (!content) continue;
+
+    const relCandidate = path.relative(root, candidate);
+
+    // FP mitigation: require the candidate to import the export name (with
+    // path provenance) before counting callers. Track local names so aliased
+    // imports (`import { foo as bar }; bar()`) match the alias usage.
+    let locals;
+    if (kind === 'default') {
+      const localName = findDefaultImportLocal(content, ownerAbs, candidate, root);
+      locals = localName ? [localName] : [];
+    } else {
+      locals = findImportLocals(content, name, candLang, ownerAbs, candidate, root);
+    }
+
+    if (locals.length === 0) {
+      // Accept downstream re-exports as a usage signal: `export { name } from '<path-to-owner>'`.
+      if (candLang === 'tsjs' && hasReExportFrom(content, name, ownerAbs, candidate, root)) {
+        callers.push({ file: relCandidate, line: lineOfReExport(content, name), pattern: 're-export' });
+      }
+      continue;
+    }
+
+    const hits = scanCallerPatternsForLocals(content, locals, candLang);
+    for (const h of hits) callers.push({ file: relCandidate, line: h.line, pattern: h.pattern });
+  }
+
+  return callers;
+}
+
+function findImportLocals(content, name, lang, ownerAbs, candidateAbs, root) {
+  // Returns array of local names used in the caller for the export `name`
+  // from `ownerAbs`. Empty if the caller doesn't import the export. Path-like
+  // specifiers (relative/absolute) must resolve to ownerAbs (FP mitigation);
+  // bare specifiers (`react`, `@org/pkg`, path aliases) trust the name.
+  // Namespace imports return synthetic `ns.name` locals for downstream scanning.
+  const locals = new Set();
+
+  if (lang === 'py') {
+    const fromImport = /^\s*from\s+([\w.]+)\s+import\s+([^\n#]+)/gm;
+    let m;
+    while ((m = fromImport.exec(content)) !== null) {
+      const mod = m[1];
+      if (mod.startsWith('.')) {
+        const resolved = resolvePyModule(path.dirname(candidateAbs), mod);
+        if (!resolved || !pathEqualish(resolved, ownerAbs)) continue;
+      }
+      for (const raw of m[2].split(',')) {
+        const item = raw.trim().replace(/[()\\]/g, '');
+        if (!item) continue;
+        const parts = item.split(/\s+as\s+/);
+        if (parts[0].trim() === name) locals.add((parts[1] ?? parts[0]).trim());
+      }
+    }
+    // `import <module>` (no path resolution for v5.0); add namespaced access form.
+    const importMod = /^\s*import\s+([\w.]+)(?:\s+as\s+(\w+))?/gm;
+    while ((m = importMod.exec(content)) !== null) {
+      const tail = m[1].split('.').pop();
+      const alias = m[2] ?? tail;
+      // Heuristic: if `alias.name` appears anywhere, it's a usage — emit synthetic local.
+      const access = new RegExp(`\\b${escapeRe(alias)}\\.${escapeRe(name)}\\b`);
+      if (access.test(content)) locals.add(`${alias}.${name}`);
+    }
+    return [...locals];
+  }
+
+  // TS/JS:
+  // Match `import { ... } from '...'` and `import x, { ... } from '...'` (mixed default+named).
+  const importBlock =
+    /import\s+(?:\w+\s*,\s*)?(?:type\s*)?\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = importBlock.exec(content)) !== null) {
+    const importPath = m[2];
+    if (!importTargetsOwner(importPath, candidateAbs, root, ownerAbs)) continue;
+    for (const item of m[1].split(',')) {
+      const parts = item.trim().split(/\s+as\s+/);
+      const importedName = parts[0].trim();
+      const localName = (parts[1] ?? parts[0]).trim();
+      if (importedName === name) locals.add(localName);
+    }
+  }
+  const ns = /import\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
+  while ((m = ns.exec(content)) !== null) {
+    const importPath = m[2];
+    if (!importTargetsOwner(importPath, candidateAbs, root, ownerAbs)) continue;
+    const nsName = m[1];
+    const access = new RegExp(`\\b${escapeRe(nsName)}\\.${escapeRe(name)}\\b`);
+    if (access.test(content)) locals.add(`${nsName}.${name}`);
+  }
+  return [...locals];
+}
+
+function importTargetsOwner(importPath, candidateAbs, root, ownerAbs) {
+  // Returns true when this import is plausibly bringing in the export from
+  // ownerAbs. Two cases return true:
+  //   1. Path-like specifier (relative or absolute) that resolves to ownerAbs.
+  //   2. Bare specifier (`react`, `@org/pkg`, path aliases like `@/`) — we
+  //      cannot resolve it here, so we TRUST the name match. This trades a
+  //      tiny FP risk (two unrelated bare modules with the same export name)
+  //      for FP-orphan-free behavior on aliased projects (much more common).
+  // Path-like specifiers that DON'T resolve to ownerAbs return false — this
+  // is the case-19 fix (same name imported from a different relative module).
+  if (importPath.startsWith('.') || path.isAbsolute(importPath)) {
+    const resolved = resolveImport(path.dirname(candidateAbs), importPath);
+    return Boolean(resolved && pathEqualish(resolved, ownerAbs));
+  }
+  return true;
+}
+
+function resolvePyModule(fromDir, mod) {
+  // `.lib` -> ./lib.py or ./lib/__init__.py; `..lib` -> ../lib.py
+  let dots = 0;
+  while (dots < mod.length && mod[dots] === '.') dots++;
+  const rest = mod.slice(dots);
+  let target = fromDir;
+  for (let i = 1; i < dots; i++) target = path.dirname(target);
+  const segments = rest.split('.').filter(Boolean);
+  const base = path.join(target, ...segments);
+  for (const candidate of [base + '.py', path.join(base, '__init__.py')]) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+
+function hasReExportFrom(content, name, ownerAbs, candidateAbs, root) {
+  // Catch `export { name } from '<path>'` where <path> resolves to ownerAbs.
+  const re = /export\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const importPath = m[2];
+    if (!importTargetsOwner(importPath, candidateAbs, root, ownerAbs)) continue;
+    for (const item of m[1].split(',')) {
+      const parts = item.trim().split(/\s+as\s+/);
+      const original = parts[0].trim();
+      if (original === name) return true;
+    }
+  }
+  return false;
+}
+
+function lineOfReExport(content, name) {
+  const lines = content.split('\n');
+  const re = /export\s*\{([^}]+)\}/;
+  for (let i = 0; i < lines.length; i++) {
+    const m = re.exec(lines[i]);
+    if (!m) continue;
+    if (m[1].split(',').some((it) => it.trim().split(/\s+as\s+/)[0].trim() === name)) {
+      return i + 1;
+    }
+  }
+  return 0;
+}
+
+function findDefaultImportLocal(content, ownerAbs, candidatePath, root) {
+  // Find `import LOCAL from '<path>'` or `import LOCAL, { ... } from '<path>'`
+  // where path resolves to ownerAbs.
+  const re = /import\s+(\w+)(?:\s*,\s*\{[^}]*\})?\s+from\s*['"]([^'"]+)['"]/g;
+  let m;
+  const candidateAbs = path.resolve(root, candidatePath);
+  while ((m = re.exec(content)) !== null) {
+    const localName = m[1];
+    const importPath = m[2];
+    if (!importPath.startsWith('.') && !path.isAbsolute(importPath)) continue;
+    const resolved = resolveImport(path.dirname(candidateAbs), importPath);
+    if (resolved && pathEqualish(resolved, ownerAbs)) return localName;
+  }
+  return null;
+}
+
+function resolveImport(fromDir, importPath) {
+  const exts = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '/index.ts', '/index.tsx', '/index.js', '/index.jsx'];
+  const base = path.resolve(fromDir, importPath);
+  for (const ext of exts) {
+    const candidate = base + ext;
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+
+function pathEqualish(a, b) {
+  // Compare with extension stripped (TS allows extensionless imports).
+  const strip = (p) => p.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, '');
+  return strip(path.resolve(a)) === strip(path.resolve(b));
+}
+
+function scanCallerPatternsForLocals(content, locals, lang) {
+  const hits = [];
+  if (locals.length === 0) return hits;
+  const lines = content.split('\n');
+  const commentPrefix = lang === 'py' ? '#' : '//';
+
+  // Build patterns per local name. A local containing '.' is a namespace
+  // access (e.g. `ns.foo` from `import * as ns`); JSX/new patterns aren't
+  // typical for that form so we only emit invocation/mount/reference.
+  const patterns = [];
+  for (const local of locals) {
+    const escaped = escapeRe(local);
+    const isMember = local.includes('.');
+    if (lang === 'py') {
+      patterns.push({ kind: 'invocation', re: new RegExp(`\\b${escaped}\\s*\\(`) });
+      patterns.push({ kind: 'reference', re: new RegExp(`(?<!\\.)\\b${escaped}\\b`) });
+      continue;
+    }
+    if (!isMember) {
+      patterns.push({ kind: 'new', re: new RegExp(`\\bnew\\s+${escaped}\\s*\\(`) });
+      patterns.push({ kind: 'jsx', re: new RegExp(`<${escaped}(\\s|/|>)`) });
+    }
+    patterns.push({
+      kind: 'mount',
+      re: new RegExp(
+        `\\b(?:app|router)\\.(?:use|get|post|put|delete|patch|head|options|all)\\s*\\([^)]*\\b${escaped}\\b`,
+      ),
+    });
+    patterns.push({ kind: 'invocation', re: new RegExp(`\\b${escaped}\\s*\\(`) });
+    // Reference fallback: any non-property occurrence of the local name.
+    // Covers member access (`meta.version`), pass-as-arg (`fn(handler)`),
+    // assignments, etc. Lower-priority than the structural patterns above.
+    if (isMember) {
+      patterns.push({ kind: 'reference', re: new RegExp(`\\b${escaped}\\b`) });
+    } else {
+      patterns.push({ kind: 'reference', re: new RegExp(`(?<!\\.)\\b${escaped}\\b`) });
+    }
+  }
+
+  // Skip lines inside import statements so the import declaration itself
+  // (which contains the local name) doesn't register as a caller. Tracks
+  // multi-line imports too — `import {\n  foo,\n  bar,\n} from '...'` — by
+  // staying in skip mode until the `from '...'` or `import '...'` clause is
+  // seen. Dynamic imports (`import('./x')`) and meta access (`import.meta`)
+  // do NOT enter skip mode — both lack the whitespace after `import` that
+  // identifies a static import declaration.
+  // Static import must be `import` + whitespace + a token that ISN'T `(`.
+  // The negative lookbehind keeps `import ('./x')` (space before paren — still
+  // dynamic) out of skip mode.
+  const STATIC_IMPORT_START = /^\s*import\s+(?!\()/;
+  const STATIC_IMPORT_END = /\bfrom\s*['"][^'"]+['"]|^\s*import\s+['"][^'"]+['"]/;
+  let inImport = false;
+  for (let i = 0; i < lines.length; i++) {
+    const lineRaw = lines[i];
+    if (!inImport && STATIC_IMPORT_START.test(lineRaw)) inImport = true;
+    if (inImport) {
+      if (STATIC_IMPORT_END.test(lineRaw)) inImport = false;
+      continue;
+    }
+    const line = stripLineComment(lineRaw, commentPrefix);
+    for (const p of patterns) {
+      if (p.re.test(line)) {
+        hits.push({ line: i + 1, pattern: p.kind });
+        break;
+      }
+    }
+  }
+  return hits;
+}
+
+function stripLineComment(line, commentPrefix) {
+  const idx = findLineCommentStart(line, commentPrefix);
+  return idx >= 0 ? line.slice(0, idx) : line;
+}
+
+function findLineCommentStart(line, prefix) {
+  // Two-state scan over single/double/backtick quotes; returns the index where
+  // the line comment starts (outside any string literal), or -1 if none.
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    const prev = line[i - 1];
+    if (c === '\\' && prev !== '\\') {
+      i++; // skip escaped char
+      continue;
+    }
+    if (!inDouble && !inBacktick && c === "'") inSingle = !inSingle;
+    else if (!inSingle && !inBacktick && c === '"') inDouble = !inDouble;
+    else if (!inSingle && !inDouble && c === '`') inBacktick = !inBacktick;
+    if (!inSingle && !inDouble && !inBacktick) {
+      if (line.startsWith(prefix, i)) return i;
+    }
+  }
+  return -1;
+}
+
+// ---- Filesystem helpers ----------------------------------------------------
+
+function* walkFiles(dir, depth = 0) {
+  if (depth > 24) return;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (DEFAULT_IGNORE_DIRS.has(e.name)) continue;
+    if (e.name.startsWith('.') && e.name !== '.claude') continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) yield* walkFiles(full, depth + 1);
+    else if (e.isFile()) yield full;
+  }
+}
+
+function readSafe(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function isTestFile(file, globs) {
+  // Cheap glob match: exact-segment globs (e.g. **/*.test.*, **/__tests__/**)
+  for (const g of globs) {
+    if (matchGlob(g, file)) return true;
+  }
+  return false;
+}
+
+function matchGlob(pattern, file) {
+  // Convert glob to regex: ** -> .*, * -> [^/]*, . -> \., everything else literal.
+  const re = new RegExp(
+    '^' +
+      pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '')
+        .replace(/\*/g, '[^/]*')
+        .replace(//g, '.*') +
+      '$',
+  );
+  return re.test(file);
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ---- CLI -------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const out = { files: [], root: process.cwd(), testGlobs: undefined };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--files') {
+      out.files = (argv[++i] ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+    } else if (a === '--root') {
+      out.root = path.resolve(argv[++i]);
+    } else if (a === '--test-globs') {
+      out.testGlobs = (argv[++i] ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+    } else if (a === '--help' || a === '-h') {
+      out.help = true;
+    } else {
+      throw new Error(`Unknown arg: ${a}`);
+    }
+  }
+  return out;
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      'Usage: check.mjs --files <a,b,c> [--root <dir>] [--test-globs <a,b>]',
+      '',
+      'Walks slice-diff exports and reports production / test callers + annotations.',
+      'Output: JSON to stdout. Manifest cross-check is the agent\'s responsibility.',
+      '',
+    ].join('\n'),
+  );
+}
+
+const isMain = (() => {
+  try {
+    return import.meta.url === `file://${fileURLToPath(import.meta.url)}` && process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+  } catch {
+    return false;
+  }
+})();
+
+if (isMain) {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (e) {
+    process.stderr.write(`error: ${e.message}\n`);
+    process.exit(2);
+  }
+  if (args.help || args.files.length === 0) {
+    printHelp();
+    process.exit(args.help ? 0 : 2);
+  }
+  try {
+    const result = check(args);
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`error: ${e.message}\n`);
+    process.exit(2);
+  }
+}