@_vrsen/openswarm 0.1.0

package/slides_agent/tools/RearrangePptxSlidesFromTemplate.py

@@ -0,0 +1,114 @@
+"""Rearrange PowerPoint slides based on a sequence of indices."""
+
+import sys
+from pathlib import Path
+from typing import List, Union
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+# Add pptx/scripts to path for rearrange module
+PPTX_SCRIPTS_DIR = Path(__file__).parent.parent / "pptx" / "scripts"
+sys.path.insert(0, str(PPTX_SCRIPTS_DIR))
+
+
+class RearrangePptxSlidesFromTemplate(BaseTool):
+    """
+    Build a new presentation from a template by duplicating and reordering slides.
+
+    Takes a template PPTX and a sequence of 0-based slide indices, then creates
+    a new presentation with slides in the specified order. The same slide index
+    can appear multiple times to duplicate that slide.
+
+    Example: slide_sequence=[0, 5, 5, 12, 3] creates a 5-slide deck using
+    slides 0, 5 (twice), 12, and 3 from the template.
+    """
+
+    template_pptx: str = Field(
+        ...,
+        description="Path to the template PowerPoint file (.pptx)",
+    )
+    output_pptx: str = Field(
+        ...,
+        description="Path where the rearranged presentation will be saved",
+    )
+    slide_sequence: Union[str, List[int]] = Field(
+        ...,
+        description="Comma-separated string or list of 0-based slide indices (e.g., '0,5,5,12,3' or [0,5,5,12,3])",
+    )
+    overwrite: bool = Field(
+        default=False,
+        description=(
+            "If False, return an error when the output PPTX already exists. "
+            "If True, overwrite the existing file."
+        ),
+    )
+
+    def run(self) -> str:
+        """Rearrange slides and save the new presentation."""
+        import sys
+        from pathlib import Path as PathLib
+        
+        # Add pptx/scripts to path for rearrange import
+        scripts_dir = PathLib(__file__).parent.parent / "pptx" / "scripts"
+        if str(scripts_dir) not in sys.path:
+            sys.path.insert(0, str(scripts_dir))
+        
+        from rearrange import rearrange_presentation  # type: ignore
+
+        template_path = Path(self.template_pptx)
+        output_path = Path(self.output_pptx)
+
+        # Validate template exists
+        if not template_path.exists():
+            return f"Error: Template file not found: {self.template_pptx}"
+        if template_path.suffix.lower() != ".pptx":
+            return f"Error: Template must be a PowerPoint file (.pptx), got: {template_path.suffix}"
+
+        # Parse slide sequence
+        if isinstance(self.slide_sequence, str):
+            try:
+                sequence = [int(x.strip()) for x in self.slide_sequence.split(",")]
+            except ValueError:
+                return "Error: Invalid sequence format. Use comma-separated integers (e.g., '0,5,5,12,3')"
+        else:
+            sequence = list(self.slide_sequence)
+
+        if not sequence:
+            return "Error: Slide sequence cannot be empty"
+
+        # Ensure output directory exists
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        if output_path.exists() and not self.overwrite:
+            return (
+                "Error: Output file already exists. "
+                "Set overwrite=True to replace it or add a postfix to the filename."
+            )
+
+        # Rearrange presentation
+        try:
+            rearrange_presentation(template_path, output_path, sequence)
+            return (
+                f"Presentation saved to: {output_path}\n"
+                f"Created {len(sequence)} slides from template"
+            )
+        except ValueError as e:
+            return f"Error: {e}"
+
+
+if __name__ == "__main__":
+    # Test with a sample file if available
+    import tempfile
+
+    test_pptx = Path(__file__).parent.parent / "files" / "test.pptx"
+    if test_pptx.exists():
+        with tempfile.NamedTemporaryFile(suffix=".pptx", delete=False) as f:
+            tool = RearrangePptxSlidesFromTemplate(
+                template_pptx=str(test_pptx),
+                output_pptx=f.name,
+                slide_sequence="0,0,0",  # Duplicate first slide 3 times
+            )
+            print(tool.run())
+    else:
+        print(f"Test file not found: {test_pptx}")
+        print("Tool definition is valid.")

package/slides_agent/tools/RestoreSnapshot.py

@@ -0,0 +1,89 @@
+"""Restore HTML slides from a PPTX export snapshot."""
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from .slide_file_utils import get_project_dir, restore_snapshot_html
+
+
+class RestoreSnapshot(BaseTool):
+    """
+    Restore the working HTML slides from a previous PPTX export snapshot.
+
+    Every time BuildPptxFromHtmlSlides runs it saves a self-contained snapshot
+    of the slide HTML alongside the PPTX:
+
+        my_deck.pptx
+        my_deck.pptx.slides/
+            1.html
+            2.html
+            …
+
+    Use this tool to roll back the working slides in a project to the state
+    captured in any previous export.  The tool:
+
+    1. Reads each numbered HTML file from the snapshot directory.
+    2. Extracts the inlined ``_theme.css`` back to disk so the theme is
+       available for future edits.
+    3. Writes the restored ``slide_01.html``, ``slide_02.html``, … files into
+       the project directory, ready to work with.
+
+    To see which exports are available, list *.pptx files in the project folder.
+    """
+
+    project_name: str = Field(
+        ...,
+        description="Presentation project folder name (e.g. 'my_pitch')",
+    )
+    pptx_filename: str = Field(
+        ...,
+        description=(
+            "Filename of the PPTX export to restore from, e.g. 'my_deck.pptx' "
+            "or 'my_deck_v2.pptx'. The file must exist in the project folder."
+        ),
+    )
+
+    def run(self) -> str:
+        project_dir = get_project_dir(self.project_name)
+        pptx_name = self.pptx_filename if self.pptx_filename.endswith(".pptx") else f"{self.pptx_filename}.pptx"
+        slides_dir = project_dir / f"{pptx_name}.slides"
+
+        if not slides_dir.exists():
+            available = sorted(p.name for p in project_dir.glob("*.pptx.slides") if p.is_dir())
+            hint = (
+                "\nAvailable snapshots:\n" + "\n".join(f"  {d}" for d in available)
+                if available else "\nNo snapshots found in this project."
+            )
+            return f"Error: No snapshot found for '{pptx_name}'.{hint}"
+
+        snapshot_files = sorted(
+            [p for p in slides_dir.glob("*.html") if p.stem.isdigit()],
+            key=lambda p: int(p.stem),
+        )
+        if not snapshot_files:
+            return "Error: Snapshot directory is empty"
+
+        pad_width = max(2, len(str(len(snapshot_files))))
+        css_written = False
+        restored_slides: list[str] = []
+
+        for i, snapshot in enumerate(snapshot_files, start=1):
+            html = snapshot.read_text(encoding="utf-8")
+            restored_html, css_files = restore_snapshot_html(html)
+
+            if not css_written and css_files:
+                for filename, css in css_files.items():
+                    (project_dir / filename).write_text(css, encoding="utf-8")
+                css_written = True
+
+            slide_name = f"slide_{i:0{pad_width}d}.html"
+            (project_dir / slide_name).write_text(restored_html, encoding="utf-8")
+            restored_slides.append(slide_name)
+
+        summary = "\n".join(f"  {s}" for s in restored_slides)
+        return (
+            f"Restored {len(restored_slides)} slide(s) to {project_dir}:\n{summary}"
+        )
+
+if __name__ == "__main__":
+    tool = RestoreSnapshot(project_name="dinosaur_presentation_v2", pptx_filename="dinosaur_presentation_v2.pptx")
+    print(tool.run())

package/slides_agent/tools/SlideScreenshot.py

@@ -0,0 +1,66 @@
+"""Render a slide to an image attachment."""
+
+from __future__ import annotations
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from .CheckSlide import CheckSlide
+from .slide_file_utils import get_project_dir, list_slide_files
+
+
+class SlideScreenshot(BaseTool):
+    """
+    Render a single HTML slide from a project to an image attachment.
+    Cannot be ran in parallel with other tools.
+    """
+
+    project_name: str = Field(
+        ...,
+        description="Project folder name",
+    )
+    slide_name: str = Field(
+        ...,
+        description="Slide filename (e.g., 'slide_01_title' or 'slide_01_title.html')",
+    )
+    slide_index: int | None = Field(
+        default=None,
+        description="Optional 1-based slide index to render using project slide order",
+    )
+    output_image_path: str | None = Field(
+        default=None,
+        description="Optional output image path (.jpg)",
+    )
+    layout: str = Field(
+        default="LAYOUT_16x9_1280",
+        description="Layout for HTML slides",
+    )
+
+    class ToolConfig:
+        one_call_at_a_time: bool = True
+
+    def run(self):
+        project_dir = get_project_dir(self.project_name)
+        slide_path = None
+        if self.slide_index is not None:
+            slides = list_slide_files(project_dir)
+            if self.slide_index < 1 or self.slide_index > len(slides):
+                return f"Error: slide_index out of range (1-{len(slides)})"
+            slide_path = slides[self.slide_index - 1].path
+        else:
+            slide_name = self.slide_name if self.slide_name.endswith(".html") else f"{self.slide_name}.html"
+            slide_path = project_dir / slide_name
+        if not slide_path.exists():
+            return f"Error: Slide not found at {slide_path}"
+
+        tool = CheckSlide(
+            slide_path=str(slide_path),
+            output_image_path=self.output_image_path,
+            layout=self.layout,
+        )
+        return tool.run()
+
+
+if __name__ == "__main__":
+    tool = SlideScreenshot(project_name="claude_cowork_deck", slide_name="slide_01_title", output_image_path="test.jpg")
+    print(tool.run())

package/slides_agent/tools/__init__.py

@@ -0,0 +1,54 @@
+"""Tools for the slides_agent."""
+
+# Slide creation and management: InsertNewSlides then ModifySlide
+from .InsertNewSlides import InsertNewSlides
+from .ModifySlide import ModifySlide
+from .ManageTheme import ManageTheme
+from .DeleteSlide import DeleteSlide
+from .SlideScreenshot import SlideScreenshot
+from .ReadSlide import ReadSlide
+
+# PPTX building and validation
+from .BuildPptxFromHtmlSlides import BuildPptxFromHtmlSlides
+from .RestoreSnapshot import RestoreSnapshot
+from .CreatePptxThumbnailGrid import CreatePptxThumbnailGrid
+from .CheckSlideCanvasOverflow import CheckSlideCanvasOverflow
+from .CheckSlide import CheckSlide
+
+# Template-based editing (for existing PPTX files)
+from .ExtractPptxTextInventory import ExtractPptxTextInventory
+from .RearrangePptxSlidesFromTemplate import RearrangePptxSlidesFromTemplate
+from .ApplyPptxTextReplacements import ApplyPptxTextReplacements
+
+# Asset utilities
+from .EnsureRasterImage import EnsureRasterImage
+from .CreateImageMontage import CreateImageMontage
+from .DownloadImage import DownloadImage
+from .ImageSearch import ImageSearch
+from .GenerateImage import GenerateImage
+
+__all__ = [
+    # Slide management
+    "InsertNewSlides",
+    "ModifySlide",
+    "ManageTheme",
+    "DeleteSlide",
+    "SlideScreenshot",
+    "ReadSlide",
+    # PPTX building
+    "BuildPptxFromHtmlSlides",
+    "RestoreSnapshot",
+    "CreatePptxThumbnailGrid",
+    "CheckSlideCanvasOverflow",
+    "CheckSlide",
+    # Template editing
+    "ExtractPptxTextInventory",
+    "RearrangePptxSlidesFromTemplate",
+    "ApplyPptxTextReplacements",
+    # Assets
+    "EnsureRasterImage",
+    "CreateImageMontage",
+    "DownloadImage",
+    "ImageSearch",
+    "GenerateImage",
+]

package/slides_agent/tools/deck_utils.py

@@ -0,0 +1,31 @@
+"""Utilities for slides_agent test deck."""
+
+from pathlib import Path
+import shutil
+
+from .slide_file_utils import get_project_dir
+
+
+def test_deck_dir() -> Path:
+    return Path(__file__).resolve().parents[1] / "test_deck"
+
+
+def test_project_dir(project_name: str) -> Path:
+    return get_project_dir(project_name)
+
+
+def load_theme_css() -> str:
+    return (test_deck_dir() / "_theme.css").read_text(encoding="utf-8")
+
+
+def load_slide_body(slide_name: str) -> str:
+    return (test_deck_dir() / f"{slide_name}.html").read_text(encoding="utf-8")
+
+
+def ensure_assets(project_name: str) -> None:
+    assets_src = test_deck_dir() / "assets"
+    assets_dst = test_project_dir(project_name) / "assets"
+    assets_dst.mkdir(parents=True, exist_ok=True)
+    for asset in assets_src.iterdir():
+        if asset.is_file():
+            shutil.copy2(asset, assets_dst / asset.name)