hanlint 0.0.7 → 0.0.8

package/src/rules/document/countMismatch.js

@@ -2,6 +2,7 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "countMismatch";
+export const mechanism = "contrast";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc @param {number} line */
 function sectionIndexAt(doc, line) {
@@ -10,16 +11,31 @@ function sectionIndexAt(doc, line) {
   return index;
 }
 
-/** 같은 절 안이거나, 도입과 마지막 절 사이일 때만 같은 목록을 센다고 본다. */
-function comparable(doc, lineA, lineB) {
+/** 줄이 든 문단의 차례. sectionIndexAt 과 같은 꼴로 훑는다. */
+function blockIndexAt(doc, line) {
+  let index = 0;
+  for (const block of doc.blocks) if (block.startLine <= line) index = block.index;
+  return index;
+}
+
+/** 도입의 약속과 마지막 절의 결산만 같은 목록으로 본다. 절이 없으면 첫 문단과 마지막 문단이다. 파이썬과 같다. */
+function comparable(doc, lineA, lineB, span) {
   const a = sectionIndexAt(doc, lineA);
   const b = sectionIndexAt(doc, lineB);
   const last = doc.sections[doc.sections.length - 1].index;
-  return a === b || (Math.min(a, b) === 0 && Math.max(a, b) === last && a !== b);
+  if (last === 0) {
+    if (Math.max(...doc.blocks.map((block) => block.endLine)) > span) return false;
+    const lastBlock = doc.blocks[doc.blocks.length - 1].index;
+    return lastBlock !== 0 && blockIndexAt(doc, lineA) === 0 && blockIndexAt(doc, lineB) === lastBlock;
+  }
+  return Math.min(a, b) === 0 && Math.max(a, b) === last && a !== b;
 }
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
   const findings = [];
   /** @type {Map<string, [number, number, string][]>} */
   const byUnit = new Map();
@@ -31,7 +47,7 @@ export function run(doc) {
     promises.sort((a, b) => a[0] - b[0] || a[1] - b[1] || (a[2] < b[2] ? -1 : a[2] > b[2] ? 1 : 0));
     for (let i = 0; i < promises.length; i++) {
       const [lineA, numberA, textA] = promises[i];
-      const conflict = promises.slice(i + 1).find((p) => p[1] !== numberA && comparable(doc, lineA, p[0]));
+      const conflict = promises.slice(i + 1).find((p) => p[1] !== numberA && comparable(doc, lineA, p[0], config.countMismatchSpan));
       if (!conflict) continue;
       const [lineB, , textB] = conflict;
       findings.push(finding(name, lineB, textB, `${lineA}번째 줄은 \`${textA}\` 인데 여기는 \`${textB}\` 다. 같은 단위로 다른 수를 약속하면 독자가 어느 쪽을 믿을지 모른다`, null, "error", DOCUMENT, -1));

package/src/rules/document/enoughOnce.js

@@ -0,0 +1,25 @@
+// @ts-check
+import { matchedTexts } from "../../fingerprint/markers.js";
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "enoughOnce";
+export const mechanism = "repeat";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  /** @type {[import("../../fingerprint/build.js").SentencePrint, string][]} */
+  const breaks = [];
+  for (const sentence of doc.sentences) {
+    const texts = matchedTexts(sentence.text, "enoughMarkers.txt");
+    if (texts.length) breaks.push([sentence, texts[0]]);
+  }
+  if (breaks.length < 2) return [];
+  const first = breaks[0][0];
+  return breaks.slice(1).map(([sentence, text]) =>
+    finding(name, sentence.line, sentence.text, `\`${text}\` 로 끊는 문장이 ${first.line}행에 이미 있다. 글 전체에 한 번만 쓴다. 계속 끝나는 척하다 이어지는 꼴이 된다`, null, "error", SENTENCE, sentence.index),
+  );
+}

package/src/rules/document/fieldEcho.js

@@ -0,0 +1,38 @@
+// @ts-check
+import { topicsOf } from "../../fingerprint/topics.js";
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "fieldEcho";
+export const mechanism = "contrast";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../fingerprint/build.js").SectionPrint} section
+ * @param {string[]} fields
+ * @param {string} where
+ */
+function check(doc, section, fields, where) {
+  const findings = [];
+  for (const name_ of fields) {
+    const value = doc.frontmatter[name_];
+    if (!value) continue;
+    const promised = topicsOf(value);
+    if (!promised.size) continue;
+    if ([...promised].some((word) => section.topics.has(word))) continue;
+    findings.push(
+      finding(name, section.startLine, value, `frontmatter 의 \`${name_}\` 가 약속한 말이 ${where}에 하나도 없다. 약속한 것을 ${where}에서 그 말로 답한다`, null, NOTICE, DOCUMENT, section.index),
+    );
+  }
+  return findings;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  if (!config.introFields.length && !config.endingFields.length) return [];
+  const findings = check(doc, doc.intro, config.introFields, "도입");
+  if (doc.sections.length > 1) findings.push(...check(doc, doc.sections[doc.sections.length - 1], config.endingFields, "마지막 절"));
+  return findings;
+}

package/src/rules/document/keywordHeading.js

@@ -0,0 +1,27 @@
+// @ts-check
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "keywordHeading";
+export const mechanism = "contrast";
+/** 목차라고 부를 수 있는 최소 H2 수. 둘 이하는 훑을 목차가 아니다. */
+const MIN_HEADINGS = 3;
+/** 한 글자 낱말은 어느 제목에나 우연히 들어 있어 가르지 못한다. */
+const MIN_WORD = 2;
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  if (!config.keywordField) return [];
+  const keyword = (doc.frontmatter[config.keywordField] ?? "").trim();
+  const title = doc.frontmatter.title ?? "";
+  const headings = doc.headings.filter(([level]) => level === 2);
+  if (!keyword || headings.length < MIN_HEADINGS) return [];
+  const joined = headings.map(([, text]) => text).join(" / ");
+  const missing = keyword.split(/\s+/).filter((word) => word.length >= MIN_WORD && title.includes(word) && !joined.includes(word));
+  if (!missing.length) return [];
+  return [
+    finding(name, headings[0][2], joined, `제목이 약속한 \`${missing[0]}\` 가 절 제목 어디에도 없다. 목차를 훑는 독자가 이 글이 그것을 다루는지 못 본다`, null, NOTICE, DOCUMENT, -1),
+  ];
+}

package/src/rules/document/keywordMissing.js

@@ -2,6 +2,7 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "keywordMissing";
+export const mechanism = "contrast";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc

package/src/rules/document/noQuestion.js

@@ -2,10 +2,14 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "noQuestion";
+export const mechanism = "threshold";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   if (doc.bodySections.length < 2 || doc.questionCount > 0) return [];
   const first = doc.sentences.length ? doc.sentences[0] : null;
-  return [finding(name, first ? first.line : 1, first ? first.text : "", "물음표가 한 번도 없다. 독자가 품을 의문을 한 번은 대신 묻고 다음 문장에서 답한다", null, "error", DOCUMENT, -1)];
+  const why = doc.readerCallCount === 0
+    ? "물음표가 한 번도 없고 독자를 부르는 말도 없다. 독자가 품을 의문을 한 번은 대신 묻고, 독자가 할 행동을 동사로 끝내는 문장을 넣는다"
+    : "물음표가 한 번도 없다. 독자가 품을 의문을 한 번은 대신 묻고 다음 문장에서 답한다";
+  return [finding(name, first ? first.line : 1, first ? first.text : "", why, null, "error", DOCUMENT, -1)];
 }

package/src/rules/document/promiseRecall.js

@@ -2,11 +2,13 @@
 import { DOCUMENT, NOTICE, finding } from "../finding.js";
 
 export const name = "promiseRecall";
+export const mechanism = "reader";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
-  if (!doc.promises.length || doc.recalls.length) return [];
-  return doc.promises.map(([line, text]) =>
+  const reader = doc.reader.final;
+  if (!reader.promises.length || reader.recalls.length) return [];
+  return reader.promises.map(([line, text]) =>
     finding(name, line, text, "뒤로 미룬 것을 앞에서 미룬 것으로 다시 부르는 자리가 글 어디에도 없다. 회수하거나 미루지 않는다", null, NOTICE, DOCUMENT, -1),
   );
 }

package/src/rules/document/tableOddCell.js

@@ -0,0 +1,60 @@
+// @ts-check
+import { TABLE } from "../../document/model.js";
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "tableOddCell";
+export const mechanism = "contrast";
+const SEPARATOR = /^:?-{2,}:?$/;
+const MEASURE = /^([+-]?\d[\d,]*(?:\.\d+)?)\s*([^\s\d]{0,6})$/;
+const EMPTY = ["", "-", "--"];
+
+/** (블록 안 줄 오프셋, 칸 목록). 구분 줄은 뺀다. @param {string} text @returns {[number, string[]][]} */
+function cellsOf(text) {
+  /** @type {[number, string[]][]} */
+  const rows = [];
+  text.split("\n").forEach((line, offset) => {
+    const stripped = line.trim();
+    if (!stripped.startsWith("|")) return;
+    const cells = stripped.replace(/^\|+/, "").replace(/\|+$/, "").split("|").map((cell) => cell.trim());
+    if (cells.length && cells.filter((cell) => cell).every((cell) => SEPARATOR.test(cell))) return;
+    rows.push([offset, cells]);
+  });
+  return rows;
+}
+
+/** `3.72초` 는 초, `533MB` 는 MB, `직접 부르지 않음` 은 null. @param {string} cell */
+function unitOf(cell) {
+  const match = MEASURE.exec(cell);
+  return match ? match[2] : null;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  for (const block of doc.blocks) {
+    if (block.kind !== TABLE) continue;
+    const rows = cellsOf(block.text);
+    if (rows.length < 2) continue;
+    const body = rows.slice(1);
+    const width = Math.min(...body.map(([, cells]) => cells.length));
+    for (let column = 1; column < width; column += 1) {
+      /** @type {[number, string][]} */
+      const values = [];
+      for (const [offset, cells] of body) if (!EMPTY.includes(cells[column])) values.push([offset, cells[column]]);
+      if (values.length < config.tableOddCellMinRows) continue;
+      const units = values.map(([offset, cell]) => /** @type {[number, string, string | null]} */ ([offset, cell, unitOf(cell)]));
+      const odd = units.filter(([, , unit]) => unit === null);
+      const kinds = new Set(units.filter(([, , unit]) => unit !== null).map(([, , unit]) => unit));
+      if (odd.length !== 1 || kinds.size !== 1) continue;
+      const unit = [...kinds][0];
+      const [offset, cell] = odd[0];
+      findings.push(
+        finding(name, block.startLine + offset, cell, `이 열의 나머지 ${values.length - 1}칸은 \`${unit}\` 으로 잰 값 하나인데 이 칸만 다르다. 같은 잣대로 다시 재거나 그 줄을 본문 문장으로 옮긴다`, null, NOTICE, DOCUMENT, block.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/finding.js

@@ -9,6 +9,8 @@ export const PARAGRAPH = "paragraph";
 export const SECTION = "section";
 export const DOCUMENT = "document";
 
+const MIN_LOCAL_CUE = 2;
+
 /**
  * @typedef {object} Finding
  * @property {string} rule
@@ -21,8 +23,11 @@ export const DOCUMENT = "document";
  * @property {number} at scope 가 가리키는 지문의 index
  * @property {string | null} fragment 원문에서 바꿀 조각. hanlint fix 가 replacement 로 바꾼다
  * @property {string | null} replacement
+ * @property {Candidate[]} candidates 뜻을 정하지 않고 형태로 좁힐 수 있을 때만. 순위와 점수는 없다
  */
 
+/** @typedef {{text: string, why: string}} Candidate */
+
 /**
  * @param {string} rule
  * @param {number} line
@@ -34,10 +39,11 @@ export const DOCUMENT = "document";
  * @param {number} [at]
  * @param {string | null} [fragment]
  * @param {string | null} [replacement]
+ * @param {Candidate[]} [candidates]
  * @returns {Finding}
  */
-export function finding(rule, line, quote, why, fix = null, severity = ERROR, scope = SENTENCE, at = -1, fragment = null, replacement = null) {
-  return { rule, line, quote, why, fix, severity, scope, at, fragment, replacement };
+export function finding(rule, line, quote, why, fix = null, severity = ERROR, scope = SENTENCE, at = -1, fragment = null, replacement = null, candidates = []) {
+  return { rule, line, quote, why, fix, severity, scope, at, fragment, replacement, candidates };
 }
 
 /** @param {Finding} f */
@@ -49,5 +55,21 @@ export function findingAsDict(f) {
     data.fragment = f.fragment;
     data.replacement = f.replacement;
   }
+  if (f.candidates.length) data.candidates = f.candidates.map((candidate) => ({ text: candidate.text, why: candidate.why }));
   return data;
 }
+
+/** 규칙이 짚은 국소 표지. 너무 짧으면 오선택을 피하려고 인용 전체를 쓴다. @param {Finding} f */
+export function localCue(f) {
+  const flat = (text) => text.split(/\s+/).filter(Boolean).join(" ");
+  const quote = flat(f.quote);
+  if (f.fragment) {
+    const fragment = flat(f.fragment);
+    if (fragment.length >= MIN_LOCAL_CUE) return fragment;
+  }
+  const marked = [...f.why.matchAll(/`([^`\n]+)`/g)]
+    .map((match) => flat(match[1]))
+    .filter((candidate) => candidate.length >= MIN_LOCAL_CUE && quote.includes(candidate));
+  marked.sort((left, right) => right.length - left.length || (left < right ? 1 : left > right ? -1 : 0));
+  return marked[0] ?? quote;
+}

package/src/rules/orthography/confusable.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "confusable";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/orthography/spacing.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "spacing";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/orthography/spelling.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "spelling";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/paragraph/factListParagraph.js

@@ -2,6 +2,7 @@
 import { NOTICE, PARAGRAPH, finding } from "../finding.js";
 
 export const name = "factListParagraph";
+export const mechanism = "threshold";
 
 /** 문장 사이를 잇는 표지가 하나라도 있는가. @param {import("../../fingerprint/build.js").ParagraphPrint} paragraph */
 function isLinked(paragraph) {

package/src/rules/paragraph/paraFragment.js

@@ -1,7 +1,9 @@
 // @ts-check
 import { PARAGRAPH, finding } from "../finding.js";
+import { runsOf } from "../shared/repeat.js";
 
 export const name = "paraFragment";
+export const mechanism = "repeat";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
@@ -10,19 +12,27 @@ export const name = "paraFragment";
 export function run(doc, config) {
   const findings = [];
   for (const section of doc.sections) {
-    /** @type {import("../../fingerprint/build.js").ParagraphPrint[]} */
-    let run = [];
-    for (const paragraph of section.paragraphs) {
+    const paragraphs = section.paragraphs;
+    // 열쇠는 짧은 문단의 구간 번호다. 코드나 표 뒤의 짧은 문단과 긴 문단 뒤의 짧은 문단은 새 구간을 연다.
+    /** @type {string[]} */
+    const keys = [];
+    let runId = 0;
+    let previousShort = false;
+    for (const paragraph of paragraphs) {
       const short = paragraph.sentenceCount <= 2;
-      if (short && (!run.length || paragraph.followsProseDirectly)) run.push(paragraph);
-      else if (short) run = [paragraph];
-      else run = [];
-      if (run.length === config.fragmentRun) {
-        const first = run[0];
-        findings.push(
-          finding(name, first.startLine, first.sentences.length ? first.sentences[0].text : "", `${run.length}개 문단이 연달아 한두 문장씩이다. 화제가 같으면 한 문단으로 묶는다. 줄바꿈은 화제가 바뀌는 자리에만`, null, "error", PARAGRAPH, first.index),
-        );
+      if (short) {
+        if (!previousShort || !paragraph.followsProseDirectly) runId += 1;
+        keys.push(`short${runId}`);
+      } else {
+        keys.push(`__${paragraph.index}`);
       }
+      previousShort = short;
+    }
+    for (const [start] of runsOf(keys, config.fragmentRun)) {
+      const first = paragraphs[start];
+      findings.push(
+        finding(name, first.startLine, first.sentences.length ? first.sentences[0].text : "", `${config.fragmentRun}개 문단이 연달아 한두 문장씩이다. 화제가 같으면 한 문단으로 묶는다. 줄바꿈은 화제가 바뀌는 자리에만`, null, "error", PARAGRAPH, first.index),
+      );
     }
   }
   return findings;

package/src/rules/paragraph/topicBreak.js

@@ -2,6 +2,7 @@
 import { NOTICE, PARAGRAPH, finding } from "../finding.js";
 
 export const name = "topicBreak";
+export const mechanism = "contrast";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc

package/src/rules/registry.js

@@ -5,12 +5,15 @@
  * 기술서 (왜, 어디서, 고치기, 안 잡는 것) 는 파이썬 docstring 의 투영 data/ruleDocs.json 에서 읽는다.
  */
 import { enabled } from "../config/settings.js";
-import { loadRuleDocs } from "../data/load.js";
+import { loadRuleCategories, loadRuleDocs } from "../data/load.js";
 import * as countMismatch from "./document/countMismatch.js";
+import * as enoughOnce from "./document/enoughOnce.js";
+import * as fieldEcho from "./document/fieldEcho.js";
+import * as keywordHeading from "./document/keywordHeading.js";
 import * as keywordMissing from "./document/keywordMissing.js";
 import * as noQuestion from "./document/noQuestion.js";
 import * as promiseRecall from "./document/promiseRecall.js";
-import * as readerAbsent from "./document/readerAbsent.js";
+import * as tableOddCell from "./document/tableOddCell.js";
 import * as duplicateBlock from "./code/duplicateBlock.js";
 import * as firstResultDistance from "./code/firstResultDistance.js";
 import * as inputFileSource from "./code/inputFileSource.js";
@@ -26,6 +29,8 @@ import * as cliche from "./sentence/cliche.js";
 import * as hardWord from "./sentence/hardWord.js";
 import * as connectorRepeat from "./sentence/connectorRepeat.js";
 import * as danglingDeixis from "./sentence/danglingDeixis.js";
+import * as draftHistory from "./sentence/draftHistory.js";
+import * as numberOrphan from "./sentence/numberOrphan.js";
 import * as dash from "./sentence/dash.js";
 import * as deixis from "./sentence/deixis.js";
 import * as doubleNegative from "./sentence/doubleNegative.js";
@@ -39,9 +44,16 @@ import * as japaneseLoan from "./sentence/japaneseLoan.js";
 import * as longSentence from "./sentence/longSentence.js";
 import * as negationRedefine from "./sentence/negationRedefine.js";
 import * as nounPile from "./sentence/nounPile.js";
+import * as outsideProfile from "./sentence/outsideProfile.js";
 import * as redundantPair from "./sentence/redundantPair.js";
 import * as translationese from "./sentence/translationese.js";
+import * as blockUnread from "./structure/blockUnread.js";
+import * as bridgeRepeat from "./structure/bridgeRepeat.js";
 import * as emojiBullet from "./structure/emojiBullet.js";
+import * as headingQuestion from "./structure/headingQuestion.js";
+import * as introImage from "./structure/introImage.js";
+import * as loneSubheading from "./structure/loneSubheading.js";
+import * as moreLater from "./structure/moreLater.js";
 import * as headingSentence from "./structure/headingSentence.js";
 import * as headingSkip from "./structure/headingSkip.js";
 import * as headingUniform from "./structure/headingUniform.js";
@@ -52,6 +64,7 @@ import * as sectionResult from "./structure/sectionResult.js";
 /**
  * @typedef {object} Rule
  * @property {string} name
+ * @property {string} mechanism 세는 방법. MECHANISMS 의 키 하나
  * @property {(doc: import("../fingerprint/build.js").DocumentPrint, config: import("../config/settings.js").Config) => import("./finding.js").Finding[]} run
  */
 
@@ -61,6 +74,8 @@ export const RULES = [
   connectorRepeat,
   danglingDeixis,
   dash,
+  draftHistory,
+  numberOrphan,
   deixis,
   doubleNegative,
   doublePassive,
@@ -74,12 +89,19 @@ export const RULES = [
   longSentence,
   negationRedefine,
   nounPile,
+  outsideProfile,
   redundantPair,
   translationese,
   factListParagraph,
   paraFragment,
   topicBreak,
+  blockUnread,
+  bridgeRepeat,
   emojiBullet,
+  headingQuestion,
+  introImage,
+  loneSubheading,
+  moreLater,
   headingSentence,
   headingSkip,
   headingUniform,
@@ -87,10 +109,13 @@ export const RULES = [
   sectionNoProse,
   sectionResult,
   countMismatch,
+  enoughOnce,
+  fieldEcho,
+  tableOddCell,
+  keywordHeading,
   keywordMissing,
   noQuestion,
   promiseRecall,
-  readerAbsent,
   spelling,
   spacing,
   confusable,
@@ -101,6 +126,23 @@ export const RULES = [
   platformApi,
 ];
 
+/**
+ * 규칙이 세는 방법의 닫힌 집합. 파이썬 rules/registry.py 의 MECHANISMS 와 같은 값과 같은 순서다.
+ * @type {Record<string, string>}
+ */
+export const MECHANISMS = {
+  dictionary: "사전. 낱말 목록과 정규식이 맞는 자리",
+  repeat: "반복. 같은 모양이 창 안에서 N 번",
+  threshold: "셈. 지문의 값이 임계를 넘거나 모양이 계약과 다른 자리",
+  contrast: "대조. 두 자리를 맞대 어긋난 곳",
+  reader: "독자 상태. 문장 순서대로 독자가 손에 든 것과 본 것에 그 자리가 요구하는 것을 맞댄다",
+};
+for (const rule of RULES) {
+  if (!(rule.mechanism in MECHANISMS)) {
+    throw new Error(`규칙 ${rule.name} 의 기제 ${rule.mechanism} 은 닫힌 집합 밖이다 (${Object.keys(MECHANISMS).join(", ")}). 새 기제는 규칙 하나 때문에 들어오지 않는다. 멈춰서 묻는다`);
+  }
+}
+
 const BY_NAME = new Map(RULES.map((rule) => [rule.name, rule]));
 
 /** 이름 순. */
@@ -120,6 +162,33 @@ export function ruleSummary(name) {
   return ruleDoc(name).split("\n")[0];
 }
 
+/**
+ * 부류의 사람 이름. 파이썬 rules/registry.py 의 CATEGORY_TITLES 와 같은 값과 같은 순서다.
+ * @type {Record<string, string>}
+ */
+export const CATEGORY_TITLES = {
+  sentence: "문장 안에서 세는 것",
+  paragraph: "문단 사이에서 세는 것",
+  structure: "글의 짜임에서 세는 것",
+  document: "두 자리를 대조해 세는 것",
+  orthography: "표기와 띄어쓰기",
+  code: "코드 블록 사이를 대조하는 것",
+};
+
+/** 규칙이 세는 방법. @param {string} name */
+export function ruleMechanism(name) {
+  const rule = BY_NAME.get(name);
+  if (!rule) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  return rule.mechanism;
+}
+
+/** 규칙이 사는 부류. 정본은 파이썬 쪽 폴더이고 여기는 그 투영을 읽는다. @param {string} name */
+export function ruleCategory(name) {
+  const categories = loadRuleCategories();
+  if (!(name in categories)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  return categories[name];
+}
+
 /**
  * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*` 는 전부다.
  * @param {import("./finding.js").Finding} f

package/src/rules/sentence/cliche.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "cliche";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/connectorRepeat.js

@@ -1,22 +1,23 @@
 // @ts-check
 import { SENTENCE, finding } from "../finding.js";
+import { runsOf } from "../shared/repeat.js";
 
 export const name = "connectorRepeat";
+export const mechanism = "repeat";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const paragraph of doc.paragraphs) {
-    /** @type {string | null} */
-    let previous = null;
-    for (const sentence of paragraph.sentences) {
-      const current = sentence.connectorStart;
-      if (current && current === previous) {
+    const sentences = paragraph.sentences;
+    // 열쇠는 문두 접속부사다. 접속부사가 없는 문장은 저마다 다른 열쇠를 받아 구간을 끊는다.
+    const keys = sentences.map((sentence) => sentence.connectorStart || `__${sentence.index}`);
+    for (const [start, length, connector] of runsOf(keys, 2)) {
+      for (const sentence of sentences.slice(start + 1, start + length)) {
         findings.push(
-          finding(name, sentence.line, sentence.text, `\`${current}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
+          finding(name, sentence.line, sentence.text, `\`${connector}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
         );
       }
-      previous = current;
     }
   }
   return findings;

package/src/rules/sentence/danglingDeixis.js

@@ -1,18 +1,23 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { overlap } from "../../fingerprint/topics.js";
 import { SENTENCE, finding } from "../finding.js";
+import { danglingDeixisCandidates } from "../shared/candidates.js";
+import { hasLocalAntecedent } from "../shared/localAntecedent.js";
 
 export const name = "danglingDeixis";
+export const mechanism = "reader";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
     if (!sentence.deixis.length) continue;
-    const previous = sentence.index > 0 ? doc.sentences[sentence.index - 1] : null;
-    if (previous !== null && overlap(previous.topics, sentence.topics) > 0) continue;
+    if (hasLocalAntecedent(sentence)) continue;
+    const reader = doc.reader.beforeSentence[sentence.index];
+    if (overlap(reader.recent, sentence.topics) > 0) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` 이 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
+      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` ${fitJosa(sentence.deixis[0], "이")} 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index, null, null, danglingDeixisCandidates(sentence, reader.previous)),
     );
   }
   return findings;

package/src/rules/sentence/dash.js

@@ -2,13 +2,14 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "dash";
+export const mechanism = "dictionary";
 // 리터럴로 쓰면 이 파일이 자기 게이트에 걸린다. 코드포인트로 만든다.
 const DASHES = new RegExp(`[${String.fromCharCode(0x2013)}${String.fromCharCode(0x2014)}]`);
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
-  for (const block of doc.blocks) {
+  for (const block of [...doc.blocks, ...doc.ignored]) {
     block.text.split("\n").forEach((lineText, offset) => {
       if (DASHES.test(lineText)) {
         findings.push(