hanlint 0.0.17 → 0.0.18

package/src/config/settings.js

@@ -66,6 +66,7 @@ PRESETS.chat = [...CONVERSATION, ...SCREEN];
 const SCREEN_OFF = [
   "cliche",
   "connectorRepeat",
+  "phraseRepeat",
   "danglingDeixis",
   "deixis",
   "doubleNegative",
@@ -123,6 +124,11 @@ export const PROFILE_OF = {
   screen: null,
 };
 
+/** 프리셋 → 용례 빈도표의 종류. 정본은 파이썬 config/settings.py 의 USAGE_OF 다. @type {Record<string, string>} */
+export const USAGE_OF = { report: "report" };
+/** 실린 빈도표의 종류. */
+export const USAGE_KINDS = [...new Set(Object.values(USAGE_OF))].sort();
+
 export const PRESET_NAMES = Object.keys(PRESETS);
 /** 설정도 옵션도 없을 때의 종류. 이 이름일 때는 출력에 프리셋을 적지 않는다. */
 export const DEFAULT_PRESET = PRESET_NAMES[0];
@@ -152,6 +158,9 @@ export const DEFAULT_PRESET = PRESET_NAMES[0];
  * @property {number} headingSentenceMaxLevel
  * @property {number} bridgeRepeatMin
  * @property {number} nounPileMin
+ * @property {string | null} usageKind 용례 빈도표의 종류. null 이면 프리셋이 정하고 "" 면 보지 않는다
+ * @property {number} usageMin 명사 연쇄가 몇 편의 문서에 나와야 용례로 보는가
+ * @property {number} usageShare 사전 항목이 그 종류의 문서 몇 할에 나오면 관용으로 보는가
  * @property {number} endingRun
  * @property {number} factListMinSentences
  * @property {number} factListMaxMeanLength
@@ -191,6 +200,9 @@ export function defaultConfig() {
     headingSentenceMaxLevel: 6,
     bridgeRepeatMin: 3,
     nounPileMin: 5,
+    usageKind: null,
+    usageMin: 3,
+    usageShare: 0.9,
     endingRun: 4,
     factListMinSentences: 3,
     factListMaxMeanLength: 8.0,
@@ -235,6 +247,11 @@ export function configFromMapping(data) {
         throw new Error(`enforceStyle 은 ${ENFORCEABLE.join(", ")}의 배열이다`);
       }
       config.enforceStyle = [...value];
+    } else if (key === "usageKind") {
+      if (value !== null && value !== "" && !USAGE_KINDS.includes(/** @type {string} */ (value))) {
+        throw new Error(`usageKind 는 ${USAGE_KINDS.join(", ")} 가운데 하나이거나 빈 문자열이다: ${JSON.stringify(value)}`);
+      }
+      config.usageKind = /** @type {string | null} */ (value);
     } else if (key === "dictionary") {
       config.dictionary = { .../** @type {Record<string, unknown[]>} */ (value) };
     } else if (key === "exemplars") {

package/src/data/profiles.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
  * 참조 분포 (프로파일) 의 자료형과 읽기. 파이썬 data/profiles.py 와 같다. 종류별 프로파일은 profiles.json (투영) 에서,
- * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 판의 셈이 같다.
+ * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 구현의 셈이 같다.
  */
 import { readExternal } from "./read.js";
 
@@ -52,7 +52,7 @@ function histogramFromDict(data) {
   return { total: Number(data.total), counts, percentiles };
 }
 
-/** 값이 이 이상인 것의 몫을 천분율 정수로. 정수 셈이라 두 판의 글자가 같다. @param {Histogram} hist @param {number} value */
+/** 값이 이 이상인 것의 몫을 천분율 정수로. 정수 셈이라 두 구현의 글자가 같다. @param {Histogram} hist @param {number} value */
 export function shareAtOrAbove(hist, value) {
   const capped = Math.min(value, CAP);
   let above = 0;

package/src/data/prose.js

@@ -0,0 +1,27 @@
+// @ts-check
+/**
+ * 쓰기 전에 읽는 작법서. 파이썬 data/prose.py 의 투영이고 정본은 koreanProse.txt 하나다.
+ * primer 는 절마다 한 줄로 펴서 첫머리에 싣고, hook --prime 은 본문을 그대로 에이전트 문맥에 넣는다.
+ */
+import { readText } from "./load.js";
+
+export const PROSE = "koreanProse.txt";
+
+/** 작법서 본문. 끝의 줄바꿈 하나까지 파일 그대로다. @returns {string} */
+export function proseGuide() {
+  return readText(PROSE);
+}
+
+/**
+ * (제목, 본문) 짝. 첫 짝은 문서 제목과 첫머리이고 나머지는 일곱 줄이다. 제목의 `#` 는 뗀다.
+ * 파이썬 proseSections 와 같다. @returns {[string, string][]}
+ */
+export function proseSections() {
+  /** @type {[string, string[]][]} */
+  const sections = [];
+  for (const line of proseGuide().split(/\r?\n/)) {
+    if (line.startsWith("#")) sections.push([line.replace(/^#+/, "").trim(), []]);
+    else if (sections.length) sections[sections.length - 1][1].push(line);
+  }
+  return sections.map(([title, body]) => [title, body.join("\n").trim()]);
+}

package/src/document/sourceText.js

@@ -4,15 +4,29 @@
  * 뜻과 규칙은 파이썬 document/sourceText.py 가 소유한다. 여기는 같은 값을 낸다.
  */
 
-export const SOURCE_SUFFIXES = [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".rs", ".py"];
+export const SOURCE_SUFFIXES = [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".rs", ".py", ".html", ".htm", ".vue", ".svelte"];
+/** 태그 사이 글과 속성값을 JSX 와 같은 길로 읽는 파일. HTML 주석 `<!-- -->` 을 걷어낸다. */
+const MARKUP_SUFFIXES = [".html", ".htm", ".vue", ".svelte"];
 
 const KOREAN = /[가-힣]/;
 // 문자열의 경계. 줄을 앞에서부터 훑어 여는 따옴표에서 같은 닫는 따옴표까지를 한 마디로 본다. 파이썬 sourceText.py 와 같다.
 const QUOTES = ["'", '"', "`"];
 const BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
+const HTML_COMMENT = /<!--[\s\S]*?-->/g;
 const DEVELOPER_LINE = /new Error\(|console\.|panic!\(|expect\(|assert/;
 const RUST_CONTINUATION = /\\\r?\n[ \t]*/g;
 const RUST_TEST_MARKER = "#[cfg(test)]";
+/** 문장을 끊지 않는 HTML 인라인 태그. 같은 줄에서 이 태그만 사이에 둔 글 조각은 한 마디로 잇는다. 파이썬 INLINE_TAGS 와 같다. */
+const INLINE_TAGS = new Set("a abbr b bdi bdo cite code data del dfn em i ins kbd mark q s samp small span strong sub sup time u var wbr br".split(" "));
+const INLINE_TAG = /<\/?([a-zA-Z][a-zA-Z0-9]*)[^<>]*>/g;
+const INLINE_GAP = /^(?:\s*<\/?[a-zA-Z][a-zA-Z0-9]*[^<>]*>)+\s*$/;
+const SIBLING_GAP = /<\/[a-zA-Z][a-zA-Z0-9]*\s*>\s*<[a-zA-Z]/;
+const CODE_OPEN = /<(?:script|style)\b/i;
+const CODE_TAG = /<\/?(?:script|style)\b[^<>]*>/gi;
+const CODE_CLOSE = /<\/(?:script|style)\s*>/i;
+/** 마크업 파일에서 태그도 코드 기호도 없는 줄. 여러 줄 문단의 이어지는 줄이다. */
+const PROSE_LINE = /^(?![\s]*$)[^<>=;{}]*$/;
+const HEAD_TEXT = /^\s*[^<\s][^<]*(?=<\/)/;
 
 /**
  * @typedef {object} SourceLiteral
@@ -79,17 +93,36 @@ export function userFacingSource(source, path) {
   if (isRust && body.includes(RUST_TEST_MARKER)) body = body.slice(0, body.indexOf(RUST_TEST_MARKER));
   if (isRust) body = body.replace(RUST_CONTINUATION, "");
   body = body.replace(BLOCK_COMMENT, (block) => block.replace(/[^\n]/g, " "));
+  if (MARKUP_SUFFIXES.some((suffix) => path.endsWith(suffix))) body = body.replace(HTML_COMMENT, (block) => block.replace(/[^\n]/g, " "));
   return body
     .split("\n")
     .map((line) => {
       const trimmed = line.trim();
       if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("#")) return "";
       if (DEVELOPER_LINE.test(line)) return "";
-      return line.replace(/\/\/.*$/, "");
+      return withoutLineComment(line);
     })
     .join("\n");
 }
 
+
+/**
+ * 따옴표 밖의 `//` 부터 자른다. `https://` 처럼 `:` 뒤의 `//` 는 주소라 두고, 문자열 안의 `//` 도 둔다.
+ * 뜻은 파이썬 document/sourceText.py 의 withoutLineComment 가 소유한다.
+ */
+export function withoutLineComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (quote) {
+      if (char === "\\") { i++; continue; }
+      if (char === quote) quote = null;
+    } else if (char === "'" || char === '"' || char === "`") quote = char;
+    else if (char === "/" && line[i + 1] === "/" && (i === 0 || line[i - 1] !== ":")) return line.slice(0, i);
+  }
+  return line;
+}
+
 /** 검사에 쓰는 글. 식을 비우고 공백을 하나로 모은다. @param {string} text */
 export function plainText(text) {
   let plain = "";
@@ -99,6 +132,8 @@ export function plainText(text) {
     cursor = end;
   }
   plain += text.slice(cursor);
+  // 인라인 태그를 비운다. 이름이 영문자로 시작하는 것만이라 `<대상> 필요` 의 꺾쇠는 남는다.
+  plain = plain.replace(INLINE_TAG, (tag, name) => (INLINE_TAGS.has(name.toLowerCase()) ? "" : tag));
   return plain.replace(/\s+/g, " ").trim();
 }
 
@@ -160,7 +195,12 @@ function innerLiterals(text, offset) {
 }
 
 /** 한 줄의 글 마디를 [시작 자리, 글] 로 나온 차례로. 뜻은 파이썬 lineLiterals 가 소유한다. @param {string} line @param {number} [offset] @returns {[number, string][]} */
-export function lineLiterals(line, offset = 0) {
+/**
+ * openEnded (마크업 파일) 이면 여는 태그 뒤 줄 끝까지의 글과 줄 처음부터 닫는 태그 앞까지의 글도 마디다.
+ * 뜻은 파이썬 lineLiterals 가 소유한다.
+ * @param {string} line @param {number} [offset] @param {boolean} [openEnded]
+ */
+export function lineLiterals(line, offset = 0, openEnded = false) {
   /** @type {[number, string][]} */
   const found = [];
   let index = 0;
@@ -176,7 +216,8 @@ export function lineLiterals(line, offset = 0) {
       continue;
     }
     if (char === ">" && tagCloses(line, index)) {
-      const end = jsxTextEnd(line, index + 1);
+      let end = jsxTextEnd(line, index + 1);
+      if (end < 0 && openEnded && index + 1 < line.length) end = line.length;
       if (end > index) {
         const raw = line.slice(index + 1, end);
         found.push([offset + index + 1, raw]);
@@ -187,16 +228,73 @@ export function lineLiterals(line, offset = 0) {
     }
     index += 1;
   }
+  if (openEnded) {
+    const head = HEAD_TEXT.exec(line);
+    if (head && !found.some(([start]) => start < head[0].length)) found.push([offset, head[0]]);
+    else if (!found.length && PROSE_LINE.test(line)) found.push([offset, line]);
+  }
   found.sort((a, b) => a[0] - b[0]);
-  return found;
+  return joinInline(line, found, offset);
+}
+
+/**
+ * 사이가 인라인 태그뿐인 태그 사이 글 조각을 한 마디로 잇는다. 태그 안의 속성 문자열은 잇기에 끼지 않고 제 마디로 남는다.
+ * 뜻은 파이썬 joinInline 이 소유한다.
+ * @param {string} line @param {[number, string][]} found @param {number} offset @returns {[number, string][]}
+ */
+function joinInline(line, found, offset) {
+  const pieces = found.filter(([, raw]) => raw.trim());
+  const attributes = pieces.filter(([start]) => insideTag(line, start - offset));
+  /** @type {[number, string][]} */
+  const joined = [];
+  for (const piece of pieces) {
+    if (attributes.includes(piece)) continue;
+    const [start, raw] = piece;
+    if (joined.length) {
+      const [previousStart, previousRaw] = joined[joined.length - 1];
+      const tail = previousStart - offset + previousRaw.length;
+      if (start - offset >= tail && inlineOnly(line.slice(tail, start - offset))) {
+        joined[joined.length - 1] = [previousStart, line.slice(previousStart - offset, start - offset + raw.length)];
+        continue;
+      }
+    }
+    joined.push([start, raw]);
+  }
+  return [...joined, ...attributes].sort((a, b) => a[0] - b[0]);
+}
+
+/** position 이 태그 안 (`<` 뒤, `>` 앞) 인가. @param {string} line @param {number} position */
+function insideTag(line, position) {
+  const opened = line.lastIndexOf("<", position - 1);
+  return opened >= 0 && line.lastIndexOf(">", position - 1) < opened;
+}
+
+/** 사이가 인라인 태그뿐이고 형제 (`</a><a>`) 가 아니다. @param {string} gap */
+function inlineOnly(gap) {
+  if (!INLINE_GAP.test(gap) || SIBLING_GAP.test(gap)) return false;
+  return [...gap.matchAll(INLINE_TAG)].every((match) => INLINE_TAGS.has(match[1].toLowerCase()));
 }
 
 /** 소스에서 글 마디를 줄 번호 순으로. @param {string} source @param {string} [path] @returns {SourceLiteral[]} */
 export function sourceLiterals(source, path = "") {
   /** @type {SourceLiteral[]} */
   const found = [];
+  const markup = MARKUP_SUFFIXES.some((suffix) => path.endsWith(suffix));
+  // 마크업은 주석 지우기가 줄 수를 지키므로 원문 줄과 나란히 간다. script 블록 판정은 원문 줄로 한다 (`// 주석</script>` 가 지워져도).
+  const rawLines = markup ? source.split("\n") : [];
+  let inCode = false;
   userFacingSource(source, path).split("\n").forEach((line, index) => {
-    for (const [start, raw] of lineLiterals(line)) {
+    // <script> 와 <style> 안은 코드다. 열린 조각 규칙을 끄고 따옴표 문자열만 잡는다. 태그 자체는 빈칸으로 바꿔 자리를 지킨다.
+    const rawLine = markup && index < rawLines.length ? rawLines[index] : line;
+    const opensCode = markup && CODE_OPEN.test(rawLine);
+    const closesCode = markup && CODE_CLOSE.test(rawLine);
+    const openEnded = markup && !inCode && !opensCode;
+    if (markup) {
+      if (opensCode && !closesCode) inCode = true;
+      else if (inCode && closesCode) inCode = false;
+    }
+    const scanned = opensCode || closesCode ? line.replace(CODE_TAG, (tag) => " ".repeat(tag.length)) : line;
+    for (const [start, raw] of lineLiterals(scanned, 0, openEnded)) {
       const text = raw.trim();
       const plain = plainText(text);
       if (text && KOREAN.test(plain)) found.push({ line: index + 1, text, plain, column: start + (raw.length - raw.trimStart().length) + 1 });

package/src/fingerprint/build.js

@@ -130,11 +130,15 @@ function quotedIn(sentence, blockSpans) {
 function makeSentencePrint(build, text, line, block, sectionIndex, quoted) {
   const { entries } = build;
   const ending = markers.endingOf(text);
+  const protectedSpans = markers.termSpans(text, build.protectedTerms);
+  // 인용 안의 것과 보호한 용어에 걸친 것은 뺀다. 뜻은 파이썬 fingerprint/build.py 의 kept 가 정한다.
+  /** @param {number} start @param {number} end */
+  const kept = (start, end) => !markers.insideAny(start, end, quoted) && !markers.overlapsAny(start, end, protectedSpans);
   const deixis = markers
     .matchedSpans(text, "deixis.txt")
-    .filter(([start, end]) => !markers.insideAny(start, end, quoted))
+    .filter(([start, end]) => kept(start, end))
     .map(([, , found]) => found);
-  const matches = matchesIn(text, entries).filter((m) => !markers.insideAny(m.start, m.end, quoted));
+  const matches = matchesIn(text, entries).filter((m) => kept(m.start, m.end));
   const mood = markers.moodOf(text, ending);
   return {
     index: build.sentences.length,
@@ -154,7 +158,7 @@ function makeSentencePrint(build, text, line, block, sectionIndex, quoted) {
     euiCount: euiCount(text),
     nounRun: longestNounRun(text),
     passives: doublePassiveSpans(text)
-      .filter(([start, end]) => !markers.insideAny(start, end, quoted))
+      .filter(([start, end]) => kept(start, end))
       .map(([, , surface]) => surface),
     hedges: markers.countMatches(text, "hedges.txt"),
     numbers: markers.countNumbers(text),
@@ -267,7 +271,12 @@ function buildSection(build, section, sectionIndex) {
 export function buildFingerprint(doc, config = defaultConfig()) {
   // 코드도 산문도 아닌 펜스는 지문에 들어오기 전에 뺀다. 모든 진입점이 여기를 지나므로 한 자리면 된다.
   doc = dropFences(doc, config.ignoreFences);
-  const build = { entries: entriesFor(config), sentences: /** @type {SentencePrint[]} */ ([]), paragraphs: /** @type {ParagraphPrint[]} */ ([]) };
+  const build = {
+    entries: entriesFor(config),
+    protectedTerms: config.protectedTerms ?? [],
+    sentences: /** @type {SentencePrint[]} */ ([]),
+    paragraphs: /** @type {ParagraphPrint[]} */ ([]),
+  };
   const { sentences, paragraphs } = build;
   const sections = doc.sections.map((section, index) =>
     buildSection(build, section, index),

package/src/fingerprint/dictionaries.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 사전 넷을 한 번 컴파일하고 문장에서 맞는 자리를 찾는다. 설정의 dictionary 항목을 더한다. */
+/** 사전들을 한 번 컴파일하고 문장에서 맞는 자리를 찾는다. 설정의 dictionary 항목을 더한다. */
 import { loadEntries } from "../data/load.js";
 import { compile } from "../regex.js";
 
@@ -16,6 +16,7 @@ export const DICTIONARY_FILES = {
   screenNarration: "screenNarration.toml",
   screenTone: "screenTone.toml",
   screenWord: "screenWord.toml",
+  calqueFrame: "calqueFrame.toml",
 };
 const GROUP_REF = /\$(\d)/g;
 const FINALS = { ㄴ: 4, ㄹ: 8 };
@@ -44,6 +45,9 @@ export function expandClasses(pattern) {
  * @property {string} why
  * @property {string} source
  * @property {string | null} fix
+ * @property {{ pattern: import("../regex.js").Pattern, into: string }[]} to 문장 전체를 다시 쓰는 규칙. 앞의 것부터 시도한다
+ * @property {string} raw pattern 의 원문. 내장 항목만 갖고 설정 항목은 빈 글자라 관용으로 접히지 않는다
+ * @property {import("../regex.js").Pattern | null} unless 문장 전체에서 이것이 맞으면 그 문장에서는 항목이 맞지 않는다. 파이썬 Entry.unless 와 같다
  */
 
 /**
@@ -55,10 +59,12 @@ export function expandClasses(pattern) {
  * @property {string} why
  * @property {string} source
  * @property {string | null} fix
+ * @property {string | null} rewrite 항목의 to 규칙으로 문장 전체를 다시 쓴 제안. 없거나 안 맞으면 null
+ * @property {string} pattern 맞은 항목의 pattern 원문. 용례 빈도표의 키다
  */
 
-/** @param {string} dictionary @param {Record<string, unknown> | string} raw @returns {Entry} */
-export function entryFrom(dictionary, raw) {
+/** @param {string} dictionary @param {Record<string, unknown> | string} raw @param {boolean} [builtin] @returns {Entry} */
+export function entryFrom(dictionary, raw, builtin = false) {
   const data = typeof raw === "string" ? { pattern: raw } : raw;
   return {
     dictionary,
@@ -66,6 +72,9 @@ export function entryFrom(dictionary, raw) {
     why: /** @type {string} */ (data.why ?? "설정에서 더한 항목"),
     source: /** @type {string} */ (data.source ?? "설정"),
     fix: /** @type {string | null} */ (data.fix ?? null),
+    to: (/** @type {[string, string][]} */ (data.to ?? [])).map(([source, into]) => ({ pattern: compile(expandClasses(source)), into })),
+    raw: builtin ? /** @type {string} */ (data.pattern) : "",
+    unless: data.unless ? compile(expandClasses(/** @type {string} */ (data.unless))) : null,
   };
 }
 
@@ -75,7 +84,7 @@ export function builtinEntries() {
   if (!builtinCache) {
     builtinCache = [];
     for (const [dictionary, name] of Object.entries(DICTIONARY_FILES)) {
-      for (const raw of loadEntries(name)) builtinCache.push(entryFrom(dictionary, raw));
+      for (const raw of loadEntries(name)) builtinCache.push(entryFrom(dictionary, raw, true));
     }
   }
   return builtinCache;
@@ -99,11 +108,27 @@ export function applyFix(match, fix) {
   return fix.replace(GROUP_REF, (_, n) => match[Number(n)] ?? "");
 }
 
+/**
+ * to 규칙으로 문장을 다시 쓴다. 빈 그룹이 남긴 겹 공백은 하나로 줄이고 양끝을 다듬는다. 원문과 같으면 null.
+ * 뜻은 파이썬 fingerprint/dictionaries.py 의 rewriteBy 가 소유한다.
+ * @param {string} text @param {Entry["to"]} rules
+ */
+export function rewriteBy(text, rules) {
+  for (const { pattern, into } of rules) {
+    const match = pattern.search(text);
+    if (!match) continue;
+    const rewritten = applyFix(match, into).split(/\s+/).filter(Boolean).join(" ");
+    return rewritten && rewritten !== text ? rewritten : null;
+  }
+  return null;
+}
+
 /** @param {string} text @param {Entry[]} entries @returns {DictionaryMatch[]} */
 export function matchesIn(text, entries) {
   /** @type {DictionaryMatch[]} */
   const found = [];
   for (const entry of entries) {
+    if (entry.unless && entry.unless.search(text)) continue;
     for (const match of entry.pattern.all(text)) {
       const start = /** @type {number} */ (match.index);
       found.push({
@@ -114,6 +139,8 @@ export function matchesIn(text, entries) {
         why: entry.why,
         source: entry.source,
         fix: entry.fix ? applyFix(match, entry.fix) : null,
+        rewrite: entry.to.length ? rewriteBy(text, entry.to) : null,
+        pattern: entry.raw,
       });
     }
   }

package/src/fingerprint/markers.js

@@ -147,6 +147,28 @@ export function quoteSpans(text) {
   return found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
 }
 
+/**
+ * 설정의 protectedTerms 가 글에 나온 [시작, 끝] 전부. 겹쳐 나온 자리도 따로 센다. 파이썬 termSpans 와 같다.
+ * @param {string} text @param {string[]} terms @returns {[number, number][]}
+ */
+export function termSpans(text, terms) {
+  /** @type {[number, number][]} */
+  const found = [];
+  for (const term of terms) {
+    let start = text.indexOf(term);
+    while (start !== -1) {
+      found.push([start, start + term.length]);
+      start = text.indexOf(term, start + 1);
+    }
+  }
+  return found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+
+/** 두 구간이 한 글자라도 겹치는가. 파이썬 overlapsAny 와 같다. @param {number} start @param {number} end @param {[number, number][]} spans */
+export function overlapsAny(start, end, spans) {
+  return spans.some(([spanStart, spanEnd]) => spanStart < end && start < spanEnd);
+}
+
 /** @param {number} start @param {number} end @param {[number, number][]} spans */
 export function insideAny(start, end, spans) {
   return spans.some(([spanStart, spanEnd]) => spanStart <= start && end <= spanEnd);

package/src/index.js

@@ -26,7 +26,7 @@ import { configFromMapping, defaultConfig } from "./config/settings.js";
 import { loadVersion } from "./data/load.js";
 import { parseMarkdown } from "./document/parseMarkdown.js";
 import { SOURCE_SUFFIXES, replaceLiteral, sourceLiterals } from "./document/sourceText.js";
-import { parseSheet, renderSheet, renderSheetJson } from "./report/sheet.js";
+import { applyRows, parseSheet, renderSheet, renderSheetJson, sheetRows } from "./report/sheet.js";
 import { headingsOf } from "./document/model.js";
 import { applyFixes } from "./edit/applyFixes.js";
 import { buildFingerprint } from "./fingerprint/build.js";
@@ -54,6 +54,8 @@ export {
   parseSheet,
   renderSheet,
   renderSheetJson,
+  sheetRows,
+  applyRows,
   replaceLiteral,
   sourceLiterals,
   CONTRACT_VERSION,

package/src/report/compactReport.js

@@ -1,7 +1,7 @@
 // @ts-check
-/** 한 줄에 지적 하나. AI 와 스크립트가 읽는 꼴이다. 파이썬 report/compactReport.py 와 같은 글자다. */
+/** 한 줄에 지적 하나. AI 와 스크립트가 읽는 형식이다. 파이썬 report/compactReport.py 와 같은 글자다. */
 
-/** 줄바꿈과 이어진 공백을 하나로 눕힌다. 한 줄은 이 꼴의 계약이다. @param {string} text */
+/** 줄바꿈과 이어진 공백을 하나로 눕힌다. 한 줄은 이 형식의 계약이다. @param {string} text */
 function flat(text) {
   return text.split(/\s+/).filter(Boolean).join(" ");
 }
@@ -9,6 +9,10 @@ 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}] ${f.severity === "notice" ? "notice: " : ""}${flat(f.why)}` + (f.fix ? `  고친 뒤: ${flat(f.fix)}` : ""))
+    .map((f) => {
+      const label = f.severity === "notice" ? "notice: " : "";
+      const fixLabel = f.severity === "notice" ? "검토할 대안" : "고친 뒤";
+      return `${path}:${f.line} [${f.rule}] ${label}${flat(f.why)}` + (f.fix ? `  ${fixLabel}: ${flat(f.fix)}` : "");
+    })
     .join("\n");
 }

package/src/report/jsonReport.js

@@ -1,8 +1,8 @@
 // @ts-check
 /**
- * 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다.
+ * 기계가 읽는 형식. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다.
  * 지적마다 `exemplar` 를 붙인다. 승인 원문 완전 일치 `patch`는 맞는 지적에만 별도로 붙인다.
- * 실제 수정 차이는 파이썬의 exemplarLift와 patchMemory 탐침에서 따로 잰다.
+ * 실제 수정 차이는 파이썬의 exemplarLift와 patchMemory 실험 스크립트에서 따로 잰다.
  */
 import { exemplarFor } from "../data/exemplars.js";
 import { findingAsDict } from "../rules/finding.js";

package/src/report/textReport.js

@@ -35,21 +35,40 @@ function candidateLines(findings) {
   return lines;
 }
 
-/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings @param {string | null | undefined} [register] @param {string | null | undefined} [preset] @param {import("../data/exemplars.js").Exemplar[]} [customExemplars] */
-export function renderText(path, findings, register = null, preset = null, customExemplars = []) {
-  if (!findings.length) return `${path}  집은 자리 없음`;
+/** 접은 확인 권고. 규칙마다 개수와 줄 번호 한 줄. 뜻은 파이썬 textReport.py 의 noticeLines 가 소유한다. @param {import("../rules/finding.js").Finding[]} notices */
+function noticeLines(notices) {
+  /** @type {Map<string, number[]>} */
+  const byRule = new Map();
+  for (const finding of notices) {
+    if (!byRule.has(finding.rule)) byRule.set(finding.rule, []);
+    /** @type {number[]} */ (byRule.get(finding.rule)).push(finding.line);
+  }
+  const lines = [`확인 권고 ${notices.length}건 (접음. 다 보려면 --notices)`];
+  for (const rule of [...byRule.keys()].sort()) {
+    const numbers = [...new Set(/** @type {number[]} */ (byRule.get(rule)))].sort((a, b) => a - b);
+    lines.push(`  ${rule} ${/** @type {number[]} */ (byRule.get(rule)).length}  ${numbers.join(", ")}줄`);
+  }
+  return lines;
+}
+
+/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings @param {string | null | undefined} [register] @param {string | null | undefined} [preset] @param {import("../data/exemplars.js").Exemplar[]} [customExemplars] @param {boolean} [unfoldNotices] */
+export function renderText(path, findings, register = null, preset = null, customExemplars = [], unfoldNotices = false) {
+  if (!findings.length) return `${path}  오류 없음`;
   const errors = findings.filter((f) => f.severity === "error").length;
   const notices = findings.length - errors;
-  const summary = `${path}  집은 자리 ${errors}` + (notices ? `, 확인할 자리 ${notices}` : "");
+  const summary = `${path}  오류 ${errors}건` + (notices ? `, 확인 권고 ${notices}건` : "");
   const lines = [summary, ""];
-  for (const f of findings) {
+  const folded = unfoldNotices ? [] : findings.filter((f) => f.severity === "notice");
+  const shown = findings.filter((f) => unfoldNotices || f.severity === "error");
+  for (const f of shown) {
     const tag = `[${f.rule}]` + (f.severity === "notice" ? " 확인" : "");
     lines.push(`${path}:${f.line}  ${tag}`, `  ${f.quote}`, `  ${f.why}`);
-    if (f.fix) lines.push(`  고친 뒤: ${f.fix}`);
+    if (f.fix) lines.push(`  ${f.severity === "notice" ? "검토할 대안" : "고친 뒤"}: ${f.fix}`);
     lines.push("");
   }
-  lines.push(...exemplarLines(findings, register, preset, customExemplars));
-  const candidates = candidateLines(findings);
+  if (folded.length) lines.push(...noticeLines(folded), "");
+  lines.push(...exemplarLines(shown, register, preset, customExemplars));
+  const candidates = candidateLines(shown);
   if (candidates.length) lines.push("", ...candidates);
   return lines.join("\n").replace(/\n+$/, "");
 }

package/src/report/writingSpec.js

@@ -34,7 +34,7 @@ function selectedProfile(config) {
 }
 
 /**
- * 현재 규칙판을 쓰기 전 숫자 사양으로 편다. 품질 점수나 새 임계는 만들지 않는다.
+ * 현재 규칙 세트를 쓰기 전 숫자 사양으로 편다. 품질 점수나 새 임계는 만들지 않는다.
  * @param {import("./settings.js").Config} [config]
  * @param {string} [register]
  * @param {number | null} [targetChars]
@@ -161,11 +161,11 @@ export function writingSpec(config = defaultConfig(), register = HAPNIDA, target
   };
 }
 
-/** 사람이 읽는 꼴. basis는 JSON에서 확인한다. @param {ReturnType<typeof writingSpec>} spec */
+/** 사람이 읽는 형식. 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} 프로파일을 쓰기 전 숫자로 편다`,
+    `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}`);

package/src/rules/registry.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";
@@ -70,8 +72,10 @@ import * as screenWord from "./screen/screenWord.js";
 
 /** @type {Rule[]} */
 export const RULES = [
+  calqueFrame,
   cliche,
   connectorRepeat,
+  phraseRepeat,
   danglingDeixis,
   dash,
   draftHistory,
@@ -133,7 +137,7 @@ export const RULES = [
 export const MECHANISMS = {
   dictionary: "사전. 낱말 목록과 정규식이 맞는 자리",
   repeat: "반복. 같은 모양이 창 안에서 N 번",
-  threshold: "셈. 지문의 값이 임계를 넘거나 모양이 계약과 다른 자리",
+  threshold: "셈. 분석표의 값이 임계를 넘거나 모양이 계약과 다른 자리",
   contrast: "대조. 두 자리를 맞대 어긋난 곳",
   reader: "독자 상태. 문장 순서대로 독자가 손에 든 것과 본 것에 그 자리가 요구하는 것을 맞댄다",
 };

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);
 }