@nomadamas/k-skill 0.1.0

package/skills/korean-patent-search/scripts/patent_search.py

@@ -0,0 +1,409 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from dataclasses import asdict, dataclass
+from html.parser import HTMLParser
+from typing import Callable
+
+SERVICE_KEY_ENV_VAR = "KIPRIS_PLUS_API_KEY"
+DEFAULT_TIMEOUT = 30
+DEFAULT_NUM_ROWS = 10
+DEFAULT_PAGE_NO = 1
+BASE_API_URL = "https://plus.kipris.or.kr/kipo-api/kipi/patUtiModInfoSearchSevice"
+SEARCH_OPERATION = "getWordSearch"
+DETAIL_OPERATION = "getBibliographyDetailInfoSearch"
+DEFAULT_HEADERS = {
+    "Accept": "application/xml,text/xml;q=0.9,*/*;q=0.8",
+    "User-Agent": (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36"
+    ),
+}
+
+
+@dataclass(frozen=True)
+class PatentSearchResult:
+    index_no: int | None
+    application_number: str
+    invention_title: str | None
+    register_status: str | None
+    application_date: str | None
+    open_number: str | None
+    open_date: str | None
+    publication_number: str | None
+    publication_date: str | None
+    register_number: str | None
+    register_date: str | None
+    ipc_number: str | None
+    abstract_text: str | None
+    applicant_name: str | None
+    drawing: str | None
+    big_drawing: str | None
+
+
+@dataclass(frozen=True)
+class PatentSearchResponse:
+    query: str
+    page_no: int
+    num_of_rows: int
+    total_count: int
+    items: list[PatentSearchResult]
+
+
+@dataclass(frozen=True)
+class PatentDetail:
+    application_number: str
+    invention_title: str | None
+    register_status: str | None
+    application_date: str | None
+    open_number: str | None
+    open_date: str | None
+    publication_number: str | None
+    publication_date: str | None
+    register_number: str | None
+    register_date: str | None
+    ipc_number: str | None
+    abstract_text: str | None
+    applicant_name: str | None
+    drawing: str | None
+    big_drawing: str | None
+
+
+@dataclass
+class XmlNode:
+    tag: str
+    children: list["XmlNode"]
+    text_chunks: list[str]
+
+    @property
+    def text(self) -> str:
+        return "".join(self.text_chunks)
+
+
+class XmlNodeBuilder(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.root: XmlNode | None = None
+        self.stack: list[XmlNode] = []
+
+    def handle_starttag(self, tag: str, attrs) -> None:  # type: ignore[override]
+        node = XmlNode(tag=tag, children=[], text_chunks=[])
+        if self.stack:
+            self.stack[-1].children.append(node)
+        else:
+            self.root = node
+        self.stack.append(node)
+
+    def handle_endtag(self, tag: str) -> None:  # type: ignore[override]
+        if self.stack:
+            self.stack.pop()
+
+    def handle_data(self, data: str) -> None:  # type: ignore[override]
+        if self.stack:
+            self.stack[-1].text_chunks.append(data)
+
+
+def clean_text(value: str | None) -> str | None:
+    if value is None:
+        return None
+    cleaned = " ".join(value.split()).strip()
+    return cleaned or None
+
+
+def parse_positive_int(raw_value: str) -> int:
+    value = int(raw_value)
+    if value <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return value
+
+
+def resolve_service_key(explicit_key: str | None = None) -> str:
+    candidate = clean_text(explicit_key) or clean_text(os.getenv(SERVICE_KEY_ENV_VAR))
+    if candidate:
+        return urllib.parse.unquote(candidate)
+    raise ValueError(
+        f"missing {SERVICE_KEY_ENV_VAR}. Export {SERVICE_KEY_ENV_VAR} or pass --service-key "
+        "(mapped to the KIPRIS Plus ServiceKey query parameter)."
+    )
+
+
+def build_operation_url(operation: str) -> str:
+    return f"{BASE_API_URL}/{operation}"
+
+
+def build_search_params(
+    *,
+    query: str,
+    year: int | None = None,
+    page_no: int = DEFAULT_PAGE_NO,
+    num_of_rows: int = DEFAULT_NUM_ROWS,
+    patent: bool = True,
+    utility: bool = True,
+    service_key: str,
+) -> dict[str, str]:
+    if not patent and not utility:
+        raise ValueError("At least one of patent or utility must remain enabled for keyword search.")
+    params = {
+        "word": query,
+        "patent": "true" if patent else "false",
+        "utility": "true" if utility else "false",
+        "pageNo": str(page_no),
+        "numOfRows": str(num_of_rows),
+        "ServiceKey": urllib.parse.unquote(service_key),
+    }
+    if year is not None:
+        params["year"] = str(year)
+    return params
+
+
+def build_detail_params(*, application_number: str, service_key: str) -> dict[str, str]:
+    return {"applicationNumber": application_number, "ServiceKey": urllib.parse.unquote(service_key)}
+
+
+def fetch_xml(url: str, params: dict[str, str], timeout: int = DEFAULT_TIMEOUT) -> str:
+    request_url = f"{url}?{urllib.parse.urlencode(params)}"
+    request = urllib.request.Request(request_url, headers=DEFAULT_HEADERS)
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.read().decode("utf-8", errors="replace")
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"KIPRIS Plus HTTP {exc.code}: {body or exc.reason}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"Failed to reach KIPRIS Plus API: {exc.reason}") from exc
+
+
+def normalize_tag(tag_name: str) -> str:
+    return tag_name.casefold()
+
+
+def iter_children(element: ET.Element | XmlNode | None) -> list[ET.Element | XmlNode]:
+    if element is None:
+        return []
+    if isinstance(element, XmlNode):
+        return element.children
+    return list(element)
+
+
+def find_child(element: ET.Element | XmlNode | None, tag_name: str) -> ET.Element | XmlNode | None:
+    normalized_tag = normalize_tag(tag_name)
+    for child in iter_children(element):
+        if normalize_tag(child.tag) == normalized_tag:
+            return child
+    return None
+
+
+def find_children(element: ET.Element | XmlNode | None, tag_name: str) -> list[ET.Element | XmlNode]:
+    normalized_tag = normalize_tag(tag_name)
+    return [child for child in iter_children(element) if normalize_tag(child.tag) == normalized_tag]
+
+
+def parse_xml_with_fallback(xml_text: str) -> XmlNode:
+    parser = XmlNodeBuilder()
+    try:
+        parser.feed(xml_text)
+        parser.close()
+    except Exception as exc:  # pragma: no cover - defensive fallback guard
+        raise RuntimeError(f"Failed to parse KIPRIS Plus XML response: {exc}") from exc
+    if parser.root is None:
+        raise RuntimeError("Failed to parse KIPRIS Plus XML response: empty document")
+    return parser.root
+
+
+def get_child_text(element: ET.Element | XmlNode | None, tag_name: str) -> str | None:
+    child = find_child(element, tag_name)
+    return clean_text(child.text if child is not None else None)
+
+
+def parse_int(value: str | None) -> int | None:
+    if value is None:
+        return None
+    return int(value)
+
+
+def parse_xml_response(xml_text: str) -> ET.Element | XmlNode:
+    try:
+        root = ET.fromstring(xml_text)
+    except (ET.ParseError, ImportError):
+        root = parse_xml_with_fallback(xml_text)
+
+    header = find_child(root, "header")
+    result_code = get_child_text(header, "resultCode")
+    result_msg = get_child_text(header, "resultMsg")
+    if result_code and result_code != "00":
+        raise RuntimeError(result_msg or f"KIPRIS Plus API error code {result_code}")
+    return root
+
+
+def parse_patent_item(item: ET.Element | XmlNode) -> PatentSearchResult:
+    application_number = get_child_text(item, "applicationNumber")
+    if not application_number:
+        raise RuntimeError("KIPRIS Plus response item is missing applicationNumber")
+
+    return PatentSearchResult(
+        index_no=parse_int(get_child_text(item, "indexNo")),
+        application_number=application_number,
+        invention_title=get_child_text(item, "inventionTitle"),
+        register_status=get_child_text(item, "registerStatus"),
+        application_date=get_child_text(item, "applicationDate"),
+        open_number=get_child_text(item, "openNumber"),
+        open_date=get_child_text(item, "openDate"),
+        publication_number=get_child_text(item, "publicationNumber"),
+        publication_date=get_child_text(item, "publicationDate"),
+        register_number=get_child_text(item, "registerNumber"),
+        register_date=get_child_text(item, "registerDate"),
+        ipc_number=get_child_text(item, "ipcNumber"),
+        abstract_text=get_child_text(item, "astrtCont"),
+        applicant_name=get_child_text(item, "applicantName"),
+        drawing=get_child_text(item, "drawing"),
+        big_drawing=get_child_text(item, "bigDrawing"),
+    )
+
+
+def parse_patent_search_response(xml_text: str, *, query: str) -> PatentSearchResponse:
+    root = parse_xml_response(xml_text)
+    body = find_child(root, "body")
+    items_parent = find_child(body, "items")
+    item_elements = find_children(items_parent, "item")
+    items = [parse_patent_item(item) for item in item_elements]
+    return PatentSearchResponse(
+        query=query,
+        page_no=parse_int(get_child_text(body, "pageNo")) or DEFAULT_PAGE_NO,
+        num_of_rows=parse_int(get_child_text(body, "numOfRows")) or len(items),
+        total_count=parse_int(get_child_text(body, "totalCount")) or len(items),
+        items=items,
+    )
+
+
+def parse_patent_detail_response(xml_text: str) -> PatentDetail:
+    root = parse_xml_response(xml_text)
+    body = find_child(root, "body")
+    item = find_child(body, "item")
+    if item is None and body is not None:
+        items_parent = find_child(body, "items")
+        item = find_child(items_parent, "item")
+    if item is None:
+        raise RuntimeError("KIPRIS Plus detail response did not include an item payload")
+
+    search_item = parse_patent_item(item)
+    return PatentDetail(
+        application_number=search_item.application_number,
+        invention_title=search_item.invention_title,
+        register_status=search_item.register_status,
+        application_date=search_item.application_date,
+        open_number=search_item.open_number,
+        open_date=search_item.open_date,
+        publication_number=search_item.publication_number,
+        publication_date=search_item.publication_date,
+        register_number=search_item.register_number,
+        register_date=search_item.register_date,
+        ipc_number=search_item.ipc_number,
+        abstract_text=search_item.abstract_text,
+        applicant_name=search_item.applicant_name,
+        drawing=search_item.drawing,
+        big_drawing=search_item.big_drawing,
+    )
+
+
+def search_patents(
+    query: str,
+    *,
+    year: int | None = None,
+    page_no: int = DEFAULT_PAGE_NO,
+    num_of_rows: int = DEFAULT_NUM_ROWS,
+    patent: bool = True,
+    utility: bool = True,
+    service_key: str | None = None,
+    fetcher: Callable[[str, dict[str, str], int], str] = fetch_xml,
+    timeout: int = DEFAULT_TIMEOUT,
+) -> PatentSearchResponse:
+    key = resolve_service_key(service_key)
+    xml_text = fetcher(
+        build_operation_url(SEARCH_OPERATION),
+        build_search_params(
+            query=query,
+            year=year,
+            page_no=page_no,
+            num_of_rows=num_of_rows,
+            patent=patent,
+            utility=utility,
+            service_key=key,
+        ),
+        timeout,
+    )
+    return parse_patent_search_response(xml_text, query=query)
+
+
+def get_patent_detail(
+    application_number: str,
+    *,
+    service_key: str | None = None,
+    fetcher: Callable[[str, dict[str, str], int], str] = fetch_xml,
+    timeout: int = DEFAULT_TIMEOUT,
+) -> PatentDetail:
+    key = resolve_service_key(service_key)
+    xml_text = fetcher(
+        build_operation_url(DETAIL_OPERATION),
+        build_detail_params(application_number=application_number, service_key=key),
+        timeout,
+    )
+    return parse_patent_detail_response(xml_text)
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Search Korean patent information via the official KIPRIS Plus Open API."
+    )
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--query", help="Keyword for KIPRIS getWordSearch")
+    mode.add_argument("--application-number", help="Application number for bibliography detail lookup")
+    parser.add_argument("--year", type=parse_positive_int, help="Optional year filter for keyword search")
+    parser.add_argument("--page-no", type=parse_positive_int, default=DEFAULT_PAGE_NO, help="Response page number")
+    parser.add_argument("--num-rows", type=parse_positive_int, default=DEFAULT_NUM_ROWS, help="Rows per page")
+    parser.add_argument("--service-key", help=f"KIPRIS Plus ServiceKey (defaults to ${SERVICE_KEY_ENV_VAR})")
+    parser.add_argument("--exclude-patent", action="store_true", help="Exclude patent results from keyword search")
+    parser.add_argument("--exclude-utility", action="store_true", help="Exclude utility-model results from keyword search")
+    parser.add_argument("--timeout", type=parse_positive_int, default=DEFAULT_TIMEOUT, help="HTTP timeout seconds")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    try:
+        if args.query:
+            payload = search_patents(
+                args.query,
+                year=args.year,
+                page_no=args.page_no,
+                num_of_rows=args.num_rows,
+                patent=not args.exclude_patent,
+                utility=not args.exclude_utility,
+                service_key=args.service_key,
+                timeout=args.timeout,
+            )
+        else:
+            payload = get_patent_detail(
+                args.application_number,
+                service_key=args.service_key,
+                timeout=args.timeout,
+            )
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    except RuntimeError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+    print(json.dumps(asdict(payload), ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

package/skills/korean-patent-search/skill.json

@@ -0,0 +1,9 @@
+{
+  "name": "korean-patent-search",
+  "description": "Search Korean patent and utility-model publications through the official KIPRIS Plus Open API with keyword search plus application-number detail lookup.",
+  "profiles": [
+    "vault",
+    "lookup"
+  ],
+  "frontmatter": "name: korean-patent-search\ndescription: Search Korean patent and utility-model publications through the official KIPRIS Plus Open API with keyword search plus application-number detail lookup.\nlicense: MIT\nmetadata:\n  category: ip\n  locale: ko-KR\n  phase: v1"
+}

package/skills/korean-privacy-terms/instruction.md

@@ -0,0 +1,128 @@
+# Korean Privacy & Terms (thin wrapper)
+
+## What this skill does
+
+[`kimlawtech/korean-privacy-terms`](https://github.com/kimlawtech/korean-privacy-terms) (Apache-2.0) 업스트림을 사용해 한국 법령 기반 **개인정보처리방침·이용약관·쿠키 배너·회원가입 동의 모달** 생성을 수행한다. k-skill 측은 **얇은 wrapper** 만 유지하고, 실제 인터뷰/렌더/설치 로직은 업스트림에 위임한다.
+
+반영 기준은 업스트림이 관리한다:
+
+- 개인정보위원회 처리방침 작성지침 (2025.4.21)
+- 개정 개인정보보호법 (2026.3 공포, 2026.9.11 시행, 과징금 매출액 최대 10%)
+- 공정거래위원회 전자상거래 표준약관 제10023호
+- EU GDPR / ePrivacy (업스트림 v2.0+ 지원)
+
+이 스킬이 생성하는 모든 문서는 **참고용 초안**이며 **법률 자문이 아니다**. 실서비스 배포 전 반드시 **변호사 검토**가 필요하다.
+
+## When to use
+
+- "개인정보처리방침 만들어줘"
+- "이용약관 추가해줘"
+- "쿠키 배너 붙여줘"
+- "회원가입 동의 모달 필요해"
+- "행태정보 고지 추가해줘"
+- "개인정보 동의 UI 깎아줘"
+
+## When not to use
+
+- 실제 법률 자문 · 소송 전략 · 개별 약관 분쟁 판단이 필요한 경우 → 변호사 상담
+- 한국/EU 외 관할(미국 CCPA · 일본 APPI · 중국 PIPL 등) 을 단독으로 다뤄야 하는 경우 (업스트림 로드맵)
+- Next.js App Router 가 아닌 환경 (업스트림이 Pages Router 미지원)
+
+## Prerequisites
+
+- 인터넷 연결 (업스트림 clone 용)
+- `git` 2.20+
+- `bash`
+- 대상 프로젝트가 Next.js 13 ~ 16 App Router 기반일 것 (업스트림 제약)
+
+## Install (dual-install)
+
+업스트림을 `~/.claude/skills/korean-privacy-terms/upstream/` 와 `~/.agents/skills/korean-privacy-terms/upstream/` 양쪽에 pinned SHA 로 체크아웃한다. 레포 내부에 업스트림 payload 를 커밋하지 않으므로 실사용 전 반드시 이 단계를 거친다.
+
+```bash
+bash korean-privacy-terms/scripts/install.sh
+```
+
+레포를 로컬에 clone 하지 않고 이미 홈 디렉토리 스킬 번들만 가진 상태에서도 설치할 수 있다 (installer 는 `${BASH_SOURCE[0]}` 로 절대경로를 해석하므로 cwd 에 구애받지 않는다):
+
+```bash
+bash ~/.claude/skills/korean-privacy-terms/scripts/install.sh
+# 또는
+bash ~/.agents/skills/korean-privacy-terms/scripts/install.sh
+```
+
+스크립트는 `korean-privacy-terms/scripts/upstream.pin` 에 기록된 40자리 커밋 SHA 만 체크아웃한다. 두 경로 모두에서 `git -C <path> rev-parse HEAD` 가 pin 과 동일해야 설치 성공.
+
+오프라인 환경이나 네트워크 차단 상황에서는 업스트림 clone 이 실패하므로 이 스킬의 생성 흐름을 실행할 수 없다. 스크립트가 명시적인 실패 메시지를 남기고 비정상 종료한다.
+
+## Mandatory interview first
+
+사용자가 "개인정보처리방침 만들어줘" 같은 생성 요청을 하면 **바로 파일을 만들지 말고 먼저 되묻는다.** 업스트림 `scripts/interview.md` Step 0 ~ 9 의 인터뷰 프로토콜을 따라 순차로 질문하되, 최소한 아래 항목을 확인한 뒤 생성 단계로 넘어간다.
+
+권장 첫 질문 묶음:
+
+- 대상 사용자 범위 (한국 사용자만 / 해외 위주 / 양쪽 글로벌) — 관할법 결정
+- 운영 주체 소재지 (한국 / 해외)
+- 서비스 유형 (SaaS / 쇼핑몰 / 커뮤니티 / 블로그 / 핀테크 / AI 서비스)
+- Next.js 버전 (13 ~ 16), App Router 사용 여부, 언어 (`.ts` / `.tsx` / `.js` / `.jsx`)
+- Tailwind 버전 (v3 / v4), 번들러 (Turbopack / Webpack)
+- shadcn/ui 기설치 여부, 기존 디자인 시스템 (Tailwind 순정 / Chakra / MUI / Mantine 등)
+- 출력 언어 (한국어만 / 영문만 / 한영 병기)
+- 14세 미만 대상 여부
+- 자동화된 결정(AI) · 행태정보(쿠키) · 맞춤형 광고 처리 여부
+- 개인정보 보호책임자(CPO) 정보, 사업자 상호·대표자·주소 (사용자가 알려줘야 함)
+
+인터뷰는 특정 에이전트의 전용 UI 컴포넌트 호출(질문 위젯 등) 에 의존하지 않는 agent-neutral 톤으로, 한 번에 1 ~ 2문항씩 진행한다. 법률 공포감(과태료 폭탄 등)을 유발하는 표현은 피하고, "법적으로 필요한 부분이에요" 정도의 담담한 톤을 유지한다. 모르는 항목은 "넘어가도 됩니다" 로 열어 둔다.
+
+## Workflow
+
+1. 사용자가 트리거 문구를 말하면 먼저 위 인터뷰 게이트를 실행한다.
+2. `bash korean-privacy-terms/scripts/install.sh` 로 업스트림을 dual-install 한다 (이미 설치돼 있으면 pin 확인만 한다).
+3. 업스트림이 제공하는 순서를 따른다: `scripts/interview.md` → `scripts/render.md` → `scripts/install.md`.
+4. 업스트림은 Next.js 감지 → MDX/shadcn 의존성 설치 → 템플릿 치환 → `src/app/privacy/page.tsx` · `src/app/terms/page.tsx` · `src/components/legal/*` 등 파일 생성 → 법정 필수 11개 항목 검증 → 면책 주석 삽입 을 순차 실행한다.
+5. 생성이 끝나면 사용자에게 보고하되, 아래 **Response policy** 의 고정 블록을 반드시 포함한다.
+
+## CLI examples
+
+```bash
+cat korean-privacy-terms/scripts/upstream.pin
+
+bash korean-privacy-terms/scripts/install.sh
+
+git -C ~/.claude/skills/korean-privacy-terms/upstream rev-parse HEAD
+git -C ~/.agents/skills/korean-privacy-terms/upstream rev-parse HEAD
+```
+
+## Response policy
+
+- 생성된 문서는 **참고용 초안**이며 법률 자문이 아니라는 점을 **모든 답변 말미**에 고지한다.
+- 실서비스 적용 전 반드시 **변호사 검토**가 필요함을 고정 문구로 출력한다.
+- 2026.9.11 시행 개정 개인정보보호법의 §30 법정 항목, 과징금 상향(매출액 10%), 사업주 책임 등이 업스트림 pin 시점 기준으로 반영돼 있음을 알린다. 이후 개정에 대한 최신 반영 여부는 사용자에게 확인 책임이 있다고 명시한다.
+- "등" 으로 뭉뚱그리는 표현, 법정 필수 11개 항목 누락, 면책 주석 제거, 사용자 확인 없이 회사명·책임자명을 추측해 채워넣는 행위는 금지된다 (업스트림 규칙).
+- 14세 미만 대상 서비스에 성인용 방침을 그대로 적용하지 않는다.
+
+## Done when
+
+- 인터뷰 게이트가 실행되어 최소 jurisdiction · 서비스 유형 · Next.js 버전 · App Router 여부 · 출력 언어 가 확인되었다.
+- `scripts/install.sh` 이 업스트림을 dual-install (`~/.claude/skills/korean-privacy-terms/upstream/` + `~/.agents/skills/korean-privacy-terms/upstream/`) 했고, 양쪽 경로 모두 pin 과 동일한 SHA 이다.
+- 업스트림 `scripts/interview.md` → `scripts/render.md` → `scripts/install.md` 순서로 생성이 끝났다.
+- 법정 필수 11개 항목 검증과 면책 주석 삽입이 업스트림 규칙대로 완료되었다.
+- 사용자에게 참고용 초안 + 법률 자문 아님 + 변호사 검토 필수 + 2026.9.11 개정 반영 기준이 함께 고지되었다.
+
+## Failure modes
+
+- 오프라인 또는 네트워크 차단: `scripts/install.sh` 가 upstream clone 단계에서 실패한다. 네트워크 확보 후 재실행.
+- pin SHA 가 업스트림에서 삭제/force-push 된 경우: 스크립트가 SHA mismatch 로 비정상 종료한다. `scripts/upstream.pin` 을 최신 태그 SHA 로 bump 하고 PR 을 만든다.
+- Next.js Pages Router 단독 프로젝트: 업스트림이 실행을 중단한다. 사용자에게 App Router 전환이 선행 조건임을 안내한다.
+- 법률 개정 드리프트: 업스트림이 CHANGELOG 로 반영 기준을 관리한다. pin 만 올리지 말고 업스트림 CHANGELOG 를 함께 확인한다.
+
+## Notes
+
+- upstream: https://github.com/kimlawtech/korean-privacy-terms (Apache-2.0)
+- upstream pin: [`scripts/upstream.pin`](./scripts/upstream.pin)
+- installer: [`scripts/install.sh`](./scripts/install.sh)
+- 법률 면책 전문: [`./DISCLAIMER.md`](./DISCLAIMER.md)
+- upstream 저자·커뮤니티 attribution: [`./NOTICE`](./NOTICE) (@kimlawtech, SpeciAI)
+- Apache-2.0 전문 (업스트림 `LICENSE` verbatim): [`./LICENSE.upstream`](./LICENSE.upstream) — Apache License, Version 2.0 §4(a) ("give any other recipients of the Work or Derivative Works a copy of this License") 준수를 위해 `install.sh` 실행 전에도 레포 트리에 번들해 둔다. 레포 루트의 [`../LICENSE`](../LICENSE) (MIT) 는 k-skill 자체 라이선스이며 이 스킬 상부에 적용되지 않는다.
+- 본 스킬은 업스트림 산출물의 재배포에 해당하므로 Apache License, Version 2.0 §4 요건 (LICENSE 번들, NOTICE 포함, 라이선스 고지) 을 준수한다.
+- 중첩 `SKILL.md` 안내: `install.sh` 실행 후 `~/.claude/skills/korean-privacy-terms/upstream/SKILL.md` 가 존재하게 되지만, Claude Code / Codex / Vercel Agent Skills 등 에이전트 플랫폼은 top-level `SKILL.md` 만 discovery 대상으로 삼는다. 중첩 업스트림 `SKILL.md` 는 직접 호출되지 않는다.

package/skills/korean-privacy-terms/scripts/install.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+#
+# korean-privacy-terms upstream installer.
+#
+# k-skill 측은 얇은 wrapper 만 유지하고, 인터뷰/렌더/설치 로직은 업스트림
+# kimlawtech/korean-privacy-terms (Apache-2.0) 에 위임한다. 이 스크립트는
+# scripts/upstream.pin 에 기록된 커밋 SHA 를 두 홈 디렉토리 스킬 경로
+#
+#   ~/.claude/skills/korean-privacy-terms/upstream/
+#   ~/.agents/skills/korean-privacy-terms/upstream/
+#
+# 아래에 동일하게 체크아웃해 둔다. 레포 내부에 업스트림을 커밋하지 않으므로
+# 실사용 전에는 반드시 이 스크립트를 한 번 실행해야 한다.
+#
+# 사용법:
+#   bash korean-privacy-terms/scripts/install.sh
+#
+# AGENTS.md 규칙에 따라 ~/.claude/skills 와 ~/.agents/skills 는 홈 디렉토리 구조
+# 의 indirection(예: ~/.agents/skills 가 symlink 인 경우) 을 존중한다. 레포
+# 내부에 repo-local .claude/ 또는 .agents/ 디렉토리는 생성하지 않는다.
+
+set -euo pipefail
+
+UPSTREAM_REPO="https://github.com/kimlawtech/korean-privacy-terms.git"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PIN_FILE="${SCRIPT_DIR}/upstream.pin"
+SKILL_NAME="korean-privacy-terms"
+
+if [[ ! -f "${PIN_FILE}" ]]; then
+  echo "[korean-privacy-terms] upstream.pin not found at ${PIN_FILE}" >&2
+  exit 1
+fi
+
+UPSTREAM_SHA="$(tr -d '[:space:]' <"${PIN_FILE}")"
+
+if [[ ! "${UPSTREAM_SHA}" =~ ^[0-9a-f]{40}$ ]]; then
+  echo "[korean-privacy-terms] upstream.pin must contain a 40-char git SHA (got: ${UPSTREAM_SHA})" >&2
+  exit 1
+fi
+
+CACHE_DIR="${HOME}/.cache/k-skill/${SKILL_NAME}"
+CLONE_DIR="${CACHE_DIR}/upstream"
+
+mkdir -p "${CACHE_DIR}"
+
+if [[ ! -d "${CLONE_DIR}/.git" ]]; then
+  echo "[korean-privacy-terms] cloning upstream into ${CLONE_DIR}"
+  if ! git clone --filter=blob:none "${UPSTREAM_REPO}" "${CLONE_DIR}" >&2; then
+    echo "" >&2
+    echo "[korean-privacy-terms] upstream clone failed (network required)." >&2
+    echo "  upstream: ${UPSTREAM_REPO}" >&2
+    echo "  오프라인 환경에서는 이 스킬의 생성 흐름을 실행할 수 없다." >&2
+    echo "  네트워크를 확보한 뒤 다시 실행해달라." >&2
+    exit 1
+  fi
+fi
+
+echo "[korean-privacy-terms] syncing upstream to pinned SHA ${UPSTREAM_SHA}"
+git -C "${CLONE_DIR}" fetch --tags origin "${UPSTREAM_SHA}" >&2 || git -C "${CLONE_DIR}" fetch origin >&2
+git -C "${CLONE_DIR}" checkout --force --detach "${UPSTREAM_SHA}" >&2
+
+HEAD_SHA="$(git -C "${CLONE_DIR}" rev-parse HEAD)"
+
+if [[ "${HEAD_SHA}" != "${UPSTREAM_SHA}" ]]; then
+  echo "[korean-privacy-terms] HEAD (${HEAD_SHA}) does not match pinned SHA (${UPSTREAM_SHA})" >&2
+  exit 1
+fi
+
+# Dual-install targets. Both paths respect AGENTS.md indirection rules and do not
+# introduce repo-local skill directories.
+HOME_DIRS=(
+  "${HOME}/.claude/skills/${SKILL_NAME}"
+  "${HOME}/.agents/skills/${SKILL_NAME}"
+)
+
+for HOME_SKILL_DIR in "${HOME_DIRS[@]}"; do
+  HOME_UPSTREAM="${HOME_SKILL_DIR}/upstream"
+  mkdir -p "${HOME_SKILL_DIR}"
+
+  if [[ -e "${HOME_UPSTREAM}" || -L "${HOME_UPSTREAM}" ]]; then
+    rm -rf "${HOME_UPSTREAM}"
+  fi
+
+  # rsync-style copy preserves the git metadata so `git -C <path> rev-parse HEAD`
+  # still reports the pinned SHA after install. Prefer rsync when available;
+  # otherwise fall back to `cp -a` which is portable on macOS and Linux.
+  if command -v rsync >/dev/null 2>&1; then
+    rsync -a --delete "${CLONE_DIR}/" "${HOME_UPSTREAM}/"
+  else
+    cp -a "${CLONE_DIR}/" "${HOME_UPSTREAM}/"
+  fi
+
+  INSTALLED_SHA="$(git -C "${HOME_UPSTREAM}" rev-parse HEAD)"
+
+  if [[ "${INSTALLED_SHA}" != "${UPSTREAM_SHA}" ]]; then
+    echo "[korean-privacy-terms] ${HOME_UPSTREAM} HEAD (${INSTALLED_SHA}) does not match pin (${UPSTREAM_SHA})" >&2
+    exit 1
+  fi
+
+  echo "[korean-privacy-terms] installed upstream@${UPSTREAM_SHA} -> ${HOME_UPSTREAM}"
+done
+
+echo ""
+echo "[korean-privacy-terms] done."
+echo "  pinned upstream SHA: ${UPSTREAM_SHA}"
+echo "  upstream repo:       ${UPSTREAM_REPO}"
+echo "  이 스킬이 생성하는 모든 문서는 참고용 초안이며 법률 자문이 아니다."
+echo "  실서비스 배포 전 반드시 변호사 검토를 받아달라."

package/skills/korean-privacy-terms/scripts/upstream.pin

@@ -0,0 +1 @@
+e390f7b9feb825e368c26726363ea5ce11a34083

package/skills/korean-privacy-terms/skill.json

@@ -0,0 +1,8 @@
+{
+  "name": "korean-privacy-terms",
+  "description": "kimlawtech/korean-privacy-terms (Apache-2.0) 업스트림을 경유해 Next.js 프로젝트에 한국 법령(개인정보보호법·약관규제법·전자상거래법) 기반 개인정보처리방침·이용약관·쿠키 배너·동의 모달을 생성하는 thin wrapper 스킬.",
+  "profiles": [
+    "local"
+  ],
+  "frontmatter": "name: korean-privacy-terms\ndescription: kimlawtech/korean-privacy-terms (Apache-2.0) 업스트림을 경유해 Next.js 프로젝트에 한국 법령(개인정보보호법·약관규제법·전자상거래법) 기반 개인정보처리방침·이용약관·쿠키 배너·동의 모달을 생성하는 thin wrapper 스킬.\nlicense: Apache-2.0\nmetadata:\n  category: legal\n  locale: ko-KR\n  phase: v1"
+}