Initial commit

9f53616abc84e79b831bd28c437fd36954d160ca

permissionBRICK <you@example.com>

Parents: 5c0a85854a32a7593a2a8b6bac4a24efa3f6d353

Dockerfile+3 -1 Viewed

 COPY requirements.txt /app/
 RUN pip install --no-cache-dir -r requirements.txt
-COPY main.py epub_builder.py /app/
+COPY main.py epub_builder.py generate_reference_doc.py /app/
 COPY center-v.lua /app/
+COPY pagebreak.lua /app/
 COPY epub-style.css /app/
+RUN python generate_reference_doc.py
 # /vault  - mount your markdown source folder here (read-write for flag reset)
 # /output - mount your EPUB destination folder here

README.md+1 -1 Viewed

 . 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 exports a DOCX 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`, using a custom reference document so headings are black and the document uses Times New Roman instead of the default Office theme.
 . That DOCX is then converted into EPUB and MOBI with Calibre's `ebook-convert`.
 . 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`.

epub_builder.py+32 -6 Viewed

 import re
 import subprocess
 import tempfile
+import unicodedata
 from pathlib import Path
 from typing import Optional

 logger = logging.getLogger(__name__)
 METADATA_FILENAME = "metadata.md"
-DEFAULT_OUTPUT_FILE_MODE = 0o644
+DEFAULT_OUTPUT_FILE_MODE = 0o664
 EPUB_SUBDIR = "epub"
 MOBI_SUBDIR = "mobi"
+REFERENCE_DOC_PATH = Path("/app/reference.docx")
+DEFAULT_OUTPUT_UID = 99
+DEFAULT_OUTPUT_GID = 100
 def parse_frontmatter(text: str) -> dict:

             continue
         if i > 0 and add_page_breaks:
-            merged_parts.append('\n\n<div style="page-break-before: always;"></div>\n\n')
+            # Use Pandoc's explicit page break marker so DOCX gets a real break.
+            merged_parts.append("\n\n\\newpage\n\n")
         merged_parts.append(content)
     return "\n\n".join(merged_parts)
+def normalize_text_for_docx(text: str) -> str:
+    """Normalize markdown text before DOCX export.
+    NFC is a conservative choice that can reduce weirdness around combining
+    characters without stripping the visual effect from decorated text.
+    """
+    return unicodedata.normalize("NFC", text)
 def sanitize_title(title: str) -> str:
     """Convert a story title into a safe base filename."""
     return re.sub(r"[^\w\s-]", "", title).strip()

         os.chmod(path, DEFAULT_OUTPUT_FILE_MODE)
+def set_output_ownership(*paths: Path):
+    """Set predictable ownership on generated output paths."""
+    for path in paths:
+        os.chown(path, DEFAULT_OUTPUT_UID, DEFAULT_OUTPUT_GID)
 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)}")

     story: dict,
     output_dir: Path,
     lua_filter: Optional[Path] = None,
+    pagebreak_filter: Optional[Path] = None,
     css_file: Optional[Path] = None,
 ) -> Optional[dict[str, Path]]:
     """Build DOCX, EPUB, and MOBI outputs for a story."""

     output_dir.mkdir(parents=True, exist_ok=True)
     epub_dir.mkdir(parents=True, exist_ok=True)
     mobi_dir.mkdir(parents=True, exist_ok=True)
+    set_output_ownership(output_dir, epub_dir, mobi_dir)
     if not story["chapters"]:
         logger.warning(f"No chapters found for '{title}', skipping")

     logger.info(f"Building book files: '{title}' ({len(story['chapters'])} chapters)")
-    merged_content = merge_chapters(story["chapters"])
+    merged_content = normalize_text_for_docx(merge_chapters(story["chapters"]))
     cover_path = get_cover_path(story)
     with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as tmp:

             "-o",
             str(docx_file),
             "--from",
-            "markdown+raw_html",
+            "markdown+raw_html+raw_tex",
             "--to",
             "docx",
             "--metadata",

             f"author={author}",
             "--metadata",
             f"lang={language}",
-            "--toc",
-            "--toc-depth=1",
             "--wrap=none",
+        ]
+        if REFERENCE_DOC_PATH.exists():
+            docx_cmd.extend(["--reference-doc", str(REFERENCE_DOC_PATH)])
         if lua_filter and lua_filter.exists():
             docx_cmd.extend(["--lua-filter", str(lua_filter)])
+        if pagebreak_filter and pagebreak_filter.exists():
+            docx_cmd.extend(["--lua-filter", str(pagebreak_filter)])
         if not run_command(docx_cmd, title, "DOCX"):
             return None

         logger.info(f"MOBI created: {mobi_file}")
         set_output_permissions(docx_file, epub_file, mobi_file)
+        set_output_ownership(docx_file, epub_file, mobi_file)
         return {"docx": docx_file, "epub": epub_file, "mobi": mobi_file}
     except subprocess.TimeoutExpired:

generate_reference_doc.py+55 -0 Viewed

+from docx import Document
+from docx.enum.style import WD_STYLE_TYPE
+from docx.oxml.ns import qn
+from docx.shared import Pt, RGBColor
+def set_font(font, name: str, size_pt: int, *, bold: bool = False):
+    font.name = name
+    font.size = Pt(size_pt)
+    font.bold = bold
+    font.color.rgb = RGBColor(0x00, 0x00, 0x00)
+def set_run_fonts(style, name: str):
+    r_pr = style.element.get_or_add_rPr()
+    r_fonts = r_pr.get_or_add_rFonts()
+    r_fonts.set(qn("w:ascii"), name)
+    r_fonts.set(qn("w:hAnsi"), name)
+    r_fonts.set(qn("w:eastAsia"), name)
+    r_fonts.set(qn("w:cs"), name)
+def style_paragraph(style, name: str, size_pt: int, *, bold: bool = False, space_before: int = 0, space_after: int = 0):
+    set_font(style.font, name, size_pt, bold=bold)
+    set_run_fonts(style, name)
+    fmt = style.paragraph_format
+    fmt.space_before = Pt(space_before)
+    fmt.space_after = Pt(space_after)
+doc = Document()
+styles = doc.styles
+normal = styles["Normal"]
+style_paragraph(normal, "Times New Roman", 12)
+title = styles["Title"]
+style_paragraph(title, "Times New Roman", 22, bold=True, space_after=12)
+heading1 = styles["Heading 1"]
+style_paragraph(heading1, "Times New Roman", 18, bold=True, space_before=18, space_after=10)
+heading2 = styles["Heading 2"]
+style_paragraph(heading2, "Times New Roman", 16, bold=True, space_before=14, space_after=8)
+heading3 = styles["Heading 3"]
+style_paragraph(heading3, "Times New Roman", 14, bold=True, space_before=12, space_after=6)
+if "First Paragraph" not in [style.name for style in styles]:
+    styles.add_style("First Paragraph", WD_STYLE_TYPE.PARAGRAPH)
+first_paragraph = styles["First Paragraph"]
+style_paragraph(first_paragraph, "Times New Roman", 12)
+doc.save("reference.docx")

main.py+7 -2 Viewed

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

 OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/output")
 LUA_FILTER_PATH = os.environ.get("LUA_FILTER_PATH", "/app/center-v.lua")
+PAGEBREAK_FILTER_PATH = os.environ.get("PAGEBREAK_FILTER_PATH", "/app/pagebreak.lua")
 CSS_FILE_PATH = os.environ.get("CSS_FILE_PATH", "/app/epub-style.css")
 # How often to scan for export flags (seconds)

     output_path = Path(OUTPUT_DIR)
     lua_filter = Path(LUA_FILTER_PATH) if LUA_FILTER_PATH else None
+    pagebreak_filter = Path(PAGEBREAK_FILTER_PATH) if PAGEBREAK_FILTER_PATH else None
     css_file = Path(CSS_FILE_PATH) if CSS_FILE_PATH else None
     for story in to_export:

             story=story,
             output_dir=output_path,
             lua_filter=lua_filter,
+            pagebreak_filter=pagebreak_filter,
             css_file=css_file if css_file and css_file.exists() else None,
+        )

     logger.info(f"Poll interval: {POLL_INTERVAL}s")
     vault_path = Path(VAULT_PATH)
-    Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+    output_path = Path(OUTPUT_DIR)
+    output_path.mkdir(parents=True, exist_ok=True)
+    set_output_ownership(output_path)
     if not vault_path.exists():
         logger.error(f"Vault path does not exist: {vault_path}")

pagebreak.lua+39 -0 Viewed

+-- pagebreak.lua
+-- Converts explicit page break markers into format-specific page breaks.
+local DOCX_PAGEBREAK = [[
+<w:p>
+  <w:r>
+    <w:br w:type="page"/>
+  </w:r>
+</w:p>
+]]
+local HTML_PAGEBREAK = '<div style="page-break-before: always;"></div>'
+local function is_pagebreak(el)
+  return (
+    (el.t == "RawBlock" and el.format == "tex" and (el.text == "\\newpage" or el.text == "\\pagebreak")) or
+    (el.t == "Para" and #el.content == 1 and el.content[1].t == "Str" and el.content[1].text == "\f")
+  )
+end
+function RawBlock(el)
+  if el.format == "tex" and (el.text == "\\newpage" or el.text == "\\pagebreak") then
+    if FORMAT == "docx" or FORMAT == "openxml" then
+      return pandoc.RawBlock("openxml", DOCX_PAGEBREAK)
+    elseif FORMAT == "epub" or FORMAT == "epub3" or FORMAT == "html" or FORMAT == "html5" then
+      return pandoc.RawBlock("html", HTML_PAGEBREAK)
+    end
+  end
+end
+function Para(el)
+  if is_pagebreak(el) then
+    if FORMAT == "docx" or FORMAT == "openxml" then
+      return pandoc.RawBlock("openxml", DOCX_PAGEBREAK)
+    elseif FORMAT == "epub" or FORMAT == "epub3" or FORMAT == "html" or FORMAT == "html5" then
+      return pandoc.RawBlock("html", HTML_PAGEBREAK)
+    end
+  end
+end

reference.docx+0 -0 Viewed

Binary file

requirements.txt+1 -0 Viewed

@@ -1 +1,2 @@
1	PyYAML>=6.0	1	PyYAML>=6.0
		2	python-docx>=1.1.2