ai-pdf-builder 0.3.1 → 0.4.0

package/dist/chunk-C63SSMWG.mjs

@@ -0,0 +1,594 @@
+// src/generator.ts
+import { spawn } from "child_process";
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/templates.ts
+import * as fs from "fs";
+import * as path from "path";
+var TEMPLATES_DIR = path.join(__dirname, "..", "templates");
+var BUILT_IN_TEMPLATES = {
+  default: {
+    name: "default",
+    path: path.join(TEMPLATES_DIR, "default.latex"),
+    description: "Clean, professional default template with modern styling",
+    supportedDocTypes: ["memo", "whitepaper", "report", "proposal", "generic"]
+  },
+  memo: {
+    name: "memo",
+    path: path.join(TEMPLATES_DIR, "memo.latex"),
+    description: "Business memo template with executive summary styling",
+    supportedDocTypes: ["memo", "report", "proposal"]
+  },
+  agreement: {
+    name: "agreement",
+    path: path.join(TEMPLATES_DIR, "agreement.latex"),
+    description: "Legal agreement template with formal structure",
+    supportedDocTypes: ["agreement", "generic"]
+  },
+  termsheet: {
+    name: "termsheet",
+    path: path.join(TEMPLATES_DIR, "termsheet.latex"),
+    description: "Term sheet template for investment documents",
+    supportedDocTypes: ["termsheet", "agreement"]
+  }
+};
+var customTemplates = /* @__PURE__ */ new Map();
+var templateCache = /* @__PURE__ */ new Map();
+function getTemplate(name) {
+  if (templateCache.has(name)) {
+    return templateCache.get(name) || null;
+  }
+  if (customTemplates.has(name)) {
+    const config = customTemplates.get(name);
+    return loadTemplateFile(config.path, name);
+  }
+  if (BUILT_IN_TEMPLATES[name]) {
+    return loadTemplateFile(BUILT_IN_TEMPLATES[name].path, name);
+  }
+  if (fs.existsSync(name)) {
+    return loadTemplateFile(name, name);
+  }
+  return null;
+}
+function getTemplatePath(name) {
+  if (customTemplates.has(name)) {
+    return customTemplates.get(name).path;
+  }
+  if (BUILT_IN_TEMPLATES[name]) {
+    return BUILT_IN_TEMPLATES[name].path;
+  }
+  if (fs.existsSync(name)) {
+    return name;
+  }
+  return null;
+}
+function loadTemplateFile(filePath, cacheKey) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      console.warn(`Template file not found: ${filePath}`);
+      return null;
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    templateCache.set(cacheKey, content);
+    return content;
+  } catch (error) {
+    console.error(`Error loading template ${filePath}:`, error);
+    return null;
+  }
+}
+function listTemplates() {
+  const builtIn = Object.values(BUILT_IN_TEMPLATES);
+  const custom = Array.from(customTemplates.values());
+  return [...builtIn, ...custom];
+}
+function getTemplateConfig(name) {
+  if (customTemplates.has(name)) {
+    return customTemplates.get(name) || null;
+  }
+  if (BUILT_IN_TEMPLATES[name]) {
+    return BUILT_IN_TEMPLATES[name];
+  }
+  return null;
+}
+function registerTemplate(config) {
+  if (!fs.existsSync(config.path)) {
+    throw new Error(`Template file not found: ${config.path}`);
+  }
+  const absolutePath = path.resolve(config.path);
+  customTemplates.set(config.name, {
+    ...config,
+    path: absolutePath
+  });
+  templateCache.delete(config.name);
+}
+function unregisterTemplate(name) {
+  if (customTemplates.has(name)) {
+    customTemplates.delete(name);
+    templateCache.delete(name);
+    return true;
+  }
+  return false;
+}
+function hasTemplate(name) {
+  return customTemplates.has(name) || BUILT_IN_TEMPLATES.hasOwnProperty(name) || fs.existsSync(name);
+}
+function getTemplatesForDocType(docType) {
+  const all = listTemplates();
+  return all.filter((t) => t.supportedDocTypes.includes(docType));
+}
+function clearTemplateCache() {
+  templateCache.clear();
+}
+function getTemplatesDirectory() {
+  return TEMPLATES_DIR;
+}
+
+// src/utils.ts
+import { execSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+function checkPandoc() {
+  try {
+    const version = execSync("pandoc --version", { encoding: "utf-8" });
+    const versionMatch = version.match(/pandoc\s+([\d.]+)/);
+    const pathResult = execSync("which pandoc", { encoding: "utf-8" }).trim();
+    return {
+      available: true,
+      version: versionMatch ? versionMatch[1] : "unknown",
+      path: pathResult
+    };
+  } catch (error) {
+    return {
+      available: false,
+      error: "Pandoc not found. Install with: brew install pandoc (macOS) or apt-get install pandoc (Linux)"
+    };
+  }
+}
+function checkLaTeX() {
+  try {
+    const version = execSync("pdflatex --version", { encoding: "utf-8" });
+    const versionMatch = version.match(/pdfTeX\s+([\d.-]+)/);
+    const pathResult = execSync("which pdflatex", { encoding: "utf-8" }).trim();
+    return {
+      available: true,
+      engine: "pdflatex",
+      version: versionMatch ? versionMatch[1] : "unknown",
+      path: pathResult
+    };
+  } catch (error) {
+    return {
+      available: false,
+      error: "pdflatex not found. Install BasicTeX (brew install --cask basictex) or TeX Live"
+    };
+  }
+}
+function checkSystem() {
+  const pandoc = checkPandoc();
+  const latex = checkLaTeX();
+  const ready = pandoc.available && latex.available;
+  let message = "";
+  if (ready) {
+    message = `Ready: Pandoc ${pandoc.version}, pdfTeX ${latex.version}`;
+  } else {
+    const missing = [];
+    if (!pandoc.available) missing.push("Pandoc");
+    if (!latex.available) missing.push("LaTeX/pdflatex");
+    message = `Missing dependencies: ${missing.join(", ")}`;
+  }
+  return { pandoc, latex, ready, message };
+}
+function createTempDir(prefix = "pdf-builder") {
+  const tempDir = path2.join(os.tmpdir(), `${prefix}-${Date.now()}`);
+  fs2.mkdirSync(tempDir, { recursive: true });
+  return tempDir;
+}
+function cleanupTempDir(dirPath) {
+  try {
+    if (fs2.existsSync(dirPath)) {
+      fs2.rmSync(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not clean up temp directory: ${dirPath}`);
+  }
+}
+function generateYAMLFrontMatter(metadata) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(metadata)) {
+    if (value !== void 0 && value !== "") {
+      const escapedValue = String(value).replace(/"/g, '\\"');
+      lines.push(`${key}: "${escapedValue}"`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function sanitizeContent(content) {
+  const dangerousCommands = [
+    "\\input",
+    "\\include",
+    "\\write18",
+    "\\immediate",
+    "\\openin",
+    "\\openout",
+    "\\read",
+    "\\write",
+    "\\newwrite",
+    "\\closeout",
+    "\\closein"
+  ];
+  let sanitized = content;
+  for (const cmd of dangerousCommands) {
+    const regex = new RegExp(cmd.replace("\\", "\\\\") + "[^\\s{]*({[^}]*})?", "gi");
+    sanitized = sanitized.replace(regex, "");
+  }
+  return sanitized;
+}
+function parseColor(color) {
+  if (/^\d+,\s*\d+,\s*\d+$/.test(color)) {
+    return color.replace(/\s/g, "");
+  }
+  const rgbMatch = color.match(/RGB\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/i);
+  if (rgbMatch) {
+    return `${rgbMatch[1]},${rgbMatch[2]},${rgbMatch[3]}`;
+  }
+  const hexMatch = color.match(/^#?([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})$/);
+  if (hexMatch) {
+    const r = parseInt(hexMatch[1], 16);
+    const g = parseInt(hexMatch[2], 16);
+    const b = parseInt(hexMatch[3], 16);
+    return `${r},${g},${b}`;
+  }
+  return "59,130,246";
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/generator.ts
+var DEFAULT_OPTIONS = {
+  toc: true,
+  tocDepth: 2,
+  numberSections: true,
+  fontSize: 11,
+  margin: "1in",
+  paperSize: "letter",
+  timeout: 6e4
+};
+async function generatePDF(options) {
+  const startTime = Date.now();
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const sysCheck = checkSystem();
+  if (!sysCheck.ready) {
+    return {
+      success: false,
+      error: `System requirements not met: ${sysCheck.message}`
+    };
+  }
+  if (!opts.content || opts.content.trim().length === 0) {
+    return {
+      success: false,
+      error: "Content is required"
+    };
+  }
+  let tempDir = null;
+  try {
+    tempDir = opts.workDir || createTempDir("pdf-builder");
+    const sanitizedContent = sanitizeContent(opts.content);
+    const fullMarkdown = buildMarkdownDocument(sanitizedContent, opts);
+    const inputPath = path3.join(tempDir, "input.md");
+    fs3.writeFileSync(inputPath, fullMarkdown, "utf-8");
+    const templatePath = await prepareTemplate(tempDir, opts);
+    const outputPath = opts.outputPath || path3.join(tempDir, "output.pdf");
+    const pandocOpts = {
+      inputPath,
+      outputPath,
+      templatePath,
+      toc: opts.toc ?? true,
+      tocDepth: opts.tocDepth ?? 2,
+      numberSections: opts.numberSections ?? true,
+      fontSize: opts.fontSize ?? 11,
+      margin: opts.margin ?? "1in",
+      paperSize: opts.paperSize ?? "letter",
+      timeout: opts.timeout ?? 6e4
+    };
+    await executePandoc(pandocOpts);
+    if (!fs3.existsSync(outputPath)) {
+      return {
+        success: false,
+        error: "PDF generation failed - output file not created"
+      };
+    }
+    const buffer = fs3.readFileSync(outputPath);
+    const stats = fs3.statSync(outputPath);
+    const generationTime = Date.now() - startTime;
+    const result = {
+      success: true,
+      buffer: opts.outputPath ? void 0 : buffer,
+      path: opts.outputPath || void 0,
+      fileSize: stats.size,
+      generationTime
+    };
+    result.pageCount = estimatePageCount(buffer);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `PDF generation failed: ${errorMessage}`,
+      generationTime: Date.now() - startTime
+    };
+  } finally {
+    if (tempDir && !opts.workDir && !opts.outputPath) {
+    } else if (tempDir && !opts.workDir) {
+      cleanupTempDir(tempDir);
+    }
+  }
+}
+function buildMarkdownDocument(content, opts) {
+  const parts = [];
+  if (opts.metadata) {
+    const frontMatter = generateYAMLFrontMatter({
+      ...opts.metadata,
+      geometry: `margin=${opts.margin || "1in"}`,
+      fontsize: `${opts.fontSize || 11}pt`,
+      papersize: opts.paperSize || "letter"
+    });
+    parts.push(frontMatter);
+    parts.push("");
+  }
+  parts.push(content);
+  return parts.join("\n");
+}
+async function prepareTemplate(tempDir, opts) {
+  const templateName = opts.template || "default";
+  let templateContent = getTemplate(templateName);
+  if (!templateContent) {
+    const templatePath = getTemplatePath(templateName);
+    if (templatePath && fs3.existsSync(templatePath)) {
+      templateContent = fs3.readFileSync(templatePath, "utf-8");
+    } else {
+      templateContent = getTemplate("default");
+    }
+  }
+  if (!templateContent) {
+    throw new Error(`Template not found: ${templateName}`);
+  }
+  if (opts.customColors) {
+    templateContent = applyColorCustomizations(templateContent, opts.customColors);
+  }
+  const customTemplatePath = path3.join(tempDir, "template.latex");
+  fs3.writeFileSync(customTemplatePath, templateContent, "utf-8");
+  return customTemplatePath;
+}
+function applyColorCustomizations(template, colors) {
+  let result = template;
+  if (colors.primary) {
+    const rgb = parseColor(colors.primary);
+    result = result.replace(
+      /\\definecolor{(?:zeroBlue|primaryColor)}{RGB}{[^}]+}/g,
+      `\\definecolor{primaryColor}{RGB}{${rgb}}`
+    );
+  }
+  if (colors.secondary) {
+    const rgb = parseColor(colors.secondary);
+    result = result.replace(
+      /\\definecolor{(?:zeroGray|secondaryColor)}{RGB}{[^}]+}/g,
+      `\\definecolor{secondaryColor}{RGB}{${rgb}}`
+    );
+  }
+  if (colors.accent) {
+    const rgb = parseColor(colors.accent);
+    result = result.replace(
+      /\\definecolor{(?:zeroDark|accentColor)}{RGB}{[^}]+}/g,
+      `\\definecolor{accentColor}{RGB}{${rgb}}`
+    );
+  }
+  return result;
+}
+function executePandoc(opts) {
+  return new Promise((resolve2, reject) => {
+    const args = [
+      opts.inputPath,
+      "-o",
+      opts.outputPath,
+      "--pdf-engine=pdflatex",
+      `-V`,
+      `geometry:margin=${opts.margin}`,
+      `-V`,
+      `fontsize=${opts.fontSize}pt`,
+      `-V`,
+      `papersize=${opts.paperSize}`,
+      `-V`,
+      `documentclass=article`,
+      `-V`,
+      `colorlinks=true`,
+      `-V`,
+      `linkcolor=blue`,
+      `-V`,
+      `urlcolor=blue`
+    ];
+    if (opts.templatePath) {
+      args.push(`--template=${opts.templatePath}`);
+    }
+    if (opts.toc) {
+      args.push("--toc");
+      args.push(`--toc-depth=${opts.tocDepth}`);
+    }
+    if (opts.numberSections) {
+      args.push("--number-sections");
+    }
+    const pandoc = spawn("pandoc", args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stderr = "";
+    pandoc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const timeout = setTimeout(() => {
+      pandoc.kill("SIGKILL");
+      reject(new Error(`Pandoc timed out after ${opts.timeout}ms`));
+    }, opts.timeout);
+    pandoc.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Pandoc failed with code ${code}: ${stderr}`));
+      }
+    });
+    pandoc.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(new Error(`Failed to execute Pandoc: ${error.message}`));
+    });
+  });
+}
+function estimatePageCount(buffer) {
+  const content = buffer.toString("binary");
+  const matches = content.match(/\/Type\s*\/Page[^s]/g);
+  return matches ? matches.length : 1;
+}
+
+// src/presets.ts
+async function generateMemo(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "memo",
+    toc: false,
+    numberSections: true,
+    fontSize: 11,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateAgreement(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "agreement",
+    toc: false,
+    numberSections: true,
+    fontSize: 10,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateTermsheet(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "termsheet",
+    toc: false,
+    numberSections: true,
+    fontSize: 10,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateWhitepaper(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "whitepaper",
+    toc: true,
+    tocDepth: 2,
+    numberSections: true,
+    fontSize: 11,
+    margin: "1.2in",
+    ...options
+  });
+}
+async function generateReport(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "default",
+    toc: true,
+    tocDepth: 2,
+    numberSections: true,
+    fontSize: 11,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateProposal(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "default",
+    toc: false,
+    numberSections: true,
+    fontSize: 11,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateCapitalIntroAgreement(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "agreement",
+    toc: false,
+    numberSections: true,
+    fontSize: 10,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateSAFE(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "agreement",
+    toc: false,
+    numberSections: true,
+    fontSize: 10,
+    margin: "1in",
+    ...options
+  });
+}
+async function generateNDA(content, metadata, options) {
+  return generatePDF({
+    content,
+    metadata,
+    template: "agreement",
+    toc: false,
+    numberSections: true,
+    fontSize: 10,
+    margin: "1in",
+    ...options
+  });
+}
+
+export {
+  getTemplate,
+  getTemplatePath,
+  listTemplates,
+  getTemplateConfig,
+  registerTemplate,
+  unregisterTemplate,
+  hasTemplate,
+  getTemplatesForDocType,
+  clearTemplateCache,
+  getTemplatesDirectory,
+  checkPandoc,
+  checkLaTeX,
+  checkSystem,
+  sanitizeContent,
+  parseColor,
+  formatFileSize,
+  generatePDF,
+  generateMemo,
+  generateAgreement,
+  generateTermsheet,
+  generateWhitepaper,
+  generateReport,
+  generateProposal,
+  generateCapitalIntroAgreement,
+  generateSAFE,
+  generateNDA
+};

package/dist/cli.js

@@ -476,12 +476,12 @@ async function generateWhitepaper(content, metadata, options) {
   return generatePDF({
     content,
     metadata,
-    template: "default",
+    template: "whitepaper",
     toc: true,
     tocDepth: 2,
     numberSections: true,
     fontSize: 11,
-    margin: "1in",
+    margin: "1.2in",
     ...options
   });
 }

package/dist/cli.mjs

@@ -10,7 +10,7 @@ import {
   generateTermsheet,
   generateWhitepaper,
   listTemplates
-} from "./chunk-6CO4SNHC.mjs";
+} from "./chunk-C63SSMWG.mjs";
 
 // src/cli.ts
 import * as fs from "fs";

package/dist/index.js

@@ -554,12 +554,12 @@ async function generateWhitepaper(content, metadata, options) {
   return generatePDF({
     content,
     metadata,
-    template: "default",
+    template: "whitepaper",
     toc: true,
     tocDepth: 2,
     numberSections: true,
     fontSize: 11,
-    margin: "1in",
+    margin: "1.2in",
     ...options
   });
 }

package/dist/index.mjs

@@ -25,7 +25,7 @@ import {
   registerTemplate,
   sanitizeContent,
   unregisterTemplate
-} from "./chunk-6CO4SNHC.mjs";
+} from "./chunk-C63SSMWG.mjs";
 export {
   checkLaTeX,
   checkPandoc,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-pdf-builder",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Professional PDF generation from Markdown using Pandoc and LaTeX",
   "main": "dist/index.js",
   "module": "dist/index.mjs",