jhonny-editor/code/engine/aplicar_plano_de_edicao.py

"""Entrada de linha de comando: aplica um plano de edição na sequência ativa do Premiere.

Espelha o ``executar_scanner.py``/``executar_retakes.py``: recebe o caminho
de um JSON de ações (``kind``/``start``/``end``/``params``/``reason``,
formato das skills de seleção de trechos) e aplica cada ação na sequência
que estiver ativa no Premiere no momento da execução, via o MCP existente em
``engine.integracoes.premiere``.

Uso::

    python aplicar_plano_de_edicao.py "/caminho/0E6A8290_edit_actions.json"

Pré-requisito: o Premiere precisa estar aberto com a sequência correta ativa
e o painel/plugin do MCP em execução — este script não abre o Premiere nem
troca de sequência.
"""

from __future__ import annotations

import json
import sys
from pathlib import Path

CAMINHO_DO_CODIGO = Path(__file__).resolve().parent.parent
if str(CAMINHO_DO_CODIGO) not in sys.path:
    sys.path.insert(0, str(CAMINHO_DO_CODIGO))

from engine.editor import (
    AplicadorDePlanoDeEdicao,
    BackupDaSequencia,
    EscritaNoEditor,
    LeitorDePlanoDeEdicao,
    MapeadorDeTempoDeOrigemParaTimeline,
)
from engine.integracoes.premiere.cliente_mcp import ClienteMCPPorStdio
from engine.integracoes.premiere.cliente_mcp_com_pausa import ClienteMCPComPausa
from engine.integracoes.premiere.conversores import ConversorDeTimeline
from engine.integracoes.premiere.leitura import AcessoAoEditor, AcessoATimeline
from engine.integracoes.premiere.sessao_mcp import SessaoMCP

CAMINHO_DO_SERVIDOR_MCP = CAMINHO_DO_CODIGO / "dist" / "index.js"


def executar(caminho_do_plano: Path) -> dict:
    """Lê o plano em ``caminho_do_plano`` e o aplica na sequência ativa do Premiere.

    Devolve um dicionário pronto para virar JSON, com o resultado de cada
    ação — para o painel exibir o que foi aplicado e o que falhou.
    """
    plano = LeitorDePlanoDeEdicao().ler(caminho_do_plano)

    # A pausa é aplicada no cliente, e não dentro do aplicador, para valer
    # igualmente nas leituras da timeline e nas escritas — são todas
    # round-trips síncronos no processo principal do Premiere.
    cliente = ClienteMCPComPausa(ClienteMCPPorStdio(["node", str(CAMINHO_DO_SERVIDOR_MCP)]))
    with SessaoMCP(cliente):
        acesso_ao_editor = AcessoAoEditor(AcessoATimeline(cliente))
        conversor_de_timeline = ConversorDeTimeline()

        # Backup antes de qualquer corte, espelhando o painel CEP
        # (applyEditorialActions() em cep-plugin/main.js): sem undo por
        # script nesta versão do Premiere, é a única forma de recuperar o
        # estado anterior se algo sair errado. Uma falha aqui não impede a
        # aplicação — só fica registrada em stderr, igual ao painel.
        sequencia_ativa = conversor_de_timeline.converter(acesso_ao_editor.obter_timeline_ativa())
        backup_ok = BackupDaSequencia(cliente).criar_backup(sequencia_ativa.identificador)
        print(
            "Backup da sequência criado." if backup_ok else "Não foi possível criar o backup automático; aplicando mesmo assim.",
            file=sys.stderr,
        )

        aplicador = AplicadorDePlanoDeEdicao(
            acesso_ao_editor=acesso_ao_editor,
            conversor_de_timeline=conversor_de_timeline,
            escrita=EscritaNoEditor(cliente),
            mapeador=MapeadorDeTempoDeOrigemParaTimeline(),
        )
        resultado = aplicador.aplicar(plano)

    return {
        "arquivo_de_origem": plano.arquivo_de_origem,
        "todas_bem_sucedidas": resultado.todas_bem_sucedidas,
        "acoes": [
            {
                "tipo": item.acao.tipo.value,
                "inicio": item.acao.inicio,
                "fim": item.acao.fim,
                "motivo": item.acao.motivo,
                "sucesso": item.sucesso,
                "detalhe": item.detalhe,
            }
            for item in resultado.resultados
        ],
    }


def main() -> None:
    """Ponto de entrada da linha de comando."""
    if len(sys.argv) != 2:
        print("Uso: python aplicar_plano_de_edicao.py <caminho_do_plano.json>", file=sys.stderr)
        sys.exit(2)
    resultado = executar(Path(sys.argv[1]))
    print(json.dumps(resultado, ensure_ascii=False, indent=2))
    if not resultado["todas_bem_sucedidas"]:
        sys.exit(1)


if __name__ == "__main__":
    main()