dsh-office-kit 0.4.7 → 0.4.8

package/CAPABILITY.md

@@ -46,8 +46,11 @@ The four routers register through `ctx.skills.registerProvider` in
 - **DOCX** — create from a block spec: headings, paragraphs, bullets, numbered
   lists, tables, images, LaTeX equations (OMML, fallbacks counted in
   `equation_fallbacks`), quotes, page breaks, spacers, header/footer, page size,
-  margins. Read returns styled text, tables, images, equations, counts. Edits run
-  as pack scripts (text replacement, block append, core properties).
+  margins, and an optional `font` family shared by Western, East Asian and
+  complex-script text. Heading styles stay consistent when later extended. Headings
+  and titles are black. Read returns styled text,
+  tables, images, equations, counts. Edits run as pack scripts (text replacement
+  preserving run formatting, block append, core properties).
 - **PDF** — create with reportlab; the CJK font is auto-detected (named in the
   report, e.g. `OfficeCJK`). Read returns page text, metadata, word counts and
   form fields; OCR is not bundled (`ocr.available: false`). Edits run as pack

package/assets/skills/office-documents/SKILL.md

@@ -63,6 +63,7 @@ Where no verb exists, use the listed script or a short `python-docx`/`lxml` snip
 ## Document defaults
 
 - Letter 8.5×11 portrait (A4 when the user or template says so), 1in margins, body 11–12pt, single column.
+- `docx create` accepts an optional top-level `"font": "Microsoft YaHei"` family string; omit it to retain Calibri. The selected family applies consistently to Western, East Asian and complex-script text through document defaults and styles used by generated blocks, with East Asian language `zh-CN`. Choose an installed font with the glyph coverage the content needs; the helper does not install or embed fonts. Native equations retain their math font.
 - Black headings and body; colour only for deliberate emphasis, links and chart series.
 - Tables: `#D9D9D9` borders, bold header row, `w:tblHeader` repeat, no vertical merges in wide tables.
 - No callout boxes, drop shadows or coloured sidebars — structure comes from headings, lists and tables.

package/assets/skills/office-documents/scripts/replace_text.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 """Replace text in a Word document without touching the original.
 
-Pairs run inside single runs first; when a match straddles runs the paragraph
-text is rewritten into its first run, so ordinary prose survives intact and a
-paragraph that mixes formats collapses. Body, tables, and every section header
-and footer are covered.
+Only changed spans are rewritten, preserving the original text nodes and run
+formatting even when a match straddles runs. Changed text uses the formatting
+at the start of its span. Body, tables, and every section header and footer
+are covered.
 
 Usage:
   replace_text.py --input IN.docx [--out OUT.docx] --find OLD --replace NEW [--find ...]
@@ -21,6 +21,7 @@ from __future__ import annotations
 import argparse
 import json
 import sys
+from difflib import SequenceMatcher
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
@@ -41,26 +42,46 @@ def paragraph_text_nodes(paragraph) -> list:
 
 
 def replace_in_paragraph(paragraph, find: str, replacement: str) -> int:
-    nodes = paragraph_text_nodes(paragraph)
-    if not nodes:
+    if not find:
         return 0
-    count = 0
-    for node in nodes:
+    ranges = []
+    joined = ""
+    for node in paragraph_text_nodes(paragraph):
         text = node.text or ""
-        if find in text:
-            hits = text.count(find)
-            node.text = text.replace(find, replacement)
-            count += hits
-    if count:
-        return count
-    joined = "".join(node.text or "" for node in nodes)
-    if find not in joined:
+        if text:
+            ranges.append((node, len(joined), len(joined) + len(text)))
+            joined += text
+    matches = []
+    offset = joined.find(find)
+    while offset != -1:
+        matches.append(offset)
+        offset = joined.find(find, offset + len(find))
+    if not matches:
         return 0
-    hits = joined.count(find)
-    nodes[0].text = joined.replace(find, replacement)
-    for node in nodes[1:]:
-        node.text = ""
-    return hits
+
+    changes = [opcode for opcode in SequenceMatcher(
+        None, find, replacement, autojunk=False
+    ).get_opcodes() if opcode[0] != "equal"]
+    # All offsets refer to the original text. Working backwards also prevents
+    # inserted text from being matched again during this replacement pair.
+    for offset in reversed(matches):
+        for _, old_start, old_end, new_start, new_end in reversed(changes):
+            start, end = offset + old_start, offset + old_end
+            first = next((i for i, (_, _, stop) in enumerate(ranges)
+                          if stop > start), len(ranges) - 1)
+            for i in range(first, len(ranges)):
+                node, node_start, node_end = ranges[i]
+                if i != first and node_start >= end:
+                    break
+                text = node.text or ""
+                left = max(0, start - node_start)
+                right = min(node_end, end) - node_start
+                node.text = (text[:left]
+                             + (replacement[new_start:new_end] if i == first else "")
+                             + text[right:])
+                if node.text and (node.text[0].isspace() or node.text[-1].isspace()):
+                    node.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+    return len(matches)
 
 
 def iter_paragraphs(document):

package/assets/skills/office-documents/tasks/create_edit.md

@@ -29,6 +29,8 @@ Write a JSON spec next to the output, then run:
 }
 ```
 
+The optional top-level `font` string sets the same family for Western, East Asian and complex-script text (for example, `"font": "Microsoft YaHei"`). The default is `Calibri`; choose an installed family with the glyph coverage your document needs. Body, headings, lists, tables, headers and footers share this family. Heading styles are prepared even when unused, so later `append_blocks.py` headings keep the same family. Headings and titles are black, and East Asian language metadata is `zh-CN`. Native equations keep their math font.
+
 Block types and keys: `heading` (`level`, `text`), `paragraph` (`text`, `bold`, `italic`, `size`, `color`, `align`, `style`), `bullets` / `numbered` (`items`), `table` (`headers`, `rows`, optional `style`, default `Table Grid`), `image` (`path`, optional `width` in inches), `equation` (`latex`), `quote`, `page_break`, `spacer`. Page keys: `page_size` (`Letter` or `A4`), `orientation`, and `top_margin` / `bottom_margin` / `left_margin` / `right_margin` in inches.
 
 The command prints counts for headings, paragraphs, list items, tables, images and equations. Check `equation_fallbacks`: a non-zero value means some LaTeX was emitted as styled text instead of OMML.
@@ -44,7 +46,7 @@ Replace text — body, tables, and every header and footer:
   --find "18%" --replace "21%" --find "Hardware flat" --replace "Hardware steady"
 ```
 
-`--find` / `--replace` pair up in order; `--spec edits.json` takes `{"replace": [{"find": "...", "replace": "..."}]}` instead. The command prints a count per pair. A match inside one run keeps that run's formatting; a match straddling runs collapses the paragraph into its first run, so keep needles inside a single styled span when formatting matters. `--require-all` exits 1 if a pair matched nothing — the check for a scripted edit.
+`--find` / `--replace` pair up in order; `--spec edits.json` takes `{"replace": [{"find": "...", "replace": "..."}]}` instead. The command prints a count per pair. Matches preserve existing run formatting, including unchanged text on either side of a replacement. Within a cross-run match, unchanged text keeps its original run; inserted or changed text inherits the formatting at the start of that changed span (an insertion at a run boundary uses the following run, or the preceding run at the paragraph end). `--require-all` exits 1 if a pair matched nothing — the check for a scripted edit.
 
 Append blocks — the same block types `docx create` accepts:
 
@@ -74,19 +76,14 @@ Set properties:
 | Edit inside a header, footer, footnote or comment | `docx_kit.py xml <file> <part>` to inspect, then the snippet below |
 | Mark edits as tracked changes | `add_tracked_replacements.py` (`tasks/clean_tracked_changes.md`) |
 | Header date, footer page numbers, first hyperlink | `docx_ooxml_patch.py` |
-| Replace a paragraph but keep its formatting | `python-docx` snippet below |
+| Replace text across styled runs | `replace_text.py` above |
 
 ```bash
 "<python>" - <<'PY'
 from docx import Document
 d = Document(r"<file.docx>")
-for p in d.paragraphs:
-    if "18%" in p.text:
-        runs = p.runs or [p.add_run()]
-        runs[0].text = p.text.replace("18%", "21%")
-        for r in runs[1:]:
-            r.text = ""
-        break
+# Structural edits use python-docx; text substitutions use replace_text.py above.
+d.sections[0].header.paragraphs[0].add_run(" — Reviewed")
 d.save(r"<file-edited.docx>")
 PY
 ```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-office-kit",
   "type": "module",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "Office documents, PDF, presentations, and spreadsheets for DeepSeek Harness",
   "author": "Hairy",
   "license": "MIT",

package/python/office_cli.py

@@ -631,13 +631,83 @@ def _docx_add_blocks(document, blocks: Iterable[dict[str, Any]], counters: dict[
             _docx_add_block(document, block, counters)
 
 
+def _docx_set_font(properties, family: str) -> None:
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    fonts = properties.get_or_add_rFonts()
+    # Theme attributes take precedence over literal font names in Word.
+    for attribute in list(fonts.attrib):
+        if attribute.lower().endswith("theme"):
+            del fonts.attrib[attribute]
+    for slot in ("ascii", "hAnsi", "eastAsia", "cs"):
+        fonts.set(qn(f"w:{slot}"), family)
+    language = properties.find(qn("w:lang"))
+    if language is None:
+        language = OxmlElement("w:lang")
+        properties.append(language)
+    language.set(qn("w:eastAsia"), "zh-CN")
+
+
+def _docx_normalize_styles(document, family: str) -> None:
+    from docx.oxml.ns import qn
+
+    styles = document.styles.element
+    defaults = styles.find(qn("w:docDefaults")).find(qn("w:rPrDefault")).find(qn("w:rPr"))
+    _docx_set_font(defaults, family)
+    normal = document.styles["Normal"].element
+    _docx_set_font(normal.get_or_add_rPr(), family)
+
+    # Normalize used styles and headings for content appended after creation.
+    headings = {"Title", "TitleChar"} | {
+        f"Heading{level}{suffix}" for level in range(1, 10) for suffix in ("", "Char")
+    }
+    roots = [document.element]
+    roots.extend(
+        part.element for part in document.part.related_parts.values()
+        if str(part.partname).startswith(("/word/header", "/word/footer"))
+    )
+    used = {"Normal"} | headings
+    for root in roots:
+        for node in root.iter(qn("w:pStyle"), qn("w:rStyle"), qn("w:tblStyle")):
+            used.add(node.get(qn("w:val")))
+    by_id = {style.get(qn("w:styleId")): style for style in styles.findall(qn("w:style"))}
+    pending = list(used)
+    while pending:
+        style = by_id[pending.pop()]
+        for tag in ("w:basedOn", "w:link"):
+            reference = style.find(qn(tag))
+            if reference is not None:
+                target = reference.get(qn("w:val"))
+                if target not in used:
+                    used.add(target)
+                    pending.append(target)
+
+    for style_id in used:
+        style = by_id[style_id]
+        for fonts in style.iter(qn("w:rFonts")):
+            _docx_set_font(fonts.getparent(), family)
+        for language in style.iter(qn("w:lang")):
+            language.set(qn("w:eastAsia"), "zh-CN")
+        if style_id in headings:
+            color = style.get_or_add_rPr().get_or_add_color()
+            color.attrib.clear()
+            color.set(qn("w:val"), "000000")
+        if style_id == "Title":
+            for border in style.xpath("./w:pPr/w:pBdr"):
+                border.getparent().remove(border)
+
+
 def docx_create(spec: dict[str, Any], out: Path) -> dict[str, Any]:
     from docx import Document
     from docx.shared import Pt
 
+    family = spec.get("font", "Calibri")
+    if not isinstance(family, str) or not family.strip():
+        fail("font must be a non-empty font family string")
+    family = family.strip()
     document = Document()
     style = document.styles["Normal"]
-    style.font.name = "Calibri"
     style.font.size = Pt(11)
     section = document.sections[0]
     page_size = str(spec.get("page_size", "Letter")).lower()
@@ -670,6 +740,7 @@ def docx_create(spec: dict[str, Any], out: Path) -> dict[str, Any]:
 
     counters = {key: 0 for key in ("headings", "paragraphs", "list_items", "tables", "images", "equations", "equation_fallbacks")}
     _docx_add_blocks(document, spec.get("blocks", spec.get("sections", [])), counters)
+    _docx_normalize_styles(document, family)
     ensure_parent(str(out))
     document.save(str(out))
     return {"ok": True, "kind": "docx", "command": "create", "output": str(out), "counts": counters}