primocode 8.42.1 → 9.0.0

package/skills/slides-que-prendem/SKILL.md

@@ -0,0 +1,40 @@
+---
+nome: Slides que prendem
+descricao: apresentação sem template, que se lê de longe e não entedia
+quando: slides, slide, apresentação, apresentacao, deck, pitch, palestra
+autor: PrimoCode
+---
+Slide não é documento projetado. Se ele se lê inteiro em voz alta, é um
+documento — e o público já leu antes de você falar.
+
+## A estrutura, sem modelo pronto
+
+Não existe "layout capa" nem "layout duas colunas". Cada slide é composto do
+zero, como uma cena: fundo, elementos posicionados, tipografia escolhida.
+
+O que existe é uma ORDEM que funciona: a tensão antes da solução. Comece pelo
+problema que a plateia reconhece, não pela apresentação de quem fala.
+
+## Uma ideia por slide
+
+Se precisa rolar o olho para ler, dividiu errado. Título que é uma AFIRMAÇÃO
+("o custo dobrou em 6 meses"), não um rótulo ("custos").
+
+Número grande é slide inteiro: um número, uma linha do que ele significa, e
+mais nada.
+
+## Legibilidade antes de beleza
+
+Texto de corpo nunca abaixo de 28pt no 1920×1080. Contraste alto — slide é
+visto em sala com luz. No máximo duas fontes e três cores.
+
+## Ritmo
+
+Varie: slide denso, slide de respiro, slide de número, slide de citação.
+Quinze slides iguais em sequência perdem qualquer plateia, por melhores que
+sejam.
+
+## Prova
+
+Todo dado tem origem escrita ao lado, pequena. Dado sem fonte é opinião com
+fonte tipográfica melhor — e alguém vai perguntar.

package/studio/edge.py

@@ -117,81 +117,32 @@ def disponivel():
     return _verificado
 
 
-# Por que a instalação falhava calada, e o vídeo saía com a voz do Google:
-# `pip install --user` é recusado pelo Python do sistema em Debian/Ubuntu e
-# no do Homebrew ("externally-managed-environment", PEP 668), e em máquina
-# sem pip o `-m pip` nem existe. Um `pip install` só, em segundo plano, com a
-# saída jogada fora, era exatamente a falha que ninguém vê. Agora são várias
-# tentativas, em ordem, e a última linha do erro de cada uma fica guardada
-# para o status contar o que houve.
-ESTRATEGIAS = [
-    ["-m", "pip", "install", "--user", "--quiet", "edge-tts"],
-    ["-m", "pip", "install", "--user", "--quiet", "--break-system-packages", "edge-tts"],
-    ["-m", "pip", "install", "--quiet", "edge-tts"],
-    ["-m", "pip", "install", "--quiet", "--break-system-packages", "edge-tts"],
-]
-_ultimo_erro = ""
-_thread = None
-
-
 def _rotina_instalar():
-    global _instalando, _verificado, _ultimo_erro
+    global _instalando, _verificado
     try:
-        # Sem pip, primeiro o ensurepip — é o que o python.org e a Apple
-        # trazem para o caso.
-        try:
-            r = subprocess.run([sys.executable, "-m", "pip", "--version"],
-                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=30)
-            if r.returncode != 0:
-                subprocess.run([sys.executable, "-m", "ensurepip", "--user", "--default-pip"],
-                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=120)
-        except Exception:
-            pass
-        for args in ESTRATEGIAS:
-            try:
-                r = subprocess.run([sys.executable] + args, stdout=subprocess.DEVNULL,
-                                   stderr=subprocess.PIPE, timeout=240)
-            except Exception as e:
-                _ultimo_erro = str(e)[-200:]
-                continue
-            _verificado = None
-            if r.returncode == 0 and disponivel():
-                _ultimo_erro = ""
-                sys.stderr.write("[edge] edge-tts instalado (%s)\n" % " ".join(args[2:]))
-                return
-            _ultimo_erro = (r.stderr or b"").decode("utf-8", "replace").strip().splitlines()[-1:][0][-200:] \
-                if (r.stderr or b"").strip() else "pip devolveu %s" % r.returncode
-        sys.stderr.write("[edge] não consegui instalar o edge-tts: %s\n" % _ultimo_erro)
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--user", "--quiet", "edge-tts"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=180)
+    except Exception as e:
+        sys.stderr.write("[edge] pip install falhou: %s\n" % e)
     finally:
         _verificado = None          # força nova checagem
         with _tranca:
             _instalando = False
 
 
-def instalar(esperar=0):
-    """Traz o pacote — em segundo plano por padrão; com `esperar` (segundos),
-    quem chamou fica aguardando até esse teto.
-
-    Esperar existe porque a narração de um vídeo NÃO pode sair pela voz de
-    reserva só porque o pip ainda estava rodando: quem pede voz agora e tem
-    internet merece a voz neural agora. Meio minuto de pip é menos ruim que
-    um vídeo inteiro com voz de robô."""
-    global _instalando, _thread
+def instalar():
+    """Tenta trazer o pacote em segundo plano, uma vez. Não bloqueia: quem
+    pediu narração agora ouve o próximo motor da corrente, e a partir da
+    próxima vez o Edge já responde."""
+    global _instalando
     if disponivel():
-        return True
+        return
     with _tranca:
-        if not _instalando:
-            _instalando = True
-            _thread = threading.Thread(target=_rotina_instalar, daemon=True)
-            _thread.start()
-        t = _thread
-    if t and esperar:
-        t.join(esperar)
-    return disponivel()
-
-
-def ultimo_erro():
-    return _ultimo_erro
+        if _instalando:
+            return
+        _instalando = True
+    threading.Thread(target=_rotina_instalar, daemon=True).start()
 
 
 def _dur_do_vtt(caminho):
@@ -264,7 +215,6 @@ def estado():
         "motor": "edge",
         "disponivel": disponivel(),
         "instalando": inst,
-        "erro": _ultimo_erro or None,
         "precisa_internet": True,
         "vozes": [{"id": v["id"], "nome": v["nome"], "genero": v["genero"],
                    "padrao": bool(v.get("padrao"))} for v in CATALOGO],

package/studio/narrar.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""narrar.py — a narração, em Python, sem servidor.
+
+    "Narração: gerar em Python, com biblioteca de TTS instalada no projeto. A
+     IA escolhe a voz e o estilo da narração."
+
+── POR QUE UM SCRIPT, E NÃO UM SERVIDOR ─────────────────────────────────────
+O Studio antigo subia um servidor Python em localhost:7777 e falava com ele
+por HTTP — inclusive para gerar narração. Aquilo existia porque havia uma
+interface web para servir. A interface morreu; o servidor não tem mais razão
+de ser, e com ele some uma classe inteira de defeito ("o estúdio não está
+rodando", porta ocupada, processo zumbi entre sessões).
+
+Aqui é um comando: entra texto, sai um mp3 e os tempos de cada fala.
+
+── OS TEMPOS SÃO MEDIDOS, NÃO ESTIMADOS ─────────────────────────────────────
+O edge-tts escreve as legendas junto com o áudio (`--write-media` +
+`--write-subtitles`). Delas sai o instante exato de cada frase.
+
+Isso é o que faz a cena caber na fala. Estimar duração por número de palavras
+erra em segundos, e o erro aparece como imagem trocando antes de a frase
+acabar — o defeito de vídeo automático mais fácil de reconhecer.
+
+── A CORRENTE ───────────────────────────────────────────────────────────────
+1. ELEVENLABS  se houver chave com crédito (melhor entonação, custa).
+2. EDGE TTS    neural, grátis, sem chave, sem conta.   ← o padrão
+3. diz que não deu, com o comando de instalar.
+
+Nunca uma voz de robô como "reserva": entregar um vídeo com voz dos anos 90
+é pior que entregar sem narração e dizer o que falta.
+
+Uso:
+    python3 narrar.py falar --texto "..." --saida narracao.mp3 [--voz antonio]
+                           [--ritmo -8%] [--tom +2Hz]
+    python3 narrar.py vozes
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+AQUI = Path(__file__).resolve().parent
+sys.path.insert(0, str(AQUI))
+
+# ── catálogo ────────────────────────────────────────────────────────────────
+# As vozes neurais de português do Brasil que existem no serviço da Microsoft.
+# Não há por que inventar mais: são estas três, e o `estilo` é o que a IA
+# escolhe para dar registro diferente à mesma voz.
+VOZES = [
+    {"id": "antonio", "voz": "pt-BR-AntonioNeural", "nome": "Antonio",
+     "genero": "masculina", "serve": "locução, abertura, institucional", "padrao": True},
+    {"id": "francisca", "voz": "pt-BR-FranciscaNeural", "nome": "Francisca",
+     "genero": "feminina", "serve": "conversa, explicação, tutorial"},
+    {"id": "thalita", "voz": "pt-BR-ThalitaMultilingualNeural", "nome": "Thalita",
+     "genero": "feminina", "serve": "jovem, anúncio, redes sociais"},
+]
+
+# O "estilo" não existe como parâmetro no edge-tts: ele é ritmo + tom. Estes
+# quatro cobrem o que se pede num vídeo, e são o ponto de partida — a IA pode
+# mandar ritmo e tom na mão quando quiser outra coisa.
+ESTILOS = {
+    "normal":    {"ritmo": "+0%",  "tom": "+0Hz"},
+    "anuncio":   {"ritmo": "+8%",  "tom": "+2Hz"},   # mais rápido e mais alto: energia
+    "calmo":     {"ritmo": "-8%",  "tom": "-2Hz"},   # mais devagar e mais grave: explicação
+    "dramatico": {"ritmo": "-14%", "tom": "-4Hz"},   # pausa e peso
+}
+
+
+def voz_de(apelido):
+    a = (apelido or "").strip().lower()
+    for v in VOZES:
+        if a in (v["id"], v["voz"].lower(), v["nome"].lower()):
+            return v
+    return VOZES[0]
+
+
+def tempo_vtt(marca):
+    """"00:00:03.480" → 3.48"""
+    h, m, s = marca.split(":")
+    return int(h) * 3600 + int(m) * 60 + float(s.replace(",", "."))
+
+
+def ler_legendas(caminho):
+    """As falas com início e fim, lidas do VTT que o edge-tts escreveu."""
+    falas = []
+    try:
+        bruto = Path(caminho).read_text(encoding="utf-8")
+    except OSError:
+        return falas
+    bloco = None
+    for linha in bruto.splitlines():
+        linha = linha.strip()
+        if "-->" in linha:
+            de, ate = [p.strip() for p in linha.split("-->")[:2]]
+            bloco = {"de": tempo_vtt(de), "ate": tempo_vtt(ate.split(" ")[0]), "texto": ""}
+        elif bloco is not None and linha:
+            bloco["texto"] = (bloco["texto"] + " " + linha).strip()
+        elif bloco is not None and not linha:
+            if bloco["texto"]:
+                falas.append(bloco)
+            bloco = None
+    if bloco and bloco["texto"]:
+        falas.append(bloco)
+    return falas
+
+
+def edge_disponivel():
+    try:
+        subprocess.run([sys.executable, "-m", "edge_tts", "--help"],
+                       capture_output=True, timeout=25, check=True)
+        return True
+    except Exception:
+        return False
+
+
+# Por que uma única tentativa de pip não serve — e falha CALADA.
+#
+# Em Debian e Ubuntu, e no Python do Homebrew, o `pip install` no Python do
+# sistema é recusado de saída: "externally-managed-environment" (PEP 668). Em
+# máquina sem pip, o `-m pip` nem existe. Uma tentativa só, com a saída jogada
+# fora, é exatamente a falha que ninguém vê: a instalação "não deu erro", o
+# edge-tts continua ausente, e a narração cai calada na voz de reserva — o
+# vídeo sai com outra voz e ninguém sabe por quê.
+#
+# Então são várias tentativas, em ordem da menos invasiva para a mais, e o
+# erro da última fica guardado para a resposta poder contar o que houve.
+ESTRATEGIAS = [
+    ["-m", "pip", "install", "--user", "--quiet", "edge-tts"],
+    ["-m", "pip", "install", "--user", "--quiet", "--break-system-packages", "edge-tts"],
+    ["-m", "pip", "install", "--quiet", "edge-tts"],
+    ["-m", "pip", "install", "--quiet", "--break-system-packages", "edge-tts"],
+]
+
+ultimo_erro_pip = ""
+
+
+def instalar_edge():
+    """Traz o edge-tts com pip. Uma vez, e o usuário vê acontecer."""
+    global ultimo_erro_pip
+
+    # Sem pip, primeiro o ensurepip — é o que o python.org e a Apple trazem
+    # justamente para este caso.
+    try:
+        r = subprocess.run([sys.executable, "-m", "pip", "--version"],
+                           capture_output=True, timeout=30)
+        if r.returncode != 0:
+            subprocess.run([sys.executable, "-m", "ensurepip", "--default-pip"],
+                           capture_output=True, timeout=120)
+    except Exception as e:
+        ultimo_erro_pip = str(e)
+
+    for args in ESTRATEGIAS:
+        try:
+            r = subprocess.run([sys.executable] + args, capture_output=True, timeout=240)
+            if r.returncode == 0 and edge_disponivel():
+                return True
+            saida = (r.stderr or b"").decode("utf-8", "replace").strip()
+            if saida:
+                ultimo_erro_pip = saida.splitlines()[-1][:300]
+        except Exception as e:
+            ultimo_erro_pip = str(e)[:300]
+    return False
+
+
+def falar_edge(texto, saida, voz, ritmo, tom):
+    with tempfile.TemporaryDirectory() as tmp:
+        vtt = str(Path(tmp) / "legenda.vtt")
+        cmd = [
+            sys.executable, "-m", "edge_tts",
+            "--voice", voz,
+            "--text", texto,
+            "--write-media", str(saida),
+            "--write-subtitles", vtt,
+        ]
+        if ritmo and ritmo != "+0%":
+            cmd += ["--rate", ritmo]
+        if tom and tom != "+0Hz":
+            cmd += ["--pitch", tom]
+
+        r = subprocess.run(cmd, capture_output=True, timeout=300)
+        if r.returncode != 0 or not Path(saida).exists():
+            return {"ok": False, "error": (r.stderr or b"").decode("utf-8", "ignore")[-400:]}
+
+        falas = ler_legendas(vtt)
+        return {
+            "ok": True,
+            "arquivo": str(saida),
+            "motor": "edge",
+            "voz": voz,
+            "segundos": round(falas[-1]["ate"], 3) if falas else None,
+            "falas": [{"de": round(f["de"], 3), "ate": round(f["ate"], 3), "texto": f["texto"]}
+                      for f in falas],
+        }
+
+
+def falar_elevenlabs(texto, saida, voz):
+    """Só quando há chave. Sem ela, nem se tenta — e não é erro."""
+    chave = os.environ.get("ELEVENLABS_API_KEY", "").strip()
+    if not chave:
+        return None
+    try:
+        sys.path.insert(0, str(AQUI))
+        import elevenlabs  # o módulo que já existia no Studio
+        r = elevenlabs.falar(texto, str(saida), voz=voz, chave=chave)
+        if r and r.get("ok"):
+            r["motor"] = "elevenlabs"
+            return r
+    except Exception:
+        pass
+    return None
+
+
+def comando_falar(args):
+    texto = args.texto
+    if args.arquivo:
+        texto = Path(args.arquivo).read_text(encoding="utf-8")
+    texto = re.sub(r"\s+", " ", (texto or "")).strip()
+    if not texto:
+        return {"ok": False, "error": "não há texto para narrar"}
+
+    v = voz_de(args.voz)
+    estilo = ESTILOS.get((args.estilo or "normal").lower(), ESTILOS["normal"])
+    ritmo = args.ritmo or estilo["ritmo"]
+    tom = args.tom or estilo["tom"]
+
+    premium = falar_elevenlabs(texto, args.saida, v["id"])
+    if premium:
+        return premium
+
+    if not edge_disponivel() and not instalar_edge():
+        return {
+            "ok": False,
+            "error": "a narração precisa do pacote edge-tts, e não deu para instalá-lo aqui.",
+            "comoResolver": f"{sys.executable} -m pip install edge-tts"
+                            + (" (no Debian/Ubuntu ou no Homebrew, acrescente --break-system-packages)"
+                               if "externally-managed" in ultimo_erro_pip else ""),
+            "erroDoPip": ultimo_erro_pip or None,
+        }
+
+    return falar_edge(texto, args.saida, v["voz"], ritmo, tom)
+
+
+def main():
+    p = argparse.ArgumentParser(description="Narração do PrimoCode Studio")
+    sub = p.add_subparsers(dest="comando", required=True)
+
+    f = sub.add_parser("falar")
+    f.add_argument("--texto", default="")
+    f.add_argument("--arquivo", default="")
+    f.add_argument("--saida", required=True)
+    f.add_argument("--voz", default="antonio")
+    f.add_argument("--estilo", default="normal")
+    f.add_argument("--ritmo", default="")
+    f.add_argument("--tom", default="")
+
+    sub.add_parser("vozes")
+
+    args = p.parse_args()
+    if args.comando == "vozes":
+        saida = {"ok": True, "vozes": VOZES, "estilos": list(ESTILOS.keys())}
+    else:
+        saida = comando_falar(args)
+
+    print(json.dumps(saida, ensure_ascii=False))
+    sys.exit(0 if saida.get("ok") else 1)
+
+
+if __name__ == "__main__":
+    main()

package/studio/pessoa.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""pessoa.py — tirar você do fundo do seu próprio vídeo.
+
+    "Recorte de pessoa: segmentar meu rosto/corpo e trocar o fundo por uma
+     imagem relacionada ao que estou falando (ex.: falando sobre o olho →
+     imagem do olho no fundo)."
+
+── POR QUE ISTO NÃO É FEITO COM ffmpeg ──────────────────────────────────────
+O ffmpeg sabe fazer chroma key: tirar um fundo VERDE. Ele não sabe olhar um
+quadro e dizer onde termina a pessoa e começa a parede — isso é trabalho de
+modelo de visão, quadro a quadro.
+
+O MediaPipe faz exatamente isso, roda no computador da pessoa, é grátis e não
+precisa de chave. O custo é o download do modelo na primeira vez.
+
+── O QUE SAI DAQUI ──────────────────────────────────────────────────────────
+Um .webm com CANAL ALFA: a pessoa recortada, e transparência no lugar do
+fundo. Ele não é o resultado final — é a peça que o `video.sobreporAlfa`
+costura sobre a imagem escolhida, ou que entra como elemento de vídeo numa
+cena com qualquer coisa atrás.
+
+Separar assim é de propósito: o recorte é caro (segundos por segundo de
+vídeo) e o fundo muda de ideia. Recortar uma vez e testar cinco fundos custa
+um recorte; recortar junto com o fundo custa cinco.
+
+── A BORDA É O QUE DENUNCIA ─────────────────────────────────────────────────
+Recorte automático erra na borda do cabelo, e o erro aparece como um contorno
+duro, tipo adesivo. Duas defesas: suavizar a máscara (desfoque leve) e
+encolhê-la um pouco, para o corte cair um fio DENTRO da pessoa em vez de
+pegar um halo da parede.
+
+Uso:
+    python3 pessoa.py recortar --entrada gravacao.mp4 --saida pessoa.webm
+    python3 pessoa.py conferir
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+
+
+def faltando():
+    """O que precisa estar instalado, e não está."""
+    falta = []
+    for modulo, pacote in (("cv2", "opencv-python"), ("mediapipe", "mediapipe"), ("numpy", "numpy")):
+        try:
+            __import__(modulo)
+        except ImportError:
+            falta.append(pacote)
+    return falta
+
+
+def instalar(pacotes):
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "install", "--quiet", *pacotes],
+                       capture_output=True, timeout=900, check=True)
+        return not faltando()
+    except Exception:
+        return False
+
+
+def recortar(entrada, saida, suavizar=7, encolher=2, limiar=0.6):
+    import cv2
+    import numpy as np
+    import mediapipe as mp
+
+    captura = cv2.VideoCapture(entrada)
+    if not captura.isOpened():
+        return {"ok": False, "error": f"não consegui abrir {entrada}"}
+
+    fps = captura.get(cv2.CAP_PROP_FPS) or 30
+    largura = int(captura.get(cv2.CAP_PROP_FRAME_WIDTH))
+    altura = int(captura.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total = int(captura.get(cv2.CAP_PROP_FRAME_COUNT)) or 0
+
+    # VP9 num .webm é o formato de vídeo com transparência que o Chromium do
+    # Remotion abre — e é o Chromium dele que vai desenhar isto.
+    escritor = subprocess.Popen(
+        ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+         "-f", "rawvideo", "-pix_fmt", "bgra",
+         "-s", f"{largura}x{altura}", "-r", str(fps), "-i", "-",
+         "-c:v", "libvpx-vp9", "-pix_fmt", "yuva420p", "-b:v", "3M",
+         "-auto-alt-ref", "0", saida],
+        stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    segmentador = mp.solutions.selfie_segmentation.SelfieSegmentation(model_selection=1)
+    nucleo = np.ones((3, 3), np.uint8)
+    feitos = 0
+
+    try:
+        while True:
+            ok, quadro = captura.read()
+            if not ok:
+                break
+            resultado = segmentador.process(cv2.cvtColor(quadro, cv2.COLOR_BGR2RGB))
+            mascara = (resultado.segmentation_mask > limiar).astype(np.uint8) * 255
+
+            # Encolher: o corte cai um fio DENTRO da pessoa, em vez de levar
+            # um halo da parede junto — é o halo que faz parecer adesivo.
+            if encolher > 0:
+                mascara = cv2.erode(mascara, nucleo, iterations=int(encolher))
+            # Suavizar: borda dura no cabelo é o segundo sinal de recorte
+            # automático. Ímpar porque o desfoque gaussiano exige.
+            if suavizar > 0:
+                k = int(suavizar) | 1
+                mascara = cv2.GaussianBlur(mascara, (k, k), 0)
+
+            bgra = cv2.cvtColor(quadro, cv2.COLOR_BGR2BGRA)
+            bgra[:, :, 3] = mascara
+            escritor.stdin.write(bgra.tobytes())
+            feitos += 1
+    finally:
+        try:
+            escritor.stdin.close()
+        except Exception:
+            pass
+        captura.release()
+        segmentador.close()
+
+    escritor.wait()
+    if escritor.returncode != 0:
+        erro = (escritor.stderr.read() or b"").decode("utf-8", "ignore")[-400:]
+        return {"ok": False, "error": f"o ffmpeg recusou o recorte: {erro}"}
+
+    return {"ok": True, "arquivo": saida, "quadros": feitos,
+            "segundos": round(feitos / fps, 2) if fps else None,
+            "largura": largura, "altura": altura, "fps": round(fps, 2)}
+
+
+def main():
+    p = argparse.ArgumentParser(description="Recorte de pessoa do PrimoCode Studio")
+    sub = p.add_subparsers(dest="comando", required=True)
+    sub.add_parser("conferir")
+    r = sub.add_parser("recortar")
+    r.add_argument("--entrada", required=True)
+    r.add_argument("--saida", required=True)
+    r.add_argument("--suavizar", type=int, default=7)
+    r.add_argument("--encolher", type=int, default=2)
+    r.add_argument("--limiar", type=float, default=0.6)
+    args = p.parse_args()
+
+    falta = faltando()
+
+    if args.comando == "conferir":
+        saida = {"ok": not falta, "falta": falta,
+                 "comoResolver": f"{sys.executable} -m pip install " + " ".join(falta) if falta else None}
+    else:
+        if falta:
+            # A instalação é pesada (o MediaPipe passa de 100 MB) e demora.
+            # Tentar em silêncio seria uma tarefa parada sem explicação; por
+            # isso o aviso sai ANTES, na saída de erro, que o agente mostra.
+            print(f"instalando {', '.join(falta)} (uma vez, alguns minutos)…", file=sys.stderr)
+            if not instalar(falta):
+                saida = {"ok": False,
+                         "error": "o recorte de pessoa precisa do MediaPipe, e não deu para instalá-lo.",
+                         "comoResolver": f"{sys.executable} -m pip install " + " ".join(falta)}
+                print(json.dumps(saida, ensure_ascii=False))
+                sys.exit(1)
+        saida = recortar(args.entrada, args.saida, args.suavizar, args.encolher, args.limiar)
+
+    print(json.dumps(saida, ensure_ascii=False))
+    sys.exit(0 if saida.get("ok") else 1)
+
+
+if __name__ == "__main__":
+    main()