@mytechtoday/augment-extensions 2.3.7 → 2.4.0

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

@@ -12,6 +12,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextBuilder = void 0;
+const ai_entity_extractor_1 = require("./ai-entity-extractor");
 /**
  * Context Builder class
  * Requirement 9: Track character blocking continuity across shots
@@ -23,7 +24,93 @@ class ContextBuilder {
         this.characterBlockingHistory = new Map();
         this.characterBible = new Map(); // Requirement 10
         this.setBible = new Map(); // Requirement 11
+        this.styleGuidelines = null;
         this.config = config;
+        this.styleGuidelines = config.styleGuidelines || null;
+        this.aiExtractor = new ai_entity_extractor_1.AIEntityExtractor();
+    }
+    /**
+     * Normalize character name for fuzzy matching
+     * Handles variations like "THE CAPTAIN" vs "CAPTAIN", "A WIZARD" vs "WIZARD"
+     *
+     * Rules:
+     * - Remove leading articles: THE, A, AN
+     * - Trim whitespace
+     * - Convert to uppercase for consistent comparison
+     *
+     * Examples:
+     * - "THE CAPTAIN" -> "CAPTAIN"
+     * - "A WIZARD" -> "WIZARD"
+     * - "AN OFFICER" -> "OFFICER"
+     * - "CAPTAIN" -> "CAPTAIN"
+     */
+    normalizeCharacterName(name) {
+        return name
+            .trim()
+            .toUpperCase()
+            .replace(/^(THE|A|AN)\s+/, ''); // Remove leading articles
+    }
+    /**
+     * Find character in Bible using fuzzy matching
+     * Tries exact match first, then normalized match, then partial match
+     *
+     * @param characterName - The character name to search for
+     * @returns The Bible entry if found, null otherwise
+     */
+    findCharacterInBible(characterName) {
+        // Try exact match first
+        let bibleEntry = this.characterBible.get(characterName);
+        if (bibleEntry)
+            return bibleEntry;
+        // Try normalized match
+        const normalizedName = this.normalizeCharacterName(characterName);
+        for (const [bibleKey, bibleValue] of this.characterBible.entries()) {
+            if (this.normalizeCharacterName(bibleKey) === normalizedName) {
+                return bibleValue;
+            }
+        }
+        // Try partial match (e.g., "CLIF" matches "WIZARD CLIF HIGH")
+        for (const [bibleKey, bibleValue] of this.characterBible.entries()) {
+            if (bibleKey.includes(characterName) || characterName.includes(bibleKey)) {
+                return bibleValue;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get or create character in Bible using fuzzy matching
+     * Returns the canonical name (the one stored in the Bible)
+     *
+     * @param characterName - The character name to search for
+     * @returns Object with bibleEntry and canonicalName
+     */
+    getOrCreateCharacterInBible(characterName) {
+        // Try to find existing entry
+        const existingEntry = this.findCharacterInBible(characterName);
+        if (existingEntry) {
+            return { bibleEntry: existingEntry, canonicalName: existingEntry.name };
+        }
+        // Create new entry
+        const newEntry = {
+            name: characterName,
+            wardrobe: '',
+            physicalAppearance: '',
+            props: [],
+            lastSeenPosition: 'in scene',
+            lastSeenEmotion: undefined
+        };
+        this.characterBible.set(characterName, newEntry);
+        return { bibleEntry: newEntry, canonicalName: characterName };
+    }
+    /**
+     * Reset all state (Character Bible, Set Bible, blocking history)
+     * Call this at the start of each new screenplay generation to prevent contamination
+     */
+    reset() {
+        this.characterBlockingHistory.clear();
+        this.characterBible.clear();
+        this.setBible.clear();
+        console.log('ContextBuilder state reset - all Bibles and history cleared');
     }
     /**
      * Build scene-level context from scene heading and elements
@@ -87,31 +174,31 @@ class ContextBuilder {
      * Build character states from scene elements
      * Requirement 9: Maintain character blocking continuity across shots
      * Requirement 10: Use Character Bible to maintain rich, consistent character descriptions
-     * PRIORITY: Extract character introductions from action lines using known character names
+     * PRIORITY: Use AI-powered fuzzy logic to extract characters following MPAA/AMPAS standards
      */
-    buildCharacterStates(elements, sceneContext) {
+    async buildCharacterStates(elements, sceneContext) {
         const characterMap = new Map();
-        // FIRST PASS: Collect ALL character names from dialogue AND action lines
-        const characterNames = [];
+        // FIRST PASS: Use AI to extract characters from scene text
+        const characterNames = await this.extractCharactersWithAI(elements, sceneContext);
+        // ALSO check Character Bible for mixed-case character name references
+        // Example: "Clif pauses" should match "CLIF" or "WIZARD CLIF HIGH" from Bible
+        // This handles cases where a character was introduced in a previous segment
         for (const element of elements) {
-            if (element.type === 'dialogue') {
-                const dialogueElement = element;
-                const characterName = dialogueElement.dialogue.character.name;
-                if (!characterNames.includes(characterName)) {
-                    characterNames.push(characterName);
-                }
-            }
-            else if (element.type === 'action') {
-                // Also extract character names from action lines (ALL CAPS names)
+            if (element.type === 'action') {
                 const actionElement = element;
-                const regex = /\b([A-Z]{2,}(?:\s+[A-Z]{2,})*)\b/g;
-                let match;
-                while ((match = regex.exec(actionElement.text)) !== null) {
-                    const name = match[1].trim();
-                    // Skip common words that are all caps
-                    if (!['INT', 'EXT', 'DAY', 'NIGHT', 'CONTINUOUS', 'LATER', 'PADD', 'FLU'].includes(name) &&
-                        !characterNames.includes(name)) {
-                        characterNames.push(name);
+                for (const [bibleName, bibleEntry] of this.characterBible.entries()) {
+                    const nameParts = bibleName.split(/\s+/);
+                    for (const part of nameParts) {
+                        if (part.length > 2) {
+                            const regex = new RegExp(`\\b${part}\\b`, 'i'); // Case-insensitive match
+                            if (regex.test(actionElement.text)) {
+                                // Found a reference to this character - add the full Bible name
+                                if (!characterNames.includes(bibleName)) {
+                                    characterNames.push(bibleName);
+                                }
+                                break;
+                            }
+                        }
                     }
                 }
             }
@@ -129,48 +216,35 @@ class ContextBuilder {
             if (element.type === 'dialogue') {
                 const dialogueElement = element;
                 const characterName = dialogueElement.dialogue.character.name;
-                if (!characterMap.has(characterName)) {
-                    // Check Character Bible first (try exact match, then partial match)
-                    let bibleEntry = this.characterBible.get(characterName);
-                    // If no exact match, try to find a Bible entry that contains this character name
-                    // E.g., "CLIF" should match "WIZARD CLIF HIGH"
-                    if (!bibleEntry) {
-                        for (const [bibleKey, bibleValue] of this.characterBible.entries()) {
-                            if (bibleKey.includes(characterName) || characterName.includes(bibleKey)) {
-                                bibleEntry = bibleValue;
-                                break;
-                            }
-                        }
-                    }
+                // Use fuzzy matching to find or create character in Bible
+                let { bibleEntry, canonicalName } = this.getOrCreateCharacterInBible(characterName);
+                if (!characterMap.has(canonicalName)) {
                     const previousState = this.characterBlockingHistory.get(characterName);
-                    if (!bibleEntry && previousState) {
-                        // Create Character Bible entry from previous state
-                        bibleEntry = {
-                            name: characterName,
-                            wardrobe: previousState.wardrobe || '',
-                            physicalAppearance: previousState.physicalAppearance || '',
-                            props: [],
-                            lastSeenPosition: previousState.position || 'in scene',
-                            lastSeenEmotion: previousState.emotion
-                        };
-                        this.characterBible.set(characterName, bibleEntry);
+                    // If we found an existing entry but it's under a different name, update from previous state
+                    if (canonicalName !== characterName && previousState) {
+                        if (previousState.wardrobe)
+                            bibleEntry.wardrobe = previousState.wardrobe;
+                        if (previousState.physicalAppearance)
+                            bibleEntry.physicalAppearance = previousState.physicalAppearance;
+                        if (previousState.position)
+                            bibleEntry.lastSeenPosition = previousState.position;
+                        if (previousState.emotion)
+                            bibleEntry.lastSeenEmotion = previousState.emotion;
                     }
-                    else if (!bibleEntry) {
-                        // Create minimal Character Bible entry (will be populated from action lines)
-                        bibleEntry = {
-                            name: characterName,
-                            wardrobe: '',
-                            physicalAppearance: '',
-                            props: [],
-                            lastSeenPosition: 'in scene',
-                            lastSeenEmotion: undefined
-                        };
-                        this.characterBible.set(characterName, bibleEntry);
+                    // If this is a new entry and we have previous state, populate from it
+                    if (!bibleEntry.wardrobe && !bibleEntry.physicalAppearance && previousState) {
+                        bibleEntry.wardrobe = previousState.wardrobe || '';
+                        bibleEntry.physicalAppearance = previousState.physicalAppearance || '';
+                        bibleEntry.lastSeenPosition = previousState.position || 'in scene';
+                        bibleEntry.lastSeenEmotion = previousState.emotion;
                     }
-                    // Build rich character state from Bible
-                    characterMap.set(characterName, {
-                        name: characterName,
-                        position: bibleEntry.lastSeenPosition,
+                    // Check if character is V.O. (voice over) - they're not visible
+                    const isVoiceOver = dialogueElement.dialogue.character.extension?.includes('V.O.');
+                    const position = isVoiceOver ? 'not visible' : bibleEntry.lastSeenPosition;
+                    // Build rich character state from Bible (use canonical name for consistency)
+                    characterMap.set(canonicalName, {
+                        name: canonicalName,
+                        position: position,
                         appearance: `${bibleEntry.physicalAppearance}${bibleEntry.props.length > 0 ? ', carrying ' + bibleEntry.props.join(', ') : ''}`,
                         wardrobe: bibleEntry.wardrobe,
                         physicalAppearance: bibleEntry.physicalAppearance,
@@ -179,16 +253,18 @@ class ContextBuilder {
                     });
                 }
                 else {
+                    // Update position if V.O. (voice over)
+                    const isVoiceOver = dialogueElement.dialogue.character.extension?.includes('V.O.');
+                    if (isVoiceOver) {
+                        characterMap.get(canonicalName).position = 'not visible';
+                    }
                     // Update emotion if tracking
                     if (this.config.trackCharacterEmotions) {
                         const emotion = this.extractEmotion(dialogueElement);
                         if (emotion) {
-                            characterMap.get(characterName).emotion = emotion;
-                            // Update Bible
-                            const bibleEntry = this.characterBible.get(characterName);
-                            if (bibleEntry) {
-                                bibleEntry.lastSeenEmotion = emotion;
-                            }
+                            characterMap.get(canonicalName).emotion = emotion;
+                            // Update Bible (already have bibleEntry from above)
+                            bibleEntry.lastSeenEmotion = emotion;
                         }
                     }
                 }
@@ -198,14 +274,56 @@ class ContextBuilder {
                 this.updateCharacterStatesFromAction(actionElement, characterMap);
             }
         }
+        // FOURTH PASS: Process any character names found in action lines that weren't in dialogue
+        // This handles cases like "Clif pauses" where the character is referenced but doesn't speak
+        for (const characterName of characterNames) {
+            // Use fuzzy matching to find or create character in Bible
+            let { bibleEntry, canonicalName } = this.getOrCreateCharacterInBible(characterName);
+            if (!characterMap.has(canonicalName)) {
+                const previousState = this.characterBlockingHistory.get(characterName);
+                // If we found an existing entry but it's under a different name, update from previous state
+                if (canonicalName !== characterName && previousState) {
+                    if (previousState.wardrobe)
+                        bibleEntry.wardrobe = previousState.wardrobe;
+                    if (previousState.physicalAppearance)
+                        bibleEntry.physicalAppearance = previousState.physicalAppearance;
+                    if (previousState.position)
+                        bibleEntry.lastSeenPosition = previousState.position;
+                    if (previousState.emotion)
+                        bibleEntry.lastSeenEmotion = previousState.emotion;
+                }
+                // If this is a new entry and we have previous state, populate from it
+                if (!bibleEntry.wardrobe && !bibleEntry.physicalAppearance && previousState) {
+                    bibleEntry.wardrobe = previousState.wardrobe || '';
+                    bibleEntry.physicalAppearance = previousState.physicalAppearance || '';
+                    bibleEntry.lastSeenPosition = previousState.position || 'in scene';
+                    bibleEntry.lastSeenEmotion = previousState.emotion;
+                }
+                // Build character state from Bible (use canonical name for consistency)
+                characterMap.set(canonicalName, {
+                    name: canonicalName,
+                    position: bibleEntry.lastSeenPosition,
+                    appearance: `${bibleEntry.physicalAppearance}${bibleEntry.props.length > 0 ? ', carrying ' + bibleEntry.props.join(', ') : ''}`,
+                    wardrobe: bibleEntry.wardrobe,
+                    physicalAppearance: bibleEntry.physicalAppearance,
+                    emotion: bibleEntry.lastSeenEmotion,
+                    action: undefined
+                });
+            }
+        }
         // Update blocking history and Character Bible for continuity
         for (const [name, state] of characterMap.entries()) {
             this.characterBlockingHistory.set(name, { ...state });
-            // Update Character Bible with latest information
-            const bibleEntry = this.characterBible.get(name);
+            // Update Character Bible with latest information (using fuzzy matching)
+            const bibleEntry = this.findCharacterInBible(name);
             if (bibleEntry) {
+                // Normalize position: "enters scene" becomes "in scene" after first appearance
+                let normalizedPosition = state.position;
+                if (normalizedPosition === 'enters scene') {
+                    normalizedPosition = 'in scene';
+                }
                 if (state.position)
-                    bibleEntry.lastSeenPosition = state.position;
+                    bibleEntry.lastSeenPosition = normalizedPosition;
                 if (state.wardrobe)
                     bibleEntry.wardrobe = state.wardrobe;
                 if (state.physicalAppearance)
@@ -395,10 +513,41 @@ class ContextBuilder {
         }
         return undefined;
     }
+    /**
+     * Check if the scene is set in space (spaceship, space station, etc.)
+     * where weather doesn't make sense
+     */
+    isSpaceSetting(scene) {
+        const location = scene.heading.location.toLowerCase();
+        const intExt = scene.heading.intExt.toLowerCase();
+        // Check for space-related keywords in location
+        const spaceKeywords = [
+            'enterprise', 'starship', 'spaceship', 'space station',
+            'bridge', 'engineering', 'sickbay', 'transporter room',
+            'cargo bay', 'shuttle bay', 'ready room', 'observation lounge',
+            'holodeck', 'jefferies tube', 'turbolift',
+            'death star', 'millennium falcon', 'star destroyer',
+            'serenity', 'galactica', 'voyager', 'defiant', 'discovery'
+        ];
+        // If it's an interior space setting, no weather
+        if (intExt === 'int' && spaceKeywords.some(keyword => location.includes(keyword))) {
+            return true;
+        }
+        // Check for explicit "space" in location
+        if (location.includes('space') || location.includes('orbit')) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Extract weather from scene elements
+     * Style-aware: respects franchise settings (no weather on spaceships!)
      */
     extractWeather(scene) {
+        // Check if this is a space setting where weather doesn't make sense
+        if (this.isSpaceSetting(scene)) {
+            return undefined;
+        }
         const weatherKeywords = ['rain', 'snow', 'fog', 'storm', 'sunny', 'cloudy', 'wind'];
         for (const element of scene.elements) {
             const text = element.text.toLowerCase();
@@ -412,13 +561,42 @@ class ContextBuilder {
     }
     /**
      * Extract emotion from dialogue element
+     * Handles both parenthetical and character extension (V.O., O.S., etc.)
      */
     extractEmotion(dialogueElement) {
-        // Check parenthetical for emotion
+        const parts = [];
+        // Check character extension (V.O., O.S., etc.)
+        let hasVoiceOver = false;
+        let hasOffScreen = false;
+        if (dialogueElement.dialogue.character.extension) {
+            const ext = dialogueElement.dialogue.character.extension.replace(/[()]/g, '').trim();
+            if (ext === 'V.O.') {
+                parts.push('voice over');
+                hasVoiceOver = true;
+            }
+            else if (ext === 'O.S.') {
+                parts.push('off screen');
+                hasOffScreen = true;
+            }
+            else {
+                parts.push(ext.toLowerCase());
+            }
+        }
+        // Check parenthetical for additional context (e.g., "over intercom")
         if (dialogueElement.dialogue.parenthetical) {
-            return dialogueElement.dialogue.parenthetical.replace(/[()]/g, '').trim();
+            let paren = dialogueElement.dialogue.parenthetical.replace(/[()]/g, '').trim();
+            // Skip if it's redundant with the extension
+            if (paren.toLowerCase().includes('v.o.') || paren.toLowerCase().includes('o.s.')) {
+                return parts.length > 0 ? parts.join(' ') : undefined;
+            }
+            // If we have voice over and parenthetical starts with "over", merge them
+            // "voice over" + "over intercom" -> "voice over intercom"
+            if (hasVoiceOver && paren.toLowerCase().startsWith('over ')) {
+                paren = paren.substring(5); // Remove "over " prefix
+            }
+            parts.push(paren);
         }
-        return undefined;
+        return parts.length > 0 ? parts.join(' ') : undefined;
     }
     /**
      * Extract ALL character introductions from an action line
@@ -467,27 +645,29 @@ class ContextBuilder {
                     physicalParts.push(part);
                 }
             }
-            // Update or create Character Bible entry using the matched name
-            let bibleEntry = this.characterBible.get(matchedName);
-            if (!bibleEntry) {
-                bibleEntry = {
-                    name: matchedName,
-                    wardrobe: wardrobeParts.join(', '),
-                    physicalAppearance: physicalParts.join(', '),
-                    props: [],
-                    lastSeenPosition: 'in scene',
-                    lastSeenEmotion: undefined
-                };
-                this.characterBible.set(matchedName, bibleEntry);
+            // Detect if this is an entrance or exit
+            const lowerText = text.toLowerCase();
+            let position = 'in scene';
+            if (lowerText.includes('enters') || lowerText.includes('enter')) {
+                position = 'enters scene';
             }
-            else {
-                // Update existing entry if we have more details
-                if (physicalParts.length > 0 && !bibleEntry.physicalAppearance) {
-                    bibleEntry.physicalAppearance = physicalParts.join(', ');
-                }
-                if (wardrobeParts.length > 0 && !bibleEntry.wardrobe) {
-                    bibleEntry.wardrobe = wardrobeParts.join(', ');
-                }
+            else if (lowerText.includes('exits') || lowerText.includes('exit')) {
+                position = 'exits scene';
+            }
+            // Enrich wardrobe with specific colors based on cinematic style
+            const enrichedWardrobe = this.enrichWardrobeWithColors(wardrobeParts.join(', '), matchedName, text);
+            // Update or create Character Bible entry using the matched name (with fuzzy matching)
+            let { bibleEntry } = this.getOrCreateCharacterInBible(matchedName);
+            // Update entry with extracted details
+            if (physicalParts.length > 0 && !bibleEntry.physicalAppearance) {
+                bibleEntry.physicalAppearance = physicalParts.join(', ');
+            }
+            if (wardrobeParts.length > 0 && !bibleEntry.wardrobe) {
+                bibleEntry.wardrobe = enrichedWardrobe;
+            }
+            // Update position if this is an entrance/exit
+            if (position !== 'in scene') {
+                bibleEntry.lastSeenPosition = position;
             }
         }
     }
@@ -537,14 +717,14 @@ class ContextBuilder {
             if (intro) {
                 if (intro.physicalAppearance) {
                     state.physicalAppearance = intro.physicalAppearance;
-                    const bibleEntry = this.characterBible.get(name);
+                    const bibleEntry = this.findCharacterInBible(name);
                     if (bibleEntry) {
                         bibleEntry.physicalAppearance = intro.physicalAppearance;
                     }
                 }
                 if (intro.wardrobe) {
                     state.wardrobe = intro.wardrobe;
-                    const bibleEntry = this.characterBible.get(name);
+                    const bibleEntry = this.findCharacterInBible(name);
                     if (bibleEntry) {
                         bibleEntry.wardrobe = intro.wardrobe;
                     }
@@ -552,8 +732,14 @@ class ContextBuilder {
             }
         }
         for (const [name, state] of characterMap.entries()) {
-            if (text.includes(name)) {
+            // Check for character name (case-insensitive, and check for partial matches)
+            // Example: "CLIF" should match "Clif" or "WIZARD CLIF HIGH" should match "Clif"
+            const nameParts = name.split(/\s+/);
+            const textLower = text.toLowerCase();
+            const nameMatches = nameParts.some(part => part.length > 2 && textLower.includes(part.toLowerCase()));
+            if (nameMatches || text.includes(name)) {
                 state.action = text;
+                console.log(`[DEBUG] Assigning action to ${name}: "${text.substring(0, 100)}..."`);
                 // Extract position/blocking keywords
                 const positionKeywords = [
                     'stands', 'sits', 'walks', 'enters', 'exits', 'moves',
@@ -562,6 +748,15 @@ class ContextBuilder {
                 ];
                 for (const keyword of positionKeywords) {
                     if (text.toLowerCase().includes(keyword)) {
+                        // Special handling for "enters" and "exits" - use simple position
+                        if (keyword === 'enters' && text.toLowerCase().includes('enters')) {
+                            state.position = 'enters scene';
+                            break;
+                        }
+                        else if (keyword === 'exits' && text.toLowerCase().includes('exits')) {
+                            state.position = 'exits scene';
+                            break;
+                        }
                         // Extract sentence containing the keyword for position context
                         const sentences = text.split(/[.!?]/);
                         for (const sentence of sentences) {
@@ -595,7 +790,7 @@ class ContextBuilder {
                             // Join multiple sentences for verbose description
                             state.wardrobe = relevantSentences.join('. ');
                             // Update Character Bible
-                            const bibleEntry = this.characterBible.get(name);
+                            const bibleEntry = this.findCharacterInBible(name);
                             if (bibleEntry) {
                                 bibleEntry.wardrobe = relevantSentences.join('. ');
                             }
@@ -627,7 +822,7 @@ class ContextBuilder {
                             // Join multiple sentences for verbose description
                             state.physicalAppearance = relevantSentences.join('. ');
                             // Update Character Bible
-                            const bibleEntry = this.characterBible.get(name);
+                            const bibleEntry = this.findCharacterInBible(name);
                             if (bibleEntry) {
                                 bibleEntry.physicalAppearance = relevantSentences.join('. ');
                             }
@@ -648,7 +843,7 @@ class ContextBuilder {
                         for (const sentence of sentences) {
                             if (sentence.toLowerCase().includes(keyword) && sentence.includes(name)) {
                                 // Update Character Bible with prop
-                                const bibleEntry = this.characterBible.get(name);
+                                const bibleEntry = this.findCharacterInBible(name);
                                 if (bibleEntry) {
                                     const prop = sentence.trim();
                                     if (!bibleEntry.props.includes(prop)) {
@@ -664,6 +859,107 @@ class ContextBuilder {
             }
         }
     }
+    /**
+     * Enrich wardrobe descriptions with specific colors based on cinematic style
+     * Maintains visual continuity by adding particular details
+     *
+     * Star Trek uniform colors:
+     * - Command: Gold/Yellow
+     * - Science/Medical: Blue
+     * - Engineering/Security: Red
+     */
+    enrichWardrobeWithColors(wardrobe, characterName, fullText) {
+        if (!wardrobe || !this.styleGuidelines) {
+            return wardrobe;
+        }
+        // Check if this is a Star Trek style
+        const isStarTrek = this.styleGuidelines.appliedStyles.some(style => style.toLowerCase().includes('star trek'));
+        if (!isStarTrek) {
+            return wardrobe; // Only enrich for Star Trek for now
+        }
+        // If wardrobe already has color, don't override
+        const hasColor = /\b(red|blue|gold|yellow|green|black|white|gray|grey|purple|orange|brown)\b/i.test(wardrobe);
+        if (hasColor) {
+            return wardrobe;
+        }
+        // Determine department from wardrobe or character context
+        const lowerWardrobe = wardrobe.toLowerCase();
+        const lowerText = fullText.toLowerCase();
+        let color = '';
+        // Engineering/Security = Red
+        if (lowerWardrobe.includes('engineering') || lowerWardrobe.includes('security') ||
+            lowerText.includes('engineer') || lowerText.includes('security')) {
+            color = 'red';
+        }
+        // Science/Medical = Blue
+        else if (lowerWardrobe.includes('science') || lowerWardrobe.includes('medical') ||
+            lowerText.includes('science') || lowerText.includes('medical') || lowerText.includes('doctor')) {
+            color = 'blue';
+        }
+        // Command = Gold
+        else if (lowerWardrobe.includes('command') || lowerWardrobe.includes('captain') ||
+            lowerText.includes('captain') || lowerText.includes('commander')) {
+            color = 'gold';
+        }
+        // Default to red for generic Starfleet uniforms
+        else if (lowerWardrobe.includes('starfleet') || lowerWardrobe.includes('uniform')) {
+            color = 'red'; // Default to engineering red
+        }
+        // Add color to wardrobe description
+        if (color) {
+            // Insert color before "uniform" or "robe" if present
+            if (lowerWardrobe.includes('uniform')) {
+                return wardrobe.replace(/uniform/i, `${color} uniform`);
+            }
+            else if (lowerWardrobe.includes('robe')) {
+                return wardrobe.replace(/robe/i, `${color} robe`);
+            }
+            else {
+                // Prepend color
+                return `${color} ${wardrobe}`;
+            }
+        }
+        return wardrobe;
+    }
+    /**
+     * Extract characters using AI-powered fuzzy logic
+     * Follows MPAA and AMPAS Nicholl Fellowship screenplay standards
+     */
+    async extractCharactersWithAI(elements, sceneContext) {
+        // Build scene text from all elements
+        const sceneText = elements.map(el => {
+            if (el.type === 'dialogue') {
+                const dialogueEl = el;
+                return `${dialogueEl.dialogue.character.name}\n${dialogueEl.dialogue.speech}`;
+            }
+            else if (el.type === 'action') {
+                const actionEl = el;
+                return actionEl.text;
+            }
+            return '';
+        }).join('\n\n');
+        // Use AI extractor
+        const result = await this.aiExtractor.extractEntities(sceneText, sceneContext.set);
+        // Combine AI-extracted characters with dialogue characters
+        const characterNames = [];
+        // Add dialogue characters (always include these)
+        for (const element of elements) {
+            if (element.type === 'dialogue') {
+                const dialogueElement = element;
+                const characterName = dialogueElement.dialogue.character.name;
+                if (!characterNames.includes(characterName)) {
+                    characterNames.push(characterName);
+                }
+            }
+        }
+        // Add AI-extracted characters
+        for (const character of result.characters) {
+            if (!characterNames.includes(character)) {
+                characterNames.push(character);
+            }
+        }
+        return characterNames;
+    }
 }
 exports.ContextBuilder = ContextBuilder;
 //# sourceMappingURL=context-builder.js.map