@kaydash9999/banker-plugins 0.27.0 → 0.28.0

package/skills/wbs-gen/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: wbs-gen
+description: "WBS(작업 분해 구조)를 간트 차트 한 장으로 만들어 XLSX 와 HTML 로 냄. 막대는 셀 채움(조건부 서식 없음), 영업일 열만, 주 단위 머리글, 파트별 색, 마름모 마일스톤, 빨간 게이트 선, 범례와 메모. 공휴일은 인터넷에 닿으면 Google 공개 달력에서 받아 확인을 받고, 망분리 환경이면 사용자에게 'M/D, M/D' 로 받음. 순수 Node 도우미라 설치와 내려받기 없이 오프라인에서 동작. 'wbs-gen'/'WBS 간트'/'간트 차트 만들어'/'일정표 xlsx'/'WBS 일정표' 시 사용."
+argument-hint: "[--xlsx] [--html] [--dir <폴더>] [--plan <plan.json>]"
+---
+
+# wbs-gen: WBS 간트 차트(XLSX, HTML)
+
+WBS 와 일정을 받아 간트 차트 한 장을 XLSX 와 HTML 로 만든다. 답변은 한글.
+모양은 엑셀로 직접 그린 한 장짜리 간트와 같다: 1행 제목, 2~3행 머리글(8열 + 주와 날짜), 틀 고정 8열 3행, A3 가로 한 장 너비 인쇄.
+
+## 원칙
+
+- **설치와 내려받기가 없다.** 도우미는 Node 표준 모듈만 쓴다(XLSX 도 직접 씀). 인터넷을 쓰는 곳은 `holidays` 하나이고, 닿지 않으면 사용자에게 묻는다.
+- **막대는 셀 채움이다.** 조건부 서식과 수식을 쓰지 않아 어느 뷰어에서나 같게 보인다. 일정이 바뀌면 계획 파일을 고치고 다시 만든다.
+- **영업일은 도우미가 센다.** 토, 일과 공휴일을 뺀 날만 날짜 열이 되고, 일수 칸도 그 수다. 사람이 적은 일수를 옮기지 않는다.
+- **WBS 와 일정은 나누어 적는다.** WBS 번호와 작업 이름은 산출물이고, 시작, 종료, 선행은 일정이다. 제약사항 같은 메모 행은 WBS 번호 체계 밖 묶음(예: `C`, `P`)으로 둔다.
+- 글꼴은 한글이 Noto Sans KR, 그 밖(영문, 숫자, 기호)이 Noto Sans 다. XLSX 는 한 칸 안에서 글자 종류마다 글꼴을 나눠 적고, HTML 은 `"Noto Sans","Noto Sans KR"` 순서로 지정한다. 글꼴 파일은 넣지 않으므로 보는 PC 에 두 글꼴이 있어야 그대로 보인다.
+- 있는 파일을 덮어쓰지 않는다. 같은 이름이 있으면 묻고, 허락을 받은 뒤에만 `--force` 를 준다.
+- 계획 파일과 출력에 비밀값을 넣지 않는다.
+
+## 런타임
+
+| 항목 | Claude Code | Codex |
+|---|---|---|
+| 스킬 디렉터리 `<S>` | 스킬 맨 위 "Base directory for this skill:" 경로 | 이 SKILL.md 의 폴더. npm 설치는 `~/.codex/skills/banker-wbs-gen/`, 플러그인 설치는 `~/.codex/plugins/cache/<마켓플레이스>/banker/<판>/skills/wbs-gen/`. 절대경로로 씀 |
+| 부르기 | `/banker:wbs-gen` | `$banker-wbs-gen`, 플러그인 `$banker:wbs-gen` |
+| 확인 질문 | `AskUserQuestion` | `request_user_input`. 없으면 번호 붙인 평문 선택지 |
+| 샌드박스 | 없음 | `holidays` 는 네트워크를 쓰므로 `sandbox_permissions: "require_escalated"` 로 승인을 청함. 승인이 없거나 거절되면 망분리와 같이 사용자에게 공휴일을 받음. 나머지 명령은 작업 폴더 안에서만 읽고 써서 승인이 필요 없음 |
+| 셸 | bash | Windows 는 PowerShell. 도우미는 Node 라 두 셸에서 같다 |
+
+물을 수 없는 실행(`codex exec`, 다른 스킬의 연쇄)에서는 공휴일을 묻지 못한다. `holidays` 가 3 으로 끝나면 공휴일 없이 만들고 보고에 `공휴일 미확인` 을 적는다.
+
+## 인자
+
+| 인자 | 뜻 |
+|---|---|
+| `--xlsx`, `--html` | 낼 형식. 둘 다 없으면 둘 다 냄 |
+| `--dir <폴더>` | 출력 폴더. 없으면 지금 작업 폴더. 도우미의 `--out <파일>` 과 다름 |
+| `--plan <plan.json>` | 이미 있는 계획 파일을 씀. 없으면 대화와 자료로 새로 씀 |
+
+## 도우미
+
+`G="<S>/scripts/wbs-gen.mjs"`. 머리 주석이 전체 사용법이다.
+
+| 명령 | 하는 일 | 종료 코드 |
+|---|---|---|
+| `node "$G" example` | 예시 계획(JSON)을 냄. 계획 파일의 틀로 씀 | 0 |
+| `node "$G" holidays --from <YYYY-MM-DD> --to <YYYY-MM-DD>` | 기간 안 한국 공휴일을 `MM/DD 이름` 줄과 마지막 줄 `HOLIDAYS MM/DD, ...` 로 냄. 기간이 두 해에 걸치면 `YYYY-MM-DD` 로 냄. 기념일(어버이날 등)은 빼고 공휴일만 | 0, 인자나 `--ics` 파일 오류 2, 닿지 못하거나 공휴일을 읽지 못하면 3 |
+| `node "$G" check --plan <plan.json>` | 계획을 검사하고 `OK 영업일 N ...` 한 줄을 냄 | 0, 계획 오류 1 |
+| `node "$G" build --plan <plan.json> --out <파일.xlsx> --out <파일.html>` | 파일을 만듦. 쓰기 전에 모든 `--out` 을 검사하고, 하나라도 이미 있으면 `--force` 없이는 아무것도 쓰지 않고 2 로 끝남 | 0, 계획 오류 1, 사용법과 파일 오류 2 |
+
+- `--holidays "8/17, 10/5"` 는 계획의 `holidays` 를 그 값으로 바꾼다. `check`, `build` 둘 다 받는다.
+- `holidays --ics <파일>` 은 저장해 둔 달력 파일(.ics)을 읽는다. 사내망에서 다른 경로로 받은 달력을 쓸 때다. `--url <https 주소>` 는 같은 꼴의 다른 달력 주소, `--timeout <초>` 는 1~60 정수(기본 10)다.
+
+## 계획 파일(plan.json)
+
+`node "$G" example` 이 낸 틀을 고쳐 쓴다. 날짜는 `YYYY-MM-DD` 나 `M/D` 이고, `M/D` 는 프로젝트 기간 안의 해로 읽는다(12/20~01/15 이면 `1/5` 는 다음 해).
+기간이 1년을 넘어 같은 `M/D` 가 두 해에 들면 오류다. 그때는 `YYYY-MM-DD` 로 적는다. 기간은 5년까지이고, 그보다 길면 단계나 해로 나누어 만든다.
+
+| 칸 | 뜻 |
+|---|---|
+| `title`, `subtitle` | 1행 제목과 메모. 제목 줄에 기간, 영업일 수가 함께 들어감 |
+| `start`, `end` | 기간. `YYYY-MM-DD` |
+| `holidays` | 공휴일. `"8/17, 10/5"` 같은 글이나 배열. `"없음"` 은 없음 |
+| `gates` | `[{ "date", "label" }]`. 그 날짜 열 왼쪽에 빨간 수직선 |
+| `parts` | `{ "<id>": { "name", "light", "dark", "legend" } }`. `light` 는 묶음 행 바탕, `dark` 는 막대. 색은 6자리 16진수. `legend: false` 면 범례에서 뺌 |
+| `bars` | 우선순위별 막대 색. 예: `{ "선택": "FAD7A0", "준비": "D5DBDB", "마무리": "34495E" }`. 파트 색보다 앞섬 |
+| `rows` | 행 목록. 아래 표 |
+| `legend` | 범례에 더할 항목 `[{ "color", "label", "dotted" }]`. 파트 색, ◆, 게이트 선은 자동으로 들어감 |
+| `notes` | 아래 메모 `[{ "heading", "lines" }]`. 예: `[우선순위]`, `[미확정]`, `[가정·변경]` |
+| `sheet` | 시트 이름. 없으면 `WBS 간트`. Excel 이 막는 글자(`[]:*?/\`), 앞뒤 `'`, `History` 는 바꿈 |
+| `milestoneLegend`, `milestoneLabel` | 범례의 ◆ 항목. `false` 면 뺌, 이름 기본값은 `마일스톤` |
+
+`rows` 의 `kind`
+
+| kind | 쓰는 칸 | 그림 |
+|---|---|---|
+| `group` | `wbs`, `task`, `owner`, `part` | 행 전체를 파트의 연한 색으로 칠함 |
+| `task` | `wbs`, `task`, `owner`, `priority`, `pending`, `start`, `end`, `part`, `bar` | 시작부터 종료까지 막대. 일수 칸은 그 사이 영업일 수 |
+| `constraint` | `task` 칸들과 `date`(또는 `start`, `end`) | 종료 날짜에 ◆ 와 점선 테두리. 개발이 아닌 외부 선행 |
+| `milestone` | `wbs`, `task`, `date` | 그 날짜에 ◆ |
+
+시작, 종료, 마일스톤, 게이트 날짜가 주말이나 공휴일이면 오류다. 기간 중간의 공휴일은 그냥 열에서 빠진다.
+
+## 절차
+
+### 1. 자료 모으기
+- 사용자가 준 WBS(표, 문서, 기존 엑셀, 말로 한 설명)를 읽는다. 기존 xlsx 는 읽기만 하고 고치지 않는다.
+- 아래가 없으면 한 번에 묻는다: 기간(시작, 종료), 작업 목록과 담당, 각 작업의 시작과 종료, 마일스톤, 게이트. 파트 구분과 색은 묻지 않고 예시 색을 쓴다.
+- 날짜가 정해지지 않은 작업은 `pending` 칸에 기다리는 것을 적고, 가정한 날짜는 `notes` 의 `[가정·변경]` 에 적는다.
+
+### 2. 공휴일
+1. `node "$G" holidays --from <start> --to <end>` 를 돈다.
+2. 종료 코드가 0 이면 나온 목록을 보여 주고 확인 질문으로 묻는다: 이대로, 더하거나 빼기(그다음 `M/D, M/D` 를 받음).
+3. 종료 코드가 3 이면(인터넷에 닿지 못함, 망분리, 프록시, Codex 승인 거절) 사용자에게 기간 안 공휴일을 `M/D, M/D` 로 받는다. 없으면 `없음`.
+4. 확정한 값을 계획의 `holidays` 에 적는다. 회사 휴무일처럼 공휴일이 아닌 쉬는 날도 여기에 더한다.
+
+### 3. 계획 파일 쓰기
+- 출력 폴더에 `<이름>-wbs.json` 으로 쓴다. 이름은 제목에서 짧게 만든다. 같은 이름이 있으면 묻는다.
+- `node "$G" check --plan <파일>` 이 0 이 될 때까지 고친다. 오류 줄은 어느 행의 무슨 칸인지 알려 준다. 경고(기간 밖 공휴일)는 보고에만 적는다.
+
+### 4. 만들기
+- `node "$G" build --plan <파일> --out <이름>-wbs.xlsx --out <이름>-wbs.html` 을 돈다. 형식 인자를 받았으면 그 형식만 준다.
+- 종료 코드 2 에 `--force` 안내가 나오면 덮어쓸지 묻고, 허락을 받은 뒤에만 `--force` 를 더해 다시 돈다.
+
+### 5. 확인
+- `build` 출력의 `OK 영업일 N (시작 ~ 끝), 주 W, 행 R, 작업 T, ◆ M, 게이트 G` 를 계획과 대조한다. 영업일 수는 기간과 공휴일로 맞는지, 작업 수와 ◆ 수가 계획 행 수와 맞는지 본다.
+- 브라우저를 쓸 수 있으면 HTML 을 열어 한 번 본다. 쓸 수 없으면 보았다고 적지 않는다.
+
+## 보고
+
+- 만든 파일의 절대경로
+- 기간, 영업일 수, 뺀 공휴일(`MM/DD 이름`, 사용자가 입력했으면 입력값)
+- 행 수, 작업 수, 마일스톤 수, 게이트
+- 가정한 날짜와 확인하지 못한 것(`공휴일 미확인`, 브라우저로 보지 않음 등)
+- 다음 행동이 있으면 마지막 줄에. 예: "일정이 바뀌면 `<이름>-wbs.json` 을 고치고 다시 부르십시오."
+
+## 함정
+
+- `holidays` 가 0 으로 끝나도 목록을 그대로 믿지 않는다. 임시공휴일이 늦게 들어갈 수 있으니 늘 사용자 확인을 받는다.
+- 토요일 공휴일(예: 08/15)도 목록에 나온다. 원래 날짜 열에 없으므로 그대로 두어도 된다.
+- 막대를 셀 채움으로 그렸으므로 엑셀에서 날짜 칸만 고치면 막대가 따라가지 않는다. 일정은 계획 파일에서 고친다.
+- 보는 PC 에 Noto Sans KR, Noto Sans 가 없으면 다른 글꼴로 보인다. 글꼴 없이 한글을 그리지 못하는 뷰어(글꼴이 없는 macOS 의 LibreOffice 등)는 한글을 비워 둘 수 있으나 파일에는 글이 들어 있다.
+- ◆ 는 Noto Sans 에 없어서 Noto Sans KR 로 적는다.
+- 주 번호(W1, W2)는 달력 주를 센다. 영업일이 하나도 없는 주는 열이 없고 번호만 건너뛴다.
+- 게이트가 주 중간이면 병합된 주 머리글 칸에는 빨간 선이 보이지 않는다. 날짜 머리글과 본문에는 보인다.

package/skills/wbs-gen/assets/example.json

@@ -0,0 +1,58 @@
+{
+  "title": "샘플 대시보드 2차 개발 WBS 간트",
+  "subtitle": "범위 미정, 요건과 UI 확정(08/03) 뒤 단계적 상세화",
+  "start": "2026-07-22",
+  "end": "2026-08-28",
+  "holidays": "8/17",
+  "sheet": "WBS 간트",
+  "gates": [{ "date": "08/03", "label": "요건·UI 확정 게이트" }],
+  "parts": {
+    "plan": { "name": "기획", "light": "D6EAF8", "dark": "5DADE2" },
+    "data": { "name": "데이터 리서치", "light": "D4EFDF", "dark": "27AE60" },
+    "eng": { "name": "데이터 엔지니어링", "light": "D4E6F1", "dark": "2E86C1" },
+    "be": { "name": "백엔드", "light": "FAE5D3", "dark": "E67E22" },
+    "fe": { "name": "프론트엔드", "light": "FADBD8", "dark": "E74C3C" },
+    "ai": { "name": "AI 에이전트", "light": "E8DAEF", "dark": "9B59B6" },
+    "ops": { "name": "공통", "light": "D6DBDF", "dark": "34495E", "legend": false }
+  },
+  "bars": { "선택": "FAD7A0", "준비": "D5DBDB", "마무리": "34495E" },
+  "rows": [
+    { "kind": "group", "wbs": "C", "task": "제약사항", "owner": "타 부서", "part": "ops" },
+    { "kind": "constraint", "wbs": "C-1", "task": "기획 담당자 확정", "owner": "기획부", "priority": "선행", "pending": "미해소 시 요건 확정 불가", "date": "07/24" },
+    { "kind": "constraint", "wbs": "C-2", "task": "UI/UX 디자인 확정", "owner": "디자인팀", "priority": "선행", "pending": "프론트 재디자인 선행", "date": "08/03" },
+    { "kind": "constraint", "wbs": "C-3", "task": "데이터 원천 확보", "owner": "영업부", "priority": "선행", "pending": "실적 지표 개발 선행", "date": "08/07" },
+    { "kind": "group", "wbs": "P", "task": "병행 트랙", "owner": "전 파트", "part": "ops" },
+    { "kind": "task", "wbs": "P-1", "task": "기준선 대비 변경 추적", "owner": "전 파트", "priority": "준비", "pending": "요건 비종속", "start": "07/22", "end": "08/03" },
+    { "kind": "task", "wbs": "P-2", "task": "시험 도구 준비", "owner": "전 파트", "priority": "준비", "pending": "요건 비종속", "start": "07/28", "end": "08/07" },
+    { "kind": "group", "wbs": "1", "task": "기획", "owner": "기획부", "part": "plan" },
+    { "kind": "task", "wbs": "1.1", "task": "요건·UI 확정", "owner": "홍길동", "priority": "필수", "pending": "화면 항목과 진입점 결정", "start": "07/27", "end": "08/03", "part": "plan" },
+    { "kind": "group", "wbs": "2", "task": "데이터 리서치", "owner": "데이터팀", "part": "data" },
+    { "kind": "task", "wbs": "2.1", "task": "항목별 데이터 추출 매핑", "owner": "김철수", "priority": "확정예정", "pending": "항목 확정", "start": "08/04", "end": "08/07", "part": "data" },
+    { "kind": "task", "wbs": "2.2", "task": "계열사 종합 수치", "owner": "김철수", "priority": "선택", "pending": "계열사 마트 제공", "start": "08/10", "end": "08/14", "part": "data" },
+    { "kind": "group", "wbs": "3", "task": "데이터 엔지니어링", "owner": "엔지니어링팀", "part": "eng" },
+    { "kind": "task", "wbs": "3.1", "task": "마트와 파이프라인 변경", "owner": "이영희", "priority": "확정예정", "pending": "데이터 원천 확인", "start": "08/10", "end": "08/14", "part": "eng" },
+    { "kind": "group", "wbs": "4", "task": "백엔드", "owner": "백엔드팀", "part": "be" },
+    { "kind": "task", "wbs": "4.1", "task": "API 리팩터링", "owner": "박민수", "priority": "확정예정", "pending": "화면 항목 확정", "start": "08/04", "end": "08/14", "part": "be" },
+    { "kind": "group", "wbs": "5", "task": "프론트엔드", "owner": "프론트팀", "part": "fe" },
+    { "kind": "task", "wbs": "5.1", "task": "대시보드 웹 개발", "owner": "최지우", "priority": "확정예정", "pending": "항목, 진입점, UI 확정", "start": "08/04", "end": "08/14", "part": "fe" },
+    { "kind": "group", "wbs": "6", "task": "AI 에이전트", "owner": "솔루션팀", "part": "ai" },
+    { "kind": "task", "wbs": "6.1", "task": "에이전트 변경 반영", "owner": "정하늘", "priority": "확정예정", "pending": "항목 확정", "start": "08/06", "end": "08/14", "part": "ai" },
+    { "kind": "group", "wbs": "7", "task": "배포", "owner": "전 파트", "part": "ops" },
+    { "kind": "task", "wbs": "7.1", "task": "통합 점검", "owner": "전 파트", "priority": "마무리", "pending": "-", "start": "08/18", "end": "08/21" },
+    { "kind": "task", "wbs": "7.2", "task": "운영망 배포", "owner": "전 파트", "priority": "마무리", "pending": "-", "start": "08/28", "end": "08/28" },
+    { "kind": "group", "wbs": "M", "task": "마일스톤", "part": "ops" },
+    { "kind": "milestone", "wbs": "M0", "task": "착수", "date": "07/22" },
+    { "kind": "milestone", "wbs": "M1", "task": "요건·UI 확정", "date": "08/03" },
+    { "kind": "milestone", "wbs": "M2", "task": "개발 완료", "date": "08/14" },
+    { "kind": "milestone", "wbs": "M3", "task": "서비스 오픈", "date": "08/28" }
+  ],
+  "legend": [
+    { "color": "BDC3C7", "label": "선행 항목(◆, 점선 = 개발 아님, 외부 선행)", "dotted": true },
+    { "color": "D5DBDB", "label": "준비 트랙(요건 비종속, 바로 병행)" },
+    { "color": "FAD7A0", "label": "선택 = 마감 위험 시 먼저 제외" }
+  ],
+  "notes": [
+    { "heading": "[우선순위]", "lines": ["필수, 권장, 선택(마감 위험 시 먼저 제외), 확정예정(범위 확정 뒤 지정)"] },
+    { "heading": "[가정·변경]", "lines": ["범위 전면 미정: 자리표시 항목, 요건 확정(08/03) 뒤 상세화"] }
+  ]
+}

package/skills/wbs-gen/scripts/wbs-gen.mjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * wbs-gen.mjs: the helper the wbs-gen skill runs. It turns a WBS plan (JSON) into a Gantt sheet as XLSX and/or a
+ * self-contained HTML file. Pure Node, no dependencies; only `holidays` uses the network.
+ *
+ *   node wbs-gen.mjs example                                  print a sample plan (JSON)
+ *   node wbs-gen.mjs holidays --from <YYYY-MM-DD> --to <YYYY-MM-DD> [--timeout <s>] [--ics <file> | --url <https URL>]
+ *   node wbs-gen.mjs check --plan <plan.json> [--holidays "<M/D, M/D>"]
+ *   node wbs-gen.mjs build --plan <plan.json> --out <file.xlsx|file.html>... [--holidays "<M/D, M/D>"] [--force]
+ *
+ * - holidays prints `MM/DD 이름` lines and a last line `HOLIDAYS MM/DD, MM/DD` (`HOLIDAYS 없음` when there are none)
+ *   from Google's public Korean holiday calendar (공휴일 only, not 기념일). --ics reads a saved calendar file instead;
+ *   --url reads another iCalendar URL in the same form (a mirror).
+ * - --holidays replaces the plan's holidays; it takes 'M/D' or 'YYYY-MM-DD' items, or 없음.
+ * - build checks every --out first (kind, duplicates, folder, existing files) and makes every output before it
+ *   writes any, each through a random temporary
+ *   name: a hard link (or an exclusive copy) puts it in place, so a file that appears meanwhile is never replaced;
+ *   --force renames over an existing file instead.
+ * - holidays prints MM/DD within one year and YYYY-MM-DD when --from and --to are in different years.
+ *
+ * Exit status: 0 done, 1 the plan has errors, 2 usage error or a file that could not be read or written,
+ * 3 the holiday calendar could not be reached (ask the user for the holidays instead).
+ */
+import { randomBytes } from "node:crypto";
+import { constants, copyFileSync, existsSync, linkSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, realpathSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { keyMs, mmdd } from "./wg-dates.mjs";
+import { fetchText, ICS_URL, parseIcs, publicHolidays } from "./wg-holidays.mjs";
+import { toHtml } from "./wg-html.mjs";
+import { layout } from "./wg-plan.mjs";
+import { toXlsx } from "./wg-xlsx.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const EXAMPLE = join(HERE, "..", "assets", "example.json");
+
+class Usage extends Error {}
+
+const isDir = (p) => {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+/** Reads --name value pairs; flags listed in bools take no value; --out may repeat. */
+export function parseArgs(argv, bools = ["force"]) {
+  const out = { _: [], out: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      out._.push(a);
+      continue;
+    }
+    const name = a.slice(2);
+    if (bools.includes(name)) {
+      out[name] = true;
+      continue;
+    }
+    const v = argv[++i];
+    if (v === undefined || v.startsWith("--")) throw new Usage(`--${name} 에 값이 없음`);
+    if (name === "out") out.out.push(v);
+    else out[name] = v;
+  }
+  return out;
+}
+
+function readPlan(args) {
+  if (!args.plan) throw new Usage("--plan <plan.json> 이 필요함");
+  let plan;
+  try {
+    plan = JSON.parse(readFileSync(args.plan, "utf8").replace(/^\uFEFF/, ""));
+  } catch (e) {
+    throw new Usage(`plan 을 읽지 못함: ${e.message}`);
+  }
+  if (args.holidays !== undefined && plan && typeof plan === "object") plan.holidays = args.holidays;
+  return plan;
+}
+
+function report(res) {
+  for (const w of res.warnings) process.stderr.write(`경고: ${w}\n`);
+  for (const e of res.errors) process.stderr.write(`오류: ${e}\n`);
+}
+
+function summary(m) {
+  const tasks = m.rows.filter((r) => r.kind === "task").length;
+  const marks = m.rows.reduce((n, r) => n + r.diamonds.length, 0);
+  const span = `${m.days[0].key} ~ ${m.days[m.days.length - 1].key}`;
+  return `영업일 ${m.days.length} (${span}), 주 ${m.weeks.length}, 행 ${m.rows.length}, 작업 ${tasks}, ◆ ${marks}, 게이트 ${m.gates.length}`;
+}
+
+function cmdCheck(args) {
+  const res = layout(readPlan(args));
+  report(res);
+  if (!res.model) return 1;
+  process.stdout.write(`OK ${summary(res.model)}\n`);
+  return 0;
+}
+
+/** An exclusive copy; a copy that fails after making target (disk full) removes what it made. */
+function copyExclusive(tmp, target) {
+  try {
+    copyFileSync(tmp, target, constants.COPYFILE_EXCL);
+  } catch (e) {
+    if (e.code !== "EEXIST") rmSync(target, { force: true });
+    throw e;
+  }
+}
+
+/** Puts tmp at target without replacing a file that appeared meanwhile (link, else an exclusive copy). */
+function placeNew(tmp, target) {
+  try {
+    linkSync(tmp, target);
+  } catch (e) {
+    if (e.code === "EEXIST") throw e;
+    copyExclusive(tmp, target);
+  }
+  rmSync(tmp, { force: true });
+}
+
+function writeOut(target, data, force) {
+  const tmp = join(dirname(target), `.${randomBytes(6).toString("hex")}.wbs-gen.tmp`);
+  try {
+    writeFileSync(tmp, data, { flag: "wx" });
+    if (force) renameSync(tmp, target);
+    else placeNew(tmp, target);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    const why = e.code === "EEXIST" ? "이미 있음(덮어쓰려면 --force)" : e.message;
+    throw new Usage(`쓰지 못함 ${target}: ${why}`);
+  }
+  return target;
+}
+
+/** Checks every output before any is written: kind, duplicates, and (without --force) files already there. */
+function targetsOf(args) {
+  if (!args.out.length) throw new Usage("--out <파일.xlsx|파일.html> 이 필요함");
+  const targets = args.out.map((f) => ({ path: resolve(f), kind: extname(f).toLowerCase() }));
+  const bad = targets.filter((x) => ![".xlsx", ".html", ".htm"].includes(x.kind));
+  if (bad.length) throw new Usage(`--out 은 .xlsx 나 .html 이어야 함: ${bad.map((x) => x.path).join(", ")}`);
+  if (new Set(targets.map((x) => x.path)).size !== targets.length) throw new Usage("--out 에 같은 파일이 두 번 있음");
+  const noDir = targets.filter((x) => !isDir(dirname(x.path)));
+  if (noDir.length) throw new Usage(`출력 폴더가 없음: ${noDir.map((x) => dirname(x.path)).join(", ")}`);
+  const there = targets.filter((x) => existsSync(x.path));
+  if (there.length && !args.force) throw new Usage(`이미 있음(덮어쓰려면 --force): ${there.map((x) => x.path).join(", ")}`);
+  return targets;
+}
+
+function cmdBuild(args) {
+  const targets = targetsOf(args);
+  const res = layout(readPlan(args));
+  report(res);
+  if (!res.model) return 1;
+  // Every output is made before any is written, so a drawing error leaves no half set behind.
+  const made = targets.map((x) => ({ ...x, data: x.kind === ".xlsx" ? toXlsx(res.model) : toHtml(res.model) }));
+  for (const x of made) process.stdout.write(`WROTE ${writeOut(x.path, x.data, args.force)}\n`);
+  process.stdout.write(`OK ${summary(res.model)}\n`);
+  return 0;
+}
+
+function holidayArgs(args) {
+  const { from, to } = args;
+  if (keyMs(from) === null || keyMs(to) === null || to < from) throw new Usage("--from, --to 는 YYYY-MM-DD 이고 from <= to 여야 함");
+  const seconds = Number(args.timeout ?? 10);
+  if (!Number.isInteger(seconds) || seconds < 1 || seconds > 60) throw new Usage("--timeout 은 1~60 사이 정수(초)");
+  if (args.url && !/^https:\/\//.test(args.url)) throw new Usage("--url 은 https:// 로 시작해야 함");
+  return { from, to, ms: seconds * 1000 };
+}
+
+/** The calendar text, or null when it cannot be reached (the caller asks the user instead). */
+async function calendarText(args, ms) {
+  if (args.ics) {
+    try {
+      return readFileSync(args.ics, "utf8");
+    } catch (e) {
+      throw new Usage(`ics 를 읽지 못함: ${e.message}`);
+    }
+  }
+  try {
+    return await fetchText(args.url || ICS_URL, ms);
+  } catch (e) {
+    process.stderr.write(`공휴일 달력에 닿지 못함(${e.message}). ${ASK}\n`);
+    return null;
+  }
+}
+
+const ASK = "사용자에게 공휴일을 'M/D, M/D' 로 받으십시오.";
+
+async function cmdHolidays(args) {
+  const { from, to, ms } = holidayArgs(args);
+  const text = await calendarText(args, ms);
+  if (text === null) return 3;
+  const items = parseIcs(text);
+  // A calendar with events but not one 공휴일 means its wording changed: do not report "no holidays".
+  if (!items.some((h) => h.isPublic)) {
+    process.stderr.write(`공휴일 달력에서 공휴일을 읽지 못함. ${ASK}\n`);
+    return 3;
+  }
+  const days = publicHolidays(items, from, to);
+  // Within one year a month/day is enough; across years the full date keeps 2026 and 2027 apart.
+  const show = from.slice(0, 4) === to.slice(0, 4) ? mmdd : (k) => k;
+  for (const d of days) process.stdout.write(`${show(d.key)} ${d.name}\n`);
+  process.stdout.write(`HOLIDAYS ${days.length ? days.map((d) => show(d.key)).join(", ") : "없음"}\n`);
+  return 0;
+}
+
+export async function main(argv) {
+  const [cmd, ...rest] = argv;
+  const args = parseArgs(rest);
+  if (cmd === "example") {
+    process.stdout.write(readFileSync(EXAMPLE, "utf8"));
+    return 0;
+  }
+  if (cmd === "holidays") return cmdHolidays(args);
+  if (cmd === "check") return cmdCheck(args);
+  if (cmd === "build") return cmdBuild(args);
+  throw new Usage("명령: example | holidays | check | build");
+}
+
+// Compared as real paths: Node resolves links in import.meta.url but not in argv[1], so a linked path would
+// otherwise do nothing and exit 0.
+const real = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return null;
+  }
+};
+if (process.argv[1] && real(process.argv[1]) !== null && real(process.argv[1]) === real(fileURLToPath(import.meta.url))) {
+  main(process.argv.slice(2)).then(
+    (code) => { process.exitCode = code; },
+    (e) => {
+      process.stderr.write(`${e instanceof Usage ? "" : "내부 오류: "}${e.message}\n`);
+      process.exitCode = 2;
+    },
+  );
+}

package/skills/wbs-gen/scripts/wg-dates.mjs

@@ -0,0 +1,106 @@
+// wg-dates.mjs: dates for wbs-gen. A date is a 'YYYY-MM-DD' key read as a calendar day (UTC math, no time zone).
+// Input dates may be 'YYYY-MM-DD' or 'M/D' ('MM/DD'); a month/day takes the year that puts it inside the project,
+// and is refused when two years would (a project longer than a year).
+
+const DOW = ["일", "월", "화", "수", "목", "금", "토"];
+const DAY = 86400000;
+
+const pad = (n) => String(n).padStart(2, "0");
+
+/** Milliseconds of a valid 'YYYY-MM-DD' key, or null. */
+export function keyMs(key) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(key));
+  if (!m) return null;
+  const ms = Date.UTC(+m[1], +m[2] - 1, +m[3]);
+  return toKey(ms) === key ? ms : null;
+}
+
+export function toKey(ms) {
+  const d = new Date(ms);
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+}
+
+export const addDays = (key, n) => toKey(keyMs(key) + n * DAY);
+export const dow = (key) => new Date(keyMs(key)).getUTCDay();
+export const dowName = (key) => DOW[dow(key)];
+export const mmdd = (key) => `${key.slice(5, 7)}/${key.slice(8, 10)}`;
+/** Whole days from a to b (keys). */
+export const daysBetween = (a, b) => Math.round((keyMs(b) - keyMs(a)) / DAY);
+
+/** One month/day in a year, or null when that day does not exist (2/30, 2/29 of a common year). */
+function monthDay(y, m, d) {
+  const key = `${y}-${pad(m)}-${pad(d)}`;
+  return keyMs(key) === null ? null : key;
+}
+
+/**
+ * Reads 'YYYY-MM-DD' or 'M/D' against the project range { start, end }.
+ * Returns { key, inRange }, { ambiguous: true } when a month/day falls inside the range in two years, or null when
+ * the text is not a date. A month/day outside the range takes the start year (inRange false).
+ */
+export function resolveDate(text, range) {
+  const s = String(text ?? "").trim();
+  if (keyMs(s) !== null) return { key: s, inRange: s >= range.start && s <= range.end };
+  const m = /^(\d{1,2})\s*\/\s*(\d{1,2})$/.exec(s);
+  return m ? placeMonthDay(+m[1], +m[2], range) : null;
+}
+
+function placeMonthDay(month, day, range) {
+  const all = [];
+  for (let y = +range.start.slice(0, 4); y <= +range.end.slice(0, 4); y++) all.push(monthDay(y, month, day));
+  const keys = all.filter(Boolean);
+  const inside = keys.filter((k) => k >= range.start && k <= range.end);
+  if (inside.length > 1) return { ambiguous: true };
+  if (inside.length) return { key: inside[0], inRange: true };
+  return keys.length ? { key: keys[0], inRange: false } : null;
+}
+
+/**
+ * Reads a holiday list: an array, or text such as "8/17, 10/03" (commas, spaces or new lines between). The words
+ * 없음 / none / - mean no holiday. Returns { keys: Set of keys inside the range, outside: [text], bad: [text],
+ * ambiguous: [text] }.
+ */
+export function parseHolidays(list, range) {
+  const items = Array.isArray(list) ? list.map(String) : String(list ?? "").split(/[,\s]+/);
+  const out = { keys: new Set(), outside: [], bad: [], ambiguous: [] };
+  for (const raw of items) {
+    const t = raw.trim();
+    if (!t || /^(없음|none|-)$/i.test(t)) continue;
+    const r = resolveDate(t, range);
+    if (!r) out.bad.push(t);
+    else if (r.ambiguous) out.ambiguous.push(t);
+    else if (r.inRange) out.keys.add(r.key);
+    else out.outside.push(t);
+  }
+  return out;
+}
+
+/** The working days from start to end inclusive: Monday to Friday and not in holidays. */
+export function businessDays(start, end, holidays = new Set()) {
+  const days = [];
+  const last = keyMs(end);
+  for (let ms = keyMs(start); ms !== null && last !== null && ms <= last; ms += DAY) {
+    const k = toKey(ms);
+    const w = new Date(ms).getUTCDay();
+    if (w !== 0 && w !== 6 && !holidays.has(k)) days.push(k);
+  }
+  return days;
+}
+
+/**
+ * Groups working days by calendar week (Monday first): [{ label: 'W<n>', first, count }]. n counts calendar weeks
+ * from the week of the first day, so a week with no working day keeps its number.
+ */
+export function weeks(days) {
+  const out = [];
+  if (!days.length) return out;
+  const monday = (k) => addDays(k, -((dow(k) + 6) % 7));
+  const base = monday(days[0]);
+  days.forEach((k, i) => {
+    const n = daysBetween(base, monday(k)) / 7 + 1;
+    const last = out[out.length - 1];
+    if (last && last.n === n) last.count++;
+    else out.push({ n, label: `W${n}`, first: i, count: 1 });
+  });
+  return out;
+}

package/skills/wbs-gen/scripts/wg-holidays.mjs

@@ -0,0 +1,89 @@
+// wg-holidays.mjs: Korean public holidays from Google's public calendar (iCalendar, no key). Only events whose
+// description starts with 공휴일 count; the calendar also lists observances (기념일) that are working days.
+// When the calendar cannot be reached (an air-gapped network, a proxy Node does not use), the skill asks the user
+// for the holidays as 'M/D, M/D' instead. Nothing here is cached or written.
+import { get } from "node:https";
+import { addDays, keyMs } from "./wg-dates.mjs";
+
+export const ICS_URL =
+  "https://calendar.google.com/calendar/ical/ko.south_korea%23holiday%40group.v.calendar.google.com/public/basic.ics";
+const MAX_BYTES = 4 * 1024 * 1024;
+
+/** Fetches a URL as text within timeoutMs (redirects followed up to 3 times). Rejects on any failure. */
+export function fetchText(url, timeoutMs, hops = 0, deadline = Date.now() + timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const left = Math.max(1, deadline - Date.now());
+    const req = get(url, { headers: { "user-agent": "wbs-gen" } }, (res) => {
+      const code = res.statusCode ?? 0;
+      if (code >= 300 && code < 400 && res.headers.location && hops < 3) {
+        res.resume();
+        resolve(fetchText(new URL(res.headers.location, url).href, timeoutMs, hops + 1, deadline));
+        return;
+      }
+      if (code !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${code}`));
+        return;
+      }
+      readBody(res, resolve, reject);
+    });
+    // One deadline for the whole exchange, redirects included: a server that sends a little at a time is cut too.
+    const timer = setTimeout(() => req.destroy(new Error(`${Math.round(timeoutMs / 1000)}초 안에 끝나지 않음`)), left);
+    req.on("close", () => clearTimeout(timer));
+    req.on("error", reject);
+  });
+}
+
+function readBody(res, resolve, reject) {
+  const chunks = [];
+  let size = 0;
+  res.on("data", (c) => {
+    size += c.length;
+    if (size > MAX_BYTES) res.destroy(new Error("응답이 너무 큼"));
+    else chunks.push(c);
+  });
+  res.on("error", reject);
+  res.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+}
+
+const unescape = (s) => s.replace(/\\n/gi, "\n").replace(/\\([,;\\])/g, "$1");
+
+function field(block, name) {
+  const m = new RegExp(`^${name}(?:;[^:\\n]*)?:(.*)$`, "m").exec(block);
+  return m ? unescape(m[1].trim()) : "";
+}
+
+const icsDate = (v) => {
+  const m = /^(\d{4})(\d{2})(\d{2})/.exec(v);
+  return m ? `${m[1]}-${m[2]}-${m[3]}` : null;
+};
+
+/**
+ * Reads iCalendar text. Returns [{ key, name, isPublic }], one item per day (DTEND is exclusive), sorted by date.
+ */
+export function parseIcs(text) {
+  const unfolded = String(text).replace(/\r\n/g, "\n").replace(/\n[ \t]/g, "");
+  const out = [];
+  for (const m of unfolded.matchAll(/BEGIN:VEVENT\n([\s\S]*?)END:VEVENT/g)) {
+    const start = icsDate(field(m[1], "DTSTART"));
+    if (!start || keyMs(start) === null) continue;
+    const endRaw = icsDate(field(m[1], "DTEND"));
+    const end = endRaw && keyMs(endRaw) !== null && endRaw > start ? endRaw : addDays(start, 1);
+    const name = field(m[1], "SUMMARY");
+    const isPublic = /^공휴일/.test(field(m[1], "DESCRIPTION"));
+    for (let k = start; k < end && out.length < 100000; k = addDays(k, 1)) out.push({ key: k, name, isPublic });
+  }
+  return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
+
+/** Public holidays from start to end inclusive, one per day (names of the same day joined with ' / '). */
+export function publicHolidays(items, start, end) {
+  const byDay = new Map();
+  for (const h of items) {
+    if (!h.isPublic || h.key < start || h.key > end) continue;
+    const names = byDay.get(h.key) ?? [];
+    if (!names.includes(h.name)) names.push(h.name);
+    byDay.set(h.key, names);
+  }
+  return [...byDay].map(([key, names]) => ({ key, name: names.join(" / ") }));
+}