dsh-office-kit 0.2.0 → 0.3.1

package/assets/skills/office-documents/scripts/privacy_scrub.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+"""Remove metadata that identifies the author or the machine that edited a file.
+
+Word leaves a trail: core properties, the company and manager fields, custom
+properties, revision-save identifiers (``w:rsid*``) and spell-check markers.  None
+of it is visible in the document, all of it travels with the file.
+
+Exit codes: 0 success, 2 bad input.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from lxml import etree
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import docx_kit as kit
+
+# Windows consoles default to a legacy code page; every payload is UTF-8 JSON.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, ValueError):
+        pass
+
+DC = "http://purl.org/dc/elements/1.1/"
+CP = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
+DCTERMS = "http://purl.org/dc/terms/"
+EP = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
+REL_CUSTOM = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties"
+
+CORE_CLEAR = ["{%s}creator" % DC, "{%s}lastModifiedBy" % CP, "{%s}keywords" % CP, "{%s}description" % DC, "{%s}subject" % DC, "{%s}title" % DC, "{%s}category" % CP]
+APP_CLEAR = ["{%s}Company" % EP, "{%s}Manager" % EP, "{%s}Application" % EP]
+
+
+def clear_core(doc: kit.Docx) -> list[str]:
+    cleared = []
+    if not doc.exists("docProps/core.xml"):
+        return cleared
+    root = doc.xml("docProps/core.xml")
+    for tag in CORE_CLEAR:
+        for node in root.findall(tag):
+            node.text = ""
+            cleared.append(tag.rsplit("}", 1)[-1])
+    for node in root.findall("{%s}revision" % CP):
+        node.text = "1"
+    return cleared
+
+
+def clear_app(doc: kit.Docx) -> list[str]:
+    cleared = []
+    if not doc.exists("docProps/app.xml"):
+        return cleared
+    root = doc.xml("docProps/app.xml")
+    for tag in APP_CLEAR:
+        for node in root.findall(tag):
+            node.text = ""
+            cleared.append(tag.rsplit("}", 1)[-1])
+    return cleared
+
+
+def drop_custom(doc: kit.Docx) -> bool:
+    dropped = False
+    if doc.exists("docProps/custom.xml"):
+        doc.drop("docProps/custom.xml")
+        doc.drop_override("docProps/custom.xml")
+        dropped = True
+    ns = "{http://schemas.openxmlformats.org/package/2006/relationships}"
+    for name in [part for part in doc.parts if part.endswith(".rels")]:
+        root = doc.xml(name)
+        changed = False
+        for node in list(root.findall(ns + "Relationship")):
+            if node.get("Type") == REL_CUSTOM:
+                root.remove(node)
+                changed = True
+                dropped = True
+        if changed:
+            doc.set_xml(name, root)
+    return dropped
+
+
+def scrub_document(doc: kit.Docx) -> dict:
+    stats = {"rsid_attributes": 0, "proof_error_markers": 0, "render_breaks": 0}
+    for name in [part for part in doc.parts if part.endswith(".xml") and (part.startswith("word/") or part == "word/document.xml")]:
+        root = doc.xml(name)
+        changed = False
+        for node in root.iter():
+            for key in list(node.attrib):
+                if key.startswith(kit.q("rsid")) or key.startswith("{%s}rsid" % kit.W):
+                    del node.attrib[key]
+                    stats["rsid_attributes"] += 1
+                    changed = True
+        for tag, key in ((kit.q("proofErr"), "proof_error_markers"), (kit.q("lastRenderedPageBreak"), "render_breaks")):
+            for node in list(root.iter(tag)):
+                node.getparent().remove(node)
+                stats[key] += 1
+                changed = True
+        if changed:
+            doc.set_xml(name, root)
+    return stats
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Strip author, company, custom properties and revision identifiers.")
+    parser.add_argument("input_docx", help="Input .docx")
+    parser.add_argument("--out", required=True, help="Output .docx")
+    parser.add_argument("--keep_title", action="store_true", help="Keep dc:title and dc:subject")
+    args = parser.parse_args(argv)
+
+    try:
+        doc = kit.Docx(args.input_docx)
+    except (OSError, KeyError) as exc:
+        print("error: %s" % exc, file=sys.stderr)
+        return 2
+
+    cleared = clear_core(doc) + clear_app(doc)
+    if args.keep_title:
+        cleared = [name for name in cleared if name not in ("title", "subject")]
+        root = doc.xml("docProps/core.xml")
+        original = kit.Docx(args.input_docx).xml("docProps/core.xml")
+        for tag in ("{%s}title" % DC, "{%s}subject" % DC):
+            source = original.find(tag)
+            target = root.find(tag)
+            if source is not None and target is not None:
+                target.text = source.text
+
+    custom_dropped = drop_custom(doc)
+    stats = scrub_document(doc)
+    doc.save(args.out)
+    kit.emit({"ok": True, "output": str(Path(args.out)), "cleared": cleared, "custom_properties_dropped": custom_dropped, **stats})
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/skills/office-documents/scripts/redact_docx.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+"""Mask emails, phone numbers and custom patterns in a document's text.
+
+The replacement happens inside individual text runs, so a match split across
+formatted runs is not found; that trade keeps the surrounding formatting (bold,
+italics, links) untouched.  Length-preserving masking keeps a redacted table
+aligned, which is usually why the number of characters matters.
+
+Exit codes: 0 success, 2 bad input.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import docx_kit as kit
+
+# Windows consoles default to a legacy code page; every payload is UTF-8 JSON.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, ValueError):
+        pass
+
+EMAIL = re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}")
+PHONE = re.compile(r"(?<!\d)(?:\+\d{1,3}[\s.\-]?)?(?:\(\d{2,4}\)[\s.\-]?)?\d{2,4}[\s.\-]\d{3,4}(?:[\s.\-]\d{3,4})?(?!\d)")
+
+
+def redact_text(text: str, patterns: list[re.Pattern], mask: str, preserve: bool) -> tuple[str, int]:
+    total = 0
+    for pattern in patterns:
+        def replace(match: re.Match) -> str:
+            nonlocal total
+            total += 1
+            return (mask * len(match.group(0))) if preserve else mask
+
+        text = pattern.sub(replace, text)
+    return text, total
+
+
+def collect_parts(doc: kit.Docx, include_comments: bool) -> list[str]:
+    parts = ["word/document.xml"] + doc.names("word/header") + doc.names("word/footer")
+    for note in ("word/footnotes.xml", "word/endnotes.xml"):
+        if doc.exists(note):
+            parts.append(note)
+    if include_comments and doc.exists("word/comments.xml"):
+        parts.append("word/comments.xml")
+    return parts
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Mask emails, phone numbers or custom regex matches in text runs.")
+    parser.add_argument("input_docx", help="Input .docx")
+    parser.add_argument("output_docx", help="Output .docx")
+    parser.add_argument("--emails", action="store_true", help="Redact email addresses (default when no pattern is given)")
+    parser.add_argument("--phones", action="store_true", help="Redact phone numbers (default when no pattern is given)")
+    parser.add_argument("--pattern", action="append", default=[], help="Extra regex to redact (repeatable)")
+    parser.add_argument("--mask_char", default="*", help="Masking character")
+    parser.add_argument("--replacement", default="[redacted]", help="Replacement text when length is not preserved")
+    parser.add_argument("--no_preserve_length", action="store_true", help="Use --replacement instead of a per-character mask")
+    parser.add_argument("--include_comments", action="store_true", help="Also redact comment text")
+    args = parser.parse_args(argv)
+
+    patterns: list[re.Pattern] = []
+    if args.emails or not (args.emails or args.phones or args.pattern):
+        patterns.append(EMAIL)
+    if args.phones or not (args.emails or args.phones or args.pattern):
+        patterns.append(PHONE)
+    for raw in args.pattern:
+        try:
+            patterns.append(re.compile(raw))
+        except re.error as exc:
+            print("error: bad --pattern %r: %s" % (raw, exc), file=sys.stderr)
+            return 2
+
+    try:
+        doc = kit.Docx(args.input_docx)
+    except (OSError, KeyError) as exc:
+        print("error: %s" % exc, file=sys.stderr)
+        return 2
+
+    mask = args.replacement if args.no_preserve_length else (args.mask_char or "*")[:1]
+    preserve = not args.no_preserve_length
+    matches = 0
+    touched_parts = []
+    for part in collect_parts(doc, args.include_comments):
+        if not doc.exists(part):
+            continue
+        root = doc.xml(part)
+        part_matches = 0
+        for node in root.iter(kit.q("t")):
+            if not node.text:
+                continue
+            updated, count = redact_text(node.text, patterns, mask, preserve)
+            if count:
+                node.text = updated
+                part_matches += count
+        for node in root.iter(kit.q("delText")):
+            if not node.text:
+                continue
+            updated, count = redact_text(node.text, patterns, mask, preserve)
+            if count:
+                node.text = updated
+                part_matches += count
+        if part_matches:
+            doc.set_xml(part, root)
+            matches += part_matches
+            touched_parts.append({"part": part, "matches": part_matches})
+
+    doc.save(args.output_docx)
+    kit.emit({"ok": True, "output": str(Path(args.output_docx)), "matches": matches, "patterns": len(patterns), "parts": touched_parts})
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/skills/office-documents/scripts/render_and_diff.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+"""Render two documents and report which pages changed, pixel by pixel.
+
+This is how you prove an edit did what you meant without opening Word: render
+both versions, diff the page images, then look at the pages that moved.  The diff
+image marks changed pixels in colour so a one-line change is obvious.
+
+Exit codes: 0 compared, 1 render failed, 3 no renderer installed, 2 bad input.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import docx_kit as kit
+
+# Windows consoles default to a legacy code page; every payload is UTF-8 JSON.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, ValueError):
+        pass
+
+THRESHOLD = 8
+
+
+def render(path: Path, out_dir: Path, dpi: int) -> tuple[int, list[str], str]:
+    code, stdout, stderr = kit.run_office_cli(["docx", "render", "--input", str(path), "--out-dir", str(out_dir), "--dpi", str(dpi)])
+    payload = kit.cli_json(stdout) or kit.cli_json(stderr) or {}
+    detail = payload.get("error") or payload.get("reason") or ""
+    if not detail:
+        lines = [line.strip() for line in (stderr or stdout).splitlines() if line.strip() not in ("", "{", "}")]
+        detail = lines[-1] if lines else "render failed"
+    return code, payload.get("pages") or [], detail
+
+
+def diff_pages(first: Path, second: Path, out_path: Path) -> dict:
+    from PIL import Image, ImageChops, ImageOps
+
+    with Image.open(first) as a, Image.open(second) as b:
+        left = a.convert("RGB")
+        right = b.convert("RGB")
+        if left.size != right.size:
+            right = right.resize(left.size)
+        difference = ImageChops.difference(left, right)
+        grey = difference.convert("L").point(lambda value: 255 if value > THRESHOLD else 0)
+        changed = sum(1 for value in grey.getdata() if value)
+        box = difference.getbbox()
+        ImageOps.autocontrast(difference).save(out_path)
+        return {
+            "changed_pixels": changed,
+            "total_pixels": left.width * left.height,
+            "ratio": round(changed / float(left.width * left.height), 6),
+            "bbox": list(box) if box else None,
+            "size": list(left.size),
+            "diff_image": str(out_path),
+        }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Render two .docx files and report per-page pixel differences.")
+    parser.add_argument("first", help="Original .docx")
+    parser.add_argument("second", help="Changed .docx")
+    parser.add_argument("--outdir", required=True, help="Directory for rendered pages and diff images")
+    parser.add_argument("--dpi", type=int, default=120)
+    parser.add_argument("--threshold", type=int, default=THRESHOLD, help="Per-pixel channel difference that counts as a change")
+    args = parser.parse_args(argv)
+
+    root = Path(args.outdir).expanduser().resolve()
+    first = Path(args.first).expanduser().resolve()
+    second = Path(args.second).expanduser().resolve()
+    for path in (first, second):
+        if not path.is_file():
+            print("error: %s not found" % path, file=sys.stderr)
+            return 2
+
+    code_a, pages_a, detail_a = render(first, root / "a", args.dpi)
+    code_b, pages_b, detail_b = render(second, root / "b", args.dpi)
+    if code_a != 0 or code_b != 0 or not pages_a or not pages_b:
+        detail = detail_a or detail_b or "render failed"
+        reason = "no_renderer" if ("renderer" in detail.lower() or "libreoffice" in detail.lower()) else "render_failed"
+        kit.emit({"ok": False, "reason": reason, "detail": detail, "remedy": "Install Microsoft Office, WPS Office, or LibreOffice, then re-run."})
+        return 3 if reason == "no_renderer" else 1
+
+    pairs = list(zip(pages_a, pages_b))
+    results = []
+    for index, (left, right) in enumerate(pairs, start=1):
+        results.append(diff_pages(Path(left), Path(right), root / ("diff-%02d.png" % index)))
+
+    changed_pages = [index for index, item in enumerate(results, start=1) if item["changed_pixels"]]
+    kit.emit(
+        {
+            "ok": True,
+            "pages_first": len(pages_a),
+            "pages_second": len(pages_b),
+            "changed_pages": changed_pages,
+            "page_count_delta": len(pages_b) - len(pages_a),
+            "diffs": results,
+        }
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/skills/office-documents/scripts/replace_text.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""Replace text in a Word document without touching the original.
+
+Pairs run inside single runs first; when a match straddles runs the paragraph
+text is rewritten into its first run, so ordinary prose survives intact and a
+paragraph that mixes formats collapses. Body, tables, and every section header
+and footer are covered.
+
+Usage:
+  replace_text.py --input IN.docx [--out OUT.docx] --find OLD --replace NEW [--find ...]
+  replace_text.py --input IN.docx [--out OUT.docx] --spec edits.json
+
+The spec file is {"replace": [{"find": "18%", "replace": "21%"}]} or a bare list
+of those objects.
+
+Exit codes: 0 replaced, 1 nothing replaced (with --require-all) or invalid
+input, 2 argparse usage error.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import docx_kit as kit  # noqa: E402
+
+# Windows consoles default to a legacy code page; every payload is UTF-8 JSON.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, ValueError):
+        pass
+
+
+def paragraph_text_nodes(paragraph) -> list:
+    """Every w:t below a paragraph, including runs inside hyperlinks."""
+    return paragraph._p.xpath(".//w:t")
+
+
+def replace_in_paragraph(paragraph, find: str, replacement: str) -> int:
+    nodes = paragraph_text_nodes(paragraph)
+    if not nodes:
+        return 0
+    count = 0
+    for node in nodes:
+        text = node.text or ""
+        if find in text:
+            hits = text.count(find)
+            node.text = text.replace(find, replacement)
+            count += hits
+    if count:
+        return count
+    joined = "".join(node.text or "" for node in nodes)
+    if find not in joined:
+        return 0
+    hits = joined.count(find)
+    nodes[0].text = joined.replace(find, replacement)
+    for node in nodes[1:]:
+        node.text = ""
+    return hits
+
+
+def iter_paragraphs(document):
+    def walk_tables(tables):
+        for table in tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    yield from cell.paragraphs
+                    yield from walk_tables(cell.tables)
+
+    yield from document.paragraphs
+    yield from walk_tables(document.tables)
+    for section in document.sections:
+        for part in (section.header, section.footer, section.first_page_header,
+                     section.first_page_footer, section.even_page_header,
+                     section.even_page_footer):
+            try:
+                yield from part.paragraphs
+            except Exception:  # a header/footer that is not linked or not present
+                continue
+
+
+def fail(payload: dict, code: int = 1) -> int:
+    kit.emit({"ok": False, **payload})
+    return code
+
+
+def load_spec(path: str) -> list[tuple[str, str]]:
+    payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    items = payload.get("replace", []) if isinstance(payload, dict) else payload
+    pairs: list[tuple[str, str]] = []
+    for item in items:
+        find = str(item.get("find", ""))
+        if find:
+            pairs.append((find, str(item.get("replace", ""))))
+    return pairs
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Replace text in a .docx copy.")
+    parser.add_argument("--input", required=True, help="source .docx (never modified)")
+    parser.add_argument("--out", help="output path; default <name>-edited.docx")
+    parser.add_argument("--find", action="append", default=[], help="text to find; pair with --replace")
+    parser.add_argument("--replace", action="append", default=[], help="replacement for the matching --find")
+    parser.add_argument("--spec", help="JSON file with replace pairs")
+    parser.add_argument("--require-all", action="store_true", help="exit 1 when a pair matches nothing")
+    args = parser.parse_args()
+
+    if args.find and len(args.find) != len(args.replace):
+        return fail({"error": "--find and --replace must be given in pairs"}, 2)
+    pairs = list(zip(args.find, args.replace))
+    if args.spec:
+        try:
+            pairs.extend(load_spec(args.spec))
+        except (OSError, ValueError) as exc:
+            return fail({"error": f"cannot read spec: {exc}"}, 2)
+    if not pairs:
+        return fail({"error": "no replacements requested"}, 2)
+
+    source = Path(args.input).expanduser()
+    if not source.is_file():
+        return fail({"error": f"input not found: {args.input}"}, 1)
+    out = Path(args.out).expanduser() if args.out else source.with_name(f"{source.stem}-edited.docx")
+    if out.resolve() == source.resolve():
+        return fail({"error": "refusing to overwrite the input; pass a different --out"}, 1)
+
+    from docx import Document
+
+    document = Document(str(source))
+    per_pair: list[dict] = []
+    total = 0
+    for find, replacement in pairs:
+        hits = 0
+        for paragraph in iter_paragraphs(document):
+            hits += replace_in_paragraph(paragraph, find, replacement)
+        total += hits
+        per_pair.append({"find": find, "replace": replacement, "count": hits})
+
+    out.parent.mkdir(parents=True, exist_ok=True)
+    document.save(str(out))
+    misses = [item["find"] for item in per_pair if not item["count"]]
+    payload = {
+        "ok": not (args.require_all and misses),
+        "input": str(source),
+        "output": str(out),
+        "replacements": total,
+        "pairs": per_pair,
+        "misses": misses,
+    }
+    if args.require_all and misses:
+        payload["error"] = "patterns matched nothing: " + ", ".join(misses)
+        return fail(payload, 1)
+    kit.emit(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/skills/office-documents/scripts/section_audit.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+"""Report section geometry in inches so layout problems are visible as numbers.
+
+Every ``sectPr`` is one page-layout decision: page size, orientation (portrait is
+a page size where width < height, not a flag), margins, columns, header/footer
+links, and the section start type.  Mixed page sizes in one file are the most
+common cause of "why did page 4 shrink" reports, so a summary flag calls it out.
+
+Exit codes: 0 clean, 1 suspicious geometry, 2 bad input.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import docx_kit as kit
+
+# Windows consoles default to a legacy code page; every payload is UTF-8 JSON.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, ValueError):
+        pass
+
+TWIPS_PER_INCH = 1440
+
+
+def inches(value: str | None) -> float | None:
+    return round(int(value) / TWIPS_PER_INCH, 3) if value and value.lstrip("-").isdigit() else None
+
+
+def describe(part: str, sect, index: int, doc: kit.Docx) -> dict:
+    page = sect.find(kit.q("pgSz"))
+    margins = sect.find(kit.q("pgMar"))
+    columns = sect.find(kit.q("cols"))
+    kind = sect.find(kit.q("type"))
+    info = {
+        "index": index,
+        "part": part,
+        "width_in": inches(page.get(kit.q("w"))) if page is not None else None,
+        "height_in": inches(page.get(kit.q("h"))) if page is not None else None,
+        "orientation": None,
+        "margin_in": {},
+        "columns": int(columns.get(kit.q("num"))) if columns is not None and columns.get(kit.q("num")) else 1,
+        "start": kind.get(kit.q("val")) if kind is not None else "nextPage",
+        "headers": [],
+        "footers": [],
+        "title_page": sect.find(kit.q("titlePg")) is not None,
+        "page_number_start": None,
+    }
+    if info["width_in"] and info["height_in"]:
+        info["orientation"] = "portrait" if info["width_in"] < info["height_in"] else "landscape"
+    if margins is not None:
+        for side in ("top", "bottom", "left", "right", "header", "footer", "gutter"):
+            info["margin_in"][side] = inches(margins.get(kit.q(side)))
+    numbering = sect.find(kit.q("pgNumType"))
+    if numbering is not None and numbering.get(kit.q("start")):
+        info["page_number_start"] = int(numbering.get(kit.q("start")))
+    rels = {entry["id"]: entry for entry in doc.relationships(part)}
+    for tag, key in (("headerReference", "headers"), ("footerReference", "footers")):
+        for ref in sect.findall(kit.q(tag)):
+            rid = ref.get(kit.q("id", kit.R))
+            info[key].append({"type": ref.get(kit.q("type")), "part": rels[rid]["resolved"] if rid in rels else None})
+    return info
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Report page size, orientation, margins and columns per section.")
+    parser.add_argument("docx", help="Input .docx")
+    args = parser.parse_args(argv)
+
+    try:
+        doc = kit.Docx(args.docx)
+    except (OSError, KeyError) as exc:
+        print("error: %s" % exc, file=sys.stderr)
+        return 2
+
+    sections = [describe("word/document.xml", sect, index, doc) for index, sect in enumerate(doc.sections(), start=1)]
+    findings = []
+    sizes = {(item["width_in"], item["height_in"]) for item in sections}
+    if len(sizes) > 1:
+        findings.append({"kind": "mixed_page_sizes", "sizes": sorted(sizes, key=lambda pair: (pair[0] or 0, pair[1] or 0))})
+    for item in sections:
+        margins = item["margin_in"]
+        if margins.get("left") is not None and margins.get("right") is not None and margins["left"] + margins["right"] >= (item["width_in"] or 8.5) - 1:
+            findings.append({"kind": "narrow_text_column", "section": item["index"], "left": margins["left"], "right": margins["right"]})
+        if item["width_in"] and item["width_in"] > 8.5 and item["orientation"] == "portrait":
+            findings.append({"kind": "portrait_wider_than_letter", "section": item["index"]})
+
+    kit.emit({"ok": not findings, "sections": sections, "findings": findings})
+    return 1 if findings else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())