README.md

@@ -80,8 +80,6 @@ bin/update.sh
 | Comando | Descripción |
 |---------|-------------|
 | `bin/odoo_set.sh` | Crea un nuevo proyecto Odoo con estructura completa |
-| `bin/rate_update.py` | Actualiza tarifas por hora de diferentes tipos de programadores |
-| `bin/cocomo.py` | Calcula costos de proyecto usando el modelo COCOMO |
 
 ## 📚 Guía de Usuario
 
@@ -168,50 +166,6 @@ cd [ruta-al-proyecto]
 ./scripts/start.sh
 ```
 
-### Gestión de Tarifas y Costos
-
-MRDevs Tools incluye utilidades para la gestión de tarifas y estimación de costos:
-
-#### Actualización de Tarifas
-
-El script `rate_update.py` permite mantener actualizadas las tarifas por hora de diferentes tipos de programadores:
-
-```bash
-# Actualizar tarifas faltantes
-bin/rate_update.py
-
-# Listar todas las tarifas disponibles
-bin/rate_update.py --list
-
-# Actualizar la tarifa de un tipo específico de programador
-bin/rate_update.py --type python
-
-# Actualizar todas las tarifas, incluso las existentes
-bin/rate_update.py --init
-```
-
-Las tarifas se almacenan en archivos individuales dentro de `bin/config/rates/` y pueden ser utilizadas por otras herramientas.
-
-#### Estimación de Costos con COCOMO
-
-El script `cocomo.py` implementa el modelo COCOMO para estimar costos de proyectos de software basados en las líneas de código:
-
-```bash
-# Calcular costo de un proyecto
-bin/cocomo.py --project /ruta/al/proyecto
-
-# Usar un tipo específico de programador para los costos
-bin/cocomo.py --project /ruta/al/proyecto --type devops
-
-# Especificar un modelo COCOMO específico
-bin/cocomo.py --project /ruta/al/proyecto --model embedded
-
-# Ignorar patrones adicionales de archivos
-bin/cocomo.py --project /ruta/al/proyecto --ignore "*.generated.js" --ignore "vendor/**"
-```
-
-El script analizará el código fuente, contará las líneas efectivas, y calculará estimaciones de esfuerzo, tiempo y costos utilizando las tarifas por hora configuradas.
-
 ## 🔌 Arquitectura del Sistema
 
 ### Estructura de Directorios

bin/cocomo.py

@@ -1,453 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-COCOMO Calculator
-
-Este script calcula el costo de un proyecto de software utilizando el modelo COCOMO,
-basado en el conteo de líneas de código en un directorio dado.
-
-Licencia: AGPL-3.0
-Modified: 2025-03-12
-"""
-
-import os
-import sys
-import argparse
-import logging
-import fnmatch
-from pathlib import Path
-from math import ceil
-
-# Configuración de logging
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.WARNING)
-console_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
-
-# Configuración global del logger
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[])
-logger = logging.getLogger('cocomo')
-logger.addHandler(console_handler)
-
-# Variable para controlar si se muestra el resultado en la consola
-SHOW_RESULTS = True
-
-# Directorio base del proyecto
-BASE_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-CONFIG_DIR = BASE_DIR / 'bin' / 'config'
-RATES_DIR = CONFIG_DIR / 'rates'  # Ubicación para archivos de tarifas
-
-# Constantes para el modelo COCOMO básico
-COCOMO_MODELS = {
-    # [a, b, c, d] - Coeficientes para Esfuerzo = a * (KLOC^b) y Tiempo = c * (Esfuerzo^d)
-    'organic': [2.4, 1.05, 2.5, 0.38],     # Proyectos simples, pequeños equipos con experiencia
-    'semi-detached': [3.0, 1.12, 2.5, 0.35],  # Proyectos intermedios
-    'embedded': [3.6, 1.20, 2.5, 0.32]     # Proyectos complejos
-}
-
-# Número de horas laborables en un mes (22 días x 8 horas)
-HOURS_PER_MONTH = 176
-
-# Extensiones de archivo a considerar por defecto
-DEFAULT_EXTENSIONS = [
-    '.py', '.java', '.c', '.cpp', '.cc', '.cxx', '.h', '.hpp', '.js', '.ts',
-    '.html', '.css', '.php', '.rb', '.go', '.rs', '.swift', '.kt', '.scala',
-    '.sh', '.bash', '.pl', '.pm', '.lua', '.sql'
-]
-
-# Archivos a ignorar por defecto
-DEFAULT_IGNORE_PATTERNS = [
-    '*.min.js', '*.min.css', '**/node_modules/**', '**/venv/**', '**/.git/**',
-    '**/__pycache__/**', '**/build/**', '**/dist/**', '**/bin/config/rates/**',
-    '**/bin/msg/**'
-]
-
-def count_lines_of_code(project_path, extensions=None, ignore_patterns=None):
-    """
-    Cuenta las líneas de código no vacías en los archivos con las extensiones especificadas.
-    Excluye comentarios en archivos Python.
-    
-    Args:
-        project_path: Ruta del directorio del proyecto
-        extensions: Lista de extensiones de archivo a considerar
-        ignore_patterns: Lista de patrones de archivo a ignorar
-    
-    Returns:
-        Número total de líneas de código
-    """
-    if extensions is None:
-        extensions = DEFAULT_EXTENSIONS
-    
-    if ignore_patterns is None:
-        ignore_patterns = DEFAULT_IGNORE_PATTERNS
-    
-    total_lines = 0
-    files_counted = 0
-    skipped_files = 0
-    
-    logger.info(f"Contando líneas de código en: {project_path}")
-    logger.info(f"Extensiones: {extensions}")
-    
-    for root, _, files in os.walk(project_path):
-        for file in files:
-            file_path = os.path.join(root, file)
-            rel_path = os.path.relpath(file_path, project_path)
-            
-            # Verificar si el archivo debe ser ignorado
-            should_ignore = False
-            for pattern in ignore_patterns:
-                if fnmatch.fnmatch(rel_path, pattern):
-                    should_ignore = True
-                    break
-            
-            if should_ignore:
-                logger.debug(f"Ignorando archivo: {rel_path}")
-                skipped_files += 1
-                continue
-            
-            # Verificar si la extensión está en la lista
-            file_extension = os.path.splitext(file)[1].lower()
-            if file_extension not in extensions:
-                logger.debug(f"Extensión no considerada: {rel_path}")
-                skipped_files += 1
-                continue
-            
-            try:
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    lines = f.readlines()
-                    
-                    # Contar líneas no vacías (excluyendo comentarios en Python)
-                    if file_extension == '.py':
-                        non_empty_lines = 0
-                        in_multiline_comment = False
-                        
-                        for line in lines:
-                            line = line.strip()
-                            
-                            # Saltar líneas vacías
-                            if not line:
-                                continue
-                            
-                            # Manejar comentarios multilinea
-                            if '"""' in line or "'''" in line:
-                                # Si ya estamos en un comentario multilinea, verificamos si termina
-                                if in_multiline_comment:
-                                    if line.endswith('"""') or line.endswith("'''"):
-                                        in_multiline_comment = False
-                                    continue
-                                # Si encontramos el inicio de un comentario multilinea
-                                elif line.startswith('"""') or line.startswith("'''"):
-                                    # Verificar si el comentario comienza y termina en la misma línea
-                                    if line.endswith('"""') or line.endswith("'''"):
-                                        if line.count('"""') == 2 or line.count("'''") == 2:
-                                            continue
-                                    else:
-                                        in_multiline_comment = True
-                                        continue
-                            
-                            # Saltar si estamos en un comentario multilinea
-                            if in_multiline_comment:
-                                continue
-                            
-                            # Saltar comentarios de una línea
-                            if line.startswith('#'):
-                                continue
-                            
-                            # Contar línea de código válida
-                            non_empty_lines += 1
-                        
-                        total_lines += non_empty_lines
-                    else:
-                        # Para otros lenguajes, simplemente contamos líneas no vacías
-                        non_empty_lines = sum(1 for line in lines if line.strip())
-                        total_lines += non_empty_lines
-                    
-                    files_counted += 1
-                    
-                    if files_counted % 100 == 0:
-                        logger.info(f"Procesados {files_counted} archivos, {total_lines} líneas contadas hasta ahora.")
-                    
-            except Exception as e:
-                logger.warning(f"Error al procesar archivo {file_path}: {e}")
-                skipped_files += 1
-    
-    logger.info(f"Conteo completo. Procesados {files_counted} archivos, ignorados {skipped_files}.")
-    return total_lines
-
-def estimate_cocomo(loc, model_type='organic', cost_per_pm=5000, programmer_type='fullstack'):
-    """
-    Calcula las estimaciones COCOMO basadas en las líneas de código.
-    
-    Args:
-        loc: Líneas de código
-        model_type: Tipo de modelo COCOMO ('organic', 'semi-detached', 'embedded')
-        cost_per_pm: Costo por persona-mes en USD
-        programmer_type: Tipo de programador usado para el cálculo de costo
-    
-    Returns:
-        Dictionary con los resultados del cálculo
-    """
-    # Convertir LOC a KLOC (miles de líneas de código)
-    kloc = loc / 1000
-    
-    # Obtener coeficientes del modelo
-    a, b, c, d = COCOMO_MODELS[model_type]
-    
-    # Calcular esfuerzo en persona-mes
-    effort_pm = a * (kloc ** b)
-    
-    # Calcular tiempo de desarrollo en meses
-    dev_time = c * (effort_pm ** d)
-    
-    # Calcular personas requeridas (promedio)
-    avg_staff = effort_pm / dev_time
-    
-    # Calcular costo total
-    total_cost = effort_pm * cost_per_pm
-    
-    # Calcular costo por hora (dividir el costo por persona-mes entre las horas laborables)
-    hourly_rate = cost_per_pm / HOURS_PER_MONTH
-    
-    # Redondear valores para presentación
-    effort_pm = round(effort_pm, 2)
-    dev_time = round(dev_time, 2)
-    avg_staff = round(avg_staff, 2)
-    hourly_rate = round(hourly_rate, 2)
-    total_cost = round(total_cost, 2)
-    
-    # Preparar resultados
-    results = {
-        'loc': loc,
-        'kloc': round(kloc, 2),
-        'model': model_type,
-        'effort_pm': effort_pm,
-        'dev_time': dev_time,
-        'avg_staff': avg_staff,
-        'cost_per_pm': cost_per_pm,
-        'hourly_rate': hourly_rate,
-        'programmer_type': programmer_type,
-        'total_cost': total_cost
-    }
-    
-    return results
-
-def show_result(message):
-    """
-    Función para mostrar resultados en la consola.
-    Solo muestra mensajes si SHOW_RESULTS es True.
-    """
-    if SHOW_RESULTS:
-        print(message)
-
-def determine_cocomo_model(loc):
-    """
-    Determina automáticamente el modelo COCOMO basado en el tamaño del proyecto.
-    
-    Args:
-        loc: Líneas de código
-    
-    Returns:
-        Tipo de modelo COCOMO ('organic', 'semi-detached', 'embedded')
-    """
-    kloc = loc / 1000
-    
-    if kloc < 50:
-        return 'organic'  # Proyectos pequeños (menos de 50K líneas)
-    elif kloc < 300:
-        return 'semi-detached'  # Proyectos medianos (entre 50K y 300K líneas)
-    else:
-        return 'embedded'  # Proyectos grandes (más de 300K líneas)
-
-def get_available_programmer_types():
-    """
-    Obtiene una lista de los tipos de programadores disponibles
-    basados en los archivos .rate existentes en el directorio de tarifas.
-    
-    Returns:
-        List: Lista de tipos de programadores disponibles
-    """
-    if not RATES_DIR.exists():
-        logger.warning(f"El directorio de tarifas no existe: {RATES_DIR}")
-        return ['fullstack']  # Por defecto solo fullstack si no hay directorio
-    
-    try:
-        # Buscar archivos .rate en el directorio
-        rate_files = list(RATES_DIR.glob('*.rate'))
-        
-        # Extraer nombres de programadores de los nombres de archivo
-        programmer_types = [file.stem for file in rate_files]
-        
-        if not programmer_types:
-            logger.warning("No se encontraron archivos de tarifas. Usando solo 'fullstack' por defecto.")
-            return ['fullstack']
-        
-        return sorted(programmer_types)
-    except Exception as e:
-        logger.error(f"Error al buscar tipos de programadores disponibles: {e}")
-        return ['fullstack']  # En caso de error, devolver tipo por defecto
-
-def get_programmer_rate(programmer_type='fullstack'):
-    """
-    Obtiene la tarifa por hora de un tipo específico de programador desde el archivo de configuración.
-    Si el archivo no existe, devuelve un valor predeterminado según el tipo.
-    
-    Args:
-        programmer_type: Tipo de programador (por defecto: 'fullstack')
-    
-    Returns:
-        Float: Tarifa por hora en USD
-    """
-    rate_file = RATES_DIR / f"{programmer_type}.rate"
-    
-    # Valores predeterminados por tipo de programador
-    default_rates = {
-        'fullstack': 45.00,
-        'frontend': 40.00,
-        'backend': 42.00,
-        'devops': 50.00,
-        'python': 35.00,
-        'java': 40.00,
-        'php': 30.00,
-        'mobile': 45.00,
-        'data': 55.00,
-        'ml': 65.00,
-        'cloud': 60.00,
-        'bash': 20.00
-    }
-    
-    default_rate = default_rates.get(programmer_type, 40.00)
-    
-    # Comprobar si existe el archivo
-    if not rate_file.exists():
-        logger.warning(f"No se encontró el archivo de tarifa: {rate_file}")
-        logger.warning(f"Usando tarifa predeterminada de {default_rate:.2f} USD/hora para {programmer_type}")
-        return default_rate
-    
-    # Leer la tarifa del archivo
-    try:
-        with open(rate_file, 'r', encoding='utf-8') as f:
-            rate = float(f.read().strip())
-            logger.info(f"Tarifa leída desde {rate_file}: {rate:.2f} USD/hora")
-            return rate
-    except (FileNotFoundError, ValueError, IOError) as e:
-        logger.warning(f"Error al leer el archivo de tarifa {rate_file}: {e}")
-        logger.warning(f"Usando tarifa predeterminada de {default_rate:.2f} USD/hora para {programmer_type}")
-        return default_rate
-
-def print_results(results):
-    """
-    Imprime los resultados del cálculo COCOMO de manera formateada.
-    
-    Args:
-        results: Dictionary con los resultados del cálculo COCOMO
-    """
-    print("\n========== RESULTADOS DEL ANÁLISIS COCOMO ==========")
-    print(f"Proyecto: {results['project_path']}")
-    print(f"Líneas de código: {results['loc']} ({results['kloc']} KLOC)")
-    print(f"Modelo COCOMO: {results['model'].upper()}")
-    print("\n--- Estimaciones ---")
-    print(f"Esfuerzo: {results['effort_pm']} persona-meses")
-    print(f"Tiempo de desarrollo: {results['dev_time']} meses")
-    print(f"Personal promedio: {results['avg_staff']} personas")
-    print("\n--- Costos ---")
-    print(f"Tipo de programador: {results['programmer_type']}")
-    print(f"Costo por hora: ${results['hourly_rate']}")
-    print(f"Costo por persona-mes: ${results['cost_per_pm']} ({HOURS_PER_MONTH} horas)")
-    print(f"Costo total estimado: ${results['total_cost']:,.2f}")
-    print("=====================================================\n")
-
-if __name__ == "__main__":
-    # Obtener los tipos de programadores disponibles para el parámetro --type
-    available_types = get_available_programmer_types()
-    available_types_str = ', '.join(available_types)
-    
-    # Parámetros de línea de comandos
-    parser = argparse.ArgumentParser(description='Calculadora COCOMO para estimar costos de proyectos de software')
-    parser.add_argument('--project', required=True, help='Ruta del directorio del proyecto a analizar')
-    parser.add_argument('--model', choices=['organic', 'semi-detached', 'embedded', 'auto'], 
-                      default='auto', help='Tipo de modelo COCOMO a utilizar (por defecto: auto)')
-    parser.add_argument('--type', choices=available_types, default='fullstack',
-                      help=f'Tipo de programador para calcular costos (por defecto: fullstack). Disponibles: {available_types_str}')
-    parser.add_argument('--cost', type=float, 
-                      help='Costo por persona-mes en USD (por defecto: tarifa del tipo de programador × 176)')
-    parser.add_argument('--ignore', action='append', 
-                      help='Patrones adicionales de archivos a ignorar')
-    parser.add_argument('--ext', action='append', 
-                      help='Extensiones adicionales de archivo a considerar')
-    parser.add_argument('-q', '--quiet', action='store_true', 
-                      help='No mostrar resultados detallados')
-    parser.add_argument('-v', '--verbose', action='store_true', 
-                      help='Mostrar información detallada del proceso')
-    
-    args = parser.parse_args()
-    
-    # Configurar nivel de log según parámetros
-    if args.verbose:
-        console_handler.setLevel(logging.INFO)
-    
-    # Configurar si se muestran resultados
-    SHOW_RESULTS = not args.quiet
-    
-    # Verificar que el directorio del proyecto existe
-    project_path = Path(args.project)
-    if not project_path.exists() or not project_path.is_dir():
-        logger.error(f"El directorio del proyecto no existe: {args.project}")
-        print(f"ERROR: El directorio del proyecto no existe: {args.project}")
-        sys.exit(1)
-    
-    # Verificar que el directorio de tarifas existe
-    if not RATES_DIR.exists():
-        logger.warning(f"El directorio de tarifas no existe: {RATES_DIR}")
-        logger.warning("Se creará el directorio y se usarán valores predeterminados.")
-        try:
-            os.makedirs(RATES_DIR, exist_ok=True)
-        except Exception as e:
-            logger.error(f"Error al crear el directorio de tarifas: {e}")
-    
-    # Obtener tipo de programador y su tarifa
-    programmer_type = args.type  # Usar el tipo especificado por el usuario
-    
-    # Obtener costo por hora desde el archivo .rate y convertir a costo por persona-mes
-    if args.cost is None:
-        # Obtener la tarifa por hora y multiplicar por las horas mensuales
-        hourly_rate = get_programmer_rate(programmer_type)
-        cost_per_pm = hourly_rate * HOURS_PER_MONTH
-        logger.info(f"Costo por hora ({programmer_type}): ${hourly_rate:.2f} × {HOURS_PER_MONTH} horas = ${cost_per_pm:.2f} por persona-mes")
-    else:
-        cost_per_pm = args.cost
-        programmer_type = f"{programmer_type} (personalizado)"  # Indicar que es un valor personalizado
-        hourly_rate = cost_per_pm / HOURS_PER_MONTH
-        logger.info(f"Usando costo por persona-mes especificado: ${cost_per_pm:.2f} (${hourly_rate:.2f}/hora)")
-    
-    # Preparar extensiones y patrones de ignorar
-    extensions = DEFAULT_EXTENSIONS.copy()
-    if args.ext:
-        extensions.extend([ext if ext.startswith('.') else f'.{ext}' for ext in args.ext])
-    
-    ignore_patterns = DEFAULT_IGNORE_PATTERNS.copy()
-    if args.ignore:
-        ignore_patterns.extend(args.ignore)
-    
-    try:
-        # Contar líneas de código
-        loc = count_lines_of_code(project_path, extensions, ignore_patterns)
-        
-        # Determinar el modelo COCOMO a utilizar
-        if args.model == 'auto':
-            model_type = determine_cocomo_model(loc)
-            logger.info(f"Modelo seleccionado automáticamente: {model_type}")
-        else:
-            model_type = args.model
-        
-        # Calcular estimaciones COCOMO
-        results = estimate_cocomo(loc, model_type, cost_per_pm, programmer_type)
-        
-        # Añadir ruta del proyecto para la presentación
-        results['project_path'] = str(project_path)
-        
-        # Mostrar resultados
-        print_results(results)
-        
-    except Exception as e:
-        logger.error(f"Error durante el cálculo COCOMO: {e}")
-        print(f"ERROR: {e}")
-        sys.exit(1)