gongwen-skill 2.2.0 → 2.4.0

package/engine/core/document/parser.py

@@ -320,27 +320,63 @@ def _assign_paragraph_roles(paragraphs: list[Paragraph]) -> None:
             para.role = 'cc'
             continue
 
-    # 落款：日期前的短文本（< 20 字，或含机关关键词）
+    # 落款：日期前的短文本（< 20 字，或含机关关键词）——支持多行落款单位
+    # V2.3 修复：原实现只识别日期前一段；长单位名跨两行（如"XX民族传统体育运动会"换行"XX办公室"）
+    # 时只标最后一行，第一行被当 body 应用正文缩进。现从日期前一段向上连续扫描落款单位行。
+    # 收集附件说明内容（"附件：xxx"），用于把"附件标题"与"落款单位"区分开：
+    # 附件标题（heading 且带分页，或文本与附件说明一致）不是落款，扫描到此为止；
+    # 被 B-0 启发式误判为标题的居中落款单位行（如"XX民族传统体育运动会"）则照常标为 signature。
+    _att_note_items: list[str] = []
+    for _p in paragraphs:
+        _pt = (_p.text or '').strip()
+        if _pt.startswith(('附件：', '附：')):
+            _rest = re.sub(r'^附[:：]', '', _pt)
+            for _seg in re.split(r'[、，]', _rest):
+                _seg = re.sub(r'^d+[.、]', '', _seg).strip()
+                if _seg:
+                    _att_note_items.append(_seg)
+
     date_indices = [i for i, p in non_empty if p.role == 'date']
     if date_indices:
         date_idx = date_indices[-1]
-        for i in range(len(non_empty)):
-            idx, para = non_empty[i]
-            if idx == date_idx - 1:
+        date_pos = next((i for i, (idx, p) in enumerate(non_empty) if idx == date_idx), -1)
+        if date_pos > 0:
+            for i in range(date_pos - 1, -1, -1):
+                idx, para = non_empty[i]
                 text = para.text.strip()
+                # 已识别其他角色（如抄送/印发/attachment）→ 落款区到此为止
+                if para.role:
+                    break
+                # 句末标点结尾 = 正文收尾，不是落款单位
+                if not text or text[-1] in '。？！；，、':
+                    break
+                # 附件说明/附件标题（"附件："开头）不是落款
+                if text.startswith(('附件', '附：')):
+                    break
                 is_sig = False
                 if len(text) < 20:
                     is_sig = True
                 elif any(kw in text for kw in ['人民政府', '委员会', '办公厅', '办公室', '管理局', '局', '部']):
                     if len(text) < 40:
                         is_sig = True
-                if is_sig:
-                    para.role = 'signature'
-                    # P4 修复：居中署名段（如"陈龙"）可能被 B-0 启发式误判为标题，
-                    # 落款区识别后清除标题标记，避免 optimize 套用标题格式破坏署名段
-                    if para.is_heading:
-                        para.is_heading = False
-                        para.heading_level = None
+                if not is_sig:
+                    break
+                # 续行是标题段：仅当是"附件标题"（带分页 或 文本与附件说明一致）才停止，
+                # 否则（如 B-0 误判的居中落款单位）继续标为 signature 并清除标题标记
+                if i < date_pos - 1 and para.is_heading:
+                    _pb = bool(getattr(para, "page_break", False))
+                    _matches_att = any(
+                        _seg and (_seg == text or _seg.endswith(text))
+                        for _seg in _att_note_items
+                    )
+                    if _pb or _matches_att:
+                        break
+                para.role = 'signature'
+                # P4 修复：居中署名段（如"陈龙"）可能被 B-0 启发式误判为标题，
+                # 落款区识别后清除标题标记，避免 optimize 套用标题格式破坏署名段
+                if para.is_heading:
+                    para.is_heading = False
+                    para.heading_level = None
 
     # 主送机关：标题后第一段，以冒号结尾
     if len(non_empty) >= 2:
@@ -352,10 +388,15 @@ def _assign_paragraph_roles(paragraphs: list[Paragraph]) -> None:
             elif any(kw in text for kw in _RECIPIENT_KEYWORDS) and text.endswith(('：', ':')):
                 second_para.role = 'recipient'
 
-    # 附件
+    # 附件（区分附件说明 vs 附件页标题）
+    # 附件标题（# 附件：，heading level 0，如"附件：报名表"）应标为 title，
+    # 而非 attachment——否则 CHK-C027 会误把标题当附件说明查"左空二字"缩进。
     for idx, para in non_empty:
         if not para.role and _ATTACHMENT_RE.match(para.text.strip()):
-            para.role = 'attachment'
+            if para.is_heading and para.heading_level == 0:
+                para.role = 'title'
+            else:
+                para.role = 'attachment'
 
     # AI 声明段（末尾批注，如"（内容由GongWen-skill-AI生成，仅供参考）"）
     # 标记为 annotation 角色，避免 check 将其误判为正文并报格式违规
@@ -506,7 +547,10 @@ def parse_docx(file_path: Path | str) -> DocumentModel:
     from lxml import etree
     from engine.core.document.ooxml_parser import OOXMLParser  # I7: 集成 OOXMLParser
     para_count = 0
-    table_position_map = {}  # {table_element_id: last_para_index_before_it}
+    # {table_element: last_para_index_before_it}
+    # 注意：必须用 lxml 元素对象本身作 key，不能用 id(child)——body 迭代产生的
+    # 临时代理对象 id 会被复用（多表格时键冲突/错位，锚点全部落回 -1）。
+    table_position_map = {}
     ooxml = OOXMLParser()
     para_index_map = ooxml.get_paragraph_index_map(str(file_path))  # I7: 段落索引映射
     for child in doc.element.body:
@@ -514,14 +558,14 @@ def parse_docx(file_path: Path | str) -> DocumentModel:
         if tag == 'p':
             para_count += 1
         elif tag == 'tbl':
-            table_position_map[id(child)] = para_count - 1  # 紧跟在哪个段落之后
+            table_position_map[child] = para_count - 1  # 紧跟在哪个段落之后
 
     tables = []
     for idx, table in enumerate(doc.tables):
         parsed_table = _parse_table(table, idx)
-        # 计算 insert_after_index
+        # 计算 insert_after_index（用元素对象查表，与上面 body 遍历的 key 一致）
         tbl_elem = table._tbl
-        parsed_table.insert_after_index = table_position_map.get(id(tbl_elem), -1)
+        parsed_table.insert_after_index = table_position_map.get(tbl_elem, -1)
         tables.append(parsed_table)
 
     model = DocumentModel(
@@ -771,6 +815,9 @@ def _parse_paragraph(para, index: int) -> Paragraph:
                 # 公文大标题（方正小标宋简体）优先级更高
                 heading_level = 0
 
+    # 段前分页（--- 附件分页标记）：读取 w:pageBreakBefore
+    page_break = bool(getattr(para.paragraph_format, "page_break_before", False))
+
     return Paragraph(
         text=para.text,
         index=index,
@@ -779,6 +826,7 @@ def _parse_paragraph(para, index: int) -> Paragraph:
         heading_level=heading_level,
         format=para_format,
         runs=runs,
+        page_break=page_break,
     )
 
 
@@ -819,16 +867,27 @@ _PRINT_RE = re.compile(r'^印发机关|^印发日期')
 
 def _parse_table(table, index: int) -> Table:
     """Parse a table with cell-level paragraph preservation."""
+    from docx.oxml.ns import qn as _qn
     cells = []
     # P1-5 修复：合并单元格时 python-docx 对同一 XML 元素返回多个 cell 对象，
-    # 用 id(cell._element) 去重，避免重复添加破坏写回
-    seen_cells: set[int] = set()
+    # 用元素对象本身去重，避免重复添加破坏写回。
+    # V2.3 修复：此前用 id(cell._element) 去重——lxml 代理对象 id 会被 GC 复用，
+    # 非合并表格也会误丢大量单元格（实测 88 个误丢 51 个），改用元素对象做 key
+    # （与 parse_docx 的 table_position_map[child] 同法，元素对象哈希基于节点身份）。
+    seen_cells: set = set()
     for row_idx, row in enumerate(table.rows):
         for col_idx, cell in enumerate(row.cells):
-            elem_id = id(cell._element)
-            if elem_id in seen_cells:
+            cell_elem = cell._element
+            if cell_elem in seen_cells:
                 continue
-            seen_cells.add(elem_id)
+            seen_cells.add(cell_elem)
+            # V2.3：表头单元格底色（w:shd fill）——供表格样式检测/修复
+            cell_fill = None
+            _tcPr = cell._tc.tcPr
+            if _tcPr is not None:
+                _shd = _tcPr.find(_qn('w:shd'))
+                if _shd is not None:
+                    cell_fill = _shd.get(_qn('w:fill')) or None
             # Parse cell paragraphs
             cell_paras = []
             for p_idx, para in enumerate(cell.paragraphs):
@@ -839,13 +898,27 @@ def _parse_table(table, index: int) -> Table:
                 row=row_idx,
                 col=col_idx,
                 paragraphs=cell_paras,
+                fill=cell_fill,
             ))
 
+    # V2.3：单元格边距（w:tblCellMar，twips）——供表格样式检测/修复
+    cell_margin = None
+    _tblPr = table._tbl.tblPr
+    if _tblPr is not None:
+        _cm = _tblPr.find(_qn('w:tblCellMar'))
+        if _cm is not None:
+            cell_margin = {}
+            for _edge in ('top', 'left', 'bottom', 'right'):
+                _el = _cm.find(_qn('w:' + _edge))
+                if _el is not None:
+                    cell_margin[_edge] = int(_el.get(_qn('w:w'), 0) or 0)
+
     return Table(
         index=index,
         rows=len(table.rows),
         cols=len(table.columns) if table.rows else 0,
         cells=cells,
+        cell_margin=cell_margin,
     )
 
 # 已迁移至 parser_format.py

package/engine/core/document/parser_format.py

@@ -121,7 +121,10 @@ def parse_run(run, index: int) -> Run:
         color_rgb = str(font.color.rgb)
 
     # 通过 XML 检测删除线（python-docx 1.2.0 无 font.strikethrough）
-    # 注意：必须检查 w:val 属性——<w:strike w:val="false"/> 表示无删除线
+    # V2.3 修复：w:val 布尔取值须处理 OOXML 全套写法（true/1/on 为真；
+    # false/0/off 为假）。原实现只认 'false'，导致 <w:strike w:val="0"/>
+    # （无删除线）被误判为真删除线，optimize 的 clean_path_b_markers 会
+    # 借此删掉标题/正文 run，进而丢失字体（全部回退为仿宋_GB2312）。
     _strikethrough = False
     ns = '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}'
     rPr = run._element.find(f'{ns}rPr')
@@ -129,7 +132,7 @@ def parse_run(run, index: int) -> Run:
         strike_elem = rPr.find(f'{ns}strike')
         if strike_elem is not None:
             val = strike_elem.get(f'{ns}val', 'true')
-            _strikethrough = val.lower() != 'false'
+            _strikethrough = val.strip().lower() not in ('false', '0', 'off')
 
     return Run(
         text=run.text,

package/engine/core/rules/checker.py

@@ -102,6 +102,11 @@ def check_document(model: DocumentModel, rules: dict[str, Any]) -> list[CheckIss
             # 此前无分发分支，规则定义但从不执行
             issues.extend(_check_header_field(model, rule_id, severity, name, field_path,
                                               expected, message))
+        elif field_path.startswith("table."):
+            # V2.3：table.* 表格样式检查（表头字体/字号/加粗/对齐/底色、表体字体/字号、
+            # 单元格边距）——此前 _common.yaml 的 table 配置块为死配置，无任何 CHK 规则
+            issues.extend(_check_table_style(model, rule_id, severity, name, field_path,
+                                             expected, message))
         else:
             # P1-6 修复：删除 generic else 中的硬编码索引逻辑（model.paragraphs[0]/[1]
             # 不一定是标题/正文，检查结果会指向错误段落），未识别的 field 直接 skip + warning
@@ -348,7 +353,11 @@ def _check_body(model, rule_id, severity, name, field_path, expected, message) -
     issues = []
     # 顶格左对齐的段落（主送机关/称呼段、署名、日期、AI 声明批注）不属于正文，
     # 不应套用正文的缩进/对齐/字体检查
-    _EXCLUDE_ROLES = {'signature', 'date', 'annotation', 'notes', 'recipient', 'salutation'}
+    # V2.3 修复：附件说明（attachment）有自己的格式规范（CHK-C027 左空二字），
+    # 不属于正文——若纳入正文行距检查，会报出 FIX-C015（target=body，仅 role=='body'）
+    # 修不到的问题，形成"检查报错但优化不动"的不一致。
+    _EXCLUDE_ROLES = {'signature', 'date', 'annotation', 'notes', 'recipient',
+                      'salutation', 'attachment'}
     body_paras = [p for p in model.paragraphs
                   if not p.is_heading and p.text.strip() and p.role not in _EXCLUDE_ROLES]
     if not body_paras:
@@ -971,16 +980,24 @@ def _check_common_issues(model: DocumentModel) -> list[CheckIssue]:
             ))
 
         # Extra blank lines (empty paragraphs)
-        if not text.strip() and para.index > 0:
-            prev = model.paragraphs[para.index - 1] if para.index - 1 < len(model.paragraphs) else None
-            if prev and not prev.text.strip():
+        # V2.3 修复：连续 2 个空行是规范允许的（blank_line_rules.body_to_signature=2，
+        # 附件说明/正文与落款之间空 2 行）；仅当连续空行 >= 3 时，第 3 个起才算多余。
+        # 原实现把任意连续 2 空行都报"多余空行"，与规范冲突（误报）。
+        if not text.strip() and para.index > 1:
+            # 连续空行数：从本段向前数（含本段）
+            run_len = 0
+            j = para.index
+            while j >= 0 and j < len(model.paragraphs) and not model.paragraphs[j].text.strip():
+                run_len += 1
+                j -= 1
+            if run_len >= 3:
                 issues.append(CheckIssue(
                     rule_id="CHK-HEUR-002", check_type="format", severity="P2",
                     name="多余空行",
                     location=f"paragraph:{para.index}",
                     original_text="(空行)",
                     suggested_fix="移除多余空行",
-                    reason="连续出现多个空行",
+                    reason="连续出现多个空行（规范允许落款前 2 空行）",
                 ))
 
     # --- 页码检查（GB/T 9704: 公文应标注页码）---
@@ -1001,3 +1018,115 @@ def _check_common_issues(model: DocumentModel) -> list[CheckIssue]:
         ))
 
     return issues
+
+
+# ---------------------------------------------------------------------------
+#  Table style checks (V2.3)
+# ---------------------------------------------------------------------------
+
+def _check_table_style(model, rule_id, severity, name, field_path, expected, message) -> list:
+    """检查表格具体样式（field: table.header.* / table.body.* / table.cell_margin.*）。
+
+    - header.font / header.size / header.bold / header.align：取自表头行（row==0）首段首 run
+    - header.fill：取自 TableCell.fill（parser 解析 w:shd）
+    - body.font / body.size：取自数据行（row>0）非空单元格首段首 run
+    - cell_margin.left/right/top/bottom：取自 Table.cell_margin（parser 解析 w:tblCellMar）
+    """
+    issues: list = []
+    if not model.tables:
+        return issues
+    sub = field_path.split(".", 1)[1] if "." in field_path else ""
+
+    def _style_run(cell):
+        """取单元格用于样式检查的 run：优先第一个非空文本 run，其次第一个有样式 run。"""
+        if not cell.paragraphs:
+            return None, None
+        for para in cell.paragraphs:
+            for run in para.runs:
+                if run.text.strip():
+                    return para, run
+        for para in cell.paragraphs:
+            if para.runs:
+                return para, para.runs[0]
+        return None, None
+
+    for ti, table in enumerate(model.tables):
+        loc = f"table:{ti}"
+
+        if sub in ("header.font", "header.size", "header.bold", "header.align"):
+            hdr_cells = [c for c in table.cells if c.row == 0]
+            if not hdr_cells:
+                continue
+            for c in hdr_cells:
+                para, run = _style_run(c)
+                if para is None or run is None:
+                    continue
+                if sub == "header.font":
+                    got = run.format.font_name
+                    if got != expected:
+                        issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                                 str(got), str(expected), message))
+                        break
+                elif sub == "header.size":
+                    got = run.format.font_size_pt
+                    exp_pt = float(str(expected).replace("pt", ""))
+                    if got is None or abs(got - exp_pt) > 0.5:
+                        issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                                 str(got), str(expected), message))
+                        break
+                elif sub == "header.bold":
+                    got = run.format.bold
+                    if bool(got) != bool(expected):
+                        issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                                 str(got), str(expected), message))
+                        break
+                elif sub == "header.align":
+                    got = para.format.alignment if para.format else None
+                    if got != expected:
+                        issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                                 str(got), str(expected), message))
+                        break
+
+        elif sub == "header.fill":
+            hdr_cells = [c for c in table.cells if c.row == 0]
+            if not hdr_cells:
+                continue
+            for c in hdr_cells:
+                got = getattr(c, "fill", None)
+                if (got or "").strip().lower() != str(expected).strip().lower():
+                    issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                             str(got), str(expected), message))
+                    break
+
+        elif sub in ("body.font", "body.size"):
+            body_cells = [c for c in table.cells if c.row > 0 and (c.text or "").strip()]
+            if not body_cells:
+                continue
+            for c in body_cells:
+                _para, run = _style_run(c)
+                if run is None:
+                    continue
+                if sub == "body.font":
+                    got = run.format.font_name
+                    if got != expected:
+                        issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                                 str(got), str(expected), message))
+                        break
+                else:  # body.size
+                    got = run.format.font_size_pt
+                    exp_pt = float(str(expected).replace("pt", ""))
+                    if got is None or abs(got - exp_pt) > 0.5:
+                        issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                                 str(got), str(expected), message))
+                        break
+
+        elif sub.startswith("cell_margin"):
+            margin = getattr(table, "cell_margin", None) or {}
+            edge = sub.split(".")[-1]
+            got = margin.get(edge)
+            exp = int(expected)
+            if got is None or got != exp:
+                issues.append(CheckIssue(rule_id, "format", severity, name, loc,
+                                         str(got), str(expected), message))
+
+    return issues

package/engine/core/rules/fixer.py

@@ -18,6 +18,7 @@ from engine.core.document.models import DocumentModel
 from engine.core.document.modifier import (
     modify_font, modify_size, modify_alignment, modify_line_spacing,
     modify_first_line_indent, modify_margins, modify_bold,
+    modify_paper_size,  # V2.3：纸张尺寸修复（FIX-C054）
     remove_extra_spaces, remove_extra_blank_lines,
     normalize_punctuation, normalize_heading_content,
     convert_markdown, fix_bold_range,
@@ -49,6 +50,12 @@ _ACTION_MAP = {
     ),
     "set_margins": lambda model, target, value, _rules: modify_margins(model, value),
     "set_page_margins": lambda model, target, value, _rules: modify_margins(model, value),
+    "set_paper_size": lambda model, target, value, _rules: modify_paper_size(
+        model,
+        width_mm=value.get("width_mm") if isinstance(value, dict) else None,
+        height_mm=value.get("height_mm") if isinstance(value, dict) else None,
+    ),
+    "set_table_style": lambda model, target, value, _rules: _apply_table_style(model, value),
     "remove_extra_spaces": lambda model, target, value, _rules: remove_extra_spaces(model),
     "remove_extra_blank_lines": lambda model, target, value, _rules: remove_extra_blank_lines(
         model,
@@ -273,3 +280,58 @@ def _apply_fix_paragraph_type(model: DocumentModel, target: str, value: Any) ->
         modify_size(model, target, _parse_pt_value(value["size"]))
     if value.get("first_line_indent") is not None:
         modify_first_line_indent(model, target, _parse_indent_value(value["first_line_indent"]))
+
+
+def _apply_table_style(model: DocumentModel, value: Any) -> None:
+    """应用表格具体样式（V2.3，供 FIX-C055 set_table_style）。
+
+    value 格式（dict）：
+        {
+            "header": {"font": "黑体", "size": "12pt", "bold": true,
+                       "align": "center", "fill": "D9E2F3"},
+            "body":   {"font": "仿宋_GB2312", "size": "12pt", "align": "left"},
+            "cell_margin": {"top": 0, "left": 80, "bottom": 0, "right": 80},
+        }
+    对 model 中所有表格的表头行（row==0）/数据行应用样式，并设置 cell.fill 与
+    table.cell_margin；随后由 generator（_generator_helpers）写出到 docx。
+    数字单元格按智能对齐右对齐（与 _smart_align_cell 一致）。
+    """
+    import re as _re
+    if not isinstance(value, dict) or not model.tables:
+        return
+    header = value.get("header") or {}
+    body = value.get("body") or {}
+    margin = value.get("cell_margin")
+    _num_re = _re.compile(r'^[\d.,%‰]+$')
+
+    for table in model.tables:
+        if isinstance(margin, dict) and margin:
+            base = dict(table.cell_margin or {})
+            base.update(margin)
+            table.cell_margin = base
+
+        for cell in table.cells:
+            is_header = cell.row == 0
+            style = header if is_header else body
+            # 单元格段落 run 样式
+            for p in cell.paragraphs:
+                for run in p.runs:
+                    if style.get("font"):
+                        run.format.font_name = str(style["font"])
+                    if style.get("size") is not None:
+                        run.format.font_size_pt = float(str(style["size"]).replace("pt", ""))
+                    if style.get("bold") is not None and is_header:
+                        run.format.bold = bool(style["bold"])
+                # 对齐：表头居中；数据行数字右对齐、其余按 body.align
+                if is_header:
+                    if header.get("align") and p.format is not None:
+                        p.format.alignment = str(header["align"])
+                elif body.get("align") and p.format is not None:
+                    txt = (cell.text or "").strip()
+                    if _num_re.match(txt):
+                        p.format.alignment = "right"
+                    else:
+                        p.format.alignment = str(body["align"])
+            # 表头底色
+            if is_header and header.get("fill"):
+                cell.fill = str(header["fill"])

package/gongwen/__init__.py

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