paperlint 11.1.0 → 11.1.2

package/src/cli.test.ts

@@ -25,6 +25,7 @@ import {
   parseSettings,
   run,
   runHook,
+  portalHosts,
   silentOptionalRules,
   toolchainTex,
 } from "./cli.ts";
@@ -241,6 +242,40 @@ test("runHook paper-folder-layout: in-process, on the real disk — a refusal on
   );
 });
 
+test("runHook submission-confirm: in-process — an ask on stdout for a send, nothing for anything else, and an ask when its input cannot be read", () => {
+  const hook = (stdin: () => string) => {
+    const out: string[] = [];
+    const code = runHook("submission-confirm", {
+      stdin,
+      out: (t) => out.push(t),
+      run: () => {
+        throw new Error("an in-process hook spawns nothing");
+      },
+    });
+    return { code, out };
+  };
+  const command = (c: string) => () =>
+    JSON.stringify({ tool_input: { command: c }, cwd: root });
+  const send = hook(command("npx paperlint submission update nope --save"));
+  assert.equal(send.code, 0);
+  assert.match(
+    send.out.join(""),
+    /^\{"hookSpecificOutput":\{"hookEventName":"PreToolUse","permissionDecision":"ask","permissionDecisionReason":"This sends the paper to the venue's portal/,
+  );
+  assert.deepEqual(hook(command("npx paperlint submission show nope")), {
+    code: 0,
+    out: [],
+  });
+  const unreadable = hook(() => {
+    throw new Error("EAGAIN");
+  });
+  assert.equal(unreadable.code, 0);
+  assert.match(
+    unreadable.out.join(""),
+    /"permissionDecision":"ask","permissionDecisionReason":"paperlint could not read this command/,
+  );
+});
+
 test("runHook paper-folder-layout: by default its output goes to stdout, where Claude Code reads it", () => {
   const dir = join(root, "layout-hook-stdout");
   writeTree(dir, { "papers/p/PIPELINE-STATUS.md": "# status\n" });
@@ -450,6 +485,27 @@ test("build and toolchain over a broken or empty declaration", async () => {
   assert.deepEqual(toolchainTex(broken), toolchainTex(empty));
 });
 
+test("portalHosts: the hosts of the shipped presets' portals, and of the venues the project's papers extend", () => {
+  const dir = writeTree(join(root, "portal-hosts"), {
+    "package.json": "{}",
+    "venue.jsonc": JSON.stringify({
+      type: "venue",
+      name: "Own Venue",
+      url: "https://own.example.org/cfp",
+      deadlines: [],
+      extends: "paperlint:ieee-conference",
+      portal: { kind: "hotcrp", url: "https://submit.own-venue.example.org" },
+    }),
+    "papers/p/PIPELINE-STATUS.md": "# status\n",
+    "papers/p/paper.tex": "x",
+    "papers/p/paperlint.json": JSON.stringify({ extends: "../../venue.jsonc" }),
+  });
+  const hosts = portalHosts(dir);
+  assert.ok(hosts.includes("aidc.submit.acsac.org"), hosts.join());
+  assert.ok(hosts.includes("msr2027.hotcrp.com"), hosts.join());
+  assert.ok(hosts.includes("submit.own-venue.example.org"), hosts.join());
+});
+
 test("build --dry-run on a paper with a venue plans for the preset's packages", async () => {
   const dir = writeTree(join(root, "build-venue"), {
     "package.json": "{}",

package/src/cli.ts

@@ -70,6 +70,7 @@ import {
   pageLimitRules,
   VENUE_RULE_LEVELS,
   venueRules,
+  type VenueMessage,
 } from "./venue-rules.ts";
 import {
   FORMAT_RULE_LEVELS,
@@ -116,11 +117,13 @@ import {
   settingsProblemLine,
   presetProblemText,
   resolvePreset,
+  resolveShipped,
   shippedPresets,
   shippedSpec,
   shippedVenueNames,
   SHIPPED_PREFIX,
   type PaperPreset,
+  type Preset,
   type PresetTemplate,
 } from "./presets.ts";
 import type { ToolInstaller } from "./ports/tool-installer.ts";
@@ -181,6 +184,11 @@ import {
   folderLayoutRules,
 } from "./folder-layout-rule.ts";
 import { folderLayoutHook } from "./folder-layout-hook.ts";
+import {
+  submissionConfirm,
+  UNREADABLE_INPUT,
+} from "./submission-confirm-hook.ts";
+import { leafCommandsNormalized } from "vigiles/hook";
 import {
   REPRO_LAYOUT_RULE_LEVELS,
   reproLayoutRules,
@@ -238,7 +246,7 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       create the paper's submission on the venue's portal: the title
                                       and abstract from the build, the authors from paperlint.json,
                                       the PDF. A DRY RUN unless --save; a save records the new id in
-                                      paperlint.json
+                                      paperlint.json. Prints the venue check first, as update does
   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
@@ -246,7 +254,9 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
   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
+                                      change and keeps nothing. First prints what the venue rules find
+                                      in that exact PDF, as lint does; --save refuses a PDF the last
+                                      build did not measure (exit 2)
   npx paperlint submission topics [paper]
                                       the topics the venue's portal offers, against the ones its
                                       preset records; exit 1 when they differ
@@ -1237,8 +1247,42 @@ const IN_PROCESS_HOOKS: Readonly<Record<string, (io: HookIo) => number>> = {
     }
     return 0;
   },
+  // Never advisory-silent: an input it cannot read is asked about, not let through.
+  "submission-confirm": ({ stdin, out }) => {
+    const said = ((): ReturnType<typeof submissionConfirm> => {
+      try {
+        return submissionConfirm(stdin(), {
+          ...PRESET_DEPS,
+          portalHosts,
+          shellLeaves: leafCommandsNormalized,
+          readSend: submissionSend,
+        });
+      } catch {
+        return UNREADABLE_INPUT;
+      }
+    })();
+    if (said !== null) out(`${JSON.stringify(said)}\n`);
+    return 0;
+  },
 };
 
+/**
+ * The words after `submission` read by this CLI's own parser, as the command reads them: the paper
+ * and `--pdf` a send names, null for their defaults — or null when the words would not run cleanly
+ * (a flag missing its value, an unknown flag, a stray operand), so `submission-confirm` says it
+ * cannot tell rather than guess.
+ */
+export function submissionSend(
+  words: readonly string[],
+): { readonly paper: string | null; readonly pdf: string | null } | null {
+  const a = parseArgs(["submission", ...words]);
+  const clean =
+    a.missingValue === undefined &&
+    a.unknownFlag === undefined &&
+    a.paths.length <= 2;
+  return clean ? { paper: a.paths[1] ?? null, pdf: a.pdf } : null;
+}
+
 /**
  * `paperlint hook <name>` — run an editor hook. It exists for ONE thing: so that the wiring does not
  * address the runtime from the project root.
@@ -1653,17 +1697,40 @@ function paperRequirements(dir: string): TexRequirements {
  * package, so the shipped union alone would not see it.
  */
 export function toolchainTex(cwd: string): TexRequirements {
+  const chains = projectPresets(cwd).map((p) => p.tex);
+  return declaredUnion(undefined, chains).tex;
+}
+
+/** The resolved venue preset of every paper under the project's papers directories, seen from `cwd`. */
+function projectPresets(cwd: string): readonly Preset[] {
   const cfg = readConfig(parseArgs(["toolchain"]), {
     log: () => {},
     err: () => {},
     cwd,
   });
   const roots = cfg.code === undefined ? papersRoots(cfg) : [];
-  const chains = roots
+  return roots
     .flatMap((r) => papersIn(r))
     .map((dir) => paperPreset(dir, PRESET_DEPS))
-    .flatMap((p) => (p.kind === "resolved" ? [p.preset.tex] : []));
-  return declaredUnion(undefined, chains).tex;
+    .flatMap((p) => (p.kind === "resolved" ? [p.preset] : []));
+}
+
+/**
+ * The host of every venue portal paperlint knows of from `cwd` — the shipped presets', and those the
+ * project's papers extend: what `submission-confirm` asks about when a request goes straight there.
+ */
+export function portalHosts(cwd: string): readonly string[] {
+  return [...resolveShipped(PRESET_DEPS), ...projectPresets(cwd)].flatMap(
+    (p) =>
+      p.portal === null
+        ? []
+        : [
+            p.portal.url
+              .replace(/^[a-z][a-z0-9+.-]*:\/\//iu, "")
+              .split("/", 1)
+              .join(""),
+          ],
+  );
 }
 
 /**
@@ -1755,6 +1822,7 @@ const SIMPLE: Readonly<
         site: portalSite,
         latex: latexReader,
         codec: sourcesCodec,
+        lintText,
         log,
         err,
       },
@@ -2082,6 +2150,32 @@ const isEmptySet = (e: unknown): boolean => {
   );
 };
 
+/**
+ * Findings on one file, printed by the formatter `paperlint lint` prints with — what `paperlint
+ * submission` shows of the venue rules before a send, so the two read the same.
+ */
+export async function lintText(
+  file: string,
+  messages: readonly VenueMessage[],
+): Promise<string> {
+  const errorCount = messages.filter((m) => m.severity === 2).length;
+  const result: Readonly<ESLint.LintResult> = {
+    filePath: file,
+    messages: [...messages],
+    suppressedMessages: [],
+    errorCount,
+    fatalErrorCount: 0,
+    warningCount: messages.length - errorCount,
+    fixableErrorCount: 0,
+    fixableWarningCount: 0,
+    usedDeprecatedRules: [],
+  };
+  return (await new ESLint().loadFormatter(LINT_FORMAT)).format([result]);
+}
+
+/** The formatter `paperlint lint` prints with. */
+const LINT_FORMAT = "stylish";
+
 /**
  * The end of `paperlint lint`: refuse an optional rule that reached no paper, print the findings, and
  * decide the exit code. Pulled out of `run` so each question has its own function.
@@ -2125,7 +2219,7 @@ async function reportLint(
     // Missing things are printed FIRST: they explain why the report below may be suspiciously
     // short. The reverse order would read as "all clean — oh, and also this".
     if (structure.length > 0) log(formatStructure(structure));
-    const out = await (await eslint.loadFormatter("stylish")).format(results);
+    const out = await (await eslint.loadFormatter(LINT_FORMAT)).format(results);
     log(
       out.trim() ||
         (structure.length > 0

package/src/cycle-rules.test.ts

@@ -8,15 +8,23 @@ import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { cycleRules } from "./cycle-rules.ts";
+import { frozenText } from "../test/frozen-presets.ts";
 
 const VENUES = presetsDir();
 const DIR = "/work/papers/p";
-/** The shipped presets, so a cycle naming `paperlint:msr` resolves through the memory files. */
-const SHIPPED = Object.fromEntries(
-  readdirSync(VENUES)
-    .filter((f) => f.endsWith(".jsonc"))
-    .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f), "utf8")]),
-);
+/**
+ * The shipped presets, so a cycle naming `paperlint:msr` resolves through the memory files — msr
+ * FROZEN (test/frozen-presets.ts): its deadlines are rewritten by the scheduled refresh, and the
+ * tests below assert the readings they sit beside.
+ */
+const SHIPPED = {
+  ...Object.fromEntries(
+    readdirSync(VENUES)
+      .filter((f) => f.endsWith(".jsonc"))
+      .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f), "utf8")]),
+  ),
+  [join(VENUES, "msr.jsonc")]: frozenText("msr.jsonc"),
+};
 
 interface Reported {
   readonly rule: string;

package/src/hooks-settings.harness.ts

@@ -65,9 +65,9 @@ check(
 // ── the one source: plugin/hooks/hooks.json ─────────────────────────────────────────────
 const wiring = shippedWiring();
 check(
-  "the hook names are DERIVED from hooks.json — four, in its order",
+  "the hook names are DERIVED from hooks.json — five, in its order",
   wiring.names.join() ===
-    "paper-edit-guard,paper-folder-layout,paper-skills-nudge,paper-status-gates",
+    "paper-edit-guard,submission-confirm,paper-folder-layout,paper-skills-nudge,paper-status-gates",
 );
 // ── settings written by hand: shapes Claude Code would ignore are skipped, not crashed on ──
 check(
@@ -284,7 +284,7 @@ try {
       "and names the hooks that are not wired in ANY form",
       r.status === "foreign" &&
         r.missing.join() ===
-          "paper-folder-layout,paper-skills-nudge,paper-status-gates",
+          "submission-confirm,paper-folder-layout,paper-skills-nudge,paper-status-gates",
     );
     // The control: without the check, vigiles' merge WOULD add a second copy. This is the
     // reason the check exists, measured rather than asserted.
@@ -320,13 +320,13 @@ try {
   const wiredOnce = merge({}, wiring.compiled, MANAGED_BY);
   check(
     "wired once each → ✓ wired, with the fresh-clone consequence",
-    /✓ wired — paper-edit-guard, paper-folder-layout, paper-skills-nudge, paper-status-gates, once each/.test(
+    /✓ wired — paper-edit-guard, submission-confirm, paper-folder-layout, paper-skills-nudge, paper-status-gates, once each/.test(
       doc(wiredOnce),
     ) && /cannot run until `npm install`/.test(doc(wiredOnce)),
   );
   check(
     "nothing wired → ⚠ not wired, with the remedy",
-    /⚠ not wired — none of the 4 hooks/.test(doc({})),
+    /⚠ not wired — none of the 5 hooks/.test(doc({})),
   );
   const twice = PreToolUseSettings.parse(structuredClone(wiredOnce));
   twice.hooks.PreToolUse[0]?.hooks.push({
@@ -354,7 +354,7 @@ try {
   });
   check(
     "🔴 partly wired BY HAND → the remedy is NOT `npx paperlint init`, which would refuse to write",
-    /partly wired — missing: paper-folder-layout, paper-skills-nudge, paper-status-gates/.test(
+    /partly wired — missing: submission-confirm, paper-folder-layout, paper-skills-nudge, paper-status-gates/.test(
       handPartial,
     ) && /writes nothing then/.test(handPartial),
   );

package/src/presets.test.ts

@@ -10,6 +10,7 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
+import { frozenText } from "../test/frozen-presets.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { parsePreset } from "./tex-requirements.ts";
 import {
@@ -23,18 +24,27 @@ import {
 } from "./presets.ts";
 
 const VENUES = presetsDir();
-const shipped = Object.fromEntries(
+const live = Object.fromEntries(
   readdirSync(VENUES)
     .filter((f) => f.endsWith(".jsonc") || f.endsWith(".json"))
     .map((f) => [join(VENUES, f), readFileSync(join(VENUES, f))]),
 );
+// The shipped msr.jsonc's deadlines are rewritten by the scheduled refresh, so the tests of LOGIC
+// read it FROZEN (test/frozen-presets.ts); only the shape test below reads the shipped file.
+const shipped = {
+  ...live,
+  [join(VENUES, "msr.jsonc")]: frozenText("msr.jsonc"),
+};
 const PAPER_FILE = "/work/papers/p/paperlint.json";
-const deps = (extra: Record<string, string> = {}) => ({
-  files: memoryFiles({ ...shipped, ...extra }),
+const deps = (extra: Record<string, string> = {}, base = shipped) => ({
+  files: memoryFiles({ ...base, ...extra }),
   venuesDir: VENUES,
 });
-const resolve = (spec: string, extra: Record<string, string> = {}) =>
-  resolvePreset(spec, PAPER_FILE, deps(extra));
+const resolve = (
+  spec: string,
+  extra: Record<string, string> = {},
+  base = shipped,
+) => resolvePreset(spec, PAPER_FILE, deps(extra, base));
 /** A venue preset of a project's own: the identity every venue declares, then `body`. */
 const venue = (body: Record<string, unknown>, name = "Our Workshop"): string =>
   JSON.stringify({
@@ -80,7 +90,7 @@ describe("shipped presets", () => {
 
 describe("shipped presets: paperlint:msr", () => {
   it("paperlint:msr → msr over ieee-conference: one kind, appendices counted as body, compsoc forbidden", () => {
-    const r = resolve("paperlint:msr");
+    const r = resolve("paperlint:msr", {}, live);
     expect(r.ok).toBe(true);
     if (!r.ok) return;
     expect(r.value.chain.map((f) => f.split("/").pop())).toEqual([
@@ -103,26 +113,26 @@ describe("shipped presets: paperlint:msr", () => {
       kind: "hotcrp",
       url: "https://msr2027.hotcrp.com",
     });
-    // The portal's deadlines, read 2026-10-19 18:05 UTC off https://msr2027.hotcrp.com/deadlines:
-    // «Wednesday Oct 21, 2026, 7:59:59 AM EDT» (`"sub":1792583999`) and «Saturday Oct 24, 2026,
-    // 7:59:59 AM EDT» (#235).
-    expect(r.value.deadlines).toEqual([
-      {
-        what: "submission",
-        at: "2026-10-21T11:59:59Z",
-        source: "portal",
-        url: "https://msr2027.hotcrp.com/deadlines",
-        read: "2026-10-19",
-      },
-      {
-        what: "resubmission",
-        at: "2026-10-24T11:59:59Z",
+    // The deadlines' SHAPE, never their dates: the scheduled refresh rewrites those whenever the
+    // portal moves them (deadlines.yml), and a date asserted here turns its pull request red.
+    // Guards: the shipped preset keeps a submission deadline, every reading is the portal's own
+    // from the venue's deadlines page, with a read day and an instant that carries its zone.
+    expect(r.value.deadlines.map((d) => d.what)).toContain("submission");
+    expect(
+      r.value.deadlines.map((d) => ({
+        source: d.source,
+        url: d.url,
+        read: /^\d{4}-\d{2}-\d{2}$/.test(d.read),
+        at: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(d.at),
+      })),
+    ).toEqual(
+      r.value.deadlines.map(() => ({
         source: "portal",
         url: "https://msr2027.hotcrp.com/deadlines",
-        read: "2026-10-19",
-      },
-    ]);
-    expect(Date.parse("2026-10-21T11:59:59Z") / 1000).toBe(1792583999);
+        read: true,
+        at: true,
+      })),
+    );
     // No rule turned on: the IEEE capitalization rule has not been read and quoted.
     expect(r.value.rules).toEqual({});
     expect(r.value.registerAnchors).toEqual([]);