pi-studio 0.5.25 → 0.5.26

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to `pi-studio` are documented here.
 
 ## [Unreleased]
 
+## [0.5.26] — 2026-03-21
+
+### Added
+- Added a file-based `/studio-pdf <path>` command that exports a local file to `<name>.studio.pdf` using the existing Studio PDF pipeline and opens the result in the default PDF viewer, without requiring the Studio browser UI.
+
+### Fixed
+- Markdown preview/PDF rendering now also allows blockquotes without a preceding blank line, matching the earlier tolerant list parsing and preventing leading `>` quote lines from collapsing into plain paragraph text.
+- Studio browser preview now keeps the existing MathML rendering for ordinary equations but falls back to MathJax for pandoc-unsupported math blocks, improving advanced LaTeX matrix/array preview cases without switching all preview math to MathJax.
+
 ## [0.5.25] — 2026-03-21
 
 ### Fixed

package/README.md

@@ -28,6 +28,7 @@ Experimental extension for [pi](https://github.com/badlogic/pi-mono) that opens
   - saves `.annotated.md`
 - Renders Markdown/LaTeX/code previews (math + Mermaid), theme-synced with pi
 - Exports right-pane preview as PDF (pandoc + LaTeX)
+- Exports local files headlessly via `/studio-pdf <path>` to `<name>.studio.pdf`
 - Shows model/session/context usage in the footer, plus a compact-context action
 
 ## Commands
@@ -41,6 +42,7 @@ Experimental extension for [pi](https://github.com/badlogic/pi-mono) that opens
 | `/studio --status` | Show studio server status |
 | `/studio --stop` | Stop studio server |
 | `/studio --help` | Show help |
+| `/studio-pdf <path>` | Export a local file to `<name>.studio.pdf` via the Studio PDF pipeline |
 
 ## Install
 

package/client/studio-client.js

@@ -223,6 +223,7 @@
       const ANNOTATION_MARKER_REGEX = /\[an:\s*([^\]]+?)\]/gi;
       const EMPTY_OVERLAY_LINE = "\u200b";
       const MERMAID_CDN_URL = "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";
+      const MATHJAX_CDN_URL = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js";
       const BOOT = (typeof window.__PI_STUDIO_BOOT__ === "object" && window.__PI_STUDIO_BOOT__)
         ? window.__PI_STUDIO_BOOT__
         : {};
@@ -231,8 +232,11 @@
         : {};
       const MERMAID_UNAVAILABLE_MESSAGE = "Mermaid renderer unavailable. Showing mermaid blocks as code.";
       const MERMAID_RENDER_FAIL_MESSAGE = "Mermaid render failed. Showing diagram source text.";
+      const MATHJAX_UNAVAILABLE_MESSAGE = "Math fallback unavailable. Some unsupported equations may remain as raw TeX.";
+      const MATHJAX_RENDER_FAIL_MESSAGE = "Math fallback could not render some unsupported equations.";
       let mermaidModulePromise = null;
       let mermaidInitialized = false;
+      let mathJaxPromise = null;
 
       const DEBUG_ENABLED = (() => {
         try {
@@ -1137,6 +1141,171 @@
         return buildPreviewErrorHtml("Preview sanitizer unavailable. Showing plain markdown.", markdown);
       }
 
+      function appendMathFallbackNotice(targetEl, message) {
+        if (!targetEl || typeof targetEl.querySelector !== "function" || typeof targetEl.appendChild !== "function") {
+          return;
+        }
+
+        if (targetEl.querySelector(".preview-math-warning")) {
+          return;
+        }
+
+        const warningEl = document.createElement("div");
+        warningEl.className = "preview-warning preview-math-warning";
+        warningEl.textContent = String(message || MATHJAX_UNAVAILABLE_MESSAGE);
+        targetEl.appendChild(warningEl);
+      }
+
+      function extractMathFallbackTex(text, displayMode) {
+        const source = typeof text === "string" ? text.trim() : "";
+        if (!source) return "";
+
+        if (displayMode) {
+          if (source.startsWith("$$") && source.endsWith("$$") && source.length >= 4) {
+            return source.slice(2, -2).replace(/^\s+|\s+$/g, "");
+          }
+          if (source.startsWith("\\[") && source.endsWith("\\]") && source.length >= 4) {
+            return source.slice(2, -2).replace(/^\s+|\s+$/g, "");
+          }
+          return source;
+        }
+
+        if (source.startsWith("\\(") && source.endsWith("\\)") && source.length >= 4) {
+          return source.slice(2, -2).trim();
+        }
+        if (source.startsWith("$") && source.endsWith("$") && source.length >= 2) {
+          return source.slice(1, -1).trim();
+        }
+        return source;
+      }
+
+      function collectMathFallbackTargets(targetEl) {
+        if (!targetEl || typeof targetEl.querySelectorAll !== "function") return [];
+
+        const nodes = Array.from(targetEl.querySelectorAll(".math.display, .math.inline"));
+        const targets = [];
+        const seenTargets = new Set();
+
+        nodes.forEach((node) => {
+          if (!node || !node.classList) return;
+          const displayMode = node.classList.contains("display");
+          const rawText = typeof node.textContent === "string" ? node.textContent : "";
+          const tex = extractMathFallbackTex(rawText, displayMode);
+          if (!tex) return;
+
+          let renderTarget = node;
+          if (displayMode) {
+            const parent = node.parentElement;
+            const parentText = parent && typeof parent.textContent === "string" ? parent.textContent.trim() : "";
+            if (parent && parent.tagName === "P" && parentText === rawText.trim()) {
+              renderTarget = parent;
+            }
+          }
+
+          if (seenTargets.has(renderTarget)) return;
+          seenTargets.add(renderTarget);
+          targets.push({ node, renderTarget, displayMode, tex });
+        });
+
+        return targets;
+      }
+
+      function ensureMathJax() {
+        if (window.MathJax && typeof window.MathJax.typesetPromise === "function") {
+          return Promise.resolve(window.MathJax);
+        }
+
+        if (mathJaxPromise) {
+          return mathJaxPromise;
+        }
+
+        mathJaxPromise = new Promise((resolve, reject) => {
+          const globalMathJax = (window.MathJax && typeof window.MathJax === "object") ? window.MathJax : {};
+          const texConfig = (globalMathJax.tex && typeof globalMathJax.tex === "object") ? globalMathJax.tex : {};
+          const loaderConfig = (globalMathJax.loader && typeof globalMathJax.loader === "object") ? globalMathJax.loader : {};
+          const startupConfig = (globalMathJax.startup && typeof globalMathJax.startup === "object") ? globalMathJax.startup : {};
+          const optionsConfig = (globalMathJax.options && typeof globalMathJax.options === "object") ? globalMathJax.options : {};
+          const loaderEntries = Array.isArray(loaderConfig.load) ? loaderConfig.load.slice() : [];
+          ["[tex]/ams", "[tex]/noerrors", "[tex]/noundefined"].forEach((entry) => {
+            if (loaderEntries.indexOf(entry) === -1) loaderEntries.push(entry);
+          });
+
+          window.MathJax = Object.assign({}, globalMathJax, {
+            loader: Object.assign({}, loaderConfig, {
+              load: loaderEntries,
+            }),
+            tex: Object.assign({}, texConfig, {
+              inlineMath: [["\\(", "\\)"], ["$", "$"]],
+              displayMath: [["\\[", "\\]"], ["$$", "$$"]],
+              packages: Object.assign({}, texConfig.packages || {}, { "[+]": ["ams", "noerrors", "noundefined"] }),
+            }),
+            options: Object.assign({}, optionsConfig, {
+              skipHtmlTags: ["script", "noscript", "style", "textarea", "pre", "code"],
+            }),
+            startup: Object.assign({}, startupConfig, {
+              typeset: false,
+            }),
+          });
+
+          const script = document.createElement("script");
+          script.src = MATHJAX_CDN_URL;
+          script.async = true;
+          script.dataset.piStudioMathjax = "1";
+          script.onload = () => {
+            const api = window.MathJax;
+            if (api && api.startup && api.startup.promise && typeof api.startup.promise.then === "function") {
+              api.startup.promise.then(() => resolve(api)).catch(reject);
+              return;
+            }
+            if (api && typeof api.typesetPromise === "function") {
+              resolve(api);
+              return;
+            }
+            reject(new Error("MathJax did not initialize."));
+          };
+          script.onerror = () => {
+            reject(new Error("Failed to load MathJax."));
+          };
+          document.head.appendChild(script);
+        }).catch((error) => {
+          mathJaxPromise = null;
+          throw error;
+        });
+
+        return mathJaxPromise;
+      }
+
+      async function renderMathFallbackInElement(targetEl) {
+        const fallbackTargets = collectMathFallbackTargets(targetEl);
+        if (fallbackTargets.length === 0) return;
+
+        fallbackTargets.forEach((entry) => {
+          entry.renderTarget.classList.add("studio-mathjax-fallback");
+          if (entry.displayMode) {
+            entry.renderTarget.classList.add("studio-mathjax-fallback-display");
+            entry.renderTarget.textContent = "\\[\n" + entry.tex + "\n\\]";
+          } else {
+            entry.renderTarget.textContent = "\\(" + entry.tex + "\\)";
+          }
+        });
+
+        let mathJax;
+        try {
+          mathJax = await ensureMathJax();
+        } catch (error) {
+          console.error("MathJax load failed:", error);
+          appendMathFallbackNotice(targetEl, MATHJAX_UNAVAILABLE_MESSAGE);
+          return;
+        }
+
+        try {
+          await mathJax.typesetPromise(fallbackTargets.map((entry) => entry.renderTarget));
+        } catch (error) {
+          console.error("MathJax fallback render failed:", error);
+          appendMathFallbackNotice(targetEl, MATHJAX_RENDER_FAIL_MESSAGE);
+        }
+      }
+
       function applyAnnotationMarkersToElement(targetEl, mode) {
         if (!targetEl || mode === "none") return;
         if (typeof document.createTreeWalker !== "function") return;
@@ -1596,6 +1765,7 @@
             : "none";
           applyAnnotationMarkersToElement(targetEl, annotationMode);
           await renderMermaidInElement(targetEl);
+          await renderMathFallbackInElement(targetEl);
 
           // Warn if relative images are present but unlikely to resolve (non-file-backed content)
           if (!sourceState.path && !(resourceDirInput && resourceDirInput.value.trim())) {

package/client/studio.css

@@ -860,7 +860,8 @@
       overflow-wrap: anywhere;
     }
 
-    .rendered-markdown .studio-algorithm-line-content math {
+    .rendered-markdown .studio-algorithm-line-content math,
+    .rendered-markdown .studio-algorithm-line-content mjx-container {
       font-size: 1em;
     }
 
@@ -868,6 +869,14 @@
       font-family: "STIX Two Math", "Cambria Math", "Latin Modern Math", "STIXGeneral", serif;
     }
 
+    .rendered-markdown mjx-container[display="true"] {
+      display: block;
+      margin: 1em 0;
+      text-align: center;
+      overflow-x: auto;
+      overflow-y: hidden;
+    }
+
     .rendered-markdown .studio-display-equation {
       position: relative;
       margin: 1em 0;
@@ -879,7 +888,8 @@
       overflow-y: hidden;
     }
 
-    .rendered-markdown .studio-display-equation-body math[display="block"] {
+    .rendered-markdown .studio-display-equation-body math[display="block"],
+    .rendered-markdown .studio-display-equation-body mjx-container[display="true"] {
       margin: 0;
     }
 

package/index.ts

@@ -5,7 +5,7 @@ import { readFileSync, statSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { URL, pathToFileURL } from "node:url";
 import { WebSocketServer, WebSocket, type RawData } from "ws";
 
@@ -927,6 +927,23 @@ function readStudioFile(pathArg: string, cwd: string):
 	}
 }
 
+function inferStudioPdfLanguageFromPath(pathInput: string): string | undefined {
+	const extension = extname(pathInput).toLowerCase();
+	if (extension === ".tex" || extension === ".latex") return "latex";
+	if (extension === ".md" || extension === ".markdown" || extension === ".mdx") return "markdown";
+	if (extension === ".diff" || extension === ".patch") return "diff";
+	return undefined;
+}
+
+function buildStudioPdfOutputPath(sourcePath: string): string {
+	const sourceDir = dirname(sourcePath);
+	const sourceName = basename(sourcePath);
+	const sourceExt = extname(sourceName);
+	const sourceStem = sourceExt ? sourceName.slice(0, -sourceExt.length) : sourceName;
+	const outputStem = sourceStem || sourceName || "studio-export";
+	return join(sourceDir, `${outputStem}.studio.pdf`);
+}
+
 function writeStudioFile(pathArg: string, cwd: string, content: string):
 	| { ok: true; label: string; resolvedPath: string }
 	| { ok: false; message: string } {
@@ -2785,7 +2802,7 @@ async function renderStudioMarkdownWithPandoc(markdown: string, isLatex?: boolea
 	const sourceWithResolvedRefs = isLatex
 		? preprocessStudioLatexReferences(latexAlgorithmPreviewTransform.markdown, sourcePath, resourcePath)
 		: markdown;
-	const inputFormat = isLatex ? "latex" : "markdown+lists_without_preceding_blankline+tex_math_dollars+tex_math_single_backslash+tex_math_double_backslash+autolink_bare_uris-raw_html";
+	const inputFormat = isLatex ? "latex" : "markdown+lists_without_preceding_blankline-blank_before_blockquote+tex_math_dollars+tex_math_single_backslash+tex_math_double_backslash+autolink_bare_uris-raw_html";
 	const bibliographyArgs = buildStudioPandocBibliographyArgs(markdown, isLatex, resourcePath);
 	const args = ["-f", inputFormat, "-t", "html5", "--mathml", "--wrap=none", ...bibliographyArgs];
 	if (resourcePath) {
@@ -3191,7 +3208,7 @@ async function renderStudioPdfWithPandoc(
 	}
 
 	if (!isLatex && effectiveEditorLanguage === "diff") {
-		const inputFormat = "markdown+lists_without_preceding_blankline+tex_math_dollars+autolink_bare_uris+superscript+subscript-raw_html";
+		const inputFormat = "markdown+lists_without_preceding_blankline-blank_before_blockquote+tex_math_dollars+autolink_bare_uris+superscript+subscript-raw_html";
 		const diffMarkdown = prepareStudioPdfMarkdown(markdown, false, effectiveEditorLanguage);
 		try {
 			return await runPandocPdfExport(inputFormat, diffMarkdown);
@@ -3207,7 +3224,7 @@ async function renderStudioPdfWithPandoc(
 
 	const inputFormat = isLatex
 		? "latex"
-		: "markdown+lists_without_preceding_blankline+tex_math_dollars+tex_math_single_backslash+tex_math_double_backslash+autolink_bare_uris+superscript+subscript-raw_html";
+		: "markdown+lists_without_preceding_blankline-blank_before_blockquote+tex_math_dollars+tex_math_single_backslash+tex_math_double_backslash+autolink_bare_uris+superscript+subscript-raw_html";
 	const normalizedMarkdown = prepareStudioPdfMarkdown(sourceWithResolvedRefs, isLatex, effectiveEditorLanguage);
 
 	const tempDir = join(tmpdir(), `pi-studio-pdf-${Date.now()}-${randomUUID()}`);
@@ -6250,7 +6267,8 @@ export default function (pi: ExtensionAPI) {
 						+ "  /studio --last    Open with last model response\n"
 						+ "  /studio --status  Show studio status\n"
 						+ "  /studio --stop    Stop studio server\n"
-						+ "  /studio-current <path>  Load a file into currently open Studio tab(s)",
+						+ "  /studio-current <path>  Load a file into currently open Studio tab(s)\n"
+						+ "  /studio-pdf <path>      Export a file to <name>.studio.pdf via Studio PDF",
 					"info",
 				);
 				return;
@@ -6368,6 +6386,86 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerCommand("studio-pdf", {
+		description: "Export a file to PDF via the Studio PDF pipeline (/studio-pdf <file>)",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const trimmed = args.trim();
+			if (!trimmed || trimmed === "help" || trimmed === "--help" || trimmed === "-h") {
+				ctx.ui.notify(
+					"Usage: /studio-pdf <path>\n"
+						+ "  Export a local Markdown/LaTeX file to <name>.studio.pdf using the Studio PDF pipeline.",
+					"info",
+				);
+				return;
+			}
+
+			if (trimmed.startsWith("-")) {
+				ctx.ui.notify(`Unknown flag: ${trimmed}. Use /studio-pdf --help`, "error");
+				return;
+			}
+
+			const pathArg = parsePathArgument(trimmed);
+			if (!pathArg) {
+				ctx.ui.notify("Invalid file path argument.", "error");
+				return;
+			}
+
+			const file = readStudioFile(pathArg, ctx.cwd);
+			if (file.ok === false) {
+				ctx.ui.notify(file.message, "error");
+				return;
+			}
+
+			if (file.text.length > PDF_EXPORT_MAX_CHARS) {
+				ctx.ui.notify(`PDF export text exceeds ${PDF_EXPORT_MAX_CHARS} characters.`, "error");
+				return;
+			}
+
+			await ctx.waitForIdle();
+			const pathPdfLanguage = inferStudioPdfLanguageFromPath(file.resolvedPath);
+			const editorPdfLanguage = pathPdfLanguage ?? inferStudioPdfLanguage(file.text);
+			const isLatex = editorPdfLanguage === "latex"
+				|| (
+					!pathPdfLanguage
+					&& (editorPdfLanguage === undefined || editorPdfLanguage === "markdown")
+					&& /\\documentclass\b|\\begin\{document\}/.test(file.text)
+				);
+			const resourcePath = resolveStudioBaseDir(file.resolvedPath, undefined, ctx.cwd);
+			const outputPath = buildStudioPdfOutputPath(file.resolvedPath);
+
+			try {
+				const { pdf, warning } = await renderStudioPdfWithPandoc(
+					file.text,
+					isLatex,
+					resourcePath,
+					editorPdfLanguage,
+					file.resolvedPath,
+				);
+				await writeFile(outputPath, pdf);
+
+				let openError: string | null = null;
+				try {
+					await openPathInDefaultViewer(outputPath);
+				} catch (error) {
+					openError = error instanceof Error ? error.message : String(error);
+				}
+
+				ctx.ui.notify(`Exported Studio PDF: ${outputPath}`, "info");
+				if (warning) {
+					ctx.ui.notify(warning, "warning");
+				}
+				if (openError) {
+					ctx.ui.notify(`PDF was exported but could not be opened automatically: ${openError}`, "warning");
+				}
+			} catch (error) {
+				ctx.ui.notify(
+					`Studio PDF export failed for ${file.label}: ${error instanceof Error ? error.message : String(error)}`,
+					"error",
+				);
+			}
+		},
+	});
+
 	pi.registerCommand("studio-current", {
 		description: "Load a file into current open Studio tab(s) without opening a new browser session",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-studio",
-  "version": "0.5.25",
+  "version": "0.5.26",
   "description": "Browser GUI for structured critique workflows in pi",
   "type": "module",
   "license": "MIT",