@_vrsen/openswarm 0.1.0

package/slides_agent/tools/DeleteSlide.py

@@ -0,0 +1,78 @@
+"""Delete HTML slide files from a presentation project."""
+
+from .slide_file_utils import get_project_dir, list_slide_files
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+
+class DeleteSlide(BaseTool):
+    """
+    Delete an HTML slide file from a presentation project.
+    
+    Use this tool to remove slides that are no longer needed.
+    """
+
+    project_name: str = Field(
+        ...,
+        description="Name of the presentation project"
+    )
+    slide_name: str | None = Field(
+        default=None,
+        description="Name of the slide file to delete (e.g., 'slide_01' - .html extension added automatically)"
+    )
+    slide_indexes: list[int] | None = Field(
+        default=None,
+        description="1-based slide indexes to delete (uses project slide order)",
+    )
+    file_prefix: str = Field(
+        default="slide",
+        description="Slide filename prefix when deleting by index",
+    )
+
+    def run(self):
+        """Delete the specified slide file."""
+        project_dir = get_project_dir(self.project_name)
+        
+        if not project_dir.exists():
+            return f"❌ Project '{self.project_name}' does not exist at {project_dir}"
+        
+        if self.slide_indexes:
+            slides = list_slide_files(project_dir, self.file_prefix)
+            missing = [idx for idx in self.slide_indexes if idx < 1 or idx > len(slides)]
+            if missing:
+                return f"❌ Slide indexes out of range: {missing}"
+            deleted = []
+            for idx in sorted(self.slide_indexes, reverse=True):
+                slide_path = slides[idx - 1].path
+                if slide_path.exists():
+                    slide_path.unlink()
+                    deleted.append(slide_path)
+            if not deleted:
+                return "❌ No slides deleted."
+            return "✅ Deleted slides:\n" + "\n".join(f"- {path}" for path in deleted)
+
+        if not self.slide_name:
+            return "Error: Provide slide_name or slide_indexes to delete slides."
+
+        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"❌ Slide '{slide_name}' does not exist in project '{self.project_name}'"
+
+        try:
+            slide_path.unlink()
+            return f"✅ Successfully deleted slide: {slide_path}"
+
+        except Exception as e:
+            return f"Error deleting slide: {e}"
+
+
+if __name__ == "__main__":
+    # Test (will fail if file doesn't exist, which is expected)
+    tool = DeleteSlide(
+        project_name="test_project",
+        slide_name="slide_01"
+    )
+    print(tool.run())

package/slides_agent/tools/DownloadImage.py

@@ -0,0 +1,79 @@
+"""Download an image into a project's assets folder."""
+
+from pathlib import Path
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from .slide_file_utils import get_project_dir
+
+
+class DownloadImage(BaseTool):
+    """
+    Download an image from a URL into the project's assets folder.
+    """
+
+    project_name: str = Field(..., description="Name of the presentation project")
+    url: str = Field(..., description="Image URL to download")
+    image_name: str = Field(..., description="Desired filename (with or without extension)")
+
+    def run(self) -> str:
+        project_dir = get_project_dir(self.project_name)
+        assets_dir = project_dir / "assets"
+        assets_dir.mkdir(parents=True, exist_ok=True)
+
+        parsed = urlparse(self.url)
+        if parsed.scheme not in ("http", "https"):
+            return "Error: URL must start with http or https."
+
+        file_name = self._ensure_extension(self.image_name, self.url)
+        output_path = assets_dir / file_name
+
+        try:
+            request = Request(self.url, headers={"User-Agent": "slides_agent/1.0"})
+            with urlopen(request, timeout=30) as response:
+                content = response.read()
+            # Reject HTML or non-image content (e.g. error pages)
+            if content.lstrip()[:100].lower().startswith((b"<!doctype", b"<html", b"< ")):
+                return "Error: URL did not return an image (got HTML). Use a direct image URL or try another source."
+            output_path.write_bytes(content)
+            # Verify we can read it as an image (SVGs are validated separately)
+            if output_path.suffix.lower() == ".svg":
+                snippet = content.lstrip()[:200].lower()
+                if b"<svg" not in snippet and b"<?xml" not in snippet:
+                    output_path.unlink(missing_ok=True)
+                    return "Error: Downloaded file is not a valid SVG. Use a direct image URL or try another source."
+            else:
+                try:
+                    from PIL import Image
+                    with Image.open(output_path) as img:
+                        img.verify()
+                except Exception:
+                    output_path.unlink(missing_ok=True)
+                    return "Error: Downloaded file is not a valid image. Use a direct image URL (e.g. .jpg, .png) or try another source."
+        except Exception as exc:
+            return f"Error downloading image: {exc}"
+
+        return f"Downloaded image to: {output_path}"
+
+    def _ensure_extension(self, image_name: str, url: str) -> str:
+        if Path(image_name).suffix:
+            return image_name
+
+        url_path = urlparse(url).path
+        url_ext = Path(url_path).suffix
+        if url_ext:
+            return image_name + url_ext
+
+        return image_name + ".png"
+
+
+if __name__ == "__main__":
+    tool = DownloadImage(
+        project_name="openclaw_presentation_v3",
+        url="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/sponsors/convex.svg",
+        image_name="sponsor_convex.svg"
+    )
+    print(tool.run())

package/slides_agent/tools/EnsureRasterImage.py

@@ -0,0 +1,157 @@
+"""Convert vector/container image formats to raster PNG."""
+
+import gzip
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+# Supported file extensions
+RASTER_EXTS = {".png", ".jpg", ".jpeg", ".bmp", ".gif", ".tif", ".tiff", ".webp"}
+CONVERTIBLE_EXTS = {
+    ".emf", ".wmf", ".emz", ".wmz",  # Windows metafiles
+    ".svg", ".svgz",  # SVG
+    ".wdp", ".jxr",  # JPEG XR
+    ".heic", ".heif",  # HEIF
+    ".pdf", ".eps", ".ps",  # Page description formats
+}
+SUPPORTED_EXTS = RASTER_EXTS | CONVERTIBLE_EXTS
+
+
+class EnsureRasterImage(BaseTool):
+    """
+    Convert vector or container image formats to raster PNG.
+
+    Supports conversion of:
+    - EMF/WMF/EMZ/WMZ (Windows metafiles) via Inkscape
+    - SVG/SVGZ via Inkscape
+    - WDP/JXR (JPEG XR) via JxrDecApp + ImageMagick
+    - HEIC/HEIF via heif-convert
+    - PDF/EPS/PS (first page) via Ghostscript
+
+    Already-raster formats (PNG, JPG, etc.) are returned as-is.
+
+    This is useful for preparing images extracted from PowerPoint files
+    for preview or re-embedding, as PPTX files may contain vector formats
+    that need rasterization.
+
+    Required external tools (depending on input format):
+    - Inkscape: SVG/EMF/WMF rasterization
+    - ImageMagick: format bridging
+    - Ghostscript: PDF/EPS/PS rasterization
+    - libheif-examples: HEIC/HEIF conversion
+    - jxr-tools: JPEG XR conversion
+    """
+
+    input_path: str = Field(
+        ...,
+        description="Path to the input image file",
+    )
+    output_dir: Optional[str] = Field(
+        default=None,
+        description="Directory for output PNG (defaults to same directory as input)",
+    )
+    dpi: Optional[int] = Field(
+        default=None,
+        description="Optional rasterization DPI for vector formats (e.g., 192 for crisp icons)",
+    )
+
+    def run(self) -> str:
+        """Convert image to PNG if needed and return the output path."""
+        input_path = Path(self.input_path)
+
+        # Validate input
+        if not input_path.exists():
+            return f"Error: Input file not found: {self.input_path}"
+
+        ext_lower = input_path.suffix.lower()
+        if ext_lower not in SUPPORTED_EXTS:
+            return f"Error: Unsupported format '{ext_lower}'. Supported: {', '.join(sorted(SUPPORTED_EXTS))}"
+
+        # Determine output directory and path
+        out_dir = Path(self.output_dir) if self.output_dir else input_path.parent
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / (input_path.stem + ".png")
+
+        # Already raster - return as-is
+        if ext_lower in RASTER_EXTS:
+            return f"Already raster format: {input_path}"
+
+        try:
+            result_path = self._convert(input_path, out_path, ext_lower, self.dpi)
+            return f"Converted to: {result_path}"
+        except Exception as e:
+            return f"Error converting {input_path}: {e}"
+
+    def _convert(self, input_path: Path, out_path: Path, ext: str, dpi: Optional[int]) -> str:
+        """Convert the file and return the output path."""
+        out_dir = out_path.parent
+        dpi_arg = [f"--export-dpi={dpi}"] if dpi else []
+
+        # EMF/WMF via Inkscape
+        if ext in (".emf", ".wmf"):
+            self._run_cmd(["inkscape", str(input_path), "-o", str(out_path), *dpi_arg])
+            return str(out_path)
+
+        # EMZ/WMZ - decompress then convert
+        if ext in (".emz", ".wmz"):
+            decompressed = out_dir / (input_path.stem + (".emf" if ext == ".emz" else ".wmf"))
+            with gzip.open(input_path, "rb") as zin, open(decompressed, "wb") as zout:
+                zout.write(zin.read())
+            self._run_cmd(["inkscape", str(decompressed), "-o", str(out_path), *dpi_arg])
+            decompressed.unlink()  # Clean up
+            return str(out_path)
+
+        # SVG/SVGZ via Inkscape
+        if ext in (".svg", ".svgz"):
+            self._run_cmd(["inkscape", str(input_path), "-o", str(out_path), *dpi_arg])
+            return str(out_path)
+
+        # JPEG XR via JxrDecApp + ImageMagick
+        if ext in (".wdp", ".jxr"):
+            tmp_tiff = out_dir / (input_path.stem + ".tiff")
+            self._run_cmd(["JxrDecApp", "-i", str(input_path), "-o", str(tmp_tiff)])
+            self._imagemagick_convert(str(tmp_tiff), str(out_path))
+            tmp_tiff.unlink()  # Clean up
+            return str(out_path)
+
+        # HEIC/HEIF via heif-convert
+        if ext in (".heic", ".heif"):
+            heif_convert = shutil.which("heif-convert") or "heif-convert"
+            self._run_cmd([heif_convert, str(input_path), str(out_path)])
+            return str(out_path)
+
+        # PDF/EPS/PS via Ghostscript (first page only)
+        if ext in (".pdf", ".eps", ".ps"):
+            gs = shutil.which("gs") or "gs"
+            dpi_value = str(dpi or 200)
+            self._run_cmd([
+                gs, "-dSAFER", "-dBATCH", "-dNOPAUSE",
+                "-sDEVICE=pngalpha",
+                "-dFirstPage=1", "-dLastPage=1",
+                f"-r{dpi_value}",
+                "-o", str(out_path),
+                str(input_path),
+            ])
+            return str(out_path)
+
+        raise ValueError(f"No conversion handler for {ext}")
+
+    def _run_cmd(self, cmd: list) -> None:
+        """Run a command and raise on failure."""
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise RuntimeError(f"Command failed: {' '.join(cmd)}\n{result.stderr}")
+
+    def _imagemagick_convert(self, src: str, dst: str) -> None:
+        """Convert using ImageMagick."""
+        binary = shutil.which("magick") or "convert"
+        self._run_cmd([binary, src, dst])
+
+
+if __name__ == "__main__":
+    print("EnsureRasterImage tool definition is valid.")
+    print(f"Supported formats: {', '.join(sorted(SUPPORTED_EXTS))}")

package/slides_agent/tools/ExtractPptxTextInventory.py

@@ -0,0 +1,104 @@
+"""Extract structured text inventory from 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 inventory module
+PPTX_SCRIPTS_DIR = Path(__file__).parent.parent / "pptx" / "scripts"
+sys.path.insert(0, str(PPTX_SCRIPTS_DIR))
+
+
+class ExtractPptxTextInventory(BaseTool):
+    """
+    Extract structured text inventory from a PowerPoint presentation.
+
+    Returns a JSON file containing all text shapes organized by slide, with:
+    - Position and dimensions (in inches)
+    - Placeholder types (TITLE, BODY, SUBTITLE, etc.)
+    - Paragraph formatting (bullets, alignment, fonts, colors, spacing)
+    - Overflow and overlap issue detection
+
+    Use this tool to understand the structure of a presentation before
+    making text replacements, or to detect formatting issues.
+    """
+
+    input_pptx: str = Field(
+        ...,
+        description="Path to the input PowerPoint file (.pptx)",
+    )
+    output_json: str = Field(
+        ...,
+        description="Path where the inventory JSON will be saved",
+    )
+    issues_only: bool = Field(
+        default=False,
+        description="If True, only include shapes with overflow or overlap issues",
+    )
+
+    def run(self) -> str:
+        """Extract text inventory and save to JSON."""
+        import sys
+        from pathlib import Path as PathLib
+        
+        # Add pptx/scripts to path for inventory 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 inventory import extract_text_inventory, save_inventory  # type: ignore
+
+        input_path = Path(self.input_pptx)
+        output_path = Path(self.output_json)
+
+        # 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}"
+
+        # Ensure output directory exists
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Extract inventory
+        inventory = extract_text_inventory(input_path, issues_only=self.issues_only)
+
+        # Save to JSON
+        save_inventory(inventory, output_path)
+
+        # Generate summary
+        total_slides = len(inventory)
+        total_shapes = sum(len(shapes) for shapes in inventory.values())
+
+        if self.issues_only:
+            if total_shapes > 0:
+                return (
+                    f"Inventory saved to: {output_path}\n"
+                    f"Found {total_shapes} text elements with issues across {total_slides} slides"
+                )
+            else:
+                return f"Inventory saved to: {output_path}\nNo issues discovered"
+        else:
+            return (
+                f"Inventory saved to: {output_path}\n"
+                f"Found {total_shapes} text elements across {total_slides} slides"
+            )
+
+
+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=".json", delete=False) as f:
+            tool = ExtractPptxTextInventory(
+                input_pptx=str(test_pptx),
+                output_json=f.name,
+            )
+            print(tool.run())
+    else:
+        print(f"Test file not found: {test_pptx}")
+        print("Tool definition is valid.")

package/slides_agent/tools/GenerateImage.py

@@ -0,0 +1,189 @@
+"""Generate images using AI models for diagrams and concept art."""
+
+from typing import Literal, Optional
+import asyncio
+import inspect
+
+import os
+from agency_swarm.tools import BaseTool, LoadFileAttachment
+from pydantic import Field
+
+
+class GenerateImage(BaseTool):
+    """
+    Generate images using Google Gemini models.
+    
+    Supports two modes:
+    - Complex Diagrams (Flowcharts, Pyramids, Org Charts): Uses nano-banana-pro (gemini-3-pro-image-preview) optimized for text rendering
+    - Concept Art (Illustrations, Atmosphere): Uses nano-banana (gemini-2.5-flash-image) for faster generation
+    
+    The generated image is saved to the specified output path or to the project's assets folder.
+    """
+
+    prompt: str = Field(
+        ...,
+        description="Detailed description of the image to generate. Be specific about layout, colors, style, and any text that should appear."
+    )
+    image_type: Literal["diagram", "concept_art"] = Field(
+        ...,
+        description="Type of image: 'diagram' for flowcharts/org charts (uses nano-banana-pro), 'concept_art' for illustrations"
+    )
+    project_name: str = Field(
+        ...,
+        description="Name of the presentation project (e.g. 'my_presentation'). The image is saved to that project's assets folder."
+    )
+    asset_name: str = Field(
+        ...,
+        description="Filename for the generated image including extension (e.g. 'hero.png'). Saved under the project's assets/ folder."
+    )
+    width: int = Field(
+        default=1024,
+        description="Image width in pixels (default 1024)"
+    )
+    height: int = Field(
+        default=1024,
+        description="Image height in pixels (default 1024)"
+    )
+    style: Optional[str] = Field(
+        default=None,
+        description="Optional style modifier (e.g., 'minimalist', 'professional', 'hand-drawn', 'technical')"
+    )
+
+    def run(self) -> str:
+        """Generate image and save to the project's assets folder."""
+        from .slide_file_utils import get_project_dir
+        try:
+            full_prompt = self.prompt
+            if self.style:
+                full_prompt = f"{self.prompt} Style: {self.style}"
+
+            if self.image_type == "diagram":
+                model = "gemini-3-pro-image-preview"
+                full_prompt = f"Technical diagram: {full_prompt}. Clear labels, professional layout, high contrast."
+            else:
+                model = "gemini-2.5-flash-image"
+                full_prompt = f"High-quality illustration: {full_prompt}"
+
+            image_data = self._generate_with_gemini(full_prompt, model)
+
+            assets_dir = get_project_dir(self.project_name) / "assets"
+            assets_dir.mkdir(parents=True, exist_ok=True)
+            output = assets_dir / self.asset_name
+            
+            # Compress image to reduce token usage
+            from PIL import Image
+            import io
+            
+            # Load image from bytes
+            img = Image.open(io.BytesIO(image_data))
+            
+            # Resize to 75% if larger than 1024px on any dimension
+            if img.width > 1024 or img.height > 1024:
+                new_size = (int(img.width * 0.75), int(img.height * 0.75))
+                img = img.resize(new_size, Image.Resampling.LANCZOS)
+            
+            # Save with JPEG quality 80 for good balance
+            img.save(output, 'JPEG', quality=80, optimize=True)
+
+            # Return image as file attachment
+            attachment = LoadFileAttachment(path=str(output))
+            result = self._run_attachment(attachment)
+            return f"Image saved to ./assets/{self.asset_name}\n\n{result}"
+        
+        except Exception as e:
+            return f"Error generating image: {e}"
+    
+    def _run_attachment(self, attachment):
+        """Run the attachment tool, handling async if needed."""
+        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()
+
+    def _generate_with_gemini(self, prompt: str, model: str) -> bytes:
+        """Generate image using Google Gemini API (nano-banana or nano-banana-pro)."""
+        try:
+            from google import genai
+            from google.genai.types import GenerateContentConfig, ImageConfig
+            
+            api_key = os.getenv("GOOGLE_API_KEY")
+            if not api_key:
+                raise ValueError("GOOGLE_API_KEY is not set. Add it to your .env to use image generation.")
+            
+            client = genai.Client(api_key=api_key)
+
+            # Determine aspect ratio based on width/height
+            aspect_ratio = "1:1"  # default square
+            if self.width != self.height:
+                # Calculate approximate aspect ratio
+                ratio = self.width / self.height
+                if abs(ratio - 16/9) < 0.1:
+                    aspect_ratio = "16:9"
+                elif abs(ratio - 9/16) < 0.1:
+                    aspect_ratio = "9:16"
+                elif abs(ratio - 4/3) < 0.1:
+                    aspect_ratio = "4:3"
+                elif abs(ratio - 3/4) < 0.1:
+                    aspect_ratio = "3:4"
+                elif abs(ratio - 3/2) < 0.1:
+                    aspect_ratio = "3:2"
+                elif abs(ratio - 2/3) < 0.1:
+                    aspect_ratio = "2:3"
+            
+            # Configure image generation
+            config = GenerateContentConfig(
+                image_config=ImageConfig(
+                    aspect_ratio=aspect_ratio,
+                )
+            )
+            
+            # Generate image
+            response = client.models.generate_content(
+                model=model,
+                contents=prompt,
+                config=config
+            )
+            
+            # Extract image data from response
+            if response.parts:
+                for part in response.parts:
+                    if hasattr(part, 'inline_data') and part.inline_data:
+                        usage_metadata = getattr(response, "usage_metadata", {}) or {}
+                        if usage_metadata and not isinstance(usage_metadata, dict):
+                            if hasattr(usage_metadata, "model_dump"):
+                                usage_metadata = usage_metadata.model_dump()
+                            elif hasattr(usage_metadata, "__dict__"):
+                                usage_metadata = vars(usage_metadata)
+                            else:
+                                try:
+                                    usage_metadata = dict(usage_metadata)
+                                except (TypeError, ValueError):
+                                    usage_metadata = {}
+                        return part.inline_data.data
+            
+            raise RuntimeError("No image data in response")
+            
+        except ImportError:
+            raise RuntimeError("Google GenAI package not installed. Please install: pip install google-genai")
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate image with Gemini: {e}")
+
+if __name__ == "__main__":
+    tool = GenerateImage(
+        prompt="A flowchart showing a three-step process: Research -> Design -> Implementation. Use blue boxes and arrows.",
+        image_type="concept_art",
+        project_name="slides_agent_test_deck",
+        asset_name="test_diagram.png",
+        style="professional"
+    )
+    print(tool.run())