v2 - docx and convert

5c0a85854a32a7593a2a8b6bac4a24efa3f6d353

permissionBRICK <you@example.com>

Parents: 15db1f8fa89eb8befa7ea04bbf369d17c66a5919

Dockerfile+1 -1 Viewed

 FROM python:3.12-slim
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends pandoc && \
+    apt-get install -y --no-install-recommends pandoc calibre && \
     rm -rf /var/lib/apt/lists/*
 RUN mkdir -p /app /output

README.md+7 -6 Viewed

-# Obsidian Markdown to EPUB Pipeline
+# Obsidian Markdown to Ebook Pipeline
-This container watches a mounted markdown share for story folders and generates EPUB files into a separate mounted output folder.
+This container watches a mounted markdown share for story folders and generates DOCX, EPUB, and MOBI files into a separate mounted output folder.
 ## How it works
 . The container scans the mounted vault under `/vault/<CREATIVE_FOLDER>`.
 . Each story folder is identified by a `metadata.md` file with YAML frontmatter.
-. If that frontmatter contains `export: true`, the container merges the sibling chapter `.md` files in that folder and converts them to EPUB with `pandoc`.
+. If that frontmatter contains `export: true`, the container merges the sibling chapter `.md` files in that folder and exports a DOCX with `pandoc`.
-. The finished EPUB is written to `/output` and explicitly set to mode `0644` so it is readable by all users.
+. That DOCX is then converted into EPUB and MOBI with Calibre's `ebook-convert`.
-. The container resets `export: false` in the story's `metadata.md`.
+. The finished files are written to `/output`, with `.docx` in the root plus `/output/epub` and `/output/mobi` subfolders for the other formats. All generated files are set to mode `0644` so they are readable by all users.
+. The container resets `export: false` in the story's `metadata.md`.
 ## Story layout

 | `VAULT_PATH` | `/vault` | Mounted source folder |
 | `OUTPUT_DIR` | `/output` | Mounted output folder |
 | `LUA_FILTER_PATH` | `/app/center-v.lua` | Pandoc Lua filter |
-| `CSS_FILE_PATH` | `/app/epub-style.css` | EPUB stylesheet |
+| `CSS_FILE_PATH` | `/app/epub-style.css` | Extra stylesheet used during EPUB and MOBI conversion |
 ## Docker Hub publishing flow

epub_builder.py+155 -124 Viewed

 """
-Story discovery and EPUB build pipeline.
+Story discovery and ebook build pipeline.
 Scans the vault for metadata.md files (with YAML frontmatter), discovers
-chapter files, merges them into a single markdown document, and converts
+chapter files, merges them into a single markdown document, exports a DOCX
-to EPUB via pandoc.
+via pandoc, then converts that DOCX to EPUB and MOBI.
 """
 import logging

 METADATA_FILENAME = "metadata.md"
 DEFAULT_OUTPUT_FILE_MODE = 0o644
+EPUB_SUBDIR = "epub"
+MOBI_SUBDIR = "mobi"
 def parse_frontmatter(text: str) -> dict:
-    """Extract YAML frontmatter from a markdown file.
+    """Extract YAML frontmatter from a markdown file."""
-    Expects the file to start with '---', followed by YAML, closed by '---'.
-    Returns the parsed dict, or {} if no valid frontmatter found.
-    """
     text = text.strip()
     if not text.startswith("---"):
         return {}
-    # Find the closing ---
     end = text.find("---", 3)
     if end == -1:
         return {}
     yaml_block = text[3:end].strip()
     try:
         return yaml.safe_load(yaml_block) or {}

 def write_frontmatter(metadata: dict, original_text: str) -> str:
-    """Replace the YAML frontmatter in a markdown file, preserving body content.
+    """Replace the YAML frontmatter in a markdown file, preserving body content."""
-    If there's content after the frontmatter, it's kept intact.
-    """
     body = ""
     original_text = original_text.strip()
     if original_text.startswith("---"):

 def natural_sort_key(path: Path) -> tuple:
-    """Sort chapter files by their chapter number naturally.
+    """Sort chapter files by chapter number when possible."""
-    Handles filenames like 'Chapter 1 - Title.md', 'Chapter 10 - Title.md', etc.
-    Falls back to alphabetical if no chapter number is found.
-    """
     name = path.stem
-    # Try to extract chapter number from common patterns
-    match = re.search(r'[Cc]hapter\s+(\d+)', name)
+    match = re.search(r"[Cc]hapter\s+(\d+)", name)
     if match:
         return (0, int(match.group(1)), name)
-    # Try plain number at start
-    match = re.match(r'(\d+)', name)
+    match = re.match(r"(\d+)", name)
     if match:
         return (0, int(match.group(1)), name)
-    # Fallback: alphabetical, but after numbered chapters
     return (1, 0, name)
 def discover_stories(vault_path: Path, creative_folder: str = "Creative") -> list[dict]:
-    """Recursively scan for metadata.md files under the creative folder.
+    """Recursively scan for metadata.md files under the creative folder."""
-    Each metadata.md (with YAML frontmatter) marks a story directory.
-    All other .md files in the same directory (not subfolders) are treated
-    as chapter files.
-    Returns a list of story dicts with keys:
-        - path: Path to the story directory
-        - metadata_file: Path to the metadata.md
-        - metadata: Parsed frontmatter dict
-        - metadata_raw: Raw text of the metadata.md file
-        - chapters: List of chapter file Paths, sorted by chapter number
-    """
     creative_path = vault_path / creative_folder
     if not creative_path.exists():
         logger.warning(f"Creative folder not found: {creative_path}")

             logger.warning(f"No valid frontmatter in {metadata_file}, skipping")
             continue
-        # Collect .md files in the story directory (not subdirectories)
         chapters = sorted(
-            [f for f in story_dir.iterdir()
+            [f for f in story_dir.iterdir() if f.suffix == ".md" and f.name != METADATA_FILENAME],
-             if f.suffix == ".md" and f.name != METADATA_FILENAME],
+            key=natural_sort_key,
-            key=natural_sort_key
+        )
-        stories.append({
+        stories.append(
-            "path": story_dir,
+            {
-            "metadata_file": metadata_file,
+                "path": story_dir,
-            "metadata": metadata,
+                "metadata_file": metadata_file,
-            "metadata_raw": raw_text,
+                "metadata": metadata,
-            "chapters": chapters,
+                "metadata_raw": raw_text,
-        })
+                "chapters": chapters,
-        logger.info(f"Discovered story: {metadata.get('title', story_dir.name)} "
+            }
-                     f"({len(chapters)} chapters)")
+        )
+        logger.info(
+            f"Discovered story: {metadata.get('title', story_dir.name)} "
+            f"({len(chapters)} chapters)"
+        )
     return stories
 def merge_chapters(chapters: list[Path], add_page_breaks: bool = True) -> str:
-    """Merge chapter markdown files into a single document.
+    """Merge chapter markdown files into a single document."""
-    Inserts pagebreak divs between chapters for pandoc to interpret.
-    """
     merged_parts = []
     for i, chapter_file in enumerate(chapters):

             continue
         if i > 0 and add_page_breaks:
-            # Pandoc-compatible page break (works for EPUB and DOCX)
             merged_parts.append('\n\n<div style="page-break-before: always;"></div>\n\n')
         merged_parts.append(content)

     return "\n\n".join(merged_parts)
-def build_epub(story: dict, output_dir: Path, lua_filter: Optional[Path] = None,
+def sanitize_title(title: str) -> str:
-               css_file: Optional[Path] = None) -> Optional[Path]:
+    """Convert a story title into a safe base filename."""
-    """Build an EPUB from a story's merged chapters using pandoc.
+    return re.sub(r"[^\w\s-]", "", title).strip()
-    Args:
-        story: Story dict from discover_stories()
-        output_dir: Directory to write the EPUB to
-        lua_filter: Path to the center-v.lua filter
-        css_file: Optional custom CSS file for EPUB styling
-    Returns:
+def get_cover_path(story: dict) -> Optional[Path]:
-        Path to the generated EPUB, or None on failure.
+    """Resolve a configured or auto-detected cover image for the story."""
-    """
+    metadata = story["metadata"]
+    cover = metadata.get("cover")
+    if cover:
+        cover_path = story["path"] / cover
+        if cover_path.exists():
+            return cover_path
+        logger.warning(f"Cover image specified but not found: {cover_path}")
+        return None
+    for ext in ["jpg", "jpeg", "png"]:
+        candidate = story["path"] / f"cover.{ext}"
+        if candidate.exists():
+            return candidate
+    return None
+def set_output_permissions(*paths: Path):
+    """Set predictable readable permissions on generated output files."""
+    for path in paths:
+        os.chmod(path, DEFAULT_OUTPUT_FILE_MODE)
+def run_command(cmd: list[str], title: str, output_label: str) -> bool:
+    """Run an external command and log any failure details."""
+    logger.debug(f"Running: {' '.join(cmd)}")
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        timeout=240,
+    )
+    if result.returncode != 0:
+        logger.error(f"{output_label} build failed for '{title}':\n{result.stderr}")
+        return False
+    if result.stderr:
+        logger.warning(f"{output_label} warnings for '{title}':\n{result.stderr}")
+    return True
+def build_outputs(
+    story: dict,
+    output_dir: Path,
+    lua_filter: Optional[Path] = None,
+    css_file: Optional[Path] = None,
+) -> Optional[dict[str, Path]]:
+    """Build DOCX, EPUB, and MOBI outputs for a story."""
     metadata = story["metadata"]
     title = metadata.get("title", story["path"].name)
     author = metadata.get("author", "Unknown Author")
     language = metadata.get("language", "en")
-    # Sanitize filename
+    safe_title = sanitize_title(title)
-    safe_title = re.sub(r'[^\w\s-]', '', title).strip()
+    epub_dir = output_dir / EPUB_SUBDIR
-    output_file = output_dir / f"{safe_title}.epub"
+    mobi_dir = output_dir / MOBI_SUBDIR
+    docx_file = output_dir / f"{safe_title}.docx"
+    epub_file = epub_dir / f"{safe_title}.epub"
+    mobi_file = mobi_dir / f"{safe_title}.mobi"
     output_dir.mkdir(parents=True, exist_ok=True)
+    epub_dir.mkdir(parents=True, exist_ok=True)
+    mobi_dir.mkdir(parents=True, exist_ok=True)
     if not story["chapters"]:
         logger.warning(f"No chapters found for '{title}', skipping")
         return None
-    logger.info(f"Building EPUB: '{title}' ({len(story['chapters'])} chapters)")
+    logger.info(f"Building book files: '{title}' ({len(story['chapters'])} chapters)")
-    # Merge all chapters into a single markdown string
     merged_content = merge_chapters(story["chapters"])
+    cover_path = get_cover_path(story)
-    # Write merged content to a temp file for pandoc
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as tmp:
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False,
-                                      encoding="utf-8") as tmp:
         tmp.write(merged_content)
         tmp_path = tmp.name
     try:
-        # Build pandoc command
+        docx_cmd = [
-        cmd = [
             "pandoc",
             tmp_path,
-            "-o", str(output_file),
+            "-o",
-            "--from", "markdown+raw_html",
+            str(docx_file),
-            "--to", "epub3",
+            "--from",
-            "--metadata", f"title={title}",
+            "markdown+raw_html",
-            "--metadata", f"author={author}",
+            "--to",
-            "--metadata", f"lang={language}",
+            "docx",
+            "--metadata",
+            f"title={title}",
+            "--metadata",
+            f"author={author}",
+            "--metadata",
+            f"lang={language}",
             "--toc",
             "--toc-depth=1",
-            "--split-level=1",
             "--wrap=none",
+        ]
-        # Add cover image: use metadata field if set, otherwise auto-detect
+        if lua_filter and lua_filter.exists():
-        cover = metadata.get("cover")
+            docx_cmd.extend(["--lua-filter", str(lua_filter)])
-        cover_path = None
-        if cover:
+        if not run_command(docx_cmd, title, "DOCX"):
-            cover_path = story["path"] / cover
+            return None
-            if not cover_path.exists():
+        logger.info(f"DOCX created: {docx_file}")
-                logger.warning(f"Cover image specified but not found: {cover_path}")
-                cover_path = None
+        base_convert_cmd = [
-        else:
+            "--title",
-            # Auto-detect cover.jpg / cover.png in the story folder
+            title,
-            for ext in ["jpg", "jpeg", "png"]:
+            "--authors",
-                candidate = story["path"] / f"cover.{ext}"
+            author,
-                if candidate.exists():
+            "--language",
-                    cover_path = candidate
+            language,
-                    break
+            "--chapter",
+            "//h:h1|//h:h2",
+            "--level1-toc",
+            "//h:h1",
+            "--level2-toc",
+            "//h:h2",
+            "--max-toc-links",
+            "500",
+        ]
+        epub_cmd = ["ebook-convert", str(docx_file), str(epub_file), *base_convert_cmd]
+        mobi_cmd = ["ebook-convert", str(docx_file), str(mobi_file), *base_convert_cmd]
         if cover_path:
-            cmd.extend(["--epub-cover-image", str(cover_path)])
             logger.info(f"Using cover image: {cover_path.name}")
+            epub_cmd.extend(["--cover", str(cover_path)])
+            mobi_cmd.extend(["--cover", str(cover_path)])
-        # Add custom CSS
         if css_file and css_file.exists():
-            cmd.extend(["--css", str(css_file)])
+            epub_cmd.extend(["--extra-css", str(css_file)])
+            mobi_cmd.extend(["--extra-css", str(css_file)])
-        # Add lua filter for ~V~ handling
-        if lua_filter and lua_filter.exists():
-            cmd.extend(["--lua-filter", str(lua_filter)])
-        logger.debug(f"Running: {' '.join(cmd)}")
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=120,
-        )
-        if result.returncode != 0:
+        if not run_command(epub_cmd, title, "EPUB"):
-            logger.error(f"Pandoc failed for '{title}':\n{result.stderr}")
             return None
+        logger.info(f"EPUB created: {epub_file}")
-        if result.stderr:
+        if not run_command(mobi_cmd, title, "MOBI"):
-            logger.warning(f"Pandoc warnings for '{title}':\n{result.stderr}")
+            return None
+        logger.info(f"MOBI created: {mobi_file}")
-        # Keep generated books readable to any user sharing the mounted output.
+        set_output_permissions(docx_file, epub_file, mobi_file)
-        os.chmod(output_file, DEFAULT_OUTPUT_FILE_MODE)
+        return {"docx": docx_file, "epub": epub_file, "mobi": mobi_file}
-        logger.info(f"EPUB created: {output_file}")
-        return output_file
     except subprocess.TimeoutExpired:
-        logger.error(f"Pandoc timed out for '{title}'")
+        logger.error(f"Build timed out for '{title}'")
-        return None
     except Exception as e:
-        logger.error(f"EPUB build failed for '{title}': {e}")
+        logger.error(f"Build failed for '{title}': {e}")
-        return None
     finally:
         Path(tmp_path).unlink(missing_ok=True)
+    return None

main.py+10 -13 Viewed

 #!/usr/bin/env python3
 """
-Obsidian EPUB Exporter
+Obsidian ebook exporter.
 Watches a mounted Obsidian vault for metadata.md files with `export: true`
-in their YAML frontmatter. When found, merges all chapter .md files in that
+in their YAML frontmatter. When found, it builds DOCX, EPUB, and MOBI files
-folder into a single EPUB via pandoc, and writes it to the mounted output folder.
+in the mounted output folder, then resets the flag back to false.
-and resets the flag back to false.
-Designed to run as a small polling container with the source markdown share
-and destination EPUB share mounted into it.
 """
 import logging

 import time
 from pathlib import Path
-from epub_builder import build_epub, discover_stories, write_frontmatter
+from epub_builder import build_outputs, discover_stories, write_frontmatter
 # ── Configuration from environment variables ──────────────────────────

 def process_exports(vault_path: Path):
-    """Scan for stories with export: true and build EPUBs."""
+    """Scan for stories with export: true and build ebook outputs."""
     stories = discover_stories(vault_path, CREATIVE_FOLDER)
     to_export = [s for s in stories if s["metadata"].get("export") is True]

         title = story["metadata"].get("title", story["path"].name)
         logger.info(f"Export requested for: '{title}'")
-        epub_path = build_epub(
+        built_files = build_outputs(
             story=story,
             output_dir=output_path,
             lua_filter=lua_filter,
             css_file=css_file if css_file and css_file.exists() else None,
+        )
-        if epub_path:
+        if built_files:
-            logger.info(f"Successfully exported: {epub_path}")
+            created = ", ".join(str(path.name) for path in built_files.values())
+            logger.info(f"Successfully exported: {created}")
             reset_export_flag(story)
         else:
             logger.error(f"Failed to export '{title}'")

 def main():
     logger.info("=" * 60)
-    logger.info("Obsidian EPUB Exporter starting up")
+    logger.info("Obsidian ebook exporter starting up")
     logger.info("=" * 60)
     logger.info(f"Vault path: {VAULT_PATH}")
     logger.info(f"Creative folder: {CREATIVE_FOLDER}")