paperlint 6.2.3 → 7.0.0

package/src/cli.test.ts

@@ -7,9 +7,15 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { createServer } from "node:http";
 import { dirname, join } from "node:path";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../test/support.ts";
+import {
+  runNode,
+  useTempDir,
+  venuePreset,
+  writeTree,
+} from "../test/support.ts";
 import type { runToolchain } from "./toolchain.ts";
 import {
   chooseVenue,
@@ -82,6 +88,14 @@ test("parseSettings refuses `talk` in the root file: it is one paper's setting",
   );
 });
 
+test("parseSettings refuses `submission` in the root file: a submission is one paper's", () => {
+  const r = parseSettings({ submission: { id: 7 } }, "paperlint.json", "/r");
+  assert.equal(
+    r.ok ? null : r.error,
+    "paperlint.json: \"submission\" is a paper's setting — set it in that paper's paperlint.json",
+  );
+});
+
 test("parseSettings refuses a non-object, names one unknown key or several, and a mistyped default", () => {
   const error = (json: unknown) => {
     const r = parseSettings(json, "paperlint.json", "/r");
@@ -186,8 +200,12 @@ test("runHook: a runtime with no cli.js beside it, and a hook killed by a signal
 test("chooseVenue: a preset by path (inside and outside the paper), by prefixed name, and a broken one", async () => {
   const dir = join(root, "venues");
   writeTree(dir, {
-    "papers/p/mine.jsonc": JSON.stringify({ extends: "paperlint:agenticdev" }),
-    "shared/ours.jsonc": JSON.stringify({ extends: "paperlint:agenticdev" }),
+    "papers/p/mine.jsonc": JSON.stringify(
+      venuePreset("mine", { extends: "paperlint:agenticdev" }),
+    ),
+    "shared/ours.jsonc": JSON.stringify(
+      venuePreset("ours", { extends: "paperlint:agenticdev" }),
+    ),
     "shared/broken.jsonc": "{ nope",
   });
   const paperDir = join(dir, "papers", "p");
@@ -385,6 +403,38 @@ test("silentOptionalRules: a config with no rules turns nothing on", async () =>
   assert.deepEqual(await silentOptionalRules(eslint, [], {}), []);
 });
 
+const lastPageOn = {
+  rules: [
+    { basePath: ".", rules: { "pdf/last-page-balance": "error" as const } },
+  ],
+};
+const eslintWith = (rules: Record<string, unknown>) => ({
+  calculateConfigForFile: () => Promise.resolve({ rules }),
+});
+
+test("silentOptionalRules: a rule on for a paper is reached", async () => {
+  const eslint = eslintWith({ "pdf/last-page-balance": [2, {}] });
+  assert.deepEqual(
+    await silentOptionalRules(eslint, ["p/paper.tex"], lastPageOn),
+    [],
+  );
+});
+
+test("silentOptionalRules: a rule a paper's own block turns off is reached — the way out of a preset's", async () => {
+  const eslint = eslintWith({ "pdf/last-page-balance": [0] });
+  assert.deepEqual(
+    await silentOptionalRules(eslint, ["p/paper.tex"], lastPageOn),
+    [],
+  );
+});
+
+test("silentOptionalRules: a rule no block names for any paper is silent — a glob that matched nothing", async () => {
+  assert.deepEqual(
+    await silentOptionalRules(eslintWith({}), ["p/paper.tex"], lastPageOn),
+    ["pdf/last-page-balance"],
+  );
+});
+
 test("init with no path and --format md sets up the current directory", async () => {
   const dir = writeTree(join(root, "init-here"), { "package.json": "{}" });
   const r = await cli(
@@ -603,3 +653,105 @@ test("parseSettings refuses a root `identity` that is not a list of words, and t
     true,
   );
 });
+
+test("parseArgs: submission's flags — two values and two switches", () => {
+  assert.deepEqual(
+    parseArgs([
+      "submission",
+      "update",
+      "papers/p",
+      "--pdf=build/p.pdf",
+      "--abstract",
+      "abs.txt",
+      "--submit",
+      "--save",
+    ]),
+    {
+      ...parseArgs([]),
+      cmd: "submission",
+      paths: ["update", "papers/p"],
+      pdf: "build/p.pdf",
+      abstract: "abs.txt",
+      submit: true,
+      save: true,
+    },
+  );
+  assert.equal(
+    parseArgs(["submission", "update", "--pdf"]).missingValue,
+    "--pdf",
+  );
+});
+
+/** A paper whose venue's HotCRP portal is `site`, submission 7, with a paper.pdf. */
+const submissionPaper = (dir: string, site: string): void => {
+  writeTree(dir, {
+    "package.json": "{}",
+    "venue.jsonc": JSON.stringify(
+      venuePreset("venue", {
+        extends: "paperlint:aidc",
+        portal: { kind: "hotcrp", url: site },
+      }),
+    ),
+    "papers/p/paperlint.json": JSON.stringify({
+      extends: "../../venue.jsonc",
+      submission: { id: 7 },
+    }),
+    "papers/p/paper.pdf": "%PDF fake",
+  });
+};
+
+test("🔴 submission: without HOTCRP_TOKEN it names the variable and asks the portal nothing", async () => {
+  const dir = join(root, "submission-no-token");
+  submissionPaper(dir, "http://127.0.0.1:9");
+  const saved = process.env["HOTCRP_TOKEN"];
+  delete process.env["HOTCRP_TOKEN"];
+  try {
+    const r = await cli(["submission", "show", "papers/p"], dir);
+    assert.equal(r.code, 2);
+    assert.match(r.err, /^HOTCRP_TOKEN is not set — /);
+  } finally {
+    if (saved !== undefined) process.env["HOTCRP_TOKEN"] = saved;
+  }
+});
+
+test("submission show: through the HotCRP adapter to a local portal, the token in the header only", async () => {
+  const seen: { url: string; auth: string }[] = [];
+  const server = createServer((req, res) => {
+    seen.push({ url: req.url ?? "", auth: req.headers.authorization ?? "" });
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(
+      JSON.stringify({
+        ok: true,
+        paper: { object: "paper", pid: 7, status: "submitted", title: "T" },
+      }),
+    );
+  });
+  await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+  const address = server.address();
+  assert.ok(address !== null && typeof address === "object");
+  const dir = join(root, "submission-show");
+  submissionPaper(dir, `http://127.0.0.1:${String(address.port)}`);
+  const saved = process.env["HOTCRP_TOKEN"];
+  process.env["HOTCRP_TOKEN"] = "hct_cli_test";
+  try {
+    const r = await cli(["submission", "show"], join(dir, "papers/p"));
+    assert.equal(r.code, 0, r.err);
+    assert.deepEqual(seen, [
+      { url: "/api/paper?p=7&word_limit=hard", auth: "bearer hct_cli_test" },
+    ]);
+    assert.match(
+      r.out,
+      /^submission 7 on http:\/\/127\.0\.0\.1:\d+ \(hotcrp\)$/m,
+    );
+    assert.match(r.out, /^match {9}NO — the portal holds no PDF$/m);
+    assert.doesNotMatch(r.out + r.err, /hct_cli_test/);
+  } finally {
+    if (saved === undefined) delete process.env["HOTCRP_TOKEN"];
+    else process.env["HOTCRP_TOKEN"] = saved;
+    await new Promise<void>((r) => {
+      server.close(() => {
+        r();
+      });
+    });
+  }
+});

package/src/cli.ts

@@ -78,6 +78,7 @@ import {
   REGISTER_BAND_RULE_LEVELS,
   registerBandRules,
 } from "./register-bands.ts";
+import { headingCaseRule } from "./heading-case.ts";
 import {
   paperRules,
   identityField,
@@ -86,6 +87,10 @@ import {
 } from "./paper-settings.ts";
 import { referenceRules, REFERENCE_RULE_LEVELS } from "./reference-rules.ts";
 import { onlineReferences } from "./adapters/references/index.ts";
+import { hotcrpPortal } from "./adapters/hotcrp/index.ts";
+import { runSubmission } from "./submission.ts";
+import type { PortalKind, SupportedPortal } from "./domain/submission.ts";
+import type { SubmissionPortal } from "./ports/submission-portal.ts";
 import type { CheckReferences } from "./ports/check-references.ts";
 import {
   narrowToOwners,
@@ -99,6 +104,8 @@ import {
   presetProblemText,
   resolvePreset,
   shippedPresets,
+  shippedSpec,
+  shippedVenueNames,
   SHIPPED_PREFIX,
   type PaperPreset,
   type PresetTemplate,
@@ -152,6 +159,10 @@ export { init };
 export { nextSteps } from "./init.ts";
 
 import paperStages from "#eslint-rules/paper-stages";
+import {
+  FOLDER_VENUE_RULE_LEVELS,
+  folderVenueRules,
+} from "./folder-venue-rule.ts";
 import typography from "#eslint-rules/paper-typography";
 import texBuild from "#eslint-rules/tex-build";
 import bibReachable from "#eslint-rules/bib-reachable-entry";
@@ -171,7 +182,9 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       .claude/settings.json, offer the CI step, report what is missing
   npx paperlint new <name> [--venue <preset>] [--kind <kind>] [--format tex|md]
                                       create <papers>/<name>/ from the template; never overwrites,
-                                      on an existing folder adds only the missing files, then lints it
+                                      on an existing folder adds only the missing files, then lints it.
+                                      A <name> that names a venue (aisec-2026) is refused: name the
+                                      paper after the work
   npx paperlint lint [paths…]         run every rule over your papers
   npx paperlint build <paper> | --all
                                       compile paper.tex to paper.pdf: pdflatex and bibtex, rerun until
@@ -187,6 +200,14 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       into ~/.cache/paperlint/texlive (PAPERLINT_TEXLIVE_DIR overrides); a second
                                       run does nothing. --check: report what is missing, change nothing
   npx paperlint doctor                say what is actually wired — and what only LOOKS wired
+  npx paperlint submission show [paper]
+                                      the paper's submission on the venue's portal: status, title,
+                                      type, topics, abstract length, the PDF the portal holds, and
+                                      whether it is the local paper.pdf (sha256)
+  npx paperlint submission update [paper] [--pdf <file>] [--abstract <file>] [--submit] [--save]
+                                      send the PDF (default: the paper's own), an abstract, or
+                                      "submitted". A DRY RUN unless --save: the portal checks the
+                                      change and keeps nothing
   npx paperlint hook <name>           run an editor hook (.claude/settings.json calls this)
   npx paperlint --help
 
@@ -205,6 +226,19 @@ new:
   --kind <kind>       the paper's kind at that venue (its page limit), e.g. short — one of the
                       preset's kinds; needs --venue
   --format tex|md     the paper's source format; default tex
+  --allow-venue-name  create the folder even though its name names a venue (a whole word such as
+                      "realm" can be the work's own). Without it such a name is refused: a rejected
+                      paper moves to another venue and keeps its folder
+
+submission:
+  The venue preset declares the portal — "portal": { "kind": "hotcrp", "url": "<site>" } — and the
+  paper's paperlint.json its submission there — "submission": { "id": <number> }. The token comes
+  only from the environment: HOTCRP_TOKEN (HotCRP: Account settings → Developer).
+  [paper]             the paper's folder; default the current directory
+  --pdf <file>        the PDF to compare (show) or send (update) instead of the paper's own
+  --abstract <file>   update: a plain-text file whose text replaces the abstract
+  --submit            update: mark the submission submitted
+  --save              update: really change the submission. Without it, nothing is saved
 
 lint:
   npx paperlint lint [paths…] [--fix] [--config <file.json>] [--json]
@@ -258,6 +292,18 @@ const TEX_RULE_DEPS = {
   latex: latexReader,
 };
 
+/** The register band rules and `tex/heading-case`: the rules of the `tex` plugin that read a paper's words. */
+const REGISTER_AND_CASE_RULES = {
+  ...registerBandRules(TEX_RULE_DEPS),
+  "heading-case": headingCaseRule(TEX_RULE_DEPS),
+};
+
+/** The rules of the files `paper.tex` includes, each read on its own as a fragment (#144). */
+const FRAGMENT_RULES = {
+  "future-promise": texBuild["future-promise"],
+  "heading-case": REGISTER_AND_CASE_RULES["heading-case"],
+};
+
 /** What the talk rules read with: the disk, the shipped presets, and the three media readers. */
 const TALK_RULE_DEPS = {
   files: nodeFiles,
@@ -313,11 +359,22 @@ export function buildConfig(
     },
     {
       files: ["**/PIPELINE-STATUS.md"],
-      plugins: { markdown, paper: paperStages },
+      // Every paper folder has one, whatever its source format: the rules about the folder itself
+      // (its stages, its frozen sources, its name) are judged here, once per paper.
+      plugins: {
+        markdown,
+        paper: {
+          rules: {
+            ...paperStages.rules,
+            ...folderVenueRules({ files: nodeFiles, venuesDir: presetsDir() }),
+          },
+        },
+      },
       ...md,
       rules: {
         "paper/stages": "error",
         "paper/source": "error",
+        ...FOLDER_VENUE_RULE_LEVELS,
       },
     },
     {
@@ -358,7 +415,7 @@ export function buildConfig(
             ...texVenueRules(TEX_RULE_DEPS),
             "claim-provenance": claimProvenanceRule(TEX_RULE_DEPS),
             register: registerRule(TEX_RULE_DEPS),
-            ...registerBandRules(TEX_RULE_DEPS),
+            ...REGISTER_AND_CASE_RULES,
           },
         },
         paper: { rules: texPaperRules },
@@ -410,7 +467,7 @@ export function buildConfig(
           plugins: {
             tex: {
               languages: { latex: texLanguage },
-              rules: { "future-promise": texBuild["future-promise"] },
+              rules: FRAGMENT_RULES,
             },
             paper: {
               rules: {
@@ -579,7 +636,11 @@ export async function silentOptionalRules(
   for (const f of new Set(files.filter((p) => basename(p) === MAIN))) {
     // Undefined for a file outside ESLint's cwd or scope: it reaches nothing.
     const cfg = ComputedConfig.parse(await eslint.calculateConfigForFile(f));
-    for (const id of turnedOn) if (isOn(cfg?.rules?.[id])) reached.add(id);
+    // Reached is "some block names the rule for this paper", on OR off: a paper that turns off what
+    // its venue preset turned on is the documented way out, and reads the same as a glob that missed
+    // only if "off" is counted as "not there" — which refused every such paper.
+    for (const id of turnedOn)
+      if (cfg?.rules?.[id] !== undefined) reached.add(id);
   }
   return [...turnedOn].filter((id) => !reached.has(id));
 }
@@ -781,10 +842,15 @@ export function parseArgs(argv: readonly string[]): Args {
     check: false,
     yes: false,
     noHooks: false,
+    allowVenueName: false,
     paper: null,
     format: null,
     venue: null,
     kind: null,
+    pdf: null,
+    abstract: null,
+    submit: false,
+    save: false,
     hooksMode: null,
     // -1 = warnings NEVER fail the run. In this set most findings are advisory by design, and a
     // gate that fails on advice gets muted entirely.
@@ -824,19 +890,14 @@ export function parseArgs(argv: readonly string[]): Args {
       if (inline === "") out.missingValue = a;
       return inline === "" ? undefined : inline;
     };
-    if (a === "--json") out.json = true;
-    else if (a === "--fix") out.fix = true;
-    else if (a === "--all") out.all = true;
-    else if (a === "--dry-run") out.dryRun = true;
-    else if (a === "--check") out.check = true;
-    else if (a === "--yes" || a === "-y") out.yes = true;
-    else if (a === "--no-hooks") out.noHooks = true;
+    const on = SWITCHES.get(a);
+    if (on !== undefined) out[on] = true;
     else if (a.startsWith("--hooks="))
       out.hooksMode = a.slice("--hooks=".length);
-    else if (a === "--paper") out.paper = take() ?? null;
-    else if (a === "--format") out.format = take() ?? null;
-    else if (a === "--venue") out.venue = take() ?? null;
-    else if (a === "--kind") out.kind = take() ?? null;
+    else if (STRING_FLAGS.has(a)) {
+      const field = STRING_FLAGS.get(a);
+      if (field !== undefined) out[field] = take() ?? null;
+    }
     // `--options` was the first spelling and is kept working. It named the wrong thing — every
     // other tool in the stack calls this file its config — but a flag in someone's CI is not
     // ours to break.
@@ -852,12 +913,49 @@ export function parseArgs(argv: readonly string[]): Args {
   return out;
 }
 
+/** The flags that take no value: each turns one field of `Args` on. */
+const SWITCHES: ReadonlyMap<
+  string,
+  | "json"
+  | "fix"
+  | "all"
+  | "dryRun"
+  | "check"
+  | "yes"
+  | "noHooks"
+  | "allowVenueName"
+  | "submit"
+  | "save"
+> = new Map([
+  ["--json", "json"],
+  ["--fix", "fix"],
+  ["--all", "all"],
+  ["--dry-run", "dryRun"],
+  ["--check", "check"],
+  ["--yes", "yes"],
+  ["-y", "yes"],
+  ["--no-hooks", "noHooks"],
+  ["--allow-venue-name", "allowVenueName"],
+  ["--submit", "submit"],
+  ["--save", "save"],
+]);
+
+/** The flags whose value is one string field of `Args`. */
+const STRING_FLAGS: ReadonlyMap<
+  string,
+  "paper" | "format" | "venue" | "kind" | "pdf" | "abstract"
+> = new Map([
+  ["--paper", "paper"],
+  ["--format", "format"],
+  ["--venue", "venue"],
+  ["--kind", "kind"],
+  ["--pdf", "pdf"],
+  ["--abstract", "abstract"],
+]);
+
 /** The flags that take a value, in either spelling: `--flag value` or `--flag=value`. */
 const VALUE_FLAGS: ReadonlySet<string> = new Set([
-  "--paper",
-  "--format",
-  "--venue",
-  "--kind",
+  ...STRING_FLAGS.keys(),
   "--config",
   "--options",
   "--max-warnings",
@@ -1048,15 +1146,21 @@ export async function createPaperAt(
     err,
     cwd,
     venue = null,
+    allowVenueName = false,
   }: {
     log: typeof console.log;
     err: typeof console.error;
     cwd: string;
     /** What `--venue` chose; null writes the template's `paperlint.json` as it is. */
     venue?: VenueChoice | null;
+    /** `--allow-venue-name`: a name that names a venue is created, not refused. */
+    allowVenueName?: boolean;
   },
 ): Promise<number> {
-  const result = newPaper(papersRoot, name, format, { venue });
+  const result = newPaper(papersRoot, name, format, {
+    venue,
+    venues: allowVenueName ? [] : shippedVenueNames(PRESET_DEPS),
+  });
   const here = (p: string): string => shown(cwd, p);
   for (const line of reportNewPaper(result, here)) log(line);
   if (!result.ok) return 2;
@@ -1075,7 +1179,7 @@ export async function createPaperAt(
 
 /** A venue `paperlint new` will write, with what the messages need to say about it. */
 export interface VenueChoice extends VenueSetting {
-  /** The preset's word in messages (`agenticdev`, `my-workshop`). */
+  /** The preset's word in messages: the venue's name (`AgenticDev`), else the file name (`my-workshop`). */
   readonly label: string;
   /** The preset's kinds; empty when it sets no page limit. */
   readonly kinds: readonly string[];
@@ -1194,7 +1298,7 @@ function venueSpec(
     return bad(
       `--venue ${venue}: no such venue preset. Shipped: ${shipped.join(", ")} — or a path to your own preset, starting with ./ or ../`,
     );
-  return { ok: true, value: `${SHIPPED_PREFIX}${name}` };
+  return { ok: true, value: shippedSpec(name) };
 }
 
 /**
@@ -1274,6 +1378,7 @@ async function runNew(
     err,
     cwd,
     venue: venue.value,
+    allowVenueName: a.allowVenueName,
   });
 }
 
@@ -1420,7 +1525,37 @@ const SIMPLE: Readonly<
       banal: hostBanalInstaller(),
       tex: toolchainTex(cwd),
     }),
+  submission: (a, { log, err, cwd }) =>
+    runSubmission(
+      {
+        sub: a.paths[0],
+        paperDir: a.paths[1] ?? ".",
+        extra: a.paths.slice(2),
+        pdf: a.pdf,
+        abstract: a.abstract,
+        submit: a.submit,
+        save: a.save,
+      },
+      {
+        files: nodeFiles,
+        presets: PRESET_DEPS,
+        cwd,
+        env: (name) => process.env[name],
+        portalFor,
+        log,
+        err,
+      },
+    ),
+};
+
+/** The adapter of each portal kind — one per kind, chosen here at the root. */
+const PORTALS: Readonly<
+  Record<PortalKind, (url: string, token: string) => SubmissionPortal>
+> = {
+  hotcrp: (url, token) => hotcrpPortal({ url, token }),
 };
+const portalFor = (p: SupportedPortal, token: string): SubmissionPortal =>
+  PORTALS[p.kind](p.url, token);
 
 /** banal's installer, wired from this process's environment: the composition root's work. */
 function hostBanalInstaller(): ToolInstaller {
@@ -1503,6 +1638,7 @@ async function runInit(
     format: isFormat(a.format) ? a.format : null,
     createPaper: (papersRoot, name, format) =>
       createPaperAt(papersRoot, name, format, { log, err, cwd }),
+    venues: shippedVenueNames(PRESET_DEPS),
     tex: initTexLive(a, { log, err, cwd }),
     resolveCliPapers: (root: string): string | null =>
       cliPapers({ ...a, config: null }, root),
@@ -1584,8 +1720,8 @@ export async function run(
   // editing a file.
   //
   // 🔴 A path FROM THE CONFIG is resolved relative to the PROJECT ROOT, not the current directory.
-  // Otherwise walking up is pointless: from `papers/aisec-2026` the root would be found, but
-  // `"papersDir": "papers"` would point at `papers/aisec-2026/papers`. A command-line argument stays
+  // Otherwise walking up is pointless: from `papers/rule-drift` the root would be found, but
+  // `"papersDir": "papers"` would point at `papers/rule-drift/papers`. A command-line argument stays
   // relative to the current directory: it was typed here and now.
   //
   // Both kinds end up ABSOLUTE: ESLint below runs from `lintRoot`, not from here, and would resolve a