dayassist 0.1.0

package/skills/docx/scripts/node/docx.cjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+/**
+ * docx.cjs — deterministic Word document generator & editor.
+ *
+ * The model produces a JSON spec; this tested code turns it into a .docx with
+ * all the OOXML/docx-js correctness rules baked in (DXA table widths, real
+ * bullet numbering, ShadingType.CLEAR, US-Letter default, xml:space, …). The
+ * model never writes docx-js or touches raw XML.
+ *
+ * Usage (spec via --spec <file> or stdin):
+ *   "$OPEN_CORE_NODE" docx.cjs create --out doc.docx   < spec.json
+ *   "$OPEN_CORE_NODE" docx.cjs edit   --out doc.docx    < editspec.json
+ *
+ * Deps (docx, jszip, xml-js) resolve from the skill's own node_modules.
+ */
+const fs = require("fs");
+const path = require("path");
+const D = require("docx");
+
+// ---- unit conversions (spec uses friendly units) ----------------------------
+const pt = (p) => Math.round(p * 2);        // points → half-points (run size)
+const tw = (p) => Math.round(p * 20);       // points → twips (spacing)
+const inТwips = (i) => Math.round(i * 1440); // inches → twips (margins)
+
+const PAGE = {
+  letter: { width: 12240, height: 15840 },
+  a4: { width: 11906, height: 16838 },
+};
+
+// =============================================================================
+// CREATE
+// =============================================================================
+function buildDocument(spec) {
+  const fontFamily = spec.font?.family || "Arial";
+  const fontSize = pt(spec.font?.size || 11);
+
+  const paper = PAGE[(spec.page?.size || "letter").toLowerCase()] || PAGE.letter;
+  const landscape = spec.page?.orientation === "landscape";
+  const margin = inТwips(spec.page?.margin ?? 1);
+  // Content width = page width minus L/R margins (long edge in landscape).
+  const contentWidth = (landscape ? paper.height : paper.width) - margin * 2;
+
+  const numbering = { config: [
+    { reference: "bullets", levels: bulletLevels() },
+    { reference: "numbers", levels: numberLevels() },
+  ] };
+
+  const children = (spec.body || []).map((b) => block(b, contentWidth)).flat();
+
+  const section = {
+    properties: {
+      page: {
+        size: {
+          width: paper.width,
+          height: paper.height,
+          orientation: landscape ? D.PageOrientation.LANDSCAPE : D.PageOrientation.PORTRAIT,
+        },
+        margin: { top: margin, right: margin, bottom: margin, left: margin },
+      },
+    },
+    children,
+  };
+  if (spec.header) section.headers = { default: makeHF(spec.header, false) };
+  if (spec.footer) section.footers = { default: makeHF(spec.footer, true) };
+
+  return new D.Document({
+    styles: {
+      default: { document: { run: { font: fontFamily, size: fontSize } } },
+      paragraphStyles: [
+        headingStyle("Heading1", 18, fontFamily, 0),
+        headingStyle("Heading2", 14, fontFamily, 1),
+        headingStyle("Heading3", 12, fontFamily, 2),
+      ],
+    },
+    numbering,
+    sections: [section],
+  });
+}
+
+function headingStyle(id, sizePt, font, outline) {
+  return {
+    id, name: id.replace(/(\d)/, " $1"), basedOn: "Normal", next: "Normal", quickFormat: true,
+    run: { size: pt(sizePt), bold: true, font },
+    paragraph: { spacing: { before: tw(10), after: tw(8) }, outlineLevel: outline },
+  };
+}
+function bulletLevels() {
+  return [0, 1, 2].map((level) => ({
+    level, format: D.LevelFormat.BULLET, text: ["•", "◦", "▪"][level],
+    alignment: D.AlignmentType.LEFT,
+    style: { paragraph: { indent: { left: 720 * (level + 1), hanging: 360 } } },
+  }));
+}
+function numberLevels() {
+  return [0, 1, 2].map((level) => ({
+    level, format: D.LevelFormat.DECIMAL, text: `%${level + 1}.`,
+    alignment: D.AlignmentType.LEFT,
+    style: { paragraph: { indent: { left: 720 * (level + 1), hanging: 360 } } },
+  }));
+}
+
+const ALIGN = {
+  left: D.AlignmentType.LEFT, center: D.AlignmentType.CENTER,
+  right: D.AlignmentType.RIGHT, justify: D.AlignmentType.JUSTIFIED,
+};
+
+function runs(spec) {
+  const list = spec.runs ? spec.runs : [spec.text ?? ""];
+  return list.map((r) => {
+    if (typeof r === "string") r = { text: r };
+    const opts = {
+      text: r.text ?? "", bold: r.bold, italics: r.italic,
+      underline: r.underline ? {} : undefined,
+      color: r.color, size: r.size ? pt(r.size) : undefined, font: r.font,
+    };
+    if (r.link) {
+      return new D.ExternalHyperlink({
+        children: [new D.TextRun({ ...opts, style: "Hyperlink" })], link: r.link,
+      });
+    }
+    return new D.TextRun(opts);
+  });
+}
+
+function block(b, contentWidth) {
+  switch (b.type) {
+    case "heading": {
+      const lvl = Math.min(Math.max(b.level || 1, 1), 3);
+      return new D.Paragraph({
+        heading: [D.HeadingLevel.HEADING_1, D.HeadingLevel.HEADING_2, D.HeadingLevel.HEADING_3][lvl - 1],
+        children: runs(b),
+      });
+    }
+    case "paragraph":
+      return new D.Paragraph({
+        children: runs(b),
+        alignment: ALIGN[b.align],
+        spacing: b.spacingAfter ? { after: tw(b.spacingAfter) } : undefined,
+      });
+    case "bullets":
+    case "numbered": {
+      const ref = b.type === "bullets" ? "bullets" : "numbers";
+      return (b.items || []).map((it) => {
+        if (typeof it === "string") it = { text: it };
+        return new D.Paragraph({ numbering: { reference: ref, level: it.level || 0 }, children: runs(it) });
+      });
+    }
+    case "table":
+      return table(b, contentWidth);
+    case "image":
+      return new D.Paragraph({ children: [image(b)] });
+    case "pagebreak":
+      return new D.Paragraph({ children: [new D.PageBreak()] });
+    case "toc":
+      return new D.TableOfContents(b.title || "Table of Contents", { hyperlink: true, headingStyleRange: "1-3" });
+    default:
+      throw new Error(`unknown block type: ${JSON.stringify(b.type)}`);
+  }
+}
+
+function table(b, contentWidth) {
+  const header = b.header || null;
+  const bodyRows = b.rows || [];
+  const nCols = header ? header.length : (bodyRows[0] || []).length;
+  if (!nCols) throw new Error("table has no columns");
+  // Dual widths: column widths sum to content width; each cell echoes its column width.
+  const widths = b.widths || Array(nCols).fill(Math.floor(contentWidth / nCols));
+  const border = { style: D.BorderStyle.SINGLE, size: 1, color: "CCCCCC" };
+  const borders = { top: border, bottom: border, left: border, right: border };
+
+  const mkRow = (cells, isHeader) => new D.TableRow({
+    children: cells.map((c, i) => {
+      if (typeof c === "string") c = { text: c };
+      return new D.TableCell({
+        borders,
+        width: { size: widths[i], type: D.WidthType.DXA },
+        shading: c.fill ? { fill: c.fill, type: D.ShadingType.CLEAR }
+          : isHeader ? { fill: "D9EAF7", type: D.ShadingType.CLEAR } : undefined,
+        margins: { top: 80, bottom: 80, left: 120, right: 120 },
+        children: [new D.Paragraph({ alignment: ALIGN[c.align], children: runs({ ...c, bold: c.bold ?? isHeader }) })],
+      });
+    }),
+  });
+
+  const rows = [];
+  if (header) rows.push(mkRow(header, true));
+  for (const r of bodyRows) rows.push(mkRow(r, false));
+  return new D.Table({ width: { size: widths.reduce((a, b) => a + b, 0), type: D.WidthType.DXA }, columnWidths: widths, rows });
+}
+
+function image(b) {
+  const data = b.path ? fs.readFileSync(b.path) : Buffer.from(b.data, "base64");
+  const ext = (b.path ? path.extname(b.path).slice(1) : b.format || "png").toLowerCase();
+  return new D.ImageRun({
+    type: ext === "jpg" ? "jpeg" : ext,
+    data,
+    transformation: { width: b.width || 300, height: b.height || 200 },
+    altText: { title: b.alt || "image", description: b.alt || "image", name: b.alt || "image" },
+  });
+}
+
+function makeHF(spec, isFooter) {
+  const children = spec.text || spec.runs ? runs({ text: spec.text, runs: spec.runs }) : [];
+  if (isFooter && spec.pageNumber) {
+    if (spec.text) children.push(new D.TextRun(" "));
+    children.push(new D.TextRun({ children: ["Page ", D.PageNumber.CURRENT] }));
+  }
+  const P = new D.Paragraph({ alignment: ALIGN[spec.align] || (isFooter ? D.AlignmentType.CENTER : D.AlignmentType.RIGHT), children });
+  return isFooter ? new D.Footer({ children: [P] }) : new D.Header({ children: [P] });
+}
+
+async function create(spec, out) {
+  const doc = buildDocument(spec);
+  const buf = await D.Packer.toBuffer(doc);
+  fs.writeFileSync(out, buf);
+  console.log(`Created ${out} (${buf.length} bytes)`);
+}
+
+// =============================================================================
+// EDIT — high-level ops over the document XML (model never sees XML)
+// =============================================================================
+const JSZip = require("jszip");
+const xmljs = require("xml-js");
+
+async function edit(spec, outOverride) {
+  const input = spec.file;
+  const out = outOverride || spec.out || input;
+  if (!input) throw new Error("edit spec needs a \"file\"");
+
+  const zip = await JSZip.loadAsync(fs.readFileSync(input));
+  const docXmlName = "word/document.xml";
+  let tree = xmljs.xml2js(await zip.file(docXmlName).async("string"), { compact: false });
+  mergeRunsTree(tree); // so replaceText sees contiguous text
+
+  for (const op of spec.ops || []) applyOp(tree, op);
+
+  const xml = xmljs.js2xml(tree, {});
+  zip.file(docXmlName, repairSpace(xml));
+  const buf = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE", compressionOptions: { level: 6 } });
+  fs.writeFileSync(out, buf);
+  console.log(`Edited ${input} → ${out} (${(spec.ops || []).length} ops, ${buf.length} bytes)`);
+}
+
+function applyOp(tree, op) {
+  switch (op.op) {
+    case "replaceText": {
+      let n = 0;
+      eachText(tree, (node) => {
+        if (op.find && node.text.includes(op.find)) {
+          node.text = op.all === false
+            ? node.text.replace(op.find, op.replace ?? "")
+            : node.text.split(op.find).join(op.replace ?? "");
+          n++;
+        }
+      });
+      if (op.find && n === 0) throw new Error(`replaceText: text not found: ${JSON.stringify(op.find)}`);
+      return;
+    }
+    case "appendParagraph":
+      return appendToBody(tree, paragraphXml(op.text ?? "", null));
+    case "appendHeading":
+      return appendToBody(tree, paragraphXml(op.text ?? "", Math.min(Math.max(op.level || 1, 1), 3)));
+    default:
+      throw new Error(`unknown edit op: ${JSON.stringify(op.op)}`);
+  }
+}
+
+// Build a <w:p> element node for plain text (optionally a heading level).
+function paragraphXml(text, level) {
+  const pPr = level
+    ? [{ type: "element", name: "w:pPr", elements: [
+        { type: "element", name: "w:pStyle", attributes: { "w:val": `Heading${level}` } }] }]
+    : [];
+  const needsSpace = /^\s|\s$/.test(text);
+  return {
+    type: "element", name: "w:p",
+    elements: [
+      ...pPr,
+      { type: "element", name: "w:r", elements: [
+        { type: "element", name: "w:t",
+          attributes: needsSpace ? { "xml:space": "preserve" } : undefined,
+          elements: [{ type: "text", text }] }] },
+    ],
+  };
+}
+
+function appendToBody(tree, pNode) {
+  const body = findFirst(tree, "w:body");
+  if (!body) throw new Error("no <w:body> in document");
+  const sectIdx = (body.elements || []).findIndex((e) => e.name === "w:sectPr");
+  if (sectIdx >= 0) body.elements.splice(sectIdx, 0, pNode); // before final sectPr
+  else body.elements.push(pNode);
+}
+
+// ---- shared XML tree helpers (also used by run-merging) ---------------------
+function eachText(node, fn) {
+  if (!node.elements) return;
+  for (const el of node.elements) {
+    if (el.name === "w:t") {
+      for (const t of el.elements || []) if (t.type === "text") fn(t);
+    }
+    eachText(el, fn);
+  }
+}
+function findFirst(node, name) {
+  if (!node.elements) return null;
+  for (const el of node.elements) {
+    if (el.name === name) return el;
+    const f = findFirst(el, name);
+    if (f) return f;
+  }
+  return null;
+}
+function mergeRunsTree(node) {
+  if (!node.elements) return;
+  const merged = [];
+  for (const child of node.elements) {
+    const prev = merged[merged.length - 1];
+    if (prev && simpleRun(prev) && simpleRun(child) && sameRpr(prev, child)) {
+      const pt2 = wtOf(prev), combined = txt(pt2) + txt(wtOf(child));
+      pt2.elements = [{ type: "text", text: combined }];
+      if (/^\s|\s$/.test(combined)) (pt2.attributes = pt2.attributes || {})["xml:space"] = "preserve";
+    } else merged.push(child);
+  }
+  node.elements = merged;
+  for (const c of merged) mergeRunsTree(c);
+}
+const simpleRun = (e) => e?.type === "element" && e.name === "w:r" && (e.elements || []).filter((x) => x.name !== "w:rPr").length === 1 && (e.elements || []).find((x) => x.name !== "w:rPr")?.name === "w:t";
+const rprOf = (r) => (r.elements || []).find((e) => e.name === "w:rPr");
+const wtOf = (r) => (r.elements || []).find((e) => e.name === "w:t");
+const sameRpr = (a, b) => (rprOf(a) ? xmljs.js2xml({ elements: [rprOf(a)] }) : "") === (rprOf(b) ? xmljs.js2xml({ elements: [rprOf(b)] }) : "");
+const txt = (wt) => (wt.elements || []).filter((e) => e.type === "text").map((e) => e.text).join("");
+function repairSpace(xml) {
+  const tree = xmljs.xml2js(xml, { compact: false });
+  eachText(tree, () => {});
+  (function fix(node) {
+    if (!node.elements) return;
+    for (const el of node.elements) {
+      if (el.name === "w:t" && /^\s|\s$/.test(txt(el))) (el.attributes = el.attributes || {})["xml:space"] = "preserve";
+      fix(el);
+    }
+  })(tree);
+  return xmljs.js2xml(tree, { spaces: 2 });
+}
+
+// =============================================================================
+// CLI
+// =============================================================================
+function readSpec(argv) {
+  const si = argv.indexOf("--spec");
+  const raw = si >= 0 ? fs.readFileSync(argv[si + 1], "utf8") : fs.readFileSync(0, "utf8");
+  try { return JSON.parse(raw); }
+  catch (e) { throw new Error(`invalid JSON spec: ${e.message}`); }
+}
+function flag(argv, name) { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : undefined; }
+
+async function main() {
+  const [, , cmd, ...rest] = process.argv;
+  if (cmd === "create") {
+    const out = flag(rest, "--out");
+    if (!out) throw new Error("create needs --out <file>");
+    await create(readSpec(rest), out);
+  } else if (cmd === "edit") {
+    await edit(readSpec(rest), flag(rest, "--out"));
+  } else {
+    console.error("usage: docx.cjs create --out <file> < spec.json\n       docx.cjs edit [--out <file>] < editspec.json");
+    process.exit(1);
+  }
+}
+main().catch((e) => { console.error("docx.cjs:", e.message); process.exit(1); });

package/skills/docx/scripts/node/unpack.cjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * unpack.cjs — unpack a .docx for reading (no Python needed).
+ *
+ * A .docx is a ZIP of XML parts. This extracts it to a directory, pretty-prints
+ * the XML so it's editable with the Edit tool, and (by default) merges adjacent
+ * runs in the story parts so a single sentence isn't split across many <w:r>
+ * elements — which is what makes find-and-replace editing actually work.
+ *
+ * Usage:
+ *   "$OPEN_CORE_NODE" unpack.cjs <input.docx> <outDir> [--no-merge-runs]
+ *
+ * Then edit files under <outDir>/word/, and repack with pack.cjs.
+ *
+ * Deps (jszip, xml-js) resolve from the skill's own node_modules.
+ */
+const JSZip = require("jszip");
+const xmljs = require("xml-js");
+const fs = require("fs");
+const path = require("path");
+
+const STORY_PART = /(?:^|\/)(document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
+const XML_PART = /\.(xml|rels)$/i;
+
+async function main() {
+  const [, , input, outDir, ...rest] = process.argv;
+  if (!input || !outDir) {
+    console.error("usage: unpack.cjs <input.docx> <outDir> [--no-merge-runs]");
+    process.exit(1);
+  }
+  const mergeRuns = !rest.includes("--no-merge-runs");
+
+  const zip = await JSZip.loadAsync(fs.readFileSync(input));
+  const manifest = [];
+
+  for (const name of Object.keys(zip.files)) {
+    const entry = zip.files[name];
+    const dest = path.join(outDir, name);
+    if (entry.dir) {
+      fs.mkdirSync(dest, { recursive: true });
+      continue;
+    }
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+    if (XML_PART.test(name)) {
+      const raw = await entry.async("string");
+      const tree = xmljs.xml2js(raw, { compact: false });
+      if (mergeRuns && STORY_PART.test(name)) mergeRunsTree(tree);
+      // spaces:2 indents element structure; xml-js keeps text-only elements
+      // (like <w:t>) inline, so significant whitespace is preserved.
+      fs.writeFileSync(dest, xmljs.js2xml(tree, { spaces: 2 }), "utf8");
+    } else {
+      fs.writeFileSync(dest, await entry.async("nodebuffer"));
+    }
+    manifest.push(name);
+  }
+
+  // Record original part order so pack.cjs can rebuild a faithful archive.
+  fs.writeFileSync(
+    path.join(outDir, ".docx-manifest.json"),
+    JSON.stringify(manifest),
+  );
+  console.log(
+    `Unpacked ${manifest.length} parts to ${outDir}${mergeRuns ? " (adjacent runs merged)" : ""}`,
+  );
+}
+
+/** Recursively merge adjacent, identically-formatted simple runs in every element. */
+function mergeRunsTree(node) {
+  if (!node.elements) return;
+  const merged = [];
+  for (const child of node.elements) {
+    const prev = merged[merged.length - 1];
+    if (prev && isSimpleRun(prev) && isSimpleRun(child) && sameRpr(prev, child)) {
+      appendRunText(prev, child);
+    } else {
+      merged.push(child);
+    }
+  }
+  node.elements = merged;
+  for (const child of merged) mergeRunsTree(child);
+}
+
+/** A run we can safely merge: <w:r> whose only non-rPr child is a single <w:t>. */
+function isSimpleRun(el) {
+  if (!el || el.type !== "element" || el.name !== "w:r") return false;
+  const nonRpr = (el.elements || []).filter((e) => e.name !== "w:rPr");
+  return nonRpr.length === 1 && nonRpr[0].name === "w:t";
+}
+
+function rprOf(run) {
+  return (run.elements || []).find((e) => e.name === "w:rPr");
+}
+function wtOf(run) {
+  return (run.elements || []).find((e) => e.name === "w:t");
+}
+function sameRpr(a, b) {
+  const sa = rprOf(a) ? xmljs.js2xml({ elements: [rprOf(a)] }) : "";
+  const sb = rprOf(b) ? xmljs.js2xml({ elements: [rprOf(b)] }) : "";
+  return sa === sb;
+}
+function textOf(wt) {
+  return (wt.elements || [])
+    .filter((e) => e.type === "text")
+    .map((e) => e.text)
+    .join("");
+}
+function appendRunText(prev, next) {
+  const pt = wtOf(prev);
+  const combined = textOf(pt) + textOf(wtOf(next));
+  pt.elements = [{ type: "text", text: combined }];
+  // Leading/trailing whitespace is only kept by Word with xml:space="preserve".
+  if (/^\s|\s$/.test(combined)) {
+    pt.attributes = pt.attributes || {};
+    pt.attributes["xml:space"] = "preserve";
+  }
+}
+
+main().catch((err) => {
+  console.error("unpack failed:", err.message);
+  process.exit(1);
+});