@mytechtoday/augment-extensions 2.3.7 → 2.5.0

package/cli/dist/commands/generate-shot-list/generator/index.js

@@ -11,6 +11,7 @@ const validator_1 = require("./validator");
 const scene_segmenter_1 = require("./scene-segmenter");
 const context_builder_1 = require("./context-builder");
 const metadata_extractor_1 = require("./metadata-extractor");
+const ai_blocking_extractor_1 = require("./ai-blocking-extractor");
 /**
  * Default generator implementation
  */
@@ -18,27 +19,37 @@ class ShotListGenerator {
     constructor(styleGuidelines) {
         this.validator = (0, validator_1.createValidator)();
         this.styleGuidelines = null;
+        this.characterBlockingCache = new Map();
+        // Store style guidelines first
+        this.styleGuidelines = styleGuidelines || null;
         // Initialize modules with default configurations
         this.segmenter = new scene_segmenter_1.SceneSegmenter({
             maxShotLength: 30, // 30 seconds max
             targetShotLength: 15, // 15 seconds target
             minShotLength: 5 // 5 seconds minimum
         });
+        // Pass style guidelines to ContextBuilder so it can filter appropriately
         this.contextBuilder = new context_builder_1.ContextBuilder({
             includeAtmosphere: true,
             includeWeather: true,
-            trackCharacterEmotions: true
+            trackCharacterEmotions: true,
+            styleGuidelines: this.styleGuidelines
         });
         this.metadataExtractor = new metadata_extractor_1.MetadataExtractor({
             extractTechnicalNotes: true,
             inferFromContext: true
         });
-        this.styleGuidelines = styleGuidelines || null;
+        this.blockingExtractor = new ai_blocking_extractor_1.AIBlockingExtractor(undefined, this.styleGuidelines);
     }
     /**
      * Generate shot list from parsed screenplay
      */
-    generate(scenes, config) {
+    async generate(scenes, config) {
+        // CRITICAL: Reset all state at the start of each screenplay generation
+        // This prevents Character Bible contamination between different screenplays
+        this.contextBuilder.reset();
+        this.characterBlockingCache.clear();
+        this.blockingExtractor.clearCache(); // Clear character description cache
         const shots = [];
         let shotNumber = 1;
         const warnings = [];
@@ -46,7 +57,7 @@ class ShotListGenerator {
         for (const scene of scenes) {
             // TODO: Implement scene segmentation (bd-shot-list-3.2)
             // For now, create one shot per scene as placeholder
-            const sceneShots = this.segmentScene(scene, shotNumber, config);
+            const sceneShots = await this.segmentScene(scene, shotNumber, config);
             shots.push(...sceneShots);
             shotNumber += sceneShots.length;
         }
@@ -96,7 +107,7 @@ class ShotListGenerator {
      * Implemented: bd-shot-list-3.2
      * Enhanced: bd-2b68 (Requirement 2: Intelligent Shot Splitting)
      */
-    segmentScene(scene, startShotNumber, config) {
+    async segmentScene(scene, startShotNumber, config) {
         // Build scene-level context once
         const sceneContext = this.contextBuilder.buildSceneContext(scene);
         // Segment scene into shots
@@ -108,20 +119,30 @@ class ShotListGenerator {
             const segment = segments[i];
             const isFirstShot = i === 0;
             // Build character states for this segment
-            const characters = this.contextBuilder.buildCharacterStates(segment.elements, sceneContext);
+            const characters = await this.contextBuilder.buildCharacterStates(segment.elements, sceneContext);
             // Extract metadata for this segment
             const metadata = this.metadataExtractor.extract(segment.elements, isFirstShot);
             // Apply style guidelines if available
             if (this.styleGuidelines) {
                 this.applyStyleToMetadata(metadata, this.styleGuidelines);
             }
+            // Extract blocking using AI
+            const blockingData = await this.extractBlockingWithAI(segment.elements, characters);
+            // Apply AI-generated character descriptions to character states
+            this.applyCharacterDescriptions(characters, blockingData.characterDescriptions);
             // Build structured description components
             const set = this.buildSetDescription(sceneContext);
-            const description = this.buildVisualDescription(sceneContext);
-            const actions = this.buildActions(segment.elements);
+            const description = blockingData.setDescription || this.buildVisualDescription(sceneContext);
+            const actions = blockingData.characterActions.length > 0
+                ? blockingData.characterActions.join('. ')
+                : 'No specific actions in this shot';
             const dialogue = this.extractDialogue(segment.elements);
-            const blocking = this.buildBlocking(characters);
-            const sfx = this.buildSFX(segment.elements);
+            const blocking = this.buildBlockingFromAI(blockingData.characterPositions, characters);
+            const sfx = config.muteSfx
+                ? 'No sound effects specified'
+                : (blockingData.soundEffects.length > 0
+                    ? blockingData.soundEffects.join('. ')
+                    : 'No sound effects specified');
             const techDetails = this.buildTechDetails(metadata);
             // Calculate total character count from all components
             const totalCharacterCount = set.length + description.length + actions.length +
@@ -129,7 +150,7 @@ class ShotListGenerator {
             // Check if shot exceeds max duration (Requirement 2)
             if (segment.estimatedDuration > config.maxShotLength) {
                 // Split into sub-shots
-                const subShots = this.splitIntoSubShots(segment, currentShotNumber, scene, sceneContext, config);
+                const subShots = await this.splitIntoSubShots(segment, currentShotNumber, scene, sceneContext, config);
                 shots.push(...subShots);
                 currentShotNumber += subShots.length;
             }
@@ -163,7 +184,7 @@ class ShotListGenerator {
      * Requirement 2: Intelligent Shot Splitting for Long Durations
      * Recursively splits sub-shots that still exceed maxShotLength
      */
-    splitIntoSubShots(segment, baseShotNumber, scene, sceneContext, config) {
+    async splitIntoSubShots(segment, baseShotNumber, scene, sceneContext, config) {
         const subShots = [];
         const elements = segment.elements;
         const targetDuration = config.maxShotLength;
@@ -180,20 +201,30 @@ class ShotListGenerator {
                 ? `${baseShotNumber}.${i + 1}` // Nested: "3a.1", "3a.2" or "3a.1.1", "3a.1.2"
                 : `${baseShotNumber}${String.fromCharCode(97 + i)}`; // First level: "3a", "3b"
             // Build character states for this sub-shot
-            const characters = this.contextBuilder.buildCharacterStates(subShotElements, sceneContext);
+            const characters = await this.contextBuilder.buildCharacterStates(subShotElements, sceneContext);
             // Extract metadata for this sub-shot
             const metadata = this.metadataExtractor.extract(subShotElements, i === 0);
             // Apply style guidelines if available
             if (this.styleGuidelines) {
                 this.applyStyleToMetadata(metadata, this.styleGuidelines);
             }
+            // Extract blocking using AI
+            const blockingData = await this.extractBlockingWithAI(subShotElements, characters);
+            // Apply AI-generated character descriptions to character states
+            this.applyCharacterDescriptions(characters, blockingData.characterDescriptions);
             // Build structured description components
             const set = this.buildSetDescription(sceneContext);
-            const description = this.buildVisualDescription(sceneContext);
-            const actions = this.buildActions(subShotElements);
+            const description = blockingData.setDescription || this.buildVisualDescription(sceneContext);
+            const actions = blockingData.characterActions.length > 0
+                ? blockingData.characterActions.join('. ')
+                : 'No specific actions in this shot';
             const dialogue = this.extractDialogue(subShotElements);
-            const blocking = this.buildBlocking(characters);
-            const sfx = this.buildSFX(subShotElements);
+            const blocking = this.buildBlockingFromAI(blockingData.characterPositions, characters);
+            const sfx = config.muteSfx
+                ? 'No sound effects specified'
+                : (blockingData.soundEffects.length > 0
+                    ? blockingData.soundEffects.join('. ')
+                    : 'No sound effects specified');
             const techDetails = this.buildTechDetails(metadata);
             // Calculate total character count from all components
             const totalCharacterCount = set.length + description.length + actions.length +
@@ -211,7 +242,7 @@ class ShotListGenerator {
                         breakReason: 'duration'
                     };
                     // Recursively split this sub-shot
-                    const nestedSubShots = this.splitIntoSubShots(nestedSegment, subShotNumber, scene, sceneContext, config);
+                    const nestedSubShots = await this.splitIntoSubShots(nestedSegment, subShotNumber, scene, sceneContext, config);
                     subShots.push(...nestedSubShots);
                 }
                 // If we have a single dialogue element, split the dialogue text
@@ -225,7 +256,7 @@ class ShotListGenerator {
                         breakReason: 'duration'
                     };
                     // Recursively split the dialogue-based segment
-                    const dialogueSubShots = this.splitIntoSubShots(dialogueSegment, subShotNumber, scene, sceneContext, config);
+                    const dialogueSubShots = await this.splitIntoSubShots(dialogueSegment, subShotNumber, scene, sceneContext, config);
                     subShots.push(...dialogueSubShots);
                 }
                 // Single non-dialogue element that can't be split further
@@ -412,21 +443,78 @@ class ShotListGenerator {
     }
     /**
      * Build character actions from scene elements
+     * Includes both explicit actions and inferred actions from dialogue
      */
     buildActions(elements) {
+        const actionList = [];
+        // Extract explicit action descriptions
+        // Include ALL actions (character entrances, movements, and general actions)
+        // Only filter out pure sound effects
         const actionElements = elements.filter(el => el.type === 'action');
-        if (actionElements.length === 0) {
+        const explicitActions = actionElements
+            .map(el => el.text)
+            .filter(text => {
+            // Keep the action if it's NOT a pure sound effect
+            // Character entrances should always be included
+            return !this.isSoundEffect(text) || this.isCharacterEntrance(text);
+        });
+        actionList.push(...explicitActions);
+        // Infer actions from dialogue (e.g., spell-casting, shouting, etc.)
+        const dialogueElements = elements.filter((el) => el.type === 'dialogue');
+        for (const dialogueEl of dialogueElements) {
+            const inferredAction = this.inferActionFromDialogue(dialogueEl);
+            if (inferredAction) {
+                actionList.push(inferredAction);
+            }
+        }
+        if (actionList.length === 0) {
             return 'No specific actions in this shot';
         }
-        // Extract action descriptions, filtering out sound effects
-        const actions = actionElements
-            .map(el => el.text)
-            .filter(text => !this.isSoundEffect(text))
-            .join('. ');
-        return actions || 'No specific actions in this shot';
+        return actionList.join('. ');
+    }
+    /**
+     * Infer character actions from dialogue content
+     * Examples:
+     * - Spell incantations -> "waves staff and casts spell"
+     * - Shouting -> "shouts"
+     * - Whispering -> "whispers"
+     */
+    inferActionFromDialogue(dialogueEl) {
+        const characterName = dialogueEl.dialogue.character.name;
+        const speech = dialogueEl.dialogue.speech;
+        const parenthetical = dialogueEl.dialogue.parenthetical?.toLowerCase() || '';
+        // Detect spell incantations - ONLY specific magical phrases
+        // Removed overly broad Latin-like pattern that matched treaty names
+        const spellPatterns = [
+            /\b(Expecto|Lumos|Accio|Wingardium|Expelliarmus|Avada)/i, // Harry Potter spells
+            /\b(Abracadabra|Alakazam|Hocus Pocus|Presto)/i, // Classic magic words
+        ];
+        const isSpell = spellPatterns.some(pattern => pattern.test(speech));
+        if (isSpell) {
+            // Check if character has a staff/wand in their props
+            // For now, assume wizards have staffs/wands
+            return `${characterName} waves staff and casts spell`;
+        }
+        // Detect shouting (ALL CAPS or exclamation marks)
+        if (speech === speech.toUpperCase() && speech.length > 10) {
+            return `${characterName} shouts`;
+        }
+        // Detect whispering from parenthetical
+        if (parenthetical.includes('whisper')) {
+            return `${characterName} whispers`;
+        }
+        // Detect other emotional delivery
+        if (parenthetical.includes('angry') || parenthetical.includes('furious')) {
+            return `${characterName} speaks angrily`;
+        }
+        if (parenthetical.includes('sad') || parenthetical.includes('crying')) {
+            return `${characterName} speaks sadly`;
+        }
+        return null;
     }
     /**
      * Build character blocking (positions and movements)
+     * DEPRECATED: Use buildBlockingFromAI() instead
      */
     buildBlocking(characters) {
         if (characters.length === 0) {
@@ -448,19 +536,135 @@ class ShotListGenerator {
             ? blockingParts.join('. ')
             : 'Characters maintain their positions';
     }
+    /**
+     * Extract blocking using AI-powered spatial inference
+     */
+    async extractBlockingWithAI(elements, characters) {
+        // Extract action lines
+        const actionLines = elements
+            .filter(el => el.type === 'action')
+            .map(el => el.text);
+        if (actionLines.length === 0) {
+            return {
+                characterPositions: [],
+                characterDescriptions: [],
+                setDescription: '',
+                characterActions: [],
+                soundEffects: []
+            };
+        }
+        // Get character names
+        const characterNames = characters.map(c => c.name);
+        // Call AI blocking extractor
+        console.log(`Extracting blocking with AI for ${characterNames.length} characters...`);
+        const result = await this.blockingExtractor.extractBlocking(actionLines, characterNames, this.characterBlockingCache);
+        // Update cache with new positions
+        for (const pos of result.characterPositions) {
+            this.characterBlockingCache.set(pos.character, pos);
+        }
+        return result;
+    }
+    /**
+     * Build blocking description from AI-extracted positions
+     */
+    buildBlockingFromAI(positions, characters) {
+        if (positions.length === 0) {
+            // Fallback to cached positions
+            const cachedBlocking = [];
+            for (const char of characters) {
+                const cached = this.characterBlockingCache.get(char.name);
+                if (cached) {
+                    cachedBlocking.push(this.formatBlockingPosition(cached));
+                }
+            }
+            return cachedBlocking.length > 0
+                ? cachedBlocking.join('\n')
+                : 'Characters maintain their positions';
+        }
+        return positions.map(pos => this.formatBlockingPosition(pos)).join('\n');
+    }
+    /**
+     * Format a single character blocking position
+     */
+    formatBlockingPosition(pos) {
+        const parts = [pos.character + ':'];
+        if (pos.action) {
+            parts.push(pos.action);
+        }
+        if (pos.position) {
+            parts.push(pos.position);
+        }
+        if (pos.stagePosition) {
+            parts.push(`(${pos.stagePosition})`);
+        }
+        if (pos.relativePosition) {
+            parts.push(`[${pos.relativePosition}]`);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Apply AI-generated character descriptions to character states
+     */
+    applyCharacterDescriptions(characters, descriptions) {
+        for (const desc of descriptions) {
+            const char = characters.find(c => c.name === desc.character);
+            if (char) {
+                if (desc.physicalAppearance) {
+                    char.physicalAppearance = desc.physicalAppearance;
+                }
+                if (desc.wardrobe) {
+                    char.wardrobe = desc.wardrobe;
+                }
+                if (desc.emotion) {
+                    char.emotion = desc.emotion;
+                }
+            }
+        }
+    }
     /**
      * Build sound effects from scene elements
+     * Filters out character entrances/exits which should be in Actions, not SFX
      */
     buildSFX(elements) {
-        const actionElements = elements.filter(el => el.type === 'action');
+        const sfxList = [];
+        // Check dialogue for intercom references
+        const dialogueElements = elements.filter(el => el.type === 'dialogue');
+        for (const dialogueEl of dialogueElements) {
+            const parenthetical = dialogueEl.dialogue.parenthetical?.toLowerCase() || '';
+            if (parenthetical.includes('intercom') || parenthetical.includes('over intercom')) {
+                sfxList.push('Intercom buzz/chirp');
+            }
+        }
         // Extract sound effects from action lines
-        const sfxElements = actionElements
+        const actionElements = elements.filter(el => el.type === 'action');
+        const actionSfx = actionElements
             .map(el => el.text)
-            .filter(text => this.isSoundEffect(text));
-        if (sfxElements.length === 0) {
+            .filter(text => this.isSoundEffect(text) && !this.isCharacterEntrance(text));
+        sfxList.push(...actionSfx);
+        if (sfxList.length === 0) {
             return 'No sound effects specified';
         }
-        return sfxElements.join('. ');
+        return sfxList.join('. ');
+    }
+    /**
+     * Check if text describes a character entrance or exit
+     * These should be in Actions, not SFX
+     */
+    isCharacterEntrance(text) {
+        const entranceKeywords = [
+            'enters', 'enter', 'entering',
+            'exits', 'exit', 'exiting',
+            'arrives', 'arrive', 'arriving',
+            'leaves', 'leave', 'leaving',
+            'walks in', 'walks out',
+            'comes in', 'goes out'
+        ];
+        const lowerText = text.toLowerCase();
+        // Check if text contains character introduction pattern: "NAME (description) enters"
+        const hasCharacterIntro = /[A-Z][A-Z\s]+\s*\([^)]+\)/.test(text);
+        // Check for entrance keywords
+        const hasEntranceKeyword = entranceKeywords.some(keyword => lowerText.includes(keyword));
+        return hasCharacterIntro || hasEntranceKeyword;
     }
     /**
      * Check if text describes a sound effect
@@ -498,19 +702,35 @@ class ShotListGenerator {
      * Build verbose context description for generative AI
      * Target: Extremely detailed set/environment description (1000+ characters)
      * PRIORITY: Extract concrete details from screenplay, avoid generic filler
+     * STYLE-AWARE: Apply style-specific visual characteristics
+     * QUALITY: Environment only - no character actions
      */
     buildVerboseContext(context) {
         const parts = [];
         // Start with the actual set description from the screenplay
         // This should contain the concrete visual details
         if (context.description && context.description.length > 50) {
-            // Use the actual screenplay description as the foundation
-            parts.push(context.description);
+            // Clean the description to remove character actions
+            const environmentOnly = this.extractEnvironmentDescription(context.description);
+            if (environmentOnly) {
+                parts.push(environmentOnly);
+            }
+            else {
+                // Fallback if cleaning removed everything
+                parts.push(`${context.set} fills the frame`);
+            }
         }
         else {
             // Fallback: Build from available context
             parts.push(`${context.set} fills the frame`);
         }
+        // Apply style-specific visual characteristics
+        if (this.styleGuidelines) {
+            const styleEnhancements = this.getStyleVisualCharacteristics(context);
+            if (styleEnhancements) {
+                parts.push(styleEnhancements);
+            }
+        }
         // Add lighting details if specific
         if (context.lighting && !context.lighting.includes('natural') && !context.lighting.includes('standard')) {
             parts.push(`Lighting: ${context.lighting}`);
@@ -519,7 +739,7 @@ class ShotListGenerator {
         if (context.atmosphere && context.atmosphere !== 'neutral') {
             parts.push(`Atmosphere: ${context.atmosphere}`);
         }
-        // Add weather if present
+        // Add weather if present (already filtered by ContextBuilder for space settings)
         if (context.weather) {
             parts.push(`Weather: ${context.weather}`);
         }
@@ -533,6 +753,116 @@ class ShotListGenerator {
         }
         return parts.join('. ');
     }
+    /**
+     * Extract environment description only, removing character actions
+     * Keeps: Set details, props, lighting, atmosphere
+     * Removes: Character introductions, character actions
+     */
+    extractEnvironmentDescription(description) {
+        // First, remove character introductions with parenthetical descriptions
+        // Example: "WIZARD CLIF HIGH (mid-70s, magnificent long white beard...) stands at..."
+        // This removes the entire character introduction clause
+        let cleaned = description.replace(/[A-Z][A-Z\s]+\([^)]+\)\s+[^.]*\./g, '');
+        // Split into sentences to process individually
+        const sentences = cleaned.split(/\.\s+/);
+        const cleanedSentences = [];
+        for (let sentence of sentences) {
+            // Skip if this is primarily a character action sentence
+            // Check if sentence starts with or contains character action patterns
+            if (this.isCharacterActionSentence(sentence)) {
+                continue;
+            }
+            // Trim and check if anything meaningful remains
+            sentence = sentence.trim();
+            // Keep sentences that have substantial content
+            if (sentence.length > 15) {
+                cleanedSentences.push(sentence);
+            }
+        }
+        return cleanedSentences.join('. ').trim();
+    }
+    /**
+     * Check if a sentence is primarily about character actions
+     * Returns true only if the sentence describes what a character is DOING
+     * Returns false if it's describing the environment, even if it contains action-like verbs
+     */
+    isCharacterActionSentence(sentence) {
+        const lowerSentence = sentence.toLowerCase();
+        // Check if sentence contains character name patterns (ALL CAPS words or known character names)
+        const hasCharacterName = /\b[A-Z]{2,}(?:\s+[A-Z]{2,})*\b/.test(sentence);
+        // Character action patterns: "CHARACTER + ACTION VERB"
+        // Example: "WIZARD stands at the center", "Clif pauses", "HEIDI enters"
+        const characterActionPatterns = [
+            /\b(stands?|stood|standing)\s+(at|in|near|by)/i,
+            /\b(sits?|sat|sitting)\s+(at|in|on|down)/i,
+            /\b(walks?|walked|walking)\s+(to|toward|into|through)/i,
+            /\b(enters?|entered|entering)\b/i,
+            /\b(exits?|exited|exiting)\b/i,
+            /\b(waves?|waved|waving)\s+(his|her|their|a)/i,
+            /\b(pauses?|paused|pausing)\b/i,
+            /\b(sighs?|sighed|sighing)\b/i,
+            /\b(looks?|looked|looking)\s+(at|toward|up|down)/i,
+            /\b(turns?|turned|turning)\s+(to|toward|around)/i,
+            /\b(moves?|moved|moving)\s+(to|toward|closer)/i,
+            /\b(gestures?|gestured|gesturing)\b/i,
+            /\b(points?|pointed|pointing)\s+(at|to|toward)/i,
+            /\b(reaches?|reached|reaching)\s+(for|toward|out)/i,
+            /\b(grabs?|grabbed|grabbing)\b/i
+        ];
+        // Check if sentence matches character action patterns
+        const hasCharacterAction = characterActionPatterns.some(pattern => pattern.test(lowerSentence));
+        // Return true only if it has both a character reference AND an action pattern
+        return hasCharacterName && hasCharacterAction;
+    }
+    /**
+     * Check if a sentence is a character introduction
+     * Example: "WIZARD CLIF HIGH (mid-70s, magnificent long white beard...)"
+     */
+    isCharacterIntroduction(sentence) {
+        // Character introductions typically have:
+        // 1. All-caps name
+        // 2. Parenthetical description with age, appearance, etc.
+        const hasAllCapsName = /[A-Z]{2,}\s+[A-Z]{2,}/.test(sentence);
+        const hasParentheticalDescription = /\([^)]*\)/.test(sentence);
+        return hasAllCapsName && hasParentheticalDescription;
+    }
+    /**
+     * Get style-specific visual characteristics based on active style guidelines
+     * Returns visual descriptors that match the franchise/format aesthetic
+     */
+    getStyleVisualCharacteristics(context) {
+        if (!this.styleGuidelines || !this.styleGuidelines.appliedStyles) {
+            return null;
+        }
+        const characteristics = [];
+        const appliedStylesLower = this.styleGuidelines.appliedStyles.map(s => s.toLowerCase());
+        // Check for Star Trek franchise style
+        if (appliedStylesLower.some(s => s.includes('star trek'))) {
+            // Apply Star Trek visual aesthetic
+            characteristics.push('Clean futurism with bright, optimistic lighting');
+            characteristics.push('Sleek, utopian design with smooth surfaces and advanced technology');
+            // Check if this is a bridge/command center
+            const location = context.set.toLowerCase();
+            if (location.includes('bridge') || location.includes('command')) {
+                characteristics.push('Command stations with illuminated displays and ergonomic controls');
+            }
+        }
+        // Check for SNL comedy format style
+        if (appliedStylesLower.some(s => s.includes('saturday night live') || s.includes('snl'))) {
+            // Apply SNL visual style
+            characteristics.push('Exaggerated, absurd visual comedy elements');
+            characteristics.push('Fast-paced, chaotic energy with physical comedy potential');
+            // Emphasize the comedic tone
+            if (context.atmosphere && context.atmosphere !== 'neutral') {
+                characteristics.push(`Absurdly ${context.atmosphere} atmosphere for comedic effect`);
+            }
+        }
+        // Check for other franchises
+        if (appliedStylesLower.some(s => s.includes('star wars'))) {
+            characteristics.push('Lived-in, used-future aesthetic with weathered technology');
+        }
+        return characteristics.length > 0 ? characteristics.join('. ') : null;
+    }
     /**
      * Build verbose character description for generative AI
      * Target: 500-800 characters per character with complete visual detail