hanlint 0.0.1

package/src/rules/document/readerAbsent.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "readerAbsent";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  if (doc.bodySections.length < 2 || doc.questionCount > 0 || doc.readerCallCount > 0) return [];
+  const first = doc.sentences.length ? doc.sentences[0] : null;
+  return [finding(name, first ? first.line : 1, first ? first.text : "", "질문도 독자를 부르는 문장도 없다. 독자가 할 행동을 동사로 끝내는 문장을 한 번은 넣는다", null, NOTICE, DOCUMENT, -1)];
+}

package/src/rules/finding.js

@@ -0,0 +1,53 @@
+// @ts-check
+/** 지적 하나의 모양. 파이썬 rules/finding.py 와 같은 필드와 같은 JSON 순서다. */
+
+export const ERROR = "error";
+export const NOTICE = "notice";
+
+export const SENTENCE = "sentence";
+export const PARAGRAPH = "paragraph";
+export const SECTION = "section";
+export const DOCUMENT = "document";
+
+/**
+ * @typedef {object} Finding
+ * @property {string} rule
+ * @property {number} line
+ * @property {string} quote
+ * @property {string} why
+ * @property {string | null} fix 기계가 낼 수 있을 때만
+ * @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 {string | null} replacement
+ */
+
+/**
+ * @param {string} rule
+ * @param {number} line
+ * @param {string} quote
+ * @param {string} why
+ * @param {string | null} [fix]
+ * @param {string} [severity]
+ * @param {string} [scope]
+ * @param {number} [at]
+ * @param {string | null} [fragment]
+ * @param {string | null} [replacement]
+ * @returns {Finding}
+ */
+export function finding(rule, line, quote, why, fix = null, severity = ERROR, scope = SENTENCE, at = -1, fragment = null, replacement = null) {
+  return { rule, line, quote, why, fix, severity, scope, at, fragment, replacement };
+}
+
+/** @param {Finding} f */
+export function findingAsDict(f) {
+  /** @type {Record<string, unknown>} */
+  const data = { rule: f.rule, line: f.line, severity: f.severity, scope: f.scope, at: f.at, quote: f.quote, why: f.why };
+  if (f.fix) data.fix = f.fix;
+  if (f.replacement !== null) {
+    data.fragment = f.fragment;
+    data.replacement = f.replacement;
+  }
+  return data;
+}

package/src/rules/orthography/confusable.js

@@ -0,0 +1,9 @@
+// @ts-check
+import { dictionaryFindings } from "../shared/dictionaryRule.js";
+
+export const name = "confusable";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return dictionaryFindings(doc, "confusable", name);
+}

package/src/rules/orthography/spacing.js

@@ -0,0 +1,9 @@
+// @ts-check
+import { dictionaryFindings } from "../shared/dictionaryRule.js";
+
+export const name = "spacing";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return dictionaryFindings(doc, "spacing", name);
+}

package/src/rules/orthography/spelling.js

@@ -0,0 +1,9 @@
+// @ts-check
+import { dictionaryFindings } from "../shared/dictionaryRule.js";
+
+export const name = "spelling";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return dictionaryFindings(doc, "spelling", name);
+}

package/src/rules/paragraph/factListParagraph.js

@@ -0,0 +1,27 @@
+// @ts-check
+import { NOTICE, PARAGRAPH, finding } from "../finding.js";
+
+export const name = "factListParagraph";
+
+/** 문장 사이를 잇는 표지가 하나라도 있는가. @param {import("../../fingerprint/build.js").ParagraphPrint} paragraph */
+function isLinked(paragraph) {
+  if (paragraph.causalTotal > 0) return true;
+  return paragraph.sentences.some((s) => s.connectorStart || s.mood === "의문" || s.readerCall);
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  for (const paragraph of doc.paragraphs) {
+    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),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/paragraph/paraFragment.js

@@ -0,0 +1,29 @@
+// @ts-check
+import { PARAGRAPH, finding } from "../finding.js";
+
+export const name = "paraFragment";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  for (const section of doc.sections) {
+    /** @type {import("../../fingerprint/build.js").ParagraphPrint[]} */
+    let run = [];
+    for (const paragraph of section.paragraphs) {
+      const short = paragraph.sentenceCount <= 2;
+      if (short && (!run.length || paragraph.followsProseDirectly)) run.push(paragraph);
+      else if (short) run = [paragraph];
+      else run = [];
+      if (run.length === config.fragmentRun) {
+        const first = run[0];
+        findings.push(
+          finding(name, first.startLine, first.sentences.length ? first.sentences[0].text : "", `${run.length}개 문단이 연달아 한두 문장씩이다. 화제가 같으면 한 문단으로 묶는다. 줄바꿈은 화제가 바뀌는 자리에만`, null, "error", PARAGRAPH, first.index),
+        );
+      }
+    }
+  }
+  return findings;
+}

package/src/rules/paragraph/topicBreak.js

@@ -0,0 +1,25 @@
+// @ts-check
+import { NOTICE, PARAGRAPH, finding } from "../finding.js";
+
+export const name = "topicBreak";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  for (const section of doc.sections) {
+    const paragraphs = section.paragraphs;
+    for (let i = 0; i + 1 < paragraphs.length; i++) {
+      const previous = paragraphs[i];
+      const paragraph = paragraphs[i + 1];
+      if (paragraph.overlapWithPrevious !== 0) continue;
+      if (Math.min(previous.sentenceCount, paragraph.sentenceCount) < config.topicBreakMinSentences) continue;
+      findings.push(
+        finding(name, paragraph.startLine, paragraph.sentences[0].text, "앞 문단과 화제어가 하나도 겹치지 않는다. 앞에서 만든 것의 이름을 첫 문장에서 다시 부른다", null, NOTICE, PARAGRAPH, paragraph.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/registry.js

@@ -0,0 +1,147 @@
+// @ts-check
+/**
+ * 규칙 등록부. 규칙 하나는 파일 하나이고 `name` 과 `run(doc, config)` 을 내보낸다. 파이썬은 폴더를 걸어 찾고
+ * 여기는 목록으로 든다. test/rules.test.js 가 목록과 폴더와 ruleDocs.json 이 같은지 본다.
+ * 기술서 (왜, 어디서, 고치기, 안 잡는 것) 는 파이썬 docstring 의 투영 data/ruleDocs.json 에서 읽는다.
+ */
+import { enabled } from "../config/settings.js";
+import { loadRuleDocs } from "../data/load.js";
+import * as countMismatch from "./document/countMismatch.js";
+import * as keywordMissing from "./document/keywordMissing.js";
+import * as noQuestion from "./document/noQuestion.js";
+import * as promiseRecall from "./document/promiseRecall.js";
+import * as readerAbsent from "./document/readerAbsent.js";
+import * as duplicateBlock from "./code/duplicateBlock.js";
+import * as firstResultDistance from "./code/firstResultDistance.js";
+import * as inputFileSource from "./code/inputFileSource.js";
+import * as installImport from "./code/installImport.js";
+import * as platformApi from "./code/platformApi.js";
+import * as confusable from "./orthography/confusable.js";
+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 topicBreak from "./paragraph/topicBreak.js";
+import * as cliche from "./sentence/cliche.js";
+import * as hardWord from "./sentence/hardWord.js";
+import * as connectorRepeat from "./sentence/connectorRepeat.js";
+import * as danglingDeixis from "./sentence/danglingDeixis.js";
+import * as dash from "./sentence/dash.js";
+import * as deixis from "./sentence/deixis.js";
+import * as doubleNegative from "./sentence/doubleNegative.js";
+import * as doublePassive from "./sentence/doublePassive.js";
+import * as ellipsis from "./sentence/ellipsis.js";
+import * as endingRepeat from "./sentence/endingRepeat.js";
+import * as euiChain from "./sentence/euiChain.js";
+import * as fillerOpener from "./sentence/fillerOpener.js";
+import * as imperativePeriod from "./sentence/imperativePeriod.js";
+import * as japaneseLoan from "./sentence/japaneseLoan.js";
+import * as longSentence from "./sentence/longSentence.js";
+import * as negationRedefine from "./sentence/negationRedefine.js";
+import * as nounPile from "./sentence/nounPile.js";
+import * as redundantPair from "./sentence/redundantPair.js";
+import * as translationese from "./sentence/translationese.js";
+import * as emojiBullet from "./structure/emojiBullet.js";
+import * as headingSentence from "./structure/headingSentence.js";
+import * as headingSkip from "./structure/headingSkip.js";
+import * as headingUniform from "./structure/headingUniform.js";
+import * as introLong from "./structure/introLong.js";
+import * as sectionNoProse from "./structure/sectionNoProse.js";
+import * as sectionResult from "./structure/sectionResult.js";
+
+/**
+ * @typedef {object} Rule
+ * @property {string} name
+ * @property {(doc: import("../fingerprint/build.js").DocumentPrint, config: import("../config/settings.js").Config) => import("./finding.js").Finding[]} run
+ */
+
+/** @type {Rule[]} */
+export const RULES = [
+  cliche,
+  connectorRepeat,
+  danglingDeixis,
+  dash,
+  deixis,
+  doubleNegative,
+  doublePassive,
+  ellipsis,
+  endingRepeat,
+  euiChain,
+  fillerOpener,
+  hardWord,
+  imperativePeriod,
+  japaneseLoan,
+  longSentence,
+  negationRedefine,
+  nounPile,
+  redundantPair,
+  translationese,
+  factListParagraph,
+  paraFragment,
+  topicBreak,
+  emojiBullet,
+  headingSentence,
+  headingSkip,
+  headingUniform,
+  introLong,
+  sectionNoProse,
+  sectionResult,
+  countMismatch,
+  keywordMissing,
+  noQuestion,
+  promiseRecall,
+  readerAbsent,
+  spelling,
+  spacing,
+  confusable,
+  inputFileSource,
+  installImport,
+  duplicateBlock,
+  firstResultDistance,
+  platformApi,
+];
+
+const BY_NAME = new Map(RULES.map((rule) => [rule.name, rule]));
+
+/** 이름 순. */
+export function ruleNames() {
+  return [...BY_NAME.keys()].sort();
+}
+
+/** @param {string} name */
+export function ruleDoc(name) {
+  const docs = loadRuleDocs();
+  if (!(name in docs) || !BY_NAME.has(name)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  return docs[name];
+}
+
+/** @param {string} name */
+export function ruleSummary(name) {
+  return ruleDoc(name).split("\n")[0];
+}
+
+/**
+ * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*` 는 전부다.
+ * @param {import("./finding.js").Finding} f
+ * @param {[string, number, number][]} disabled
+ */
+export function isDisabledAt(f, disabled) {
+  return disabled.some(([name, start, end]) => (name === "*" || name === f.rule) && start <= f.line && f.line <= end);
+}
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../config/settings.js").Config} config
+ * @returns {import("./finding.js").Finding[]}
+ */
+export function runAll(doc, config) {
+  /** @type {import("./finding.js").Finding[]} */
+  const findings = [];
+  for (const name of ruleNames()) {
+    if (!enabled(config, name)) continue;
+    const rule = /** @type {Rule} */ (BY_NAME.get(name));
+    for (const f of rule.run(doc, config)) if (!isDisabledAt(f, doc.disabled)) findings.push(f);
+  }
+  findings.sort((a, b) => a.line - b.line || (a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : 0));
+  return findings;
+}

package/src/rules/sentence/cliche.js

@@ -0,0 +1,9 @@
+// @ts-check
+import { dictionaryFindings } from "../shared/dictionaryRule.js";
+
+export const name = "cliche";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return dictionaryFindings(doc, "cliches", name);
+}

package/src/rules/sentence/connectorRepeat.js

@@ -0,0 +1,23 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "connectorRepeat";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const paragraph of doc.paragraphs) {
+    /** @type {string | null} */
+    let previous = null;
+    for (const sentence of paragraph.sentences) {
+      const current = sentence.connectorStart;
+      if (current && current === previous) {
+        findings.push(
+          finding(name, sentence.line, sentence.text, `\`${current}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
+        );
+      }
+      previous = current;
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/danglingDeixis.js

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

package/src/rules/sentence/dash.js

@@ -0,0 +1,21 @@
+// @ts-check
+import { DOCUMENT, finding } from "../finding.js";
+
+export const name = "dash";
+// 리터럴로 쓰면 이 파일이 자기 게이트에 걸린다. 코드포인트로 만든다.
+const DASHES = new RegExp(`[${String.fromCharCode(0x2013)}${String.fromCharCode(0x2014)}]`);
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const block of doc.blocks) {
+    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),
+        );
+      }
+    });
+  }
+  return findings;
+}

package/src/rules/sentence/deixis.js

@@ -0,0 +1,19 @@
+// @ts-check
+import { overlap } from "../../fingerprint/topics.js";
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "deixis";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    if (!sentence.deixis.length || sentence.index === 0) continue;
+    const previous = doc.sentences[sentence.index - 1];
+    if (overlap(previous.topics, sentence.topics) === 0) continue;
+    findings.push(
+      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` 은 독자가 스크롤을 되돌려야 하는 지시어다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
+    );
+  }
+  return findings;
+}

package/src/rules/sentence/doubleNegative.js

@@ -0,0 +1,28 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "doubleNegative";
+const DOUBLE_NEGATIVE = /(하지 않으면 안 (?:된다|됩니다)|하지 않을 수 없(?:다|습니다)|지 않으면 안 (?:된다|됩니다)|지 않을 수 없(?:다|습니다))/;
+/** @type {Record<string, string>} */
+const FIXES = {
+  "하지 않으면 안 된다": "해야 한다",
+  "하지 않으면 안 됩니다": "해야 합니다",
+  "하지 않을 수 없다": "한다",
+  "하지 않을 수 없습니다": "합니다",
+};
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const match = DOUBLE_NEGATIVE.exec(sentence.text);
+    if (!match) continue;
+    const replacement = FIXES[match[1]];
+    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),
+    );
+  }
+  return findings;
+}

package/src/rules/sentence/doublePassive.js

@@ -0,0 +1,17 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "doublePassive";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    if (sentence.passives.length) {
+      findings.push(
+        finding(name, sentence.line, sentence.text, `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`, null, "error", SENTENCE, sentence.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/ellipsis.js

@@ -0,0 +1,17 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "ellipsis";
+// 괄호 안의 점 셋 (`OVER (...)`) 은 인라인 코드의 생략 표기라 뺀다.
+const ELLIPSIS = /(?<![(\[])(…|\.{3,})(?![)\]])/;
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    if (ELLIPSIS.test(sentence.text)) {
+      findings.push(finding(name, sentence.line, sentence.text, "말줄임표로 말끝을 흐리면 독자가 결론을 받아 가지 못한다. 문장을 끝까지 쓴다", null, "error", SENTENCE, sentence.index));
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/endingRepeat.js

@@ -0,0 +1,25 @@
+// @ts-check
+import { NOTICE, SENTENCE, finding } from "../finding.js";
+import { runsOf } from "../shared/runs.js";
+
+export const name = "endingRepeat";
+const COUNTED_ENDINGS = new Set(["니다", "다", "것이다", "요", "죠"]);
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  for (const section of doc.sections) {
+    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)) {
+      const first = sentences[start];
+      findings.push(
+        finding(name, first.line, first.text, `\`${ending}\` 로 끝나는 문장이 ${length}개 이어진다. 질문, 인과, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/euiChain.js

@@ -0,0 +1,18 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "euiChain";
+const ADJACENT = /[가-힣]+의\s+[가-힣]+의(?=[\s,.)\]]|$)/;
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    if (sentence.euiCount >= 3 || (sentence.euiCount >= 2 && ADJACENT.test(sentence.text))) {
+      findings.push(
+        finding(name, sentence.line, sentence.text, `한 문장에 \`의\` 가 ${sentence.euiCount}번이다. 명사를 쌓은 자리라 관계가 표시되지 않는다. 동사로 편다`, null, "error", SENTENCE, sentence.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/fillerOpener.js

@@ -0,0 +1,18 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "fillerOpener";
+const FILLER = /^(다음으로|이어서|마지막에는|마지막으로)(?=[\s,])/;
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const match = FILLER.exec(sentence.text);
+    if (!match) continue;
+    findings.push(
+      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 만 붙여 잇는 문장이다. 앞에서 만든 파일이나 값을 이름으로 다시 부르고 다음 행동을 붙인다`, null, "error", SENTENCE, sentence.index),
+    );
+  }
+  return findings;
+}

package/src/rules/sentence/hardWord.js

@@ -0,0 +1,10 @@
+// @ts-check
+import { NOTICE } from "../finding.js";
+import { dictionaryFindings } from "../shared/dictionaryRule.js";
+
+export const name = "hardWord";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return dictionaryFindings(doc, "easyWords", name, NOTICE);
+}

package/src/rules/sentence/imperativePeriod.js

@@ -0,0 +1,20 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "imperativePeriod";
+const IMPERATIVE_PERIOD = /(세요|십시오|합시다|봅시다|하자|해라)\.(?=\s|$)/;
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const match = IMPERATIVE_PERIOD.exec(sentence.text);
+    if (!match) continue;
+    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]),
+    );
+  }
+  return findings;
+}

package/src/rules/sentence/japaneseLoan.js

@@ -0,0 +1,9 @@
+// @ts-check
+import { dictionaryFindings } from "../shared/dictionaryRule.js";
+
+export const name = "japaneseLoan";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return dictionaryFindings(doc, "japaneseLoan", name);
+}

package/src/rules/sentence/longSentence.js

@@ -0,0 +1,20 @@
+// @ts-check
+import { NOTICE, SENTENCE, finding } from "../finding.js";
+
+export const name = "longSentence";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const findings = [];
+  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),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/negationRedefine.js

@@ -0,0 +1,22 @@
+// @ts-check
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "negationRedefine";
+const NEGATION = /단순(?:한|히)\s?.{0,15}?(?:이|가)\s?아(?:닙니다|니다|니에요|니죠|닌)/;
+const COPULA = /(입니다|이다|이에요|예요)[.!]?$/;
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  const findings = [];
+  for (const paragraph of doc.paragraphs) {
+    const sentences = paragraph.sentences;
+    for (let i = 0; i + 1 < sentences.length; i++) {
+      const current = sentences[i];
+      const following = sentences[i + 1];
+      if (NEGATION.test(current.text) && COPULA.test(following.text.trim())) {
+        findings.push(finding(name, current.line, current.text, "단순한 X 가 아닙니다 뒤에 Y 입니다 로 재정의하는 공식이다. 앞 문장을 지우고 Y 를 바로 쓴다", null, "error", SENTENCE, current.index));
+      }
+    }
+  }
+  return findings;
+}