redline-emailer

Files (6)

• README.md
• SKILL.md
• email-templates.md · reference/
• intake-questions.md · reference/
• validation-rules.md · reference/
• skill.yml

SKILL.md (first lines)

---
name: redline-emailer
description: >
  Translates contract redlines into client-ready or opposing-counsel emails.
  Accepts three input modes: (1) a .docx with tracked changes, (2) a redlined
  PDF with strikethrough/underline formatting, or (3) a verbal description of
  changes. Produces a copy-paste-ready email, tone-matched to the recipient:
  plain-English for own clients, professional legal cover for opposing counsel.
  Use when the attorney says "write the redline email", "summarize these changes
  for the client", "draft a cover email for the redline", "explain these edits
  to opposing counsel", or "turn this redline into an email". Do NOT use for
  drafting contracts or generating redlines — use the relevant drafter skill.
  Do NOT use for diffing two clean (non-redlined) document versions.
---

## Input Modes

| Mode | Trigger | Input |
|------|---------|-------|
| A: .docx Tracked Changes | User provides a `.docx` with Track Changes | Parse Word XML for `w:del`/`w:ins` elements |
| B: Redlined PDF | User provides a `.pdf` with redline formatting | Parse PDF for strikethrough/underline/color-coded text |
| C: Verbal Description | User describes changes, no file | Work from the attorney's description |

Auto-detect the mode from what the user provides. See `references/intake-questions.md` Q1.

---

## Instructions

### Step 1: Load References

Read before doing anything:
- `references/intake-questions.md` — short intake flow (4 questions, most auto-detectable)
- `references/email-templates.md` — tone guides and structural templates for both recipient types
- `references/validation-rules.md` — quality checks per recipient type

### Step 2: Run Intake

Follow `references/intake-questions.md`. This should take 60 seconds or less.

**What you must know before proceeding:**
1. Input mode (auto-detect from file type)
2. Recipient: client or opposing counsel
3. Contract identity: title, parties
4. Special instructions (if any)

Do NOT re-ask questions the attorney already answered in their initial request.
If the attorney says "write the redline email for opposing counsel" and drops a
.docx, you have all four answers — go straight to Step 3.

### Step 3: Extract Changes

This step varies by input mode.

---

#### Mode A: .docx with Tracked Changes

Extract changes from Word XML. The .docx format uses the same elements that
`redline_engine.py` writes — we're reading them instead.

**Namespace:**
```
W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
```

**Element patterns:**
- `<w:del>` → `<w:r>` → `<w:delText>` = deleted text
- `<w:ins>` → `<w:r>` → `<w:t>` = inserted text

**Extraction approach:**

1. Load the .docx with `python-docx`: `doc = Document(filepath)`
2. Walk `doc.element.body` looking for `{W}del` and `{W}ins` elements
3. **Substitutions:** When `w:del` and `w:ins` are siblings in the same `w:p`,
   they represent a substitution (old → new)
4. **Pure deletions:** A `w:del` with no adjacent `w:ins` = text was removed
5. **Pure additions:** A `w:ins` with no adjacent `w:del` = text was added
6. **Comments:** Parse `word/comments.xml` from the .docx zip archive for
   `w:comment` elements — these provide reviewer context for each change.
   Match comments to changes via `w:commentRangeStart` / `w:commentReference` IDs.

**Grouping:** For each change, find the nearest preceding paragraph with a
heading style (e.g., `Heading 1`, `Heading 2`) to determine which contract
section it belongs to. If no heading styles are used, fall back to pattern
matching: "Section X.X", "Article Y", numbered paragraphs.

**Output:** A structured change list:
```
[
  { section: "Section 4.2 — Limitation of Liability",
    type: "substitution",
    old: "twelve (12) months",
    new: "twenty-four (24) months",
    comment: "Per client instruction — doubled the liability cap" },
  ...
]
```

---

#### Mode B: Redlined PDF

Parse the PDF for redline formatting. Redlined PDFs come in two flavors —
detect which one and apply the right strategy.

**Format detection:** Scan the first 2-3 pages using `PyMuPDF` (`fitz`):

```python
import fitz
doc = fitz.open(filepath)
page = doc[0]
blocks = page.get_text("dict")["blocks"]
```

Check text spans for formatting flags:
- Strikethrough flag present → **Strikethrough + underline format**
- Red/colored text without strikethrough → **Track Changes exported to PDF**
- Neither → **Uncertain format** (trigger fallback)

From bstevescherer/heycounsel-community, MIT.

More from bstevescherer/heycounsel-community