@danielsimonjr/repo-tools 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -6,6 +6,42 @@ All notable changes to this project are recorded in this file. The format follow
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-09-25
+
+The STE release. `repo-tools ste` checks Markdown, and docstring prose with `--prose`, against the
+mechanically decidable part of ASD-STE100. It replaces the Python checker of the architecture-docs
+skill and the docstring harness of the code-docs skill. The port gives the same 362 findings as
+`ste_check.py` on 111 Markdown files. `ste` runs on Node 20, 22 and 24. A static test keeps the
+tool offline.
+
+### Added
+
+- Tests: `tests/unit/node-compat.test.ts` keeps regex modifier groups (`(?i:...)`) out of `src/`.
+  Node 20 and Node 22 cannot compile one. A rule regex compiles when its module loads. Thus one such
+  group stopped every subcommand of the Node bundle, although Bun and Node 24 ran it. The STE
+  rules now spell each case-insensitive word as letter classes (`ci`). The classes also match the
+  letters that Python's case-insensitive match accepts (U+0131 and U+0130 for `i`, U+017F for
+  `s`, U+212A for `k`). The STE output on Node 20 is byte-identical to the output on Bun.
+- `repo-tools ste`: checks Markdown against the mechanically decidable part of ASD-STE100
+  (sentence length in two tiers, wordy forms, ambiguous references, the passive voice with an
+  agent). The subcommand is a port of `ste_check.py` and `ste_rules.py` from the architecture-docs
+  skill.
+  `repo-tools ste --prose <file>` is the docstring harness of the code-docs skill, over the same
+  one rule module. `docs/design.md` has a table of every behavioral difference between the two
+  harnesses; a run of both on the same text proves each row. The port and `ste_check.py` give the
+  same 362 findings, byte for byte, on 111 Markdown files. The corpus holds the architecture docs
+  of memoryjs, Mathts and universal-physics-tensor, the repo-tools docs, and 17 files of a
+  private repository. Only the file order differs: the port sorts in code-unit order on every
+  operating system.
+- `docs/design.md`: 8 STE findings fixed (the new checker found them); the document is STE-clean.
+- Tests: `tests/unit/offline.test.ts` keeps the tool offline. It fails when a file in `src/`
+  imports a network module (`http`, `https`, `http2`, `net`, `dgram`, `tls`, `dns`, `undici`,
+  `ws`, with or without `node:`) or uses a network global (`fetch`, `WebSocket`,
+  `XMLHttpRequest`, `EventSource`, `Bun.connect`, `Bun.listen`, `Bun.serve`, `Bun.udpSocket`,
+  `navigator.sendBeacon`). repo-tools reads private repositories, so it must never send their
+  content. 18 positive controls prove that the scan finds each form, and a planted `fetch` in
+  `src/` fails the test.
+
 ## [1.0.0] - 2026-09-24
 
 The first release. One command, `repo-tools`, replaces the copies of the repository tools that

package/README.md

@@ -1,6 +1,6 @@
 # repo-tools
 
-`repo-tools` is one command-line tool with four subcommands for TypeScript repositories:
+`repo-tools` is one command-line tool with five subcommands for repositories:
 
 | Subcommand | Job |
 |---|---|
@@ -8,10 +8,11 @@
 | `chunk` | Splits a large file into chunks, merges the chunks back, and shows which chunks changed. |
 | `compress` | Writes a compact copy of a file for a model context, and restores it. |
 | `query` | Answers structural questions from the depgraph reports, and writes two derived reports. |
+| `ste` | Checks Markdown or docstring prose against Simplified Technical English. |
 
-Status: version 1.0.0.
+Status: version 1.1.0.
 
-- All four subcommands work.
+- All five subcommands work.
 - `depgraph` and `query` read their settings from `repo-tools.config.json` in the root.
   `--config=<file>` makes either subcommand read another file.
 - `compress -d` restores JSON files only.
@@ -33,7 +34,7 @@ repo-tools --version
 
 The executable holds the tool and the Bun runtime. It needs no Bun, Node or `node_modules`.
 Download the file for your platform and `SHA256SUMS` from the
-[GitHub release](https://github.com/danielsimonjr/repo-tools/releases/tag/v1.0.0):
+[GitHub release](https://github.com/danielsimonjr/repo-tools/releases/tag/v1.1.0):
 
 | Platform | File |
 |---|---|

package/dist/cli.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@danielsimonjr/repo-tools",
-  version: "1.0.0",
+  version: "1.1.0",
   description: "One CLI for repository analysis: dependency graphs creation and query with per-export API facts, file chunking, and context compression. TypeScript on Bun, compiled to a single executable.",
   type: "module",
   license: "MIT",
@@ -10971,6 +10971,472 @@ async function run4(argv, io) {
   }
 }
 
+// src/ste/index.ts
+import { existsSync as existsSync14, lstatSync as lstatSync3, readdirSync as readdirSync3, readFileSync as readFileSync14, statSync as statSync7 } from "node:fs";
+import { basename as basename6, join as join15 } from "node:path";
+
+// src/ste/py.ts
+var SPACE_BODY = "\\t\\n\\v\\f\\r\\x1c-\\x1f \\x85\\xa0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000";
+var S = `[${SPACE_BODY}]`;
+var W = "[\\p{L}\\p{N}_]";
+var B = `(?:(?<=${W})(?!${W})|(?<!${W})(?=${W}))`;
+var D = "\\p{Nd}";
+var EXTRA_CASES = {
+  i: String.fromCharCode(305, 304),
+  s: String.fromCharCode(383),
+  k: String.fromCharCode(8490)
+};
+function ci(pattern) {
+  let out = "";
+  for (const ch of pattern) {
+    const lower = ch.toLowerCase();
+    if (lower >= "a" && lower <= "z" && lower.length === 1) {
+      out += `[${lower}${lower.toUpperCase()}${EXTRA_CASES[lower] ?? ""}]`;
+    } else
+      out += ch;
+  }
+  return out;
+}
+var SPACE_RUN = new RegExp(`${S}+`, "u");
+var LEADING_SPACE = new RegExp(`^${S}+`, "u");
+var TRAILING_SPACE = new RegExp(`${S}+$`, "u");
+function pyStrip(text) {
+  return text.replace(LEADING_SPACE, "").replace(TRAILING_SPACE, "");
+}
+function pyLstrip(text) {
+  return text.replace(LEADING_SPACE, "");
+}
+function pySplit(text) {
+  return text.split(SPACE_RUN).filter((part) => part !== "");
+}
+var LINE_ENDS = new Set([10, 11, 12, 13, 28, 29, 30, 133, 8232, 8233]);
+var CR = 13;
+var LF = 10;
+function pySplitlines(text) {
+  const lines = [];
+  let start = 0;
+  for (let i = 0;i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (!LINE_ENDS.has(c))
+      continue;
+    lines.push(text.slice(start, i));
+    if (c === CR && text.charCodeAt(i + 1) === LF)
+      i += 1;
+    start = i + 1;
+  }
+  if (start < text.length)
+    lines.push(text.slice(start));
+  return lines;
+}
+function isAlnum(ch) {
+  return /^[\p{L}\p{N}]$/u.test(ch);
+}
+function headCodePoints(text, n) {
+  return Array.from(text).slice(0, n).join("");
+}
+function codePointLength(text) {
+  return Array.from(text).length;
+}
+var NOT_PRINTABLE = /^[\p{Cc}\p{Cf}\p{Co}\p{Cn}\p{Cs}\p{Zl}\p{Zp}\p{Zs}]$/u;
+function pyRepr(text) {
+  const quote = text.includes("'") && !text.includes('"') ? '"' : "'";
+  let out = quote;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (ch === "\\")
+      out += "\\\\";
+    else if (ch === quote)
+      out += `\\${quote}`;
+    else if (ch === `
+`)
+      out += "\\n";
+    else if (ch === "\r")
+      out += "\\r";
+    else if (ch === "\t")
+      out += "\\t";
+    else if (ch !== " " && NOT_PRINTABLE.test(ch)) {
+      if (cp < 256)
+        out += `\\x${cp.toString(16).padStart(2, "0")}`;
+      else if (cp < 65536)
+        out += `\\u${cp.toString(16).padStart(4, "0")}`;
+      else
+        out += `\\U${cp.toString(16).padStart(8, "0")}`;
+    } else
+      out += ch;
+  }
+  return out + quote;
+}
+function reEscape(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/ste/rules.ts
+var IRREGULAR_PARTICIPLES = "read|built|sent|held|kept|made|found|put|set|run|lost|left|met|paid|told" + "|thrown|drawn|given|taken|shown|known|grown|blown" + "|cut|meant|dealt|felt|sold|said|spent|split|shut|hit|let|bred|fed|led";
+var DETERMINERS = "the|a|an|its|their|this|that|our|your|each|every" + "|his|her|my|these|those";
+var PASSIVE_SOURCE = `${B}(?:${ci("is|are|was|were|be|been|being")})${S}+` + `(?:${W}+(?:${ci("ed|en")})|(?:${ci(IRREGULAR_PARTICIPLES)}))${S}+` + `by${S}+(?:(?:${ci(DETERMINERS)})${B}|[A-Z\`])`;
+var AMBIGUOUS_VERBS = "is|are|was|were|be|will|can|may|must|does|do|has|have|should|shall" + "|disables?|enables?|causes?|returns?|means?|allows?|prevents?|makes?" + "|sets?|gets?|adds?|removes?|creates?|requires?|affects?|applies|happens?";
+var AMBIGUOUS_SOURCE = `(?:^|(?<=[.!?,;:])${S})${S}*(?:(?:${ci("and|but|or|so|then|yet")})${S}+)?` + `(${ci("it|this|that|these|those")})${S}+(?:${AMBIGUOUS_VERBS})${B}`;
+var WORDY = [
+  ["in order to", "to"],
+  ["at this point in time", "now"],
+  ["in the event that", "if"],
+  ["due to the fact that", "because"],
+  ["a number of", "some"],
+  ["utilise", "use"],
+  ["utilize", "use"],
+  ["prior to", "before"],
+  ["subsequent to", "after"],
+  ["in the case of", "for"],
+  ["in spite of the fact that", "although"],
+  ["for the purpose of", "to"],
+  ["has the ability to", "can"],
+  ["is able to", "can"]
+];
+var IDENTIFIER_SOURCE = "`[^`]*`" + `|${B}${W}+\\(\\)` + `|${B}${W}*[a-z]${W}*[A-Z]${W}*${B}` + `|${B}${W}+_${W}+${B}` + `|${B}${W}+\\.${W}+${B}`;
+var MAX_WORDS_PROCEDURAL = 20;
+var MAX_WORDS_DESCRIPTIVE = 25;
+function rule(source, flags = "") {
+  return new RegExp(source, `u${flags}`);
+}
+function stripIdentifiers(text) {
+  return text.replace(rule(IDENTIFIER_SOURCE, "g"), " ");
+}
+
+// src/ste/markdown.ts
+function stripNoise(text) {
+  const out = [];
+  let inFence = false;
+  const lines = pySplitlines(text);
+  let start = 0;
+  if (lines.length > 0 && pyStrip(lines[0]) === "---") {
+    for (let j = 1;j < lines.length; j++) {
+      if (pyStrip(lines[j]) === "---") {
+        start = j + 1;
+        break;
+      }
+    }
+  }
+  for (let i = start;i < lines.length; i++) {
+    const line = lines[i];
+    if (pyLstrip(line).startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence)
+      continue;
+    const s = pyStrip(line);
+    if (s === "" || s.startsWith("#") || s.startsWith("|") || s.startsWith(">"))
+      continue;
+    if (s.startsWith("---") || s.startsWith("<!--"))
+      continue;
+    if (s.startsWith("- Not:"))
+      continue;
+    out.push([i + 1, line]);
+  }
+  return out;
+}
+var LINK = /\[([^\]]*)\]\([^)]*\)/gu;
+var IDENTIFIER = rule(IDENTIFIER_SOURCE, "g");
+function proseOnly(line) {
+  const s = line.replace(LINK, (m, text) => text + " ".repeat(m.length - text.length));
+  return s.replace(IDENTIFIER, (m) => " ".repeat(m.length));
+}
+var EMPHASIS = /\*\*|__/gu;
+var DECIMAL2 = rule(`(${D})\\.(${D})`, "g");
+var SENTENCE_END = rule(`(?<=[.!?])${S}+`);
+function sentences(block) {
+  const guarded = block.replace(EMPHASIS, "").replace(DECIMAL2, "$1<DOT>$2");
+  return guarded.split(SENTENCE_END).map((part) => part.replaceAll("<DOT>", "."));
+}
+var CODE_SPAN = /`[^`]*`/gu;
+var EMPHASIS_CHARS = /[*_]/gu;
+var LIST_MARKER = rule(`^${S}*[-*${D}.]+${S}*`);
+function wordCount(sentence) {
+  const s = sentence.replace(CODE_SPAN, "X").replace(LINK, "$1").replace(EMPHASIS_CHARS, "").replace(LIST_MARKER, "");
+  return pySplit(s).filter((w) => Array.from(w).some(isAlnum)).length;
+}
+function join14(parts, start) {
+  const chunks = [];
+  const lineMap = [];
+  parts.forEach(([n, body], i) => {
+    if (i > 0) {
+      chunks.push(" ");
+      lineMap.push(n);
+    }
+    chunks.push(body);
+    for (let k = 0;k < body.length; k++)
+      lineMap.push(n);
+  });
+  return [start, chunks.join(""), lineMap];
+}
+function lineAt2(index, lineMap) {
+  return lineMap.length > 0 ? lineMap[Math.min(index, lineMap.length - 1)] : 0;
+}
+var LIST_ITEM = rule(`^${S}*(?:[-*+]|${D}+\\.)${S}`);
+var PROCEDURAL_STARTS = ["- [", "1.", "2.", "3.", "4.", "5.", "6."];
+var WORDY_RULES = WORDY.map(([phrase, better]) => [phrase, better, rule(`(?<![\\p{L}\\p{N}_-])${reEscape(phrase)}${B}`, "g")]);
+var AMBIGUOUS = rule(AMBIGUOUS_SOURCE, "g");
+var PASSIVE = rule(PASSIVE_SOURCE, "g");
+function paragraphs(text) {
+  const blocks = [];
+  let para = [];
+  let paraStart = 0;
+  let prevLine = -2;
+  for (const [n, line] of stripNoise(text)) {
+    const startsItem = LIST_ITEM.test(line);
+    if ((n !== prevLine + 1 || startsItem) && para.length > 0) {
+      blocks.push(join14(para, paraStart));
+      para = [];
+    }
+    if (para.length === 0)
+      paraStart = n;
+    para.push([n, pyStrip(line)]);
+    prevLine = n;
+  }
+  if (para.length > 0)
+    blocks.push(join14(para, paraStart));
+  return blocks;
+}
+function checkMarkdown(name, text) {
+  const problems = [];
+  const blocks = paragraphs(text);
+  for (const [start, block] of blocks) {
+    const procedural = PROCEDURAL_STARTS.some((p) => pyLstrip(block).startsWith(p));
+    const limit = procedural ? MAX_WORDS_PROCEDURAL : MAX_WORDS_DESCRIPTIVE;
+    for (const sentence of sentences(block)) {
+      const n = wordCount(sentence);
+      if (n > limit) {
+        const tier = procedural ? "procedural" : "descriptive";
+        problems.push(`${name}:~${start}: ${n} words (>${limit} ${tier}): ${headCodePoints(pyStrip(sentence), 90)}`);
+      }
+    }
+  }
+  for (const [, block, lineMap] of blocks) {
+    const bare = proseOnly(block);
+    for (const [phrase, better, re] of WORDY_RULES) {
+      for (const m of bare.matchAll(re)) {
+        problems.push(`${name}:${lineAt2(m.index, lineMap)}: wordy: ${pyRepr(phrase)} - prefer ${pyRepr(better)}`);
+      }
+    }
+    for (const m of bare.matchAll(AMBIGUOUS)) {
+      problems.push(`${name}:${lineAt2(m.index, lineMap)}: ambiguous reference: ${pyRepr(pyStrip(m[0]))}`);
+    }
+    for (const m of bare.matchAll(PASSIVE)) {
+      problems.push(`${name}:${lineAt2(m.index, lineMap)}: passive voice: ${pyRepr(pyStrip(m[0]))}`);
+    }
+  }
+  return problems;
+}
+
+// src/ste/prose.ts
+var PASSIVE2 = rule(PASSIVE_SOURCE);
+var AMBIGUOUS2 = rule(AMBIGUOUS_SOURCE);
+var SENTENCE_END2 = rule(`(?<=[.!?])${S}+`);
+function sentencesOf(text) {
+  const collapsed = pySplit(text).join(" ");
+  return collapsed.split(SENTENCE_END2).map(pyStrip).filter((s) => s !== "");
+}
+function clip(text, limit = 60) {
+  return codePointLength(text) <= limit ? text : `${headCodePoints(text, limit - 1)}…`;
+}
+function checkProse(text) {
+  const findings = [];
+  for (const sentence of sentencesOf(text)) {
+    const words = pySplit(sentence);
+    if (words.length > MAX_WORDS_PROCEDURAL) {
+      findings.push([
+        "STE-LEN",
+        `sentence has ${words.length} words (limit ${MAX_WORDS_PROCEDURAL}): '${clip(sentence)}'`
+      ]);
+    }
+    const passive = PASSIVE2.exec(sentence);
+    if (passive) {
+      findings.push(["STE-VOICE", `possible passive voice '${passive[0]}' -- prefer active`]);
+    }
+    const ambiguous = AMBIGUOUS2.exec(sentence);
+    if (ambiguous) {
+      findings.push(["STE-REF", `ambiguous '${ambiguous[1]}' -- name the thing it refers to`]);
+    }
+  }
+  const prose = stripIdentifiers(text);
+  for (const [phrase, better] of WORDY) {
+    if (rule(`${B}${ci(reEscape(phrase))}${B}`).test(prose)) {
+      findings.push(["STE-WORD", `'${phrase}' -- prefer '${better}'`]);
+    }
+  }
+  return findings;
+}
+var SECTION_HEADER = /^(Args|Arguments|Returns|Raises|Yields|Examples|Attributes|Parameters|Notes?|See Also):?$/u;
+function proseOf(doc) {
+  const out = [];
+  let inFence = false;
+  for (const raw of pySplitlines(doc)) {
+    const line = pyStrip(pyStrip(raw).replace(/^\*+/, ""));
+    if (line.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence || line.startsWith("@") || line.startsWith(">>>"))
+      continue;
+    if (SECTION_HEADER.test(line))
+      continue;
+    if (/^-{3,}$/u.test(line))
+      continue;
+    out.push(line);
+  }
+  return out.filter((p) => p !== "").join(" ");
+}
+
+// src/ste/index.ts
+var STE_HELP = `Usage: repo-tools ste <file-or-directory> [...]
+       repo-tools ste --prose <file>
+
+Check prose against the mechanically decidable part of ASD-STE100 Simplified
+Technical English: sentence length, wordy forms, ambiguous references (a
+demonstrative with no noun) and the passive voice with an agent. The checker
+cannot judge the approved dictionary.
+
+Markdown mode (the default) checks each Markdown file, or each .md file below a
+directory, in code-unit order of the path. A descriptive sentence may have 25
+words; a procedural one (a numbered step or a check box) may have 20. Code
+fences, tables, headings, quotes, comments, frontmatter, inline code and
+identifiers are not checked. A file whose first five lines hold
+"<!-- ste:historical-record -->" is skipped, and the skip is counted.
+
+  --prose <file>  Check the file as one docstring. Tag lines (@param), section
+                  headers, doctest lines and code fences are removed first. Each
+                  finding prints as "RULE<TAB>detail". The findings are advice:
+                  the exit code is 0.
+  --help, -h      Show this help.
+
+Exit codes: 0 when no finding (Markdown mode) or always (--prose mode). 1 when a
+Markdown finding exists. 2 on a usage error, when no Markdown file was examined,
+or when a file is not UTF-8.
+`;
+var HISTORICAL_MARKER = "<!-- ste:historical-record -->";
+function readText(path) {
+  const bytes = readFileSync14(path);
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  return text.replace(/\r\n?/g, `
+`);
+}
+function comparePaths(a, b) {
+  for (let i = 0;i < Math.min(a.length, b.length); i++) {
+    const c = compareCodeUnits(a[i], b[i]);
+    if (c !== 0)
+      return c;
+  }
+  return a.length - b.length;
+}
+function targetsFor(path) {
+  if (existsSync14(path) && statSync7(path).isFile())
+    return [path];
+  const found = [];
+  const walk = (dir, parts) => {
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join15(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== ".pytest_cache")
+          walk(full, [...parts, entry.name]);
+      } else if (entry.name.endsWith(".md")) {
+        const isFile = entry.isFile() || entry.isSymbolicLink() && statSync7(full).isFile();
+        if (isFile)
+          found.push([...parts, entry.name]);
+      }
+    }
+  };
+  if (existsSync14(path) && lstatSync3(path).isDirectory())
+    walk(path, []);
+  return found.sort(comparePaths).map((parts) => join15(path, ...parts));
+}
+function isHistoricalRecord(path) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8").decode(readFileSync14(path));
+  } catch {
+    return false;
+  }
+  return text.split(/\r\n|\r|\n/).slice(0, 5).some((line) => line.trim() === HISTORICAL_MARKER);
+}
+function runProse(args, io) {
+  const [file, ...extra] = args;
+  if (file === undefined || extra.length > 0) {
+    io.stderr(`repo-tools ste: --prose needs exactly one file
+`);
+    return 2;
+  }
+  let text;
+  try {
+    text = readText(file);
+  } catch {
+    io.stderr(`repo-tools ste: cannot read ${basename6(file)} as UTF-8 text
+`);
+    return 2;
+  }
+  for (const [rule, detail] of checkProse(proseOf(text)))
+    io.stdout(`${rule}	${detail}
+`);
+  return 0;
+}
+async function run5(argv, io) {
+  if (argv[0] === "--prose")
+    return runProse(argv.slice(1), io);
+  if (argv.length === 0) {
+    io.stdout(`usage: repo-tools ste <file-or-directory> [...]
+`);
+    return 2;
+  }
+  let total = 0;
+  let checked = 0;
+  let skipped = 0;
+  for (const arg of argv) {
+    for (const target of targetsFor(arg)) {
+      const name = basename6(target);
+      if (isHistoricalRecord(target)) {
+        skipped += 1;
+        io.stdout(`
+=== ${name}: SKIPPED (historical record) ===
+`);
+        continue;
+      }
+      let text;
+      try {
+        text = readText(target);
+      } catch {
+        io.stderr(`repo-tools ste: cannot read ${name} as UTF-8 text
+`);
+        return 2;
+      }
+      const problems = checkMarkdown(name, text);
+      checked += 1;
+      total += problems.length;
+      const status = problems.length === 0 ? "OK" : `${problems.length} problem(s)`;
+      io.stdout(`
+=== ${name}: ${status} ===
+`);
+      for (const p of problems)
+        io.stdout(`  ${p}
+`);
+    }
+  }
+  const tail = skipped > 0 ? `; ${skipped} skipped as historical record(s)` : "";
+  io.stdout(`
+TOTAL: ${total} problem(s) in ${checked} file(s)${tail}
+`);
+  if (checked === 0) {
+    io.stderr(`ERROR: no Markdown file was examined. This is a failure, not a clean result -- check the path(s) given.
+`);
+    return 2;
+  }
+  return total > 0 ? 1 : 0;
+}
+
 // src/cli.ts
 var REGISTRY = {
   depgraph: {
@@ -10992,6 +11458,11 @@ var REGISTRY = {
     summary: "Answer structural questions from the depgraph reports, or write derived reports.",
     help: QUERY_HELP,
     run: run4
+  },
+  ste: {
+    summary: "Check Markdown or docstring prose against Simplified Technical English.",
+    help: STE_HELP,
+    run: run5
   }
 };
 var SUBCOMMANDS = Object.keys(REGISTRY);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/repo-tools",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "One CLI for repository analysis: dependency graphs creation and query with per-export API facts, file chunking, and context compression. TypeScript on Bun, compiled to a single executable.",
   "type": "module",
   "license": "MIT",