defluffisizer 1.0.0

package/skills/defluffisizer/scripts/pdf_write.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+Render a local HTML file to PDF, for defluffisizer's pdf-in / pdf-out path.
+
+Chrome's CLI --headless --print-to-pdf switch always burns a date/URL/
+page-number header and footer into the page with no way to turn it off in
+current Chrome (the --print-to-pdf-no-header switch has been removed), so
+this drives Page.printToPDF over the DevTools Protocol directly instead,
+where displayHeaderFooter is a real, working parameter. Pure standard
+library: no websocket-client, no puppeteer, no pip install.
+
+Example:
+    python3 scripts/pdf_write.py page.html output.pdf
+"""
+
+import base64
+import json
+import os
+import shutil
+import socket
+import struct
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+CHROME_CANDIDATES = [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+]
+
+INSTALL_HINT = (
+    "No Chrome or Chromium found for PDF rendering.\n"
+    "Install Google Chrome (https://google.com/chrome), or "
+    "`brew install --cask google-chrome` (macOS) / `apt install chromium` (Debian/Ubuntu)."
+)
+
+
+def find_chrome():
+    for candidate in CHROME_CANDIDATES:
+        if os.path.isabs(candidate):
+            if os.path.exists(candidate):
+                return candidate
+        elif shutil.which(candidate):
+            return shutil.which(candidate)
+    return None
+
+
+def _ws_handshake(sock, host, port, path):
+    key = base64.b64encode(os.urandom(16)).decode()
+    request = (
+        f"GET {path} HTTP/1.1\r\n"
+        f"Host: {host}:{port}\r\n"
+        "Upgrade: websocket\r\n"
+        "Connection: Upgrade\r\n"
+        f"Sec-WebSocket-Key: {key}\r\n"
+        "Sec-WebSocket-Version: 13\r\n\r\n"
+    )
+    sock.sendall(request.encode())
+    response = b""
+    while b"\r\n\r\n" not in response:
+        response += sock.recv(4096)
+    if b"101" not in response.split(b"\r\n", 1)[0]:
+        raise SystemExit(f"Chrome DevTools WebSocket handshake failed: {response[:200]!r}")
+
+
+def _ws_send(sock, payload):
+    data = json.dumps(payload).encode()
+    length = len(data)
+    mask = os.urandom(4)
+    if length <= 125:
+        header = struct.pack("!BB", 0x81, 0x80 | length)
+    elif length <= 65535:
+        header = struct.pack("!BBH", 0x81, 0x80 | 126, length)
+    else:
+        header = struct.pack("!BBQ", 0x81, 0x80 | 127, length)
+    masked = bytes(byte ^ mask[i % 4] for i, byte in enumerate(data))
+    sock.sendall(header + mask + masked)
+
+
+def _ws_recv_message(sock):
+    buffered = b""
+
+    def read_exact(n):
+        nonlocal buffered
+        while len(buffered) < n:
+            chunk = sock.recv(65536)
+            if not chunk:
+                raise SystemExit("Chrome DevTools WebSocket closed unexpectedly")
+            buffered += chunk
+        out, rest = buffered[:n], buffered[n:]
+        buffered = rest
+        return out
+
+    message = b""
+    while True:
+        header = read_exact(2)
+        fin = header[0] & 0x80
+        opcode = header[0] & 0x0F
+        length = header[1] & 0x7F
+        if length == 126:
+            length = struct.unpack("!H", read_exact(2))[0]
+        elif length == 127:
+            length = struct.unpack("!Q", read_exact(8))[0]
+        payload = read_exact(length)
+        if opcode == 0x8:
+            raise SystemExit("Chrome DevTools WebSocket connection closed by Chrome")
+        message += payload
+        if fin:
+            return message
+
+
+def html_to_pdf(html_path, pdf_path, timeout=30, port=9333):
+    """Render html_path to a real PDF at pdf_path using headless Chrome."""
+    chrome = find_chrome()
+    if not chrome:
+        raise SystemExit(INSTALL_HINT)
+
+    html_path = Path(html_path).resolve()
+    pdf_path = Path(pdf_path).resolve()
+
+    proc = subprocess.Popen(
+        [
+            chrome,
+            "--headless=new",
+            "--disable-gpu",
+            f"--remote-debugging-port={port}",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-extensions",
+            "about:blank",
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    try:
+        deadline = time.time() + timeout
+        ready = False
+        while time.time() < deadline:
+            try:
+                urllib.request.urlopen(f"http://127.0.0.1:{port}/json/version", timeout=1)
+                ready = True
+                break
+            except Exception:
+                time.sleep(0.2)
+        if not ready:
+            raise SystemExit("Chrome did not start a debuggable session in time.")
+
+        new_tab_request = urllib.request.Request(
+            f"http://127.0.0.1:{port}/json/new?file://{html_path}", method="PUT"
+        )
+        with urllib.request.urlopen(new_tab_request, timeout=5) as response:
+            tab = json.loads(response.read())
+        ws_path = tab["webSocketDebuggerUrl"].split(f"127.0.0.1:{port}", 1)[1]
+
+        sock = socket.create_connection(("127.0.0.1", port), timeout=timeout)
+        try:
+            _ws_handshake(sock, "127.0.0.1", port, ws_path)
+            time.sleep(0.5)
+
+            _ws_send(sock, {"id": 1, "method": "Page.enable", "params": {}})
+            _ws_recv_message(sock)
+
+            _ws_send(
+                sock,
+                {
+                    "id": 2,
+                    "method": "Page.printToPDF",
+                    "params": {
+                        "displayHeaderFooter": False,
+                        "printBackground": True,
+                        "preferCSSPageSize": True,
+                    },
+                },
+            )
+            while True:
+                message = json.loads(_ws_recv_message(sock))
+                if message.get("id") == 2:
+                    if "error" in message:
+                        raise SystemExit(f"Page.printToPDF failed: {message['error']}")
+                    pdf_path.write_bytes(base64.b64decode(message["result"]["data"]))
+                    return pdf_path
+        finally:
+            sock.close()
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=5)
+        except Exception:
+            proc.kill()
+
+
+def text_to_html(text):
+    """Wrap plain rewritten text in a minimal, clean, readable page.
+
+    This is the generic fallback when the caller has not supplied a
+    styled .html file: no attempt to clone the source PDF's original
+    design, just clean type on a page, single column, in reading order.
+    """
+    escaped = (
+        text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    )
+    paragraphs = "\n".join(
+        f"<p>{line}</p>" for line in escaped.split("\n") if line.strip()
+    )
+    return f"""<!doctype html>
+<html><head><meta charset="utf-8"><style>
+  @page {{ size: letter; margin: 1in; }}
+  body {{ font-family: Georgia, 'Times New Roman', serif; font-size: 12pt;
+          line-height: 1.5; color: #1a1a1a; }}
+  p {{ margin: 0 0 12pt 0; }}
+</style></head><body>
+{paragraphs}
+</body></html>"""
+
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit("Usage: pdf_write.py <input.html> <output.pdf>")
+    out = html_to_pdf(sys.argv[1], sys.argv[2])
+    print(f"Wrote {out}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/defluffisizer/scripts/pptx_rewrite.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""
+Extract and rewrite text inside PPTX files while preserving the deck structure.
+
+Examples:
+    python3 scripts/pptx_rewrite.py extract input.pptx --out editable.json
+    python3 scripts/pptx_rewrite.py apply input.pptx replacements.json --output output.pptx
+"""
+
+import argparse
+import copy
+import difflib
+import json
+import re
+import zipfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+NS = {
+    "a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "p": "http://schemas.openxmlformats.org/presentationml/2006/main",
+}
+A_NS = f"{{{NS['a']}}}"
+P_NS = f"{{{NS['p']}}}"
+SKIP_TAGS = {"nvGrpSpPr", "grpSpPr"}
+SLIDE_RE = re.compile(r"ppt/slides/slide(\d+)\.xml$")
+
+ET.register_namespace("a", NS["a"])
+ET.register_namespace("p", NS["p"])
+
+
+def local_name(tag):
+    return tag.split("}", 1)[-1]
+
+
+def slide_sort_key(name):
+    match = SLIDE_RE.match(name)
+    return int(match.group(1)) if match else 0
+
+
+def paragraph_text(paragraph):
+    parts = []
+    for node in paragraph:
+        if node.tag in {f"{A_NS}r", f"{A_NS}fld"}:
+            text_node = node.find("a:t", NS)
+            if text_node is not None and text_node.text:
+                parts.append(text_node.text)
+    return "".join(parts)
+
+
+def txbody_to_text(txbody):
+    lines = []
+    for paragraph in txbody.findall("a:p", NS):
+        text = paragraph_text(paragraph).strip()
+        if text:
+            lines.append(text)
+    return "\n".join(lines)
+
+
+def find_text_targets(parent, path=""):
+    targets = {}
+    child_index = 0
+    for child in list(parent):
+        tag = local_name(child.tag)
+        if tag in SKIP_TAGS:
+            continue
+        child_index += 1
+        child_path = f"{path}/{tag}[{child_index}]" if path else f"{tag}[{child_index}]"
+
+        if tag == "sp":
+            txbody = child.find("p:txBody", NS)
+            if txbody is not None:
+                targets[child_path] = txbody
+        elif tag == "graphicFrame":
+            table = child.find(".//a:tbl", NS)
+            if table is not None:
+                for row_index, row in enumerate(table.findall("a:tr", NS), start=1):
+                    for col_index, cell in enumerate(row.findall("a:tc", NS), start=1):
+                        txbody = cell.find("a:txBody", NS)
+                        if txbody is not None:
+                            cell_path = f"{child_path}/table[{row_index},{col_index}]"
+                            targets[cell_path] = txbody
+        elif tag == "grpSp":
+            targets.update(find_text_targets(child, child_path))
+
+    return targets
+
+
+def extract_slide(root, slide_number):
+    sp_tree = root.find(".//p:spTree", NS)
+    if sp_tree is None:
+        return {"slide": slide_number, "elements": []}
+
+    elements = []
+    for path, txbody in find_text_targets(sp_tree).items():
+        text = txbody_to_text(txbody)
+        if not text:
+            continue
+        elements.append({"path": path, "text": text})
+
+    return {"slide": slide_number, "elements": elements}
+
+
+def clone_paragraph_template(txbody):
+    templates = []
+    for paragraph in txbody.findall("a:p", NS):
+        template = {
+            "pPr": None,
+            "rPr": None,
+            "endParaRPr": None,
+            "text": paragraph_text(paragraph).strip(),
+        }
+        ppr = paragraph.find("a:pPr", NS)
+        if ppr is not None:
+            template["pPr"] = copy.deepcopy(ppr)
+        for node in paragraph:
+            if node.tag in {f"{A_NS}r", f"{A_NS}fld"}:
+                rpr = node.find("a:rPr", NS)
+                if rpr is not None:
+                    template["rPr"] = copy.deepcopy(rpr)
+                    break
+        end_para = paragraph.find("a:endParaRPr", NS)
+        if end_para is not None:
+            template["endParaRPr"] = copy.deepcopy(end_para)
+        templates.append(template)
+
+    if not templates:
+        templates.append({"pPr": None, "rPr": None, "endParaRPr": None, "text": ""})
+    return templates
+
+
+def assign_templates(templates, lines):
+    """Match each rewritten line to the paragraph it most likely descends from.
+
+    Matching by raw position breaks alignment and bullet level as soon as a
+    rewrite drops, merges, or reorders a bullet: the fact that used to sit
+    at index 2 (top level bullet) slides into index 1's template (a
+    sub-bullet) once the fluff above it is cut, so it silently picks up the
+    wrong indent and bullet character. Matching by text similarity keeps a
+    surviving sentence anchored to its own original formatting even when
+    lines around it disappear.
+    """
+    scored = []
+    for line_index, line in enumerate(lines):
+        for template_index, template in enumerate(templates):
+            score = difflib.SequenceMatcher(None, line.lower(), template["text"].lower()).ratio()
+            scored.append((score, line_index, template_index))
+    scored.sort(key=lambda item: item[0], reverse=True)
+
+    assignment = [None] * len(lines)
+    used_templates = set()
+    for score, line_index, template_index in scored:
+        if score < 0.35:
+            break
+        if assignment[line_index] is not None or template_index in used_templates:
+            continue
+        assignment[line_index] = template_index
+        used_templates.add(template_index)
+
+    fallback_pool = [i for i in range(len(templates)) if i not in used_templates] or list(range(len(templates)))
+    for line_index in range(len(lines)):
+        if assignment[line_index] is not None:
+            continue
+        position = line_index / max(len(lines) - 1, 1)
+        assignment[line_index] = fallback_pool[round(position * (len(fallback_pool) - 1))]
+
+    return [templates[index] for index in assignment]
+
+
+def reset_stale_autofit(txbody):
+    """Clear cached shrink-to-fit numbers after a text rewrite.
+
+    PowerPoint bakes the shrink percentage for the old text into
+    normAutofit fontScale/lnSpcReduction. Left in place after a rewrite,
+    a box that used to need 3 crowded bullets keeps rendering at the old
+    shrunk size even though the new text is short enough for full size,
+    which reads as a mostly empty box with undersized text. Clearing the
+    cached numbers tells PowerPoint to recompute fit for the new text.
+    """
+    body_pr = txbody.find("a:bodyPr", NS)
+    if body_pr is None:
+        return
+    autofit = body_pr.find("a:normAutofit", NS)
+    if autofit is None:
+        return
+    autofit.attrib.pop("fontScale", None)
+    autofit.attrib.pop("lnSpcReduction", None)
+
+
+def set_txbody_text(txbody, new_text):
+    templates = clone_paragraph_template(txbody)
+    for paragraph in list(txbody.findall("a:p", NS)):
+        txbody.remove(paragraph)
+
+    lines = [line.strip() for line in new_text.split("\n")]
+    lines = [line for line in lines if line] or [""]
+    assigned = assign_templates(templates, lines)
+
+    for line, template in zip(lines, assigned):
+        paragraph = ET.SubElement(txbody, f"{A_NS}p")
+        if template["pPr"] is not None:
+            paragraph.append(copy.deepcopy(template["pPr"]))
+        if line:
+            run = ET.SubElement(paragraph, f"{A_NS}r")
+            if template["rPr"] is not None:
+                run.append(copy.deepcopy(template["rPr"]))
+            text_node = ET.SubElement(run, f"{A_NS}t")
+            text_node.text = line
+        if template["endParaRPr"] is not None:
+            paragraph.append(copy.deepcopy(template["endParaRPr"]))
+
+    reset_stale_autofit(txbody)
+
+
+def load_replacements(path):
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    slides = data.get("slides")
+    if not isinstance(slides, list):
+        raise ValueError("Replacement file must contain a top level 'slides' list")
+
+    replacements = {}
+    for slide in slides:
+        slide_number = int(slide["slide"])
+        replacements[slide_number] = {}
+        for element in slide.get("elements", []):
+            replacements[slide_number][element["path"]] = element["text"]
+    return replacements
+
+
+def extract_pptx(input_path):
+    slides = []
+    with zipfile.ZipFile(input_path) as archive:
+        slide_names = sorted(
+            [name for name in archive.namelist() if SLIDE_RE.match(name)],
+            key=slide_sort_key,
+        )
+        for slide_name in slide_names:
+            slide_number = slide_sort_key(slide_name)
+            root = ET.fromstring(archive.read(slide_name))
+            slides.append(extract_slide(root, slide_number))
+    return {"source": str(Path(input_path).resolve()), "slides": slides}
+
+
+def apply_replacements(input_path, replacement_path, output_path):
+    replacements = load_replacements(replacement_path)
+    input_path = Path(input_path)
+    output_path = Path(output_path)
+
+    with zipfile.ZipFile(input_path) as source, zipfile.ZipFile(
+        output_path,
+        "w",
+        compression=zipfile.ZIP_DEFLATED,
+    ) as dest:
+        for info in source.infolist():
+            data = source.read(info.filename)
+            match = SLIDE_RE.match(info.filename)
+            if match:
+                slide_number = int(match.group(1))
+                slide_replacements = replacements.get(slide_number)
+                if slide_replacements:
+                    root = ET.fromstring(data)
+                    sp_tree = root.find(".//p:spTree", NS)
+                    if sp_tree is None:
+                        raise ValueError(f"Slide {slide_number} has no shape tree")
+                    targets = find_text_targets(sp_tree)
+                    missing = sorted(set(slide_replacements) - set(targets))
+                    if missing:
+                        raise ValueError(
+                            f"Missing text target(s) on slide {slide_number}: {', '.join(missing)}"
+                        )
+                    for path, text in slide_replacements.items():
+                        set_txbody_text(targets[path], text)
+                    data = ET.tostring(root, encoding="utf-8", xml_declaration=True)
+            dest.writestr(info, data)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract and rewrite PPTX text.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    extract_parser = subparsers.add_parser("extract", help="Extract editable text from a deck")
+    extract_parser.add_argument("input", help="Input PPTX file")
+    extract_parser.add_argument("--out", required=True, help="Output JSON path")
+
+    apply_parser = subparsers.add_parser("apply", help="Apply text replacements to a deck")
+    apply_parser.add_argument("input", help="Input PPTX file")
+    apply_parser.add_argument("replacements", help="JSON file with edited slide text")
+    apply_parser.add_argument("--output", required=True, help="Output PPTX file")
+
+    args = parser.parse_args()
+
+    if args.command == "extract":
+        payload = extract_pptx(args.input)
+        Path(args.out).write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        return
+
+    if args.command == "apply":
+        apply_replacements(args.input, args.replacements, args.output)
+        return
+
+
+if __name__ == "__main__":
+    main()