Update routers/editor.py

routers/editor.py

@@ -6,6 +6,8 @@ import json
 import uuid
 
 from utils.helpers import extract_json_from_text, get_gemini_model
+from srt_utils import parse_srt, shift_srt_timestamps
+from routers.media import get_groq_srt_base
 import core.globals as g
 
 router = APIRouter(prefix="/editor")
@@ -24,6 +26,16 @@ class EditorChatRequest(BaseModel):
     # build_editor_prompt below).
     project: Dict[str, Any] = {}
 
+class SmartCutRequest(BaseModel):
+    video_url: str
+    # The clip's own current [videoStartOffset, videoStartOffset+duration]
+    # window in the SOURCE file's timeline — only this window is transcribed
+    # and analyzed, matching what the user actually sees/already trimmed on
+    # the timeline, not the whole source file.
+    window_start: float
+    window_end: float
+    instruction: str
+
 
 # ── Template catalog (hand-mirrored from src/components/common/templates.ts)
 # ─────────────────────────────────────────────────────────────────────────
@@ -122,6 +134,20 @@ CATÁLOGO DE AÇÕES DISPONÍVEIS (campos entre colchetes são opcionais):
 7. insert_template — {{ "type": "insert_template", "templateId": string, ["startTime"]: number, ["overrides"]: {{ "<localId>": {{ ...campos... }} }} }}
 8. group_elements — {{ "type": "group_elements", "elementIds": string[] }}
 9. select_element — {{ "type": "select_element", "elementId": string }}
+10. smart_cut_video — {{ "type": "smart_cut_video", "elementId": string, "instruction": string }}
+    Use SOMENTE quando o pedido for pra CORTAR/EDITAR um elemento de vídeo
+    (type "image" com mediaType "video" no arquivo anexado) com base na FALA
+    dele — ex: "corta esse vídeo e deixa só as melhores falas", "tira as
+    partes de enrolação da entrevista", "deixa só os melhores momentos".
+    "elementId" tem que ser um elemento de vídeo real do arquivo anexado
+    (nunca um `refId` de um elemento que você acabou de criar). "instruction"
+    é o pedido do usuário sobre COMO cortar, repassado da forma mais fiel
+    possível. Essa ação é DIFERENTE de todas as outras: não é aplicada na
+    hora — o editor ainda vai transcrever a fala e analisar o que manter,
+    o que pode levar cerca de um minuto. Por isso, quando usar essa ação,
+    seu "reply" deve deixar isso claro (ex: "Vou ouvir o vídeo e separar as
+    melhores falas — isso pode levar um minuto."), nunca afirmar que o corte
+    já foi feito. No máximo UMA ação smart_cut_video por resposta.
 
 TEMPLATES DISPONÍVEIS (use o "id" exato em insert_template.templateId; os ids
 dentro de "editableFields" podem ser usados como chave em "overrides"):
@@ -158,10 +184,11 @@ REGRAS IMPORTANTES:
 - Cores são sempre string hex (ex: "#ff3366").
 - HONESTIDADE (CRÍTICO, NÃO NEGOCIÁVEL): você só pode fazer exatamente o que
   está no catálogo de ações acima — nada além disso é possível hoje (ex:
-  cortar vídeo automaticamente com base na fala/transcrição, gerar ou editar
-  imagens, mexer em áudio além do que já existe como campo de elemento,
-  alterar o código/comportamento do próprio editor, acessar informação de
-  fora do que foi anexado). Se o usuário pedir algo assim, ou qualquer coisa
+  gerar ou editar imagens, mexer em áudio além do que já existe como campo
+  de elemento, alterar o código/comportamento do próprio editor, acessar
+  informação de fora do que foi anexado). Cortar vídeo com base na fala JÁ é
+  possível — ver ação 10 (smart_cut_video) — não trate isso como limitação.
+  Se o usuário pedir algo fora do catálogo, ou qualquer coisa
   que você não tenha certeza de conseguir fazer com o catálogo, diga isso de
   forma CLARA, HONESTA e EDUCADA no "reply" — algo como "ainda não fui
   programado(a) pra fazer isso" — em vez de inventar uma solução, fingir que
@@ -223,6 +250,167 @@ async def editor_chat(request: EditorChatRequest):
         raise HTTPException(status_code=500, detail=str(e))
     finally:
         if os.path.exists(context_path):
+            try:
+                os.remove(context_path)
+            except Exception:
+                pass
+
+
+# ── Smart video cut (Fase 2) ────────────────────────────────────────────────
+# Groq Whisper transcreve (mesma get_groq_srt_base já usada por /subtitle);
+# Gemini decide QUAIS trechos manter, olhando só o texto/timestamps — nunca
+# assiste ao vídeo aqui, então essa chamada é rápida/barata.
+
+def build_smart_cut_prompt(instruction: str) -> str:
+    return f"""
+Você é um editor de vídeo profissional. Você recebe a TRANSCRIÇÃO de um
+trecho de vídeo (anexada como JSON: uma lista de blocos, cada um com "start"
+e "end" em SEGUNDOS — tempo absoluto do arquivo fonte — e "text", a fala
+naquele intervalo) e o PEDIDO do usuário sobre como cortar esse vídeo.
+
+SUA TAREFA: escolher quais blocos (um ou vários, não precisam ser
+consecutivos) devem ser MANTIDOS no corte final, de acordo com o pedido.
+Tudo que não for escolhido é descartado.
+
+REGRAS (CRÍTICAS):
+- Você só pode usar OS TIMESTAMPS REAIS da transcrição anexada. NUNCA invente
+  ou arredonde um valor — cada trecho escolhido tem que começar e terminar
+  EXATAMENTE no "start"/"end" de um ou mais blocos consecutivos do arquivo.
+- Os trechos escolhidos devem estar em ORDEM CRONOLÓGICA e NUNCA se
+  sobrepor.
+- Prefira POUCOS trechos bem escolhidos a muitos trechos curtos picados.
+- Cada trecho deve fazer sentido sozinho, como uma afirmação/ideia completa
+  — nunca corte no meio de uma frase.
+- Se o pedido for vago (ex: "as melhores partes", "os melhores momentos"),
+  use julgamento editorial: priorize afirmações fortes, conclusivas, com
+  informação ou emoção real — evite perguntas do entrevistador, hesitação,
+  saudação/introdução genérica, repetição.
+- Se a transcrição não tiver nada que se destaque claramente pro pedido, é
+  válido escolher poucos trechos, ou até nenhum — nunca force uma
+  quantidade só pra preencher.
+
+PEDIDO DO USUÁRIO:
+"{instruction}"
+
+Responda ESTRITAMENTE em JSON, sem markdown, sem texto fora do JSON:
+{{
+  "segments": [
+    {{ "start": number, "end": number, "text": "o texto falado nesse trecho, como veio da transcrição", "reason": "por que esse trecho foi escolhido, uma frase curta" }}
+  ],
+  "summary": "um resumo curto (1-2 frases), em texto normal, do que foi mantido/cortado — isso vai aparecer direto pro usuário no chat"
+}}
+
+Mande APENAS o JSON.
+"""
+
+
+def snap_segments_to_transcript(
+    segments: list,
+    transcript_blocks: list,
+    tolerance: float = 0.35,
+    max_segments: int = 40,
+) -> list:
+    """Defesa contra timestamp alucinado: cada segmento que o Gemini devolveu
+    só é aceito se o "start"/"end" dele estiver bem perto (`tolerance`
+    segundos) do start/end de um bloco REAL da transcrição — nesse caso o
+    valor é substituído pelo valor EXATO do bloco real, nunca o número cru
+    que o modelo escreveu. Fora da tolerância, o segmento inteiro é
+    descartado. Diferente de um erro de texto (Fase 1), um timestamp errado
+    aqui corrompe o vídeo cortado, então essa validação não é opcional.
+    Depois: ordena por tempo, descarta sobreposição, e limita a
+    `max_segments` (segurança contra uma resposta anormalmente picada).
+    """
+    if not transcript_blocks:
+        return []
+
+    valid = []
+    for seg in segments:
+        if not isinstance(seg, dict):
+            continue
+        start, end = seg.get("start"), seg.get("end")
+        if not isinstance(start, (int, float)) or not isinstance(end, (int, float)) or end <= start:
+            continue
+
+        nearest_start_block = min(transcript_blocks, key=lambda b: abs(b["start"] - start))
+        nearest_end_block = min(transcript_blocks, key=lambda b: abs(b["end"] - end))
+        if abs(nearest_start_block["start"] - start) > tolerance or abs(nearest_end_block["end"] - end) > tolerance:
+            continue
+
+        valid.append({
+            "start": nearest_start_block["start"],
+            "end": nearest_end_block["end"],
+            "text": seg.get("text") or "",
+            "reason": seg.get("reason") or "",
+        })
+
+    valid.sort(key=lambda s: s["start"])
+    result = []
+    last_end = -1.0
+    for s in valid:
+        if s["start"] < last_end:
+            continue
+        result.append(s)
+        last_end = s["end"]
+        if len(result) >= max_segments:
+            break
+    return result
+
+
+@router.post("/smart-cut")
+async def editor_smart_cut(request: SmartCutRequest):
+    if not hasattr(g, "client") or not g.client:
+        raise HTTPException(status_code=500, detail="Gemini client is not initialized")
+    if request.window_end <= request.window_start:
+        raise HTTPException(status_code=400, detail="Invalid time window.")
+
+    original_media_to_delete = None
+    context_path = None
+    try:
+        srt_base, _, _audio_url, _word_level, original_media_path = await get_groq_srt_base(
+            request.video_url, time_start=request.window_start, time_end=request.window_end,
+        )
+        original_media_to_delete = original_media_path
+
+        # get_groq_srt_base's timestamps are relative to the TRIMMED window
+        # (0-based) — shift back to the source file's own absolute time, the
+        # same space Element.videoStartOffset already uses, so the frontend
+        # can apply "start"/"end" straight through with no extra math.
+        srt_absolute = shift_srt_timestamps(srt_base, request.window_start)
+        transcript_blocks = parse_srt(srt_absolute)
+        if not transcript_blocks:
+            return {"segments": [], "summary": "I couldn't find any speech in this clip to analyze."}
+
+        temp_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "static", "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        context_path = os.path.join(temp_dir, f"smart_cut_transcript_{uuid.uuid4().hex[:8]}.json")
+        with open(context_path, "w", encoding="utf-8") as f:
+            json.dump(transcript_blocks, f, ensure_ascii=False)
+
+        print(f"🎬 [EDITOR] Analisando fala pra corte inteligente...")
+        prompt = build_smart_cut_prompt(request.instruction)
+        model_obj = get_gemini_model("flash")
+        response = await g.client.generate_content(prompt, files=[context_path], model=model_obj)
+
+        data = extract_json_from_text(response.text)
+        if not data or not isinstance(data, dict):
+            return {"segments": [], "summary": "Couldn't make sense of the speech analysis — try again."}
+
+        raw_segments = data.get("segments")
+        segments = snap_segments_to_transcript(raw_segments if isinstance(raw_segments, list) else [], transcript_blocks)
+        summary = data.get("summary") or ""
+
+        return {"segments": segments, "summary": summary}
+
+    except Exception as e:
+        print(f"❌ Erro no /editor/smart-cut: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if original_media_to_delete and os.path.exists(original_media_to_delete) and "static" in original_media_to_delete:
+            try:
+                os.unlink(original_media_to_delete)
+            except Exception:
+                pass
+        if context_path and os.path.exists(context_path):
             try:
                 os.remove(context_path)
             except Exception: