@deepseek-ai/dsh-skill-office 0.1.6-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/skill/skill-office/README.md
+README.md: 18cb08a027a447bbb66e35061d25fe853f51977a
+README.zh.md: 432043c5a06116f3f2928c995301ff032cda75bb

package/README.md

@@ -0,0 +1,100 @@
+---
+description: "Bundled Word, PowerPoint, and Excel instructions for deployments providing Office file authoring and structural checks."
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-skill-office
+
+English | [中文](README.zh.md)
+
+## Summary
+
+Agents can load Word, PowerPoint, and Excel workflows that use the bundled Python environment by default and respect explicit user or AGENTS.md environment choices. The skills cover creation, focused edits, structural checks, and file delivery. Visual inspection is conditional on image-capable models and an available rendering tool; ordinary document delivery does not require installing a renderer.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Mount this provider beside the skill registry and `dsh-tool-skill` to expose `office-docx`, `office-pptx`, and `office-xlsx` in the session catalog. The provider supplies instructions and scripts; the deployment supplies its interpreters, authoring libraries, execution tools, and file delivery tool.
+
+### Minimal configuration
+
+```yaml
+- name: '@deepseek-ai/dsh-skill-office'
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `assetRoot` | Packaged `assets/` | Absolute resource directory containing the three skill folders and shared `scripts/`; deployments can place it outside an application archive. |
+
+Relative paths, missing resources, and skill files without a YAML frontmatter description reject activation. Disposing the plugin removes its candidates. Project and user skill precedence remains owned by the skill registry.
+
+### Structural checks
+
+The shared Python checker reads DOCX, PPTX, or XLSX without modifying the source. It recognizes Transitional and Strict OOXML namespaces, validates ZIP/XML and internal package relationships, reports document structure, and optionally checks required text or slide/sheet count. DOCX text assertions cover the main body, section-referenced headers and footers, and body-referenced footnotes and endnotes; comments, glossary text, and unreferenced parts or notes do not satisfy them. It uses only the Python standard library. Invalid packages, corrupt or encrypted ZIP members, and report-file write failures produce a JSON failure report on stdout. A passing report does not establish appearance, feature preservation, or calculated formula results.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+The provider registers three bundled candidates and reads their descriptions from the shipped YAML frontmatter at activation. Loaded instruction bodies exclude that metadata. Each loaded skill exposes its own filesystem directory, so the execution tool can resolve the shared checker without relying on the task working directory. Configurable external resources support carriers whose application archive is not readable by Python.
+
+| File | Responsibility |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Provider registration and configured resource paths. |
+| [`assets/`](assets/) | Three workflows and the read-only OOXML checker. |
+| — | No runtime invariant companion is published: the provider owns immutable candidates, and the skill registry owns registration lifecycle and precedence. |
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+- [Skill registry](../skill/README.md) — discovery and precedence.
+- [Skill tool](../tool-skill/README.md) — model-visible catalogs and bodies.
+- [File delivery](../../deliverables/tool-present/README.md) — current source-path delivery.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+Indirectly, through `dsh-tool-skill`, which renders the catalog entries and selected instruction body.
+
+#### KV Cache effect
+
+Mounting the provider adds three catalog entries; loading a skill adds its body at the existing skill-tool insertion point. The provider does not add separate prompt sections.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- The provider does not install Python, authoring libraries, or a rendering engine. The checker requires Python 3.9 or later.
+- Structural checks do not judge pagination, clipping, fonts, chart appearance, or Excel recalculation.
+- The checker accepts DOCX, PPTX, and XLSX only; legacy, encrypted, and macro-enabled formats require an appropriate separate workflow.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,100 @@
+---
+description: "随包附带的 Word、PowerPoint 和 Excel 指令，供需要 Office 文件编写与结构检查能力的部署使用。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-skill-office
+
+[English](README.md) | 中文
+
+## 概述
+
+Agent（智能体）可以加载 Word、PowerPoint 和 Excel 工作流，默认使用内置 Python 环境，并遵循用户或 AGENTS.md 明确指定的环境。这些 skill（技能）涵盖创建、局部编辑、结构检查和文件交付。视觉检查以模型支持图片且有可用渲染工具为前提；普通文档交付不要求安装渲染器。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [了解实现](#understand-the-implementation)
+- [延伸阅读](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与暂缓事项](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+将本提供方与 skill 注册表及 `dsh-tool-skill` 一同挂载，即可在会话目录中提供 `office-docx`、`office-pptx` 和 `office-xlsx`。提供方携带指令和脚本；部署提供解释器、编写库、执行工具与文件交付工具。
+
+### 最小配置
+
+```yaml
+- name: '@deepseek-ai/dsh-skill-office'
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `assetRoot` | 包内的 `assets/` | 包含三个 skill 文件夹和共享 `scripts/` 的绝对资源目录；部署可将其放在应用归档之外。 |
+
+相对路径、资源缺失或 skill 文件的 YAML frontmatter 缺少描述都会导致激活失败。卸载插件会移除其候选项。项目和用户 skill 的优先级仍由 skill 注册表负责。
+
+### 结构检查
+
+共享 Python 检查器读取 DOCX、PPTX 或 XLSX，不修改源文件。它识别 Transitional 与 Strict OOXML 命名空间，验证 ZIP/XML 和包内引用关系，报告文档结构，并可检查必需文本或幻灯片／工作表数量。DOCX 文本断言覆盖正文、分节引用的页眉和页脚，以及正文引用的脚注和尾注；批注、词库文本与未引用的部件或脚注／尾注不能满足断言。它只使用 Python 标准库。无效包、损坏或加密的 ZIP 成员和报告文件写入失败都会在标准输出中产生 JSON 失败报告。检查通过不代表外观、特性保留或公式计算结果已得到验证。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 了解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+提供方注册三个内置候选项，并在激活时从随包 YAML frontmatter 读取描述。加载后的指令正文不包含这些元数据。加载后的每个 skill 暴露自己的文件系统目录，因此执行工具可以定位共享检查器，而不依赖任务工作目录。可配置的外部资源支持 Python 无法读取应用归档的分发方式。
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 提供方注册与配置资源路径。 |
+| [`assets/`](assets/) | 三种工作流和只读 OOXML 检查器。 |
+| — | 不发布运行时不变量伴随入口：提供方拥有不可变候选项，skill 注册表负责注册生命周期和优先级。 |
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 延伸阅读
+
+- [skill 注册表](../skill/README.zh.md)——发现与优先级。
+- [skill 工具](../tool-skill/README.zh.md)——模型可见目录与正文。
+- [文件交付](../../deliverables/tool-present/README.zh.md)——当前源路径交付。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+通过 `dsh-tool-skill` 间接呈现，由其渲染目录项与选中的指令正文。
+
+#### KV 缓存影响
+
+挂载提供方会增加三个目录项；加载 skill 时，其正文进入既有 skill 工具的插入位置。提供方不另增提示词分区。
+
+## 已知限制与暂缓事项
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- 提供方不安装 Python、编写库或渲染引擎。检查器要求 Python 3.9 或更高版本。
+- 结构检查不判断分页、裁切、字体、图表外观或 Excel 重算。
+- 检查器只接受 DOCX、PPTX 和 XLSX；传统格式、加密文件和启用宏的格式需要合适的其他工作流。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/assets/office-docx/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: office-docx
+description: Create, read, edit, and check Word documents (.docx), including reports, letters, and formatted tables. Use when a DOCX file is an input or requested deliverable.
+---
+
+# Word documents
+
+Use `python-docx` for DOCX creation and ordinary edits. Follow an explicit user or applicable AGENTS.md requirement for a project environment or another library. Otherwise call `load_workspace_dependencies` and execute the returned Python path with its bundled libraries. Do not install packages or discover a system Python for the default workflow. If the tool is unavailable, use an already configured environment and report a missing dependency only when it prevents the requested operation.
+
+Keep source scripts, intermediate files, and final documents in the task workspace; the runtime and this skill directory are read-only resources. Use the user's requested language and preserve an existing document's design unless a redesign is requested.
+
+## Create and edit
+
+For existing files, inspect paragraphs, runs, tables, sections, headers, and footers before changing the affected content. Save to a new file unless the user requests an in-place edit. Replacing a paragraph's `.text` destroys its run formatting; change the relevant runs when formatting must survive. Reconstructing the whole document can lose features outside python-docx's supported editing API.
+
+Use paragraph styles for headings and body text. Size tables for the section that contains them, and account for merged cells and nested tables. Chinese, Japanese, and Korean text may need an explicit `w:eastAsia` font assignment in addition to `run.font.name`; font names alone do not establish glyph availability or rendered appearance.
+
+For a new document, use the selected Python executable:
+
+```python
+from docx import Document
+
+document = Document()
+document.add_heading("Project report", level=0)
+document.add_paragraph("Summary", style="Heading 1")
+document.add_paragraph("The requested findings go here.")
+document.save("report.docx")
+```
+
+python-docx does not paginate or render documents. Do not represent ordinary replacement, colored text, or comments as tracked changes. When real revisions or unsupported OOXML features matter, preserve their package parts and verify the requested operation rather than silently discarding them.
+
+## Check and deliver
+
+Run the shared checker with the selected Python executable; `<skill-directory>` is this loaded skill's resource base:
+
+```text
+<python> <skill-directory>/../scripts/check_office.py <document.docx> --out <checks.json>
+```
+
+It checks ZIP/XML integrity and internal relationships, and reports paragraphs, logical table dimensions, and sections. Optional `--contains TEXT` arguments assert required text. A successful structural check does not verify pagination, clipping, fonts, or visual appearance. Compare the summary and reopened document with the user's request, including unchanged content that matters to an edit.
+
+If `render_document` is available and visual inspection is useful, call it on the final DOCX without `pages` to prepare page 1 and learn `pageCount`. It checks the current main model's actual image capability; do not choose a second model. On `status: "skipped"`, complete structural and content checks and deliver the document, briefly stating that visual layout was not inspected. On a ready result, call `read_image` on `pages[].imagePath` and request remaining pages in small batches. Check page breaks, clipped text, headings, table widths, and consistency with the requested format or source design. Fix the source and render affected pages again.
+
+Use the available rendering tool for this check. Review `warnings` such as missing fonts. LibreOffice pagination can differ from Microsoft Word. If rendering is unavailable or fails, preserve the usable document and report the inspection limit; do not require the user to install a renderer.
+
+Call `present({"files":[{"path":"report.docx"}]})` with the actual final DOCX path. It exposes the current source file without copying or preserving its bytes, so keep that file in place and do not present temporary QA reports unless requested. If `present` is unavailable, provide the final workspace path using the session's supported file delivery method.

package/assets/office-pptx/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: office-pptx
+description: Create, read, edit, and check PowerPoint presentations (.pptx), including slide text, tables, images, and charts. Use when a PPTX file is an input or requested deliverable.
+---
+
+# PowerPoint presentations
+
+Follow an explicit user or applicable AGENTS.md requirement for an environment or library. Otherwise call `load_workspace_dependencies` and use its Python executable and bundled presentation libraries. Do not install npm or pip packages or locate a system interpreter for the default workflow. If the tool is unavailable, use an already configured environment and report a missing dependency only when it prevents the requested operation.
+
+Keep scripts and output files in the task workspace. The runtime and skill directory contain shared read-only resources. Match the requested slide language and the supplied presentation's design when editing it.
+
+## Create and edit
+
+Use `python-pptx` to inspect or modify an existing presentation. Inspect slide layouts, text runs, images, tables, and charts before editing. Change only the requested content, preserve mixed text formatting, and save to a new file unless the user requests an in-place edit. Rebuilding slides can discard unsupported animation, SmartArt, or other extension content.
+
+For a new deck, use `python-pptx` with editable text, tables, and charts. Use local image assets rather than network-dependent image URLs. Set slide dimensions, text sizes, and chart data explicitly.
+
+A minimal editable deck, run with the selected Python executable:
+
+```python
+from pptx import Presentation
+from pptx.chart.data import CategoryChartData
+from pptx.enum.chart import XL_CHART_TYPE
+from pptx.util import Inches, Pt
+
+presentation = Presentation()
+presentation.slide_width = Inches(13.333)
+presentation.slide_height = Inches(7.5)
+slide = presentation.slides.add_slide(presentation.slide_layouts[6])
+title = slide.shapes.add_textbox(Inches(0.6), Inches(0.4), Inches(12), Inches(0.8))
+run = title.text_frame.paragraphs[0].add_run()
+run.text = "Quarterly report"
+run.font.size = Pt(30)
+data = CategoryChartData()
+data.categories = ["Q1", "Q2"]
+data.add_series("Revenue", [12, 18])
+slide.shapes.add_chart(XL_CHART_TYPE.COLUMN_CLUSTERED,
+                       Inches(0.8), Inches(1.6), Inches(11.5), Inches(4.8), data)
+presentation.save("report.pptx")
+```
+
+Use `Inches` or `Cm` for positions and sizes and `Pt` for font sizes. To edit a generated title while retaining its other slides and charts:
+
+```python
+from pptx import Presentation
+
+presentation = Presentation("report.pptx")
+for shape in presentation.slides[0].shapes:
+    if shape.has_text_frame and shape.text == "Quarterly report":
+        shape.text_frame.paragraphs[0].runs[0].text = "Quarterly results"
+presentation.save("report-edited.pptx")
+```
+
+Check that text and images fit the slide dimensions, titles form a useful sequence, and chart labels agree with source values. A native chart's embedded workbook is part of the deliverable and must contain the intended data. Library support for writing PPTX is not a rendering engine or a guarantee that every PowerPoint feature survives editing.
+
+## Check and deliver
+
+Run the shared checker with the selected Python executable; `<skill-directory>` is this loaded skill's resource base:
+
+```text
+<python> <skill-directory>/../scripts/check_office.py <presentation.pptx> --out <checks.json>
+```
+
+It checks ZIP/XML integrity and internal relationships and reports slide count and extracted text. Use repeated `--contains TEXT` arguments for required slide text and `--count N` for a requested slide count; `--contains` excludes chart text and speaker notes. Reopen the file to check the requested edits, chart data, and notes. Structural success does not establish text fit, alignment, readable contrast, or rendering fidelity.
+
+If `render_document` is available and visual inspection is useful, call it on the final PPTX, initially omitting `pages` to prepare page 1 and obtain `pageCount`. The tool checks the current main model's actual image capability; do not choose a second model. If `status` is `skipped`, complete structural and content checks and deliver the PPTX, briefly stating that visual layout was not inspected. If ready, call `read_image` on its returned `pages[].imagePath`, then inspect remaining slides in small batches such as `pages: [2, 3, 4]`. Check clipping, alignment, contrast, chart labels, and consistency with the requested design or supplied reference; fix the source and render the affected pages again.
+
+Use the available rendering tool for this check. Inspect `warnings`, especially missing fonts. LibreOffice previews do not certify pixel-identical PowerPoint or Keynote output, animation, or media playback. If the rendering tool is unavailable or fails, retain the usable source and report the inspection limit; do not require the user to install another tool.
+
+Call `present({"files":[{"path":"report-edited.pptx"}]})` with the actual final PPTX path. It exposes the current source file without copying or preserving its bytes, so keep that file in place and leave intermediate images and reports out of delivery unless requested. If `present` is unavailable, use the session's supported file delivery method.

package/assets/office-xlsx/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: office-xlsx
+description: Read, create, and modify Excel workbooks (.xlsx), including cell values, formulas, formatting, and pandas analysis. Use when an Excel workbook is an input or deliverable.
+---
+
+# Excel workbooks
+
+Follow an explicit user or applicable AGENTS.md requirement for an environment or library. Otherwise call `load_workspace_dependencies` and run its Python executable with bundled `openpyxl` and `pandas`. Do not install packages or search for a system Python for the default workflow. If the tool is unavailable, use an already configured environment and report a missing dependency only when it prevents the requested operation.
+
+Keep scripts, working files, and outputs in the task workspace. The runtime and skill directory are shared read-only resources. Save to a new workbook unless the user requests an in-place edit.
+
+## Read and modify
+
+Use `openpyxl` for existing XLSX workbooks and targeted cell or style changes. Load with `data_only=False` when formulas must survive. Inspect sheet names, the affected cell types, formulas, styles, merged ranges, and referenced ranges before editing. Check the saved file by reopening it, including unchanged content that the request requires preserving.
+
+Use pandas for data analysis and transformations. A DataFrame is not the workbook: exporting it over an existing file can lose sheets, formulas, charts, and formatting. Write analysis results back to the intended ranges with openpyxl. `XlsxWriter` can create new workbooks, but cannot read or modify existing ones.
+
+For a new workbook, the selected Python environment can write editable values, styles, and formulas directly:
+
+```python
+from openpyxl import Workbook
+from openpyxl.styles import Font
+
+workbook = Workbook()
+sheet = workbook.active
+sheet.title = "Revenue"
+for row in [("Quarter", "Revenue"), ("Q1", 12), ("Q2", 18), ("Total", "=SUM(B2:B3)")]:
+    sheet.append(row)
+for cell in sheet[1]:
+    cell.font = Font(bold=True)
+sheet.column_dimensions["A"].width = 18
+sheet.column_dimensions["B"].width = 18
+workbook.save("report.xlsx")
+```
+
+Preserve numbers, dates, booleans, and identifiers as the intended cell types; formatting is not a type conversion. For modifications, load the existing file with `openpyxl.load_workbook("input.xlsx", data_only=False)`, change the requested ranges, and save a separate result. Avoid a DataFrame round trip when workbook features must survive.
+
+Writing a formula does not calculate its result. openpyxl and XlsxWriter do not evaluate Excel formulas; `data_only=True` returns stored cached values that may be absent or stale. Verify formulas and inputs separately, and state when current results require recalculation in a spreadsheet application. Do not replace requested formulas with constants or report cached values as newly calculated results.
+
+Do not rename `.xls`, `.xlsb`, encrypted files, or macro-enabled files to `.xlsx`. They need an appropriate supported operation. `keep_vba=True` can preserve VBA package content in an XLSM workflow, but does not execute or edit macros and does not guarantee every advanced workbook feature survives. Preserve the original and verify such requirements explicitly.
+
+## Check and deliver
+
+Run the shared checker with the selected Python executable; `<skill-directory>` is this loaded skill's resource base:
+
+```text
+<python> <skill-directory>/../scripts/check_office.py <workbook.xlsx> --out <checks.json>
+```
+
+It checks ZIP/XML integrity and internal relationships, and reports sheet names, populated-cell counts, and formula counts. Repeated `--contains TEXT` arguments check string cells and sheet names, and `--count N` checks sheet count. `--contains` excludes numeric cells and does not validate formula results; verify those separately with openpyxl. The checker does not calculate formulas or judge workbook appearance. Compare relevant values, types, formulas, styles, and totals with the task's source data.
+
+If `render_document` is available and visual inspection is useful, call it on the final workbook without `pages` to prepare page 1 and learn `pageCount`. It checks the current main model's actual image capability; do not choose a second model. On `status: "skipped"`, complete structural and data checks and deliver the workbook, briefly stating that visual layout was not inspected. Otherwise call `read_image` on `pages[].imagePath` and request remaining pages in small batches. Check column widths, number formats, clipping, charts, and print areas; fix the workbook and review the affected pages again.
+
+Rendered pages follow spreadsheet print settings, so a page is not necessarily a worksheet. Set appropriate print areas and scaling when a readable printed layout is requested. Review `warnings` such as missing fonts. LibreOffice preview conversion neither updates the original workbook's cached formulas nor certifies native Excel calculation or appearance. If rendering is unavailable or fails, preserve the usable workbook and report the inspection limit; ordinary cell edits do not require installing an external renderer.
+
+Call `present({"files":[{"path":"report.xlsx"}]})` with the actual final workbook path. It exposes the current source file without copying or preserving its bytes, so keep that file in place and omit intermediate scripts and reports unless requested. If `present` is unavailable, use the session's supported file delivery method.

package/assets/scripts/check_office.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""Read-only OOXML checks and structural summaries; no rendering or formula evaluation.
+
+Run with INPUT.docx, INPUT.pptx, or INPUT.xlsx. Optional --contains assertions
+check extracted text; DOCX excludes comments, glossary text, and unreferenced parts or notes.
+--count checks slides or sheets. JSON escapes non-ASCII
+characters and goes to stdout and optionally --out. Exit 0 means the requested
+structural checks passed, 1 means a document, assertion, or report write failed, and 2 means
+invalid command-line arguments.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import posixpath
+import sys
+import zipfile
+import zlib
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+from xml.etree import ElementTree as ET
+
+W_NAMESPACES = (
+    "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "http://purl.oclc.org/ooxml/wordprocessingml/main",
+)
+A_NAMESPACES = (
+    "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "http://purl.oclc.org/ooxml/drawingml/main",
+)
+P_NAMESPACES = (
+    "http://schemas.openxmlformats.org/presentationml/2006/main",
+    "http://purl.oclc.org/ooxml/presentationml/main",
+)
+S_NAMESPACES = (
+    "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+    "http://purl.oclc.org/ooxml/spreadsheetml/main",
+)
+R_NAMESPACES = (
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "http://purl.oclc.org/ooxml/officeDocument/relationships",
+)
+MAIN_PARTS = {
+    ".docx": ("word/document.xml", "wordprocessingml.document.main+xml"),
+    ".pptx": ("ppt/presentation.xml", "presentationml.presentation.main+xml"),
+    ".xlsx": ("xl/workbook.xml", "spreadsheetml.sheet.main+xml"),
+}
+
+
+def namespace(root: ET.Element, supported: tuple[str, ...], part: str) -> str:
+    """Return the main XML namespace after checking its OOXML variant."""
+    uri = root.tag[1:].split("}", 1)[0] if root.tag.startswith("{") else ""
+    if uri not in supported:
+        raise ValueError(f"{part} uses unsupported XML namespace: {uri or '(none)'}")
+    return "{" + uri + "}"
+
+
+def relationship_id(node: ET.Element, part: str) -> str:
+    """Read an office-document relationship id from Transitional or Strict OOXML."""
+    for uri in R_NAMESPACES:
+        value = node.get("{" + uri + "}id")
+        if value is not None:
+            return value
+    raise ValueError(f"{part} has a reference without a relationship id")
+
+
+def relationship_types(kind: str) -> set[str]:
+    """Return the Transitional and Strict relationship type names for one role."""
+    return {f"{uri}/{kind}" for uri in R_NAMESPACES}
+
+
+def iter_namespaces(root: ET.Element, namespaces: tuple[str, ...], local_name: str):
+    """Iterate matching elements across Transitional and Strict namespaces."""
+    for uri in namespaces:
+        yield from root.iter("{" + uri + "}" + local_name)
+
+
+def relationship_target(part: str, target: str) -> str:
+    """Resolve a package relationship without fetching external resources."""
+    path = unquote(urlsplit(target).path)
+    return posixpath.normpath(path.lstrip("/") if path.startswith("/") else posixpath.join(posixpath.dirname(part), path))
+
+
+def relationships(part: str, xml: dict[str, ET.Element], types: set[str] | None = None) -> dict[str, str]:
+    path = posixpath.join(posixpath.dirname(part), "_rels", posixpath.basename(part) + ".rels")
+    root = xml.get(path)
+    if root is None:
+        return {}
+    return {
+        rel.attrib["Id"]: relationship_target(part, rel.attrib["Target"])
+        for rel in root if rel.get("TargetMode") != "External" and (types is None or rel.get("Type") in types)
+    }
+
+
+def related_xml(part: str, reference: str, links: dict[str, str], xml: dict[str, ET.Element]) -> ET.Element:
+    """Read a related XML part with diagnostics naming its source and reference."""
+    if reference not in links:
+        raise ValueError(f"{part} references missing relationship: {reference}")
+    target = links[reference]
+    if target not in xml:
+        raise ValueError(f"{part} relationship {reference} targets a non-XML member: {target}")
+    return xml[target]
+
+
+def inspect_docx(xml: dict[str, ET.Element]) -> tuple[dict, str]:
+    part = "word/document.xml"
+    root = xml[part]
+    w = namespace(root, W_NAMESPACES, part)
+    body = root.find(f"{w}body")
+    if body is None:
+        raise ValueError("word/document.xml has no document body")
+    tables = []
+    for table in body.iter(f"{w}tbl"):
+        grid = table.findall(f"{w}tblGrid/{w}gridCol")
+        rows = table.findall(f"{w}tr")
+        # Merged cells span logical grid columns; counting physical cells loses them.
+        columns = len(grid) if grid else max((sum(
+            int(cell.find(f"{w}tcPr/{w}gridSpan").get(f"{w}val", "1"))
+            if cell.find(f"{w}tcPr/{w}gridSpan") is not None else 1
+            for cell in row.findall(f"{w}tc")
+        ) for row in rows), default=0)
+        tables.append({"rows": len(rows), "columns": columns})
+    sections = []
+    for section in body.iter(f"{w}sectPr"):
+        size = section.find(f"{w}pgSz")
+        margins = section.find(f"{w}pgMar")
+        sections.append({
+            "page_twips": {} if size is None else {key.removeprefix(w): value for key, value in size.attrib.items()},
+            "margins_twips": {} if margins is None else {key.removeprefix(w): value for key, value in margins.attrib.items()},
+        })
+    text_parts = [body]
+    for kind in ("header", "footer"):
+        links = relationships(part, xml, relationship_types(kind))
+        for section in body.iter(f"{w}sectPr"):
+            for reference in section.findall(f"{w}{kind}Reference"):
+                text_parts.append(related_xml(part, relationship_id(reference, part), links, xml))
+    for kind in ("footnote", "endnote"):
+        references = {node.attrib[f"{w}id"] for node in body.iter(f"{w}{kind}Reference")}
+        if not references:
+            continue
+        links = relationships(part, xml, relationship_types(f"{kind}s"))
+        for reference in links:
+            tree = related_xml(part, reference, links, xml)
+            text_parts.extend(note for note in tree.findall(f"{w}{kind}") if note.get(f"{w}id") in references)
+    text = "\n".join("".join(node.text or "" for node in paragraph.iter(f"{w}t")) for tree in text_parts
+                     for paragraph in tree.iter(f"{w}p"))
+    return {"paragraphs": len(list(body.iter(f"{w}p"))), "tables": tables, "sections": sections}, text
+
+
+def inspect_pptx(xml: dict[str, ET.Element]) -> tuple[dict, str]:
+    part = "ppt/presentation.xml"
+    links = relationships(part, xml)
+    root = xml[part]
+    p = namespace(root, P_NAMESPACES, part)
+    slides = root.findall(f"{p}sldIdLst/{p}sldId")
+    texts = []
+    for slide in slides:
+        reference = relationship_id(slide, part)
+        tree = related_xml(part, reference, links, xml)
+        texts.append("\n".join("".join(node.text or "" for node in iter_namespaces(paragraph, A_NAMESPACES, "t"))
+                               for paragraph in iter_namespaces(tree, A_NAMESPACES, "p")))
+    return {"slides": len(slides)}, "\n".join(texts)
+
+
+def inspect_xlsx(xml: dict[str, ET.Element]) -> tuple[dict, str]:
+    part = "xl/workbook.xml"
+    links = relationships(part, xml)
+    root = xml[part]
+    s = namespace(root, S_NAMESPACES, part)
+    sheets = []
+    texts = []
+    shared = xml.get("xl/sharedStrings.xml")
+    shared_s = s if shared is None else namespace(shared, S_NAMESPACES, "xl/sharedStrings.xml")
+    shared_strings = [] if shared is None else [
+        "".join(node.text or "" for node in item.iter(f"{shared_s}t")) for item in shared.iter(f"{shared_s}si")
+    ]
+    for sheet in root.findall(f"{s}sheets/{s}sheet"):
+        reference = relationship_id(sheet, part)
+        tree = related_xml(part, reference, links, xml)
+        sheet_s = namespace(tree, S_NAMESPACES, links[reference])
+        cells = list(tree.iter(f"{sheet_s}c"))
+        formulas = sum(cell.find(f"{sheet_s}f") is not None for cell in cells)
+        sheets.append({"name": sheet.attrib["name"], "cells": len(cells), "formulas": formulas})
+        for cell in cells:
+            if cell.get("t") == "s":
+                value = cell.findtext(f"{sheet_s}v", "")
+                location = f"{links[reference]} cell {cell.get('r', '(no reference)')}"
+                try:
+                    index = int(value)
+                except ValueError as error:
+                    raise ValueError(f"{location}: invalid shared string index {value!r}") from error
+                if not 0 <= index < len(shared_strings):
+                    raise ValueError(f"{location}: shared string index out of range: {index}")
+                texts.append(shared_strings[index])
+        texts.extend("".join(node.text or "" for node in cell.iter(f"{sheet_s}t")) for cell in cells)
+        texts.extend(cell.findtext(f"{sheet_s}v", "") for cell in cells if cell.get("t") == "str")
+        texts.append(sheet.attrib["name"])
+    return {"sheets": sheets, "formulas_evaluated": False}, "\n".join(texts)
+
+
+def inspect(path: Path) -> tuple[dict, str]:
+    """Validate package members and relationships before inspecting the main part."""
+    main, content_type = MAIN_PARTS[path.suffix.lower()]
+    with zipfile.ZipFile(path) as archive:
+        members = archive.namelist()
+        if len(members) != len(set(members)):
+            raise ValueError("ZIP contains duplicate member names")
+        corrupt = archive.testzip()
+        if corrupt is not None:
+            raise ValueError(f"ZIP member failed its CRC check: {corrupt}")
+        xml = {name: ET.fromstring(archive.read(name)) for name in members
+               if name.endswith((".xml", ".rels"))}
+    if main not in xml:
+        raise ValueError(f"missing main part: {main}")
+    types = xml.get("[Content_Types].xml")
+    if types is None or not any(node.get("PartName") == "/" + main
+                                and node.get("ContentType", "").endswith(content_type) for node in types):
+        raise ValueError(f"[Content_Types].xml does not declare {main} as {path.suffix.lower()}")
+    for name, tree in xml.items():
+        if not name.endswith(".rels"):
+            continue
+        source = "" if name == "_rels/.rels" else posixpath.join(posixpath.dirname(posixpath.dirname(name)), posixpath.basename(name)[:-5])
+        for rel in tree:
+            if rel.get("TargetMode") == "External":
+                continue
+            target = relationship_target(source, rel.attrib["Target"])
+            if target not in members:
+                raise ValueError(f"{name} references missing package member: {target}")
+    if path.suffix.lower() == ".docx":
+        return inspect_docx(xml)
+    if path.suffix.lower() == ".pptx":
+        return inspect_pptx(xml)
+    return inspect_xlsx(xml)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("input", type=Path)
+    parser.add_argument("--out", type=Path)
+    parser.add_argument("--contains", action="append", default=[], metavar="TEXT")
+    parser.add_argument("--count", type=int, help="expected slide or sheet count")
+    args = parser.parse_args()
+    if args.input.suffix.lower() not in MAIN_PARTS:
+        parser.error("input must be .docx, .pptx, or .xlsx; converting the filename does not convert its contents")
+    if args.count is not None and (args.count < 0 or args.input.suffix.lower() == ".docx"):
+        parser.error("--count must be non-negative and applies only to slides or sheets")
+    if args.out is not None and args.out.resolve() == args.input.resolve():
+        parser.error("--out must differ from the input document")
+    checks = []
+    summary = {}
+    try:
+        summary, text = inspect(args.input)
+        checks.append({"id": "package", "status": "pass"})
+        for required in args.contains:
+            checks.append({"id": "contains", "status": "pass" if required in text else "fail", "text": required})
+        if args.count is not None:
+            actual = summary.get("slides", len(summary.get("sheets", [])))
+            checks.append({"id": "count", "status": "pass" if actual == args.count else "fail", "expected": args.count, "actual": actual})
+    except (OSError, ValueError, KeyError, RuntimeError, ET.ParseError, zipfile.BadZipFile, zlib.error) as error:
+        checks.append({"id": "package", "status": "fail", "detail": str(error)})
+    failed = any(check["status"] == "fail" for check in checks)
+    report = {"format": args.input.suffix.lower()[1:], "verdict": "fail" if failed else "pass", "checks": checks, "summary": summary}
+    output = json.dumps(report, ensure_ascii=True, indent=2) + "\n"
+    if args.out is not None:
+        try:
+            args.out.parent.mkdir(parents=True, exist_ok=True)
+            args.out.write_text(output, encoding="utf-8")
+        except OSError as error:
+            failed = True
+            report["verdict"] = "fail"
+            checks.append({"id": "output", "status": "fail", "detail": str(error)})
+            output = json.dumps(report, ensure_ascii=True, indent=2) + "\n"
+    sys.stdout.write(output)
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/index.js

@@ -0,0 +1,80 @@
+import { readFileSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import z from "@deepseek-ai/schemastery";
+import { BUNDLED_SKILL_RANK } from "@deepseek-ai/dsh-skill";
+import { parse } from "yaml";
+//#region lib/types/index.js
+/** Bundled Office workflows and filesystem resources for document authoring and checks. */
+const SKILL_NAMES = [
+	"office-docx",
+	"office-pptx",
+	"office-xlsx"
+];
+/** Validated resource configuration. */
+const Config = z.object({ assetRoot: z.string().min(1) });
+/** Cordis plugin identity. */
+const name = "skill-office";
+/** Registry used by the bundled provider. */
+const inject = ["skills"];
+function parseSkill(raw, path) {
+	const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(raw);
+	if (frontmatter?.[1] === void 0) throw new Error(`skill-office: ${path} has no YAML frontmatter`);
+	const metadata = parse(frontmatter[1]);
+	const description = typeof metadata === "object" && metadata !== null && "description" in metadata ? metadata.description : void 0;
+	if (typeof description !== "string" || description.length === 0) throw new Error(`skill-office: ${path} has no description`);
+	return {
+		description,
+		content: raw.slice(frontmatter[0].length).trim()
+	};
+}
+/**
+* Register Office skills with resources readable by the script interpreter.
+* @param ctx - Context carrying the skill registry.
+* @param config - Optional external assets directory for packaged applications.
+*/
+function apply(ctx, config = {}) {
+	const assetRoot = config.assetRoot ?? fileURLToPath(new URL("../assets/", import.meta.url));
+	if (!isAbsolute(assetRoot)) throw new Error("skill-office: assetRoot must be an absolute directory");
+	if (!statSync(join(assetRoot, "scripts", "check_office.py")).isFile()) throw new Error("skill-office: assets must contain scripts/check_office.py");
+	const candidates = SKILL_NAMES.map((skillName) => {
+		const directory = join(assetRoot, skillName);
+		const path = join(directory, "SKILL.md");
+		const { description } = parseSkill(readFileSync(path, "utf8"), path);
+		return {
+			name: skillName,
+			description,
+			invocation: {
+				modelInvocable: true,
+				userInvocable: true
+			},
+			provider: "dsh-office",
+			source: "bundled",
+			rank: BUNDLED_SKILL_RANK,
+			resourceBase: {
+				kind: "directory",
+				path: directory
+			},
+			locator: path
+		};
+	});
+	const provider = {
+		name: "dsh-office",
+		list: () => Promise.resolve(candidates),
+		async get(candidate, options) {
+			const { rank: _rank, locator, ...summary } = candidate;
+			const raw = await readFile(locator, {
+				encoding: "utf8",
+				signal: options.signal
+			});
+			return {
+				...summary,
+				content: parseSkill(raw, locator).content
+			};
+		}
+	};
+	ctx.skills.registerProvider(() => provider);
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,21 @@
+/** Bundled Office workflows and filesystem resources for document authoring and checks. */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Office skill resource location. */
+export interface Config {
+    /** Absolute assets directory containing the three skill folders and shared scripts; defaults to packaged assets. */
+    assetRoot?: string;
+}
+/** Validated resource configuration. */
+export declare const Config: z<Config>;
+/** Cordis plugin identity. */
+export declare const name = "skill-office";
+/** Registry used by the bundled provider. */
+export declare const inject: string[];
+/**
+ * Register Office skills with resources readable by the script interpreter.
+ * @param ctx - Context carrying the skill registry.
+ * @param config - Optional external assets directory for packaged applications.
+ */
+export declare function apply(ctx: Context, config?: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@deepseek-ai/dsh-skill-office",
+  "description": "Bundled Word, PowerPoint, and Excel workflows and structural checks",
+  "version": "0.1.6-alpha.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/skill/skill-office"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "assets",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-skill": "^0.1.6-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-skill": "^0.1.6-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/cordis-plugin-include": "^1.0.7",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.3"
+  },
+  "dependencies": {
+    "yaml": "^2.4.2",
+    "@deepseek-ai/schemastery": "^3.18.2"
+  }
+}