primocode 10.5.0 → 10.7.0

package/lib/mcp.js

@@ -15,6 +15,17 @@
  *
  * O cliente é o mínimo do protocolo por stdio: JSON-RPC 2.0, uma mensagem por
  * linha — initialize, notifications/initialized, tools/list, tools/call.
+ *
+ * ── MCP PRIMEIRO, MOUSE POR ÚLTIMO ───────────────────────────────────────
+ *   "Para a IA não ter que fazer as coisas manualmente no computador do
+ *    usuário. Sempre procurar um MCP primeiro; se não tiver, pesquisar se a
+ *    ferramenta tem MCP e, se tiver, conectar." (11/10)
+ *
+ * Clicar no Notion pela tela são vinte ações que quebram com um pop-up; a
+ * API do Notion é uma. Por isso `procurar` (a lista curada daqui + o registro
+ * oficial em registry.modelcontextprotocol.io) e `conectarNovo` (grava, sobe,
+ * lista as tools — e desfaz se não subir). Hoje viram tools nativas
+ * (mcp_procurar · mcp_conectar · mcp_usar), sem passar pelo run_shell.
  */
 
 'use strict';
@@ -46,9 +57,17 @@ function servidores(pasta = process.cwd()) {
 }
 
 /** Abre um servidor, faz o aperto de mão e devolve {pedir, fechar}. */
+/* `${VAR}` no argumento vira o valor do env. Sem shell no meio (spawn puro),
+   ninguém expandiria — e é assim que o token entra no header do mcp-remote
+   sem ficar escrito duas vezes no mcp.json. */
+function expandir(args, env) {
+    return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => (env[k] != null ? env[k] : '')));
+}
+
 function conectar(def, { tetoMs = 60000 } = {}) {
     return new Promise((resolve, reject) => {
-        const p = spawn(def.command, def.args || [], { env: { ...process.env, ...(def.env || {}) }, stdio: ['pipe', 'pipe', 'pipe'] });
+        const env = { ...process.env, ...(def.env || {}) };
+        const p = spawn(def.command, expandir(def.args, env), { env, stdio: ['pipe', 'pipe', 'pipe'] });
         let buf = '', id = 0;
         const espera = new Map();
         const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error('o servidor MCP não respondeu')); }, tetoMs);
@@ -75,6 +94,21 @@ function conectar(def, { tetoMs = 60000 } = {}) {
     });
 }
 
+function resumirTools(tools) {
+    return (tools || []).map((t) => ({ nome: t.name, descricao: String(t.description || '').split(/\n|\. /)[0].slice(0, 120), args: Object.keys((t.inputSchema && t.inputSchema.properties) || {}) }));
+}
+
+function gravarCache(mudar) {
+    try {
+        const c = lerJson(CACHE) || { servidores: {} };
+        c.servidores = c.servidores || {};
+        mudar(c.servidores);
+        c.quando = Date.now();
+        fs.mkdirSync(CASA, { recursive: true });
+        fs.writeFileSync(CACHE, JSON.stringify(c, null, 2));
+    } catch { /* sem cache */ }
+}
+
 async function listar(pasta) {
     const lista = servidores(pasta);
     const out = {};
@@ -83,10 +117,10 @@ async function listar(pasta) {
             const c = await conectar(def);
             const r = await c.pedir('tools/list');
             c.fechar();
-            out[nome] = (r.tools || []).map((t) => ({ nome: t.name, descricao: String(t.description || '').split(/\n|\. /)[0].slice(0, 120), args: Object.keys((t.inputSchema && t.inputSchema.properties) || {}) }));
+            out[nome] = resumirTools(r.tools);
         } catch (e) { out[nome] = { erro: e.message }; }
     }));
-    try { fs.mkdirSync(CASA, { recursive: true }); fs.writeFileSync(CACHE, JSON.stringify({ quando: Date.now(), servidores: out }, null, 2)); } catch { /* sem cache */ }
+    gravarCache((sv) => { for (const k of Object.keys(sv)) delete sv[k]; Object.assign(sv, out); });
     return out;
 }
 
@@ -100,6 +134,232 @@ async function chamar(servidor, tool, args = {}, pasta) {
     } finally { c.fechar(); }
 }
 
+/* ── A LISTA CURADA ─────────────────────────────────────────────────────
+ * Vem antes do registro, e funciona sem internet. O registro tem milhares de
+ * entradas, e na busca "github" as primeiras são de terceiros que pedem a
+ * chave da Smithery — o servidor OFICIAL do GitHub nem aparece. Aqui ficam os
+ * conhecidos, conferidos um a um (npm view / registro em 11/10): pacote que
+ * existe, não deprecado, e a chave que ele pede com onde pegar.
+ * `<...>` nos args é o que o usuário precisa dizer (a pasta, o banco). */
+const REMOTO = (url, header) => ({ command: 'npx', args: ['-y', 'mcp-remote', url, ...(header ? ['--header', header] : [])] });
+const CURADOS = [
+    { nome: 'github', termos: /git ?hub|reposit|pull request|\bpr\b|issue/i, descricao: 'GitHub oficial: repos, issues, PRs, Actions',
+      ...REMOTO('https://api.githubcopilot.com/mcp/', 'Authorization:Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}'),
+      precisa: [{ nome: 'GITHUB_PERSONAL_ACCESS_TOKEN', onde: 'github.com/settings/tokens' }] },
+    { nome: 'notion', termos: /notion/i, descricao: 'Notion oficial: páginas, bancos, busca',
+      command: 'npx', args: ['-y', '@notionhq/notion-mcp-server'],
+      precisa: [{ nome: 'NOTION_TOKEN', onde: 'notion.so/profile/integrations (integração interna, ntn_…)' }] },
+    { nome: 'slack', termos: /slack/i, descricao: 'Slack: canais, mensagens, busca',
+      command: 'npx', args: ['-y', 'slack-mcp-server@latest', '--transport', 'stdio'],
+      precisa: [{ nome: 'SLACK_MCP_XOXP_TOKEN', onde: 'api.slack.com/apps → OAuth & Permissions (User OAuth Token xoxp-…)' }] },
+    { nome: 'google-drive', termos: /google ?drive|\bdrive\b|planilha|sheets|google docs/i, descricao: 'Google Drive, Docs e Sheets',
+      command: 'npx', args: ['-y', '@piotr-agier/google-drive-mcp'],
+      precisa: [{ nome: 'GOOGLE_DRIVE_OAUTH_CREDENTIALS', onde: 'caminho do JSON de credencial OAuth (console.cloud.google.com → Credenciais)' }] },
+    { nome: 'figma', termos: /figma/i, descricao: 'Figma: lê arquivos, frames e estilos',
+      command: 'npx', args: ['-y', 'figma-developer-mcp', '--stdio'],
+      precisa: [{ nome: 'FIGMA_API_KEY', onde: 'figma.com → Settings → Personal access tokens' }] },
+    { nome: 'postgres', termos: /postgres|banco de dados|\bsql\b|\bbanco\b/i, descricao: 'Postgres: consulta, esquema, saúde do banco',
+      command: 'uvx', args: ['postgres-mcp', '--access-mode=restricted'],
+      precisa: [{ nome: 'DATABASE_URI', onde: 'a URL do banco (postgresql://usuario:senha@host:5432/banco)' }] },
+    { nome: 'sqlite', termos: /sqlite|\.db\b/i, descricao: 'SQLite: consulta um arquivo .db',
+      command: 'npx', args: ['-y', 'mcp-server-sqlite-npx', '<caminho do arquivo .db>'], precisa: [] },
+    { nome: 'filesystem', termos: /arquivos? (de|em) outra pasta|filesystem|sistema de arquivos/i, descricao: 'Arquivos de uma pasta fora do projeto',
+      command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '<pasta>'], precisa: [] },
+    { nome: 'playwright', termos: /playwright|navegador|browser|site|p[áa]gina/i, descricao: 'Playwright (Microsoft): navegador por acessibilidade, sem pixel',
+      command: 'npx', args: ['-y', '@playwright/mcp@latest'], precisa: [] },
+    { nome: 'supabase', termos: /supabase/i, descricao: 'Supabase oficial: projetos, tabelas, SQL, edge functions',
+      command: 'npx', args: ['-y', '@supabase/mcp-server-supabase@latest'],
+      precisa: [{ nome: 'SUPABASE_ACCESS_TOKEN', onde: 'supabase.com/dashboard/account/tokens' }] },
+    { nome: 'stripe', termos: /stripe|pagamento|cobran[çc]a/i, descricao: 'Stripe oficial: clientes, cobranças, links de pagamento',
+      command: 'npx', args: ['-y', '@stripe/mcp', '--tools=all'],
+      precisa: [{ nome: 'STRIPE_SECRET_KEY', onde: 'dashboard.stripe.com/apikeys (de preferência uma restricted key)' }] },
+    { nome: 'linear', termos: /linear/i, descricao: 'Linear oficial: issues, projetos (login pelo navegador)',
+      ...REMOTO('https://mcp.linear.app/mcp'), precisa: [] },
+    { nome: 'sentry', termos: /sentry/i, descricao: 'Sentry oficial: erros, issues, releases',
+      command: 'npx', args: ['-y', '@sentry/mcp-server@latest'],
+      precisa: [{ nome: 'SENTRY_ACCESS_TOKEN', onde: 'sentry.io → Settings → Auth Tokens' }] },
+    { nome: 'vercel', termos: /vercel/i, descricao: 'Vercel oficial: projetos, deploys, logs (login pelo navegador)',
+      ...REMOTO('https://mcp.vercel.com'), precisa: [] },
+    { nome: 'cloudflare', termos: /cloudflare|workers?\b/i, descricao: 'Cloudflare oficial: Workers, KV, R2, D1 (login pelo navegador)',
+      ...REMOTO('https://bindings.mcp.cloudflare.com/mcp'), precisa: [] },
+    { nome: 'firebase', termos: /firebase|firestore/i, descricao: 'Firebase oficial (firebase-tools): projetos, Firestore, Auth',
+      command: 'npx', args: ['-y', 'firebase-tools@latest', 'mcp'], precisa: [] },
+];
+
+const REGISTRO = 'https://registry.modelcontextprotocol.io/v0/servers';
+
+/* O nome que fica no mcp.json: o pedaço final, curto. "io.github.github/
+   github-mcp-server" vira "github-mcp-server". */
+function nomeCurto(n) {
+    return String(n || '').split('/').pop().replace(/[^a-zA-Z0-9_.-]+/g, '-').toLowerCase().slice(0, 40) || 'mcp';
+}
+
+/* Uma entrada do registro vira candidatos de instalação. Cada formato tem o
+   seu lançador: npm → npx, pypi → uvx, oci → docker; remoto (http/sse) entra
+   pelo mcp-remote, que fala stdio deste lado. */
+function doRegistro(item) {
+    const s = (item && item.server) || item || {};
+    const instalar = [];
+    for (const pk of s.packages || []) {
+        const env = (pk.environmentVariables || []).map((e) => ({ nome: e.name, descricao: String(e.description || '').slice(0, 140), obrigatorio: !!e.isRequired, segredo: !!e.isSecret }));
+        const t = pk.transport && pk.transport.type;
+        if (t && t !== 'stdio') continue;
+        const extra = (pk.packageArguments || []).filter((a) => a.isRequired).flatMap((a) => {
+            const v = a.value || a.default || `<${a.valueHint || a.name || 'valor'}>`;
+            return a.type === 'named' ? [a.name, v] : [v];
+        });
+        if (pk.registryType === 'npm') instalar.push({ tipo: 'npm', command: 'npx', args: ['-y', pk.identifier, ...extra], env });
+        else if (pk.registryType === 'pypi') instalar.push({ tipo: 'pypi', command: 'uvx', args: [pk.identifier, ...extra], env });
+        else if (pk.registryType === 'oci') instalar.push({ tipo: 'oci', command: 'docker', args: ['run', '-i', '--rm', ...env.flatMap((e) => ['-e', e.nome]), pk.identifier, ...extra], env });
+    }
+    for (const r of s.remotes || []) {
+        if (!/^https:\/\//.test(r.url || '') || /\{/.test(r.url)) continue; // URL com molde pede dado que não temos
+        const env = [];
+        const args = ['-y', 'mcp-remote', r.url];
+        for (const h of r.headers || []) {
+            if (!h.isRequired && !h.isSecret) continue;
+            // "Bearer {smithery_api_key}" → "Bearer ${SMITHERY_API_KEY}"; sem molde, o header inteiro vem do env.
+            let valor = h.value ? String(h.value).replace(/\{([a-zA-Z0-9_]+)\}/g, (_, k) => {
+                const n = k.toUpperCase();
+                env.push({ nome: n, descricao: String(h.description || '').slice(0, 140), obrigatorio: true, segredo: true });
+                return '${' + n + '}';
+            }) : null;
+            if (!valor) {
+                const n = `MCP_${String(h.name).toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`;
+                env.push({ nome: n, descricao: `valor do header ${h.name} (ex: Bearer <token>)`, obrigatorio: true, segredo: true });
+                valor = '${' + n + '}';
+            }
+            args.push('--header', `${h.name}:${valor}`);
+        }
+        instalar.push({ tipo: r.type || 'remoto', command: 'npx', args, env });
+    }
+    return { nome: nomeCurto(s.name), registro: s.name, descricao: String(s.title ? `${s.title} — ${s.description || ''}` : s.description || '').slice(0, 160), versao: s.version, instalar };
+}
+
+function doCurado(c) {
+    return { nome: c.nome, fonte: 'curado', descricao: c.descricao,
+        instalar: [{ tipo: 'curado', command: c.command, args: c.args, env: (c.precisa || []).map((p) => ({ nome: p.nome, descricao: p.onde, obrigatorio: true, segredo: true })) }] };
+}
+
+/**
+ * Procura um servidor MCP para o serviço: a lista curada primeiro, depois o
+ * registro oficial. `buscar` é o fetch (o teste troca; sem rede, só a curada).
+ */
+async function procurar(q, { buscar = globalThis.fetch, limite = 8, tetoMs = 8000 } = {}) {
+    const busca = String(q || '').trim();
+    if (!busca) return { ok: false, error: 'Diga o serviço ou app a procurar (ex: "notion", "github").' };
+    const ja = servidores();
+    const curados = CURADOS.filter((c) => c.termos.test(busca) || busca.toLowerCase().includes(c.nome)).map(doCurado);
+    let registro = [], aviso;
+    if (typeof buscar === 'function') {
+        const ctl = typeof AbortController === 'function' ? new AbortController() : null;
+        const relogio = ctl ? setTimeout(() => ctl.abort(), tetoMs) : null;
+        try {
+            const url = `${REGISTRO}?search=${encodeURIComponent(busca)}&limit=${Math.max(limite * 3, 20)}&version=latest`;
+            const r = await buscar(url, ctl ? { signal: ctl.signal } : {});
+            if (!r.ok) throw new Error(`registro respondeu ${r.status}`);
+            const j = await r.json();
+            const termo = busca.toLowerCase().split(/\s+/)[0];
+            registro = (j.servers || [])
+                // version=latest já filtra; a marca isLatest é a rede caso o parâmetro mude.
+                .filter((x) => { const m = x._meta && x._meta['io.modelcontextprotocol.registry/official']; return !m || m.isLatest !== false; })
+                .map(doRegistro)
+                .filter((x) => x.instalar.length)
+                // A busca do registro casa até a URL do repositório ("github" traz
+                // tudo que mora no GitHub). Fica o que fala do serviço no nome ou na descrição.
+                // O prefixo "io.github.<dono>/" não conta: é onde mora, não o que faz.
+                .filter((x) => `${x.nome} ${x.descricao}`.toLowerCase().includes(termo))
+                .map((x) => ({ ...x, fonte: 'registro',
+                    // Relevância: o nome casa com a busca, e tem pacote que roda local (sem chave de intermediário).
+                    pontos: (x.nome.includes(termo) ? 2 : 0) + (x.instalar.some((i) => i.tipo === 'npm') ? 1 : 0) - (/smithery/.test(x.registro) ? 2 : 0) }))
+                .sort((a, b) => b.pontos - a.pontos)
+                .map(({ pontos, ...x }) => x);
+        } catch (e) { aviso = `registro indisponível (${e.name === 'AbortError' ? 'demorou' : e.message}) — só a lista curada`; }
+        finally { if (relogio) clearTimeout(relogio); }
+    }
+    const vistos = new Set();
+    const resultados = [...curados, ...registro].filter((x) => !vistos.has(x.nome) && vistos.add(x.nome)).slice(0, limite)
+        .map((x) => ({ ...x, jaConectado: !!ja[x.nome] }));
+    return { ok: true, busca, resultados,
+        ...(aviso ? { aviso } : {}),
+        proximo: resultados.length
+            ? 'Escolha o primeiro que serve e chame mcp_conectar {nome, comando, args, env} com o "instalar" dele (curado: só {nome} basta). Env obrigatório sem valor: PEÇA a chave ao usuário antes.'
+            : 'Nenhum MCP para isso. Tente API/CLI pelo run_shell; o mouse (desktop_*) é o último recurso.' };
+}
+
+function lerConfig(arq) { const j = lerJson(arq) || {}; j.mcpServers = j.mcpServers || {}; return j; }
+function gravarConfig(arq, j) {
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    // Pode levar token: só o dono lê.
+    fs.writeFileSync(arq, JSON.stringify(j, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Grava, sobe e valida um servidor novo. Não salva o que não subiria: sem a
+ * chave obrigatória, devolve o que perguntar ao usuário; se não responder ao
+ * tools/list, desfaz a gravação.
+ */
+async function conectarNovo({ nome, command, comando, args, env } = {}, { config = CONFIG, tetoMs = 120000 } = {}) {
+    const n = String(nome || '').trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9_.-]{0,40}$/.test(n)) return { ok: false, error: 'nome inválido: letras, números, - _ . (ex: "notion")' };
+    const curado = CURADOS.find((c) => c.nome === n);
+    let cmd = command || comando;
+    let lista = Array.isArray(args) ? args.map(String) : (typeof args === 'string' && args.trim() ? args.trim().split(/\s+/) : null);
+    if (!cmd && curado) { cmd = curado.command; lista = lista || curado.args.slice(); }
+    if (!cmd) return { ok: false, error: `não conheço "${n}" de cor — chame mcp_procurar primeiro e passe comando e args do "instalar".` };
+    lista = lista || [];
+    const vars = {};
+    for (const [k, v] of Object.entries(env || {})) if (v != null && String(v).trim() !== '') vars[k] = String(v);
+
+    const molde = lista.filter((a) => /<[^>]+>/.test(a));
+    if (molde.length) return { ok: false, salvo: false, falta: molde, error: `Falta preencher ${molde.join(', ')} nos args. Pergunte ao usuário e chame de novo.` };
+
+    // A chave que falta: a da curadoria e a que os args citam como ${VAR}.
+    const pedidas = new Map((curado && cmd === curado.command ? curado.precisa : []).map((p) => [p.nome, p.onde]));
+    for (const a of lista) for (const m of a.matchAll(/\$\{([A-Z0-9_]+)\}/g)) if (!pedidas.has(m[1])) pedidas.set(m[1], '');
+    const faltam = [...pedidas].filter(([k]) => !vars[k] && !process.env[k]).map(([k, onde]) => ({ nome: k, onde }));
+    if (faltam.length) {
+        return { ok: false, salvo: false, precisaDe: faltam,
+            error: `O MCP "${n}" precisa de ${faltam.map((f) => f.nome).join(', ')}. NÃO salvei nada. Peça ao usuário`
+                + `${faltam.some((f) => f.onde) ? ` (onde pegar: ${faltam.filter((f) => f.onde).map((f) => `${f.nome} → ${f.onde}`).join('; ')})` : ''}`
+                + ' e chame mcp_conectar de novo com env.' };
+    }
+
+    const def = { command: cmd, args: lista, ...(Object.keys(vars).length ? { env: vars } : {}) };
+    const j = lerConfig(config);
+    const antes = j.mcpServers[n];
+    j.mcpServers[n] = def;
+    gravarConfig(config, j);
+    let c;
+    try {
+        c = await conectar(def, { tetoMs });
+        const r = await c.pedir('tools/list');
+        const ferramentas = resumirTools(r.tools);
+        gravarCache((sv) => { sv[n] = ferramentas; });
+        return { ok: true, servidor: n, ferramentas,
+            proximo: `Conectado. Use mcp_usar {servidor:"${n}", ferramenta, argumentos}.` };
+    } catch (e) {
+        // Não subiu: o mcp.json volta a ser o que era.
+        const k = lerConfig(config);
+        if (antes) k.mcpServers[n] = antes; else delete k.mcpServers[n];
+        gravarConfig(config, k);
+        return { ok: false, salvo: false, error: `o servidor "${n}" não subiu: ${e.message}. Nada ficou salvo.` };
+    } finally { if (c) c.fechar(); }
+}
+
+function textoDe(r) {
+    return (r.content || []).map((x) => (x.type === 'text' ? x.text : `[${x.type}]`)).join('\n');
+}
+
+/** A tool nativa mcp_usar: chama e devolve o texto, no formato das outras tools. */
+async function usar(servidor, ferramenta, argumentos = {}, pasta) {
+    if (!servidor || !ferramenta) return { ok: false, error: 'Diga servidor e ferramenta (veja [mcp] no contexto, ou mcp_procurar).' };
+    let a = argumentos;
+    if (typeof a === 'string') { try { a = JSON.parse(a || '{}'); } catch { return { ok: false, error: 'argumentos não é JSON válido' }; } }
+    const r = await chamar(servidor, ferramenta, a || {}, pasta);
+    return { ok: !r.isError, servidor, ferramenta, resultado: textoDe(r).slice(0, 20000) };
+}
+
 /** A linha do contexto: só se houver servidor configurado, a partir do cache. */
 function dica(pasta) {
     const lista = Object.keys(servidores(pasta));
@@ -109,8 +369,9 @@ function dica(pasta) {
         const tools = c && c.servidores && Array.isArray(c.servidores[n]) ? c.servidores[n].map((t) => t.nome).slice(0, 8).join(', ') : '';
         return tools ? `${n} (${tools})` : n;
     }).join(' · ');
-    return `[mcp] Servidores MCP disponíveis: ${det}. Use pelo run_shell: primocode mcp call <servidor> <tool> --json '{...}'`
-        + (c ? '' : ' (rode primocode mcp list para ver as tools).');
+    return `[mcp] Servidores MCP disponíveis: ${det}. Use com mcp_usar {servidor, ferramenta, argumentos}. `
+        + 'Serviço sem MCP aqui: mcp_procurar → mcp_conectar.'
+        + (c ? '' : ' (primocode mcp list mostra as tools.)');
 }
 
 /** `primocode mcp …` */
@@ -122,14 +383,15 @@ async function main(argv) {
             console.log('primocode mcp list                         — servidores e tools (de ~/.primocode/mcp.json e .mcp.json)');
             console.log("primocode mcp call <servidor> <tool> --json '{...}'  — chama uma tool; sai o resultado em JSON");
             console.log('primocode mcp add <nome> -- <comando> [args…]  — guarda um servidor em ~/.primocode/mcp.json');
+            console.log('primocode mcp procurar <serviço>           — acha o MCP de um serviço (lista curada + registro oficial)');
+            console.log('primocode mcp conectar <nome> [--env K=V…] [-- <comando> [args…]]  — grava, sobe e valida');
             return 0;
         }
         if (op === 'list') { console.log(JSON.stringify(await listar(process.cwd()))); return 0; }
         if (op === 'call') {
             if (json === null) { console.log(JSON.stringify({ ok: false, error: '--json inválido' })); return 1; }
             const r = await chamar(resto[0], resto[1], json, process.cwd());
-            const texto = (r.content || []).map((x) => (x.type === 'text' ? x.text : `[${x.type}]`)).join('\n');
-            console.log(JSON.stringify({ ok: !r.isError, resultado: texto.slice(0, 20000) }));
+            console.log(JSON.stringify({ ok: !r.isError, resultado: textoDe(r).slice(0, 20000) }));
             return r.isError ? 1 : 0;
         }
         if (op === 'add') {
@@ -137,14 +399,36 @@ async function main(argv) {
             const nome = resto[0];
             const cmd = i >= 0 ? resto.slice(i + 1) : resto.slice(1);
             if (!nome || !cmd.length) { console.log('uso: primocode mcp add <nome> -- <comando> [args…]'); return 1; }
-            const j = lerJson(CONFIG) || { mcpServers: {} };
-            j.mcpServers = j.mcpServers || {};
+            const j = lerConfig(CONFIG);
             j.mcpServers[nome] = { command: cmd[0], args: cmd.slice(1) };
-            fs.mkdirSync(CASA, { recursive: true });
-            fs.writeFileSync(CONFIG, JSON.stringify(j, null, 2));
+            gravarConfig(CONFIG, j);
             console.log(JSON.stringify({ ok: true, servidor: nome }));
             return 0;
         }
+        if (op === 'procurar' || op === 'search') {
+            const r = await procurar(resto.join(' '));
+            if (!r.ok) { console.log(r.error); return 1; }
+            for (const x of r.resultados) {
+                const i = x.instalar[0];
+                const chaves = i.env.filter((e) => e.obrigatorio).map((e) => e.nome);
+                console.log(`${x.jaConectado ? '✔' : '·'} ${x.nome}  [${x.fonte}]  ${x.descricao}`);
+                console.log(`    ${i.command} ${i.args.join(' ')}${chaves.length ? `   (precisa: ${chaves.join(', ')})` : ''}`);
+            }
+            if (!r.resultados.length) console.log('nada encontrado.');
+            if (r.aviso) console.log(r.aviso);
+            return 0;
+        }
+        if (op === 'conectar' || op === 'connect') {
+            const i = resto.indexOf('--');
+            const antes = i >= 0 ? resto.slice(0, i) : resto;
+            const cmd = i >= 0 ? resto.slice(i + 1) : [];
+            const env = {};
+            antes.forEach((x, k) => { if (x === '--env' && antes[k + 1]) { const [a, ...b] = antes[k + 1].split('='); env[a] = b.join('='); } });
+            const r = await conectarNovo({ nome: antes[0], command: cmd[0], args: cmd.length ? cmd.slice(1) : undefined, env });
+            if (r.ok) console.log(`conectado: ${r.servidor} — ${r.ferramentas.length} tools (${r.ferramentas.map((t) => t.nome).slice(0, 10).join(', ')})`);
+            else console.log(r.error);
+            return r.ok ? 0 : 1;
+        }
         console.log(JSON.stringify({ ok: false, error: `operação desconhecida: ${op}` }));
         return 1;
     } catch (e) {
@@ -153,4 +437,4 @@ async function main(argv) {
     }
 }
 
-module.exports = { servidores, conectar, listar, chamar, dica, main };
+module.exports = { servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir };

package/lib/memoria-conversa.js

@@ -79,16 +79,45 @@ async function atualizar(memoria, history, resumir) {
     const novas = pendentes(memoria, history);
     if (!novas.length) return memoria;
 
+    // A memória da pasta (AGENTS.md) entra como parte do "resumo de antes":
+    // é assim que a sessão nova CONTINUA a de ontem em vez de recomeçar — e o
+    // AGENTS.md seguinte não apaga o que a anterior tinha anotado.
+    const semente = memoria.semente && memoria.semente.texto
+        ? `Memória da pasta ${memoria.semente.pasta} (sessões anteriores):\n${memoria.semente.texto}` : '';
+    const antes = [memoria.resumo, semente].filter(Boolean).join('\n\n');
+
     let texto;
     try {
-        texto = await resumir({ resumo: memoria.resumo, mensagens: novas });
+        texto = await resumir({ resumo: antes, mensagens: novas });
     } catch {
         return memoria;
     }
     const limpo = String(texto || '').trim();
     if (!limpo) return memoria;
 
-    return { resumo: limpo, resumidasAte: (history || []).length - CRUAS };
+    return {
+        resumo: limpo,
+        resumidasAte: (history || []).length - CRUAS,
+        dobrada: memoria.semente ? memoria.semente.pasta : (memoria.dobrada || null),
+    };
+}
+
+/* ── A MEMÓRIA DA PASTA ───────────────────────────────────────────────────
+ * `semear` guarda o que o AGENTS.md da pasta trazia, para o próximo resumo
+ * dobrar junto. `jaDobrou` diz se o resumo atual já carrega a memória
+ * daquela pasta — aí ela não precisa ir de novo no contexto (seria pagar duas
+ * vezes pelo mesmo texto). Ver lib/agents-md.js. */
+function semear(memoria, pasta, texto) {
+    const base = memoria || nova();
+    if (!pasta || base.dobrada === pasta) return base;
+    const t = String(texto || '').trim();
+    // Pasta sem memória: não há o que dobrar, e ela conta como já dobrada.
+    if (!t) return { ...base, semente: null, dobrada: pasta };
+    return { ...base, semente: { pasta, texto: t } };
+}
+
+function jaDobrou(memoria, pasta) {
+    return !!(memoria && pasta && memoria.dobrada === pasta);
 }
 
 /**
@@ -153,4 +182,4 @@ function economia(memoria, history) {
     return { cheio, enxuto, poupado: Math.max(0, cheio - enxuto) };
 }
 
-module.exports = { nova, pendentes, usoDoContexto, TETO_CONVERSA, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };
+module.exports = { nova, semear, jaDobrou, pendentes, usoDoContexto, TETO_CONVERSA, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };

package/lib/mencoes.js

@@ -37,7 +37,11 @@ function instrucoesDoProjeto(projectDir, limite = LIMITE_INSTRUCOES) {
     if (global.trim()) partes.push(`[~/.primocode/PRIMO.md — suas instruções para todo projeto]\n${cortar(global, limite)}`);
     if (projectDir) {
         for (const nome of NOMES_INSTRUCOES) {
-            const texto = lerSeExiste(path.join(projectDir, nome));
+            /* O bloco de memória que o PrimoCode escreve no AGENTS.md
+               (lib/agents-md.js) não é instrução de ninguém: sai daqui e entra
+               à parte, como memória. Um AGENTS.md que só tem o bloco conta
+               como vazio — e o CLAUDE.md do repo ainda tem a vez dele. */
+            const texto = require('./agents-md.js').semBloco(lerSeExiste(path.join(projectDir, nome)));
             if (!texto.trim()) continue;
             partes.push(`[${nome} — instruções deste projeto: siga]\n${cortar(texto, limite)}`);
             break;

package/lib/nome-curto.js

@@ -0,0 +1,126 @@
+/**
+ * nome-curto.js — o nome da pasta é para ler, não para guardar a frase.
+ *
+ *   "Essa estrutura de pastas está horrível. Os nomes de pasta que a IA
+ *    decide estão horríveis." (11/10/2026)
+ *
+ * O que saía: `2026-10-11-claude-e-humano-conversam-sobre-o-segund` — a data
+ * na frente, a frase inteira com "e", "sobre", "o", e o corte no meio da
+ * palavra aos 40 caracteres. Ninguém acha nada numa lista assim.
+ *
+ * ── A REGRA ─────────────────────────────────────────────────────────────
+ *   · de 1 a 4 palavras que dizem o assunto, em kebab-case, sem acento;
+ *   · palavra de ligação (de, do, com, sobre, o, a, e…) e verbo de pedido
+ *     (faça, crie, quero…) saem — não dizem O QUE é;
+ *   · número solto (data, "2026") sai: a data mora no projeto.json;
+ *   · NUNCA corta palavra no meio. Se não cabe em 28 letras, sai uma
+ *     palavra inteira — e a escolha prefere guardar a primeira (o sujeito)
+ *     e a última (quase sempre o assunto: "segundo CÉREBRO").
+ *
+ * Puro e sem dependência: o config.js e o Estúdio usam, e nenhum dos dois
+ * pode puxar o outro.
+ */
+
+'use strict';
+
+const MAXIMO = 28;
+const PALAVRAS = 4;
+
+// Ligação e artigo: aparecem em toda frase e não dizem nada sozinhas.
+const LIGACAO = new Set([
+    'de', 'do', 'da', 'dos', 'das', 'd', 'com', 'sem', 'sobre', 'o', 'a', 'os', 'as', 'e', 'ou',
+    'em', 'no', 'na', 'nos', 'nas', 'num', 'numa', 'um', 'uma', 'uns', 'umas', 'para', 'pra', 'pro',
+    'por', 'pelo', 'pela', 'que', 'se', 'ao', 'aos', 'mais', 'muito', 'bem', 'entre', 'ate', 'como',
+    'meu', 'minha', 'meus', 'minhas', 'seu', 'sua', 'nosso', 'nossa', 'esse', 'essa', 'este', 'esta',
+    'isso', 'isto', 'aquele', 'aquela', 'the', 'of', 'and', 'to', 'for', 'with', 'in', 'on',
+]);
+
+// Pedido e narração: o que a pessoa quer FAZER, não o que a coisa É.
+const PEDIDO = new Set([
+    'faca', 'faz', 'fazer', 'crie', 'cria', 'criar', 'gere', 'gera', 'gerar', 'monte', 'monta', 'montar',
+    'quero', 'queria', 'preciso', 'bora', 'vamos', 'agora', 'novo', 'nova', 'outro', 'outra',
+    'conversam', 'conversa', 'conversando', 'falam', 'fala', 'falando', 'explica', 'explicando',
+    'mostra', 'mostrando', 'apresenta', 'apresentando', 'tipo', 'estilo', 'simples', 'rapido',
+]);
+
+function semAcento(s) {
+    return String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '');
+}
+
+/** As palavras que dizem o assunto, na ordem em que vieram. */
+function palavrasDoAssunto(texto) {
+    return semAcento(texto).toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean)
+        .filter((p) => !LIGACAO.has(p) && !PEDIDO.has(p))
+        // Número solto é data, hora ou contagem ("24 09 2026", "21h36" fica).
+        .filter((p) => !/^\d+$/.test(p));
+}
+
+/**
+ * O melhor nome que cabe: o maior número de palavras inteiras, e entre os
+ * empates o que guarda a primeira e a última. Com no máximo 5 candidatas são
+ * 31 combinações — conta de cabeça, não de algoritmo.
+ */
+function escolher(palavras, maximo, limite) {
+    const cand = palavras.slice(0, Math.max(limite + 1, 5));
+    if (!cand.length) return '';
+    let melhor = null;
+    const n = cand.length;
+    for (let mascara = 1; mascara < (1 << n); mascara++) {
+        const idx = [];
+        for (let i = 0; i < n; i++) if (mascara & (1 << i)) idx.push(i);
+        if (idx.length > limite) continue;
+        const nome = idx.map((i) => cand[i]).join('-');
+        if (nome.length > maximo) continue;
+        let juntas = 0;
+        for (let k = 1; k < idx.length; k++) if (idx[k] === idx[k - 1] + 1) juntas++;
+        const pontos = idx.length * 1000
+            + (idx[0] === 0 ? 100 : 0)
+            + (idx[idx.length - 1] === n - 1 ? 50 : 0)
+            // as duas últimas juntas costumam ser um nome só ("segundo cérebro")
+            + (n > 1 && idx.includes(n - 2) && idx.includes(n - 1) ? 20 : 0)
+            // a frase como veio, sem pular, lê melhor
+            + juntas * 10
+            // mais palavras do começo da frase (o pedido diz o principal antes)
+            - idx.reduce((a, b) => a + b, 0);
+        if (!melhor || pontos > melhor.pontos || (pontos === melhor.pontos && nome.length > melhor.nome.length)) {
+            melhor = { nome, pontos };
+        }
+    }
+    // Nem uma palavra coube: é uma palavra só, gigante. Aí corta — é o único
+    // caso, e o hífen do fim não fica.
+    if (!melhor) return cand[0].slice(0, maximo).replace(/-+$/, '');
+    return melhor.nome;
+}
+
+/**
+ * "Claude e humano conversam sobre o segundo cérebro" → "claude-segundo-cerebro".
+ * Devolve '' quando não sobra palavra nenhuma (quem chama decide a reserva).
+ */
+function nomeCurto(texto, { maximo = MAXIMO, palavras = PALAVRAS } = {}) {
+    return escolher(palavrasDoAssunto(texto), maximo, palavras);
+}
+
+/**
+ * Nome que já existe: primeiro tenta uma palavra a mais da própria frase
+ * (`anuncio-imersao` → `anuncio-imersao-paris`), que diz QUAL é; só sem
+ * palavra que caiba vem o -2, -3.
+ */
+function semColisao(nome, tomados, texto = '', { maximo = MAXIMO } = {}) {
+    const usados = new Set([...(tomados || [])].map((n) => String(n).toLowerCase()));
+    if (!usados.has(nome)) return nome;
+    const ja = new Set(nome.split('-'));
+    for (const extra of palavrasDoAssunto(texto)) {
+        if (ja.has(extra)) continue;
+        const outro = `${nome}-${extra}`;
+        if (outro.length <= maximo && !usados.has(outro)) return outro;
+    }
+    for (let i = 2; i < 1000; i++) {
+        const outro = `${nome}-${i}`;
+        if (!usados.has(outro)) return outro;
+    }
+    return `${nome}-${Date.now()}`;
+}
+
+module.exports = { nomeCurto, semColisao, palavrasDoAssunto, MAXIMO, LIGACAO, PEDIDO };

package/lib/nome-projeto.js

@@ -22,6 +22,7 @@
 'use strict';
 
 const { slugify } = require('./config.js');
+const { nomeCurto } = require('./nome-curto.js');
 
 // Nome que não diz nada: o modelo devolveu isso, é como não ter respondido.
 const GENERICOS = new Set(['projeto', 'project', 'app', 'site', 'novo', 'teste', 'test', 'meu-projeto', 'my-project']);
@@ -48,7 +49,7 @@ function pergunta(pedido, nomes) {
         : 'Use kebab-case em português, de 1 a 3 palavras.';
     return 'Dê um nome curto para a pasta do projeto deste pedido. O nome diz O QUE é '
         + '(ex.: site-padaria, jogo-de-carro, loja-roupas), nunca o que a pessoa pediu para fazer. '
-        + `${jeito} Responda SÓ com o nome, sem aspas e sem explicação.\n\nPEDIDO: ${String(pedido || '').slice(0, 600)}`;
+        + `${jeito} No máximo 28 letras, sem data e sem "de/da/com". Responda SÓ com o nome, sem aspas e sem explicação.\n\nPEDIDO: ${String(pedido || '').slice(0, 600)}`;
 }
 
 /** Limpa a resposta do modelo. Devolve null quando não dá para confiar nela. */
@@ -58,7 +59,9 @@ function limpar(resposta, nomes) {
         .replace(/^(nome|pasta)\s*:\s*/i, '');
     if (!primeira || primeira.length > 60 || primeira.split(/\s+/).length > 5) return null;
     const c = convencao(nomes);
-    let nome = slugify(primeira).split('-').filter(Boolean).slice(0, 4).join('-');
+    // A mesma régua das pastas do Estúdio (lib/nome-curto.js): sem "de/da",
+    // sem corte no meio da palavra, até 28 letras.
+    let nome = nomeCurto(primeira) || slugify(primeira).split('-').filter(Boolean).slice(0, 4).join('-');
     if (!nome || GENERICOS.has(nome)) return null;
     if (c && c.separador === '_') nome = nome.replace(/-/g, '_');
     return semColisao(nome, nomes);