ai-pdf-builder 0.5.2 → 0.6.0

package/dist/chunk-BDGLLRIX.mjs

@@ -0,0 +1,1269 @@
+// 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{(?:primaryBlue|primaryColor)}{RGB}{[^}]+}/g,
+      `\\definecolor{primaryColor}{RGB}{${rgb}}`
+    );
+  }
+  if (colors.secondary) {
+    const rgb = parseColor(colors.secondary);
+    result = result.replace(
+      /\\definecolor{(?:primaryGray|secondaryColor)}{RGB}{[^}]+}/g,
+      `\\definecolor{secondaryColor}{RGB}{${rgb}}`
+    );
+  }
+  if (colors.accent) {
+    const rgb = parseColor(colors.accent);
+    result = result.replace(
+      /\\definecolor{(?:primaryDark|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
+  });
+}
+
+// src/ai.ts
+import Anthropic from "@anthropic-ai/sdk";
+function sanitizeForLatex(content) {
+  return content.replace(/[┌┐└┘├┤┬┴┼│─═║╔╗╚╝╠╣╦╩╬]/g, "").replace(/→/g, "->").replace(/←/g, "<-").replace(/↔/g, "<->").replace(/•/g, "-").replace(/·/g, "-").replace(/…/g, "...").replace(/–/g, "-").replace(/—/g, "---").replace(/"/g, '"').replace(/"/g, '"').replace(/'/g, "'").replace(/'/g, "'").replace(/©/g, "(c)").replace(/®/g, "(R)").replace(/™/g, "(TM)").replace(/°/g, " degrees").replace(/±/g, "+/-").replace(/×/g, "x").replace(/÷/g, "/").replace(/≤/g, "<=").replace(/≥/g, ">=").replace(/≠/g, "!=").replace(/∞/g, "infinity").replace(/[^\x00-\x7F\xC0-\xFF]/g, (char) => {
+    if (char.charCodeAt(0) < 32) return char;
+    return "";
+  }).replace(/  +/g, " ").replace(/\n\n\n+/g, "\n\n");
+}
+var SYSTEM_PROMPTS = {
+  whitepaper: `You are a technical writer creating professional whitepapers.
+
+IMPORTANT RULES:
+- Do NOT use placeholder text like "[Company Name]" or "[Your Name]"
+- Do NOT use ASCII art, box diagrams, or Unicode box-drawing characters
+- Do NOT invent fake statistics or metrics
+- Use real, general industry insights when specific data isn't provided
+- Keep diagrams as simple bullet lists or tables, not ASCII art
+
+Write clear, authoritative content with:
+- Executive summary (2-3 paragraphs)
+- Problem statement
+- Solution overview
+- Key benefits
+- Implementation approach
+- Conclusion
+
+Use markdown formatting with ## for sections. Be specific and substantive.`,
+  memo: `You are a business writer creating executive memos.
+
+IMPORTANT RULES:
+- Do NOT use placeholder text like "[Recipient]" or "[Date]"
+- Do NOT invent fake names, emails, or contact info
+- If company/author info is provided, use it. Otherwise, omit those fields.
+- Keep it professional and actionable
+
+Write concise content with:
+- Clear purpose statement
+- Key points (3-5 bullets)
+- Recommendations
+- Next steps
+
+Use markdown formatting. Be direct and brief.`,
+  termsheet: `You are a financial/legal writer creating investment term sheets.
+
+IMPORTANT RULES:
+- Do NOT use placeholder brackets like "[Amount]" - use the actual values provided
+- If specific numbers aren't given, use realistic example figures
+- Do NOT invent company names - use what's provided or say "the Company"
+- Keep language precise and professional
+
+Include standard sections:
+- Investment overview (amount, type, valuation)
+- Key terms table
+- Investor rights
+- Governance provisions
+- Conditions and timeline
+
+Use markdown with tables where appropriate.`,
+  safe: `You are a legal writer creating SAFE agreements.
+
+IMPORTANT RULES:
+- Use actual investment amounts and terms provided
+- Do NOT use placeholder brackets
+- Follow standard Y Combinator SAFE conventions
+- If company name not provided, use "the Company"
+
+Include:
+- Investment amount and type
+- Valuation cap (if applicable)
+- Discount rate (if applicable)
+- Pro-rata rights
+- Standard SAFE provisions
+
+Use markdown formatting with clear section headers.`,
+  nda: `You are a legal writer creating Non-Disclosure Agreements.
+
+IMPORTANT RULES:
+- Do NOT use placeholder brackets for party names
+- Use "Disclosing Party" and "Receiving Party" if names not provided
+- Keep language clear and enforceable
+- Include standard NDA provisions
+
+Include:
+- Definition of confidential information
+- Obligations of receiving party
+- Exclusions from confidentiality
+- Term (suggest 2-3 years if not specified)
+- Return/destruction of materials
+
+Use markdown formatting.`,
+  agreement: `You are a legal writer creating professional agreements.
+
+IMPORTANT RULES:
+- Do NOT use placeholder brackets
+- Use clear party designations if names not provided
+- Keep language professional and enforceable
+
+Include appropriate sections:
+- Parties and purpose
+- Terms and conditions
+- Rights and obligations
+- Term and termination
+- General provisions
+
+Use markdown formatting.`,
+  report: `You are a business analyst creating professional reports.
+
+IMPORTANT RULES:
+- Do NOT invent fake statistics or metrics
+- Use qualitative insights when specific data isn't provided
+- Do NOT use ASCII art or box diagrams
+- Keep analysis substantive and actionable
+
+Include:
+- Executive summary
+- Key findings (use bullet points)
+- Analysis and insights
+- Recommendations
+- Next steps
+
+Use markdown with tables for data where appropriate.`,
+  proposal: `You are a business development writer creating compelling proposals.
+
+IMPORTANT RULES:
+- Do NOT use placeholder brackets
+- If company/pricing not provided, focus on value and approach
+- Be persuasive but realistic
+- No fake testimonials or statistics
+
+Include:
+- Executive summary
+- Understanding of the opportunity
+- Proposed approach
+- Key deliverables
+- Timeline
+- Investment/next steps
+
+Use markdown formatting. Be confident and professional.`
+};
+var LENGTH_TOKENS = {
+  short: 1500,
+  medium: 3e3,
+  long: 6e3
+};
+async function generateContent(options, config = {}) {
+  const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "ANTHROPIC_API_KEY not found.\n\nTo use AI features:\n  1. Get an API key at https://console.anthropic.com\n  2. Set it: export ANTHROPIC_API_KEY=sk-ant-...\n\nOr use the non-AI generate command with your own markdown file."
+    );
+  }
+  const client = new Anthropic({ apiKey });
+  const model = config.model || "claude-sonnet-4-20250514";
+  const maxTokens = config.maxTokens || LENGTH_TOKENS[options.length || "medium"];
+  const systemPrompt = SYSTEM_PROMPTS[options.type] || SYSTEM_PROMPTS.whitepaper;
+  let userPrompt = `Create a ${options.type} about: ${options.topic}`;
+  if (options.company) {
+    userPrompt += `
+
+Company: ${options.company}`;
+  }
+  if (options.author) {
+    userPrompt += `
+Author: ${options.author}`;
+  }
+  if (options.context) {
+    userPrompt += `
+
+Additional context: ${options.context}`;
+  }
+  if (options.style) {
+    userPrompt += `
+
+Writing style: ${options.style}`;
+  }
+  userPrompt += `
+
+Generate the complete document in markdown format. Start with a title using # heading. Do not use placeholder text or brackets.`;
+  try {
+    const response = await client.messages.create({
+      model,
+      max_tokens: maxTokens,
+      system: systemPrompt,
+      messages: [
+        { role: "user", content: userPrompt }
+      ]
+    });
+    const content = response.content[0];
+    if (content.type !== "text") {
+      throw new Error("Unexpected response format from AI");
+    }
+    return sanitizeForLatex(content.text);
+  } catch (error) {
+    if (error.status === 401) {
+      throw new Error(
+        "Invalid API key. Please check your ANTHROPIC_API_KEY.\nGet a valid key at https://console.anthropic.com"
+      );
+    }
+    if (error.status === 429) {
+      throw new Error(
+        "Rate limited. Please wait a moment and try again.\nOr check your API usage at https://console.anthropic.com"
+      );
+    }
+    if (error.status === 500 || error.status === 503) {
+      throw new Error(
+        "AI service temporarily unavailable. Please try again in a few moments."
+      );
+    }
+    throw error;
+  }
+}
+async function enhanceContent(content, type, config = {}) {
+  const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "ANTHROPIC_API_KEY not found. Set it to use AI enhancement features."
+    );
+  }
+  const client = new Anthropic({ apiKey });
+  const model = config.model || "claude-sonnet-4-20250514";
+  try {
+    const response = await client.messages.create({
+      model,
+      max_tokens: 4e3,
+      system: `You are a professional editor improving ${type} documents.
+
+IMPORTANT:
+- Do NOT add placeholder text or brackets
+- Do NOT use ASCII art or box-drawing characters
+- Preserve all real names, numbers, and specific details
+- Only improve writing quality, clarity, and flow
+
+Enhance the document by:
+- Improving clarity and readability
+- Fixing grammar and style issues
+- Strengthening arguments and flow
+- Adding professional polish
+- Maintaining markdown formatting`,
+      messages: [
+        {
+          role: "user",
+          content: `Enhance this ${type} document:
+
+${content}
+
+Return the improved version in markdown format.`
+        }
+      ]
+    });
+    const responseContent = response.content[0];
+    if (responseContent.type !== "text") {
+      throw new Error("Unexpected response format from AI");
+    }
+    return sanitizeForLatex(responseContent.text);
+  } catch (error) {
+    if (error.status === 401) {
+      throw new Error("Invalid API key. Please check your ANTHROPIC_API_KEY.");
+    }
+    throw error;
+  }
+}
+async function generateSummary(content, config = {}) {
+  const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "ANTHROPIC_API_KEY not found. Set it to use AI summary features."
+    );
+  }
+  const client = new Anthropic({ apiKey });
+  const model = config.model || "claude-sonnet-4-20250514";
+  try {
+    const response = await client.messages.create({
+      model,
+      max_tokens: 1e3,
+      system: `You are an executive assistant creating concise summaries.
+
+IMPORTANT:
+- Extract only facts present in the document
+- Do NOT invent statistics or claims
+- Keep it to 3-5 focused paragraphs
+- Use clear, executive-friendly language`,
+      messages: [
+        {
+          role: "user",
+          content: `Create an executive summary for this document:
+
+${content}
+
+Return just the summary in markdown, starting with "## Executive Summary".`
+        }
+      ]
+    });
+    const responseContent = response.content[0];
+    if (responseContent.type !== "text") {
+      throw new Error("Unexpected response format from AI");
+    }
+    return sanitizeForLatex(responseContent.text);
+  } catch (error) {
+    if (error.status === 401) {
+      throw new Error("Invalid API key. Please check your ANTHROPIC_API_KEY.");
+    }
+    throw error;
+  }
+}
+
+// src/deai.ts
+var EM_DASH_PATTERNS = [
+  // "Word — Word" at start of definition -> "Word:" 
+  { pattern: /\*\*([^*]+)\*\* — /g, replacement: "**$1:** " },
+  // "something — something else" mid-sentence -> ". " or ", "
+  { pattern: / — /g, replacement: ". " },
+  // Standalone em dash
+  { pattern: /—/g, replacement: ":" }
+];
+var WORD_REPLACEMENTS = {
+  "utilize": "use",
+  "utilizes": "uses",
+  "utilized": "used",
+  "utilizing": "using",
+  "utilization": "use",
+  "leverage": "use",
+  "leverages": "uses",
+  "leveraged": "used",
+  "leveraging": "using",
+  "facilitate": "help",
+  "facilitates": "helps",
+  "facilitated": "helped",
+  "facilitating": "helping",
+  "facilitation": "help",
+  "implement": "build",
+  "implements": "builds",
+  "implemented": "built",
+  "implementing": "building",
+  "implementation": "build",
+  "comprehensive": "full",
+  "robust": "strong",
+  "seamless": "smooth",
+  "seamlessly": "smoothly",
+  "cutting-edge": "modern",
+  "state-of-the-art": "modern",
+  "best-in-class": "top",
+  "world-class": "top",
+  "innovative": "new",
+  "revolutionize": "change",
+  "revolutionizes": "changes",
+  "revolutionizing": "changing",
+  "transformative": "major",
+  "synergy": "benefit",
+  "synergies": "benefits",
+  "paradigm": "model",
+  "paradigms": "models",
+  "ecosystem": "system",
+  "ecosystems": "systems",
+  "holistic": "complete",
+  "scalable": "grows with you",
+  "endeavor": "effort",
+  "endeavors": "efforts",
+  "whilst": "while",
+  "amongst": "among",
+  "towards": "toward",
+  "furthermore": "also",
+  "moreover": "also",
+  "nevertheless": "still",
+  "nonetheless": "still",
+  "henceforth": "from now on",
+  "thereby": "so",
+  "thereof": "of it",
+  "wherein": "where",
+  "whereby": "by which",
+  "insofar": "as far"
+};
+var PHRASE_REPLACEMENTS = [
+  // Filler phrases to cut entirely
+  { pattern: /It is important to note that /gi, replacement: "" },
+  { pattern: /It is worth noting that /gi, replacement: "" },
+  { pattern: /It should be noted that /gi, replacement: "" },
+  { pattern: /It goes without saying that /gi, replacement: "" },
+  { pattern: /Needless to say, /gi, replacement: "" },
+  { pattern: /As mentioned earlier, /gi, replacement: "" },
+  { pattern: /As previously mentioned, /gi, replacement: "" },
+  { pattern: /In today's world, /gi, replacement: "" },
+  { pattern: /In this day and age, /gi, replacement: "" },
+  { pattern: /At the end of the day, /gi, replacement: "" },
+  { pattern: /When all is said and done, /gi, replacement: "" },
+  { pattern: /In the realm of /gi, replacement: "In " },
+  { pattern: /In the world of /gi, replacement: "In " },
+  { pattern: /In the space of /gi, replacement: "In " },
+  // Verbose phrases to tighten
+  { pattern: /in order to /gi, replacement: "to " },
+  { pattern: /In order to /gi, replacement: "To " },
+  { pattern: /due to the fact that /gi, replacement: "because " },
+  { pattern: /Due to the fact that /gi, replacement: "Because " },
+  { pattern: /for the purpose of /gi, replacement: "for " },
+  { pattern: /For the purpose of /gi, replacement: "For " },
+  { pattern: /with the aim of /gi, replacement: "to " },
+  { pattern: /With the aim of /gi, replacement: "To " },
+  { pattern: /with regard to /gi, replacement: "about " },
+  { pattern: /With regard to /gi, replacement: "About " },
+  { pattern: /with respect to /gi, replacement: "about " },
+  { pattern: /With respect to /gi, replacement: "About " },
+  { pattern: /in the event that /gi, replacement: "if " },
+  { pattern: /In the event that /gi, replacement: "If " },
+  { pattern: /on a daily basis/gi, replacement: "daily" },
+  { pattern: /on a regular basis/gi, replacement: "regularly" },
+  { pattern: /at this point in time/gi, replacement: "now" },
+  { pattern: /at the present time/gi, replacement: "now" },
+  { pattern: /in the near future/gi, replacement: "soon" },
+  { pattern: /a large number of /gi, replacement: "many " },
+  { pattern: /A large number of /gi, replacement: "Many " },
+  { pattern: /a wide range of /gi, replacement: "many " },
+  { pattern: /A wide range of /gi, replacement: "Many " },
+  { pattern: /a variety of /gi, replacement: "various " },
+  { pattern: /A variety of /gi, replacement: "Various " },
+  { pattern: /the ability to /gi, replacement: "can " },
+  { pattern: /The ability to /gi, replacement: "Can " },
+  { pattern: /has the ability to /gi, replacement: "can " },
+  { pattern: /have the ability to /gi, replacement: "can " },
+  { pattern: /is able to /gi, replacement: "can " },
+  { pattern: /are able to /gi, replacement: "can " },
+  { pattern: /was able to /gi, replacement: "could " },
+  { pattern: /were able to /gi, replacement: "could " },
+  { pattern: /the fact that /gi, replacement: "that " },
+  { pattern: /despite the fact that /gi, replacement: "although " },
+  { pattern: /Despite the fact that /gi, replacement: "Although " },
+  { pattern: /in spite of the fact that /gi, replacement: "although " },
+  { pattern: /In spite of the fact that /gi, replacement: "Although " },
+  // AI opener patterns
+  { pattern: /^This document provides /gim, replacement: "This is " },
+  { pattern: /This enables /gi, replacement: "This lets " },
+  { pattern: /This allows /gi, replacement: "This lets " },
+  { pattern: /This ensures /gi, replacement: "This keeps " },
+  { pattern: /This provides /gi, replacement: "This gives " },
+  { pattern: /This creates /gi, replacement: "This makes " },
+  { pattern: /enables users to /gi, replacement: "lets users " },
+  { pattern: /allows users to /gi, replacement: "lets users " },
+  { pattern: /designed to /gi, replacement: "built to " },
+  // Redundant words
+  { pattern: /completely unique/gi, replacement: "unique" },
+  { pattern: /very unique/gi, replacement: "unique" },
+  { pattern: /absolutely essential/gi, replacement: "essential" },
+  { pattern: /basic fundamentals/gi, replacement: "fundamentals" },
+  { pattern: /future plans/gi, replacement: "plans" },
+  { pattern: /past history/gi, replacement: "history" },
+  { pattern: /end result/gi, replacement: "result" },
+  { pattern: /final outcome/gi, replacement: "outcome" },
+  { pattern: /free gift/gi, replacement: "gift" },
+  { pattern: /new innovation/gi, replacement: "innovation" },
+  { pattern: /unexpected surprise/gi, replacement: "surprise" },
+  { pattern: /close proximity/gi, replacement: "near" },
+  { pattern: /each and every/gi, replacement: "every" },
+  { pattern: /first and foremost/gi, replacement: "first" },
+  { pattern: /any and all/gi, replacement: "all" },
+  { pattern: /one and only/gi, replacement: "only" },
+  { pattern: /null and void/gi, replacement: "void" },
+  { pattern: /peace and quiet/gi, replacement: "quiet" }
+];
+function removeEmDashes(text) {
+  let result = text;
+  for (const { pattern, replacement } of EM_DASH_PATTERNS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function replaceAIWords(text) {
+  let result = text;
+  for (const [aiWord, simpleWord] of Object.entries(WORD_REPLACEMENTS)) {
+    const regex = new RegExp(`\\b${aiWord}\\b`, "gi");
+    result = result.replace(regex, (match) => {
+      if (match[0] === match[0].toUpperCase()) {
+        return simpleWord.charAt(0).toUpperCase() + simpleWord.slice(1);
+      }
+      return simpleWord;
+    });
+  }
+  return result;
+}
+function replacePhrases(text) {
+  let result = text;
+  for (const { pattern, replacement } of PHRASE_REPLACEMENTS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function cleanupWhitespace(text) {
+  return text.replace(/  +/g, " ").replace(/ \./g, ".").replace(/ ,/g, ",").replace(/\. \./g, ".").replace(/\n +/g, "\n").replace(/ +\n/g, "\n").replace(/\n{3,}/g, "\n\n");
+}
+function deAIify(text) {
+  let result = text;
+  result = replacePhrases(result);
+  result = replaceAIWords(result);
+  result = removeEmDashes(result);
+  result = cleanupWhitespace(result);
+  return result;
+}
+function deAIifyStats(text) {
+  let emDashes = 0;
+  let aiWords = 0;
+  let phrases = 0;
+  emDashes = (text.match(/—/g) || []).length;
+  for (const aiWord of Object.keys(WORD_REPLACEMENTS)) {
+    const regex = new RegExp(`\\b${aiWord}\\b`, "gi");
+    aiWords += (text.match(regex) || []).length;
+  }
+  for (const { pattern } of PHRASE_REPLACEMENTS) {
+    phrases += (text.match(pattern) || []).length;
+  }
+  return { emDashes, aiWords, phrases };
+}
+
+// src/pdfutils.ts
+import { execSync as execSync2 } from "child_process";
+import * as fs4 from "fs";
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function commandExists(cmd) {
+  try {
+    execSync2(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getPdfTool() {
+  if (commandExists("pdftk")) return "pdftk";
+  if (commandExists("qpdf")) return "qpdf";
+  if (commandExists("gs")) return "gs";
+  return null;
+}
+function getPdfInfo(pdfPath) {
+  if (!fs4.existsSync(pdfPath)) {
+    throw new Error(`File not found: ${pdfPath}`);
+  }
+  const stats = fs4.statSync(pdfPath);
+  if (commandExists("pdfinfo")) {
+    try {
+      const output = execSync2(`pdfinfo "${pdfPath}"`, { encoding: "utf-8" });
+      const lines = output.split("\n");
+      const info = {
+        pages: 0,
+        fileSize: stats.size,
+        fileSizeHuman: formatSize(stats.size),
+        encrypted: false
+      };
+      for (const line of lines) {
+        const [key, ...valueParts] = line.split(":");
+        const value = valueParts.join(":").trim();
+        switch (key?.trim()) {
+          case "Title":
+            info.title = value;
+            break;
+          case "Author":
+            info.author = value;
+            break;
+          case "Subject":
+            info.subject = value;
+            break;
+          case "Creator":
+            info.creator = value;
+            break;
+          case "Producer":
+            info.producer = value;
+            break;
+          case "CreationDate":
+            info.creationDate = value;
+            break;
+          case "ModDate":
+            info.modDate = value;
+            break;
+          case "Pages":
+            info.pages = parseInt(value) || 0;
+            break;
+          case "Encrypted":
+            info.encrypted = value.toLowerCase() !== "no";
+            break;
+          case "PDF version":
+            info.pdfVersion = value;
+            break;
+        }
+      }
+      return info;
+    } catch (e) {
+    }
+  }
+  return {
+    pages: 0,
+    // Can't determine without tools
+    fileSize: stats.size,
+    fileSizeHuman: formatSize(stats.size),
+    encrypted: false
+  };
+}
+function mergePdfs(inputPaths, outputPath) {
+  for (const p of inputPaths) {
+    if (!fs4.existsSync(p)) {
+      throw new Error(`File not found: ${p}`);
+    }
+  }
+  const tool = getPdfTool();
+  if (tool === "pdftk") {
+    const inputs = inputPaths.map((p) => `"${p}"`).join(" ");
+    execSync2(`pdftk ${inputs} cat output "${outputPath}"`, { stdio: "ignore" });
+  } else if (tool === "qpdf") {
+    const inputs = inputPaths.map((p) => `"${p}"`).join(" ");
+    execSync2(`qpdf --empty --pages ${inputs} -- "${outputPath}"`, { stdio: "ignore" });
+  } else if (tool === "gs") {
+    const inputs = inputPaths.map((p) => `"${p}"`).join(" ");
+    execSync2(`gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile="${outputPath}" ${inputs}`, { stdio: "ignore" });
+  } else {
+    throw new Error("No PDF tool available. Install pdftk, qpdf, or ghostscript.");
+  }
+  const info = getPdfInfo(outputPath);
+  return {
+    outputPath,
+    totalPages: info.pages,
+    fileSize: info.fileSize,
+    fileSizeHuman: info.fileSizeHuman
+  };
+}
+function extractPages(inputPath, outputPath, pages) {
+  if (!fs4.existsSync(inputPath)) {
+    throw new Error(`File not found: ${inputPath}`);
+  }
+  const tool = getPdfTool();
+  if (tool === "pdftk") {
+    const pageSpec = pages.replace(/,/g, " ");
+    execSync2(`pdftk "${inputPath}" cat ${pageSpec} output "${outputPath}"`, { stdio: "ignore" });
+  } else if (tool === "qpdf") {
+    execSync2(`qpdf "${inputPath}" --pages . ${pages} -- "${outputPath}"`, { stdio: "ignore" });
+  } else if (tool === "gs") {
+    const match = pages.match(/^(\d+)-(\d+)$/);
+    if (match) {
+      const first = match[1];
+      const last = match[2];
+      execSync2(`gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -dFirstPage=${first} -dLastPage=${last} -sOutputFile="${outputPath}" "${inputPath}"`, { stdio: "ignore" });
+    } else {
+      throw new Error('Ghostscript only supports simple page ranges (e.g., "1-5"). Install pdftk or qpdf for complex selections.');
+    }
+  } else {
+    throw new Error("No PDF tool available. Install pdftk, qpdf, or ghostscript.");
+  }
+  const info = getPdfInfo(outputPath);
+  return {
+    outputPath,
+    pagesExtracted: info.pages,
+    fileSize: info.fileSize,
+    fileSizeHuman: info.fileSizeHuman
+  };
+}
+function checkPdfTools() {
+  const pdfinfo = commandExists("pdfinfo");
+  const pdftk = commandExists("pdftk");
+  const qpdf = commandExists("qpdf");
+  const gs = commandExists("gs");
+  let recommended = null;
+  if (!pdftk && !qpdf && !gs) {
+    recommended = "brew install pdftk-java qpdf poppler";
+  } else if (!pdfinfo) {
+    recommended = "brew install poppler";
+  }
+  return { pdfinfo, pdftk, qpdf, gs, recommended };
+}
+
+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,
+  sanitizeForLatex,
+  generateContent,
+  enhanceContent,
+  generateSummary,
+  deAIify,
+  deAIifyStats,
+  getPdfInfo,
+  mergePdfs,
+  extractPages,
+  checkPdfTools
+};