claude-presentation-master 4.4.1 → 6.0.0

package/bin/cli.js

@@ -20,7 +20,7 @@ const args = process.argv.slice(2);
 
 // Help text
 const helpText = `
-Claude Presentation Master v4.2.0
+Claude Presentation Master v6.0.0
 Generate world-class presentations using expert methodologies
 
 100% FREE • Zero API Keys • Runs Locally
@@ -85,7 +85,7 @@ For more information: https://github.com/Stuinfla/claude-presentation-master
 `;
 
 // Version
-const version = '4.2.0';
+const version = '6.0.0';
 
 // Parse arguments
 function parseArgs(args) {

package/dist/index.d.mts

@@ -2,16 +2,19 @@
  * Claude Presentation Master - Type Definitions
  * @module types
  */
-type PresentationMode = 'keynote' | 'business';
+type PresentationMode$1 = 'keynote' | 'business';
 type OutputFormat = 'html' | 'pptx';
 type ThemeName = 'default' | 'light-corporate' | 'modern-tech' | 'minimal' | 'warm' | 'creative';
+type PresentationType$1 = 'ted_keynote' | 'sales_pitch' | 'consulting_deck' | 'investment_banking' | 'investor_pitch' | 'technical_presentation' | 'all_hands';
 interface PresentationConfig {
     /** Input content (Markdown, JSON, YAML, or plain text) */
     content: string;
     /** Content format */
     contentType: 'markdown' | 'json' | 'yaml' | 'text';
     /** Presentation mode: keynote (6-25 words/slide) or business (40-80 words/slide) */
-    mode: PresentationMode;
+    mode: PresentationMode$1;
+    /** Specific presentation type (optional, inferred from mode if not provided) */
+    presentationType?: PresentationType$1;
     /** Output formats to generate */
     format: OutputFormat[];
     /** Visual theme */
@@ -239,7 +242,7 @@ interface PresentationMetadata {
     /** Generation timestamp */
     generatedAt: string;
     /** Presentation mode */
-    mode: PresentationMode;
+    mode: PresentationMode$1;
     /** Total slide count */
     slideCount: number;
     /** Total word count */
@@ -251,7 +254,7 @@ interface PresentationMetadata {
     /** Themes/frameworks used */
     frameworks: string[];
 }
-interface ContentAnalysis {
+interface ContentAnalysis$1 {
     /** SCQA structure extracted */
     scqa: SCQAStructure;
     /** Sparkline narrative arc */
@@ -337,6 +340,194 @@ declare class PresentationEngine {
     private detectFrameworks;
 }
 
+/**
+ * KnowledgeGateway - Central access point to the presentation knowledge base
+ *
+ * This gateway provides methods to query the knowledge base for:
+ * - Presentation mode selection (keynote vs business)
+ * - Expert methodology recommendations
+ * - Word limits and constraints
+ * - Slide templates
+ * - Quality metrics
+ * - Color palettes
+ * - Anti-patterns to avoid
+ *
+ * The entire presentation engine should query this gateway for EVERY decision.
+ */
+interface PresentationMode {
+    name: string;
+    use_for: string[];
+    characteristics: {
+        words_per_slide: string;
+        whitespace: string;
+        visuals: string;
+        structure: string;
+        slides_per_idea?: number;
+        action_titles?: string;
+    };
+    experts: string[];
+}
+interface SlideTemplate {
+    name: string;
+    purpose: string;
+    elements?: string[];
+    components?: string[];
+    word_limit: number;
+}
+interface QualityMetrics {
+    keynote_mode: Record<string, {
+        threshold?: number;
+        required?: boolean;
+        description: string;
+    }>;
+    business_mode: Record<string, {
+        threshold?: number;
+        required?: boolean;
+        description: string;
+    }>;
+    universal: Record<string, {
+        threshold?: number;
+        required?: boolean;
+        max_items_per_chunk?: number;
+        description: string;
+    }>;
+}
+interface ColorPalette {
+    name: string;
+    background: string;
+    primary: string;
+    secondary: string;
+    accent: string;
+    text: string;
+    use_case: string;
+    contrast_ratio: string;
+}
+type PresentationType = 'ted_keynote' | 'sales_pitch' | 'consulting_deck' | 'investment_banking' | 'investor_pitch' | 'technical_presentation' | 'all_hands';
+declare class KnowledgeGateway {
+    private kb;
+    private loaded;
+    constructor();
+    /**
+     * Load the knowledge base from YAML file
+     */
+    load(): Promise<void>;
+    /**
+     * Get presentation mode configuration (keynote or business)
+     */
+    getMode(mode: 'keynote' | 'business'): PresentationMode;
+    /**
+     * Determine which mode is best for a given presentation type
+     */
+    getModeForType(type: PresentationType): 'keynote' | 'business';
+    /**
+     * Get word limits for the specified mode
+     */
+    getWordLimits(mode: 'keynote' | 'business'): {
+        min: number;
+        max: number;
+        ideal: number;
+    };
+    /**
+     * Get bullet point limits
+     */
+    getBulletLimits(mode: 'keynote' | 'business'): {
+        maxBullets: number;
+        maxWordsPerBullet: number;
+    };
+    /**
+     * Get whitespace percentage requirement
+     */
+    getWhitespaceRequirement(mode: 'keynote' | 'business'): number;
+    /**
+     * Get slide templates for the specified mode
+     */
+    getSlideTemplates(mode: 'keynote' | 'business'): SlideTemplate[];
+    /**
+     * Get a specific slide template by name
+     */
+    getSlideTemplate(mode: 'keynote' | 'business', templateName: string): SlideTemplate | undefined;
+    /**
+     * Get quality metrics for grading
+     */
+    getQualityMetrics(): QualityMetrics;
+    /**
+     * Get anti-patterns to avoid
+     */
+    getAntiPatterns(mode: 'keynote' | 'business'): string[];
+    /**
+     * Get data visualization anti-patterns
+     */
+    getDataVizAntiPatterns(): string[];
+    /**
+     * Get accessibility anti-patterns
+     */
+    getAccessibilityAntiPatterns(): string[];
+    /**
+     * Get color palette by name
+     */
+    getColorPalette(name: string): ColorPalette | undefined;
+    /**
+     * Get recommended color palette for presentation type
+     */
+    getRecommendedPalette(type: PresentationType): ColorPalette;
+    /**
+     * Get typography guidelines for mode
+     */
+    getTypography(mode: 'keynote' | 'business'): Record<string, string>;
+    /**
+     * Get story framework by name
+     */
+    getStoryFramework(name: 'sparkline' | 'scqa' | 'pyramid' | 'scr'): any;
+    /**
+     * Get expert principles by name
+     */
+    getExpertPrinciples(expertName: string): any;
+    /**
+     * Get Duarte's glance test requirements
+     */
+    getDuarteGlanceTest(): {
+        wordLimit: number;
+        timeSeconds: number;
+    };
+    /**
+     * Get Miller's Law constraints
+     */
+    getMillersLaw(): {
+        minItems: number;
+        maxItems: number;
+    };
+    /**
+     * Get cognitive load constraints
+     */
+    getCognitiveLoadLimits(): {
+        maxItemsPerChunk: number;
+    };
+    /**
+     * Get chart selection guidance
+     */
+    getChartGuidance(purpose: 'comparison' | 'composition' | 'distribution' | 'relationship'): any;
+    /**
+     * Get charts to avoid
+     */
+    getChartsToAvoid(): string[];
+    /**
+     * Get investment banking pitch book structure
+     */
+    getIBPitchBookStructure(type: 'ma_sell_side' | 'ma_buy_side' | 'ipo_pitchbook'): any;
+    /**
+     * Check if knowledge base is loaded
+     */
+    private ensureLoaded;
+    /**
+     * Get the full knowledge base (for advanced queries)
+     */
+    getRawKB(): any;
+}
+/**
+ * Get or create the KnowledgeGateway instance
+ */
+declare function getKnowledgeGateway(): Promise<KnowledgeGateway>;
+
 /**
  * Content Analyzer - Extracts Structure from Raw Content
  *
@@ -344,82 +535,114 @@ declare class PresentationEngine {
  * - SCQA structure (Barbara Minto)
  * - Sparkline narrative arc (Nancy Duarte)
  * - Key messages (Rule of Three)
- * - STAR moments
- * - Action titles
+ * - Sections with headers, bullets, metrics
+ * - Presentation type detection
+ *
+ * Fully integrated with KnowledgeGateway for expert principles.
  */
 
+interface ContentSection {
+    header: string;
+    level: number;
+    content: string;
+    bullets: string[];
+    metrics: Array<{
+        value: string;
+        label: string;
+        context?: string;
+    }>;
+}
+interface ContentAnalysis {
+    detectedType: PresentationType;
+    title: string;
+    sections: ContentSection[];
+    keyMessages: string[];
+    dataPoints: Array<{
+        value: string;
+        label: string;
+        context?: string;
+    }>;
+    scqa: {
+        situation: string;
+        complication: string;
+        question: string;
+        answer: string;
+    };
+    sparkline: {
+        whatIs: string[];
+        whatCouldBe: string[];
+        callToAdventure: string;
+    };
+    titles: string[];
+    starMoments: string[];
+    estimatedSlideCount: number;
+}
 declare class ContentAnalyzer {
+    private kb;
     private readonly situationSignals;
     private readonly complicationSignals;
-    private readonly questionSignals;
     private readonly answerSignals;
-    private readonly whatIsSignals;
-    private readonly whatCouldBeSignals;
+    private readonly ctaSignals;
+    private readonly typeSignals;
+    initialize(): Promise<void>;
     /**
      * Analyze content and extract structural elements.
      */
     analyze(content: string, contentType: string): Promise<ContentAnalysis>;
     /**
-     * Parse content based on its type.
+     * Parse content based on type
      */
     private parseContent;
     /**
-     * Parse markdown content to plain text (preserving structure hints).
-     */
-    private parseMarkdown;
-    /**
-     * Parse JSON content.
-     */
-    private parseJSON;
-    /**
-     * Parse YAML content.
+     * Extract the main title from content
      */
-    private parseYAML;
+    private extractTitle;
     /**
-     * Flatten object to text.
+     * Detect presentation type from content signals
      */
-    private flattenObject;
+    private detectPresentationType;
     /**
-     * Split text into paragraphs.
+     * Extract sections from content (headers, bullets, content)
      */
-    private splitIntoParagraphs;
+    private extractSections;
     /**
-     * Split text into sentences.
+     * Extract SCQA structure (Barbara Minto)
      */
-    private splitIntoSentences;
+    private extractSCQA;
     /**
-     * Extract SCQA structure (Barbara Minto's Pyramid Principle).
+     * Extract STAR moments (Something They'll Always Remember)
+     * Per Nancy Duarte - these are emotional peaks in the presentation
      */
-    private extractSCQA;
+    private extractStarMoments;
     /**
-     * Extract Sparkline structure (Nancy Duarte).
+     * Extract Sparkline elements (Nancy Duarte)
      */
     private extractSparkline;
     /**
-     * Extract key messages (max 3 - Rule of Three).
+     * Extract key messages (max 3 - Rule of Three)
      */
     private extractKeyMessages;
     /**
-     * Generate action titles (McKinsey-style).
+     * Extract data points (metrics with values)
      */
-    private generateActionTitles;
+    private extractDataPoints;
     /**
-     * Transform a statement into an action title.
+     * Get context around a match
      */
-    private transformToActionTitle;
+    private getContextAroundMatch;
     /**
-     * Identify STAR moments (Something They'll Always Remember).
+     * Extract a label from surrounding context
+     * Fixes the "Century Interactive |" garbage issue by stripping table syntax
      */
-    private identifyStarMoments;
+    private extractLabelFromContext;
     /**
-     * Estimate slide count based on content.
+     * Check if text contains any of the signals
      */
-    private estimateSlideCount;
     private containsSignals;
-    private extractRelevantSentence;
-    private truncateToSentence;
-    private truncateToWords;
-    private capitalizeFirst;
+    /**
+     * Extract first meaningful sentence from text
+     */
+    private extractFirstSentence;
 }
 
 /**
@@ -433,11 +656,16 @@ declare class ContentAnalyzer {
 
 declare class SlideFactory {
     private readonly templates;
+    private usedContent;
     constructor();
+    /**
+     * Check if content has already been used (deduplication)
+     */
+    private isContentUsed;
     /**
      * Create slides from analyzed content.
      */
-    createSlides(analysis: ContentAnalysis, mode: PresentationMode): Promise<Slide[]>;
+    createSlides(analysis: ContentAnalysis$1, mode: PresentationMode$1): Promise<Slide[]>;
     /**
      * Create a title slide.
      */
@@ -478,6 +706,10 @@ declare class SlideFactory {
      * Initialize slide templates with constraints.
      */
     private initializeTemplates;
+    /**
+     * Clean text by removing all content markers.
+     */
+    private cleanText;
     /**
      * Truncate text to max length at word boundary.
      */
@@ -629,19 +861,27 @@ declare class ScoreCalculator {
 }
 
 /**
- * QA Engine - Real Visual Quality Validation
+ * QA Engine - Real Visual Quality Validation with KB-Driven Metrics
  *
+ * Uses KnowledgeGateway for ALL quality thresholds and expert principles.
  * Unlike fake validation systems, this engine ACTUALLY tests:
  * - Visual quality using Playwright screenshots + Canvas API
  * - Layout balance and whitespace distribution
  * - WCAG contrast compliance
- * - Expert methodology adherence
+ * - Expert methodology adherence (Duarte, Reynolds, Gallo, Anderson)
+ *
+ * CRITICAL: All thresholds come from the knowledge base
  */
 
 declare class QAEngine {
     private browser;
+    private kb;
     /**
-     * Validate a presentation.
+     * Initialize KnowledgeGateway
+     */
+    private initialize;
+    /**
+     * Validate a presentation using KB-driven quality metrics
      */
     validate(presentation: string | Buffer, options?: {
         mode?: 'keynote' | 'business';
@@ -649,7 +889,7 @@ declare class QAEngine {
         threshold?: number;
     }): Promise<QAResults>;
     /**
-     * Calculate overall QA score.
+     * Calculate overall QA score using KB-driven weights
      */
     calculateScore(results: QAResults): number;
     /**
@@ -659,7 +899,10 @@ declare class QAEngine {
     private runVisualTests;
     private runContentTests;
     private runExpertTests;
-    private createExpertResult;
+    private validateDuartePrinciples;
+    private validateReynoldsPrinciples;
+    private validateGalloPrinciples;
+    private validateAndersonPrinciples;
     private runAccessibilityTests;
     private calculateVisualScore;
     private calculateContentScore;
@@ -674,32 +917,47 @@ declare class QAEngine {
  * Reveal.js Generator - HTML Presentation Output
  *
  * Generates complete Reveal.js presentations with:
+ * - KB-driven color palettes and typography
  * - Responsive layouts
  * - Animations
  * - Speaker notes
- * - Custom themes
  * - Chart.js integration
  * - Mermaid diagrams
+ *
+ * CRITICAL: All design decisions come from KnowledgeGateway
  */
 
 declare class RevealJsGenerator {
     private templateEngine;
+    private kb;
     private defaultRevealConfig;
     constructor();
+    /**
+     * Initialize KnowledgeGateway
+     */
+    private initialize;
     /**
      * Generate complete Reveal.js HTML presentation.
      */
     generate(slides: Slide[], config: PresentationConfig): Promise<string>;
+    /**
+     * Detect presentation type from config
+     */
+    private detectPresentationType;
     /**
      * Build the complete HTML document.
      */
     private buildDocument;
     /**
-     * Get base styles for slides.
+     * Get base styles for slides - KB-DRIVEN
      */
     private getBaseStyles;
     /**
-     * Get theme-specific styles.
+     * Lighten a hex color
+     */
+    private lightenColor;
+    /**
+     * Get theme-specific styles - KB-DRIVEN
      */
     private getThemeStyles;
     /**
@@ -1022,111 +1280,6 @@ declare class CompositeChartProvider implements ChartProvider {
  */
 declare function createDefaultChartProvider(): CompositeChartProvider;
 
-/**
- * Knowledge Base - RuVector Expert Principles Loader
- *
- * Loads and provides access to the 6,300+ line expert knowledge base
- * containing methodologies from 40+ presentation experts.
- *
- * This runs WITHOUT any API - it's static data bundled with the package.
- */
-interface ExpertPrinciple {
-    name: string;
-    description: string;
-    validation?: string[];
-    examples?: string[];
-}
-interface ExpertMethodology {
-    name: string;
-    principles: ExpertPrinciple[];
-    slideTypes?: string[];
-    wordLimits?: {
-        min?: number;
-        max?: number;
-    };
-}
-interface AutomatedQA {
-    scoringRubric: {
-        totalPoints: number;
-        passingThreshold: number;
-        categories: Record<string, {
-            weight: number;
-            checks: Record<string, unknown>;
-        }>;
-    };
-}
-declare class KnowledgeBase {
-    private data;
-    private loaded;
-    /**
-     * Load the knowledge base from the bundled YAML file.
-     */
-    load(): Promise<void>;
-    /**
-     * Get expert methodology by name.
-     */
-    getExpert(name: string): ExpertMethodology | undefined;
-    /**
-     * Get all expert names.
-     */
-    getExpertNames(): string[];
-    /**
-     * Get framework recommendation for audience.
-     */
-    getFrameworkForAudience(audience: string): {
-        primaryFramework: string;
-        secondaryFramework?: string;
-        slideTypes: string[];
-    } | undefined;
-    /**
-     * Get framework recommendation for goal.
-     */
-    getFrameworkForGoal(goal: string): {
-        primaryFramework: string;
-        secondaryFramework?: string;
-        slideTypes: string[];
-    } | undefined;
-    /**
-     * Get QA scoring rubric.
-     */
-    getScoringRubric(): AutomatedQA['scoringRubric'] | undefined;
-    /**
-     * Get mode configuration (keynote or business).
-     */
-    getModeConfig(mode: 'keynote' | 'business'): unknown;
-    /**
-     * Get slide type configuration.
-     */
-    getSlideType(type: string): unknown;
-    /**
-     * Get the knowledge base version.
-     */
-    getVersion(): string;
-    /**
-     * Validate a slide against expert principles.
-     */
-    validateAgainstExpert(expertName: string, slideData: {
-        wordCount: number;
-        hasActionTitle: boolean;
-        bulletCount: number;
-    }): {
-        passed: boolean;
-        violations: string[];
-    };
-    /**
-     * Ensure knowledge base is loaded.
-     */
-    private ensureLoaded;
-    /**
-     * Get default data if YAML can't be loaded.
-     */
-    private getDefaultData;
-}
-/**
- * Get the knowledge base singleton.
- */
-declare function getKnowledgeBase(): KnowledgeBase;
-
 /**
  * Claude Presentation Master
  *
@@ -1194,7 +1347,7 @@ declare function validate(presentation: string | Buffer, options?: {
 /**
  * Get the version of the package.
  */
-declare const VERSION = "1.0.0";
+declare const VERSION = "6.0.0";
 /**
  * Default export for convenience.
  */
@@ -1206,4 +1359,4 @@ declare const _default: {
     VERSION: string;
 };
 
-export { type AccessibilityResults, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContrastIssue, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type GlanceTestResult, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, KnowledgeBase, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode, type PresentationResult, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type SignalNoiseResult, type Slide, type SlideContentScore, type SlideData, SlideFactory, type SlideType, type SlideVisualScore, type SparklineStructure, TemplateEngine, TemplateNotFoundError, type ThemeName, UnsplashImageProvider, VERSION, ValidationError, type VisualQAResults, createDefaultChartProvider, createDefaultImageProvider, _default as default, generate, getKnowledgeBase, validate };
+export { type AccessibilityResults, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, type ColorPalette, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis$1 as ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContrastIssue, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type GlanceTestResult, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, KnowledgeGateway, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode$1 as PresentationMode, type PresentationResult, type PresentationType, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type SignalNoiseResult, type Slide, type SlideContentScore, type SlideData, SlideFactory, type SlideTemplate, type SlideType, type SlideVisualScore, type SparklineStructure, TemplateEngine, TemplateNotFoundError, type ThemeName, UnsplashImageProvider, VERSION, ValidationError, type VisualQAResults, createDefaultChartProvider, createDefaultImageProvider, _default as default, generate, getKnowledgeGateway, validate };