figquilt 0.1.0__tar.gz → 0.1.2__tar.gz

{figquilt-0.1.0 → figquilt-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: figquilt
-Version: 0.1.0
+Version: 0.1.2
 Summary: figquilt is a small, language-agnostic CLI tool that composes multiple figures (PDF/SVG/PNG) into a single publication-ready figure, based on a simple layout file (YAML/JSON). The key function is creating a PDF by composing multiple PDFs and adding subfigure labels and minimal annotations.
 Author: YY Ahn
 Author-email: YY Ahn <yongyeol@gmail.com>
@@ -16,6 +16,7 @@ Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pymupdf>=1.26.6
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: seaborn>=0.13.2
+Requires-Dist: watchfiles>=1.0.0
 Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/yy/figquilt
 Project-URL: Repository, https://github.com/yy/figquilt
@@ -37,18 +38,22 @@ Description-Content-Type: text/markdown
 
 ## Installation
 
-This project uses `uv` for dependency management.
+```bash
+uv tool install figquilt
+```
+
+Or add it as a project dependency:
+
+```bash
+uv add figquilt
+```
+
+### Development Installation
 
 ```bash
-# Clone the repository
 git clone https://github.com/yy/figquilt.git
 cd figquilt
-
-# Install dependencies and set up the environment
 uv sync
-
-# Install the package in editable mode
-uv pip install -e .
 ```
 
 ## Usage
@@ -77,4 +82,14 @@ Run `figquilt` to generate the figure:
 
 ```bash
 figquilt figure1.yaml figure1.pdf
-```
+```
+
+### Watch Mode
+
+Use `--watch` to automatically rebuild when the layout file or any panel source files change:
+
+```bash
+figquilt --watch figure1.yaml figure1.pdf
+```
+
+This is useful during layout iteration - edit your YAML or regenerate a panel, and the output updates automatically.

{figquilt-0.1.0 → figquilt-0.1.2}/README.md

@@ -14,18 +14,22 @@
 
 ## Installation
 
-This project uses `uv` for dependency management.
+```bash
+uv tool install figquilt
+```
+
+Or add it as a project dependency:
+
+```bash
+uv add figquilt
+```
+
+### Development Installation
 
 ```bash
-# Clone the repository
 git clone https://github.com/yy/figquilt.git
 cd figquilt
-
-# Install dependencies and set up the environment
 uv sync
-
-# Install the package in editable mode
-uv pip install -e .
 ```
 
 ## Usage
@@ -54,4 +58,14 @@ Run `figquilt` to generate the figure:
 
 ```bash
 figquilt figure1.yaml figure1.pdf
-```
+```
+
+### Watch Mode
+
+Use `--watch` to automatically rebuild when the layout file or any panel source files change:
+
+```bash
+figquilt --watch figure1.yaml figure1.pdf
+```
+
+This is useful during layout iteration - edit your YAML or regenerate a panel, and the output updates automatically.

{figquilt-0.1.0 → figquilt-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "figquilt"
-version = "0.1.0"
+version = "0.1.2"
 description = "figquilt is a small, language-agnostic CLI tool that composes multiple figures (PDF/SVG/PNG) into a single publication-ready figure, based on a simple layout file (YAML/JSON). The key function is creating a PDF by composing multiple PDFs and adding subfigure labels and minimal annotations."
 readme = "README.md"
 authors = [
@@ -22,6 +22,7 @@ dependencies = [
     "pymupdf>=1.26.6",
     "pyyaml>=6.0.3",
     "seaborn>=0.13.2",
+    "watchfiles>=1.0.0",
 ]
 
 [project.scripts]

figquilt-0.1.2/src/figquilt/cli.py

@@ -0,0 +1,217 @@
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional, Set, Tuple
+import threading
+
+from .parser import parse_layout
+from .errors import FigQuiltError
+from .layout import Layout
+
+
+def get_watched_paths(layout_path: Path, layout: Layout) -> Tuple[Set[Path], Set[Path]]:
+    """
+    Return the set of files and directories to watch.
+
+    Returns:
+        Tuple of (watched_files, watched_dirs)
+    """
+    layout_path = layout_path.resolve()
+    files = {layout_path}
+    for panel in layout.panels:
+        files.add(panel.file.resolve())
+    dirs = {f.parent for f in files}
+    return files, dirs
+
+
+def compose_figure(
+    layout_path: Path, output_path: Path, fmt: str, verbose: bool
+) -> bool:
+    """
+    Compose a figure from a layout file.
+
+    Returns True on success, False on error.
+    """
+    try:
+        layout = parse_layout(layout_path)
+        if verbose:
+            print(f"Layout parsed: {layout_path}")
+            print(
+                f"Page size: {layout.page.width}x{layout.page.height} {layout.page.units}"
+            )
+            print(f"Panels: {len(layout.panels)}")
+
+        if fmt == "pdf":
+            from .compose_pdf import PDFComposer
+
+            composer = PDFComposer(layout)
+            composer.compose(output_path)
+
+        elif fmt == "svg":
+            from .compose_svg import SVGComposer
+
+            composer = SVGComposer(layout)
+            composer.compose(output_path)
+
+        elif fmt == "png":
+            from .compose_pdf import PDFComposer
+
+            composer = PDFComposer(layout)
+            doc = composer.build()
+            page = doc[0]
+            pix = page.get_pixmap(dpi=layout.page.dpi)
+            pix.save(str(output_path))
+            doc.close()
+
+        else:
+            print(f"Unsupported format: {fmt}", file=sys.stderr)
+            return False
+
+        return True
+
+    except FigQuiltError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        return False
+
+
+def run_watch_mode(
+    layout_path: Path,
+    output_path: Path,
+    fmt: str,
+    verbose: bool,
+    stop_event: Optional[threading.Event] = None,
+) -> None:
+    """
+    Watch layout and panel files for changes and rebuild on each change.
+
+    Args:
+        layout_path: Path to the layout YAML file
+        output_path: Path to the output file
+        fmt: Output format (pdf, svg, png)
+        verbose: Whether to print verbose output
+        stop_event: Optional threading event to stop watching (for testing)
+    """
+    from watchfiles import watch
+
+    print("Watching for changes... (Ctrl+C to stop)")
+
+    # Initial build
+    if compose_figure(layout_path, output_path, fmt, verbose):
+        print(f"Created: {output_path}")
+    else:
+        print("Initial build failed, watching for changes...")
+
+    # Get initial set of watched files and directories
+    try:
+        layout = parse_layout(layout_path)
+        watched_files, watch_dirs = get_watched_paths(layout_path, layout)
+    except FigQuiltError:
+        # If layout is invalid, just watch the layout file itself
+        layout_path_resolved = layout_path.resolve()
+        watched_files = {layout_path_resolved}
+        watch_dirs = {layout_path_resolved.parent}
+
+    while True:
+        restart_watcher = False
+
+        for changes in watch(*watch_dirs, stop_event=stop_event):
+            if stop_event and stop_event.is_set():
+                return
+
+            # Check if any changed file is in our watched set
+            changed_paths = {Path(change[1]).resolve() for change in changes}
+            relevant_changes = changed_paths & watched_files
+
+            if relevant_changes:
+                if verbose:
+                    for p in relevant_changes:
+                        print(f"Changed: {p}")
+
+                print("Rebuilding...", end=" ", flush=True)
+                if compose_figure(layout_path, output_path, fmt, verbose):
+                    print(f"done: {output_path}")
+                else:
+                    print("failed")
+
+                # Re-parse layout to update watched files (panels might have changed)
+                try:
+                    layout = parse_layout(layout_path)
+                    new_files, new_dirs = get_watched_paths(layout_path, layout)
+                    if new_dirs != watch_dirs:
+                        # Directories changed, need to restart the watcher
+                        watched_files = new_files
+                        watch_dirs = new_dirs
+                        restart_watcher = True
+                        if verbose:
+                            print("Watch directories changed, restarting watcher...")
+                        break
+                    watched_files = new_files
+                except FigQuiltError:
+                    pass  # Keep watching existing files if layout is invalid
+
+        if stop_event and stop_event.is_set():
+            return
+        if not restart_watcher:
+            break
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="FigQuilt: Compose figures from multiple panels."
+    )
+    parser.add_argument("layout", type=Path, help="Path to layout YAML file")
+    parser.add_argument("output", type=Path, help="Path to output file (PDF/SVG/PNG)")
+    parser.add_argument(
+        "--format", choices=["pdf", "svg", "png"], help="Override output format"
+    )
+    parser.add_argument("--check", action="store_true", help="Validate layout only")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+    parser.add_argument(
+        "--watch", action="store_true", help="Watch for changes and rebuild"
+    )
+
+    args = parser.parse_args()
+
+    # Determine output format
+    suffix = args.output.suffix.lower()
+    fmt = args.format or suffix.lstrip(".")
+
+    if fmt not in ("pdf", "svg", "png"):
+        print(f"Unsupported format: {fmt}", file=sys.stderr)
+        sys.exit(1)
+
+    # Check-only mode
+    if args.check:
+        try:
+            layout = parse_layout(args.layout)
+            print(f"Layout parsed successfully: {args.layout}")
+            print(
+                f"Page size: {layout.page.width}x{layout.page.height} {layout.page.units}"
+            )
+            print(f"Panels: {len(layout.panels)}")
+            sys.exit(0)
+        except FigQuiltError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Watch mode
+    if args.watch:
+        try:
+            run_watch_mode(args.layout, args.output, fmt, args.verbose)
+        except KeyboardInterrupt:
+            print("\nStopped watching.")
+            sys.exit(0)
+        return
+
+    # Single build mode
+    if compose_figure(args.layout, args.output, fmt, args.verbose):
+        print(f"Successfully created: {args.output}")
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{figquilt-0.1.0 → figquilt-0.1.2}/src/figquilt/compose_pdf.py

@@ -4,6 +4,7 @@ from .layout import Layout, Panel
 from .units import mm_to_pt
 from .errors import FigQuiltError
 
+
 class PDFComposer:
     def __init__(self, layout: Layout):
         self.layout = layout
@@ -29,20 +30,20 @@ class PDFComposer:
             # Minimal hex parser:
             col = self._parse_color(self.layout.page.background)
             if col:
-                 page.draw_rect(page.rect, color=col, fill=col)
+                page.draw_rect(page.rect, color=col, fill=col)
 
         # Draw panels
         for i, panel in enumerate(self.layout.panels):
             self._place_panel(doc, page, panel, index=i)
-        
+
         return doc
-    
+
     def _parse_color(self, color_str: str):
         # Very basic hex support
         if color_str.startswith("#"):
-            h = color_str.lstrip('#')
+            h = color_str.lstrip("#")
             try:
-                rgb = tuple(int(h[i:i+2], 16)/255.0 for i in (0, 2, 4))
+                rgb = tuple(int(h[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
                 return rgb
             except:
                 return None
@@ -52,17 +53,20 @@ class PDFComposer:
         # We process images, so PIL is available.
         try:
             from PIL import ImageColor
+
             rgb = ImageColor.getrgb(color_str)
-            return tuple(c/255.0 for c in rgb)
+            return tuple(c / 255.0 for c in rgb)
         except:
-             return None
+            return None
 
-    def _place_panel(self, doc: fitz.Document, page: fitz.Page, panel: Panel, index: int):
+    def _place_panel(
+        self, doc: fitz.Document, page: fitz.Page, panel: Panel, index: int
+    ):
         # Calculate position and size first
         x = mm_to_pt(panel.x)
         y = mm_to_pt(panel.y)
         w = mm_to_pt(panel.width)
-        
+
         # Determine height from aspect ratio if needed
         # We need to open the source to get aspect ratio
         try:
@@ -71,35 +75,41 @@ class PDFComposer:
         except Exception as e:
             raise FigQuiltError(f"Failed to open panel file {panel.file}: {e}")
 
-        # Get source dimension
-        if src_doc.is_pdf:
-            src_page = src_doc[0]
-            src_rect = src_page.rect
-        else:
-            # For images/SVG, fitz doc acts like a list of pages too?
-            # Yes, usually page[0] is the image/svg content.
-            src_page = src_doc[0]
-            src_rect = src_page.rect
-
-        aspect = src_rect.height / src_rect.width
-        
-        if panel.height is not None:
-             h = mm_to_pt(panel.height)
-        else:
-            h = w * aspect
-
-        rect = fitz.Rect(x, y, x + w, y + h)
-
-        if src_doc.is_pdf:
-             page.show_pdf_page(rect, src_doc, 0)
-        elif panel.file.suffix.lower() == ".svg":
-             # Convert SVG to PDF in memory to allow vector embedding
-             pdf_bytes = src_doc.convert_to_pdf()
-             src_pdf = fitz.open("pdf", pdf_bytes)
-             page.show_pdf_page(rect, src_pdf, 0)
-        else:
-            # Insert as image (works for PNG/JPEG)
-            page.insert_image(rect, filename=panel.file)
+        try:
+            # Get source dimension
+            if src_doc.is_pdf:
+                src_page = src_doc[0]
+                src_rect = src_page.rect
+            else:
+                # For images/SVG, fitz doc acts like a list of pages too?
+                # Yes, usually page[0] is the image/svg content.
+                src_page = src_doc[0]
+                src_rect = src_page.rect
+
+            aspect = src_rect.height / src_rect.width
+
+            if panel.height is not None:
+                h = mm_to_pt(panel.height)
+            else:
+                h = w * aspect
+
+            rect = fitz.Rect(x, y, x + w, y + h)
+
+            if src_doc.is_pdf:
+                page.show_pdf_page(rect, src_doc, 0)
+            elif panel.file.suffix.lower() == ".svg":
+                # Convert SVG to PDF in memory to allow vector embedding
+                pdf_bytes = src_doc.convert_to_pdf()
+                src_pdf = fitz.open("pdf", pdf_bytes)
+                try:
+                    page.show_pdf_page(rect, src_pdf, 0)
+                finally:
+                    src_pdf.close()
+            else:
+                # Insert as image (works for PNG/JPEG)
+                page.insert_image(rect, filename=panel.file)
+        finally:
+            src_doc.close()
 
         # Labels
         self._draw_label(page, panel, rect, index)
@@ -107,14 +117,14 @@ class PDFComposer:
     def _draw_label(self, page: fitz.Page, panel: Panel, rect: fitz.Rect, index: int):
         # Determine effective label settings
         style = panel.label_style if panel.label_style else self.layout.page.label
-        
+
         if not style.enabled:
             return
 
         text = panel.label
         if text is None and style.auto_sequence:
             text = chr(65 + index)  # A, B, C...
-        
+
         if not text:
             return
 
@@ -126,10 +136,10 @@ class PDFComposer:
         # SVG implementation uses 'hanging' baseline, so (0,0) is top-left of text char.
         # PyMuPDF insert_text uses 'baseline', so (0,0) is bottom-left of text char.
         # We need to shift Y down by approximately the font sizing to match SVG visual.
-        
+
         pos_x = rect.x0 + mm_to_pt(style.offset_x_mm)
         raw_y = rect.y0 + mm_to_pt(style.offset_y_mm)
-        
+
         # Approximate baseline shift: font_size
         # (A more precise way uses font.ascender, but for basic standard fonts, size is decent proxy for visual top->baseline)
         pos_y = raw_y + style.font_size_pt
@@ -137,7 +147,9 @@ class PDFComposer:
         # Font - PyMuPDF supports base 14 fonts by name
         fontname = "helv"  # default mapping for Helvetica
         if style.bold:
-            fontname = "HeBo" # Helvetica-Bold
-        
+            fontname = "HeBo"  # Helvetica-Bold
+
         # Insert text
-        page.insert_text((pos_x, pos_y), text, fontsize=style.font_size_pt, fontname=fontname)
+        page.insert_text(
+            (pos_x, pos_y), text, fontsize=style.font_size_pt, fontname=fontname
+        )

{figquilt-0.1.0 → figquilt-0.1.2}/src/figquilt/compose_svg.py

@@ -6,6 +6,7 @@ from .units import mm_to_pt
 from .errors import FigQuiltError
 import fitz
 
+
 class SVGComposer:
     def __init__(self, layout: Layout):
         self.layout = layout
@@ -14,13 +15,16 @@ class SVGComposer:
 
     def compose(self, output_path: Path):
         # Create root SVG element
-        nsmap = {None: "http://www.w3.org/2000/svg", "xlink": "http://www.w3.org/1999/xlink"}
+        nsmap = {
+            None: "http://www.w3.org/2000/svg",
+            "xlink": "http://www.w3.org/1999/xlink",
+        }
         root = etree.Element("svg", nsmap=nsmap)
         root.set("width", f"{self.layout.page.width}mm")
         root.set("height", f"{self.layout.page.height}mm")
         root.set("viewBox", f"0 0 {self.width_pt} {self.height_pt}")
         root.set("version", "1.1")
-        
+
         if self.layout.page.background:
             # Draw background
             bg = etree.SubElement(root, "rect")
@@ -41,76 +45,78 @@ class SVGComposer:
         x = mm_to_pt(panel.x)
         y = mm_to_pt(panel.y)
         w = mm_to_pt(panel.width)
-        
+
         # Determine content sizing
         # For simplicity in V0, relying on fitz for aspect ratio of all inputs (robust)
         try:
-             src_doc = fitz.open(panel.file)
-             src_page = src_doc[0]
-             src_rect = src_page.rect
-             aspect = src_rect.height / src_rect.width
+            src_doc = fitz.open(panel.file)
         except Exception as e:
             raise FigQuiltError(f"Failed to inspect panel {panel.file}: {e}")
 
-        if panel.height is not None:
-            h = mm_to_pt(panel.height)
-        else:
-            h = w * aspect
-
-        # Group for the panel
-        g = etree.SubElement(root, "g")
-        g.set("transform", f"translate({x}, {y})")
-        
-        # Insert content
-        # Check if SVG
-        suffix = panel.file.suffix.lower()
-        if suffix == ".svg":
-            # Embed SVG by creating an <image> tag with data URI to avoid DOM conflicts
-            # This is safer than merging trees for V0.
-            # Merging trees requires stripping root, handling viewbox/transform matching.
-            # <image> handles scaling automatically.
-            data_uri = self._get_data_uri(panel.file, "image/svg+xml")
-            img = etree.SubElement(g, "image")
-            img.set("width", str(w))
-            img.set("height", str(h))
-            img.set("{http://www.w3.org/1999/xlink}href", data_uri)
-        else:
-            # PDF or Raster Image
-            # For PDF, we rasterize to PNG (easiest for SVG compatibility without huge libs) or embed as image/pdf?
-            # Browsers don't support image/pdf in SVG.
-            # So if PDF, convert to PNG.
-            # If PNG/JPG, embed directly.
-            
-            mime = "image/png"
-            if suffix in [".jpg", ".jpeg"]:
-                mime = "image/jpeg"
-                data_path = panel.file
-            elif suffix == ".png":
-                 mime = "image/png"
-                 data_path = panel.file
-            elif suffix == ".pdf":
-                 # Rasterize page to PNG
-                 pix = src_page.get_pixmap(dpi=300) # Use decent DPI
-                 data = pix.tobytes("png")
-                 # We can't use _get_data_uri directly on file, we have bytes
-                 b64 = base64.b64encode(data).decode("utf-8")
-                 data_uri = f"data:image/png;base64,{b64}"
-                 data_path = None # signal that we have URI
+        try:
+            src_page = src_doc[0]
+            src_rect = src_page.rect
+            aspect = src_rect.height / src_rect.width
+
+            if panel.height is not None:
+                h = mm_to_pt(panel.height)
             else:
-                 # Fallback
-                 mime = "application/octet-stream"
-                 data_path = panel.file
+                h = w * aspect
+
+            # Group for the panel
+            g = etree.SubElement(root, "g")
+            g.set("transform", f"translate({x}, {y})")
 
-            if data_path:
-                data_uri = self._get_data_uri(data_path, mime)
-            
-            img = etree.SubElement(g, "image")
-            img.set("width", str(w))
-            img.set("height", str(h))
-            img.set("{http://www.w3.org/1999/xlink}href", data_uri)
+            # Insert content
+            # Check if SVG
+            suffix = panel.file.suffix.lower()
+            if suffix == ".svg":
+                # Embed SVG by creating an <image> tag with data URI to avoid DOM conflicts
+                # This is safer than merging trees for V0.
+                # Merging trees requires stripping root, handling viewbox/transform matching.
+                # <image> handles scaling automatically.
+                data_uri = self._get_data_uri(panel.file, "image/svg+xml")
+                img = etree.SubElement(g, "image")
+                img.set("width", str(w))
+                img.set("height", str(h))
+                img.set("{http://www.w3.org/1999/xlink}href", data_uri)
+            else:
+                # PDF or Raster Image
+                # For PDF, we rasterize to PNG (easiest for SVG compatibility without huge libs)
+                # Browsers don't support image/pdf in SVG.
+                # If PNG/JPG, embed directly.
 
-        # Label
-        self._draw_label(g, panel, w, h, index)
+                mime = "image/png"
+                if suffix in [".jpg", ".jpeg"]:
+                    mime = "image/jpeg"
+                    data_path = panel.file
+                elif suffix == ".png":
+                    mime = "image/png"
+                    data_path = panel.file
+                elif suffix == ".pdf":
+                    # Rasterize page to PNG
+                    pix = src_page.get_pixmap(dpi=300)
+                    data = pix.tobytes("png")
+                    b64 = base64.b64encode(data).decode("utf-8")
+                    data_uri = f"data:image/png;base64,{b64}"
+                    data_path = None  # signal that we have URI
+                else:
+                    # Fallback
+                    mime = "application/octet-stream"
+                    data_path = panel.file
+
+                if data_path:
+                    data_uri = self._get_data_uri(data_path, mime)
+
+                img = etree.SubElement(g, "image")
+                img.set("width", str(w))
+                img.set("height", str(h))
+                img.set("{http://www.w3.org/1999/xlink}href", data_uri)
+
+            # Label
+            self._draw_label(g, panel, w, h, index)
+        finally:
+            src_doc.close()
 
     def _get_data_uri(self, path: Path, mime: str) -> str:
         with open(path, "rb") as f:
@@ -118,7 +124,9 @@ class SVGComposer:
         b64 = base64.b64encode(data).decode("utf-8")
         return f"data:{mime};base64,{b64}"
 
-    def _draw_label(self, parent: etree.Element, panel: Panel, w: float, h: float, index: int):
+    def _draw_label(
+        self, parent: etree.Element, panel: Panel, w: float, h: float, index: int
+    ):
         style = panel.label_style if panel.label_style else self.layout.page.label
         if not style.enabled:
             return
@@ -134,20 +142,20 @@ class SVGComposer:
         # Offset (relative to panel top-left, which is 0,0 inside the group)
         x = mm_to_pt(style.offset_x_mm)
         y = mm_to_pt(style.offset_y_mm)
-        
+
         # Create text element
         txt = etree.SubElement(parent, "text")
         txt.text = text_str
         txt.set("x", str(x))
         txt.set("y", str(y))
-        
+
         # Style
         # Font family is tricky in SVG (system fonts).
         txt.set("font-family", style.font_family)
         txt.set("font-size", f"{style.font_size_pt}pt")
         if style.bold:
             txt.set("font-weight", "bold")
-        
+
         # Baseline alignment? SVG text y is usually baseline.
         # If we want top-left of text at (x,y), we should adjust or use dominant-baseline.
-        txt.set("dominant-baseline", "hanging") # Matches top-down coordinate logic
+        txt.set("dominant-baseline", "hanging")  # Matches top-down coordinate logic

figquilt-0.1.0/src/figquilt/cli.py

@@ -1,65 +0,0 @@
-import argparse
-import sys
-from pathlib import Path
-from .parser import parse_layout
-from .errors import FigQuiltError
-
-def main():
-    parser = argparse.ArgumentParser(description="FigQuilt: Compose figures from multiple panels.")
-    parser.add_argument("layout", type=Path, help="Path to layout YAML file")
-    parser.add_argument("output", type=Path, help="Path to output file (PDF/SVG/PNG)")
-    parser.add_argument("--format", choices=["pdf", "svg", "png"], help="Override output format")
-    parser.add_argument("--check", action="store_true", help="Validate layout only")
-    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
-    
-    args = parser.parse_args()
-
-    try:
-        layout = parse_layout(args.layout)
-        print(f"Layout parsed successfully: {args.layout}")
-        print(f"Page size: {layout.page.width}x{layout.page.height} {layout.page.units}")
-        print(f"Panels: {len(layout.panels)}")
-        
-        if args.check:
-            sys.exit(0)
-
-        # Determine output format
-        suffix = args.output.suffix.lower()
-        fmt = args.format or suffix.lstrip('.')
-        
-        if fmt == 'pdf':
-            from .compose_pdf import PDFComposer
-            composer = PDFComposer(layout)
-            composer.compose(args.output)
-            print(f"Successfully created: {args.output}")
-        
-        elif fmt == 'svg':
-            from .compose_svg import SVGComposer
-            composer = SVGComposer(layout)
-            composer.compose(args.output)
-            print(f"Successfully created: {args.output}")
-            
-        elif fmt == 'png':
-            from .compose_pdf import PDFComposer
-            composer = PDFComposer(layout)
-            doc = composer.build()
-            # Rasterize first page
-            page = doc[0]
-            pix = page.get_pixmap(dpi=layout.page.dpi)
-            pix.save(str(args.output))
-            doc.close()
-            print(f"Successfully created: {args.output}")
-            
-        else:
-            print(f"Unsupported format: {fmt}", file=sys.stderr)
-            sys.exit(1)
-
-    except FigQuiltError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()