@nomadamas/k-skill 0.1.0

package/skills/korean-slang-writing/scripts/slang_lookup.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from html import unescape
+from typing import Any
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _slang_http import (  # noqa: E402
+    BlockedError,
+    NotFoundError,
+    UpstreamError,
+    build_namuwiki_url,
+    fetch_html,
+)
+
+
+DEFAULT_TIMEOUT = 15
+DEFAULT_MAX_LENGTH = 1500
+
+TAG_RE = re.compile(r"<[^>]+>")
+SCRIPT_STYLE_RE = re.compile(
+    r"<(script|style|noscript)[^>]*>.*?</\1>", re.DOTALL | re.IGNORECASE
+)
+TITLE_RE = re.compile(r"<title[^>]*>(.*?)</title>", re.DOTALL | re.IGNORECASE)
+NAMUWIKI_TITLE_SUFFIX_RE = re.compile(r"\s*[-|]?\s*나무위키\s*$")
+BLOCK_END_RE = re.compile(r"</(p|div|li|h[1-6])>", re.IGNORECASE)
+BR_RE = re.compile(r"<br\s*/?>", re.IGNORECASE)
+WHITESPACE_RE = re.compile(r"[ \t]+")
+BLANK_LINES_RE = re.compile(r"\n{3,}")
+H2_TAG_RE = re.compile(r"<h2\b[^>]*>.*?</h2>", re.DOTALL | re.IGNORECASE)
+NUMBERED_H2_INNER_TEXT_RE = re.compile(r"^\s*\d+(?:\.\d+)*\.\s+\S")
+SECTION_NUMBER_PREFIX_RE = re.compile(r"^\s*\d+(?:\.\d+)*\.\s+", re.MULTILINE)
+EDIT_AFFORDANCE_RE = re.compile(r"\[\s*편집\s*\]")
+CATEGORY_NAV_RE = re.compile(r"\[\s*펼치기\s*[·・•]\s*접기\s*\][^\n]*")
+DETAILS_PELCHIGI_RE = re.compile(
+    r"<details\b[^>]*>"
+    r"\s*<summary\b[^>]*>[^<]*펼치기[^<]*</summary>"
+    r".*?"
+    r"</details>",
+    re.DOTALL | re.IGNORECASE,
+)
+OG_DESCRIPTION_RE = re.compile(
+    r'<meta\s+[^>]*property\s*=\s*"og:description"\s+[^>]*content\s*=\s*"([^"]*)"',
+    re.IGNORECASE,
+)
+OG_DESCRIPTION_REVERSED_RE = re.compile(
+    r'<meta\s+[^>]*content\s*=\s*"([^"]*)"\s+[^>]*property\s*=\s*"og:description"',
+    re.IGNORECASE,
+)
+
+MAIN_CONTENT_CLASSES = (
+    "wiki-paragraph",
+    "wiki-content",
+    "namu-wiki-content",
+    "article-content",
+    "wiki-body",
+    "wiki-heading-content",
+)
+
+
+def fetch_page(url: str, timeout: int) -> str:
+    return fetch_html(url, timeout=timeout)
+
+
+def extract_title(html: str) -> str:
+    match = TITLE_RE.search(html)
+    if not match:
+        return ""
+    title = unescape(TAG_RE.sub("", match.group(1))).strip()
+    title = NAMUWIKI_TITLE_SUFFIX_RE.sub("", title).strip()
+    return title
+
+
+def _find_main_content(cleaned_html: str) -> str:
+    for class_name in MAIN_CONTENT_CLASSES:
+        pattern = re.compile(
+            rf'<[a-zA-Z]+[^>]*class="[^"]*\b{re.escape(class_name)}\b[^"]*"[^>]*>',
+            re.IGNORECASE,
+        )
+        match = pattern.search(cleaned_html)
+        if match:
+            return cleaned_html[match.start():]
+
+    article_match = re.search(r"<article[^>]*>", cleaned_html, re.IGNORECASE)
+    if article_match:
+        return cleaned_html[article_match.start():]
+
+    return ""
+
+
+def _h2_inner_text(h2_tag_html: str) -> str:
+    opening_end = h2_tag_html.index(">") + 1
+    closing_start = h2_tag_html.rindex("<")
+    inner = h2_tag_html[opening_end:closing_start]
+    return unescape(TAG_RE.sub("", inner)).strip()
+
+
+def _is_numbered_section_h2(h2_tag_html: str) -> bool:
+    return bool(NUMBERED_H2_INNER_TEXT_RE.match(_h2_inner_text(h2_tag_html)))
+
+
+def _extract_first_section_between_h2(cleaned_html: str) -> str:
+    all_matches = list(H2_TAG_RE.finditer(cleaned_html))
+    numbered = [m for m in all_matches if _is_numbered_section_h2(m.group(0))]
+    if not numbered:
+        return ""
+    start = numbered[0].end()
+    end = numbered[1].start() if len(numbered) > 1 else len(cleaned_html)
+    return cleaned_html[start:end]
+
+
+def _extract_og_description(html: str) -> str:
+    match = OG_DESCRIPTION_RE.search(html) or OG_DESCRIPTION_REVERSED_RE.search(html)
+    if not match:
+        return ""
+    return unescape(match.group(1)).strip()
+
+
+def _html_fragment_to_text(fragment: str) -> str:
+    text = BR_RE.sub("\n", fragment)
+    text = BLOCK_END_RE.sub("\n", text)
+    text = TAG_RE.sub("", text)
+    text = unescape(text)
+    text = EDIT_AFFORDANCE_RE.sub("", text)
+    text = CATEGORY_NAV_RE.sub("", text)
+    text = SECTION_NUMBER_PREFIX_RE.sub("", text)
+    lines: list[str] = []
+    for line in text.split("\n"):
+        stripped = WHITESPACE_RE.sub(" ", line).strip()
+        if stripped:
+            lines.append(stripped)
+    joined = "\n".join(lines)
+    return BLANK_LINES_RE.sub("\n\n", joined).strip()
+
+
+def _truncate(text: str, max_length: int) -> str:
+    if max_length > 0 and len(text) > max_length:
+        return text[:max_length] + "..."
+    return text
+
+
+def extract_summary(html: str, *, max_length: int = DEFAULT_MAX_LENGTH) -> str:
+    cleaned = SCRIPT_STYLE_RE.sub("", html)
+    cleaned = DETAILS_PELCHIGI_RE.sub("", cleaned)
+
+    h2_section = _extract_first_section_between_h2(cleaned)
+    if h2_section:
+        text = _html_fragment_to_text(h2_section)
+        if text:
+            return _truncate(text, max_length)
+
+    region = _find_main_content(cleaned)
+    if region:
+        text = _html_fragment_to_text(region)
+        if text:
+            return _truncate(text, max_length)
+
+    og_description = _extract_og_description(html)
+    if og_description:
+        return _truncate(og_description, max_length)
+
+    return ""
+
+
+def _is_url(value: str) -> bool:
+    return value.startswith("http://") or value.startswith("https://")
+
+
+def lookup(
+    term_or_url: str,
+    *,
+    timeout: int = DEFAULT_TIMEOUT,
+    max_length: int = DEFAULT_MAX_LENGTH,
+) -> dict[str, Any]:
+    input_value = term_or_url.strip()
+    if not input_value:
+        raise ValueError("term_or_url is empty")
+
+    url = build_namuwiki_url(input_value)
+    result: dict[str, Any] = {
+        "input": term_or_url,
+        "url": url,
+        "fetched": False,
+        "title": "",
+        "summary": "",
+        "error": None,
+        "block_reason": None,
+    }
+
+    try:
+        html = fetch_page(url, timeout=timeout)
+    except BlockedError as error:
+        result["error"] = str(error)
+        result["block_reason"] = "blocked"
+        return result
+    except NotFoundError as error:
+        result["error"] = str(error)
+        result["block_reason"] = "not_found"
+        return result
+    except UpstreamError as error:
+        result["error"] = str(error)
+        result["block_reason"] = "upstream_error"
+        return result
+
+    result["fetched"] = True
+    result["title"] = extract_title(html)
+    result["summary"] = extract_summary(html, max_length=max_length)
+    if not result["summary"]:
+        result["warning"] = (
+            "Main content region not detected. Namu Wiki HTML layout may have changed; "
+            "treat this as a hint and verify meaning from seed index or other sources."
+        )
+    return result
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Fetch a Namu Wiki page for a trending slang term and return a best-effort "
+            "summary. Gracefully reports when the upstream blocks the request."
+        )
+    )
+    parser.add_argument(
+        "term_or_url",
+        help="Slang term (e.g. '중꺾마') or full Namu Wiki URL.",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=DEFAULT_TIMEOUT,
+        help=f"HTTP timeout in seconds. Default: {DEFAULT_TIMEOUT}.",
+    )
+    parser.add_argument(
+        "--max-length",
+        type=int,
+        default=DEFAULT_MAX_LENGTH,
+        help=f"Summary truncation length (0 = unlimited). Default: {DEFAULT_MAX_LENGTH}.",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["json", "text"],
+        default="json",
+        help="Output format.",
+    )
+    return parser.parse_args(argv)
+
+
+def _format_text(result: dict) -> str:
+    lines: list[str] = []
+    lines.append(f"URL: {result['url']}")
+    if result["fetched"]:
+        lines.append(f"Title: {result['title']}")
+        lines.append("")
+        lines.append(result["summary"] or "(summary not extracted)")
+    else:
+        lines.append("Fetch failed.")
+        lines.append(f"Reason: {result.get('block_reason')}")
+        lines.append(f"Detail: {result.get('error')}")
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv if argv is not None else sys.argv[1:])
+
+    try:
+        result = lookup(
+            args.term_or_url,
+            timeout=args.timeout,
+            max_length=args.max_length,
+        )
+    except ValueError as error:
+        print(
+            json.dumps({"error": str(error)}, ensure_ascii=False),
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.format == "json":
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        sys.stdout.write(_format_text(result))
+    return 0 if result["fetched"] else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/korean-slang-writing/scripts/slang_search.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pathlib
+import sys
+from typing import Any, Iterable
+
+
+DEFAULT_LIMIT = 10
+MAX_LIMIT = 50
+
+SCRIPT_DIR = pathlib.Path(__file__).resolve().parent
+SKILL_ROOT = SCRIPT_DIR.parent
+DEFAULT_INDEX_PATH = SKILL_ROOT / "data" / "seed-slang.json"
+
+MATCH_REASON_ORDER = {
+    "exact": 0,
+    "alias": 1,
+    "substring": 2,
+    "no-query": 3,
+}
+
+
+def load_index(path: str | None = None) -> dict:
+    target = pathlib.Path(path) if path else DEFAULT_INDEX_PATH
+    if not target.exists():
+        raise FileNotFoundError(f"slang index not found at: {target}")
+    with target.open(encoding="utf-8") as fh:
+        data = json.load(fh)
+    if not isinstance(data, dict) or "entries" not in data:
+        raise ValueError(f"invalid slang index (missing 'entries'): {target}")
+    return data
+
+
+def _normalize(text: str) -> str:
+    return " ".join(text.lower().split())
+
+
+def _collect_match(entry: dict, query_norm: str) -> str | None:
+    term_norm = _normalize(entry.get("term", ""))
+    if not query_norm:
+        return "no-query"
+    if term_norm == query_norm:
+        return "exact"
+    aliases = entry.get("aliases") or []
+    alias_norms = [_normalize(a) for a in aliases]
+    if query_norm in alias_norms:
+        return "alias"
+    if query_norm in term_norm:
+        return "substring"
+    for alias_norm in alias_norms:
+        if query_norm and query_norm in alias_norm:
+            return "substring"
+    return None
+
+
+def _ensure_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, Iterable):
+        return [str(v) for v in value]
+    return [str(value)]
+
+
+def _has_overlap(entry_tags: list[str], requested: list[str]) -> bool:
+    if not requested:
+        return True
+    entry_set = {t.strip().lower() for t in entry_tags}
+    requested_set = {t.strip().lower() for t in requested}
+    return bool(entry_set & requested_set)
+
+
+def _matches_single(value: str | None, allowed: list[str]) -> bool:
+    if not allowed:
+        return True
+    if value is None:
+        return False
+    return value.strip().lower() in {a.strip().lower() for a in allowed}
+
+
+def _era_sort_key(era: str) -> int:
+    digits = "".join(ch for ch in era if ch.isdigit())
+    try:
+        return -int(digits[:4]) if digits else 0
+    except ValueError:
+        return 0
+
+
+def search(
+    *,
+    query: str | None = None,
+    mood: list[str] | None = None,
+    context: list[str] | None = None,
+    safety: str | list[str] | None = None,
+    intensity: str | list[str] | None = None,
+    limit: int = DEFAULT_LIMIT,
+    include_deprecated: bool = False,
+    index: dict | None = None,
+    index_path: str | None = None,
+) -> dict:
+    if index is None:
+        index = load_index(index_path)
+
+    entries: list[dict] = list(index.get("entries", []))
+
+    mood_list = _ensure_list(mood)
+    context_list = _ensure_list(context)
+    safety_list = _ensure_list(safety)
+    intensity_list = _ensure_list(intensity)
+
+    query_norm = _normalize(query) if query else ""
+    clamped_limit = max(1, min(int(limit), MAX_LIMIT))
+
+    scored: list[tuple[int, int, str, dict]] = []
+
+    for entry in entries:
+        if not include_deprecated and not entry.get("still_usable", True):
+            continue
+
+        match_reason = _collect_match(entry, query_norm)
+        if match_reason is None:
+            continue
+
+        if not _has_overlap(entry.get("mood_tags") or [], mood_list):
+            continue
+        if not _has_overlap(entry.get("usage_context") or [], context_list):
+            continue
+        if not _matches_single(entry.get("safety"), safety_list):
+            continue
+        if not _matches_single(entry.get("intensity"), intensity_list):
+            continue
+
+        order = MATCH_REASON_ORDER.get(match_reason, 9)
+        era_rank = _era_sort_key(str(entry.get("era", "")))
+        scored.append((order, era_rank, str(entry.get("term", "")), {**entry, "match_reason": match_reason}))
+
+    scored.sort(key=lambda item: (item[0], item[1], item[2]))
+
+    matched_before_limit = len(scored)
+    candidates = [row[3] for row in scored[:clamped_limit]]
+
+    return {
+        "query": query,
+        "filters_applied": {
+            "mood": mood_list,
+            "context": context_list,
+            "safety": safety_list,
+            "intensity": intensity_list,
+            "limit": clamped_limit,
+            "include_deprecated": include_deprecated,
+        },
+        "matched_before_limit": matched_before_limit,
+        "total_candidates": len(candidates),
+        "candidates": candidates,
+        "source": index.get("source", ""),
+        "last_reviewed": index.get("last_reviewed", ""),
+    }
+
+
+def _format_text(result: dict) -> str:
+    if not result["candidates"]:
+        return "No candidates found.\n"
+    lines: list[str] = []
+    query = result.get("query") or "(no query)"
+    lines.append(f"Query: {query}")
+    lines.append(
+        f"Matched: {result['matched_before_limit']} -> showing {result['total_candidates']}"
+    )
+    lines.append("")
+    for idx, entry in enumerate(result["candidates"], start=1):
+        mood = ", ".join(entry.get("mood_tags") or []) or "-"
+        context = ", ".join(entry.get("usage_context") or []) or "-"
+        lines.append(
+            f"{idx}. {entry['term']} ({entry.get('era', '?')}) "
+            f"[{entry.get('safety', '?')}, {entry.get('intensity', '?')}]"
+        )
+        lines.append(f"   mood: {mood}")
+        lines.append(f"   context: {context}")
+        lines.append(f"   meaning: {entry.get('meaning_short', '')}")
+        examples = entry.get("example_usage") or []
+        if examples:
+            lines.append(f"   example: {examples[0]}")
+        lines.append(f"   match: {entry.get('match_reason', '?')}")
+        lines.append(f"   url: {entry.get('namuwiki_url', '')}")
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _split_csv(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [part.strip() for part in value.split(",") if part.strip()]
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Search curated Korean trending-slang index. "
+            "Returns candidates the calling agent can use when writing text with slang."
+        )
+    )
+    parser.add_argument(
+        "--query", default=None, help="Keyword to match against term/aliases."
+    )
+    parser.add_argument(
+        "--mood",
+        default="",
+        help="Comma-separated mood tags (긍정, 부정, 유머, 의지, ...).",
+    )
+    parser.add_argument(
+        "--context",
+        default="",
+        help="Comma-separated context tags (SNS, 마케팅, 음식, 스포츠, ...).",
+    )
+    parser.add_argument(
+        "--safety",
+        default="",
+        help="Comma-separated safety levels: safe, spicy, risky.",
+    )
+    parser.add_argument(
+        "--intensity",
+        default="",
+        help="Comma-separated intensity levels: subtle, medium, strong.",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=DEFAULT_LIMIT,
+        help=f"Max candidates to return (1..{MAX_LIMIT}).",
+    )
+    parser.add_argument(
+        "--include-deprecated",
+        action="store_true",
+        help="Include entries marked still_usable=false.",
+    )
+    parser.add_argument(
+        "--index-path",
+        default=None,
+        help="Override path to a slang index JSON (defaults to bundled seed).",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["json", "text"],
+        default="json",
+        help="Output format. Default: json.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv if argv is not None else sys.argv[1:])
+
+    try:
+        result = search(
+            query=args.query,
+            mood=_split_csv(args.mood),
+            context=_split_csv(args.context),
+            safety=_split_csv(args.safety),
+            intensity=_split_csv(args.intensity),
+            limit=args.limit,
+            include_deprecated=args.include_deprecated,
+            index_path=args.index_path,
+        )
+    except (FileNotFoundError, ValueError) as error:
+        print(
+            json.dumps({"error": str(error)}, ensure_ascii=False),
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.format == "json":
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        sys.stdout.write(_format_text(result))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/korean-slang-writing/skill.json

@@ -0,0 +1,8 @@
+{
+  "name": "korean-slang-writing",
+  "description": "Use curated Korean trending-slang candidates plus best-effort Namu Wiki lookups to write witty Korean text with up-to-date slang, with conservative safety and freshness guardrails.",
+  "profiles": [
+    "local"
+  ],
+  "frontmatter": "name: korean-slang-writing\ndescription: Use curated Korean trending-slang candidates plus best-effort Namu Wiki lookups to write witty Korean text with up-to-date slang, with conservative safety and freshness guardrails.\nlicense: MIT\nmetadata:\n  category: writing\n  locale: ko-KR\n  phase: v1"
+}

package/skills/korean-spell-check/instruction.md

@@ -0,0 +1,105 @@
+# Korean Spell Check
+
+## What this skill does
+
+국립국어원 계열 규칙을 반영한 **바른한글(구 부산대 맞춤법/문법 검사기)** 표면을 이용해 한국어 문장을 최종 교정한다.
+
+- 기본 진입점은 공개 웹 표면 `https://nara-speller.co.kr/speller/` 이다.
+- 자동화가 필요하면 이전 버전 폼 POST 표면 `https://nara-speller.co.kr/old_speller/results` 를 **낮은 요청량으로만** 사용한다.
+- 긴 글은 청크로 나눠 순차 검사한다.
+- 결과는 `원문`, `교정안`, `이유` 중심으로 정리한다.
+
+## Policy first
+
+- `https://nara-speller.co.kr/old_speller/` 는 **비상업적 용도** 안내와 **개인이나 학생만 무료**라는 문구를 명시한다.
+- `https://nara-speller.co.kr/robots.txt` 는 `/` 를 허용하지만 `/test_speller/` 는 금지한다.
+- 따라서 이 스킬은 **사용자 주도 최종 검수**, **저빈도 요청**, **문서/이메일/README 교정** 용도로만 쓴다.
+- 대량 배치, SaaS 백엔드 연동, 상업 서비스 내 무단 재판매/재노출에는 쓰지 않는다. 그런 경우는 공급사 문의/유료 API 계약을 먼저 검토한다.
+
+## When to use
+
+- "이 한국어 문장 맞춤법 검사해줘"
+- "README 한국어 문장 최종 검수해줘"
+- "마크다운 파일 전체에서 띄어쓰기/맞춤법 오류를 잡아줘"
+- "AI 교정보다 규칙 기반 한국어 검사기로 한 번 더 확인해줘"
+
+## When not to use
+
+- 코드 블록/로그/영문 위주 텍스트를 그대로 대량 전송해야 하는 경우
+- 민감정보가 많은 원문을 외부 웹 서비스에 보내면 안 되는 경우
+- 상업적 대량 처리 API가 필요한 경우
+
+## Prerequisites
+
+- 인터넷 연결
+- `python3` 3.10+
+- 이 스킬 디렉토리의 `scripts/korean_spell_check.py` (설치 시 자동 포함)
+
+## Verified surface notes
+
+- 현재 공개 사이트는 `https://nara-speller.co.kr/speller/` 로 제공된다.
+- 이 환경에서 일반 shell/Node fetch는 Cloudflare 때문에 `403` 이 나올 수 있었다.
+- 같은 환경에서도 **브라우저형 User-Agent + Python stdlib `urllib` POST** 는 `old_speller/results` 에서 실제 검사 결과 HTML을 반환했다.
+- 무료 공개 표면은 HTML 결과 페이지이며, 문서화된 공개 JSON API는 확인하지 못했다.
+
+## Workflow
+
+### 1. Ask for the text or file path
+
+- 텍스트가 직접 주어지면 바로 검사한다.
+- 파일 검사라면 UTF-8 텍스트/Markdown 파일만 대상으로 잡고, 코드 블록이 많으면 먼저 사용자에게 범위를 줄일지 물어보는 편이 안전하다.
+
+### 2. Keep requests conservative
+
+- 기본 청크 크기는 `1500` 자 안팎으로 유지한다.
+- 청크 사이는 최소 `1초` 정도 쉬게 한다.
+- 한 번에 너무 많은 파일을 돌리지 않는다.
+
+### 3. Run the helper
+
+```bash
+python3 scripts/korean_spell_check.py \
+  --file README.md \
+  --format json
+```
+
+짧은 문장은 `--text` 로 바로 넣을 수 있다.
+
+```bash
+python3 scripts/korean_spell_check.py \
+  --text "아버지가방에들어가신다." \
+  --format text
+```
+
+### 4. Return change-focused output
+
+최종 답변은 아래 순서를 권장한다.
+
+1. 교정된 전체 문장/문단
+2. 주요 변경점 목록
+3. 각 변경점의 `원문`, `교정안`, `이유`
+4. 필요하면 `공개 웹 검사기 기준 결과이며, 최종 문맥 판단은 사람이 확인` 문구
+
+예시 JSON 필드:
+
+```json
+{
+  "original": "아버지가방에들어가신다",
+  "suggestions": ["아버지가 방에 들어가신다"],
+  "reason": "띄어쓰기, 붙여쓰기, 음절 대치와 같은 교정 방법에 따라 수정한 결과입니다."
+}
+```
+
+## Done when
+
+- 공개 표면 정책을 먼저 확인했다.
+- 긴 텍스트면 청크 분할을 적용했다.
+- 결과를 `원문/교정안/이유` 중심으로 정리했다.
+- 고빈도/상업적 사용이 아님을 분명히 했다.
+
+## Notes
+
+- guide: `https://nara-speller.co.kr/guide/`
+- main UI: `https://nara-speller.co.kr/speller/`
+- old UI / form post: `https://nara-speller.co.kr/old_speller/`, `https://nara-speller.co.kr/old_speller/results`
+- robots: `https://nara-speller.co.kr/robots.txt`