paperlint 2.0.0

package/src/rules-config.ts

@@ -0,0 +1,178 @@
+/**
+ * THE CONSUMER'S SETTINGS, PARSED AT THE BOUNDARY — unknown keys refused, and the `rules` key
+ * turned into ESLint config blocks.
+ *
+ * ── THE `rules` KEY: ESLint'S OWN SHAPE, NOT A NEW ONE ──────────────────────────
+ * A consumer turns an optional rule on, or changes a built-in rule's severity, by writing what they
+ * would write in an ESLint flat config — a list of `{ files, ignores, rules }` blocks:
+ *
+ *   "rules": [ { "files": ["papers/agenticdev-2026/**"],
+ *                "rules": { "pdf/last-page-balance": ["error", { "tolerancePt": 120 }] } } ]
+ *
+ * The blocks are appended AFTER rpp's built-in config, so a later block wins, exactly as in ESLint.
+ * `files` and `ignores` are resolved relative to the directory of the file that holds the settings,
+ * as ESLint resolves them relative to its config file: each block gets that directory as ESLint's
+ * own `basePath`, so paperlint matches nothing itself.
+ *
+ * ── WHY PARSED HERE, AND WHY STRICT ─────────────────────────────────────────────
+ * ESLint would reject a bad severity or an unknown rule too — but as a stack trace from inside
+ * `lintFiles`, naming neither the settings file nor the block. And a key paperlint does not read, at the
+ * top level or in a block, ESLint never sees at all: a typo would silently read as "not set". So
+ * every problem is one line naming the key path, before ESLint starts, and nothing downstream sees
+ * the raw object again.
+ *
+ * Only rules paperlint ships may be named: the settings configure paperlint, and a rule from another plugin
+ * would need that plugin, which JSON cannot carry. Which rules paperlint ships is read off its own
+ * config (`buildConfig`), not listed a second time.
+ */
+import { SETTINGS_KEYS } from "../lib/paper-config.mjs";
+
+/** ESLint's severities, in both of its spellings. */
+export type Severity = "off" | "warn" | "error" | 0 | 1 | 2;
+export type RuleEntry = Severity | readonly [Severity, ...unknown[]];
+
+/** One block of the `rules` key, parsed. `basePath` is the settings file's directory. */
+export interface RuleBlock {
+  readonly basePath: string;
+  readonly files?: readonly string[];
+  readonly ignores?: readonly string[];
+  readonly rules: Readonly<Record<string, RuleEntry>>;
+}
+
+export type Parsed<T> =
+  | { readonly ok: true; readonly value: T }
+  | { readonly ok: false; readonly error: string };
+
+const SEVERITIES: readonly unknown[] = ["off", "warn", "error", 0, 1, 2];
+const BLOCK_KEYS = new Set(["files", "ignores", "rules"]);
+
+const bad = <T>(error: string): Parsed<T> => ({ ok: false, error });
+
+/** Every top-level key must be one paperlint or its skills read. */
+export function unknownKeys(settings: Record<string, unknown>): string[] {
+  return Object.keys(settings).filter((k) => !Object.hasOwn(SETTINGS_KEYS, k));
+}
+
+const isStringList = (v: unknown): v is string[] =>
+  Array.isArray(v) &&
+  v.length > 0 &&
+  v.every((x) => typeof x === "string" && x !== "");
+
+/** A severity, or `[severity, ...options]`. */
+function parseEntry(v: unknown): RuleEntry | null {
+  const sev = Array.isArray(v) ? v[0] : v;
+  if (!SEVERITIES.includes(sev)) return null;
+  return v as RuleEntry;
+}
+
+/** One block's `rules` object. */
+function parseRules(
+  v: unknown,
+  at: string,
+  shipped: ReadonlySet<string>,
+): Parsed<Record<string, RuleEntry>> {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return bad(`${at}.rules must be an object of rule id → severity`);
+  const out: Record<string, RuleEntry> = {};
+  for (const [id, raw] of Object.entries(v)) {
+    if (!shipped.has(id))
+      return bad(
+        `${at}.rules: "${id}" is not a rule paperlint ships — known: ${[...shipped].sort().join(", ")}`,
+      );
+    const entry = parseEntry(raw);
+    if (entry === null)
+      return bad(
+        `${at}.rules["${id}"]: ${JSON.stringify(raw)} is not a severity — use "off", "warn" or "error", or ["error", { options }]`,
+      );
+    out[id] = entry;
+  }
+  return { ok: true, value: out };
+}
+
+/** `files` and `ignores`, each absent or a non-empty list of globs; the first bad one, or null. */
+function badGlobs(o: Record<string, unknown>, at: string): string | null {
+  for (const k of ["files", "ignores"] as const)
+    if (o[k] !== undefined && !isStringList(o[k]))
+      return `${at}.${k} must be a non-empty list of glob strings`;
+  return null;
+}
+
+/** The block's `files`/`ignores`, present only when given. */
+const globsOf = (o: Record<string, unknown>) => ({
+  ...(o["files"] ? { files: o["files"] as string[] } : {}),
+  ...(o["ignores"] ? { ignores: o["ignores"] as string[] } : {}),
+});
+
+/** One element of the `rules` list. */
+function parseBlock(
+  v: unknown,
+  at: string,
+  ctx: { shipped: ReadonlySet<string>; baseDir: string },
+): Parsed<RuleBlock> {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return bad(
+      `${at} must be an object like { "files": [...], "rules": {...} }`,
+    );
+  const o = v as Record<string, unknown>;
+  const extra = Object.keys(o).filter((k) => !BLOCK_KEYS.has(k));
+  if (extra.length)
+    return bad(
+      `${at}: unknown key "${extra[0]}" — a block takes "files", "ignores" and "rules"`,
+    );
+  const globs = badGlobs(o, at);
+  if (globs) return bad(globs);
+  const rules = parseRules(o["rules"], at, ctx.shipped);
+  if (!rules.ok) return rules;
+  return {
+    ok: true,
+    value: { basePath: ctx.baseDir, ...globsOf(o), rules: rules.value },
+  };
+}
+
+/**
+ * The `rules` key → config blocks, or one error naming the key path.
+ *
+ * @param raw      the value under `rules` (undefined when absent)
+ * @param where    how the settings are named in messages, e.g. `package.json → "paperlint"`
+ * @param shipped  the rule ids paperlint ships (`shippedRuleIds`)
+ * @param baseDir  the directory of the file holding the settings
+ */
+export function parseRuleBlocks(
+  raw: unknown,
+  where: string,
+  shipped: ReadonlySet<string>,
+  baseDir: string,
+): Parsed<readonly RuleBlock[]> {
+  if (raw === undefined) return { ok: true, value: [] };
+  if (!Array.isArray(raw))
+    return bad(
+      `${where}.rules must be a list of blocks, like ESLint's flat config: [{ "files": [...], "rules": {...} }]`,
+    );
+  const out: RuleBlock[] = [];
+  for (const [i, v] of raw.entries()) {
+    const b = parseBlock(v, `${where}.rules[${i}]`, { shipped, baseDir });
+    if (!b.ok) return b;
+    out.push(b.value);
+  }
+  return { ok: true, value: out };
+}
+
+/**
+ * The rule ids a config defines through its own plugins, as `<plugin>/<rule>`. Plugins passed in
+ * `foreign` (a dependency's plugin, such as `@eslint/markdown`) are not rpp's and are skipped.
+ */
+export function shippedRuleIds(
+  config: readonly unknown[],
+  foreign: readonly unknown[],
+): Set<string> {
+  const ids = new Set<string>();
+  for (const block of config) {
+    const plugins = (block as { plugins?: Record<string, unknown> }).plugins;
+    for (const [name, plugin] of Object.entries(plugins ?? {})) {
+      if (foreign.includes(plugin)) continue;
+      const rules = (plugin as { rules?: Record<string, unknown> }).rules;
+      for (const rule of Object.keys(rules ?? {})) ids.add(`${name}/${rule}`);
+    }
+  }
+  return ids;
+}

package/src/structure.harness.mjs

@@ -0,0 +1,179 @@
+/**
+ * Both halves for `structure.mjs` — the package's only check whose subject is a file's ABSENCE.
+ *
+ * 🔴 THE MAIN THING PINNED DOWN HERE IS NOT FIRING, IT'S SILENCE. An error-level check that
+ * fails on a correct tree does not get fixed, it gets turned off, and real findings go with it.
+ * So every "found" here has a paired "not found on the neighboring directory", and the defaults
+ * are separately checked against the shape of the live corpus.
+ */
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  realpathSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const { checkStructure, formatStructure, asEslintResults, STRUCTURE_DEFAULTS } =
+  await import(join(HERE, "structure.ts"));
+
+let n = 0;
+const check = (label, cond) => {
+  assert.ok(cond, label);
+  n++;
+};
+
+const root = realpathSync(mkdtempSync(join(tmpdir(), "rpp-struct-")));
+const papers = join(root, "papers");
+const paper = (name, files) => {
+  const dir = join(papers, name);
+  mkdirSync(dir, { recursive: true });
+  for (const f of files) {
+    mkdirSync(dirname(join(dir, f)), { recursive: true });
+    writeFileSync(join(dir, f), "x");
+  }
+  return dir;
+};
+
+try {
+  paper("complete", ["PIPELINE-STATUS.md", "paper.tex", "refs.bib"]);
+  paper("complete-md", ["PIPELINE-STATUS.md", "paper.md"]);
+  // the marker is present (paper.tex), the scorecard is not — the directory is linted by ZERO
+  // rules and reports clean
+  paper("no-scorecard", ["paper.tex", "refs.bib"]);
+  // the scorecard is present, the source is not
+  paper("no-source", ["PIPELINE-STATUS.md"]);
+  // not a single marker — this is a sibling in the corpus, not a paper
+  paper("research", ["NOTES.md", "plan/ideas.md"]);
+  mkdirSync(join(papers, ".hidden"), { recursive: true });
+  writeFileSync(join(papers, ".hidden", "paper.tex"), "x");
+
+  const f = checkStructure([papers], undefined, { cwd: root });
+  const at = (name) => f.filter((x) => x.file.endsWith(name));
+
+  check(
+    "a complete paper directory — NOT A SINGLE finding",
+    at("complete").length === 0,
+  );
+  check(
+    "and `paper.md` counts on equal footing with `paper.tex` — the corpus holds both forms",
+    at("complete-md").length === 0,
+  );
+  check(
+    "a missing scorecard — a finding",
+    at("no-scorecard").length === 1 &&
+      /missing `PIPELINE-STATUS\.md`/.test(at("no-scorecard")[0].message),
+  );
+  check(
+    "and the message names the CONSEQUENCE, not a restatement of the condition",
+    /is checked/.test(at("no-scorecard")[0].message) &&
+      /stages, sources or authors/.test(at("no-scorecard")[0].message),
+  );
+  check(
+    "and the consequence names THIS directory by name",
+    /no-scorecard/.test(at("no-scorecard")[0].message),
+  );
+  check(
+    "a directory with no source — a finding, and BOTH accepted forms are listed",
+    at("no-source").length === 1 &&
+      /`paper\.tex`/.test(at("no-source")[0].message) &&
+      /`paper\.md`/.test(at("no-source")[0].message),
+  );
+
+  // 🔴 THE PAIRED HALF: detection is GENEROUS. Without this the check would scream about every
+  // neighboring directory in the corpus, get turned off, and take the three findings above with it.
+  check(
+    "a directory WITHOUT a single pipeline marker is left alone entirely",
+    at("research").length === 0,
+  );
+  check("and so are hidden directories", at(".hidden").length === 0);
+  check("exactly two findings total — nothing extra turned up", f.length === 2);
+
+  // ── consumer config ────────────────────────────────────────────────────────────────
+  check(
+    "`ignore` exempts a directory by name",
+    checkStructure(
+      [papers],
+      { ignore: ["no-scorecard", "no-source"] },
+      {
+        cwd: root,
+      },
+    ).length === 0,
+  );
+  check(
+    "`structure: false` turns the check off entirely",
+    checkStructure([papers], false, { cwd: root }).length === 0,
+  );
+  check(
+    "a requirement ON TOP OF the defaults fires — the config genuinely gets through",
+    checkStructure(
+      [papers],
+      { require: ["PIPELINE-STATUS.md", "refs.bib"] },
+      {
+        cwd: root,
+      },
+    ).some(
+      (x) => x.file.endsWith("complete-md") && /refs\.bib/.test(x.message),
+    ),
+  );
+  check(
+    "a nonexistent root does not crash it — that's the empty-set guard talking",
+    checkStructure([join(root, "nope")], undefined, { cwd: root }).length === 0,
+  );
+
+  // ── defaults: a measurement, not a taste ───────────────────────────────────────────────
+  check(
+    "`paper.pdf` is NOT in the defaults — two papers in the live corpus keep the pdf under a different name",
+    !STRUCTURE_DEFAULTS.require.includes("paper.pdf"),
+  );
+  check(
+    "and `venue.json` counts as a marker but not a requirement",
+    STRUCTURE_DEFAULTS.markers.includes("venue.json") &&
+      !STRUCTURE_DEFAULTS.require.includes("venue.json"),
+  );
+
+  // ── one schema for both halves ────────────────────────────────────────────────────────
+  const asResults = asEslintResults(f);
+  check(
+    "findings come back shaped like an ESLint result — `--json` stays one array",
+    asResults.length === 2 &&
+      asResults.every(
+        (r) =>
+          r.errorCount === 1 &&
+          r.warningCount === 0 &&
+          r.messages[0].ruleId === "structure/required-file" &&
+          r.messages[0].severity === 2,
+      ),
+  );
+  check(
+    "two findings in ONE directory collapse into one result with errorCount 2",
+    (() => {
+      const two = checkStructure(
+        [papers],
+        { require: ["PIPELINE-STATUS.md", "refs.bib"] },
+        { cwd: root },
+      ).filter((x) => x.file.endsWith("no-source"));
+      return asEslintResults(two)[0].errorCount === 2;
+    })(),
+  );
+  check(
+    "the human-readable format names the directory and the finding",
+    /no-scorecard/.test(formatStructure(f)) &&
+      /error {2}missing/.test(formatStructure(f)),
+  );
+  check(
+    "and the path is RELATIVE — an absolute path to the temp directory tells the reader nothing",
+    f.every((x) => !x.file.startsWith("/")),
+  );
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}
+
+console.log(
+  `✓ ${String(n)} assertions passed — structure: a missing file cannot complain for itself`,
+);

package/src/structure.mutations.mjs

@@ -0,0 +1,83 @@
+/**
+ * Battery for `structure.ts` — the package's only check whose subject is a file's ABSENCE.
+ *
+ * A check like this is especially vulnerable to silent failure: it reports on what is missing,
+ * so a broken one looks exactly like a clean corpus. This battery exists because the mutation gate
+ * refused to accept a harness that nothing could kill.
+ */
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { runMutations } from "../lib/mutation-driver.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(HERE, "..");
+const SRC = join(HERE, "structure.ts");
+const HARNESS = join(HERE, "structure.harness.mjs");
+
+process.exit(
+  runMutations({
+    root: ROOT,
+    runner: "node",
+    cases: [
+      {
+        name: "generous detection is removed — any directory counts as a paper",
+        harness: HARNESS,
+        expect:
+          "a directory WITHOUT a single pipeline marker is left alone entirely",
+        disables:
+          "the condition the check uses at all to decide it is looking at a paper. Without it, " +
+          "findings would rain down on `data/`, `figures/` and any neighboring directory — and a " +
+          "rule that yells at the innocent gets turned off entirely, real findings and all",
+        edits: [
+          [
+            SRC,
+            "      if (!rules.markers.some((m: string) => existsSync(join(dir, m))))\n        continue;",
+            "      if (false) continue;",
+          ],
+        ],
+      },
+      {
+        name: "`ignore` stops exempting",
+        harness: HARNESS,
+        expect: "`ignore` exempts a directory by name",
+        disables:
+          'the consumer\'s only way to say "this directory is not a paper". Without it, an ' +
+          "exemption has to be expressed by renaming the directory",
+        edits: [
+          [SRC, "      if (rules.ignore.includes(name)) continue;\n", ""],
+        ],
+      },
+      {
+        name: "the second accepted source form falls out of the defaults",
+        harness: HARNESS,
+        expect: "`paper.md` counts on equal footing with `paper.tex`",
+        disables:
+          "the second source form the live corpus keeps. A paper on `paper.md` would become a " +
+          '"no source" finding while its source is right there — i.e. the check would yell at ' +
+          "the innocent, and such rules get turned off entirely, real findings and all",
+        edits: [
+          [
+            SRC,
+            'requireOneOf: [["paper.tex", "paper.md"]]',
+            'requireOneOf: [["paper.tex"]]',
+          ],
+        ],
+      },
+      {
+        name: "the path in a finding goes absolute again",
+        harness: HARNESS,
+        expect: "and the path is RELATIVE",
+        disables:
+          "the readability of the finding. An absolute path to the run's temp directory tells " +
+          "the reader nothing and on top of that makes the output useless for comparing across machines",
+        edits: [
+          [
+            SRC,
+            '    return rel &&\n      rel !== ".." &&\n      !rel.startsWith(`..${sep}`) &&\n      !isAbsolute(rel)\n      ? rel\n      : p;',
+            "    return p;",
+          ],
+        ],
+      },
+    ],
+  }),
+);

package/src/structure.ts

@@ -0,0 +1,166 @@
+/**
+ * `paperlint lint` — the half ESLint cannot do BY CONSTRUCTION: checking that the required file
+ * IS THERE.
+ *
+ * 🔴 WHY THIS IS A SEPARATE MODULE AND NOT A RULE. A rule is invoked for a file that was handed
+ * to the linter. A file that does not exist is never handed over — so the rule is not invoked,
+ * and, not having been invoked, it physically cannot report the absence. A paper directory with
+ * no `PIPELINE-STATUS.md` yields NOT ONE finding: not a single pipeline rule runs over it, and
+ * the run is green. This is exactly the green zero the `nothing was linted` guard in the CLI
+ * stands for, only one level down — not "nothing was linted", but "not everything here was".
+ *
+ * ⚠️ THIS IS NOT ls-lint's JOB, AND THE TWO ARE NOT INTERCHANGEABLE. ls-lint judges the NAMES of
+ * files that exist (`versions/2026-07-22-submitted.pdf` is named to the scheme). About a file
+ * that does not exist it says nothing — it has nothing to match. The two halves of structure:
+ *     ls-lint      — "what is there is named correctly"
+ *     this module  — "what is required is there"
+ *
+ * 🔴 DETECTION IS GENEROUS, REQUIREMENTS ARE STRICT — and this is for the sake of false positives.
+ * An error-level rule that fails on a correct tree does not get fixed, it gets turned off, and the
+ * real findings go with it. So a directory counts as a paper only if it ALREADY holds at least one
+ * pipeline marker; `research/`, `plans/` and the other neighbours in the corpus are not touched at
+ * all.
+ */
+// eslint-disable-next-line boundaries/dependencies -- legacy I/O, moves behind a port in #76
+import { readdirSync, existsSync } from "node:fs";
+import { join, relative, basename, isAbsolute, sep } from "node:path";
+import type { StructureConfig, StructureFinding } from "./types.ts";
+
+/** The requirements after the consumer's config is laid over the defaults. */
+type Rules = Required<StructureConfig>;
+
+/**
+ * The defaults are MEASURED against a live corpus of five paper directories, not picked by taste:
+ * under them it passes in full — zero findings. The counter-case was run too: `paper.pdf` added to
+ * `require` yields two findings straight away on papers that are perfectly fine — two of the four
+ * keep their pdf under a different name. That is why it is not in the defaults; declared pdfs are
+ * byte-compared by the `paper/stages` rule anyway.
+ */
+export const STRUCTURE_DEFAULTS = {
+  markers: ["PIPELINE-STATUS.md", "paper.tex", "paper.md", "venue.json"],
+  require: ["PIPELINE-STATUS.md"],
+  requireOneOf: [["paper.tex", "paper.md"]],
+  ignore: [],
+};
+
+/** The consumer's config over the defaults; `structure: false` turns the check off entirely. */
+export function structureRules(
+  structure: StructureConfig | false | undefined,
+): Rules | null {
+  if (structure === false) return null;
+  return { ...STRUCTURE_DEFAULTS, ...(structure ?? {}) };
+}
+
+const dirsIn = (dir: string): string[] => {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+      .map((e) => e.name);
+  } catch {
+    // A non-existent directory is not our concern: the empty-set guard says so loudly.
+    return [];
+  }
+};
+
+/**
+ * @returns {{file: string, message: string}[]} findings, one per missing file.
+ */
+export function checkStructure(
+  paths: readonly string[],
+  structure: StructureConfig | false | undefined,
+  // eslint-disable-next-line no-restricted-globals -- legacy I/O, moves behind a port in #76
+  { cwd = process.cwd() }: { cwd?: string } = {},
+): StructureFinding[] {
+  const rules = structureRules(structure);
+  if (!rules) return [];
+  const findings: StructureFinding[] = [];
+  // Relative to where the command was typed — unless the paper lives outside it (#48): then the
+  // absolute path, not a ladder of `../../../` that has to be counted to be read.
+  const say = (p: string): string => {
+    const rel = relative(cwd, p);
+    return rel &&
+      rel !== ".." &&
+      !rel.startsWith(`..${sep}`) &&
+      !isAbsolute(rel)
+      ? rel
+      : p;
+  };
+
+  for (const root of paths) {
+    for (const name of dirsIn(root)) {
+      if (rules.ignore.includes(name)) continue;
+      const dir = join(root, name);
+
+      // Generous detection: with not one marker this is just a neighbour directory, not a paper.
+      if (!rules.markers.some((m: string) => existsSync(join(dir, m))))
+        continue;
+
+      for (const required of rules.require)
+        if (!existsSync(join(dir, required)))
+          findings.push({
+            file: say(dir),
+            message: `missing \`${required}\` — ${whyMissingMatters(required, basename(dir))}`,
+          });
+
+      for (const group of rules.requireOneOf)
+        if (!group.some((f: string) => existsSync(join(dir, f))))
+          findings.push({
+            file: say(dir),
+            message: `missing all of ${group.map((f: string) => `\`${f}\``).join(", ")} — a paper directory with no source is not something the rules can check`,
+          });
+    }
+  }
+  return findings;
+}
+
+/**
+ * The message NAMES THE CONSEQUENCE rather than restating the condition. "missing
+ * PIPELINE-STATUS.md" without the second half reads as nitpicking about formatting; with it you
+ * can see which checks the directory silently loses — the rules that read the scorecard; the rules
+ * over `paper.md` / `paper.tex` still run.
+ */
+function whyMissingMatters(file: string, dirName: string): string {
+  if (file === "PIPELINE-STATUS.md")
+    return `\`paper/stages\`, \`paper/source\` and \`paper/author-list\` read this file, so nothing \`${dirName}\` declares about its stages, sources or authors is checked`;
+  return `declared as required by your \`structure\` configuration`;
+}
+
+export function formatStructure(findings: readonly StructureFinding[]): string {
+  const byDir = new Map<string, string[]>();
+  for (const f of findings)
+    byDir.set(f.file, [...(byDir.get(f.file) ?? []), f.message]);
+  return [...byDir]
+    .map(([dir, msgs]) => [dir, ...msgs.map((m) => `  error  ${m}`)].join("\n"))
+    .join("\n\n");
+}
+
+/**
+ * 🔴 ONE SCHEMA FOR BOTH HALVES. Findings about absence are emitted in THE SAME shape as ESLint
+ * findings, so `--json` stays a single parseable array. A separate channel would force every
+ * consumer to write a second parser — and the first one who did not write it would read "there
+ * are no structural findings" instead of "I do not parse them".
+ */
+export function asEslintResults(
+  findings: readonly StructureFinding[],
+): unknown[] {
+  const byDir = new Map<string, string[]>();
+  for (const f of findings)
+    byDir.set(f.file, [...(byDir.get(f.file) ?? []), f.message]);
+  return [...byDir].map(([filePath, msgs]) => ({
+    filePath,
+    messages: msgs.map((message: string) => ({
+      ruleId: "structure/required-file",
+      severity: 2,
+      message,
+      line: 0,
+      column: 0,
+    })),
+    errorCount: msgs.length,
+    fatalErrorCount: 0,
+    warningCount: 0,
+    fixableErrorCount: 0,
+    fixableWarningCount: 0,
+    suppressedMessages: [],
+    usedDeprecatedRules: [],
+  }));
+}