gyojeong 0.1.0

package/scripts/check.mjs

@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+import { createRequire as __gyojeongRequire } from 'node:module'; const require = __gyojeongRequire(import.meta.url);
+
+// ../../skills/gyojeong/scripts/check.mjs
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+
+// ../../skills/gyojeong/scripts/check-core.mjs
+var EXCERPT_LENGTH = 80;
+var EXIT = { pass: 0, warn: 1, fail: 2, undecidable: 3 };
+var FENCE_RE = /^\s*(`{3,}|~{3,})/;
+var HEADING_RE = /^\s{0,3}#{1,6}\s/;
+function splitBlocks(text) {
+  const blocks = [];
+  let current = [];
+  let fence = null;
+  const flush = () => {
+    if (current.length) {
+      blocks.push({ kind: "prose", text: current.join("\n") });
+      current = [];
+    }
+  };
+  for (const line of text.replace(/\r\n?/g, "\n").split("\n")) {
+    if (fence) {
+      current.push(line);
+      const close = line.trim().match(/^(`{3,}|~{3,})\s*$/);
+      if (close && close[1][0] === fence[0] && close[1].length >= fence.length) {
+        blocks.push({ kind: "code", text: current.join("\n") });
+        current = [];
+        fence = null;
+      }
+      continue;
+    }
+    const open = line.match(FENCE_RE);
+    if (open) {
+      flush();
+      fence = open[1];
+      current.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    if (HEADING_RE.test(line)) {
+      flush();
+      blocks.push({ kind: "heading", text: line });
+      continue;
+    }
+    current.push(line);
+  }
+  if (fence) {
+    blocks.push({ kind: "code", text: current.join("\n") });
+  } else {
+    flush();
+  }
+  return blocks;
+}
+function pairBlocks(sourceBlocks, draftBlocks) {
+  if (sourceBlocks.length !== draftBlocks.length) {
+    return null;
+  }
+  for (let i = 0; i < sourceBlocks.length; i += 1) {
+    if (sourceBlocks[i].kind === "code" !== (draftBlocks[i].kind === "code")) {
+      return null;
+    }
+  }
+  return sourceBlocks.map((block, i) => [block, draftBlocks[i]]);
+}
+var CODE_SPAN_RE = /`[^`\n]+`/g;
+var URL_RE = /\bhttps?:\/\/[^\s<>)\]"'`]+/g;
+var FLAG_RE = /(?<![\w-])--[A-Za-z][\w-]*/g;
+var IDENTIFIER_RE = /(?<![\w.-])[A-Za-z_][\w-]*(?:[._][\w-]+)+(?![\w-])/g;
+var IDENTIFIER_STOPLIST = /* @__PURE__ */ new Set(["e.g", "i.e", "etc", "vs", "a.m", "p.m"]);
+var LINK_TARGET_RE = /\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+function trimUrl(url) {
+  return url.replace(/[.,;:!?]+$/, "");
+}
+function maskCode(text) {
+  return text.replace(CODE_SPAN_RE, " ");
+}
+function stripComments(text) {
+  let out = "";
+  let quote = null;
+  let block = null;
+  for (let i = 0; i < text.length; i += 1) {
+    const rest = text.slice(i);
+    if (block) {
+      if (rest.startsWith(block)) {
+        i += block.length - 1;
+        block = null;
+      }
+      continue;
+    }
+    const char = text[i];
+    if (quote) {
+      out += char;
+      if (char === "\\") {
+        out += text[i + 1] ?? "";
+        i += 1;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      out += char;
+      continue;
+    }
+    if (rest.startsWith("/*")) {
+      block = "*/";
+      continue;
+    }
+    if (rest.startsWith("<!--")) {
+      block = "-->";
+      continue;
+    }
+    if (rest.startsWith("//") || char === "#") {
+      const end = text.indexOf("\n", i);
+      if (end === -1) break;
+      i = end - 1;
+      continue;
+    }
+    out += char;
+  }
+  return out;
+}
+function normalizeCodeBlock(text) {
+  const raw = text.split("\n");
+  const open = raw[0] ?? "";
+  const closes = raw.length > 1 && /^\s*(`{3,}|~{3,})\s*$/.test(raw[raw.length - 1] ?? "");
+  const body = raw.slice(1, closes ? -1 : void 0).join("\n");
+  const lines = [open, ...stripComments(body).split("\n")];
+  const indent = lines[0].match(/^\s*/)[0].length;
+  return lines.map((line) => line.slice(Math.min(indent, line.match(/^\s*/)[0].length))).map((line) => line.replace(/\s+$/, "")).filter((line) => line.trim() !== "").join("\n");
+}
+function identifiers(prose) {
+  const masked = prose.replace(URL_RE, " ").replace(LINK_TARGET_RE, "] ");
+  return [...masked.matchAll(IDENTIFIER_RE)].map((m) => m[0].replace(/[.]+$/, "")).filter((id) => !IDENTIFIER_STOPLIST.has(id.toLowerCase()) && !/^\d/.test(id) && /[._]/.test(id));
+}
+function protectedTokens(blocks) {
+  const tokens = { code_block: [], code: [], url: [], flag: [], identifier: [] };
+  for (const block of blocks) {
+    if (block.kind === "code") {
+      tokens.code_block.push(normalizeCodeBlock(block.text));
+      continue;
+    }
+    tokens.code.push(...block.text.match(CODE_SPAN_RE) ?? []);
+    const prose = maskCode(block.text);
+    tokens.url.push(...(prose.match(URL_RE) ?? []).map(trimUrl));
+    tokens.flag.push(...prose.replace(URL_RE, " ").match(FLAG_RE) ?? []);
+    tokens.identifier.push(...identifiers(prose));
+  }
+  return tokens;
+}
+function multisetMinus(a, b) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of b) counts.set(item, (counts.get(item) ?? 0) + 1);
+  const out = [];
+  for (const item of a) {
+    const n = counts.get(item) ?? 0;
+    if (n > 0) counts.set(item, n - 1);
+    else out.push(item);
+  }
+  return out;
+}
+var bareCount = (prose, text) => (prose.match(new RegExp(`(?<![\\w.$-])${text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w$-])`, "gu")) ?? []).length;
+var TOKEN_LABEL = { code_block: "\uCF54\uB4DC \uBE14\uB85D", code: "\uC778\uB77C\uC778 \uCF54\uB4DC", url: "URL", flag: "CLI \uD50C\uB798\uADF8", identifier: "\uC2DD\uBCC4\uC790" };
+function checkProtectedTokens(sourceBlocks, draftBlocks, add) {
+  const before = protectedTokens(sourceBlocks);
+  const after = protectedTokens(draftBlocks);
+  for (const kind of Object.keys(before)) {
+    const proseOf = (blocks) => maskCode(blocks.filter((block) => block.kind !== "code").map((block) => block.text).join("\n"));
+    const sourceProse = proseOf(sourceBlocks);
+    const draftProse = proseOf(draftBlocks);
+    for (const token of new Set(multisetMinus(before[kind], after[kind]))) {
+      const bare = token.slice(1, -1);
+      const replaced = multisetMinus(after[kind], before[kind]).length > 0;
+      if (kind === "code" && !replaced && bareCount(draftProse, bare) > bareCount(sourceProse, bare)) {
+        add("warn", "protected_token", `\uBC31\uD2F1\uC774 \uBE60\uC9C4 \uC778\uB77C\uC778 \uCF54\uB4DC: ${excerpt(token)}`, { token });
+        continue;
+      }
+      const severity = kind === "flag" ? "warn" : "fail";
+      add(severity, "protected_token", `\uBE60\uC9C0\uAC70\uB098 \uBC14\uB010 ${TOKEN_LABEL[kind]}: ${excerpt(token)}`, { token });
+    }
+    for (const token of new Set(multisetMinus(after[kind], before[kind]))) {
+      const severity = kind === "code_block" || kind === "url" ? "fail" : "warn";
+      add(severity, "protected_token", `\uC6D0\uBB38\uC5D0 \uC5C6\uB294 ${TOKEN_LABEL[kind]}: ${excerpt(token)}`, { token });
+    }
+  }
+}
+var NUM_RE = /\d[\d,]*(?:\.\d+)*/g;
+var LIST_MARKER_RE = /^(\s*)\d+[.)]\s/gm;
+var KOREAN_DATE_RE = /(\d{4})\s*년\s*(\d{1,2})\s*월\s*(\d{1,2})\s*일/g;
+var KOREAN_UNIT_RE = /(\d+(?:\.\d+)?)\s*(억|만|천)/g;
+var KOREAN_UNITS = { \uCC9C: 1e3, \uB9CC: 1e4, \uC5B5: 1e8 };
+var ENGLISH_NUMBER_WORDS = {
+  zero: 0,
+  zeros: 0,
+  zeroes: 0,
+  one: 1,
+  ones: 1,
+  single: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12,
+  thirteen: 13,
+  fourteen: 14,
+  fifteen: 15,
+  sixteen: 16,
+  seventeen: 17,
+  eighteen: 18,
+  nineteen: 19,
+  twenty: 20,
+  thirty: 30,
+  forty: 40,
+  fifty: 50,
+  sixty: 60,
+  seventy: 70,
+  eighty: 80,
+  ninety: 90,
+  hundred: 100,
+  thousand: 1e3,
+  first: 1,
+  second: 2,
+  third: 3,
+  fourth: 4,
+  fifth: 5,
+  sixth: 6,
+  seventh: 7,
+  eighth: 8,
+  ninth: 9,
+  tenth: 10,
+  once: 1,
+  twice: 2,
+  double: 2,
+  triple: 3,
+  both: 2,
+  dozen: 12,
+  half: 50,
+  hex: 16,
+  hexadecimal: 16,
+  octal: 8,
+  binary: 2,
+  decimal: 10,
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12
+};
+var KOREAN_NUMBER_WORDS = { \uD55C: 1, \uD558\uB098: 1, \uB450: 2, \uB458: 2, \uC138: 3, \uC14B: 3, \uB124: 4, \uB137: 4, \uB2E4\uC12F: 5, \uC5EC\uC12F: 6, \uC77C\uACF1: 7, \uC5EC\uB35F: 8, \uC544\uD649: 9, \uC5F4: 10 };
+var KOREAN_NUMERAL = "\uD55C|\uD558\uB098|\uB450|\uB458|\uC138|\uC14B|\uB124|\uB137|\uB2E4\uC12F|\uC5EC\uC12F|\uC77C\uACF1|\uC5EC\uB35F|\uC544\uD649|\uC5F4";
+var KOREAN_COUNTER = "\uAC1C|\uBC88|\uAC00\uC9C0|\uBA85|\uB300|\uC904|\uB2E8\uACC4|\uBC30|\uC2DC\uAC04|\uBD84|\uCD08|\uC77C|\uC8FC|\uB2EC|\uACF3|\uCABD|\uC7A5|\uCE78";
+var KOREAN_COUNTED_RES = [
+  new RegExp(`(?<![\uAC00-\uD7A3])(${KOREAN_NUMERAL})\\s+(?:${KOREAN_COUNTER})`, "g"),
+  new RegExp(`(?<![\uAC00-\uD7A3])(${KOREAN_NUMERAL})(?:${KOREAN_COUNTER})(?![\uAC00-\uD7A3])`, "g")
+];
+function numberProse(blocks) {
+  return blocks.filter((block) => block.kind !== "code").map((block) => {
+    const prose = maskCode(block.text).replace(URL_RE, " ").replace(LINK_TARGET_RE, "] ");
+    return prose.replace(IDENTIFIER_RE, " ").replace(LIST_MARKER_RE, "$1 ");
+  }).join("\n");
+}
+function normalizeNumber(raw) {
+  const plain = raw.replace(/,/g, "");
+  return /^\d+(\.\d+)?$/.test(plain) ? String(Number(plain)) : plain;
+}
+function digitNumbers(prose) {
+  const normalized = prose.replace(KOREAN_DATE_RE, (_, y, m, d) => ` ${y} ${Number(m)} ${Number(d)} `).replace(KOREAN_UNIT_RE, (_, n, unit) => ` ${Number(n) * KOREAN_UNITS[unit]} `);
+  return new Set((normalized.match(NUM_RE) ?? []).map(normalizeNumber));
+}
+function justifiedNumbers(prose, language) {
+  const out = /* @__PURE__ */ new Set();
+  if (language === "en") {
+    for (const m of prose.toLowerCase().matchAll(/\b[a-z]+\b/g)) {
+      if (Object.hasOwn(ENGLISH_NUMBER_WORDS, m[0])) out.add(String(ENGLISH_NUMBER_WORDS[m[0]]));
+    }
+    if (/\bnon-?negative\b|\bzero-based\b/i.test(prose)) out.add("0");
+    if (/\bpositive\b/i.test(prose)) out.add("1");
+    if (/\ban?\s+(?:full\s+|single\s+)?(?:year|month|week|day|hour|minute|second|byte|bit|character|element|item|time)s?\b/i.test(prose)) out.add("1");
+  } else {
+    for (const re of KOREAN_COUNTED_RES) {
+      for (const m of prose.matchAll(re)) out.add(String(KOREAN_NUMBER_WORDS[m[1]]));
+    }
+  }
+  return out;
+}
+function checkNumbers(sourceBlocks, draftBlocks, sourceLanguage, add) {
+  const sourceProse = numberProse(sourceBlocks);
+  const draftProse = numberProse(draftBlocks);
+  const sourceDigits = digitNumbers(sourceProse);
+  const draftDigits = digitNumbers(draftProse);
+  const justified = /* @__PURE__ */ new Set([...sourceDigits, ...justifiedNumbers(sourceProse, sourceLanguage)]);
+  const draftWords = justifiedNumbers(draftProse, "ko");
+  const draftAll = /* @__PURE__ */ new Set([...draftDigits, ...draftWords]);
+  const addedWords = [...draftWords].filter((n) => Number(n) >= 3);
+  for (const n of [...draftDigits, ...addedWords]) {
+    if (!justified.has(n)) add("fail", "number", `\uC6D0\uBB38\uC5D0 \uC5C6\uB294 \uC22B\uC790\uAC00 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4: ${n}`, { token: n });
+  }
+  for (const n of sourceDigits) {
+    if (!draftAll.has(n)) add("warn", "number", `\uC6D0\uBB38\uC758 \uC22B\uC790\uAC00 \uBE60\uC84C\uC2B5\uB2C8\uB2E4: ${n}`, { token: n });
+  }
+}
+var EN_WEAK_PROHIBITION = [/\bavoid(?:s|ing)?\b/i, /\b(?:forbid|forbids|disallow|disallows)\b/i, /\bno\b[^.;!?\n]{1,40}\bshould\b/i, /\bnot\b[^.;!?\n]{1,40}\bonly\b|\bonly\b[^.;!?\n]{1,40}\bnot\b/i, /\bcannot\b|\bcan't\b/i];
+var EN_PERMISSION = /\b(?:may|allowed|permitted|optional|optionally|free to|fine|okay|ok|need not|needn't|not required|no need|(?:do|does)n't need|(?:do|does) not need|(?:do|does)n't have to|(?:do|does) not have to|acceptable)\b/i;
+var EN = {
+  prohibition: [
+    /(?:^|[.!?:]\s+|\n\s*(?:[-*+]|\d+[.)])?\s*|\*\*|>\s*)(?:do not|don't|never|avoid)\b(?!\s+(?:need|have to|require))/i,
+    // "should not", and "should, however, not"
+    /\b(?:must|shall|should)(?:\s+not|n't|,[^,.;!?\n]{1,25},\s+not)\b/i,
+    /\b(?:is|are|isn't|aren't)\s+not\s+(?:allowed|permitted)\b/i,
+    /\b(?:not allowed|not permitted|prohibited|forbidden)\b/i
+  ],
+  obligation: [
+    /\bmust\b(?!\s*not|n't)/i,
+    /\bshall\b(?!\s*not)/i,
+    // "need to" and a bare "required" mostly describe ("elements we need to work with",
+    // "the minimal days required"), so only the directive forms count.
+    /(?<!(?:not|n't|never)\s+)\b(?:have|has)\s+to\b/i,
+    /\b(?:is|are)\s+required\s+to\b/i
+  ]
+};
+var KO = {
+  prohibition: [
+    /지\s*(?:마|말)/,
+    /말아야|말\s*것/,
+    /(?:서는|면|어선|서도)\s*안\s*(?:됩|된|돼|되|될)/,
+    /금지|금합니다|삼가/,
+    /(?:않|없|말)아야|없어야|아니어야/,
+    /않도록\s*(?:하세요|하십시오|하십시요|합니다|한다|해\s*주|하라|주의)/,
+    /않는\s*(?:것이|게)\s*(?:좋|바람직)/,
+    /피해야|피하(?:세요|십시오|십시요|는\s*것이)/,
+    // "허용하지 않는 함수" states a fact; "허용되지 않습니다" is the prohibition.
+    /(?:허용되|허락되)지\s*않/
+  ],
+  // "할 수 없습니다", "못하도록" are normal renderings of "must not" and "not allowed" in reference
+  // docs, and "절대 ~않습니다" states a fact, so these count as keeping a prohibition but not as
+  // adding one ("cannot" is also translated as 수 없다).
+  weakProhibition: [/수\s*없/, /못하(?:도록|게)|못\s*하(?:도록|게)/, /절대[^.!?\n]*(?:않|없|마)/],
+  obligation: [
+    /야(?:만)?\s*(?:하|합|한|해|함|할|했|됩|된|돼|되)/,
+    /반드시|필수|의무/,
+    /(?<![가-힣])꼭\s/,
+    /필요(?:가\s*)?있|필요(?:합니다|하다|해요|함)(?=[.!\s]|$)/
+  ],
+  permission: [/수\s*있/, /(?:해|어|아|여)도\s*(?:됩|된|돼|되|좋|괜찮)/, /가능합|가능하다|허용됩|허용합/],
+  // "~해도 됩니다", "~해도 괜찮습니다": a permission stated outright, unlike the ambiguous 수 있다.
+  explicitPermission: [/도\s*(?:됩니다|된다|돼요|됨|되는|되며|되고|괜찮)/],
+  imperative: [/(?:세요|십시오|하라|해라)(?:[.!\s]|$)/]
+};
+var has = (patterns, text) => patterns.some((re) => re.test(text));
+function modality(text, language) {
+  const prose = maskCode(text).replace(URL_RE, " ").replace(LINK_TARGET_RE, "] ").replace(/\{#[^}]*\}|\{\{[^{}]*\}\}|<[^>\n]+>/g, " ");
+  if (language === "en") {
+    const plain2 = prose.replace(/[_*]+/g, " ");
+    return {
+      permission: EN_PERMISSION.test(plain2),
+      prohibition: has(EN.prohibition, plain2),
+      weakProhibition: has(EN_WEAK_PROHIBITION, plain2),
+      obligation: has(EN.obligation, plain2)
+    };
+  }
+  const plain = prose.replace(/[_*]+/g, "");
+  return {
+    prohibition: has(KO.prohibition, plain),
+    weakProhibition: has(KO.weakProhibition, plain),
+    obligation: has(KO.obligation, plain),
+    permission: has(KO.permission, plain),
+    imperative: has(KO.imperative, plain),
+    explicitPermission: has(KO.explicitPermission, plain)
+  };
+}
+function comparePairModality(source, draft, sourceLanguage, add, where) {
+  const before = modality(source, sourceLanguage);
+  const after = modality(draft, "ko");
+  if (before.prohibition && !after.prohibition && !after.weakProhibition) {
+    if (after.permission) add("fail", "modality", "\uAE08\uC9C0 \uD45C\uD604\uC774 \uC0AC\uB77C\uC84C\uC2B5\uB2C8\uB2E4. \uD5C8\uC6A9 \uD45C\uD604\uC73C\uB85C \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4.", where);
+    else if (after.obligation) add("fail", "modality", "\uAE08\uC9C0 \uD45C\uD604\uC774 \uC0AC\uB77C\uC84C\uC2B5\uB2C8\uB2E4. \uC758\uBB34 \uD45C\uD604\uC73C\uB85C \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4.", where);
+    else add("warn", "modality", "\uAE08\uC9C0 \uD45C\uD604\uC774 \uBCF4\uC774\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uAE08\uC9C0\uC758 \uB73B\uC774 \uB0A8\uC544 \uC788\uB294\uC9C0 \uD655\uC778\uD558\uC138\uC694.", where);
+  }
+  if (before.obligation && !after.obligation && !after.prohibition) {
+    if (after.permission) {
+      add("fail", "modality", "\uC758\uBB34 \uD45C\uD604\uC774 \uD5C8\uC6A9 \uD45C\uD604\uC73C\uB85C \uC57D\uD574\uC84C\uC2B5\uB2C8\uB2E4.", where);
+    } else if (after.imperative) {
+      add("warn", "modality", "\uC758\uBB34 \uD45C\uD604\uC774 \uBA85\uB839\uD615\uC73C\uB85C \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4. \uAC15\uB3C4\uAC00 \uC720\uC9C0\uB410\uB294\uC9C0 \uD655\uC778\uD558\uC138\uC694.", where);
+    } else {
+      add("warn", "modality", "\uC758\uBB34 \uD45C\uD604\uC774 \uBCF4\uC774\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uC758\uBB34\uC758 \uB73B\uC774 \uB0A8\uC544 \uC788\uB294\uC9C0 \uD655\uC778\uD558\uC138\uC694.", where);
+    }
+  }
+  if (sourceLanguage === "en" && after.explicitPermission && !before.permission && (before.prohibition || before.obligation || before.weakProhibition)) {
+    add("fail", "modality", '\uC6D0\uBB38\uC5D0 \uC5C6\uB294 \uD5C8\uC6A9 \uD45C\uD604("~\uD574\uB3C4 \uB429\uB2C8\uB2E4")\uC774 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4.', where);
+  }
+  if (!before.prohibition && !before.weakProhibition && after.prohibition) {
+    add("warn", "modality", "\uC6D0\uBB38\uC5D0 \uC5C6\uB294 \uAE08\uC9C0 \uD45C\uD604\uC774 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4.", where);
+  }
+}
+function checkModality(sourceBlocks, draftBlocks, pairs, sourceLanguage, add) {
+  if (pairs) {
+    pairs.forEach(([source, draft], index) => {
+      if (source.kind === "code") return;
+      comparePairModality(source.text, draft.text, sourceLanguage, add, {
+        block: index + 1,
+        source_excerpt: excerpt(source.text),
+        draft_excerpt: excerpt(draft.text)
+      });
+    });
+    return;
+  }
+  const prose = (blocks) => blocks.filter((b) => b.kind !== "code").map((b) => b.text);
+  const sourceTexts = prose(sourceBlocks);
+  const draftTexts = prose(draftBlocks);
+  const count = (texts, language, key) => texts.filter((t) => {
+    const m = modality(t, language);
+    return key === "prohibition" && language === "ko" ? m.prohibition || m.weakProhibition : m[key];
+  }).length;
+  let anySource = false;
+  for (const key of ["prohibition", "obligation"]) {
+    const s = count(sourceTexts, sourceLanguage, key);
+    const d = count(draftTexts, "ko", key);
+    if (s === 0) continue;
+    anySource = true;
+    if (d === 0) {
+      add("fail", "modality", key === "prohibition" ? "\uC6D0\uBB38\uC758 \uAE08\uC9C0 \uD45C\uD604\uC774 \uACB0\uACFC \uC804\uCCB4\uC5D0\uC11C \uC0AC\uB77C\uC84C\uC2B5\uB2C8\uB2E4." : "\uC6D0\uBB38\uC758 \uC758\uBB34 \uD45C\uD604\uC774 \uACB0\uACFC \uC804\uCCB4\uC5D0\uC11C \uC0AC\uB77C\uC84C\uC2B5\uB2C8\uB2E4.");
+    }
+  }
+  if (anySource) {
+    add("undecidable", "pairing", `\uBB38\uB2E8 \uC9DD\uC744 \uB9DE\uCD94\uC9C0 \uBABB\uD574 \uBB38\uB2E8\uBCC4 \uC758\uBBF8 \uAC15\uB3C4\uB97C \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 (\uC6D0\uBB38 ${sourceBlocks.length}\uAC1C, \uACB0\uACFC ${draftBlocks.length}\uAC1C). \uAE08\uC9C0\xB7\uC758\uBB34 \uBB38\uC7A5\uC744 \uC9C1\uC811 \uD655\uC778\uD558\uC138\uC694.`);
+  }
+}
+function parseStandards(text) {
+  const terms = [];
+  let section = null;
+  for (const raw of text.replace(/\r\n?/g, "\n").split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const header = line.match(/^\[([a-z_]+)\]$/);
+    if (header) {
+      section = header[1];
+      continue;
+    }
+    if (section !== "terms") continue;
+    const [term, target, reason = ""] = line.split("|").map((part) => part.trim());
+    if (term && target) terms.push({ term, target, reason });
+  }
+  return { terms };
+}
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var isLatin = (s) => /^[\x20-\x7e]+$/.test(s);
+function termPattern(term) {
+  const body = escapeRegExp(term);
+  return isLatin(term) ? new RegExp(`(?<![A-Za-z0-9_-])${body}(?:s|es)?(?![A-Za-z0-9_-])`, "i") : new RegExp(body);
+}
+function containsTarget(text, target) {
+  return isLatin(target) ? termPattern(target).test(text) : text.includes(target);
+}
+function checkTerms(sourceBlocks, draftBlocks, pairs, mode, terms, add) {
+  if (!terms.length) return;
+  const prose = (text) => maskCode(text).replace(URL_RE, " ");
+  const units = pairs ? pairs.filter(([s]) => s.kind !== "code").map(([s, d], i) => ({ source: s.text, draft: d.text, block: i + 1 })) : [{ source: sourceBlocks.map((b) => b.text).join("\n"), draft: draftBlocks.map((b) => b.text).join("\n") }];
+  const seen = /* @__PURE__ */ new Set();
+  for (const unit of units) {
+    const source = prose(unit.source);
+    const draft = prose(unit.draft);
+    for (const { term, target, reason } of terms) {
+      const pattern = termPattern(term);
+      let wrong = false;
+      if (mode === "translate") {
+        wrong = pattern.test(source) && !containsTarget(draft, target);
+      } else {
+        wrong = term.toLowerCase() !== target.toLowerCase() && pattern.test(draft) && !containsTarget(draft, target);
+      }
+      const key = `${term}|${unit.block ?? 0}`;
+      if (wrong && !seen.has(key)) {
+        seen.add(key);
+        const why = reason ? ` (${reason})` : "";
+        add("warn", "term", `'${term}'\uC740(\uB294) '${target}'(\uC73C)\uB85C \uC501\uB2C8\uB2E4${why}.`, unit.block ? { block: unit.block, draft_excerpt: excerpt(unit.draft) } : {});
+      }
+    }
+  }
+}
+function excerpt(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > EXCERPT_LENGTH ? `${flat.slice(0, EXCERPT_LENGTH - 1)}\u2026` : flat;
+}
+function detectMode(source) {
+  const hangul = (source.match(/[가-힣]/g) ?? []).length;
+  const latin = (source.match(/[A-Za-z]/g) ?? []).length;
+  return hangul > latin * 0.2 ? "polish" : "translate";
+}
+function check({ source, draft, mode = detectMode(source), standards = { terms: [] } }) {
+  if (mode !== "translate" && mode !== "polish") throw new Error(`unknown mode: ${mode}`);
+  const sourceLanguage = mode === "translate" ? "en" : "ko";
+  const sourceBlocks = splitBlocks(source.normalize("NFC"));
+  const draftBlocks = splitBlocks(draft.normalize("NFC"));
+  const pairs = pairBlocks(sourceBlocks, draftBlocks);
+  const findings = [];
+  const add = (severity, checkName, message, extra = {}) => findings.push({ severity, check: checkName, message, ...extra });
+  const perParagraph = (run) => {
+    if (!pairs) {
+      run(sourceBlocks, draftBlocks, add);
+      return;
+    }
+    pairs.forEach(
+      ([source2, draft2], index) => run(
+        [source2],
+        [draft2],
+        (severity, checkName, message, extra = {}) => add(severity, checkName, message, {
+          block: index + 1,
+          source_excerpt: excerpt(source2.text),
+          draft_excerpt: excerpt(draft2.text),
+          ...extra
+        })
+      )
+    );
+  };
+  perParagraph((source2, draft2, report) => checkProtectedTokens(source2, draft2, report));
+  perParagraph((source2, draft2, report) => checkNumbers(source2, draft2, sourceLanguage, report));
+  checkModality(sourceBlocks, draftBlocks, pairs, sourceLanguage, add);
+  checkTerms(sourceBlocks, draftBlocks, pairs, mode, standards.terms, add);
+  const severities = new Set(findings.map((f) => f.severity));
+  const result = severities.has("fail") ? "fail" : severities.has("undecidable") ? "undecidable" : severities.has("warn") ? "warn" : "pass";
+  return {
+    schema_version: 1,
+    mode,
+    result,
+    exit_code: EXIT[result],
+    pairing: { source_blocks: sourceBlocks.length, draft_blocks: draftBlocks.length, paired: pairs !== null },
+    findings
+  };
+}
+
+// ../../skills/gyojeong/scripts/check.mjs
+var MAX_INPUT_BYTES = 2 * 1024 * 1024;
+var USAGE = "Usage: gyojeong check --source <file> --draft <file> [--mode translate|polish] [--standards <file>] [--json]";
+function readInput(file) {
+  const stat = statSync(file, { throwIfNoEntry: false });
+  if (!stat?.isFile()) throw new Error(`not a file: ${file}`);
+  if (stat.size > MAX_INPUT_BYTES) throw new Error(`file larger than 2 MiB: ${file}`);
+  return readFileSync(file, "utf8");
+}
+function parseArgs(argv) {
+  const options = { json: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") options.json = true;
+    else if (["--source", "--draft", "--mode", "--standards"].includes(arg) && argv[i + 1] !== void 0) options[arg.slice(2)] = argv[++i];
+    else if (arg === "--help" || arg === "-h") options.help = true;
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  return options;
+}
+var SEVERITY_LABEL = { fail: "\uC2E4\uD328", warn: "\uACBD\uACE0", undecidable: "\uD310\uB2E8 \uBD88\uAC00" };
+var RESULT_LABEL = { pass: "\uD1B5\uACFC", warn: "\uACBD\uACE0", fail: "\uC2E4\uD328", undecidable: "\uD310\uB2E8 \uBD88\uAC00" };
+function formatReport(report) {
+  const lines = [`${RESULT_LABEL[report.result]} (${report.mode}, \uC885\uB8CC \uCF54\uB4DC ${report.exit_code})`];
+  for (const f of report.findings) {
+    const where = f.block ? ` [\uBB38\uB2E8 ${f.block}]` : "";
+    lines.push(`- ${SEVERITY_LABEL[f.severity]} ${f.check}${where}: ${f.message}`);
+    if (f.source_excerpt) lines.push(`    \uC6D0\uBB38: ${f.source_excerpt}`);
+    if (f.draft_excerpt) lines.push(`    \uACB0\uACFC: ${f.draft_excerpt}`);
+  }
+  return lines.join("\n");
+}
+function main(argv) {
+  let options;
+  try {
+    options = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`${error.message}
+${USAGE}
+`);
+    return 64;
+  }
+  if (options.help) {
+    process.stdout.write(`${USAGE}
+`);
+    return 0;
+  }
+  if (!options.source || !options.draft) {
+    process.stderr.write(`${USAGE}
+`);
+    return 64;
+  }
+  try {
+    const source = readInput(options.source);
+    const draft = readInput(options.draft);
+    let standardsPath = options.standards;
+    if (!standardsPath && existsSync(path.join(".gyojeong", "standards"))) standardsPath = path.join(".gyojeong", "standards");
+    const standards = standardsPath ? parseStandards(readInput(standardsPath)) : { terms: [] };
+    const report = check({ source, draft, mode: options.mode ?? detectMode(source), standards });
+    process.stdout.write(`${options.json ? JSON.stringify(report) : formatReport(report)}
+`);
+    return report.exit_code;
+  } catch (error) {
+    process.stderr.write(`${error.message}
+`);
+    return 64;
+  }
+}
+process.exitCode = main(process.argv.slice(2));