@heyramzi/lint 0.0.0-stage → 1.32.2

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.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;