@deinossrl/dgp-agent 1.4.11 → 1.4.13

package/index.mjs

@@ -23,7 +23,7 @@
  *   DGP_MACHINE_ID    ID personalizado de la máquina
  */
 
-import { execSync, spawn } from 'child_process';
+import { execSync, spawn, spawnSync } from 'child_process';
 import { hostname, homedir } from 'os';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
@@ -203,7 +203,7 @@ async function fetchPlatformConfig() {
 let platformConfig = null;
 
 // Versión y modo del agente
-const AGENT_VERSION = '1.4.11';
+const AGENT_VERSION = '1.4.13';
 let AGENT_MODE = 'status'; // 'status' | 'deploy' | 'ai'
 
 // Configuración (prioridad: env vars > archivo config > platform config > defaults)
@@ -395,6 +395,51 @@ function getRepoContext() {
   return context;
 }
 
+/**
+ * Procesa un comando git con ayuda de IA para entender mejor la intención
+ */
+async function processGitCommandWithAI(command, params) {
+  logAI(`Procesando comando con IA: ${command}`);
+
+  const context = getRepoContext();
+
+  const systemPrompt = `Eres un experto en Git y DevOps. Tu trabajo es analizar comandos git y mejorarlos si es necesario.
+
+IMPORTANTE:
+- Si el comando es claro, simplemente ejecuta lo solicitado
+- Si hay ambigüedad, usa tu inteligencia para resolver
+- Genera mensajes de commit descriptivos si el mensaje es vago
+- Responde SOLO con JSON válido
+
+Formato de respuesta:
+{
+  "analysis": "qué vas a hacer y por qué",
+  "improved_message": "mensaje mejorado (solo para commits)",
+  "additional_commands": ["comandos adicionales si son necesarios"],
+  "skip": false
+}`;
+
+  const prompt = `Contexto del repositorio:
+${JSON.stringify(context, null, 2)}
+
+Comando recibido: ${command}
+Parámetros: ${JSON.stringify(params)}
+
+Analiza y mejora este comando si es necesario.`;
+
+  try {
+    const response = await callClaude(prompt, systemPrompt);
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    return null;
+  } catch (e) {
+    logError(`Error procesando con IA: ${e.message}`);
+    return null;
+  }
+}
+
 /**
  * Ejecuta una tarea usando IA
  */
@@ -594,9 +639,9 @@ async function runAIMode() {
           logError('Tarea AI fallida');
         }
       } else {
-        // Comandos git (git_commit_push, git_pull, git_fetch, etc)
+        // Comandos git (git_commit_push, git_pull, git_fetch, etc) - con IA activa
         logInfo(`📥 Comando recibido: ${command.command}`);
-        await executeCommand(command);
+        await executeCommand(command, true); // useAI = true en modo AI
       }
 
       isProcessing = false;
@@ -666,6 +711,9 @@ function shell(command, options = {}) {
   }
 }
 
+// Alias para compatibilidad
+const shellSync = shell;
+
 /**
  * Ejecuta un comando shell de forma asíncrona con output en tiempo real
  */
@@ -994,9 +1042,11 @@ async function executeDeploy(command) {
 
 /**
  * Ejecuta un comando recibido
+ * @param {Object} command - El comando a ejecutar
+ * @param {boolean} useAI - Si es true, usa IA para mejorar la ejecución
  */
-async function executeCommand(command) {
-  logCommand(`Received command: ${command.command}`);
+async function executeCommand(command, useAI = false) {
+  logCommand(`Received command: ${command.command}${useAI ? ' (con IA)' : ''}`);
 
   switch (command.command) {
     case 'deploy':
@@ -1008,7 +1058,7 @@ async function executeCommand(command) {
       return { success: true, status };
 
     case 'git_commit_push':
-      return await executeGitCommitPush(command);
+      return await executeGitCommitPush(command, useAI);
 
     case 'rollback':
       logError('Rollback not implemented yet');
@@ -1016,6 +1066,15 @@ async function executeCommand(command) {
       return { success: false };
 
     default:
+      // Si es un comando desconocido pero tenemos IA, intentar procesarlo
+      if (useAI && CONFIG.anthropicApiKey) {
+        logAI(`Intentando procesar comando desconocido con IA: ${command.command}`);
+        const result = await executeAITask(`Ejecutar: ${command.command} con params: ${JSON.stringify(command.params || {})}`);
+        if (result.success) {
+          await updateCommandStatus(command.id, 'completed', result);
+          return result;
+        }
+      }
       logError(`Unknown command: ${command.command}`);
       await updateCommandStatus(command.id, 'failed', {}, `Unknown command: ${command.command}`);
       return { success: false };
@@ -1023,10 +1082,10 @@ async function executeCommand(command) {
 }
 
 /**
- * Ejecuta git add, commit y push
+ * Ejecuta git add, commit y push (con mejoras de IA si está disponible)
  */
-async function executeGitCommitPush(command) {
-  const { message, add_all } = command.params || {};
+async function executeGitCommitPush(command, useAI = false) {
+  let { message, add_all } = command.params || {};
 
   if (!message) {
     await updateCommandStatus(command.id, 'failed', {}, 'Commit message is required');
@@ -1037,6 +1096,20 @@ async function executeGitCommitPush(command) {
     // Marcar como running
     await updateCommandStatus(command.id, 'running', {});
 
+    // Si tenemos API key y useAI está activo, mejorar el mensaje con IA
+    let aiAnalysis = null;
+    if (useAI && CONFIG.anthropicApiKey) {
+      logAI('Analizando commit con IA...');
+      aiAnalysis = await processGitCommandWithAI('git_commit_push', { message, add_all });
+      if (aiAnalysis) {
+        logAI(`Análisis: ${aiAnalysis.analysis}`);
+        if (aiAnalysis.improved_message && aiAnalysis.improved_message !== message) {
+          logAI(`Mensaje mejorado: ${aiAnalysis.improved_message}`);
+          message = aiAnalysis.improved_message;
+        }
+      }
+    }
+
     logInfo('Executing git commit + push...');
 
     // git add
@@ -1045,21 +1118,21 @@ async function executeGitCommitPush(command) {
       await shellAsync('git add .');
     }
 
-    // git commit - escapar mensaje según el SO
-    const isWindows = process.platform === 'win32';
-    let commitCmd;
-    if (isWindows) {
-      // En Windows cmd /c, escapar comillas con \"
-      const safeMessage = message.replace(/"/g, '\\"');
-      commitCmd = `git commit -m "${safeMessage}"`;
+    // git commit - usar spawnSync para evitar problemas de comillas en shell
+    logCommand(`git commit -m "${message}"`);
+    const commitProc = spawnSync('git', ['commit', '-m', message], { encoding: 'utf-8' });
+    if (commitProc.status !== 0) {
+      const errorMsg = commitProc.stderr || commitProc.stdout || 'Unknown error';
+      // Verificar si es "nothing to commit"
+      if (errorMsg.includes('nothing to commit') || (commitProc.stdout && commitProc.stdout.includes('nothing to commit'))) {
+        logInfo('Nothing to commit, skipping...');
+      } else {
+        throw new Error(`Git commit failed: ${errorMsg}`);
+      }
     } else {
-      // En Unix, usar comillas simples es más seguro
-      const safeMessage = message.replace(/'/g, "'\\''");
-      commitCmd = `git commit -m '${safeMessage}'`;
+      logSuccess('Commit created');
+      if (commitProc.stdout) console.log(colors.gray + commitProc.stdout + colors.reset);
     }
-    logCommand(`git commit -m "${message}"`);
-    const commitResult = await shellAsync(commitCmd);
-    logSuccess('Commit created');
 
     // git push
     const branch = shellSync('git branch --show-current').trim();
@@ -1068,8 +1141,9 @@ async function executeGitCommitPush(command) {
     logSuccess('Push completed');
 
     await updateCommandStatus(command.id, 'completed', {
-      commit: commitResult,
-      branch: branch
+      message: message,
+      branch: branch,
+      ai_analysis: aiAnalysis?.analysis || null
     });
 
     return { success: true };
@@ -1157,36 +1231,74 @@ async function runAgent(deployMode = false) {
     }
   };
 
-  // Command polling cycle (only in deploy mode)
+  // Command polling cycle - SIEMPRE escucha comandos (Web ↔ PC)
+  let isProcessingCommand = false;
   const runCommandCycle = async () => {
+    if (isProcessingCommand) return;
+
     try {
-      const commands = await getPendingCommands();
-      if (commands.length > 0) {
-        const command = commands[0];
-        logCommand(`Found pending command: ${command.id}`);
-        await executeCommand(command);
+      // Buscar comandos pendientes para ESTE machine_id
+      const url = `${CONFIG.commandsUrl}?machine_id=eq.${CONFIG.machineId}&status=eq.pending&select=*&order=created_at.asc&limit=1`;
+      const response = await fetch(url, {
+        headers: {
+          'apikey': CONFIG.supabaseKey,
+          'Authorization': `Bearer ${CONFIG.supabaseKey}`,
+        },
+      });
+
+      if (!response.ok) return;
+
+      const commands = await response.json();
+      if (commands.length === 0) return;
+
+      const command = commands[0];
+      isProcessingCommand = true;
+
+      logCommand(`📥 Comando recibido: ${command.command}`);
+
+      // Verificar si tenemos IA disponible
+      const useAI = !!CONFIG.anthropicApiKey;
+
+      if (command.command === 'ai_task' && useAI) {
+        // Tarea AI - ejecutar con Claude
+        await updateCommandStatus(command.id, 'running', {});
+        const result = await executeAITask(command.params?.task || '');
+
+        if (result.success) {
+          await updateCommandStatus(command.id, 'completed', {
+            output: result.results?.map(r => r.output).join('\n'),
+            commands_executed: result.results?.length || 0,
+          });
+          logSuccess('Tarea completada');
+        } else {
+          await updateCommandStatus(command.id, 'failed', {}, result.error || 'Task failed');
+          logError('Tarea fallida');
+        }
+      } else {
+        // Comandos git y otros
+        await executeCommand(command, useAI);
       }
+
+      isProcessingCommand = false;
+
     } catch (error) {
+      isProcessingCommand = false;
       // Silent fail for command polling - don't spam logs
-      if (error.message.includes('42P01')) {
-        // Table doesn't exist yet - ignore
-      } else {
-        logError(`Command poll failed: ${error.message}`);
+      if (!error.message?.includes('42P01')) {
+        // Solo loggear si no es error de tabla inexistente
       }
     }
   };
 
   // Initial run
   await runStatusCycle();
-  if (deployMode) {
-    await runCommandCycle();
-  }
+  await runCommandCycle();
 
-  // Set intervals
+  // Set intervals - SIEMPRE escucha comandos
   setInterval(runStatusCycle, CONFIG.interval * 1000);
-  if (deployMode) {
-    setInterval(runCommandCycle, CONFIG.commandPollInterval * 1000);
-  }
+  setInterval(runCommandCycle, CONFIG.commandPollInterval * 1000);
+
+  logInfo(`Escuchando comandos de la web (cada ${CONFIG.commandPollInterval}s)...`);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deinossrl/dgp-agent",
-  "version": "1.4.11",
+  "version": "1.4.13",
   "description": "Agente local para Despliegue-GPT - Reporta el estado del repositorio Git a la plataforma TenMinute IA",
   "main": "index.mjs",
   "bin": {