@_vrsen/openswarm 0.1.0

package/docs_agent/tools/ConvertDocument.py

@@ -0,0 +1,323 @@
+"""Convert documents to different formats (PDF, Markdown, TXT)."""
+
+from pathlib import Path
+from typing import Literal
+
+import html2text
+from agency_swarm.tools import BaseTool, ToolOutputText, tool_output_file_from_path
+from bs4 import BeautifulSoup
+from pydantic import Field
+from weasyprint import HTML
+
+from .CreateDocument import CreateDocument
+from .utils.html_docx_core import html_to_docx
+from .utils.html_docx_images import embed_local_images
+from .utils.html_docx_playwright import auto_page_breaks
+
+# Base directory for all document files
+from .utils.doc_file_utils import get_project_dir, next_docx_version
+
+# Characters that PDF fonts commonly lack glyphs for.
+# Includes both proper Unicode typographic chars and ASCII control-char
+# corruptions that sometimes appear when the LLM emits smart-quote/dash
+# codepoints that get truncated to their low byte during serialisation.
+_UNICODE_TO_ASCII = str.maketrans({
+    "\u2018": "'",    # '  left single quotation mark
+    "\u2019": "'",    # '  right single quotation mark / apostrophe
+    "\u201c": '"',    # "  left double quotation mark
+    "\u201d": '"',    # "  right double quotation mark
+    "\u2013": "-",    # –  en dash
+    "\u2014": "--",   # —  em dash
+    "\u2026": "...",  # …  horizontal ellipsis
+    "\u00a0": " ",    # non-breaking space
+    # Corrupted forms: low-byte of U+2019 / U+2013 stored as control chars
+    "\x19":   "'",    # truncated U+2019 right-single-quote low byte
+    "\x11":   "-",    # truncated U+2011/U+2013 dash low byte
+    "\x18":   "'",    # truncated U+2018 left-single-quote low byte
+    "\x1c":   '"',    # truncated U+201C left-double-quote low byte
+    "\x1d":   '"',    # truncated U+201D right-double-quote low byte
+    "\x14":   "--",   # truncated U+2014 em-dash low byte
+})
+
+
+def _normalize_unicode(html: str) -> str:
+    return html.translate(_UNICODE_TO_ASCII)
+
+
+class ConvertDocument(BaseTool):
+    """
+    Convert a document to different formats.
+    
+    Supported conversions:
+    - HTML → PDF (high-quality, print-ready)
+    - HTML → DOCX (Word document)
+    - HTML → Markdown (for documentation)
+    - HTML → TXT (plain text)
+    
+    The tool reads the .source.html file and converts it to the requested format.
+    The original files are preserved - conversion creates a new file.
+    
+    Use this tool to:
+    - Create PDF versions for sharing/printing
+    - Export to Markdown for documentation sites
+    - Generate plain text versions
+    """
+    
+    project_name: str = Field(
+        ...,
+        description="Name of the project folder containing the document"
+    )
+    
+    document_name: str = Field(
+        ...,
+        description="Name of the document to convert (without extension)"
+    )
+    
+    output_format: Literal["pdf", "docx", "markdown", "txt"] = Field(
+        ...,
+        description="""Target format for conversion:
+- 'pdf': High-quality PDF (requires weasyprint)
+- 'docx': Word document
+- 'markdown': Markdown format (useful for documentation)
+- 'txt': Plain text (strips all formatting)"""
+    )
+    
+    overwrite: bool = Field(
+        default=True,
+        description="If True (default), overwrites existing converted file. If False, returns error if file exists."
+    )
+
+    def run(self):
+        """Convert document to specified format."""
+        try:
+            project_dir = get_project_dir(self.project_name)
+
+            if not project_dir.exists():
+                return f"Error: Project '{self.project_name}' not found."
+
+            doc_name = (
+                self.document_name.replace(".html", "")
+                .replace(".docx", "")
+                .replace(".md", "")
+            )
+            source_path = project_dir / f"{doc_name}.source.html"
+
+            if not source_path.exists():
+                return f"Error: Document '{doc_name}' not found in project '{self.project_name}'."
+
+            # Determine output file extension
+            ext_map = {
+                "pdf": ".pdf",
+                "docx": ".docx",
+                "markdown": ".md",
+                "txt": ".txt",
+            }
+            output_path = project_dir / f"{doc_name}{ext_map[self.output_format]}"
+
+            # DOCX auto-versions; all other formats respect overwrite flag
+            if self.output_format == "docx":
+                output_path = next_docx_version(output_path)
+            elif output_path.exists() and not self.overwrite:
+                return (
+                    f"Error: Output file '{output_path.name}' already exists. "
+                    "Set overwrite=True to replace it."
+                )
+
+            html_content = source_path.read_text(encoding="utf-8")
+            html_content = embed_local_images(html_content, project_dir)
+            if self.output_format in ("pdf", "docx"):
+                html_content = auto_page_breaks(html_content)
+
+            if self.output_format == "pdf":
+                self._convert_to_pdf(html_content, output_path)
+            elif self.output_format == "docx":
+                self._convert_to_docx(html_content, output_path)
+            elif self.output_format == "markdown":
+                self._convert_to_markdown(html_content, output_path)
+            elif self.output_format == "txt":
+                self._convert_to_txt(html_content, output_path)
+
+            if not output_path.exists():
+                return f"Error: Conversion failed to produce '{output_path.name}'."
+
+            # For DOCX exports, save a snapshot of the HTML source alongside the file.
+            # This is the version history — RestoreDocument can roll back to any snapshot.
+            if self.output_format == "docx":
+                snapshot_path = output_path.parent / f"{output_path.name}.snapshot.html"
+                snapshot_path.write_text(source_path.read_text(encoding="utf-8"), encoding="utf-8")
+
+            output_size = output_path.stat().st_size
+
+            message = f"""Successfully converted document to {self.output_format.upper()}!
+
+Project: {self.project_name}
+Document: {doc_name}
+Source: {source_path.name}
+Output: {output_path.name} ({output_size:,} bytes)
+
+Path: {output_path}"""
+
+            if self.output_format == "pdf":
+                return [
+                    ToolOutputText(text=message),
+                    tool_output_file_from_path(output_path),
+                ]
+
+            return message
+        except Exception as e:
+            return f"Error converting document: {str(e)}"
+    
+    def _convert_to_pdf(self, html_content: str, output_path: Path):
+        """Convert HTML to PDF using weasyprint."""
+        HTML(string=_normalize_unicode(html_content)).write_pdf(output_path)
+
+    def _convert_to_docx(self, html_content: str, output_path: Path):
+        """Convert HTML to DOCX using the internal converter."""
+        html_to_docx(html_content, output_path)
+    
+    def _convert_to_markdown(self, html_content: str, output_path: Path):
+        """Convert HTML to Markdown."""
+        converter = html2text.HTML2Text()
+        converter.body_width = 0  # Don't wrap text
+        markdown = converter.handle(html_content)
+        output_path.write_text(markdown, encoding="utf-8")
+    
+    def _convert_to_txt(self, html_content: str, output_path: Path):
+        """Convert HTML to plain text."""
+        soup = BeautifulSoup(html_content, "html.parser")
+        text = soup.get_text(separator="\n", strip=True)
+        output_path.write_text(text, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    print("=" * 70)
+    print("TEST: ConvertDocument Tool")
+    print("=" * 70)
+    print()
+    
+    print("Setup: Creating test document...")
+    html_content = """<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Sample Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        h1 { color: #0066cc; }
+        h2 { color: #333; border-bottom: 2px solid #0066cc; padding-bottom: 5px; }
+        p { line-height: 1.6; }
+        table { border-collapse: collapse; width: 100%; margin: 20px 0; }
+        th { background: #0066cc; color: white; padding: 10px; text-align: left; }
+        td { border: 1px solid #ddd; padding: 8px; }
+    </style>
+</head>
+<body>
+    <h1>Annual Report 2026</h1>
+    
+    <h2>Executive Summary</h2>
+    <p>
+        This report provides an overview of our company's performance in 2026.
+        We achieved significant growth across all key metrics.
+    </p>
+    
+    <h2>Financial Highlights</h2>
+    <table>
+        <tr>
+            <th>Metric</th>
+            <th>2025</th>
+            <th>2026</th>
+            <th>Growth</th>
+        </tr>
+        <tr>
+            <td>Revenue</td>
+            <td>$10M</td>
+            <td>$15M</td>
+            <td>+50%</td>
+        </tr>
+        <tr>
+            <td>Customers</td>
+            <td>500</td>
+            <td>800</td>
+            <td>+60%</td>
+        </tr>
+    </table>
+    
+    <h2>Key Achievements</h2>
+    <ul>
+        <li>Launched new product line</li>
+        <li>Expanded to 3 new markets</li>
+        <li>Achieved profitability</li>
+    </ul>
+</body>
+</html>"""
+    
+    create_tool = CreateDocument(
+        project_name="test_convert",
+        document_name="annual_report",
+        content={"type": "html", "value": html_content},
+        overwrite=True,
+    )
+    print(create_tool.run())
+    print()
+    
+    # Test 1: Convert to PDF
+    print("Test 1: Converting to PDF...")
+    tool = ConvertDocument(
+        project_name="test_convert",
+        document_name="annual_report",
+        output_format="pdf"
+    )
+    result = tool.run()
+    print(result)
+    print()
+    
+    # Test 2: Convert to Markdown
+    print("Test 2: Converting to Markdown...")
+    tool = ConvertDocument(
+        project_name="test_convert",
+        document_name="annual_report",
+        output_format="markdown"
+    )
+    result = tool.run()
+    print(result)
+    print()
+    
+    # Test 3: Convert to TXT
+    print("Test 3: Converting to plain text...")
+    tool = ConvertDocument(
+        project_name="test_convert",
+        document_name="annual_report",
+        output_format="txt"
+    )
+    result = tool.run()
+    print(result)
+    print()
+    
+    # Test 4: View markdown output
+    if "✅" in result:
+        print("Test 4: Viewing converted Markdown content...")
+        from pathlib import Path
+        md_path = get_project_dir("test_convert") / "annual_report.md"
+        if md_path.exists():
+            print("Markdown content:")
+            print("-" * 70)
+            print(md_path.read_text(encoding='utf-8')[:500])
+            print("...")
+            print("-" * 70)
+    print()
+    
+    # Test 5: Convert non-existent document (should fail)
+    print("Test 5: Attempting to convert non-existent document...")
+    tool = ConvertDocument(
+        project_name="test_convert",
+        document_name="nonexistent",
+        output_format="pdf"
+    )
+    print(tool.run())
+    print()
+    
+    print("=" * 70)
+    print("✅ ALL TESTS COMPLETE")
+    print("=" * 70)
+    print("\nNote: Some conversion tests may show warnings if optional dependencies")
+    print("(weasyprint, html2text) are not installed. This is expected.")

package/docs_agent/tools/CreateDocument.py

@@ -0,0 +1,287 @@
+"""Create a new document from HTML or Markdown content."""
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Literal, Union
+
+from agency_swarm.tools import BaseTool, ToolOutputText, tool_output_image_from_path
+from playwright.sync_api import sync_playwright
+from pydantic import BaseModel, Field
+from .utils.html_validation import build_unsupported_error, find_unsupported_html
+from .utils.html_docx_playwright import _launch_chromium_with_install
+from .utils.html_docx_constants import _UA_RESET_STYLE
+from .utils.doc_file_utils import get_project_dir
+from .utils.html_docx_images import embed_local_images
+
+
+class HtmlContent(BaseModel):
+    type: Literal["html"]
+    value: str
+
+
+class MarkdownContent(BaseModel):
+    type: Literal["markdown"]
+    value: str
+
+
+ContentInput = Union[HtmlContent, MarkdownContent]
+
+
+class CreateDocument(BaseTool):
+    """
+    Create a new document from HTML or Markdown content.
+    
+    HTML workflow creates:
+    - .source.html file (the canonical source of truth)
+
+    Markdown workflow creates:
+    - .md file only (no .docx or .pdf generation)
+    
+    HTML is used as the source format because it provides:
+    - Full styling control (fonts, colors, spacing, etc.)
+    - Standard conversion tools (weasyprint)
+    - WYSIWYG editing experience
+    - Easy web preview capability
+    
+    Use this tool to create new documents with custom formatting and styling.
+    """
+    
+    project_name: str = Field(
+        ...,
+        description="Name of the project folder (creates/uses ./mnt/{project_name}/documents/). Use lowercase with underscores (e.g., 'business_proposals', 'client_reports')"
+    )
+    
+    document_name: str = Field(
+        ...,
+        description="Name of the document file without extension (e.g., 'quarterly_report', 'contract_template'). Extension will be added automatically."
+    )
+    
+    content: ContentInput = Field(
+        ...,
+        description="""Content object for the document.
+        
+HTML example:
+{
+  "type": "html",
+  "value": "<!DOCTYPE html>..."
+}
+
+Markdown example:
+{
+  "type": "markdown",
+  "value": "# Title\\n\\n- Item"
+}
+        """
+    )
+    
+    overwrite: bool = Field(
+        default=False,
+        description="If True, overwrites existing document. If False (default), returns an error if document already exists."
+    )
+
+    def run(self):
+        """Create a new document from HTML or Markdown content."""
+        try:
+            project_dir = get_project_dir(self.project_name)
+            project_dir.mkdir(parents=True, exist_ok=True)
+            (project_dir / "assets").mkdir(exist_ok=True)
+
+            # Strip extension if the caller included one
+            doc_name = (
+                self.document_name.replace(".html", "")
+                .replace(".docx", "")
+                .replace(".md", "")
+            )
+
+            content_value = self.content.value
+            if not content_value:
+                return "Error: content.value is required."
+
+            if self.content.type == "markdown":
+                return self._create_markdown(doc_name, project_dir, content_value)
+            
+            source_path = project_dir / f"{doc_name}.source.html"
+            
+            if source_path.exists() and not self.overwrite:
+                return f"Error: Document '{doc_name}' already exists in project '{self.project_name}'. Use overwrite=True to replace it, or choose a different document name."
+            
+            normalized_html = _ensure_ua_reset(content_value)
+            issues = find_unsupported_html(normalized_html)
+            if issues:
+                return build_unsupported_error(issues)
+            source_path.write_text(normalized_html, encoding='utf-8')
+            
+            source_size = source_path.stat().st_size
+            
+            operation = "updated" if self.overwrite and source_path.exists() else "created"
+            
+            message = f"""Successfully {operation} document
+
+Project: {self.project_name}
+Document: {doc_name}
+
+Files created:
+  - {source_path.name} ({source_size:,} bytes)
+
+Path: {source_path}
+
+Note: The .source.html file is the canonical source to be used for document conversion."""
+            try:
+                preview = _build_html_preview_image(normalized_html, project_dir)
+            except Exception:
+                return ToolOutputText(text=message)
+
+            return [
+                ToolOutputText(text=message),
+                preview,
+            ]
+            
+        except Exception as e:
+            return f"Error creating document: {str(e)}"
+
+    def _create_markdown(self, doc_name, project_dir, markdown_value):
+        md_path = project_dir / f"{doc_name}.md"
+        if md_path.exists() and not self.overwrite:
+            return f"Error: Document '{doc_name}' already exists in project '{self.project_name}'. Use overwrite=True to replace it, or choose a different document name."
+
+        md_path.write_text(markdown_value, encoding="utf-8")
+        if not md_path.exists():
+            return f"Error: Markdown generation failed for document '{doc_name}'."
+        md_size = md_path.stat().st_size
+        operation = "updated" if self.overwrite and md_path.exists() else "created"
+
+        return f"""Successfully {operation} document!
+
+Project: {self.project_name}
+Document: {doc_name}
+
+Files created:
+  - {md_path.name} ({md_size:,} bytes) [Markdown source]
+
+Path: {md_path}
+
+Note: Markdown workflow only creates a .md file and does not generate .docx or .pdf files."""
+
+def _build_html_preview_image(html_content: str, base_dir: Path):
+    """Render a preview JPEG of the HTML document.
+
+    The temp file is written inside base_dir so Playwright resolves
+    relative image paths correctly (mirrors the slides-agent pattern).
+    Images are also embedded as data URIs for full fidelity.
+    """
+    import tempfile
+
+    from PIL import Image
+
+    preview_html = embed_local_images(html_content, base_dir)
+
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        suffix=".html",
+        delete=False,
+        encoding="utf-8",
+        dir=base_dir,
+    ) as tmp_html:
+        tmp_html.write(preview_html)
+        tmp_html_path = Path(tmp_html.name)
+
+    try:
+        with TemporaryDirectory() as tmp_dir:
+            tmp_dir_path = Path(tmp_dir)
+            raw_jpg = tmp_dir_path / "preview_raw.jpg"
+            out_jpg = tmp_dir_path / "preview.jpg"
+
+            with sync_playwright() as p:
+                browser = _launch_chromium_with_install(p)
+                page = browser.new_page(viewport={"width": 794, "height": 1123})
+                page.goto(tmp_html_path.as_uri())
+                page.wait_for_load_state("networkidle")
+                page.screenshot(path=str(raw_jpg), full_page=True, type="jpeg", quality=80)
+                browser.close()
+
+            img = Image.open(raw_jpg)
+            new_size = (int(img.width * 0.75), int(img.height * 0.75))
+            img = img.resize(new_size, Image.Resampling.LANCZOS)
+            img.save(out_jpg, "JPEG", quality=75, optimize=True)
+
+            return tool_output_image_from_path(out_jpg, detail="auto")
+    finally:
+        tmp_html_path.unlink(missing_ok=True)
+
+def _ensure_ua_reset(html_content: str) -> str:
+    """Ensure a UA reset style exists in the HTML head."""
+    if "UA reset to neutralize browser defaults" in html_content:
+        return html_content
+
+    lower = html_content.lower()
+    head_index = lower.find("<head")
+    if head_index != -1:
+        head_close = lower.find(">", head_index)
+        if head_close != -1:
+            return (
+                html_content[: head_close + 1]
+                + _UA_RESET_STYLE
+                + html_content[head_close + 1 :]
+            )
+
+    if "<html" in lower:
+        return html_content.replace("<html>", f"<html><head>{_UA_RESET_STYLE}</head>", 1)
+
+    return f"<!DOCTYPE html><html><head>{_UA_RESET_STYLE}</head><body>{html_content}</body></html>"
+
+if __name__ == "__main__":
+    print("=" * 70)
+    print("TEST: CreateDocument Tool")
+    print("=" * 70)
+    print()    
+    html_simple = """<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Business Proposal</title>
+</head>
+<body>
+    <h1 style="color: #0066cc; font-family: Arial, sans-serif;">Business Proposal</h1>
+    
+    <h2 style="color: #333; font-family: Arial, sans-serif;">Executive Summary</h2>
+    <p style="font-family: Georgia, serif; font-size: 11pt; line-height: 1.5;">
+        This proposal outlines our comprehensive approach to solving your business challenges.
+        We bring extensive experience and proven methodologies to deliver results.
+    </p>
+    
+    <h2 style="color: #333; font-family: Arial, sans-serif;">Our Services</h2>
+    <ul style="font-family: Georgia, serif; font-size: 11pt; line-height: 1.5;">
+        <li><strong>Consulting:</strong> Strategic business advisory</li>
+        <li><strong>Implementation:</strong> End-to-end project execution</li>
+        <li><strong>Support:</strong> Ongoing maintenance and optimization</li>
+    </ul>
+    
+    <h2 style="color: #333; font-family: Arial, sans-serif;">Pricing</h2>
+    <table style="width: 100%; border-collapse: collapse; font-family: Arial, sans-serif; font-size: 10pt;">
+        <tr style="background: #0066cc; color: white;">
+            <th style="padding: 10px; border: 1px solid #ccc; text-align: left;">Package</th>
+            <th style="padding: 10px; border: 1px solid #ccc; text-align: right;">Price</th>
+        </tr>
+        <tr>
+            <td style="padding: 8px; border: 1px solid #ccc;">Basic</td>
+            <td style="padding: 8px; border: 1px solid #ccc; text-align: right;">$5,000</td>
+        </tr>
+        <tr style="background: #f9f9f9;">
+            <td style="padding: 8px; border: 1px solid #ccc;">Professional</td>
+            <td style="padding: 8px; border: 1px solid #ccc; text-align: right;">$10,000</td>
+        </tr>
+        <tr>
+            <td style="padding: 8px; border: 1px solid #ccc;">Enterprise</td>
+            <td style="padding: 8px; border: 1px solid #ccc; text-align: right;">$25,000</td>
+        </tr>
+    </table>
+</body>
+</html>"""
+    
+    tool = CreateDocument(
+        project_name="test_project",
+        document_name="business_proposal",
+        content={"type": "html", "value": html_simple},
+    )
+    print(tool.run())
+    print()