claude-presentation-master 6.1.0 → 7.2.0

package/bin/auto-fix-presentation.cjs

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+/**
+ * AUTOMATED PRESENTATION QUALITY ASSURANCE
+ *
+ * Iteratively scores and fixes presentations until ALL dimensions hit 95+
+ * Target: 100, Minimum: 95
+ *
+ * Usage: node auto-fix-presentation.cjs <html-file>
+ */
+
+const { chromium } = require('playwright');
+const path = require('path');
+const fs = require('fs');
+
+const TARGET_SCORE = 95;
+const MAX_ITERATIONS = 10;
+
+// CSS fixes for common issues
+const CSS_FIXES = {
+  smallText: {
+    selector: '.small-text-fix',
+    css: 'font-size: 1.25rem !important;'
+  },
+  lowContrast: {
+    selector: '.contrast-fix',
+    css: 'color: #ffffff !important; text-shadow: 0 2px 10px rgba(0,0,0,0.8) !important;'
+  },
+  titleContrast: {
+    selector: '.title-contrast-fix',
+    css: 'color: #ffffff !important; text-shadow: 0 4px 20px rgba(0,0,0,0.9) !important;'
+  }
+};
+
+async function analyzeSlide(page) {
+  return await page.evaluate(() => {
+    const slide = document.querySelector('.present') || document.querySelector('section');
+    if (!slide) return { error: 'No slide found' };
+
+    function parseColor(colorStr) {
+      if (!colorStr) return null;
+      const match = colorStr.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+      if (match) return { r: parseInt(match[1]), g: parseInt(match[2]), b: parseInt(match[3]) };
+      return null;
+    }
+
+    function getLuminance(rgb) {
+      const [r, g, b] = [rgb.r, rgb.g, rgb.b].map(c => {
+        c = c / 255;
+        return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+      });
+      return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    }
+
+    function getContrast(fg, bg) {
+      if (!fg || !bg) return 21;
+      const l1 = getLuminance(fg);
+      const l2 = getLuminance(bg);
+      return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+    }
+
+    function getEffectiveBg(element) {
+      let el = element;
+      while (el && el !== document.body) {
+        const bg = window.getComputedStyle(el).backgroundColor;
+        if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') {
+          const parsed = parseColor(bg);
+          if (parsed) return parsed;
+        }
+        el = el.parentElement;
+      }
+      return { r: 10, g: 10, b: 11 };
+    }
+
+    const textContent = slide.innerText || '';
+    const words = textContent.split(/\\s+/).filter(w => w.length > 0);
+    const wordCount = words.length;
+
+    const allText = slide.querySelectorAll('h1, h2, h3, h4, h5, h6, p, li, span, div');
+    const textIssues = [];
+
+    allText.forEach(el => {
+      const text = el.innerText?.trim();
+      if (!text || text.length < 2) return;
+
+      const style = window.getComputedStyle(el);
+      const fontSize = parseFloat(style.fontSize);
+      let color = parseColor(style.color);
+      if (!color) color = { r: 255, g: 255, b: 255 };
+      const bgColor = getEffectiveBg(el);
+      const contrast = getContrast(color, bgColor);
+      const isTitle = el.tagName.match(/^H[1-3]$/) || fontSize >= 30;
+
+      if (fontSize < 18) {
+        textIssues.push({ type: 'smallText', element: el.tagName, text: text.substring(0, 30), fontSize });
+      }
+      if (isTitle && contrast < 7) {
+        textIssues.push({ type: 'titleContrast', element: el.tagName, text: text.substring(0, 30), contrast });
+      } else if (!isTitle && contrast < 4.5) {
+        textIssues.push({ type: 'bodyContrast', element: el.tagName, text: text.substring(0, 30), contrast });
+      }
+    });
+
+    const images = slide.querySelectorAll('img');
+    const majorElements = slide.querySelectorAll('h1, h2, h3, img, .card, .stat, ul, ol');
+
+    return {
+      wordCount,
+      textIssues,
+      elementCount: majorElements.length,
+      imageCount: images.length,
+      hasTitle: !!slide.querySelector('h1, h2, h3')
+    };
+  });
+}
+
+function calculateScores(analysis) {
+  let layout = 100, contrast = 100, graphics = 100;
+  let content = 100, clarity = 100, effectiveness = 100;
+  const issues = [];
+
+  // Layout scoring
+  if (analysis.wordCount > 40) {
+    layout -= Math.min(30, (analysis.wordCount - 40) * 2);
+    issues.push(`Words: ${analysis.wordCount} (max 40)`);
+  }
+  if (analysis.elementCount > 7) {
+    layout -= 15;
+    issues.push(`Elements: ${analysis.elementCount} (max 7)`);
+  }
+  const smallTextCount = analysis.textIssues.filter(i => i.type === 'smallText').length;
+  if (smallTextCount > 0) {
+    layout -= smallTextCount * 5;
+    issues.push(`Small text: ${smallTextCount} elements`);
+  }
+
+  // Contrast scoring
+  const titleContrastIssues = analysis.textIssues.filter(i => i.type === 'titleContrast');
+  const bodyContrastIssues = analysis.textIssues.filter(i => i.type === 'bodyContrast');
+  if (titleContrastIssues.length > 0) {
+    contrast -= titleContrastIssues.length * 20;
+    issues.push(`Title contrast issues: ${titleContrastIssues.length}`);
+  }
+  if (bodyContrastIssues.length > 0) {
+    contrast -= bodyContrastIssues.length * 10;
+    issues.push(`Body contrast issues: ${bodyContrastIssues.length}`);
+  }
+
+  // Graphics scoring
+  if (analysis.imageCount === 0 && analysis.wordCount > 20) {
+    graphics -= 20;
+    issues.push('No images on text-heavy slide');
+  }
+
+  // Content scoring
+  if (analysis.wordCount < 10 && analysis.wordCount > 0) content -= 10;
+  if (!analysis.hasTitle) {
+    content -= 20;
+    issues.push('No title');
+  }
+
+  // Clarity scoring
+  if (analysis.wordCount > 50) clarity -= 20;
+  if (analysis.elementCount > 5) clarity -= (analysis.elementCount - 5) * 5;
+
+  // Effectiveness
+  if (!analysis.hasTitle) effectiveness -= 25;
+  if (titleContrastIssues.length > 0) effectiveness -= 30;
+
+  return {
+    layout: Math.max(0, Math.round(layout)),
+    contrast: Math.max(0, Math.round(contrast)),
+    graphics: Math.max(0, Math.round(graphics)),
+    content: Math.max(0, Math.round(content)),
+    clarity: Math.max(0, Math.round(clarity)),
+    effectiveness: Math.max(0, Math.round(effectiveness)),
+    consistency: 100,
+    issues
+  };
+}
+
+async function runFullAnalysis(htmlPath) {
+  const browser = await chromium.launch();
+  const page = await browser.newPage({ viewport: { width: 1920, height: 1080 } });
+
+  await page.goto(`file://${path.resolve(htmlPath)}`, { waitUntil: 'networkidle' });
+  await page.waitForTimeout(3000);
+
+  const totalSlides = await page.evaluate(() => {
+    if (typeof Reveal !== 'undefined') return Reveal.getTotalSlides();
+    return document.querySelectorAll('.slides > section').length || 10;
+  });
+
+  const slideResults = [];
+
+  for (let i = 0; i < totalSlides; i++) {
+    const analysis = await analyzeSlide(page);
+    const scores = calculateScores(analysis);
+    const overall = Math.round(Object.values(scores).filter(v => typeof v === 'number').reduce((a, b) => a + b, 0) / 7);
+
+    slideResults.push({
+      slide: i + 1,
+      scores,
+      overall,
+      issues: scores.issues,
+      analysis
+    });
+
+    await page.keyboard.press('ArrowRight');
+    await page.waitForTimeout(1000);
+  }
+
+  await browser.close();
+
+  // Calculate dimension averages
+  const dimensions = ['layout', 'contrast', 'graphics', 'content', 'clarity', 'effectiveness', 'consistency'];
+  const averages = {};
+  dimensions.forEach(dim => {
+    averages[dim] = Math.round(slideResults.reduce((sum, r) => sum + r.scores[dim], 0) / totalSlides);
+  });
+  averages.total = Math.round(Object.values(averages).reduce((a, b) => a + b, 0) / dimensions.length);
+
+  return { slideResults, averages, totalSlides };
+}
+
+function printScores(averages, slideResults) {
+  console.log('\\n  ═══════════════════════════════════════════════════');
+  console.log('  DIMENSION SCORES');
+  console.log('  ═══════════════════════════════════════════════════');
+  console.log(`  Layout:        ${averages.layout.toString().padStart(3)}/100  ${averages.layout >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log(`  Contrast:      ${averages.contrast.toString().padStart(3)}/100  ${averages.contrast >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log(`  Graphics:      ${averages.graphics.toString().padStart(3)}/100  ${averages.graphics >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log(`  Content:       ${averages.content.toString().padStart(3)}/100  ${averages.content >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log(`  Clarity:       ${averages.clarity.toString().padStart(3)}/100  ${averages.clarity >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log(`  Effectiveness: ${averages.effectiveness.toString().padStart(3)}/100  ${averages.effectiveness >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log(`  Consistency:   ${averages.consistency.toString().padStart(3)}/100  ${averages.consistency >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log('  ───────────────────────────────────────────────────');
+  console.log(`  TOTAL:         ${averages.total.toString().padStart(3)}/100  ${averages.total >= TARGET_SCORE ? '✅' : '❌'}`);
+  console.log('  ═══════════════════════════════════════════════════\\n');
+
+  // Show failing slides
+  const failingSlides = slideResults.filter(r => r.overall < TARGET_SCORE);
+  if (failingSlides.length > 0) {
+    console.log('  SLIDES BELOW TARGET:');
+    failingSlides.forEach(r => {
+      console.log(`  Slide ${r.slide}: ${r.overall}/100 - ${r.issues.join(', ')}`);
+    });
+    console.log('');
+  }
+}
+
+function identifyFixes(results) {
+  const fixes = [];
+
+  results.slideResults.forEach(r => {
+    if (r.scores.layout < TARGET_SCORE) {
+      const smallText = r.analysis.textIssues.filter(i => i.type === 'smallText');
+      if (smallText.length > 0) {
+        fixes.push({
+          slide: r.slide,
+          type: 'css',
+          target: 'small-fonts',
+          description: `Increase ${smallText.length} small font sizes`
+        });
+      }
+      if (r.analysis.wordCount > 40) {
+        fixes.push({
+          slide: r.slide,
+          type: 'content',
+          target: 'word-count',
+          description: `Reduce words from ${r.analysis.wordCount} to 40`
+        });
+      }
+    }
+
+    if (r.scores.contrast < TARGET_SCORE) {
+      const contrastIssues = r.analysis.textIssues.filter(i => i.type.includes('Contrast'));
+      if (contrastIssues.length > 0) {
+        fixes.push({
+          slide: r.slide,
+          type: 'css',
+          target: 'contrast',
+          description: `Fix ${contrastIssues.length} contrast issues`
+        });
+      }
+    }
+
+    if (r.scores.graphics < TARGET_SCORE && r.analysis.imageCount === 0) {
+      fixes.push({
+        slide: r.slide,
+        type: 'content',
+        target: 'add-image',
+        description: 'Add image to text-heavy slide'
+      });
+    }
+  });
+
+  return fixes;
+}
+
+async function applyFixes(htmlPath, fixes) {
+  let html = fs.readFileSync(htmlPath, 'utf8');
+  let modified = false;
+
+  // Apply CSS fixes for small fonts and contrast
+  const cssFixesToApply = fixes.filter(f => f.type === 'css');
+
+  if (cssFixesToApply.some(f => f.target === 'small-fonts')) {
+    // Increase all small font sizes
+    const smallFontPatterns = [
+      { pattern: /font-size:\s*0\.7[0-9]*rem/g, replacement: 'font-size: 1.125rem' },
+      { pattern: /font-size:\s*0\.8[0-9]*rem/g, replacement: 'font-size: 1.125rem' },
+      { pattern: /font-size:\s*0\.9[0-9]*rem/g, replacement: 'font-size: 1.125rem' },
+      { pattern: /font-size:\s*1rem([^0-9])/g, replacement: 'font-size: 1.125rem$1' },
+      { pattern: /font-size:\s*1\.0rem/g, replacement: 'font-size: 1.125rem' },
+    ];
+
+    smallFontPatterns.forEach(({ pattern, replacement }) => {
+      if (pattern.test(html)) {
+        html = html.replace(pattern, replacement);
+        modified = true;
+      }
+    });
+  }
+
+  if (cssFixesToApply.some(f => f.target === 'contrast')) {
+    // Enhance text shadows and colors for contrast
+    if (!html.includes('text-shadow: 0 4px 20px')) {
+      html = html.replace(
+        /\.large-text\s*\{([^}]*)\}/,
+        '.large-text { $1 text-shadow: 0 4px 20px rgba(0,0,0,0.9) !important; }'
+      );
+      modified = true;
+    }
+
+    // Ensure body text is light colored
+    html = html.replace(
+      /color:\s*var\(--gray\)/g,
+      'color: #e0e0e0'
+    );
+    html = html.replace(
+      /color:\s*var\(--muted\)/g,
+      'color: #cccccc'
+    );
+    modified = true;
+  }
+
+  if (modified) {
+    fs.writeFileSync(htmlPath, html);
+    return true;
+  }
+  return false;
+}
+
+async function main(htmlPath) {
+  console.log('\\n══════════════════════════════════════════════════════════════');
+  console.log('  AUTOMATED PRESENTATION QUALITY ASSURANCE');
+  console.log('  Target: ALL dimensions 95+ | Maximum iterations: ' + MAX_ITERATIONS);
+  console.log('══════════════════════════════════════════════════════════════\\n');
+
+  let iteration = 0;
+  let allPassing = false;
+
+  while (iteration < MAX_ITERATIONS && !allPassing) {
+    iteration++;
+    console.log(`\\n  ─── ITERATION ${iteration} ───────────────────────────────────\\n`);
+
+    // Run analysis
+    console.log('  Analyzing presentation...');
+    const results = await runFullAnalysis(htmlPath);
+
+    // Print current scores
+    printScores(results.averages, results.slideResults);
+
+    // Check if all dimensions pass
+    const dimensions = ['layout', 'contrast', 'graphics', 'content', 'clarity', 'effectiveness', 'consistency'];
+    const failingDimensions = dimensions.filter(d => results.averages[d] < TARGET_SCORE);
+
+    if (failingDimensions.length === 0) {
+      allPassing = true;
+      console.log('  ✅ ALL DIMENSIONS AT 95+ - PRESENTATION READY!\\n');
+      break;
+    }
+
+    console.log(`  Failing dimensions: ${failingDimensions.join(', ')}\\n`);
+
+    // Identify and apply fixes
+    const fixes = identifyFixes(results);
+    if (fixes.length === 0) {
+      console.log('  ⚠️  No automatic fixes available. Manual intervention required.\\n');
+      console.log('  REQUIRED MANUAL FIXES:');
+      failingDimensions.forEach(dim => {
+        console.log(`    - ${dim}: Currently ${results.averages[dim]}/100, needs ${TARGET_SCORE}+`);
+      });
+      break;
+    }
+
+    console.log(`  Applying ${fixes.length} fixes...`);
+    fixes.forEach(f => console.log(`    - Slide ${f.slide}: ${f.description}`));
+
+    const applied = await applyFixes(htmlPath, fixes);
+    if (!applied) {
+      console.log('  ⚠️  Could not apply fixes automatically.\\n');
+      break;
+    }
+
+    console.log('  Fixes applied. Re-analyzing...\\n');
+  }
+
+  if (!allPassing && iteration >= MAX_ITERATIONS) {
+    console.log(`  ❌ MAX ITERATIONS (${MAX_ITERATIONS}) REACHED - Manual review required\\n`);
+  }
+
+  // Final report
+  const finalResults = await runFullAnalysis(htmlPath);
+  console.log('\\n  ═══════════════════════════════════════════════════');
+  console.log('  FINAL SCORES');
+  console.log('  ═══════════════════════════════════════════════════');
+  printScores(finalResults.averages, finalResults.slideResults);
+
+  // Save report
+  const reportPath = path.join(path.dirname(htmlPath), 'qa-final-report.json');
+  fs.writeFileSync(reportPath, JSON.stringify({
+    file: htmlPath,
+    timestamp: new Date().toISOString(),
+    iterations: iteration,
+    passed: allPassing,
+    finalScores: finalResults.averages,
+    slideDetails: finalResults.slideResults
+  }, null, 2));
+
+  console.log(`  Report saved: ${reportPath}\\n`);
+
+  process.exit(allPassing ? 0 : 1);
+}
+
+// Run
+const htmlFile = process.argv[2];
+if (!htmlFile) {
+  console.error('Usage: node auto-fix-presentation.cjs <html-file>');
+  process.exit(1);
+}
+
+main(htmlFile).catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/bin/cli.js

@@ -20,10 +20,10 @@ const args = process.argv.slice(2);
 
 // Help text
 const helpText = `
-Claude Presentation Master v6.0.0
+Claude Presentation Master v7.2.0
 Generate world-class presentations using expert methodologies
 
-100% FREE • Zero API Keys • Runs Locally
+100% FREE • Zero API Keys • Runs Locally • KB-Driven Quality
 
 USAGE:
   npx claude-presentation-master <command> [options]
@@ -35,20 +35,23 @@ COMMANDS:
   info                Show package information
 
 OPTIONS:
-  -o, --output <dir>  Output directory (default: ./output)
-  -m, --mode <mode>   Presentation mode: keynote or business (default: keynote)
-  -f, --format <fmt>  Output formats: html, pptx, or both (default: html)
-  --type <type>       Presentation type (auto-detected if omitted):
-                      ted_keynote, sales_pitch, consulting_deck,
-                      investment_banking, investor_pitch,
-                      technical_presentation, all_hands
-  -t, --theme <name>  Theme: default, consulting-classic, modern-tech, minimal
-  --title <title>     Presentation title (default: filename)
-  --author <name>     Author name
-  --threshold <num>   QA score threshold 0-100 (default: 95)
-  --skip-qa           Skip QA validation (NOT recommended)
-  -h, --help          Show this help message
-  -v, --version       Show version number
+  -o, --output <dir>      Output directory (default: ./output)
+  -m, --mode <mode>       Presentation mode: keynote or business (default: keynote)
+  -f, --format <fmt>      Output formats: html, pptx, or both (default: html)
+  --type <type>           Presentation type (auto-detected if omitted):
+                          ted_keynote, sales_pitch, consulting_deck,
+                          investment_banking, investor_pitch,
+                          technical_presentation, all_hands
+  -t, --theme <name>      Theme: default, consulting-classic, modern-tech, minimal
+  --title <title>         Presentation title (default: filename)
+  --author <name>         Author name
+  --min-score <num>       Minimum QA score 0-100 (default: 95)
+  --threshold <num>       Alias for --min-score
+  --max-iterations <num>  Max auto-fix iterations (default: 5)
+  --no-iterative          Disable iterative QA (single pass only)
+  --skip-qa               Skip QA validation (NOT recommended)
+  -h, --help              Show this help message
+  -v, --version           Show version number
 
 EXAMPLES:
   # Quick one-off: Generate keynote from markdown (npx - no install needed)
@@ -85,7 +88,7 @@ For more information: https://github.com/Stuinfla/claude-presentation-master
 `;
 
 // Version
-const version = '6.0.0';
+const version = '7.2.0';
 
 // Parse arguments
 function parseArgs(args) {
@@ -100,6 +103,8 @@ function parseArgs(args) {
     title: null,
     author: null,
     threshold: 95,
+    maxIterations: 5,
+    useIterativeQA: true,
     skipQA: false,
     help: false,
     version: false
@@ -153,9 +158,18 @@ function parseArgs(args) {
         break;
 
       case '--threshold':
+      case '--min-score':
         options.threshold = parseInt(args[++i], 10);
         break;
 
+      case '--max-iterations':
+        options.maxIterations = parseInt(args[++i], 10);
+        break;
+
+      case '--no-iterative':
+        options.useIterativeQA = false;
+        break;
+
       case '--skip-qa':
         options.skipQA = true;
         break;
@@ -221,15 +235,30 @@ Author: Stuart Kerr <stuart@isovision.ai>
 License: MIT
 Cost:   100% FREE - Zero API Keys Required
 
+NEW IN v7.0.0:
+  ★ 7-Dimension Quality Scoring (KB-driven)
+  ★ Iterative Auto-Fix Loop (generates → scores → fixes → repeats)
+  ★ Knowledge Base Integration (73K+ tokens of expert rules)
+  ★ Per-dimension breakdown: Layout, Contrast, Graphics, Content, Clarity, Effectiveness, Consistency
+
 Features:
   ✓ 7 Presentation Types with Expert Methodologies
   ✓ Two modes: Keynote (6-25 words) & Business (40-80 words)
   ✓ HTML (Reveal.js) + PowerPoint output
   ✓ Investment Banking Charts (Football Field, Waterfall, Comps)
   ✓ Professional Typography (Google Fonts)
-  ✓ Hallucination Detection (zero-tolerance fact checking)
-  ✓ Auto-Remediation (fixes issues until 95/100 threshold met)
-  ✓ Real visual QA with Playwright (optional)
+  ✓ KB-Driven Slide Generation (all decisions from knowledge base)
+  ✓ Auto-Remediation (fixes issues until threshold met)
+  ✓ 7-Dimension Scoring with Iteration Loop
+
+7-Dimension Scoring:
+  • Layout       (15%) - Whitespace, balance, structure
+  • Contrast     (15%) - WCAG compliance, readability
+  • Graphics     (10%) - Images, placement, relevance
+  • Content      (20%) - Word limits, bullets, structure
+  • Clarity      (15%) - Message focus, density
+  • Effectiveness(15%) - Expert methodology compliance
+  • Consistency  (10%) - Style uniformity, coherence
 
 Presentation Types:
   • ted_keynote            Nancy Duarte (Sparkline)
@@ -241,14 +270,16 @@ Presentation Types:
   • all_hands              Internal Comms Best Practices
 
 Expert Knowledge Base:
-  • 6,300+ lines of expert principles
+  • 73K+ tokens of comprehensive rules
   • 40+ presentation experts
   • SCQA, Sparkline, STAR Moment frameworks
+  • Technical presentation templates (ADR, Post-mortem, SDR)
   • Automated type detection and framework selection
 
 Usage:
   npx claude-presentation-master generate notes.md -m keynote
   cpm generate strategy.md --type consulting_deck -f pptx
+  cpm generate content.md --min-score 98 --max-iterations 10
 `);
     process.exit(0);
   }
@@ -369,6 +400,8 @@ async function runGenerate(inputPath, options, generate) {
     title,
     author: options.author,
     qaThreshold: options.threshold,
+    maxIterations: options.maxIterations,
+    useIterativeQA: options.useIterativeQA,
     skipQA: options.skipQA,
     images: localImages,           // Local images for backgrounds
     imageBasePath: inputDir        // Base path for resolving relative image paths
@@ -376,13 +409,15 @@ async function runGenerate(inputPath, options, generate) {
 
   console.log(`
 📋 Configuration:
-   Mode:      ${options.mode}
-   Type:      ${options.type || '(auto-detect)'}
-   Format:    ${options.format.join(', ')}
-   Theme:     ${options.theme}
-   Title:     ${title}
-   Threshold: ${options.threshold}/100
-   Skip QA:   ${options.skipQA ? 'Yes (NOT RECOMMENDED)' : 'No'}
+   Mode:         ${options.mode}
+   Type:         ${options.type || '(auto-detect)'}
+   Format:       ${options.format.join(', ')}
+   Theme:        ${options.theme}
+   Title:        ${title}
+   Min Score:    ${options.threshold}/100
+   Max Iter:     ${options.maxIterations}
+   Iterative QA: ${options.useIterativeQA ? 'Yes (7-Dimension)' : 'No (Single Pass)'}
+   Skip QA:      ${options.skipQA ? 'Yes (NOT RECOMMENDED)' : 'No'}
 `);
 
   try {
@@ -412,21 +447,49 @@ async function runGenerate(inputPath, options, generate) {
 
     // Show results
     const avgWords = result.metadata.avgWordsPerSlide?.toFixed(1) ?? 'N/A';
-    const estimatedDuration = Math.ceil((result.metadata.totalWords || 0) / 150);  // ~150 words per minute
+    const totalWords = result.metadata.wordCount || result.metadata.totalWords || 0;
+    const estimatedDuration = Math.ceil(totalWords / 150);  // ~150 words per minute
 
     console.log(`
 ╔════════════════════════════════════════════════════════╗
 ║                    QA RESULTS                          ║
 ╚════════════════════════════════════════════════════════╝
 
-📊 Score: ${result.score}/100 ${result.score >= options.threshold ? '✅ PASSED' : '❌ FAILED'}
+📊 Overall Score: ${result.score}/100 ${result.score >= options.threshold ? '✅ PASSED' : '❌ FAILED'}
+`);
 
+    // Show 7-dimension breakdown if available
+    if (result.qaResults.dimensions) {
+      const dims = result.qaResults.dimensions;
+      console.log('7-Dimension Breakdown:');
+      console.log('─────────────────────────────────────────────────────────');
+      const formatScore = (name, score) => {
+        const bar = '█'.repeat(Math.floor(score / 10)) + '░'.repeat(10 - Math.floor(score / 10));
+        const status = score >= 95 ? '✅' : score >= 80 ? '⚠️' : '❌';
+        return `${status} ${name.padEnd(14)} ${bar} ${score.toString().padStart(3)}/100`;
+      };
+      console.log(`   ${formatScore('Layout', dims.layout)}`);
+      console.log(`   ${formatScore('Contrast', dims.contrast)}`);
+      console.log(`   ${formatScore('Graphics', dims.graphics)}`);
+      console.log(`   ${formatScore('Content', dims.content)}`);
+      console.log(`   ${formatScore('Clarity', dims.clarity)}`);
+      console.log(`   ${formatScore('Effectiveness', dims.effectiveness)}`);
+      console.log(`   ${formatScore('Consistency', dims.consistency)}`);
+      console.log('');
+    }
+
+    // Show iteration info if available
+    if (result.metadata.qaIterations) {
+      console.log(`🔄 Iterations: ${result.metadata.qaIterations}/${result.metadata.qaMaxIterations}`);
+    }
+
+    console.log(`
 📈 Metadata:
    Slides:    ${result.metadata.slideCount}
-   Words:     ${result.metadata.totalWords || 'N/A'}
+   Words:     ${totalWords}
    Avg/Slide: ${avgWords}
    Duration:  ~${estimatedDuration} minutes
-   Type:      ${result.metadata.presentationType}
+   Type:      ${result.metadata.presentationType || 'auto-detected'}
 `);
 
     console.log('\n✨ Generation complete!');