hanlint 0.0.9 → 0.0.10

package/src/guard/surface.js

@@ -0,0 +1,184 @@
+// @ts-check
+/** 계약 본문과 결과 글 사이의 보호 원자 차이. */
+
+/**
+ * @typedef {object} SurfaceDiff
+ * @property {string[]} missingNumbers
+ * @property {string[]} unexpectedNumbers
+ * @property {string[]} missingUrls
+ * @property {string[]} unexpectedUrls
+ * @property {string[]} missingCode
+ * @property {string[]} unexpectedCode
+ * @property {string[]} missingLinks
+ * @property {string[]} unexpectedLinks
+ */
+
+const NUMBER_ATOM = /(?<!\p{Nd})(?:\p{Nd}{1,3}(?:,\p{Nd}{3})+|\p{Nd}+)(?:\.\p{Nd}+)*(?!\p{Nd})/gu;
+const URL = /https?:\/\/[^\s)>\]]*[\p{L}\p{N}_\/#=%&+~-]/gu;
+const INLINE_CODE = /`([^`\n]+)`/gu;
+const LINK_DESTINATION = /\[[^\u005D]*\]\(([^)]+)\)/gu;
+const FACT_FIELDS = [
+  ["unexpectedNumbers", "{}"],
+  ["unexpectedUrls", "{}"],
+  ["unexpectedCode", "`{}`"],
+  ["unexpectedLinks", "[]({})"],
+];
+const UNEXPECTED_FIELDS = FACT_FIELDS.map(([field]) => field);
+const DECIMAL_ZEROS = [
+  0x0030, 0x0660, 0x06f0, 0x07c0, 0x0966, 0x09e6, 0x0a66, 0x0ae6, 0x0b66, 0x0be6,
+  0x0c66, 0x0ce6, 0x0d66, 0x0de6, 0x0e50, 0x0ed0, 0x0f20, 0x1040, 0x1090, 0x17e0,
+  0x1810, 0x1946, 0x19d0, 0x1a80, 0x1a90, 0x1b50, 0x1bb0, 0x1c40, 0x1c50, 0xa620,
+  0xa8d0, 0xa900, 0xa9d0, 0xa9f0, 0xaa50, 0xabf0, 0xff10, 0x104a0, 0x10d30, 0x11066,
+  0x110f0, 0x11136, 0x111d0, 0x112f0, 0x11450, 0x114d0, 0x11650, 0x116c0, 0x11730, 0x118e0,
+  0x11950, 0x11c50, 0x11d50, 0x11da0, 0x16a60, 0x16ac0, 0x16b50, 0x1d7ce, 0x1e140, 0x1e2f0,
+  0x1e4f0, 0x1e950,
+];
+
+/** 파이썬 문자열 순서와 같은 코드 포인트 순서. @param {string} left @param {string} right */
+export function compareText(left, right) {
+  const leftPoints = [...left].map((value) => /** @type {number} */ (value.codePointAt(0)));
+  const rightPoints = [...right].map((value) => /** @type {number} */ (value.codePointAt(0)));
+  const limit = Math.min(leftPoints.length, rightPoints.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (leftPoints[index] !== rightPoints[index]) return leftPoints[index] - rightPoints[index];
+  }
+  return leftPoints.length - rightPoints.length;
+}
+
+/** @param {string} character */
+function decimalValue(character) {
+  const point = /** @type {number} */ (character.codePointAt(0));
+  const zero = DECIMAL_ZEROS.find((start) => start <= point && point < start + 10);
+  if (zero === undefined) throw new Error(`지원하지 않는 유니코드 십진 숫자다: ${character}`);
+  return String(point - zero);
+}
+
+/** @param {string} value */
+function canonicalNumber(value) {
+  return [...value]
+    .filter((character) => character !== ",")
+    .map((character) => (/\p{Nd}/u.test(character) ? decimalValue(character) : character))
+    .join("");
+}
+
+/** @param {string} text */
+export function numberValues(text) {
+  return [...new Set([...text.matchAll(NUMBER_ATOM)].map((match) => canonicalNumber(match[0])))].sort(compareText);
+}
+
+/** @param {RegExp} pattern @param {string} text */
+function valuesOf(pattern, text) {
+  return [...new Set([...text.matchAll(pattern)].map((match) => (match.length > 1 ? match[1] : match[0])))].sort(compareText);
+}
+
+/** @param {string[]} expected @param {string[]} actual */
+function difference(expected, actual) {
+  const other = new Set(actual);
+  return expected.filter((value) => !other.has(value)).sort(compareText);
+}
+
+/** @param {string} contractText @param {string} text @param {string[] | null} [numbers] @returns {SurfaceDiff} */
+export function surfaceDiff(contractText, text, numbers = null) {
+  const surfaceText = text.normalize("NFC");
+  const expectedNumbers = numbers === null ? numberValues(contractText) : [...new Set(numbers)].sort(compareText);
+  const actualNumbers = numberValues(surfaceText);
+  const expectedUrls = valuesOf(URL, contractText);
+  const actualUrls = valuesOf(URL, surfaceText);
+  const expectedCode = valuesOf(INLINE_CODE, contractText);
+  const actualCode = valuesOf(INLINE_CODE, surfaceText);
+  const expectedLinks = valuesOf(LINK_DESTINATION, contractText);
+  const actualLinks = valuesOf(LINK_DESTINATION, surfaceText);
+  const allowedCode = [...new Set([...expectedCode, ...actualCode.filter((value) => contractText.includes(value))])];
+  const allowedLinks = [...new Set([...expectedLinks, ...actualLinks.filter((value) => contractText.includes(value))])];
+  return {
+    missingNumbers: difference(expectedNumbers, actualNumbers),
+    unexpectedNumbers: difference(actualNumbers, expectedNumbers),
+    missingUrls: difference(expectedUrls, actualUrls),
+    unexpectedUrls: difference(actualUrls, expectedUrls),
+    missingCode: difference(expectedCode, actualCode),
+    unexpectedCode: difference(actualCode, allowedCode),
+    missingLinks: difference(expectedLinks, actualLinks),
+    unexpectedLinks: difference(actualLinks, allowedLinks),
+  };
+}
+
+/** @param {ReturnType<typeof surfaceDiff>} diff */
+export function surfaceViolationCount(diff) {
+  return Object.values(diff).reduce((total, values) => total + values.length, 0);
+}
+
+/** 원문의 보호 원자를 뜻 없는 정렬 집합으로 분리한다. @param {string} text */
+export function protectedSurface(text) {
+  const surfaceText = text.normalize("NFC");
+  return {
+    numbers: numberValues(surfaceText),
+    urls: valuesOf(URL, surfaceText),
+    code: valuesOf(INLINE_CODE, surfaceText),
+    links: valuesOf(LINK_DESTINATION, surfaceText),
+  };
+}
+
+/** 원문의 보호 표면을 모두 덮는 Contract 사실 후보 줄. @param {string} text */
+export function factLines(text) {
+  const surfaceText = text.normalize("NFC");
+  const seen = new Set();
+  /** @type {{ text: string, atoms: Set<string> }[]} */
+  const candidates = [];
+  for (const line of surfaceText.split(/\r\n|[\n\v\f\r\x1c-\x1e\x85\u2028\u2029]/u)) {
+    const candidate = line.trim();
+    if (!candidate || seen.has(candidate)) continue;
+    seen.add(candidate);
+    const diff = surfaceDiff("", candidate);
+    const atoms = new Set(
+      UNEXPECTED_FIELDS.flatMap((field) =>
+        diff[/** @type {keyof typeof diff} */ (field)].map((value) => `${field}\u0000${value}`),
+      ),
+    );
+    if (atoms.size) candidates.push({ text: candidate, atoms });
+  }
+
+  const fullDiff = surfaceDiff("", surfaceText);
+  const uncovered = new Set(
+    UNEXPECTED_FIELDS.flatMap((field) =>
+      fullDiff[/** @type {keyof typeof fullDiff} */ (field)].map((value) => `${field}\u0000${value}`),
+    ),
+  );
+  if (!uncovered.size) {
+    throw new Error("원문에 자동으로 보호할 숫자, URL, 인라인 코드, 링크 목적지가 없다. facts를 직접 작성한다");
+  }
+
+  const selected = new Set();
+  while (uncovered.size) {
+    let best = -1;
+    let bestGain = 0;
+    for (let index = 0; index < candidates.length; index += 1) {
+      if (selected.has(index)) continue;
+      const gain = [...candidates[index].atoms].filter((atom) => uncovered.has(atom)).length;
+      if (gain > bestGain) {
+        best = index;
+        bestGain = gain;
+      }
+    }
+    if (!bestGain) break;
+    selected.add(best);
+    for (const atom of candidates[best].atoms) uncovered.delete(atom);
+  }
+
+  const facts = candidates.filter((_, index) => selected.has(index)).map((candidate) => candidate.text);
+  const factSet = new Set(facts);
+  for (const [field, template] of FACT_FIELDS) {
+    const prefix = `${field}\u0000`;
+    const values = [...uncovered]
+      .filter((atom) => atom.startsWith(prefix))
+      .map((atom) => atom.slice(prefix.length))
+      .sort(compareText);
+    for (const value of values) {
+      const candidate = template.replace("{}", value);
+      if (!factSet.has(candidate)) {
+        facts.push(candidate);
+        factSet.add(candidate);
+      }
+    }
+  }
+  return facts;
+}

package/src/index.js

@@ -13,15 +13,53 @@
 import { readFileSync } from "node:fs";
 
 import { loadConfig } from "./config/loadConfig.js";
+import { Patch } from "./config/patch.js";
+import {
+  CONTRACT_VERSION,
+  CONTRACT_VERSIONS,
+  LATEST_CONTRACT_VERSION,
+  Contract,
+  ContractV2,
+  Outline,
+  ProtectedSurface,
+  parseContract,
+} from "./config/readerContract.js";
 import { configFromMapping, defaultConfig } from "./config/settings.js";
 import { loadVersion } from "./data/load.js";
 import { parseMarkdown } from "./document/parseMarkdown.js";
 import { applyFixes } from "./edit/applyFixes.js";
 import { buildFingerprint } from "./fingerprint/build.js";
 import { fingerprintDict } from "./report/fingerprintJson.js";
+import { check, contractFromText, contractFromTextV2, verifyPatch } from "./guard/contract.js";
+import { CheckResult, PatchResult, renderCheck } from "./guard/receipt.js";
 import { ruleDoc, ruleNames, ruleSummary, runAll } from "./rules/registry.js";
 
-export { applyFixes, configFromMapping, defaultConfig, fingerprintDict, loadConfig, ruleDoc, ruleNames, ruleSummary };
+export {
+  CheckResult,
+  CONTRACT_VERSION,
+  CONTRACT_VERSIONS,
+  Contract,
+  ContractV2,
+  LATEST_CONTRACT_VERSION,
+  Outline,
+  Patch,
+  PatchResult,
+  ProtectedSurface,
+  applyFixes,
+  check,
+  contractFromText,
+  contractFromTextV2,
+  configFromMapping,
+  defaultConfig,
+  fingerprintDict,
+  loadConfig,
+  parseContract,
+  renderCheck,
+  ruleDoc,
+  ruleNames,
+  ruleSummary,
+  verifyPatch,
+};
 export const version = loadVersion();
 
 /**

package/src/report/compactReport.js

@@ -9,6 +9,6 @@ function flat(text) {
 /** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
 export function renderCompact(path, findings) {
   return findings
-    .map((f) => `${path}:${f.line} [${f.rule}] ${flat(f.why)}` + (f.fix ? `  고친 뒤: ${flat(f.fix)}` : ""))
+    .map((f) => `${path}:${f.line} [${f.rule}] ${f.severity === "notice" ? "notice: " : ""}${flat(f.why)}` + (f.fix ? `  고친 뒤: ${flat(f.fix)}` : ""))
     .join("\n");
 }

package/src/report/writingSpec.js

@@ -0,0 +1,174 @@
+// @ts-check
+/** 쓰기 전 숫자 사양. 파이썬 config/writingSpec.py와 같은 셈과 글자를 낸다. */
+
+import { HAPNIDA, REGISTERS } from "../analysis/grammar/index.js";
+import { PROFILE_OF, defaultConfig, enabled } from "../config/settings.js";
+import { profileOf, userProfile } from "../data/profiles.js";
+
+export const SPEC_VERSION = 1;
+const CHARS_PER_WORD = 6;
+
+/** 양수 반올림. 파이썬의 nearest와 같다. @param {number} value */
+function nearest(value) {
+  return Math.floor(value + 0.5);
+}
+
+/** @param {import("../data/profiles.js").Histogram} histogram @param {number} level */
+function percentile(histogram, level) {
+  return histogram.percentiles.get(level) ?? 0;
+}
+
+/** @param {number} value */
+function percent(value) {
+  return nearest(value * 100);
+}
+
+/** @param {import("./settings.js").Config} config */
+function selectedProfile(config) {
+  if (config.profile) return userProfile(config.profile);
+  const kind = PROFILE_OF[config.preset];
+  if (kind === null) throw new Error(`${config.preset} 은 종류 프로파일이 없어 사양을 낼 수 없다`);
+  const profile = profileOf(kind);
+  if (profile === null) throw new Error(`${kind} 프로파일을 찾지 못했다`);
+  return profile;
+}
+
+/**
+ * 현재 규칙판을 쓰기 전 숫자 사양으로 편다. 품질 점수나 새 임계는 만들지 않는다.
+ * @param {import("./settings.js").Config} [config]
+ * @param {string} [register]
+ * @param {number | null} [targetChars]
+ */
+export function writingSpec(config = defaultConfig(), register = HAPNIDA, targetChars = null) {
+  if (!REGISTERS.includes(register)) throw new Error(`register 는 ${REGISTERS.join(", ")} 가운데 하나다: ${register}`);
+  if (targetChars !== null && targetChars <= 0) throw new Error(`chars 는 1 이상이어야 한다: ${targetChars}`);
+  const profile = selectedProfile(config);
+  const sentence = profile.sentence;
+  const paragraph = profile.paragraph.get("sentenceCount");
+  if (!paragraph) throw new Error("프로파일에 paragraph.sentenceCount가 없다");
+  const perParagraph = percentile(paragraph, 50);
+  if (perParagraph <= 0) throw new Error("프로파일의 문단당 문장 중앙값이 1 이상이어야 한다");
+  const lengthHistogram = sentence.get("length");
+  if (!lengthHistogram) throw new Error("프로파일에 sentence.length가 없다");
+  const lengthP50 = percentile(lengthHistogram, 50);
+  if (lengthP50 <= 0) throw new Error("프로파일의 문장 길이 중앙값이 1 이상이어야 한다");
+
+  const rows = [];
+  let amount = `문단마다 문장 ${perParagraph}~${percentile(paragraph, 90)}개`;
+  if (targetChars !== null) {
+    const sentences = Math.max(1, nearest(targetChars / CHARS_PER_WORD / lengthP50));
+    const paragraphs = Math.max(1, nearest(sentences / perParagraph));
+    amount = `문단 ${paragraphs}개, ${amount}, 문장 ${sentences}개 안팎`;
+  }
+  rows.push({ id: "amount", label: "분량", guidance: amount, basis: [`profile.${profile.kind}.paragraph.sentenceCount`] });
+
+  let length = `중앙 ${lengthP50}어절, 문장 90%가 ${percentile(lengthHistogram, 90)}어절 이하`;
+  const lengthBasis = [`profile.${profile.kind}.sentence.length`];
+  if (enabled(config, "longSentence")) {
+    length += `. ${config.longSentenceMax}어절을 넘으면 longSentence가 지적`;
+    lengthBasis.push("rule.longSentence");
+  }
+  rows.push({ id: "sentenceLength", label: "문장 길이", guidance: length, basis: lengthBasis });
+
+  if (profile.endingRuns !== null) {
+    let endingText = `같은 끝맺음 연속 중앙 ${percentile(profile.endingRuns, 50)}개, 90%가 ${percentile(profile.endingRuns, 90)}개 이하`;
+    const endingBasis = [`profile.${profile.kind}.endingRuns`];
+    if (enabled(config, "endingRepeat")) {
+      endingText += `. 인과나 독자 호출 없이 ${config.endingRun}개부터 endingRepeat가 지적`;
+      endingBasis.push("rule.endingRepeat");
+    }
+    rows.push({ id: "endingRun", label: "끝맺음", guidance: endingText, basis: endingBasis });
+  }
+
+  const commas = sentence.get("commas");
+  if (!commas) throw new Error("프로파일에 sentence.commas가 없다");
+  rows.push({
+    id: "commas",
+    label: "쉼표",
+    guidance: `문장 중앙 ${percentile(commas, 50)}개, 90%가 ${percentile(commas, 90)}개 이하, 99%가 ${percentile(commas, 99)}개 이하`,
+    basis: [`profile.${profile.kind}.sentence.commas`],
+  });
+
+  const eui = sentence.get("euiCount");
+  if (!eui) throw new Error("프로파일에 sentence.euiCount가 없다");
+  let euiText = `문장 중앙 ${percentile(eui, 50)}개, 90%가 ${percentile(eui, 90)}개 이하`;
+  const euiBasis = [`profile.${profile.kind}.sentence.euiCount`];
+  if (enabled(config, "euiChain")) {
+    euiText += ". 3개부터, 붙은 2개부터 euiChain이 지적";
+    euiBasis.push("rule.euiChain");
+  }
+  rows.push({ id: "euiCount", label: "의", guidance: euiText, basis: euiBasis });
+
+  const nounRun = sentence.get("nounRun");
+  if (!nounRun) throw new Error("프로파일에 sentence.nounRun이 없다");
+  let nounText = `문장 90%에서 조사 없는 명사 연쇄가 ${percentile(nounRun, 90)}개 이하`;
+  const nounBasis = [`profile.${profile.kind}.sentence.nounRun`];
+  if (enabled(config, "nounPile")) {
+    nounText += `. ${config.nounPileMin}개부터 nounPile이 지적`;
+    nounBasis.push("rule.nounPile");
+  }
+  rows.push({ id: "nounRun", label: "명사 연쇄", guidance: nounText, basis: nounBasis });
+
+  const newTopics = sentence.get("newTopics");
+  if (!newTopics) throw new Error("프로파일에 sentence.newTopics가 없다");
+  rows.push({
+    id: "newTopics",
+    label: "새 화제",
+    guidance: `문장 중앙 ${percentile(newTopics, 50)}개, 90%가 ${percentile(newTopics, 90)}개 이하`,
+    basis: [`profile.${profile.kind}.sentence.newTopics`],
+  });
+
+  const connector = profile.rates.connector;
+  rows.push({
+    id: "connector",
+    label: "문두 접속",
+    guidance: `문서 중앙은 문장의 ${percent(connector.p50)}%, 문서 90%가 ${percent(connector.p90)}% 이하`,
+    basis: [`profile.${profile.kind}.rates.connector`],
+  });
+
+  const numbers = sentence.get("numbers");
+  if (!numbers) throw new Error("프로파일에 sentence.numbers가 없다");
+  const numberP50 = percentile(numbers, 50);
+  const numberP90 = percentile(numbers, 90);
+  const numberText =
+    numberP50 === 0 && numberP90 === 0
+      ? "문장 중앙과 90%에서 숫자 없음"
+      : `문장 중앙 ${numberP50}개, 90%가 ${numberP90}개 이하`;
+  rows.push({ id: "numbers", label: "숫자", guidance: numberText, basis: [`profile.${profile.kind}.sentence.numbers`] });
+
+  const question = profile.rates.question;
+  let questionText;
+  let questionBasis;
+  if (enabled(config, "noQuestion")) {
+    questionText = config.enforceStyle.includes("noQuestion")
+      ? "선택한 정책: 절이 2개 이상이면 글 전체에 물음표 최소 1개"
+      : "물음표 부재는 notice다. 질문 없이 충분히 설명했다면 유지한다";
+    questionBasis = [`profile.${profile.kind}.rates.question`, "rule.noQuestion"];
+  } else {
+    questionText = `규칙 요구 없음. 문서 중앙은 문장의 ${percent(question.p50)}%, 문서 90%가 ${percent(question.p90)}% 이하`;
+    questionBasis = [`profile.${profile.kind}.rates.question`];
+  }
+  rows.push({ id: "question", label: "물음표", guidance: questionText, basis: questionBasis });
+
+  return {
+    version: SPEC_VERSION,
+    kind: "hanlint.writingSpec",
+    preset: config.preset,
+    register,
+    targetChars,
+    profile: profile.kind,
+    rows,
+  };
+}
+
+/** 사람이 읽는 꼴. basis는 JSON에서 확인한다. @param {ReturnType<typeof writingSpec>} spec */
+export function renderWritingSpec(spec) {
+  const target = spec.targetChars !== null ? `, ${spec.targetChars}자` : "";
+  const lines = [
+    `hanlint spec  ${spec.preset} 종류, ${spec.register}체${target}. 같은 규칙판의 임계와 ${spec.profile} 프로파일을 쓰기 전 숫자로 편다`,
+  ];
+  const width = Math.max(...spec.rows.map((row) => row.label.length));
+  for (const row of spec.rows) lines.push(`  ${row.label.padEnd(width)}  ${row.guidance}`);
+  lines.push("", "이 사양은 품질 점수가 아니다. 쓴 뒤 같은 설정으로 hanlint <글.md>를 실행해 Finding을 확인한다");
+  return lines.join("\n");
+}

package/src/rules/code/inputFileSource.js

@@ -33,15 +33,15 @@ export function run(doc) {
   const reported = new Set();
   for (const block of doc.codeBlocks) {
     const reader = doc.reader.beforeBlock[block.index];
-    const [blockWrites, blockDirs] = createdIn(block.lines.map(([, line]) => line));
-    // 이 블록이 만드는 폴더는 같은 블록의 읽기에도 미리 센다. 파일은 블록 안에서 쓴 것 (blockWrites) 만 따로 본다.
+    const [, blockDirs] = createdIn(block.lines.map(([, line]) => line));
+    // 폴더 준비는 블록 단위로 보고 파일 공급은 실제 줄 순서로 쌓는다.
     const have = new Set([...reader.files, ...blockDirs, ...reported]);
     for (const [line, code] of block.lines) {
       const reads = readsIn(code);
       for (const path of reads) {
         if (!isDataFile(path)) continue;
         const name2 = fileName(path);
-        if (have.has(name2) || blockWrites.has(name2) || doc.reader.mentionedBefore(block.index, name2)) continue;
+        if (have.has(name2) || doc.reader.mentionedBefore(block.index, name2)) continue;
         findings.push(finding(name, line, code.trim(), `\`${name2}\` 을 읽는데 글 어디에서도 만들지 않았다. 독자는 여기서 파일 없음 오류로 멈춘다`, null, "error", DOCUMENT, block.index));
       }
       for (const path of [...writeTargets(code), ...reads]) {
@@ -52,6 +52,8 @@ export function run(doc) {
         reported.add(directory);
         findings.push(finding(name, line, code.trim(), `\`${directory}\` 폴더를 쓰는데 글 어디에서도 만들지 않았다. 없으면 파일을 쓰다 멈춘다`, null, NOTICE, DOCUMENT, block.index));
       }
+      const [made] = createdIn([code]);
+      for (const file of made) have.add(file);
     }
   }
   return findings;

package/src/rules/code/installImport.js

@@ -18,14 +18,14 @@ function stdlib() {
   return stdlibCache;
 }
 
-/** @type {Map<string, string> | null} */
+/** @type {Map<string, Set<string>> | null} */
 let packageCache = null;
 function packageOf() {
   if (!packageCache) {
     packageCache = new Map();
     for (const line of loadLines("pythonPackages.txt")) {
       const [module, pkg] = line.split("\t");
-      packageCache.set(module, pkg);
+      packageCache.set(module, new Set(pkg.split("|").map(normalize)));
     }
   }
   return packageCache;
@@ -105,9 +105,10 @@ export function run(doc) {
         for (const module of modules) {
           const top = module.split(".")[0];
           if (!top || stdlib().has(top) || local.has(top)) continue;
-          const pkg = normalize(packageOf().get(top) ?? top);
-          if (!packages.has(pkg)) {
-            findings.push(finding(name, line, code.trim(), `\`${top}\` 를 import 하는데 설치 줄에 \`${pkg}\` 가 없다. 독자는 ModuleNotFoundError 에서 멈춘다`, null, "error", DOCUMENT, block.index));
+          const acceptable = packageOf().get(top) ?? new Set([normalize(top)]);
+          if (![...acceptable].some((pkg) => packages.has(pkg))) {
+            const packageNames = [...acceptable].sort().join("`, `");
+            findings.push(finding(name, line, code.trim(), `\`${top}\` 를 import 하는데 설치 줄에 허용되는 이름 \`${packageNames}\` 가 없다. 독자는 ModuleNotFoundError 에서 멈춘다`, null, "error", DOCUMENT, block.index));
           }
         }
       }

package/src/rules/document/noQuestion.js

@@ -5,11 +5,11 @@ export const name = "noQuestion";
 export const mechanism = "threshold";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
+export function run(doc, config) {
   if (doc.bodySections.length < 2 || doc.questionCount > 0) return [];
   const first = doc.sentences.length ? doc.sentences[0] : null;
   const why = doc.readerCallCount === 0
-    ? "물음표가 한 번도 없고 독자를 부르는 말도 없다. 독자가 품을 의문을 한 번은 대신 묻고, 독자가 할 행동을 동사로 끝내는 문장을 넣는다"
-    : "물음표가 한 번도 없다. 독자가 품을 의문을 한 번은 대신 묻고 다음 문장에서 답한다";
-  return [finding(name, first ? first.line : 1, first ? first.text : "", why, null, "error", DOCUMENT, -1)];
+    ? "물음표가 한 번도 없고 독자를 부르는 말도 없다. 질문이나 독자 호출이 필요한 글인지 판단하고 충분하면 유지한다"
+    : "물음표가 한 번도 없다. 질문이 필요한 글인지 판단하고 설명만으로 충분하면 유지한다";
+  return [finding(name, first ? first.line : 1, first ? first.text : "", why, null, config.enforceStyle.includes(name) ? "error" : "notice", DOCUMENT, -1)];
 }

package/src/rules/readerDebt.js

@@ -0,0 +1,9 @@
+// @ts-check
+/** 독자 부채는 새 판정이 아니라 reader 기제 Finding을 사람이 읽는 이름으로 묶은 것이다. */
+
+import { ruleMechanism } from "./registry.js";
+
+/** @param {import("./finding.js").Finding[]} findings */
+export function readerDebts(findings) {
+  return findings.filter((finding) => ruleMechanism(finding.rule) === "reader");
+}

package/src/rules/registry.js

@@ -154,6 +154,33 @@ export function ruleSummary(name) {
   return ruleDoc(name).split("\n")[0];
 }
 
+/** 기술서의 네 절 표. 파이썬 rules/registry.py 의 REQUIRED_SECTIONS 와 같다. */
+export const REQUIRED_SECTIONS = ["왜:", "어디서:", "고치기:", "안 잡는 것:"];
+
+/** 기술서에서 절 하나의 본문을 한 줄로. 파이썬 docSection 과 같다. @param {string} doc @param {string} label */
+export function docSection(doc, label) {
+  const collected = [];
+  let inside = false;
+  for (const raw of doc.split("\n")) {
+    const line = raw.trim();
+    if (!inside) {
+      if (line.startsWith(label)) {
+        inside = true;
+        collected.push(line.slice(label.length).trim());
+      }
+      continue;
+    }
+    if (!line || REQUIRED_SECTIONS.some((other) => line.startsWith(other))) break;
+    collected.push(line);
+  }
+  return collected.filter(Boolean).join(" ");
+}
+
+/** 규칙의 고치기 절 한 줄. primer 가 쓰기 전에 읽히는 그 문장이다. @param {string} name */
+export function ruleFix(name) {
+  return docSection(ruleDoc(name), "고치기:");
+}
+
 /**
  * 부류의 사람 이름. 파이썬 rules/registry.py 의 CATEGORY_TITLES 와 같은 값과 같은 순서다.
  * @type {Record<string, string>}

package/src/rules/sentence/nounPile.js

@@ -13,7 +13,7 @@ export function run(doc, config) {
   for (const sentence of doc.sentences) {
     if (sentence.nounRun >= config.nounPileMin) {
       findings.push(
-        finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, "error", SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
       );
     }
   }