initial commit

15db1f8fa89eb8befa7ea04bbf369d17c66a5919

permissionBRICK <you@example.com>

.gitignore+1 -0 Viewed

@@ -0,0 +1 @@
		1	/__pycache__
	\ No newline at end of file	1	\ No newline at end of file

Dockerfile+22 -0 Viewed

+FROM python:3.12-slim
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends pandoc && \
+    rm -rf /var/lib/apt/lists/*
+RUN mkdir -p /app /output
+WORKDIR /app
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+COPY main.py epub_builder.py /app/
+COPY center-v.lua /app/
+COPY epub-style.css /app/
+# /vault  - mount your markdown source folder here (read-write for flag reset)
+# /output - mount your EPUB destination folder here
+VOLUME ["/vault", "/output"]
+CMD ["python", "-u", "main.py"]

README.md+81 -0 Viewed

+# Obsidian Markdown to EPUB Pipeline
+This container watches a mounted markdown share for story folders and generates EPUB 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`.
+. The finished EPUB is written to `/output` and explicitly set to mode `0644` so it is readable by all users.
+. The container resets `export: false` in the story's `metadata.md`.
+## Story layout
+Only markdown files directly inside the story folder are treated as chapters. Subfolders are ignored.
+```text
+Creative/
+  Novel Name/
+    metadata.md
+    Chapter 1 - Opening.md
+    Chapter 2 - Next Scene.md
+    cover.jpg
+```
+Example `metadata.md`:
+```md
+---
+title: "Novel Name"
+author: "Your Name"
+language: en
+export: false
+# cover: cover.jpg
+---
+```
+## Run with Docker Compose
+Update [`docker-compose.yml`](/Users/DevUser/Desktop/SyncNotes/obsidian-epub-pipeline/docker-compose.yml) to point at your real folders, then run:
+```bash
+docker compose up -d --build
+```
+Watch logs with:
+```bash
+docker compose logs -f
+```
+## Environment
+| Variable | Default | Description |
+|---|---|---|
+| `CREATIVE_FOLDER` | `Creative` | Subfolder under `/vault` to scan |
+| `POLL_INTERVAL` | `10` | Seconds between scans |
+| `LOG_LEVEL` | `INFO` | Python logging level |
+| `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 |
+## Docker Hub publishing flow
+Build and test locally first:
+```bash
+docker build -t YOUR_DOCKERHUB_USERNAME/obsidian-epub-pipeline:latest .
+docker run --rm ^
+  -v /path/to/markdown/share:/vault ^
+  -v /path/to/epub/output:/output ^
+  YOUR_DOCKERHUB_USERNAME/obsidian-epub-pipeline:latest
+```
+Then log in and push:
+```bash
+docker login
+docker push YOUR_DOCKERHUB_USERNAME/obsidian-epub-pipeline:latest
+```

center-v.lua+87 -0 Viewed

+-- center-v.lua
+-- Pandoc Lua filter for converting ~V~ section break symbols
+-- into properly centered paragraphs in EPUB/DOCX/HTML output.
+--
+-- Handles multiple input patterns that Obsidian might produce:
+--   1. <center>\n~V~\n</center>  (HTML blocks wrapping subscript)
+--   2. Raw ~V~ as a paragraph
+--   3. The tilde-based subscript interpretation (~V~ → subscript V)
+local function make_centered()
+  if FORMAT == "epub" or FORMAT == "epub3" or FORMAT == "html" or FORMAT == "html5" then
+    return pandoc.RawBlock("html", '<p style="text-align: center;">~V~</p>')
+  elseif FORMAT == "docx" or FORMAT == "openxml" then
+    return pandoc.RawBlock("openxml", [[
+<w:p>
+  <w:pPr><w:jc w:val="center"/></w:pPr>
+  <w:r><w:t xml:space="preserve">~V~</w:t></w:r>
+</w:p>
+]])
+  else
+    return pandoc.Para({pandoc.Str("~V~")})
+  end
+end
+function Pandoc(doc)
+  local newblocks = {}
+  local i = 1
+  while i <= #doc.blocks do
+    local b1 = doc.blocks[i]
+    local b2 = doc.blocks[i+1]
+    local b3 = doc.blocks[i+2]
+    -- Pattern 1: <center> block + subscript V + </center> block
+    if b1 and b2 and b3
+       and b1.t == "RawBlock" and b1.format == "html" and b1.text:match("^<center>%s*$")
+       and b2.t == "Plain"
+       and #b2.content == 1
+       and b2.content[1].t == "Subscript"
+       and #b2.content[1].content == 1
+       and b2.content[1].content[1].t == "Str"
+       and b2.content[1].content[1].text == "V"
+       and b3.t == "RawBlock" and b3.format == "html" and b3.text:match("^</center>%s*$")
+    then
+      table.insert(newblocks, make_centered())
+      i = i + 3
+    -- Pattern 2: Single paragraph containing just "~V~"
+    elseif b1 and b1.t == "Para"
+       and #b1.content == 1
+       and b1.content[1].t == "Str"
+       and b1.content[1].text == "~V~"
+    then
+      table.insert(newblocks, make_centered())
+      i = i + 1
+    -- Pattern 3: Plain block with subscript V (standalone, no center tags)
+    elseif b1 and b1.t == "Plain"
+       and #b1.content == 1
+       and b1.content[1].t == "Subscript"
+       and #b1.content[1].content == 1
+       and b1.content[1].content[1].t == "Str"
+       and b1.content[1].content[1].text == "V"
+    then
+      table.insert(newblocks, make_centered())
+      i = i + 1
+    -- Pattern 4: Para with Str "~" + Subscript "V" + Str "~" (tilde interpreted separately)
+    elseif b1 and b1.t == "Para"
+       and #b1.content == 3
+       and b1.content[1].t == "Str" and b1.content[1].text == "~"
+       and b1.content[2].t == "Subscript"
+       and #b1.content[2].content == 1
+       and b1.content[2].content[1].t == "Str"
+       and b1.content[2].content[1].text == "V"
+       and b1.content[3].t == "Str" and b1.content[3].text == "~"
+    then
+      table.insert(newblocks, make_centered())
+      i = i + 1
+    else
+      table.insert(newblocks, b1)
+      i = i + 1
+    end
+  end
+  doc.blocks = newblocks
+  return doc
+end

docker-compose.yml+17 -0 Viewed

+version: "3.8"
+services:
+  epub-exporter:
+    build: .
+    container_name: obsidian-epub-exporter
+    restart: unless-stopped
+    environment:
+      CREATIVE_FOLDER: "Creative"
+      POLL_INTERVAL: "10"
+      LOG_LEVEL: "INFO"
+    volumes:
+      # Source markdown share. Read-write is needed so export flags can be reset.
+      - /path/to/markdown/share:/vault
+      # Destination folder for generated EPUB files.
+      - /path/to/epub/output:/output

epub-style.css+64 -0 Viewed

+/* EPUB stylesheet - Times New Roman body text */
+body {
+    font-family: "Times New Roman", "Times", "Georgia", serif;
+    font-size: 1em;
+    line-height: 1.6;
+    margin: 1em;
+    text-align: justify;
+}
+h1 {
+    font-family: "Times New Roman", "Times", "Georgia", serif;
+    font-size: 1.8em;
+    font-weight: bold;
+    text-align: center;
+    margin-top: 2em;
+    margin-bottom: 1.5em;
+    page-break-before: always;
+}
+h2, h3, h4 {
+    font-family: "Times New Roman", "Times", "Georgia", serif;
+    font-weight: bold;
+}
+p {
+    margin-top: 0.3em;
+    margin-bottom: 0.3em;
+    text-indent: 1.5em;
+}
+/* First paragraph after a heading or break - no indent */
+h1 + p, h2 + p, h3 + p,
+.center-break + p,
+div[style*="page-break"] + p {
+    text-indent: 0;
+}
+/* Centered section break symbol (~V~) */
+p.center-break,
+p[style*="text-align: center"] {
+    text-indent: 0;
+    text-align: center;
+    margin-top: 1em;
+    margin-bottom: 1em;
+}
+/* Emphasis styles */
+em {
+    font-style: italic;
+}
+strong {
+    font-weight: bold;
+}
+/* Block quotes */
+blockquote {
+    font-style: italic;
+    margin-left: 2em;
+    margin-right: 2em;
+    border-left: 3px solid #ccc;
+    padding-left: 1em;
+}

epub_builder.py+269 -0 Viewed

+"""
+Story discovery and EPUB build pipeline.
+Scans the vault for metadata.md files (with YAML frontmatter), discovers
+chapter files, merges them into a single markdown document, and converts
+to EPUB via pandoc.
+"""
+import logging
+import os
+import re
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional
+import yaml
+logger = logging.getLogger(__name__)
+METADATA_FILENAME = "metadata.md"
+DEFAULT_OUTPUT_FILE_MODE = 0o644
+def parse_frontmatter(text: str) -> dict:
+    """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 {}
+    except yaml.YAMLError as e:
+        logger.error(f"Failed to parse YAML frontmatter: {e}")
+        return {}
+def write_frontmatter(metadata: dict, original_text: str) -> str:
+    """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("---"):
+        end = original_text.find("---", 3)
+        if end != -1:
+            body = original_text[end + 3:].strip()
+    yaml_str = yaml.dump(metadata, default_flow_style=False, allow_unicode=True).strip()
+    result = f"---\n{yaml_str}\n---"
+    if body:
+        result += f"\n\n{body}"
+    return result + "\n"
+def natural_sort_key(path: Path) -> tuple:
+    """Sort chapter files by their chapter number naturally.
+    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)
+    if match:
+        return (0, int(match.group(1)), name)
+    # Try plain number at start
+    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.
+    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}")
+        return []
+    stories = []
+    for metadata_file in creative_path.rglob(METADATA_FILENAME):
+        story_dir = metadata_file.parent
+        try:
+            raw_text = metadata_file.read_text(encoding="utf-8")
+            metadata = parse_frontmatter(raw_text)
+        except Exception as e:
+            logger.error(f"Failed to parse {metadata_file}: {e}")
+            continue
+        if not metadata:
+            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()
+             if f.suffix == ".md" and f.name != METADATA_FILENAME],
+            key=natural_sort_key
+        )
+        stories.append({
+            "path": story_dir,
+            "metadata_file": metadata_file,
+            "metadata": metadata,
+            "metadata_raw": raw_text,
+            "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.
+    Inserts pagebreak divs between chapters for pandoc to interpret.
+    """
+    merged_parts = []
+    for i, chapter_file in enumerate(chapters):
+        try:
+            content = chapter_file.read_text(encoding="utf-8").strip()
+        except Exception as e:
+            logger.error(f"Failed to read {chapter_file}: {e}")
+            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,
+               css_file: Optional[Path] = None) -> Optional[Path]:
+    """Build an EPUB from a story's merged chapters using pandoc.
+    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:
+        Path to the generated EPUB, or None on failure.
+    """
+    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 = re.sub(r'[^\w\s-]', '', title).strip()
+    output_file = output_dir / f"{safe_title}.epub"
+    output_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)")
+    # Merge all chapters into a single markdown string
+    merged_content = merge_chapters(story["chapters"])
+    # Write merged content to a temp file for pandoc
+    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
+        cmd = [
+            "pandoc",
+            tmp_path,
+            "-o", str(output_file),
+            "--from", "markdown+raw_html",
+            "--to", "epub3",
+            "--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
+        cover = metadata.get("cover")
+        cover_path = None
+        if cover:
+            cover_path = story["path"] / cover
+            if not cover_path.exists():
+                logger.warning(f"Cover image specified but not found: {cover_path}")
+                cover_path = None
+        else:
+            # Auto-detect cover.jpg / cover.png in the story folder
+            for ext in ["jpg", "jpeg", "png"]:
+                candidate = story["path"] / f"cover.{ext}"
+                if candidate.exists():
+                    cover_path = candidate
+                    break
+        if cover_path:
+            cmd.extend(["--epub-cover-image", str(cover_path)])
+            logger.info(f"Using cover image: {cover_path.name}")
+        # Add custom CSS
+        if css_file and css_file.exists():
+            cmd.extend(["--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:
+            logger.error(f"Pandoc failed for '{title}':\n{result.stderr}")
+            return None
+        if result.stderr:
+            logger.warning(f"Pandoc warnings for '{title}':\n{result.stderr}")
+        # Keep generated books readable to any user sharing the mounted output.
+        os.chmod(output_file, DEFAULT_OUTPUT_FILE_MODE)
+        logger.info(f"EPUB created: {output_file}")
+        return output_file
+    except subprocess.TimeoutExpired:
+        logger.error(f"Pandoc timed out for '{title}'")
+        return None
+    except Exception as e:
+        logger.error(f"EPUB build failed for '{title}': {e}")
+        return None
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)

main.py+132 -0 Viewed

+#!/usr/bin/env python3
+"""
+Obsidian EPUB 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
+folder into a single EPUB via pandoc, and writes it to the mounted output folder.
+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 os
+import sys
+import time
+from pathlib import Path
+from epub_builder import build_epub, discover_stories, write_frontmatter
+# ── Configuration from environment variables ──────────────────────────
+VAULT_PATH = os.environ.get("VAULT_PATH", "/vault")
+CREATIVE_FOLDER = os.environ.get("CREATIVE_FOLDER", "Creative")
+OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/output")
+LUA_FILTER_PATH = os.environ.get("LUA_FILTER_PATH", "/app/center-v.lua")
+CSS_FILE_PATH = os.environ.get("CSS_FILE_PATH", "/app/epub-style.css")
+# How often to scan for export flags (seconds)
+POLL_INTERVAL = int(os.environ.get("POLL_INTERVAL", "10"))
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")
+# ── Logging setup ─────────────────────────────────────────────────────
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL.upper(), logging.INFO),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+logger = logging.getLogger("epub-exporter")
+def reset_export_flag(story: dict):
+    """Reset the export flag to false in the metadata.md file."""
+    metadata_file = story["metadata_file"]
+    metadata = story["metadata"]
+    raw_text = story.get("metadata_raw", "")
+    metadata["export"] = False
+    new_content = write_frontmatter(metadata, raw_text)
+    try:
+        with open(metadata_file, "w", encoding="utf-8") as f:
+            f.write(new_content)
+        logger.info(f"Reset export flag: {metadata_file}")
+    except Exception as e:
+        logger.error(f"Failed to reset export flag in {metadata_file}: {e}")
+def process_exports(vault_path: Path):
+    """Scan for stories with export: true and build EPUBs."""
+    stories = discover_stories(vault_path, CREATIVE_FOLDER)
+    to_export = [s for s in stories if s["metadata"].get("export") is True]
+    if not to_export:
+        return
+    output_path = Path(OUTPUT_DIR)
+    lua_filter = Path(LUA_FILTER_PATH) if LUA_FILTER_PATH else None
+    css_file = Path(CSS_FILE_PATH) if CSS_FILE_PATH else None
+    for story in to_export:
+        title = story["metadata"].get("title", story["path"].name)
+        logger.info(f"Export requested for: '{title}'")
+        epub_path = build_epub(
+            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:
+            logger.info(f"Successfully exported: {epub_path}")
+            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("=" * 60)
+    logger.info(f"Vault path: {VAULT_PATH}")
+    logger.info(f"Creative folder: {CREATIVE_FOLDER}")
+    logger.info(f"Output dir: {OUTPUT_DIR}")
+    logger.info(f"Poll interval: {POLL_INTERVAL}s")
+    vault_path = Path(VAULT_PATH)
+    Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+    if not vault_path.exists():
+        logger.error(f"Vault path does not exist: {vault_path}")
+        logger.info("Waiting for vault to become available...")
+        while not vault_path.exists():
+            time.sleep(5)
+        logger.info("Vault path is now available")
+    # Check for any pending exports on startup
+    logger.info("Checking for pending exports...")
+    process_exports(vault_path)
+    # Main loop: poll the filesystem
+    logger.info("Entering watch loop...")
+    while True:
+        try:
+            time.sleep(POLL_INTERVAL)
+            process_exports(vault_path)
+        except KeyboardInterrupt:
+            logger.info("Shutting down gracefully...")
+            break
+        except Exception as e:
+            logger.error(f"Error in main loop: {e}")
+            time.sleep(POLL_INTERVAL)
+if __name__ == "__main__":
+    main()

requirements.txt+1 -0 Viewed

@@ -0,0 +1 @@
		1	PyYAML>=6.0