apprecio-mcp-base 1.1.1 → 1.1.3

package/README.md

@@ -1,137 +1,283 @@
-# @apprecio/mcp-base
+# apprecio-mcp-base
 
 Base package para crear servidores MCP (Model Context Protocol) de Apprecio con consistencia y reutilización de código.
 
 ## 🚀 Características
 
 - **Servidor Base Abstracto**: Clase `McpBaseServer` que encapsula toda la lógica común
+- **Sistema de Features**: Arquitectura modular con `FeatureModule`
 - **Configuración Centralizada**: Sistema de configuración con validación Zod
 - **Logger Unificado**: Winston logger con niveles configurables y rotación de archivos
-- **Middlewares Reutilizables**: Autenticación, Rate Limiting, CORS, Helmet
+- **Middlewares Reutilizables**: Autenticación Bearer Token, Rate Limiting, CORS, Helmet
 - **Conectores Database**: MongoDB y Redis pre-configurados
 - **Port Management**: Búsqueda automática de puertos disponibles
 - **Graceful Shutdown**: Manejo automático de señales SIGINT/SIGTERM
 - **TypeScript First**: Completamente tipado con soporte para path aliases
+- **CLI Generator**: Generador de proyectos y features automático
 
 ## 📦 Instalación
 
 ```bash
-npm install @apprecio/mcp-base
+npm install apprecio-mcp-base
 # o
-pnpm add @apprecio/mcp-base
+pnpm add apprecio-mcp-base
 ```
 
-## 🎯 Uso Básico
+## 🎯 Quick Start
 
-### 1. Crear un nuevo servidor MCP
+### Opción 1: Usar el CLI (Recomendado)
+
+```bash
+# 1. Setup global link (una vez)
+cd apprecio-mcp-base
+npm run build
+npm link
+
+# 2. Generar nuevo proyecto
+mcp-generate init
+
+# Responder wizard:
+# - Nombre del proyecto
+# - Ruta
+# - Usar MongoDB (sí/no)
+# - Base URL de tu API
+# ¿Instalar dependencias? Yes
+# ¿Linkear apprecio-mcp-base? Yes
+
+# 3. Ejecutar
+cd my-project
+npm run dev
+```
+
+### Opción 2: Manual
 
 ```typescript
 import { 
     McpBaseServer, 
-    createExpressServer, 
+    createServer, 
     findAvailablePort,
-    createMongoDBConnector 
-} from '@apprecio/mcp-base';
-import type { FeatureModule } from '@apprecio/mcp-base';
+    createMongoDBConnector,
+    logger,
+    type MongoDBConnector
+} from 'apprecio-mcp-base';
 
-// Definir tu servidor MCP personalizado
-class MyCustomMcpServer extends McpBaseServer {
+class MyMcpServer extends McpBaseServer {
     private dbConnector?: MongoDBConnector;
 
     protected async registerFeatures(): Promise<void> {
-        // Registrar tus features personalizadas
-        this.registerFeature('myFeature', myFeatureModule);
+        // Registrar tus features
+        this.registerFeature('users', usersFeature);
     }
 
     protected async onBeforeStart(): Promise<void> {
-        // Conectar a MongoDB si es necesario
-        if (this.config.mongodbUri) {
-            this.dbConnector = createMongoDBConnector(this.config.mongodbUri);
+        const mongoUri = this.config.mongodbUri;
+        if (mongoUri) {
+            this.dbConnector = createMongoDBConnector(mongoUri);
             await this.dbConnector.connect();
         }
     }
 
     protected async onBeforeShutdown(): Promise<void> {
-        // Cleanup
         if (this.dbConnector) {
             await this.dbConnector.disconnect();
         }
     }
 }
 
-// Iniciar el servidor
 async function main() {
-    const server = new MyCustomMcpServer({
-        name: 'my-custom-mcp',
+    const server = new MyMcpServer({
+        name: 'my-mcp-server',
         version: '1.0.0',
     });
 
     const port = await findAvailablePort(server.getConfig().ssePort);
+    const { httpServer, transport } = await createServer(port);
     
-    const httpServer = await createExpressServer({
-        mcpServer: server.getMcpServer(),
-        config: server.getConfig(),
-        port,
-    });
-
-    await server.start(httpServer, port);
+    await server.start(httpServer, transport, port);
 }
 
 main();
 ```
 
-### 2. Crear un Feature Module
+## 🔧 CLI Generator
+
+El paquete incluye un CLI para generar proyectos y features automáticamente.
+
+### Comandos Disponibles
+
+```bash
+# Generar nuevo proyecto
+mcp-generate init
+
+# Generar nueva feature
+mcp-generate feature
+
+# Help
+mcp-generate --help
+```
+
+### Generar Proyecto
+
+```bash
+mcp-generate init
+
+# Wizard interactivo:
+? Nombre del proyecto: my-awesome-mcp
+? Ruta: ./my-awesome-mcp
+? Descripción: My awesome MCP server
+? Autor: Tu Nombre
+? ¿Usar MongoDB? No
+? Base URL de tu API: https://api.example.com
+? ¿Instalar dependencias? Yes
+? ¿Linkear apprecio-mcp-base? Yes
+
+# Genera:
+# ✅ Estructura completa del proyecto
+# ✅ Archivos base (main.ts, services, utils)
+# ✅ Scripts de setup (post-install.sh, check-permissions.sh)
+# ✅ Configuración (.env, tsconfig.json, package.json)
+# ✅ README.md completo
+```
+
+### Generar Feature
+
+```bash
+cd my-project
+npm run generate
+
+# Wizard interactivo:
+? Nombre de la feature: users
+? Descripción: Manage users
+? ¿Necesita service? Yes
+? Tipo de service: API Client
+? Tools: [x] list, [x] get, [x] create, [x] update
+? Nombre de la entidad: user
+? ¿Auto-registrar en main.ts? Yes
+
+# Genera:
+# ✅ users.feature.ts - Feature module con tools
+# ✅ users.service.ts - Business logic
+# ✅ users.validation.ts - Zod schemas
+# ✅ Actualiza main.ts automáticamente
+```
+
+## 📚 Sistema de Features
+
+### Crear un Feature Module
 
 ```typescript
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { FeatureModule } from '@apprecio/mcp-base';
+import { logger, type FeatureModule } from 'apprecio-mcp-base';
 
-export const myFeatureModule: FeatureModule = {
-    name: 'myFeature',
+export const usersFeature: FeatureModule = {
+    name: 'users',
 
     register(mcpServer: McpServer): void {
-        // Registrar tools
+        // Registrar tool
         mcpServer.tool(
-            'my_tool',
-            'Description of my tool',
+            'list_users',
+            'List all users',
             {
-                type: 'object',
-                properties: {
-                    param: { type: 'string' }
-                },
-                required: ['param']
+                page: { type: 'number', description: 'Page number' },
+                limit: { type: 'number', description: 'Items per page' }
             },
-            async (params) => {
-                // Implementación del tool
+            async (args, extra) => {
+                // Extraer token de auth
+                const req = extra as any;
+                const token = req?.requestInfo?.headers?.authorization;
+                
+                // Tu lógica aquí
+                const users = await userService.list(args);
+                
                 return {
                     content: [{
                         type: 'text',
-                        text: `Result: ${params.param}`
+                        text: JSON.stringify(users)
                     }]
                 };
             }
         );
+
+        logger.info('Users feature registered');
     },
 
     async initialize(): Promise<void> {
-        // Inicialización opcional
-        console.log('Feature initialized');
+        logger.info('Users feature initialized');
     },
 
     async cleanup(): Promise<void> {
-        // Cleanup opcional
-        console.log('Feature cleaned up');
+        logger.info('Users feature cleaned up');
     }
 };
 ```
 
-### 3. Configuración (.env)
+### Registrar Features
+
+```typescript
+class MyMcpServer extends McpBaseServer {
+    protected async registerFeatures(): Promise<void> {
+        this.registerFeature('users', usersFeature);
+        this.registerFeature('products', productsFeature);
+        this.registerFeature('orders', ordersFeature);
+        
+        logger.info('All features registered');
+    }
+}
+```
+
+## 🔐 Autenticación
+
+### Middleware de Autenticación
+
+```typescript
+import { createAuthMiddleware } from 'apprecio-mcp-base';
+
+// Crear middleware
+const auth = createAuthMiddleware({
+    apiKey: process.env.API_KEY,
+    enabled: process.env.AUTH_ENABLED !== 'false'
+});
+
+// Usar en Express
+app.get('/health', handler); // Público
+
+app.use('/sse', auth); // Protegido
+app.post('/sse', handler);
+```
+
+### Usar Token en Features
+
+```typescript
+mcpServer.tool('secure_action', schema, async (args, extra) => {
+    // Extraer token
+    const req = extra as any;
+    const token = req?.requestInfo?.headers?.authorization;
+    
+    if (!token) {
+        throw new Error('Unauthorized');
+    }
+    
+    // Validar y usar token
+    const isValid = await validateToken(token);
+    if (!isValid) {
+        throw new Error('Invalid token');
+    }
+    
+    // Procesar acción
+    return { content: [{ type: 'text', text: 'Success' }] };
+});
+```
+
+## 📝 Configuración
+
+### Variables de Entorno
 
 ```env
 # Authentication
-API_KEY=your-secret-api-key
+API_KEY=your-secret-key-here
+AUTH_ENABLED=false
 
-# Database
+# Database (opcional)
 MONGODB_URI=mongodb://localhost:27017/mydb
 
 # Server
@@ -152,150 +298,359 @@ RATE_LIMIT_WINDOW_MS=900000
 RATE_LIMIT_MAX_REQUESTS=100
 ```
 
-## 📚 API Reference
-
-### McpBaseServer
-
-Clase abstracta base para servidores MCP.
+### Acceder a Configuración
 
 ```typescript
-abstract class McpBaseServer {
-    constructor(options: ServerOptions)
-    
-    // Métodos abstractos (deben implementarse)
-    protected abstract registerFeatures(): Promise<void>
-    
-    // Hooks opcionales
-    protected async onBeforeStart?(): Promise<void>
-    protected async onBeforeShutdown?(): Promise<void>
-    
-    // Métodos públicos
-    public getMcpServer(): McpServer
-    public getConfig(): BaseConfig
-    public getFeatures(): Map<string, FeatureModule>
-    
-    // Método para iniciar el servidor
-    async start(httpServer: HttpServer, port: number): Promise<void>
+class MyMcpServer extends McpBaseServer {
+    protected async registerFeatures(): Promise<void> {
+        // Acceder a config
+        const config = this.config;
+        
+        logger.info(`Server port: ${config.ssePort}`);
+        logger.info(`MongoDB URI: ${config.mongodbUri}`);
+        logger.info(`Log level: ${config.logLevel}`);
+    }
 }
 ```
 
-### BaseConfig
+## 🗄️ Database Connectors
 
-Sistema de configuración con validación.
+### MongoDB
 
 ```typescript
-class BaseConfig {
-    constructor(envPath?: string)
-    
-    // Getters
-    get apiKey(): string
-    get mongodbUri(): string | undefined
-    get ssePort(): number
-    get logLevel(): 'debug' | 'info' | 'warn' | 'error'
-    // ... más getters
-    
-    // Métodos
-    getAll(): BaseConfigType
-    extend<T>(customConfig: T): BaseConfigType & T
-}
-```
-
-### Logger
-
-Logger centralizado con Winston.
+import { createMongoDBConnector } from 'apprecio-mcp-base';
 
-```typescript
-import { logger, createChildLogger, setLogLevel } from '@apprecio/mcp-base';
+// Crear conector
+const db = createMongoDBConnector('mongodb://localhost:27017/db');
 
-// Uso básico
-logger.info('Message');
-logger.error('Error', error);
-logger.debug('Debug info', { metadata });
+// Conectar
+await db.connect();
 
-// Logger con contexto
-const childLogger = createChildLogger('MyFeature');
-childLogger.info('Feature message');
+// Usar mongoose
+const connection = db.getConnection();
+const User = connection.model('User', userSchema);
 
-// Cambiar nivel dinámicamente
-setLogLevel('debug');
+// Desconectar
+await db.disconnect();
 ```
 
-### Middlewares
+### Redis
 
 ```typescript
-import { createAuthMiddleware } from '@apprecio/mcp-base';
+import { createRedisConnector } from 'apprecio-mcp-base';
+
+// Crear conector
+const redis = createRedisConnector('redis://localhost:6379');
+
+// Conectar
+await redis.connect();
 
-const authMiddleware = createAuthMiddleware(apiKey);
+// Usar
+const client = redis.getClient();
+await client.set('key', 'value');
+const value = await client.get('key');
 
-app.use('/protected', authMiddleware.authenticate);
-app.use('/optional', authMiddleware.optionalAuth);
+// Desconectar
+await redis.disconnect();
 ```
 
-### Database Connectors
+## 📊 Logger
 
 ```typescript
-import { createMongoDBConnector } from '@apprecio/mcp-base';
+import { logger, createChildLogger, setLogLevel } from 'apprecio-mcp-base';
 
-const db = createMongoDBConnector('mongodb://localhost:27017/db');
-await db.connect();
+// Uso básico
+logger.info('Server started');
+logger.error('Error occurred', error);
+logger.debug('Debug info', { metadata });
+logger.warn('Warning message');
 
-// Usar mongoose normalmente
-const connection = db.getConnection();
+// Logger con contexto
+const featureLogger = createChildLogger('UsersFeature');
+featureLogger.info('User created', { userId: 123 });
 
-await db.disconnect();
+// Cambiar nivel dinámicamente
+setLogLevel('debug');
 ```
 
-## 🔧 Desarrollo
+## 🛠️ Desarrollo
 
-### Estructura del proyecto base
+### Estructura del Proyecto
 
 ```
-@apprecio/mcp-base/
+apprecio-mcp-base/
+├── cli/                      # CLI generator
+│   ├── generators/
+│   │   ├── init-generator.ts       # Generador de proyectos
+│   │   ├── feature-generator.ts    # Generador de features
+│   │   ├── service-generator.ts    # Generador de services
+│   │   ├── router-generator.ts     # Generador de routers
+│   │   └── main-updater.ts         # Actualizador de main.ts
+│   ├── templates/
+│   │   ├── post-install.sh
+│   │   └── check-permissions.sh
+│   └── generate-feature.ts   # Entry point del CLI
 ├── src/
 │   ├── core/                 # Núcleo del framework
 │   │   ├── McpBaseServer.ts  # Clase base
-│   │   ├── config.ts         # Configuración
-│   │   ├── logger.ts         # Logger
+│   │   ├── config.ts         # Sistema de configuración
+│   │   ├── logger.ts         # Logger centralizado
 │   │   └── types.ts          # Tipos compartidos
 │   ├── middleware/           # Middlewares Express
+│   │   ├── auth.ts           # Autenticación Bearer
+│   │   ├── rate-limit.ts     # Rate limiting
+│   │   └── cors.ts           # CORS config
 │   ├── database/             # Conectores DB
+│   │   ├── mongodb.ts
+│   │   └── redis.ts
 │   ├── server/               # Server builders
+│   │   └── express.ts
 │   ├── utils/                # Utilidades
+│   │   ├── port.ts           # Port finder
+│   │   └── shutdown.ts       # Graceful shutdown
 │   └── index.ts              # Exports principales
+├── examples/                 # Ejemplos de uso
 ├── package.json
 ├── tsconfig.json
 └── README.md
 ```
 
-### Build
+### Scripts Disponibles
+
+```bash
+# Build del paquete
+npm run build
+
+# Build con watch
+npm run build:watch
+
+# Build CLI
+npm run build:cli
+
+# Build todo
+npm run build:all
+
+# Link global
+npm link
+
+# Generate feature (si estás en un proyecto)
+npm run generate
+```
+
+### Desarrollo del CLI
 
 ```bash
+# Build CLI
+npm run build:cli
+
+# Link globalmente
+npm link
+
+# Usar en cualquier lugar
+mcp-generate init
+```
+
+## 🚀 Setup para Desarrollo
+
+### 1. Setup Inicial
+
+```bash
+# Clone repo
+git clone https://github.com/apprecio/apprecio-mcp-base.git
+cd apprecio-mcp-base
+
+# Instalar dependencias
+npm install
+
+# Build
 npm run build
+
+# Link global
+npm link
 ```
 
-### Desarrollo
+### 2. Crear Proyecto de Prueba
 
 ```bash
+# Generar proyecto
+mcp-generate init
+
+# Configurar
+cd my-test-project
+npm install
+npm link apprecio-mcp-base
+
+# Ejecutar
 npm run dev
 ```
 
-## 🎨 Ejemplos Completos
+### 3. Desarrollo Iterativo
 
-Ver el directorio `examples/` para ejemplos completos de:
+```bash
+# Terminal 1: Watch mode en apprecio-mcp-base
+cd apprecio-mcp-base
+npm run build:watch
+
+# Terminal 2: Tu proyecto
+cd my-test-project
+npm run dev
+
+# Los cambios en apprecio-mcp-base se reflejan automáticamente
+```
+
+## 📚 API Reference
+
+### McpBaseServer
+
+```typescript
+abstract class McpBaseServer {
+    constructor(options: ServerOptions)
+    
+    // Métodos abstractos
+    protected abstract registerFeatures(): Promise<void>
+    
+    // Hooks opcionales
+    protected async onBeforeStart?(): Promise<void>
+    protected async onBeforeShutdown?(): Promise<void>
+    
+    // Métodos públicos
+    getMcpServer(): McpServer
+    getConfig(): BaseConfig
+    getFeatures(): Map<string, FeatureModule>
+    
+    // Lifecycle
+    async start(httpServer: HttpServer, transport: Transport, port: number): Promise<void>
+}
+```
+
+### FeatureModule
+
+```typescript
+interface FeatureModule {
+    name: string;
+    register(mcpServer: McpServer): void;
+    initialize?(): Promise<void>;
+    cleanup?(): Promise<void>;
+}
+```
+
+### BaseConfig
+
+```typescript
+class BaseConfig {
+    get apiKey(): string
+    get mongodbUri(): string | undefined
+    get ssePort(): number
+    get logLevel(): 'debug' | 'info' | 'warn' | 'error'
+    get mcpTimeout(): number
+    get sseTimeout(): number
+    get corsAllowOrigin(): string
+    get rateLimitWindowMs(): number
+    get rateLimitMaxRequests(): number
+}
+```
+
+## 🆘 Troubleshooting
+
+### Error: Cannot find module 'apprecio-mcp-base'
+
+```bash
+# Verificar link global
+npm list -g apprecio-mcp-base --depth=0
+
+# Si no está linkeado:
+cd apprecio-mcp-base
+npm run build
+npm link
+
+# En tu proyecto:
+npm link apprecio-mcp-base
+```
+
+### Error: EACCES (Permission Denied)
+
+```bash
+# En el proyecto generado
+./check-permissions.sh
+
+# Arreglar permisos
+sudo chown -R $(whoami) .
+chmod -R 755 .
+```
+
+### Error: npm cache EACCES
+
+```bash
+# Arreglar caché de npm
+sudo chown -R $(whoami) ~/.npm
+npm cache clean --force
+npm install
+```
+
+### Cambios no se reflejan
+
+```bash
+# Rebuild apprecio-mcp-base
+cd apprecio-mcp-base
+npm run build
+
+# Los proyectos linkeados ven cambios automáticamente
+```
+
+## 💡 Best Practices
+
+### ✅ DO:
+
+- Usa el CLI para generar proyectos y features
+- Mantén features pequeños y enfocados
+- Usa el logger en lugar de console.log
+- Implementa cleanup en features con recursos
+- Usa TypeScript strict mode
+- Valida inputs con Zod
+
+### ❌ DON'T:
+
+- No uses `sudo npm install`
+- No modifies archivos generados manualmente
+- No uses console.log en producción
+- No olvides implementar cleanup
+- No hardcodees configuración
+
+## 🎯 Ejemplos
+
+Ver `examples/` para:
 
 - Servidor MCP simple
 - Servidor con MongoDB
 - Servidor con múltiples features
-- Servidor con autenticación personalizada
+- Feature con autenticación
+- Feature con validación Zod
 
-## 📝 Licencia
+## 📖 Documentación
 
-MIT
+- [Model Context Protocol](https://modelcontextprotocol.io) - Especificación MCP
+- [TypeScript](https://www.typescriptlang.org/) - TypeScript docs
+- [Winston](https://github.com/winstonjs/winston) - Logger docs
+- [Zod](https://zod.dev/) - Validation docs
 
 ## 🤝 Contribuir
 
 1. Fork el proyecto
-2. Crea una branch para tu feature
-3. Commit tus cambios
-4. Push a la branch
+2. Crea una branch: `git checkout -b feature/amazing-feature`
+3. Commit cambios: `git commit -m 'Add amazing feature'`
+4. Push: `git push origin feature/amazing-feature`
 5. Abre un Pull Request
+
+## 📄 Licencia
+
+MIT © Apprecio
+
+## 🔗 Links
+
+- [GitHub](https://github.com/apprecio/apprecio-mcp-base)
+- [npm](https://www.npmjs.com/package/apprecio-mcp-base)
+- [Issues](https://github.com/apprecio/apprecio-mcp-base/issues)
+
+---
+
+**Hecho con ❤️ por el equipo de Apprecio**

package/cli/dist/generate-feature.js

@@ -12,9 +12,6 @@ program
     .name('mcp-generate')
     .description('CLI para generar proyectos y features MCP automáticamente')
     .version('1.2.0');
-// ==========================================
-// COMANDO: init
-// ==========================================
 program
     .command('init')
     .description('Inicializa un nuevo proyecto MCP con estructura completa')
@@ -87,11 +84,112 @@ program
             apiBaseUrl: answers.apiBaseUrl
         });
         console.log(chalk.green('\n✅ ¡Proyecto creado exitosamente!\n'));
+        // Preguntar si quiere instalar dependencias automáticamente
+        const installAnswer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'installDeps',
+                message: '¿Instalar dependencias ahora? (npm install)',
+                default: true
+            }
+        ]);
+        if (installAnswer.installDeps) {
+            console.log(chalk.yellow('\n📦 Instalando dependencias (esto puede tomar unos minutos)...\n'));
+            try {
+                const { execSync } = await import('child_process');
+                // Verificar y limpiar caché de npm si hay problemas de permisos
+                try {
+                    console.log(chalk.gray('Verificando caché de npm...\n'));
+                    execSync('npm cache verify', {
+                        stdio: 'pipe',
+                        encoding: 'utf-8'
+                    });
+                }
+                catch (cacheError) {
+                    // Si hay error de permisos en caché, intentar limpiar
+                    if (cacheError.message.includes('EACCES')) {
+                        console.log(chalk.yellow('⚠️  Detectado problema de permisos en caché de npm\n'));
+                        console.log(chalk.gray('Intentando limpiar caché...\n'));
+                        try {
+                            // Intentar limpiar caché sin sudo primero
+                            execSync('npm cache clean --force', {
+                                stdio: 'pipe',
+                                encoding: 'utf-8'
+                            });
+                            console.log(chalk.green('✅ Caché limpiado\n'));
+                        }
+                        catch (cleanError) {
+                            console.log(chalk.yellow('⚠️  No se pudo limpiar caché automáticamente\n'));
+                            console.log(chalk.white('Ejecuta manualmente:\n'));
+                            console.log(chalk.cyan('  sudo chown -R $(whoami) ~/.npm\n'));
+                            console.log(chalk.cyan('  npm cache clean --force\n'));
+                        }
+                    }
+                }
+                // Ejecutar npm install de forma síncrona para esperar a que termine
+                execSync('sudo npm install', {
+                    cwd: answers.projectPath,
+                    stdio: 'inherit', // Muestra el output en tiempo real
+                    encoding: 'utf-8'
+                });
+                console.log(chalk.green('\n✅ Dependencias instaladas correctamente\n'));
+                // Preguntar si quiere linkear apprecio-mcp-base
+                const linkAnswer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'linkBase',
+                        message: '¿Linkear apprecio-mcp-base local? (npm link apprecio-mcp-base)',
+                        default: true
+                    }
+                ]);
+                if (linkAnswer.linkBase) {
+                    console.log(chalk.yellow('\n🔗 Linkeando apprecio-mcp-base...\n'));
+                    try {
+                        execSync('npm link apprecio-mcp-base', {
+                            cwd: answers.projectPath,
+                            stdio: 'inherit',
+                            encoding: 'utf-8'
+                        });
+                        console.log(chalk.green('\n✅ apprecio-mcp-base linkeado correctamente\n'));
+                    }
+                    catch (linkError) {
+                        console.log(chalk.yellow('\n⚠️  Error linkeando apprecio-mcp-base'));
+                        console.log(chalk.white('   Asegúrate de haber ejecutado en apprecio-mcp-base:'));
+                        console.log(chalk.cyan('   cd apprecio-mcp-base && npm run build && npm link\n'));
+                    }
+                }
+            }
+            catch (error) {
+                console.log(chalk.red('\n❌ Error instalando dependencias:', error.message));
+                // Detectar error de permisos de npm
+                if (error.message.includes('EACCES') && error.message.includes('.npm')) {
+                    console.log(chalk.yellow('\n⚠️  Problema de permisos en caché de npm detectado\n'));
+                    console.log(chalk.white('Solución:\n'));
+                    console.log(chalk.cyan('  sudo chown -R $(whoami) ~/.npm'));
+                    console.log(chalk.cyan('  npm cache clean --force'));
+                    console.log(chalk.cyan(`  cd ${answers.projectPath}`));
+                    console.log(chalk.cyan('  npm install\n'));
+                }
+                else {
+                    console.log(chalk.white('\nEjecuta manualmente:'));
+                    console.log(chalk.cyan(`  cd ${answers.projectPath}`));
+                    console.log(chalk.cyan('  npm install\n'));
+                }
+            }
+        }
         console.log(chalk.blue.bold('📚 Próximos pasos:\n'));
-        console.log(chalk.white(`1. cd ${answers.projectPath}`));
-        console.log(chalk.white(`2. npm install`));
-        console.log(chalk.white(`3. Edita .env con tu configuración`));
-        console.log(chalk.white(`4. npm run dev\n`));
+        if (!installAnswer.installDeps) {
+            console.log(chalk.white(`1. cd ${answers.projectPath}`));
+            console.log(chalk.white(`2. npm install`));
+            console.log(chalk.white(`3. npm link apprecio-mcp-base`));
+            console.log(chalk.white(`4. Edita .env con tu configuración`));
+            console.log(chalk.white(`5. npm run dev\n`));
+        }
+        else {
+            console.log(chalk.white(`1. cd ${answers.projectPath}`));
+            console.log(chalk.white(`2. Edita .env con tu configuración`));
+            console.log(chalk.white(`3. npm run dev\n`));
+        }
         console.log(chalk.blue.bold('🔧 Comandos útiles:\n'));
         console.log(chalk.white(`  npm run generate  - Generar nueva feature`));
         console.log(chalk.white(`  npm run dev       - Ejecutar en desarrollo`));
@@ -102,52 +200,6 @@ program
         process.exit(1);
     }
 });
-program
-    .command('tool')
-    .description('Agrega un tool a una feature existente')
-    .action(async () => {
-    console.log(chalk.blue.bold('\n🔧 Agregar Tool a Feature\n'));
-    // Listar features existentes
-    const featuresPath = path.join(process.cwd(), 'src', 'features');
-    const features = await fs.readdir(featuresPath);
-    if (features.length === 0) {
-        console.log(chalk.red('No hay features disponibles. Crea una primero con: mcp-generate feature'));
-        process.exit(1);
-    }
-    const answers = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'feature',
-            message: 'Selecciona la feature:',
-            choices: features
-        },
-        {
-            type: 'input',
-            name: 'toolName',
-            message: 'Nombre del tool (ej: approve_item):',
-            validate: (input) => {
-                if (!input)
-                    return 'El nombre es requerido';
-                if (!/^[a-z_]+$/.test(input)) {
-                    return 'El nombre debe ser snake_case';
-                }
-                return true;
-            }
-        },
-        {
-            type: 'input',
-            name: 'toolDescription',
-            message: 'Descripción del tool:',
-        },
-        {
-            type: 'confirm',
-            name: 'addToService',
-            message: '¿Agregar método al service?',
-            default: true
-        }
-    ]);
-    console.log(chalk.green(`\n✅ Tool ${answers.toolName} agregado a ${answers.feature}\n`));
-});
 // ==========================================
 // COMANDO: feature
 // ==========================================
@@ -262,5 +314,51 @@ program
         process.exit(1);
     }
 });
+program
+    .command('tool')
+    .description('Agrega un tool a una feature existente')
+    .action(async () => {
+    console.log(chalk.blue.bold('\n🔧 Agregar Tool a Feature\n'));
+    // Listar features existentes
+    const featuresPath = path.join(process.cwd(), 'src', 'features');
+    const features = await fs.readdir(featuresPath);
+    if (features.length === 0) {
+        console.log(chalk.red('No hay features disponibles. Crea una primero con: mcp-generate feature'));
+        process.exit(1);
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'feature',
+            message: 'Selecciona la feature:',
+            choices: features
+        },
+        {
+            type: 'input',
+            name: 'toolName',
+            message: 'Nombre del tool (ej: approve_item):',
+            validate: (input) => {
+                if (!input)
+                    return 'El nombre es requerido';
+                if (!/^[a-z_]+$/.test(input)) {
+                    return 'El nombre debe ser snake_case';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'input',
+            name: 'toolDescription',
+            message: 'Descripción del tool:',
+        },
+        {
+            type: 'confirm',
+            name: 'addToService',
+            message: '¿Agregar método al service?',
+            default: true
+        }
+    ]);
+    console.log(chalk.green(`\n✅ Tool ${answers.toolName} agregado a ${answers.feature}\n`));
+});
 program.parse();
 //# sourceMappingURL=generate-feature.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apprecio-mcp-base",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Base package for creating Apprecio MCP servers with consistency",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",