@diazpolanco13/context-control-mcp/ccmcp-full-context.cjs

🔥 Context Control MCP v5.0 PORTABLE EDITION - Análisis universal de proyectos que funciona en CUALQUIER entorno. Contexto completo automático para IA.

#!/usr/bin/env node

// 🔥 Context Control MCP - FULL CONTEXT COMMAND
// EL comando definitivo para IA nueva - TODO el contexto necesario automáticamente
const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

console.error('🔥 Context Control MCP - FULL CONTEXT GENERATOR');
console.error('==================================================================');
console.error('🤖 Generando contexto COMPLETO para nueva sesión de IA...');
console.error('📚 Incluye: historial, comandos, archivos clave, problemas, roadmap');
console.error('==================================================================');

// 🛡️ UTILIDADES SEGURAS
function safeExec(command) {
  try {
    return execSync(command, { encoding: 'utf8', stdio: 'pipe' }).trim();
  } catch {
    return null;
  }
}

function safeReadFile(filePath) {
  try {
    return fs.readFileSync(filePath, 'utf8');
  } catch {
    return null;
  }
}

function safeFileExists(filePath) {
  try {
    return fs.existsSync(filePath);
  } catch {
    return false;
  }
}

// 📚 1. HISTORIAL DE VERSIONES Y DESARROLLO
function analyzeVersionHistory() {
  console.error('📚 Analizando historial de versiones...');
  
  const history = {
    gitAvailable: false,
    totalCommits: 0,
    recentCommits: [],
    branches: [],
    tags: [],
    firstCommit: null,
    lastCommit: null,
    development: {
      activeFiles: [],
      recentChanges: [],
      workingDirectory: 'clean'
    }
  };

  // Git analysis
  if (safeExec('git --version')) {
    history.gitAvailable = true;
    
    // Total commits
    const commitCount = safeExec('git rev-list --count HEAD');
    history.totalCommits = commitCount ? parseInt(commitCount) : 0;
    
    // Recent commits (last 10)
    const recentLog = safeExec('git log --oneline -10');
    if (recentLog) {
      history.recentCommits = recentLog.split('\n').map(line => {
        const [hash, ...messageParts] = line.split(' ');
        return { hash: hash.substring(0, 7), message: messageParts.join(' ') };
      });
    }
    
    // Branches
    const branches = safeExec('git branch -a');
    if (branches) {
      history.branches = branches.split('\n')
        .map(b => b.replace('*', '').trim())
        .filter(b => b && !b.includes('->'));
    }
    
    // Tags/releases
    const tags = safeExec('git tag -l');
    if (tags) {
      history.tags = tags.split('\n').filter(t => t.trim());
    }
    
    // First and last commit
    history.firstCommit = safeExec('git log --reverse --oneline | head -1');
    history.lastCommit = safeExec('git log --oneline -1');
    
    // Working directory status
    const status = safeExec('git status --porcelain');
    if (status) {
      history.development.workingDirectory = 'dirty';
      history.development.activeFiles = status.split('\n')
        .filter(line => line.trim())
        .map(line => ({
          status: line.substring(0, 2).trim(),
          file: line.substring(3)
        }));
    }
    
    // Recent file changes
    const changedFiles = safeExec('git diff --name-only HEAD~5 HEAD');
    if (changedFiles) {
      history.development.recentChanges = changedFiles.split('\n').filter(f => f.trim());
    }
  }

  return history;
}

// 📦 2. INFORMACIÓN COMPLETA DEL PROYECTO
function analyzeProjectComplete() {
  console.error('📦 Analizando proyecto completo...');
  
  const project = {
    basic: {},
    scripts: [],
    dependencies: {
      production: {},
      development: {},
      critical: [],
      problematic: []
    },
    files: {
      key: [],
      documentation: [],
      config: [],
      code: []
    }
  };

  // Package.json analysis
  const packageJson = safeReadFile('package.json');
  if (packageJson) {
    try {
      const pkg = JSON.parse(packageJson);
      project.basic = {
        name: pkg.name || 'Unknown',
        version: pkg.version || '0.0.0',
        description: pkg.description || '',
        author: pkg.author || 'Unknown',
        license: pkg.license || 'Unknown',
        repository: pkg.repository?.url || 'Unknown',
        homepage: pkg.homepage || '',
        main: pkg.main || 'index.js',
        type: pkg.type || 'commonjs'
      };
      
      project.scripts = Object.entries(pkg.scripts || {}).map(([name, command]) => ({
        name,
        command,
        isMCP: command.includes('context-control') || command.includes('ccmcp'),
        isAnalysis: command.includes('analyze') || command.includes('kill-md'),
        isUtility: command.includes('dashboard') || command.includes('status')
      }));
      
      project.dependencies.production = pkg.dependencies || {};
      project.dependencies.development = pkg.devDependencies || {};
      
      // Identify critical dependencies
      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
      project.dependencies.critical = Object.keys(allDeps).filter(dep => 
        ['@modelcontextprotocol/sdk', 'next', 'react', 'express'].includes(dep)
      );
      
      // Identify potentially problematic dependencies
      project.dependencies.problematic = Object.keys(allDeps).filter(dep => 
        dep.includes('beta') || dep.includes('alpha') || dep.includes('rc') || 
        allDeps[dep].includes('^') && parseFloat(allDeps[dep].replace('^', '')) < 1
      );
      
    } catch (e) {
      console.error('⚠️ Error parsing package.json');
    }
  }

  // File analysis
  const importantFiles = [
    'README.md', 'ROADMAP.md', 'CHANGELOG.md', 'TODO.md',
    'context-control-server.js', 'ccmcp-standalone.cjs',
    'package.json', 'package-lock.json',
    '.env.example', '.gitignore',
    'next.config.js', 'tsconfig.json'
  ];

  importantFiles.forEach(file => {
    if (safeFileExists(file)) {
      const content = safeReadFile(file);
      const size = content ? content.length : 0;
      const lines = content ? content.split('\n').length : 0;
      
      const fileInfo = { name: file, size, lines, exists: true };
      
      if (file.endsWith('.md')) {
        project.files.documentation.push(fileInfo);
      } else if (file.includes('config') || file.startsWith('.')) {
        project.files.config.push(fileInfo);
      } else if (file.endsWith('.js') || file.endsWith('.ts')) {
        project.files.code.push(fileInfo);
      } else {
        project.files.key.push(fileInfo);
      }
    }
  });

  return project;
}

// 🚨 3. PROBLEMAS Y ERRORES CONOCIDOS
function analyzeKnownIssues() {
  console.error('🚨 Analizando problemas conocidos...');
  
  const issues = {
    compatibility: [],
    dependencies: [],
    runtime: [],
    documentation: []
  };

  // Check for common compatibility issues
  const packageJson = safeReadFile('package.json');
  if (packageJson) {
    try {
      const pkg = JSON.parse(packageJson);
      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
      
      // MCP SDK compatibility issue
      if (deps['@modelcontextprotocol/sdk']) {
        issues.compatibility.push({
          type: 'MCP SDK Compatibility',
          description: 'MCP SDK puede tener problemas con diferentes versiones de Node.js',
          impact: 'Server MCP puede fallar al iniciar',
          solution: 'Usar ccmcp-standalone.cjs como alternativa'
        });
      }
      
      // Version conflicts
      if (pkg.type === 'module' && pkg.main && !pkg.main.endsWith('.mjs')) {
        issues.compatibility.push({
          type: 'ES Module Configuration',
          description: 'Configuración mixta de CommonJS/ES modules',
          impact: 'Puede causar errores de importación',
          solution: 'Verificar configuración de type y main en package.json'
        });
      }
    } catch (e) {
      issues.runtime.push({
        type: 'Package.json Parse Error',
        description: 'Error al parsear package.json',
        impact: 'Información del proyecto no disponible',
        solution: 'Verificar sintaxis JSON en package.json'
      });
    }
  }

  // Check for missing critical files
  const criticalFiles = ['context-control-server.js', 'package.json'];
  criticalFiles.forEach(file => {
    if (!safeFileExists(file)) {
      issues.runtime.push({
        type: 'Missing Critical File',
        description: `Archivo crítico ${file} no encontrado`,
        impact: 'Funcionalidad principal no disponible',
        solution: `Restaurar o crear ${file}`
      });
    }
  });

  return issues;
}

// 🗺️ 4. ROADMAP Y PRÓXIMOS PASOS
function analyzeRoadmapAndNext() {
  console.error('🗺️ Analizando roadmap y próximos pasos...');
  
  const roadmap = {
    current: {
      version: '4.0.3',
      status: 'stable',
      knownIssues: []
    },
    next: {
      priorities: [],
      improvements: [],
      fixes: []
    },
    longTerm: {
      vision: '',
      features: []
    }
  };

  // Read roadmap files
  const roadmapFiles = ['ROADMAP.md', 'TODO.md', 'docs/ROADMAP.md'];
  let roadmapContent = '';
  
  for (const file of roadmapFiles) {
    const content = safeReadFile(file);
    if (content) {
      roadmapContent += content + '\n';
      break;
    }
  }

  if (roadmapContent) {
    // Extract priorities from roadmap
    const priorities = roadmapContent.match(/(?:PRIORITY|CRÍTICO|HIGH|ALTA).*?(?:\n|$)/gi) || [];
    roadmap.next.priorities = priorities.slice(0, 5).map(p => p.trim());
    
    // Extract version information
    const versionMatches = roadmapContent.match(/v?\d+\.\d+\.\d+/g) || [];
    if (versionMatches.length > 0) {
      roadmap.next.targetVersion = versionMatches[versionMatches.length - 1];
    }
  }

  // Analyze recent commits for work direction
  const recentCommits = safeExec('git log --oneline -5');
  if (recentCommits) {
    const commits = recentCommits.split('\n');
    const workPatterns = {
      'fix': commits.filter(c => c.includes('fix')).length,
      'feat': commits.filter(c => c.includes('feat')).length,
      'refactor': commits.filter(c => c.includes('refactor')).length,
      'docs': commits.filter(c => c.includes('docs')).length
    };
    
    const mainWork = Object.entries(workPatterns)
      .sort(([,a], [,b]) => b - a)[0];
    
    if (mainWork && mainWork[1] > 0) {
      roadmap.current.mainFocus = mainWork[0];
    }
  }

  return roadmap;
}

// 💡 5. EJEMPLOS DE USO Y COMANDOS
function analyzeUsageExamples() {
  console.error('💡 Analizando ejemplos de uso...');
  
  const usage = {
    mainCommands: [],
    examples: [],
    workflows: []
  };

  // Extract commands from package.json
  const packageJson = safeReadFile('package.json');
  if (packageJson) {
    try {
      const pkg = JSON.parse(packageJson);
      const scripts = pkg.scripts || {};
      
      usage.mainCommands = Object.entries(scripts).map(([name, command]) => ({
        name,
        command,
        description: getCommandDescription(name, command)
      }));
      
    } catch (e) {
      console.error('⚠️ Error extracting commands');
    }
  }

  // Common workflows
  usage.workflows = [
    {
      name: 'Nueva sesión IA',
      steps: ['node ccmcp-full-context.cjs', 'Revisar output completo', 'Comenzar desarrollo']
    },
    {
      name: 'Análisis rápido',
      steps: ['node ccmcp-portable.cjs', 'Identificar próximos pasos']
    },
    {
      name: 'Análisis completo MCP',
      steps: ['npm run kill-md', 'Revisar gaps críticos', 'Implementar soluciones']
    }
  ];

  return usage;
}

function getCommandDescription(name, command) {
  const descriptions = {
    'kill-md': 'Análisis revolucionario que mata archivos .md manuales',
    'analyze': 'Análisis standalone sin dependencias MCP',
    'dashboard': 'Dashboard de métricas del proyecto',
    'status': 'Estado del roadmap y progreso',
    'context': 'Actualizar contexto del proyecto',
    'handoff': 'Preparar handoff entre sesiones'
  };
  
  return descriptions[name] || `Ejecuta: ${command}`;
}

// 🚀 GENERACIÓN DE CONTEXTO COMPLETO
function generateFullContext() {
  const timestamp = new Date().toISOString();
  
  console.error('🔄 Generando contexto completo...');
  
  const context = {
    meta: {
      generated: timestamp,
      purpose: 'Contexto completo para nueva sesión de IA',
      version: '5.0-full'
    },
    history: analyzeVersionHistory(),
    project: analyzeProjectComplete(),
    issues: analyzeKnownIssues(),
    roadmap: analyzeRoadmapAndNext(),
    usage: analyzeUsageExamples()
  };

  return context;
}

// 📄 FORMATEO DE OUTPUT PARA IA
function formatContextForAI(context) {
  let output = `🔥 **CONTEXTO COMPLETO - CONTEXT CONTROL MCP**
═══════════════════════════════════════════════════════════════════

📅 **Generado**: ${new Date().toLocaleString()}
🎯 **Propósito**: Contexto completo para nueva sesión de IA
📊 **Versión del análisis**: ${context.meta.version}

## 📚 HISTORIAL Y DESARROLLO

**Git Status**: ${context.history.gitAvailable ? 'Disponible' : 'No disponible'}
**Total Commits**: ${context.history.totalCommits}
**Estado**: ${context.history.development.workingDirectory}
**Archivos activos**: ${context.history.development.activeFiles.length}

**Últimos commits**:
${context.history.recentCommits.slice(0, 5).map(c => `• ${c.hash} ${c.message}`).join('\n')}

**Cambios recientes en archivos**:
${context.history.development.recentChanges.slice(0, 8).map(f => `• ${f}`).join('\n')}

## 📦 INFORMACIÓN DEL PROYECTO

**Nombre**: ${context.project.basic.name} v${context.project.basic.version}
**Descripción**: ${context.project.basic.description}
**Tipo**: ${context.project.basic.type} (${context.project.basic.main})
**Autor**: ${context.project.basic.author}
**Licencia**: ${context.project.basic.license}

**Dependencias críticas** (${context.project.dependencies.critical.length}):
${context.project.dependencies.critical.map(dep => `• ${dep}: ${context.project.dependencies.production[dep] || context.project.dependencies.development[dep]}`).join('\n')}

${context.project.dependencies.problematic.length > 0 ? `
**⚠️ Dependencias problemáticas**:
${context.project.dependencies.problematic.map(dep => `• ${dep}`).join('\n')}
` : ''}

## 🔧 COMANDOS DISPONIBLES

**Scripts principales** (${context.project.scripts.length} total):
${context.project.scripts.filter(s => s.isMCP || s.isAnalysis).map(s => `• npm run ${s.name} - ${getCommandDescription(s.name, s.command)}`).join('\n')}

**Comandos de análisis**:
${context.project.scripts.filter(s => s.isAnalysis).map(s => `• npm run ${s.name}`).join('\n')}

**Comandos utilitarios**:
${context.project.scripts.filter(s => s.isUtility).map(s => `• npm run ${s.name}`).join('\n')}

## 📁 ARCHIVOS CLAVE

**Código principal** (${context.project.files.code.length}):
${context.project.files.code.map(f => `• ${f.name} (${f.lines} líneas)`).join('\n')}

**Documentación** (${context.project.files.documentation.length}):
${context.project.files.documentation.map(f => `• ${f.name} (${f.lines} líneas)`).join('\n')}

**Configuración** (${context.project.files.config.length}):
${context.project.files.config.map(f => `• ${f.name}`).join('\n')}

## 🚨 PROBLEMAS CONOCIDOS

${Object.entries(context.issues).map(([category, issues]) => 
  issues.length > 0 ? `**${category.toUpperCase()}** (${issues.length}):\n${issues.map(issue => 
    `• [${issue.type}] ${issue.description}\n  💥 Impacto: ${issue.impact}\n  🔧 Solución: ${issue.solution}`
  ).join('\n')}\n` : ''
).join('\n')}

## 🗺️ ROADMAP Y PRÓXIMOS PASOS

**Versión actual**: ${context.roadmap.current.version}
**Enfoque principal**: ${context.roadmap.current.mainFocus || 'Desarrollo general'}

**Próximas prioridades**:
${context.roadmap.next.priorities.slice(0, 3).map(p => `• ${p}`).join('\n')}

## 💡 WORKFLOWS RECOMENDADOS

${context.usage.workflows.map(w => 
  `**${w.name}**:\n${w.steps.map((step, i) => `${i+1}. ${step}`).join('\n')}`
).join('\n\n')}

## 🎯 PARA CONTINUAR TRABAJANDO

**Comando principal**: \`npm run kill-md\` (análisis revolucionario)
**Comando portable**: \`node ccmcp-portable.cjs\` (sin dependencias)
**Comando completo**: \`node ccmcp-full-context.cjs\` (este comando)

**Próximo paso recomendado**: ${context.issues.compatibility.length > 0 ? 'Resolver problemas de compatibilidad' : 'Continuar con mejoras de funcionalidad'}

═══════════════════════════════════════════════════════════════════
🤖 **CONTEXTO COMPLETO GENERADO** - Todo lo que una IA nueva necesita saber
🔥 Context Control MCP v5.0 - Full Context Generator`;

  return output;
}

// 🚀 EJECUCIÓN PRINCIPAL
console.error('🚀 Iniciando generación de contexto completo...');

const fullContext = generateFullContext();
const formattedOutput = formatContextForAI(fullContext);

console.log('\n' + formattedOutput);

console.error('\n✅ Contexto completo generado exitosamente');
console.error(`📊 Información analizada: ${fullContext.history.totalCommits} commits, ${fullContext.project.scripts.length} scripts, ${Object.values(fullContext.issues).flat().length} issues detectados`);
console.error('🤖 Una IA nueva tiene ahora TODO el contexto necesario para continuar el desarrollo');