primocode 9.10.0 → 10.0.0

package/lib/painel.js

@@ -1,291 +0,0 @@
-/**
- * painel.js — o painel da direita da janela: a prévia do site e os arquivos.
- *
- *   "Remove a IDE ou deixa idêntico ao Codex."
- *
- * Antes isto era a PrimoCode IDE: árvore, EDITOR de código, prévia e chat. O
- * editor saiu. Quem usa o PrimoCode não programa — um editor de código na
- * cara dessa pessoa é uma porta para quebrar o que o agente fez, sem saber
- * como voltar. O que ficou é o que ela usa de verdade: ver o site que está
- * nascendo (Prévia) e olhar o que tem na pasta (Arquivos), só leitura.
- *
- * ── POR QUE MORA DENTRO DO SERVIDOR DA JANELA ────────────────────────────
- * A janela (lib/app.js) já resolveu o difícil: 127.0.0.1, chave sorteada e o
- * fluxo de eventos (SSE). Aqui só entram as rotas do painel (árvore, ler,
- * prévia) e o vigia da pasta, que empurra "arquivo mudou" pelo MESMO fluxo —
- * é o que faz a prévia recarregar enquanto o agente escreve.
- *
- * ── SEGURANÇA ────────────────────────────────────────────────────────────
- *   · a chave do app.js vale aqui também (tudo mora em /api/);
- *   · todo caminho é resolvido DENTRO da pasta do projeto — "../", caminho
- *     absoluto e link simbólico que aponta para fora são recusados;
- *   · nada aqui escreve no disco: sem editor, não há rota de salvar;
- *   · a prévia roda num iframe sandbox SEM allow-same-origin, e o servidor
- *     manda o mesmo sandbox no cabeçalho. O código da prévia foi escrito pelo
- *     agente; se ele herdasse a origem da janela, poderia chamar /api/enviar
- *     e dar ordens ao agente. Com origem opaca, o fetch dele sai com
- *     `Origin: null` e o app.js recusa.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-/* O que a árvore não mostra e o vigia não escuta. node_modules sozinho tem
-   dezenas de milhares de arquivos: listar travaria a janela, e vigiar faria
-   cada `npm install` virar uma avalanche de eventos. */
-const IGNORADOS = new Set(['node_modules', '.git', '.DS_Store', '.next', '.cache',
-    '__pycache__', '.venv', 'venv', '.turbo', '.parcel-cache']);
-const MAX_ITENS = 4000;
-const MAX_PROFUNDIDADE = 12;
-// 1 MB: acima disso o visualizador engasga, e arquivo desse tamanho num
-// projeto de iniciante é quase sempre gerado (bundle, dado).
-const MAX_LEITURA = 1024 * 1024;
-
-// ── caminhos ─────────────────────────────────────────────────────────────
-
-/* Resolve `relativo` dentro de `raiz`, ou devolve null.
- *
- * `path.relative` pega o "../" e o caminho absoluto; o `realpath` pega o link
- * simbólico, que passa pelo primeiro teste com cara de arquivo de dentro e
- * aponta para ~/.ssh. Caminho que ainda não existe é checado
- * pela pasta onde vai nascer. */
-function dentro(raiz, relativo) {
-    if (typeof relativo !== 'string' || relativo.includes('\0')) return null;
-    // Absoluto é recusado de cara, e não "reinterpretado" como relativo:
-    // quem manda /etc/hosts quer o /etc/hosts, e ler <projeto>/etc/hosts
-    // no lugar seria uma surpresa. `C:\` e `\\servidor` também contam.
-    if (path.isAbsolute(relativo) || path.win32.isAbsolute(relativo)) return null;
-    const base = path.resolve(raiz);
-    const alvo = path.resolve(base, relativo);
-    if (!contido(base, alvo)) return null;
-    let real = base;
-    try { real = fs.realpathSync(base); } catch { return null; }
-    let existente = alvo;
-    while (!fs.existsSync(existente) && existente !== base) existente = path.dirname(existente);
-    try {
-        if (!contido(real, fs.realpathSync(existente))) return null;
-    } catch { return null; }
-    return alvo;
-}
-
-function contido(base, alvo) {
-    const rel = path.relative(base, alvo);
-    return rel === '' || (rel !== '..' && !rel.startsWith('..' + path.sep) && !path.isAbsolute(rel));
-}
-
-function relativoDe(raiz, abs) {
-    return path.relative(raiz, abs).split(path.sep).join('/');
-}
-
-function ignorado(rel) {
-    return rel.split(/[/\\]/).some((p) => IGNORADOS.has(p));
-}
-
-// ── árvore ───────────────────────────────────────────────────────────────
-
-/* Lista plana, pastas antes de arquivos, em ordem alfabética. Plana porque a
-   página monta a árvore dela do jeito que quiser, e o teste confere sem ter de
-   descer em objetos aninhados. */
-function arvore(raiz) {
-    const itens = [];
-    let cortada = false;
-    function andar(dir, prof) {
-        if (prof > MAX_PROFUNDIDADE || cortada) return;
-        let entradas;
-        try { entradas = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
-        entradas = entradas.filter((e) => !IGNORADOS.has(e.name));
-        entradas.sort((a, b) => (b.isDirectory() - a.isDirectory())
-            || a.name.localeCompare(b.name, 'pt-BR', { sensitivity: 'base' }));
-        for (const e of entradas) {
-            if (itens.length >= MAX_ITENS) { cortada = true; return; }
-            const abs = path.join(dir, e.name);
-            const rel = relativoDe(raiz, abs);
-            if (e.isDirectory()) {
-                itens.push({ caminho: rel, tipo: 'pasta' });
-                andar(abs, prof + 1);
-            } else if (e.isFile()) {
-                let tamanho = 0;
-                try { tamanho = fs.statSync(abs).size; } catch {}
-                itens.push({ caminho: rel, tipo: 'arquivo', tamanho });
-            }
-        }
-    }
-    andar(raiz, 0);
-    return { itens, cortada };
-}
-
-// ── ler ──────────────────────────────────────────────────────────────────
-
-/* Binário é o que tem byte zero nos primeiros 8 KB — o mesmo teste do git.
-   Mostrar um PNG como texto é uma tela de lixo que parece arquivo quebrado. */
-function ehBinario(buf) {
-    const n = Math.min(buf.length, 8000);
-    for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
-    return false;
-}
-
-function ler(raiz, rel) {
-    const abs = dentro(raiz, rel);
-    if (!abs) return { status: 403, corpo: { ok: false, error: 'fora da pasta do projeto' } };
-    let st;
-    try { st = fs.statSync(abs); } catch { return { status: 404, corpo: { ok: false, error: 'não existe' } }; }
-    if (!st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
-    const base = { ok: true, caminho: relativoDe(raiz, abs), tamanho: st.size, mtime: st.mtimeMs };
-    if (st.size > MAX_LEITURA) return { status: 200, corpo: Object.assign(base, { grande: true }) };
-    const buf = fs.readFileSync(abs);
-    if (ehBinario(buf)) return { status: 200, corpo: Object.assign(base, { binario: true }) };
-    return { status: 200, corpo: Object.assign(base, { conteudo: buf.toString('utf8') }) };
-}
-
-// ── prévia ───────────────────────────────────────────────────────────────
-
-const TIPOS = {
-    '.html': 'text/html; charset=utf-8', '.htm': 'text/html; charset=utf-8',
-    '.css': 'text/css; charset=utf-8', '.js': 'application/javascript; charset=utf-8',
-    '.mjs': 'application/javascript; charset=utf-8', '.json': 'application/json; charset=utf-8',
-    '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif', '.webp': 'image/webp', '.ico': 'image/x-icon', '.txt': 'text/plain; charset=utf-8',
-    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.mp4': 'video/mp4', '.webm': 'video/webm',
-    '.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf', '.md': 'text/plain; charset=utf-8',
-};
-
-/* Onde está a página de entrada do projeto. index.html na raiz é o caso de
-   quase todo pedido ("crie um site"); os kits de Vite e afins põem em public/
-   ou src/. Sem nenhum, a prévia diz isso em vez de mostrar um 404. */
-function entradaDaPrevia(raiz) {
-    for (const c of ['index.html', 'public/index.html', 'src/index.html', 'dist/index.html']) {
-        if (fs.existsSync(path.join(raiz, c))) return c;
-    }
-    return null;
-}
-
-function servirPrevia(raiz, rel, res) {
-    const abs = dentro(raiz, decodeURIComponent(rel || '') || 'index.html');
-    const alvo = abs && fs.existsSync(abs) && fs.statSync(abs).isDirectory() ? path.join(abs, 'index.html') : abs;
-    if (!alvo || !fs.existsSync(alvo)) {
-        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-        return res.end('não encontrado');
-    }
-    res.writeHead(200, {
-        'Content-Type': TIPOS[path.extname(alvo).toLowerCase()] || 'application/octet-stream',
-        'Cache-Control': 'no-store',
-        // O mesmo sandbox do iframe, dito pelo servidor: vale até se alguém
-        // abrir o endereço da prévia fora da janela.
-        'Content-Security-Policy': 'sandbox allow-scripts allow-forms allow-modals allow-popups allow-pointer-lock',
-    });
-    fs.createReadStream(alvo).pipe(res);
-}
-
-// ── vigia ────────────────────────────────────────────────────────────────
-
-/* fs.watch recursivo existe no Mac e no Windows desde sempre e no Linux desde
-   o Node 20. Onde não existe, vigia só a raiz — a prévia de um index.html
-   continua acompanhando, que é o que mais importa.
-
-   Os eventos vêm em rajada (um write vira 2–3 avisos, um `npm run build` vira
-   centenas), então juntam-se por 150 ms e saem numa mensagem só. */
-function vigiar(raiz, aoMudar, espera = 150) {
-    const pendentes = new Set();
-    let timer = null;
-    const soltar = () => {
-        timer = null;
-        const lista = [...pendentes];
-        pendentes.clear();
-        if (lista.length) aoMudar(lista);
-    };
-    const anotar = (_tipo, nome) => {
-        if (!nome) return;
-        const rel = String(nome).split(path.sep).join('/');
-        if (ignorado(rel)) return;
-        pendentes.add(rel);
-        if (!timer) timer = setTimeout(soltar, espera);
-    };
-    let vigia;
-    try { vigia = fs.watch(raiz, { recursive: true }, anotar); } catch {
-        try { vigia = fs.watch(raiz, anotar); } catch { return () => {}; }
-    }
-    vigia.on('error', () => {});
-    return function parar() {
-        try { vigia.close(); } catch {}
-        if (timer) clearTimeout(timer);
-    };
-}
-
-// ── as rotas ─────────────────────────────────────────────────────────────
-
-/**
- * Monta o painel num servidor do app.js.
- *
- * @param {object} op
- * @param {()=>string} op.pasta   a pasta do projeto AGORA (o /dir muda ela)
- * @param {(evento:string, dados:any)=>void} op.emitir  o fluxo SSE do app.js
- * @returns {{atender:Function, fechar:Function, conferirPasta:Function}}
- */
-function montar(op) {
-    let pastaVigiada = null;
-    let pararVigia = () => {};
-
-    function conferirPasta() {
-        const atual = op.pasta && op.pasta();
-        if (!atual || atual === pastaVigiada) return atual;
-        pararVigia();
-        pastaVigiada = atual;
-        if (!fs.existsSync(atual)) { pararVigia = () => {}; return atual; }
-        pararVigia = vigiar(atual, (mudados) => op.emitir('arquivos', { pasta: atual, mudados }));
-        op.emitir('arquivos', { pasta: atual, mudados: [], trocou: true });
-        return atual;
-    }
-    /* O /dir e os projetos da barra lateral trocam a pasta sem passar por
-       aqui: sem esta ronda o painel vigiaria o projeto anterior. E só depois
-       que o painel foi aberto de verdade — no Linux o fs.watch recursivo custa
-       um aviso do sistema por pasta, e quem só conversa não precisa disso. */
-    let usada = false;
-    const ronda = setInterval(() => { if (usada) conferirPasta(); }, 2000);
-    if (ronda.unref) ronda.unref();
-
-    function json(res, status, corpo) {
-        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
-        res.end(JSON.stringify(corpo));
-    }
-
-    /* Devolve true se a rota era do painel. A chave já foi conferida pelo
-       app.js antes de chegar aqui — por isso a prévia também mora em /api/. */
-    async function atender(req, res, url) {
-        const rota = url.pathname;
-        const ehArquivos = rota.startsWith('/api/arquivos/');
-        const m = rota.match(/^\/api\/previa\/[0-9a-f]+\/?(.*)$/);
-        if (!ehArquivos && !m) return false;
-        usada = true;
-        const raiz = conferirPasta();
-        if (!raiz || !fs.existsSync(raiz)) { json(res, 404, { ok: false, error: 'sem pasta de projeto' }); return true; }
-
-        if (rota === '/api/arquivos/arvore') {
-            const a = arvore(raiz);
-            json(res, 200, { ok: true, pasta: raiz, nome: path.basename(raiz), itens: a.itens,
-                cortada: a.cortada, entrada: entradaDaPrevia(raiz) });
-            return true;
-        }
-        if (rota === '/api/arquivos/ler') {
-            const r = ler(raiz, url.searchParams.get('p') || '');
-            json(res, r.status, r.corpo);
-            return true;
-        }
-        /* /api/previa/<chave>/<caminho>: a chave vai no CAMINHO, não na
-           query, porque a página da prévia pede style.css e script.js por
-           endereço relativo — e o relativo herda o caminho, não a query. */
-        if (m) { servirPrevia(raiz, m[1], res); return true; }
-
-        json(res, 404, { ok: false, error: 'rota desconhecida' });
-        return true;
-    }
-
-    return {
-        atender,
-        conferirPasta,
-        fechar() { clearInterval(ronda); pararVigia(); },
-    };
-}
-
-module.exports = { montar, dentro, arvore, ler, vigiar, ehBinario, entradaDaPrevia, MAX_LEITURA };

package/voz/primo_voz/desperta.py

@@ -1,195 +0,0 @@
-"""desperta.py — ouvir o nome, e só o nome, sem mandar áudio para lugar nenhum.
-
-── POR QUE OFFLINE, E POR QUE ISSO NÃO É DETALHE ───────────────────────────
-No modo de espera o microfone fica ABERTO o tempo todo. Existem dois jeitos de
-saber se alguém disse "ei, primo":
-
-  1. Mandar tudo o que o microfone ouve para um servidor transcrever.
-  2. Reconhecer a palavra aqui dentro, sem nada sair da máquina.
-
-O primeiro funciona e é mais simples de escrever. Também significa que TODA
-conversa perto do computador — a ligação, a reunião, a briga em casa — sobe
-para um servidor, o dia inteiro, para que uma vez por hora alguém diga o nome
-do programa. Isso não é uma troca aceitável, e não é decisão que um programa
-toma pelo dono da máquina.
-
-Então é o segundo. O Vosk roda local, o modelo mora no disco da pessoa, e
-NADA sai daqui enquanto o nome não for dito. Depois do nome, sim: a frase vai
-para a transcrição, como no modo normal — mas aí foi a pessoa que chamou.
-
-── A GRAMÁTICA RESTRITA ────────────────────────────────────────────────────
-O reconhecedor é criado sabendo APENAS as palavras de despertar. Não é
-otimização: é o que impede ele de "ouvir" o nome no meio de uma frase
-qualquer. Um reconhecedor livre transcreve tudo e depois se procura a palavra
-no texto — e aí "prima", "primeiro" e "exprimo" acordam o assistente. Com a
-gramática restrita ele só pode devolver uma das palavras da lista ou "[unk]".
-
-Herdado do Jarvis (src/jarvis/core/wake.py), que resolveu isto primeiro; o
-modelo aqui é o de PORTUGUÊS, porque "primo" é palavra portuguesa — ao
-contrário de "Jarvis", que é nome inglês e por isso lá usava o modelo de
-inglês.
-"""
-from __future__ import annotations
-
-import json
-import os
-import threading
-import urllib.request
-import zipfile
-from pathlib import Path
-from typing import Callable, Optional
-
-TAXA = 16000
-
-# Onde o modelo mora. Fora do pacote npm de propósito: são 31 MB, e um pacote
-# que engorda 31 MB para todo mundo por causa de um modo que nem todos usam é
-# um pacote que demora a instalar para todo mundo.
-PASTA_MODELO = Path.home() / ".primocode" / "modelos"
-NOME_MODELO = "vosk-model-small-pt-0.3"
-URL_MODELO = f"https://alphacephei.com/vosk/models/{NOME_MODELO}.zip"
-
-# O que ACORDA. Variantes porque o reconhecedor pequeno erra a vogal átona, e
-# porque as pessoas falam de jeitos diferentes ("ei primo", "oi primo", "ô
-# primo"). O "primo" sozinho entra: dentro da gramática restrita ele não
-# dispara em conversa comum, porque o reconhecedor não transcreve conversa
-# comum — só consegue devolver estas palavras.
-VOCABULARIO = ("primo", "ei", "oi", "olá", "ô")
-DESPERTA = ("primo",)
-
-
-def caminho_do_modelo() -> Path:
-    return PASTA_MODELO / NOME_MODELO
-
-
-def tem_modelo() -> bool:
-    caminho = caminho_do_modelo()
-    return caminho.is_dir() and any(caminho.iterdir())
-
-
-def baixar_modelo(aoFalar: Optional[Callable[[str], None]] = None) -> dict:
-    """Traz o modelo, uma vez. ~31 MB.
-
-    Baixa para um arquivo temporário e só então move para o lugar: interromper
-    no meio deixaria uma pasta pela metade que `tem_modelo()` daria por boa, e
-    o erro apareceria depois, como "falha ao carregar o Vosk".
-    """
-    fala = aoFalar or (lambda _t: None)
-    if tem_modelo():
-        return {"ok": True, "jaTinha": True}
-    try:
-        PASTA_MODELO.mkdir(parents=True, exist_ok=True)
-        temporario = PASTA_MODELO / (NOME_MODELO + ".zip.parcial")
-        fala("baixando o reconhecedor de voz (uma vez, ~31 MB)")
-        with urllib.request.urlopen(URL_MODELO, timeout=120) as resposta, open(temporario, "wb") as saida:
-            while True:
-                pedaco = resposta.read(1 << 16)
-                if not pedaco:
-                    break
-                saida.write(pedaco)
-        fala("descompactando")
-        with zipfile.ZipFile(temporario) as z:
-            z.extractall(PASTA_MODELO)
-        temporario.unlink(missing_ok=True)
-        if not tem_modelo():
-            return {"ok": False, "error": "o modelo baixou mas não apareceu onde devia"}
-        return {"ok": True}
-    except Exception as e:
-        return {"ok": False, "error": str(e),
-                "comoResolver": f"baixe {URL_MODELO} à mão e descompacte em {PASTA_MODELO}"}
-
-
-def contem_nome(texto: str) -> bool:
-    """O texto que o reconhecedor devolveu contém o nome?
-
-    Comparação por PALAVRA INTEIRA. Com `in` de substring, "prima" e
-    "primeiro" acordariam o assistente — e a gramática restrita não protege
-    disso sozinha, porque ela devolve as palavras da lista e o resto vira
-    "[unk]", que pode vir colado.
-    """
-    palavras = set(str(texto or "").lower().replace("[unk]", " ").split())
-    return any(n in palavras for n in DESPERTA)
-
-
-class Desperta:
-    """Escuta o nome. Nada sai da máquina até ele ser dito."""
-
-    def __init__(self, ao_despertar: Callable[[], None]) -> None:
-        self.ao_despertar = ao_despertar
-        self._rec = None
-        self._modelo = None
-        self.pronto = False
-        self.ligado = True
-        self.motivo = ""
-        # O reconhecedor do Vosk NÃO é seguro entre threads: a do áudio chama
-        # process() dez vezes por segundo enquanto o laço principal pode
-        # chamar reset() ao despertar. Sem trava, o estado interno corrompe e
-        # ele passa a levantar "Failed to process waveform" — sintoma que não
-        # fala de thread nenhuma, e por isso custa caro de achar.
-        self._trava = threading.Lock()
-        self._carregar()
-
-    def _carregar(self) -> None:
-        if not tem_modelo():
-            self.motivo = "o reconhecedor de voz não está baixado"
-            return
-        try:
-            import vosk
-            vosk.SetLogLevel(-1)
-            self._modelo = vosk.Model(str(caminho_do_modelo()))
-            self._rec = self._novo()
-            self.pronto = True
-        except ImportError:
-            self.motivo = "falta o vosk (pip install vosk)"
-        except Exception as e:
-            self.motivo = f"não consegui carregar o reconhecedor: {e}"
-
-    def _novo(self):
-        import vosk
-        gramatica = json.dumps(sorted({*VOCABULARIO, "[unk]"}))
-        return vosk.KaldiRecognizer(self._modelo, TAXA, gramatica)
-
-    def alimentar(self, bloco) -> bool:
-        """Um bloco de áudio. Devolve True se o nome foi dito."""
-        if not self.pronto or self._rec is None or not self.ligado:
-            return False
-        with self._trava:
-            try:
-                if self._rec.AcceptWaveform(bloco.tobytes()):
-                    texto = json.loads(self._rec.Result()).get("text", "")
-                else:
-                    texto = json.loads(self._rec.PartialResult()).get("partial", "")
-            except Exception:
-                # Reconhecedor travado: recria e segue. Desligar o modo de
-                # espera por causa de um bloco ruim seria perder o recurso
-                # inteiro por um soluço de áudio.
-                try:
-                    self._rec = self._novo()
-                except Exception:
-                    self.pronto = False
-                    self.motivo = "o reconhecedor parou e não voltou"
-                return False
-
-            achou = bool(texto and contem_nome(texto))
-            if achou:
-                self._rec.Reset()
-
-        if achou:
-            try:
-                self.ao_despertar()
-            except Exception:
-                pass
-        return achou
-
-    def zerar(self) -> None:
-        """Esquece o que ouviu até agora.
-
-        Chamado ao voltar do atendimento: sem isso, o resto da frase que a
-        pessoa falou DEPOIS do nome ainda está no reconhecedor, e ele desperta
-        de novo no instante seguinte.
-        """
-        with self._trava:
-            if self._rec is not None:
-                try:
-                    self._rec.Reset()
-                except Exception:
-                    pass