hanlint 0.0.1

package/src/regex.js

@@ -0,0 +1,47 @@
+// @ts-check
+/**
+ * 파이썬 re 와 같은 뜻으로 쓰는 얇은 껍질. search 는 첫 자리, at 은 문자열 첫머리에서만, all 은 전부.
+ * 정규식 문법은 데이터 파일과 규칙에서 파이썬과 같은 부분집합만 쓴다 (lookbehind 포함, 이름 그룹 없음).
+ */
+
+const BACKSLASH = String.fromCharCode(92);
+const SPECIALS = new RegExp(`[.*+?^\${}()|[${BACKSLASH}]${BACKSLASH}${BACKSLASH}/-]`, "g");
+
+/**
+ * @typedef {object} Pattern
+ * @property {string} source
+ * @property {(text: string) => RegExpExecArray | null} search 파이썬 re.search
+ * @property {(text: string) => RegExpExecArray | null} at 파이썬 re.match (첫머리에서만)
+ * @property {(text: string) => RegExpExecArray[]} all 파이썬 re.finditer
+ */
+
+/**
+ * @param {string} source
+ * @param {string} [flags] u 같은 추가 플래그
+ * @returns {Pattern}
+ */
+export function compile(source, flags = "") {
+  const once = new RegExp(source, flags);
+  const sticky = new RegExp(source, `${flags}y`);
+  const every = new RegExp(source, `${flags}g`);
+  return {
+    source,
+    search(text) {
+      once.lastIndex = 0;
+      return once.exec(text);
+    },
+    at(text) {
+      sticky.lastIndex = 0;
+      return sticky.exec(text);
+    },
+    all(text) {
+      every.lastIndex = 0;
+      return [...text.matchAll(every)];
+    },
+  };
+}
+
+/** 정규식 특수문자를 이스케이프한다 (파이썬 re.escape 의 쓰임새). @param {string} text */
+export function escape(text) {
+  return text.replace(SPECIALS, (c) => BACKSLASH + c);
+}

package/src/report/compactReport.js

@@ -0,0 +1,9 @@
+// @ts-check
+/** 한 줄에 지적 하나. AI 와 스크립트가 읽는 꼴이다. 파이썬 report/compactReport.py 와 같은 글자다. */
+
+/** @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.why}` + (f.fix ? `  고친 뒤: ${f.fix}` : ""))
+    .join("\n");
+}

package/src/report/fingerprintJson.js

@@ -0,0 +1,126 @@
+// @ts-check
+/**
+ * 지문 계층의 JSON 꼴. 파이썬 report/fingerprintJson.py 와 같은 키 순서다. 층마다 한 번씩만 적고 위층은
+ * 아래층을 index 로 가리킨다. 실수는 소수 여섯째 자리로 맞춰 두 구현이 같은 글자를 낸다.
+ */
+
+export const LAYERS = ["all", "sentences", "paragraphs", "sections", "document"];
+
+/** @param {number | null} value */
+function num(value) {
+  if (value === null) return null;
+  return Math.round(value * 1e6) / 1e6;
+}
+
+/** @param {Set<string>} set */
+function sortedList(set) {
+  return [...set].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+
+/** @param {import("../fingerprint/build.js").SentencePrint} s */
+function sentenceDict(s) {
+  return {
+    index: s.index,
+    line: s.line,
+    text: s.text,
+    blockIndex: s.blockIndex,
+    paragraphIndex: s.paragraphIndex,
+    sectionIndex: s.sectionIndex,
+    length: s.length,
+    ending: s.ending,
+    mood: s.mood,
+    commas: s.commas,
+    connectorStart: s.connectorStart,
+    causal: s.causal,
+    deixis: [...s.deixis],
+    euiCount: s.euiCount,
+    nounRun: s.nounRun,
+    passives: [...s.passives],
+    hedges: s.hedges,
+    numbers: s.numbers,
+    topics: sortedList(s.topics),
+    promises: [...s.promises],
+    recalls: [...s.recalls],
+    countPromises: s.countPromises.map(([n, unit, text]) => [n, unit, text]),
+    readerCall: s.readerCall,
+    matches: s.matches.map((m) => ({
+      dictionary: m.dictionary,
+      text: m.text,
+      start: m.start,
+      end: m.end,
+      why: m.why,
+      source: m.source,
+      fix: m.fix,
+    })),
+    quoted: s.quoted.map(([start, end]) => [start, end]),
+  };
+}
+
+/** @param {import("../fingerprint/build.js").ParagraphPrint} p */
+function paragraphDict(p) {
+  return {
+    index: p.index,
+    blockIndex: p.blockIndex,
+    sectionIndex: p.sectionIndex,
+    startLine: p.startLine,
+    endLine: p.endLine,
+    sentences: p.sentences.map((s) => s.index),
+    sentenceCount: p.sentenceCount,
+    meanLength: num(p.meanLength),
+    lengthStd: num(p.lengthStd),
+    causalTotal: p.causalTotal,
+    deixisTotal: p.deixisTotal,
+    topics: sortedList(p.topics),
+    overlapWithPrevious: num(p.overlapWithPrevious),
+    followsProseDirectly: p.followsProseDirectly,
+  };
+}
+
+/** @param {import("../fingerprint/build.js").SectionPrint} s */
+function sectionDict(s) {
+  return {
+    index: s.index,
+    title: s.title,
+    level: s.level,
+    startLine: s.startLine,
+    paragraphs: s.paragraphs.map((p) => p.index),
+    blockKinds: [...s.blockKinds],
+    topics: sortedList(s.topics),
+    isIntro: s.isIntro,
+  };
+}
+
+/** @param {import("../fingerprint/build.js").DocumentPrint} doc */
+function documentDict(doc) {
+  return {
+    path: doc.path,
+    frontmatter: { ...doc.frontmatter },
+    headings: doc.headings.map(([level, text, line]) => [level, text, line]),
+    wordCount: doc.wordCount,
+    sentenceCount: doc.sentences.length,
+    paragraphCount: doc.paragraphs.length,
+    sectionCount: doc.sections.length,
+    questionCount: doc.questionCount,
+    readerCallCount: doc.readerCallCount,
+    countPromises: doc.countPromises.map(([n, unit, line, text]) => [n, unit, line, text]),
+    promises: doc.promises.map(([line, text]) => [line, text]),
+    recalls: doc.recalls.map(([line, text]) => [line, text]),
+    disabled: doc.disabled.map(([name, start, end]) => [name, start, end]),
+  };
+}
+
+/** @param {import("../fingerprint/build.js").DocumentPrint} doc @param {string} [layer] */
+export function fingerprintDict(doc, layer = "all") {
+  /** @type {Record<string, unknown>} */
+  const data = { version: 1, layer };
+  if (layer === "all" || layer === "document") data.document = documentDict(doc);
+  if (layer === "all" || layer === "sections") data.sections = doc.sections.map(sectionDict);
+  if (layer === "all" || layer === "paragraphs") data.paragraphs = doc.paragraphs.map(paragraphDict);
+  if (layer === "all" || layer === "sentences") data.sentences = doc.sentences.map(sentenceDict);
+  return data;
+}
+
+/** @param {import("../fingerprint/build.js").DocumentPrint} doc @param {string} [layer] */
+export function renderFingerprintJson(doc, layer = "all") {
+  return JSON.stringify(fingerprintDict(doc, layer), null, 2);
+}

package/src/report/githubReport.js

@@ -0,0 +1,13 @@
+// @ts-check
+/** GitHub Actions 의 워크플로 명령 꼴. PR 에 줄 단위 주석이 붙는다. */
+
+/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
+export function renderGithub(path, findings) {
+  return findings
+    .map((f) => {
+      const level = f.severity === "error" ? "error" : "notice";
+      const message = `[${f.rule}] ${f.why}`.replace(/\n/g, " ");
+      return `::${level} file=${path},line=${f.line}::${message}`;
+    })
+    .join("\n");
+}

package/src/report/jsonReport.js

@@ -0,0 +1,16 @@
+// @ts-check
+/** 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다. */
+import { findingAsDict } from "../rules/finding.js";
+
+/**
+ * @param {Map<string, import("../rules/finding.js").Finding[]>} results
+ * @param {string | null} [configLabel]
+ */
+export function renderJson(results, configLabel = null) {
+  const files = [...results].map(([path, findings]) => ({ path, findings: findings.map(findingAsDict) }));
+  /** @type {Record<string, unknown>} */
+  const data = { version: 1 };
+  if (configLabel !== null) data.config = configLabel;
+  data.files = files;
+  return JSON.stringify(data, null, 2);
+}

package/src/report/textReport.js

@@ -0,0 +1,19 @@
+// @ts-check
+/** 사람이 읽는 지적 목록. `파일:줄` 로 시작해 편집기가 바로 연다. 파이썬 report/textReport.py 와 같은 글자다. */
+
+/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
+export function renderText(path, findings) {
+  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 lines = [summary, ""];
+  for (const f of findings) {
+    const tag = `[${f.rule}]` + (f.severity === "notice" ? " 확인" : "");
+    lines.push(`${path}:${f.line}  ${tag}`, `  ${f.quote}`, `  ${f.why}`);
+    if (f.fix) lines.push(`  고친 뒤: ${f.fix}`);
+    lines.push("");
+  }
+  lines.push(`규칙이 왜 있는지 보려면: hanlint explain ${findings[0].rule}`);
+  return lines.join("\n");
+}

package/src/rules/code/duplicateBlock.js

@@ -0,0 +1,48 @@
+// @ts-check
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+import { codeBlocksOf } from "../shared/codeBlocks.js";
+
+export const name = "duplicateBlock";
+const MIN_LINES = 4;
+
+/** 줄 다중집합의 겹침 비. 2 * 공통 / (a + b). @param {string[]} a @param {string[]} b */
+function similarity(a, b) {
+  if (!a.length || !b.length) return 0;
+  /** @type {Map<string, number>} */
+  const counts = new Map();
+  for (const line of a) counts.set(line, (counts.get(line) ?? 0) + 1);
+  let common = 0;
+  for (const line of b) {
+    const n = counts.get(line) ?? 0;
+    if (n > 0) {
+      counts.set(line, n - 1);
+      common += 1;
+    }
+  }
+  return (2 * common) / (a.length + b.length);
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  const blocks = codeBlocksOf(doc).filter((b) => b.lines.filter(([, line]) => line.trim()).length >= MIN_LINES);
+  for (let later = 0; later < blocks.length; later++) {
+    const current = blocks[later];
+    const currentLines = current.lines.filter(([, line]) => line.trim()).map(([, line]) => line.trim());
+    for (let earlier = 0; earlier < later; earlier++) {
+      const previous = blocks[earlier];
+      if (previous.isOutput !== current.isOutput) continue;
+      const ratio = similarity(previous.lines.filter(([, line]) => line.trim()).map(([, line]) => line.trim()), currentLines);
+      if (ratio >= config.duplicateBlockRatio) {
+        findings.push(
+          finding(name, current.startLine, currentLines[0], `${previous.startLine}번째 줄의 블록과 ${Math.round(ratio * 100)}% 같다. 다른 줄만 남기거나 앞 블록을 가리킨다`, null, NOTICE, DOCUMENT, current.index),
+        );
+        break;
+      }
+    }
+  }
+  return findings;
+}

package/src/rules/code/firstResultDistance.js

@@ -0,0 +1,23 @@
+// @ts-check
+import { CODE, IMAGE, TABLE } from "../../document/model.js";
+import { NOTICE, PARAGRAPH, finding } from "../finding.js";
+
+export const name = "firstResultDistance";
+const RESULT_KINDS = [CODE, IMAGE, TABLE];
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const firstResult = doc.blocks.find((b) => RESULT_KINDS.includes(b.kind));
+  if (!firstResult) return [];
+  const before = doc.paragraphs.filter((p) => p.startLine < firstResult.startLine);
+  if (before.length > config.firstResultMaxParagraphs) {
+    const over = before[config.firstResultMaxParagraphs];
+    return [
+      finding(name, over.startLine, over.sentences.length ? over.sentences[0].text : "", `첫 코드나 표까지 산문 문단이 ${before.length}개다. ${config.firstResultMaxParagraphs}개 안에 실행할 것이 온다`, null, NOTICE, PARAGRAPH, over.index),
+    ];
+  }
+  return [];
+}

package/src/rules/code/inputFileSource.js

@@ -0,0 +1,103 @@
+// @ts-check
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+import { codeBlocksOf } from "../shared/codeBlocks.js";
+
+export const name = "inputFileSource";
+
+const QUOTED = "\\(\\s*[\"']([^\"'\\n]+)[\"']";
+const READS = new RegExp(
+  "\\b(?:read_csv|read_excel|read_parquet|read_json|read_sql|read_table|read_ndjson|scan_csv|scan_parquet|scan_ndjson|" +
+    "read_text|read_bytes|loadtxt|imread|load_workbook)" + QUOTED,
+  "g",
+);
+const OPENS = new RegExp("\\bopen" + QUOTED + "\\s*(?:,\\s*(?:mode\\s*=\\s*)?[\"']([^\"']*)[\"'])?", "g");
+const WRITES = new RegExp(
+  "\\b(?:to_csv|to_excel|to_parquet|to_json|to_sql|write_csv|write_parquet|write_json|write_ndjson|sink_parquet|sink_csv|" +
+    "write_text|write_bytes|savefig|save|imwrite|savetxt|dump)" + QUOTED,
+  "g",
+);
+const SHELL_WRITES = /(?:>>?|-o|-O|--output|Out-File)\s*["']?([\w./\\-]+\.[A-Za-z0-9]+)/g;
+const SQL_PATHS = /FROM\s+'([^']+\.(?:csv|parquet|json|xlsx))'/gi;
+const MAKES_DIR = /(?:mkdir(?:\s+-p)?|makedirs|md)\s*\(?\s*["']?([\w./\\-]+)|Path\(\s*["']([^"']+)["']\s*\)\.mkdir/g;
+const EXTENSIONS = new Set(
+  "csv xlsx xls parquet json jsonl txt png jpg jpeg svg gif db sqlite md py yaml yml toml html pdf zip ndjson".split(" "),
+);
+
+/** @param {string} path */
+function fileName(path) {
+  const parts = path.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1];
+}
+
+/** @param {string} path */
+function isDataFile(path) {
+  if (["*", "{", "http", "://", "<", ">"].some((mark) => path.includes(mark))) return false;
+  const name = fileName(path);
+  return name.includes(".") && EXTENSIONS.has(name.split(".").pop()?.toLowerCase() ?? "");
+}
+
+/** @param {string} path */
+function directoryOf(path) {
+  const parts = path.replace(/\\/g, "/").split("/");
+  return parts.length > 1 && !["", ".", ".."].includes(parts[0]) ? parts[0] : null;
+}
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc @param {string} needle @param {number} line */
+function mentionedBefore(doc, needle, line) {
+  return doc.sentences.some((s) => s.line < line && s.text.includes(needle));
+}
+
+/** @param {RegExp} pattern @param {string} text @param {number} group */
+function all(pattern, text, group) {
+  pattern.lastIndex = 0;
+  const found = [];
+  for (const match of text.matchAll(pattern)) if (match[group] !== undefined) found.push(match[group]);
+  return found;
+}
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  /** @type {Set<string>} */
+  const created = new Set();
+  for (const block of codeBlocksOf(doc)) {
+    /** @type {Set<string>} */
+    const blockWrites = new Set();
+    /** @type {Set<string>} */
+    const blockDirs = new Set();
+    for (const [, code] of block.lines) {
+      for (const name2 of all(WRITES, code, 1)) blockWrites.add(fileName(name2));
+      for (const name2 of all(SHELL_WRITES, code, 1)) blockWrites.add(fileName(name2));
+      OPENS.lastIndex = 0;
+      for (const match of code.matchAll(OPENS)) {
+        const mode = match[2] ?? "r";
+        if ([..."wax"].some((flag) => mode.includes(flag))) blockWrites.add(fileName(match[1]));
+      }
+      MAKES_DIR.lastIndex = 0;
+      for (const match of code.matchAll(MAKES_DIR)) blockDirs.add((match[1] ?? match[2]).replace(/\\/g, "/").split("/")[0]);
+    }
+    for (const dir of blockDirs) created.add(dir);
+    for (const [line, code] of block.lines) {
+      OPENS.lastIndex = 0;
+      const reads = [...all(READS, code, 1), ...all(SQL_PATHS, code, 1)];
+      for (const match of code.matchAll(OPENS)) {
+        if (![..."wax"].some((flag) => (match[2] ?? "r").includes(flag))) reads.push(match[1]);
+      }
+      for (const path of reads) {
+        if (!isDataFile(path)) continue;
+        const name2 = fileName(path);
+        if (created.has(name2) || blockWrites.has(name2) || mentionedBefore(doc, name2, block.startLine)) continue;
+        findings.push(finding(name, line, code.trim(), `\`${name2}\` 을 읽는데 글 어디에서도 만들지 않았다. 독자는 여기서 파일 없음 오류로 멈춘다`, null, "error", DOCUMENT, block.index));
+      }
+      for (const path of [...all(WRITES, code, 1), ...reads]) {
+        if (["http", "://", "{", "<", ">", "*", "?"].some((mark) => path.includes(mark))) continue;
+        const directory = directoryOf(path);
+        if (!directory || created.has(directory) || mentionedBefore(doc, directory, block.startLine)) continue;
+        created.add(directory);
+        findings.push(finding(name, line, code.trim(), `\`${directory}\` 폴더를 쓰는데 글 어디에서도 만들지 않았다. 없으면 파일을 쓰다 멈춘다`, null, NOTICE, DOCUMENT, block.index));
+      }
+    }
+    for (const write of blockWrites) created.add(write);
+  }
+  return findings;
+}

package/src/rules/code/installImport.js

@@ -0,0 +1,126 @@
+// @ts-check
+import { loadLines } from "../../data/load.js";
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+import { codeBlocksOf } from "../shared/codeBlocks.js";
+
+export const name = "installImport";
+
+const INSTALL = /(?:pip\s+install|uv\s+add|uv\s+pip\s+install|conda\s+install|poetry\s+add)\s+([^\n#|&;]+)/g;
+const IMPORT = /^\s*(?:import\s+([\w.]+(?:\s*,\s*[\w.]+)*)|from\s+([\w.]+)\s+import\b)/;
+const REQUIREMENT = /^([A-Za-z0-9][A-Za-z0-9._-]*)(?:\[([^\]]*)\])?/;
+const PY_FILE = /\b(\w+)\.py\b/g;
+
+/** @type {Set<string> | null} */
+let stdlibCache = null;
+function stdlib() {
+  if (!stdlibCache) stdlibCache = new Set(loadLines("pythonStdlib.txt"));
+  return stdlibCache;
+}
+
+/** @type {Map<string, 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);
+    }
+  }
+  return packageCache;
+}
+
+/** @type {[RegExp, string, string][] | null} */
+let hiddenCache = null;
+function hiddenDeps() {
+  if (!hiddenCache) {
+    hiddenCache = loadLines("hiddenDeps.txt").map((line) => {
+      const [pattern, requirement, why] = line.split("\t");
+      return /** @type {[RegExp, string, string]} */ ([new RegExp(pattern), requirement, why]);
+    });
+  }
+  return hiddenCache;
+}
+
+/** @param {string} value */
+function normalize(value) {
+  return value.toLowerCase().replace(/_/g, "-");
+}
+
+/** 설치 줄이 말한 패키지 → extras. 설치 줄이 하나도 없으면 null. @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+function installed(doc) {
+  const texts = [...codeBlocksOf(doc).flatMap((b) => b.lines.map(([, line]) => line)), ...doc.sentences.map((s) => s.text)];
+  /** @type {Map<string, Set<string>>} */
+  const packages = new Map();
+  let seen = false;
+  for (const text of texts) {
+    INSTALL.lastIndex = 0;
+    for (const match of text.matchAll(INSTALL)) {
+      seen = true;
+      for (let token of match[1].split(/\s+/)) {
+        token = token.replace(/^["'`]+|["'`]+$/g, "");
+        if (token.startsWith("-") || !token) continue;
+        const requirement = REQUIREMENT.exec(token);
+        if (!requirement) continue;
+        const name2 = normalize(requirement[1]);
+        const extras = new Set((requirement[2] ?? "").split(",").map((e) => normalize(e.trim())).filter(Boolean));
+        const current = packages.get(name2) ?? new Set();
+        for (const extra of extras) current.add(extra);
+        packages.set(name2, current);
+      }
+    }
+  }
+  return seen ? packages : null;
+}
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+function localModules(doc) {
+  const names = new Set();
+  for (const sentence of doc.sentences) {
+    PY_FILE.lastIndex = 0;
+    for (const match of sentence.text.matchAll(PY_FILE)) names.add(match[1]);
+  }
+  for (const block of codeBlocksOf(doc)) {
+    for (const [, line] of block.lines) {
+      PY_FILE.lastIndex = 0;
+      for (const match of line.matchAll(PY_FILE)) names.add(match[1]);
+    }
+  }
+  return names;
+}
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const packages = installed(doc);
+  if (packages === null) return [];
+  const local = localModules(doc);
+  const findings = [];
+  for (const block of codeBlocksOf(doc)) {
+    if (!["python", "py"].includes(block.language)) continue;
+    for (const [line, code] of block.lines) {
+      const match = IMPORT.exec(code);
+      if (match) {
+        const modules = (match[1] ?? match[2]).split(",").map((m) => m.trim());
+        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));
+          }
+        }
+      }
+      for (const [pattern, requirement, why] of hiddenDeps()) {
+        pattern.lastIndex = 0;
+        if (!pattern.test(code)) continue;
+        const parsed = REQUIREMENT.exec(requirement);
+        if (!parsed) continue;
+        const name2 = normalize(parsed[1]);
+        const extra = parsed[2] ? normalize(parsed[2]) : null;
+        if (packages.has(name2) && (extra === null || (packages.get(name2)?.has(extra) ?? false))) continue;
+        findings.push(finding(name, line, code.trim(), `이 줄은 \`${requirement}\` 가 있어야 돈다. ${why}. 설치 줄에 없다`, null, NOTICE, DOCUMENT, block.index));
+      }
+    }
+  }
+  return findings;
+}

package/src/rules/code/platformApi.js

@@ -0,0 +1,36 @@
+// @ts-check
+import { loadLines } from "../../data/load.js";
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+import { codeBlocksOf } from "../shared/codeBlocks.js";
+
+export const name = "platformApi";
+
+/** @type {[RegExp, string, string][] | null} */
+let cache = null;
+function platformApis() {
+  if (!cache) {
+    cache = loadLines("platformApis.txt").map((line) => {
+      const [pattern, platform, alternative] = line.split("\t");
+      return /** @type {[RegExp, string, string]} */ ([new RegExp(pattern), platform, alternative]);
+    });
+  }
+  return cache;
+}
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const block of codeBlocksOf(doc)) {
+    if (block.isOutput) continue;
+    for (const [line, code] of block.lines) {
+      for (const [pattern, platform, alternative] of platformApis()) {
+        pattern.lastIndex = 0;
+        if (pattern.test(code)) {
+          findings.push(finding(name, line, code.trim(), `\`${pattern.source}\` 은 ${platform} 전용이다. 다른 운영체제 독자는 여기서 멈춘다. ${alternative}`, null, NOTICE, DOCUMENT, block.index));
+          break;
+        }
+      }
+    }
+  }
+  return findings;
+}

package/src/rules/document/countMismatch.js

@@ -0,0 +1,42 @@
+// @ts-check
+import { DOCUMENT, finding } from "../finding.js";
+
+export const name = "countMismatch";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc @param {number} line */
+function sectionIndexAt(doc, line) {
+  let index = 0;
+  for (const section of doc.sections) if (section.startLine <= line) index = section.index;
+  return index;
+}
+
+/** 같은 절 안이거나, 도입과 마지막 절 사이일 때만 같은 목록을 센다고 본다. */
+function comparable(doc, lineA, lineB) {
+  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);
+}
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  /** @type {Map<string, [number, number, string][]>} */
+  const byUnit = new Map();
+  for (const [number, unit, line, text] of doc.countPromises) {
+    if (!byUnit.has(unit)) byUnit.set(unit, []);
+    /** @type {[number, number, string][]} */ (byUnit.get(unit)).push([line, number, text]);
+  }
+  for (const promises of byUnit.values()) {
+    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]));
+      if (!conflict) continue;
+      const [lineB, , textB] = conflict;
+      findings.push(finding(name, lineB, textB, `${lineA}번째 줄은 \`${textA}\` 인데 여기는 \`${textB}\` 다. 같은 단위로 다른 수를 약속하면 독자가 어느 쪽을 믿을지 모른다`, null, "error", DOCUMENT, -1));
+      break;
+    }
+  }
+  return findings;
+}

package/src/rules/document/keywordMissing.js

@@ -0,0 +1,21 @@
+// @ts-check
+import { DOCUMENT, finding } from "../finding.js";
+
+export const name = "keywordMissing";
+
+/**
+ * @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();
+  if (!keyword) return [];
+  const title = doc.frontmatter.title ?? "";
+  const first = doc.paragraphs.length ? doc.paragraphs[0] : null;
+  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),
+  ];
+}

package/src/rules/document/noQuestion.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { DOCUMENT, finding } from "../finding.js";
+
+export const name = "noQuestion";
+
+/** @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)];
+}

package/src/rules/document/promiseRecall.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "promiseRecall";
+
+/** @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]) =>
+    finding(name, line, text, "뒤로 미룬 것을 앞에서 미룬 것으로 다시 부르는 자리가 글 어디에도 없다. 회수하거나 미루지 않는다", null, NOTICE, DOCUMENT, -1),
+  );
+}