maggie/hermes-skills
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: export core Hermes skills

Browse Source
This commit is contained in:
小Maggie
2026-07-15 02:45:56 +00:00
parent a028b63eda
commit 54711fee2a
308 changed files with 41310 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
skills/legal/contract-editor/scripts/contract_docx_lib.py
+684
View File
@@ -0,0 +1,684 @@
#!/usr/bin/env python3
"""
contract_docx_lib.py — 合同修订核心库
固化验证通过的docx XML操作，不再每次重写。
用法：
from contract_docx_lib import ContractEditor
editor = ContractEditor("原文件.docx")
editor.tracked_replace("原文片段", "新文片段")
editor.add_clause("19．服务成果持续使用权", "条款内容...", after_clause=18)
editor.renumber(19, 20) # 原19→20
errors = editor.validate()
if not errors:
editor.save("【修】原文件.docx")
关键操作顺序（renumber和新增条款）：
1. 先做所有 tracked_replace（文本修改）
2. 再做 add_clause（新增子条款，如15.4）
3. 再做 renumber_range（先腾出编号空间）
4. 最后做 add_clause_before（插入新主条款，用已腾出的编号）
5. validate() 验证
6. save() 保存
"""
import zipfile, io, copy, re, difflib
from lxml import etree
from datetime import datetime
from pathlib import Path
W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
WP = 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing'
XML_SPACE = '{http://www.w3.org/XML/1998/namespace}space'
WNS = '{' + W + '}'
def qn(tag):
return f'{WNS}{tag}'
def cjk_tokenize(text):
"""CJK每字一token，ASCII连续一token，标点单独token。
经验证的分词策略，不要改。"""
tokens = []
i = 0
while i < len(text):
ch = text[i]
if '\u4e00' <= ch <= '\u9fff' or '\u3000' <= ch <= '\u303f' or ch in '，。、；：！？""''（）【】《》—…·[]％%':
tokens.append(ch)
i += 1
elif ch.isascii() and ch.isalnum():
j = i
while j < len(text) and text[j].isascii() and text[j].isalnum():
j += 1
tokens.append(text[i:j])
i = j
else:
tokens.append(ch)
i += 1
return tokens
class ContractEditor:
"""合同修订编辑器。一个实例对应一份合同文件。"""
def __init__(self, filepath):
self.filepath = Path(filepath)
with open(filepath, 'rb') as f:
self.original_bytes = f.read()
with zipfile.ZipFile(io.BytesIO(self.original_bytes)) as z:
self.doc_xml = z.read('word/document.xml')
self.tree = etree.fromstring(self.doc_xml)
self.body = self.tree.find(qn('body'))
self._rev_id = 100
self._revision_date = datetime.now().strftime('%Y-%m-%dT%H:%M:%SZ')
self._author = 'WB'
self._rsid = '00AA0001'
# 提取原文格式（核心：避免每次猜错格式）
self._body_rpr = None # 正文格式（最常见的非加粗rPr）
self._title_rpr = None # 条款标题格式（加粗的rPr）
self._body_ppr = None
self._extract_formats()
def _extract_formats(self):
"""从原文提取正文和标题的rPr。
策略：
- 正文格式：统计所有run的rPr，取出现最多的非加粗rPr
- 标题格式：优先从条款编号标题段落（如"7.索赔条款"）提取rPr，
而非简单取第一个加粗run（可能是合同大标题，字号不同）
- 如果条款标题不加粗，标题格式回退到正文格式"""
import re
rpr_map = {} # serialized_rpr -> (count, rpr_element)
clause_title_rpr = None # 从条款编号标题提取的格式
first_bold_rpr = None # 第一个加粗run的格式（fallback）
for p in self.body.findall(qn('p')):
# 获取段落全文，判断是否是条款编号标题（如 "7.索赔条款" "5.伴随服务"）
p_text = ''.join(t.text or '' for t in p.findall(f'.//{qn("t")}')).strip()
is_clause_title = bool(re.match(r'^\d+[．.、]\s*\S', p_text)) and len(p_text) < 30
for r in p.findall(qn('r')):
rpr = r.find(qn('rPr'))
txt = ''.join(t.text or '' for t in r.findall(qn('t')))
if not txt.strip() or len(txt) < 3:
continue
if rpr is not None:
is_bold = rpr.find(qn('b')) is not None
key = etree.tostring(rpr, encoding='unicode')
if is_bold and first_bold_rpr is None:
first_bold_rpr = rpr
# 优先从条款标题段落提取标题格式
if is_clause_title and clause_title_rpr is None:
clause_title_rpr = rpr
if not is_bold:
if key not in rpr_map:
rpr_map[key] = [0, rpr]
rpr_map[key][0] += 1
if self._body_ppr is None:
ppr = p.find(qn('pPr'))
txt = ''.join(t.text or '' for t in p.findall(f'.//{qn("t")}'))
if ppr is not None and len(txt) > 20:
self._body_ppr = ppr
if rpr_map:
best = max(rpr_map.values(), key=lambda x: x[0])
self._body_rpr = best[1]
# 标题格式优先级：条款编号标题 > 第一个加粗run > 正文格式
self._title_rpr = clause_title_rpr or first_bold_rpr or self._body_rpr
if self._title_rpr is None and self._body_rpr is not None:
self._title_rpr = copy.deepcopy(self._body_rpr)
etree.SubElement(self._title_rpr, qn('b'))
def _next_id(self):
self._rev_id += 1
return str(self._rev_id)
def _mk_del(self, text, rpr=None):
d = etree.Element(qn('del'))
d.set(qn('id'), self._next_id())
d.set(qn('author'), self._author)
d.set(qn('date'), self._revision_date)
r = etree.SubElement(d, qn('r'))
r.set(qn('rsidDel'), self._rsid)
if rpr is not None:
r.append(copy.deepcopy(rpr))
t = etree.SubElement(r, qn('delText'))
t.set(XML_SPACE, 'preserve')
t.text = text
return d
def _mk_ins(self, text, rpr=None):
i = etree.Element(qn('ins'))
i.set(qn('id'), self._next_id())
i.set(qn('author'), self._author)
i.set(qn('date'), self._revision_date)
r = etree.SubElement(i, qn('r'))
r.set(qn('rsidR'), self._rsid)
if rpr is not None:
r.append(copy.deepcopy(rpr))
t = etree.SubElement(r, qn('t'))
t.set(XML_SPACE, 'preserve')
t.text = text
return i
def _mk_run(self, text, rpr=None):
r = etree.Element(qn('r'))
if rpr is not None:
r.append(copy.deepcopy(rpr))
t = etree.SubElement(r, qn('t'))
t.set(XML_SPACE, 'preserve')
t.text = text
return r
def get_para_text(self, p):
"""获取段落的原始文本（不含删除标记中的文本）"""
return ''.join(t.text or '' for t in p.findall(f'.//{qn("t")}'))
def find_para(self, search_text):
"""查找包含指定文本的段落"""
for p in self.body.findall(qn('p')):
if search_text in self.get_para_text(p):
return p
return None
def tracked_replace(self, old_text, new_text):
"""在整个文档中查找old_text并用修订模式替换为new_text。
使用字符级tokenizer+difflib实现精准修订。
返回True如果成功。"""
for p in self.body.findall(qn('p')):
runs = p.findall(f'.//{qn("r")}')
if not runs:
continue
full = ''.join(
''.join(t.text or '' for t in r.findall(qn('t')))
for r in runs
)
if old_text not in full:
continue
start = full.index(old_text)
end = start + len(old_text)
# 获取匹配位置的rPr
rpr = None
pos = 0
for r in runs:
rt = ''.join(t.text or '' for t in r.findall(qn('t')))
if pos + len(rt) > start:
rpr = r.find(qn('rPr'))
break
pos += len(rt)
# 生成diff元素
if new_text == '':
elems = [self._mk_del(old_text, rpr)]
else:
ot = cjk_tokenize(old_text)
nt = cjk_tokenize(new_text)
matcher = difflib.SequenceMatcher(None, ot, nt)
elems = []
for tag, i1, i2, j1, j2 in matcher.get_opcodes():
if tag == 'equal':
elems.append(self._mk_run(''.join(ot[i1:i2]), rpr))
elif tag == 'delete':
elems.append(self._mk_del(''.join(ot[i1:i2]), rpr))
elif tag == 'insert':
elems.append(self._mk_ins(''.join(nt[j1:j2]), rpr))
elif tag == 'replace':
elems.append(self._mk_del(''.join(ot[i1:i2]), rpr))
elems.append(self._mk_ins(''.join(nt[j1:j2]), rpr))
# 定位受影响的runs并替换
pos = 0
first = last = None
prefix_text = suffix_text = ""
for idx, r in enumerate(runs):
rt = ''.join(t.text or '' for t in r.findall(qn('t')))
run_end = pos + len(rt)
if run_end > start and pos < end:
if first is None:
first = idx
prefix_text = full[pos:start]
last = idx
suffix_text = full[end:run_end] if run_end > end else ""
pos = run_end
if first is None:
continue
ref = runs[first]
# Find the actual paragraph (w:p) element to insert into
para_elem = p
# Determine insert position: find ref or its ancestor that is a direct child of p
ref_ancestor = ref
while ref_ancestor.getparent() is not para_elem and ref_ancestor.getparent() is not None:
ref_ancestor = ref_ancestor.getparent()
insert_pos = list(para_elem).index(ref_ancestor)
# Remove runs (each from its own parent)
for idx in range(last, first - 1, -1):
r = runs[idx]
r_parent = r.getparent()
r_parent.remove(r)
# If parent (e.g. w:ins) is now empty, remove it too
if r_parent is not para_elem and len(r_parent) == 0:
gp = r_parent.getparent()
if gp is not None:
gp.remove(r_parent)
ip = insert_pos
if prefix_text:
para_elem.insert(ip, self._mk_run(prefix_text, rpr))
ip += 1
for e in elems:
para_elem.insert(ip, e)
ip += 1
if suffix_text:
para_elem.insert(ip, self._mk_run(suffix_text, rpr))
return True
return False
def _get_leading_whitespace(self, para):
"""从段落中提取前导空格/tab模式。
很多中文文档的缩进不是通过w:ind实现的，而是通过文本中的空格字符。"""
for r in para.findall(qn('r')):
# Skip deleted runs
if r.getparent().tag == qn('del'):
continue
for t in r.findall(qn('t')):
if t.text:
# Extract leading whitespace
stripped = t.text.lstrip()
if stripped: # Has actual content after whitespace
return t.text[:len(t.text) - len(stripped)]
elif t.text.isspace(): # Entire run is whitespace
return t.text
return ''
def add_clause(self, full_text, after_search, use_title_format=False):
"""在包含after_search的段落之后插入新条款段落。
full_text: 新条款全文
after_search: 在包含此文本的段落之后插入
use_title_format: True=标题格式（加粗），False=正文格式
"""
ref_para = self.find_para(after_search)
if ref_para is None:
return False
rpr = self._title_rpr if use_title_format else self._body_rpr
ppr = ref_para.find(qn('pPr')) or self._body_ppr
# 复制相邻段落的前导空格模式
leading_ws = self._get_leading_whitespace(ref_para)
if leading_ws and not full_text.startswith(leading_ws):
full_text = leading_ws + full_text
new_p = etree.Element(qn('p'))
if ppr is not None:
new_p.append(copy.deepcopy(ppr))
new_p.append(self._mk_ins(full_text, rpr))
idx = list(self.body).index(ref_para)
self.body.insert(idx + 1, new_p)
return True
def add_clause_before(self, full_text, before_search, use_title_format=False):
"""在包含before_search的段落之前插入新条款段落。"""
ref_para = self.find_para(before_search)
if ref_para is None:
return False
rpr = self._title_rpr if use_title_format else self._body_rpr
ppr = ref_para.find(qn('pPr')) or self._body_ppr
# 复制相邻段落的前导空格模式
leading_ws = self._get_leading_whitespace(ref_para)
if leading_ws and not full_text.startswith(leading_ws):
full_text = leading_ws + full_text
new_p = etree.Element(qn('p'))
if ppr is not None:
new_p.append(copy.deepcopy(ppr))
new_p.append(self._mk_ins(full_text, rpr))
idx = list(self.body).index(ref_para)
self.body.insert(idx, new_p)
return True
def add_mixed_clause(self, title_text, content_text, after_search):
"""插入标题加粗+内容不加粗的新条款（两个段落）。
用于原文标题和内容分行的合同格式。"""
ref_para = self.find_para(after_search)
if ref_para is None:
return False
ppr = ref_para.find(qn('pPr')) or self._body_ppr
idx = list(self.body).index(ref_para)
# 复制相邻段落的前导空格模式
leading_ws = self._get_leading_whitespace(ref_para)
if leading_ws:
if not title_text.startswith(leading_ws):
title_text = leading_ws + title_text
if not content_text.startswith(leading_ws):
content_text = leading_ws + content_text
p_title = etree.Element(qn('p'))
if ppr: p_title.append(copy.deepcopy(ppr))
p_title.append(self._mk_ins(title_text, self._title_rpr))
self.body.insert(idx + 1, p_title)
p_content = etree.Element(qn('p'))
if ppr: p_content.append(copy.deepcopy(ppr))
p_content.append(self._mk_ins(content_text, self._body_rpr))
self.body.insert(idx + 2, p_content)
return True
def renumber_clause(self, old_num, new_num):
"""把条款编号从old_num改为new_num（修订模式）。
从后往前扫描，避免重复修改。"""
changed = 0
for p in reversed(self.body.findall(qn('p'))):
runs = p.findall(f'.//{qn("r")}')
for r in runs:
for t in r.findall(qn('t')):
if t.text and old_num in t.text:
rpr_e = r.find(qn('rPr'))
parent = r.getparent()
idx_r = list(parent).index(r)
pos = t.text.index(old_num)
prefix = t.text[:pos]
suffix = t.text[pos + len(old_num):]
parent.remove(r)
ip = idx_r
if prefix:
parent.insert(ip, self._mk_run(prefix, rpr_e))
ip += 1
parent.insert(ip, self._mk_del(old_num, rpr_e))
ip += 1
parent.insert(ip, self._mk_ins(new_num, rpr_e))
ip += 1
if suffix:
parent.insert(ip, self._mk_run(suffix, rpr_e))
changed += 1
break
return changed
def renumber_range(self, start, shift=1):
"""从start开始，所有现有条款编号+shift。从后往前处理。
注意：先调用此方法腾出编号空间，再插入新条款。
例：要在18后插入新19条：
editor.renumber_range(19, 1) # 19→20, 20→21, 21→22
editor.add_clause_before("19．新条款内容", before_search="20．合同生效")
"""
max_num = 0
for p in self.body.findall(qn('p')):
txt = self.get_para_text(p)
for m in re.finditer(r'(\d+)[．.]', txt):
n = int(m.group(1))
if n > max_num:
max_num = n
for n in range(max_num, start - 1, -1):
self.renumber_clause(f'{n}．', f'{n + shift}．')
self.renumber_clause(f'{n}.', f'{n + shift}.')
def renumber_chinese(self, old_cn, new_cn):
"""中文编号顺延，如 "第十三条" → "第十四条"。"""
return self.renumber_clause(old_cn, new_cn)
def validate(self):
"""交付前验证。返回错误列表，空列表=通过。"""
errors = []
# 1. 编号连续性
clause_nums = []
for p in self.body.findall(qn('p')):
accepted = ''
for child in p:
tag = child.tag.split('}')[-1] if '}' in child.tag else child.tag
if tag == 'r':
accepted += ''.join(t.text or '' for t in child.findall(qn('t')))
elif tag == 'ins':
accepted += ''.join(t.text or '' for t in child.findall(f'.//{qn("t")}'))
m = re.match(r'^(\d+)[．.]', accepted.strip())
if m:
clause_nums.append(int(m.group(1)))
main_clauses = sorted(set(clause_nums))
for i in range(1, len(main_clauses)):
if main_clauses[i] - main_clauses[i-1] > 1:
errors.append(f"编号跳跃: {main_clauses[i-1]}→{main_clauses[i]}，缺少{main_clauses[i-1]+1}")
# 2. 字号一致性（WB的ins内容 vs 原文正文）
if self._body_rpr is not None:
body_sz = None
sz_elem = self._body_rpr.find(qn('sz'))
if sz_elem is not None:
body_sz = sz_elem.get(qn('val'))
if body_sz:
for ins in self.tree.findall(f'.//{qn("ins")}'):
if ins.get(qn('author')) != self._author:
continue
for r in ins.findall(qn('r')):
rpr = r.find(qn('rPr'))
txt = ''.join(t.text or '' for t in r.findall(qn('t')))
if not txt.strip():
continue
if rpr is not None:
ins_sz = rpr.find(qn('sz'))
if ins_sz is not None:
val = ins_sz.get(qn('val'))
is_bold = rpr.find(qn('b')) is not None
if val != body_sz and not is_bold:
errors.append(f"字号不一致: ins sz={val} vs 原文sz={body_sz}，'{txt[:30]}'")
# 3. 加粗规则（内容不应加粗）
for ins in self.tree.findall(f'.//{qn("ins")}'):
if ins.get(qn('author')) != self._author:
continue
for r in ins.findall(qn('r')):
rpr = r.find(qn('rPr'))
txt = ''.join(t.text or '' for t in r.findall(qn('t')))
if not txt.strip() or len(txt.strip()) < 5:
continue
is_bold = rpr is not None and rpr.find(qn('b')) is not None
is_clause_title = bool(re.match(r'^\d+[．.]\S', txt.strip())) or bool(re.match(r'^第.{1,3}条', txt.strip())) or bool(re.match(r'^[一二三四五六七八九十]{1,3}、', txt.strip()))
if is_bold and not is_clause_title:
errors.append(f"不应加粗: '{txt[:40]}'")
return errors
def dump_numbering(self):
"""输出accepted view的编号序列，用于人工确认"""
result = []
for p in self.body.findall(qn('p')):
accepted = ''
for child in p:
tag = child.tag.split('}')[-1] if '}' in child.tag else child.tag
if tag == 'r':
accepted += ''.join(t.text or '' for t in child.findall(qn('t')))
elif tag == 'ins':
accepted += ''.join(t.text or '' for t in child.findall(f'.//{qn("t")}'))
m = re.match(r'^(\d+)[．.]', accepted.strip())
if m:
result.append(f"{m.group(1)}. {accepted.strip()[:60]}")
return result
def save(self, output_path):
"""保存修订后的文件"""
new_doc_xml = etree.tostring(self.tree, xml_declaration=True,
encoding='UTF-8', standalone=True)
with zipfile.ZipFile(io.BytesIO(self.original_bytes)) as z:
settings = z.read('word/settings.xml')
stree = etree.fromstring(settings)
if stree.find(f'.//{qn("trackRevisions")}') is None:
stree.append(etree.Element(qn('trackRevisions')))
new_settings = etree.tostring(stree, xml_declaration=True,
encoding='UTF-8', standalone=True)
buf = io.BytesIO()
with zipfile.ZipFile(io.BytesIO(self.original_bytes)) as zin:
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zout:
for item in zin.infolist():
if item.filename == 'word/document.xml':
zout.writestr(item, new_doc_xml)
elif item.filename == 'word/settings.xml':
zout.writestr(item, new_settings)
else:
zout.writestr(item, zin.read(item.filename))
with open(output_path, 'wb') as f:
f.write(buf.getvalue())
return output_path
class ZhujiajaoOpinion:
"""朱家角审查意见表格填写器。严格使用模板结构，不自创格式。"""
TEMPLATE_PATH = Path.home() / ".hermes/shared/模版库/朱家角 审查意见【模板】.docx"
def __init__(self, template_path=None):
tpath = Path(template_path) if template_path else self.TEMPLATE_PATH
with open(tpath, 'rb') as f:
self.tmpl_bytes = f.read()
with zipfile.ZipFile(io.BytesIO(self.tmpl_bytes)) as z:
self.doc_xml = z.read('word/document.xml')
self.tree = etree.fromstring(self.doc_xml)
self.body = self.tree.find(qn('body'))
def fill(self, contract_name, items, has_modifications=True):
"""填写审查意见。
contract_name: 合同名称（填入标题《》中间）
items: [(条文位置, 原文, 修订后), ...]
has_modifications: False则保留"无法律修改意见"
"""
# 1. 填标题——找到空格run替换
for p in self.body.findall(qn('p')):
runs = p.findall(f'.//{qn("r")}')
for r in runs:
for t in r.findall(qn('t')):
if t.text and t.text.strip() == '' and len(t.text) >= 2:
parent_txt = ''.join(
tt.text or '' for rr in runs for tt in rr.findall(qn('t'))
)
if '关于《' in parent_txt:
t.text = contract_name
# 2. 处理"无法律修改意见"
if has_modifications:
for p in self.body.findall(qn('p')):
txt = ''.join(t.text or '' for t in p.findall(f'.//{qn("t")}'))
if '无法律修改意见' in txt:
for r in p.findall(f'.//{qn("r")}'):
for t in r.findall(qn('t')):
if '无法律修改意见' in (t.text or ''):
t.text = ''
# 3. 填表格
if not items:
return
tbl = self.body.find(qn('tbl'))
if tbl is None:
return
rows = tbl.findall(qn('tr'))
# Row 0 = header, Row 1+ = data rows
# 获取表头rPr
header_rpr = None
for hc in rows[0].findall(qn('tc')):
for hr in hc.findall(f'.//{qn("r")}'):
rr = hr.find(qn('rPr'))
if rr:
header_rpr = rr
break
if header_rpr:
break
# 确保有足够数据行
template_row = rows[1] if len(rows) > 1 else None
while len(tbl.findall(qn('tr'))) - 1 < len(items):
if template_row is not None:
tbl.append(copy.deepcopy(template_row))
rows = tbl.findall(qn('tr'))
# 填写数据
for i, (clause, orig_text, modified_text) in enumerate(items):
if i + 1 >= len(rows):
break
row = rows[i + 1]
cells = row.findall(qn('tc'))
if len(cells) < 3:
continue
for ci, text in enumerate([clause, orig_text, modified_text]):
cell = cells[ci]
p = cell.find(qn('p'))
if p is None:
p = etree.SubElement(cell, qn('p'))
for r in p.findall(qn('r')):
p.remove(r)
r = etree.SubElement(p, qn('r'))
if header_rpr:
new_rpr = copy.deepcopy(header_rpr)
b = new_rpr.find(qn('b'))
if b is not None:
new_rpr.remove(b)
if '注：' in text:
color = new_rpr.find(qn('color'))
if color is None:
color = etree.SubElement(new_rpr, qn('color'))
color.set(qn('val'), 'FF0000')
r.append(new_rpr)
t = etree.SubElement(r, qn('t'))
t.set(XML_SPACE, 'preserve')
t.text = text
# 删除多余空行
rows = tbl.findall(qn('tr'))
for i in range(len(rows) - 1, len(items), -1):
tbl.remove(rows[i])
def save(self, output_path):
new_doc = etree.tostring(self.tree, xml_declaration=True,
encoding='UTF-8', standalone=True)
buf = io.BytesIO()
with zipfile.ZipFile(io.BytesIO(self.tmpl_bytes)) as zin:
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zout:
for item in zin.infolist():
if item.filename == 'word/document.xml':
zout.writestr(item, new_doc)
else:
zout.writestr(item, zin.read(item.filename))
with open(output_path, 'wb') as f:
f.write(buf.getvalue())
return output_path