primocode 8.42.2 → 9.1.0

package/voz/primo_voz/orbe.py

@@ -0,0 +1,216 @@
+"""orbe.py — a interface inteira: um núcleo pequeno e um fundo fosco.
+
+    "Redesenhar a interface: nada de fundo escuro cheio de elementos. Apenas
+     um núcleo pequeno, tipo uma orb, com um fundo fosco/desfocado por trás.
+     Ocultar transcrição, chat e qualquer painel. É só a orb e o áudio."
+
+── O QUE ISTO NÃO TEM ──────────────────────────────────────────────────────
+Não há transcrição do que você falou, não há legenda do que ele está fazendo,
+não há resposta escrita, não há janela de conversa, não há barra de comando.
+Não é economia de trabalho: ler a resposta de um assistente de voz é trabalho,
+e ouvir não é. Se a interface mostrasse o texto, a pessoa leria — e aí o modo
+voz vira um chat com um microfone.
+
+O que a orb comunica é o ESTADO, por cor e movimento: parada quando espera,
+pulsando quando ouve, girando devagar quando pensa, brilhando quando fala.
+Quatro estados, nenhuma palavra.
+
+── POR QUE tkinter ─────────────────────────────────────────────────────────
+Ele vem com o Python. Qualquer outra escolha (Qt, GTK, pywebview, Electron)
+significaria dezenas ou centenas de megabytes para desenhar um círculo — e o
+`/voice` já precisa instalar sounddevice e numpy. Cada dependência a mais é
+uma chance a mais de o modo voz não abrir na máquina de alguém.
+
+── O FUNDO FOSCO, E O QUE ELE É DE VERDADE ─────────────────────────────────
+Desfoque real do que está ATRÁS da janela não existe de forma portátil: no
+macOS é NSVisualEffectView, no Windows é DwmEnableBlurBehindWindow, no Linux
+depende do compositor. Nenhum deles está no Python padrão.
+
+O que dá para fazer em todo lugar é uma camada escura semitransparente por
+cima da tela inteira. Não é desfoque; é escurecimento. A diferença aparece num
+fundo cheio de detalhe, e some num fundo comum.
+
+Onde o desfoque de verdade existe sem custo — macOS com pyobjc já instalado —
+ele é usado. Onde não existe, a camada escura entra, e a orb continua sendo o
+que importa. O que não se faz é fingir: nada aqui chama de "desfoque" o que é
+só uma sombra.
+"""
+from __future__ import annotations
+
+import math
+import queue
+import threading
+import tkinter as tk
+from typing import Callable, Optional
+
+# Os quatro estados, e a cor de cada um. A paleta é a do PrimoCode (ciano de
+# marca, âmbar de aviso) para o modo voz não parecer outro produto.
+CORES = {
+    "esperando": ("#0891b2", "#164e63"),   # ciano recuado: pronto, sem pressa
+    "ouvindo":   ("#22d3ee", "#0e7490"),   # ciano vivo: a vez é sua
+    "pensando":  ("#fbbf24", "#78350f"),   # âmbar: ele está trabalhando
+    "falando":   ("#67e8f9", "#0891b2"),   # ciano claro: a voz é dele
+}
+
+TAMANHO = 220          # a janela da orb, em pixels
+RAIO_BASE = 46         # o núcleo
+
+
+class Orbe:
+    """A janela da orb. Roda na thread principal, como toda interface."""
+
+    def __init__(self, ao_fechar: Optional[Callable] = None):
+        self.raiz = tk.Tk()
+        self.raiz.title("Primo Code Voice")
+        self.estado = "esperando"
+        self.nivel = 0.0          # 0..1, o quanto a pessoa está falando
+        self._fase = 0.0
+        self._fila = queue.Queue()
+        self._ao_fechar = ao_fechar
+        self._vivo = True
+
+        self._montar_veu()
+        self._montar_orbe()
+        self.raiz.protocol("WM_DELETE_WINDOW", self.fechar)
+        self.raiz.bind("<Escape>", lambda e: self.fechar())
+        self._pintar()
+
+    # ── o véu ────────────────────────────────────────────────────────────
+    def _montar_veu(self) -> None:
+        """A camada escura sobre a tela inteira.
+
+        `-alpha` é o único jeito portátil de ter transparência de janela em
+        tkinter, e ele vale para a janela INTEIRA — por isso o véu é uma
+        janela separada da orb: se fossem a mesma, a orb ficaria translúcida
+        junto com o fundo, e um núcleo translúcido some.
+        """
+        self.veu = tk.Toplevel(self.raiz)
+        self.veu.overrideredirect(True)
+        largura = self.veu.winfo_screenwidth()
+        altura = self.veu.winfo_screenheight()
+        self.veu.geometry(f"{largura}x{altura}+0+0")
+        self.veu.configure(bg="#05070a")
+        try:
+            self.veu.attributes("-alpha", 0.72)
+            self.veu.attributes("-topmost", True)
+        except tk.TclError:
+            pass
+        # O véu não recebe clique: a pessoa continua usando o computador por
+        # baixo dele. Onde o sistema não deixa, ele simplesmente cobre.
+        try:
+            self.veu.attributes("-transparent", True)
+        except tk.TclError:
+            pass
+
+    # ── a orb ────────────────────────────────────────────────────────────
+    def _montar_orbe(self) -> None:
+        self.raiz.overrideredirect(True)
+        largura = self.raiz.winfo_screenwidth()
+        altura = self.raiz.winfo_screenheight()
+        x = (largura - TAMANHO) // 2
+        y = (altura - TAMANHO) // 2
+        self.raiz.geometry(f"{TAMANHO}x{TAMANHO}+{x}+{y}")
+        self.raiz.configure(bg="#05070a")
+        try:
+            self.raiz.attributes("-topmost", True)
+            # A cor de fundo vira transparente onde o sistema deixa (Windows),
+            # e no resto ela é a mesma do véu — o que dá o mesmo efeito.
+            self.raiz.attributes("-transparentcolor", "#05070a")
+        except tk.TclError:
+            pass
+
+        self.tela = tk.Canvas(self.raiz, width=TAMANHO, height=TAMANHO,
+                              bg="#05070a", highlightthickness=0)
+        self.tela.pack()
+
+    # ── o desenho ────────────────────────────────────────────────────────
+    def _pintar(self) -> None:
+        if not self._vivo:
+            return
+        while True:
+            try:
+                estado, nivel = self._fila.get_nowait()
+            except queue.Empty:
+                break
+            if estado:
+                self.estado = estado
+            if nivel is not None:
+                self.nivel = max(0.0, min(1.0, nivel))
+
+        self.tela.delete("all")
+        vivo, fundo = CORES.get(self.estado, CORES["esperando"])
+        centro = TAMANHO / 2
+        self._fase += 0.06
+
+        # O movimento é diferente em cada estado, e é ele que diz o que está
+        # acontecendo — sem uma palavra escrita.
+        if self.estado == "ouvindo":
+            # Responde à VOZ: o núcleo cresce com o que ela está falando.
+            raio = RAIO_BASE * (1 + 0.35 * self.nivel)
+            pulso = 1.0
+        elif self.estado == "pensando":
+            # Respiração lenta: trabalho em andamento, sem pressa aparente.
+            raio = RAIO_BASE * (1 + 0.06 * math.sin(self._fase * 0.8))
+            pulso = 0.8 + 0.2 * math.sin(self._fase * 0.8)
+        elif self.estado == "falando":
+            raio = RAIO_BASE * (1 + 0.12 * math.sin(self._fase * 2.4))
+            pulso = 1.0
+        else:
+            raio = RAIO_BASE * (1 + 0.03 * math.sin(self._fase * 0.5))
+            pulso = 0.55
+
+        # O halo: anéis concêntricos cada vez mais fracos. É o que faz a orb
+        # parecer luz em vez de um círculo pintado — tkinter não tem gradiente,
+        # então o degradê é feito com camadas.
+        camadas = 7
+        for i in range(camadas, 0, -1):
+            r = raio * (1 + i * 0.28)
+            cor = self._misturar(fundo, "#05070a", i / camadas * 0.85)
+            self.tela.create_oval(centro - r, centro - r, centro + r, centro + r,
+                                  fill=cor, outline="")
+
+        self.tela.create_oval(centro - raio, centro - raio, centro + raio, centro + raio,
+                              fill=self._misturar(vivo, fundo, 1 - pulso), outline="")
+        # O brilho de cima, deslocado: dá volume à esfera.
+        br = raio * 0.42
+        self.tela.create_oval(centro - br, centro - raio * 0.62,
+                              centro + br * 0.5, centro - raio * 0.05,
+                              fill=self._misturar("#ffffff", vivo, 0.62), outline="")
+
+        self.raiz.after(33, self._pintar)
+
+    @staticmethod
+    def _misturar(a: str, b: str, quanto: float) -> str:
+        """`a` misturado com `b`. tkinter não tem alpha por forma, então a
+        transparência é resolvida na cor."""
+        quanto = max(0.0, min(1.0, quanto))
+        ra, ga, ba = int(a[1:3], 16), int(a[3:5], 16), int(a[5:7], 16)
+        rb, gb, bb = int(b[1:3], 16), int(b[3:5], 16), int(b[5:7], 16)
+        r = round(ra + (rb - ra) * quanto)
+        g = round(ga + (gb - ga) * quanto)
+        bl = round(ba + (bb - ba) * quanto)
+        return f"#{r:02x}{g:02x}{bl:02x}"
+
+    # ── de fora ──────────────────────────────────────────────────────────
+    def mudar(self, estado: Optional[str] = None, nivel: Optional[float] = None) -> None:
+        """Chamado de OUTRAS threads. tkinter não é seguro fora da thread
+        principal, então o que chega vai para uma fila e é lido no desenho."""
+        self._fila.put((estado, nivel))
+
+    def fechar(self) -> None:
+        if not self._vivo:
+            return
+        self._vivo = False
+        if self._ao_fechar:
+            try:
+                self._ao_fechar()
+            except Exception:
+                pass
+        try:
+            self.raiz.quit()
+            self.raiz.destroy()
+        except Exception:
+            pass
+
+    def rodar(self) -> None:
+        self.raiz.mainloop()

package/lib/audio-livre.js

@@ -1,177 +0,0 @@
-/**
- * audio-livre.js — música e efeitos sonoros da internet, com licença.
- *
- * Pedido do dono: "selecione músicas da internet, efeitos sonoros". O que
- * existia era a trilha SINTETIZADA (quatro osciladores e um ruído) e o
- * arquivo do próprio usuário. Faltava o meio: uma faixa de verdade, tocada
- * por gente, que ele não precise ter no disco.
- *
- * ── DE ONDE VEM ──────────────────────────────────────────────────────────
- * Da API do Openverse (openverse.org, mantida pela WordPress Foundation):
- * ela indexa áudio com licença Creative Commons de fontes abertas — música
- * do Jamendo, efeitos do Freesound, arquivos da Wikimedia — e devolve, para
- * cada faixa, a URL do arquivo, a licença e o crédito pronto. Sem chave, sem
- * conta. Não é YouTube nem Spotify: aqui a licença permite usar, e o crédito
- * vai junto para a peça não sair devendo.
- *
- * ── O QUE ELA DEVOLVE ────────────────────────────────────────────────────
- * O arquivo já BAIXADO para a pasta do projeto e ENVIADO ao estúdio: a URL
- * "/midia/…" que entra direto em `trilha.src` ou em `som: {arquivo}`, mais o
- * crédito ("Título — Autor, CC BY 4.0"). A licença decide o que o agente
- * tem de fazer: BY pede o crédito na peça; CC0/PDM não pede nada. Licença
- * NC (não comercial) não entra por padrão — a peça pode ser um anúncio.
- *
- * Zero dependências: o `pegar` do referencia.js, em modo binário.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const referencia = require('./referencia.js');
-
-const API = 'https://api.openverse.org/v1/audio/';
-
-// Licenças que permitem uso comercial sem pedir nada além do crédito.
-const LIVRES = new Set(['by', 'by-sa', 'cc0', 'pdm']);
-const NOME_LICENCA = {
-    by: 'CC BY', 'by-sa': 'CC BY-SA', 'by-nc': 'CC BY-NC', 'by-nd': 'CC BY-ND',
-    'by-nc-sa': 'CC BY-NC-SA', 'by-nc-nd': 'CC BY-NC-ND', cc0: 'CC0', pdm: 'Domínio público',
-};
-
-function slug(t) {
-    return String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
-        .toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'audio';
-}
-
-function credito(f) {
-    const lic = NOME_LICENCA[f.license] || String(f.license || '').toUpperCase();
-    const versao = f.license_version && !/cc0|pdm/.test(f.license) ? ' ' + f.license_version : '';
-    return `${f.title || 'Sem título'} — ${f.creator || 'autor desconhecido'} (${lic}${versao}, via ${f.provider || 'Openverse'})`;
-}
-
-/**
- * Pergunta ao Openverse. `tipo` "musica" restringe à categoria music; "efeito"
- * pede coisa curta (até ~12 s). `dur` em segundos aproxima a duração desejada
- * da trilha — uma faixa de 4 min para um reels de 30 s é desperdício, mas
- * uma de 20 s para um vídeo de 60 s acaba antes; a nota pesa isso.
- */
-async function procurar({ consulta, tipo = 'musica', dur = 0, comercial = true, pagina = 1 }) {
-    const q = new URLSearchParams({ q: consulta, page_size: '20', page: String(pagina) });
-    if (tipo === 'musica') q.set('category', 'music');
-    if (comercial) q.set('license_type', 'commercial');
-    const bruto = await referencia.pegar(`${API}?${q}`, { timeout: 12000 });
-    if (!bruto) return { ok: false, error: 'o Openverse não respondeu (rede?)' };
-    let j;
-    try { j = JSON.parse(bruto); } catch { return { ok: false, error: 'resposta ilegível do Openverse' }; }
-    // `f.url &&` PRECISA valer sempre: sem o parêntese, `&&` liga mais forte
-    // que `||` e `comercial: false` deixava passar item sem url (o download
-    // falhava três vezes e a tool dizia "não consegui baixar") E, pior, faixa
-    // NC dentro de peça comercial — o que a lista LIVRES existe para impedir.
-    const itens = (j.results || []).filter((f) => f.url
-        && (LIVRES.has(String(f.license || '').toLowerCase()) || !comercial));
-    const alvoMs = tipo === 'efeito' ? 2500 : (dur ? dur * 1000 : 90000);
-    const notas = itens.map((f) => {
-        let n = 0;
-        const d = Number(f.duration) || 0;
-        if (tipo === 'efeito') {
-            if (d > 15000) n -= 50;                            // não é efeito, é faixa
-            else n += 20 - Math.abs(d - alvoMs) / 500;
-        } else {
-            if (d && d < alvoMs * 0.6) n -= 20;                // acaba antes do vídeo
-            n -= Math.abs(d - alvoMs) / 20000;                 // perto da duração pedida
-            if (f.category === 'music') n += 5;
-        }
-        if (/cc0|pdm/.test(f.license)) n += 3;                 // sem crédito obrigatório
-        if (/mp3/i.test(f.filetype || '') || /\.mp3(\?|$)/i.test(f.url)) n += 4;   // toca em qualquer lugar
-        // As palavras da consulta no título/tags contam.
-        const alvo = `${f.title} ${(f.tags || []).map((t) => t.name).join(' ')} ${(f.genres || []).join(' ')}`.toLowerCase();
-        for (const p of consulta.toLowerCase().split(/\s+/)) if (p.length > 2 && alvo.includes(p)) n += 3;
-        return { f, n };
-    }).sort((a, b) => b.n - a.n);
-    return {
-        ok: true,
-        total: j.result_count || itens.length,
-        itens: notas.map(({ f }) => ({
-            id: f.id, titulo: f.title, autor: f.creator, licenca: f.license, licencaUrl: f.license_url,
-            duracao: f.duration ? Math.round(f.duration / 1000) : null, url: f.url, pagina: f.foreign_landing_url,
-            provedor: f.provider, tipoArquivo: f.filetype || null, generos: f.genres || [], credito: credito(f),
-        })),
-    };
-}
-
-/** Baixa a faixa para <projeto>/midia/ e manda ao estúdio. */
-async function trazer(item, { projectDir, studio }) {
-    const bytes = await referencia.pegar(item.url, { timeout: 45000, binario: true });
-    if (!bytes || bytes.length < 2000) return { ok: false, error: `não consegui baixar "${item.titulo}" de ${item.provedor}` };
-    // A extensão pelo conteúdo, não pela URL: o Jamendo entrega mp3 numa URL
-    // sem extensão ("?trackid=…&format=mp32").
-    const cab = bytes.subarray(0, 12);
-    const ext = cab.subarray(0, 3).toString() === 'ID3' || (cab[0] === 0xff && (cab[1] & 0xe0) === 0xe0) ? '.mp3'
-        : cab.subarray(0, 4).toString() === 'RIFF' ? '.wav'
-            : cab.subarray(0, 4).toString() === 'OggS' ? '.ogg'
-                : cab.subarray(0, 4).toString() === 'fLaC' ? '.flac'
-                    : (item.tipoArquivo ? '.' + item.tipoArquivo.replace(/^\./, '') : '.mp3');
-    const pasta = path.join(projectDir || process.cwd(), 'midia');
-    fs.mkdirSync(pasta, { recursive: true });
-    const nome = `${slug(item.titulo)}-${String(item.id || '').slice(0, 6)}${ext}`;
-    const caminho = path.join(pasta, nome);
-    fs.writeFileSync(caminho, bytes);
-    // FLAC/OGG do Freesound: o navegador toca, mas o MP4 exportado quer AAC —
-    // o estúdio cuida disso na exportação; aqui só entregamos o arquivo.
-    const envio = await studio.midiaEnviar({ arquivo: caminho, nome });
-    if (!envio || envio.ok === false) return { ok: false, error: (envio && envio.error) || 'o estúdio não aceitou o arquivo', arquivoLocal: caminho };
-    return { ok: true, url: envio.url, arquivoLocal: path.relative(projectDir || process.cwd(), caminho), bytes: bytes.length };
-}
-
-/**
- * A tool: procura, escolhe a melhor, baixa e devolve a URL pronta — e as
- * alternativas, para o agente trocar sem pesquisar de novo.
- */
-async function buscarAudio(args, { projectDir, studio }) {
-    const consulta = String(args.consulta || args.query || '').trim();
-    if (!consulta) return { ok: false, error: 'Diga o que procurar: o clima da música ("upbeat corporate", "piano calmo") ou o efeito ("whoosh", "ding", "click").' };
-    const tipo = /^(efeito|som|sfx|sound)/i.test(String(args.tipo || '')) ? 'efeito' : 'musica';
-    const dur = Number(args.duracao) || 0;
-    const busca = await procurar({ consulta, tipo, dur, comercial: args.comercial !== false });
-    if (!busca.ok) return busca;
-    if (!busca.itens.length) {
-        return {
-            ok: false,
-            error: `Nenhuma faixa livre para "${consulta}".`,
-            comoCorrigir: tipo === 'efeito'
-                ? 'Use um som SINTETIZADO do estúdio, que não precisa de arquivo: som: "whoosh" | "impacto" | "click" | "pop" | "ding" | "subida" | "tique" | "brilho".'
-                : 'Tente a consulta em inglês e mais genérica ("upbeat electronic", "calm piano", "epic cinematic"), ou use a trilha GERADA: "trilha": {"tipo":"gerada","estilo":"pulso"}.',
-        };
-    }
-    // Baixa a melhor; se ela falhar, a próxima. Três tentativas.
-    let trazido = null;
-    let escolhida = null;
-    for (const item of busca.itens.slice(0, 3)) {
-        trazido = await trazer(item, { projectDir, studio });
-        if (trazido.ok) { escolhida = item; break; }
-    }
-    if (!trazido || !trazido.ok) return { ok: false, error: (trazido && trazido.error) || 'não consegui baixar nenhuma faixa', alternativas: busca.itens.slice(0, 5) };
-    const precisaCredito = !/cc0|pdm/.test(escolhida.licenca);
-    return {
-        ok: true,
-        tipo,
-        url: trazido.url,
-        titulo: escolhida.titulo,
-        autor: escolhida.autor,
-        duracao: escolhida.duracao,
-        licenca: NOME_LICENCA[escolhida.licenca] || escolhida.licenca,
-        licencaUrl: escolhida.licencaUrl,
-        credito: escolhida.credito,
-        pagina: escolhida.pagina,
-        arquivoLocal: trazido.arquivoLocal,
-        comoUsar: tipo === 'efeito'
-            ? `No elemento ou na cena: "som": {"arquivo": "${trazido.url}", "volume": 0.8}.`
-            : `No documento: "trilha": {"tipo":"arquivo","src":"${trazido.url}","volume":0.55,"repetir":true}.`
-              + (precisaCredito ? ` A licença pede CRÉDITO: ponha "${escolhida.credito}" na assinatura ou numa legenda da última cena.` : ' Licença sem exigência de crédito.'),
-        alternativas: busca.itens.filter((i) => i.id !== escolhida.id).slice(0, 4)
-            .map((i) => ({ titulo: i.titulo, autor: i.autor, duracao: i.duracao, licenca: i.licenca, id: i.id })),
-    };
-}
-
-module.exports = { buscarAudio, procurar, trazer, credito, LIVRES, NOME_LICENCA };

package/lib/chaves.js

@@ -1,149 +0,0 @@
-/**
- * chaves.js — a chave de API da própria pessoa.
- *
- *   "Você vai usar com a API que já está ali, e pode configurar sua própria
- *    API, por exemplo do Claude, do Codex, etc."
- *
- * ── ONDE ELAS MORAM ──────────────────────────────────────────────────────
- * Em `~/.primocode/chaves.json`, com permissão 600 — o mesmo lugar e o mesmo
- * cuidado da credencial da conta, e pela mesma razão: o `config.json` é o
- * arquivo que alguém abre para conferir um ajuste, cola num chamado de
- * suporte ou copia para outra máquina. Chave junto de preferência é chave que
- * vaza por hábito, não por ataque.
- *
- * ── COMO ELAS CHEGAM AO MOTOR ────────────────────────────────────────────
- * Como VARIÁVEL DE AMBIENTE do processo filho, que é o jeito que o Claude
- * Code e o Codex já leem chave. Não se escreve em arquivo de configuração
- * deles, não se mexe no login que a pessoa já fez: quem não configurar nada
- * aqui continua usando a conta em que entrou nas ferramentas, e quem
- * configurar passa a chave só naquela chamada.
- *
- * ── O QUE NUNCA APARECE ──────────────────────────────────────────────────
- * A chave inteira. Nem ao listar, nem ao salvar, nem numa mensagem de erro. O
- * que se mostra é o suficiente para a pessoa reconhecer qual é (o começo e o
- * fim), porque quem tem três chaves precisa saber qual está ali — e é isso
- * que evita ela colar a chave na tela para conferir.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'chaves.json');
-
-/**
- * Os provedores que o PrimoCode sabe usar, e a variável que cada um lê.
- *
- * O nome da variável é o do provedor, não um inventado aqui: é o que as
- * ferramentas já procuram, e inventar um significaria a chave certa no lugar
- * errado — configurada, aceita, e ignorada na hora de valer.
- */
-const PROVEDORES = {
-    claude: {
-        nome: 'Claude',
-        variavel: 'ANTHROPIC_API_KEY',
-        prefixo: 'sk-ant-',
-        onde: 'https://console.anthropic.com/settings/keys',
-        motor: 'claude-code',
-    },
-    codex: {
-        nome: 'Codex',
-        variavel: 'OPENAI_API_KEY',
-        prefixo: 'sk-',
-        onde: 'https://platform.openai.com/api-keys',
-        motor: 'codex',
-    },
-};
-
-function ler() {
-    try { return JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8')); }
-    catch { return {}; }
-}
-
-function gravar(dados) {
-    const caminho = ARQUIVO();
-    fs.mkdirSync(path.dirname(caminho), { recursive: true });
-    fs.writeFileSync(caminho, JSON.stringify(dados, null, 2), 'utf8');
-    // 600 = só o dono lê. No Windows o modo é ignorado pelo sistema de
-    // arquivos e a chamada não falha — lá quem protege é a pasta do perfil.
-    try { fs.chmodSync(caminho, 0o600); } catch {}
-}
-
-/** O bastante para reconhecer, nunca o bastante para usar. */
-function disfarcar(chave) {
-    const s = String(chave || '');
-    if (s.length <= 12) return '•'.repeat(s.length);
-    return `${s.slice(0, 7)}…${s.slice(-4)}`;
-}
-
-/**
- * Guarda uma chave. Recusa a que claramente não é do provedor pedido — o
- * erro mais comum é colar a do Claude no Codex, e sem esta conferência isso
- * só apareceria como "não autorizado" no meio de uma tarefa, longe da causa.
- */
-function guardar(provedor, chave) {
-    const p = PROVEDORES[provedor];
-    if (!p) return { ok: false, error: `não conheço "${provedor}". Use: ${Object.keys(PROVEDORES).join(', ')}` };
-    const limpa = String(chave || '').trim();
-    if (!limpa) return { ok: false, error: 'a chave veio vazia' };
-    if (limpa.length < 20) return { ok: false, error: 'isso é curto demais para ser uma chave' };
-    if (!limpa.startsWith(p.prefixo)) {
-        return { ok: false,
-            error: `uma chave do ${p.nome} começa com "${p.prefixo}", e essa não. Colou a do outro provedor?` };
-    }
-    // A do Claude também começa com "sk-", então o Codex precisa da recusa
-    // explícita: sem ela, `sk-ant-…` passaria como chave da OpenAI.
-    if (provedor === 'codex' && limpa.startsWith('sk-ant-')) {
-        return { ok: false, error: `essa é uma chave do Claude. Use /chave claude para ela.` };
-    }
-    const tudo = ler();
-    tudo[provedor] = limpa;
-    gravar(tudo);
-    return { ok: true, provedor, nome: p.nome, disfarce: disfarcar(limpa) };
-}
-
-function esquecer(provedor) {
-    const tudo = ler();
-    if (!(provedor in tudo)) return { ok: false, error: `não havia chave do ${provedor}` };
-    delete tudo[provedor];
-    gravar(tudo);
-    return { ok: true };
-}
-
-/** O que está configurado, disfarçado. */
-function listar() {
-    const tudo = ler();
-    return Object.entries(PROVEDORES).map(([id, p]) => ({
-        id, nome: p.nome, variavel: p.variavel, onde: p.onde,
-        tem: typeof tudo[id] === 'string' && tudo[id].length > 0,
-        disfarce: tudo[id] ? disfarcar(tudo[id]) : null,
-    }));
-}
-
-/**
- * O ambiente para rodar o motor de um provedor: o de agora, mais a chave.
- *
- * Sem chave configurada devolve o ambiente INTACTO — nem a variável vazia,
- * que apagaria a chave que a pessoa já tem exportada no shell e faria a
- * ferramenta parar de funcionar por ter sido "configurada".
- */
-function ambienteDe(provedor, base = process.env) {
-    const p = PROVEDORES[provedor];
-    if (!p) return base;
-    const chave = ler()[provedor];
-    if (!chave) return base;
-    return { ...base, [p.variavel]: chave };
-}
-
-/** Qual provedor um motor usa. */
-function provedorDoMotor(motor) {
-    for (const [id, p] of Object.entries(PROVEDORES)) if (p.motor === motor) return id;
-    return null;
-}
-
-module.exports = {
-    PROVEDORES, guardar, esquecer, listar, ambienteDe, disfarcar,
-    provedorDoMotor, ARQUIVO,
-};