gongwen-skill 2.6.1 → 2.7.0

package/.dsh/skills/gongwen-skill/SKILL.md

@@ -258,21 +258,23 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 
 ## 用户交互指引（Agent 必须遵守）
 
+> **终端用户也可直接运行 `python -m gongwen wizard`**：交互式向导以菜单方式完成同样的 A/B/C/D 路径选择与逐步确认（详见下文「向导式交互」小节）。Agent 读到本条时，若用户表示「不熟悉命令/不想记参数」，应主动引导其使用向导，而非逐字念命令行参数。
+
 ### 第一步：确认路径（必须，严禁跳过）
 
-用通俗语言问用户走哪条路，**不允许跳过**：
+用通俗语言问用户走哪条路，**不允许跳过**。向导模式与对话模式共用同一套路径：
 
 > 这个工具支持四种处理方式：
-> - **格式优化**：不改文字，只修排版（字体/字号/页边距/行距/缩进），按国标标准化
-> - **内容优化**：润色文字表达，生成带标记的对比文档——保持原文档排版样式，修改处红色高亮或删除线、每段附修改说明
-> - **生成模板**：直接生成一份空白公文模板，按国标设好版式
-> - **一键格式修复**（fix-common）：快速规范化常见格式问题（段落类型/编号拆分/首句加粗），输出不含 AI 声明段的干净文档
+> - **A. 格式优化**：不改文字，只修排版（字体/字号/页边距/行距/缩进），按国标标准化
+> - **B. 内容优化**：润色文字表达，生成带标记的对比文档——保持原文档排版样式，修改处红色高亮或删除线、每段附修改说明
+> - **C. 生成模板**：直接生成一份空白公文模板，按国标设好版式
+> - **D. 一键格式修复**（fix-common）：快速规范化常见格式问题（段落类型/编号拆分/首句加粗），输出不含 AI 声明段的干净文档
 
 若用户说「帮我优化一下」，必须追问是改格式还是改内容。
 
 ### 第二步：告知输出物
 
-执行前明确说会生成什么文件、包含什么标记。
+执行前明确说会生成什么文件、包含什么标记。向导模式会在执行前展示将运行的完整命令。
 
 ### 第三步：执行后验证
 
@@ -280,6 +282,29 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 
 ---
 
+### 向导式交互（`wizard` 命令）
+
+当用户**不熟悉命令行**、希望**逐步确认后再执行**，或 Agent 需要**把交互决策委托给工具**时，使用向导：
+
+```
+python -m gongwen wizard                        # 终端交互：菜单选 A/B/C/D → 逐项填参 → 预览确认 → 执行
+python -m gongwen wizard --answers 答案.json     # Agent 非交互：跳过提问直接执行
+python -m gongwen wizard --answers 答案.json --dry-run  # 只打印将执行的命令，不真正执行
+```
+
+- **路径菜单**：A 格式优化（`optimize`）｜B 内容优化（`optimize-content`）｜C 生成模板（`template`）｜D 一键格式修复（`fix-common`）
+- **交互流程**：选择路径 → 收集参数（公文类型支持 序号 / id / 中文名，如 `1`、`notice`、`通知`）→ A/B/D 先预览再 y/n 确认 → 执行；C 无修改风险直接执行
+- **`--answers` JSON 扁平结构**（Agent 场景，顶层带 `path`）：
+  ```json
+  {"path": "A", "input": "原文.docx", "doc_type": "notice", "output": "成品.docx", "apply": true}
+  ```
+  - 字段缺失：非交互模式直接报错并列出缺失项（不静默、不进交互菜单）
+  - 不写 `apply` 时 A/B/D **仅预览不执行**（安全默认）；`apply: true` 跳过确认直接执行
+  - 非交互执行机制：`subprocess` 调用 `sys.executable -m gongwen <子命令>`，输出流式透传，Agent 可直接解析子命令原始输出
+- **`--dry-run`**：只打印将执行的命令；A/B 会同时打印「预览」与「执行」两条命令，便于 Agent 预演与调试
+
+---
+
 ## 执行标准总则（所有路径共享）
 
 ### Agent 行为准则
@@ -295,7 +320,7 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 | "按上级文件要求调整" | 用户有政策依据但未提供 | 追问具体文件名或文号，或用 web 搜索相关政策 |
 | "弄漂亮一点" | 希望格式规范 | 解释 GB/T 9704 标准是唯一合规格式 |
 
-**原则**：不确定时 **先确认路径**（A/B/C），再用 **具体示例引导用户选择**，不猜测。
+**原则**：不确定时 **先确认路径**（A/B/C/D，向导模式同），再用 **具体示例引导用户选择**，不猜测。
 
 #### 2. 充分利用 skill 知识库
 
@@ -846,10 +871,16 @@ python -m gongwen fix-common 文件.docx -o 成品.docx
 
 ---
 
-## 附录：全部命令速查（24 个，按用途分组）
+## 附录：全部命令速查（25 个，按用途分组）
 
 > Agent 遇到用户需求时，先在此表定位对应命令；命令用法不明确时运行 `python -m gongwen <命令> --help` 查看完整参数。
 
+### 🧭 向导式交互
+
+| 命令 | 用途 | 最小用法 |
+|------|------|---------|
+| `wizard` | 交互式路径引导（A/B/C/D）+ 一键执行；Agent 用 `--answers` 非交互 / `--dry-run` 只打印命令 | `python -m gongwen wizard` |
+
 ### 🏗️ 生成与模板
 
 | 命令 | 用途 | 最小用法 |

package/.dsh/skills/gongwen-skill.md

@@ -258,21 +258,23 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 
 ## 用户交互指引（Agent 必须遵守）
 
+> **终端用户也可直接运行 `python -m gongwen wizard`**：交互式向导以菜单方式完成同样的 A/B/C/D 路径选择与逐步确认（详见下文「向导式交互」小节）。Agent 读到本条时，若用户表示「不熟悉命令/不想记参数」，应主动引导其使用向导，而非逐字念命令行参数。
+
 ### 第一步：确认路径（必须，严禁跳过）
 
-用通俗语言问用户走哪条路，**不允许跳过**：
+用通俗语言问用户走哪条路，**不允许跳过**。向导模式与对话模式共用同一套路径：
 
 > 这个工具支持四种处理方式：
-> - **格式优化**：不改文字，只修排版（字体/字号/页边距/行距/缩进），按国标标准化
-> - **内容优化**：润色文字表达，生成带标记的对比文档——保持原文档排版样式，修改处红色高亮或删除线、每段附修改说明
-> - **生成模板**：直接生成一份空白公文模板，按国标设好版式
-> - **一键格式修复**（fix-common）：快速规范化常见格式问题（段落类型/编号拆分/首句加粗），输出不含 AI 声明段的干净文档
+> - **A. 格式优化**：不改文字，只修排版（字体/字号/页边距/行距/缩进），按国标标准化
+> - **B. 内容优化**：润色文字表达，生成带标记的对比文档——保持原文档排版样式，修改处红色高亮或删除线、每段附修改说明
+> - **C. 生成模板**：直接生成一份空白公文模板，按国标设好版式
+> - **D. 一键格式修复**（fix-common）：快速规范化常见格式问题（段落类型/编号拆分/首句加粗），输出不含 AI 声明段的干净文档
 
 若用户说「帮我优化一下」，必须追问是改格式还是改内容。
 
 ### 第二步：告知输出物
 
-执行前明确说会生成什么文件、包含什么标记。
+执行前明确说会生成什么文件、包含什么标记。向导模式会在执行前展示将运行的完整命令。
 
 ### 第三步：执行后验证
 
@@ -280,6 +282,29 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 
 ---
 
+### 向导式交互（`wizard` 命令）
+
+当用户**不熟悉命令行**、希望**逐步确认后再执行**，或 Agent 需要**把交互决策委托给工具**时，使用向导：
+
+```
+python -m gongwen wizard                        # 终端交互：菜单选 A/B/C/D → 逐项填参 → 预览确认 → 执行
+python -m gongwen wizard --answers 答案.json     # Agent 非交互：跳过提问直接执行
+python -m gongwen wizard --answers 答案.json --dry-run  # 只打印将执行的命令，不真正执行
+```
+
+- **路径菜单**：A 格式优化（`optimize`）｜B 内容优化（`optimize-content`）｜C 生成模板（`template`）｜D 一键格式修复（`fix-common`）
+- **交互流程**：选择路径 → 收集参数（公文类型支持 序号 / id / 中文名，如 `1`、`notice`、`通知`）→ A/B/D 先预览再 y/n 确认 → 执行；C 无修改风险直接执行
+- **`--answers` JSON 扁平结构**（Agent 场景，顶层带 `path`）：
+  ```json
+  {"path": "A", "input": "原文.docx", "doc_type": "notice", "output": "成品.docx", "apply": true}
+  ```
+  - 字段缺失：非交互模式直接报错并列出缺失项（不静默、不进交互菜单）
+  - 不写 `apply` 时 A/B/D **仅预览不执行**（安全默认）；`apply: true` 跳过确认直接执行
+  - 非交互执行机制：`subprocess` 调用 `sys.executable -m gongwen <子命令>`，输出流式透传，Agent 可直接解析子命令原始输出
+- **`--dry-run`**：只打印将执行的命令；A/B 会同时打印「预览」与「执行」两条命令，便于 Agent 预演与调试
+
+---
+
 ## 执行标准总则（所有路径共享）
 
 ### Agent 行为准则
@@ -295,7 +320,7 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 | "按上级文件要求调整" | 用户有政策依据但未提供 | 追问具体文件名或文号，或用 web 搜索相关政策 |
 | "弄漂亮一点" | 希望格式规范 | 解释 GB/T 9704 标准是唯一合规格式 |
 
-**原则**：不确定时 **先确认路径**（A/B/C），再用 **具体示例引导用户选择**，不猜测。
+**原则**：不确定时 **先确认路径**（A/B/C/D，向导模式同），再用 **具体示例引导用户选择**，不猜测。
 
 #### 2. 充分利用 skill 知识库
 
@@ -846,10 +871,16 @@ python -m gongwen fix-common 文件.docx -o 成品.docx
 
 ---
 
-## 附录：全部命令速查（24 个，按用途分组）
+## 附录：全部命令速查（25 个，按用途分组）
 
 > Agent 遇到用户需求时，先在此表定位对应命令；命令用法不明确时运行 `python -m gongwen <命令> --help` 查看完整参数。
 
+### 🧭 向导式交互
+
+| 命令 | 用途 | 最小用法 |
+|------|------|---------|
+| `wizard` | 交互式路径引导（A/B/C/D）+ 一键执行；Agent 用 `--answers` 非交互 / `--dry-run` 只打印命令 | `python -m gongwen wizard` |
+
 ### 🏗️ 生成与模板
 
 | 命令 | 用途 | 最小用法 |

package/CHANGELOG.md

@@ -4,6 +4,15 @@
   Licensed under the MIT License. See the LICENSE file for details.
 -->
 
+## v2.7.0 (2026-09-03)
+
+### Added
+- **新增 `wizard` 向导式交互命令**：`python -m gongwen wizard` 以 A/B/C/D 路径菜单引导用户（A 格式优化 `optimize` / B 内容优化 `optimize-content` / C 生成模板 `template` / D 一键格式修复 `fix-common`），交互收集参数后一键执行
+- **双模式交互**：终端 input() 交互（公文类型支持序号 / id / 中文名智能匹配）+ `--answers` 扁平 JSON 非交互（Agent 场景，顶层带 `path`，如 `{"path":"A","input":"a.docx","apply":true}`）
+- **安全默认**：A/B/D 修改类路径先预览再 y/n 确认；非交互模式不写 `apply` 时仅预览不执行；`--dry-run` 只打印将执行的命令（A/B 同时打印预览+执行两条）
+- **执行机制**：`subprocess` 调用 `sys.executable -m gongwen <子命令>`，输出流式透传，Agent 可直接解析子命令原始输出
+- **文档同步**：SKILL.md「用户交互指引」升级为向导式三步流程并新增「向导式交互」小节（命令速查 24→25 个）；README 能力表与命令行速查补充 wizard 用法
+
 ## v2.6.1 (2026-09-02)
 
 ### Changed

package/README.md

@@ -50,6 +50,7 @@ Licensed under the MIT License. See the LICENSE file for details.
 | 🕵️ 文档审计 | `audit` | 检查删除线/加粗/AI 声明等痕迹 |
 | 🤝 会话交接 | `handoff` | 跨会话上下文传递（`--list` / `--latest` / Agent 长任务收尾必写） |
 | ⚙️ 规则管理 | `rule-export/import/list` | YAML 规则三层定制（官方/单位/用户） |
+| 🧭 向导式交互 | `wizard` | 交互式路径引导（A/B/C/D）+ 一键执行；Agent 用 `--answers` 非交互 / `--dry-run` 只打印命令 |
 
 ## 使用示例
 
@@ -259,6 +260,24 @@ python -m gongwen optimize-content 新闻稿.docx --changes changes.json \
 --show-confirmed             已确认实体也生成批注
 ```
 
+### 🧭 向导式交互（wizard）
+
+交互式引导选择处理路径并一键执行，适合不熟悉命令行的用户；Agent 可走非交互模式：
+
+```bash
+python -m gongwen wizard                        # 终端交互：菜单选 A/B/C/D → 逐项填参 → 预览确认 → 执行
+python -m gongwen wizard --answers 答案.json     # Agent 非交互：跳过提问直接执行
+python -m gongwen wizard --answers 答案.json --dry-run  # 只打印将执行的命令
+```
+
+`--answers` 扁平 JSON（顶层带 `path`）：
+
+```json
+{"path": "A", "input": "原文.docx", "doc_type": "notice", "output": "成品.docx", "apply": true}
+```
+
+路径：A 格式优化（`optimize`）｜B 内容优化（`optimize-content`）｜C 生成模板（`template`）｜D 一键格式修复（`fix-common`）。A/B/D 默认先预览再 y/n 确认；不写 `apply` 时非交互模式仅预览不执行（安全默认）。
+
 ## 📐 GB/T 9704 标准格式
 
 | 元素 | 字体 | 字号 | 对齐 |
@@ -337,7 +356,7 @@ DSH 采用 **Cordis 模块化微内核架构**：技能体系基于本地文件
 git clone https://github.com/linhut/gongwen-skill.git
 cd gongwen-skill
 pip install -r requirements.txt   # 或 pip install gongwen-skill（已上 PyPI）
-python -m gongwen --version       # 检验：gongwen-skill v2.6.1
+python -m gongwen --version       # 检验：gongwen-skill v2.7.0
 ```
 
 ### 方式一：作为 DSH Skill 注册（基于本地文件系统）
@@ -393,7 +412,7 @@ pnpm add -w gongwen-skill
   "dependencies": {
     "@deepseek-ai/dsh-base": "...",
     "@deepseek-ai/dsh-web-app": "...",
-    "gongwen-skill": "^2.6.1"
+    "gongwen-skill": "^2.7.0"
   },
   "dsh": {
     "profile": {
@@ -574,7 +593,7 @@ pip install -r requirements.txt
 用户：帮我优化这份会议通知的第二章节措辞
 
 Agent：📋 合规自检报告
-Skill 版本: v2.6.1（版本自检已确认最新）
+Skill 版本: v2.7.0（版本自检已确认最新）
 路径判定: B（内容优化）
 依据: 用户指定了已有文档，且要求"优化措辞"
 命令调用: 1. python -m gongwen optimize-content 会议通知.docx --changes changes.json --apply --paragraphs "5-8"

package/SKILL.md

@@ -258,21 +258,23 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 
 ## 用户交互指引（Agent 必须遵守）
 
+> **终端用户也可直接运行 `python -m gongwen wizard`**：交互式向导以菜单方式完成同样的 A/B/C/D 路径选择与逐步确认（详见下文「向导式交互」小节）。Agent 读到本条时，若用户表示「不熟悉命令/不想记参数」，应主动引导其使用向导，而非逐字念命令行参数。
+
 ### 第一步：确认路径（必须，严禁跳过）
 
-用通俗语言问用户走哪条路，**不允许跳过**：
+用通俗语言问用户走哪条路，**不允许跳过**。向导模式与对话模式共用同一套路径：
 
 > 这个工具支持四种处理方式：
-> - **格式优化**：不改文字，只修排版（字体/字号/页边距/行距/缩进），按国标标准化
-> - **内容优化**：润色文字表达，生成带标记的对比文档——保持原文档排版样式，修改处红色高亮或删除线、每段附修改说明
-> - **生成模板**：直接生成一份空白公文模板，按国标设好版式
-> - **一键格式修复**（fix-common）：快速规范化常见格式问题（段落类型/编号拆分/首句加粗），输出不含 AI 声明段的干净文档
+> - **A. 格式优化**：不改文字，只修排版（字体/字号/页边距/行距/缩进），按国标标准化
+> - **B. 内容优化**：润色文字表达，生成带标记的对比文档——保持原文档排版样式，修改处红色高亮或删除线、每段附修改说明
+> - **C. 生成模板**：直接生成一份空白公文模板，按国标设好版式
+> - **D. 一键格式修复**（fix-common）：快速规范化常见格式问题（段落类型/编号拆分/首句加粗），输出不含 AI 声明段的干净文档
 
 若用户说「帮我优化一下」，必须追问是改格式还是改内容。
 
 ### 第二步：告知输出物
 
-执行前明确说会生成什么文件、包含什么标记。
+执行前明确说会生成什么文件、包含什么标记。向导模式会在执行前展示将运行的完整命令。
 
 ### 第三步：执行后验证
 
@@ -280,6 +282,29 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 
 ---
 
+### 向导式交互（`wizard` 命令）
+
+当用户**不熟悉命令行**、希望**逐步确认后再执行**，或 Agent 需要**把交互决策委托给工具**时，使用向导：
+
+```
+python -m gongwen wizard                        # 终端交互：菜单选 A/B/C/D → 逐项填参 → 预览确认 → 执行
+python -m gongwen wizard --answers 答案.json     # Agent 非交互：跳过提问直接执行
+python -m gongwen wizard --answers 答案.json --dry-run  # 只打印将执行的命令，不真正执行
+```
+
+- **路径菜单**：A 格式优化（`optimize`）｜B 内容优化（`optimize-content`）｜C 生成模板（`template`）｜D 一键格式修复（`fix-common`）
+- **交互流程**：选择路径 → 收集参数（公文类型支持 序号 / id / 中文名，如 `1`、`notice`、`通知`）→ A/B/D 先预览再 y/n 确认 → 执行；C 无修改风险直接执行
+- **`--answers` JSON 扁平结构**（Agent 场景，顶层带 `path`）：
+  ```json
+  {"path": "A", "input": "原文.docx", "doc_type": "notice", "output": "成品.docx", "apply": true}
+  ```
+  - 字段缺失：非交互模式直接报错并列出缺失项（不静默、不进交互菜单）
+  - 不写 `apply` 时 A/B/D **仅预览不执行**（安全默认）；`apply: true` 跳过确认直接执行
+  - 非交互执行机制：`subprocess` 调用 `sys.executable -m gongwen <子命令>`，输出流式透传，Agent 可直接解析子命令原始输出
+- **`--dry-run`**：只打印将执行的命令；A/B 会同时打印「预览」与「执行」两条命令，便于 Agent 预演与调试
+
+---
+
 ## 执行标准总则（所有路径共享）
 
 ### Agent 行为准则
@@ -295,7 +320,7 @@ python -m gongwen handoff --latest --summary # 最新交接文档（Markdown 摘
 | "按上级文件要求调整" | 用户有政策依据但未提供 | 追问具体文件名或文号，或用 web 搜索相关政策 |
 | "弄漂亮一点" | 希望格式规范 | 解释 GB/T 9704 标准是唯一合规格式 |
 
-**原则**：不确定时 **先确认路径**（A/B/C），再用 **具体示例引导用户选择**，不猜测。
+**原则**：不确定时 **先确认路径**（A/B/C/D，向导模式同），再用 **具体示例引导用户选择**，不猜测。
 
 #### 2. 充分利用 skill 知识库
 
@@ -846,10 +871,16 @@ python -m gongwen fix-common 文件.docx -o 成品.docx
 
 ---
 
-## 附录：全部命令速查（24 个，按用途分组）
+## 附录：全部命令速查（25 个，按用途分组）
 
 > Agent 遇到用户需求时，先在此表定位对应命令；命令用法不明确时运行 `python -m gongwen <命令> --help` 查看完整参数。
 
+### 🧭 向导式交互
+
+| 命令 | 用途 | 最小用法 |
+|------|------|---------|
+| `wizard` | 交互式路径引导（A/B/C/D）+ 一键执行；Agent 用 `--answers` 非交互 / `--dry-run` 只打印命令 | `python -m gongwen wizard` |
+
 ### 🏗️ 生成与模板
 
 | 命令 | 用途 | 最小用法 |

package/dsh/index.js

@@ -1,4 +1,4 @@
-// 公文全流程处理工具 - DSH plugin bridge (gongwen-skill, v2.6.1+)
+// 公文全流程处理工具 - DSH plugin bridge (gongwen-skill, v2.7.0+)
 // (c) 2026 Jose AI (https://www.linhut.cn)
 // https://github.com/linhut/gongwen-skill
 // Licensed under the MIT License. See the LICENSE file for details.

package/engine/core/document/_generator_helpers.py

@@ -529,8 +529,9 @@ def _apply_run_format(run, run_model: Run):
         run.font.italic = fmt.italic
     if fmt.underline is not None:
         run.font.underline = fmt.underline
-    if fmt.strikethrough is True:
-        run.font.strike = True
+    if fmt.strikethrough is not None:
+        # True 设置删除线 / False 显式清除已有删除线（避免 strikethrough=False 时旧删除线残留）
+        run.font.strike = fmt.strikethrough
 
     # === 颜色 ===
     if fmt.color:

package/engine/core/document/markdown_converter.py

@@ -30,8 +30,8 @@ _MD_UL_RE = re.compile(r'^[-*+]\s+')
 # markdown 有序列表前缀：1. 2. 3. 或 1、2、3、
 _MD_OL_RE = re.compile(r'^\d+[.、]\s*')
 
-# markdown 表格行
-_MD_TABLE_RE = re.compile(r'^\|.+\|.+\|$')
+# markdown 表格行（支持单列：| a |；贪婪匹配到行尾，多列 | a | b | 亦能识别）
+_MD_TABLE_RE = re.compile(r'^\|.+\|$')
 
 # markdown 表格分隔行：|----|----|
 _MD_TABLE_SEP_RE = re.compile(r'^\|[\s\-:|]+\|$')
@@ -263,6 +263,8 @@ def convert_markdown(model: DocumentModel) -> int:
         ol_match = _MD_OL_RE.match(text)
         if ol_match and not para.is_heading:
             is_list = True
+            text = _MD_OL_RE.sub('', text)
+            list_indent_pt = 32  # 有序列表同样 2 字符缩进（与无序列表一致）
 
         # --- 应用格式修改到 run ---
 

package/engine/core/document/ooxml_workflow.py

@@ -79,7 +79,7 @@ class OOXMLWorkflow:
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        # S5 修复：异常时保留临时目录便于调试；正常结束才清理
-        if self.unpack_dir is not None and exc_type is None:
+        # 修复：无论正常结束或异常均清理临时目录，避免每次异常残留 gongwen_ooxml_* 目录泄漏磁盘
+        if self.unpack_dir is not None:
             shutil.rmtree(self.unpack_dir, ignore_errors=True)
             self.unpack_dir = None

package/engine/core/rules/checker.py

@@ -893,7 +893,7 @@ def _check_header_field(model, rule_id: str, severity: str, name: str,
                     suggested_fix="仅保留一个主送机关",
                     reason="请示一般只写一个主送机关（发现多个主送机关段）",
                 ))
-            elif re.search(r'[、，,s]{2,}', first.strip().rstrip('：:')) and len(first.strip().rstrip('：:')) > 5:
+            elif re.search(r'[、，,]{2,}', first.strip().rstrip('：:')) and len(first.strip().rstrip('：:')) > 5:
                 issues.append(CheckIssue(
                     rule_id=rule_id, check_type="content", severity=severity,
                     name=name, location=f"paragraph:{recips[0].index}",

package/engine/inject.py

@@ -379,7 +379,7 @@ def inject_footer(output_path: str, footer_config: dict) -> None:
 #  页码注入：Word PAGE 域动态页码
 # ---------------------------------------------------------------------------
 
-def _add_page_run(para_elem, text: str, font_name: str, size_pt: int) -> None:
+def _add_page_run(para_elem, text: str, font_name: str, size_pt: float) -> None:
     """添加一个普通文本 run 到段落元素。"""
     from docx.oxml import OxmlElement
     from docx.oxml.ns import qn
@@ -402,7 +402,7 @@ def _add_page_run(para_elem, text: str, font_name: str, size_pt: int) -> None:
     para_elem.append(r)
 
 
-def _build_page_number_xml(fmt: str, font_name: str, size_pt: int) -> list:
+def _build_page_number_xml(fmt: str, font_name: str, size_pt: float) -> list:
     """解析页码格式字符串，返回 (类型, 内容, 字体, 字号) 元素列表。"""
     import re
     elements = []
@@ -621,6 +621,10 @@ def inject_page_number(output_path: str, page_number_config: dict) -> None:
         from docx.oxml import OxmlElement
         from docx.oxml.ns import qn
         from docx.shared import Pt
+        from engine.core.document.font_utils import (
+            PAGE_NUMBER_FONT,
+            PAGE_NUMBER_SIZE_PT,
+        )
 
         enabled = page_number_config.get('enabled')
         if enabled is None:
@@ -629,8 +633,8 @@ def inject_page_number(output_path: str, page_number_config: dict) -> None:
             return
 
         fmt = page_number_config.get('format', '- {PAGE} -')
-        font_name = page_number_config.get('font', '宋体')
-        size_pt = page_number_config.get('size', 14)
+        font_name = page_number_config.get('font', PAGE_NUMBER_FONT)
+        size_pt = page_number_config.get('size', PAGE_NUMBER_SIZE_PT)
         align = page_number_config.get('alignment') or page_number_config.get('position', 'center')
         if align == 'right-left':
             align = 'right'
@@ -671,9 +675,9 @@ def inject_page_number(output_path: str, page_number_config: dict) -> None:
             if is_odd_even:
                 ind = OxmlElement('w:ind')
                 if align == 'right':
-                    ind.set(qn('w:right'), str(int(14 * 20)))
+                    ind.set(qn('w:right'), str(int(PAGE_NUMBER_SIZE_PT * 20)))
                 else:
-                    ind.set(qn('w:left'), str(int(14 * 20)))
+                    ind.set(qn('w:left'), str(int(PAGE_NUMBER_SIZE_PT * 20)))
                 pPr.append(ind)
             try:
                 bm = section.bottom_margin

package/gongwen/__init__.py

@@ -7,7 +7,7 @@
 #
 # 公文全流程处理工具 - gongwen-skill Python package
 
-__version__ = "2.6.1"
+__version__ = "2.7.0"
 
 # Re-export everything from the legacy module for backward compatibility
 # This allows: from gongwen import main, cmd_check, etc.

package/gongwen/_legacy.py

@@ -39,13 +39,20 @@ from gongwen.cli.doctor_cmds import (
     cmd_doctor,
     cmd_repair,
 )
+from gongwen.cli.wizard_cmds import (
+    cmd_wizard,
+)
 from gongwen.cli.helpers import (
     detect_doc_type as _detect_doc_type,
     build_output_name as _build_output_name,
     parse_config_overrides as _parse_config_overrides,
     load_rules_with_overrides as _load_rules_with_overrides,
 )
-__version__ = "2.6.1"
+from engine.core.document.font_utils import (
+    PAGE_NUMBER_FONT,
+    PAGE_NUMBER_SIZE_PT,
+)
+__version__ = "2.7.0"
 # 版本号应与 gongwen/__init__.py 保持一致，每次发版同步更新
 """
 中文公文全流程处理工具 —— 基于 GB/T 9704《党政机关公文格式》国家标准。
@@ -68,6 +75,7 @@ __version__ = "2.6.1"
   rule-export <type>           导出某类型的合并规则为 YAML 用于二次定制
   rule-list                    列出三层规则（official / custom / user）
   rule-import <key> -f <file>  导入/保存自定义规则 YAML
+  wizard    [--answers json]     向导式交互：A/B/C/D 路径引导 + 一键执行（--dry-run 只打印命令）
   font      [list|check|install] 公文标准字体管理（方正小标宋简体/仿宋_GB2312/楷体_GB2312）
 
 示例：
@@ -945,8 +953,8 @@ def main():
     p = sub.add_parser("pagenum", help="注入页码：Word PAGE 域动态页码")
     p.add_argument("input", help="输入 .docx 路径")
     p.add_argument("-o", "--output", help="输出 .docx 路径（默认原地修改）")
-    p.add_argument("--font", default="宋体", help="页码字体（默认 宋体）")
-    p.add_argument("--size", type=int, default=14, help="页码字号（默认 14）")
+    p.add_argument("--font", default=PAGE_NUMBER_FONT, help="页码字体（默认 宋体）")
+    p.add_argument("--size", type=int, default=PAGE_NUMBER_SIZE_PT, help="页码字号（默认 14）")
     p.add_argument("--alignment", default="right",
                    choices=["center", "left", "right"],
                    help="对齐（默认 right 单右双左奇偶排版，适配双面打印；center 居中；left 左对齐）")
@@ -1096,6 +1104,14 @@ def main():
     p.add_argument("--title", default="", help="待审文稿标题")
     p.set_defaults(func=cmd_review)
 
+    # ---- 向导式交互 ----
+    p = sub.add_parser("wizard", help="向导式交互：A/B/C/D 路径引导 + 一键执行（--answers 非交互 / --dry-run 只打印）")
+    p.add_argument("--answers", default="",
+                   help="答案 JSON 文件路径（Agent 非交互模式）："
+                        '{"path":"A","input":"a.docx","apply":true}')
+    p.add_argument("--dry-run", action="store_true", help="只打印将执行的命令，不真正执行")
+    p.set_defaults(func=cmd_wizard)
+
     # ---- 字体管理 ----
     p = sub.add_parser("font", help="公文标准字体管理：安装/检查/列出内置字体")
     p.add_argument("action", nargs="?", default="list",

package/gongwen/cli/wizard_cmds.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# (c) 2026 Jose AI (https://www.linhut.cn)
+# https://github.com/linhut/gongwen-skill
+# Licensed under the MIT License. See the LICENSE file for details.
+#
+# gongwen wizard —— 向导式交互命令
+# A/B/C/D 路径引导 + 一键执行；终端交互 + --answers JSON 非交互双模式。
+"""向导式交互：以 A/B/C/D 路径菜单引导用户，交互收集参数后直接执行对应命令。
+
+使用方式：
+    python -m gongwen wizard                       # 终端交互模式
+    python -m gongwen wizard --answers a.json      # Agent 非交互模式
+    python -m gongwen wizard --answers a.json --dry-run  # 只打印将执行的命令
+
+--answers JSON 扁平结构（顶层带 path）：
+    {"path": "A", "input": "a.docx", "doc_type": "notice",
+     "output": "b.docx", "apply": true}
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+
+# 路径定义：(键, 标题, 一句话说明, 子命令)
+PATH_DEFS = [
+    ("A", "格式优化", "不改文字只修排版，按国标（GB/T 9704）标准化", "optimize"),
+    ("B", "内容优化", "润色文字表达，红色标注+删除线对比版", "optimize-content"),
+    ("C", "生成模板", "按类型生成一份 GB/T 9704 空白模板", "template"),
+    ("D", "一键格式修复", "段落类型/编号拆分/首句加粗等常见问题快速修复", "fix-common"),
+]
+PATH_KEYS = [p[0] for p in PATH_DEFS]
+
+
+# ---------------------------------------------------------------------------
+# 交互 helper
+# ---------------------------------------------------------------------------
+
+def _ask(question: str, default: str | None = None) -> str:
+    """交互提问：显示默认值，返回去除首尾空白的输入。
+
+    输入为空时返回默认值；default 为 None 且输入为空时返回空串，
+    由调用方决定是否必填重问。
+    """
+    if default:
+        prompt = f"{question} [{default}]: "
+    else:
+        prompt = f"{question}: "
+    try:
+        raw = input(prompt).strip()
+    except EOFError:
+        return default or ""
+    except KeyboardInterrupt:
+        print("\n已取消向导。", file=sys.stderr)
+        raise SystemExit(130)
+    return raw or (default or "")
+
+
+def _ask_yes_no(question: str, default: bool = True) -> bool:
+    """y/n 确认。Enter 使用默认值。"""
+    hint = "Y/n" if default else "y/N"
+    while True:
+        raw = input(f"{question} ({hint}): ").strip().lower()
+        if not raw:
+            return default
+        if raw in ("y", "yes", "是"):
+            return True
+        if raw in ("n", "no", "否"):
+            return False
+        print("请输入 y 或 n。", file=sys.stderr)
+
+
+def _ask_path() -> str:
+    """展示 A/B/C/D 菜单，返回路径键。"""
+    print("\n请选择要执行的操作：\n")
+    for key, title, desc, _sub in PATH_DEFS:
+        print(f"  {key}. {title} —— {desc}")
+    print()
+    while True:
+        try:
+            raw = input("请输入路径（A/B/C/D，Enter 退出）: ").strip().upper()
+        except EOFError:
+            print("已退出向导。")
+            raise SystemExit(0)
+        if not raw:
+            print("已退出向导。")
+            raise SystemExit(0)
+        if raw in PATH_KEYS:
+            return raw
+        print("无效路径，请输入 A/B/C/D。", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# 类型匹配
+# ---------------------------------------------------------------------------
+
+def _load_available_types() -> list[str]:
+    """加载 rules/official 下的公文类型 id 列表（排序）。"""
+    from engine.core.rules.loader import list_available_types
+    return list_available_types()
+
+
+def _resolve_doc_type(raw: str, types: list[str]) -> str:
+    """类型智能匹配：序号 / id / 中文名 / 子串。找不到抛 ValueError。"""
+    raw = raw.strip()
+    if not raw:
+        raise ValueError("公文类型不能为空")
+    if raw.isdigit():
+        idx = int(raw)
+        if 1 <= idx <= len(types):
+            return types[idx - 1]
+        raise ValueError(f"序号超出范围（1-{len(types)}）：{raw}")
+
+    if raw in types:
+        return raw
+
+    # 中文名匹配（复用 helpers.TYPE_KEYWORDS 关键词表）
+    try:
+        from gongwen.cli.helpers import TYPE_KEYWORDS
+        for kw, tid in TYPE_KEYWORDS.items():
+            if raw == kw or raw in kw or kw in raw:
+                return tid
+    except ImportError:
+        pass
+
+    # 子串匹配 id（如 "not" → notice）
+    hits = [t for t in types if raw.lower() in t]
+    if len(hits) == 1:
+        return hits[0]
+
+    raise ValueError(
+        f"无法识别公文类型：{raw}。可用：{', '.join(types)}，"
+        "或输入序号/中文名（如 通知）。"
+    )
+
+
+def _prompt_doc_type(default: str | None = None) -> str:
+    """交互收集公文类型：展示序号列表，支持序号/id/中文名。"""
+    types = _load_available_types()
+    print("\n可用公文类型：")
+    for i, t in enumerate(types, 1):
+        print(f"  {i:2d}. {t}")
+    print()
+    while True:
+        raw = _ask("请输入公文类型（序号 / id / 中文名）", default or "")
+        if not raw:
+            return types[0]
+        try:
+            return _resolve_doc_type(raw, types)
+        except ValueError as e:
+            print(f"  ⚠ {e}", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# 参数收集
+# ---------------------------------------------------------------------------
+
+def _get(answers: dict, key: str, default: str | None = None) -> str | None:
+    """从 answers 取参数；缺失返回 default。"""
+    val = answers.get(key)
+    if val is None:
+        return default
+    s = str(val).strip()
+    return s or default
+
+
+def _require(answers: dict, key: str, label: str, interactive: bool,
+             validator=None) -> str:
+    """必填参数：answers 优先；缺失时交互补充；非交互报错。"""
+    val = _get(answers, key)
+    if val:
+        if validator and not validator(val):
+            raise SystemExit(f"参数验证失败: {label}={val!r}")
+        return val
+    if not interactive:
+        raise SystemExit(f"缺少必填参数 {key}（{label}）—— 请在 --answers JSON 中提供")
+    while True:
+        raw = _ask(f"请输入{label}")
+        if not raw:
+            print(f"  ⚠ {label}不能为空", file=sys.stderr)
+            continue
+        if validator and not validator(raw):
+            print(f"  ⚠ {label}验证失败，请重新输入", file=sys.stderr)
+            continue
+        return raw
+
+
+def _file_exists(p: str) -> bool:
+    return Path(p).expanduser().is_file()
+
+
+def _collect_params(path_key: str, answers: dict, interactive: bool) -> dict:
+    """按路径收集参数并返回。answers 优先，缺失时交互补充。"""
+    params: dict = {}
+
+    if path_key == "A":
+        params["input"] = _require(
+            answers, "input", "输入 .docx 路径", interactive,
+            validator=lambda p: _file_exists(p) or print(f"  ⚠ 文件不存在: {p}", file=sys.stderr) or False)
+        params["doc_type"] = _get(answers, "doc_type") or ""
+        params["output"] = _get(answers, "output") or ""
+    elif path_key == "B":
+        params["input"] = _require(
+            answers, "input", "输入 .docx 路径", interactive,
+            validator=lambda p: _file_exists(p) or print(f"  ⚠ 文件不存在: {p}", file=sys.stderr) or False)
+        changes = _get(answers, "changes")
+        if interactive and not changes:
+            changes = _ask("变更 JSON 路径（可回车留空，留空需 --auto-generate 生成建议）")
+        params["changes"] = changes or ""
+        params["output"] = _get(answers, "output") or ""
+    elif path_key == "C":
+        raw_type = _get(answers, "doc_type")
+        if interactive and not raw_type:
+            params["doc_type"] = _prompt_doc_type()
+        elif raw_type:
+            params["doc_type"] = _resolve_doc_type(raw_type, _load_available_types())
+        else:
+            raise SystemExit("缺少必填参数 doc_type（公文类型）—— 请在 --answers JSON 中提供")
+        params["output"] = _get(answers, "output") or ""
+    elif path_key == "D":
+        params["input"] = _require(
+            answers, "input", "输入 .docx 路径", interactive,
+            validator=lambda p: _file_exists(p) or print(f"  ⚠ 文件不存在: {p}", file=sys.stderr) or False)
+        params["output"] = _get(answers, "output") or ""
+    else:
+        raise SystemExit(f"未知路径: {path_key}")
+
+    return params
+
+
+# ---------------------------------------------------------------------------
+# 命令构造与执行
+# ---------------------------------------------------------------------------
+
+def _build_cmd(path_key: str, params: dict, apply: bool) -> list[str]:
+    """拼出 [sys.executable, -m, gongwen, 子命令, ...] argv。"""
+    sub_cmd = dict((p[0], p[3]) for p in PATH_DEFS)[path_key]
+    argv = [sys.executable, "-m", "gongwen", sub_cmd]
+
+    if path_key == "A":
+        argv.append(params["input"])
+        if params.get("doc_type"):
+            argv += ["-t", params["doc_type"]]
+        if params.get("output"):
+            argv += ["-o", params["output"]]
+        if apply:
+            argv.append("--apply")
+    elif path_key == "B":
+        argv.append(params["input"])
+        if params.get("changes"):
+            argv += ["--changes", params["changes"]]
+        elif apply:
+            argv.append("--auto-generate")
+        if params.get("output"):
+            argv += ["-o", params["output"]]
+        if apply:
+            argv.append("--apply")
+    elif path_key == "C":
+        argv.append(params["doc_type"])
+        if params.get("output"):
+            argv += ["-o", params["output"]]
+    elif path_key == "D":
+        argv.append(params["input"])
+        if params.get("output"):
+            argv += ["-o", params["output"]]
+
+    return argv
+
+
+def _print_cmd(argv: list[str]) -> str:
+    """把 argv 拼成可读命令行字符串（Windows 兼容/引号）。"""
+    return " ".join(shlex.quote(a) for a in argv)
+
+
+def _run(argv: list[str], dry_run: bool) -> int:
+    """subprocess 执行（输出流式透传）；dry-run 只打印。"""
+    cmd_str = _print_cmd(argv)
+    if dry_run:
+        print(f"[dry-run] {cmd_str}")
+        return 0
+    print(f"▶ {cmd_str}", file=sys.stderr)
+    return subprocess.call(argv)
+
+
+def _confirm_and_run(argv: list[str], dry_run: bool, interactive: bool,
+                     apply: bool) -> int:
+    """A/B/D 修改类路径执行。
+
+    apply=True（用户选择直接执行）→ 跳过预览，直接执行（argv 已含 --apply；
+    D 无 --apply 概念，原样执行）。
+    apply=False → 先预览（optimize/optimize-content 无 --apply 即预览模式；
+    fix-common 显示将要执行的命令），再 y/n 确认，确认后 A/B 自动补
+    --apply 真正执行，拒绝则取消。
+    非交互模式 apply=False：仅预览不执行（安全默认），提示加 apply:true。
+    """
+    sub_cmd = _argv_sub(argv)
+    has_apply = "--apply" in argv
+
+    if dry_run:
+        if path_key_is_b(sub_cmd):
+            preview_argv = [a for a in argv if a != "--apply"]
+            print(f"[dry-run] 预览: {_print_cmd(preview_argv)}")
+            if apply:
+                print(f"[dry-run] 执行: {_print_cmd(argv)}")
+        else:
+            print(f"[dry-run] 执行: {_print_cmd(argv)}")
+        return 0
+
+    if apply:
+        # 直接执行（跳过预览确认）
+        return _run(argv, dry_run=False)
+
+    # 先预览
+    if path_key_is_b(sub_cmd):
+        rc = _run(argv, dry_run=False)  # argv 无 --apply 即预览模式
+        if rc != 0:
+            return rc
+    else:
+        print(f"将要执行: {_print_cmd(argv)}")
+
+    if not interactive:
+        # 非交互缺 apply：安全默认只预览，不执行
+        print("\n（非交互模式未提供 apply:true，仅预览未执行。"
+              "如需执行请加 apply:true 重新运行）")
+        return 0
+
+    if not _ask_yes_no("确认执行？（将修改/生成文件）", default=False):
+        print("已取消。")
+        return 0
+    # 确认后：A/B 补 --apply 真正执行（D 无 apply 概念，原样执行）
+    exec_argv = list(argv)
+    if path_key_is_b(sub_cmd) and not has_apply:
+        exec_argv.append("--apply")
+    return _run(exec_argv, dry_run=False)
+
+
+def _argv_sub(argv: list[str]) -> str:
+    """从 argv 提取子命令名（[python, -m, gongwen, sub, ...]）。"""
+    return argv[3] if len(argv) > 3 else ""
+
+
+def path_key_is_b(sub_cmd: str) -> bool:
+    """子命令是否需要先跑预览模式（optimize / optimize-content）。"""
+    return sub_cmd in ("optimize", "optimize-content")
+
+
+def _non_interactive_plan(path_key: str, params: dict, apply: bool,
+                          dry_run: bool) -> int:
+    """非交互（--answers）执行路径；dry-run 只打印。"""
+    argv = _build_cmd(path_key, params, apply)
+    if path_key == "C":
+        return _run(argv, dry_run)
+    return _confirm_and_run(argv, dry_run, interactive=False, apply=apply)
+
+
+# ---------------------------------------------------------------------------
+# 入口
+# ---------------------------------------------------------------------------
+
+def cmd_wizard(args: argparse.Namespace) -> int:
+    """wizard 命令入口。"""
+    answers: dict = {}
+    # --answers 提供即视为非交互（Agent 场景），严格校验字段，不做 isatty 猜测
+    interactive = True
+
+    if getattr(args, "answers", None):
+        p = Path(args.answers).expanduser()
+        if not p.is_file():
+            raise SystemExit(f"--answers 文件不存在: {p}")
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as e:
+            raise SystemExit(f"--answers JSON 解析失败: {e}")
+        if not isinstance(data, dict):
+            raise SystemExit("--answers 必须是一个 JSON 对象")
+        answers = data
+        interactive = False
+
+    dry_run = bool(getattr(args, "dry_run", False))
+
+    path_key = answers.get("path")
+    if not path_key:
+        if not interactive:
+            raise SystemExit("缺少必填参数 path（A/B/C/D）—— 请在 --answers JSON 中提供")
+        path_key = _ask_path()
+    path_key = str(path_key).strip().upper()
+    if path_key not in PATH_KEYS:
+        raise SystemExit(f"无效 path: {path_key}（可选 A/B/C/D）")
+
+    apply = bool(answers.get("apply", False))
+
+    try:
+        params = _collect_params(path_key, answers, interactive)
+    except ValueError as e:
+        raise SystemExit(str(e))
+
+    if not interactive:
+        return _non_interactive_plan(path_key, params, apply, dry_run)
+    if dry_run:
+        # 交互 + dry-run：打印将执行的命令
+        argv = _build_cmd(path_key, params, False)
+        print(f"[dry-run] {_print_cmd(argv)}")
+        return 0
+    return _interactive_flow_selected(path_key, params)
+
+
+def _interactive_flow_selected(path_key: str, params: dict) -> int:
+    """交互模式已有 path/params 时的执行分支。"""
+    if path_key == "C":
+        # C 生成模板无修改风险，直接执行，不问确认
+        argv = _build_cmd(path_key, params, False)
+        return _run(argv, dry_run=False)
+    apply = _ask_yes_no("是否直接执行（跳过预览确认）？", default=False)
+    argv = _build_cmd(path_key, params, apply)
+    return _confirm_and_run(argv, dry_run=False, interactive=True, apply=apply)

package/gongwen/md2docx_render.py

@@ -397,8 +397,9 @@ def _add_paragraph(doc: Document, para, rules: dict):
                 run.font.bold = True
             if fmt.italic is not None:
                 run.font.italic = fmt.italic
-            if fmt.strikethrough is True:
-                run.font.strike = True
+            if fmt.strikethrough is not None:
+                # True 设置删除线 / False 显式清除已有删除线（避免 strikethrough=False 时旧删除线残留）
+                run.font.strike = fmt.strikethrough
             if fmt.color:
                 try:
                     rgb = str(fmt.color).lstrip("#")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gongwen-skill",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "公文全流程处理工具 - GB/T 9704 格式检查/修复/内容优化/模板生成/版式注入",
   "type": "module",
   "main": "dsh/index.js",

package/prompts/usage-prompts.md

@@ -201,7 +201,7 @@ python -m gongwen optimize 文件.docx -o 优化版.docx
 **Agent 响应**：
 ```
 📋 合规自检报告
-Skill 版本: v2.6.1
+Skill 版本: v2.7.0
 路径判定: B（内容优化）
 依据: 用户提供纯文本+优化要求，无已有文档
 命令调用: 将原文保存为临时文件后执行 optimize-content --apply --paragraphs "1-3"

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gongwen-skill"
-version = "2.6.1"
+version = "2.7.0"
 description = "公文全流程处理工具 - GB/T 9704 格式检查/修复/内容优化/模板生成/版式注入"
 readme = "README.md"
 license = {text = "MIT"}