@kaydash9999/banker-plugins 0.26.1 → 0.28.0

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(" / ") }));
+}

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

@@ -0,0 +1,108 @@
+// wg-html.mjs: draws the wbs-gen model as one self-contained HTML file (a table and CSS, no script, no library, no
+// network). The grid matches the XLSX: 8 fixed columns, week and day headers, cell-fill bars, ◆, the red gate line.
+// Colours reach the page only as 6-digit hex checked by wg-plan.mjs. Fonts: Noto Sans first and Noto Sans KR next;
+// Noto Sans has no Hangul, so Hangul is drawn in Noto Sans KR and everything else in Noto Sans. Nothing is embedded:
+// a viewer without the fonts uses its own sans-serif.
+
+const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const br = (s) => esc(s).replace(/\n/g, "<br>");
+const WIDTHS = [48, 260, 84, 70, 210, 56, 56, 60];
+const DAY = 36;
+const ALIGN = ["c", "l", "c", "c", "l", "c", "c", "c"];
+
+const CSS = `
+*{box-sizing:border-box}
+body{margin:16px;font-family:"Noto Sans","Noto Sans KR",sans-serif;color:#2C3E50;font-size:12px}
+.wrap{overflow:auto;max-height:calc(100vh - 32px);border:1px solid #D5D8DC}
+table{border-collapse:separate;border-spacing:0;table-layout:fixed}
+th,td{border-right:1px solid #D5D8DC;border-bottom:1px solid #D5D8DC;padding:2px 4px;overflow:hidden;vertical-align:middle;height:22px}
+.l{text-align:left;white-space:normal;word-break:keep-all}.c,th{text-align:center}
+.title th{background:#1F3864;color:#fff;font-size:15px;text-align:left;height:34px;padding:0 10px}
+.h th{background:#34495E;color:#fff;font-size:12px}
+.h th.w{background:#5D6D7E}
+.d th{background:#EBEDEF;color:#2C3E50;font-size:10px;line-height:1.2;height:36px;padding:0;letter-spacing:-.3px}
+thead tr th{position:sticky;z-index:2}
+.title th{top:0}.h th{top:34px}.d th{top:56px}
+.fix{position:sticky;z-index:1;background:#fff}
+thead .fix{z-index:3}
+tr.group td{font-weight:700;color:#1B2631}
+.dia{color:#C0392B;font-weight:700;text-align:center;padding:0}
+.dot{outline:1px dotted #7F8C8D;outline-offset:-2px}
+.gate{box-shadow:inset 2px 0 0 #C0392B}
+.notes{margin-top:18px;font-size:12px}
+.notes h3{font-size:13px;margin:14px 0 6px;color:#1B2631}
+.notes ul{margin:0;padding:0;list-style:none}
+.notes li{margin:3px 0;display:flex;align-items:center;gap:8px}
+.sw{display:inline-block;width:28px;height:14px;border:1px solid #D5D8DC}
+.sw.dotted{border:1px dotted #7F8C8D}
+.sw.gateline{border:0;border-left:2px solid #C0392B;border-right:2px solid #C0392B;width:10px}
+.sw.diamond{border:0;color:#C0392B;font-weight:700;text-align:center;line-height:14px}
+@page{size:A3 landscape;margin:10mm}
+@media print{body{margin:0}.wrap{overflow:visible;max-height:none;border:0}thead tr th,.fix{position:static}
+*{-webkit-print-color-adjust:exact;print-color-adjust:exact}}
+`;
+
+function colgroup(n) {
+  return `<colgroup>${WIDTHS.map((w) => `<col style="width:${w}px">`).join("")}${`<col style="width:${DAY}px">`.repeat(n)}</colgroup>`;
+}
+
+// Left offsets of the 8 sticky columns.
+const LEFT = WIDTHS.map((_, i) => WIDTHS.slice(0, i).reduce((a, b) => a + b, 0));
+const fixStyle = (c, bg) => ` class="fix" style="left:${LEFT[c]}px${bg ? `;background:#${bg}` : ""}"`;
+
+function head(m, gate) {
+  const total = 8 + m.days.length;
+  const title = `<tr class="title"><th colspan="${total}">${esc(m.title)}</th></tr>`;
+  const fixed = m.head.map((h, c) => `<th rowspan="2" class="fix" style="left:${LEFT[c]}px;background:#34495E">${br(h)}</th>`).join("");
+  const wk = m.weeks.map((w) => `<th class="w${gate.has(w.first) ? " gate" : ""}" colspan="${w.count}">${esc(w.label)}</th>`).join("");
+  const days = m.days.map((d, i) => `<th${gate.has(i) ? ' class="gate"' : ""}>${esc(d.label)}<br>${esc(d.dow)}</th>`).join("");
+  return `<thead>${title}<tr class="h">${fixed}${wk}</tr><tr class="d">${days}</tr></thead>`;
+}
+
+function dayTd(row, i, gate) {
+  const cls = [gate.has(i) ? "gate" : ""];
+  if (row.diamonds.includes(i)) {
+    cls.push("dia", row.dotted ? "dot" : "");
+    const bg = row.fill ? ` style="background:#${row.fill}"` : "";
+    return `<td class="${cls.filter(Boolean).join(" ")}"${bg}>◆</td>`;
+  }
+  const fill = i >= row.from && i <= row.to ? row.bar : row.fill;
+  const c = cls.filter(Boolean).join(" ");
+  return `<td${c ? ` class="${c}"` : ""}${fill ? ` style="background:#${fill}"` : ""}></td>`;
+}
+
+function body(m, gate) {
+  const rows = m.rows.map((row) => {
+    const fixed = row.cells.map((v, c) => `<td${fixStyle(c, row.fill)}><div class="${ALIGN[c]}">${br(v)}</div></td>`)
+      .join("");
+    const days = m.days.map((_, i) => dayTd(row, i, gate)).join("");
+    return `<tr class="${row.kind}">${fixed}${days}</tr>`;
+  });
+  return `<tbody>${rows.join("")}</tbody>`;
+}
+
+function swatch(item) {
+  if (item.type === "diamond") return `<span class="sw diamond">◆</span>`;
+  if (item.type === "gate") return `<span class="sw gateline"></span>`;
+  const cls = item.type === "dotted" ? "sw dotted" : "sw";
+  return `<span class="${cls}" style="background:#${item.color}"></span>`;
+}
+
+function notes(m) {
+  const legend = m.legend.length
+    ? `<h3>[범례]</h3><ul>${m.legend.map((l) => `<li>${swatch(l)}<span>${esc(l.label)}</span></li>`).join("")}</ul>`
+    : "";
+  const blocks = m.notes.map((n) => `${n.heading ? `<h3>${esc(n.heading)}</h3>` : ""}<ul>${n.lines.map((l) => `<li>${esc(l)}</li>`).join("")}</ul>`);
+  return `<section class="notes">${legend}${blocks.join("")}</section>`;
+}
+
+/** Returns the HTML text for a layout model. */
+export function toHtml(m) {
+  const gate = new Set(m.gates.map((g) => g.col));
+  // A fixed width keeps every column at its colgroup width, so the sticky offsets match in a narrow window too.
+  const width = WIDTHS.reduce((x, y) => x + y, 0) + DAY * m.days.length;
+  const table = `<table style="width:${width}px">${colgroup(m.days.length)}${head(m, gate)}${body(m, gate)}</table>`;
+  return `<!doctype html>\n<html lang="ko"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">`
+    + `<title>${esc(m.title.split("    |    ")[0])}</title><style>${CSS}</style></head>`
+    + `<body><div class="wrap">${table}</div>${notes(m)}</body></html>\n`;
+}

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

@@ -0,0 +1,230 @@
+// wg-plan.mjs: reads a wbs-gen plan (JSON), checks it and lays it out as one model that the XLSX and HTML writers
+// both draw. Nothing here touches the network or the disk.
+import { businessDays, daysBetween, dowName, keyMs, mmdd, parseHolidays, resolveDate, weeks } from "./wg-dates.mjs";
+
+export const HEAD = ["WBS", "작업", "담당", "우선순위", "선행·미확정", "시작", "종료", "일수\n(영업일)"];
+export const KINDS = ["group", "task", "constraint", "milestone"];
+// Five years of calendar days at most: about 1300 day columns, well inside Excel's 16384 columns.
+export const MAX_SPAN_DAYS = 5 * 366;
+// Excel keeps at most 32767 characters in a cell.
+export const MAX_TEXT = 32767;
+const HEX = /^#?[0-9A-Fa-f]{6}$/;
+const DEFAULT_BAR = "5D6D7E";
+const DEFAULT_LIGHT = "EBEDEF";
+
+export const hex = (c) => String(c).replace(/^#/, "").toUpperCase();
+const str = (v) => (v === undefined || v === null ? "" : String(v));
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
+// Lookups by a plan string go through own keys only, so "constructor" or "__proto__" is just a missing name.
+const own = (o, k) => (Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
+
+/** A list field: absent is empty; present but not an array is an error. */
+function list(plan, name, errors) {
+  const v = plan[name];
+  if (v === undefined || v === null) return [];
+  if (Array.isArray(v)) return v;
+  errors.push(`${name} 는 배열이어야 함`);
+  return [];
+}
+
+function readRange(plan, errors) {
+  const range = { start: str(plan.start), end: str(plan.end) };
+  if (keyMs(range.start) === null || keyMs(range.end) === null) {
+    errors.push("start, end 는 YYYY-MM-DD 여야 함");
+    return null;
+  }
+  if (range.end < range.start) {
+    errors.push("end 가 start 보다 앞섬");
+    return null;
+  }
+  if (daysBetween(range.start, range.end) > MAX_SPAN_DAYS) {
+    errors.push("기간이 5년을 넘음. 단계나 해로 나누어 만드십시오");
+    return null;
+  }
+  return range;
+}
+
+/** Checks the plan's frame (title, range, holidays, parts, bars). */
+function readFrame(plan, errors, warnings) {
+  if (!str(plan.title).trim()) errors.push("title 이 없음");
+  const range = readRange(plan, errors);
+  if (!range) return null;
+  const h = parseHolidays(plan.holidays ?? [], range);
+  if (h.bad.length) errors.push(`공휴일을 날짜로 읽지 못함: ${h.bad.join(", ")}`);
+  if (h.ambiguous.length) errors.push(`기간 안 두 해에 걸리는 M/D: ${h.ambiguous.join(", ")}. YYYY-MM-DD 로 적으십시오`);
+  if (h.outside.length) warnings.push(`기간 밖 공휴일은 뺌: ${h.outside.join(", ")}`);
+  return { range, holidays: h.keys, parts: readParts(obj(plan.parts), errors), bars: readBars(obj(plan.bars), errors) };
+}
+
+function readBars(given, errors) {
+  const bars = Object.create(null);
+  for (const [k, v] of Object.entries(given)) {
+    if (HEX.test(str(v))) bars[k] = hex(v);
+    else errors.push(`bars.${k} 색이 6자리 16진수가 아님: ${str(v)}`);
+  }
+  return bars;
+}
+
+function readParts(parts, errors) {
+  const out = Object.create(null);
+  for (const [id, raw] of Object.entries(parts)) {
+    const p = obj(raw);
+    for (const k of ["light", "dark"]) {
+      if (p[k] !== undefined && !HEX.test(str(p[k]))) errors.push(`parts.${id}.${k} 색이 6자리 16진수가 아님: ${str(p[k])}`);
+    }
+    out[id] = { name: str(p.name || id), light: hex(p.light ?? DEFAULT_LIGHT), dark: hex(p.dark ?? DEFAULT_BAR), legend: p.legend !== false };
+  }
+  return out;
+}
+
+/** A plan date as a key inside the range that is a working day, or null with an error. */
+function workday(text, what, ctx) {
+  const r = resolveDate(text, ctx.range);
+  if (!r) ctx.errors.push(`${what}: 날짜로 읽지 못함 (${str(text)})`);
+  else if (r.ambiguous) ctx.errors.push(`${what}: ${str(text)} 가 기간 안 두 해에 걸림. YYYY-MM-DD 로 적으십시오`);
+  else if (!r.inRange) ctx.errors.push(`${what}: 기간 밖 (${r.key})`);
+  else if (ctx.index.get(r.key) === undefined) ctx.errors.push(`${what}: 주말이나 공휴일 (${r.key} ${dowName(r.key)})`);
+  else return r.key;
+  return null;
+}
+
+function gatesOf(plan, ctx) {
+  return list(plan, "gates", ctx.errors).map((g, i) => {
+    const key = workday(obj(g).date, `gates[${i}]`, ctx);
+    return key && { key, col: ctx.index.get(key), label: str(obj(g).label) };
+  }).filter(Boolean);
+}
+
+function barColor(row, part, ctx) {
+  if (row.bar !== undefined) {
+    if (HEX.test(str(row.bar))) return hex(row.bar);
+    ctx.errors.push(`${str(row.wbs || row.task)}: bar 색이 6자리 16진수가 아님`);
+  }
+  return own(ctx.bars, str(row.priority)) ?? part?.dark ?? DEFAULT_BAR;
+}
+
+function partOf(row, what, ctx) {
+  if (row.part === undefined) return null;
+  const p = own(ctx.parts, str(row.part));
+  if (!p) ctx.errors.push(`${what}: parts 에 없는 part (${str(row.part)})`);
+  return p ?? null;
+}
+
+/** Start and end of a task or constraint; a constraint may give date alone. */
+function spanOf(row, what, ctx) {
+  const s = workday(row.start ?? row.date, `${what} 시작`, ctx);
+  const e = workday(row.end ?? row.start ?? row.date, `${what} 종료`, ctx);
+  if (s && e && e < s) {
+    ctx.errors.push(`${what}: 종료가 시작보다 앞섬`);
+    return null;
+  }
+  return s && e ? { s, e } : null;
+}
+
+function cellsOf(row, extra) {
+  return [str(row.wbs), str(row.task), str(row.owner), str(row.priority), str(row.pending), ...extra];
+}
+
+function layRow(row, i, ctx) {
+  const kind = str(row.kind || "task");
+  const what = `rows[${i}] ${str(row.wbs || row.task)}`.trim();
+  if (!KINDS.includes(kind)) {
+    ctx.errors.push(`${what}: kind 는 ${KINDS.join(", ")} 중 하나여야 함 (${kind})`);
+    return null;
+  }
+  const part = partOf(row, what, ctx);
+  const out = { kind, fill: null, bar: null, from: -1, to: -1, diamonds: [], dotted: false, cells: cellsOf(row, ["", "", ""]) };
+  if (kind === "group") return { ...out, fill: part?.light ?? DEFAULT_LIGHT };
+  if (kind === "milestone") {
+    const k = workday(row.date ?? row.start, what, ctx);
+    return { ...out, diamonds: k ? [ctx.index.get(k)] : [] };
+  }
+  return laySpan(row, kind, part, what, ctx, out);
+}
+
+function laySpan(row, kind, part, what, ctx, out) {
+  const span = spanOf(row, what, ctx);
+  if (!span) return out;
+  const from = ctx.index.get(span.s);
+  const to = ctx.index.get(span.e);
+  const cells = cellsOf(row, [ctx.label(span.s), ctx.label(span.e), to - from + 1]);
+  if (kind === "constraint") return { ...out, diamonds: [to], dotted: true, cells };
+  return { ...out, bar: barColor(row, part, ctx), from, to, cells };
+}
+
+function legendOf(plan, parts, gates, errors) {
+  const items = Object.values(parts).filter((p) => p.legend).map((p) => ({ type: "swatch", color: p.dark, label: p.name }));
+  list(plan, "legend", errors).map(obj).forEach((l, i) => {
+    if (!HEX.test(str(l.color))) errors.push(`legend[${i}] 색이 6자리 16진수가 아님`);
+    else items.push({ type: l.dotted ? "dotted" : "swatch", color: hex(l.color), label: str(l.label) });
+  });
+  if (plan.milestoneLegend !== false) items.push({ type: "diamond", color: "", label: str(plan.milestoneLabel || "마일스톤") });
+  for (const g of gates) items.push({ type: "gate", color: "C0392B", label: `${g.label || "게이트"}(빨간 수직선 = ${mmdd(g.key)})` });
+  return items;
+}
+
+/** notes: [{ heading, lines }]; lines may also be one string. */
+function notesOf(plan, errors) {
+  return list(plan, "notes", errors).map(obj).map((n, i) => {
+    const lines = typeof n.lines === "string" ? [n.lines] : n.lines ?? [];
+    if (!Array.isArray(lines)) errors.push(`notes[${i}].lines 는 배열이나 글이어야 함`);
+    return { heading: str(n.heading), lines: (Array.isArray(lines) ? lines : []).map(str) };
+  });
+}
+
+function rowsOf(plan, ctx) {
+  if (!Array.isArray(plan.rows) || !plan.rows.length) {
+    ctx.errors.push("rows 가 비어 있음");
+    return [];
+  }
+  return plan.rows.map((r, i) => layRow(obj(r), i, ctx)).filter(Boolean);
+}
+
+function titleOf(plan, range, n) {
+  const sameYear = range.start.slice(0, 4) === range.end.slice(0, 4);
+  const endText = sameYear ? mmdd(range.end) : range.end;
+  const span = `${range.start}(${dowName(range.start)}) ~ ${endText}(${dowName(range.end)})`;
+  return [str(plan.title).trim(), span, `${n} 영업일`, str(plan.subtitle).trim()].filter(Boolean).join("    |    ");
+}
+
+function tooLong(model, errors) {
+  const texts = [
+    model.title, model.sheet, ...model.legend.map((l) => l.label), ...model.rows.flatMap((r) => r.cells.map(str)),
+    ...model.notes.flatMap((n) => [n.heading, ...n.lines]),
+  ];
+  if (texts.some((t) => t.length > MAX_TEXT)) errors.push(`한 칸의 글이 ${MAX_TEXT}자를 넘음(Excel 한도)`);
+}
+
+/**
+ * Checks a plan and lays it out. Returns { errors, warnings, model }; model is null when there are errors.
+ * model: { title, sheet, head, days: [{ key, label, dow }], weeks, gates, rows, legend, notes }
+ */
+export function layout(plan) {
+  const errors = [];
+  const warnings = [];
+  if (!plan || typeof plan !== "object" || Array.isArray(plan)) return { errors: ["plan 은 JSON 객체여야 함"], warnings, model: null };
+  const frame = readFrame(plan, errors, warnings);
+  if (!frame) return { errors, warnings, model: null };
+  const days = businessDays(frame.range.start, frame.range.end, frame.holidays);
+  if (!days.length) errors.push("기간 안에 영업일이 없음");
+  const multiYear = frame.range.start.slice(0, 4) !== frame.range.end.slice(0, 4);
+  const label = (k) => (multiYear ? `${k.slice(2, 4)}/${mmdd(k)}` : mmdd(k));
+  const ctx = { ...frame, errors, label, index: new Map(days.map((k, i) => [k, i])) };
+  const gates = gatesOf(plan, ctx);
+  const rows = rowsOf(plan, ctx);
+  const legend = legendOf(plan, frame.parts, gates, errors);
+  const notes = notesOf(plan, errors);
+  const model = {
+    title: titleOf(plan, frame.range, days.length),
+    sheet: str(plan.sheet || "WBS 간트"),
+    head: HEAD,
+    days: days.map((k) => ({ key: k, label: mmdd(k), dow: dowName(k) })),
+    weeks: weeks(days),
+    gates,
+    rows,
+    legend,
+    notes,
+  };
+  tooLong(model, errors);
+  return { errors, warnings, model: errors.length ? null : model };
+}