@heyramzi/lint 0.0.0-stage → 1.32.2

package/bin/heyramzi-jev-code.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * `heyramzi-jev-code <file...>` or `--hook` (PostToolUse). 0.75+ exits 2, 0.6 to 0.75 returns
+ * context to double-check, and no key or a timeout passes. Why: TECHLOG.md.
+ */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { NO_KEY, kiloKey } from "#lint/jev.js";
+import { RULES, auditCode } from "#lint/jev-code.js";
+
+// =========================
+// CONSTANTS
+// =========================
+const STUDIO = process.env.JEV_CODE_ROOT ?? join(homedir(), "Studio");
+const SKIP =
+  /\/(node_modules|dist|build|\.svelte-kit|\.next|coverage|\.claude|\.codex|\.gemini|\.opencode|vendor|generated)\/|\.min\.js$|\.d\.ts$/;
+/** Chunks of 60 lines; a Write of a whole file is judged on its first 240. */
+const MAX_CHARS = 240 * 80;
+const TIMEOUT_MS = 20_000;
+
+// =========================
+// FUNCTIONS
+// =========================
+/** The text an Edit, MultiEdit or Write put into the file. */
+export function writtenText(input) {
+  if (typeof input.content === "string") return input.content;
+  if (typeof input.new_string === "string") return input.new_string;
+  if (Array.isArray(input.edits)) return input.edits.map((e) => e.new_string ?? "").join("\n\n");
+  return "";
+}
+
+function report({ findings, review }, file) {
+  const line = (h) => `- ${h.id} (${h.p.toFixed(2)}): ${RULES[h.id].fix}`;
+  const out = [];
+  if (findings.length)
+    out.push(`jev-code: ${file} breaks a coding rule. Fix it now:`, ...findings.map(line));
+  if (review.length)
+    out.push(
+      `jev-code: double-check ${file}; these may not apply here, so fix only what's real:`,
+      ...review.map(line),
+    );
+  if (out.length)
+    out.push(
+      "Change only the file you edited. Never delete a file or edit code you haven't read to satisfy a rule.",
+    );
+  return out.join("\n");
+}
+
+const dedupe = (hits) => [
+  ...new Map(hits.toSorted((a, b) => b.p - a.p).map((h) => [h.id, h])).values(),
+];
+
+async function hook() {
+  let input;
+  try {
+    input = JSON.parse(readFileSync(0, "utf8"));
+  } catch {
+    return 0;
+  }
+  const file = input.tool_input?.file_path ?? "";
+  if (!file.startsWith(`${STUDIO}/`) || SKIP.test(file)) return 0;
+  const code = writtenText(input.tool_input).slice(0, MAX_CHARS);
+  const k = kiloKey();
+  if (!code || !k) return 0;
+
+  const timeout = new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS).unref());
+  const result = await Promise.race([auditCode(code, file, { key: k }).catch(() => null), timeout]);
+  if (!result) return 0;
+  const hits = { findings: dedupe(result.findings), review: dedupe(result.review) };
+  hits.review = hits.review.filter((r) => !hits.findings.some((f) => f.id === r.id));
+  if (hits.findings.length) {
+    process.stderr.write(`${report(hits, file)}\n`);
+    return 2;
+  }
+  if (hits.review.length) {
+    const additionalContext = report(hits, file);
+    process.stdout.write(
+      JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } }),
+    );
+  }
+  return 0;
+}
+
+async function files(paths) {
+  const k = kiloKey();
+  if (!k) {
+    process.stderr.write(`heyramzi-jev-code ${NO_KEY}\n`);
+    return 2;
+  }
+  let failed = false;
+  for (const file of paths) {
+    const { findings, review } = await auditCode(readFileSync(file, "utf8"), file, { key: k });
+    const text = report({ findings: dedupe(findings), review: dedupe(review) }, file);
+    if (text) console.log(text);
+    failed ||= findings.length > 0;
+  }
+  return failed ? 1 : 0;
+}
+
+const args = process.argv.slice(2);
+if (!args.length) {
+  process.stderr.write("usage: heyramzi-jev-code <file...> | --hook\n");
+  process.exit(2);
+}
+process.exit(args[0] === "--hook" ? await hook() : await files(args));

package/bin/heyramzi-push-diff.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * The pushed-diff gate: no changed `StorageKey` string. Rule and message: `push-diff.js`.
+ * Run it from a pre-push hook.
+ *
+ *   heyramzi-push-diff [--base <rev>]  # non-zero when the push changes a stored key's value
+ */
+
+import { execFileSync } from "node:child_process";
+import { exit } from "node:process";
+
+import { gateFiles } from "#lint/gate-files.js";
+import { changedStorageValues, hasStorageKeys, report } from "#lint/push-diff.js";
+
+const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+const git = (args) =>
+  execFileSync("git", args, { cwd: repoRoot, encoding: "utf8", maxBuffer: 512 * 1024 * 1024 });
+const tryGit = (args) => {
+  try {
+    return git(args);
+  } catch {
+    return "";
+  }
+};
+
+const flagAt = process.argv.indexOf("--base");
+const base = (flagAt === -1 ? process.env.PUSH_BASE : process.argv[flagAt + 1]) || mergeBase();
+
+if (!base) {
+  console.log("push-diff: skip (no upstream to compare with)");
+  exit(0);
+}
+
+const changed = changedFiles();
+const inPush = new Set(gateFiles(repoRoot, [...changed.keys()]));
+const files = [...changed].filter(([file]) => inPush.has(file));
+
+const storage = registryFiles(files.map(([file]) => file)).flatMap((file) =>
+  changedStorageValues(
+    tryGit(["show", `${base}:${changed.get(file)}`]),
+    tryGit(["show", `HEAD:${file}`]),
+  ).map((change) => ({ file, ...change })),
+);
+
+if (storage.length === 0) {
+  console.log("push-diff: no changed StorageKey string");
+} else {
+  console.error(report(storage));
+  exit(1);
+}
+
+function mergeBase() {
+  for (const upstream of ["@{u}", "origin/HEAD"]) {
+    const found = tryGit(["merge-base", "HEAD", upstream]).trim();
+    if (found) return found;
+  }
+  return "";
+}
+
+/** New path to old path for every added, copied, modified or renamed file. A pure move is R100 and changes nothing. */
+function changedFiles() {
+  const fields = git(["diff", "--name-status", "-M", "-z", "--diff-filter=ACMR", base, "HEAD"]).split(
+    "\0",
+  );
+  const map = new Map();
+  for (let index = 0; index < fields.length - 1; ) {
+    const status = fields[index];
+    const paired = status.startsWith("R") || status.startsWith("C");
+    const target = fields[index + (paired ? 2 : 1)];
+    if (status !== "R100") map.set(target, paired ? fields[index + 1] : target);
+    index += paired ? 3 : 2;
+  }
+  return map;
+}
+
+/** The changed files that hold a `StorageKey` registry. One `git grep` per 200 paths keeps the command line short. */
+function registryFiles(candidates) {
+  const code = candidates.filter((file) => /\.(?:ts|js|mjs|cjs)$/.test(file));
+  const found = [];
+  for (let index = 0; index < code.length; index += 200) {
+    const out = tryGit([
+      "grep",
+      "-l",
+      "-E",
+      String.raw`(enum[[:space:]]+StorageKey[[:space:]]*\{|StorageKey[[:space:]]*(:[^=]+)?=[[:space:]]*\{)`,
+      "HEAD",
+      "--",
+      ...code.slice(index, index + 200),
+    ]);
+    found.push(...out.split("\n").filter(Boolean).map((line) => line.replace(/^HEAD:/, "")));
+  }
+  return found.filter((file) => hasStorageKeys(tryGit(["show", `HEAD:${file}`])));
+}

package/bin/heyramzi-repo-rules.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * The repo-rules gate over staged files. Usage: this package's README, "Repo Rules Gate".
+ *
+ *   heyramzi-repo-rules        # non-zero when a staged file breaks a rule
+ *   heyramzi-repo-rules --all  # judge every tracked file, for an audit
+ */
+
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { exit } from "node:process";
+
+import { check, createTree, report } from "#lint/repo-rules.js";
+
+const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+const git = (args) =>
+  execFileSync("git", args, {
+    cwd: repoRoot,
+    maxBuffer: 256 * 1024 * 1024,
+    stdio: ["pipe", "pipe", "ignore"],
+  });
+const all = process.argv.includes("--all");
+
+const tracked = git(["ls-files", "-z"]).toString("utf8").split("\0").filter(Boolean);
+const changes = all ? { touched: tracked, added: tracked } : staged();
+const tree = createTree({ ...changes, tracked, read: all ? readWorking : readStaged });
+
+const violations = check(tree);
+if (violations.length === 0) {
+  console.log(`repo-rules: ${all ? "every tracked" : "every staged"} file passes`);
+} else {
+  console.error(report(violations));
+  exit(1);
+}
+
+/** What the commit changes. A pure move (R100) keeps its content, but its new path still counts as added. */
+function staged() {
+  const fields = git(["diff", "--cached", "--name-status", "-M", "-z", "--diff-filter=ACMR"])
+    .toString("utf8")
+    .split("\0");
+  const touched = [];
+  const added = [];
+  for (let index = 0; index < fields.length - 1;) {
+    const status = fields[index];
+    const paired = status.startsWith("R") || status.startsWith("C");
+    const target = fields[index + (paired ? 2 : 1)];
+    if (status !== "R100") touched.push(target);
+    if (status !== "M") added.push(target);
+    index += paired ? 3 : 2;
+  }
+  return { touched, added };
+}
+
+/** The staged blob, which is what gets committed. A binary file reads as text noise nobody matches. */
+function readStaged(file) {
+  try {
+    return git(["cat-file", "blob", `:${file}`]).toString("utf8");
+  } catch {
+    return null;
+  }
+}
+
+function readWorking(file) {
+  try {
+    return readFileSync(path.join(repoRoot, file), "utf8");
+  } catch {
+    return null;
+  }
+}

package/bin/heyramzi-slop.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+/**
+ * The publish gate on the command line, and the only entry point to it.
+ */
+
+/*
+ * heyramzi-slop draft.md                     report, exit 1 on any hit heyramzi-slop src/lib/content              a directory, walked heyramzi-slop a.md b.md src/copy           any mix of files and directories
+ */
+
+/*
+ * heyramzi-slop short.md --register=shorts   also grade the delivery rates heyramzi-slop draft.html --fix             rewrite with the invisibles gone heyramzi-slop draft.md --json              machine-readable, for a build step
+ */
+
+/*
+ * cat draft.txt | heyramzi-slop -            stdin in, cleaned text on stdout
+ */
+
+/*
+ * It takes the paths itself rather than a shell pipeline, because `cat dir/*.ts |
+ */
+
+/*
+ * heyramzi-slop -` is what every repo invented instead, and it loses the file a hit is in. One command, whatever you point it at.
+ */
+
+/*
+ * `--fix` only ever removes invisible characters. It never touches a word: a ban list cannot write the replacement sentence, and a gate that guesses is a gate nobody trusts.
+ */
+
+/*
+ * The words are the writer's job, and the report names each one.
+ */
+
+/*
+ * Exit 1 on a slop hit, so a hook or a build step can gate on it.
+ */
+
+/*
+ * Exit 0 with invisible characters removed under `--fix`, because that half is repaired rather than reported.
+ */
+
+/*
+ * `--jev` adds model-scored shapes. They are a report, never a failure: one sentence scored 0.71, then 0.78.
+ */
+
+/*
+ * `--shape-block=0.85` makes a shape at that score or above fail the run. Scores are cached per sentence.
+ */
+
+/*
+ * With the model unreachable the exact patterns still run, stderr says the model check didn't, and the exit code is theirs.
+ */
+
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { patterns, shapes, titleTells } from "#lint/data/slop-words.js";
+import { REVIEW, auditShapes, isUnavailable, kiloKey, proseOf } from "#lint/jev.js";
+import { slopGate } from "#lint/slop.js";
+
+// =========================
+// CONSTANTS
+// =========================
+const READ = /\.(md|mdx|txt|html?|svelte|vue|m?[jt]sx?|json)$/i;
+const SKIP = new Set(["node_modules", ".git", ".svelte-kit", "dist", "build", ".next", "coverage"]);
+// Keys from upsys/app/src/lib/diagram/board-doc.ts.
+const BOARD_TITLE = new Set(["name", "label", "title", "headers"]);
+const BOARD_PROSE = new Set(["text", "point", "lines", "spoken", "a", "b", "rows", "kicker"]);
+const BOARD_CAPTION = new Set(["arrow", "annotate", "icon", "figure", "image"]);
+
+// =========================
+// FUNCTIONS
+// =========================
+/** Every file a path stands for. A directory is walked; a named file is taken as given. */
+function expand(path) {
+  if (path === "-") return [path];
+  if (!statSync(path).isDirectory()) return [path];
+  return readdirSync(path, { withFileTypes: true })
+    .filter((e) => !SKIP.has(e.name) && !e.name.startsWith("."))
+    .flatMap((e) => {
+      const child = join(path, e.name);
+      return e.isDirectory() ? expand(child) : READ.test(e.name) ? [child] : [];
+    })
+    .toSorted();
+}
+
+function gate(file, register) {
+  const raw = file === "-" ? readFileSync(0, "utf8") : readFileSync(file, "utf8");
+  // HTML gets its tags stripped before anything is matched, so an email body audits the same way a post does.
+
+  // A `--fix` on HTML still writes the original markup back with only the invisible characters gone, never the stripped prose.
+  const markup = /\.(html?|svelte|vue)$/i.test(file);
+  // A copy module opens its sentences after `key: "`, which no sentence anchor
+  // reads as a start. `withStringStarts` in slop.js carries what that cost.
+  const code = /\.(m?[jt]sx?|json)$/i.test(file);
+  if (/\.board\.json$/i.test(file)) return { raw, result: gateBoard(raw, register) };
+  const text = /\.mdx?$/i.test(file) ? proseOfMarkdown(raw) : raw;
+  return { raw, result: slopGate(text, { markup, code, register }) };
+}
+
+/**
+ * Markdown prose only: frontmatter and fences go blank, inline code becomes a neutral word.
+ * Unmasked, a fenced heading read as a second h1 (4 Oct 2026).
+ */
+function proseOfMarkdown(raw) {
+  const blank = (block) => block.replace(/[^\n]/g, "");
+  // A distinct token per span, or two spans side by side read as an echoed word.
+  let n = 0;
+  return (
+    raw
+      .replace(/^---\n[\s\S]*?\n---\n/, blank)
+      // `next dev` rewrites this block whenever it differs from its own copy, so an edit never sticks.
+      .replace(/<!-- BEGIN:nextjs-agent-rules -->[\s\S]*?<!-- END:nextjs-agent-rules -->/g, blank)
+      .replace(/^([ \t]*)(`{3,}|~{3,})[^\n]*\n[\s\S]*?\n\1\2[^\n]*$/gm, blank)
+      .replace(/`[^`\n]+`/g, () => `code${(n += 1)}`)
+  );
+}
+
+/** A board's titles face `titleTells` and its prose the gate; ids and layout numbers are neither. */
+function gateBoard(raw, register) {
+  const titles = [];
+  const prose = [];
+  (function walk(node, key, kind) {
+    if (Array.isArray(node)) return node.forEach((n) => walk(n, key, kind));
+    if (node && typeof node === "object") {
+      for (const [k, v] of Object.entries(node)) walk(v, k, node.kind);
+      return;
+    }
+    if (typeof node !== "string") return;
+    const heading = key === "text" && (kind === "title" || kind === "heading");
+    if ((BOARD_TITLE.has(key) && !BOARD_CAPTION.has(kind)) || heading) titles.push(node);
+    else if (BOARD_PROSE.has(key) || BOARD_TITLE.has(key)) prose.push(node);
+  })(JSON.parse(raw));
+  const result = slopGate([...titles, ...prose].join("\n\n"), { register });
+  for (const title of titles)
+    for (const t of titleTells.filter((t) => t.test.test(title)))
+      result.findings.push({
+        kind: "title",
+        id: t.id,
+        detail: `${JSON.stringify(title)}: ${t.rule}`,
+      });
+  result.ok = result.findings.length === 0;
+  return result;
+}
+
+/** The model-scored shapes of one file, or null after noting why the model could not answer. */
+async function modelShapes(file, raw) {
+  try {
+    jevKey ??= kiloKey();
+    const text = /\.(html?|svelte|vue)$/i.test(file) ? proseOf(raw) : raw;
+    return await auditShapes(text, { key: jevKey, block: shapeBlock });
+  } catch (err) {
+    if (!isUnavailable(err)) throw err;
+    jevDown = err.message;
+    return null;
+  }
+}
+
+function report(file, result, fixed) {
+  const { first, second } = result.ledger;
+  console.log(
+    `${file}: ${result.words} words, ${result.language}, ledger ${first} first / ${second} second`,
+  );
+  if (result.register) {
+    const m = result.register.measured;
+    console.log(
+      `  register ${result.register.label}: ${m.meanSentence.toFixed(1)} words/sentence, ` +
+        `${m.fragmentShare.toFixed(0)}% fragments, ${m.contractions.toFixed(1)} contractions/1k, ` +
+        `${m.secondPerson.toFixed(1)} you/1k, ${m.chaining.toFixed(1)} chaining/1k`,
+    );
+  }
+  for (const r of result.removed) {
+    console.log(`  invisible     ${r.what} x${r.count}${fixed ? " (removed)" : ""}`);
+  }
+  for (const f of result.findings) console.log(`  ${f.kind.padEnd(13)} ${f.id}  ${f.detail}`);
+  for (const r of result.review) console.log(`  ${r.kind.padEnd(13)} ${r.id}  ${r.detail}`);
+  if (result.removed.length === 0 && result.ok) console.log("clean");
+}
+
+// =========================
+// MAIN
+// =========================
+const args = process.argv.slice(2);
+const flags = new Set(args.filter((a) => a.startsWith("--")));
+const paths = args.filter((a) => !a.startsWith("--"));
+
+if (paths.length === 0) {
+  process.stderr.write(
+    "usage: heyramzi-slop <file|dir|-> [more...] [--fix] [--json] [--jev [--shape-block=0.6-1]] [--quiet] [--register=spoken|shorts|written] [--only=kind|id,...]\n",
+  );
+  process.exit(2);
+}
+
+const registerFlag = args.find((a) => a.startsWith("--register"));
+// A bare `--register`, or one written with a space, used to grade nothing and exit 0.
+
+// That is the worst thing a gate can do: silence a caller reads as a pass.
+if (registerFlag && !registerFlag.includes("=")) {
+  process.stderr.write("--register takes a value: --register=spoken|shorts|written\n");
+  process.exit(2);
+}
+const register = registerFlag ? registerFlag.split("=")[1] : undefined;
+
+// `--only=dash,emoji` keeps findings whose kind or id is named, dropping review and ledger. The
+// instruction-file hook runs it: the full set fails nearly every skill.
+const onlyFlag = args.find((a) => a.startsWith("--only"));
+if (onlyFlag && !onlyFlag.includes("=")) {
+  process.stderr.write("--only takes a value: --only=dash or --only=dash,emoji\n");
+  process.exit(2);
+}
+const only = onlyFlag ? new Set(onlyFlag.split("=")[1].split(",").filter(Boolean)) : null;
+
+// The opt-in bar. Below REVIEW would promise to block scores the model check never keeps.
+const blockFlag = args.find((a) => a.startsWith("--shape-block"));
+let shapeBlock = Infinity;
+if (blockFlag) {
+  shapeBlock = blockFlag.includes("=") ? Number(blockFlag.split("=")[1]) : Number.NaN;
+  if (!(shapeBlock >= REVIEW && shapeBlock <= 1) || !flags.has("--jev")) {
+    process.stderr.write(
+      `--shape-block takes a score from ${REVIEW} to 1 and needs --jev: --jev --shape-block=0.85\n`,
+    );
+    process.exit(2);
+  }
+}
+
+const files = paths.flatMap(expand);
+const results = [];
+/** Looked up once, on the first file that needs Jev. */
+let jevKey;
+/** Why the model check could not run, once it has failed: later files don't wait on it again. */
+let jevDown = "";
+
+for (const file of files) {
+  const { raw, result } = gate(file, register);
+  if (only) {
+    result.findings = result.findings.filter((f) => only.has(f.kind) || only.has(f.id));
+    result.review = [];
+    result.ok = result.findings.length === 0;
+  }
+  if (flags.has("--jev") && !jevDown) {
+    const found = await modelShapes(file, raw);
+    if (found) {
+      result.findings.push(...found.findings);
+      result.review.push(...found.review);
+      result.ok = result.ok && found.findings.length === 0;
+    }
+  }
+  if (flags.has("--jev")) result.jev = jevDown ? { ran: false, reason: jevDown } : { ran: true };
+  results.push({ file, raw, result });
+
+  if (flags.has("--fix") && result.removed.length > 0) {
+    const repaired = slopGate(raw, { markup: false }).text;
+    if (file === "-") process.stdout.write(repaired);
+    else writeFileSync(file, repaired);
+  }
+}
+
+// The pronoun ledger is a property of a body of copy, never of a file.
+
+// A module holding four nav labels is not selfish framing, it is a list, and it failed as one the first time this walked a directory.
+
+// So over several files it is measured once over all of them and the per-file copies go.
+let ledger = null;
+if (files.length > 1) {
+  for (const r of results) {
+    r.result.findings = r.result.findings.filter((f) => f.id !== "selfish-framing");
+    r.result.ok = r.result.findings.length === 0;
+  }
+  // Summed from each file's own ledger, which reads markup as prose and source as its copy strings.
+  const first = results.reduce((n, r) => n + r.result.ledger.first, 0);
+  const second = results.reduce((n, r) => n + r.result.ledger.second, 0);
+  if (!only && first > 0 && second < first)
+    ledger = { kind: "ledger", id: "selfish-framing", detail: `first ${first}, second ${second}` };
+}
+
+const ok = results.every((r) => r.result.ok) && !ledger;
+
+// Said on stderr in every mode, so a quiet or JSON run never reads as a full pass.
+if (jevDown)
+  process.stderr.write(
+    `model check did not run: ${jevDown}. Exact patterns only; the exit code is theirs alone.\n`,
+  );
+
+if (flags.has("--json")) {
+  console.log(JSON.stringify(files.length === 1 ? results[0].result : results, null, 2));
+  process.exit(ok ? 0 : 1);
+}
+
+if (files.length === 1 && files[0] === "-" && flags.has("--fix")) process.exit(ok ? 0 : 1);
+
+if (!flags.has("--quiet")) {
+  // A clean file prints one line, so a directory of them stays readable; a file
+  // with anything to say prints the detail under it.
+  for (const { file, result } of results) report(file, result, flags.has("--fix"));
+  if (ledger)
+    console.log(
+      `\nover all ${files.length} files:\n  ${ledger.kind.padEnd(13)} ${ledger.id}  ${ledger.detail}`,
+    );
+
+  const hits = results.reduce((n, r) => n + r.result.findings.length, 0) + (ledger ? 1 : 0);
+  const review = results.reduce((n, r) => n + r.result.review.length, 0);
+  const invisible = results.reduce((n, r) => n + r.result.removed.length, 0);
+  if (invisible > 0 && !flags.has("--fix")) {
+    console.log(`\nrun again with --fix to remove the invisible characters.`);
+  }
+  const scope = files.length === 1 ? "" : ` across ${files.length} files`;
+  console.log(`\n${hits} hits, ${review} to review by hand${scope}.`);
+  // Counted, never typed: the same two numbers were hand-written in this line
+  // and in SKILL.md, and both were stale within a week of the last promotion.
+  console.log(
+    `This is the enumerable half: ${patterns.length} patterns matched exactly. ${shapes.length} \`shapes\` still need a human read of humanizer references/patterns.md.`,
+  );
+}
+
+process.exit(ok ? 0 : 1);

package/bin/heyramzi-svelte-markup.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * The Svelte markup gate. Usage in packages/lint/README.md, "Svelte Markup Gate".
+ *
+ *   heyramzi-svelte-markup          # the pushed .svelte files, or all of them outside a push
+ *   heyramzi-svelte-markup --all    # every tracked .svelte file
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { exit } from "node:process";
+
+import { gateFiles } from "#lint/gate-files.js";
+import { findMarkupViolations, selectFiles } from "#lint/svelte-markup.js";
+
+const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+const args = process.argv.slice(2);
+if (args.includes("--all")) delete process.env.PUSH_FILES;
+const targets = args.filter((arg) => !arg.startsWith("-"));
+
+const tracked = execFileSync(
+  "git",
+  ["ls-files", "--cached", "--others", "--exclude-standard", "*.svelte"],
+  { cwd: repoRoot, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 },
+)
+  .trim()
+  .split("\n")
+  .filter(Boolean);
+
+const files = gateFiles(repoRoot, selectFiles(tracked, { targets })).filter((file) =>
+  existsSync(path.join(repoRoot, file)),
+);
+
+let failures = 0;
+for (const file of files) {
+  for (const { line, rule, message } of findMarkupViolations(
+    readFileSync(path.join(repoRoot, file), "utf8"),
+  )) {
+    console.error(`${file}:${line}: svelte-markup/${rule}: ${message}`);
+    failures += 1;
+  }
+}
+
+if (failures === 0) {
+  console.log(`svelte-markup: ${files.length} .svelte files, no Svelte 4 or broken markup`);
+} else {
+  console.error(`\nsvelte-markup: ${failures} violation(s) in ${files.length} .svelte files`);
+  exit(1);
+}

package/bin/heyramzi-ui-rules.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * The UI-rules gate over staged or pushed files. Usage: this package's README, "UI Rules Gate".
+ *
+ *   heyramzi-ui-rules          # staged files, or PUSH_FILES when the pre-push hook sets it
+ *   heyramzi-ui-rules --all    # every tracked file
+ *   heyramzi-ui-rules a.svelte # named files
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { exit } from "node:process";
+
+import { gateFiles } from "#lint/gate-files.js";
+import { checkFile, checkProject, durationNames, ignoredPath, report, resolvedDurations } from "#lint/ui-rules.js";
+
+const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+const git = (args) => execFileSync("git", args, { cwd: repoRoot, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+const lines = (text) => text.split("\n").filter(Boolean);
+
+const args = process.argv.slice(2);
+const all = args.includes("--all");
+const named = args.filter((arg) => !arg.startsWith("-"));
+if (all) delete process.env.PUSH_FILES;
+
+const tracked = lines(git(["ls-files", "--cached", "--others", "--exclude-standard"]));
+const candidates = named.length
+  ? named
+  : all
+    ? tracked
+    : process.env.PUSH_FILES === undefined
+      ? lines(git(["diff", "--cached", "--name-only", "--diff-filter=ACMR"]))
+      : lines(process.env.PUSH_FILES);
+
+const files = gateFiles(repoRoot, candidates.filter((file) => !ignoredPath(file)));
+const read = (file) => {
+  const full = path.join(repoRoot, file);
+  return existsSync(full) ? readFileSync(full, "utf8") : null;
+};
+
+let hits = [];
+for (const file of files) {
+  const source = read(file);
+  if (source === null) continue;
+  for (const hit of checkFile(file, source)) hits.push({ file, ...hit });
+}
+hits.push(...checkProject(files, tracked, read));
+if (hits.some((hit) => hit.rule === "duration-bare")) hits = resolvedDurations(hits, durationNames(tracked, read));
+
+if (hits.length === 0) {
+  console.log("ui-rules: no violations");
+} else {
+  console.error(report(hits));
+  exit(1);
+}