primocode 7.15.0 → 7.17.0

package/lib/referencia.js

@@ -0,0 +1,287 @@
+/**
+ * referencia.js — pesquisa de referência antes de escrever código.
+ *
+ * A ideia do dono: em vez de o agente inventar tudo da cabeça, ele consulta o
+ * que já existe sobre o pedido (documentação oficial, exemplos, respostas) e
+ * escreve com esse conhecimento na mão. A qualidade sobe porque ele para de
+ * chutar API que não existe e passa a seguir o padrão real da ferramenta.
+ *
+ * Duas decisões de projeto, deliberadas:
+ *
+ * 1. É VISÍVEL, não oculto. Cada pesquisa aparece no terminal com as fontes
+ *    que ele abriu. Um agente que abre coisas escondido do dono da máquina é
+ *    um agente em que não dá para confiar.
+ *
+ * 2. Ele extrai CONHECIMENTO (como se faz, qual API, que cuidado tomar), não
+ *    blocos de código para colar. Copiar trechos de terceiros para dentro do
+ *    projeto do usuário sem olhar licença é problema jurídico dele, não nosso;
+ *    e código colado de fontes que não conversam entre si é justamente o que
+ *    produz o Frankenstein que não compila. O modelo lê, aprende e ESCREVE.
+ *
+ * Zero dependências: https nativo. Sem chave de API — usa as fontes abertas.
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const net = require('net');
+const tls = require('tls');
+const { URL } = require('url');
+
+const TIMEOUT_MS = 12000;
+const MAX_POR_FONTE = 4;
+const MAX_TEXTO = 4500;
+
+// Rede de empresa costuma exigir proxy. Sem isto, a pesquisa simplesmente não
+// funciona em metade dos computadores corporativos — e o usuário nunca
+// descobre por quê.
+const PROXY = process.env.HTTPS_PROXY || process.env.https_proxy
+    || process.env.HTTP_PROXY || process.env.http_proxy || null;
+
+/** Abre um túnel CONNECT no proxy e devolve o socket TLS pronto. */
+function viaProxy(alvo, { timeout }) {
+    return new Promise((resolve, reject) => {
+        const p = new URL(PROXY);
+        const porta = alvo.port || 443;
+        const req = http.request({
+            host: p.hostname,
+            port: p.port || 80,
+            method: 'CONNECT',
+            path: `${alvo.hostname}:${porta}`,
+            timeout,
+            headers: p.username
+                ? { 'Proxy-Authorization': 'Basic ' + Buffer.from(`${p.username}:${p.password}`).toString('base64') }
+                : {},
+        });
+        req.on('connect', (res, socket) => {
+            if (res.statusCode !== 200) { socket.destroy(); return reject(new Error(`proxy ${res.statusCode}`)); }
+            resolve(tls.connect({ socket, servername: alvo.hostname }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('timeout no proxy')); });
+        req.end();
+    });
+}
+
+function pegar(url, { timeout = TIMEOUT_MS } = {}) {
+    return new Promise((resolve) => {
+        let req;
+        const alvo = (() => { try { return new URL(url); } catch { return null; } })();
+        if (!alvo) return resolve(null);
+
+        const opcoes = {
+            headers: {
+                'User-Agent': 'PrimoCode/1.0 (+https://github.com/ConectaPrimoAI/primocode)',
+                Accept: 'text/html,application/json;q=0.9,*/*;q=0.8',
+            },
+            timeout,
+        };
+
+        // Com proxy, a conexão vai por um túnel CONNECT; sem proxy, direto.
+        const abrir = PROXY && alvo.protocol === 'https:'
+            ? viaProxy(alvo, { timeout }).then((socket) => ({
+                ...opcoes, createConnection: () => socket, host: alvo.hostname, servername: alvo.hostname,
+            })).catch(() => null)
+            : Promise.resolve(opcoes);
+
+        abrir.then((cfg) => {
+            if (!cfg) return resolve(null);
+            try {
+                req = https.get(url, cfg, (res) => {
+                // Redirecionamento: segue uma vez, o suficiente para docs.
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    res.resume();
+                    const destino = new URL(res.headers.location, url).href;
+                    return pegar(destino, { timeout }).then(resolve);
+                }
+                if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+                let corpo = '';
+                res.setEncoding('utf8');
+                res.on('data', (c) => {
+                    corpo += c;
+                    if (corpo.length > 400000) { req.destroy(); }   // página gigante não serve
+                });
+                    res.on('end', () => resolve(corpo));
+                    res.on('error', () => resolve(null));
+                });
+            } catch { return resolve(null); }
+            req.on('timeout', () => { req.destroy(); resolve(null); });
+            req.on('error', () => resolve(null));
+        });
+    });
+}
+
+/** HTML → texto legível. Sem dependência: corta script/style e as tags. */
+function textoDe(html) {
+    return String(html || '')
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<nav[\s\S]*?<\/nav>/gi, ' ')
+        .replace(/<footer[\s\S]*?<\/footer>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+// Links que não são referência de nada — resultado de busca sujo.
+const LIXO = /(facebook|twitter|x)\.com|instagram|pinterest|youtube\.com\/(?!watch)|\/search\?|duckduckgo|bing\.com\/(?!ck)|google\./i;
+
+function limparLinks(pares, limite) {
+    const vistos = new Set();
+    const bons = [];
+    for (const { titulo, url } of pares) {
+        if (!/^https?:\/\//i.test(url) || LIXO.test(url)) continue;
+        const chave = url.replace(/[#?].*$/, '');
+        if (vistos.has(chave)) continue;
+        vistos.add(chave);
+        bons.push({ titulo: titulo.slice(0, 140), url });
+        if (bons.length >= limite) break;
+    }
+    return bons;
+}
+
+/** DuckDuckGo (HTML). O destino vem embrulhado em /l/?uddg=<url>. */
+async function buscarDDG(consulta, limite) {
+    const html = await pegar(`https://duckduckgo.com/html/?q=${encodeURIComponent(consulta)}`);
+    if (!html) return [];
+    const pares = [];
+    const re = /<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let m;
+    while ((m = re.exec(html))) {
+        let href = m[1];
+        const embrulho = href.match(/[?&]uddg=([^&]+)/);
+        if (embrulho) href = decodeURIComponent(embrulho[1]);
+        pares.push({ titulo: textoDe(m[2]), url: href });
+    }
+    return limparLinks(pares, limite);
+}
+
+/** Bing (HTML) — a reserva quando o DDG não responde. */
+async function buscarBing(consulta, limite) {
+    const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`);
+    if (!html) return [];
+    const pares = [];
+    const re = /<h2>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let m;
+    while ((m = re.exec(html))) pares.push({ titulo: textoDe(m[2]), url: m[1] });
+    return limparLinks(pares, limite);
+}
+
+/** SearXNG público, em JSON — a terceira porta. */
+async function buscarSearx(consulta, limite) {
+    const corpo = await pegar(`https://searx.be/search?q=${encodeURIComponent(consulta)}&format=json`);
+    if (!corpo) return [];
+    try {
+        const j = JSON.parse(corpo);
+        return limparLinks((j.results || []).map((r) => ({ titulo: String(r.title || ''), url: String(r.url || '') })), limite);
+    } catch { return []; }
+}
+
+/**
+ * Busca na web. Tenta as portas em ordem e para na primeira que responder —
+ * um buscador fora do ar (ou bloqueado pela rede) não pode desligar a
+ * pesquisa inteira. Sem chave de API em nenhuma delas.
+ */
+async function buscar(consulta, limite = MAX_POR_FONTE) {
+    for (const porta of [buscarDDG, buscarBing, buscarSearx]) {
+        try {
+            const achados = await porta(consulta, limite);
+            if (achados.length) return achados;
+        } catch {}
+    }
+    return [];
+}
+
+/** Respostas do StackOverflow — a API pública, sem chave. */
+async function stackoverflow(consulta, limite = 3) {
+    const url = 'https://api.stackexchange.com/2.3/search/advanced'
+        + `?order=desc&sort=relevance&q=${encodeURIComponent(consulta)}`
+        + '&site=stackoverflow&filter=default&pagesize=' + limite;
+    const corpo = await pegar(url);
+    if (!corpo) return [];
+    try {
+        const j = JSON.parse(corpo);
+        return (j.items || []).slice(0, limite).map((i) => ({
+            titulo: textoDe(i.title).slice(0, 140),
+            url: i.link,
+            nota: `${i.score} votos${i.is_answered ? ', respondida' : ''}`,
+        }));
+    } catch { return []; }
+}
+
+// Última porta: a documentação oficial dos assuntos mais comuns, direto. Não
+// depende de buscador nenhum — é o que salva a pesquisa em rede corporativa
+// que bloqueia mecanismo de busca mas libera site de documentação.
+const DOCS = [
+    [/\b(js|javascript|array|string|promise|fetch|dom|css|html|regex)\b/i,
+        (q) => `https://developer.mozilla.org/en-US/search?q=${encodeURIComponent(q)}`],
+    [/\b(react|jsx|hook|usestate|useeffect)\b/i, () => 'https://react.dev/reference/react'],
+    [/\b(node|npm|express|fs|require)\b/i, () => 'https://nodejs.org/docs/latest/api/'],
+    [/\b(python|django|flask|pandas)\b/i,
+        (q) => `https://docs.python.org/3/search.html?q=${encodeURIComponent(q)}`],
+];
+
+function docsConhecidas(consulta) {
+    const achados = [];
+    for (const [re, url] of DOCS) {
+        if (re.test(consulta)) achados.push({ titulo: 'documentação oficial', url: url(consulta) });
+    }
+    return achados;
+}
+
+/**
+ * A pesquisa completa: busca, abre as melhores páginas e devolve o texto
+ * delas para o modelo LER. O modelo escreve o código dele com isso na mão.
+ */
+async function pesquisar({ consulta, paginas = 3 }) {
+    const termo = String(consulta || '').trim();
+    if (!termo) return { ok: false, error: 'diga o que pesquisar' };
+
+    const [web, so] = await Promise.all([
+        buscar(termo, MAX_POR_FONTE),
+        stackoverflow(termo, 2),
+    ]);
+
+    // A documentação oficial entra SEMPRE na fila, não só quando as outras
+    // portas vieram vazias: ela é a melhor fonte, e é o que salva a pesquisa
+    // quando os links do buscador não abrem (rede corporativa, site fora do
+    // ar, bloqueio). Foi assim que a pesquisa falhava mesmo achando links.
+    const candidatos = [...web, ...so, ...docsConhecidas(termo)]
+        .slice(0, Math.max(2, Math.min(8, paginas + 4)));
+    if (!candidatos.length) {
+        return { ok: false, error: `nada encontrado para "${termo}" (sem internet?)`, consulta: termo };
+    }
+
+    const lidas = [];
+    for (const cand of candidatos) {
+        if (lidas.length >= paginas) break;
+        const html = await pegar(cand.url);
+        if (!html) continue;
+        const texto = textoDe(html);
+        if (texto.length < 200) continue;
+        lidas.push({
+            titulo: cand.titulo,
+            url: cand.url,
+            nota: cand.nota,
+            trecho: texto.slice(0, MAX_TEXTO),
+        });
+    }
+
+    if (!lidas.length) {
+        return { ok: false, error: 'achei os links mas não consegui abrir nenhum', consulta: termo, links: candidatos.map((c) => c.url) };
+    }
+
+    return {
+        ok: true,
+        consulta: termo,
+        fontes: lidas.length,
+        referencias: lidas,
+        comoUsar: 'Leia, entenda o padrão e ESCREVA o seu próprio código. Não copie trechos literais: '
+            + 'cite a fonte se aproveitar uma ideia, e confira se a API citada existe na versão que o projeto usa.',
+    };
+}
+
+module.exports = { pesquisar, buscar, stackoverflow, textoDe };

package/lib/tools.js

@@ -13,6 +13,7 @@ const os = require('os');
 const { exec } = require('child_process');
 const browser = require('./browser');
 const desktop = require('./desktop');
+const referencia = require('./referencia');
 
 const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
 const MAX_ARQUIVOS_VARREDURA = 5000;
@@ -388,6 +389,15 @@ async function despachar(name, args, ctx) {
             case 'write_todos':
                 return writeTodos(args);
 
+            // Pesquisa de referência: abre documentação e exemplos sobre o
+            // pedido e devolve o TEXTO para o modelo aprender antes de
+            // escrever. Aparece no terminal, com as fontes — nada oculto.
+            case 'pesquisar_referencia':
+                return referencia.pesquisar({
+                    consulta: args.consulta || args.query || '',
+                    paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
+                });
+
             // ── Navegador controlado (CDP) — o agente age numa página real ──
             case 'browser_open': {
                 const alvo = /^https?:\/\//i.test(args.url || '')

package/lib/ui.js

@@ -157,13 +157,13 @@ const NOME = 'Primo Code';
 const TIPS = [
     'Peça um app novo, ou aponte para um repositório e mande clonar',
     '/dir <pasta> para ele trabalhar numa pasta que já é sua',
-    '/help lista tudo · /mode troca o modo · /status confere a API',
+    '/help lista tudo · /effort ajusta o esforço · /status confere a API',
 ];
 
 const NEWS = [
-    '/streaming agora é VÍDEO ao vivo — assista ele trabalhando, aba por aba',
-    'Comandos se autopreenchem: /str + Tab (ou Enter) vira /streaming',
-    'Ele INTERAGE com o computador: janelas, botões e ícones pelo nome',
+    '/effort escolhe o esforço num slider — do rápido ao mais esperto',
+    'Do "high" para cima ele PESQUISA referências antes de escrever',
+    'Esc Esc a qualquer momento para o agente no meio do trabalho',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────
@@ -302,7 +302,7 @@ function actionHeader(name, args) {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
         list_dir:'List', glob:'Glob', grep:'Grep', run_shell:'Bash',
         run_in_new_terminal:'Terminal', open_in_browser:'Open', spawn_agent:'Agent',
-        write_todos:'Plano', finish:'Finish',
+        write_todos:'Plano', finish:'Finish', pesquisar_referencia:'Pesquisa',
         browser_open:'Browser', browser_click:'Browser·click', browser_type:'Browser·type',
         browser_key:'Browser·key', browser_read:'Browser·read', browser_screenshot:'Browser·shot',
         browser_scroll:'Browser·scroll', browser_wait:'Browser·wait', browser_eval:'Browser·eval',
@@ -314,7 +314,7 @@ function actionHeader(name, args) {
         desktop_elements:'Desktop·elementos', desktop_click_element:'Desktop·click',
     };
     const label = nice[name] || name;
-    const argStr = args ? (args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || JSON.stringify(args).slice(0,60)) : '';
+    const argStr = args ? (args.consulta || args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || JSON.stringify(args).slice(0,60)) : '';
     return `  ${c.dim('⎿')} ${c.brand(label)}${argStr ? ' '+c.muted(argStr) : ''}`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "7.15.0",
+  "version": "7.17.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js"
   },
   "engines": {
     "node": ">=18.17.0"