port-nuker 1.0.1 → 1.0.4

package/.agent/skills/skills/pptx-official/scripts/rearrange.py

@@ -1,231 +0,0 @@
-#!/usr/bin/env python3
-"""
-Rearrange PowerPoint slides based on a sequence of indices.
-
-Usage:
-    python rearrange.py template.pptx output.pptx 0,34,34,50,52
-
-This will create output.pptx using slides from template.pptx in the specified order.
-Slides can be repeated (e.g., 34 appears twice).
-"""
-
-import argparse
-import shutil
-import sys
-from copy import deepcopy
-from pathlib import Path
-
-import six
-from pptx import Presentation
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Rearrange PowerPoint slides based on a sequence of indices.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  python rearrange.py template.pptx output.pptx 0,34,34,50,52
-    Creates output.pptx using slides 0, 34 (twice), 50, and 52 from template.pptx
-
-  python rearrange.py template.pptx output.pptx 5,3,1,2,4
-    Creates output.pptx with slides reordered as specified
-
-Note: Slide indices are 0-based (first slide is 0, second is 1, etc.)
-        """,
-    )
-
-    parser.add_argument("template", help="Path to template PPTX file")
-    parser.add_argument("output", help="Path for output PPTX file")
-    parser.add_argument(
-        "sequence", help="Comma-separated sequence of slide indices (0-based)"
-    )
-
-    args = parser.parse_args()
-
-    # Parse the slide sequence
-    try:
-        slide_sequence = [int(x.strip()) for x in args.sequence.split(",")]
-    except ValueError:
-        print(
-            "Error: Invalid sequence format. Use comma-separated integers (e.g., 0,34,34,50,52)"
-        )
-        sys.exit(1)
-
-    # Check template exists
-    template_path = Path(args.template)
-    if not template_path.exists():
-        print(f"Error: Template file not found: {args.template}")
-        sys.exit(1)
-
-    # Create output directory if needed
-    output_path = Path(args.output)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        rearrange_presentation(template_path, output_path, slide_sequence)
-    except ValueError as e:
-        print(f"Error: {e}")
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error processing presentation: {e}")
-        sys.exit(1)
-
-
-def duplicate_slide(pres, index):
-    """Duplicate a slide in the presentation."""
-    source = pres.slides[index]
-
-    # Use source's layout to preserve formatting
-    new_slide = pres.slides.add_slide(source.slide_layout)
-
-    # Collect all image and media relationships from the source slide
-    image_rels = {}
-    for rel_id, rel in six.iteritems(source.part.rels):
-        if "image" in rel.reltype or "media" in rel.reltype:
-            image_rels[rel_id] = rel
-
-    # CRITICAL: Clear placeholder shapes to avoid duplicates
-    for shape in new_slide.shapes:
-        sp = shape.element
-        sp.getparent().remove(sp)
-
-    # Copy all shapes from source
-    for shape in source.shapes:
-        el = shape.element
-        new_el = deepcopy(el)
-        new_slide.shapes._spTree.insert_element_before(new_el, "p:extLst")
-
-        # Handle picture shapes - need to update the blip reference
-        # Look for all blip elements (they can be in pic or other contexts)
-        # Using the element's own xpath method without namespaces argument
-        blips = new_el.xpath(".//a:blip[@r:embed]")
-        for blip in blips:
-            old_rId = blip.get(
-                "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}embed"
-            )
-            if old_rId in image_rels:
-                # Create a new relationship in the destination slide for this image
-                old_rel = image_rels[old_rId]
-                # get_or_add returns the rId directly, or adds and returns new rId
-                new_rId = new_slide.part.rels.get_or_add(
-                    old_rel.reltype, old_rel._target
-                )
-                # Update the blip's embed reference to use the new relationship ID
-                blip.set(
-                    "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}embed",
-                    new_rId,
-                )
-
-    # Copy any additional image/media relationships that might be referenced elsewhere
-    for rel_id, rel in image_rels.items():
-        try:
-            new_slide.part.rels.get_or_add(rel.reltype, rel._target)
-        except Exception:
-            pass  # Relationship might already exist
-
-    return new_slide
-
-
-def delete_slide(pres, index):
-    """Delete a slide from the presentation."""
-    rId = pres.slides._sldIdLst[index].rId
-    pres.part.drop_rel(rId)
-    del pres.slides._sldIdLst[index]
-
-
-def reorder_slides(pres, slide_index, target_index):
-    """Move a slide from one position to another."""
-    slides = pres.slides._sldIdLst
-
-    # Remove slide element from current position
-    slide_element = slides[slide_index]
-    slides.remove(slide_element)
-
-    # Insert at target position
-    slides.insert(target_index, slide_element)
-
-
-def rearrange_presentation(template_path, output_path, slide_sequence):
-    """
-    Create a new presentation with slides from template in specified order.
-
-    Args:
-        template_path: Path to template PPTX file
-        output_path: Path for output PPTX file
-        slide_sequence: List of slide indices (0-based) to include
-    """
-    # Copy template to preserve dimensions and theme
-    if template_path != output_path:
-        shutil.copy2(template_path, output_path)
-        prs = Presentation(output_path)
-    else:
-        prs = Presentation(template_path)
-
-    total_slides = len(prs.slides)
-
-    # Validate indices
-    for idx in slide_sequence:
-        if idx < 0 or idx >= total_slides:
-            raise ValueError(f"Slide index {idx} out of range (0-{total_slides - 1})")
-
-    # Track original slides and their duplicates
-    slide_map = []  # List of actual slide indices for final presentation
-    duplicated = {}  # Track duplicates: original_idx -> [duplicate_indices]
-
-    # Step 1: DUPLICATE repeated slides
-    print(f"Processing {len(slide_sequence)} slides from template...")
-    for i, template_idx in enumerate(slide_sequence):
-        if template_idx in duplicated and duplicated[template_idx]:
-            # Already duplicated this slide, use the duplicate
-            slide_map.append(duplicated[template_idx].pop(0))
-            print(f"  [{i}] Using duplicate of slide {template_idx}")
-        elif slide_sequence.count(template_idx) > 1 and template_idx not in duplicated:
-            # First occurrence of a repeated slide - create duplicates
-            slide_map.append(template_idx)
-            duplicates = []
-            count = slide_sequence.count(template_idx) - 1
-            print(
-                f"  [{i}] Using original slide {template_idx}, creating {count} duplicate(s)"
-            )
-            for _ in range(count):
-                duplicate_slide(prs, template_idx)
-                duplicates.append(len(prs.slides) - 1)
-            duplicated[template_idx] = duplicates
-        else:
-            # Unique slide or first occurrence already handled, use original
-            slide_map.append(template_idx)
-            print(f"  [{i}] Using original slide {template_idx}")
-
-    # Step 2: DELETE unwanted slides (work backwards)
-    slides_to_keep = set(slide_map)
-    print(f"\nDeleting {len(prs.slides) - len(slides_to_keep)} unused slides...")
-    for i in range(len(prs.slides) - 1, -1, -1):
-        if i not in slides_to_keep:
-            delete_slide(prs, i)
-            # Update slide_map indices after deletion
-            slide_map = [idx - 1 if idx > i else idx for idx in slide_map]
-
-    # Step 3: REORDER to final sequence
-    print(f"Reordering {len(slide_map)} slides to final sequence...")
-    for target_pos in range(len(slide_map)):
-        # Find which slide should be at target_pos
-        current_pos = slide_map[target_pos]
-        if current_pos != target_pos:
-            reorder_slides(prs, current_pos, target_pos)
-            # Update slide_map: the move shifts other slides
-            for i in range(len(slide_map)):
-                if slide_map[i] > current_pos and slide_map[i] <= target_pos:
-                    slide_map[i] -= 1
-                elif slide_map[i] < current_pos and slide_map[i] >= target_pos:
-                    slide_map[i] += 1
-            slide_map[target_pos] = target_pos
-
-    # Save the presentation
-    prs.save(output_path)
-    print(f"\nSaved rearranged presentation to: {output_path}")
-    print(f"Final presentation has {len(prs.slides)} slides")
-
-
-if __name__ == "__main__":
-    main()

package/.agent/skills/skills/pptx-official/scripts/replace.py

@@ -1,385 +0,0 @@
-#!/usr/bin/env python3
-"""Apply text replacements to PowerPoint presentation.
-
-Usage:
-    python replace.py <input.pptx> <replacements.json> <output.pptx>
-
-The replacements JSON should have the structure output by inventory.py.
-ALL text shapes identified by inventory.py will have their text cleared
-unless "paragraphs" is specified in the replacements for that shape.
-"""
-
-import json
-import sys
-from pathlib import Path
-from typing import Any, Dict, List
-
-from inventory import InventoryData, extract_text_inventory
-from pptx import Presentation
-from pptx.dml.color import RGBColor
-from pptx.enum.dml import MSO_THEME_COLOR
-from pptx.enum.text import PP_ALIGN
-from pptx.oxml.xmlchemy import OxmlElement
-from pptx.util import Pt
-
-
-def clear_paragraph_bullets(paragraph):
-    """Clear bullet formatting from a paragraph."""
-    pPr = paragraph._element.get_or_add_pPr()
-
-    # Remove existing bullet elements
-    for child in list(pPr):
-        if (
-            child.tag.endswith("buChar")
-            or child.tag.endswith("buNone")
-            or child.tag.endswith("buAutoNum")
-            or child.tag.endswith("buFont")
-        ):
-            pPr.remove(child)
-
-    return pPr
-
-
-def apply_paragraph_properties(paragraph, para_data: Dict[str, Any]):
-    """Apply formatting properties to a paragraph."""
-    # Get the text but don't set it on paragraph directly yet
-    text = para_data.get("text", "")
-
-    # Get or create paragraph properties
-    pPr = clear_paragraph_bullets(paragraph)
-
-    # Handle bullet formatting
-    if para_data.get("bullet", False):
-        level = para_data.get("level", 0)
-        paragraph.level = level
-
-        # Calculate font-proportional indentation
-        font_size = para_data.get("font_size", 18.0)
-        level_indent_emu = int((font_size * (1.6 + level * 1.6)) * 12700)
-        hanging_indent_emu = int(-font_size * 0.8 * 12700)
-
-        # Set indentation
-        pPr.attrib["marL"] = str(level_indent_emu)
-        pPr.attrib["indent"] = str(hanging_indent_emu)
-
-        # Add bullet character
-        buChar = OxmlElement("a:buChar")
-        buChar.set("char", "•")
-        pPr.append(buChar)
-
-        # Default to left alignment for bullets if not specified
-        if "alignment" not in para_data:
-            paragraph.alignment = PP_ALIGN.LEFT
-    else:
-        # Remove indentation for non-bullet text
-        pPr.attrib["marL"] = "0"
-        pPr.attrib["indent"] = "0"
-
-        # Add buNone element
-        buNone = OxmlElement("a:buNone")
-        pPr.insert(0, buNone)
-
-    # Apply alignment
-    if "alignment" in para_data:
-        alignment_map = {
-            "LEFT": PP_ALIGN.LEFT,
-            "CENTER": PP_ALIGN.CENTER,
-            "RIGHT": PP_ALIGN.RIGHT,
-            "JUSTIFY": PP_ALIGN.JUSTIFY,
-        }
-        if para_data["alignment"] in alignment_map:
-            paragraph.alignment = alignment_map[para_data["alignment"]]
-
-    # Apply spacing
-    if "space_before" in para_data:
-        paragraph.space_before = Pt(para_data["space_before"])
-    if "space_after" in para_data:
-        paragraph.space_after = Pt(para_data["space_after"])
-    if "line_spacing" in para_data:
-        paragraph.line_spacing = Pt(para_data["line_spacing"])
-
-    # Apply run-level formatting
-    if not paragraph.runs:
-        run = paragraph.add_run()
-        run.text = text
-    else:
-        run = paragraph.runs[0]
-        run.text = text
-
-    # Apply font properties
-    apply_font_properties(run, para_data)
-
-
-def apply_font_properties(run, para_data: Dict[str, Any]):
-    """Apply font properties to a text run."""
-    if "bold" in para_data:
-        run.font.bold = para_data["bold"]
-    if "italic" in para_data:
-        run.font.italic = para_data["italic"]
-    if "underline" in para_data:
-        run.font.underline = para_data["underline"]
-    if "font_size" in para_data:
-        run.font.size = Pt(para_data["font_size"])
-    if "font_name" in para_data:
-        run.font.name = para_data["font_name"]
-
-    # Apply color - prefer RGB, fall back to theme_color
-    if "color" in para_data:
-        color_hex = para_data["color"].lstrip("#")
-        if len(color_hex) == 6:
-            r = int(color_hex[0:2], 16)
-            g = int(color_hex[2:4], 16)
-            b = int(color_hex[4:6], 16)
-            run.font.color.rgb = RGBColor(r, g, b)
-    elif "theme_color" in para_data:
-        # Get theme color by name (e.g., "DARK_1", "ACCENT_1")
-        theme_name = para_data["theme_color"]
-        try:
-            run.font.color.theme_color = getattr(MSO_THEME_COLOR, theme_name)
-        except AttributeError:
-            print(f"  WARNING: Unknown theme color name '{theme_name}'")
-
-
-def detect_frame_overflow(inventory: InventoryData) -> Dict[str, Dict[str, float]]:
-    """Detect text overflow in shapes (text exceeding shape bounds).
-
-    Returns dict of slide_key -> shape_key -> overflow_inches.
-    Only includes shapes that have text overflow.
-    """
-    overflow_map = {}
-
-    for slide_key, shapes_dict in inventory.items():
-        for shape_key, shape_data in shapes_dict.items():
-            # Check for frame overflow (text exceeding shape bounds)
-            if shape_data.frame_overflow_bottom is not None:
-                if slide_key not in overflow_map:
-                    overflow_map[slide_key] = {}
-                overflow_map[slide_key][shape_key] = shape_data.frame_overflow_bottom
-
-    return overflow_map
-
-
-def validate_replacements(inventory: InventoryData, replacements: Dict) -> List[str]:
-    """Validate that all shapes in replacements exist in inventory.
-
-    Returns list of error messages.
-    """
-    errors = []
-
-    for slide_key, shapes_data in replacements.items():
-        if not slide_key.startswith("slide-"):
-            continue
-
-        # Check if slide exists
-        if slide_key not in inventory:
-            errors.append(f"Slide '{slide_key}' not found in inventory")
-            continue
-
-        # Check each shape
-        for shape_key in shapes_data.keys():
-            if shape_key not in inventory[slide_key]:
-                # Find shapes without replacements defined and show their content
-                unused_with_content = []
-                for k in inventory[slide_key].keys():
-                    if k not in shapes_data:
-                        shape_data = inventory[slide_key][k]
-                        # Get text from paragraphs as preview
-                        paragraphs = shape_data.paragraphs
-                        if paragraphs and paragraphs[0].text:
-                            first_text = paragraphs[0].text[:50]
-                            if len(paragraphs[0].text) > 50:
-                                first_text += "..."
-                            unused_with_content.append(f"{k} ('{first_text}')")
-                        else:
-                            unused_with_content.append(k)
-
-                errors.append(
-                    f"Shape '{shape_key}' not found on '{slide_key}'. "
-                    f"Shapes without replacements: {', '.join(sorted(unused_with_content)) if unused_with_content else 'none'}"
-                )
-
-    return errors
-
-
-def check_duplicate_keys(pairs):
-    """Check for duplicate keys when loading JSON."""
-    result = {}
-    for key, value in pairs:
-        if key in result:
-            raise ValueError(f"Duplicate key found in JSON: '{key}'")
-        result[key] = value
-    return result
-
-
-def apply_replacements(pptx_file: str, json_file: str, output_file: str):
-    """Apply text replacements from JSON to PowerPoint presentation."""
-
-    # Load presentation
-    prs = Presentation(pptx_file)
-
-    # Get inventory of all text shapes (returns ShapeData objects)
-    # Pass prs to use same Presentation instance
-    inventory = extract_text_inventory(Path(pptx_file), prs)
-
-    # Detect text overflow in original presentation
-    original_overflow = detect_frame_overflow(inventory)
-
-    # Load replacement data with duplicate key detection
-    with open(json_file, "r") as f:
-        replacements = json.load(f, object_pairs_hook=check_duplicate_keys)
-
-    # Validate replacements
-    errors = validate_replacements(inventory, replacements)
-    if errors:
-        print("ERROR: Invalid shapes in replacement JSON:")
-        for error in errors:
-            print(f"  - {error}")
-        print("\nPlease check the inventory and update your replacement JSON.")
-        print(
-            "You can regenerate the inventory with: python inventory.py <input.pptx> <output.json>"
-        )
-        raise ValueError(f"Found {len(errors)} validation error(s)")
-
-    # Track statistics
-    shapes_processed = 0
-    shapes_cleared = 0
-    shapes_replaced = 0
-
-    # Process each slide from inventory
-    for slide_key, shapes_dict in inventory.items():
-        if not slide_key.startswith("slide-"):
-            continue
-
-        slide_index = int(slide_key.split("-")[1])
-
-        if slide_index >= len(prs.slides):
-            print(f"Warning: Slide {slide_index} not found")
-            continue
-
-        # Process each shape from inventory
-        for shape_key, shape_data in shapes_dict.items():
-            shapes_processed += 1
-
-            # Get the shape directly from ShapeData
-            shape = shape_data.shape
-            if not shape:
-                print(f"Warning: {shape_key} has no shape reference")
-                continue
-
-            # ShapeData already validates text_frame in __init__
-            text_frame = shape.text_frame  # type: ignore
-
-            text_frame.clear()  # type: ignore
-            shapes_cleared += 1
-
-            # Check for replacement paragraphs
-            replacement_shape_data = replacements.get(slide_key, {}).get(shape_key, {})
-            if "paragraphs" not in replacement_shape_data:
-                continue
-
-            shapes_replaced += 1
-
-            # Add replacement paragraphs
-            for i, para_data in enumerate(replacement_shape_data["paragraphs"]):
-                if i == 0:
-                    p = text_frame.paragraphs[0]  # type: ignore
-                else:
-                    p = text_frame.add_paragraph()  # type: ignore
-
-                apply_paragraph_properties(p, para_data)
-
-    # Check for issues after replacements
-    # Save to a temporary file and reload to avoid modifying the presentation during inventory
-    # (extract_text_inventory accesses font.color which adds empty <a:solidFill/> elements)
-    import tempfile
-
-    with tempfile.NamedTemporaryFile(suffix=".pptx", delete=False) as tmp:
-        tmp_path = Path(tmp.name)
-        prs.save(str(tmp_path))
-
-    try:
-        updated_inventory = extract_text_inventory(tmp_path)
-        updated_overflow = detect_frame_overflow(updated_inventory)
-    finally:
-        tmp_path.unlink()  # Clean up temp file
-
-    # Check if any text overflow got worse
-    overflow_errors = []
-    for slide_key, shape_overflows in updated_overflow.items():
-        for shape_key, new_overflow in shape_overflows.items():
-            # Get original overflow (0 if there was no overflow before)
-            original = original_overflow.get(slide_key, {}).get(shape_key, 0.0)
-
-            # Error if overflow increased
-            if new_overflow > original + 0.01:  # Small tolerance for rounding
-                increase = new_overflow - original
-                overflow_errors.append(
-                    f'{slide_key}/{shape_key}: overflow worsened by {increase:.2f}" '
-                    f'(was {original:.2f}", now {new_overflow:.2f}")'
-                )
-
-    # Collect warnings from updated shapes
-    warnings = []
-    for slide_key, shapes_dict in updated_inventory.items():
-        for shape_key, shape_data in shapes_dict.items():
-            if shape_data.warnings:
-                for warning in shape_data.warnings:
-                    warnings.append(f"{slide_key}/{shape_key}: {warning}")
-
-    # Fail if there are any issues
-    if overflow_errors or warnings:
-        print("\nERROR: Issues detected in replacement output:")
-        if overflow_errors:
-            print("\nText overflow worsened:")
-            for error in overflow_errors:
-                print(f"  - {error}")
-        if warnings:
-            print("\nFormatting warnings:")
-            for warning in warnings:
-                print(f"  - {warning}")
-        print("\nPlease fix these issues before saving.")
-        raise ValueError(
-            f"Found {len(overflow_errors)} overflow error(s) and {len(warnings)} warning(s)"
-        )
-
-    # Save the presentation
-    prs.save(output_file)
-
-    # Report results
-    print(f"Saved updated presentation to: {output_file}")
-    print(f"Processed {len(prs.slides)} slides")
-    print(f"  - Shapes processed: {shapes_processed}")
-    print(f"  - Shapes cleared: {shapes_cleared}")
-    print(f"  - Shapes replaced: {shapes_replaced}")
-
-
-def main():
-    """Main entry point for command-line usage."""
-    if len(sys.argv) != 4:
-        print(__doc__)
-        sys.exit(1)
-
-    input_pptx = Path(sys.argv[1])
-    replacements_json = Path(sys.argv[2])
-    output_pptx = Path(sys.argv[3])
-
-    if not input_pptx.exists():
-        print(f"Error: Input file '{input_pptx}' not found")
-        sys.exit(1)
-
-    if not replacements_json.exists():
-        print(f"Error: Replacements JSON file '{replacements_json}' not found")
-        sys.exit(1)
-
-    try:
-        apply_replacements(str(input_pptx), str(replacements_json), str(output_pptx))
-    except Exception as e:
-        print(f"Error applying replacements: {e}")
-        import traceback
-
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()