claude-presentation-master 5.0.0 → 6.1.0

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,13 +254,41 @@ interface PresentationMetadata {
     /** Themes/frameworks used */
     frameworks: string[];
 }
-interface ContentAnalysis {
+interface ContentSection$1 {
+    /** Section header text */
+    header: string;
+    /** Header level (1-6) */
+    level: number;
+    /** Body content */
+    content: string;
+    /** Bullet points */
+    bullets: string[];
+    /** Metrics extracted from section */
+    metrics: Array<{
+        value: string;
+        label: string;
+        context?: string;
+    }>;
+}
+interface ContentAnalysis$1 {
+    /** Detected presentation type */
+    detectedType: PresentationType$1;
+    /** Main title */
+    title: string;
+    /** Content sections */
+    sections: ContentSection$1[];
     /** SCQA structure extracted */
     scqa: SCQAStructure;
     /** Sparkline narrative arc */
     sparkline: SparklineStructure;
     /** Key messages identified */
     keyMessages: string[];
+    /** Data points (metrics, percentages, etc.) */
+    dataPoints: Array<{
+        value: string;
+        label: string;
+        context?: string;
+    }>;
     /** Generated action titles */
     titles: string[];
     /** STAR moments identified */
@@ -337,6 +368,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 +563,121 @@ 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).
+     * Extract the main title from content
      */
-    private parseMarkdown;
+    private extractTitle;
     /**
-     * Parse JSON content.
+     * Detect presentation type from content signals
      */
-    private parseJSON;
+    private detectPresentationType;
     /**
-     * Parse YAML content.
+     * Extract sections from content (headers, bullets, content)
      */
-    private parseYAML;
+    private extractSections;
     /**
-     * Flatten object to text.
+     * Extract SCQA structure (Barbara Minto)
      */
-    private flattenObject;
-    /**
-     * Split text into paragraphs.
-     */
-    private splitIntoParagraphs;
-    /**
-     * Split text into sentences.
-     */
-    private splitIntoSentences;
+    private extractSCQA;
     /**
-     * Extract SCQA structure (Barbara Minto's Pyramid Principle).
+     * Extract STAR moments (Something They'll Always Remember)
+     * Per Nancy Duarte: These should be memorable, COMPLETE thoughts with impact
+     *
+     * CRITICAL REQUIREMENTS:
+     * - Must be complete sentences with subject + verb structure
+     * - Must have 5+ words minimum (no fragments!)
+     * - Must be 30+ characters
+     * - Must contain a verb
+     * - NOT fragments like "significant growth" or "cloud-first strategy"
+     * - NOT headers or topic labels
      */
-    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 - the actual insights from the content
+     * Per Carmine Gallo: Rule of Three - max 3 key messages
+     * Per Barbara Minto: Messages should be actionable conclusions, not topics
      */
     private extractKeyMessages;
     /**
-     * Generate action titles (McKinsey-style).
+     * Extract data points (metrics with values)
+     * IMPROVED: Smarter label extraction that understands markdown tables
      */
-    private generateActionTitles;
+    private extractDataPoints;
     /**
-     * Transform a statement into an action title.
+     * Extract a meaningful label from a line containing a metric
      */
-    private transformToActionTitle;
+    private extractLabelFromLine;
     /**
-     * Identify STAR moments (Something They'll Always Remember).
+     * Check if text contains any of the signals
      */
-    private identifyStarMoments;
+    private containsSignals;
     /**
-     * Estimate slide count based on content.
+     * Extract first meaningful sentence from text
+     * CRITICAL: Must strip headers, CTA text, and fragments
      */
-    private estimateSlideCount;
-    private containsSignals;
-    private extractRelevantSentence;
-    private truncateToSentence;
-    private truncateToWords;
-    private capitalizeFirst;
+    private extractFirstSentence;
 }
 
 /**
@@ -433,11 +691,43 @@ 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.
+     *
+     * ARCHITECTURE (per KB expert methodologies):
+     * 1. Title slide - always first
+     * 2. Agenda slide - business mode only with 3+ sections
+     * 3. SCQA slides - Situation, Complication (per Minto)
+     * 4. Content slides - from sections with bullets/content
+     * 5. Metrics slide - if data points exist
+     * 6. Solution slide - SCQA answer
+     * 7. STAR moments - only if high-quality (per Duarte)
+     * 8. CTA slide - if call to action exists
+     * 9. Thank you slide - always last
+     */
+    createSlides(analysis: ContentAnalysis$1, mode: PresentationMode$1): Promise<Slide[]>;
+    /**
+     * Create a slide from a section with bullets
+     */
+    private createSectionBulletSlide;
+    /**
+     * Create a slide from a section with body content
+     */
+    private createSectionContentSlide;
+    /**
+     * Extract first sentence from text
+     */
+    private extractFirstSentence;
+    /**
+     * Create a metrics slide from data points
      */
-    createSlides(analysis: ContentAnalysis, mode: PresentationMode): Promise<Slide[]>;
+    private createMetricsSlide;
     /**
      * Create a title slide.
      */
@@ -479,11 +769,13 @@ declare class SlideFactory {
      */
     private initializeTemplates;
     /**
-     * Clean text by removing all content markers.
+     * Clean text by removing all markdown and content markers.
+     * CRITICAL: Must strip all formatting to prevent garbage in slides
      */
     private cleanText;
     /**
-     * Truncate text to max length at word boundary.
+     * Truncate text to max length at sentence boundary when possible.
+     * CRITICAL: Never cut mid-number (99.5% should not become 99.)
      */
     private truncate;
     /**
@@ -495,7 +787,7 @@ declare class SlideFactory {
      */
     private extractBullets;
     /**
-     * Remove a statistic from text.
+     * Remove a statistic from text and clean thoroughly.
      */
     private removeStatistic;
 }
@@ -633,19 +925,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;
+    /**
+     * Initialize KnowledgeGateway
+     */
+    private initialize;
     /**
-     * Validate a presentation.
+     * Validate a presentation using KB-driven quality metrics
      */
     validate(presentation: string | Buffer, options?: {
         mode?: 'keynote' | 'business';
@@ -653,7 +953,7 @@ declare class QAEngine {
         threshold?: number;
     }): Promise<QAResults>;
     /**
-     * Calculate overall QA score.
+     * Calculate overall QA score using KB-driven weights
      */
     calculateScore(results: QAResults): number;
     /**
@@ -663,7 +963,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;
@@ -678,32 +981,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;
     /**
@@ -1026,111 +1344,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
  *
@@ -1198,7 +1411,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.
  */
@@ -1210,4 +1423,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 ContentSection$1 as ContentSection, 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 };