primocode 11.0.0 → 11.2.0

package/lib/plugin/video/zoom.js

@@ -0,0 +1,275 @@
+/**
+ * zoom.js — o zoom que segue o cursor numa gravação de tela.
+ *
+ * Três peças, como conta pura e testável sem vídeo nenhum:
+ *
+ *   · os FOCOS: o clique, quando há registro dele; sem clique, o lugar onde
+ *     o movimento PARA (o cursor anda, assenta e alguém vai clicar ali);
+ *   · os TRECHOS: focos próximos no tempo viram um zoom só; uma pausa longa
+ *     ou um salto para longe (com tempo de sobra) fecham o zoom e abrem outro;
+ *   · a CÂMERA: dentro do trecho ela fica parada enquanto o cursor anda numa
+ *     zona morta no meio da vista, e só anda quando ele sai dali — puxada por
+ *     uma mola criticamente amortecida, sem tremer e sem passar do ponto.
+ *
+ * Reimplementação independente da ideia (curva, regra de clique e mola):
+ * nenhuma linha vem de outro projeto.
+ *
+ * Saída: keyframes de zoom e do FOCO do zoom (fx, fy: 0–1 do clipe), que o
+ * filters.js já sabe desenhar no zoompan.
+ */
+
+'use strict';
+
+const { spawn } = require('child_process');
+
+const lim = (v, a, b) => Math.max(a, Math.min(b, v));
+
+// ── medir: onde a tela mexeu (quando ninguém gravou o cursor) ────────────
+
+/**
+ * Quadros cinza (Uint8Array w*h, um por amostra) → [{t, x, y, move}].
+ * x,y = centro do que mudou desde o quadro anterior (o cursor, numa tela
+ * parada). Mudança grande demais (rolagem, troca de janela) não é cursor.
+ */
+function movimento(quadros, w, h, fps, { limiar = 24, maxFracao = 0.2 } = {}) {
+    const out = [];
+    for (let i = 1; i < quadros.length; i++) {
+        const a = quadros[i - 1];
+        const b = quadros[i];
+        let n = 0;
+        let sx = 0;
+        let sy = 0;
+        for (let k = 0; k < w * h; k++) {
+            if (Math.abs(a[k] - b[k]) > limiar) { n++; sx += k % w; sy += Math.floor(k / w); }
+        }
+        const t = i / fps;
+        if (n < 2 || n > maxFracao * w * h) out.push({ t, x: null, y: null, move: false });
+        else out.push({ t, x: (sx / n + 0.5) / w, y: (sy / n + 0.5) / h, move: true });
+    }
+    return out;
+}
+
+/** Trilha de cursor [{t,x,y,click?}] → amostras com `move` (andou desde a anterior). */
+function doCursor(cursor, { parado = 0.004 } = {}) {
+    const c = cursor.filter((p) => Number.isFinite(p.t) && Number.isFinite(p.x) && Number.isFinite(p.y)).sort((a, b) => a.t - b.t);
+    return c.map((p, i) => ({ ...p, move: i > 0 && Math.hypot(p.x - c[i - 1].x, p.y - c[i - 1].y) > parado }));
+}
+
+/**
+ * Os focos: os cliques, se houver; senão, onde o movimento para — andou por
+ * `minAndou` s e depois ficou parado por `minParado` s. [{t, x, y}].
+ */
+function focos(amostras, { minAndou = 0.15, minParado = 0.3 } = {}) {
+    const cliques = amostras.filter((a) => a.click);
+    if (cliques.length) return cliques.map(({ t, x, y }) => ({ t, x, y }));
+    const out = [];
+    let ini = null;
+    let ult = null;
+    for (const a of amostras) {
+        if (a.move) { if (ini === null) ini = a.t; ult = a; continue; }
+        if (ult && ini !== null && ult.t - ini >= minAndou - 1e-9 && a.t - ult.t >= minParado - 1e-9) {
+            out.push({ t: ult.t, x: ult.x, y: ult.y });
+            ini = null;
+            ult = null;
+        }
+    }
+    return out;
+}
+
+// ── os trechos e a câmera ────────────────────────────────────────────────
+
+/**
+ * Focos (t em QUADROS do clipe) → trechos [{de, ate, focos}]. Fecha o trecho
+ * na pausa maior que `juntar` ou no salto maior que `longe` quando há tempo
+ * de sair e voltar (2 rampas); salto rápido fica no mesmo trecho e vira pan.
+ */
+function trechos(fs, { fps, juntar = 2.5, longe = 0.35, antes = 0.4, segura = 1.2, rampa = 0.5 } = {}) {
+    const out = [];
+    const R = rampa * fps;
+    for (const f of [...fs].sort((a, b) => a.t - b.t)) {
+        const u = out[out.length - 1];
+        const ult = u && u.focos[u.focos.length - 1];
+        const gap = ult ? f.t - ult.t : Infinity;
+        if (u && gap <= juntar * fps && !(Math.hypot(f.x - ult.x, f.y - ult.y) > longe && gap > 2 * R + segura * fps)) { u.focos.push(f); continue; }
+        out.push({ focos: [f] });
+    }
+    for (const s of out) {
+        s.de = Math.max(0, Math.round(s.focos[0].t - antes * fps - R));
+        s.ate = Math.round(s.focos[s.focos.length - 1].t + segura * fps);
+    }
+    // Um trecho não invade a saída do anterior.
+    for (let i = 1; i < out.length; i++) out[i - 1].ate = Math.max(out[i - 1].focos[out[i - 1].focos.length - 1].t, Math.min(out[i - 1].ate, out[i].de - R));
+    return out;
+}
+
+/**
+ * A câmera, quadro a quadro: [{z, x, y}] para `dur` quadros. `pos(f)` = onde
+ * o cursor está no quadro f (ou null). Zona morta = fração da meia-vista.
+ */
+function camera(dur, ts, pos, { fps, zoom = 1.8, rampa = 0.5, zonaMorta = 0.45, hz = 1.4 } = {}) {
+    const R = Math.max(1, Math.round(rampa * fps));
+    const out = [];
+    const w = 2 * Math.PI * hz;
+    const dt = 1 / fps;
+    let cam = { x: 0.5, y: 0.5 };
+    let vel = { x: 0, y: 0 };
+    let alvo = { ...cam };
+    let s = null;
+    for (let f = 0; f < dur; f++) {
+        const novo = ts.find((t) => f >= t.de && f < t.ate + R);
+        if (novo !== s) {
+            s = novo;
+            if (s) { cam = { x: s.focos[0].x, y: s.focos[0].y }; alvo = { ...cam }; vel = { x: 0, y: 0 }; }
+        }
+        let z = 1;
+        if (s) {
+            const p = f < s.de + R ? (f - s.de) / R : f >= s.ate ? 1 - (f - s.ate) / R : 1;
+            z = 1 + (zoom - 1) * p * p * (3 - 2 * p);
+            // Segue o cursor só entre o primeiro e o último foco: antes, mira o foco; depois, segura.
+            const c = f >= s.focos[0].t && f <= s.focos[s.focos.length - 1].t ? pos(f) : null;
+            const meia = 0.5 / zoom;
+            if (c) {
+                for (const k of ['x', 'y']) {
+                    const d = c[k] - alvo[k];
+                    const zm = zonaMorta * meia;
+                    if (Math.abs(d) > zm) alvo[k] = c[k] - Math.sign(d) * zm;
+                    alvo[k] = lim(alvo[k], meia, 1 - meia);
+                }
+            }
+            for (const k of ['x', 'y']) {
+                vel[k] += (w * w * (alvo[k] - cam[k]) - 2 * w * vel[k]) * dt;   // mola crítica: chega sem passar
+                cam[k] += vel[k] * dt;
+            }
+        }
+        const meiaZ = 0.5 / z;
+        out.push({ z, x: lim(cam.x, meiaZ, 1 - meiaZ), y: lim(cam.y, meiaZ, 1 - meiaZ) });
+    }
+    return out;
+}
+
+/** Ramer–Douglas–Peucker numa série: os quadros que bastam para a reta não errar mais que `tol`. */
+function enxugar(v, tol) {
+    const manter = new Set([0, v.length - 1]);
+    const pilha = [[0, v.length - 1]];
+    while (pilha.length) {
+        const [a, b] = pilha.pop();
+        let pior = -1;
+        let max = tol;
+        for (let i = a + 1; i < b; i++) {
+            const d = Math.abs(v[i] - (v[a] + ((v[b] - v[a]) * (i - a)) / (b - a)));
+            if (d > max) { max = d; pior = i; }
+        }
+        if (pior >= 0) { manter.add(pior); pilha.push([a, pior], [pior, b]); }
+    }
+    return [...manter].sort((x, y) => x - y);
+}
+
+/** Câmera → keyframes {zoom, fx, fy} em quadros do clipe ({frame, value, interp}). */
+function keyframes(cam, { tol = 0.002 } = {}) {
+    const out = {};
+    for (const [prop, k] of [['zoom', 'z'], ['fx', 'x'], ['fy', 'y']]) {
+        const v = cam.map((c) => c[k]);
+        out[prop] = enxugar(v, prop === 'zoom' ? 0.01 : tol).map((f) => ({ frame: f, value: Math.round(v[f] * 10000) / 10000, interp: 'linear' }));
+    }
+    return out;
+}
+
+/**
+ * Tudo junto. `amostras` com t em QUADROS do clipe e x,y em 0–1 do clipe.
+ * Devolve {focos, trechos, cam, keys}.
+ */
+function planejar(amostras, dur, opts) {
+    const fs = focos(amostras.map((a) => ({ ...a, t: a.t / opts.fps })), opts).map((f) => ({ ...f, t: Math.round(f.t * opts.fps) }));
+    const ts = trechos(fs, opts);
+    const comPos = amostras.filter((a) => a.x !== null && a.x !== undefined);
+    let i = 0;
+    const pos = (f) => {   // a última posição conhecida até f (f só cresce)
+        while (i + 1 < comPos.length && comPos[i + 1].t <= f) i++;
+        return comPos[i] && comPos[i].t <= f ? comPos[i] : null;
+    };
+    const cam = camera(dur, ts, pos, opts);
+    return { focos: fs, trechos: ts, cam, keys: keyframes(cam) };
+}
+
+// ── o ffmpeg mede ────────────────────────────────────────────────────────
+
+/** Quadros cinza pequenos da origem [de, ate) segundos, a `fps` por segundo. */
+function quadrosCinza(arquivo, de, ate, { fps = 15, w = 160, h = 90 } = {}) {
+    const video = require('../estudio/video.js');
+    return new Promise((resolve, reject) => {
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-ss', String(de), '-t', String(ate - de), '-i', arquivo,
+            '-vf', `fps=${fps},scale=${w}:${h}:flags=area,format=gray`, '-f', 'rawvideo', '-']);
+        const partes = [];
+        p.stdout.on('data', (d) => partes.push(d));
+        p.on('error', reject);
+        p.on('close', (code) => {
+            if (code !== 0) return reject(new Error('não consegui ler os quadros'));
+            const b = Buffer.concat(partes);
+            const out = [];
+            for (let k = 0; k + w * h <= b.length; k += w * h) out.push(b.subarray(k, k + w * h));
+            resolve(out);
+        });
+    });
+}
+
+// ── a operação do editor ─────────────────────────────────────────────────
+
+/** Ponto da ORIGEM (0–1) → ponto do clipe (0–1), depois do encaixe (cover/contain). */
+function paraClipe(tl, clip, asset, x, y) {
+    if (clip.fit === 'stretch') return { x, y };
+    const bw = clip.transform.w * tl.width;
+    const bh = clip.transform.h * tl.height;
+    const aw = asset.width || bw;
+    const ah = asset.height || bh;
+    const esc = clip.fit === 'contain' ? Math.min(bw / aw, bh / ah) : Math.max(bw / aw, bh / ah);
+    return { x: lim(0.5 + ((x - 0.5) * aw * esc) / bw, 0, 1), y: lim(0.5 + ((y - 0.5) * ah * esc) / bh, 0, 1) };
+}
+
+const OPS = {
+    auto_zoom: {
+        uso: 'auto_zoom {id?,zoom?:1.8,cursor?:[{t(s da origem),x,y(0–1),click?}]|cursorFile?,deadZone?:0.45,remove?} — gravação de tela: entra no clique (sem cursor: onde o movimento para), segue com zona morta e mola, sai na pausa',
+        async run(ctx, a) {
+            const T = require('./timeline.js');
+            const E = require('./edits.js');
+            const { mutar } = require('./mutar.js');
+            if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."}');
+            const primeiro = T.todosOsClipes(ctx.tl).find((x) => x.clip.type === 'video');
+            if (!a.id && !primeiro) throw T.erro('não há clipe de vídeo');
+            const { clip } = T.achar(ctx.tl, a.id || primeiro.clip.id);
+            if (a.remove) return mutar(ctx, 'auto_zoom', (tl) => { for (const p of ['zoom', 'fx', 'fy']) E.keyframes(tl, clip.id, p, []); });
+            const asset = ctx.tl.assets[clip.asset];
+            const fps = ctx.tl.fps;
+            const { de, ate } = T.janelaOrigem(ctx.tl, clip);
+            let cru;
+            let fonte;
+            if (a.cursor || a.cursorFile) {
+                cru = doCursor(a.cursor || JSON.parse(require('fs').readFileSync(a.cursorFile, 'utf8')));
+                fonte = cru.some((x) => x.click) ? 'cliques' : 'cursor';
+            } else {
+                const mfps = 15;
+                const h = 2 * Math.round((80 * (asset.height || 9)) / (asset.width || 16));
+                cru = movimento(await quadrosCinza(asset.path, de, ate, { fps: mfps, w: 160, h }), 160, h, mfps).map((x) => ({ ...x, t: x.t + de }));
+                fonte = 'movimento';
+            }
+            const amostras = [];
+            for (const x of cru) {
+                const f = T.origemParaQuadro(ctx.tl, clip, x.t);
+                if (f === null) continue;
+                const p = x.x === null ? { x: null, y: null } : paraClipe(ctx.tl, clip, asset, x.x, x.y);
+                amostras.push({ ...x, ...p, t: f - clip.startFrame });
+            }
+            const pl = planejar(amostras, clip.durationFrames, { fps, zoom: lim(Number(a.zoom) || 1.8, 1.1, 3), zonaMorta: a.deadZone ?? 0.45 });
+            const zooms = pl.trechos.map((t) => [t.de + clip.startFrame, t.ate + clip.startFrame]);
+            if (!pl.focos.length) return { ok: true, nada: true, fonte, focos: 0, aviso: 'nenhum clique nem parada do cursor: nada para aproximar' };
+            return mutar(ctx, 'auto_zoom', (tl) => {
+                for (const [p, ks] of Object.entries(pl.keys)) E.keyframes(tl, clip.id, p, ks.map((k) => ({ ...k, frame: k.frame + clip.startFrame })));
+                return { fonte, focos: pl.focos.length, zooms };
+            });
+        },
+    },
+};
+
+// Sem linha de exemplo: a ajuda principal cabe em 60 linhas, e o `uso` já mostra a forma.
+const EX = {};
+
+module.exports = { movimento, doCursor, focos, trechos, camera, enxugar, keyframes, planejar, quadrosCinza, paraClipe, OPS, EX };

package/lib/plugin/voz-ponte.js

@@ -0,0 +1,15 @@
+/**
+ * voz-ponte.js — o aviso do agente para o modo voz, sem um depender do outro.
+ *
+ * O agente (lib/session/runner/act.js) diz "comecei a ferramenta X" aqui; o /voice, se estiver
+ * ligado, se inscreve e repassa ao Primo (painel mostra "executando" e ele
+ * confirma em voz alta: "rodando os testes"). Sem /voice, ninguém escuta.
+ */
+'use strict';
+
+let ouvinte = null;
+
+module.exports = {
+    escutar: (fn) => { ouvinte = typeof fn === 'function' ? fn : null; },
+    ferramenta: (nome, args) => { if (ouvinte) { try { ouvinte(String(nome || ''), args || {}); } catch { /* o aviso nunca derruba o agente */ } } },
+};