@heyramzi/lint 0.0.0-stage → 1.32.4

package/scripts/jev-bench.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Scores every held-out line against every Jev shape. Exits 1 when a bad line fails nothing or a plain line fails something. Run after any change to SHAPES: `node scripts/jev-bench.mjs`.
+
+// Needs KILO_API_KEY, from the env or Proton Pass (Dev vault, item Kilo).
+
+import { PARAGRAPHS, SENTENCES } from "#lint/data/jev-bench.js";
+import { PARAGRAPH_SHAPES, SHAPES, auditShapes, kiloKey } from "#lint/jev.js";
+
+// Measuring the model, so no cached score stands in for a fresh answer.
+process.env.HEYRAMZI_SLOP_CACHE = "off";
+
+const FAIL = 0.75;
+let wrong = 0;
+const key = kiloKey();
+
+async function score(rows, shapes, wrap) {
+  for (const row of rows) {
+    const { findings, review } = await auditShapes(wrap(row.text), { key });
+    const scores = Object.fromEntries(Object.keys(shapes).map((id) => [id, 0]));
+    for (const hit of [...findings, ...review])
+      if (hit.id in scores) scores[hit.id] = Math.max(scores[hit.id], hit.p);
+    const failed = Object.entries(scores)
+      .filter(([, p]) => p >= FAIL)
+      .map(([id]) => id);
+    const ok = row.shape ? failed.length > 0 : failed.length === 0;
+    if (!ok) wrong += 1;
+    const label =
+      ok && row.shape && !failed.includes(row.shape) ? ` (caught as ${failed.join(", ")})` : "";
+    const shown = Object.entries(scores)
+      .map(([id, p]) => `${id} ${p.toFixed(2)}`)
+      .join("  ");
+    console.log(
+      `${ok ? "ok  " : "MISS"} ${(row.shape ?? "plain").padEnd(11)} ${row.text.slice(0, 60)}${label}\n       ${shown}`,
+    );
+  }
+}
+
+await score(SENTENCES, SHAPES, (text) => text);
+await score(PARAGRAPHS, PARAGRAPH_SHAPES, (text) => text);
+console.log(`\n${wrong} on the wrong side of ${FAIL}`);
+process.exit(wrong ? 1 : 0);

package/scripts/jev-code-bench.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+// Scores the Jev code rules on the synthetic set, per tier. Exits 1 when HELDOUT misses its bar.
+// `node scripts/jev-code-bench.mjs [train|heldout|all]`. Needs KILO_API_KEY (env or Proton Pass). Why: TECHLOG.md.
+
+import { HELDOUT, TRAIN } from "#lint/data/jev-code-bench.js";
+import { auditCode } from "#lint/jev-code.js";
+import { kiloKey } from "#lint/jev.js";
+
+const set = process.argv[2] ?? "all";
+const key = kiloKey();
+
+async function score(name, cases) {
+  const tally = { bad: 0, high: 0, medium: 0, plain: 0, fpHigh: 0, fpMedium: 0 };
+  const rows = await Promise.all(
+    cases.map(async (c) => ({ c, r: await auditCode(c.code, c.file, { key }) })),
+  );
+  for (const { c, r } of rows) {
+    const high = new Set(r.findings.map((h) => h.id));
+    const medium = new Set(r.review.map((h) => h.id).filter((id) => !high.has(id)));
+    const fired =
+      [...high]
+        .map((id) => `${id}!`)
+        .concat([...medium].map((id) => `${id}?`))
+        .join(" ") || "-";
+    let verdict;
+    if (c.rule) {
+      tally.bad++;
+      if (high.has(c.rule)) {
+        tally.high++;
+        verdict = "high";
+      } else if (medium.has(c.rule)) {
+        tally.medium++;
+        verdict = "med ";
+      } else verdict = "MISS";
+    } else {
+      tally.plain++;
+      if (high.size) {
+        tally.fpHigh++;
+        verdict = "FP! ";
+      } else if (medium.size) {
+        tally.fpMedium++;
+        verdict = "fp? ";
+      } else verdict = "ok  ";
+    }
+    console.log(`${verdict} ${(c.rule ?? "plain").padEnd(11)} ${c.file.padEnd(36)} ${fired}`);
+  }
+  const pct = (n, d) => `${Math.round((100 * n) / d)}%`;
+  console.log(
+    `\n${name}: caught ${pct(tally.high, tally.bad)} at high, ${pct(tally.high + tally.medium, tally.bad)} with medium; ` +
+      `false alarms on plain code ${pct(tally.fpHigh, tally.plain)} at high, ${pct(tally.fpHigh + tally.fpMedium, tally.plain)} with medium\n`,
+  );
+  return tally;
+}
+
+if (set !== "heldout") await score("train", TRAIN);
+if (set !== "train") {
+  const t = await score("heldout", HELDOUT);
+  // The bar: medium tier catches 3 in 4, and a high-tier alarm never fires on plain code.
+  const ok = (t.high + t.medium) / t.bad >= 0.75 && t.fpHigh === 0;
+  process.exit(ok ? 0 : 1);
+}

package/scripts/measure-register.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * Recount a corpus, so a band in `register.js` is never a typed number.
+ */
+
+/*
+ * node scripts/measure-register.mjs <file|dir> [more...]
+ */
+
+/*
+ * A directory is read one level deep for .txt and .md. A `.json` file is read
+ */
+
+/*
+ * as an array of posts and every string field longer than 40 characters is treated as body text, which is the shape `voice-corpus` writes.
+ */
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { measureRegister } from "#lint/register.js";
+
+function bodies(target) {
+  const st = statSync(target);
+  if (st.isDirectory()) {
+    return readdirSync(target)
+      .filter((f) => /\.(txt|md)$/i.test(f))
+      .flatMap((f) => bodies(join(target, f)));
+  }
+  if (target.endsWith(".json")) {
+    const data = JSON.parse(readFileSync(target, "utf8"));
+    if (!Array.isArray(data)) throw new Error(`${target} is not a JSON array of posts.`);
+    return data
+      .map((r) =>
+        typeof r === "string"
+          ? r
+          : Object.values(r).find((v) => typeof v === "string" && v.length > 40),
+      )
+      .filter(Boolean);
+  }
+  return [readFileSync(target, "utf8")];
+}
+
+const targets = process.argv.slice(2);
+if (targets.length === 0) {
+  process.stderr.write("usage: measure-register.mjs <file|dir|json> [more...]\n");
+  process.exit(2);
+}
+
+const m = measureRegister(targets.flatMap(bodies).join("\n\n"));
+const row = (k, v) => console.log(`  ${k.padEnd(16)} ${v.toFixed(1)}`);
+console.log(`${m.words} words, ${m.sentences} sentences`);
+row("meanSentence", m.meanSentence);
+row("medianSentence", m.medianSentence);
+row("fragmentShare", m.fragmentShare);
+row("longShare", m.longShare);
+row("lengthVariation", m.lengthVariation);
+row("contractions", m.contractions);
+row("secondPerson", m.secondPerson);
+row("firstPerson", m.firstPerson);
+row("chaining", m.chaining);
+row("egoRatio", m.egoRatio);

package/slop-views.js

@@ -0,0 +1,122 @@
+/**
+ * The views of a draft the audit judges: code, comments, strings and FAQ sections cut away, and the names its prose keeps.
+ */
+
+/**
+ * Code is not copy.
+ */
+
+/*
+ * `#if`, `#endif`, `#Preview` and `#available` are Swift, `#newlink` is a DOM id and `#sales-alerts` is a Slack channel: all 16 hashtag hits in the first corpus run were one of
+ */
+
+/*
+ * those, every one of them inside a fence or a backtick span. Only the hashtag check reads this, because only it is confused by code.
+ */
+export function withoutCode(text) {
+  return (
+    text
+      .replace(/```[\s\S]*?```/g, " ")
+      .replace(/`[^`\n]*`/g, " ")
+      // A tool directive is syntax the file has to carry: `/* eslint-enable ... */`
+      // failed the banned word `enable` in 2 files that contain no copy at all.
+      .replace(
+        /\/[*/][ \t]*(?:eslint|oxlint|prettier|biome|c8|v8|ts-(?:ignore|expect-error|nocheck))[^\n]*/g,
+        " ",
+      )
+  );
+}
+
+/** A source file with its comments blanked. Comments are notes to the next developer, not copy; `comment-length` gates them. */
+export function withoutComments(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
+    .replace(/(^|[\s;{}(,])\/\/[^\n]*/g, "$1");
+}
+
+/**
+ * The copy inside a source file: string literals of 2+ words, comments gone. The ledger read `get
+ * ours()` and `winner: "ours"` as first person: 24 false hits.
+ */
+export function copyStrings(text) {
+  const literals =
+    withoutComments(text).match(/"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`|'(?:[^'\\\n]|\\.)*'/g) ?? [];
+  return literals.filter((s) => /\p{L}{2,}\s+\p{L}{2,}/u.test(s)).join("\n");
+}
+
+/**
+ * A string literal's first sentence is sentence-initial, and every anchored pattern used to miss it.
+ */
+
+/*
+ * The anchors in `patterns` accept `^`, a newline, or `.!?` plus a space.
+ */
+
+/*
+ * In a copy module the sentence opens after `key: "`, which is none of the three, so `nobody-opener` and the 4 other anchored patterns never fired on the first sentence
+ */
+
+/*
+ * of any string. sitesmiths keeps every word of the page in `copy.ts`, ran the gate as its AGENTS.md tells it to, and shipped "Nobody
+ */
+
+/*
+ * pays us to start." past a pattern that had been lint-enforced since 5 Sep 2026. Opening the quote into a line break makes the anchors true again.
+ */
+
+/*
+ * Only for files the caller says are source, because in markdown `he said, "Nobody knows."` is a quotation rather than a key, and it stays one.
+ */
+export function withStringStarts(text) {
+  return text.replace(/([:(,=[]\s*)["'`]/g, "$1\n");
+}
+
+/**
+ * An FAQ is the one section where a question heading is the right heading: it is written to match the query the reader typed,
+ */
+
+/*
+ * and it holds its own subheadings by design. `question-heading` and `empty-section` skip it rather than asking a page to hide the question it answers.
+ */
+export const FAQ_TITLE =
+  /^(?:FAQ|F\.A\.Q\.?|Frequently asked questions|よくある質問|Questions? fréquentes?)$/i;
+
+export function withoutFaqSections(text) {
+  let depth = 0;
+  return text
+    .split("\n")
+    .map((line) => {
+      const heading = /^(#{1,6})[ \t]+(.+?)[ \t]*#*$/.exec(line);
+      if (heading) {
+        const level = heading[1].length;
+        if (depth && level <= depth) depth = 0;
+        if (!depth && FAQ_TITLE.test(heading[2].trim())) depth = level;
+      }
+      return depth ? "" : line;
+    })
+    .join("\n");
+}
+
+/**
+ * The words the body capitalises mid-sentence, which are names rather than styling.
+ */
+
+/*
+ * Without it every review page naming 2 products failed `title-case-heading`: "What Wispr Flow does better than Wavenote" counts 2 capitals and none of them is a styling choice.
+ */
+
+/*
+ * Headings are excluded from the scan so a title-cased heading cannot vouch for itself.
+ */
+export function properNouns(body) {
+  const found = new Set();
+  for (const line of body.replace(/^#{1,6}[ \t]+.*$/gm, " ").split("\n")) {
+    let start = true;
+    for (const raw of line.trim().split(/\s+/)) {
+      const word = raw.replace(/^[^\p{L}]+/u, "").replace(/[^\p{L}\p{N}'’-]+$/u, "");
+      if (word && !start && /^[A-ZÀ-Þ]/.test(word)) found.add(word);
+      start = /[.!?:][""''”’)\]]?$/.test(raw);
+    }
+  }
+  return found;
+}

package/slop.d.ts

@@ -0,0 +1,53 @@
+export type SlopFinding = {
+  /** `word`, `phrase`, `pattern`, `artifact`, `structure`, `dash`, `emoji`, `hashtag` or `ledger`. */
+  kind: string;
+  /** The banned word, the phrase, the pattern id, or the check name. */
+  id: string;
+  /** The offending text, trimmed to something readable in a terminal. */
+  detail: string;
+};
+
+export type SlopAudit = {
+  /** Every hit. A non-empty list fails the gate. */
+  findings: SlopFinding[];
+  /** Shapes a regex cannot judge. Reported, never failed. */
+  review: SlopFinding[];
+  /** The language the checks ran in. English on a tie. */
+  language: "en" | "fr";
+  /** First-person against second-person word counts, in that language. */
+  ledger: { first: number; second: number };
+  words: number;
+};
+
+export type SlopLint = SlopAudit & {
+  /** The text with every invisible character removed. Always safe to send. */
+  text: string;
+  /** What was removed, one row per character kind. */
+  removed: { what: string; count: number }[];
+  /** True when `findings` is empty. Says whether the words are good enough. */
+  ok: boolean;
+};
+
+/** HTML in, plain text out, so an email body audits the same way a post does. */
+export declare function stripMarkup(raw: string): string;
+
+/** Remove the invisible characters and normalise the fake spaces. */
+export declare function stripInvisibles(
+  text: string,
+  options?: { normalizeSpaces?: boolean },
+): { text: string; removed: { what: string; count: number }[] };
+
+/** True when the text carries nothing invisible. */
+export declare function isClean(text: string): boolean;
+
+/** Which language the draft is in, by stopword count. English on a tie. */
+export declare function detectLanguage(text: string): "en" | "fr";
+
+/** The enumerable half of the humanizer, over one string. Never rewrites. */
+export declare function auditSlop(text: string): SlopAudit;
+
+/** Clean, then audit. The one call a publishing path makes. */
+export declare function slopGate(
+  raw: string,
+  options?: { markup?: boolean; normalizeSpaces?: boolean },
+): SlopLint;