feat(services): 添加图片提取和自定义样式保留功能

- 从 Word 文档中提取图片，包含位置跟踪和元数据
- 使用 HTML 注释在 Markdown 输出中保留自定义段落样式
- 添加标准样式检测，避免不必要的样式注释
- 实现带有 data URL 和样式的图片 Markdown 生成
- 增强表格单元格处理，捕获并保留自定义样式
- 从 JSON 注入编号格式，用于恢复标题编号
- 改进文档转换，在往返转换过程中保持格式保真度

app/services/document_service.py

@@ -20,6 +20,27 @@ from app.schemas.document import CreateDocumentRequest, UpdateDocumentRequest
 # Word → Markdown 解析（完整实现，支持往返转换）
 # ------------------------------------------------------------------ #
 
+# 标准样式列表（不需要添加样式注释）
+STANDARD_STYLES = {
+    "Normal",
+    "Heading 1", "Heading 2", "Heading 3", "Heading 4", "Heading 5", "Heading 6",
+    "List Bullet", "List Bullet 2", "List Bullet 3",
+    "List Number", "List Number 2", "List Number 3",
+    "Quote", "Quote Char",
+    "No Spacing",
+    "Table Grid",
+}
+
+
+def _is_standard_style(style_name: str) -> bool:
+    """判断是否为标准样式"""
+    if not style_name or style_name in STANDARD_STYLES:
+        return True
+    if style_name.startswith("Heading ") or "List Bullet" in style_name or "List Number" in style_name:
+        return True
+    return False
+
+
 def _render_run_with_format(run) -> str:
     """将单个 Run 转换为带格式的 Markdown 文本"""
     text = run.text
@@ -94,6 +115,7 @@ def _convert_table_to_markdown(table) -> str:
         # 对单元格内容也应用格式解析
         cell_text = []
         for para in cell.paragraphs:
+            para_style = para.style.name if para.style else "Normal"
             para_text = _render_para_with_inline_format(para).strip()
             # 移除表头自动添加的粗体格式
             # 因为导出时会自动给表头加粗，但原始Markdown可能没有
@@ -101,6 +123,9 @@ def _convert_table_to_markdown(table) -> str:
             if para_text.startswith("**") and para_text.endswith("**") and para_text.count("**") == 2:
                 para_text = para_text[2:-2]
             if para_text:
+                # 如果表头单元格使用自定义样式，添加注释
+                if not _is_standard_style(para_style) and para_style not in ("Normal", "Table Grid"):
+                    para_text = f"<!-- style: {para_style} -->{para_text}"
                 cell_text.append(para_text)
         header_cells.append(" ".join(cell_text))
     
@@ -116,8 +141,13 @@ def _convert_table_to_markdown(table) -> str:
             # 对单元格内容也应用格式解析
             cell_text = []
             for para in cell.paragraphs:
+                para_style = para.style.name if para.style else "Normal"
                 para_text = _render_para_with_inline_format(para).strip()
+                
                 if para_text:
+                    # 如果单元格段落使用自定义样式，添加注释
+                    if not _is_standard_style(para_style) and para_style not in ("Normal", "Table Grid"):
+                        para_text = f"<!-- style: {para_style} -->{para_text}"
                     cell_text.append(para_text)
             cells.append(" ".join(cell_text))
         md_lines.append("| " + " | ".join(cells) + " |")
@@ -176,6 +206,17 @@ def _docx_to_markdown(path: Path) -> str:
     """将 .docx 文件解析为完整 Markdown 文本（支持往返转换）"""
     doc = DocxDocument(str(path))
     
+    # 提取所有图片及其位置信息
+    from app.services.image_service import extract_images_from_word
+    images = extract_images_from_word(doc)
+    # 按段落索引建立映射，方便查找
+    image_map = {}
+    for img in images:
+        para_idx = img['paragraph_index']
+        if para_idx not in image_map:
+            image_map[para_idx] = []
+        image_map[para_idx].append(img)
+    
     # 收集所有元素（段落和表格）并按文档顺序排列
     elements = []
     
@@ -200,7 +241,15 @@ def _docx_to_markdown(path: Path) -> str:
     in_code_block = False
     code_block_lines = []
     
-    for elem_type, elem in elements:
+    # 记录实际的段落索引到元素索引的映射
+    para_idx_in_elements = {}
+    actual_para_idx = 0
+    for elem_idx, (elem_type, elem) in enumerate(elements):
+        if elem_type == "para":
+            para_idx_in_elements[actual_para_idx] = elem_idx
+            actual_para_idx += 1
+    
+    for elem_idx, (elem_type, elem) in enumerate(elements):
         if elem_type == "para":
             para = elem
             style_name = para.style.name if para.style else ""
@@ -234,6 +283,24 @@ def _docx_to_markdown(path: Path) -> str:
                 # 检测是否是分隔线（只有底部边框的空段落）
                 if _has_bottom_border(para):
                     lines.append("---")
+                
+                # 空段落也要检查是否有图片
+                current_para_idx = None
+                for para_idx, e_idx in para_idx_in_elements.items():
+                    if e_idx == elem_idx:
+                        current_para_idx = para_idx
+                        break
+                
+                if current_para_idx is not None and current_para_idx in image_map:
+                    from app.services.image_service import create_image_markdown
+                    for img in image_map[current_para_idx]:
+                        img_md = create_image_markdown(
+                            img['data_url'],
+                            img['style'],
+                            alt=f"图片"
+                        )
+                        lines.append(img_md.strip())
+                
                 continue
             
             # 标题
@@ -260,7 +327,30 @@ def _docx_to_markdown(path: Path) -> str:
             
             # 普通段落
             else:
-                lines.append(text)
+                # 如果是自定义样式，添加样式注释（和文本在同一行）
+                if not _is_standard_style(style_name) and style_name != "Normal":
+                    lines.append(f"<!-- style: {style_name} -->{text}")
+                else:
+                    lines.append(text)
+            
+            # 段落处理完成后，检查是否有图片
+            # 找到当前 elem_idx 对应的实际段落索引
+            current_para_idx = None
+            for para_idx, e_idx in para_idx_in_elements.items():
+                if e_idx == elem_idx:
+                    current_para_idx = para_idx
+                    break
+            
+            if current_para_idx is not None and current_para_idx in image_map:
+                # 在段落后输出图片
+                from app.services.image_service import create_image_markdown
+                for img in image_map[current_para_idx]:
+                    img_md = create_image_markdown(
+                        img['data_url'],
+                        img['style'],
+                        alt=f"图片"
+                    )
+                    lines.append(img_md.strip())
         
         elif elem_type == "table":
             # 如果之前在代码块中，先结束

app/services/export_service.py

@@ -1,5 +1,6 @@
 """export_service.py — 将文档 Markdown 内容转换为 .doc 文件并返回永久下载链接。"""
 
+import base64
 import io
 import json
 import time
@@ -10,6 +11,7 @@ from typing import Optional
 
 import mistune
 from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.oxml import OxmlElement
 from docx.oxml.ns import qn
 from docx.shared import Pt, RGBColor
@@ -91,6 +93,42 @@ def inject_styles_from_json(doc: Document, style_data: dict) -> None:
         styles_element.append(new_elem)
 
 
+def inject_numbering_from_json(doc: Document, style_data: dict) -> None:
+    """
+    将 JSON 中的 numbering 定义注入到文档中。
+    这样可以恢复标题的编号格式。
+    """
+    numbering_def = style_data.get("numbering")
+    if not numbering_def:
+        return  # 没有编号定义，跳过
+    
+    try:
+        # 将字典转换为 lxml Element
+        numbering_elem = dict_to_element(numbering_def)
+        
+        # 获取文档的 numbering part
+        # python-docx 可能没有 numbering part，需要创建
+        if doc.part.numbering_part is None:
+            # 创建 numbering part
+            from docx.opc.constants import CONTENT_TYPE as CT
+            from docx.opc.part import XmlPart
+            from docx.opc.packuri import PackURI
+            
+            numbering_part = XmlPart(
+                PackURI('/word/numbering.xml'),
+                CT.WML_NUMBERING,
+                numbering_elem,
+                doc.part.package
+            )
+            doc.part.relate_to(numbering_part, 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering')
+        else:
+            # 替换现有的 numbering part 内容
+            doc.part.numbering_part._element = numbering_elem
+    except Exception as e:
+        # 编号注入失败，不影响其他功能
+        print(f"警告: 编号格式注入失败: {e}")
+
+
 def _resolve_style_id(style_map: dict, *keys: str) -> Optional[str]:
     for key in keys:
         entry = style_map.get(key)
@@ -111,13 +149,53 @@ class DocxRenderer(mistune.BaseRenderer):
         self.style_map = style_map
         self.doc = Document()
         inject_styles_from_json(self.doc, style_data)
+        inject_numbering_from_json(self.doc, style_data)  # 新增：注入编号格式
         self._normal_id: Optional[str] = _resolve_style_id(style_map, "Normal", "1")
+        self.pending_style: Optional[str] = None  # 待应用的样式名
+        self.pending_image_style: Optional[dict] = None  # 待应用的图片样式
 
     def _get_style_by_id(self, style_id: str):
         for style in self.doc.styles:
             if style.style_id == style_id:
                 return style
         raise KeyError(style_id)
+    
+    def _apply_numbering_from_style(self, paragraph):
+        """
+        从段落的样式中提取编号属性并应用到段落。
+        这是必需的，因为 python-docx 不会自动继承样式的编号格式。
+        """
+        if not paragraph.style:
+            return
+        
+        try:
+            # 获取样式的 XML 元素
+            style_elem = paragraph.style.element
+            
+            # 查找样式中的编号定义
+            pPr = style_elem.find(qn('w:pPr'))
+            if pPr is None:
+                return
+            
+            numPr = pPr.find(qn('w:numPr'))
+            if numPr is None:
+                return
+            
+            # 复制编号属性到段落
+            para_pPr = paragraph._p.get_or_add_pPr()
+            
+            # 移除现有的 numPr（如果有）
+            existing_numPr = para_pPr.find(qn('w:numPr'))
+            if existing_numPr is not None:
+                para_pPr.remove(existing_numPr)
+            
+            # 深度复制样式的 numPr 到段落
+            from copy import deepcopy
+            new_numPr = deepcopy(numPr)
+            para_pPr.append(new_numPr)
+        except Exception:
+            # 编号应用失败，不影响其他功能
+            pass
 
     @staticmethod
     def _extract_text(children: list) -> str:
@@ -139,6 +217,8 @@ class DocxRenderer(mistune.BaseRenderer):
             para = self.doc.add_paragraph(text)
             try:
                 para.style = self._get_style_by_id(style_id)
+                # 应用样式后，复制编号属性到段落
+                self._apply_numbering_from_style(para)
             except KeyError:
                 pass
         else:
@@ -146,18 +226,180 @@ class DocxRenderer(mistune.BaseRenderer):
         return ""
 
     def paragraph(self, token: dict, state) -> str:
+        # 检查是否包含图片
+        children = token.get("children", [])
+        has_image = any(child.get("type") == "image" for child in children)
+        
+        if has_image:
+            # 如果包含图片，直接调用 image 处理
+            for child in children:
+                if child.get("type") == "image":
+                    self.image(child, state)
+            return ""
+        
         p = self.doc.add_paragraph()
-        if self._normal_id:
+        
+        # 尝试应用待定样式
+        style_applied = False
+        if self.pending_style:
+            style_id = _resolve_style_id(self.style_map, self.pending_style)
+            if style_id:
+                try:
+                    p.style = self._get_style_by_id(style_id)
+                    style_applied = True
+                except KeyError:
+                    pass  # 样式不存在，静默忽略
+            self.pending_style = None
+        
+        # 如果没有应用样式，使用 Normal
+        if not style_applied and self._normal_id:
             try:
                 p.style = self._get_style_by_id(self._normal_id)
             except Exception:
                 pass
+        
         self._render_inline_children(p, token.get("children", []))
         return ""
+    
+    def html(self, token: dict, state) -> str:
+        """处理内联 HTML 注释（表格单元格中的样式标记）"""
+        raw = token.get("raw", "")
+        if "<!-- style:" in raw and "-->" in raw:
+            try:
+                start = raw.index("<!-- style:") + 11
+                end = raw.index("-->", start)
+                self.pending_style = raw[start:end].strip()
+            except (ValueError, IndexError):
+                pass
+        return ""
+    
+    def block_html(self, token: dict, state) -> str:
+        """处理块级 HTML（样式注释+文本在同一行）"""
+        raw = token.get("raw", "")
+        
+        # 处理图片样式注释
+        if "<!-- img-style:" in raw and "-->" in raw:
+            try:
+                start = raw.index("{")
+                end = raw.rindex("}") + 1
+                self.pending_image_style = json.loads(raw[start:end])
+            except (ValueError, json.JSONDecodeError):
+                pass
+            return ""
+        
+        # 处理文本样式注释
+        if "<!-- style:" in raw and "-->" in raw:
+            try:
+                # 提取样式名
+                style_start = raw.index("<!-- style:") + 11
+                style_end = raw.index("-->", style_start)
+                style_name = raw[style_start:style_end].strip()
+                
+                # 提取文本（注释后面的内容）
+                text_start = style_end + 3  # "-->".length = 3
+                text = raw[text_start:].strip()
+                
+                # 创建段落并应用样式
+                p = self.doc.add_paragraph(text)
+                style_id = _resolve_style_id(self.style_map, style_name)
+                if style_id:
+                    try:
+                        p.style = self._get_style_by_id(style_id)
+                        # 应用样式后，复制编号属性到段落
+                        self._apply_numbering_from_style(p)
+                    except KeyError:
+                        pass  # 样式不存在，使用默认
+            except (ValueError, IndexError):
+                # 解析失败，当作普通 HTML 处理（忽略）
+                pass
+        return ""
 
     def blank_line(self, token: dict, state) -> str:
         return ""
 
+    def image(self, token: dict, state) -> str:
+        """处理图片 token（支持 Base64 Data URL）"""
+        url = token['attrs']['url']
+        alt = token['attrs'].get('alt', '图片')
+        
+        # 只处理 Data URL
+        if not url.startswith('data:'):
+            return ""
+        
+        try:
+            # 解析 data:image/png;base64,xxxxx
+            if ',' not in url:
+                return ""
+            
+            header, b64_data = url.split(',', 1)
+            image_bytes = base64.b64decode(b64_data)
+            
+            # 获取样式（来自前面的 HTML 注释）
+            style = self.pending_image_style or {}
+            self.pending_image_style = None
+            
+            # 创建段落并设置对齐
+            paragraph = self.doc.add_paragraph()
+            
+            # 应用段落样式：优先使用保存的样式，否则使用 Normal
+            para_style = style.get('para_style', 'Normal')
+            style_id = _resolve_style_id(self.style_map, para_style)
+            
+            if style_id:
+                try:
+                    paragraph.style = self._get_style_by_id(style_id)
+                except KeyError:
+                    # 如果样式不存在，回退到 Normal
+                    if self._normal_id:
+                        try:
+                            paragraph.style = self._get_style_by_id(self._normal_id)
+                        except Exception:
+                            pass
+            elif self._normal_id:
+                # 如果没有找到样式 ID，使用 Normal
+                try:
+                    paragraph.style = self._get_style_by_id(self._normal_id)
+                except Exception:
+                    pass
+            
+            align = style.get('align', 'left')
+            if align == 'center':
+                paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            elif align == 'right':
+                paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            
+            # 插入图片
+            run = paragraph.add_run()
+            width = style.get('width', 10.0)
+            height = style.get('height', 7.0)
+            unit = style.get('unit', 'cm')
+            
+            # 转换为磅（Word内部单位：1厘米 = 28.35磅，1英寸 = 72磅）
+            if unit == 'cm':
+                width_pt = width * 28.35
+                height_pt = height * 28.35
+            else:  # inches
+                width_pt = width * 72
+                height_pt = height * 72
+            
+            run.add_picture(
+                io.BytesIO(image_bytes),
+                width=Pt(width_pt),
+                height=Pt(height_pt)
+            )
+            
+        except Exception as e:
+            # 失败时添加占位文本
+            p = self.doc.add_paragraph(f"[图片加载失败: {alt}]")
+            if self._normal_id:
+                try:
+                    p.style = self._get_style_by_id(self._normal_id)
+                except Exception:
+                    pass
+            p.runs[0].font.color.rgb = RGBColor(255, 0, 0)
+        
+        return ""
+
     def thematic_break(self, token: dict, state) -> str:
         p = self.doc.add_paragraph()
         pPr = p._p.get_or_add_pPr()
@@ -248,17 +490,14 @@ class DocxRenderer(mistune.BaseRenderer):
         tbl = self.doc.add_table(rows=1 + len(body_rows), cols=cols)
         tbl.style = "Table Grid"
 
-        # 表头行（保留内联格式）
+        # 表头行（保留内联格式，不强制加粗）
         for c, cell_token in enumerate(head_cells):
             cell = tbl.rows[0].cells[c]
             # 清空默认段落
             cell.text = ""
             para = cell.paragraphs[0]
-            # 渲染内联内容
+            # 渲染内联内容（样式由 _render_inline_children 处理）
             self._render_inline_children(para, cell_token.get("children", []))
-            # 设置粗体
-            for run in para.runs:
-                run.bold = True
 
         # 数据行（保留内联格式）
         for r, row_cells in enumerate(body_rows):
@@ -266,22 +505,54 @@ class DocxRenderer(mistune.BaseRenderer):
                 if c >= cols:
                     break
                 cell = tbl.rows[r + 1].cells[c]
-                # 清空默认段落
                 cell.text = ""
                 para = cell.paragraphs[0]
-                # 渲染内联内容
+                # 渲染内联内容（样式注释会在 _render_inline_children 中处理）
                 self._render_inline_children(para, cell_token.get("children", []))
 
         return ""
 
-        return ""
-
     def _render_inline_children(self, paragraph, children: list) -> None:
+        """渲染内联子元素，处理粗体、斜体等格式"""
         for child in children:
             ctype = child.get("type", "")
             raw = child.get("raw", "")
-            if ctype == "text":
+            
+            if ctype == "inline_html":
+                # 处理图片样式注释
+                if "<!-- img-style:" in raw and "-->" in raw:
+                    try:
+                        start = raw.index("{")
+                        end = raw.rindex("}") + 1
+                        self.pending_image_style = json.loads(raw[start:end])
+                    except (ValueError, json.JSONDecodeError):
+                        pass
+                    # 注释不输出
+                    continue
+                
+                # 处理文本样式注释
+                if "<!-- style:" in raw and "-->" in raw:
+                    try:
+                        start = raw.index("<!-- style:") + 11
+                        end = raw.index("-->", start)
+                        self.pending_style = raw[start:end].strip()
+                    except (ValueError, IndexError):
+                        pass
+                # 注释不输出
+                continue
+            
+            elif ctype == "text":
+                # 应用待定样式（来自前一个 inline_html）
+                if self.pending_style:
+                    style_id = _resolve_style_id(self.style_map, self.pending_style)
+                    if style_id:
+                        try:
+                            paragraph.style = self._get_style_by_id(style_id)
+                        except KeyError:
+                            pass
+                    self.pending_style = None
                 paragraph.add_run(raw)
+            
             elif ctype == "strong":
                 paragraph.add_run(self._extract_text(child.get("children", []))).bold = True
             elif ctype == "emphasis":
@@ -296,6 +567,11 @@ class DocxRenderer(mistune.BaseRenderer):
                 paragraph.add_run().add_break()
             elif ctype == "softlinebreak":
                 paragraph.add_run(" ")
+            elif ctype == "image":
+                # 处理内联图片
+                # 注意：这里的图片是在段落中的，需要特殊处理
+                # 我们需要跳过这个段落，让 image() 方法来处理
+                pass
             else:
                 sub = child.get("children")
                 if sub:

app/services/image_service.py

@@ -0,0 +1,103 @@
+"""image_service.py — 图片提取和处理服务"""
+
+import base64
+import json
+from typing import Dict, List
+
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+
+def extract_images_from_word(doc: Document) -> List[Dict]:
+    """从 Word 文档提取图片及基本样式信息
+    
+    Args:
+        doc: python-docx Document 对象
+        
+    Returns:
+        图片列表，每个元素包含：
+        - paragraph_index: 图片所在段落索引
+        - data_url: Base64 编码的 Data URL
+        - style: 样式信息（宽度、高度、对齐方式、段落样式）
+    """
+    images = []
+    
+    # 建立 rel_id -> 图片数据映射
+    image_parts = {}
+    for rel in doc.part.rels.values():
+        if "image" in rel.target_ref:
+            image_parts[rel.rId] = {
+                "blob": rel.target_part.blob,
+                "content_type": rel.target_part.content_type
+            }
+    
+    # 遍历段落查找图片
+    for para_idx, paragraph in enumerate(doc.paragraphs):
+        for run in paragraph.runs:
+            # 查找 inline 图片（w:drawing 元素）
+            for drawing in run._element.findall('.//{http://schemas.openxmlformats.org/wordprocessingml/2006/main}drawing'):
+                # 提取图片引用
+                blip = drawing.find('.//{http://schemas.openxmlformats.org/drawingml/2006/main}blip')
+                if blip is None:
+                    continue
+                    
+                rel_id = blip.get('{http://schemas.openxmlformats.org/officeDocument/2006/relationships}embed')
+                if not rel_id or rel_id not in image_parts:
+                    continue
+                
+                # 提取尺寸（EMU 转厘米，1厘米 = 360000 EMU）
+                extent = drawing.find('.//{http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing}extent')
+                width_emu = int(extent.get('cx')) if extent is not None else 360000 * 10  # 默认 10cm
+                height_emu = int(extent.get('cy')) if extent is not None else 360000 * 7   # 默认 7cm
+                
+                width_cm = round(width_emu / 360000, 2)
+                height_cm = round(height_emu / 360000, 2)
+                
+                # 获取对齐方式
+                align = 'left'
+                if paragraph.alignment == WD_ALIGN_PARAGRAPH.CENTER:
+                    align = 'center'
+                elif paragraph.alignment == WD_ALIGN_PARAGRAPH.RIGHT:
+                    align = 'right'
+                
+                # 获取段落样式名称
+                para_style = paragraph.style.name if paragraph.style else "Normal"
+                
+                # Base64 编码
+                image_blob = image_parts[rel_id]['blob']
+                content_type = image_parts[rel_id]['content_type']
+                b64_data = base64.b64encode(image_blob).decode('utf-8')
+                data_url = f"data:{content_type};base64,{b64_data}"
+                
+                images.append({
+                    "paragraph_index": para_idx,
+                    "data_url": data_url,
+                    "style": {
+                        "width": width_cm,
+                        "height": height_cm,
+                        "align": align,
+                        "unit": "cm",
+                        "para_style": para_style  # 新增：段落样式
+                    }
+                })
+    
+    return images
+
+
+def create_image_markdown(data_url: str, style: Dict, alt: str = "图片") -> str:
+    """生成带样式注释的图片 Markdown
+    
+    Args:
+        data_url: Base64 编码的 Data URL
+        style: 样式字典（width, height, align）
+        alt: 图片替代文本
+        
+    Returns:
+        格式化的 Markdown 字符串
+        
+    Example:
+        <!-- img-style: {"width": 4.0, "height": 3.0, "align": "center"} -->
+        ![图片](data:image/png;base64,...)
+    """
+    style_json = json.dumps(style, ensure_ascii=False)
+    return f'<!-- img-style: {style_json} -->\n![{alt}]({data_url})\n'

tmp/styles.py

@@ -1,6 +1,7 @@
 """
 提取 Word 文档中所有样式的完整 XML 定义（不遗漏任何属性）。
-目标文件: 2026年Q2季度报告_E-EdHk4r1Lg.doc
+同时提取编号格式定义（numbering.xml）以支持标题编号。
+目标文件: default.docx
 """
 
 import json
@@ -8,6 +9,7 @@ from pathlib import Path
 from docx import Document
 from docx.oxml.ns import qn
 from lxml import etree
+from zipfile import ZipFile
 
 DOC_PATH = Path(__file__).parent / "default.docx"
 OUTPUT_PATH = Path(__file__).parent / "default.json"
@@ -159,17 +161,45 @@ def extract_styles(doc_path: Path) -> list[dict]:
     return styles_data
 
 
+def extract_numbering(doc_path: Path) -> dict | None:
+    """
+    提取 numbering.xml 的完整内容（编号格式定义）
+    返回字典格式，如果文档中没有编号则返回 None
+    """
+    try:
+        with ZipFile(str(doc_path), 'r') as docx_zip:
+            # 尝试读取 numbering.xml
+            try:
+                numbering_xml = docx_zip.read('word/numbering.xml')
+            except KeyError:
+                # 文档中没有编号定义
+                return None
+            
+            # 解析 XML 并转换为字典
+            root = etree.fromstring(numbering_xml)
+            numbering_dict = element_to_dict(root)
+            return numbering_dict
+    except Exception as e:
+        print(f"警告: 提取编号格式失败: {e}")
+        return None
+
+
 def main():
     print(f"读取文件: {DOC_PATH}")
     if not DOC_PATH.exists():
         raise FileNotFoundError(f"文件不存在: {DOC_PATH}")
 
+    # 提取样式
     styles_data = extract_styles(DOC_PATH)
+    
+    # 提取编号格式
+    numbering_data = extract_numbering(DOC_PATH)
 
     result = {
         "source_file": DOC_PATH.name,
         "total_styles": len(styles_data),
         "styles": styles_data,
+        "numbering": numbering_data,  # 新增：编号格式定义
     }
 
     OUTPUT_PATH.write_text(
@@ -178,7 +208,11 @@ def main():
     )
 
     print(f"共提取 {len(styles_data)} 个样式")
-    print(f"完整 XML 定义已保存至: {OUTPUT_PATH}")
+    if numbering_data:
+        print(f"✅ 已提取编号格式定义")
+    else:
+        print(f"ℹ️  文档中没有编号格式")
+    print(f"完整定义已保存至: {OUTPUT_PATH}")
 
     # 打印摘要
     by_type: dict[str, list[str]] = {}