@farazirfan/costar-server-executor 1.7.37 → 1.7.39

package/skills/pptx/scripts/pack.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""Pack a directory into a PPTX file.
+
+Validates with auto-repair, condenses XML formatting, and creates the PPTX.
+"""
+
+import argparse
+import shutil
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+
+from ooxml.scripts.validation import PPTXSchemaValidator
+
+# Smart quotes to re-encode after DOM serialization (DOM decodes entities to Unicode)
+SMART_QUOTE_REPLACEMENTS = {
+    "\u201c": "“",  # Left double quote "
+    "\u201d": "”",  # Right double quote "
+    "\u2018": "‘",  # Left single quote '
+    "\u2019": "’",  # Right single quote '
+}
+
+
+def pack(
+    input_directory: str,
+    output_file: str,
+    original_file: str | None = None,
+    validate: bool = True,
+) -> tuple[None, str]:
+    """Pack a directory into a PPTX file.
+
+    Args:
+        input_directory: Path to unpacked PPTX directory
+        output_file: Path to output PPTX file
+        original_file: Path to original PPTX for validation comparison
+        validate: If True, run validation with auto-repair before packing
+
+    Returns:
+        (None, message) - message indicates success or failure
+    """
+    input_dir = Path(input_directory)
+    output_path = Path(output_file)
+
+    if not input_dir.is_dir():
+        return None, f"Error: {input_dir} is not a directory"
+
+    if output_path.suffix.lower() != ".pptx":
+        return None, f"Error: {output_file} must be a .pptx file"
+
+    # Validate with auto-repair if requested and original file provided
+    if validate and original_file:
+        original_path = Path(original_file)
+        if original_path.exists():
+            success, output = _run_validation(input_dir, original_path)
+            if output:
+                print(output)
+            if not success:
+                return None, f"Error: Validation failed for {input_dir}"
+
+    # Work in temporary directory to avoid modifying original
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_content_dir = Path(temp_dir) / "content"
+        shutil.copytree(input_dir, temp_content_dir)
+
+        # Process XML files to remove pretty-printing whitespace
+        for pattern in ["*.xml", "*.rels"]:
+            for xml_file in temp_content_dir.rglob(pattern):
+                _condense_xml(xml_file)
+
+        # Create final PPTX file as zip archive
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for f in temp_content_dir.rglob("*"):
+                if f.is_file():
+                    zf.write(f, f.relative_to(temp_content_dir))
+
+    return None, f"Successfully packed {input_dir} to {output_file}"
+
+
+def _run_validation(unpacked_dir: Path, original_file: Path) -> tuple[bool, str | None]:
+    """Run validation with auto-repair.
+
+    Returns:
+        (success, output) - success is True if all validations pass
+    """
+    output_lines = []
+
+    # Run auto-repair
+    validator = PPTXSchemaValidator(unpacked_dir, original_file)
+    repairs = validator.repair()
+    if repairs:
+        output_lines.append(f"Auto-repaired {repairs} issue(s)")
+
+    # Run validation
+    validator = PPTXSchemaValidator(unpacked_dir, original_file)
+    success = validator.validate()
+
+    if success:
+        output_lines.append("All validations PASSED!")
+
+    return success, "\n".join(output_lines) if output_lines else None
+
+
+def _encode_smart_quotes(text: str) -> str:
+    """Re-encode smart quotes as XML entities after DOM serialization."""
+    for char, entity in SMART_QUOTE_REPLACEMENTS.items():
+        text = text.replace(char, entity)
+    return text
+
+
+def _condense_xml(xml_file: Path) -> None:
+    """Strip unnecessary whitespace and remove comments from XML."""
+    try:
+        with open(xml_file, encoding="utf-8") as f:
+            dom = defusedxml.minidom.parse(f)
+
+        # Process each element to remove whitespace and comments
+        for element in dom.getElementsByTagName("*"):
+            # Skip text elements (w:t, a:t, etc.) - preserve their content
+            if element.tagName.endswith(":t"):
+                continue
+
+            # Remove whitespace-only text nodes and comment nodes
+            for child in list(element.childNodes):
+                if (
+                    child.nodeType == child.TEXT_NODE
+                    and child.nodeValue
+                    and child.nodeValue.strip() == ""
+                ) or child.nodeType == child.COMMENT_NODE:
+                    element.removeChild(child)
+
+        # Re-encode smart quotes that DOM decoded to Unicode
+        output = _encode_smart_quotes(dom.toxml(encoding="UTF-8").decode("utf-8"))
+        xml_file.write_text(output, encoding="utf-8")
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Pack a directory into a PPTX file")
+    parser.add_argument("input_directory", help="Unpacked PPTX directory")
+    parser.add_argument("output_file", help="Output PPTX file")
+    parser.add_argument(
+        "--original",
+        help="Original PPTX file for validation comparison",
+    )
+    parser.add_argument(
+        "--validate",
+        type=lambda x: x.lower() == "true",
+        default=True,
+        metavar="true|false",
+        help="Run validation with auto-repair (default: true)",
+    )
+    args = parser.parse_args()
+
+    _, message = pack(
+        args.input_directory,
+        args.output_file,
+        original_file=args.original,
+        validate=args.validate,
+    )
+    print(message)
+
+    if "Error" in message:
+        sys.exit(1)

package/skills/pptx/scripts/thumbnail.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""Create thumbnail grids from PowerPoint presentation slides.
+
+Creates a grid layout of slide thumbnails for quick visual analysis.
+Labels each thumbnail with its XML filename (e.g., slide1.xml).
+Hidden slides are shown with a placeholder pattern.
+
+Usage:
+    python thumbnail.py input.pptx [output_prefix] [--cols N]
+
+Examples:
+    python thumbnail.py presentation.pptx
+    # Creates: thumbnails.jpg
+
+    python thumbnail.py template.pptx grid --cols 4
+    # Creates: grid.jpg (or grid-1.jpg, grid-2.jpg for large decks)
+"""
+
+import argparse
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+from PIL import Image, ImageDraw, ImageFont
+
+# Constants
+THUMBNAIL_WIDTH = 300
+CONVERSION_DPI = 100
+MAX_COLS = 6
+DEFAULT_COLS = 3
+JPEG_QUALITY = 95
+GRID_PADDING = 20
+BORDER_WIDTH = 2
+FONT_SIZE_RATIO = 0.10
+LABEL_PADDING_RATIO = 0.4
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create thumbnail grids from PowerPoint slides."
+    )
+    parser.add_argument("input", help="Input PowerPoint file (.pptx)")
+    parser.add_argument(
+        "output_prefix",
+        nargs="?",
+        default="thumbnails",
+        help="Output prefix for image files (default: thumbnails)",
+    )
+    parser.add_argument(
+        "--cols",
+        type=int,
+        default=DEFAULT_COLS,
+        help=f"Number of columns (default: {DEFAULT_COLS}, max: {MAX_COLS})",
+    )
+
+    args = parser.parse_args()
+
+    cols = min(args.cols, MAX_COLS)
+    if args.cols > MAX_COLS:
+        print(f"Warning: Columns limited to {MAX_COLS}")
+
+    input_path = Path(args.input)
+    if not input_path.exists() or input_path.suffix.lower() != ".pptx":
+        print(f"Error: Invalid PowerPoint file: {args.input}", file=sys.stderr)
+        sys.exit(1)
+
+    output_path = Path(f"{args.output_prefix}.jpg")
+
+    try:
+        # Get slide info (filenames and hidden status) in presentation order
+        slide_info = get_slide_info(input_path)
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            visible_images = convert_to_images(input_path, temp_path)
+
+            if not visible_images and not any(s["hidden"] for s in slide_info):
+                print("Error: No slides found", file=sys.stderr)
+                sys.exit(1)
+
+            # Build slide list with images (visible) or placeholders (hidden)
+            slides = build_slide_list(slide_info, visible_images, temp_path)
+
+            grid_files = create_grids(slides, cols, THUMBNAIL_WIDTH, output_path)
+
+            print(f"Created {len(grid_files)} grid(s):")
+            for grid_file in grid_files:
+                print(f"  {grid_file}")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def get_slide_info(pptx_path: Path) -> list[dict]:
+    """Get slide filenames and hidden status in presentation order.
+
+    Returns list of dicts with 'name' and 'hidden' keys.
+    """
+    with zipfile.ZipFile(pptx_path, "r") as zf:
+        # Read presentation.xml.rels to get rId -> slide filename mapping
+        rels_content = zf.read("ppt/_rels/presentation.xml.rels").decode("utf-8")
+        rels_dom = defusedxml.minidom.parseString(rels_content)
+
+        rid_to_slide = {}
+        for rel in rels_dom.getElementsByTagName("Relationship"):
+            rid = rel.getAttribute("Id")
+            target = rel.getAttribute("Target")
+            rel_type = rel.getAttribute("Type")
+            if "slide" in rel_type and target.startswith("slides/"):
+                rid_to_slide[rid] = target.replace("slides/", "")
+
+        # Read presentation.xml to get slide order and hidden status
+        pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
+        pres_dom = defusedxml.minidom.parseString(pres_content)
+
+        slides = []
+        for sld_id in pres_dom.getElementsByTagName("p:sldId"):
+            rid = sld_id.getAttribute("r:id")
+            if rid in rid_to_slide:
+                # Check if slide is hidden (show="0")
+                hidden = sld_id.getAttribute("show") == "0"
+                slides.append({"name": rid_to_slide[rid], "hidden": hidden})
+
+        return slides
+
+
+def build_slide_list(
+    slide_info: list[dict],
+    visible_images: list[Path],
+    temp_dir: Path,
+) -> list[tuple[Path, str]]:
+    """Build list of (image_path, slide_name) tuples.
+
+    Hidden slides get placeholder images.
+    """
+    # Get placeholder size from first visible image
+    if visible_images:
+        with Image.open(visible_images[0]) as img:
+            placeholder_size = img.size
+    else:
+        placeholder_size = (1920, 1080)
+
+    slides = []
+    visible_idx = 0
+
+    for info in slide_info:
+        if info["hidden"]:
+            # Create placeholder for hidden slide
+            placeholder_path = temp_dir / f"hidden-{info['name']}.jpg"
+            placeholder_img = create_hidden_placeholder(placeholder_size)
+            placeholder_img.save(placeholder_path, "JPEG")
+            slides.append((placeholder_path, f"{info['name']} (hidden)"))
+        else:
+            # Use visible image
+            if visible_idx < len(visible_images):
+                slides.append((visible_images[visible_idx], info["name"]))
+                visible_idx += 1
+
+    return slides
+
+
+def create_hidden_placeholder(size: tuple[int, int]) -> Image.Image:
+    """Create placeholder image for hidden slides (gray with X pattern)."""
+    img = Image.new("RGB", size, color="#F0F0F0")
+    draw = ImageDraw.Draw(img)
+    line_width = max(5, min(size) // 100)
+    draw.line([(0, 0), size], fill="#CCCCCC", width=line_width)
+    draw.line([(size[0], 0), (0, size[1])], fill="#CCCCCC", width=line_width)
+    return img
+
+
+def convert_to_images(pptx_path: Path, temp_dir: Path) -> list[Path]:
+    """Convert PowerPoint to images via PDF."""
+    pdf_path = temp_dir / f"{pptx_path.stem}.pdf"
+
+    # Convert to PDF
+    result = subprocess.run(
+        [
+            "soffice",
+            "--headless",
+            "--convert-to",
+            "pdf",
+            "--outdir",
+            str(temp_dir),
+            str(pptx_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0 or not pdf_path.exists():
+        raise RuntimeError("PDF conversion failed")
+
+    # Convert PDF to images
+    result = subprocess.run(
+        [
+            "pdftoppm",
+            "-jpeg",
+            "-r",
+            str(CONVERSION_DPI),
+            str(pdf_path),
+            str(temp_dir / "slide"),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError("Image conversion failed")
+
+    return sorted(temp_dir.glob("slide-*.jpg"))
+
+
+def create_grids(
+    slides: list[tuple[Path, str]],
+    cols: int,
+    width: int,
+    output_path: Path,
+) -> list[str]:
+    """Create thumbnail grids, max cols×(cols+1) images per grid."""
+    max_per_grid = cols * (cols + 1)
+    grid_files = []
+
+    for chunk_idx, start_idx in enumerate(range(0, len(slides), max_per_grid)):
+        end_idx = min(start_idx + max_per_grid, len(slides))
+        chunk_slides = slides[start_idx:end_idx]
+
+        grid = create_grid(chunk_slides, cols, width)
+
+        if len(slides) <= max_per_grid:
+            grid_filename = output_path
+        else:
+            stem = output_path.stem
+            suffix = output_path.suffix
+            grid_filename = output_path.parent / f"{stem}-{chunk_idx + 1}{suffix}"
+
+        grid_filename.parent.mkdir(parents=True, exist_ok=True)
+        grid.save(str(grid_filename), quality=JPEG_QUALITY)
+        grid_files.append(str(grid_filename))
+
+    return grid_files
+
+
+def create_grid(
+    slides: list[tuple[Path, str]],
+    cols: int,
+    width: int,
+) -> Image.Image:
+    """Create a single thumbnail grid."""
+    font_size = int(width * FONT_SIZE_RATIO)
+    label_padding = int(font_size * LABEL_PADDING_RATIO)
+
+    # Get dimensions from first image
+    with Image.open(slides[0][0]) as img:
+        aspect = img.height / img.width
+    height = int(width * aspect)
+
+    # Calculate grid size
+    rows = (len(slides) + cols - 1) // cols
+    grid_w = cols * width + (cols + 1) * GRID_PADDING
+    grid_h = rows * (height + font_size + label_padding * 2) + (rows + 1) * GRID_PADDING
+
+    # Create grid
+    grid = Image.new("RGB", (grid_w, grid_h), "white")
+    draw = ImageDraw.Draw(grid)
+
+    try:
+        font = ImageFont.load_default(size=font_size)
+    except Exception:
+        font = ImageFont.load_default()
+
+    # Place thumbnails
+    for i, (img_path, slide_name) in enumerate(slides):
+        row, col = i // cols, i % cols
+        x = col * width + (col + 1) * GRID_PADDING
+        y_base = (
+            row * (height + font_size + label_padding * 2) + (row + 1) * GRID_PADDING
+        )
+
+        # Add slide filename label
+        label = slide_name
+        bbox = draw.textbbox((0, 0), label, font=font)
+        text_w = bbox[2] - bbox[0]
+        draw.text(
+            (x + (width - text_w) // 2, y_base + label_padding),
+            label,
+            fill="black",
+            font=font,
+        )
+
+        # Add thumbnail
+        y_thumbnail = y_base + label_padding + font_size + label_padding
+
+        with Image.open(img_path) as img:
+            img.thumbnail((width, height), Image.Resampling.LANCZOS)
+            w, h = img.size
+            tx = x + (width - w) // 2
+            ty = y_thumbnail + (height - h) // 2
+            grid.paste(img, (tx, ty))
+
+            # Add border
+            if BORDER_WIDTH > 0:
+                draw.rectangle(
+                    [
+                        (tx - BORDER_WIDTH, ty - BORDER_WIDTH),
+                        (tx + w + BORDER_WIDTH - 1, ty + h + BORDER_WIDTH - 1),
+                    ],
+                    outline="gray",
+                    width=BORDER_WIDTH,
+                )
+
+    return grid
+
+
+if __name__ == "__main__":
+    main()

package/skills/pptx/scripts/unpack.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Unpack and format XML contents of PPTX files.
+
+Usage: python unpack.py <pptx_file> <output_dir>
+
+Example:
+    python unpack.py presentation.pptx unpacked/
+"""
+
+import sys
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+
+# Smart quotes that get mangled by the tokenizer - convert to XML entities
+SMART_QUOTE_REPLACEMENTS = {
+    "\u201c": "&#x201C;",  # Left double quote "
+    "\u201d": "&#x201D;",  # Right double quote "
+    "\u2018": "&#x2018;",  # Left single quote '
+    "\u2019": "&#x2019;",  # Right single quote '
+}
+
+
+def unpack(input_file: str, output_dir: str) -> None:
+    """Unpack a PPTX file and pretty-print XML contents.
+
+    Args:
+        input_file: Path to PPTX file
+        output_dir: Path to output directory
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_dir)
+
+    if not input_path.exists():
+        print(f"Error: {input_file} not found", file=sys.stderr)
+        sys.exit(1)
+
+    if input_path.suffix.lower() != ".pptx":
+        print(f"Error: {input_file} must be a .pptx file", file=sys.stderr)
+        sys.exit(1)
+
+    # Extract
+    output_path.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(input_path, "r") as zf:
+        zf.extractall(output_path)
+
+    # Pretty print all XML files
+    xml_files = list(output_path.rglob("*.xml")) + list(output_path.rglob("*.rels"))
+    for xml_file in xml_files:
+        _pretty_print_xml(xml_file)
+
+    # Escape smart quotes so they survive tokenization
+    for xml_file in xml_files:
+        _escape_smart_quotes(xml_file)
+
+    print(f"Unpacked {input_file} to {output_dir}")
+
+
+def _pretty_print_xml(xml_file: Path) -> None:
+    """Pretty print an XML file with indentation."""
+    try:
+        content = xml_file.read_text(encoding="utf-8")
+        dom = defusedxml.minidom.parseString(content)
+        xml_file.write_bytes(dom.toprettyxml(indent="  ", encoding="utf-8"))
+    except Exception:
+        pass  # Skip files that can't be parsed
+
+
+def _escape_smart_quotes(xml_file: Path) -> None:
+    """Replace smart quotes with XML entities so they survive tokenization."""
+    try:
+        content = xml_file.read_text(encoding="utf-8")
+        for char, entity in SMART_QUOTE_REPLACEMENTS.items():
+            content = content.replace(char, entity)
+        xml_file.write_text(content, encoding="utf-8")
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print("Usage: python unpack.py <pptx_file> <output_dir>", file=sys.stderr)
+        sys.exit(1)
+
+    unpack(sys.argv[1], sys.argv[2])