@_vrsen/openswarm 0.1.0

package/slides_agent/test_deck/slide_03_kpi.html

@@ -0,0 +1,21 @@
+<div class="canvas">
+  <div class="title-block">
+    <p class="kicker">METRICS</p>
+    <h2>KPI layout with three cards</h2>
+    <p class="small">Use big numbers and short labels for fast scanning.</p>
+  </div>
+  <div class="kpi-row">
+    <div class="kpi-card">
+      <p class="kpi-value">3.2x</p>
+      <p class="kpi-label">Faster turnaround</p>
+    </div>
+    <div class="kpi-card">
+      <p class="kpi-value">18%</p>
+      <p class="kpi-label">Lower review time</p>
+    </div>
+    <div class="kpi-card">
+      <p class="kpi-value">92</p>
+      <p class="kpi-label">Quality score</p>
+    </div>
+  </div>
+</div>

package/slides_agent/tools/ApplyPptxTextReplacements.py

@@ -0,0 +1,91 @@
+"""Apply text replacements to a PowerPoint presentation."""
+
+import sys
+from pathlib import Path
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+# Add pptx/scripts to path for replace module
+PPTX_SCRIPTS_DIR = Path(__file__).parent.parent / "pptx" / "scripts"
+sys.path.insert(0, str(PPTX_SCRIPTS_DIR))
+
+
+class ApplyPptxTextReplacements(BaseTool):
+    """
+    Apply text replacements to shapes in a PowerPoint presentation.
+
+    Takes a PPTX file and a JSON file containing replacement paragraphs,
+    then applies the replacements while preserving formatting. All text
+    shapes identified in the inventory will have their text cleared unless
+    "paragraphs" is specified for that shape in the replacements JSON.
+
+    The replacements JSON should follow the structure from ExtractPptxTextInventory:
+    {
+        "slide-0": {
+            "shape-0": {
+                "paragraphs": [
+                    {"text": "New title", "bold": true, "alignment": "CENTER"},
+                    {"text": "Bullet point", "bullet": true, "level": 0}
+                ]
+            }
+        }
+    }
+
+    The tool validates that:
+    - All referenced shapes exist in the presentation
+    - Text overflow does not worsen after replacements
+    - No bullet formatting warnings are triggered
+    """
+
+    input_pptx: str = Field(
+        ...,
+        description="Path to the input PowerPoint file (.pptx)",
+    )
+    replacements_json: str = Field(
+        ...,
+        description="Path to the JSON file containing replacement paragraphs",
+    )
+    output_pptx: str = Field(
+        ...,
+        description="Path where the updated presentation will be saved",
+    )
+
+    def run(self) -> str:
+        """Apply replacements and save the updated presentation."""
+        import sys
+        from pathlib import Path as PathLib
+        
+        # Add pptx/scripts to path for replace 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 replace import apply_replacements  # type: ignore
+
+        input_path = Path(self.input_pptx)
+        json_path = Path(self.replacements_json)
+        output_path = Path(self.output_pptx)
+
+        # Validate inputs
+        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}"
+        if not json_path.exists():
+            return f"Error: Replacements JSON not found: {self.replacements_json}"
+
+        # Ensure output directory exists
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Apply replacements
+        try:
+            apply_replacements(str(input_path), str(json_path), str(output_path))
+            return f"Presentation saved to: {output_path}\nReplacements applied successfully"
+        except ValueError as e:
+            return f"Error: {e}"
+
+
+if __name__ == "__main__":
+    print("ApplyPptxTextReplacements tool definition is valid.")
+    print("Requires input PPTX and replacements JSON to test.")

package/slides_agent/tools/BuildPptxFromHtmlSlides.py

@@ -0,0 +1,221 @@
+"""Convert HTML slides to an editable PowerPoint presentation via dom-to-pptx."""
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from .slide_file_utils import get_project_dir, next_pptx_version
+
+RUNNER_JS = Path(__file__).parent / "html2pptx_runner.js"
+
+
+class BuildPptxFromHtmlSlides(BaseTool):
+    """
+    Convert HTML slides to a fully editable PowerPoint presentation.
+
+    Uses dom-to-pptx (via Playwright) to measure every element's exact computed
+    position and style, then maps them to native PPTX shapes and text boxes.
+    CSS gradients are converted to vector SVGs, inline SVGs are kept as editable
+    vectors, custom fonts are auto-embedded, and text remains fully editable.
+
+    The output file is auto-versioned: if my_deck.pptx already exists the tool
+    saves my_deck_v2.pptx, then my_deck_v3.pptx, etc. Previous exports and their
+    snapshots are never overwritten.
+
+    Requires: Node.js with local node_modules (dom-to-pptx, playwright)
+    """
+
+    project_name: str = Field(
+        ...,
+        description="Presentation project folder name (e.g. 'my_pitch')",
+    )
+    slide_names: List[str] = Field(
+        ...,
+        description=(
+            "Ordered list of slide names to include, e.g. ['slide_01', 'slide_02']. "
+            "Use bare names (without .html) or include the extension — both work."
+        ),
+    )
+    output_filename: str = Field(
+        ...,
+        description=(
+            "Output filename stem, e.g. 'my_deck' (saved as my_deck.pptx inside "
+            "the project folder). Including the .pptx extension is also accepted."
+        ),
+    )
+    layout: str = Field(
+        default="LAYOUT_16x9_1280",
+        description=(
+            "Presentation layout: LAYOUT_16x9_1280 (1280x720 HTML), "
+            "LAYOUT_16x9_1920 (1920x1080 HTML), LAYOUT_16x9, LAYOUT_4x3, or LAYOUT_16x10"
+        ),
+    )
+    tmp_dir: Optional[str] = Field(
+        default=None,
+        description="Optional temporary directory for intermediate files",
+    )
+
+    def run(self) -> str:
+        """Convert HTML slides to PPTX."""
+        project_dir = get_project_dir(self.project_name)
+
+        html_paths = self._resolve_slide_paths(self.slide_names, project_dir)
+        if isinstance(html_paths, str):
+            return html_paths  # error message
+
+        if not html_paths:
+            return "Error: No slide names provided"
+
+        valid_layouts = ["LAYOUT_16x9_1280", "LAYOUT_16x9_1920", "LAYOUT_16x9", "LAYOUT_4x3", "LAYOUT_16x10"]
+        if self.layout not in valid_layouts:
+            return f"Error: Invalid layout '{self.layout}'. Must be one of: {', '.join(valid_layouts)}"
+
+        output_path = next_pptx_version(self._resolve_output_path(self.output_filename, project_dir))
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if not self._check_node():
+            return "Error: Node.js not found. Please install Node.js."
+
+        node_modules = Path(__file__).parent.parent.parent / "node_modules"
+        if not node_modules.exists():
+            return (
+                "Error: node_modules not found. Please run 'npm install' in the project root.\n"
+                f"Expected location: {node_modules}"
+            )
+
+        if not RUNNER_JS.exists():
+            return f"Error: Runner script not found at {RUNNER_JS}"
+
+        tmp_dir = self.tmp_dir or tempfile.mkdtemp(prefix="html2pptx_")
+
+        cmd = [
+            "node",
+            str(RUNNER_JS),
+            "--output", str(output_path),
+            "--layout", self.layout,
+            "--tmp-dir", tmp_dir,
+            "--",
+        ] + html_paths
+
+        try:
+            kwargs = {
+                "capture_output": True,
+                "text": True,
+                "timeout": 300,
+                "cwd": str(Path(__file__).parent.parent.parent),
+            }
+            if os.name == "nt":
+                kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+
+            result = subprocess.run(cmd, **kwargs)
+
+            if result.returncode != 0:
+                error_msg = result.stderr.strip() or result.stdout.strip()
+                return f"Error converting HTML to PPTX:\n{error_msg}"
+
+            self._write_snapshots(html_paths, output_path)
+            snapshot_dir = output_path.parent / f"{output_path.name}.slides"
+            return (
+                f"Presentation saved to: {output_path}\n"
+                f"Snapshot saved to: {snapshot_dir}\n"
+                f"Converted {len(html_paths)} slide(s)"
+            )
+
+        except subprocess.TimeoutExpired:
+            return "Error: Conversion timed out after 5 minutes"
+        except Exception as e:
+            return f"Error running html2pptx: {e}"
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _resolve_slide_paths(self, slide_names: List[str], project_dir: Path) -> list[str] | str:
+        """Resolve slide name strings to absolute .html paths."""
+        paths = []
+        for name in slide_names:
+            path = project_dir / (name if name.endswith(".html") else f"{name}.html")
+            if not path.exists():
+                return f"Error: Slide not found: {name} (looked for {path})"
+            paths.append(str(path.absolute()))
+        return paths
+
+    def _resolve_output_path(self, output_filename: str, project_dir: Path) -> Path:
+        """Return the full output .pptx path from a stem or filename."""
+        stem = Path(output_filename).stem
+        return project_dir / f"{stem}.pptx"
+
+    def _write_snapshots(self, html_paths: list[str], output_pptx: Path) -> None:
+        """Write self-contained HTML snapshots to <output>.pptx.slides/1.html, 2.html, …"""
+        slides_dir = output_pptx.parent / f"{output_pptx.name}.slides"
+        slides_dir.mkdir(parents=True, exist_ok=True)
+
+        for i, html_path in enumerate(html_paths, start=1):
+            src = Path(html_path)
+            html = src.read_text(encoding="utf-8")
+            html = self._inline_theme_css(html, src.parent)
+            (slides_dir / f"{i}.html").write_text(html, encoding="utf-8")
+
+    def _inline_theme_css(self, html: str, slide_dir: Path) -> str:
+        """Inline local <link rel="stylesheet"> tags into sentinel-marked <style> blocks.
+
+        External URLs (http/https/protocol-relative) are left as-is.
+        Local files are inlined as:
+            <!-- css-snapshot:<filename>:start -->
+            <style>…</style>
+            <!-- css-snapshot:<filename>:end -->
+        so that RestoreSnapshot can reverse the operation exactly.
+        """
+        import re
+
+        def replace_link(match: re.Match) -> str:
+            href = match.group(1)
+            if href.startswith(("http://", "https://", "//")):
+                return match.group(0)
+            css_path = (slide_dir / href).resolve()
+            if not css_path.exists():
+                return match.group(0)
+            filename = css_path.name
+            css = css_path.read_text(encoding="utf-8")
+            return (
+                f"<!-- css-snapshot:{filename}:start -->\n"
+                f"<style>\n{css}\n</style>\n"
+                f"<!-- css-snapshot:{filename}:end -->"
+            )
+
+        return re.sub(
+            r'<link\b[^>]*\brel=["\']stylesheet["\'][^>]*\bhref=["\']([^"\']+)["\'][^>]*>',
+            replace_link,
+            html,
+            flags=re.IGNORECASE,
+        )
+
+    def _check_node(self) -> bool:
+        """Check if Node.js is available."""
+        try:
+            kwargs = {
+                "capture_output": True,
+                "timeout": 5,
+                "text": True,
+            }
+            if os.name == "nt":
+                kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+            subprocess.run(["node", "--version"], **kwargs)
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+
+if __name__ == "__main__":
+    tool = BuildPptxFromHtmlSlides(
+        project_name="dinosaur_presentation_v2",
+        slide_names=["slide_01", "slide_02", "slide_03", "slide_04", "slide_05"],
+        output_filename="dinosaur_presentation_v2",
+        layout="LAYOUT_16x9_1280",
+    )
+    print(tool.run())

package/slides_agent/tools/CheckSlide.py

@@ -0,0 +1,218 @@
+"""Render a single slide to image and load it as attachment."""
+
+import asyncio
+import inspect
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from agency_swarm.tools import BaseTool, LoadFileAttachment
+from pydantic import Field
+
+PPTX_SCRIPTS_DIR = Path(__file__).parent.parent / "pptx" / "scripts"
+sys.path.insert(0, str(PPTX_SCRIPTS_DIR))
+
+_SLIDE_VIEWPORT = {"width": 1280, "height": 720}
+
+
+class CheckSlide(BaseTool):
+    """
+    Render a single slide (HTML or PPTX) to an image and return a file attachment.
+
+    Allows you to see the slide so you can inspect it for spacing, alignment, and other issues.
+    """
+
+    slide_path: str = Field(
+        ...,
+        description="Path to a single HTML slide or a PPTX file",
+    )
+    output_image_path: Optional[str] = Field(
+        default=None,
+        description="Optional output image path (.jpg). Defaults next to slide.",
+    )
+    layout: str = Field(
+        default="LAYOUT_16x9_1280",
+        description="Layout for HTML slides: LAYOUT_16x9_1280 or LAYOUT_16x9_1920",
+    )
+    slide_index: int = Field(
+        default=1,
+        description="1-based slide index when rendering a PPTX with multiple slides",
+    )
+
+    def run(self):
+        input_path = Path(self.slide_path)
+        if not input_path.exists():
+            return f"Error: Slide not found: {self.slide_path}"
+
+        if input_path.suffix.lower() == ".pptx":
+            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)."
+
+        try:
+            if input_path.suffix.lower() == ".html":
+                image_path = self._screenshot_html(input_path)
+            elif input_path.suffix.lower() == ".pptx":
+                image_path = self._render_pptx_slide(input_path, input_path)
+            else:
+                return "Error: slide_path must be a .html or .pptx file."
+
+            attachment = LoadFileAttachment(path=str(image_path))
+            return self._run_attachment(attachment)
+        except Exception as exc:
+            return f"Error checking slide: {exc}"
+
+    def _screenshot_html(self, html_path: Path) -> Path:
+        """Direct Playwright screenshot — fast, no PPTX/PDF round-trip."""
+        from playwright.sync_api import sync_playwright
+        from PIL import Image
+
+        output_path = self._resolve_output_path(html_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with sync_playwright() as pw:
+            browser = pw.chromium.launch(headless=True)
+            page = browser.new_page(viewport=_SLIDE_VIEWPORT)
+            page.goto(html_path.resolve().as_uri(), wait_until="load", timeout=20_000)
+            page.wait_for_timeout(800)
+            tmp = Path(tempfile.mktemp(suffix=".jpg"))
+            page.screenshot(
+                path=str(tmp),
+                clip={"x": 0, "y": 0, **_SLIDE_VIEWPORT},
+                type="jpeg",
+                quality=80,
+            )
+            browser.close()
+
+        img = Image.open(tmp)
+        new_size = (int(img.width * 0.75), int(img.height * 0.75))
+        img = img.resize(new_size, Image.Resampling.LANCZOS)
+        img.save(output_path, "JPEG", quality=75, optimize=True)
+        return output_path
+
+    def _build_temp_pptx(self, html_path: Path) -> Path:
+        if __package__ is None:
+            sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+            from tools.BuildPptxFromHtmlSlides import BuildPptxFromHtmlSlides
+        else:
+            from .BuildPptxFromHtmlSlides import BuildPptxFromHtmlSlides
+
+        temp_dir = Path(tempfile.mkdtemp(prefix="slide_check_"))
+        output_pptx = temp_dir / "slide_check.pptx"
+        tool = BuildPptxFromHtmlSlides(
+            html_files=[str(html_path)],
+            output_pptx=str(output_pptx),
+            layout=self.layout,
+        )
+        result = tool.run()
+        if isinstance(result, str) and result.lower().startswith("error"):
+            raise RuntimeError(result)
+        return output_pptx
+
+    def _render_pptx_slide(self, pptx_path: Path, source_path: Path) -> Path:
+        import sys
+        from pathlib import Path as PathLib
+        
+        # Add pptx/scripts to path for thumbnail 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 thumbnail import convert_to_images  # type: ignore
+        from PIL import Image
+
+        output_path = self._resolve_output_path(source_path)
+        with tempfile.TemporaryDirectory() as temp_dir:
+            slide_images = convert_to_images(pptx_path, Path(temp_dir), 120)
+            if not slide_images:
+                raise RuntimeError("No slides found in presentation")
+
+            if self.slide_index < 1 or self.slide_index > len(slide_images):
+                raise RuntimeError(
+                    f"slide_index out of range (1-{len(slide_images)}): {self.slide_index}"
+                )
+
+            selected = Path(slide_images[self.slide_index - 1])
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Compress image to reduce token usage
+            img = Image.open(selected)
+            # Resize to 75% of original (reduces token usage significantly)
+            new_size = (int(img.width * 0.75), int(img.height * 0.75))
+            img = img.resize(new_size, Image.Resampling.LANCZOS)
+            # Save with moderate JPEG quality
+            img.save(output_path, 'JPEG', quality=75, optimize=True)
+            
+            return output_path
+
+    def _resolve_output_path(self, pptx_path: Path) -> Path:
+        if self.output_image_path:
+            return Path(self.output_image_path)
+
+        stem = pptx_path.stem
+        if pptx_path.suffix.lower() == ".pptx":
+            return pptx_path.with_name(f"{stem}_check.jpg")
+        return pptx_path.with_name(f"{stem}_check.jpg")
+
+    def _check_soffice(self) -> bool:
+        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:
+        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
+
+    def _run_attachment(self, attachment):
+        result = attachment.run()
+        if not inspect.isawaitable(result):
+            return result
+
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(result)
+
+        new_loop = asyncio.new_event_loop()
+        try:
+            return new_loop.run_until_complete(result)
+        finally:
+            new_loop.close()
+
+
+if __name__ == "__main__":
+    repo_root = Path(__file__).resolve().parents[2]
+    test_pptx = repo_root / "mnt/claude_cowork_deck/presentations/claude_cowork_deck_v5_rendered.pptx"
+    if test_pptx.exists():
+        tool = CheckSlide(slide_path="mnt/claude_cowork_deck/presentations/claude_cowork_deck_v5_rendered.pptx", slide_index=3, output_image_path="mnt/claude_cowork_deck/presentations/_v5_prev3.jpg")
+        print(tool.run())
+    else:
+        print(f"Test file not found: {test_pptx}")
+        print("Tool definition is valid.")