hanlint 0.0.17 → 0.0.19

package/data/version.json

@@ -1 +1 @@
-{"version": "0.0.17"}
+{"version": "0.0.19"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hanlint",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "한국어 글 검사기. Korean prose linter for Markdown: translationese, noun piles, double passives, weak structure. Zero dependencies",
   "type": "module",
   "bin": {

package/src/analysis/grammar/ending.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/ending.py`와 `predicate.py`의 투영. 종결 서술어를 풀고 세 문체로 짠다. */
+/** 파이썬 `analysis/grammar/ending.py`와 `predicate.py`를 옮긴 것. 종결 서술어를 풀고 세 문체로 짠다. */
 import { loadLines } from "../../data/load.js";
 import * as hangul from "./hangul.js";
 

package/src/analysis/grammar/hangul.js

@@ -1,6 +1,6 @@
 // @ts-check
 /**
- * 한글 음절의 자모 산술. 파이썬 `analysis/grammar/hangul.py` 의 투영이다. 표 대신 산술로 하는 까닭은 그 파일이 소유한다.
+ * 한글 음절의 자모 산술. 파이썬 `analysis/grammar/hangul.py`를 옮긴 것이다. 표 대신 산술로 하는 까닭은 그 파일에 적었다.
  */
 
 export const BASE = 0xac00;
@@ -31,7 +31,7 @@ export const EU = 18;
 export const UI = 19;
 export const IH = 20;
 
-// 종성 자리 번호 가운데 형태 층이 이름으로 부르는 것.
+// 종성 자리 번호 가운데 형태 부분이 이름으로 부르는 것.
 export const NONE = 0;
 export const GIYEOK = 1;
 export const NIEUN = 4;
@@ -44,7 +44,7 @@ export const SSANGSIOT = 20;
 export const IEUNG = 21;
 export const HIEUT = 27;
 
-/** 양성 모음. 이 모음 뒤에는 `아` 가 붙고 나머지에는 `어` 가 붙는다. */
+/** 양성 모음. 이 모음 뒤에는 `아`가 붙고 나머지에는 `어`가 붙는다. */
 export const BRIGHT = new Set([A, OH, YA, YO, WA]);
 
 /** @param {string} ch */
@@ -88,7 +88,7 @@ export function withVowel(ch, vowel) {
   return join(initial, vowel, final);
 }
 
-/** 낱말의 마지막 한글 음절. 없으면 null. @param {string} word */
+/** 단어의 마지막 한글 음절. 없으면 null. @param {string} word */
 export function lastSyllable(word) {
   return word && isSyllable(word[word.length - 1]) ? word[word.length - 1] : null;
 }

package/src/analysis/grammar/josa.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/josa.py`의 투영. 받침에 따라 조사 꼴을 맞춘다. */
+/** 파이썬 `analysis/grammar/josa.py`를 옮긴 것. 받침에 따라 조사 꼴을 맞춘다. */
 import * as hangul from "./hangul.js";
 
 const PAIRS = [

package/src/analysis/grammar/register.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/register.py`의 투영. 글의 문체를 판별하고 문장 끝 서술어를 맞춘다. */
+/** 파이썬 `analysis/grammar/register.py`를 옮긴 것. 글의 문체를 판별하고 문장 끝 서술어를 맞춘다. */
 import * as hangul from "./hangul.js";
 import { HAEYO, HANDA, HAPNIDA, REGISTERS, parsePredicate, render } from "./ending.js";
 

package/src/analysis/grammar/voice.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 `analysis/grammar/voice.py`의 투영. 확정되는 사동과 피동의 겹만 분해한다. */
+/** 파이썬 `analysis/grammar/voice.py`를 옮긴 것. 확정되는 사동과 피동의 겹만 분해한다. */
 import { loadLines } from "../../data/load.js";
 
 export const PASSIVE = "피동";

package/src/analysis/index.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 분석 층. 문장 분리와 어절 판정을 표층 (어절과 꼬리 사전) 으로 한다. 형태소 분석기는 없다. 파이썬 analysis/__init__.py 와 같다.
- * 지문이 필요로 하는 것은 넷이다. splitSentences, euiCount 와 euiAdjacent, longestNounRun, doublePassives.
+ * 분석 부분. 문장 분리와 어절 판정을 글자 모양(어절과 꼬리 사전)만으로 한다. 형태소 분석기는 없다. 파이썬 analysis/__init__.py와 같다.
+ * 글 분석에 필요한 것은 넷이다. splitSentences, euiCount와 euiAdjacent, longestNounRun, doublePassives.
  */
 export { splitSentences } from "./splitSentences.js";
-export { doublePassives, doublePassiveSpans, euiAdjacent, euiCount, longestNounRun } from "./tokenize.js";
+export { doublePassives, doublePassiveSpans, euiAdjacent, euiCount, longestNounRun, nounRuns } from "./tokenize.js";

package/src/analysis/josa.js

@@ -1,2 +1,2 @@
-// 이전 deep path 호환. 정본 투영은 grammar/josa.js다.
+// 이전 deep path 호환. 실제 구현은 grammar/josa.js에 있다.
 export * from "./grammar/josa.js";

package/src/analysis/splitSentences.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 종결 부호 뒤 공백에서 문장을 나눈다. 파이썬 analysis/splitSentences.py 와 같다. */
+/** 종결 부호 뒤 공백에서 문장을 나눈다. 파이썬 analysis/splitSentences.py와 같다. */
 
 const TERMINAL = /[.?!]+\s+(?=\S)/g;
 const ABBREVIATION = /(?:^|[^A-Za-z])[A-Za-z]$/;

package/src/analysis/tokenize.js

@@ -1,6 +1,6 @@
 // @ts-check
 /**
- * 어절 단위 근사. 조사와 어미 꼬리 사전으로 명사 어절을 가려낸다. 파이썬 analysis/tokenize.py 와 같은 판정이다.
+ * 어절 단위 어림. 조사와 어미 꼬리 사전으로 명사 어절을 가려낸다. 파이썬 analysis/tokenize.py와 같은 판정이다.
  * 띄어 쓴 조사와 계사는 앞 어절에 붙은 것으로, 영문 어절 연속은 한 덩어리로, 수사와 바로 뒤 단위는 수량으로 본다.
  */
 import { loadLines } from "../data/load.js";
@@ -9,16 +9,16 @@ import { splitWords, stripChars } from "../text.js";
 const HANGUL = /[가-힣]/;
 const HANGUL_WORD = /^[가-힣]+$/;
 const WORD_CHARS = /^[가-힣A-Za-z0-9]+$/;
-/** 관형격 조사 의. 영문과 숫자 뒤 (API의, 600MiB의) 와 닫는 괄호 뒤 (L7(HTTP)의) 도 센다. 파이썬 tokenize.py 와 같다. */
+/** 관형격 조사 `의`. 영문과 숫자 뒤(`API의`, `600MiB의`)와 닫는 괄호 뒤(`L7(HTTP)의`)도 센다. 파이썬 tokenize.py와 같다. */
 const GENITIVE = /([가-힣A-Za-z0-9]+|\))의(?=[\s,.)\]]|$)/g;
 const SPACED_GENITIVE = /(?<=\s)의(?=\s)/g;
-const COPULA = /^(?:이(?:고|며|다|라|란|면|라서|므로|지만|어서|었다|었고)|인|인데|입니다|였다)$/;
+export const COPULA = /^(?:이(?:고|며|다|라|란|면|라서|므로|지만|어서|었다|었고)|인|인데|입니다|였다)$/;
 const DIGITS = /^\d+$/;
 /** 수에 단위가 붙은 어절 (2012년, 30분쯤, 제16호, 100명). 수량이라 명사 나열에서 세지도 끊지도 않는다. */
 const QUANTITY = /^제?\d[\d,.]*[가-힣]{1,3}$/;
 const OPENERS = "([{\"“‘'";
 const CLOSERS = ",.?!;:)]}\"”’'";
-const EDGE_PUNCTUATION = ".,?!:;\"'“”‘’()[]{}<>";
+export const EDGE_PUNCTUATION = ".,?!:;\"'“”‘’()[]{}<>";
 
 /**
  * @typedef {object} Word
@@ -77,8 +77,8 @@ export function inNouns() {
 }
 
 /**
- * `도구인`, `규모인` 처럼 명사에 계사 관형형 인 이 붙은 어절. 서술어라 명사 나열을 끊는다. 어간이 두 음절 이상일 때만이고
- * 외국인 같은 세 음절 명사는 data/inNouns.txt 가 뺀다. 파이썬 tokenize.py 와 같다.
+ * `도구인`, `규모인`처럼 명사에 계사 관형형 `인`이 붙은 어절. 서술어라 명사 나열을 끊는다. 어간이 두 음절 이상일 때만이고
+ * 외국인 같은 세 음절 명사는 data/inNouns.txt가 뺀다. 파이썬 tokenize.py와 같다.
  * @param {string} core
  */
 export function isCopulaAdnominal(core) {
@@ -126,40 +126,55 @@ export function isBareNoun(core) {
 }
 
 /**
- * 명사 어절 연속의 최대 길이. 의존명사와 관형사와 부사 (`수`, `몇`, `직접`) 는 조사도 어미도 안 붙어
- * 표층으로는 명사로 보이지만 명사 쌓기의 재료가 아니다. data/nonNouns.txt 가 그 목록이고 연속을 끊는다.
+ * 명사 어절 연속의 최대 길이. 의존명사와 관형사와 부사(`수`, `몇`, `직접`)는 조사도 어미도 안 붙어
+ * 글자 모양으로는 명사로 보이지만 명사 쌓기의 재료가 아니다. data/nonNouns.txt가 그 목록이고 연속을 끊는다.
  * @param {string} text
  */
-export function longestNounRun(text) {
-  let longest = 0;
+/**
+ * 명사 어절 연속마다 [어절들, 센 길이]. 뜻은 파이썬 analysis/tokenize.py의 nounRuns가 정한다.
+ * 수사와 단위는 세지도 끊지도 않고 어절에도 안 넣는다. 잇달은 영문 어절은 하나로 센다.
+ * @param {string} text @returns {[string[], number][]}
+ */
+export function nounRuns(text) {
+  /** @type {[string[], number][]} */
+  const runs = [];
+  /** @type {string[]} */
+  let chain = [];
   let run = 0;
   let previousAscii = false;
   let afterNumeral = false;
+  const close = () => {
+    if (run) runs.push([chain, run]);
+    chain = [];
+    run = 0;
+    previousAscii = false;
+  };
   for (const word of words(text)) {
-    if (word.opens) {
-      run = 0;
-      previousAscii = false;
-    }
+    if (word.opens) close();
     const transparent = isNumeral(word.core) || afterNumeral || isQuantity(word.core);
     afterNumeral = isNumeral(word.core);
     if (word.particle || nonNouns().has(word.core) || !isBareNoun(word.core) || isCopulaAdnominal(word.core)) {
-      run = 0;
-      previousAscii = false;
+      close();
     } else if (!transparent) {
       const isAscii = !HANGUL.test(word.core);
       if (!(isAscii && previousAscii)) run += 1;
+      chain.push(word.core);
       previousAscii = isAscii;
-      longest = Math.max(longest, run);
-    }
-    if (word.endsClause) {
-      run = 0;
-      previousAscii = false;
     }
+    if (word.endsClause) close();
   }
+  close();
+  return runs;
+}
+
+/** 명사 어절 연속의 최대 길이. nounRuns의 센 길이 가운데 가장 큰 것. @param {string} text */
+export function longestNounRun(text) {
+  let longest = 0;
+  for (const [, length] of nounRuns(text)) longest = Math.max(longest, length);
   return longest;
 }
 
-/** 관형격 조사 의 가 붙은 자리 [시작, 끝]. 정의, 회의 처럼 의 로 끝나는 낱말은 빼고 띄어 쓴 의 는 넣는다. @param {string} text @returns {[number, number][]} */
+/** 관형격 조사 `의`가 붙은 곳 [시작, 끝]. `정의`, `회의`처럼 `의`로 끝나는 단어는 빼고 띄어 쓴 `의`는 넣는다. @param {string} text @returns {[number, number][]} */
 export function genitiveSpans(text) {
   /** @type {[number, number][]} */
   const spans = [];
@@ -170,13 +185,13 @@ export function genitiveSpans(text) {
   return spans.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
 }
 
-/** 의 로 끝나는 어절 둘이 붙어 있는가 (회사의 팀의). 사이가 공백뿐이어야 한다. @param {string} text */
+/** `의`로 끝나는 어절 둘이 붙어 있는가(`회사의 팀의`). 사이가 공백뿐이어야 한다. @param {string} text */
 export function euiAdjacent(text) {
   const spans = genitiveSpans(text);
   return spans.some((span, index) => index > 0 && /^\s+$/.test(text.slice(spans[index - 1][1], span[0])));
 }
 
-/** 관형격 조사 의 의 수. @param {string} text */
+/** 관형격 조사 `의`의 수. @param {string} text */
 export function euiCount(text) {
   return genitiveSpans(text).length;
 }
@@ -205,7 +220,7 @@ export function doublePassivePattern() {
   return passivePattern;
 }
 
-/** 이중 피동의 [시작, 끝, `되어지` 꼴 표층형]. @param {string} text @returns {[number, number, string][]} */
+/** 이중 피동의 [시작, 끝, `되어지` 꼴로 쓴 글자]. @param {string} text @returns {[number, number, string][]} */
 export function doublePassiveSpans(text) {
   return [...text.matchAll(doublePassivePattern())].map((match) => {
     const start = /** @type {number} */ (match.index);
@@ -213,7 +228,7 @@ export function doublePassiveSpans(text) {
   });
 }
 
-/** 이중 피동의 표층형을 `되어지` 꼴로. @param {string} text */
+/** 이중 피동의 글자를 `되어지` 꼴로. @param {string} text */
 export function doublePassives(text) {
   return doublePassiveSpans(text).map(([, , surface]) => surface);
 }

package/src/baseline/store.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 이미 있는 지적을 잠가 두고 새로 생긴 것만 막는다. 파이썬 `hanlint/baseline/store.py` 의 투영이다.
- * 왜 줄 번호가 아니라 글자인지, 왜 사람이 읽는 꼴인지는 그 파일의 docstring 이 정본이다.
+ * 이미 있는 지적을 baseline 파일에 적어 두고 새로 생긴 지적만 막는다. 파이썬 `hanlint/baseline/store.py`를 옮긴 것이다.
+ * 왜 줄 번호가 아니라 글자인지, 왜 사람이 읽는 형식인지는 그 파일의 docstring에 있다.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, posix, relative, resolve, sep } from "node:path";
@@ -20,7 +20,7 @@ export function keyOf(finding) {
   return `${finding.rule}\u0000${normalizeQuote(finding.quote)}`;
 }
 
-/** 잠금 파일이 있는 폴더 기준의 상대 경로. @param {string} path @param {string | null} target */
+/** baseline 파일이 있는 폴더에서 본 상대 경로. @param {string} path @param {string | null} target */
 export function pathKey(path, target) {
   if (!target || !path || path.startsWith("<")) return path;
   return relative(dirname(resolve(target)), resolve(path)).split(sep).join(posix.sep);
@@ -44,7 +44,7 @@ export class Baseline {
     return (this.locked.get(pathKey(path, this.source)) ?? new Set()).has(keyOf(finding));
   }
 
-  /** 잠기지 않은 지적만 남긴다. @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
+  /** baseline 파일에 없는 지적만 남긴다. @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
   keep(path, findings) {
     return findings.filter((finding) => !this.isLocked(path, finding));
   }
@@ -60,7 +60,7 @@ export function build(results, target = null) {
   return new Baseline(locked, target ? resolve(target) : null);
 }
 
-/** 사람이 읽고 리뷰하는 꼴. 정렬해 담아 같은 입력에 같은 파일이 나온다. @param {Baseline} baseline */
+/** 사람이 읽고 리뷰하는 형식. 정렬해 담아 같은 입력에 같은 파일이 나온다. @param {Baseline} baseline */
 export function render(baseline) {
   /** @type {Record<string, {rule: string, quote: string}[]>} */
   const files = {};
@@ -80,7 +80,7 @@ export function render(baseline) {
 /** @param {string} text @param {string | null} [source] */
 export function parse(text, source = null) {
   const data = JSON.parse(text);
-  if (data.version !== VERSION) throw new Error(`모르는 baseline 판 ${data.version}. hanlint baseline 으로 다시 만든다`);
+  if (data.version !== VERSION) throw new Error(`지원하지 않는 baseline 버전: ${data.version}. hanlint baseline으로 다시 만든다`);
   /** @type {Map<string, Set<string>>} */
   const locked = new Map();
   for (const [path, entries] of Object.entries(data.files ?? {})) {
@@ -92,7 +92,7 @@ export function parse(text, source = null) {
 /** @param {string} path */
 export function load(path) {
   if (!existsSync(path)) {
-    const error = /** @type {NodeJS.ErrnoException} */ (new Error(`${path} 를 찾지 못했다`));
+    const error = /** @type {NodeJS.ErrnoException} */ (new Error(`파일을 찾지 못했다: ${path}`));
     error.code = "ENOENT";
     error.path = path;
     throw error;
@@ -100,7 +100,7 @@ export function load(path) {
   return parse(readFileSync(path, "utf-8"), resolve(path));
 }
 
-/** 지금 글에 더 없는 잠금을 지운다. @param {Baseline} baseline @param {Map<string, import("../rules/finding.js").Finding[]>} results */
+/** 지금 글에 더는 없는 지적을 baseline 파일에서 지운다. @param {Baseline} baseline @param {Map<string, import("../rules/finding.js").Finding[]>} results */
 export function prune(baseline, results) {
   const kept = new Map(baseline.locked);
   for (const [path, findings] of results) {

package/src/cli/help.js

@@ -2,14 +2,14 @@
 /** 첫 화면 다음에 보이는 작업 흐름 중심 도움말. */
 
 export function rootHelp() {
-  return `hanlint: 한국어 마크다운에서 반복되는 결함과 계약 위반을 결정적으로 찾는다
+  return `hanlint: 한국어 글에서 규칙으로 잡을 수 있는 잘못을 찾는다
 
 일상 검사
   hanlint 글.md                         글을 검사한다
   hanlint fix 글.md                     안전한 고침만 적용한다
-  hanlint hook                          AI가 저장한 마크다운을 같은 턴에 검사한다
+  hanlint hook                          AI가 쓰기 전에 글쓰기 지침을 넣어 주고, 저장한 마크다운을 같은 턴에 검사한다
 
-요구사항 잠금
+요구사항 고정
   hanlint contract init 글.md --reader "독자" --goal "목표" --outline h2
   hanlint check contract.json 글.md --format text
   hanlint verify-patch contract.json 글.md patch.json
@@ -17,19 +17,20 @@ export function rootHelp() {
 설정과 이해
   hanlint init                           설정 파일을 만든다
   hanlint doctor                         적용 설정과 꺼진 규칙을 본다
-  hanlint rules                          규칙을 부류별로 본다
-  hanlint explain <규칙>                 규칙의 이유와 본보기를 본다
+  hanlint rules                          규칙을 카테고리별로 본다
+  hanlint explain <규칙>                 규칙의 이유와 예시를 본다
   hanlint patterns --rule <규칙>         다시 쓸 문장 틀을 본다
   hanlint spec --preset <종류> --chars 800
-                                         쓰기 전 숫자 사양을 만든다
-  hanlint primer --preset <종류>         쓰기 전에 규칙의 고치는 법과 본보기를 한 장으로 본다
-  hanlint sheet src/ --preset screen    소스의 화면 글을 표 하나로 떨군다. 고친 표는 sheet apply 로 되돌려 쓴다
+                                         쓰기 전에 볼 스펙을 만든다
+  hanlint primer --preset <종류>         쓰기 전에 규칙의 고치는 법과 예시를 한 장으로 본다
+  hanlint sheet src/ --preset screen    소스의 화면 글을 표 하나로 내보낸다. 고친 표는 sheet apply로 원본에 반영한다
+  hanlint usage "단어 단어"             그 종류의 실제 글에서 단어가 쓰인 문장을 본다. 색인은 usage build가 만든다
 
 추가 명령
   baseline, print
   Python 전용: audit, map, watch, profile, coverage, diff, learn, packet,
   guard, arena, blueprint, evidence, entailment, terms
 
-자세한 옵션은 hanlint <명령> --help 로 본다. 폴더를 주면 그 아래 마크다운을 검사한다.
-종료 코드: 0 error 없음, 1 error 있음, 2 입력이나 설정 문제. 좋은 글인지는 판정하지 않는다.`;
+명령마다의 옵션은 README의 명령 표에 있다. 폴더를 주면 그 아래 마크다운을 검사한다.
+종료 코드: 0은 오류 없음, 1은 오류 있음, 2는 입력이나 설정 문제. 좋은 글인지는 판정하지 않는다.`;
 }