oh-my-codex-cli 0.1.0

package/.agent/skills/patent-workflow/tools/irr_checker.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+IRR (Inverse Repetition Rate) Checker for Patent Documents
+
+借鉴AutoPatent的IRR指标，用于检测专利文档中的句子重复率。
+
+IRR = 1 - (重复句子数 / 总句子数)
+目标: IRR ≥ 0.85 (重复率 ≤ 15%)
+
+Usage:
+    python irr_checker.py <patent_document_path>
+"""
+
+import sys
+import re
+from pathlib import Path
+from typing import List, Tuple, Dict
+from collections import Counter
+
+
+class IRRChecker:
+    """IRR重复率检查器"""
+
+    def __init__(self, threshold: float = 0.85):
+        """
+        初始化IRR检查器
+
+        Args:
+            threshold: IRR阈值，默认0.85（重复率≤15%）
+        """
+        self.threshold = threshold
+
+    def extract_sentences(self, text: str) -> List[str]:
+        """
+        从文本中提取句子
+
+        Args:
+            text: 输入文本
+
+        Returns:
+            句子列表
+        """
+        # 中文句子分隔符
+        sentences = re.split(r'[。！？；\n]', text)
+
+        # 清理空句子和过短句子
+        sentences = [s.strip() for s in sentences if s.strip() and len(s.strip()) > 5]
+
+        return sentences
+
+    def normalize_sentence(self, sentence: str) -> str:
+        """
+        标准化句子（去除空格、标点等）
+
+        Args:
+            sentence: 原始句子
+
+        Returns:
+            标准化后的句子
+        """
+        # 去除空格
+        normalized = re.sub(r'\s+', '', sentence)
+
+        # 去除标点符号（保留中文字符、数字、英文字母）
+        normalized = re.sub(r'[^\u4e00-\u9fa5a-zA-Z0-9]', '', normalized)
+
+        return normalized
+
+    def calculate_irr(self, text: str) -> Tuple[float, Dict]:
+        """
+        计算IRR指标
+
+        Args:
+            text: 专利文档文本
+
+        Returns:
+            (IRR分数, 详细统计信息)
+        """
+        sentences = self.extract_sentences(text)
+        total_sentences = len(sentences)
+
+        if total_sentences == 0:
+            return 1.0, {
+                'total_sentences': 0,
+                'unique_sentences': 0,
+                'repetition_rate': 0.0,
+                'repeated_sentences': []
+            }
+
+        # 标准化句子
+        normalized_sentences = [self.normalize_sentence(s) for s in sentences]
+
+        # 统计句子频率
+        sentence_counts = Counter(normalized_sentences)
+
+        # 找出重复的句子
+        repeated = {sent: count for sent, count in sentence_counts.items() if count > 1}
+
+        # 计算唯一句子数
+        unique_sentences = len(sentence_counts)
+
+        # 计算IRR
+        irr = unique_sentences / total_sentences
+
+        # 计算重复率
+        repetition_rate = 1 - irr
+
+        # 找出重复句子的原文
+        repeated_sentences = []
+        for norm_sent, count in repeated.items():
+            # 找到第一个匹配的原句
+            for original in sentences:
+                if self.normalize_sentence(original) == norm_sent:
+                    repeated_sentences.append({
+                        'sentence': original[:100] + '...' if len(original) > 100 else original,
+                        'count': count
+                    })
+                    break
+
+        return irr, {
+            'total_sentences': total_sentences,
+            'unique_sentences': unique_sentences,
+            'repetition_rate': repetition_rate,
+            'repeated_sentences': repeated_sentences
+        }
+
+    def check_document(self, file_path: str) -> Dict:
+        """
+        检查专利文档的IRR
+
+        Args:
+            file_path: 文档路径
+
+        Returns:
+            检查结果字典
+        """
+        try:
+            # 读取文件
+            with open(file_path, 'r', encoding='utf-8') as f:
+                text = f.read()
+
+            # 计算IRR
+            irr, stats = self.calculate_irr(text)
+
+            # 判断是否通过
+            passed = irr >= self.threshold
+
+            return {
+                'passed': passed,
+                'irr': irr,
+                'threshold': self.threshold,
+                'stats': stats
+            }
+
+        except FileNotFoundError:
+            return {
+                'error': f'文件不存在: {file_path}'
+            }
+        except Exception as e:
+            return {
+                'error': f'处理文件时出错: {str(e)}'
+            }
+
+    def format_report(self, result: Dict) -> str:
+        """
+        格式化检查报告
+
+        Args:
+            result: 检查结果
+
+        Returns:
+            格式化的报告字符串
+        """
+        if 'error' in result:
+            return f"❌ Error: {result['error']}"
+
+        irr = result['irr']
+        threshold = result['threshold']
+        passed = result['passed']
+        stats = result['stats']
+
+        # 状态emoji
+        status = "✅ Pass" if passed else "❌ Fail"
+
+        # 构建报告
+        report = []
+        report.append("=" * 60)
+        report.append("IRR (Inverse Repetition Rate) Check Report")
+        report.append("=" * 60)
+        report.append("")
+        report.append(f"IRR Score: {irr:.4f} ({status} - 目标≥{threshold:.2f})")
+        report.append(f"Unique Sentences: {stats['unique_sentences']} / {stats['total_sentences']}")
+        report.append(f"Repetition Rate: {stats['repetition_rate'] * 100:.2f}%")
+        report.append("")
+
+        # 如果有重复句子，列出来
+        if stats['repeated_sentences']:
+            report.append("Repetitive Sentences Found:")
+            report.append("-" * 60)
+            for i, item in enumerate(stats['repeated_sentences'][:10], 1):  # 最多显示10个
+                report.append(f"{i}. (重复{item['count']}次)")
+                report.append(f"   {item['sentence']}")
+                report.append("")
+
+            if len(stats['repeated_sentences']) > 10:
+                report.append(f"... and {len(stats['repeated_sentences']) - 10} more repeated sentences")
+                report.append("")
+
+        # 建议
+        report.append("Recommendations:")
+        report.append("-" * 60)
+        if passed:
+            report.append("✅ IRR指标达标，文档重复率控制良好。")
+        else:
+            report.append("⚠️  IRR指标未达标，建议:")
+            report.append("   1. 变换表述方式（同一技术特征用不同角度描述）")
+            report.append("   2. 增加技术细节（不同实施例补充不同参数）")
+            report.append("   3. 避免模板化表述（减少套话）")
+
+        report.append("")
+        report.append("=" * 60)
+
+        return '\n'.join(report)
+
+
+def main():
+    """主函数"""
+    if len(sys.argv) < 2:
+        print("Usage: python irr_checker.py <patent_document_path>")
+        print("")
+        print("Example:")
+        print("  python irr_checker.py /path/to/patent.txt")
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+
+    # 创建检查器
+    checker = IRRChecker(threshold=0.85)
+
+    # 检查文档
+    print(f"Checking document: {file_path}")
+    print("")
+
+    result = checker.check_document(file_path)
+
+    # 输出报告
+    report = checker.format_report(result)
+    print(report)
+
+    # 返回退出码
+    if 'error' in result:
+        sys.exit(2)
+    elif not result['passed']:
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/.agent/skills/patent-workflow/tools/sample_terminology.json

@@ -0,0 +1,49 @@
+{
+  "standard_terms": {
+    "联邦学习": ["标准术语", "分布式机器学习方法"],
+    "用户画像数据": ["标准术语", "用户特征数据"],
+    "第三方鉴权节点": ["标准术语", "可信第三方"],
+    "差分隐私": ["标准术语", "隐私保护技术"],
+    "模型训练": ["标准术语"],
+    "数据加密": ["标准术语"],
+    "梯度聚合": ["标准术语", "联邦学习核心步骤"],
+    "本地训练": ["标准术语"],
+    "全局模型": ["标准术语"],
+    "隐私预算": ["标准术语", "差分隐私参数"],
+    "权利要求": ["专利术语"],
+    "技术方案": ["专利术语"],
+    "有益效果": ["专利术语"],
+    "具体实施方式": ["专利术语"],
+    "背景技术": ["专利术语"]
+  },
+  "synonym_groups": [
+    ["联邦学习", "分布式学习", "联合学习", "协作学习"],
+    ["用户画像数据", "用户数据", "用户特征", "用户信息"],
+    ["第三方鉴权节点", "可信第三方", "中间方", "第三方服务器"],
+    ["差分隐私", "隐私保护", "隐私计算"],
+    ["模型训练", "训练模型", "模型学习"],
+    ["数据加密", "加密数据", "加密传输"],
+    ["梯度聚合", "梯度汇总", "梯度融合"],
+    ["本地训练", "本地模型训练", "局部训练"],
+    ["全局模型", "全局模型参数", "中心模型"],
+    ["隐私预算", "隐私参数", "ε-差分隐私参数"]
+  ],
+  "forbidden_terms": [
+    "等",
+    "或类似",
+    "大约",
+    "约",
+    "优化",
+    "改进",
+    "优秀",
+    "高效",
+    "先进"
+  ],
+  "notes": [
+    "本术语库为联邦学习领域专利示例",
+    "请根据实际技术领域创建专用术语库",
+    "standard_terms: 推荐使用的标准术语",
+    "synonym_groups: 同义词组（第一个为标准术语）",
+    "forbidden_terms: 应避免使用的模糊词汇"
+  ]
+}

package/.agent/skills/patent-workflow/tools/term_checker.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""
+Terminology Consistency Checker for Patent Documents
+
+用于检查专利文档中的术语一致性，确保全文使用统一的技术术语。
+
+目标: 术语一致性 ≥ 90%
+
+Usage:
+    python term_checker.py <patent_document_path> <terminology_database_path>
+"""
+
+import sys
+import re
+import json
+from pathlib import Path
+from typing import List, Dict, Tuple, Set
+
+
+class TermChecker:
+    """术语一致性检查器"""
+
+    def __init__(self, threshold: float = 0.90):
+        """
+        初始化术语检查器
+
+        Args:
+            threshold: 一致性阈值，默认0.90（90%）
+        """
+        self.threshold = threshold
+        self.term_database = {}  # 标准术语库
+        self.synonym_groups = []  # 同义词组
+
+    def load_terminology(self, file_path: str):
+        """
+        加载术语库
+
+        术语库格式（JSON）:
+        {
+            "standard_terms": {
+                "联邦学习": ["标准术语", "应在全文统一使用"],
+                "用户画像数据": ["标准术语"],
+                ...
+            },
+            "synonym_groups": [
+                ["联邦学习", "分布式学习", "联合学习"],
+                ["用户画像", "用户数据", "用户特征"]
+            ]
+        }
+
+        Args:
+            file_path: 术语库文件路径
+        """
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+
+            self.term_database = data.get('standard_terms', {})
+            self.synonym_groups = data.get('synonym_groups', [])
+
+        except FileNotFoundError:
+            print(f"⚠️  术语库文件不存在: {file_path}")
+            print("将使用空术语库进行检查。")
+        except json.JSONDecodeError as e:
+            print(f"❌ 术语库文件格式错误: {e}")
+            sys.exit(2)
+
+    def extract_terms(self, text: str) -> Dict[str, List[Tuple[int, str]]]:
+        """
+        从文本中提取术语及其位置
+
+        Args:
+            text: 专利文档文本
+
+        Returns:
+            {术语: [(行号, 上下文), ...]}
+        """
+        terms_found = {}
+
+        # 按行处理
+        lines = text.split('\n')
+
+        for line_no, line in enumerate(lines, 1):
+            # 检查术语库中的标准术语
+            for term in self.term_database.keys():
+                if term in line:
+                    if term not in terms_found:
+                        terms_found[term] = []
+                    # 提取上下文（前后各20个字符）
+                    match_pos = line.find(term)
+                    context_start = max(0, match_pos - 20)
+                    context_end = min(len(line), match_pos + len(term) + 20)
+                    context = line[context_start:context_end]
+                    terms_found[term].append((line_no, context))
+
+            # 检查同义词组
+            for synonym_group in self.synonym_groups:
+                for synonym in synonym_group:
+                    if synonym in line:
+                        # 记录非标准术语
+                        standard_term = synonym_group[0]  # 第一个为标准术语
+                        if synonym != standard_term:
+                            key = f"⚠️ {synonym} (建议: {standard_term})"
+                            if key not in terms_found:
+                                terms_found[key] = []
+                            match_pos = line.find(synonym)
+                            context_start = max(0, match_pos - 20)
+                            context_end = min(len(line), match_pos + len(synonym) + 20)
+                            context = line[context_start:context_end]
+                            terms_found[key].append((line_no, context))
+
+        return terms_found
+
+    def check_consistency(self, text: str) -> Dict:
+        """
+        检查术语一致性
+
+        Args:
+            text: 专利文档文本
+
+        Returns:
+            检查结果字典
+        """
+        terms_found = self.extract_terms(text)
+
+        # 分析一致性问题
+        issues = []
+        warnings = []
+
+        # 检查同义词混用
+        for synonym_group in self.synonym_groups:
+            found_variants = [term for term in synonym_group if term in text]
+            if len(found_variants) > 1:
+                standard_term = synonym_group[0]
+                issues.append({
+                    'type': 'synonym_mixing',
+                    'standard_term': standard_term,
+                    'variants_found': found_variants,
+                    'severity': 'high'
+                })
+
+        # 检查非标准术语使用
+        for key in terms_found.keys():
+            if key.startswith('⚠️'):
+                warnings.append({
+                    'type': 'non_standard_term',
+                    'term': key,
+                    'occurrences': terms_found[key],
+                    'severity': 'medium'
+                })
+
+        # 计算一致性得分
+        total_term_usages = sum(len(occurrences) for occurrences in terms_found.values())
+        inconsistent_usages = sum(len(occurrences) for key, occurrences in terms_found.items() if key.startswith('⚠️'))
+
+        if total_term_usages > 0:
+            consistency_score = 1 - (inconsistent_usages / total_term_usages)
+        else:
+            consistency_score = 1.0
+
+        # 判断是否通过
+        passed = consistency_score >= self.threshold and len(issues) == 0
+
+        return {
+            'passed': passed,
+            'consistency_score': consistency_score,
+            'threshold': self.threshold,
+            'total_term_usages': total_term_usages,
+            'inconsistent_usages': inconsistent_usages,
+            'issues': issues,
+            'warnings': warnings,
+            'terms_found': terms_found
+        }
+
+    def check_document(self, doc_path: str, term_db_path: str = None) -> Dict:
+        """
+        检查文档的术语一致性
+
+        Args:
+            doc_path: 文档路径
+            term_db_path: 术语库路径（可选）
+
+        Returns:
+            检查结果字典
+        """
+        try:
+            # 加载术语库
+            if term_db_path:
+                self.load_terminology(term_db_path)
+
+            # 读取文档
+            with open(doc_path, 'r', encoding='utf-8') as f:
+                text = f.read()
+
+            # 检查一致性
+            return self.check_consistency(text)
+
+        except FileNotFoundError:
+            return {'error': f'文件不存在: {doc_path}'}
+        except Exception as e:
+            return {'error': f'处理文件时出错: {str(e)}'}
+
+    def format_report(self, result: Dict) -> str:
+        """
+        格式化检查报告
+
+        Args:
+            result: 检查结果
+
+        Returns:
+            格式化的报告字符串
+        """
+        if 'error' in result:
+            return f"❌ Error: {result['error']}"
+
+        score = result['consistency_score']
+        threshold = result['threshold']
+        passed = result['passed']
+        issues = result['issues']
+        warnings = result['warnings']
+
+        # 状态emoji
+        status = "✅ Pass" if passed else "❌ Fail"
+
+        # 构建报告
+        report = []
+        report.append("=" * 60)
+        report.append("Terminology Consistency Check Report")
+        report.append("=" * 60)
+        report.append("")
+        report.append(f"Consistency Score: {score * 100:.2f}% ({status} - 目标≥{threshold * 100:.0f}%)")
+        report.append(f"Total Term Usages: {result['total_term_usages']}")
+        report.append(f"Inconsistent Usages: {result['inconsistent_usages']}")
+        report.append("")
+
+        # 严重问题（同义词混用）
+        if issues:
+            report.append("❌ Critical Issues (同义词混用):")
+            report.append("-" * 60)
+            for issue in issues:
+                report.append(f"标准术语: {issue['standard_term']}")
+                report.append(f"发现变体: {', '.join(issue['variants_found'])}")
+                report.append(f"建议: 全文统一使用 '{issue['standard_term']}'")
+                report.append("")
+
+        # 警告（非标准术语）
+        if warnings:
+            report.append("⚠️  Warnings (非标准术语):")
+            report.append("-" * 60)
+            for warning in warnings[:5]:  # 最多显示5个
+                term_key = warning['term']
+                occurrences = warning['occurrences']
+                report.append(f"{term_key}")
+                for line_no, context in occurrences[:3]:  # 最多显示3个位置
+                    report.append(f"  Line {line_no}: ...{context}...")
+                report.append("")
+
+            if len(warnings) > 5:
+                report.append(f"... and {len(warnings) - 5} more warnings")
+                report.append("")
+
+        # 建议
+        report.append("Recommendations:")
+        report.append("-" * 60)
+        if passed:
+            report.append("✅ 术语一致性达标，全文术语使用规范。")
+        else:
+            report.append("⚠️  术语一致性未达标，建议:")
+            report.append("   1. 全文统一使用标准术语（从术语库选择）")
+            report.append("   2. 避免同义词混用（如'联邦学习'和'分布式学习'）")
+            report.append("   3. 权利要求书与说明书术语保持一致")
+
+        report.append("")
+        report.append("=" * 60)
+
+        return '\n'.join(report)
+
+
+def create_sample_terminology():
+    """创建示例术语库"""
+    sample_terminology = {
+        "standard_terms": {
+            "联邦学习": ["标准术语", "分布式机器学习方法"],
+            "用户画像数据": ["标准术语", "用户特征数据"],
+            "第三方鉴权节点": ["标准术语", "可信第三方"],
+            "差分隐私": ["标准术语", "隐私保护技术"],
+            "模型训练": ["标准术语"],
+            "数据加密": ["标准术语"],
+            "权利要求": ["专利术语"],
+            "技术方案": ["专利术语"],
+            "有益效果": ["专利术语"]
+        },
+        "synonym_groups": [
+            ["联邦学习", "分布式学习", "联合学习", "协作学习"],
+            ["用户画像数据", "用户数据", "用户特征", "用户信息"],
+            ["第三方鉴权节点", "可信第三方", "中间方", "第三方服务器"],
+            ["差分隐私", "隐私保护", "隐私计算"],
+            ["模型训练", "训练模型", "模型学习"],
+            ["数据加密", "加密数据", "加密传输"]
+        ]
+    }
+
+    return sample_terminology
+
+
+def main():
+    """主函数"""
+    if len(sys.argv) < 2:
+        print("Usage: python term_checker.py <patent_document_path> [terminology_database_path]")
+        print("")
+        print("Example:")
+        print("  python term_checker.py /path/to/patent.txt /path/to/terminology.json")
+        print("")
+        print("如果未提供术语库，将使用默认术语库。")
+        sys.exit(1)
+
+    doc_path = sys.argv[1]
+    term_db_path = sys.argv[2] if len(sys.argv) > 2 else None
+
+    # 如果没有提供术语库，创建默认术语库
+    if not term_db_path:
+        import tempfile
+        sample_term = create_sample_terminology()
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
+            json.dump(sample_term, f, ensure_ascii=False, indent=2)
+            term_db_path = f.name
+        print("⚠️  未提供术语库，使用默认术语库（联邦学习领域）")
+        print("")
+
+    # 创建检查器
+    checker = TermChecker(threshold=0.90)
+
+    # 检查文档
+    print(f"Checking document: {doc_path}")
+    if term_db_path:
+        print(f"Terminology database: {term_db_path}")
+    print("")
+
+    result = checker.check_document(doc_path, term_db_path)
+
+    # 输出报告
+    report = checker.format_report(result)
+    print(report)
+
+    # 返回退出码
+    if 'error' in result:
+        sys.exit(2)
+    elif not result['passed']:
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()