primocode 7.0.1 → 7.0.3

package/bin/primocode.js

@@ -69,11 +69,14 @@ async function sendPrompt(userText) {
 
     if (state.mode === 'agent') {
         await runAgent(promptWithAttach, userText);
-    } else if (state.mode === 'act') {
+    } else if (state.mode === 'primocode') {
+        const projectDir = state.currentProject ? getProjectDir(state.currentProject) : process.cwd();
         const r = await runAct(promptWithAttach, {
             server: state.config.server,
             model: state.config.model,
             history: state.history,
+            projectDir: projectDir,
+            projectName: state.currentProject,
         });
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
@@ -354,7 +357,7 @@ async function main() {
             catch { console.log(c.err(`Não consegui ler: ${args[fileFlag+1]}`)); process.exit(1); }
         }
         if (isAgent) await runAgent(promptText, prompt);
-        else { const r = await runAct(promptText, {server:state.config.server, model:state.config.model, history:[]}); console.log('\n'+c.white(r.assistantMessage.content)); }
+        else { const r = await runAct(promptText, {server:state.config.server, model:state.config.model, history:[], projectDir: process.cwd()}); console.log('\n'+c.white(r.assistantMessage.content)); }
         process.exit(0);
     }
     console.log(welcomeBox(VERSION, state.config.server));

package/lib/act.js

@@ -1,10 +1,13 @@
-// Loop do agente autônomo — vai e volta entre server e execução local.
+// Loop do agente autônomo — streaming via /api/act/stream
 
 '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 MAX_ITERATIONS = 15;
 
@@ -28,45 +31,123 @@ function makeLogger() {
     };
 }
 
+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 {}
+        }
+    }
+
+    return context;
+}
+
+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 {}
+}
+
 async function runAct(userPrompt, opts) {
     const { server, model, history, projectDir, projectName } = opts || {};
     const logger = makeLogger();
-    const messages = [
-        ...(Array.isArray(history) ? history.filter(m => m && m.role && m.content).slice(-20) : []),
-        { role: 'user', content: userPrompt },
-    ];
+
+    // 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 toolResults = [];
     let iteration = 0;
+    let plan = '';
+    let assistantContent = '';
 
     while (iteration < MAX_ITERATIONS) {
         iteration++;
-        const sp = new Spinner('pensando').start();
-        let response;
-        try { response = await api.requestAct(server, messages, model); }
-        catch (e) { sp.stop(); console.log(c.err(`\nErro no servidor: ${e.message||e}`)); throw e; }
-        sp.stop();
-
-        if (!response.tool_calls || !response.tool_calls.length) {
-            const content = response.content || '';
-            console.log('\n' + c.white(content));
-            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content } };
-        }
+        const sp = new Spinner('Primo Code pensando').start();
 
-        for (const tc of response.tool_calls) {
-            const name = tc.function?.name || tc.name;
-            let args = {}; try { args = JSON.parse(tc.function?.arguments || tc.arguments || '{}'); } catch {}
-            console.log(actionHeader(name, args));
-            logger.event(name, null, null);
-            let result; try { result = await tools.execute(name, args); } catch (e) { result = { ok: false, error: e.message || String(e) }; }
-            logger.event(name + '_done', null, result);
-            toolResults.push({ tool_call_id: tc.id, role: 'tool', name, content: JSON.stringify(result) });
-        }
+        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 || '';
+                }
+                if (evt.delta) {
+                    sp.stop();
+                    process.stdout.write(evt.delta);
+                    sp.start();
+                }
+            });
+            sp.stop();
 
-        messages.push({ role: 'assistant', content: response.content || '', tool_calls: response.tool_calls });
-        for (const tr of toolResults) messages.push({ role: 'tool', tool_call_id: tr.tool_call_id, name: tr.name, content: tr.content });
+            // 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 } };
+            }
+
+            // Se teve tool_results, enviar de volta para próximo turno
+            if (toolResults.length > 0) {
+                // Limpar para próximo turno
+                toolResults.length = 0;
+                assistantContent = '';
+                continue;
+            }
+
+            break;
+        } catch (e) {
+            sp.stop();
+            console.log(c.err(`\nErro: ${e.message||e}`));
+            throw e;
+        }
     }
-    console.log(c.err('\nLimite de iterações atingido.'));
-    return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: 'Limite de iterações atingido.' } };
+
+    // Atualizar memória
+    updateMemory(projectDir, projectName, `Tarefa: ${userPrompt}\nResultado: Concluído`);
+    return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: assistantContent || 'Concluído.' } };
 }
 
 module.exports = { runAct };

package/lib/api.js

@@ -30,8 +30,9 @@ function requestStream(serverUrl, endpoint, payload, onEvent) {
     });
 }
 
-function requestAct(serverUrl, messages, model, extras) { 
-    return request(serverUrl, '/api/act', { messages, model, ...(extras || {}) }); 
+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);
 }
 
 function getHealth(serverUrl) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "7.0.1",
+  "version": "7.0.3",
   "description": "PrimoCode \u2014 agente de engenharia com IA e cursor pr\u00f3prio. Modo primocode cria arquivos, controla o desktop e navegador. Modo chat \u00e9 conversa pura.",
   "main": "bin/primocode.js",
   "bin": "./bin/primocode.js",