@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/law/opencontracts-guide/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: opencontracts-guide
+description: "Legal document annotation, versioning, and analysis platform"
+metadata:
+  openclaw:
+    emoji: "📋"
+    category: "domains"
+    subcategory: "law"
+    keywords: ["legal documents", "contract annotation", "document versioning", "legal AI", "NLP legal", "MCP"]
+    source: "https://github.com/Open-Source-Legal/OpenContracts"
+---
+
+# OpenContracts Guide
+
+## Overview
+
+OpenContracts is an open-source platform for legal document annotation, versioning, and analysis. It provides collaborative annotation tools for legal text, version tracking across document drafts, NLP-powered clause extraction, and integration with AI agents via MCP. Designed for legal researchers, law firms, and teams managing large document collections that need structured annotation and analysis.
+
+## Installation
+
+```bash
+# Docker deployment
+git clone https://github.com/Open-Source-Legal/OpenContracts.git
+cd OpenContracts
+docker-compose up -d
+
+# Access at http://localhost:3000
+```
+
+## Core Features
+
+### Document Management
+
+```python
+from opencontracts import Client
+
+client = Client("http://localhost:3000")
+
+# Upload documents
+doc = client.upload(
+    file="contract.pdf",
+    metadata={
+        "type": "NDA",
+        "parties": ["Company A", "Company B"],
+        "date": "2025-01-15",
+        "jurisdiction": "Delaware",
+    },
+)
+
+# Version tracking
+versions = client.get_versions(doc.id)
+for v in versions:
+    print(f"v{v.number}: {v.date} — {v.changes_summary}")
+
+# Compare versions
+diff = client.compare_versions(doc.id, v1=1, v2=3)
+for change in diff.changes:
+    print(f"[{change.type}] Section {change.section}: "
+          f"{change.description}")
+```
+
+### Annotation
+
+```python
+# Create annotation project
+project = client.create_project(
+    name="NDA Clause Analysis",
+    documents=[doc.id],
+    label_set=[
+        "confidentiality_scope",
+        "term_duration",
+        "exclusions",
+        "remedies",
+        "governing_law",
+        "dispute_resolution",
+    ],
+)
+
+# Add annotations
+client.annotate(
+    document_id=doc.id,
+    annotations=[
+        {
+            "start": 1250, "end": 1480,
+            "label": "confidentiality_scope",
+            "note": "Broad definition including derivatives",
+        },
+        {
+            "start": 2100, "end": 2250,
+            "label": "term_duration",
+            "note": "5-year term with auto-renewal",
+        },
+    ],
+)
+```
+
+### NLP Analysis
+
+```python
+# Automated clause extraction
+clauses = client.extract_clauses(
+    doc.id,
+    clause_types=[
+        "indemnification",
+        "limitation_of_liability",
+        "termination",
+        "force_majeure",
+        "assignment",
+    ],
+)
+
+for clause in clauses:
+    print(f"\n[{clause.type}] (confidence: {clause.confidence:.2f})")
+    print(f"  Location: p.{clause.page}, para {clause.paragraph}")
+    print(f"  Text: {clause.text[:100]}...")
+
+# Risk assessment
+risks = client.assess_risks(doc.id)
+for risk in risks:
+    print(f"[{risk.severity}] {risk.clause}: {risk.description}")
+```
+
+### MCP Integration
+
+```json
+{
+  "mcpServers": {
+    "opencontracts": {
+      "command": "npx",
+      "args": ["@opencontracts/mcp-server"],
+      "env": {
+        "OPENCONTRACTS_URL": "http://localhost:3000"
+      }
+    }
+  }
+}
+```
+
+## Search and Analytics
+
+```python
+# Full-text search across documents
+results = client.search(
+    query="indemnification unlimited liability",
+    document_types=["NDA", "MSA"],
+    date_range=("2024-01-01", "2025-12-31"),
+)
+
+# Analytics
+stats = client.analytics(project_id=project.id)
+print(f"Documents annotated: {stats.docs_complete}")
+print(f"Total annotations: {stats.total_annotations}")
+print(f"Inter-annotator agreement: {stats.agreement:.2f}")
+print(f"Most common clause: {stats.top_clauses[0]}")
+```
+
+## Use Cases
+
+1. **Contract review**: Systematic clause analysis and risk assessment
+2. **Legal research**: Annotate case law and legislation
+3. **Compliance**: Track regulatory document requirements
+4. **Training data**: Build labeled datasets for legal NLP
+5. **Due diligence**: Structured review of deal documents
+
+## References
+
+- [OpenContracts GitHub](https://github.com/Open-Source-Legal/OpenContracts)
+- [Legal NLP Resources](https://github.com/thunlp/LegalPapers)

package/skills/domains/law/patent-analysis-guide/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: patent-analysis-guide
+description: "Patent search, classification, landscape analysis, and prior art mining"
+metadata:
+  openclaw:
+    emoji: "page-with-curl"
+    category: "domains"
+    subcategory: "law"
+    keywords: ["patent", "intellectual-property", "prior-art", "cpc", "patent-landscape", "citation-analysis"]
+    source: "wentor"
+---
+
+# Patent Analysis Guide
+
+A skill for conducting patent research, landscape analysis, and prior art searches. Covers patent database APIs, classification systems, citation network analysis, claim parsing, and technology trend mapping for intellectual property research.
+
+## Patent Data Sources
+
+### Major Patent Databases
+
+| Database | Coverage | API | Cost |
+|----------|----------|-----|------|
+| USPTO PatentsView | US patents and applications | REST API, bulk download | Free |
+| EPO Open Patent Services | EP, WO, and 100+ offices | REST API (OPS) | Free (throttled) |
+| Google Patents | 120M+ documents worldwide | BigQuery (Google Patents Public) | Free (BigQuery costs) |
+| Lens.org | 130M+ patent records | REST API | Free for researchers |
+| WIPO PATENTSCOPE | PCT applications + national | REST API | Free |
+
+### Programmatic Patent Search
+
+```python
+import requests
+import xml.etree.ElementTree as ET
+
+class EPOClient:
+    """Client for the EPO Open Patent Services (OPS) API."""
+
+    BASE_URL = "https://ops.epo.org/3.2/rest-services"
+
+    def __init__(self, consumer_key: str, consumer_secret: str):
+        self.token = self._authenticate(consumer_key, consumer_secret)
+
+    def _authenticate(self, key: str, secret: str) -> str:
+        import base64
+        credentials = base64.b64encode(f"{key}:{secret}".encode()).decode()
+        resp = requests.post(
+            "https://ops.epo.org/3.2/auth/accesstoken",
+            headers={"Authorization": f"Basic {credentials}"},
+            data={"grant_type": "client_credentials"},
+        )
+        return resp.json()["access_token"]
+
+    def search(self, cql_query: str, max_results: int = 25) -> list[dict]:
+        """
+        Search patents using CQL (Common Query Language).
+        Example queries:
+          ta="machine learning" AND cl="neural network"
+          pa="university" AND pd>=2020
+        """
+        resp = requests.get(
+            f"{self.BASE_URL}/published-data/search",
+            headers={"Authorization": f"Bearer {self.token}",
+                     "Accept": "application/json"},
+            params={"q": cql_query, "Range": f"1-{max_results}"},
+        )
+        return resp.json()
+```
+
+## Patent Classification Systems
+
+### Cooperative Patent Classification (CPC)
+
+The CPC hierarchy has five levels: Section > Class > Subclass > Group > Subgroup.
+
+```
+Example: H04L 9/3247
+  H       = Electricity (Section)
+  H04     = Electric communication technique (Class)
+  H04L    = Transmission of digital information (Subclass)
+  H04L 9/ = Cryptographic mechanisms (Group)
+  H04L 9/3247 = Digital signatures (Subgroup)
+```
+
+### IPC to CPC Mapping
+
+```python
+def parse_cpc_code(code: str) -> dict:
+    """Parse a CPC classification code into its hierarchical components."""
+    code = code.strip().replace(" ", "")
+    return {
+        "section": code[0],
+        "class": code[:3],
+        "subclass": code[:4],
+        "group": code.split("/")[0] if "/" in code else code[:4],
+        "subgroup": code if "/" in code else None,
+        "full": code,
+    }
+
+# Technology domain mapping (top-level CPC sections)
+CPC_SECTIONS = {
+    "A": "Human Necessities",
+    "B": "Performing Operations; Transporting",
+    "C": "Chemistry; Metallurgy",
+    "D": "Textiles; Paper",
+    "E": "Fixed Constructions",
+    "F": "Mechanical Engineering; Lighting; Heating",
+    "G": "Physics",
+    "H": "Electricity",
+    "Y": "General Tagging of New Technological Developments",
+}
+```
+
+## Patent Landscape Analysis
+
+### Building a Patent Landscape
+
+A patent landscape maps the technology and competitive environment in a domain:
+
+```python
+import pandas as pd
+import numpy as np
+from collections import Counter
+
+def patent_landscape_metrics(patents: pd.DataFrame) -> dict:
+    """
+    Compute patent landscape metrics from a patent dataset.
+    Expected columns: patent_id, filing_date, grant_date,
+    assignee, cpc_codes (list), claims_count, citations_received
+    """
+    # Filing trend (annual)
+    patents["filing_year"] = pd.to_datetime(patents.filing_date).dt.year
+    annual_filings = patents.groupby("filing_year").size()
+
+    # Top assignees
+    top_assignees = patents.assignee.value_counts().head(20)
+
+    # Technology distribution (CPC subclass level)
+    all_cpc = []
+    for codes in patents.cpc_codes:
+        all_cpc.extend([c[:4] for c in codes])
+    cpc_distribution = Counter(all_cpc).most_common(20)
+
+    # Citation impact
+    citation_stats = patents.citations_received.describe()
+
+    # Geographic distribution (from assignee country)
+    geo_dist = patents.assignee_country.value_counts()
+
+    return {
+        "total_patents": len(patents),
+        "annual_filings": annual_filings.to_dict(),
+        "top_assignees": top_assignees.to_dict(),
+        "technology_areas": cpc_distribution,
+        "citation_stats": citation_stats.to_dict(),
+        "geographic_distribution": geo_dist.head(10).to_dict(),
+    }
+```
+
+### Citation Network Analysis
+
+```python
+import networkx as nx
+
+def build_citation_network(patents: pd.DataFrame,
+                            citations: pd.DataFrame) -> nx.DiGraph:
+    """
+    Build a patent citation network.
+    citations: DataFrame with columns [citing_patent, cited_patent]
+    """
+    G = nx.DiGraph()
+
+    # Add patent nodes with attributes
+    for _, row in patents.iterrows():
+        G.add_node(row.patent_id, assignee=row.assignee,
+                   year=row.filing_year, cpc=row.cpc_codes[0][:4])
+
+    # Add citation edges
+    for _, row in citations.iterrows():
+        if row.citing_patent in G and row.cited_patent in G:
+            G.add_edge(row.citing_patent, row.cited_patent)
+
+    return G
+
+def identify_seminal_patents(G: nx.DiGraph, top_n: int = 20) -> list:
+    """Find the most influential patents by various centrality measures."""
+    in_degree = dict(G.in_degree())
+    pagerank = nx.pagerank(G)
+
+    # Combine metrics
+    scores = {}
+    for node in G.nodes():
+        scores[node] = {
+            "citations_received": in_degree[node],
+            "pagerank": pagerank[node],
+        }
+    ranked = sorted(scores.items(), key=lambda x: x[1]["pagerank"], reverse=True)
+    return ranked[:top_n]
+```
+
+## Claim Analysis
+
+### Parsing Patent Claims
+
+Patent claims define the legal scope of protection. Independent claims are the broadest; dependent claims narrow them:
+
+```python
+def parse_claims(claims_text: str) -> list[dict]:
+    """
+    Parse patent claims text into structured claim objects.
+    Identifies independent vs dependent claims and extracts dependencies.
+    """
+    # Split on claim numbers
+    claim_pattern = re.compile(r"\n\s*(\d+)\.\s+", re.MULTILINE)
+    parts = claim_pattern.split(claims_text)
+
+    claims = []
+    for i in range(1, len(parts), 2):
+        claim_num = int(parts[i])
+        claim_text = parts[i + 1].strip()
+
+        # Detect dependency
+        dep_match = re.match(
+            r"(?:The|A)\s+\w+\s+(?:of|according to)\s+claim\s+(\d+)",
+            claim_text, re.IGNORECASE
+        )
+        is_independent = dep_match is None
+        depends_on = int(dep_match.group(1)) if dep_match else None
+
+        claims.append({
+            "number": claim_num,
+            "text": claim_text,
+            "independent": is_independent,
+            "depends_on": depends_on,
+            "word_count": len(claim_text.split()),
+        })
+    return claims
+```
+
+## Prior Art Search Strategy
+
+Systematic prior art search methodology:
+
+1. **Define the invention**: Break the invention into key technical features
+2. **Keyword search**: Use synonyms, broader terms, and technical variants
+3. **Classification search**: Identify relevant CPC/IPC codes and search within them
+4. **Citation search**: Forward and backward citation tracking from known relevant patents
+5. **Assignee search**: Search patents from known competitors and research groups
+6. **Non-patent literature**: Check academic papers, standards, product documentation
+
+## Tools and Resources
+
+- **PatentsView API**: Free US patent data with assignee disambiguation
+- **Google Patents**: Full-text search with CPC browsing and citation links
+- **Lens.org**: Scholarly and patent search with linking between patents and papers
+- **Derwent Innovation**: Commercial tool for comprehensive patent analytics
+- **PatSnap**: AI-powered patent intelligence platform
+- **WIPO Pearl**: Multilingual patent terminology database

package/skills/domains/law/regulatory-compliance-guide/SKILL.md

@@ -0,0 +1,267 @@
+---
+name: regulatory-compliance-guide
+description: "Regulatory text mining, compliance research, and policy analysis tools"
+metadata:
+  openclaw:
+    emoji: "scroll"
+    category: "domains"
+    subcategory: "law"
+    keywords: ["regulation", "compliance", "policy-analysis", "text-mining", "federal-register", "rulemaking"]
+    source: "wentor"
+---
+
+# Regulatory Compliance Guide
+
+A skill for mining regulatory texts, tracking regulatory changes, and conducting compliance research. Covers accessing regulatory databases, parsing regulatory language, change detection in regulations, compliance gap analysis, and computational policy analysis.
+
+## Regulatory Data Sources
+
+### US Federal Regulatory Data
+
+| Source | Content | Format | Access |
+|--------|---------|--------|--------|
+| Federal Register API | Proposed and final rules | JSON API | Free (federalregister.gov) |
+| eCFR (Electronic CFR) | Current Code of Federal Regulations | XML + API | Free (ecfr.gov) |
+| Regulations.gov | Public comments on rulemakings | JSON API | Free |
+| Congress.gov | Bills and legislative history | API + bulk | Free |
+| SEC EDGAR | Securities filings and no-action letters | Full-text search + API | Free |
+
+### Accessing Federal Register Data
+
+```python
+import requests
+from datetime import date, timedelta
+
+class FederalRegisterClient:
+    """Client for the Federal Register API."""
+
+    BASE_URL = "https://www.federalregister.gov/api/v1"
+
+    def search_rules(self, query: str, agency: str = None,
+                     date_from: str = None, per_page: int = 20) -> dict:
+        """
+        Search for rules and proposed rules in the Federal Register.
+        """
+        params = {
+            "conditions[term]": query,
+            "conditions[type][]": ["RULE", "PRORULE"],
+            "per_page": per_page,
+            "order": "newest",
+        }
+        if agency:
+            params["conditions[agencies][]"] = agency
+        if date_from:
+            params["conditions[publication_date][gte]"] = date_from
+
+        resp = requests.get(f"{self.BASE_URL}/documents", params=params)
+        data = resp.json()
+        return {
+            "count": data.get("count", 0),
+            "results": [
+                {
+                    "title": r["title"],
+                    "document_number": r["document_number"],
+                    "publication_date": r["publication_date"],
+                    "agency_names": r.get("agency_names", []),
+                    "type": r["type"],
+                    "abstract": r.get("abstract", ""),
+                    "html_url": r["html_url"],
+                }
+                for r in data.get("results", [])
+            ],
+        }
+
+    def get_document(self, document_number: str) -> dict:
+        """Retrieve full document details by document number."""
+        resp = requests.get(
+            f"{self.BASE_URL}/documents/{document_number}.json"
+        )
+        return resp.json()
+```
+
+## Regulatory Text Parsing
+
+### Identifying Regulatory Obligations
+
+Regulatory language follows predictable patterns that indicate obligation strength:
+
+```python
+import re
+from enum import Enum
+
+class ObligationLevel(Enum):
+    MANDATORY = "mandatory"       # shall, must, required
+    PROHIBITIVE = "prohibitive"   # shall not, must not, prohibited
+    PERMISSIVE = "permissive"     # may, is permitted
+    RECOMMENDED = "recommended"   # should, is recommended
+    INFORMATIVE = "informative"   # for information, note
+
+OBLIGATION_PATTERNS = {
+    ObligationLevel.MANDATORY: [
+        r"\bshall\b(?!\s+not)", r"\bmust\b(?!\s+not)",
+        r"\bis required to\b", r"\bare required to\b",
+    ],
+    ObligationLevel.PROHIBITIVE: [
+        r"\bshall not\b", r"\bmust not\b",
+        r"\bis prohibited\b", r"\bmay not\b",
+    ],
+    ObligationLevel.PERMISSIVE: [
+        r"\bmay\b(?!\s+not)", r"\bis permitted\b",
+        r"\bis authorized\b",
+    ],
+    ObligationLevel.RECOMMENDED: [
+        r"\bshould\b(?!\s+not)", r"\bis recommended\b",
+        r"\bit is advisable\b",
+    ],
+}
+
+def classify_obligations(text: str) -> list[dict]:
+    """
+    Extract and classify regulatory obligations from text.
+    Returns sentences tagged with their obligation level.
+    """
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    results = []
+    for sent in sentences:
+        level = ObligationLevel.INFORMATIVE
+        for obl_level, patterns in OBLIGATION_PATTERNS.items():
+            if any(re.search(p, sent, re.IGNORECASE) for p in patterns):
+                level = obl_level
+                break
+        results.append({"sentence": sent.strip(), "obligation": level.value})
+    return results
+```
+
+### CFR Section Parsing
+
+```python
+def parse_cfr_section(xml_text: str) -> dict:
+    """
+    Parse an eCFR XML section into structured components.
+    Extracts the section number, heading, paragraphs, and cross-references.
+    """
+    root = ET.fromstring(xml_text)
+    section = {
+        "number": root.findtext(".//SECTNO", ""),
+        "heading": root.findtext(".//SUBJECT", ""),
+        "paragraphs": [],
+        "cross_references": [],
+    }
+
+    for para in root.iter("P"):
+        text = "".join(para.itertext()).strip()
+        if text:
+            section["paragraphs"].append(text)
+            # Extract cross-references to other CFR sections
+            xrefs = re.findall(r"\d+\s+CFR\s+[\d.]+(?:\([a-z]\))?", text)
+            section["cross_references"].extend(xrefs)
+
+    return section
+```
+
+## Regulatory Change Detection
+
+### Tracking Amendments Over Time
+
+```python
+from difflib import SequenceMatcher, unified_diff
+
+def compare_regulation_versions(old_text: str, new_text: str,
+                                  section_id: str) -> dict:
+    """
+    Compare two versions of a regulation section to identify changes.
+    Returns a structured diff with change classification.
+    """
+    old_lines = old_text.splitlines(keepends=True)
+    new_lines = new_text.splitlines(keepends=True)
+
+    diff = list(unified_diff(old_lines, new_lines,
+                              fromfile=f"{section_id} (old)",
+                              tofile=f"{section_id} (new)"))
+
+    additions = sum(1 for l in diff if l.startswith("+") and not l.startswith("+++"))
+    deletions = sum(1 for l in diff if l.startswith("-") and not l.startswith("---"))
+
+    similarity = SequenceMatcher(None, old_text, new_text).ratio()
+
+    return {
+        "section": section_id,
+        "similarity": round(similarity, 4),
+        "lines_added": additions,
+        "lines_removed": deletions,
+        "change_magnitude": "major" if similarity < 0.8 else
+                           "minor" if similarity < 0.95 else "trivial",
+        "diff": "".join(diff),
+    }
+```
+
+## Compliance Gap Analysis
+
+### Mapping Requirements to Controls
+
+```python
+def compliance_gap_analysis(requirements: list[dict],
+                             controls: list[dict]) -> pd.DataFrame:
+    """
+    Map regulatory requirements to organizational controls.
+    Identify gaps where requirements lack corresponding controls.
+
+    requirements: [{id, text, obligation_level, cfr_section}]
+    controls: [{id, description, implemented, evidence}]
+    """
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.metrics.pairwise import cosine_similarity
+
+    req_texts = [r["text"] for r in requirements]
+    ctrl_texts = [c["description"] for c in controls]
+
+    vectorizer = TfidfVectorizer(stop_words="english", max_features=5000)
+    all_texts = req_texts + ctrl_texts
+    tfidf = vectorizer.fit_transform(all_texts)
+
+    req_vecs = tfidf[:len(req_texts)]
+    ctrl_vecs = tfidf[len(req_texts):]
+
+    similarity_matrix = cosine_similarity(req_vecs, ctrl_vecs)
+
+    gaps = []
+    for i, req in enumerate(requirements):
+        best_match_idx = similarity_matrix[i].argmax()
+        best_score = similarity_matrix[i][best_match_idx]
+        matched_ctrl = controls[best_match_idx] if best_score > 0.3 else None
+
+        gaps.append({
+            "requirement_id": req["id"],
+            "cfr_section": req["cfr_section"],
+            "obligation": req["obligation_level"],
+            "matched_control": matched_ctrl["id"] if matched_ctrl else "NONE",
+            "match_score": round(best_score, 3),
+            "status": "covered" if matched_ctrl and matched_ctrl["implemented"]
+                      else "gap" if not matched_ctrl
+                      else "planned",
+        })
+
+    return pd.DataFrame(gaps)
+```
+
+## Regulatory Domains
+
+Key regulated sectors with their primary frameworks:
+
+| Sector | Primary Regulator | Key Regulations |
+|--------|------------------|----------------|
+| Financial services | SEC, CFTC, FINRA | Dodd-Frank, SOX, MiFID II |
+| Healthcare | FDA, HHS | HIPAA, 21 CFR Parts 210-211 |
+| Environment | EPA | Clean Air Act, RCRA, CERCLA |
+| Data privacy | FTC, state AGs | CCPA, GDPR, COPPA |
+| Telecommunications | FCC | Communications Act, net neutrality rules |
+| Energy | FERC, NRC | Federal Power Act, 10 CFR 50 |
+
+## Tools and Resources
+
+- **RegInfo.gov**: Unified Agenda of regulatory actions
+- **Regulations.gov API**: Public comments on proposed rules
+- **GovInfo.gov**: Official publications of all branches of government
+- **LexisNexis / Westlaw**: Commercial legal research platforms
+- **RegTech tools**: Ascent, Compliance.ai, Clausematch
+- **spaCy + custom pipelines**: NLP for regulatory text extraction