dsh-office-kit 0.2.0 → 0.3.1

package/python/office_cli.py

@@ -21,7 +21,18 @@ import tempfile
 from pathlib import Path
 from typing import Any, Iterable
 
-VERSION = "0.1.0"
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+
+
+def _package_version() -> str:
+    try:
+        data = json.loads((PACKAGE_ROOT / "package.json").read_text(encoding="utf-8"))
+        return str(data["version"])
+    except (OSError, ValueError, KeyError, TypeError):
+        return "0.0.0"
+
+
+VERSION = _package_version()
 
 # Windows consoles default to a legacy code page; every payload is UTF-8 JSON.
 for _stream in (sys.stdout, sys.stderr):
@@ -93,53 +104,121 @@ def find_soffice() -> str | None:
     return found
 
 
-def office_binary(kind: str) -> str | None:
+#: Automation entry points per suite and format: (executable, COM ProgID).
+RENDER_ENGINES: dict[str, dict[str, tuple[str, str]]] = {
+    "microsoft": {
+        "docx": ("WINWORD.EXE", "Word.Application"),
+        "pptx": ("POWERPNT.EXE", "PowerPoint.Application"),
+        "xlsx": ("EXCEL.EXE", "Excel.Application"),
+    },
+    "kingsoft": {
+        "docx": ("wps.exe", "KWps.Application"),
+        "pptx": ("wpp.exe", "KWpp.Application"),
+        "xlsx": ("et.exe", "Ket.Application"),
+    },
+}
+
+
+def _kingsoft_dirs() -> list[Path]:
+    """WPS Office hides its binaries under a per-version directory."""
+    bases = [
+        os.environ.get("WPS_OFFICE_HOME"),
+        os.path.join(os.environ.get("ProgramFiles", r"C:\Program Files"), "Kingsoft", "WPS Office"),
+        os.path.join(os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)"), "Kingsoft", "WPS Office"),
+        os.path.join(os.environ.get("LOCALAPPDATA", ""), "Kingsoft", "WPS Office"),
+    ]
+    found: list[Path] = []
+    for base in bases:
+        if not base:
+            continue
+        root = Path(base)
+        if (root / "office6").is_dir():
+            found.append(root / "office6")
+            continue
+        if not root.is_dir():
+            continue
+        versions = [child for child in root.iterdir() if (child / "office6").is_dir()]
+        versions.sort(key=lambda child: [int(part) if part.isdigit() else part for part in child.name.replace("-", ".").split(".")], reverse=True)
+        for child in versions:
+            found.append(child / "office6")
+    return found
+
+
+def office_engine(kind: str, family: str | None = None) -> tuple[str, str] | None:
+    """Return (suite, executable) for an installed Office-compatible application."""
     if sys.platform != "win32":
         return None
-    names = {"docx": "WINWORD.EXE", "pptx": "POWERPNT.EXE", "xlsx": "EXCEL.EXE"}
-    name = names[kind]
-    roots = [
-        r"C:\Program Files\Microsoft Office\root\Office16",
-        r"C:\Program Files (x86)\Microsoft Office\root\Office16",
-        r"C:\Program Files\Microsoft Office\Office16",
-        r"C:\Program Files (x86)\Microsoft Office\Office16",
-    ]
-    for root in roots:
-        candidate = Path(root) / name
-        if candidate.is_file():
-            return str(candidate)
+    families = [family] if family else ["microsoft", "kingsoft"]
+    for name in families:
+        executable = RENDER_ENGINES[name][kind][0]
+        if name == "microsoft":
+            roots = [
+                r"C:\Program Files\Microsoft Office\root\Office16",
+                r"C:\Program Files (x86)\Microsoft Office\root\Office16",
+                r"C:\Program Files\Microsoft Office\Office16",
+                r"C:\Program Files (x86)\Microsoft Office\Office16",
+            ]
+            for root in roots:
+                candidate = Path(root) / executable
+                if candidate.is_file():
+                    return name, str(candidate)
+            continue
+        for directory in _kingsoft_dirs():
+            candidate = directory / executable
+            if candidate.is_file():
+                return name, str(candidate)
     return None
 
 
+def office_binary(kind: str) -> str | None:
+    engine = office_engine(kind)
+    return engine[1] if engine else None
+
+
+def _engine_path(kind: str, family: str) -> str | None:
+    engine = office_engine(kind, family)
+    return engine[1] if engine else None
+
+
 def _powershell() -> str | None:
     return shutil.which("powershell") or shutil.which("pwsh")
 
 
-def _office_script(kind: str) -> str:
+def _office_script(kind: str, family: str) -> str:
+    progid = RENDER_ENGINES[family][kind][1]
     if kind == "docx":
-        return r"""
+        if family == "kingsoft":
+            return rf"""
+$ErrorActionPreference = 'Stop'
+$app = New-Object -ComObject {progid}
+$app.Visible = $false
+$app.DisplayAlerts = 0
+$doc = $app.Documents.Open($env:DSH_INPUT, $false, $true)
+try {{ $doc.SaveAs([ref]$env:DSH_PDF, [ref]17) }} finally {{ $doc.Close(0); $app.Quit() }}
+"""
+        return rf"""
 $ErrorActionPreference = 'Stop'
-$app = New-Object -ComObject Word.Application
+$app = New-Object -ComObject {progid}
 $app.Visible = $false
 $app.DisplayAlerts = 0
 $doc = $app.Documents.Open($env:DSH_INPUT, $false, $true)
-try { $doc.ExportAsFixedFormat($env:DSH_PDF, 17) } finally { $doc.Close(0); $app.Quit() }
+try {{ $doc.ExportAsFixedFormat($env:DSH_PDF, 17) }} finally {{ $doc.Close(0); $app.Quit() }}
 """
     if kind == "pptx":
-        return r"""
+        return rf"""
 $ErrorActionPreference = 'Stop'
-$app = New-Object -ComObject PowerPoint.Application
+$app = New-Object -ComObject {progid}
 $app.DisplayAlerts = 1
 $pres = $app.Presentations.Open($env:DSH_INPUT, $true, $false, $false)
-try { $pres.SaveAs($env:DSH_PDF, 32) } finally { $pres.Close(); $app.Quit() }
+try {{ $pres.SaveAs($env:DSH_PDF, 32) }} finally {{ $pres.Close(); $app.Quit() }}
 """
-    return r"""
+    return rf"""
 $ErrorActionPreference = 'Stop'
-$app = New-Object -ComObject Excel.Application
+$app = New-Object -ComObject {progid}
 $app.Visible = $false
 $app.DisplayAlerts = $false
 $wb = $app.Workbooks.Open($env:DSH_INPUT)
-try { $wb.ExportAsFixedFormat(0, $env:DSH_PDF) } finally { $wb.Close($false); $app.Quit() }
+try {{ $wb.ExportAsFixedFormat(0, $env:DSH_PDF) }} finally {{ $wb.Close($false); $app.Quit() }}
 """
 
 
@@ -151,28 +230,33 @@ def export_pdf(input_path: Path, kind: str, out_dir: Path) -> tuple[str, str]:
         pdf.unlink()
 
     power_shell = _powershell()
-    if power_shell and office_binary(kind):
-        script = Path(tempfile.gettempdir()) / f"dsh-office-{kind}-{os.getpid()}.ps1"
-        script.write_text(_office_script(kind), encoding="utf-8")
-        env = dict(os.environ)
-        env["DSH_INPUT"] = str(input_path.resolve())
-        env["DSH_PDF"] = str(pdf.resolve())
-        try:
-            completed = subprocess.run(
-                [power_shell, "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", str(script)],
-                capture_output=True,
-                text=True,
-                timeout=240,
-                env=env,
-            )
-        except subprocess.TimeoutExpired:
-            fail(f"Microsoft Office export timed out for {input_path.name}")
-        finally:
-            script.unlink(missing_ok=True)
-        if completed.returncode != 0 or not pdf.is_file():
-            detail = (completed.stderr or completed.stdout).strip()
-            fail(f"Microsoft Office export failed for {input_path.name}", detail=detail or None)
-        return "microsoft-office", str(pdf)
+    failures: list[str] = []
+    if power_shell:
+        for family, renderer in (("microsoft", "microsoft-office"), ("kingsoft", "kingsoft-wps")):
+            engine = office_engine(kind, family)
+            if engine is None:
+                continue
+            script = Path(tempfile.gettempdir()) / f"dsh-office-{kind}-{os.getpid()}.ps1"
+            script.write_text(_office_script(kind, family), encoding="utf-8")
+            env = dict(os.environ)
+            env["DSH_INPUT"] = str(input_path.resolve())
+            env["DSH_PDF"] = str(pdf.resolve())
+            try:
+                completed = subprocess.run(
+                    [power_shell, "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", str(script)],
+                    capture_output=True,
+                    text=True,
+                    timeout=240,
+                    env=env,
+                )
+            except subprocess.TimeoutExpired:
+                failures.append(f"{family}: timed out")
+                continue
+            finally:
+                script.unlink(missing_ok=True)
+            if completed.returncode == 0 and pdf.is_file():
+                return renderer, str(pdf)
+            failures.append(f"{family}: " + ((completed.stderr or completed.stdout).strip() or "no PDF produced"))
 
     soffice = find_soffice()
     if soffice:
@@ -187,7 +271,10 @@ def export_pdf(input_path: Path, kind: str, out_dir: Path) -> tuple[str, str]:
             fail(f"LibreOffice export failed for {input_path.name}", detail=detail or None)
         return "libreoffice", str(pdf)
 
-    fail("no document renderer found: install LibreOffice or Microsoft Office (Word/PowerPoint/Excel)")
+    fail(
+        "no document renderer found: install LibreOffice, Microsoft Office, or WPS Office",
+        detail="; ".join(failures) or None,
+    )
 
 
 def rasterize_pdf(pdf: str, out_dir: Path, dpi: int = 110) -> list[str]:
@@ -263,6 +350,16 @@ def _docx_add_equation(paragraph, latex: str) -> bool:
         return False
 
 
+def _docx_mark_header_row(row) -> None:
+    """Repeat this row across pages and mark it as a header for assistive tech."""
+    from docx.oxml.ns import qn
+
+    properties = row._tr.get_or_add_trPr()
+    if properties.find(qn("w:tblHeader")) is None:
+        header = properties.makeelement(qn("w:tblHeader"), {})
+        properties.append(header)
+
+
 def _docx_add_block(document, block: dict[str, Any], counters: dict[str, int]) -> None:
     from docx.shared import Inches, Pt
 
@@ -315,6 +412,7 @@ def _docx_add_block(document, block: dict[str, Any], counters: dict[str, int]) -
                 for paragraph in cells[index].paragraphs:
                     for run in paragraph.runs:
                         run.bold = True
+            _docx_mark_header_row(table.rows[0])
         for row in rows:
             cells = table.add_row().cells
             for index, value in enumerate(row):
@@ -383,6 +481,10 @@ def docx_create(spec: dict[str, Any], out: Path) -> dict[str, Any]:
     if spec.get("author") or spec.get("title"):
         document.core_properties.title = str(spec.get("title", ""))
         document.core_properties.author = str(spec.get("author", ""))
+        # A fresh python-docx document carries the library name in comments; a
+        # delivered file should not advertise the tool that wrote it.
+        document.core_properties.comments = str(spec.get("comments", ""))
+        document.core_properties.last_modified_by = str(spec.get("author", ""))
     if spec.get("header"):
         document.sections[0].header.paragraphs[0].text = str(spec["header"])
     if spec.get("footer"):
@@ -424,38 +526,6 @@ def _replace_in_paragraph(paragraph, find: str, replacement: str) -> int:
     return count
 
 
-def docx_edit(spec: dict[str, Any], input_path: Path, out: Path) -> dict[str, Any]:
-    from docx import Document
-
-    document = Document(str(input_path))
-    replace_count = 0
-    for item in spec.get("replace", []):
-        find = str(item.get("find", ""))
-        replacement = str(item.get("replace", ""))
-        if not find:
-            continue
-        for paragraph in _docx_iter_paragraphs(document):
-            replace_count += _replace_in_paragraph(paragraph, find, replacement)
-    counters = {key: 0 for key in ("headings", "paragraphs", "list_items", "tables", "images", "equations", "equation_fallbacks")}
-    _docx_add_blocks(document, spec.get("blocks", []), counters)
-    core = spec.get("core")
-    if isinstance(core, dict):
-        for key in ("title", "author", "subject", "keywords", "comments"):
-            if key in core:
-                setattr(document.core_properties, key, str(core[key]))
-    ensure_parent(str(out))
-    document.save(str(out))
-    return {
-        "ok": True,
-        "kind": "docx",
-        "command": "edit",
-        "input": str(input_path),
-        "output": str(out),
-        "replacements": replace_count,
-        "counts": counters,
-    }
-
-
 def _docx_has_equation(paragraph) -> bool:
     tag = "{http://schemas.openxmlformats.org/officeDocument/2006/math}oMath"
     return bool(paragraph._p.findall(f".//{tag}"))
@@ -615,17 +685,21 @@ def pdf_create(spec: dict[str, Any], out: Path) -> dict[str, Any]:
         author=str(spec.get("author", "")),
     )
     counters = {key: 0 for key in ("headings", "paragraphs", "list_items", "tables", "images")}
+    following: list[dict[str, Any]] = []
+    for page in spec.get("pages", []):
+        if isinstance(page, dict):
+            following.extend(page.get("blocks", []))
+            if page.get("break", True):
+                following.append({"type": "page_break"})
+    following.extend(spec.get("blocks", []))
+    kinds = {str(block.get("type", "")).lower() for block in following if isinstance(block, dict)}
     blocks: list[dict[str, Any]] = []
-    if spec.get("title"):
+    # `title` is metadata; only draw it when the blocks do not already carry one.
+    if spec.get("title") and "title" not in kinds:
         blocks.append({"type": "title", "text": spec["title"]})
     if spec.get("subtitle"):
         blocks.append({"type": "paragraph", "text": spec["subtitle"]})
-    for page in spec.get("pages", []):
-        if isinstance(page, dict):
-            blocks.extend(page.get("blocks", []))
-            if page.get("break", True):
-                blocks.append({"type": "page_break"})
-    blocks.extend(spec.get("blocks", []))
+    blocks.extend(following)
     document.build(_pdf_flowables(blocks, font, counters))
     return {"ok": True, "kind": "pdf", "command": "create", "output": str(out), "font": font, "counts": counters}
 
@@ -667,45 +741,6 @@ def pdf_read(input_path: Path) -> dict[str, Any]:
     }
 
 
-def pdf_edit(spec: dict[str, Any], input_path: Path, out: Path) -> dict[str, Any]:
-    from pypdf import PdfReader, PdfWriter
-
-    writer = PdfWriter()
-    reader = PdfReader(str(input_path))
-    for page in reader.pages:
-        writer.add_page(page)
-    rotate = int(spec.get("rotate", 0))
-    targets = spec.get("pages")
-    if rotate:
-        for index, page in enumerate(writer.pages):
-            if targets is None or index in targets:
-                page.rotate(rotate)
-    for extra in spec.get("merge", []):
-        extra_reader = PdfReader(str(require_file(str(extra), "PDF to merge")))
-        for page in extra_reader.pages:
-            writer.add_page(page)
-    if spec.get("remove_pages"):
-        remove = set(int(value) for value in spec["remove_pages"])
-        writer = PdfWriter()
-        for index, page in enumerate(reader.pages):
-            if index not in remove:
-                writer.add_page(page)
-        for extra in spec.get("merge", []):
-            extra_reader = PdfReader(str(require_file(str(extra), "PDF to merge")))
-            for page in extra_reader.pages:
-                writer.add_page(page)
-    if isinstance(spec.get("metadata"), dict):
-        metadata = {}
-        for key, value in spec["metadata"].items():
-            name = str(key)
-            metadata[name if name.startswith("/") else f"/{name}"] = str(value)
-        writer.add_metadata(metadata)
-    ensure_parent(str(out))
-    with open(out, "wb") as handle:
-        writer.write(handle)
-    return {"ok": True, "kind": "pdf", "command": "edit", "input": str(input_path), "output": str(out), "page_count": len(writer.pages)}
-
-
 def pdf_render(input_path: Path, out_dir: Path, dpi: int) -> dict[str, Any]:
     pages = rasterize_pdf(str(input_path), out_dir, dpi)
     return {"ok": True, "kind": "pdf", "command": "render", "input": str(input_path), "page_count": len(pages), "pages": pages}
@@ -844,6 +879,10 @@ def pptx_create(spec: dict[str, Any], out: Path) -> dict[str, Any]:
     prs.slide_height = int(7.5 * 914400)
     prs.core_properties.title = str(spec.get("title", ""))
     prs.core_properties.author = str(spec.get("author", "DSH Office Suite"))
+    # python-pptx leaves its own name in the properties; a delivered deck should
+    # carry the author's, not the library's.
+    prs.core_properties.comments = str(spec.get("comments", ""))
+    prs.core_properties.last_modified_by = str(spec.get("author", "DSH Office Suite"))
     counters = {key: 0 for key in ("slides", "bullets", "tables", "charts", "images")}
     for slide_spec in spec.get("slides", []):
         if isinstance(slide_spec, dict):
@@ -912,38 +951,6 @@ def pptx_read(input_path: Path) -> dict[str, Any]:
     }
 
 
-def pptx_edit(spec: dict[str, Any], input_path: Path, out: Path) -> dict[str, Any]:
-    from pptx import Presentation
-
-    prs = Presentation(str(input_path))
-    replacements = 0
-    for item in spec.get("replace", []):
-        find = str(item.get("find", ""))
-        replacement = str(item.get("replace", ""))
-        if not find:
-            continue
-        for slide in prs.slides:
-            for shape in slide.shapes:
-                if not shape.has_text_frame:
-                    continue
-                for paragraph in shape.text_frame.paragraphs:
-                    for run in paragraph.runs:
-                        if find in run.text:
-                            run.text = run.text.replace(find, replacement)
-                            replacements += 1
-    counters = {key: 0 for key in ("slides", "bullets", "tables", "charts", "images")}
-    for slide_spec in spec.get("slides", []):
-        if isinstance(slide_spec, dict):
-            _pptx_add_slide(prs, slide_spec, counters)
-    if isinstance(spec.get("core"), dict):
-        for key in ("title", "author", "subject", "keywords", "comments"):
-            if key in spec["core"]:
-                setattr(prs.core_properties, key, str(spec["core"][key]))
-    ensure_parent(str(out))
-    prs.save(str(out))
-    return {"ok": True, "kind": "pptx", "command": "edit", "input": str(input_path), "output": str(out), "replacements": replacements, "added": counters}
-
-
 # ---------------------------------------------------------------------------
 # XLSX
 # ---------------------------------------------------------------------------
@@ -1113,86 +1120,26 @@ def xlsx_read(input_path: Path, data_only: bool = False) -> dict[str, Any]:
     }
 
 
-def xlsx_edit(spec: dict[str, Any], input_path: Path, out: Path) -> dict[str, Any]:
-    from openpyxl import load_workbook
-    from openpyxl.drawing.image import Image as XLImage
-
-    workbook = load_workbook(str(input_path))
-    changed = 0
-    for operation in spec.get("operations", []):
-        if not isinstance(operation, dict):
-            continue
-        action = str(operation.get("action", "set"))
-        if action == "add_sheet":
-            title = str(operation.get("name", "Sheet"))
-            worksheet = workbook.create_sheet(title)
-        elif action == "delete_sheet":
-            name = str(operation.get("name", ""))
-            if name not in workbook.sheetnames:
-                fail(f"sheet not found: {name}")
-            workbook.remove(workbook[name])
-            continue
-        elif action == "rename_sheet":
-            old = str(operation.get("from", ""))
-            new = str(operation.get("to", ""))
-            if old not in workbook.sheetnames:
-                fail(f"sheet not found: {old}")
-            workbook[old].title = new
-            continue
-        else:
-            name = str(operation.get("sheet", workbook.sheetnames[0]))
-            if name not in workbook.sheetnames:
-                fail(f"sheet not found: {name}")
-            worksheet = workbook[name]
-            if action == "set_cells":
-                for address, value in (operation.get("cells") or {}).items():
-                    worksheet[str(address)] = _xlsx_value(value)
-                    changed += 1
-            elif action == "append_rows":
-                for row in operation.get("rows", []):
-                    worksheet.append([_xlsx_value(value) for value in row])
-                    changed += 1
-            elif action == "style":
-                for address, style in (operation.get("cells") or {}).items():
-                    if isinstance(style, dict):
-                        for cell in _xlsx_cells(worksheet, str(address)):
-                            _xlsx_apply_style(cell, style)
-                            changed += 1
-            elif action == "chart":
-                _xlsx_add_chart(worksheet, operation)
-                changed += 1
-            elif action == "image":
-                path = require_file(str(operation.get("path", "")), "image")
-                worksheet.add_image(XLImage(str(path)), str(operation.get("anchor", "A1")))
-                changed += 1
-            elif action == "rows":
-                for row in operation.get("rows", []):
-                    worksheet.append([_xlsx_value(value) for value in row])
-                    changed += 1
-    ensure_parent(str(out))
-    workbook.save(str(out))
-    workbook.close()
-    return {"ok": True, "kind": "xlsx", "command": "edit", "input": str(input_path), "output": str(out), "changes": changed}
-
-
 def xlsx_recalc(input_path: Path, out: Path) -> dict[str, Any]:
-    """Force Microsoft Excel to recalculate and save cached formula values."""
-    if sys.platform != "win32" or office_binary("xlsx") is None:
-        fail("formula recalculation requires Microsoft Excel on Windows; openpyxl cannot evaluate formulas")
+    """Force a spreadsheet application to recalculate and store cached formula values."""
+    engine = office_engine("xlsx") if sys.platform == "win32" else None
+    if engine is None or _powershell() is None:
+        fail("formula recalculation requires Microsoft Excel or WPS Spreadsheets on Windows; openpyxl cannot evaluate formulas")
+    family, executable = engine
+    progid = RENDER_ENGINES[family]["xlsx"][1]
+    ensure_parent(str(out))
+    if out.resolve() != input_path.resolve():
+        shutil.copyfile(input_path, out)
     script = Path(tempfile.gettempdir()) / f"dsh-office-recalc-{os.getpid()}.ps1"
-    script.write_text(r"""
+    script.write_text(rf"""
 $ErrorActionPreference = 'Stop'
-$app = New-Object -ComObject Excel.Application
+$app = New-Object -ComObject {progid}
 $app.Visible = $false
 $app.DisplayAlerts = $false
-$wb = $app.Workbooks.Open($env:DSH_INPUT)
-try {
-  $app.CalculateFull()
-  $wb.SaveAs($env:DSH_OUT, 51)
-} finally { $wb.Close($false); $app.Quit() }
+$wb = $app.Workbooks.Open($env:DSH_OUT)
+try {{ $app.CalculateFull(); $wb.Save() }} finally {{ $wb.Close($true); $app.Quit() }}
 """, encoding="utf-8")
     env = dict(os.environ)
-    env["DSH_INPUT"] = str(input_path.resolve())
     env["DSH_OUT"] = str(out.resolve())
     try:
         completed = subprocess.run(
@@ -1205,8 +1152,28 @@ try {
     finally:
         script.unlink(missing_ok=True)
     if completed.returncode != 0 or not out.is_file():
-        fail("Excel recalculation failed", detail=(completed.stderr or completed.stdout).strip() or None)
-    return {"ok": True, "kind": "xlsx", "command": "recalc", "input": str(input_path), "output": str(out)}
+        fail("formula recalculation failed", detail=(completed.stderr or completed.stdout).strip() or None)
+    cached = 0
+    try:
+        import openpyxl
+
+        workbook = openpyxl.load_workbook(str(out), data_only=True)
+        for sheet in workbook.worksheets:
+            for row in sheet.iter_rows():
+                cached += sum(1 for cell in row if cell.value is not None)
+        workbook.close()
+    except Exception:
+        cached = 0
+    return {
+        "ok": True,
+        "kind": "xlsx",
+        "command": "recalc",
+        "input": str(input_path),
+        "output": str(out),
+        "renderer": f"{family}-office" if family == "microsoft" else "kingsoft-wps",
+        "executable": executable,
+        "cached_values": cached,
+    }
 
 
 # ---------------------------------------------------------------------------
@@ -1246,9 +1213,20 @@ def status() -> dict[str, Any]:
         "renderers": {
             "libreoffice": find_soffice(),
             "microsoft_office": {
-                "word": office_binary("docx"),
-                "powerpoint": office_binary("pptx"),
-                "excel": office_binary("xlsx"),
+                "word": _engine_path("docx", "microsoft"),
+                "powerpoint": _engine_path("pptx", "microsoft"),
+                "excel": _engine_path("xlsx", "microsoft"),
+            },
+            "kingsoft_wps": {
+                "writer": _engine_path("docx", "kingsoft"),
+                "presentation": _engine_path("pptx", "kingsoft"),
+                "spreadsheet": _engine_path("xlsx", "kingsoft"),
+            },
+            "can_render": {
+                "docx": bool(office_engine("docx") or find_soffice()),
+                "pptx": bool(office_engine("pptx") or find_soffice()),
+                "xlsx": bool(office_engine("xlsx") or find_soffice()),
+                "pdf": True,
             },
         },
     }
@@ -1280,13 +1258,6 @@ def main() -> None:
         render.add_argument("--dpi", type=int, default=110)
         render.add_argument("--json-out")
 
-        if kind in {"docx", "pdf", "pptx", "xlsx"}:
-            edit = commands.add_parser("edit")
-            edit.add_argument("--input", required=True)
-            edit.add_argument("--spec", required=True)
-            edit.add_argument("--out", required=True)
-            edit.add_argument("--json-out")
-
         if kind == "xlsx":
             recalc = commands.add_parser("recalc")
             recalc.add_argument("--input", required=True)
@@ -1321,18 +1292,6 @@ def main() -> None:
                 result = pptx_read(input_path)
             else:
                 result = xlsx_read(input_path, data_only=bool(getattr(args, "data_only", False)))
-        elif args.command == "edit":
-            input_path = require_file(args.input)
-            spec = load_json(args.spec)
-            out = Path(args.out)
-            if args.format == "docx":
-                result = docx_edit(spec, input_path, out)
-            elif args.format == "pdf":
-                result = pdf_edit(spec, input_path, out)
-            elif args.format == "pptx":
-                result = pptx_edit(spec, input_path, out)
-            else:
-                result = xlsx_edit(spec, input_path, out)
         elif args.command == "render":
             input_path = require_file(args.input)
             out_dir = Path(args.out_dir)