@sutrata/editor 0.1.0

package/dist/ai/ai-client.js

@@ -0,0 +1,494 @@
+import generatedProvidersData from './generated-providers.json';
+/** Compiled-in last resort when both the remote and local models-config.json
+ * fetches fail (e.g. fully offline). Generated by scripts/generate-providers.mjs
+ * from the same source as models-config.json, so this can no longer drift
+ * from the runtime-fetched list the way the old hand-written array did. */
+const FALLBACK_PROVIDERS = generatedProvidersData.providers
+    .filter(p => p.essential)
+    .map(({ id, name, baseUrl, models }) => ({ id, name, baseUrl, models }));
+export async function getApiKey(provider) {
+    if (window.desktopAPI?.getApiKey) {
+        try {
+            return (await window.desktopAPI.getApiKey(provider)) || null;
+        }
+        catch (e) {
+            console.error('Failed to get key from tauri keyring:', e);
+        }
+    }
+    return localStorage.getItem(`sutrata_api_key_${provider}`);
+}
+export async function setApiKey(provider, key) {
+    if (window.desktopAPI?.setApiKey) {
+        try {
+            await window.desktopAPI.setApiKey(provider, key);
+            return;
+        }
+        catch (e) {
+            console.error('Failed to set key in tauri keyring:', e);
+        }
+    }
+    localStorage.setItem(`sutrata_api_key_${provider}`, key);
+}
+export async function deleteApiKey(provider) {
+    if (window.desktopAPI?.deleteApiKey) {
+        try {
+            await window.desktopAPI.deleteApiKey(provider);
+            return;
+        }
+        catch (e) {
+            console.error('Failed to delete key from tauri keyring:', e);
+        }
+    }
+    localStorage.removeItem(`sutrata_api_key_${provider}`);
+}
+export function getAIConfig() {
+    const stored = localStorage.getItem('sutrata_ai_config');
+    if (stored) {
+        try {
+            return JSON.parse(stored);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return {
+        // No model id is hardcoded here — callAI/callAIStructured already fall
+        // back to the chosen provider's first available model when
+        // preferredModel doesn't match one of its models.
+        preferredProvider: 'anthropic',
+        preferredModel: '',
+        customProviders: [],
+    };
+}
+export function saveAIConfig(config) {
+    localStorage.setItem('sutrata_ai_config', JSON.stringify(config));
+}
+let cachedProviders = null;
+export async function fetchProviders(config) {
+    if (cachedProviders) {
+        return mergeCustomProviders(cachedProviders, config?.customProviders);
+    }
+    const isProd = import.meta.env?.PROD;
+    const githubUrl = 'https://raw.githubusercontent.com/sivarajd/sutrata/main/packages/app/public/models-config.json';
+    let providers = [];
+    if (isProd) {
+        try {
+            const res = await fetch(githubUrl);
+            if (res.ok) {
+                const data = await res.json();
+                providers = data.providers || [];
+            }
+        }
+        catch (e) {
+            console.warn('Failed to fetch models config from github raw URL, falling back to local:', e);
+        }
+    }
+    if (providers.length === 0) {
+        try {
+            const res = await fetch('/models-config.json');
+            if (res.ok) {
+                const data = await res.json();
+                providers = data.providers || [];
+            }
+        }
+        catch (e) {
+            console.error('Failed to fetch local models-config.json:', e);
+        }
+    }
+    if (providers.length === 0) {
+        // Both the remote and local fetches failed (or returned nothing) — use
+        // the compiled-in snapshot generated at build time. See FALLBACK_PROVIDERS.
+        providers = FALLBACK_PROVIDERS;
+    }
+    cachedProviders = providers;
+    return mergeCustomProviders(providers, config?.customProviders);
+}
+function mergeCustomProviders(base, custom) {
+    if (!custom || custom.length === 0)
+        return base;
+    const list = [...base];
+    for (const c of custom) {
+        const index = list.findIndex(p => p.id === c.id);
+        if (index >= 0) {
+            const existing = list[index];
+            list[index] = {
+                ...existing,
+                name: c.name,
+                baseUrl: c.baseUrl,
+                models: c.models,
+            };
+        }
+        else {
+            list.push({
+                id: c.id,
+                name: c.name,
+                baseUrl: c.baseUrl,
+                models: c.models,
+            });
+        }
+    }
+    return list;
+}
+async function requestHttp(url, method, headers, body) {
+    if (window.desktopAPI?.callProviderApi) {
+        try {
+            const res = await window.desktopAPI.callProviderApi(url, method, headers, body);
+            return res;
+        }
+        catch (e) {
+            throw new Error(`Desktop API Error: ${e}`);
+        }
+    }
+    else {
+        try {
+            const res = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            let data;
+            const text = await res.text();
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = text;
+            }
+            return {
+                status: res.status,
+                data,
+            };
+        }
+        catch (e) {
+            throw new Error(`Web Fetch Error: ${e}`);
+        }
+    }
+}
+const STRUCTURED_TOOL_NAME = 'emit_result';
+/**
+ * Anthropic has no OpenAI-compatible endpoint, so it's the only provider
+ * that still needs a bespoke request/response shape here — everyone else
+ * (including Gemini, via its official /v1beta/openai compat base URL) goes
+ * through the generic OpenAI-compatible branch below.
+ */
+async function invokeProvider(provider, model, key, prompt, systemPrompt, responseSchema) {
+    let url = '';
+    let headers = {};
+    let body = null;
+    const method = 'POST';
+    if (provider.id === 'anthropic') {
+        url = `${provider.baseUrl}/messages`;
+        headers = {
+            'x-api-key': key,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+        };
+        body = {
+            model,
+            max_tokens: 2000,
+            system: systemPrompt,
+            messages: [
+                { role: 'user', content: prompt }
+            ],
+            temperature: 0.1,
+        };
+        if (responseSchema) {
+            // Force a schema-valid tool call instead of parsing free text —
+            // guarantees the fields we asked for, in the shape we asked for.
+            body.tools = [{
+                    name: STRUCTURED_TOOL_NAME,
+                    description: 'Return the structured result for this request.',
+                    input_schema: responseSchema,
+                    strict: true,
+                }];
+            body.tool_choice = { type: 'tool', name: STRUCTURED_TOOL_NAME };
+        }
+    }
+    else {
+        url = `${provider.baseUrl}/chat/completions`;
+        headers = {
+            'Authorization': `Bearer ${key}`,
+            'Content-Type': 'application/json',
+        };
+        const effectiveSystemPrompt = responseSchema
+            ? `${systemPrompt}\n\n[OUTPUT FORMAT]\nRespond with ONLY a single JSON object matching this JSON schema — no markdown fences, no commentary, no extra text before or after it:\n${JSON.stringify(responseSchema)}`
+            : systemPrompt;
+        body = {
+            model,
+            messages: [
+                { role: 'system', content: effectiveSystemPrompt },
+                { role: 'user', content: prompt }
+            ],
+            temperature: 0.1,
+        };
+        if (responseSchema) {
+            // Broadest-compatibility structured-output mode — many self-hosted/
+            // aggregator OpenAI-compatible backends don't support the stricter
+            // json_schema mode, so this is paired with the prompt instruction
+            // above and extractJson()'s tolerant parsing on the caller side.
+            body.response_format = { type: 'json_object' };
+        }
+    }
+    const res = await requestHttp(url, method, headers, body);
+    if (res.status === 429) {
+        throw new Error(`Rate limit exceeded (HTTP 429)`);
+    }
+    if (res.status < 200 || res.status >= 300) {
+        const errMsg = typeof res.data === 'object'
+            ? JSON.stringify(res.data)
+            : res.data;
+        throw new Error(`HTTP ${res.status}: ${errMsg}`);
+    }
+    if (provider.id === 'anthropic') {
+        if (responseSchema) {
+            const toolUse = res.data?.content?.find((block) => block?.type === 'tool_use' && block?.name === STRUCTURED_TOOL_NAME);
+            if (!toolUse)
+                throw new Error('Invalid response from Anthropic: missing tool_use block');
+            return JSON.stringify(toolUse.input);
+        }
+        const text = res.data?.content?.[0]?.text;
+        if (!text)
+            throw new Error('Invalid response from Anthropic: missing content text');
+        return text;
+    }
+    else {
+        const text = res.data?.choices?.[0]?.message?.content;
+        if (!text)
+            throw new Error(`Invalid response from ${provider.name}: missing message content`);
+        return text;
+    }
+}
+/**
+ * Parses a structured AI response into T, tolerating a model that wraps the
+ * JSON in a markdown fence or adds stray text around it despite being asked
+ * not to (some providers don't strictly honor response_format hints).
+ */
+export function extractJson(raw) {
+    const attempts = [raw.trim()];
+    const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenceMatch?.[1])
+        attempts.push(fenceMatch[1].trim());
+    const firstBrace = raw.indexOf('{');
+    const lastBrace = raw.lastIndexOf('}');
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        attempts.push(raw.slice(firstBrace, lastBrace + 1));
+    }
+    for (const attempt of attempts) {
+        try {
+            return JSON.parse(attempt);
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`AI did not return valid JSON: ${raw.slice(0, 200)}`);
+}
+export function cleanVoiceResponse(text) {
+    let cleaned = text.trim();
+    // Strip markdown code block wrapper if present
+    cleaned = cleaned.replace(/^```[a-zA-Z0-9]*\n/, '').replace(/\n```$/, '');
+    const lines = cleaned.split('\n');
+    const filteredLines = lines.map(line => {
+        let l = line.trim();
+        // Strip leading list bullet (e.g. *, -, +, •) and spaces
+        l = l.replace(/^[*•\-+]\s*/, '').trim();
+        // Strip leading/trailing backticks if any
+        l = l.replace(/^`+/, '').replace(/`+$/, '').trim();
+        // Strip common explanatory trailing comments in parens
+        l = l.replace(/\s*\(Standard screenplay shorthand[^)]*\)/gi, '');
+        l = l.replace(/\s*\(Standard shorthand[^)]*\)/gi, '');
+        return l;
+    }).filter(line => {
+        const trimmed = line.toLowerCase();
+        if (!trimmed)
+            return false;
+        // Discard reasoning/mapping/explanation patterns
+        if (trimmed.includes('->') ||
+            trimmed.includes('=>') ||
+            trimmed.startsWith('input:') ||
+            trimmed.startsWith('task:') ||
+            trimmed.startsWith('rules:') ||
+            trimmed.startsWith('instructions:') ||
+            trimmed.startsWith('sutra rules:') ||
+            trimmed.startsWith('scene headings:') ||
+            trimmed.startsWith('scene id:') ||
+            trimmed.startsWith('characters:') ||
+            trimmed.startsWith('parentheticals:') ||
+            trimmed.startsWith('dialogue:') ||
+            trimmed.startsWith('transitions:') ||
+            trimmed.startsWith('lyrics:') ||
+            trimmed.startsWith('action:') ||
+            trimmed.startsWith('format:') ||
+            trimmed.startsWith('components:') ||
+            trimmed.startsWith('output only') ||
+            trimmed.startsWith('no markdown') ||
+            trimmed.includes('convert it into valid sutra') ||
+            trimmed.includes('sutra syntax rules') ||
+            trimmed.includes('clearly a scene heading') ||
+            trimmed.includes('screenplay shorthand') ||
+            trimmed.includes('append as')) {
+            return false;
+        }
+        return true;
+    });
+    return filteredLines.join('\n').trim();
+}
+let nextCallId = 0;
+const activeCalls = new Map();
+const subscribers = new Set();
+export function subscribeToAICalls(callback) {
+    subscribers.add(callback);
+    callback(Array.from(activeCalls.values()));
+    return () => {
+        subscribers.delete(callback);
+    };
+}
+function notifySubscribers() {
+    const list = Array.from(activeCalls.values());
+    for (const sub of subscribers) {
+        sub(list);
+    }
+}
+export function formatActiveCalls(calls) {
+    if (calls.length === 0)
+        return '';
+    if (calls.length === 1) {
+        return `Calling ${calls[0].providerName} (${calls[0].model})...`;
+    }
+    const unique = Array.from(new Set(calls.map(c => `${c.providerName} (${c.model})`)));
+    if (unique.length === 1) {
+        return `Calling ${unique[0]} (${calls.length} calls)...`;
+    }
+    return `Calling ${unique.join(', ')}...`;
+}
+/**
+ * Resolves the provider/key/model fallback chain and invokes it, retrying
+ * the next configured provider on failure. Shared by callAI and
+ * callAIStructured so the two don't duplicate this logic.
+ */
+async function resolveAndInvoke(prompt, systemPrompt, config, responseSchema) {
+    const providers = await fetchProviders(config);
+    const availableProviders = [];
+    for (const p of providers) {
+        const key = await getApiKey(p.id);
+        if (key) {
+            availableProviders.push(p.id);
+        }
+    }
+    if (availableProviders.length === 0) {
+        throw new Error('No AI API keys configured. Please configure keys in Settings.');
+    }
+    let providersToTry = [config.preferredProvider, ...availableProviders.filter(p => p !== config.preferredProvider)];
+    providersToTry = providersToTry.filter(p => availableProviders.includes(p));
+    if (providersToTry.length === 0) {
+        providersToTry = [availableProviders[0]];
+    }
+    let lastError = '';
+    for (const providerId of providersToTry) {
+        const provider = providers.find(p => p.id === providerId);
+        if (!provider)
+            continue;
+        const key = await getApiKey(providerId);
+        if (!key)
+            continue;
+        // config.preferredModel is only meaningful for config.preferredProvider
+        // — Settings/Onboarding always save them together, and the model is
+        // picked from that provider's *live* listModels() result, which is
+        // usually not a member of `provider.models` (the static generated
+        // list, kept only as a last-resort default). Validating it against
+        // that static list here would silently discard a perfectly valid
+        // live-picked model and substitute a possibly-stale/retired one
+        // instead. For any other (fallback) provider in this loop,
+        // preferredModel genuinely doesn't apply, so fall back to its first
+        // static model.
+        const model = providerId === config.preferredProvider
+            ? (config.preferredModel || provider.models[0]?.id || '')
+            : (provider.models[0]?.id || '');
+        const callId = `call-${nextCallId++}`;
+        activeCalls.set(callId, { providerName: provider.name, model });
+        notifySubscribers();
+        try {
+            return await invokeProvider(provider, model, key, prompt, systemPrompt, responseSchema);
+        }
+        catch (e) {
+            console.warn(`Provider ${providerId} failed:`, e);
+            lastError = `[${provider.name} / ${model}] ${e.message || String(e)}`;
+            continue;
+        }
+        finally {
+            activeCalls.delete(callId);
+            notifySubscribers();
+        }
+    }
+    throw new Error(`AI generation failed. Last error: ${lastError}`);
+}
+export async function callAI(prompt, systemPrompt, config, options) {
+    const response = await resolveAndInvoke(prompt, systemPrompt, config);
+    return options?.clean === 'voice' ? cleanVoiceResponse(response) : response;
+}
+/**
+ * Like callAI, but requests and validates a JSON response matching `schema`
+ * instead of returning free text — the explicit contract that replaced
+ * sniffing the system prompt for keywords like "duration"/"synopsis".
+ */
+export async function callAIStructured(prompt, systemPrompt, config, schema) {
+    const response = await resolveAndInvoke(prompt, systemPrompt, config, schema);
+    return extractJson(response);
+}
+/** Any provider (from the fetched + custom list) with a stored API key. */
+export async function hasConfiguredApiKey(config) {
+    const providers = await fetchProviders(config);
+    for (const p of providers) {
+        if (await getApiKey(p.id))
+            return true;
+    }
+    return false;
+}
+/**
+ * Fetches the provider's live model list so Settings/Onboarding show
+ * current models instead of a potentially stale static one. Never throws —
+ * falls back to `provider.models` on any error (missing endpoint, bad key,
+ * network failure), since this is a progressive enhancement.
+ */
+export async function listModels(provider, apiKey) {
+    try {
+        const isAnthropic = provider.id === 'anthropic';
+        const url = isAnthropic ? 'https://api.anthropic.com/v1/models' : `${provider.baseUrl}/models`;
+        const headers = isAnthropic
+            ? { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' }
+            : { 'Authorization': `Bearer ${apiKey}` };
+        const res = await requestHttp(url, 'GET', headers, null);
+        if (res.status < 200 || res.status >= 300) {
+            throw new Error(`HTTP ${res.status}`);
+        }
+        const data = res.data?.data;
+        if (!Array.isArray(data) || data.length === 0) {
+            throw new Error('Provider returned an empty model list');
+        }
+        return data.map((m) => ({
+            id: m.id,
+            name: m.display_name || m.id,
+        }));
+    }
+    catch (e) {
+        console.warn(`Failed to list live models for ${provider.id}, using static list:`, e);
+        return provider.models;
+    }
+}
+export async function testConnection(providerId, apiKey, config) {
+    const providers = await fetchProviders(config);
+    const provider = providers.find(p => p.id === providerId);
+    if (!provider)
+        throw new Error('Unknown provider');
+    const liveModels = await listModels(provider, apiKey);
+    const testModel = liveModels[0]?.id;
+    if (!testModel)
+        throw new Error('No models found for provider');
+    const resText = await invokeProvider(provider, testModel, apiKey, "Hello, reply with one word: OK", "Connection test verification.");
+    return resText.trim().length > 0;
+}
+export function mockActiveCallsList(calls) {
+    activeCalls.clear();
+    calls.forEach((c, idx) => activeCalls.set(`mock-${idx}`, c));
+    notifySubscribers();
+}

package/dist/ai/commands.d.ts

@@ -0,0 +1,12 @@
+export type CommandType = 'scene' | 'character' | 'dialogue' | 'parenthetical' | 'transition' | 'lyrics' | 'action' | 'literal' | 'plain';
+export interface CommandDefinition {
+    type: CommandType;
+    keywords: string[];
+}
+export declare const LOCALIZED_COMMANDS: Record<string, CommandDefinition[]>;
+export interface ParsedVoiceResult {
+    type: CommandType | 'action';
+    text: string;
+    isLiteral: boolean;
+}
+export declare function parseVoiceCommand(transcript: string, langCode: string): ParsedVoiceResult;

package/dist/ai/commands.js

@@ -0,0 +1,140 @@
+export const LOCALIZED_COMMANDS = {
+    en: [
+        { type: 'literal', keywords: ['literal', 'plain', 'bypass'] },
+        { type: 'scene', keywords: ['new scene', 'scene heading', 'scene'] },
+        { type: 'character', keywords: ['character name', 'character', 'char'] },
+        { type: 'dialogue', keywords: ['dialogue', 'dialog', 'says'] },
+        { type: 'parenthetical', keywords: ['parenthetical', 'bracket', 'brackets'] },
+        { type: 'transition', keywords: ['transition', 'fade out', 'fade in', 'cut to'] },
+        { type: 'lyrics', keywords: ['lyrics', 'sing lyrics', 'song'] },
+        { type: 'action', keywords: ['action description', 'action'] },
+    ],
+    hi: [
+        { type: 'literal', keywords: ['शब्दशः', 'वास्तविक', 'प्लेन'] },
+        { type: 'scene', keywords: ['नया दृश्य', 'दृश्य'] },
+        { type: 'character', keywords: ['पात्र नाम', 'पात्र', 'चरित्र'] },
+        { type: 'dialogue', keywords: ['संवाद', 'बोलता है', 'बोलती है'] },
+        { type: 'parenthetical', keywords: ['कोष्ठक', 'ब्रैकेट'] },
+        { type: 'transition', keywords: ['बदलाव', 'कट टू'] },
+        { type: 'lyrics', keywords: ['गीत', 'गाना'] },
+        { type: 'action', keywords: ['विवरण', 'एक्शन'] },
+    ],
+    ta: [
+        { type: 'literal', keywords: ['உண்மையான', 'வார்த்தை', 'நேரடி'] },
+        { type: 'scene', keywords: ['புதிய காட்சி', 'காட்சி'] },
+        { type: 'character', keywords: ['கதாபாத்திரம் பெயர்', 'கதாபாத்திரம்'] },
+        { type: 'dialogue', keywords: ['வசனம்', 'பேசுகிறார்'] },
+        { type: 'parenthetical', keywords: ['அடைப்புக்குறி', 'பிராக்கெட்'] },
+        { type: 'transition', keywords: ['மாற்றம்', 'கட் டூ'] },
+        { type: 'lyrics', keywords: ['பாடல்', 'பாட்டு'] },
+        { type: 'action', keywords: ['செயல்', 'விளக்கம்'] },
+    ],
+    te: [
+        { type: 'literal', keywords: ['యథార్థం', 'సాధారణ'] },
+        { type: 'scene', keywords: ['కొత్త సన్నివేశం', 'సన్నివేశం'] },
+        { type: 'character', keywords: ['పాత్ర పేరు', 'పాత్ర'] },
+        { type: 'dialogue', keywords: ['సంభాషణ', 'మాట్లాడు'] },
+        { type: 'parenthetical', keywords: ['బ్రాకెట్', 'వరణము'] },
+        { type: 'transition', keywords: ['మార్పు', 'కట్ టు'] },
+        { type: 'lyrics', keywords: ['పాట', 'గీతం'] },
+        { type: 'action', keywords: ['చర్య', 'వివరణ'] },
+    ],
+    ml: [
+        { type: 'literal', keywords: ['യഥാർത്ഥ', 'സാധാരണ'] },
+        { type: 'scene', keywords: ['പുതിയ രംഗം', 'രംഗം'] },
+        { type: 'character', keywords: ['കഥാപാത്രം പേര്', 'കഥാപാത്രം'] },
+        { type: 'dialogue', keywords: ['സംഭാഷണം', 'പറയുന്നു'] },
+        { type: 'parenthetical', keywords: ['ബ്രാക്കറ്റ്'] },
+        { type: 'transition', keywords: ['മാറ്റം', 'കട്ട് ടു'] },
+        { type: 'lyrics', keywords: ['പാട്ട്', 'ഗാനം'] },
+        { type: 'action', keywords: ['പ്രവർത്തി', 'വിവരണം'] },
+    ],
+    kn: [
+        { type: 'literal', keywords: ['ನಿಜವಾದ', 'ಸಾಮಾನ್ಯ'] },
+        { type: 'scene', keywords: ['ಹೊಸ ದೃಶ್ಯ', 'ದೃಶ್ಯ'] },
+        { type: 'character', keywords: ['ಪಾತ್ರ ಹೆಸರು', 'ಪಾತ್ರ'] },
+        { type: 'dialogue', keywords: ['ಸಂಭಾಷಣೆ', 'ಹೇಳುತ್ತದೆ'] },
+        { type: 'parenthetical', keywords: ['ವರಣಚಿಹ್ನೆ', 'ಬ್ರಾಕೆಟ್'] },
+        { type: 'transition', keywords: ['ಬದಲಾವಣೆ', 'ಕಟ್ ಟು'] },
+        { type: 'lyrics', keywords: ['ಹಾಡು', 'ಗೀತೆ'] },
+        { type: 'action', keywords: ['ಕ್ರಿಯೆ', 'ವಿವರಣೆ'] },
+    ],
+    bn: [
+        { type: 'literal', keywords: ['আক্ষরিক', 'সাধারণ'] },
+        { type: 'scene', keywords: ['নতুন দৃশ্য', 'দৃশ্য'] },
+        { type: 'character', keywords: ['চরিত্রের নাম', 'চরিত্র'] },
+        { type: 'dialogue', keywords: ['সংলাপ', 'বলে'] },
+        { type: 'parenthetical', keywords: ['বন্ধনী', 'ব্র্যাকেট'] },
+        { type: 'transition', keywords: ['পরিবর্তন', 'কাট টু'] },
+        { type: 'lyrics', keywords: ['গান', 'গীতি'] },
+        { type: 'action', keywords: ['ক্রিয়া', 'বর্ণনা'] },
+    ],
+    gu: [
+        { type: 'literal', keywords: ['શાબ્દિક', 'સામાન્ય'] },
+        { type: 'scene', keywords: ['નવું દ્રશ્ય', 'દ્રશ્ય'] },
+        { type: 'character', keywords: ['પાત્રનું નામ', 'પાત્ર'] },
+        { type: 'dialogue', keywords: ['સંવાદ', 'બોલે છે'] },
+        { type: 'parenthetical', keywords: ['કૌંસ', 'બ્રેકેટ'] },
+        { type: 'transition', keywords: ['પરિવર્તન', 'કટ ટુ'] },
+        { type: 'lyrics', keywords: ['ગીત', 'ગાણું'] },
+        { type: 'action', keywords: ['ક્રિયા', 'વર્ણન'] },
+    ],
+    mr: [
+        { type: 'literal', keywords: ['शाब्दिक', 'साधे'] },
+        { type: 'scene', keywords: ['नवीन दृश्य', 'दृश्य'] },
+        { type: 'character', keywords: ['पात्राचे नाव', 'पात्र'] },
+        { type: 'dialogue', keywords: ['संवाद', 'बोलतो', 'बोलते'] },
+        { type: 'parenthetical', keywords: ['कंसात', 'ब्रॅकेट'] },
+        { type: 'transition', keywords: ['बदल', 'कट टू'] },
+        { type: 'lyrics', keywords: ['गाणे', 'गीत'] },
+        { type: 'action', keywords: ['कृती', 'वर्णन'] },
+    ],
+};
+export function parseVoiceCommand(transcript, langCode) {
+    const normText = transcript.trim();
+    // Get language mapping, default to English if not found
+    const baseLang = langCode.split('-')[0] || 'en';
+    const defs = LOCALIZED_COMMANDS[baseLang] || LOCALIZED_COMMANDS.en;
+    // 1. Check for literal bypass sequence
+    const literalDef = defs.find(d => d.type === 'literal');
+    if (literalDef) {
+        for (const kw of literalDef.keywords) {
+            if (normText.toLowerCase().startsWith(kw + ' ')) {
+                return {
+                    type: 'action',
+                    text: normText.substring(kw.length + 1).trim(),
+                    isLiteral: true,
+                };
+            }
+        }
+    }
+    // 2. Scan other formatting keywords
+    for (const def of defs) {
+        if (def.type === 'literal')
+            continue;
+        for (const kw of def.keywords) {
+            // Check if text starts with the keyword followed by space or is exactly the keyword
+            const prefix = kw + ' ';
+            if (normText.toLowerCase().startsWith(prefix)) {
+                return {
+                    type: def.type,
+                    text: normText.substring(kw.length + 1).trim(),
+                    isLiteral: false,
+                };
+            }
+            else if (normText.toLowerCase() === kw) {
+                return {
+                    type: def.type,
+                    text: '',
+                    isLiteral: false,
+                };
+            }
+        }
+    }
+    // 3. Fallback to default action text
+    return {
+        type: 'action',
+        text: normText,
+        isLiteral: false,
+    };
+}