# Redlining Content > Use when the user asks to redline, track changes, or compare differences in a file. Compares an uploaded .docx or .pdf against a provided .dotx/.docx template and returns a redlined .docx where every textual difference is a Word tracked change (insertion/deletion) authored by "Copilot Studio AI". No visual conversion — built directly on the template. - Skill: `kody-w/redlining-content` (Agent Skill, multi-file: 6 files) - Install (CLI): `npx skillmds@latest add kody-w/redlining-content` - Raw SKILL.md: https://api.skillmd.com/api/skills/kody-w/redlining-content/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: AI & ML - Author: kody-w (https://skillmd.com/u/kody-w) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/kody-w/redlining-content --- # Redlining Content Skill Reimplements "Word Compare" for the new Copilot Studio orchestrator. The template is already a perfect Word document, so the output **is** the template body with revisions injected as OOXML `` / `` elements. Accepting all changes yields the submission's wording; rejecting all keeps the template. Changes are authored by **`Copilot Studio AI`** and the output has Track Changes turned on so Word keeps tracking any further human edits. ## Requirements - `lxml` (always) - `pdfplumber` (PDF submissions; `pypdfium2` used as a fallback) All are present in the Copilot Studio sandbox — no `pip install` required. `.docx`/`.dotx` handling is pure `lxml` + standard library. ## Inputs 1. **Template** — the canonical baseline. Bundled with this skill in `assets/` (any single `.dotx`/`.docx` file — the name doesn't matter) and used automatically. A different template (`.dotx` or `.docx`) may be supplied explicitly to override it. 2. **Submission** — the user-uploaded file to compare against the template, either a `.docx` or a `.pdf`. ## Steps 1. Run from this skill's directory: `python scripts/redline.py [output.docx]` The bundled template in `assets/` is auto-discovered and used as the baseline (whatever its file name). To override the template explicitly, pass it via `--template`: `python scripts/redline.py --template [output.docx]` 2. Return the output `.docx` to the user. Output defaults to the submission name with a `_redlined.docx` suffix. ## How it works One shared engine, two input readers — the only thing that differs by file type is how the submission's words are read: - `.docx` / `.dotx` → `read_docx_words()` (paragraph text from `word/document.xml`). - `.pdf` → `read_pdf_words()` (**text extraction only — never converted** to DOCX; uses pdfplumber, then pypdfium2). Both produce a single flat **word list** fed into the same pipeline: 1. **Word-level diff over the whole document.** The template's words and the submission's words are each flattened into one stream and compared once with `difflib.SequenceMatcher`. PDF line-wrapping and paragraph boundaries are therefore irrelevant — only real word differences matter. 2. Each template word is mapped back to its source paragraph. Paragraphs with no changes are kept **byte-for-byte** (all formatting preserved); only changed paragraphs are rebuilt, with differing words wrapped in `` / ``. 3. **Tables.** For `.docx` submissions, template tables are diffed against the submission's tables **cell by cell** (aligned by position: table → row → cell), with `` / `` injected directly into each cell while its `` (width, borders, shading) is preserved. For `.pdf` submissions there is no table structure to align, so template tables pass through untouched and their words are stripped from the extracted text so they aren't flagged as insertions. 4. Writes the output zip: replaces `word/document.xml`, adds `` to `settings.xml`, and converts the `.dotx` main-part content type to the `.docx` one so the result opens as a normal document. ## Per-input guidance See the focused reference docs: - `references/docx-submissions.md` — `.docx` handling, high-fidelity path. - `references/pdf-submissions.md` — `.pdf` handling, why text is extracted (not converted), the word-level diff, and table handling. ## v1 limitations - Inside a *changed* paragraph, intra-run **character** formatting (bold/italic on individual words) is simplified to the paragraph's base formatting. Unchanged paragraphs keep all formatting exactly. - **Tables**: `.docx` table cells are diffed and redlined (aligned by position); cells are matched by position, so inserted/deleted rows or columns and nested tables are not tracked, and multiple paragraphs in one cell collapse to one. `.pdf` tables are not diffed (passed through unchanged). - A brand-new paragraph in the submission is tracked as inserted **words** at the nearest template position; a hard paragraph break may not be recreated. - Matching is by visible text; curly quotes/apostrophes are compared literally. ## Run this — do not improvise This capability's deterministic implementation is a RAPP single-file agent, linked beside this file as `redlining_content_agent.py` and embedded as the fenced Python below (sha256 fa7910f52de141e1…; a byte-exact copy is also vaulted in the capsule comment at the end of this file). On a host with sandbox execution, run the linked file directly — if it is missing, write the fence contents verbatim to `redlining_content_agent.py` first: ```bash python3 redlining_content_agent.py '{"key": "value"}' # arguments as one JSON object echo '{"key": "value"}' | python3 redlining_content_agent.py # or on stdin python3 redlining_content_agent.py --tool # emit the JSON tool contract ``` Treat stdout as a tool result. If it reports missing or unresolved inputs, stop and collect them. If it returns `steps`, execute those steps in order exactly as returned; if it returns `instructions`, follow them with the supplied inputs. Otherwise use the result verbatim. Do not invent behavior beyond that output. On a host without code execution, treat the Parameters schema and the code below as the exact specification and never paraphrase a step. Never edit inside the generated markers; a converter-equipped host can instead restore the original file checksum-verified with the installed `rapp-agent-converter/scripts/toast.py convert SKILL.md --to agent`. ```python # rapp:deterministic """RedliningContent -- Use when the user asks to redline, track changes, or compare differences in a file. Compares an uploaded .docx or .pdf against a provided .dotx/.docx template and returns a redlined .docx where every textual difference is a Word tracked change (insertion/deletion) authored by "Copilot Studio AI". No visual conversion — built directly on the template. Generated by the rapp skill from redlining-content. The RCI capsule at the bottom of this file carries the full original; `toast.py convert` restores it byte-exact.""" import json import re import sys try: from agents.basic_agent import BasicAgent except ImportError: # running OUTSIDE a brainstem -- stay executable anyway. class BasicAgent: # noqa: D101 - minimal stand-in, same contract def __init__(self, name=None, metadata=None): if name: self.name = name if metadata: self.metadata = metadata def perform(self, **kwargs): return "Not implemented." def system_context(self): return None def to_tool(self): return {"type": "function", "function": { "name": self.name, "description": self.metadata.get("description", ""), "parameters": self.metadata.get("parameters", {})}} # The procedural layer, verbatim from the source capability. INSTRUCTIONS = '# Redlining Content Skill\n\nReimplements "Word Compare" for the new Copilot Studio orchestrator. The\ntemplate is already a perfect Word document, so the output **is** the template\nbody with revisions injected as OOXML `` / `` elements. Accepting\nall changes yields the submission's wording; rejecting all keeps the template.\n\nChanges are authored by **`Copilot Studio AI`** and the output has Track\nChanges turned on so Word keeps tracking any further human edits.\n\n## Requirements\n\n- `lxml` (always)\n- `pdfplumber` (PDF submissions; `pypdfium2` used as a fallback)\n\nAll are present in the Copilot Studio sandbox — no `pip install` required.\n`.docx`/`.dotx` handling is pure `lxml` + standard library.\n\n## Inputs\n\n1. **Template** — the canonical baseline. Bundled with this skill in\n `assets/` (any single `.dotx`/`.docx` file — the name doesn't matter) and\n used automatically. A different template (`.dotx` or `.docx`) may be\n supplied explicitly to override it.\n2. **Submission** — the user-uploaded file to compare against the template,\n either a `.docx` or a `.pdf`.\n\n## Steps\n\n1. Run from this skill's directory:\n `python scripts/redline.py [output.docx]`\n The bundled template in `assets/` is auto-discovered and used as the\n baseline (whatever its file name).\n To override the template explicitly, pass it via `--template`:\n `python scripts/redline.py --template [output.docx]`\n2. Return the output `.docx` to the user. Output defaults to the submission\n name with a `_redlined.docx` suffix.\n\n## How it works\n\nOne shared engine, two input readers — the only thing that differs by file\ntype is how the submission's words are read:\n\n- `.docx` / `.dotx` → `read_docx_words()` (paragraph text from\n `word/document.xml`).\n- `.pdf` → `read_pdf_words()` (**text extraction only — never converted** to\n DOCX; uses pdfplumber, then pypdfium2).\n\nBoth produce a single flat **word list** fed into the same pipeline:\n\n1. **Word-level diff over the whole document.** The template's words and the\n submission's words are each flattened into one stream and compared once with\n `difflib.SequenceMatcher`. PDF line-wrapping and paragraph boundaries are\n therefore irrelevant — only real word differences matter.\n2. Each template word is mapped back to its source paragraph. Paragraphs with no\n changes are kept **byte-for-byte** (all formatting preserved); only changed\n paragraphs are rebuilt, with differing words wrapped in `` / ``.\n3. **Tables.** For `.docx` submissions, template tables are diffed against the\n submission's tables **cell by cell** (aligned by position: table → row →\n cell), with `` / `` injected directly into each cell while its\n `` (width, borders, shading) is preserved. For `.pdf` submissions\n there is no table structure to align, so template tables pass through\n untouched and their words are stripped from the extracted text so they aren't\n flagged as insertions.\n4. Writes the output zip: replaces `word/document.xml`, adds ``\n to `settings.xml`, and converts the `.dotx` main-part content type to the\n `.docx` one so the result opens as a normal document.\n\n## Per-input guidance\n\nSee the focused reference docs:\n\n- `references/docx-submissions.md` — `.docx` handling, high-fidelity path.\n- `references/pdf-submissions.md` — `.pdf` handling, why text is extracted (not\n converted), the word-level diff, and table handling.\n\n## v1 limitations\n\n- Inside a *changed* paragraph, intra-run **character** formatting (bold/italic\n on individual words) is simplified to the paragraph's base formatting.\n Unchanged paragraphs keep all formatting exactly.\n- **Tables**: `.docx` table cells are diffed and redlined (aligned by position);\n cells are matched by position, so inserted/deleted rows or columns and nested\n tables are not tracked, and multiple paragraphs in one cell collapse to one.\n `.pdf` tables are not diffed (passed through unchanged).\n- A brand-new paragraph in the submission is tracked as inserted **words** at\n the nearest template position; a hard paragraph break may not be recreated.\n- Matching is by visible text; curly quotes/apostrophes are compared literally.' # Ordered commands lifted verbatim from the capability's own documentation. STEPS = [] class RedliningContentAgent(BasicAgent): def __init__(self): self.name = 'RedliningContent' self.metadata = { "name": "RedliningContent", "description": "Use when the user asks to redline, track changes, or compare differences in a file. Compares an uploaded .docx or .pdf against a provided .dotx/.docx template and returns a redlined .docx where every textual difference is a Word tracked change (insertion/deletion) authored by \"Copilot Studio AI\". No visual conversion \u2014 built directly on the template.", "parameters": { "type": "object", "properties": {}, "required": [] } } super().__init__(name=self.name, metadata=self.metadata) def perform(self, **kwargs): # toaster:generated-perform return json.dumps({"status": "ok", "instructions": INSTRUCTIONS, "inputs": kwargs, "note": "Prose-only capability: follow INSTRUCTIONS " "with the given inputs."}, indent=2) if __name__ == "__main__": # echo '{"arg": "value"}' | python3 redlining_content_agent.py # python3 redlining_content_agent.py '{"arg": "value"}' # python3 redlining_content_agent.py --tool # emit the JSON tool contract _a = sys.argv[1:] if _a and _a[0] == "--tool": print(json.dumps(RedliningContentAgent().to_tool(), indent=2)) else: _raw = _a[0] if _a else (sys.stdin.read().strip() or "{}") print(RedliningContentAgent().perform(**json.loads(_raw))) # rci-capsule:v1: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 ```