const test = require("node:test");

const assert = require("node:assert/strict");

const fs = require("node:fs");

const os = require("node:os");

const path = require("node:path");

const childProcess = require("node:child_process");

const repoRoot = path.join(__dirname, "..");

function read(relativePath) {

return fs.readFileSync(path.join(repoRoot, relativePath), "utf8");

}

function readJson(relativePath) {

return JSON.parse(read(relativePath));

}

function escapeRegex(value) {

return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

}

function findSection(doc, heading) {

const escaped = escapeRegex(heading);

const match = doc.match(new RegExp(`${escaped}[\\s\\S]*?(?=\\n## |\\n### |$)`));

assert.ok(match, `expected section headed by "${heading}"`);

return match[0];

}

function assertOliveYoungCloneFallbackCommands(doc, label) {

assert.match(doc, /node dist\/bin\.js health/, `${label} should document the runnable local health command`);

assert.match(

doc,

/node dist\/bin\.js get \/api\/oliveyoung\/stores --keyword 명동 --limit 5 --json/,

`${label} should document the runnable local store lookup command`,

);

assert.match(

doc,

/node dist\/bin\.js get \/api\/oliveyoung\/products --keyword 선크림 --size 5 --json/,

`${label} should document the runnable local product lookup command`,

);

assert.match(

doc,

/node dist\/bin\.js get \/api\/oliveyoung\/inventory --keyword 선크림 --storeKeyword 명동 --size 5 --json/,

`${label} should document the runnable local inventory lookup command`,

);

assert.doesNotMatch(doc, /^\s*npx daiso\b/m, `${label} should not publish broken clone-local npx commands`);

}

function assertOliveYoungCloneFallbackShorthand(doc, label) {

assert.match(

doc,

/git clone https:\/\/github\.com\/hmmhmmhm\/daiso-mcp\.git && cd daiso-mcp && npm install && npm run build/,

`${label} should include a runnable shorthand that changes into the clone before install/build`,

);

assert.doesNotMatch(

doc,

/git clone https:\/\/github\.com\/hmmhmmhm\/daiso-mcp\.git && npm install && npm run build/,

`${label} should not publish the broken shorthand that skips cd daiso-mcp`,

);

}

function extractQuotedEntries(block, indent) {

return block

.split("\n")

.map((line) => line.match(new RegExp(`^ {${indent}}"([^"]+)":\\s*(.+?)(?:,)?$`)))

.filter(Boolean)

.map(([, key, value]) => [key, value.trim()]);

}

function findPrintedObjectBlock(doc, carrier) {

const block = [...doc.matchAll(/print\(json\.dumps\(\{\n([\s\S]*?)\n\}, ensure_ascii=False, indent=2\)\)/g)]

.map((match) => match[1])

.find((candidate) => candidate.includes(`"carrier": "${carrier}"`));

assert.ok(block, `expected ${carrier} normalized JSON example`);

return block;

}

function findRecentEventsBlock(doc, carrier) {

const block = [...doc.matchAll(/normalized_events = \[\n\s*\{\n([\s\S]*?)\n\s*\}\n\s*for [^\n]+ in events\n\]/g)]

.map((match) => match[1])

.find((candidate) => candidate.includes('"status_code":') === (carrier === "cj"));

assert.ok(block, `expected ${carrier} recent_events example`);

return block;

}

function findJsonFenceAfterLabel(doc, label) {

return JSON.parse(findJsonFenceTextAfterLabel(doc, label));

}

function findJsonFenceTextAfterLabel(doc, label) {

const escaped = escapeRegex(label);

const match = doc.match(new RegExp(`${escaped}[\\s\\S]*?\\\`\\\`\\\`json\\n([\\s\\S]*?)\\n\\\`\\\`\\\``));

assert.ok(match, `expected JSON example after "${label}"`);

return match[1];

}

function assertSampleProvenance(doc, sectionLabel, expected, docLabel) {

const escapedSectionLabel = escapeRegex(sectionLabel);

const escapedVerifiedAt = escapeRegex(expected.verified_at);

const escapedInvoice = escapeRegex(expected.invoice);

assert.match(

doc,

new RegExp(

`${escapedSectionLabel}[\\s\\S]*?아래 값은 ${escapedVerifiedAt} 기준 live smoke test\\(\\x60${escapedInvoice}\\x60\\)에서 확인한 정규화 결과다\\.\\n\\n\\\`\\\`\\\`json`,

),

`${docLabel} ${sectionLabel} provenance line must stay pinned to the verified smoke-test date and invoice`,

);

}

function assertSanitizedPublicOutput(output, label) {

const serialized = JSON.stringify(output);

assert.doesNotMatch(serialized, /\bTEL\b/i, `${label} must not leak TEL fragments`);

assert.doesNotMatch(

serialized,

/\d{2,4}[.\-]\d{3,4}[.\-]\d{4}/,

`${label} must not leak phone-number-like strings anywhere in the published sample`,

);

assert.doesNotMatch(serialized, /crgNm/, `${label} must not leak CJ assignee/source fields`);

assert.doesNotMatch(serialized, /sender/i, `${label} must not leak sender fields`);

assert.doesNotMatch(serialized, /receiver/i, `${label} must not leak receiver fields`);

assert.doesNotMatch(serialized, /delivered_to/i, `${label} must not leak delivered_to fields`);

}

function assertKakaoBarNearbySadangSmokeSnapshot(smoke, label) {

assert.equal(smoke.anchor.name, "사당1동먹자골목상점가", `${label} anchor should stay on the verified area landmark`);

assert.equal(smoke.meta.openNowCount, 4, `${label} should publish the verified open-now count`);

assert.deepEqual(

smoke.items.map((item) => item.name),

["우미노식탁", "방배을지로골뱅이술집포차 사당역점", "커먼테이블"],

`${label} should keep the verified top-3 ordering`,

);

}

test("root npm test script includes the skill docs regression suite", () => {

const packageJson = JSON.parse(read("package.json"));

assert.match(packageJson.scripts.test, /node --test scripts\/skill-docs\.test\.js/);

});

test("README advertises OpenClaw among the supported coding agents", () => {

const readme = read("README.md");

assert.match(

readme,

/Claude Code, Codex, OpenCode, OpenClaw\/ClawHub 등 각종 코딩 에이전트 지원합니다\./,

);

});

test("repository publishes Korean contribution guidance for external contributors", () => {

const contributingPath = path.join(repoRoot, "CONTRIBUTING.md");

assert.ok(fs.existsSync(contributingPath), "expected CONTRIBUTING.md to exist");

const contributing = read("CONTRIBUTING.md");

assert.match(contributing, /^# 기여 가이드$/m);

assert.match(contributing, /PR 코멘트, 이슈, 리뷰 등 모든 소통은 한국어로 진행/);

assert.match(contributing, /PR의 대상 브랜치는 반드시 `dev`/);

assert.match(contributing, /`main` 브랜치로 PR을 만들 수 있는 사람은 `@vkehfdl1`뿐/);

assert.match(contributing, /스킬을 추가하거나 변경할 때는 관련 기능 문서와 `README\.md`의 표/);

assert.match(contributing, /npm 패키지를 수정할 때는 Changesets/);

assert.match(contributing, /Changeset 파일의 존재 여부를 테스트로 검증하지 않는다/);

assert.match(contributing, /`package\.json`과 `package-lock\.json`의 `version` 필드를 테스트에서 고정하지 않는다/);

assert.match(contributing, /`name`, `license`, `engines\.node`, workspace link metadata/);

assert.match(contributing, /현재 구현이 registry token 기반인 경우에도 신규 또는 재설계 흐름은 trusted publishing\/OIDC를 우선/);

assert.match(contributing, /신규 proxy route는 upstream이 API key를 요구하는 무료 API인 경우에만 `k-skill-proxy` 경유를 검토/);

assert.match(contributing, /인증 없이 동작하는 공개 read-only endpoint는 기본적으로 사용자 머신에서 직접 호출/);

assert.doesNotMatch(contributing, /무료 API이고 1일 리미트가 충분한 경우/);

assert.match(contributing, /유료 API/);

assert.match(contributing, /`k-skill-proxy`를 타지 않도록 설계/);

assert.match(contributing, /릴리스나 패키징 관련 변경은 `npm run ci`/);

assert.match(contributing, /`~\/\.claude\/skills\/<skill-name>`/);

assert.match(contributing, /`~\/\.agents\/skills\/<skill-name>`/);

assert.match(contributing, /프로덕션 프록시는 `~\/\.local\/share\/k-skill-proxy`/);

});

test("README links to the contribution guide", () => {

const readme = read("README.md");

assert.match(readme, /\[기여 가이드\]\(CONTRIBUTING\.md\)/);

});

test("repository docs advertise Daangn read-only search skills", () => {

const readme = read("README.md");

const sources = read(path.join("docs", "sources.md"));

const skills = [

["daangn-used-goods-search", "당근 중고거래 검색"],

["daangn-realty-search", "당근부동산 검색"],

["daangn-jobs-search", "당근알바 검색"],

["daangn-cars-search", "당근중고차 검색"],

];

assert.match(sources, /www\.daangn\.com\/kr\/api\/v1\/regions\/keyword/);

assert.match(sources, /realty\.daangn\.com\/articles/);

for (const [skillName, label] of skills) {

const skill = read(path.join(skillName, "SKILL.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", `${skillName}.md`);

const featureDoc = read(path.join("docs", "features", `${skillName}.md`));

assert.ok(fs.existsSync(featureDocPath), `expected docs/features/${skillName}.md to exist`);

assert.ok(

readme.includes(`| ${label} | \`${skillName}\``),

`README should advertise ${skillName}`,

);

assert.ok(

readme.includes(`](docs/features/${skillName}.md)`),

`README should link docs/features/${skillName}.md`,

);

assert.match(skill, /kr\/api\/v1\/regions\/keyword/);

assert.match(featureDoc, /kr\/api\/v1\/regions\/keyword/);

assert.match(featureDoc, /(로그인|채팅|구매|문의|지원).*자동화/);

}

});

test("hwp skill documents kordoc-based parsing and supported operations", () => {

const skillPath = path.join(repoRoot, "hwp", "SKILL.md");

assert.ok(fs.existsSync(skillPath), "expected hwp/SKILL.md to exist");

const skill = read(path.join("hwp", "SKILL.md"));

assert.match(skill, /^name: hwp$/m);

assert.match(skill, /\bkordoc\b/);

assert.doesNotMatch(skill, /@ohah\/hwpjs/);

assert.doesNotMatch(skill, /\bhwp-mcp\b/);

assert.match(skill, /JSON/i);

assert.match(skill, /Markdown/i);

assert.match(skill, /image/i);

assert.match(skill, /(batch|배치)/i);

assert.match(skill, /HWPX/i);

assert.match(skill, /(역변환|되돌려)/);

assert.match(skill, /(비교|compare)/i);

assert.match(skill, /pdfjs-dist/);

assert.match(skill, /(extractFormFields|양식 필드)/);

assert.doesNotMatch(skill, /fillForm/);

assert.doesNotMatch(skill, /kordoc fill/);

assert.doesNotMatch(skill, /kordoc mcp/);

});

test("hwp docs match the published kordoc install and runtime contract", () => {

const skill = read(path.join("hwp", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "hwp.md"));

const install = read(path.join("docs", "install.md"));

const readme = read("README.md");

const sources = read(path.join("docs", "sources.md"));

assert.match(skill, /npx --yes --package kordoc --package pdfjs-dist kordoc .* -o .*\.md/);

assert.match(skill, /markdownToHwpx/);

assert.match(skill, /extractFormFields/);

assert.match(skill, /npm init -y/);

assert.match(skill, /npm install kordoc pdfjs-dist/);

assert.doesNotMatch(skill, /^\s*npx kordoc\b/m);

assert.doesNotMatch(skill, /export NODE_PATH/);

assert.match(featureDoc, /npx --yes --package kordoc --package pdfjs-dist kordoc .* --format json/);

assert.match(featureDoc, /markdownToHwpx/);

assert.match(featureDoc, /(extractFormFields|양식 필드)/);

assert.match(featureDoc, /npx --yes --package kordoc --package pdfjs-dist kordoc watch/);

assert.match(featureDoc, /npm init -y/);

assert.match(featureDoc, /npm install kordoc pdfjs-dist/);

assert.doesNotMatch(featureDoc, /^\s*npx kordoc\b/m);

assert.doesNotMatch(featureDoc, /export NODE_PATH/);

assert.match(featureDoc, /npm install -g kordoc pdfjs-dist/);

assert.doesNotMatch(featureDoc, /선택적으로 `pdfjs-dist`/);

assert.doesNotMatch(featureDoc, /kordoc fill/);

assert.doesNotMatch(featureDoc, /kordoc mcp/);

assert.doesNotMatch(featureDoc, /fillForm/);

assert.match(install, /npm install -g kordoc pdfjs-dist /);

assert.match(install, /HWP Node API 예시는 전역 `NODE_PATH` 대신 로컬 프로젝트에 `npm install kordoc pdfjs-dist` 후 실행/);

assert.match(install, /`kordoc` CLI를 일회성으로만 쓸 때는 `npx --yes --package kordoc --package pdfjs-dist kordoc \.\.\.` 형태를 사용한다\./);

assert.match(readme, /\| HWP 문서 조회\/변환 \| .*양식 필드 추출.*Markdown→HWPX 역변환/);

assert.doesNotMatch(readme, /\| HWP 문서 조회\/변환 \| .*양식 채우기/);

assert.match(sources, /kordoc/);

assert.match(sources, /pdfjs-dist/);

});

test("repository docs advertise the hwp skill", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "hwp.md");

const featureDoc = read(path.join("docs", "features", "hwp.md"));

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/hwp.md to exist");

assert.match(readme, /\| HWP 문서 조회\/변환 \|/);

assert.match(readme, /\[HWP 문서 처리 가이드\]\(docs\/features\/hwp\.md\)/);

assert.match(install, /--skill hwp/);

assert.match(featureDoc, /\bkordoc\b/);

assert.doesNotMatch(featureDoc, /@ohah\/hwpjs/);

assert.doesNotMatch(featureDoc, /\bhwp-mcp\b/);

assert.match(install, /npm install -g kordoc /);

assert.doesNotMatch(install, /@ohah\/hwpjs/);

});

test("repository docs advertise the kakaotalk-mac skill", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "kakaotalk-mac.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/kakaotalk-mac.md to exist");

assert.match(readme, /\| 카카오톡 Mac CLI \|/);

assert.match(readme, /\[카카오톡 Mac CLI\]\(docs\/features\/kakaotalk-mac\.md\)/);

assert.match(install, /--skill kakaotalk-mac/);

});

test("repository docs advertise the used-car-price-search skill", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "used-car-price-search.md");

const skillPath = path.join(repoRoot, "used-car-price-search", "SKILL.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/used-car-price-search.md to exist");

assert.ok(fs.existsSync(skillPath), "expected used-car-price-search/SKILL.md to exist");

assert.match(readme, /\| 중고차 가격 조회 \|/);

assert.match(readme, /\[중고차 가격 조회 가이드\]\(docs\/features\/used-car-price-search\.md\)/);

assert.match(install, /--skill used-car-price-search/);

assert.match(

install,

/npm install -g kordoc pdfjs-dist kbo-game kbl-results kleague-results lck-analytics toss-securities hipass-receipt k-lotto coupang-product-search used-car-price-search cheap-gas-nearby public-restroom-nearby korean-law-mcp/,

);

});

test("repository docs advertise the public-restroom-nearby skill", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "public-restroom-nearby.md");

const skillPath = path.join(repoRoot, "public-restroom-nearby", "SKILL.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/public-restroom-nearby.md to exist");

assert.ok(fs.existsSync(skillPath), "expected public-restroom-nearby/SKILL.md to exist");

assert.match(readme, /\| 근처 공중화장실 찾기 \|/);

assert.match(readme, /\[근처 공중화장실 찾기 가이드\]\(docs\/features\/public-restroom-nearby\.md\)/);

assert.match(install, /--skill public-restroom-nearby/);

assert.match(install, /npm install -g .*public-restroom-nearby/);

});

test("public-restroom-nearby docs describe the maxDistanceMeters distance cap", () => {

const featureDoc = read(path.join("docs", "features", "public-restroom-nearby.md"));

const packageReadme = read(path.join("packages", "public-restroom-nearby", "README.md"));

assert.match(featureDoc, /maxDistanceMeters/);

assert.match(featureDoc, /100m/);

assert.match(packageReadme, /maxDistanceMeters/);

assert.match(packageReadme, /100m/);

});

test("repository docs advertise the lck-analytics skill and package", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "lck-analytics.md");

const skillPath = path.join(repoRoot, "lck-analytics", "SKILL.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/lck-analytics.md to exist");

assert.ok(fs.existsSync(skillPath), "expected lck-analytics/SKILL.md to exist");

assert.match(readme, /\| LCK 경기 분석 \|/);

assert.match(readme, /\[LCK 경기 분석 가이드\]\(docs\/features\/lck-analytics\.md\)/);

assert.match(install, /--skill lck-analytics/);

assert.match(install, /npm install -g .*lck-analytics/);

});

test("lck-analytics docs and skill credit the original author and reference repo", () => {

const skill = read(path.join("lck-analytics", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "lck-analytics.md"));

const packageReadme = read(path.join("packages", "lck-analytics", "README.md"));

const sources = read(path.join("docs", "sources.md"));

for (const doc of [skill, featureDoc, packageReadme]) {

assert.match(doc, /jerjangmin/);

assert.match(doc, /https:\/\/github\.com\/jerjangmin\/share\/tree\/main\/SKILL\/lck-analytics/);

assert.match(doc, /Riot|LoL Esports|Oracle(?:'s)? Elixir/i);

}

assert.match(sources, /https:\/\/github\.com\/jerjangmin\/share\/tree\/main\/SKILL\/lck-analytics/);

});

test("repository docs advertise the korean-spell-check skill and usage constraints", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "korean-spell-check.md");

const skillPath = path.join(repoRoot, "korean-spell-check", "SKILL.md");

const featureDoc = read(path.join("docs", "features", "korean-spell-check.md"));

const skill = read(path.join("korean-spell-check", "SKILL.md"));

const sources = read(path.join("docs", "sources.md"));

const roadmap = read(path.join("docs", "roadmap.md"));

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/korean-spell-check.md to exist");

assert.ok(fs.existsSync(skillPath), "expected korean-spell-check/SKILL.md to exist");

assert.match(readme, /\| 한국어 맞춤법 검사 \|/);

assert.match(readme, /\[한국어 맞춤법 검사 가이드\]\(docs\/features\/korean-spell-check\.md\)/);

assert.match(install, /--skill korean-spell-check/);

assert.match(skill, /비상업적 용도|개인이나 학생만 무료/);

assert.match(skill, /robots\.txt/i);

assert.match(skill, /청크|chunk/i);

assert.match(skill, /원문.*교정안.*이유/s);

assert.match(featureDoc, /old_speller\/results/);

assert.match(featureDoc, /Cloudflare|403/);

assert.match(featureDoc, /python3 scripts\/korean_spell_check\.py/);

assert.match(sources, /https:\/\/nara-speller\.co\.kr\/speller\//);

assert.match(sources, /https:\/\/nara-speller\.co\.kr\/old_speller\//);

assert.match(sources, /https:\/\/nara-speller\.co\.kr\/robots\.txt/);

assert.match(roadmap, /한국어 맞춤법 검사 스킬 출시/);

});

test("repository docs advertise the MFDS public-health skills and mandatory symptom interview", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const sources = read(path.join("docs", "sources.md"));

const setup = read(path.join("docs", "setup.md"));

const security = read(path.join("docs", "security-and-secrets.md"));

const setupSkill = read(path.join("k-skill-setup", "SKILL.md"));

const drugSkillPath = path.join(repoRoot, "mfds-drug-safety", "SKILL.md");

const foodSkillPath = path.join(repoRoot, "mfds-food-safety", "SKILL.md");

const drugFeaturePath = path.join(repoRoot, "docs", "features", "mfds-drug-safety.md");

const foodFeaturePath = path.join(repoRoot, "docs", "features", "mfds-food-safety.md");

assert.ok(fs.existsSync(drugSkillPath), "expected mfds-drug-safety/SKILL.md to exist");

assert.ok(fs.existsSync(foodSkillPath), "expected mfds-food-safety/SKILL.md to exist");

assert.ok(fs.existsSync(drugFeaturePath), "expected docs/features/mfds-drug-safety.md to exist");

assert.ok(fs.existsSync(foodFeaturePath), "expected docs/features/mfds-food-safety.md to exist");

assert.match(readme, /\| 의약품 안전 체크 \|/);

assert.match(readme, /\| 식품 안전 체크 \|/);

assert.match(readme, /\| 의약품 안전 체크 \| .* \| 불필요 \|/);

assert.match(readme, /\| 식품 안전 체크 \| .* \| 불필요 \|/);

assert.match(install, /--skill mfds-drug-safety/);

assert.match(install, /--skill mfds-food-safety/);

assert.match(sources, /15075057\/openapi\.do/);

assert.match(sources, /15097208\/openapi\.do/);

assert.match(sources, /15056516\/openapi\.do/);

assert.match(sources, /15074318\/openapi\.do/);

assert.match(sources, /foodsafetykorea\.go\.kr\/api\/openApiInfo\.do.*svc_no=I0490/);

for (const doc of [setup, security, setupSkill]) {

assert.match(doc, /의약품 안전 체크|식품 안전 체크/);

assert.match(doc, /FOODSAFETYKOREA_API_KEY|DATA_GO_KR_API_KEY/);

assert.match(doc, /사용자.*불필요|proxy 서버/u);

}

for (const relativePath of [

path.join("mfds-drug-safety", "SKILL.md"),

path.join("mfds-food-safety", "SKILL.md"),

path.join("docs", "features", "mfds-drug-safety.md"),

path.join("docs", "features", "mfds-food-safety.md")

]) {

const doc = read(relativePath);

assert.match(doc, /인터뷰|되묻/);

assert.match(doc, /호흡곤란/);

assert.match(doc, /직접 진단|진단\/처방|진단\)이나/);

assert.match(doc, /119|응급실/);

}

});

test("used-car-price-search docs document the provider survey and SK direct surface", () => {

const skill = read(path.join("used-car-price-search", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "used-car-price-search.md"));

const sources = read(path.join("docs", "sources.md"));

const roadmap = read(path.join("docs", "roadmap.md"));

for (const doc of [skill, featureDoc]) {

assert.match(doc, /SK렌터카|SK렌터카 다이렉트|타고BUY/);

assert.match(doc, /롯데렌탈|롯데오토옥션/);

assert.match(doc, /레드캡렌터카/);

assert.match(doc, /MCP/i);

assert.match(doc, /Skill/i);

assert.match(doc, /https:\/\/www\.skdirect\.co\.kr\/tb/);

assert.match(doc, /__NEXT_DATA__/);

assert.match(doc, /인수가/);

assert.match(doc, /월\s*렌트료|월\s*요금|월\s*가격/);

assert.match(doc, /10회 이상|최소 10회/);

}

assert.match(featureDoc, /2026-04-02/);

assert.match(featureDoc, /inventory 규모는 시점에 따라 변동될 수/);

assert.doesNotMatch(featureDoc, /총 `\d+대`/);

assert.match(sources, /https:\/\/www\.skdirect\.co\.kr\/tb/);

assert.match(sources, /https:\/\/www\.lotteautoauction\.net\/hp\/pub\/cmm\/viewMain\.do/);

assert.match(sources, /https:\/\/biz\.redcap\.co\.kr\/rent\//);

assert.match(roadmap, /중고차 가격 조회 스킬 출시/);

});

test("seoul subway docs default to the hosted proxy when KSKILL_PROXY_BASE_URL is unset", () => {

const readme = read("README.md");

const setup = read(path.join("docs", "setup.md"));

const install = read(path.join("docs", "install.md"));

const security = read(path.join("docs", "security-and-secrets.md"));

const setupSkill = read(path.join("k-skill-setup", "SKILL.md"));

const skill = read(path.join("seoul-subway-arrival", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "seoul-subway-arrival.md"));

const proxyDoc = read(path.join("docs", "features", "k-skill-proxy.md"));

const proxyReadme = read(path.join("packages", "k-skill-proxy", "README.md"));

const secretsExample = read(path.join("examples", "secrets.env.example"));

assert.match(readme, /\| 서울 지하철 도착정보 조회 \| .* \| 불필요 \|/);

assert.match(setup, /\| 서울 지하철 도착정보 조회 \| 사용자 시크릿 불필요 \(기본 hosted proxy 사용, 운영자만 `SEOUL_OPEN_API_KEY`\) \|/);

assert.match(install, /--skill seoul-subway-arrival/);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /KSKILL_PROXY_BASE_URL/);

assert.match(doc, /\/v1\/seoul-subway\/arrival/);

assert.match(doc, /사용자가 .*OpenAPI key.*직접.*필요(가|는)? 없다|개인 API key 없이/i);

assert.match(doc, /비우면 기본 hosted `https:\/\/k-skill-proxy\.nomadamas\.org`|없으면 기본 hosted proxy/i);

assert.doesNotMatch(doc, /SEOUL_OPEN_API_KEY/);

assert.doesNotMatch(doc, /swopenAPI\.seoul\.go\.kr\/api\/subway\/\$\{SEOUL_OPEN_API_KEY\}/);

assert.doesNotMatch(doc, /필수: self-host|반드시 명시|먼저 확보|public hosted route rollout 전/);

}

assert.match(proxyDoc, /GET \/v1\/seoul-subway\/arrival/);

assert.match(proxyDoc, /KSKILL_PROXY_BASE_URL/);

assert.match(proxyDoc, /unset\/empty|비워 두면/);

assert.match(proxyDoc, /https:\/\/k-skill-proxy\.nomadamas\.org/);

assert.match(proxyDoc, /KSKILL_PROXY_BASE_URL=https:\/\/your-proxy\.example\.com/);

assert.match(proxyDoc, /self-host|alternate proxy/i);

assert.match(proxyDoc, /override/i);

assert.match(proxyDoc, /SEOUL_OPEN_API_KEY/);

assert.match(proxyReadme, /GET \/v1\/seoul-subway\/arrival/);

assert.match(proxyReadme, /SEOUL_OPEN_API_KEY/);

assert.match(security, /KSKILL_PROXY_BASE_URL/);

assert.match(security, /서울 지하철.*한국 날씨.*기본 hosted proxy|기본 hosted proxy.*서울 지하철.*한국 날씨/i);

assert.match(setupSkill, /서울 지하철: 사용자 시크릿 불필요 \(기본 hosted proxy 사용, 운영자만 `SEOUL_OPEN_API_KEY`\)/);

assert.doesNotMatch(secretsExample, /SEOUL_OPEN_API_KEY/);

assert.doesNotMatch(secretsExample, /^KSKILL_PROXY_BASE_URL=https:\/\/your-proxy\.example\.com$/m);

assert.match(secretsExample, /^(#\s*)?KSKILL_PROXY_BASE_URL=$|^#\s*KSKILL_PROXY_BASE_URL=https:\/\/your-proxy\.example\.com$/m);

assert.doesNotMatch(secretsExample, /KSKILL_PROXY_BASE_URL=https:\/\/k-skill-proxy\.nomadamas\.org/);

});

test("repository docs advertise the korea-weather skill across the documented surfaces", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const roadmap = read(path.join("docs", "roadmap.md"));

const sources = read(path.join("docs", "sources.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "korea-weather.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/korea-weather.md to exist");

assert.match(readme, /\| 한국 날씨 조회 \|/);

assert.match(readme, /\[한국 날씨 조회 가이드\]\(docs\/features\/korea-weather\.md\)/);

assert.match(install, /--skill korea-weather/);

assert.match(roadmap, /한국 날씨 조회 스킬 출시/);

assert.match(sources, /기상청 단기예보 조회서비스: https:\/\/www\.data\.go\.kr\/data\/15084084\/openapi\.do/);

});

test("korea-weather docs route short-term forecast calls through the proxy without requiring a user API key", () => {

const skillPath = path.join(repoRoot, "korea-weather", "SKILL.md");

assert.ok(fs.existsSync(skillPath), "expected korea-weather/SKILL.md to exist");

const skill = read(path.join("korea-weather", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "korea-weather.md"));

const proxyDoc = read(path.join("docs", "features", "k-skill-proxy.md"));

const proxyReadme = read(path.join("packages", "k-skill-proxy", "README.md"));

assert.match(skill, /^name: korea-weather$/m);

assert.match(skill, /^description: .*날씨.*기상청.*프록시.*$/m);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /\/v1\/korea-weather\/forecast/);

assert.match(doc, /기상청.*단기예보|단기예보.*기상청/);

assert.match(doc, /사용자가 .*API key.*직접.*필요(가|는)? 없다|개인 API key 없이/i);

assert.match(doc, /nx|ny|위도|경도/u);

assert.match(doc, /TMP|SKY|PTY|POP/);

assert.match(doc, /KSKILL_PROXY_BASE_URL|k-skill-proxy\.nomadamas\.org/);

assert.match(doc, /비우면 기본 hosted `https:\/\/k-skill-proxy\.nomadamas\.org`|없으면 기본 hosted proxy/i);

assert.doesNotMatch(doc, /필수: self-host|반드시 명시|먼저 확보|public hosted route rollout 전/);

assert.doesNotMatch(doc, /KMA_OPEN_API_KEY=.*사용자/);

}

assert.match(proxyDoc, /GET \/v1\/korea-weather\/forecast/);

assert.match(proxyDoc, /KMA_OPEN_API_KEY/);

assert.match(proxyReadme, /GET \/v1\/korea-weather\/forecast/);

assert.match(proxyReadme, /KMA_OPEN_API_KEY/);

});

test("hosted proxy docs keep self-host overrides inactive and demonstrate resolver fallback", () => {

const setup = read(path.join("docs", "setup.md"));

const security = read(path.join("docs", "security-and-secrets.md"));

const setupSkill = read(path.join("k-skill-setup", "SKILL.md"));

const secretsExample = read(path.join("examples", "secrets.env.example"));

const subwaySkill = read(path.join("seoul-subway-arrival", "SKILL.md"));

const weatherSkill = read(path.join("korea-weather", "SKILL.md"));

const subwayFeatureDoc = read(path.join("docs", "features", "seoul-subway-arrival.md"));

const weatherFeatureDoc = read(path.join("docs", "features", "korea-weather.md"));

const proxyDoc = read(path.join("docs", "features", "k-skill-proxy.md"));

for (const doc of [setup, security, setupSkill, secretsExample]) {

assert.doesNotMatch(doc, /^KSKILL_PROXY_BASE_URL=https:\/\/your-proxy\.example\.com$/m);

}

for (const doc of [setup, security, setupSkill, secretsExample]) {

assert.match(

doc,

/^(#\s*)?KSKILL_PROXY_BASE_URL=$|^#\s*KSKILL_PROXY_BASE_URL=https:\/\/your-proxy\.example\.com$/m,

);

}

for (const doc of [subwaySkill, weatherSkill, subwayFeatureDoc, weatherFeatureDoc]) {

assert.match(doc, /BASE="\$\{KSKILL_PROXY_BASE_URL:-https:\/\/k-skill-proxy\.nomadamas\.org\}"/);

assert.match(doc, /curl -fsS --get "\$\{BASE\}/);

assert.doesNotMatch(doc, /curl -fsS --get 'https:\/\/k-skill-proxy\.nomadamas\.org/);

}

assert.match(proxyDoc, /BASE="\$\{KSKILL_PROXY_BASE_URL:-https:\/\/k-skill-proxy\.nomadamas\.org\}"/);

for (const endpoint of ["seoul-subway/arrival", "korea-weather/forecast"]) {

assert.match(proxyDoc, new RegExp(`curl -fsS --get "\\$\\{BASE\\}/v1/${endpoint}"`));

assert.doesNotMatch(proxyDoc, new RegExp(`curl -fsS --get 'http://127\\.0\\.0\\.1:4020/v1/${endpoint}'`));

}

});

test("kakaotalk-mac skill documents safe macOS kakaocli usage", () => {

const skillPath = path.join(repoRoot, "kakaotalk-mac", "SKILL.md");

const helperPath = path.join(repoRoot, "scripts", "kakaotalk_mac.py");

const featureDoc = read(path.join("docs", "features", "kakaotalk-mac.md"));

assert.ok(fs.existsSync(skillPath), "expected kakaotalk-mac/SKILL.md to exist");

assert.ok(fs.existsSync(helperPath), "expected scripts/kakaotalk_mac.py to exist");

const skill = read(path.join("kakaotalk-mac", "SKILL.md"));

assert.match(skill, /^name: kakaotalk-mac$/m);

assert.match(skill, /kakaocli/);

assert.match(skill, /macOS/i);

assert.match(skill, /KakaoTalk/i);

assert.match(skill, /Full Disk Access/i);

assert.match(skill, /Accessibility/i);

assert.match(skill, /--me/);

assert.match(skill, /confirm before sending/i);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /python3 scripts\/kakaotalk_mac\.py auth/);

assert.match(doc, /python3 scripts\/kakaotalk_mac\.py chats --limit 10 --json/);

assert.match(doc, /python3 scripts\/kakaotalk_mac\.py messages --chat/);

assert.match(doc, /python3 scripts\/kakaotalk_mac\.py search/);

assert.match(doc, /user_id 자동 감지 실패|SHA-512|DESIGNATEDFRIENDSREVISION/i);

assert.match(doc, /cache|캐시/);

assert.match(doc, /read-only|읽기 전용/i);

assert.doesNotMatch(doc, /`query`/);

}

});

test("repository docs advertise the KTX booking skill as supported", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "ktx-booking.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/ktx-booking.md to exist");

assert.match(readme, /\| KTX 예매 \|/);

assert.match(readme, /\[KTX 예매 가이드\]\(docs\/features\/ktx-booking\.md\)/);

assert.doesNotMatch(readme, /KTX 예매는 현재 작동하지 않습니다/);

assert.doesNotMatch(readme, /KTX 예매 \| 현재 작동하지 않음/);

assert.match(install, /--skill ktx-booking/);

});

test("ktx-booking docs document the helper-based live Korail workflow", () => {

const skillPath = path.join(repoRoot, "ktx-booking", "SKILL.md");

const helperPath = path.join(repoRoot, "scripts", "ktx_booking.py");

assert.ok(fs.existsSync(skillPath), "expected ktx-booking/SKILL.md to exist");

assert.ok(fs.existsSync(helperPath), "expected scripts/ktx_booking.py to exist");

const skill = read(path.join("ktx-booking", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "ktx-booking.md"));

const helper = read(path.join("scripts", "ktx_booking.py"));

assert.match(skill, /^name: ktx-booking$/m);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /python3 scripts\/ktx_booking\.py search/);

assert.match(doc, /python3 scripts\/ktx_booking\.py reserve/);

assert.match(doc, /python3 scripts\/ktx_booking\.py reservations/);

assert.match(doc, /python3 scripts\/ktx_booking\.py cancel/);

assert.match(doc, /train_id/);

assert.match(doc, /--train-id/);

assert.match(doc, /--include-no-seats/);

assert.match(doc, /--include-waiting-list/);

assert.match(doc, /--try-waiting/);

assert.match(doc, /credential resolution order|KSKILL_KTX_ID/);

assert.match(doc, /anti-bot|Dynapath|x-dynapath-m-token/i);

assert.match(doc, /결제(까지)?는 자동화하지 않는다|결제는 제외/);

assert.doesNotMatch(doc, /예약 시 선택할 `--train-index`/);

}

assert.match(helper, /x-dynapath-m-token/);

assert.match(helper, /250601002/);

assert.match(helper, /def build_parser/);

assert.match(helper, /train_id/);

});

test("ktx-booking helper python regression tests pass", () => {

const result = childProcess.spawnSync(

"python3",

["-m", "unittest", "discover", "-s", "scripts", "-p", "test_ktx_booking.py"],

{

cwd: repoRoot,

encoding: "utf8",

env: { ...process.env, PYTHONNOUSERSITE: "1" },

},

);

assert.equal(

result.status,

0,

`expected python KTX helper regression tests to pass\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,

);

});

test("repository docs advertise the geeknews-search skill across the documented surfaces", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "geeknews-search.md");

const skillPath = path.join(repoRoot, "geeknews-search", "SKILL.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/geeknews-search.md to exist");

assert.ok(fs.existsSync(skillPath), "expected geeknews-search/SKILL.md to exist");

assert.match(readme, /\| 긱뉴스 조회 \|/);

assert.match(readme, /\[긱뉴스 조회 가이드\]\(docs\/features\/geeknews-search\.md\)/);

assert.match(install, /--skill geeknews-search/);

});

test("geeknews-search docs lock the RSS-first list-search-detail workflow", () => {

const skill = read(path.join("geeknews-search", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "geeknews-search.md"));

for (const doc of [skill, featureDoc]) {

assert.match(doc, /feeds\.feedburner\.com\/geeknews-feed/);

assert.match(doc, /python3 scripts\/geeknews_search\.py list/);

assert.match(doc, /python3 scripts\/geeknews_search\.py search/);

assert.match(doc, /python3 scripts\/geeknews_search\.py detail/);

assert.match(doc, /RSS-first|RSS first|RSS 피드/);

assert.match(doc, /read-only|읽기 전용/);

}

});

test("repository docs advertise the subway-lost-property skill across the documented surfaces", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "subway-lost-property.md");

const skillPath = path.join(repoRoot, "subway-lost-property", "SKILL.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/subway-lost-property.md to exist");

assert.ok(fs.existsSync(skillPath), "expected subway-lost-property/SKILL.md to exist");

assert.match(readme, /\| 지하철 분실물 조회 \|/);

assert.match(readme, /\[지하철 분실물 조회 가이드\]\(docs\/features\/subway-lost-property\.md\)/);

assert.match(install, /--skill subway-lost-property/);

});

test("subway-lost-property docs lock the official LOST112 guidance flow", () => {

const skill = read(path.join("subway-lost-property", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "subway-lost-property.md"));

for (const doc of [skill, featureDoc]) {

assert.match(doc, /LOST112/);

assert.match(doc, /seoulmetro\.co\.kr\/kr\/page\.do\?menuIdx=541/);

assert.match(doc, /python3 scripts\/subway_lost_property\.py/);

assert.match(doc, /SITE=V/);

assert.match(doc, /안내형|하이브리드/);

}

});

test("repository docs advertise the zipcode-search skill across the documented surfaces", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const roadmap = read(path.join("docs", "roadmap.md"));

const sources = read(path.join("docs", "sources.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "zipcode-search.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/zipcode-search.md to exist");

assert.match(readme, /\| 우편번호 검색 \|/);

assert.match(readme, /\[우편번호 검색 가이드\]\(docs\/features\/zipcode-search\.md\)/);

assert.match(install, /--skill zipcode-search/);

assert.match(roadmap, /우편번호 검색/);

assert.match(sources, /우체국 도로명주소 검색: https:\/\/parcel\.epost\.go\.kr\/parcel\/comm\/zipcode\/comm_newzipcd_list\.jsp/);

});

test("zipcode-search docs lock the official postcode plus English-address extraction flow", () => {

const skillPath = path.join(repoRoot, "zipcode-search", "SKILL.md");

assert.ok(fs.existsSync(skillPath), "expected zipcode-search/SKILL.md to exist");

const skill = read(path.join("zipcode-search", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "zipcode-search.md"));

const readme = read("README.md");

const sources = read(path.join("docs", "sources.md"));

assert.match(skill, /^name: zipcode-search$/m);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /https:\/\/www\.epost\.kr\/search\.RetrieveIntegrationNewZipCdList\.comm/);

assert.match(doc, /viewDetail/);

assert.match(doc, /English\/집배코드/);

assert.match(doc, /Rep\. of KOREA/);

assert.match(doc, /curl --http1\.1 --tls-max 1\.2/);

assert.match(doc, /--max-time/);

assert.match(doc, /"--retry",\s+"3"/);

assert.match(doc, /--retry-all-errors/);

assert.match(doc, /"--retry-delay",\s+"1"/);

assert.match(doc, /영문 주소|영문주소/);

assert.match(doc, /python3 scripts\/zipcode_search\.py/);

assert.match(doc, /\.\/scripts\/zipcode_search\.py/);

assert.match(doc, /mktemp|임시 파일/);

assert.doesNotMatch(doc, /urllib\.request/);

}

assert.match(readme, /우편번호 \+ 공식 영문주소 조회/);

assert.match(sources, /우체국 통합 우편번호\/영문주소 검색: https:\/\/www\.epost\.kr\/search\.RetrieveIntegrationNewZipCdList\.comm/);

assert.match(skill, /검색 결과가 없으면/i);

assert.doesNotMatch(skill, /timeout\s*=/);

assert.doesNotMatch(featureDoc, /timeout\s*=/);

assert.match(featureDoc, /프로토콜\/클라이언트 제약/i);

});

test("repository docs advertise the delivery-tracking skill across the documented surfaces", () => {

const readme = read("README.md");

const install = read(path.join("docs", "install.md"));

const roadmap = read(path.join("docs", "roadmap.md"));

const sources = read(path.join("docs", "sources.md"));

const featureDocPath = path.join(repoRoot, "docs", "features", "delivery-tracking.md");

assert.ok(fs.existsSync(featureDocPath), "expected docs/features/delivery-tracking.md to exist");

assert.match(readme, /\| 택배 배송조회 \|/);

assert.match(readme, /\[택배 배송조회 가이드\]\(docs\/features\/delivery-tracking\.md\)/);

assert.match(install, /--skill delivery-tracking/);

assert.match(roadmap, /택배 배송조회 스킬 출시/);

assert.match(sources, /CJ대한통운 배송조회: https:\/\/www\.cjlogistics\.com\/ko\/tool\/parcel\/tracking/);

assert.match(sources, /우체국 배송조회: https:\/\/service\.epost\.go\.kr\/trace\.RetrieveRegiPrclDeliv\.postal\?sid1=/);

});

test("delivery-tracking skill documents official CJ and ePost flows with extension guidance", () => {

const skillPath = path.join(repoRoot, "delivery-tracking", "SKILL.md");

assert.ok(fs.existsSync(skillPath), "expected delivery-tracking/SKILL.md to exist");

const skill = read(path.join("delivery-tracking", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "delivery-tracking.md"));

assert.match(skill, /^name: delivery-tracking$/m);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /https:\/\/www\.cjlogistics\.com\/ko\/tool\/parcel\/tracking/);

assert.match(doc, /tracking-detail/);

assert.match(doc, /paramInvcNo/);

assert.match(doc, /_csrf/);

assert.match(doc, /10자리 또는 12자리/);

assert.match(doc, /https:\/\/service\.epost\.go\.kr\/trace\.RetrieveRegiPrclDeliv\.postal\?sid1=/);

assert.match(doc, /trace\.RetrieveDomRigiTraceList\.comm/);

assert.match(doc, /sid1/);

assert.match(doc, /13자리/);

assert.match(doc, /curl --http1\.1 --tls-max 1\.2/);

assert.match(doc, /carrier adapter/i);

assert.match(doc, /다른 택배사/);

}

assert.match(skill, /1234567890/);

assert.match(skill, /1234567890123/);

assert.match(skill, /python3/);

assert.match(featureDoc, /JSON/);

assert.match(featureDoc, /HTML/);

});

test("delivery-tracking published examples lock a shared normalized non-PII schema", () => {

const skill = read(path.join("delivery-tracking", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "delivery-tracking.md"));

const expectedTopLevelEntries = {

cj: [

["carrier", '"cj"'],

["invoice", 'payload["parcelDetailResultMap"]["paramInvcNo"]'],

["status_code", 'latest.get("crgSt")'],

["status", 'status_map.get(latest.get("crgSt"), latest.get("scanNm") or "알수없음")'],

["timestamp", 'latest.get("dTime")'],

["location", 'latest.get("regBranNm")'],

["event_count", "len(events)"],

["recent_events", "normalized_events[-min(3, len(normalized_events)):]"],

],

epost: [

["carrier", '"epost"'],

["invoice", 'clean(summary.group("tracking"))'],

["status", 'clean(summary.group("result"))'],

["timestamp", 'latest_event["timestamp"] if latest_event else None'],

["location", 'latest_event["location"] if latest_event else None'],

["event_count", "len(normalized_events)"],

["recent_events", "normalized_events[-min(3, len(normalized_events)):]"],

],

};

const expectedRecentEventEntries = {

cj: [

["timestamp", 'event.get("dTime")'],

["location", 'event.get("regBranNm")'],

["status_code", 'event.get("crgSt")'],

["status", 'status_map.get(event.get("crgSt"), event.get("scanNm") or "알수없음")'],

],

epost: [

["timestamp", 'f"{day} {time_}"'],

["location", "clean_location(location)"],

["status", "clean(status)"],

],

};

assert.doesNotMatch(skill, /"message":\s*latest\.get\("crgNm"\)/);

assert.doesNotMatch(

featureDoc,

/print\(json\.dumps\(payload\["parcelDetailResultMap"\]\["resultList"\]\[-1\],\s*ensure_ascii=False,\s*indent=2\)\)/,

);

for (const doc of [skill, featureDoc]) {

assert.match(doc, /공통 포맷/);

assert.match(doc, /공통 결과 스키마/);

assert.match(doc, /최근 이벤트/);

assert.match(doc, /`carrier`/);

assert.match(doc, /`invoice`/);

assert.match(doc, /`status`/);

assert.match(doc, /`timestamp`/);

assert.match(doc, /`location`/);

assert.match(doc, /`event_count`/);

assert.match(doc, /`recent_events`/);

assert.match(doc, /최근 최대 3개 이벤트/);

assert.doesNotMatch(doc, /최근 3~5개 이벤트/);

assert.match(doc, /"invoice":\s*payload\["parcelDetailResultMap"\]\["paramInvcNo"\]/);

assert.match(doc, /"status_code":\s*latest\.get\("crgSt"\)/);

assert.match(doc, /"status":\s*status_map\.get\(latest\.get\("crgSt"\),/);

assert.match(doc, /"timestamp":\s*latest\.get\("dTime"\)/);

assert.match(doc, /"location":\s*latest\.get\("regBranNm"\)/);

assert.match(doc, /"event_count":\s*len\(events\)/);

assert.match(doc, /"recent_events":/);

assert.match(doc, /"invoice":\s*clean\(summary\.group/);

assert.match(doc, /"timestamp":\s*latest_event\["timestamp"\] if latest_event else None/);

assert.match(doc, /"location":\s*latest_event\["location"\] if latest_event else None/);

assert.match(doc, /"event_count":\s*len\(normalized_events\)/);

assert.match(doc, /"recent_events":\s*normalized_events\[-min\(3,\s*len\(normalized_events\)\):\]/);

assert.match(doc, /def clean_location\(raw: str\) -> str:/);

assert.match(doc, /TEL/);

assert.match(doc, /\\d\{2,4\}/);

assert.match(doc, /"location":\s*clean_location\(location\)/);

assert.doesNotMatch(doc, /"tracking_no":/);

assert.doesNotMatch(doc, /"latest_event_date":/);

assert.doesNotMatch(doc, /"latest_event_time":/);

assert.doesNotMatch(doc, /"latest_event_location":/);

assert.doesNotMatch(doc, /"delivered_to":/);

assert.doesNotMatch(doc, /"delivery_result":/);

}

for (const [label, doc] of [

["skill doc", skill],

["feature doc", featureDoc],

]) {

assert.deepEqual(

extractQuotedEntries(findPrintedObjectBlock(doc, "cj"), 4),

expectedTopLevelEntries.cj,

`${label} CJ example must keep the exact normalized top-level mapping`,

);

assert.deepEqual(

extractQuotedEntries(findPrintedObjectBlock(doc, "epost"), 4),

expectedTopLevelEntries.epost,

`${label} ePost example must keep the exact normalized top-level mapping`,

);

assert.deepEqual(

extractQuotedEntries(

findRecentEventsBlock(doc, "cj"),

8,

),

expectedRecentEventEntries.cj,

`${label} CJ recent_events entries must keep the exact normalized mapping`,

);

assert.deepEqual(

extractQuotedEntries(

findRecentEventsBlock(doc, "epost"),

8,

),

expectedRecentEventEntries.epost,

`${label} ePost recent_events entries must keep the exact normalized mapping`,

);

}

assert.doesNotMatch(skill, /"message":\s*latest\.get\("crgNm"\)/);

assert.doesNotMatch(featureDoc, /print\(\{\s*"tracking_no"/);

});

test("delivery-tracking docs publish aligned sample normalized outputs for both carriers", () => {

const expectedSamples = readJson(

path.join("scripts", "fixtures", "delivery-tracking-public-samples.json"),

);

const skill = read(path.join("delivery-tracking", "SKILL.md"));

const featureDoc = read(path.join("docs", "features", "delivery-tracking.md"));

const cjSkillOutput = findJsonFenceAfterLabel(skill, "CJ 공개 출력 예시");

const cjFeatureOutput = findJsonFenceAfterLabel(featureDoc, "CJ 공개 출력 예시");

const epostSkillOutput = findJsonFenceAfterLabel(skill, "우체국 공개 출력 예시");

const epostFeatureOutput = findJsonFenceAfterLabel(featureDoc, "우체국 공개 출력 예시");

for (const [docLabel, doc] of [

["skill doc", skill],

["feature doc", featureDoc],

]) {

for (const [carrier, label] of [

["cj", "CJ 공개 출력 예시"],

["epost", "우체국 공개 출력 예시"],

]) {

assert.equal(

findJsonFenceTextAfterLabel(doc, label),

JSON.stringify(expectedSamples[carrier], null, 2),

`${docLabel} ${carrier} sample JSON block must stay byte-for-byte aligned with the checked-in public fixture`,