hanlint 0.0.17 → 0.0.19

package/src/rules/document/enoughOnce.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { matchedTexts } from "../../fingerprint/markers.js";
 import { SENTENCE, finding } from "../finding.js";
 
@@ -20,6 +21,6 @@ export function run(doc, config) {
   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),
+    finding(name, sentence.line, sentence.text, `\`${text}\`${fitJosa(text, "로")} 끊는 문장이 ${first.line}번째 줄에 이미 있다. 글 전체에 한 번만 쓴다. 여러 번 쓰면 끝난다고 해 놓고 글이 계속 이어진다`, null, "error", SENTENCE, sentence.index),
   );
 }

package/src/rules/document/fieldEcho.js

@@ -5,22 +5,26 @@ import { DOCUMENT, NOTICE, finding } from "../finding.js";
 export const name = "fieldEcho";
 export const mechanism = "contrast";
 
+/** 글의 끝으로 보는 절의 수. 결말 뒤에 `더 해 볼 것` 목록이 붙는 경우가 흔하다. 파이썬과 같다. */
+const ENDING_SECTIONS = 2;
+
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
- * @param {import("../../fingerprint/build.js").SectionPrint} section
+ * @param {import("../../fingerprint/build.js").SectionPrint[]} sections
  * @param {string[]} fields
  * @param {string} where
  */
-function check(doc, section, fields, where) {
+function check(doc, sections, fields, where) {
   const findings = [];
+  const section = sections[0];
   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;
+    if ([...promised].some((word) => sections.some((spoken) => spoken.topics.has(word)))) continue;
     findings.push(
-      finding(name, section.startLine, value, `frontmatter 의 \`${name_}\` 가 약속한 말이 ${where}에 하나도 없다. 약속한 것을 ${where}에서 그 말로 답한다`, null, NOTICE, DOCUMENT, section.index),
+      finding(name, section.startLine, value, `frontmatter의 \`${name_}\` 필드가 약속한 말이 ${where}에 하나도 없다. 약속한 것을 ${where}에서 그 말로 답한다`, null, NOTICE, DOCUMENT, section.index),
     );
   }
   return findings;
@@ -32,7 +36,7 @@ function check(doc, section, fields, where) {
  */
 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, "마지막 절"));
+  const findings = check(doc, [doc.intro], config.introFields, "도입");
+  if (doc.sections.length > 1) findings.push(...check(doc, doc.sections.slice(-ENDING_SECTIONS), config.endingFields, "글의 끝"));
   return findings;
 }

package/src/rules/document/keywordHeading.js

@@ -27,6 +27,6 @@ export function run(doc, config) {
     .filter((word) => word.length >= MIN_WORD && promised.includes(word) && !joined.includes(word));
   if (!missing.length) return [];
   return [
-    finding(name, headings[0][2], joined, `글이 내건 \`${missing[0]}\` 가 절 제목 어디에도 없다. 목차를 훑는 독자가 이 글이 그것을 다루는지 못 본다`, null, NOTICE, DOCUMENT, -1),
+    finding(name, headings[0][2], joined, `글이 내건 말이 절 제목 어디에도 없다: \`${missing[0]}\`. 목차를 훑는 독자는 이 글이 그것을 다루는지 알 수 없다`, null, NOTICE, DOCUMENT, -1),
   ];
 }

package/src/rules/document/keywordMissing.js

@@ -17,6 +17,6 @@ export function run(doc, config) {
   const head = `${title}\n${first ? first.text : ""}`;
   if (head.includes(keyword)) return [];
   return [
-    finding(name, first ? first.startLine : 1, title || (first ? first.text : ""), `대표 검색어 \`${keyword}\` 가 제목에도 첫 문단에도 없다. 검색해 들어온 독자가 자기가 친 이름을 못 본다`, null, "error", DOCUMENT, -1),
+    finding(name, first ? first.startLine : 1, title || (first ? first.text : ""), `대표 검색어가 제목에도 첫 문단에도 없다: \`${keyword}\`. 검색해 들어온 독자는 자기가 친 이름을 보지 못한다`, null, "error", DOCUMENT, -1),
   ];
 }

package/src/rules/document/noQuestion.js

@@ -9,7 +9,7 @@ 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, config.enforceStyle.includes(name) ? "error" : "notice", DOCUMENT, -1)];
 }

package/src/rules/document/promiseRecall.js

@@ -9,6 +9,6 @@ export function run(doc) {
   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),
+    finding(name, line, text, "뒤로 미룬 이야기를 `앞에서 미룬 X`처럼 다시 언급하는 문장이 글 어디에도 없다. 뒤에서 다루거나 처음부터 미루지 않는다", null, NOTICE, DOCUMENT, -1),
   );
 }

package/src/rules/document/tableOddCell.js

@@ -53,7 +53,7 @@ export function run(doc, config) {
       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),
+        finding(name, block.startLine + offset, cell, `이 열의 다른 ${values.length - 1}칸은 모두 \`${unit}\` 단위인데 이 칸만 다르다. 같은 단위로 다시 재거나 그 줄을 본문 문장으로 옮긴다`, null, NOTICE, DOCUMENT, block.index),
       );
     }
   }

package/src/rules/finding.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 지적 하나의 모양. 파이썬 rules/finding.py 와 같은 필드와 같은 JSON 순서다. */
+/** 지적 하나의 형식. 파이썬 rules/finding.py와 필드도 JSON 순서도 같다. */
 
 export const ERROR = "error";
 export const NOTICE = "notice";
@@ -18,10 +18,10 @@ const MIN_LOCAL_CUE = 2;
  * @property {string} quote
  * @property {string} why
  * @property {string | null} fix 기계가 낼 수 있을 때만
- * @property {string} severity error 는 규칙 위반, notice 는 확인이 필요한 것
+ * @property {string} severity error는 규칙 위반, notice는 확인이 필요한 것
  * @property {string} scope sentence, paragraph, section, document
- * @property {number} at scope 가 가리키는 지문의 index
- * @property {string | null} fragment 원문에서 바꿀 조각. hanlint fix 가 replacement 로 바꾼다
+ * @property {number} at scope가 가리키는 분석 결과의 index
+ * @property {string | null} fragment 원문에서 바꿀 조각. hanlint fix가 replacement로 바꾼다
  * @property {string | null} replacement
  * @property {Candidate[]} candidates 뜻을 정하지 않고 형태로 좁힐 수 있을 때만. 순위와 점수는 없다
  */

package/src/rules/paragraph/factListParagraph.js

@@ -20,7 +20,7 @@ export function run(doc, config) {
     if (paragraph.sentenceCount < config.factListMinSentences || isLinked(paragraph)) continue;
     if (paragraph.meanLength <= config.factListMaxMeanLength) {
       findings.push(
-        finding(name, paragraph.startLine, paragraph.sentences[0].text, `문장 ${paragraph.sentenceCount}개에 인과 표지가 하나도 없다. 사실만 나열한 문단일 수 있다. 그래서, 때문에 로 잇는다`, null, NOTICE, PARAGRAPH, paragraph.index),
+        finding(name, paragraph.startLine, paragraph.sentences[0].text, `문장 ${paragraph.sentenceCount}개에 인과 접속사가 하나도 없다. 사실만 나열한 문단일 수 있다. \`그래서\`, \`때문에\`로 잇는다`, null, NOTICE, PARAGRAPH, paragraph.index),
       );
     }
   }

package/src/rules/paragraph/paraFragment.js

@@ -31,7 +31,7 @@ export function run(doc, config) {
     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),
+        finding(name, first.startLine, first.sentences.length ? first.sentences[0].text : "", `${config.fragmentRun}개 문단이 연달아 한두 문장씩이다. 화제가 같으면 한 문단으로 묶는다. 줄바꿈은 화제가 바뀌는 곳에만 둔다`, null, "error", PARAGRAPH, first.index),
       );
     }
   }

package/src/rules/readerDebt.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 독자 부채는 새 판정이 아니라 reader 기제 Finding을 사람이 읽는 이름으로 묶은 것이다. */
+/** 독자가 막힐 곳. 새로 판정하지 않고, reader 방법을 쓰는 규칙의 지적을 사람이 읽을 이름으로 묶는다. */
 
 import { ruleMechanism } from "./registry.js";
 

package/src/rules/registry.js

@@ -1,8 +1,8 @@
 // @ts-check
 /**
- * 규칙 등록부. 규칙 하나는 파일 하나이고 `name` 과 `run(doc, config)` 을 내보낸다. 파이썬은 폴더를 걸어 찾고
- * 여기는 목록으로 든다. test/rules.test.js 가 목록과 폴더와 ruleDocs.json 이 같은지 본다.
- * 기술서 (왜, 어디서, 고치기, 안 잡는 것) 는 파이썬 docstring 의 투영 data/ruleDocs.json 에서 읽는다.
+ * 규칙 목록. 규칙 하나는 파일 하나이고 `name`과 `run(doc, config)`을 내보낸다. 파이썬은 폴더를 걸어 찾고
+ * 여기는 목록으로 든다. test/rules.test.js가 목록과 폴더와 ruleDocs.json이 같은지 본다.
+ * 규칙 설명(왜, 어디서, 고치기, 안 잡는 것)은 파이썬 docstring을 옮긴 data/ruleDocs.json에서 읽는다.
  */
 import { enabled } from "../config/settings.js";
 import { loadRuleCategories, loadRuleDocs } from "../data/load.js";
@@ -24,9 +24,11 @@ import * as spacing from "./orthography/spacing.js";
 import * as spelling from "./orthography/spelling.js";
 import * as factListParagraph from "./paragraph/factListParagraph.js";
 import * as paraFragment from "./paragraph/paraFragment.js";
+import * as calqueFrame from "./sentence/calqueFrame.js";
 import * as cliche from "./sentence/cliche.js";
 import * as hardWord from "./sentence/hardWord.js";
 import * as connectorRepeat from "./sentence/connectorRepeat.js";
+import * as phraseRepeat from "./sentence/phraseRepeat.js";
 import * as danglingDeixis from "./sentence/danglingDeixis.js";
 import * as draftHistory from "./sentence/draftHistory.js";
 import * as numberOrphan from "./sentence/numberOrphan.js";
@@ -64,14 +66,16 @@ import * as screenWord from "./screen/screenWord.js";
 /**
  * @typedef {object} Rule
  * @property {string} name
- * @property {string} mechanism 세는 방법. MECHANISMS 의 키 하나
+ * @property {string} mechanism 세는 방법. MECHANISMS의 키 하나
  * @property {(doc: import("../fingerprint/build.js").DocumentPrint, config: import("../config/settings.js").Config) => import("./finding.js").Finding[]} run
  */
 
 /** @type {Rule[]} */
 export const RULES = [
+  calqueFrame,
   cliche,
   connectorRepeat,
+  phraseRepeat,
   danglingDeixis,
   dash,
   draftHistory,
@@ -127,19 +131,19 @@ export const RULES = [
 ];
 
 /**
- * 규칙이 세는 방법의 닫힌 집합. 파이썬 rules/registry.py 의 MECHANISMS 와 같은 값과 같은 순서다.
+ * 규칙이 방식의 닫힌 목록. 파이썬 rules/registry.py의 MECHANISMS와 같은 값과 같은 순서다.
  * @type {Record<string, string>}
  */
 export const MECHANISMS = {
-  dictionary: "사전. 낱말 목록과 정규식이 맞는 자리",
-  repeat: "반복. 같은 모양이 창 안에서 N 번",
-  threshold: "셈. 지문의 값이 임계를 넘거나 모양이 계약과 다른 자리",
-  contrast: "대조. 두 자리를 맞대 어긋난 곳",
-  reader: "독자 상태. 문장 순서대로 독자가 손에 든 것과 본 것에 그 자리가 요구하는 것을 맞댄다",
+  dictionary: "사전. 단어 목록과 정규식이 맞는 곳",
+  repeat: "반복. 같은 모양이 가까이에서 여러 번 나오는 곳",
+  threshold: "수치. 글에서 잰 값이 기준값을 넘거나 정해 둔 형식과 다른 곳",
+  contrast: "비교. 두 곳을 비교해 어긋난 곳",
+  reader: "독자. 앞에서 읽은 내용만으로 그 문장을 이해할 수 있는지 문장 순서대로 본다",
 };
 for (const rule of RULES) {
   if (!(rule.mechanism in MECHANISMS)) {
-    throw new Error(`규칙 ${rule.name} 의 기제 ${rule.mechanism} 은 닫힌 집합 밖이다 (${Object.keys(MECHANISMS).join(", ")}). 새 기제는 규칙 하나 때문에 들어오지 않는다. 멈춰서 묻는다`);
+    throw new Error(`규칙 ${rule.name}의 방식이 닫힌 집합 밖이다: ${rule.mechanism} (있는 것: ${Object.keys(MECHANISMS).join(", ")}). 새 방법은 규칙 하나 때문에 더하지 않는다. 멈추고 묻는다`);
   }
 }
 
@@ -153,7 +157,7 @@ export function ruleNames() {
 /** @param {string} name */
 export function ruleDoc(name) {
   const docs = loadRuleDocs();
-  if (!(name in docs) || !BY_NAME.has(name)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  if (!(name in docs) || !BY_NAME.has(name)) throw new Error(`모르는 규칙: ${name}. hanlint rules로 목록을 본다`);
   return docs[name];
 }
 
@@ -162,10 +166,10 @@ export function ruleSummary(name) {
   return ruleDoc(name).split("\n")[0];
 }
 
-/** 기술서의 네 절 표. 파이썬 rules/registry.py 의 REQUIRED_SECTIONS 와 같다. */
+/** 기술서의 네 절 표. 파이썬 rules/registry.py의 REQUIRED_SECTIONS와 같다. */
 export const REQUIRED_SECTIONS = ["왜:", "어디서:", "고치기:", "안 잡는 것:"];
 
-/** 기술서에서 절 하나의 본문을 한 줄로. 파이썬 docSection 과 같다. @param {string} doc @param {string} label */
+/** 기술서에서 절 하나의 본문을 한 줄로. 파이썬 docSection과 같다. @param {string} doc @param {string} label */
 export function docSection(doc, label) {
   const collected = [];
   let inside = false;
@@ -184,41 +188,41 @@ export function docSection(doc, label) {
   return collected.filter(Boolean).join(" ");
 }
 
-/** 규칙의 고치기 절 한 줄. primer 가 쓰기 전에 읽히는 그 문장이다. @param {string} name */
+/** 규칙의 고치기 절 한 줄. primer가 쓰기 전에 읽히는 그 문장이다. @param {string} name */
 export function ruleFix(name) {
   return docSection(ruleDoc(name), "고치기:");
 }
 
 /**
- * 부류의 사람 이름. 파이썬 rules/registry.py 의 CATEGORY_TITLES 와 같은 값과 같은 순서다.
+ * 묶음의 사람 이름. 파이썬 rules/registry.py의 CATEGORY_TITLES와 같은 값과 같은 순서다.
  * @type {Record<string, string>}
  */
 export const CATEGORY_TITLES = {
-  sentence: "문장 안에서 세는 것",
-  paragraph: "문단 사이에서 세는 것",
-  structure: "글의 짜임에서 세는 것",
-  document: "두 자리를 대조해 세는 것",
+  sentence: "문장",
+  paragraph: "문단",
+  structure: "글의 짜임",
+  document: "문서",
   orthography: "표기와 띄어쓰기",
-  code: "코드 블록 사이를 대조하는 것",
-  screen: "화면의 글에서 세는 것",
+  code: "코드 블록",
+  screen: "화면의 글",
 };
 
 /** 규칙이 세는 방법. @param {string} name */
 export function ruleMechanism(name) {
   const rule = BY_NAME.get(name);
-  if (!rule) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  if (!rule) throw new Error(`모르는 규칙: ${name}. hanlint rules로 목록을 본다`);
   return rule.mechanism;
 }
 
-/** 규칙이 사는 부류. 정본은 파이썬 쪽 폴더이고 여기는 그 투영을 읽는다. @param {string} name */
+/** 규칙이 사는 묶음. 정본은 파이썬 쪽 폴더이고 여기는 그 투영을 읽는다. @param {string} name */
 export function ruleCategory(name) {
   const categories = loadRuleCategories();
-  if (!(name in categories)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  if (!(name in categories)) throw new Error(`모르는 규칙: ${name}. hanlint rules로 목록을 본다`);
   return categories[name];
 }
 
 /**
- * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*` 는 전부다.
+ * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*`는 전부다.
  * @param {import("./finding.js").Finding} f
  * @param {[string, number, number][]} disabled
  */

package/src/rules/screen/screenWord.js

@@ -1,10 +1,11 @@
 // @ts-check
 import { overridingFindings } from "../shared/dictionaryRule.js";
+import { NOTICE } from "../finding.js";
 
 export const name = "screenWord";
 export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
-  return overridingFindings(doc, "screenWord", name);
+  return overridingFindings(doc, "screenWord", name, undefined, NOTICE);
 }

package/src/rules/sentence/calqueFrame.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { overridingFindings } from "../shared/dictionaryRule.js";
+import { NOTICE } from "../finding.js";
+
+export const name = "calqueFrame";
+export const mechanism = "dictionary";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return overridingFindings(doc, "calqueFrame", name, undefined, NOTICE);
+}

package/src/rules/sentence/cliche.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 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) {
-  return dictionaryFindings(doc, "cliches", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "cliches", name, ERROR, config);
 }

package/src/rules/sentence/connectorRepeat.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { SENTENCE, finding } from "../finding.js";
 import { runsOf } from "../shared/repeat.js";
 
@@ -15,7 +16,7 @@ export function run(doc) {
     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, `\`${connector}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
+          finding(name, sentence.line, sentence.text, `\`${connector}\`${fitJosa(connector, "로")} 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
         );
       }
     }

package/src/rules/sentence/danglingDeixis.js

@@ -32,7 +32,7 @@ export function run(doc) {
     if (overlap(reader.recent, sentence.topics) > 0) continue;
     if (isPrompt(reader.previous)) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` ${fitJosa(sentence.deixis[0], "이")} 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index, null, null, danglingDeixisCandidates(sentence, reader.previous)),
+      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

@@ -13,7 +13,7 @@ export function run(doc) {
     block.text.split("\n").forEach((lineText, offset) => {
       if (DASHES.test(lineText)) {
         findings.push(
-          finding(name, block.startLine + offset, lineText.trim(), "긴 줄표다. 부연은 마침표로 끊거나 괄호로, 범위는 물결표 ~ 로 쓴다", null, "error", DOCUMENT, block.index),
+          finding(name, block.startLine + offset, lineText.trim(), "긴 줄표다. 덧붙이는 말은 마침표로 끊거나 괄호에 넣고, 범위는 물결표(~)로 쓴다", null, "error", DOCUMENT, block.index),
         );
       }
     });

package/src/rules/sentence/deixis.js

@@ -16,7 +16,7 @@ export function run(doc) {
     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]}\` ${fitJosa(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),
     );
   }
   return findings;

package/src/rules/sentence/doubleNegative.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "doubleNegative";
@@ -24,7 +25,7 @@ export function run(doc) {
     const start = /** @type {number} */ (match.index);
     const fix = replacement ? sentence.text.slice(0, start) + replacement + sentence.text.slice(start + match[0].length) : null;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 는 이중 부정이다. 긍정으로 쓴다`, fix, "error", SENTENCE, sentence.index, replacement ? match[1] : null, replacement ?? null),
+      finding(name, sentence.line, sentence.text, `\`${match[1]}\`${fitJosa(match[1], "는")} 이중 부정이다. 긍정으로 쓴다`, fix, "error", SENTENCE, sentence.index, replacement ? match[1] : null, replacement ?? null),
     );
   }
   return findings;

package/src/rules/sentence/doublePassive.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { SENTENCE, finding } from "../finding.js";
 import { doublePassiveCandidates } from "../shared/candidates.js";
 
@@ -38,7 +39,7 @@ export function run(doc) {
           name,
           sentence.line,
           sentence.text,
-          `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`,
+          `\`${sentence.passives[0]}\`${fitJosa(sentence.passives[0], "는")} 피동에 \`-어지다\`를 또 붙인 이중 피동이다. 하나만 남긴다`,
           approved ? candidates[0].text : null,
           "error",
           SENTENCE,

package/src/rules/sentence/draftHistory.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { insideAny, matchedSpans } from "../../fingerprint/markers.js";
 import { SENTENCE, finding } from "../finding.js";
 
@@ -16,7 +17,7 @@ export function run(doc, config) {
     for (const [start, end, text] of matchedSpans(sentence.text, "draftHistory.txt")) {
       if (insideAny(start, end, sentence.quoted)) continue;
       findings.push(
-        finding(name, sentence.line, sentence.text, `\`${text}\` 는 글쓴이의 과정이다. 독자는 초고를 본 적이 없다. 알아낸 사실만 결과 문장으로 남긴다`, null, "error", SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `\`${text}\`${fitJosa(text, "는")} 글쓴이의 과정이다. 독자는 초고를 본 적이 없다. 알아낸 사실만 결과 문장으로 남긴다`, null, "error", SENTENCE, sentence.index),
       );
     }
   }

package/src/rules/sentence/endingRepeat.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { NOTICE, SENTENCE, finding } from "../finding.js";
 import { runsOf } from "../shared/repeat.js";
 
@@ -16,12 +17,12 @@ export function run(doc, config) {
     const sentences = section.paragraphs.flatMap((p) => p.sentences);
     const endings = sentences.map((s) => (COUNTED_ENDINGS.has(s.ending) ? s.ending : `__${s.index}`));
     for (const [start, length, ending] of runsOf(endings, config.endingRun)) {
-      // 구간 어딘가에 이유를 잇는 말이나 독자를 부르는 말이 있으면 리듬이 산 것이다. 구간을 쪼개면
+      // 구간 어딘가에 인과 접속사나 독자에게 말을 거는 문장이 있으면 리듬이 산 것이다. 구간을 쪼개면
       // 조각마다 지적이 되어 오히려 늘어난다. 구간 전체를 하나로 보고 살린다.
       if (sentences.slice(start, start + length).some((s) => s.causal || s.readerCall)) continue;
       const first = sentences[start];
       findings.push(
-        finding(name, first.line, first.text, `\`${ending}\` 로 끝나는 문장 ${length}개에 인과도 질문도 독자를 부르는 말도 없다. 질문, 인과, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
+        finding(name, first.line, first.text, `\`${ending}\`${fitJosa(ending, "로")} 끝나는 문장 ${length}개에 인과 접속사도 질문도 독자를 부르는 말도 없다. 질문, 인과 접속사, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
       );
     }
   }

package/src/rules/sentence/euiChain.js

@@ -11,7 +11,7 @@ export function run(doc) {
   for (const sentence of doc.sentences) {
     if (sentence.euiCount >= 3 || (sentence.euiCount >= 2 && euiAdjacent(sentence.text))) {
       findings.push(
-        finding(name, sentence.line, sentence.text, `한 문장에 \`의\` 가 ${sentence.euiCount}번이다. 명사를 쌓은 자리라 관계가 표시되지 않는다. 동사로 편다`, null, "error", SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `한 문장에 \`의\`가 ${sentence.euiCount}번이다. 명사를 쌓은 문장이라 관계가 표시되지 않는다. 동사로 편다`, null, "error", SENTENCE, sentence.index),
       );
     }
   }

package/src/rules/sentence/fillerOpener.js

@@ -12,7 +12,7 @@ export function run(doc) {
     const match = FILLER.exec(sentence.text);
     if (!match) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 만 붙여 잇는 문장이다. 앞에서 만든 파일이나 값을 이름으로 다시 부르고 다음 행동을 붙인다`, null, "error", SENTENCE, sentence.index),
+      finding(name, sentence.line, sentence.text, `\`${match[1]}\`만 붙여 잇는 문장이다. 앞에서 만든 파일이나 값을 이름으로 다시 언급하고 다음 행동을 붙인다`, null, "error", SENTENCE, sentence.index),
     );
   }
   return findings;

package/src/rules/sentence/hardWord.js

@@ -5,7 +5,10 @@ import { dictionaryFindings } from "../shared/dictionaryRule.js";
 export const name = "hardWord";
 export const mechanism = "dictionary";
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  return dictionaryFindings(doc, "easyWords", name, NOTICE);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "easyWords", name, NOTICE, config);
 }

package/src/rules/sentence/imperativePeriod.js

@@ -14,7 +14,7 @@ export function run(doc) {
     const start = /** @type {number} */ (match.index);
     const fix = sentence.text.slice(0, start) + match[1] + sentence.text.slice(start + match[0].length);
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 처럼 명령형과 청유형 뒤에는 마침표를 붙이지 않는다`, fix, "error", SENTENCE, sentence.index, match[0], match[1]),
+      finding(name, sentence.line, sentence.text, `명령·청유 문장 끝(\`${match[1]}\`)에 마침표를 붙이지 않는 표기 방침이다`, fix, "error", SENTENCE, sentence.index, match[0], match[1]),
     );
   }
   return findings;

package/src/rules/sentence/japaneseLoan.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "japaneseLoan";
 export const mechanism = "dictionary";
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  return dictionaryFindings(doc, "japaneseLoan", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "japaneseLoan", name, ERROR, config);
 }

package/src/rules/sentence/longSentence.js

@@ -14,7 +14,7 @@ export function run(doc, config) {
   for (const sentence of doc.sentences) {
     if (sentence.length > config.longSentenceMax) {
       findings.push(
-        finding(name, sentence.line, sentence.text, `어절 ${sentence.length}개다. 상한은 ${config.longSentenceMax}. 마침표로 끊거나 나열이면 목록으로 꺼낸다`, null, NOTICE, SENTENCE, sentence.index, null, null, longSentenceCandidates(sentence.text)),
+        finding(name, sentence.line, sentence.text, `어절이 ${sentence.length}개로 상한 ${config.longSentenceMax}개를 넘는다. 마침표로 끊거나 나열이면 목록으로 꺼낸다`, null, NOTICE, SENTENCE, sentence.index, null, null, longSentenceCandidates(sentence.text)),
       );
     }
   }

package/src/rules/sentence/negationRedefine.js

@@ -24,7 +24,7 @@ export function run(doc) {
       const current = sentences[i];
       const following = sentences[i + 1];
       if (NEGATION.test(current.text) && isDefinition(following.text)) {
-        findings.push(finding(name, current.line, current.text, "단순한 X 가 아닙니다 뒤에 Y 입니다 로 재정의하는 공식이다. 앞 문장을 지우고 Y 를 바로 쓴다", null, "error", SENTENCE, current.index));
+        findings.push(finding(name, current.line, current.text, "`단순한 X가 아닙니다` 뒤에 `Y입니다`로 다시 정의하는 공식이다. 앞 문장을 지우고 Y를 바로 쓴다", null, "error", SENTENCE, current.index));
       }
     }
   }

package/src/rules/sentence/nounPile.js

@@ -1,4 +1,6 @@
 // @ts-check
+import { nounRuns } from "../../analysis/index.js";
+import { attested, usageKindOf } from "../../usage/counts.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "nounPile";
@@ -10,12 +12,16 @@ export const mechanism = "threshold";
  */
 export function run(doc, config) {
   const findings = [];
+  const kind = usageKindOf(config);
   for (const sentence of doc.sentences) {
-    if (sentence.nounRun >= config.nounPileMin) {
-      findings.push(
-        finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
-      );
+    if (sentence.nounRun < config.nounPileMin) continue;
+    if (kind) {
+      const piles = nounRuns(sentence.text).filter(([, length]) => length >= config.nounPileMin).map(([chain]) => chain);
+      if (piles.length && piles.every((chain) => attested(chain, kind, config.usageMin))) continue;
     }
+    findings.push(
+      finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
+    );
   }
   return findings;
 }

package/src/rules/sentence/numberOrphan.js

@@ -37,7 +37,7 @@ export function run(doc, config) {
       if (reader.numerals.has(base) || numeralsIn(sentence.text.slice(0, start)).has(base)) continue;
       if (isAnchored(sentence.text, start)) continue;
       findings.push(
-        finding(name, sentence.line, sentence.text, `\`${base}\` ${fitJosa(base, "가")} 여기서 처음 나오는 값이다. 무엇에서 올라간 것인지 알 수 없다. 그 값이 어디서 나왔는지 밝힌다`, null, NOTICE, SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `\`${base}\`${fitJosa(base, "가")} 여기서 처음 나오는 값이다. 무엇에서 올라간 것인지 알 수 없다. 그 값이 어디서 나왔는지 밝힌다`, null, NOTICE, SENTENCE, sentence.index),
       );
     }
   }