feat: alinhada a remoção da engine Python ao fluxo ripple do execu

- alinhada a remoção da engine Python ao fluxo ripple do executor CEP para cortar vídeo e áudio - criada remoção atômica para manter vídeo e áudio vinculados sincronizados - criada aba de configuração de legendas offline e inclusão das preferências no pacote para a IA - criado gerador offline de blocos de legenda sincronizados com palavras da transcrição e cortes aprovados - criada uma versão base portátil da skill edit-video-by-voice para testes em outros agentes de IA - incorporado perfil editorial opcional à skill portátil para orientar decisões de edição Resumo: - 14 arquivos alterados - 4 novos - 10 modificados - 0 removidos 10 files changed, 278 insertions(+), 33 deletions(-) Arquivos: - code/cep-plugin/index.html - code/cep-plugin/main.js - code/docs/supported-actions.md - code/engine/editor/aplicador_de_plano_de_edicao.py - code/engine/editor/escrita/escrita_no_editor.py - code/engine/testes/duplos_de_premiere.py - code/engine/testes/test_aplicador_de_plano_de_edicao.py - code/src/tools/timeline.ts - code/tests/tools/structural-verification.test.ts - code/tests/tools/tool-modules.test.ts - code/engine/arquitetura/legendas.md - code/engine/editor/legendas/ - code/engine/testes/test_gerador_de_legendas.py - skills/
2026-09-09 13:05:07 -04:00
parent f3e356340b
commit 1249b3aeb7
18 changed files with 730 additions and 33 deletions
@@ -5,7 +5,7 @@ têm posição na timeline diferente da posição no arquivo de origem — o mes
 descompasso encontrado no projeto real entre ``inicio_na_timeline`` e
 ``inicio_na_origem`` do banco de análises. Implementa só as ferramentas MCP
 que o módulo ``engine.editor`` usa: ``get_active_sequence``, ``split_clip``,
-``ripple_delete``, ``set_clip_properties`` e ``add_marker``.
+``remove_from_timeline``, ``remove_linked_from_timeline``, ``set_clip_properties`` e ``add_marker``.
 """

 from __future__ import annotations
@@ -78,8 +78,8 @@ class ClienteMCPFalso(ClienteMCP):

    @property
    def chamadas_de_remocao(self) -> list[dict[str, Any]]:
-        """Argumentos de cada chamada a ``ripple_delete``, na ordem em que ocorreram."""
-        return [argumentos for nome, argumentos in self.chamadas if nome == "ripple_delete"]
+        """Argumentos de cada remoção com ripple, na ordem em que ocorreram."""
+        return [argumentos for nome, argumentos in self.chamadas if nome in {"ripple_delete", "remove_from_timeline", "remove_linked_from_timeline"}]

    def conectar(self) -> None:
        """Não há conexão real; existe só para satisfazer a interface de :class:`ClienteMCP`."""
@@ -98,7 +98,8 @@ class ClienteMCPFalso(ClienteMCP):
        despachantes = {
            "get_active_sequence": self._simular_get_active_sequence,
            "split_clip": self._simular_split_clip,
-            "ripple_delete": self._simular_ripple_delete,
+            "remove_from_timeline": self._simular_ripple_delete,
+            "remove_linked_from_timeline": self._simular_remocao_vinculada,
            "set_clip_properties": self._simular_set_clip_properties,
            "add_marker": self._simular_add_marker,
            "undo": self._simular_undo,
@@ -213,6 +214,15 @@ class ClienteMCPFalso(ClienteMCP):
                    return {"rippleDeleted": True, "verified": True}
        raise ErroDeFerramentaMCP(f"Clipe não encontrado para remoção: {identificador_do_clipe!r}.")

+    def _simular_remocao_vinculada(self, argumentos: dict[str, Any]) -> dict[str, Any]:
+        """Remove o par de vídeo e áudio, fechando o espaço nos dois lados."""
+        identificadores = argumentos["node_ids"]
+        if len(identificadores) != 2:
+            raise ErroDeFerramentaMCP("O par vinculado precisa conter dois clipes.")
+        for identificador in identificadores:
+            self._simular_ripple_delete({"node_id": identificador, "ripple": True})
+        return {"removed": True, "verified": True}
+
    def _simular_set_clip_properties(self, argumentos: dict[str, Any]) -> dict[str, Any]:
        """Aceita a alteração de propriedades sem simular geometria (não é usada pelos testes)."""
        del argumentos
@@ -38,13 +38,27 @@ class TesteAplicadorDePlanoDeEdicao(unittest.TestCase):
        ))
        resultado = self.aplicador.aplicar(plano)
        self.assertTrue(resultado.todas_bem_sucedidas)
-        self.assertNotIn("000f4763_video", [c["node_id"] for c in self.cliente.chamadas_de_remocao])
-        # o clipe único que cobre 2.3-40.6s de origem foi removido em ambas as faixas
+        chamadas = self.cliente.chamadas_de_remocao
+        self.assertEqual(len(chamadas), 1)
        self.assertEqual(
-            {c["node_id"] for c in self.cliente.chamadas_de_remocao},
+            {identificador.split("_esq")[0] for identificador in chamadas[0]["node_ids"]},
            {"clipe_a_video", "clipe_a_audio"},
        )

+    def test_corte_de_video_e_audio_usa_uma_remocao_atomica(self):
+        plano = PlanoDeEdicao("0E6A8290.mp4", (
+            AcaoDeEdicao(TipoDeAcao.CORTE, inicio=0.0, fim=40.6, motivo="bastidor"),
+        ))
+        resultado = self.aplicador.aplicar(plano)
+        self.assertTrue(resultado.todas_bem_sucedidas, msg=[r.detalhe for r in resultado.falhas])
+        chamadas = [c for c in self.cliente.chamadas if c[0] == "remove_linked_from_timeline"]
+        self.assertEqual(len(chamadas), 1)
+        self.assertEqual(
+            {identificador.split("_esq")[0] for identificador in chamadas[0][1]["node_ids"]},
+            {"clipe_a_video", "clipe_a_audio"},
+        )
+        self.assertFalse(any(c[0] == "remove_from_timeline" for c in self.cliente.chamadas))
+
    def test_localiza_fonte_por_nome_base_do_source_file(self):
        """Aceita um source completo quando o Premiere retorna outro nome de clipe."""
        faixa = Faixa("video_0", "Vídeo 1", "video", 0, [
@@ -75,7 +89,9 @@ class TesteAplicadorDePlanoDeEdicao(unittest.TestCase):
        # corte aconteceu antes de marcador e zoom na sequência de chamadas
        indice_do_marcador = next(i for i, c in enumerate(self.cliente.chamadas) if c[0] == "add_marker")
        indice_do_zoom = next(i for i, c in enumerate(self.cliente.chamadas) if c[0] == "set_clip_properties")
-        indice_da_remocao = next(i for i, c in enumerate(self.cliente.chamadas) if c[0] == "ripple_delete")
+        indice_da_remocao = next(
+            i for i, c in enumerate(self.cliente.chamadas) if c[0] == "remove_linked_from_timeline"
+        )
        self.assertLess(indice_da_remocao, indice_do_marcador)
        self.assertLess(indice_da_remocao, indice_do_zoom)

@@ -86,9 +102,12 @@ class TesteAplicadorDePlanoDeEdicao(unittest.TestCase):
        ))
        resultado = self.aplicador.aplicar(plano)
        self.assertTrue(resultado.todas_bem_sucedidas, msg=[r.detalhe for r in resultado.falhas])
-        remocoes = [c["node_id"] for c in self.cliente.chamadas_de_remocao]
+        remocoes = [c["node_ids"][0] for c in self.cliente.chamadas_de_remocao]
        # o corte com início maior (86.2s) precisa ser removido antes do de início 0.0s
-        self.assertLess(remocoes.index("clipe_b_video"), remocoes.index("clipe_a_video"))
+        self.assertLess(
+            next(i for i, identificador in enumerate(remocoes) if identificador.startswith("clipe_b_video")),
+            next(i for i, identificador in enumerate(remocoes) if identificador.startswith("clipe_a_video")),
+        )

    def test_corte_sem_clipe_sobreposto_falha_sem_interromper_o_resto(self):
        plano = PlanoDeEdicao("0E6A8290.mp4", (
@@ -149,7 +168,7 @@ class TesteAplicadorDePlanoDeEdicao(unittest.TestCase):
        ))
        resultado = aplicador.aplicar(plano)
        self.assertTrue(resultado.todas_bem_sucedidas, msg=[r.detalhe for r in resultado.falhas])
-        self.assertEqual(len(cliente.chamadas_de_remocao), 2)  # vídeo + áudio
+        self.assertEqual(len(cliente.chamadas_de_remocao), 1)  # par vídeo + áudio
        # nenhuma segunda tentativa de corte no mesmo ponto pedido, por faixa
        pedidos_por_faixa = [
            (c[1]["track_type"], c[1]["time_seconds"]) for c in cliente.chamadas if c[0] == "split_clip"
@@ -196,7 +215,7 @@ class TesteAplicadorDePlanoDeEdicao(unittest.TestCase):
        ))
        resultado = aplicador.aplicar(plano)
        self.assertTrue(resultado.todas_bem_sucedidas, msg=[r.detalhe for r in resultado.falhas])
-        self.assertEqual(len(cliente.chamadas_de_remocao), 2)  # vídeo + áudio
+        self.assertEqual(len(cliente.chamadas_de_remocao), 1)  # par vídeo + áudio
        self.assertEqual(len(cliente._faixas["video_0"]), 2)  # sem fatia sobrando

    def test_corte_falha_em_vez_de_ignorar_faixa_sem_intervalo_de_origem(self):
@@ -0,0 +1,44 @@
+"""Testes do gerador offline de legendas."""
+
+import unittest
+
+from engine.editor.legendas import ConfiguracaoDeLegendas, GeradorDeLegendas
+from engine.editor.modelos import AcaoDeEdicao, TipoDeAcao
+from engine.scanner.modelos import PalavraDeTranscricao
+
+
+class TesteGeradorDeLegendas(unittest.TestCase):
+    """Verifica filtragem, reposicionamento e agrupamento de palavras."""
+
+    def setUp(self) -> None:
+        self.gerador = GeradorDeLegendas()
+        self.corte = AcaoDeEdicao(TipoDeAcao.CORTE, 0.0, 2.0, "abertura")
+        self.palavras = [
+            PalavraDeTranscricao("Olá", 2.1, 2.5),
+            PalavraDeTranscricao("mundo", 2.6, 3.0),
+            PalavraDeTranscricao("hoje", 5.0, 5.4),
+        ]
+
+    def test_remove_palavras_cortadas_e_reposiciona_as_restantes(self) -> None:
+        legendas = self.gerador.gerar(self.palavras, [self.corte], 10.0)
+        self.assertEqual([legenda.texto for legenda in legendas], ["Olá mundo", "hoje"])
+        self.assertAlmostEqual(legendas[0].inicio, 0.1)
+        self.assertAlmostEqual(legendas[1].inicio, 3.0)
+
+    def test_respeita_limites_de_palavras_e_caracteres(self) -> None:
+        configuracao = ConfiguracaoDeLegendas(maximo_de_palavras=2, maximo_de_caracteres=10)
+        palavras = [
+            PalavraDeTranscricao("uma", 0.0, 0.2),
+            PalavraDeTranscricao("frase", 0.2, 0.4),
+            PalavraDeTranscricao("longa", 0.4, 0.6),
+        ]
+        legendas = self.gerador.gerar(palavras, [], 2.0, configuracao)
+        self.assertEqual([legenda.texto for legenda in legendas], ["uma frase", "longa"])
+
+    def test_rejeita_cortes_sobrepostos(self) -> None:
+        cortes = [
+            self.corte,
+            AcaoDeEdicao(TipoDeAcao.CORTE, 1.5, 3.0, "repetição"),
+        ]
+        with self.assertRaisesRegex(ValueError, "não podem se sobrepor"):
+            self.gerador.gerar(self.palavras, cortes, 10.0)