primocode 7.0.3 → 7.2.0

package/bin/primocode.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 /**
- * PrimoCode CLI v6.1  ·  ConectaPrimoAI
- *   Interface estilo Claude Code — minimalista, poderosa, elegante.
- *   Auto-instalação de Node.js com confirmação Y/n e barra de progresso.
- *   Suporte Termux (pkg install nodejs).
+ * PrimoCode CLI  ·  ConectaPrimoAI
  *   Modos: primocode (agente completo, PADRÃO) · chat (conversa pura)
+ *   Cada sessão trabalha dentro de uma pasta de projeto em ~/primocode/.
  */
 
 'use strict';
@@ -13,14 +11,12 @@ const readline = require('readline');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const { execSync, spawn } = require('child_process');
-const pkg = require('../package.json');
 
-const { c, welcomeBox, Spinner, ProgressBar, askYesNo } = require('../lib/ui');
+const pkg = require('../package.json');
+const { c, welcomeBox, Spinner } = require('../lib/ui');
 const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
-const { createProjectDir, getProjectDir, listProjects } = require('../lib/config');
 const { runAct } = require('../lib/act');
 
 const VERSION = pkg.version;
@@ -32,59 +28,141 @@ const state = {
     attachedFiles: [],
     lastResponse: '',
     currentProject: null,
+    workDir: null, // pasta onde o agente trabalha nesta sessão
 };
 
 const HELP = `
 ${c.bold('Comandos')}
   ${c.brand('/project')}              lista projetos ou muda: /project <nome>
-  ${c.brand('/mode')}                 Primo Code / Chat
-  ${c.brand('/attach')}               (Caminho do arquivo ou pasta) anexa arquivo
-  ${c.brand('/clear')}                limpa conversa
-  ${c.brand('/cls')}                  limpa tela
-  ${c.brand('/uninstall')}            remove PrimoCode
+  ${c.brand('/mode')}                 alterna: /mode primocode|chat
+  ${c.brand('/attach')} <arquivo>     anexa arquivo ao próximo pedido
+  ${c.brand('/files')}                lista anexos   ${c.brand('/detach')} remove
+  ${c.brand('/tree')} [n]             árvore do projeto
+  ${c.brand('/read')} <arquivo>       mostra um arquivo
+  ${c.brand('/run')} <comando>        executa no shell do projeto
+  ${c.brand('/open')} <arquivo|url>   abre no navegador
+  ${c.brand('/status')}               checa o servidor
+  ${c.brand('/clear')}                limpa a conversa   ${c.brand('/cls')} limpa a tela
+  ${c.brand('/uninstall')}            remove o PrimoCode
   ${c.brand('/exit')}                 sair
 
 ${c.bold('Modos')}
-  ${c.magenta('Primo Code')}  ${c.muted('Agente completo — cursor próprio, escreve código, controla desktop e navegador')}
+  ${c.magenta('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
   ${c.brand('Chat')}        ${c.muted('Conversa pura — sem tools, só diálogo')}
 `;
 
 let rl = null;
 
 function makePrompt() {
-    const modeTag = state.mode === 'primocode'
-        ? c.magenta('Primo Code')
-        : c.brand('Chat');
+    const modeTag = state.mode === 'primocode' ? c.magenta('Primo Code') : c.brand('Chat');
+    const proj = state.currentProject ? c.dim(` ${state.currentProject}`) : '';
     const att = state.attachedFiles.length ? c.muted(` +${state.attachedFiles.length}`) : '';
-    return `\n${c.muted(modeTag + att)} ${c.brand('❯')} `;
+    return `\n${c.muted(modeTag)}${proj}${att} ${c.brand('❯')} `;
 }
 function refreshPrompt() { if (rl) rl.setPrompt(makePrompt()); }
 
+// Enquanto uma pergunta está no ar, a próxima linha digitada é a RESPOSTA dela
+// — não um novo comando. Sem isso o "s" de confirmação virava prompt para a IA.
+let pendingAsk = null;
+
+function ask(question) {
+    return new Promise((resolve) => {
+        if (rl) { process.stdout.write(question); pendingAsk = resolve; return; }
+        const tmp = readline.createInterface({ input: process.stdin, output: process.stdout });
+        tmp.question(question, (a) => { tmp.close(); resolve(a); });
+    });
+}
+
+async function confirm(question) {
+    const raw = await ask(`${c.brand('?')} ${question} ${c.muted('(S/n)')} `);
+    if (!process.stdin.isTTY) process.stdout.write('\n'); // pipe não ecoa o Enter
+    const a = raw.trim().toLowerCase();
+    return a === '' || a === 's' || a === 'sim' || a === 'y' || a === 'yes';
+}
+
+// ── Projetos ───────────────────────────────────────────────────────────
+
+const STOPWORDS = new Set([
+    'crie', 'cria', 'criar', 'faca', 'faça', 'faz', 'fazer', 'monte', 'montar',
+    'desenvolva', 'desenvolver', 'construa', 'construir', 'gere', 'gerar',
+    'quero', 'queria', 'gostaria', 'preciso', 'me', 'meu', 'minha', 'favor',
+    'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'por', 'pra', 'para',
+]);
+
+// "crie um jogo de carro" -> "jogo de carro"
+function deriveProjectName(text) {
+    const words = String(text).trim().split(/\s+/);
+    let i = 0;
+    while (i < words.length && STOPWORDS.has(words[i].toLowerCase().replace(/[^\wáéíóúâêôãõç]/gi, ''))) i++;
+    const picked = words.slice(i, i + 5).join(' ').replace(/[^\w\sáéíóúâêôãõçÁÉÍÓÚÂÊÔÃÕÇ-]/gi, '').trim();
+    return picked || 'projeto';
+}
+
+// Como o Claude Code: se você abriu o PrimoCode dentro de uma pasta de
+// trabalho, é ali que ele trabalha. Home e raiz de disco não contam — ninguém
+// quer um agente soltando arquivo no meio de C:\Users\você.
+function isUsableCwd(dir) {
+    const home = os.homedir();
+    const resolved = path.resolve(dir);
+    if (resolved === path.resolve(home)) return false;
+    if (resolved === path.parse(resolved).root) return false;
+    if (resolved.startsWith(path.join(home, 'primocode'))) return false;
+    return true;
+}
+
+// Escolhe onde trabalhar SEM criar nada. A pasta só é criada de verdade em
+// createPendingProject(), quando o agente for mexer em arquivo.
+function planWorkDir(userText) {
+    if (state.workDir) return { dir: state.workDir, pending: false };
+    const proposed = deriveProjectName(userText);
+    const similar = cfg.findSimilarProject(proposed);
+    const name = similar ? similar.name : proposed;
+    return { dir: cfg.getProjectDir(name), pending: true, name, similar: !!similar };
+}
+
+function createPendingProject(plan) {
+    const dir = cfg.createProjectDir(plan.name);
+    state.workDir = dir;
+    state.currentProject = path.basename(dir);
+    const rotulo = plan.similar ? 'Continuando em' : 'Projeto novo:';
+    console.log(c.ok(`  ${rotulo} ${state.currentProject}`) + c.muted(`  (${dir})`));
+    refreshPrompt();
+    return dir;
+}
+
+function projectDir() {
+    return state.workDir || process.cwd();
+}
+
+// ── Envio ──────────────────────────────────────────────────────────────
+
 async function sendPrompt(userText) {
-    let promptWithAttach = userText;
+    let prompt = userText;
     if (state.attachedFiles.length) {
-        const parts = state.attachedFiles.map(f => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
-        promptWithAttach = parts.join('\n\n') + '\n\n' + userText;
+        const parts = state.attachedFiles.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
+        prompt = parts.join('\n\n') + '\n\n' + userText;
     }
 
-    if (state.mode === 'agent') {
-        await runAgent(promptWithAttach, userText);
-    } else if (state.mode === 'primocode') {
-        const projectDir = state.currentProject ? getProjectDir(state.currentProject) : process.cwd();
-        const r = await runAct(promptWithAttach, {
+    if (state.mode === 'primocode') {
+        const plan = planWorkDir(userText);
+        const r = await runAct(prompt, {
             server: state.config.server,
             model: state.config.model,
+            token: state.config.token,
             history: state.history,
-            projectDir: projectDir,
-            projectName: state.currentProject,
+            projectDir: plan.dir,
+            projectName: plan.pending ? plan.name : state.currentProject,
+            // Só chamado se o agente for mesmo mexer em arquivo.
+            ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
         });
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
         state.lastResponse = r.assistantMessage.content;
-        cfg.appendHistory({ mode: 'primocode', prompt: userText, response: r.assistantMessage.content });
+        cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
     } else {
-        await runChat(promptWithAttach, userText);
+        await runChat(prompt, userText);
     }
+
     state.attachedFiles = [];
     refreshPrompt();
 }
@@ -94,282 +172,251 @@ async function runChat(promptForModel, userTextForMemory) {
     let started = false;
     let text = '';
     try {
-        await api.requestStream(state.config.server, '/api/normal/stream', {
+        await api.requestChat(state.config.server, {
             prompt: promptForModel,
             history: state.history.slice(-20),
             model: state.config.model,
+            token: state.config.token,
         }, (evt) => {
-            if (evt.erro) {
-                if (!started) sp.stop();
-                console.log(c.err(`\nerro: ${evt.erro}`));
-                return;
-            }
+            if (evt.erro) { if (!started) sp.stop(); console.log(c.err(`\nerro: ${evt.erro}`)); return; }
             if (evt.delta) {
                 if (!started) { sp.stop(); process.stdout.write('\n'); started = true; }
                 text += evt.delta;
                 process.stdout.write(c.white(evt.delta));
             }
-            if (evt.done) { if (!started) sp.stop(); process.stdout.write('\n'); }
+            if (evt.done && !started) sp.stop();
         });
     } catch (e) {
         sp.stop();
         console.log(c.err(`\n${e.message || e}`));
+        return;
     }
+    sp.stop();
     if (text) {
+        process.stdout.write('\n');
         state.history.push({ role: 'user', content: userTextForMemory });
         state.history.push({ role: 'assistant', content: text });
         state.lastResponse = text;
-        cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory, response: text });
+        cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory });
     }
 }
 
-async function runAgent(promptForModel, userTextForMemory) {
-    const sp = new Spinner('agente pensando').start();
-    let step = '';
-    let text = '';
-    try {
-        await api.requestStream(state.config.server, '/api/agent/stream', {
-            prompt: promptForModel,
-            history: state.history.slice(-20),
-        }, (evt) => {
-            if (evt.erro) { sp.stop(); console.log(c.err(`\nerro: ${evt.erro}`)); return; }
-            if (evt.step && evt.event === 'start') {
-                if (!step) sp.stop();
-                step = evt.step;
-                const label = step === 'arquiteto' ? 'Arquiteto' : step === 'engenheiro' ? 'Engenheiro' : 'Revisor';
-                console.log(c.muted(`\n  ${label}…`));
-                return;
-            }
-            if (evt.step === 'revisor' && evt.delta) {
-                if (!text) process.stdout.write('\n');
-                text += evt.delta;
-                process.stdout.write(c.white(evt.delta));
-            }
-            if (evt.done) process.stdout.write('\n');
-        });
-    } catch (e) { sp.stop(); console.log(c.err(`\n${e.message || e}`)); }
-    if (text) {
-        state.history.push({ role: 'user', content: userTextForMemory });
-        state.history.push({ role: 'assistant', content: text });
-        state.lastResponse = text;
-        cfg.appendHistory({ mode: 'agent', prompt: userTextForMemory, response: text });
-    }
-}
+// ── Slash commands ─────────────────────────────────────────────────────
 
 function isSlash(text) { return text.trim().startsWith('/'); }
 
 async function handleSlash(text) {
-    const [cmd, ...args] = text.trim().slice(1).split(/\s+/);
+    const [cmd] = text.trim().slice(1).split(/\s+/);
     const rest = text.trim().slice(1 + cmd.length).trim();
+
     switch (cmd.toLowerCase()) {
         case 'help': console.log(HELP); break;
+
+        case 'project': {
+            if (!rest) {
+                const projects = cfg.listProjects();
+                if (!projects.length) { console.log(c.muted('  Nenhum projeto ainda. Peça algo e eu crio o primeiro.')); break; }
+                console.log('');
+                for (const p of projects) {
+                    const mark = p === state.currentProject ? c.brand(' ●') : '  ';
+                    console.log(`${mark} ${p === state.currentProject ? c.brand(p) : c.white(p)}`);
+                }
+                console.log(c.muted(`\n  ${cfg.ROOT_DIR}`));
+                break;
+            }
+            const dir = cfg.createProjectDir(rest);
+            state.workDir = dir;
+            state.currentProject = path.basename(dir);
+            console.log(c.ok(`Projeto: ${state.currentProject}`) + c.muted(`  (${dir})`));
+            refreshPrompt();
+            break;
+        }
+
         case 'mode': {
             const m = rest.toLowerCase();
-            if (['act','agent','chat'].includes(m)) { state.mode = m; console.log(c.ok(`Modo: ${m}`)); }
-            else console.log(c.err('Uso: /mode chat|agent|act'));
+            if (['primocode', 'chat'].includes(m)) { state.mode = m; console.log(c.ok(`Modo: ${m}`)); refreshPrompt(); }
+            else console.log(c.err('Uso: /mode primocode|chat'));
             break;
         }
+
         case 'model': {
             const m = rest.toLowerCase();
-            if (['main','fast'].includes(m)) { state.config.model = m; cfg.saveConfig(state.config); console.log(c.ok(`Modelo: ${m}`)); }
+            if (['main', 'fast'].includes(m)) { state.config.model = m; cfg.saveConfig({ model: m }); console.log(c.ok(`Modelo: ${m}`)); }
             else console.log(c.err('Uso: /model main|fast'));
             break;
         }
+
         case 'attach': {
             if (!rest) { console.log(c.err('Uso: /attach <arquivo>')); break; }
-            try { const content = fs.readFileSync(path.resolve(rest), 'utf-8'); state.attachedFiles.push({ path: rest, content }); console.log(c.ok(`Anexado: ${rest} (${tools.fmtBytes(content.length)})`)); }
-            catch { console.log(c.err(`Não consegui ler: ${rest}`)); }
+            try {
+                const content = fs.readFileSync(path.resolve(rest), 'utf-8');
+                state.attachedFiles.push({ path: rest, content });
+                console.log(c.ok(`Anexado: ${rest} (${tools.fmtBytes(content.length)})`));
+                refreshPrompt();
+            } catch { console.log(c.err(`Não consegui ler: ${rest}`)); }
             break;
         }
-        case 'detach': state.attachedFiles = []; console.log(c.ok('Anexos removidos.')); break;
+
+        case 'detach': state.attachedFiles = []; console.log(c.ok('Anexos removidos.')); refreshPrompt(); break;
+
         case 'files':
             if (!state.attachedFiles.length) console.log(c.muted('Nenhum arquivo anexado.'));
-            else state.attachedFiles.forEach(f => console.log(`  ${c.brand(f.path)} ${c.muted(tools.fmtBytes(f.content.length))}`));
+            else state.attachedFiles.forEach((f) => console.log(`  ${c.brand(f.path)} ${c.muted(tools.fmtBytes(f.content.length))}`));
             break;
-        case 'tree': { const depth = parseInt(rest,10)||2; console.log(tools.treeDir('.', depth)); break; }
+
+        case 'tree': console.log(tools.treeDir(projectDir(), parseInt(rest, 10) || 2)); break;
+
         case 'read': {
             if (!rest) { console.log(c.err('Uso: /read <arquivo>')); break; }
-            try { const content = fs.readFileSync(path.resolve(rest), 'utf-8'); console.log(c.muted(`\n--- ${rest} ---\n`)); console.log(content.length>2000?content.slice(0,2000)+'\n...':content); }
-            catch { console.log(c.err(`Não consegui ler: ${rest}`)); }
-            break;
-        }
-        case 'write': {
-            if (!rest) { console.log(c.err('Uso: /write <arquivo>')); break; }
-            if (!state.lastResponse) { console.log(c.err('Nenhuma resposta para salvar.')); break; }
-            try { fs.writeFileSync(path.resolve(rest), state.lastResponse, 'utf-8'); console.log(c.ok(`Salvo em: ${rest}`)); }
-            catch (e) { console.log(c.err(`Erro: ${e.message}`)); }
-            break;
-        }
-        case 'apply': {
-            const applied = tools.applyCodeBlocks(state.lastResponse);
-            if (applied.length) applied.forEach(a => console.log(c.ok(`${a.created?'Criado':'Atualizado'}: ${a.path}`)));
-            else console.log(c.muted('Nenhum bloco com hint // filename: encontrado.'));
+            try {
+                const content = fs.readFileSync(path.resolve(projectDir(), rest), 'utf-8');
+                console.log(c.muted(`\n--- ${rest} ---\n`));
+                console.log(content.length > 2000 ? content.slice(0, 2000) + '\n…' : content);
+            } catch { console.log(c.err(`Não consegui ler: ${rest}`)); }
             break;
         }
+
         case 'run': {
             if (!rest) { console.log(c.err('Uso: /run <comando>')); break; }
             console.log(c.muted(`$ ${rest}`));
-            const result = await tools.runShell(rest);
+            const result = await tools.runShell(rest, 60000, projectDir());
             if (result.stdout) console.log(result.stdout);
             if (result.stderr) console.log(c.err(result.stderr));
             if (result.code !== 0) console.log(c.err(`exit ${result.code}`));
             break;
         }
+
         case 'open': {
             if (!rest) { console.log(c.err('Uso: /open <arquivo|url>')); break; }
-            await tools.openInBrowser(rest);
+            const target = /^https?:\/\//i.test(rest) ? rest : path.resolve(projectDir(), rest);
+            await tools.openInBrowser(target);
             console.log(c.ok(`Aberto: ${rest}`));
             break;
         }
-        case 'act': {
-            if (!rest) { console.log(c.err('Uso: /act <tarefa>')); break; }
-            const old = state.mode; state.mode = 'act'; await sendPrompt(rest); state.mode = old;
-            break;
-        }
-        case 'clear': state.history = []; console.log(c.ok('Memória limpa.')); break;
+
+        case 'clear': state.history = []; console.log(c.ok('Conversa limpa.')); break;
         case 'cls': process.stdout.write('\x1Bc'); break;
+
         case 'status': {
-            const sp2 = new Spinner('verificando').start();
-            try { const h = await api.getHealth(state.config.server); sp2.stop(); console.log(c.ok(`Servidor: ${h.status||'ok'}`)); console.log(c.muted(`  Modelos: ${Object.values(h.models||{}).join(', ')}`)); console.log(c.muted(`  Fallback: ${h.using_fallback?'ativo':'inativo'}`)); }
-            catch (e) { sp2.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
+            const sp = new Spinner('verificando').start();
+            try {
+                const h = await api.getHealth(state.config.server, state.config.token);
+                sp.stop();
+                console.log(c.ok(`Servidor: ${h.status || 'ok'}`));
+                if (h.version) console.log(c.muted(`  Versão: ${h.version}`));
+                if (h.model) console.log(c.muted(`  Modelo: ${h.model}`));
+            } catch (e) { sp.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
             break;
         }
+
+        case 'uninstall': {
+            if (await confirm('Remover o PrimoCode? Seus projetos em ~/primocode NÃO serão apagados.')) {
+                await tools.uninstall();
+            } else console.log(c.muted('Cancelado.'));
+            break;
+        }
+
         case 'version': console.log(c.brand(`PrimoCode v${VERSION}`)); break;
-        case 'exit': case 'quit': console.log(c.muted('Até logo!')); process.exit(0);
+        // rl.close() em vez de process.exit(): sair na marra descarta o que
+        // ainda estava no buffer de saída.
+        case 'exit': case 'quit': if (rl) rl.close(); break;
         default: console.log(c.err(`Comando desconhecido: /${cmd}. Digite /help.`));
     }
 }
 
-// Detecta Termux
-function isTermux() {
-    return !!process.env.TERMUX_VERSION || (process.env.PREFIX && process.env.PREFIX.includes('termux'));
-}
-
-// ---- Auto-instalação Node.js com barra de progresso ----
-async function checkAndInstallNode() {
-    const nodeExists = () => { try { execSync('node --version', {stdio:'ignore'}); return true; } catch { return false; } };
+// ── Main ───────────────────────────────────────────────────────────────
 
-    if (nodeExists()) {
-        const v = execSync('node --version', {encoding:'utf-8'}).trim();
-        const major = parseInt(v.replace('v','').split('.')[0]);
-        if (major >= 18) { console.log(c.ok(`Node.js ${v} detectado.`)); return true; }
-        console.log(c.warn(`Node.js ${v} detectado, mas requer v18.17+.`));
-    } else {
-        console.log(c.err('Node.js não encontrado no sistema.'));
-    }
-
-    // PERGUNTA antes de instalar — aguarda resposta do usuário
-    const answer = await askYesNo('Deseja instalar o Node.js automaticamente?');
-    if (!answer) {
-        console.log(c.err('Node.js é necessário para rodar o PrimoCode.'));
-        console.log(c.muted('Instale manualmente em: https://nodejs.org/'));
-        process.exit(1);
-    }
-
-    const platform = os.platform();
-    const pb = new ProgressBar('Instalando Node.js');
+function shortPath(p) {
+    // Normaliza as barras antes de comparar — no Windows o cwd vem com "\"
+    // e a home pode vir com "/", e aí o prefixo nunca batia.
+    const norm = (s) => path.resolve(s).replace(/\\/g, '/');
+    const home = norm(os.homedir());
+    const full = norm(p);
+    return full.startsWith(home + '/') ? '~' + full.slice(home.length) : full;
+}
 
-    try {
-        if (isTermux()) {
-            // Termux — usa pkg
-            pb.start();
-            const child = spawn('pkg', ['install', '-y', 'nodejs'], { stdio: 'pipe' });
-            let stderr = '';
-            child.stderr.on('data', d => { stderr += d; pb.tick(); });
-            await new Promise((resolve, reject) => {
-                child.on('close', code => { pb.stop(); code === 0 ? resolve() : reject(new Error(stderr || 'pkg failed')); });
-            });
-        } else if (platform === 'darwin' || platform === 'linux') {
-            const hasNvm = () => { try { execSync('command -v nvm', {stdio:'ignore'}); return true; } catch { return false; } };
-            const hasFnm = () => { try { execSync('command -v fnm', {stdio:'ignore'}); return true; } catch { return false; } };
-
-            if (hasNvm() || fs.existsSync(path.join(os.homedir(), '.nvm'))) {
-                pb.start();
-                const nvmDir = path.join(os.homedir(), '.nvm');
-                const child = spawn('bash', ['-c', `export NVM_DIR="${nvmDir}" && [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" && nvm install 20 && nvm use 20 && nvm alias default 20`], { stdio: 'pipe' });
-                let stderr = '';
-                child.stderr.on('data', d => { stderr += d; pb.tick(); });
-                await new Promise((resolve, reject) => {
-                    child.on('close', code => { pb.stop(); code === 0 ? resolve() : reject(new Error(stderr || 'nvm failed')); });
-                });
-            } else if (hasFnm()) {
-                pb.start();
-                const child = spawn('bash', ['-c', 'fnm install 20 && fnm use 20 && fnm default 20'], { stdio: 'pipe' });
-                let stderr = '';
-                child.stderr.on('data', d => { stderr += d; pb.tick(); });
-                await new Promise((resolve, reject) => {
-                    child.on('close', code => { pb.stop(); code === 0 ? resolve() : reject(new Error(stderr || 'fnm failed')); });
-                });
-            } else {
-                pb.start();
-                // Instala nvm primeiro
-                const child1 = spawn('bash', ['-c', 'curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash'], { stdio: 'pipe' });
-                let stderr1 = '';
-                child1.stderr.on('data', d => { stderr1 += d; pb.tick(); });
-                await new Promise((resolve, reject) => {
-                    child1.on('close', code => { code === 0 ? resolve() : reject(new Error(stderr1)); });
-                });
-
-                // Instala Node via nvm
-                const nvmDir = path.join(os.homedir(), '.nvm');
-                const child2 = spawn('bash', ['-c', `export NVM_DIR="${nvmDir}" && [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" && nvm install 20 && nvm use 20 && nvm alias default 20`], { stdio: 'pipe' });
-                let stderr2 = '';
-                child2.stderr.on('data', d => { stderr2 += d; pb.tick(); });
-                await new Promise((resolve, reject) => {
-                    child2.on('close', code => { pb.stop(); code === 0 ? resolve() : reject(new Error(stderr2 || 'nvm install failed')); });
-                });
-            }
-        } else if (platform === 'win32') {
-            pb.start();
-            const child = spawn('cmd', ['/c', 'winget install OpenJS.NodeJS.LTS'], { stdio: 'pipe' });
-            let stderr = '';
-            child.stderr.on('data', d => { stderr += d; pb.tick(); });
-            await new Promise((resolve, reject) => {
-                child.on('close', code => { pb.stop(); code === 0 ? resolve() : reject(new Error(stderr || 'winget failed')); });
-            });
-        }
+async function main() {
+    cfg.ensureStructure();
 
-        // Verifica instalação
-        if (!nodeExists()) {
-            throw new Error('Node.js não foi instalado corretamente');
-        }
-        const v = execSync('node --version', {encoding:'utf-8'}).trim();
-        console.log(c.ok(`Node.js ${v} instalado com sucesso!`));
-        return true;
-    } catch (e) {
-        pb.stop();
-        console.log(c.err(`Falha ao instalar Node.js: ${e.message}`));
-        console.log(c.muted('Por favor, instale manualmente: https://nodejs.org/'));
-        process.exit(1);
+    // Abriu dentro de uma pasta de trabalho? Então é ali que ele atua.
+    if (isUsableCwd(process.cwd())) {
+        state.workDir = process.cwd();
+        state.currentProject = path.basename(state.workDir);
     }
-}
 
-async function main() {
-    await checkAndInstallNode();
     const args = process.argv.slice(2);
+
+    // Modo one-shot: primocode "crie um jogo de carro"
     if (args.length && !args[0].startsWith('-')) {
-        const prompt = args.join(' ');
-        const isAgent = args.includes('--agent');
         const fileFlag = args.indexOf('-f');
-        let promptText = prompt;
-        if (fileFlag >= 0 && args[fileFlag+1]) {
-            try { const fc = fs.readFileSync(path.resolve(args[fileFlag+1]), 'utf-8'); promptText = `Arquivo: ${args[fileFlag+1]}\n\`\`\`\n${fc}\n\`\`\`\n\n${prompt}`; }
-            catch { console.log(c.err(`Não consegui ler: ${args[fileFlag+1]}`)); process.exit(1); }
+        const words = fileFlag >= 0 ? args.slice(0, fileFlag) : args;
+        const promptText = words.join(' ');
+        let fullPrompt = promptText;
+
+        if (fileFlag >= 0 && args[fileFlag + 1]) {
+            try {
+                const fc = fs.readFileSync(path.resolve(args[fileFlag + 1]), 'utf-8');
+                fullPrompt = `Arquivo: ${args[fileFlag + 1]}\n\`\`\`\n${fc}\n\`\`\`\n\n${promptText}`;
+            } 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:[], projectDir: process.cwd()}); console.log('\n'+c.white(r.assistantMessage.content)); }
+
+        const plan = planWorkDir(promptText);
+        await runAct(fullPrompt, {
+            server: state.config.server,
+            model: state.config.model,
+            token: state.config.token,
+            history: [],
+            projectDir: plan.dir,
+            projectName: plan.pending ? plan.name : state.currentProject,
+            ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
+        });
         process.exit(0);
     }
-    console.log(welcomeBox(VERSION, state.config.server));
+
+    console.log(welcomeBox(VERSION, state.workDir ? shortPath(state.workDir) : null));
     rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: makePrompt() });
     rl.prompt();
-    rl.on('line', async (line) => {
-        const text = line.trim();
-        if (!text) { rl.prompt(); return; }
-        if (isSlash(text)) await handleSlash(text); else await sendPrompt(text);
-        rl.prompt();
+
+    // Fila: o readline continua emitindo 'line' enquanto um pedido está sendo
+    // processado. Sem enfileirar, dois pedidos rodariam sobrepostos.
+    const queue = [];
+    let busy = false;
+    let closed = false;
+    let saidBye = false;
+
+    function sayBye() {
+        if (saidBye) return;
+        saidBye = true;
+        console.log(c.muted('\nAté logo!'));
+    }
+
+    async function drain() {
+        if (busy) return;
+        busy = true;
+        while (queue.length) {
+            const text = queue.shift().trim();
+            if (!text) continue;
+            try {
+                if (isSlash(text)) await handleSlash(text);
+                else await sendPrompt(text);
+            } catch (e) {
+                console.log(c.err(`\n${e.message || e}`));
+            }
+        }
+        busy = false;
+        // Se o stdin já fechou (pipe, Ctrl+D), a despedida espera a fila terminar
+        // — senão ela aparece antes do resultado do último pedido.
+        if (closed) sayBye();
+        else rl.prompt();
+    }
+
+    rl.on('line', (line) => {
+        if (pendingAsk) { const resolve = pendingAsk; pendingAsk = null; resolve(line); return; }
+        queue.push(line);
+        drain();
     });
-    rl.on('close', () => { console.log(c.muted('\nAté logo!')); process.exit(0); });
+
+    rl.on('close', () => { closed = true; if (!busy) sayBye(); });
 }
 
-main().catch(e => { console.error(c.err(e.message||e)); process.exit(1); });
+main().catch((e) => { console.error(c.err(e.message || e)); process.exit(1); });