primocode 11.0.0 → 11.2.0

package/lib/video/ops.js

@@ -1,384 +0,0 @@
-/**
- * ops.js — as operações do editor, uma por nome, com o texto de ajuda junto.
- *
- * O texto de ajuda mora AO LADO da operação de propósito: é ele que o modelo
- * lê (`primocode video help`) para saber o que existe, e ajuda escrita
- * noutro arquivo envelhece diferente do código. Cada linha é curta, com a
- * unidade de cada número — quadro na linha do tempo, segundo na origem.
- *
- * Toda operação que MUDA o projeto passa por `mutar`: foto de antes, edição,
- * validação, gravação, delta. Se qualquer passo falha, nada é gravado — um
- * add_clips de dez clipes com um errado não deixa nove pela metade.
- */
-
-'use strict';
-
-const T = require('./timeline.js');
-const E = require('./edits.js');
-const F = require('./filters.js');
-const { diff } = require('./delta.js');
-const P = require('./projeto.js');
-const TR = require('./transcript.js');
-const A = require('./analise.js');
-
-const r = () => require('./render.js');   // só carrega o ffmpeg quando precisa
-
-const lista = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
-
-/** Os clipes que a operação pediu: ids, id, ou "all" (todos os visuais). */
-function alvos(tl, args, { tipos = ['video', 'image'] } = {}) {
-    const refs = lista(args.ids !== undefined ? args.ids : args.id);
-    if (!refs.length) throw T.erro('faltou "ids" (ou "all")');
-    if (refs.length === 1 && (refs[0] === 'all' || refs[0] === '*')) {
-        return T.todosOsClipes(tl).filter((x) => tipos.includes(x.clip.type)).map((x) => x.clip.id);
-    }
-    return refs.map((ref) => T.achar(tl, ref).clip.id);
-}
-
-async function mutar(ctx, op, fn) {
-    const antes = T.clone(ctx.tl);
-    const extra = (await fn(ctx.tl)) || {};
-    T.ordenar(ctx.tl);
-    const probs = T.problemas(ctx.tl);
-    if (probs.length) throw T.erro(`edição recusada (nada mudou): ${probs.slice(0, 4).join('; ')}`);
-    P.fotografar(ctx.p, antes, op);
-    P.salvar(ctx.p, ctx.tl);
-    const d = diff(antes, ctx.tl, extra);
-    P.anotar(ctx.p, op, { dur: d.dur, added: (d.added || []).length, removed: (d.removed || []).length });
-    return d;
-}
-
-function precisaProjeto(ctx) {
-    if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."} (cria o projeto) ou new');
-}
-
-// ── as operações ─────────────────────────────────────────────────────────
-
-const OPS = {
-    new: {
-        uso: 'new {name?,width?:1080,height?:1920,fps?:30} — cria projeto em ./video/<id>/ e o torna atual',
-        async run(ctx, a) {
-            const { p, tl } = P.criar({ nome: a.name, width: a.width, height: a.height, fps: a.fps });
-            return { ok: true, project: p.id, dir: p.dir, fps: tl.fps, size: `${tl.width}x${tl.height}` };
-        },
-    },
-    open: {
-        uso: 'open {id} | list {} — troca de projeto / lista os projetos desta pasta',
-        async run(ctx, a) {
-            const x = P.abrir(a.id);
-            if (!x) throw T.erro(`não há projeto "${a.id}"`);
-            P.usar(x.p.id);
-            return { ok: true, project: x.p.id, ...T.vista(x.tl) };
-        },
-    },
-    list: { oculto: true, async run() { return { ok: true, current: P.atual(), projects: P.listar() }; } },
-    import: {
-        uso: 'import {path|paths[],track?,at?,from?,to?,noClip?} — mídia vira asset + clipe no fim da faixa (sem projeto, cria um do tamanho do vídeo)',
-        async run(ctx, a) {
-            const caminhos = lista(a.paths || a.path);
-            if (!caminhos.length) throw T.erro('faltou "path"');
-            if (!ctx.tl) {
-                const probe = await r().medirAsset(T.novo(), caminhos[0]);
-                const vert = probe.width && probe.height;
-                const x = P.criar({ nome: a.name || probe.nome.replace(/\.[^.]+$/, ''),
-                    width: a.width || (vert ? probe.width : 1080), height: a.height || (vert ? probe.height : 1920),
-                    fps: a.fps || (probe.fps ? Math.min(60, Math.round(probe.fps)) : 30) });
-                Object.assign(ctx, x);
-            }
-            const medidos = [];
-            for (const c of caminhos) medidos.push(await r().medirAsset(ctx.tl, c));
-            return mutar(ctx, 'import', (tl) => {
-                for (const m of medidos) {
-                    m.id = T.novoAssetId(tl);
-                    tl.assets[m.id] = m;
-                    if (!a.noClip) E.adicionar(tl, { asset: m.id, track: a.track, at: a.at, from: a.from, to: a.to });
-                }
-                return { project: ctx.p.id };
-            });
-        },
-    },
-    get_timeline: {
-        uso: 'get_timeline {from?,to?} — o projeto compacto (só o que não é padrão). src=[s,s] segundos da origem',
-        async run(ctx, a) { precisaProjeto(ctx); return { ok: true, project: ctx.p.id, ...T.vista(ctx.tl, a) }; },
-    },
-    inspect: {
-        uso: 'inspect {frames:[f..]|at:f} — renderiza os quadros com grade 0–1 + nº do quadro numa folha PNG (abra e OLHE)',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const d = T.duracao(ctx.tl);
-            const frames = a.frames ? lista(a.frames) : a.at !== undefined ? [a.at] : [0, Math.floor(d / 2), d - 1];
-            return r().inspecionar(ctx.p.dir, ctx.tl, { frames, escala: a.scale || 0.5, out: a.out });
-        },
-    },
-    get_transcript: {
-        uso: 'get_transcript {asset?,from?,to?,force?} — palavras [i,texto,f,e] em QUADROS da timeline atual; i é estável entre edições',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const asset = T.acharAsset(ctx.tl, a.asset);
-            const t = await TR.obter(ctx.p.dir, asset, { force: a.force, idioma: a.lang || 'pt' });
-            if (!t.ok) return t;
-            const mapa = TR.mapear(ctx.tl, asset.id, t.palavras)
-                .filter((w) => w.e > (a.from || 0) && w.f < (a.to === undefined ? Infinity : a.to));
-            return { ok: true, asset: asset.id, fonte: t.fonte, total: t.palavras.length, onTimeline: mapa.length, words: mapa.map((w) => [w.i, w.texto, w.f, w.e]) };
-        },
-    },
-    add_clips: {
-        uso: 'add_clips {clips:[{asset,track?,at?,from?,to?|dur?,...props}]} — lote atômico (tudo ou nada)',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            return mutar(ctx, 'add_clips', (tl) => { lista(a.clips).forEach((c) => E.adicionar(tl, c)); });
-        },
-    },
-    insert: {
-        uso: 'insert {asset|type:"text",at,from?,to?|dur?,track?,rippleTracks?} — insere empurrando tudo depois de at (ripple)',
-        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'insert', (tl) => { E.inserir(tl, a); }); },
-    },
-    move: {
-        uso: 'move {id,to?(quadro),track?(índice|"new")} — move sem ripple (sobrepor na mesma faixa é recusado)',
-        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'move', (tl) => { E.mover(tl, a.id, a); }); },
-    },
-    remove: {
-        uso: 'remove {ids,ripple?:false} — apaga clipes; ripple fecha o buraco se nenhuma faixa usa o trecho',
-        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'remove', (tl) => { E.remover(tl, lista(a.ids || a.id), { ripple: a.ripple }); }); },
-    },
-    split: {
-        uso: 'split {id,at(quadro da timeline)} — divide em dois',
-        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'split', (tl) => { E.dividir(tl, a.id, a.at); }); },
-    },
-    ripple_delete_ranges: {
-        uso: 'ripple_delete_ranges {ranges:[[de,ate],..](quadros, ate exclusivo),tracks?} — apaga trechos em todas as faixas e fecha',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            return mutar(ctx, 'ripple_delete_ranges', (tl) => E.apagarTrechos(tl, lista(a.ranges), { tracks: a.tracks }));
-        },
-    },
-    remove_silence: {
-        uso: 'remove_silence {asset?,threshold?:-35(dB),minSilence?:0.5(s),padding?:0.15(s),dryRun?} — silencedetect → ripple',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const asset = T.acharAsset(ctx.tl, a.asset);
-            const sil = await r().silenciosDe(ctx.p.dir, asset, { threshold: a.threshold ?? -35, minSilence: a.minSilence ?? 0.5 });
-            const clipes = T.todosOsClipes(ctx.tl).map((x) => x.clip).filter((c) => c.asset === asset.id);
-            const ranges = A.trechosDeSilencio(ctx.tl, clipes, { [asset.id]: sil }, { padding: a.padding ?? 0.15 });
-            if (a.dryRun) return { ok: true, silences: sil.length, ranges: E.juntar(ranges) };
-            return mutar(ctx, 'remove_silence', (tl) => ({ silences: sil.length, ...E.apagarTrechos(tl, ranges) }));
-        },
-    },
-    remove_words: {
-        uso: 'remove_words {words:[i..],asset?} — apaga as palavras (índices do get_transcript) com ripple',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const asset = T.acharAsset(ctx.tl, a.asset);
-            const t = await TR.obter(ctx.p.dir, asset);
-            if (!t.ok) return t;
-            const { ranges, faltou } = E.trechosDasPalavras(TR.mapear(ctx.tl, asset.id, t.palavras), lista(a.words));
-            if (!ranges.length) throw T.erro('nenhuma dessas palavras está na timeline');
-            return mutar(ctx, 'remove_words', (tl) => ({ ...E.apagarTrechos(tl, ranges), ...(faltou.length ? { notOnTimeline: faltou } : {}) }));
-        },
-    },
-    set_clip_properties: {
-        uso: 'set_clip_properties {ids|"all",props:{volume,opacity,speed,fadeIn,fadeOut(quadros),dur,cx,cy,w,h,rotation,crop{l,t,r,b},fit(cover|contain|stretch),hidden,content,style,animation}}',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            return mutar(ctx, 'set_clip_properties', (tl) => { E.propriedades(tl, alvos(tl, a, { tipos: ['video', 'image', 'audio', 'text'] }), a.props || {}); });
-        },
-    },
-    set_keyframes: {
-        uso: 'set_keyframes {id,prop(zoom|fx|fy|cx|cy|rotation|opacity|volume),keys:[{frame(timeline),value,interp?:ease|linear|hold}]} — keys:[] limpa',
-        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'set_keyframes', (tl) => { E.keyframes(tl, a.id, a.prop, a.keys); }); },
-    },
-    apply_layout: {
-        uso: `apply_layout {layout(${E.LAYOUTS.join('|')}),ids:[principal,..],size?:0.34} — posiciona (transform 0–1)`,
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            return mutar(ctx, 'apply_layout', (tl) => { const av = E.layout(tl, a.layout, lista(a.ids), a); return av.length ? { avisos: av } : {}; });
-        },
-    },
-    add_texts: {
-        uso: 'add_texts {texts:[{content,at,dur(quadros),cx?,cy?,w?,animation?,style?}]} — títulos/letreiros',
-        async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'add_texts', (tl) => { E.textos(tl, lista(a.texts)); }); },
-    },
-    add_captions: {
-        uso: 'add_captions {asset?,maxWords?:3,animation?:highlightPop,cy?:0.72,style?} — legenda da transcrição, já nos cortes atuais (refazer substitui)',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const asset = T.acharAsset(ctx.tl, a.asset);
-            const t = await TR.obter(ctx.p.dir, asset);
-            if (!t.ok) return t;
-            // o que vale conferir vai junto da resposta: o modelo repete pra pessoa, com o tempo de cada palavra
-            const CL = require('./conferir-legenda.js');
-            const mapa = TR.mapear(ctx.tl, asset.id, t.palavras);
-            // o tempo é o do vídeo editado (depois dos cortes), não o da gravação: é onde a pessoa vai procurar
-            const conferir = CL.texto(CL.duvidosas(mapa.map((w) => ({ texto: w.texto, de: T.segundos(ctx.tl, w.f), p: t.palavras[w.i].p }))));
-            return mutar(ctx, 'add_captions', (tl) => ({ captions: E.legendas(tl, TR.mapear(tl, asset.id, t.palavras), a).length, ...(conferir ? { conferir } : {}) }));
-        },
-    },
-    apply_color: {
-        // Fora da ajuda (13/10): o `grade` mede e escolhe sozinho; este, de número à mão, segue funcionando.
-        oculto: true,
-        uso: `apply_color {ids|"all",preset?(${Object.keys(F.PRESETS_COR).join('|')}),exposure,contrast,saturation,temperature,tint(-1..1),gamma}`,
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const ef = F.efeitoDeCor(a);
-            return mutar(ctx, 'apply_color', (tl) => {
-                for (const id of alvos(tl, a)) { const { clip } = T.achar(tl, id); clip.effects = clip.effects.filter((e) => e.type !== 'color.adjust').concat(ef); }
-            });
-        },
-    },
-    /* O COLOR GRADING SOZINHO (cor.js, 13/10): mede cada mídia, corrige a
-       exposição e a dominante e põe o look de cinema — sem número chutado.
-       Troca o apply_color/grade que o clipe tinha. */
-    grade: {
-        uso: `grade {ids?|"all",look?(${require('./cor.js').LOOKS.join('|')}; sem: a imagem escolhe),intensidade?:0.8} — color grading de cinema medido do vídeo; depois inspect e OLHE`,
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const C = require('./cor.js');
-            const ids = alvos(ctx.tl, { ...a, ids: a.ids || 'all' }).filter((id) => { const { clip } = T.achar(ctx.tl, id); return clip.asset && ctx.tl.assets[clip.asset] && clip.type !== 'audio'; });
-            const porAsset = {};
-            for (const id of ids) {
-                const { clip } = T.achar(ctx.tl, id);
-                if (porAsset[clip.asset]) continue;
-                const asset = ctx.tl.assets[clip.asset];
-                const m = await C.medir(asset.path);
-                if (!m.ok) return m;
-                const look = C.LOOKS.includes(a.look) ? a.look : C.escolherLook(m);
-                porAsset[clip.asset] = { look, ...C.correcao(m), intensidade: a.intensidade != null ? Number(a.intensidade) : 0.8 };
-            }
-            const r = await mutar(ctx, 'grade', (tl) => {
-                for (const id of ids) {
-                    const { clip } = T.achar(tl, id);
-                    const params = porAsset[clip.asset];
-                    if (params) clip.effects = (clip.effects || []).filter((e) => e.type !== 'color.adjust' && e.type !== 'color.cine').concat({ type: 'color.cine', params });
-                }
-            });
-            return { ...r, grade: porAsset };
-        },
-    },
-    apply_effect: {
-        uso: `apply_effect {ids|"all",type(${Object.keys(F.EFEITOS).filter((k) => k !== 'color.adjust').join('|')}),params?,remove?:true}`,
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const ef = { type: a.type, params: a.params || {} };
-            if (!a.remove) F.filtrosDoEfeito(ef);
-            return mutar(ctx, 'apply_effect', (tl) => {
-                for (const id of alvos(tl, a)) {
-                    const { clip } = T.achar(tl, id);
-                    clip.effects = clip.effects.filter((e) => e.type !== a.type);
-                    if (!a.remove) clip.effects.push(ef);
-                }
-            });
-        },
-    },
-    detect_beats: {
-        uso: 'detect_beats {asset,sensitivity?:1.4,markers?:false} — batidas em quadros da timeline (+bpm); markers:true grava marcadores',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const asset = T.acharAsset(ctx.tl, a.asset);
-            const taxa = 22050;
-            const b = A.batidas(await r().amostras(asset.path, taxa), taxa, { sensibilidade: a.sensitivity || 1.4 });
-            const clipes = T.todosOsClipes(ctx.tl).map((x) => x.clip).filter((c) => c.asset === asset.id);
-            const quadros = clipes.length
-                ? [...new Set(clipes.flatMap((c) => b.beats.map((s) => T.origemParaQuadro(ctx.tl, c, s)).filter((f) => f !== null)))].sort((x, y) => x - y)
-                : b.beats.map((s) => T.quadros(ctx.tl, s));
-            const res = { bpm: b.bpm, count: quadros.length, beats: quadros.slice(0, 300) };
-            if (!a.markers) return { ok: true, ...res };
-            return mutar(ctx, 'detect_beats', (tl) => {
-                tl.markers = tl.markers.filter((m) => m.label !== 'beat').concat(quadros.map((f) => ({ frame: f, label: 'beat' })));
-                return res;
-            });
-        },
-    },
-    undo: {
-        uso: 'undo {steps?:1} — volta edições (cada edição guarda foto; edite sem pedir licença)',
-        async run(ctx, a) {
-            precisaProjeto(ctx);
-            const antes = ctx.tl;
-            const u = P.desfazer(ctx.p, a.steps || 1);
-            P.salvar(ctx.p, u.tl);
-            ctx.tl = u.tl;
-            return diff(antes, u.tl, { undone: u.desfeitas, left: u.restam });
-        },
-    },
-    export: {
-        uso: 'export {out?,from?,to?(quadros),preview?:false(meia resolução),crf?:20} — renderiza o mp4',
-        async run(ctx, a) { precisaProjeto(ctx); return r().exportar(ctx.p.dir, ctx.tl, a); },
-    },
-};
-
-// Os efeitos que seguem a pessoa (rastro, camadas, objetos 3D, legenda na cabeça) e o pedido em português.
-const FXO = require('./ops-fx.js');
-const PED = require('./pedido.js');
-const AUTO = require('./auto.js');
-const ZOOM = require('./zoom.js');   // o zoom que segue o cursor (gravação de tela): fica na ajuda principal
-Object.assign(OPS, FXO.OPS, PED.OPS, AUTO.OPS, ZOOM.OPS);
-
-const ALIAS = { timeline: 'get_timeline', transcript: 'get_transcript', captions: 'add_captions', texts: 'add_texts', render: 'export', pedido: 'do', analyze: 'track' };
-
-// Um exemplo por operação: o modelo copia a forma, e não inventa a chave.
-const EX = {
-    new: '{"name":"aula","width":1920,"height":1080,"fps":30}',
-    open: '{"id":"2026-09-29-aula"}',
-    import: '{"path":"gravacao.mp4"}',
-    get_timeline: '{"from":0,"to":300}',
-    inspect: '{"frames":[0,150,299]}',
-    get_transcript: '{"from":0,"to":600}',
-    add_clips: '{"clips":[{"asset":"a2","track":"new","at":90,"from":2.5,"to":6}]}',
-    insert: '{"asset":"a2","at":120,"from":0,"to":3}',
-    move: '{"id":"3f2a","to":240,"track":"new"}',
-    remove: '{"ids":["3f2a"],"ripple":true}',
-    split: '{"id":"3f2a","at":180}',
-    ripple_delete_ranges: '{"ranges":[[120,150],[400,410]]}',
-    remove_silence: '{"padding":0.12,"minSilence":0.4}',
-    remove_words: '{"words":[12,13,14]}',
-    set_clip_properties: '{"ids":["3f2a"],"props":{"volume":0.3,"fadeIn":15,"opacity":0.9}}',
-    set_keyframes: '{"id":"3f2a","prop":"zoom","keys":[{"frame":60,"value":1},{"frame":64,"value":1.2}]}',
-    apply_layout: '{"layout":"pip_br","ids":["<fala>","<broll>"]}',
-    add_texts: '{"texts":[{"content":"3 DICAS","at":0,"dur":60,"cy":0.2,"animation":"popIn","style":{"bg":"#E11D48"}}]}',
-    add_captions: '{"maxWords":3,"animation":"highlightPop","style":{"upper":true}}',
-    apply_color: '{"ids":"all","preset":"warm","contrast":0.1}',
-    apply_effect: '{"ids":["3f2a"],"type":"stylize.vignette","params":{"strength":0.6}}',
-    detect_beats: '{"asset":"a3","markers":true}',
-    undo: '{"steps":2}',
-    export: '{"out":"final.mp4"}',
-};
-
-const EFEITOS = new Set([...Object.keys(FXO.OPS), ...Object.keys(PED.OPS), ...Object.keys(AUTO.OPS)]);
-
-/* A ajuda principal fica curta (o modelo a lê inteira a cada tarefa): os
-   efeitos entram num resumo de três linhas, e o detalhe em `help efeitos`. */
-function ajuda(secao) {
-    Object.assign(EX, FXO.EX, PED.EX, AUTO.EX, ZOOM.EX);
-    const linha = (nome, o, linhas) => {
-        linhas.push('  ' + o.uso);
-        if (EX[nome]) linhas.push(`      ex: primocode video ${nome} --json '${EX[nome]}'`);
-    };
-    if (secao === 'efeitos' || secao === 'fx') {
-        const linhas = ['EFEITOS QUE SEGUEM A PESSOA — o rastro (MediaPipe) roda 1x por mídia, em paralelo; o 3D renderiza no export (Remotion).',
-            'Momentos: um quadro, "snap" (o estalo do áudio), "junta"/"abre" (as mãos) ou "palavra:<texto>" (quando é dito).',
-            'Receitas em segundos da ORIGEM: cortar silêncio depois não desalinha nada. hand left/right = lado da TELA.'];
-        for (const nome of EFEITOS) linha(nome, OPS[nome], linhas);
-        return linhas.join('\n');
-    }
-    const linhas = [
-        "primocode video <op> [--json '{...}'] [--project <id>]   — editor de vídeo por linha do tempo (ffmpeg)",
-        'UNIDADES: posição/duração na timeline = QUADROS inteiros (fps do projeto); from/to da mídia = SEGUNDOS da origem.',
-        'Faixa 0 = a de cima. cx,cy,w,h em 0–1 do quadro (cx,cy = centro). Clipe por id curto ou prefixo único. Mídia: a1, a2…',
-        'Toda edição devolve um DELTA (added/removed/changed/shifted[{by,ids}]/dur) e é desfeita com undo — não peça licença.',
-        'Saída: 1 linha JSON no stdout (ok:false + error se falhou). Depois de editar, use inspect e OLHE o png.',
-    ];
-    for (const [nome, o] of Object.entries(OPS)) {
-        if (o.oculto || EFEITOS.has(nome)) continue;
-        linha(nome, o, linhas);
-    }
-    linhas.push(
-        'Texto: animation none|fade|popIn|typewriter|wordReveal|highlightPop; style {size(0–1 da altura),color,stroke,',
-        '  strokeWidth,highlight,bg,upper,font(bold|black|regular|caminho .ttf),align}.',
-        'EFEITOS (recorte, fundo no estalo, logo 3D na mão, cérebro, legenda na cabeça) — detalhe: primocode video help efeitos',
-        '  track · separate_layers{show3d} · replace_background{with,at:"snap"} · attach_3d{object,hand} · merge_on_join · cut_silence_at · style_captions{color,position:"above_head"}',
-        `  do {pedido:"<português>"} — ex.: primocode video do --json '{"pedido":"quando eu estalar o dedo me coloca numa praia"}'`,
-        `  auto {} — O VÍDEO É O PEDIDO: lê o que a pessoa fala na gravação e aplica cada efeito no momento em que ela diz. "Edite esse vídeo" sem dizer o quê: import e auto`,
-    );
-    return linhas.join('\n');
-}
-
-module.exports = { OPS, ALIAS, ajuda, mutar, alvos };

package/lib/video/pedido.js

@@ -1,191 +0,0 @@
-/**
- * pedido.js — `primocode video do {"pedido":"..."}`: o pedido em português
- * vira operações do editor, por REGRA (palavras-chave), sem modelo.
- *
- *   "Tira o fundo e separa em camadas. Quando eu estalar o dedo me coloca
- *    numa praia. Põe o logo do ChatGPT na minha mão, e o do Claude nessa.
- *    Quando eu juntar as mãos vira um cérebro. Corta o silêncio depois do
- *    estalo. A legenda eu quero azul, em cima da minha cabeça."
- *
- * Por que regra e não o modelo: o modelo que dirige o editor pode ser um
- * modelo grátis e pequeno. O pedido comum ("legenda azul") tem que dar
- * certo sempre, igual, em milissegundos — e o que a regra não entende volta
- * como "não entendi" com os exemplos, para o modelo usar as operações à mão.
- *
- * `interpretar` é pura (o teste roda cada frase); `do` executa o plano,
- * adiantando EM PARALELO o que é lento e independente (rastreio e
- * transcrição) antes do primeiro passo.
- */
-
-'use strict';
-
-const C = require('./camadas.js');
-
-const tira = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
-
-const LUGARES = ['praia', 'espaco', 'cidade', 'floresta', 'montanha', 'escritorio', 'deserto', 'neve', 'por do sol', 'paris', 'nova york', 'mar'];
-const NOMES_COR = Object.keys(C.CORES).filter((k) => !/[^a-z ]/.test(k)).sort((a, b) => b.length - a.length);
-
-/** A cor PEDIDA: ignora a que só descreve o estado atual ("ela está amarela"). */
-function corPedida(t) {
-    const limpo = t.replace(/\b(esta|ta|e|era|estava|tava|ficou)\s+(\w+)/g, (m, v, w) => (NOMES_COR.includes(w) ? ' ' : m));
-    let melhor = null;
-    for (const nome of NOMES_COR) {
-        const m = new RegExp(`\\b${nome}\\b`).exec(limpo);
-        if (m && (melhor === null || m.index < melhor.i)) melhor = { i: m.index, nome };
-    }
-    return melhor && melhor.nome;
-}
-
-function lugar(t) {
-    for (const l of LUGARES) if (new RegExp(`\\b${l}\\b`).test(t)) return l;
-    const m = t.match(/\bfundo\s+(?:de|com|do|da|num|numa)\s+(?:um|uma\s+)?([a-z][a-z ]{2,30}?)(?=[,.;!?]|\s+e\s|\s+quando|$)/);
-    return m ? m[1].trim() : null;
-}
-
-/** Onde cada objeto é citado, em ordem, com a mão dita logo depois. */
-function objetosCitados(t) {
-    const out = [];
-    const re = /\b(chat ?gpt|gpt|openai|claude|anthropic|chrome|drive)\b|\blogo\s+d[aoe]s?\s+([a-z0-9]+)/g;
-    let m;
-    const todas = [];
-    while ((m = re.exec(t))) todas.push(m);
-    for (let k = 0; k < todas.length; k++) {
-        m = todas[k];
-        const nome = m[1] || m[2];
-        const modelo = C.modeloDe(nome);
-        if (!modelo && m[2] && /^(chat|gpt|claude)/.test(m[2])) continue;
-        if (out.some((o) => o.pos === m.index)) continue;
-        // A mão dita vale até a próxima citação: "ChatGPT na mão, e o do Claude nessa" — o "nessa" é do Claude.
-        const prox = todas.slice(k + 1).find((x) => x.index > m.index + m[0].length);
-        const depois = t.slice(m.index, Math.min(m.index + 70, prox ? prox.index : Infinity));
-        const mao = /\besquerd/.test(depois) ? 'left' : /\bdireit/.test(depois) ? 'right'
-            : /\b(nessa|nesta|outra|dessa|desta|nessa aqui|na outra)\b/.test(depois) ? 'other' : null;
-        if (modelo === 'cerebro') continue;
-        const item = { object: modelo || nome, pos: m.index, mao };
-        // "o logo do ChatGPT": a mesma citação casou duas vezes.
-        if (out.length && out[out.length - 1].object === item.object && m.index - out[out.length - 1].pos < 14) continue;
-        out.push(item);
-    }
-    return out;
-}
-
-/**
- * pedido → {passos:[{op,args}], avisos}. `ctx`: {temLegenda, objetos:[{modelo,mao}]}.
- */
-function interpretar(pedido, ctx = {}) {
-    const t = tira(pedido).replace(/\s+/g, ' ');
-    const passos = [];
-    const avisos = [];
-    const add = (op, args = {}) => passos.push({ op, args });
-
-    const camadas = /\bcamadas?\b|\b3d\b|tres dimens/.test(t);
-    const tiraFundo = /\b(tir\w*|remov\w*|apag\w*|recort\w*)\s+(?:o\s+|do\s+|meu\s+)?fundo\b|\brecort\w*\s+(?:eu|me|a pessoa)\b|\bme\s+recort/.test(t);
-    const estalo = /\bestal\w*|\bsnap\b|\bdedo\b/.test(t);
-    const onde = lugar(t);
-    const trocaFundo = !!onde && /\b(coloc\w*|poe|pon\w*|bot\w*|lev\w*|transport\w*|troc\w*|mud\w*|fundo|joga\w*)\b/.test(t);
-
-    if (camadas && /\bsepar\w*|camadas\b/.test(t)) add('separate_layers', { show3d: true });
-    else if (tiraFundo && !trocaFundo) add('separate_layers', {});
-
-    if (trocaFundo) add('replace_background', { with: onde, ...(estalo ? { at: 'snap' } : {}) });
-
-    const objs = objetosCitados(t);
-    let anteriores = (ctx.objetos || []).length;
-    for (const o of objs) {
-        const hand = o.mao || (anteriores > 0 ? 'other' : 'auto');
-        add('attach_3d', { object: o.object, hand });
-        anteriores++;
-    }
-
-    const cerebro = /\bcerebro\b|\bbrain\b/.test(t);
-    const juntar = /\bjunt\w*\s+(?:as\s+|minhas\s+)?maos\b|\bmaos\s+juntas\b|\bfund\w*\s+(?:os|as)\b|\bjunt\w*\s+(?:os|as)\s+(?:dois|duas|logos)\b/.test(t);
-    if (juntar || (cerebro && objs.length + (ctx.objetos || []).length)) add('merge_on_join', { then: cerebro ? 'brain' : 'none' });
-    else if (cerebro) add('attach_3d', { object: 'brain', hand: 'auto' });
-
-    if (/\b(cort\w*|tir\w*|remov\w*|apag\w*)\s+(?:o\s+|os\s+|esse\s+|aquele\s+)?silencios?\b/.test(t)) {
-        if (estalo) add('cut_silence_at', { event: 'snap' });
-        else add('remove_silence', {});
-    }
-
-    if (/\blegenda/.test(t)) {
-        const cor = corPedida(t);
-        let position = null;
-        if (/\b(em cima|acima|sobre|por cima|encima)\s+da\s+(?:minha\s+)?cabeca\b/.test(t)) position = 'above_head';
-        else if (/\b(embaixo|em baixo|rodape|parte de baixo|la embaixo)\b/.test(t)) position = 'bottom';
-        else if (/\b(no topo|la em cima|parte de cima)\b/.test(t)) position = 'top';
-        else if (/\b(no meio|no centro|centralizad)\w*/.test(t)) position = 'center';
-        const estilo = {};
-        if (cor) estilo.color = cor;
-        if (position) estilo.position = position;
-        if (!ctx.temLegenda) add('add_captions', {});
-        if (Object.keys(estilo).length) add('style_captions', estilo);
-        else if (ctx.temLegenda) avisos.push('a legenda já existe: diga a cor ou a posição (ex.: "legenda azul", "em cima da minha cabeça")');
-    }
-
-    return { passos, avisos };
-}
-
-const EXEMPLOS = [
-    'tira o fundo e separa em camadas', 'quando eu estalar o dedo me coloca numa praia', 'põe o logo do ChatGPT na minha mão',
-    'e o do Claude nessa', 'quando eu juntar as mãos vira um cérebro', 'corta o silêncio depois do estalo',
-    'essa legenda eu quero azul', 'quero a legenda em cima da minha cabeça',
-];
-
-const OPS = {
-    do: {
-        uso: 'do {pedido:"<português>",dryRun?} — ex.: "tira o fundo e separa em camadas", "quando eu estalar o dedo me coloca numa praia", "põe o logo do ChatGPT na minha mão", "o do Claude nessa", "quando eu juntar as mãos vira um cérebro", "corta o silêncio depois do estalo", "legenda azul em cima da minha cabeça"',
-        async run(ctx, a) {
-            const T = require('./timeline.js');
-            const pedido = a.pedido || a.request || a.texto;
-            if (!pedido) throw T.erro('faltou "pedido"');
-            const tl = ctx.tl;
-            const info = {
-                temLegenda: !!tl && T.todosOsClipes(tl).some((x) => x.clip.caption),
-                objetos: tl && tl.fx ? Object.values(tl.fx).flatMap((v) => v.objetos || []) : [],
-            };
-            const plano = interpretar(pedido, info);
-            if (!plano.passos.length) {
-                return { ok: false, error: 'não entendi o pedido (nenhuma regra casou)', exemplos: EXEMPLOS,
-                    dica: 'use as operações direto: primocode video help' };
-            }
-            const resumo = plano.passos.map((p) => ({ op: p.op, args: p.args }));
-            if (a.dryRun) return { ok: true, plano: resumo, ...(plano.avisos.length ? { avisos: plano.avisos } : {}) };
-            if (!tl) throw T.erro('nenhum projeto aberto: import {"path":"..."} primeiro');
-            const { OPS: TODAS } = require('./ops.js');
-            // O que é lento e não depende de nada roda JUNTO antes do primeiro passo.
-            const C2 = require('./camadas.js');
-            const asset = C2.base(tl);
-            const precisaRastro = plano.passos.some((p) => p.op !== 'add_captions' && p.op !== 'remove_silence');
-            const precisaFala = plano.passos.some((p) => ['add_captions', 'attach_3d', 'separate_layers'].includes(p.op));
-            const inicio = Date.now();
-            const [rs] = await Promise.all([
-                precisaRastro ? require('./rastrear.js').garantir(ctx.p.dir, asset) : null,
-                precisaFala && asset.hasAudio ? require('./transcript.js').obter(ctx.p.dir, asset).catch(() => null) : null,
-            ]);
-            if (rs && !rs.ok) return rs;
-            const feitos = [];
-            for (const p of plano.passos) {
-                const res = await TODAS[p.op].run(ctx, p.args);
-                feitos.push({ op: p.op, ...compacto(res) });
-                if (!res || res.ok === false) {
-                    return { ok: false, error: `o passo ${p.op} falhou: ${res && res.error}`, feitos, desfazer: feitos.length > 1 ? `undo {"steps":${feitos.length - 1}}` : null };
-                }
-            }
-            return { ok: true, plano: resumo, feitos, tookS: Math.round((Date.now() - inicio) / 100) / 10, ...(plano.avisos.length ? { avisos: plano.avisos } : {}),
-                depois: 'inspect para OLHAR; export renderiza o 3D (Remotion) na primeira vez' };
-        },
-    },
-};
-
-/** O que importa de cada passo, numa linha (o delta inteiro de cada um encheria o contexto). */
-function compacto(res) {
-    if (!res) return { ok: false };
-    const o = { ok: res.ok !== false };
-    for (const k of ['layers', 'show3d', 'background', 'object', 'merge', 'silence', 'removedFrames', 'captions', 'color', 'follow', 'dur', 'error']) if (res[k] !== undefined) o[k] = res[k];
-    return o;
-}
-
-const EX = { do: '{"pedido":"quando eu estalar o dedo me coloca numa praia"}' };
-
-module.exports = { interpretar, corPedida, objetosCitados, lugar, OPS, EX, EXEMPLOS };