primocode 7.0.3 → 7.2.0

package/lib/act.js

@@ -1,153 +1,163 @@
-// Loop do agente autônomo — streaming via /api/act/stream
+// Loop do agente autônomo — streaming via /api/act/stream.
+//
+// O contrato com o servidor é uma conversa completa (`messages`, estilo OpenAI).
+// Cada volta do loop: o servidor devolve tool_calls -> executamos AQUI, com await,
+// e devolvemos o resultado na próxima volta. Sem isso o modelo fica cego e repete
+// a mesma tool até estourar o limite.
 
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
 const { c, actionHeader, Spinner } = require('./ui');
 const tools = require('./tools');
 const api = require('./api');
-const { ROOT_DIR } = require('./config');
+const cfg = require('./config');
 
 const MAX_ITERATIONS = 15;
 
-function makeLogger() {
-    return {
-        event(kind, arg, result) {
-            if (kind === 'run_shell') return;
-            if (kind === 'run_shell_done') {
-                if (result) { const s = result.ok ? c.ok('  exit 0') : c.err(`  exit ${result.code}${result.killed?' timeout':''}`); process.stdout.write('\n'+s+'\n'); }
-                return;
-            }
-            const prefix = c.muted('  ⎿ ');
-            if (kind === 'write_file' && result && result.ok) { console.log(prefix + c.muted(`${result.created?'created':'updated'} · ${tools.fmtBytes(result.bytes)}`)); return; }
-            if (kind === 'read_file' && result && result.ok) { console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes||0)}${result.truncated?' (truncated)':''}`)); return; }
-            if (kind === 'list_dir' && result && result.ok) { const lines = result.tree.split('\n').slice(0,8); for (const l of lines) console.log(prefix + c.muted(l)); const total = result.tree.split('\n').length; if (total>8) console.log(prefix + c.muted(`… +${total-8}`)); return; }
-            if (kind === 'open_in_browser' && result && result.ok) { console.log(prefix + c.muted(`${result.opener||'browser'}`)); return; }
-            if (kind === 'run_in_new_terminal' && result && result.ok) { console.log(prefix + c.muted(`${result.opener}`)); return; }
-            if (kind === 'finish') { console.log(prefix + c.muted(arg || 'ok')); return; }
-            if (result && result.ok === false) console.log(prefix + c.err(result.error || 'failed'));
-        },
-    };
-}
-
-function readMemory(projectDir, projectName) {
-    let context = '';
-
-    // Ler you.md (memória geral)
-    const youMdPath = path.join(ROOT_DIR, 'you.md');
-    if (fs.existsSync(youMdPath)) {
-        try {
-            const youContent = fs.readFileSync(youMdPath, 'utf-8');
-            context += `[Memória Geral (you.md)]\n${youContent.slice(0, 2000)}\n\n`;
-        } catch {}
-    }
-
-    // Ler memory.md do projeto
-    if (projectDir && projectName) {
-        const memoryPath = path.join(projectDir, 'memory.md');
-        if (fs.existsSync(memoryPath)) {
-            try {
-                const memContent = fs.readFileSync(memoryPath, 'utf-8');
-                context += `[Memória do Projeto: ${projectName}]\n${memContent.slice(0, 2000)}\n\n`;
-            } catch {}
+function logResult(kind, result) {
+    const prefix = c.muted('  ⎿ ');
+    if (!result) return;
+    if (result.ok === false) { console.log(prefix + c.err(result.error || `exit ${result.code ?? 'erro'}`)); return; }
+
+    switch (kind) {
+        case 'write_file':
+            console.log(prefix + c.muted(`${result.created ? 'created' : 'updated'} · ${tools.fmtBytes(result.bytes)}`));
+            return;
+        case 'read_file':
+            console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes || 0)}${result.truncated ? ' (truncated)' : ''}`));
+            return;
+        case 'list_dir': {
+            const lines = (result.tree || '').split('\n').filter(Boolean);
+            for (const l of lines.slice(0, 8)) console.log(prefix + c.muted(l));
+            if (lines.length > 8) console.log(prefix + c.muted(`… +${lines.length - 8}`));
+            return;
         }
+        case 'run_shell':
+            console.log(prefix + c.ok('exit 0'));
+            return;
+        case 'open_in_browser':
+        case 'run_in_new_terminal':
+            console.log(prefix + c.muted(result.opener || 'ok'));
+            return;
     }
+}
 
-    return context;
+// O que mandamos de volta ao modelo. Cortamos saídas gigantes para não
+// estourar a janela de contexto na iteração seguinte.
+function summarizeForModel(result) {
+    const json = JSON.stringify(result);
+    return json.length > 4000 ? json.slice(0, 4000) + '…(truncado)' : json;
 }
 
-function updateMemory(projectDir, projectName, entry) {
-    if (!projectDir || !projectName) return;
-    const memoryPath = path.join(projectDir, 'memory.md');
-    try {
-        let content = '';
-        if (fs.existsSync(memoryPath)) {
-            content = fs.readFileSync(memoryPath, 'utf-8');
-        }
-        const timestamp = new Date().toISOString().split('T')[0];
-        content += `\n## ${timestamp}\n${entry}\n`;
-        fs.writeFileSync(memoryPath, content, 'utf-8');
-    } catch {}
+function buildMemoryContext(projectDir, projectName) {
+    const parts = [];
+    const geral = cfg.readGeneralMemory();
+    if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
+    const projeto = cfg.readProjectMemory(projectDir);
+    if (projeto.trim()) parts.push(`[${projectName}/memory.md]\n${projeto}`);
+    return parts.join('\n\n');
 }
 
 async function runAct(userPrompt, opts) {
-    const { server, model, history, projectDir, projectName } = opts || {};
-    const logger = makeLogger();
-
-    // Ler memórias
-    const memoryContext = readMemory(projectDir, projectName);
-
-    // Montar prompt com contexto de memória
-    const fullPrompt = memoryContext 
-        ? `[Contexto de memória]\n${memoryContext}\n[Tarefa]\n${userPrompt}`
-        : userPrompt;
+    const { server, model, token, history, projectDir, projectName, ensureWorkDir } = opts || {};
+    // A pasta só nasce quando o agente for mesmo mexer em arquivo. Um "oi"
+    // não deve deixar diretório vazio espalhado pelo disco.
+    let workDirReady = !ensureWorkDir;
+
+    // Conversa completa desta tarefa: histórico recente + memória + pedido.
+    const messages = [];
+    const memory = buildMemoryContext(projectDir, projectName);
+    if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
+    for (const m of (history || []).slice(-20)) {
+        if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
+    }
+    messages.push({ role: 'user', content: userPrompt });
 
-    const toolResults = [];
-    let iteration = 0;
-    let plan = '';
-    let assistantContent = '';
+    let finalText = '';
 
-    while (iteration < MAX_ITERATIONS) {
-        iteration++;
+    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
         const sp = new Spinner('Primo Code pensando').start();
 
+        const toolCalls = [];
+        let assistantText = '';
+        let streamError = null;
+        let streaming = false;
+
         try {
-            await api.requestAct(server, fullPrompt, history, model, { projectDir, projectName, plan_cache: plan, tool_results: toolResults }, (evt) => {
-                if (evt.plan) {
-                    plan = evt.plan;
-                }
-                if (evt.tool_call) {
-                    sp.stop();
-                    const tc = evt.tool_call;
-                    console.log(actionHeader(tc.name, tc.arguments));
-                    logger.event(tc.name, tc.arguments);
-
-                    // Executar tool localmente
-                    tools.execute(tc.name, tc.arguments).then(result => {
-                        logger.event(tc.name + '_done', null, result);
-                        toolResults.push({ tool_call_id: tc.id || 'tc_' + iteration, result });
-                    });
-                    sp.start();
-                }
-                if (evt.assistant_message) {
-                    assistantContent = evt.assistant_message.content || '';
-                }
+            await api.requestAct(server, { messages, model, token, projectDir, projectName }, (evt) => {
+                if (evt.erro) { streamError = evt.erro; return; }
+                if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
-                    sp.stop();
-                    process.stdout.write(evt.delta);
-                    sp.start();
+                    if (!streaming) { sp.stop(); streaming = true; }
+                    assistantText += evt.delta;
+                    process.stdout.write(c.white(evt.delta));
                 }
+                if (evt.assistant_message) assistantText = evt.assistant_message.content || assistantText;
             });
+        } catch (e) {
             sp.stop();
+            console.log(c.err(`\nErro: ${e.message || e}`));
+            throw e;
+        }
+        sp.stop();
 
-            // Se não teve tool_calls, mostrar conteúdo
-            if (toolResults.length === 0 && assistantContent) {
-                console.log('\n' + c.white(assistantContent));
-                // Atualizar memória
-                updateMemory(projectDir, projectName, `Tarefa: ${userPrompt}\nResultado: ${assistantContent.slice(0, 500)}`);
-                return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: assistantContent } };
-            }
+        if (streamError) {
+            console.log(c.err(`\nErro: ${streamError}`));
+            return { assistantMessage: { role: 'assistant', content: `Erro: ${streamError}` } };
+        }
 
-            // Se teve tool_results, enviar de volta para próximo turno
-            if (toolResults.length > 0) {
-                // Limpar para próximo turno
-                toolResults.length = 0;
-                assistantContent = '';
+        // Sem tool_calls: o modelo respondeu e acabou.
+        if (!toolCalls.length) {
+            finalText = assistantText.trim();
+            if (finalText && !streaming) console.log('\n' + c.white(finalText));
+            else if (streaming) process.stdout.write('\n');
+            break;
+        }
+
+        if (streaming) process.stdout.write('\n');
+
+        // Registra na conversa o turno do assistente COM os tool_calls.
+        // A API exige que cada mensagem role:'tool' venha depois deste turno.
+        messages.push({
+            role: 'assistant',
+            content: assistantText || null,
+            tool_calls: toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: JSON.stringify(tc.arguments || {}) },
+            })),
+        });
+
+        let finished = null;
+        for (const tc of toolCalls) {
+            if (tc.name === 'finish') {
+                finished = (tc.arguments && tc.arguments.summary) || 'Concluído.';
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
                 continue;
             }
 
-            break;
-        } catch (e) {
-            sp.stop();
-            console.log(c.err(`\nErro: ${e.message||e}`));
-            throw e;
+            if (!workDirReady) { ensureWorkDir(); workDirReady = true; }
+
+            console.log(actionHeader(tc.name, tc.arguments));
+            const result = await tools.execute(tc.name, tc.arguments, { projectDir });
+            logResult(tc.name, result);
+            messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }
+
+        if (finished) { finalText = finished; console.log('\n' + c.white(finished)); break; }
     }
 
-    // Atualizar memória
-    updateMemory(projectDir, projectName, `Tarefa: ${userPrompt}\nResultado: Concluído`);
-    return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: assistantContent || 'Concluído.' } };
+    if (!finalText) finalText = 'Cheguei ao limite de passos sem concluir. Refaça o pedido em partes menores.';
+
+    // Nada de arquivo mexido = nada para lembrar.
+    if (projectName && workDirReady) {
+        cfg.appendProjectMemory(projectDir, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
+    }
+
+    return {
+        userMessage: { role: 'user', content: userPrompt },
+        assistantMessage: { role: 'assistant', content: finalText },
+    };
 }
 
 module.exports = { runAct };

package/lib/api.js

@@ -1,5 +1,5 @@
 /**
- * API client — comunicação com primocode-server
+ * Cliente HTTP do primocode-server.
  */
 
 'use strict';
@@ -8,35 +8,128 @@ const https = require('https');
 const http = require('http');
 const { URL } = require('url');
 
-function request(serverUrl, endpoint, payload) {
+// Erro cru do servidor não diz o que fazer. Estes dois dizem.
+function explainHttpError(status, msg) {
+    if (status === 401) {
+        return `${msg}\nEste servidor pede um token. Configure com:\n  export PRIMOCODE_TOKEN="seu-token"\nou adicione "token" em ~/.primocode/config.json`;
+    }
+    if (status === 429) {
+        return `${msg}\nSe você é o dono do servidor, configure PRIMOCODE_TOKEN para não ter limite.`;
+    }
+    return msg;
+}
+
+function buildOptions(url, method, extraHeaders, bodyLength, token) {
+    const headers = { ...extraHeaders };
+    if (bodyLength != null) {
+        headers['Content-Type'] = 'application/json';
+        headers['Content-Length'] = bodyLength;
+    }
+    if (token) headers['x-primocode-token'] = token;
+    return {
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 80),
+        path: url.pathname + url.search,
+        method,
+        headers,
+    };
+}
+
+function request(serverUrl, endpoint, payload, token) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, serverUrl);
         const data = JSON.stringify(payload);
-        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data) } };
-        const client = url.protocol==='https:' ? https : http;
-        const req = client.request(options, (res) => { let body=''; res.on('data', c=>body+=c); res.on('end', () => { try { const json=JSON.parse(body); if (res.statusCode>=400) reject(new Error(json.erro||json.error||`HTTP ${res.statusCode}`)); else resolve(json); } catch { reject(new Error(`Resposta inválida: ${body.slice(0,200)}`)); } }); });
-        req.on('error', reject); req.write(data); req.end();
+        const client = url.protocol === 'https:' ? https : http;
+        const req = client.request(buildOptions(url, 'POST', {}, Buffer.byteLength(data), token), (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                let json;
+                try { json = JSON.parse(body); }
+                catch { return reject(new Error(`Resposta inválida (HTTP ${res.statusCode}): ${body.slice(0, 200)}`)); }
+                if (res.statusCode >= 400) reject(new Error(json.erro || json.error || `HTTP ${res.statusCode}`));
+                else resolve(json);
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
     });
 }
 
-function requestStream(serverUrl, endpoint, payload, onEvent) {
+function requestStream(serverUrl, endpoint, payload, onEvent, token) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, serverUrl);
         const data = JSON.stringify(payload);
-        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data), 'Accept':'text/event-stream' } };
-        const client = url.protocol==='https:' ? https : http;
-        const req = client.request(options, (res) => { let buffer=''; res.on('data', chunk => { buffer+=chunk; const lines=buffer.split('\n'); buffer=lines.pop(); for (const line of lines) if (line.startsWith('data: ')) { try { const evt=JSON.parse(line.slice(6)); onEvent(evt); if (evt.done) resolve(); } catch {} } }); res.on('end', () => resolve()); });
-        req.on('error', reject); req.write(data); req.end();
+        const client = url.protocol === 'https:' ? https : http;
+        const options = buildOptions(url, 'POST', { Accept: 'text/event-stream' }, Buffer.byteLength(data), token);
+
+        const req = client.request(options, (res) => {
+            // Erro HTTP não vem como SSE — o corpo é um JSON de erro.
+            if (res.statusCode >= 400) {
+                let body = '';
+                res.on('data', (chunk) => { body += chunk; });
+                res.on('end', () => {
+                    let msg = `HTTP ${res.statusCode}`;
+                    try { const j = JSON.parse(body); msg = j.erro || j.error || msg; } catch {}
+                    reject(new Error(explainHttpError(res.statusCode, msg)));
+                });
+                return;
+            }
+
+            let settled = false;
+            const finish = () => { if (!settled) { settled = true; resolve(); } };
+
+            let buffer = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                buffer += chunk;
+                const lines = buffer.split('\n');
+                buffer = lines.pop();
+                for (const line of lines) {
+                    if (!line.startsWith('data: ')) continue;
+                    let evt;
+                    try { evt = JSON.parse(line.slice(6)); } catch { continue; }
+                    onEvent(evt);
+                    if (evt.done) finish();
+                }
+            });
+            res.on('end', finish);
+            res.on('error', reject);
+        });
+
+        req.on('error', reject);
+        req.write(data);
+        req.end();
     });
 }
 
-function requestAct(serverUrl, prompt, history, model, extras, onEvent) { 
-    // Envia prompt (string) e history (array) separados para /api/act/stream
-    return requestStream(serverUrl, '/api/act/stream', { prompt, history, model, ...(extras || {}) }, onEvent);
+// Agente autônomo. `payload` carrega a conversa completa (messages).
+function requestAct(serverUrl, payload, onEvent) {
+    const { token, ...body } = payload;
+    return requestStream(serverUrl, '/api/act/stream', body, onEvent, token);
+}
+
+// Chat puro.
+function requestChat(serverUrl, payload, onEvent) {
+    const { token, ...body } = payload;
+    return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token);
 }
 
-function getHealth(serverUrl) {
-    return new Promise((resolve, reject) => { const url=new URL('/health',serverUrl); const client=url.protocol==='https:'?https:http; const req=client.get(url, (res)=>{ let body=''; res.on('data',c=>body+=c); res.on('end',()=>{ try { resolve(JSON.parse(body)); } catch { reject(new Error('Resposta inválida do health check')); } }); }); req.on('error',reject); });
+function getHealth(serverUrl, token) {
+    return new Promise((resolve, reject) => {
+        const url = new URL('/health', serverUrl);
+        const client = url.protocol === 'https:' ? https : http;
+        const req = client.get(buildOptions(url, 'GET', {}, null, token), (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try { resolve(JSON.parse(body)); }
+                catch { reject(new Error(`Resposta inválida do health check (HTTP ${res.statusCode})`)); }
+            });
+        });
+        req.on('error', reject);
+    });
 }
 
-module.exports = { request, requestStream, requestAct, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, getHealth };