claude-presentation-master 7.2.0 → 7.3.0

package/dist/index.js

@@ -102,6 +102,75 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_url = require("url");
 var yaml = __toESM(require("yaml"));
+
+// src/utils/Logger.ts
+var Logger = class {
+  level;
+  prefix;
+  timestamps;
+  constructor(options = {}) {
+    this.level = options.level ?? 1 /* INFO */;
+    this.prefix = options.prefix ?? "";
+    this.timestamps = options.timestamps ?? false;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  formatMessage(message) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
+    }
+    if (this.prefix) {
+      parts.push(`[${this.prefix}]`);
+    }
+    parts.push(message);
+    return parts.join(" ");
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(this.formatMessage(message), ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.info(this.formatMessage(message), ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(this.formatMessage(message), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(this.formatMessage(message), ...args);
+    }
+  }
+  // Progress messages (always shown unless silent)
+  progress(message) {
+    if (this.level < 4 /* SILENT */) {
+      console.info(message);
+    }
+  }
+  // Success messages
+  success(message) {
+    if (this.level < 4 /* SILENT */) {
+      console.info(`\u2705 ${message}`);
+    }
+  }
+  // Step messages for workflow progress
+  step(message) {
+    if (this.level <= 1 /* INFO */) {
+      console.info(`  \u2713 ${message}`);
+    }
+  }
+};
+var logger = new Logger({
+  level: process.env.LOG_LEVEL ? parseInt(process.env.LOG_LEVEL) : 1 /* INFO */
+});
+
+// src/kb/KnowledgeGateway.ts
 var import_meta = {};
 function getModuleDir() {
   if (typeof import_meta !== "undefined" && import_meta.url) {
@@ -113,7 +182,7 @@ function getModuleDir() {
   return process.cwd();
 }
 var KnowledgeGateway = class {
-  kb;
+  kb = {};
   loaded = false;
   constructor() {
   }
@@ -136,7 +205,7 @@ var KnowledgeGateway = class {
         const content = (0, import_fs.readFileSync)(path, "utf-8");
         this.kb = yaml.parse(content);
         this.loaded = true;
-        console.log(`  \u2713 Knowledge base loaded from ${path}`);
+        logger.step(`Knowledge base loaded from ${path}`);
         return;
       } catch {
       }
@@ -327,7 +396,7 @@ var KnowledgeGateway = class {
    */
   getChartGuidance(purpose) {
     this.ensureLoaded();
-    return this.kb.chart_selection_guide.by_purpose[purpose];
+    return this.kb.chart_selection_guide.by_purpose?.[purpose];
   }
   /**
    * Get charts to avoid
@@ -342,7 +411,7 @@ var KnowledgeGateway = class {
    */
   getIBPitchBookStructure(type) {
     this.ensureLoaded();
-    return this.kb.investment_banking?.pitch_book_types[type];
+    return this.kb.investment_banking?.pitch_book_types?.[type];
   }
   /**
    * Check if knowledge base is loaded
@@ -892,22 +961,27 @@ var ContentAnalyzer = class {
   async analyze(content, contentType) {
     await this.initialize();
     const text = this.parseContent(content, contentType);
-    const title = this.extractTitle(text);
+    const { title, subtitle } = this.extractTitleAndSubtitle(text);
+    logger.step(`Title: "${title}", Subtitle: "${subtitle || "(none)"}"`);
     const detectedType = this.detectPresentationType(text);
-    console.log(`  \u2713 Detected type: ${detectedType}`);
+    logger.step(`Detected type: ${detectedType}`);
     const sections = this.extractSections(text);
-    console.log(`  \u2713 Found ${sections.length} sections`);
+    logger.step(`Found ${sections.length} sections`);
     const scqa = this.extractSCQA(text);
     const sparkline = this.extractSparkline(text);
     const keyMessages = this.extractKeyMessages(text);
     const dataPoints = this.extractDataPoints(text);
-    console.log(`  \u2713 Found ${dataPoints.length} data points`);
+    logger.step(`Found ${dataPoints.length} data points`);
     const titles = sections.map((s) => s.header).filter((h) => h.length > 0);
     const starMoments = this.extractStarMoments(text);
     const estimatedSlideCount = Math.max(5, sections.length + 3);
+    const whatIsContent = scqa.situation ? [scqa.situation] : [];
+    const whatCouldBeContent = scqa.answer ? [scqa.answer] : keyMessages.slice(0, 2);
     return {
       detectedType,
       title,
+      subtitle,
+      // NEW: Use explicit subtitle from content
       sections,
       keyMessages,
       dataPoints,
@@ -918,8 +992,10 @@ var ContentAnalyzer = class {
         answer: scqa.answer || ""
       },
       sparkline: {
-        whatIs: sparkline.callToAction ? [sparkline.callToAction] : [],
-        whatCouldBe: keyMessages,
+        whatIs: whatIsContent,
+        // FIX: Use situation, not CTA
+        whatCouldBe: whatCouldBeContent,
+        // FIX: Use answer/vision, not random messages
         callToAdventure: sparkline.callToAction || ""
       },
       titles,
@@ -947,18 +1023,46 @@ var ContentAnalyzer = class {
     return text;
   }
   /**
-   * Extract the main title from content
+   * Extract the main title AND subtitle from content
+   * Subtitle is the line immediately after the H1 title (if not another header)
    */
-  extractTitle(text) {
-    const h1Match = text.match(/^#\s+(.+)$/m);
-    if (h1Match && h1Match[1]) {
-      return h1Match[1].replace(/\*\*/g, "").trim();
+  extractTitleAndSubtitle(text) {
+    const lines = text.split("\n");
+    let title = "Presentation";
+    let subtitle = "";
+    let foundTitle = false;
+    let titleLineIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const rawLine = lines[i];
+      if (!rawLine) continue;
+      const line = rawLine.trim();
+      const h1Match = line.match(/^#\s+(.+)$/);
+      if (h1Match && h1Match[1] && !foundTitle) {
+        title = h1Match[1].replace(/\*\*/g, "").trim();
+        foundTitle = true;
+        titleLineIndex = i;
+        continue;
+      }
+      if (foundTitle && i > titleLineIndex && line.length > 0) {
+        if (line.startsWith("#")) break;
+        if (line.startsWith("-") || line.startsWith("*") || /^\d+\./.test(line)) break;
+        subtitle = line.replace(/\*\*/g, "").trim().slice(0, 100);
+        break;
+      }
     }
-    const lines = text.split("\n").filter((l) => l.trim().length > 0);
-    if (lines.length > 0 && lines[0]) {
-      return lines[0].replace(/^#+\s*/, "").replace(/\*\*/g, "").trim().slice(0, 80);
+    if (!foundTitle) {
+      const firstLine = lines.find((l) => l.trim().length > 0);
+      if (firstLine) {
+        title = firstLine.replace(/^#+\s*/, "").replace(/\*\*/g, "").trim().slice(0, 80);
+      }
     }
-    return "Presentation";
+    return { title, subtitle };
+  }
+  /**
+   * Extract the main title from content (legacy wrapper)
+   */
+  extractTitle(text) {
+    return this.extractTitleAndSubtitle(text).title;
   }
   /**
    * Detect presentation type from content signals
@@ -1021,12 +1125,16 @@ var ContentAnalyzer = class {
       }
       const bulletMatch = trimmedLine.match(/^[-*+]\s+(.+)$/);
       if (bulletMatch && bulletMatch[1] && currentSection) {
-        currentSection.bullets.push(bulletMatch[1]);
+        const bulletText = bulletMatch[1];
+        currentSection.bullets.push(bulletText);
+        this.extractMetricsFromText(bulletText, currentSection.metrics);
         continue;
       }
       const numberedMatch = trimmedLine.match(/^\d+\.\s+(.+)$/);
       if (numberedMatch && numberedMatch[1] && currentSection) {
-        currentSection.bullets.push(numberedMatch[1]);
+        const itemText = numberedMatch[1];
+        currentSection.bullets.push(itemText);
+        this.extractMetricsFromText(itemText, currentSection.metrics);
         continue;
       }
       const metricMatch = trimmedLine.match(/\$?([\d,]+\.?\d*)[%]?\s*[-–—:]\s*(.+)/);
@@ -1037,6 +1145,9 @@ var ContentAnalyzer = class {
         });
         continue;
       }
+      if (currentSection && trimmedLine) {
+        this.extractMetricsFromText(trimmedLine, currentSection.metrics);
+      }
       if (trimmedLine.includes("|") && currentSection) {
         const cells = trimmedLine.split("|").map((c) => c.trim()).filter((c) => c && !c.match(/^-+$/));
         if (cells.length >= 2) {
@@ -1408,6 +1519,49 @@ var ContentAnalyzer = class {
     const fallback = cleaned.slice(0, 150);
     return fallback.length >= 20 ? fallback : "";
   }
+  /**
+   * Extract metrics from natural language text
+   * Handles formats like "40% productivity loss", "$2.5M investment"
+   */
+  extractMetricsFromText(text, metrics) {
+    const usedValues = new Set(metrics.map((m) => m.value));
+    const moneyMatches = text.matchAll(/(\$[\d,.]+[MBK]?)\s+([a-zA-Z][a-zA-Z\s]{2,30})/g);
+    for (const match of moneyMatches) {
+      const value = match[1];
+      const rawLabel = match[2]?.trim();
+      if (value && rawLabel && !usedValues.has(value)) {
+        usedValues.add(value);
+        metrics.push({ value, label: this.cleanMetricLabel(rawLabel) });
+      }
+    }
+    const percentMatches = text.matchAll(/(\d+(?:\.\d+)?%)\s+([a-zA-Z][a-zA-Z\s]{2,30})/g);
+    for (const match of percentMatches) {
+      const value = match[1];
+      const rawLabel = match[2]?.trim();
+      if (value && rawLabel && !usedValues.has(value)) {
+        usedValues.add(value);
+        metrics.push({ value, label: this.cleanMetricLabel(rawLabel) });
+      }
+    }
+    const multMatches = text.matchAll(/(\d+[xX])\s+([a-zA-Z][a-zA-Z\s]{2,20})/g);
+    for (const match of multMatches) {
+      const value = match[1];
+      const rawLabel = match[2]?.trim();
+      if (value && rawLabel && !usedValues.has(value)) {
+        usedValues.add(value);
+        metrics.push({ value, label: this.cleanMetricLabel(rawLabel) });
+      }
+    }
+    const numMatches = text.matchAll(/(\d{3,}\+?)\s+([a-zA-Z][a-zA-Z\s]{2,20})/g);
+    for (const match of numMatches) {
+      const value = match[1];
+      const rawLabel = match[2]?.trim();
+      if (value && rawLabel && !usedValues.has(value)) {
+        usedValues.add(value);
+        metrics.push({ value, label: this.cleanMetricLabel(rawLabel) });
+      }
+    }
+  }
 };
 
 // src/core/ContentPatternClassifier.ts
@@ -1592,8 +1746,8 @@ var SlideFactory = class {
     this.usedContent = /* @__PURE__ */ new Set();
     this.usedTitles = /* @__PURE__ */ new Set();
     this.config = this.loadKBConfig(type);
-    console.log(`  \u2713 SlideFactory v7.1.0 initialized for ${type} (${this.config.mode} mode)`);
-    console.log(`  \u2713 KB Config loaded: ${this.config.allowedTypes.length} allowed types`);
+    logger.step(`SlideFactory v7.1.0 initialized for ${type} (${this.config.mode} mode)`);
+    logger.step(`KB Config loaded: ${this.config.allowedTypes.length} allowed types`);
   }
   /**
    * Load ALL configuration from KB - ZERO hardcoded values after this.
@@ -1621,7 +1775,7 @@ var SlideFactory = class {
   async createSlides(analysis) {
     const slides = [];
     const storyStructure = this.kb.getStoryStructure(this.presentationType);
-    console.log(`  \u2713 Using ${storyStructure.framework} story framework`);
+    logger.step(`Using ${storyStructure.framework} story framework`);
     slides.push(this.createTitleSlide(0, analysis));
     const minSectionsForAgenda = Math.max(3, this.config.rules.bulletsPerSlide.max - 2);
     if (this.config.mode === "business" && analysis.sections.length >= minSectionsForAgenda) {
@@ -1659,7 +1813,7 @@ var SlideFactory = class {
     const validatedSlides = this.validateAndFixSlides(slides);
     this.checkRequiredElements(validatedSlides);
     this.checkAntiPatterns(validatedSlides);
-    console.log(`  \u2713 Created ${validatedSlides.length} validated slides`);
+    logger.step(`Created ${validatedSlides.length} validated slides`);
     return validatedSlides;
   }
   // ===========================================================================
@@ -1700,7 +1854,7 @@ var SlideFactory = class {
       case "technical":
         return this.createCodeSlide(index, section);
       default:
-        console.log(`  \u26A0 Unknown slide type '${type}', using bullet-points`);
+        logger.warn(`Unknown slide type '${type}', using bullet-points`);
         return this.createBulletSlide(index, section);
     }
   }
@@ -1711,9 +1865,10 @@ var SlideFactory = class {
     const data = {
       title: this.truncateText(analysis.title, this.config.rules.wordsPerSlide.max)
     };
-    if (analysis.keyMessages[0]) {
+    const subtitleSource = analysis.subtitle || analysis.keyMessages[0] || "";
+    if (subtitleSource) {
       data.subtitle = this.truncateText(
-        analysis.keyMessages[0],
+        subtitleSource,
         this.config.defaults.subtitle.maxWords
         // FROM KB
       );
@@ -1757,7 +1912,9 @@ var SlideFactory = class {
   addSCQASlides(slides, analysis) {
     const scqa = analysis.scqa;
     const titles = this.config.scqaTitles;
-    if (scqa?.situation && !this.usedContent.has("scqa-situation")) {
+    const minBodyLength = 20;
+    const situationBody = scqa?.situation ? this.truncateText(scqa.situation, this.config.rules.wordsPerSlide.max) : "";
+    if (situationBody.length >= minBodyLength && !this.usedContent.has("scqa-situation")) {
       this.usedContent.add("scqa-situation");
       slides.push({
         index: slides.length,
@@ -1765,12 +1922,13 @@ var SlideFactory = class {
         data: {
           title: titles.situation,
           // FROM KB - not hardcoded 'Current Situation'
-          body: this.truncateText(scqa.situation, this.config.rules.wordsPerSlide.max)
+          body: situationBody
         },
         classes: ["situation-slide"]
       });
     }
-    if (scqa?.complication && !this.usedContent.has("scqa-complication")) {
+    const complicationBody = scqa?.complication ? this.truncateText(scqa.complication, this.config.rules.wordsPerSlide.max) : "";
+    if (complicationBody.length >= minBodyLength && !this.usedContent.has("scqa-complication")) {
       this.usedContent.add("scqa-complication");
       slides.push({
         index: slides.length,
@@ -1778,12 +1936,13 @@ var SlideFactory = class {
         data: {
           title: titles.complication,
           // FROM KB - not hardcoded 'The Challenge'
-          body: this.truncateText(scqa.complication, this.config.rules.wordsPerSlide.max)
+          body: complicationBody
         },
         classes: ["complication-slide"]
       });
     }
-    if (scqa?.question && !this.usedContent.has("scqa-question")) {
+    const questionBody = scqa?.question ? this.truncateText(scqa.question, this.config.rules.wordsPerSlide.max) : "";
+    if (questionBody.length >= minBodyLength && !this.usedContent.has("scqa-question")) {
       this.usedContent.add("scqa-question");
       slides.push({
         index: slides.length,
@@ -1791,7 +1950,7 @@ var SlideFactory = class {
         data: {
           title: titles.question,
           // FROM KB - not hardcoded 'The Question'
-          body: this.truncateText(scqa.question, this.config.rules.wordsPerSlide.max)
+          body: questionBody
         },
         classes: ["question-slide"]
       });
@@ -1801,7 +1960,8 @@ var SlideFactory = class {
     const spark = analysis.sparkline;
     const titles = this.config.sparklineTitles;
     const whatIsFirst = spark?.whatIs?.[0];
-    if (whatIsFirst && !this.usedContent.has("spark-what-is")) {
+    const whatIsBody = whatIsFirst ? this.truncateText(whatIsFirst, this.config.rules.wordsPerSlide.max) : "";
+    if (whatIsBody.length >= 20 && !this.usedContent.has("spark-what-is")) {
       this.usedContent.add("spark-what-is");
       slides.push({
         index: slides.length,
@@ -1809,13 +1969,14 @@ var SlideFactory = class {
         data: {
           title: titles.whatIs,
           // FROM KB - not hardcoded 'Where We Are Today'
-          body: this.truncateText(whatIsFirst, this.config.rules.wordsPerSlide.max)
+          body: whatIsBody
         },
         classes: ["what-is-slide"]
       });
     }
     const whatCouldBeFirst = spark?.whatCouldBe?.[0];
-    if (whatCouldBeFirst && !this.usedContent.has("spark-could-be")) {
+    const whatCouldBeBody = whatCouldBeFirst ? this.truncateText(whatCouldBeFirst, this.config.rules.wordsPerSlide.max) : "";
+    if (whatCouldBeBody.length >= 20 && !this.usedContent.has("spark-could-be")) {
       this.usedContent.add("spark-could-be");
       slides.push({
         index: slides.length,
@@ -1823,7 +1984,7 @@ var SlideFactory = class {
         data: {
           title: titles.whatCouldBe,
           // FROM KB - not hardcoded 'What Could Be'
-          body: this.truncateText(whatCouldBeFirst, this.config.rules.wordsPerSlide.max)
+          body: whatCouldBeBody
         },
         classes: ["what-could-be-slide"]
       });
@@ -1833,15 +1994,19 @@ var SlideFactory = class {
   // CONTENT SLIDES - ALL values from KB
   // ===========================================================================
   createBigNumberSlide(index, section, pattern) {
-    const bigNumber = this.classifier.extractBigNumber(
-      `${section.header} ${section.content} ${section.bullets.join(" ")}`
-    );
+    const fullContent = `${section.header} ${section.content} ${section.bullets.join(" ")}`;
+    const bigNumber = this.classifier.extractBigNumber(fullContent);
+    const actualValue = bigNumber?.value || pattern.bigNumberValue;
+    if (!actualValue) {
+      logger.warn(`No number found for big-number slide, falling back to single-statement`);
+      return this.createSingleStatementSlide(index, section);
+    }
     return {
       index,
       type: "big-number",
       data: {
         title: this.createTitle(section.header, section),
-        keyMessage: bigNumber?.value || pattern.bigNumberValue || "0",
+        keyMessage: actualValue,
         body: bigNumber?.context || this.truncateText(
           section.content,
           this.config.defaults.context.maxWords
@@ -2028,16 +2193,18 @@ var SlideFactory = class {
     };
   }
   createSingleStatementSlide(index, section) {
+    const bodyContent = section.content || section.bullets.join(" ") || "";
+    const truncatedBody = this.truncateText(bodyContent, this.config.rules.wordsPerSlide.max);
+    if (truncatedBody.length < 15 && section.bullets.length > 0) {
+      return this.createBulletSlide(index, section);
+    }
     return {
       index,
       type: "single-statement",
       data: {
         title: this.createTitle(section.header, section),
-        body: this.truncateText(
-          section.content || section.bullets[0] || "",
-          this.config.rules.wordsPerSlide.max
-          // FROM KB
-        )
+        body: truncatedBody || section.header
+        // Fallback to header if no body
       },
       classes: ["single-statement-slide"]
     };
@@ -2110,7 +2277,7 @@ var SlideFactory = class {
         slide.data.bullets = slide.data.bullets.slice(0, validation.fixes.bulletCount);
       }
       if (validation.violations.length > 0) {
-        console.log(`  \u26A0 Slide ${slide.index} (${slide.type}): Fixed ${Object.keys(validation.fixes).length} issues, ${validation.violations.length} remaining`);
+        logger.warn(`Slide ${slide.index} (${slide.type}): Fixed ${Object.keys(validation.fixes).length} issues, ${validation.violations.length} remaining`);
       }
       if (validation.warnings.length > 0) {
         slide.notes = (slide.notes || "") + "\nWarnings: " + validation.warnings.join(", ");
@@ -2150,7 +2317,7 @@ var SlideFactory = class {
       }
     }
     if (missingElements.length > 0) {
-      console.log(`  \u26A0 Missing required elements: ${missingElements.join(", ")}`);
+      logger.warn(`Missing required elements: ${missingElements.join(", ")}`);
     }
   }
   /**
@@ -2181,7 +2348,7 @@ var SlideFactory = class {
       }
     }
     if (violations.length > 0) {
-      console.log(`  \u26A0 Anti-pattern violations: ${violations.join(", ")}`);
+      logger.warn(`Anti-pattern violations: ${violations.join(", ")}`);
     }
   }
   // ===========================================================================
@@ -2526,9 +2693,12 @@ var TemplateEngine = class {
     this.templates.set("big-number", this.handlebars.compile(`
       <section class="{{classes}}" data-slide-index="{{slideIndex}}" style="{{styles}}">
         <div class="slide-content big-number-content">
-          <div class="number animate-zoomIn">{{title}}</div>
-          {{#if subtitle}}
-          <p class="number-context animate-fadeIn delay-300">{{subtitle}}</p>
+          {{#if title}}
+          <h2 class="title animate-fadeIn">{{title}}</h2>
+          {{/if}}
+          <div class="number animate-zoomIn">{{keyMessage}}</div>
+          {{#if body}}
+          <p class="number-context animate-fadeIn delay-300">{{body}}</p>
           {{/if}}
           {{> source}}
         </div>
@@ -4912,6 +5082,12 @@ ${slides}
     const highlight = palette.accent || "#e94560";
     const text = palette.text || "#1a1a2e";
     const background = palette.background || "#ffffff";
+    const isDark = this.isDarkPalette(palette);
+    const defaultBg = isDark ? background : "#ffffff";
+    const defaultText = isDark ? text : "#1a1a2e";
+    const headingColor = isDark ? primary : primary;
+    const titleBg = isDark ? background : primary;
+    const titleBgEnd = isDark ? this.lightenColor(background, 10) : this.darkenColor(primary, 15);
     return `
     /* Base Styles - KB-Driven Design System */
     :root {
@@ -4938,7 +5114,13 @@ ${slides}
       font-family: var(--font-body);
       font-size: ${fontSize};
       line-height: ${lineHeight};
-      color: var(--color-text);
+      color: ${defaultText};
+      background: ${defaultBg};
+    }
+
+    /* Override reveal.js default backgrounds for dark mode */
+    .reveal .slides section {
+      background: ${defaultBg};
     }
 
     .reveal .slides {
@@ -4967,10 +5149,17 @@ ${slides}
       font-family: var(--font-heading);
       font-weight: 700;
       letter-spacing: -0.02em;
-      color: var(--color-primary);
+      color: ${isDark ? primary : primary};
       margin-bottom: 0.5em;
     }
 
+    /* Dark mode text visibility */
+    ${isDark ? `
+    .reveal, .reveal p, .reveal li, .reveal span {
+      color: ${text};
+    }
+    ` : ""}
+
     .reveal h1 { font-size: 2.5em; }
     .reveal h2 { font-size: 1.8em; }
     .reveal h3 { font-size: 1.3em; }
@@ -5148,6 +5337,124 @@ ${slides}
       font-weight: 600;
       margin-top: 1em;
     }
+
+    /* ================================================================
+       SLIDE TYPE BACKGROUNDS - KB-Driven Visual Design
+       Creates visual hierarchy and differentiation between slide types
+       ================================================================ */
+
+    /* Title slide: Bold background - makes strong first impression */
+    .reveal .slide-title {
+      background: linear-gradient(135deg, ${titleBg} 0%, ${titleBgEnd} 100%);
+    }
+    .reveal .slide-title h1,
+    .reveal .slide-title h2,
+    .reveal .slide-title p,
+    .reveal .slide-title .subtitle {
+      color: ${isDark ? primary : "#ffffff"};
+    }
+
+    /* Section dividers: Subtle visual breaks */
+    .reveal .slide-section-divider {
+      background: ${isDark ? this.lightenColor(background, 8) : `linear-gradient(180deg, ${this.lightenColor(primary, 85)} 0%, ${this.lightenColor(primary, 92)} 100%)`};
+    }
+
+    /* Big number slides: Clean with accent highlight - emphasizes the data */
+    .reveal .slide-big-number {
+      background: var(--color-background);
+      border-left: 8px solid var(--color-highlight);
+    }
+    .reveal .slide-big-number .number {
+      font-size: 5em;
+      background: linear-gradient(135deg, var(--color-highlight) 0%, var(--color-accent) 100%);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+    }
+
+    /* Metrics grid: Light accent background - data-focused */
+    .reveal .slide-metrics-grid {
+      background: ${isDark ? this.lightenColor(background, 8) : this.lightenColor(accent, 90)};
+    }
+    ${isDark ? `.reveal .slide-metrics-grid { color: ${text}; }` : ""}
+
+    /* CTA slide: Highlight color - drives action */
+    .reveal .slide-cta {
+      background: linear-gradient(135deg, var(--color-highlight) 0%, var(--color-accent) 100%);
+    }
+    .reveal .slide-cta h2,
+    .reveal .slide-cta p {
+      color: #ffffff;
+    }
+    .reveal .slide-cta .cta-button {
+      background: #ffffff;
+      color: var(--color-highlight);
+    }
+
+    /* Thank you slide: Matches title for bookend effect */
+    .reveal .slide-thank-you {
+      background: linear-gradient(135deg, ${titleBg} 0%, ${titleBgEnd} 100%);
+    }
+    .reveal .slide-thank-you h2,
+    .reveal .slide-thank-you p,
+    .reveal .slide-thank-you .subtitle {
+      color: ${isDark ? primary : "#ffffff"};
+    }
+
+    /* Quote slides: Elegant subtle background */
+    .reveal .slide-quote {
+      background: ${isDark ? this.lightenColor(background, 5) : this.lightenColor(secondary, 92)};
+    }
+    .reveal .slide-quote blockquote {
+      border-left-color: var(--color-accent);
+      font-size: 1.3em;
+    }
+    ${isDark ? `.reveal .slide-quote { color: ${text}; }` : ""}
+
+    /* Single statement: Clean, centered, impactful */
+    .reveal .slide-single-statement {
+      background: var(--color-background);
+    }
+    .reveal .slide-single-statement .statement,
+    .reveal .slide-single-statement .big-idea-text {
+      font-size: 2.2em;
+      max-width: 80%;
+      margin: 0 auto;
+    }
+
+    /* Comparison slides: Split visual */
+    .reveal .slide-comparison .columns {
+      gap: 60px;
+    }
+    .reveal .slide-comparison .column:first-child {
+      border-right: 2px solid ${this.lightenColor(secondary, 70)};
+      padding-right: 30px;
+    }
+
+    /* Timeline/Process: Visual flow */
+    .reveal .slide-timeline .steps,
+    .reveal .slide-process .steps {
+      display: flex;
+      gap: 20px;
+    }
+    .reveal .slide-timeline .step,
+    .reveal .slide-process .step {
+      flex: 1;
+      padding: 20px;
+      background: ${isDark ? this.lightenColor(background, 10) : this.lightenColor(secondary, 92)};
+      border-radius: 8px;
+      border-top: 4px solid var(--color-accent);
+      ${isDark ? `color: ${text};` : ""}
+    }
+
+    /* Progress bar enhancement */
+    .reveal .progress {
+      background: ${this.lightenColor(primary, 80)};
+      height: 4px;
+    }
+    .reveal .progress span {
+      background: var(--color-highlight);
+    }
     `;
   }
   /**
@@ -5163,6 +5470,37 @@ ${slides}
     b = Math.min(255, Math.floor(b + (255 - b) * (percent / 100)));
     return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
   }
+  /**
+   * Check if a palette is "dark mode" (dark background, light text)
+   */
+  isDarkPalette(palette) {
+    const bgLuminance = this.getLuminance(palette.background || "#ffffff");
+    const textLuminance = this.getLuminance(palette.text || "#000000");
+    return bgLuminance < textLuminance;
+  }
+  /**
+   * Get relative luminance of a hex color (0-1, 0=black, 1=white)
+   */
+  getLuminance(hex) {
+    hex = hex.replace("#", "");
+    const r = parseInt(hex.substring(0, 2), 16) / 255;
+    const g = parseInt(hex.substring(2, 4), 16) / 255;
+    const b = parseInt(hex.substring(4, 6), 16) / 255;
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  }
+  /**
+   * Darken a hex color
+   */
+  darkenColor(hex, percent) {
+    hex = hex.replace("#", "");
+    let r = parseInt(hex.substring(0, 2), 16);
+    let g = parseInt(hex.substring(2, 4), 16);
+    let b = parseInt(hex.substring(4, 6), 16);
+    r = Math.max(0, Math.floor(r * (1 - percent / 100)));
+    g = Math.max(0, Math.floor(g * (1 - percent / 100)));
+    b = Math.max(0, Math.floor(b * (1 - percent / 100)));
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
   /**
    * Get theme-specific styles - KB-DRIVEN
    */
@@ -5379,15 +5717,15 @@ var IterativeQAEngine = class {
     let autoFixSummary = "";
     let totalFixesApplied = 0;
     if (opts.verbose) {
-      console.log("\n\u{1F504} Starting Iterative QA Process");
-      console.log(`   Target Score: ${opts.minScore}/100`);
-      console.log(`   Max Iterations: ${opts.maxIterations}`);
-      console.log("");
+      logger.progress("\n\u{1F504} Starting Iterative QA Process");
+      logger.info(`   Target Score: ${opts.minScore}/100`);
+      logger.info(`   Max Iterations: ${opts.maxIterations}`);
+      logger.progress("");
     }
     for (let i = 0; i < opts.maxIterations; i++) {
       const iterationNum = i + 1;
       if (opts.verbose) {
-        console.log(`\u{1F4CA} Iteration ${iterationNum}/${opts.maxIterations}...`);
+        logger.progress(`\u{1F4CA} Iteration ${iterationNum}/${opts.maxIterations}...`);
       }
       scoringResult = await this.scorer.score(currentSlides, currentHtml, opts.minScore);
       iterations.push({
@@ -5406,17 +5744,17 @@ var IterativeQAEngine = class {
         timestamp: /* @__PURE__ */ new Date()
       });
       if (opts.verbose) {
-        console.log(`   Score: ${scoringResult.overallScore}/100`);
+        logger.info(`   Score: ${scoringResult.overallScore}/100`);
       }
       if (scoringResult.passed) {
         if (opts.verbose) {
-          console.log(`   \u2705 PASSED - Score meets threshold (${opts.minScore})`);
+          logger.success(`PASSED - Score meets threshold (${opts.minScore})`);
         }
         break;
       }
       if (i < opts.maxIterations - 1) {
         if (opts.verbose) {
-          console.log(`   \u26A0\uFE0F  Below threshold, applying auto-fixes...`);
+          logger.warn("Below threshold, applying auto-fixes...");
         }
         const fixResult = await this.fixer.fix(currentSlides, scoringResult);
         if (fixResult.fixesApplied.length > 0) {
@@ -5428,12 +5766,12 @@ var IterativeQAEngine = class {
           }
           totalFixesApplied += fixResult.fixesApplied.length;
           if (opts.verbose) {
-            console.log(`   \u{1F527} Applied ${fixResult.fixesApplied.length} fixes`);
+            logger.info(`   \u{1F527} Applied ${fixResult.fixesApplied.length} fixes`);
           }
           autoFixSummary += fixResult.summary + "\n";
         } else {
           if (opts.verbose) {
-            console.log(`   \u26A0\uFE0F  No auto-fixes available, manual review needed`);
+            logger.warn("No auto-fixes available, manual review needed");
           }
           break;
         }
@@ -5449,7 +5787,7 @@ var IterativeQAEngine = class {
       totalFixesApplied
     );
     if (opts.verbose) {
-      console.log(report);
+      logger.info(report);
     }
     return {
       finalScore: scoringResult.overallScore,
@@ -6251,6 +6589,172 @@ var PowerPointGenerator = class {
   }
 };
 
+// src/generators/PDFGenerator.ts
+var import_puppeteer = __toESM(require("puppeteer"));
+var PDFGenerator = class {
+  defaultOptions = {
+    orientation: "landscape",
+    printBackground: true,
+    format: "Slide",
+    scale: 1
+  };
+  /**
+   * Generate PDF from HTML presentation
+   * @param html - The HTML content of the presentation
+   * @param options - PDF generation options
+   * @returns Buffer containing the PDF file
+   */
+  async generate(html, options = {}) {
+    const opts = { ...this.defaultOptions, ...options };
+    logger.progress("\u{1F4C4} Generating PDF...");
+    let browser;
+    try {
+      browser = await import_puppeteer.default.launch({
+        headless: true,
+        args: [
+          "--no-sandbox",
+          "--disable-setuid-sandbox",
+          "--disable-dev-shm-usage"
+        ]
+      });
+      const page = await browser.newPage();
+      const printHtml = this.preparePrintHtml(html);
+      await page.setViewport({
+        width: 1920,
+        height: 1080
+      });
+      await page.setContent(printHtml, {
+        waitUntil: ["networkidle0", "domcontentloaded"]
+      });
+      await page.evaluate(() => {
+        return new Promise((resolve) => {
+          if (document.fonts && document.fonts.ready) {
+            document.fonts.ready.then(() => resolve());
+          } else {
+            setTimeout(resolve, 1e3);
+          }
+        });
+      });
+      const pdfBuffer = await page.pdf({
+        width: "1920px",
+        height: "1080px",
+        printBackground: opts.printBackground,
+        scale: opts.scale,
+        landscape: opts.orientation === "landscape",
+        margin: {
+          top: "0px",
+          right: "0px",
+          bottom: "0px",
+          left: "0px"
+        }
+      });
+      logger.step("PDF generated successfully");
+      return Buffer.from(pdfBuffer);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`PDF generation failed: ${errorMessage}`);
+      throw new Error(`PDF generation failed: ${errorMessage}`);
+    } finally {
+      if (browser) {
+        await browser.close();
+      }
+    }
+  }
+  /**
+   * Prepare HTML for print/PDF output
+   * Modifies the HTML to work better as a printed document
+   */
+  preparePrintHtml(html) {
+    const printCss = `
+      <style id="pdf-print-styles">
+        /* Print-specific overrides */
+        @page {
+          size: 1920px 1080px;
+          margin: 0;
+        }
+
+        @media print {
+          html, body {
+            margin: 0;
+            padding: 0;
+            width: 1920px;
+            height: 1080px;
+          }
+
+          .reveal .slides {
+            width: 100% !important;
+            height: 100% !important;
+            margin: 0 !important;
+            padding: 0 !important;
+            transform: none !important;
+          }
+
+          .reveal .slides section {
+            page-break-after: always;
+            page-break-inside: avoid;
+            width: 1920px !important;
+            height: 1080px !important;
+            margin: 0 !important;
+            padding: 60px !important;
+            box-sizing: border-box;
+            position: relative !important;
+            top: auto !important;
+            left: auto !important;
+            transform: none !important;
+            display: flex !important;
+            opacity: 1 !important;
+            visibility: visible !important;
+          }
+
+          .reveal .slides section:last-child {
+            page-break-after: auto;
+          }
+
+          /* Make all slides visible for printing */
+          .reveal .slides section.future,
+          .reveal .slides section.past {
+            display: flex !important;
+            opacity: 1 !important;
+            visibility: visible !important;
+          }
+
+          /* Disable animations for print */
+          * {
+            animation: none !important;
+            transition: none !important;
+          }
+
+          /* Hide Reveal.js controls */
+          .reveal .controls,
+          .reveal .progress,
+          .reveal .slide-number,
+          .reveal .speaker-notes,
+          .reveal .navigate-left,
+          .reveal .navigate-right,
+          .reveal .navigate-up,
+          .reveal .navigate-down {
+            display: none !important;
+          }
+        }
+
+        /* Force print mode in Puppeteer */
+        .reveal .slides section {
+          page-break-after: always;
+          page-break-inside: avoid;
+        }
+      </style>
+    `;
+    if (html.includes("</head>")) {
+      return html.replace("</head>", `${printCss}</head>`);
+    } else {
+      return printCss + html;
+    }
+  }
+};
+function createPDFGenerator() {
+  return new PDFGenerator();
+}
+
 // src/core/PresentationEngine.ts
 var PresentationEngine = class {
   contentAnalyzer;
@@ -6259,6 +6763,7 @@ var PresentationEngine = class {
   qaEngine;
   htmlGenerator;
   pptxGenerator;
+  pdfGenerator;
   kb;
   constructor() {
     this.contentAnalyzer = new ContentAnalyzer();
@@ -6267,6 +6772,7 @@ var PresentationEngine = class {
     this.qaEngine = new QAEngine();
     this.htmlGenerator = new RevealJsGenerator();
     this.pptxGenerator = new PowerPointGenerator();
+    this.pdfGenerator = createPDFGenerator();
   }
   /**
    * Generate a presentation from content.
@@ -6276,26 +6782,26 @@ var PresentationEngine = class {
    */
   async generate(config) {
     this.validateConfig(config);
-    console.log("\u{1F4DA} Loading knowledge base...");
+    logger.progress("\u{1F4DA} Loading knowledge base...");
     this.kb = await getKnowledgeGateway();
-    console.log("\u{1F4DD} Analyzing content...");
+    logger.progress("\u{1F4DD} Analyzing content...");
     const analysis = await this.contentAnalyzer.analyze(config.content, config.contentType);
     const presentationType = config.presentationType || analysis.detectedType;
-    console.log(`  \u2713 Presentation type: ${presentationType}`);
+    logger.step(`Presentation type: ${presentationType}`);
     const slideFactory = createSlideFactory(this.kb, presentationType);
-    console.log("\u{1F3A8} Creating slides...");
+    logger.progress("\u{1F3A8} Creating slides...");
     const slides = await slideFactory.createSlides(analysis);
-    console.log("\u2705 Validating structure...");
+    logger.progress("\u2705 Validating structure...");
     const structureErrors = this.validateStructure(slides, config.mode);
     if (structureErrors.length > 0) {
       if (config.skipQA) {
-        console.log("\u26A0\uFE0F  Structure warnings (bypassed):");
-        structureErrors.forEach((e) => console.log(`   \u2022 ${e}`));
+        logger.warn("Structure warnings (bypassed):");
+        structureErrors.forEach((e) => logger.warn(`   \u2022 ${e}`));
       } else {
         throw new ValidationError(structureErrors, "Slide structure validation failed");
       }
     }
-    console.log("\u{1F528} Generating outputs...");
+    logger.progress("\u{1F528} Generating outputs...");
     const outputs = {};
     if (config.format.includes("html")) {
       outputs.html = await this.htmlGenerator.generate(slides, config);
@@ -6313,7 +6819,7 @@ var PresentationEngine = class {
       const maxIterations = config.maxIterations ?? 5;
       const useIterativeQA = config.useIterativeQA !== false;
       if (useIterativeQA) {
-        console.log("\u{1F50D} Running Iterative QA (7-Dimension Scoring)...");
+        logger.progress("\u{1F50D} Running Iterative QA (7-Dimension Scoring)...");
         const iterativeEngine = createIterativeQAEngine(
           config.mode,
           presentationType,
@@ -6335,20 +6841,30 @@ var PresentationEngine = class {
           throw new QAFailureError(score, threshold, qaResults);
         }
       } else {
-        console.log("\u{1F50D} Running QA validation (legacy mode)...");
+        logger.progress("\u{1F50D} Running QA validation (legacy mode)...");
         qaResults = await this.qaEngine.validate(outputs.html, {
           mode: config.mode,
           strictMode: true
         });
         score = this.scoreCalculator.calculate(qaResults);
-        console.log(`\u{1F4CA} QA Score: ${score}/100`);
+        logger.info(`\u{1F4CA} QA Score: ${score}/100`);
         if (score < threshold) {
           throw new QAFailureError(score, threshold, qaResults);
         }
       }
     } else {
       qaResults = this.qaEngine.createEmptyResults();
-      console.log("\u26A0\uFE0F  QA validation skipped (NOT RECOMMENDED)");
+      logger.warn("QA validation skipped (NOT RECOMMENDED)");
+    }
+    if (outputs.html && (config.format.includes("pdf") || config.generatePdf !== false)) {
+      try {
+        logger.progress("\u{1F4C4} Generating PDF from validated HTML...");
+        outputs.pdf = await this.pdfGenerator.generate(outputs.html);
+        logger.step("PDF generated successfully");
+      } catch (pdfError) {
+        const errorMsg = pdfError instanceof Error ? pdfError.message : String(pdfError);
+        logger.warn(`PDF generation failed (non-critical): ${errorMsg}`);
+      }
     }
     const metadata = this.buildMetadata(config, analysis, finalSlides, iterativeResult);
     return {
@@ -6436,15 +6952,28 @@ var PresentationEngine = class {
     if (slides.length < 3) {
       errors.push("Presentation must have at least 3 slides");
     }
+    const sparseByDesignTypes = [
+      "title",
+      "section-divider",
+      "thank-you",
+      "big-number",
+      "single-statement",
+      "cta",
+      "agenda",
+      "metrics-grid",
+      "quote",
+      "image-focus"
+    ];
     slides.forEach((slide, index) => {
       const wordCount = this.countWords(slide);
       if (mode === "keynote") {
-        if (wordCount > 25) {
+        if (wordCount > 25 && !sparseByDesignTypes.includes(slide.type)) {
           errors.push(`Slide ${index + 1}: ${wordCount} words exceeds keynote limit of 25`);
         }
       } else {
-        if (wordCount < 20 && !["title", "section-divider", "thank-you"].includes(slide.type)) {
-          errors.push(`Slide ${index + 1}: ${wordCount} words may be too sparse for business mode`);
+        const requiresMinWords = ["bullet-points", "two-column", "process-flow"];
+        if (wordCount < 20 && requiresMinWords.includes(slide.type)) {
+          logger.warn(`Slide ${index + 1}: ${wordCount} words is sparse for ${slide.type} slide`);
         }
         if (wordCount > 100) {
           errors.push(`Slide ${index + 1}: ${wordCount} words exceeds business limit of 100`);
@@ -6538,11 +7067,11 @@ var SlideGenerator = class {
     await this.initialize();
     this.presentationType = type || analysis.detectedType;
     this.mode = this.kb.getModeForType(this.presentationType);
-    console.log(`  \u2713 Using ${this.mode} mode for ${this.presentationType}`);
+    logger.step(`Using ${this.mode} mode for ${this.presentationType}`);
     this.factory = createSlideFactory(this.kb, this.presentationType);
     const slides = await this.factory.createSlides(analysis);
     const legacySlides = this.convertToLegacyFormat(slides);
-    console.log(`  \u2713 Generated ${legacySlides.length} KB-validated slides`);
+    logger.step(`Generated ${legacySlides.length} KB-validated slides`);
     return legacySlides;
   }
   /**