@_vrsen/openswarm 0.1.0

package/slides_agent/tools/CheckSlideCanvasOverflow.py

@@ -0,0 +1,221 @@
+"""Check for content overflowing the slide canvas boundaries."""
+
+import os
+import subprocess
+import sys
+import tempfile
+from copy import deepcopy
+from pathlib import Path
+from typing import List, Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+# Add slides directory to path for render_slides module
+SLIDES_DIR = Path(__file__).parent.parent.parent / "slides"
+sys.path.insert(0, str(SLIDES_DIR))
+
+
+class CheckSlideCanvasOverflow(BaseTool):
+    """
+    Detect slides with content overflowing the original canvas boundaries.
+
+    This tool works by:
+    1. Adding grey padding around each slide
+    2. Rendering the padded presentation to images
+    3. Inspecting the padding margins for non-grey pixels
+
+    If content extends beyond the original slide boundaries, it will appear
+    in the padding area and be detected as overflow.
+
+    Returns a list of failing slide indices (1-based) and paths to debug
+    images showing the overflow.
+
+    Requires: LibreOffice (soffice) and pdf2image Python package.
+    """
+
+    input_pptx: str = Field(
+        ...,
+        description="Path to the input PowerPoint file (.pptx)",
+    )
+    max_width_px: int = Field(
+        default=1600,
+        description="Maximum width in pixels for rendered images (default 1600)",
+    )
+    max_height_px: int = Field(
+        default=900,
+        description="Maximum height in pixels for rendered images (default 900)",
+    )
+    pad_px: int = Field(
+        default=100,
+        description="Padding in pixels to add on each side (default 100)",
+    )
+
+    def run(self) -> str:
+        """Check for canvas overflow and return results."""
+        input_path = Path(self.input_pptx)
+
+        # Validate input
+        if not input_path.exists():
+            return f"Error: Input file not found: {self.input_pptx}"
+        if input_path.suffix.lower() != ".pptx":
+            return f"Error: Input must be a PowerPoint file (.pptx), got: {input_path.suffix}"
+
+        # Check for required external tools
+        if not self._check_soffice():
+            return "Error: LibreOffice (soffice) not found. Please install LibreOffice."
+
+        try:
+            import numpy as np
+            from pdf2image import convert_from_path
+            from PIL import Image
+            from pptx import Presentation
+            from pptx.dml.color import RGBColor
+            from pptx.enum.shapes import MSO_AUTO_SHAPE_TYPE
+            from pptx.util import Emu
+        except ImportError as e:
+            return f"Error: Missing required package: {e}"
+
+        # Import render_slides for DPI calculation
+        try:
+            import render_slides
+        except ImportError:
+            return "Error: Could not import render_slides module"
+
+        # Constants
+        EMU_PER_INCH = 914_400
+        PAD_RGB = (200, 200, 200)
+
+        def px_to_emu(px: int, dpi: int) -> Emu:
+            return Emu(int(px * EMU_PER_INCH // dpi))
+
+        # Calculate DPI
+        try:
+            dpi = render_slides.calc_dpi_via_ooxml(
+                str(input_path), self.max_width_px, self.max_height_px
+            )
+        except Exception as e:
+            return f"Error calculating DPI: {e}"
+
+        # Create temporary directory for work
+        tmpdir = tempfile.mkdtemp(prefix="overflow_check_")
+        enlarged_pptx = Path(tmpdir) / "enlarged.pptx"
+
+        try:
+            # Enlarge the deck with padding
+            prs = Presentation(str(input_path))
+            w0 = prs.slide_width
+            h0 = prs.slide_height
+            pad_emu = px_to_emu(self.pad_px, dpi)
+            w1 = Emu(w0 + 2 * pad_emu)
+            h1 = Emu(h0 + 2 * pad_emu)
+            prs.slide_width = w1
+            prs.slide_height = h1
+
+            for slide in prs.slides:
+                # Shift all shapes
+                for shp in list(slide.shapes):
+                    shp.left = Emu(int(shp.left) + pad_emu)
+                    shp.top = Emu(int(shp.top) + pad_emu)
+
+                # Add padding rectangles
+                pads = (
+                    (Emu(0), Emu(0), pad_emu, h1),  # left
+                    (Emu(int(w1) - int(pad_emu)), Emu(0), pad_emu, h1),  # right
+                    (Emu(0), Emu(0), w1, pad_emu),  # top
+                    (Emu(0), Emu(int(h1) - int(pad_emu)), w1, pad_emu),  # bottom
+                )
+
+                sp_tree = slide.shapes._spTree
+
+                for left, top, width, height in pads:
+                    pad_shape = slide.shapes.add_shape(
+                        MSO_AUTO_SHAPE_TYPE.RECTANGLE, left, top, width, height
+                    )
+                    pad_shape.fill.solid()
+                    pad_shape.fill.fore_color.rgb = RGBColor(*PAD_RGB)
+                    pad_shape.line.fill.background()
+                    sp_tree.remove(pad_shape._element)
+                    sp_tree.insert(2, pad_shape._element)
+
+            prs.save(str(enlarged_pptx))
+
+            # Render to images
+            img_paths = render_slides.rasterize(str(enlarged_pptx), str(Path(tmpdir) / "imgs"), dpi)
+
+            # Calculate padding ratios
+            pad_ratio_w = pad_emu / w1
+            pad_ratio_h = pad_emu / h1
+
+            # Inspect images for overflow
+            tol = max(1, round((300 - dpi) / 25)) if dpi < 300 else 0
+            tol = min(tol, 10)
+            pad_colour = np.array(PAD_RGB, dtype=np.uint8)
+            failures = []
+
+            for idx, img_path in enumerate(img_paths, start=1):
+                with Image.open(img_path) as img:
+                    rgb = img.convert("RGB")
+                    arr = np.asarray(rgb)
+
+                h, w, _ = arr.shape
+                pad_x = int(w * pad_ratio_w) - 1
+                pad_y = int(h * pad_ratio_h) - 1
+
+                margins = [
+                    arr[:, :pad_x, :],  # left
+                    arr[:, w - pad_x:, :],  # right
+                    arr[:pad_y, :, :],  # top
+                    arr[h - pad_y:, :, :],  # bottom
+                ]
+
+                def is_clean(margin):
+                    diff = np.abs(margin.astype(np.int16) - pad_colour)
+                    matches = np.all(diff <= tol, axis=-1)
+                    mismatch_fraction = 1.0 - (np.count_nonzero(matches) / matches.size)
+                    max_mismatch = 0.01 if dpi >= 300 else (0.02 if dpi >= 200 else 0.03)
+                    return mismatch_fraction <= max_mismatch
+
+                if not all(is_clean(m) for m in margins):
+                    failures.append((idx, img_path))
+
+            if failures:
+                result = f"OVERFLOW DETECTED on {len(failures)} slide(s):\n"
+                for idx, img_path in failures:
+                    result += f"  - Slide {idx}: {img_path}\n"
+                result += "\nDebug images show grey padding with overflow content visible."
+                return result
+            else:
+                return "No overflow detected. All slides are within canvas boundaries."
+
+        except Exception as e:
+            return f"Error checking overflow: {e}"
+
+    def _check_soffice(self) -> bool:
+        """Check if LibreOffice is available."""
+        try:
+            kwargs = {
+                "capture_output": True,
+                "timeout": 15,
+                "text": True,
+                "input": "\n",
+            }
+            if os.name == "nt":
+                kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+
+            soffice_bin = "soffice.com" if os.name == "nt" else "soffice"
+            subprocess.run([soffice_bin, "--version"], **kwargs)
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+
+if __name__ == "__main__":
+    # Test with a sample file if available
+    test_pptx = Path(__file__).parent.parent / "files" / "test.pptx"
+    if test_pptx.exists():
+        tool = CheckSlideCanvasOverflow(input_pptx=str(test_pptx))
+        print(tool.run())
+    else:
+        print(f"Test file not found: {test_pptx}")
+        print("Tool definition is valid.")

package/slides_agent/tools/CreateImageMontage.py

@@ -0,0 +1,261 @@
+"""Create labeled montage images from a collection of images."""
+
+import re
+import tempfile
+from math import ceil
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Literal, Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+if TYPE_CHECKING:
+    from PIL import Image
+
+# Supported image extensions (same as EnsureRasterImage)
+RASTER_EXTS = {".png", ".jpg", ".jpeg", ".bmp", ".gif", ".tif", ".tiff", ".webp"}
+CONVERTIBLE_EXTS = {
+    ".emf", ".wmf", ".emz", ".wmz",
+    ".svg", ".svgz",
+    ".wdp", ".jxr",
+    ".heic", ".heif",
+    ".pdf", ".eps", ".ps",
+}
+SUPPORTED_EXTS = RASTER_EXTS | CONVERTIBLE_EXTS
+
+
+class CreateImageMontage(BaseTool):
+    """
+    Create a labeled montage image from a collection of images.
+
+    Arranges images in a grid layout with optional labels (numbers or filenames).
+    Useful for:
+    - Reviewing slide images extracted from presentations
+    - Comparing multiple versions of assets
+    - Creating visual indexes of image collections
+
+    Non-raster formats (SVG, EMF, etc.) are automatically converted to PNG
+    before inclusion in the montage.
+    """
+
+    input_files: Optional[List[str]] = Field(
+        default=None,
+        description="List of image file paths (mutually exclusive with input_dir)",
+    )
+    input_dir: Optional[str] = Field(
+        default=None,
+        description="Directory containing images (mutually exclusive with input_files)",
+    )
+    output_file: str = Field(
+        ...,
+        description="Path for the output montage image",
+    )
+    num_col: int = Field(
+        default=5,
+        description="Number of columns in the grid (default 5)",
+    )
+    cell_width: int = Field(
+        default=400,
+        description="Width of each cell in pixels (default 400)",
+    )
+    cell_height: int = Field(
+        default=225,
+        description="Height of each cell in pixels (default 225)",
+    )
+    gap: int = Field(
+        default=16,
+        description="Gap between cells in pixels (default 16)",
+    )
+    label_mode: Literal["number", "filename", "none"] = Field(
+        default="number",
+        description="Label mode: 'number' (1-based index), 'filename', or 'none'",
+    )
+
+    def run(self) -> str:
+        """Create the montage and return the output path."""
+        try:
+            from PIL import Image, ImageDraw, ImageFont, ImageOps
+        except ImportError:
+            return "Error: PIL/Pillow not installed"
+
+        # Validate inputs
+        if self.input_files and self.input_dir:
+            return "Error: Specify either input_files or input_dir, not both"
+        if not self.input_files and not self.input_dir:
+            return "Error: Must specify either input_files or input_dir"
+
+        # Gather input files
+        if self.input_files:
+            input_paths = [Path(f) for f in self.input_files]
+            for p in input_paths:
+                if not p.exists():
+                    return f"Error: File not found: {p}"
+        else:
+            input_dir = Path(self.input_dir)
+            if not input_dir.is_dir():
+                return f"Error: Directory not found: {self.input_dir}"
+            # Natural sort for proper ordering (slide-1, slide-2, ..., slide-10)
+            input_paths = sorted(
+                [p for p in input_dir.iterdir() if p.suffix.lower() in SUPPORTED_EXTS],
+                key=lambda p: self._natural_key(p.name)
+            )
+            if not input_paths:
+                return f"Error: No supported images found in {self.input_dir}"
+
+        # Validate parameters
+        if self.num_col <= 0:
+            return "Error: num_col must be positive"
+        if self.cell_width <= 0 or self.cell_height <= 0:
+            return "Error: cell_width and cell_height must be positive"
+
+        # Load images (converting non-raster formats as needed)
+        labels = [p.name for p in input_paths]
+        images = []
+        placeholder = None
+
+        with tempfile.TemporaryDirectory(prefix="montage_convert_") as tmp_dir:
+            for p in input_paths:
+                try:
+                    img_path = self._ensure_raster(p, tmp_dir)
+                    images.append(Image.open(img_path))
+                except Exception:
+                    pass
+                    images.append(None)
+
+        # Check we have at least one valid image
+        valid_count = sum(1 for img in images if img is not None)
+        if valid_count == 0:
+            return "Error: No valid images to render"
+
+        # Create placeholder for failed images
+        if valid_count < len(images):
+            placeholder = self._make_placeholder(
+                int(min(self.cell_width, self.cell_height) * 0.6)
+            )
+
+        # Calculate grid dimensions
+        cols = self.num_col
+        rows = ceil(len(images) / cols)
+
+        # Set up font
+        try:
+            font_size = max(12, min(36, int(self.cell_height * 0.12)))
+            font = ImageFont.truetype("arial.ttf", font_size)
+        except Exception:
+            font = ImageFont.load_default()
+            font_size = 12
+
+        # Calculate label height
+        draw_labels = self.label_mode != "none"
+        label_height = 0
+        if draw_labels:
+            temp_img = Image.new("RGB", (10, 10))
+            temp_draw = ImageDraw.Draw(temp_img)
+            sample = "1" if self.label_mode == "number" else "Ag"
+            bbox = temp_draw.textbbox((0, 0), sample, font=font)
+            label_height = ceil(bbox[3] - bbox[1]) + 6
+
+        row_h = self.cell_height + label_height
+        canvas_w = cols * self.cell_width + (cols + 1) * self.gap
+        canvas_h = rows * row_h + (rows + 1) * self.gap
+
+        # Create canvas
+        canvas = Image.new("RGB", (canvas_w, canvas_h), (242, 242, 242))
+        draw = ImageDraw.Draw(canvas)
+
+        # Place images
+        for idx, img in enumerate(images):
+            col = idx % cols
+            row = idx // cols
+            x0 = self.gap + col * (self.cell_width + self.gap)
+            y0 = self.gap + row * (row_h + self.gap)
+
+            # Prepare label
+            if self.label_mode == "number":
+                label = str(idx + 1)
+            elif self.label_mode == "filename":
+                label = labels[idx]
+            else:
+                label = ""
+
+            # Get image to display
+            if img is not None:
+                resized = ImageOps.contain(
+                    img.convert("RGBA"),
+                    (self.cell_width, self.cell_height),
+                    method=Image.Resampling.LANCZOS,
+                )
+            else:
+                resized = placeholder
+
+            # Calculate position
+            paste_x = x0 + (self.cell_width - resized.width) // 2
+            paste_y = y0 + (self.cell_height - resized.height) // 2
+
+            # Paste image
+            canvas.paste(
+                resized,
+                (paste_x, paste_y),
+                mask=resized.split()[3] if resized.mode == "RGBA" else None,
+            )
+
+            # Draw border
+            draw.rectangle(
+                [paste_x - 1, paste_y - 1, paste_x + resized.width, paste_y + resized.height],
+                outline=(160, 160, 160),
+                width=1,
+            )
+
+            # Draw label
+            if draw_labels and label:
+                bbox = draw.textbbox((0, 0), label, font=font)
+                text_w = bbox[2] - bbox[0]
+                tx = x0 + (self.cell_width - text_w) // 2
+                ty = y0 + self.cell_height + 3
+                draw.text((tx, ty), label, font=font, fill=(0, 0, 0))
+
+        # Save output
+        output_path = Path(self.output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        canvas.save(str(output_path))
+
+        return f"Montage saved to: {output_path}\n{len(images)} images in {rows}x{cols} grid"
+
+    def _natural_key(self, s: str) -> list:
+        """Key function for natural sorting (e.g., slide2 before slide10)."""
+        return [int(part) if part.isdigit() else part for part in re.split(r"(\d+)", s)]
+
+    def _make_placeholder(self, size: int) -> "Image.Image":
+        """Create a placeholder image for failed loads."""
+        from PIL import Image, ImageDraw
+
+        ph = Image.new("RGBA", (size, size), (220, 220, 220, 255))
+        draw = ImageDraw.Draw(ph)
+        draw.line([(0, 0), (size - 1, size - 1)], fill=(180, 0, 0, 255), width=3)
+        draw.line([(size - 1, 0), (0, size - 1)], fill=(180, 0, 0, 255), width=3)
+        return ph
+
+    def _ensure_raster(self, path: Path, tmp_dir: str) -> str:
+        """Ensure the image is in a raster format, converting if needed."""
+        ext = path.suffix.lower()
+        if ext in RASTER_EXTS:
+            return str(path)
+
+        # Use EnsureRasterImage tool logic for conversion
+        from .EnsureRasterImage import EnsureRasterImage
+
+        tool = EnsureRasterImage(input_path=str(path), output_dir=tmp_dir)
+        result = tool.run()
+
+        if result.startswith("Error"):
+            raise RuntimeError(result)
+
+        # Extract the output path from the result
+        if result.startswith("Converted to:"):
+            return result.replace("Converted to:", "").strip()
+        return str(path)
+
+
+if __name__ == "__main__":
+    print("CreateImageMontage tool definition is valid.")
+    print(f"Supported formats: {', '.join(sorted(SUPPORTED_EXTS))}")

package/slides_agent/tools/CreatePptxThumbnailGrid.py

@@ -0,0 +1,168 @@
+"""Create thumbnail grids from PowerPoint presentation slides."""
+
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+# Add pptx/scripts to path for thumbnail module
+PPTX_SCRIPTS_DIR = Path(__file__).parent.parent / "pptx" / "scripts"
+sys.path.insert(0, str(PPTX_SCRIPTS_DIR))
+
+
+class CreatePptxThumbnailGrid(BaseTool):
+    """
+    Create visual thumbnail grids from PowerPoint presentation slides.
+
+    Converts all slides to images and arranges them in a large, unlabeled grid layout.
+    Useful for:
+    - Template analysis: quickly understand slide layouts and design patterns
+    - Content review: visual overview of entire presentation
+    - Quality check: verify all slides are properly formatted
+    - Navigation reference: find specific slides by visual appearance
+
+    Grid limits by column count:
+    - 3 cols: max 12 slides per grid (3×4)
+    - 4 cols: max 20 slides per grid (4×5)
+    - 5 cols: max 30 slides per grid (5×6) [default]
+    - 6 cols: max 42 slides per grid (6×7)
+
+    For large presentations, multiple numbered grid files are created automatically.
+
+    Requires: LibreOffice (soffice) and Poppler (pdftoppm) to be installed.
+    """
+
+    input_pptx: str = Field(
+        ...,
+        description="Path to the input PowerPoint file (.pptx)",
+    )
+    output_prefix: str = Field(
+        default="thumbnails",
+        description="Output prefix for image files (creates prefix.jpg or prefix-N.jpg for multiple grids)",
+    )
+    cols: int = Field(
+        default=5,
+        description="Number of columns in the grid (1-6, default 5). Auto-reduces for small decks.",
+    )
+    outline_placeholders: bool = Field(
+        default=False,
+        description="If True, outline text placeholders with red borders for visibility",
+    )
+
+    def run(self) -> str:
+        """Create thumbnail grids and return list of generated files."""
+        input_path = Path(self.input_pptx)
+
+        # Validate input
+        if not input_path.exists():
+            return f"Error: Input file not found: {self.input_pptx}"
+        if input_path.suffix.lower() != ".pptx":
+            return f"Error: Input must be a PowerPoint file (.pptx), got: {input_path.suffix}"
+
+        # Check for required external tools
+        if not self._check_soffice():
+            return "Error: LibreOffice (soffice) not found. Please install LibreOffice."
+        if not self._check_pdftoppm():
+            return "Error: pdftoppm not found. Please install Poppler (poppler-utils)."
+
+        # Import and run thumbnail creation
+        from thumbnail import (  # type: ignore[import-not-found]
+            convert_to_images,
+            create_grids,
+            get_placeholder_regions,
+        )
+
+        prefix_path = Path(self.output_prefix)
+        if prefix_path.parent == Path("."):
+            prefix_path = input_path.parent / prefix_path.name
+        output_path = prefix_path.with_suffix(".jpg")
+
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                # Get placeholder regions if outlining is enabled
+                placeholder_regions = None
+                slide_dimensions = None
+                if self.outline_placeholders:
+                    placeholder_regions, slide_dimensions = get_placeholder_regions(
+                        input_path
+                    )
+
+                # Convert slides to images
+                slide_images = convert_to_images(input_path, Path(temp_dir), 100)
+                if not slide_images:
+                    return "Error: No slides found in presentation"
+
+                # Validate columns after slide count is known
+                cols = max(1, min(6, self.cols))
+                cols = min(cols, len(slide_images))
+                if cols != self.cols:
+                    pass
+
+                # Create grids
+                grid_files = create_grids(
+                    slide_images,
+                    cols,
+                    420,  # thumbnail width
+                    output_path,
+                    placeholder_regions,
+                    slide_dimensions,
+                )
+
+                return (
+                    f"Created {len(grid_files)} thumbnail grid(s):\n"
+                    + "\n".join(f"  - {f}" for f in grid_files)
+                )
+
+        except Exception as e:
+            return f"Error creating thumbnails: {e}"
+
+    def _check_soffice(self) -> bool:
+        """Check if LibreOffice is available."""
+        try:
+            kwargs = {
+                "capture_output": True,
+                "timeout": 15,
+                "text": True,
+                "input": "\n",
+            }
+            if os.name == "nt":
+                kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+
+            soffice_bin = "soffice.com" if os.name == "nt" else "soffice"
+            subprocess.run([soffice_bin, "--version"], **kwargs)
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    def _check_pdftoppm(self) -> bool:
+        """Check if pdftoppm is available."""
+        try:
+            kwargs = {
+                "capture_output": True,
+                "timeout": 5,
+                "stdin": subprocess.DEVNULL,
+            }
+            if os.name == "nt":
+                kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+
+            subprocess.run(["pdftoppm", "-v"], **kwargs)
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+
+if __name__ == "__main__":
+    # Test with a sample file if available
+    test_pptx = Path(__file__).parent.parent / "files" / "test.pptx"
+    if test_pptx.exists():
+        tool = CreatePptxThumbnailGrid(
+            input_pptx=str(test_pptx),
+            output_prefix="/tmp/test_thumbnails",
+        )
+        print(tool.run())
+    else:
+        print(f"Test file not found: {test_pptx}")
+        print("Tool definition is valid.")