ai-pdf-builder 0.2.0 → 0.3.1

package/dist/cli.js

@@ -0,0 +1,751 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// src/generator.ts
+var import_child_process2 = require("child_process");
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+
+// src/templates.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("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];
+}
+
+// src/utils.ts
+var import_child_process = require("child_process");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
+function checkPandoc() {
+  try {
+    const version = (0, import_child_process.execSync)("pandoc --version", { encoding: "utf-8" });
+    const versionMatch = version.match(/pandoc\s+([\d.]+)/);
+    const pathResult = (0, import_child_process.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 = (0, import_child_process.execSync)("pdflatex --version", { encoding: "utf-8" });
+    const versionMatch = version.match(/pdfTeX\s+([\d.-]+)/);
+    const pathResult = (0, import_child_process.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";
+}
+
+// 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((resolve3, 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 = (0, import_child_process2.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) {
+        resolve3();
+      } 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: "default",
+    toc: true,
+    tocDepth: 2,
+    numberSections: true,
+    fontSize: 11,
+    margin: "1in",
+    ...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 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/cli.ts
+var VERSION = "0.3.1";
+var HELP = `
+ai-pdf-builder v${VERSION}
+Generate professional PDFs from Markdown
+
+USAGE:
+  ai-pdf-builder <command> [options]
+
+COMMANDS:
+  generate <type> <input>   Generate a PDF from markdown file
+  check                     Check system requirements
+  templates                 List available templates
+  help                      Show this help message
+
+DOCUMENT TYPES:
+  whitepaper    Technical documentation, litepapers
+  memo          Executive summaries, internal memos
+  agreement     Legal contracts, general agreements
+  termsheet     Investment term sheets
+  safe          SAFE agreements
+  nda           Non-disclosure agreements
+  report        Business reports, analysis
+  proposal      Business proposals, pitches
+
+OPTIONS:
+  -o, --output <file>       Output file path (default: output.pdf)
+  -t, --title <title>       Document title
+  -s, --subtitle <text>     Document subtitle
+  -a, --author <name>       Author name
+  -d, --date <date>         Document date
+  -v, --version <ver>       Document version
+  --no-toc                  Disable table of contents
+  --color-primary <hex>     Primary brand color
+  --color-secondary <hex>   Secondary brand color
+
+EXAMPLES:
+  # Generate a whitepaper
+  ai-pdf-builder generate whitepaper ./content.md -o whitepaper.pdf -t "My Project"
+
+  # Generate a term sheet
+  ai-pdf-builder generate termsheet ./terms.md -t "Series Seed" -s "Acme Inc."
+
+  # Generate a SAFE
+  ai-pdf-builder generate safe ./safe.md -o safe-agreement.pdf
+
+  # Check if Pandoc/LaTeX are installed
+  ai-pdf-builder check
+
+  # List available templates
+  ai-pdf-builder templates
+`;
+function parseArgs(args) {
+  const options = {
+    output: "output.pdf",
+    toc: true
+  };
+  let command = "help";
+  let type;
+  let input;
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "generate" || arg === "check" || arg === "templates" || arg === "help") {
+      command = arg;
+      if (arg === "generate") {
+        type = args[++i];
+        input = args[++i];
+      }
+    } else if (arg === "-o" || arg === "--output") {
+      options.output = args[++i];
+    } else if (arg === "-t" || arg === "--title") {
+      options.title = args[++i];
+    } else if (arg === "-s" || arg === "--subtitle") {
+      options.subtitle = args[++i];
+    } else if (arg === "-a" || arg === "--author") {
+      options.author = args[++i];
+    } else if (arg === "-d" || arg === "--date") {
+      options.date = args[++i];
+    } else if (arg === "-v" || arg === "--version") {
+      options.version = args[++i];
+    } else if (arg === "--no-toc") {
+      options.toc = false;
+    } else if (arg === "--color-primary") {
+      options.colorPrimary = args[++i];
+    } else if (arg === "--color-secondary") {
+      options.colorSecondary = args[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      command = "help";
+    }
+    i++;
+  }
+  return { command, type, input, options };
+}
+async function runGenerate(type, input, options) {
+  if (!fs4.existsSync(input)) {
+    console.error(`Error: Input file not found: ${input}`);
+    process.exit(1);
+  }
+  const content = fs4.readFileSync(input, "utf-8");
+  const metadata = {
+    title: options.title || path4.basename(input, path4.extname(input)),
+    subtitle: options.subtitle || "",
+    author: options.author || "",
+    date: options.date || (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { month: "long", year: "numeric" }),
+    version: options.version || ""
+  };
+  const pdfOptions = {
+    outputPath: path4.resolve(options.output),
+    toc: options.toc,
+    customColors: options.colorPrimary || options.colorSecondary ? {
+      primary: options.colorPrimary,
+      secondary: options.colorSecondary
+    } : void 0
+  };
+  console.log(`Generating ${type}...`);
+  let result;
+  switch (type) {
+    case "whitepaper":
+      result = await generateWhitepaper(content, metadata, pdfOptions);
+      break;
+    case "memo":
+      result = await generateMemo(content, metadata, pdfOptions);
+      break;
+    case "agreement":
+      result = await generateAgreement(content, metadata, pdfOptions);
+      break;
+    case "termsheet":
+      result = await generateTermsheet(content, metadata, pdfOptions);
+      break;
+    case "safe":
+      result = await generateSAFE(content, metadata, pdfOptions);
+      break;
+    case "nda":
+      result = await generateNDA(content, metadata, pdfOptions);
+      break;
+    case "report":
+      result = await generateReport(content, metadata, pdfOptions);
+      break;
+    case "proposal":
+      result = await generateProposal(content, metadata, pdfOptions);
+      break;
+    default:
+      console.error(`Unknown document type: ${type}`);
+      console.log("Valid types: whitepaper, memo, agreement, termsheet, safe, nda, report, proposal");
+      process.exit(1);
+  }
+  if (result.success) {
+    console.log(`\u2713 Generated: ${options.output}`);
+    console.log(`  Size: ${(result.fileSize / 1024).toFixed(1)} KB`);
+    console.log(`  Time: ${result.generationTime}ms`);
+    if (result.pageCount) {
+      console.log(`  Pages: ${result.pageCount}`);
+    }
+  } else {
+    console.error(`\u2717 Error: ${result.error}`);
+    process.exit(1);
+  }
+}
+function runCheck() {
+  console.log("Checking system requirements...\n");
+  const check = checkSystem();
+  if (check.ready) {
+    console.log("\u2713 System is ready for PDF generation\n");
+    console.log(`  Pandoc: ${check.pandoc?.version || "installed"}`);
+    console.log(`  LaTeX: ${check.latex?.version || "installed"}`);
+  } else {
+    console.log("\u2717 System requirements not met\n");
+    console.log(`  ${check.message}
+`);
+    console.log("Install instructions:");
+    console.log("  macOS: brew install pandoc && brew install --cask basictex");
+    console.log("  Linux: sudo apt-get install pandoc texlive-full");
+    process.exit(1);
+  }
+}
+function runTemplates() {
+  console.log("Available templates:\n");
+  const templates = listTemplates();
+  templates.forEach((t) => {
+    console.log(`  ${t.name.padEnd(15)} - ${t.description || "No description"}`);
+  });
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log(HELP);
+    return;
+  }
+  const { command, type, input, options } = parseArgs(args);
+  switch (command) {
+    case "generate":
+      if (!type || !input) {
+        console.error("Error: generate requires <type> and <input> arguments");
+        console.log("Usage: ai-pdf-builder generate <type> <input> [options]");
+        process.exit(1);
+      }
+      await runGenerate(type, input, options);
+      break;
+    case "check":
+      runCheck();
+      break;
+    case "templates":
+      runTemplates();
+      break;
+    case "help":
+    default:
+      console.log(HELP);
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});