plazbot-cli 0.1.2 → 0.1.4

package/src/commands/whatsapp/broadcast.ts

@@ -0,0 +1,100 @@
+import { Command } from 'commander';
+import { Message } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner, theme, section, progressBar } from '../../utils/ui';
+import fs from 'fs/promises';
+
+export const broadcastCommand = new Command('broadcast')
+  .description('Envio masivo de mensajes de template WhatsApp')
+  .requiredOption('-t, --template <name>', 'Nombre del template')
+  .requiredOption('--phones <file>', 'Archivo CSV con numeros de telefono (uno por linea)')
+  .option('--var <vars...>', 'Variables del body (formato: name=valor)')
+  .option('--delay <ms>', 'Delay entre mensajes en ms', '1000')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: any) => {
+    try {
+      const credentials = await getStoredCredentials();
+
+      const messageClient = new Message({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      // Leer archivo de telefonos
+      let phones: string[];
+      try {
+        const content = await fs.readFile(options.phones, 'utf-8');
+        phones = content.split('\n')
+          .map(line => line.trim())
+          .filter(line => line && !line.startsWith('#'));
+      } catch {
+        throw new Error(`No se pudo leer el archivo: ${options.phones}`);
+      }
+
+      if (phones.length === 0) {
+        throw new Error('El archivo no contiene numeros de telefono');
+      }
+
+      // Parsear variables
+      const variablesBody = parseVariables(options.var);
+
+      console.log(section('Broadcast WhatsApp'));
+      logger.label('Template', options.template);
+      logger.label('Destinatarios', String(phones.length));
+      logger.label('Delay', `${options.delay}ms`);
+      if (variablesBody.length > 0) {
+        logger.label('Variables', variablesBody.map(v => `${v.variable}=${v.value}`).join(', '));
+      }
+      console.log();
+
+      const delay = parseInt(options.delay) || 1000;
+      let sent = 0;
+      let failed = 0;
+
+      for (let i = 0; i < phones.length; i++) {
+        const phone = phones[i];
+        try {
+          const params: any = {
+            to: phone,
+            template: options.template,
+          };
+          if (variablesBody.length > 0) params.variablesBody = variablesBody;
+
+          await messageClient.onConversation(params);
+          sent++;
+        } catch {
+          failed++;
+          console.log(theme.error(`  ✖ Fallo: ${phone}`));
+        }
+
+        // Progress
+        console.log(`  ${progressBar(i + 1, phones.length)}`);
+
+        // Rate limiting
+        if (i < phones.length - 1) {
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+
+      console.log(section('Resultado'));
+      logger.label('Enviados', theme.success(String(sent)));
+      logger.label('Fallidos', failed > 0 ? theme.error(String(failed)) : '0');
+      logger.label('Total', String(phones.length));
+
+    } catch (error: unknown) {
+      const message = (error as Error)?.message || 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+function parseVariables(vars: string[] | undefined): { variable: string; value: string }[] {
+  if (!vars) return [];
+  return vars.map(v => {
+    const [variable, ...rest] = v.split('=');
+    return { variable: variable.trim(), value: rest.join('=').trim() };
+  }).filter(v => v.variable && v.value);
+}

package/src/commands/whatsapp/channels.ts

@@ -0,0 +1,98 @@
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner, createTable, theme, section, statusBadge } from '../../utils/ui';
+
+export const channelsCommand = new Command('channels')
+  .description('Listar agentes con canales de WhatsApp asignados')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (options: any) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const agent = new Agent({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const spinner = createSpinner('Cargando canales...');
+      spinner.start();
+      const agents = await agent.getAgents();
+      spinner.stop();
+
+      console.log(section('Canales WhatsApp'));
+
+      const whatsappAgents = (agents || []).filter((a: any) =>
+        a.channels && a.channels.some((c: any) => c.channel === 'whatsapp')
+      );
+
+      if (whatsappAgents.length === 0) {
+        console.log(theme.muted('\n  No hay agentes con WhatsApp configurado'));
+        console.log(theme.muted('  Usa el wizard: plazbot agent create\n'));
+        return;
+      }
+
+      const rows = whatsappAgents.map((a: any) => {
+        const waChannel = a.channels.find((c: any) => c.channel === 'whatsapp');
+        return [
+          a.id || a._id,
+          a.name,
+          waChannel?.key || 'N/A',
+          statusBadge(a.enable !== false),
+        ];
+      });
+
+      console.log(createTable(['Agent ID', 'Nombre', 'Numero WhatsApp', 'Estado'], rows));
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+export const assignCommand = new Command('assign')
+  .description('Asignar un agente a un numero de WhatsApp')
+  .argument('<phone>', 'Numero de WhatsApp')
+  .argument('<agentId>', 'ID del agente')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (phone: string, agentId: string, options: any) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const agent = new Agent({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const spinner = createSpinner('Cargando agente...');
+      spinner.start();
+      const agentData = await agent.getAgentById({ id: agentId });
+      spinner.stop();
+
+      const channels = agentData.channels || [];
+
+      // Verificar si ya tiene este canal
+      const existing = channels.findIndex((c: any) => c.channel === 'whatsapp' && c.key === phone);
+      if (existing >= 0) {
+        logger.warning('Este numero ya esta asignado a este agente');
+        return;
+      }
+
+      // Agregar canal
+      channels.push({ channel: 'whatsapp', key: phone, multianswer: false });
+
+      const updateSpinner = createSpinner('Asignando...');
+      updateSpinner.start();
+      await agent.updateAgent(agentId, { channels });
+      updateSpinner.succeed(`Agente "${agentData.name}" asignado a WhatsApp ${phone}`);
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });

package/src/commands/whatsapp/chat.ts

@@ -0,0 +1,77 @@
+import { Command } from 'commander';
+import { Message } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner, theme } from '../../utils/ui';
+import readline from 'readline';
+import chalk from 'chalk';
+
+export const whatsappChatCommand = new Command('chat')
+  .description('Chat interactivo directo por WhatsApp')
+  .argument('<phone>', 'Numero de telefono destino (con codigo de pais)')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (phone: string, options: any) => {
+    try {
+      const credentials = await getStoredCredentials();
+
+      const messageClient = new Message({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      console.clear();
+      console.log();
+      console.log(chalk.hex('#25D366')('  ┌' + '─'.repeat(50) + '┐'));
+      console.log(chalk.hex('#25D366')('  │') + chalk.bold(`  WhatsApp Chat`).padEnd(60) + chalk.hex('#25D366')('│'));
+      console.log(chalk.hex('#25D366')('  │') + chalk.gray(`  Destino: ${phone}`).padEnd(60) + chalk.hex('#25D366')('│'));
+      console.log(chalk.hex('#25D366')('  │') + chalk.gray('  /exit para salir').padEnd(60) + chalk.hex('#25D366')('│'));
+      console.log(chalk.hex('#25D366')('  └' + '─'.repeat(50) + '┘'));
+      console.log();
+
+      const ask = () => {
+        rl.question(chalk.hex('#25D366')('  > '), async (message) => {
+          if (!message.trim()) {
+            ask();
+            return;
+          }
+
+          if (message.toLowerCase() === '/exit') {
+            console.log(chalk.gray('\n  Chat terminado.\n'));
+            rl.close();
+            return;
+          }
+
+          try {
+            const spinner = createSpinner('Enviando...');
+            spinner.start();
+
+            await messageClient.onWhatsappMessage({
+              message,
+              to: phone,
+            });
+
+            spinner.succeed('Enviado');
+            ask();
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : 'Error';
+            console.log(chalk.hex('#EF5350')(`  ✖ ${msg}`));
+            ask();
+          }
+        });
+      };
+
+      ask();
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });

package/src/commands/whatsapp/index.ts

@@ -3,10 +3,19 @@ import { sendMessageCommand } from './send';
 import { sendTemplateCommand } from './send-template';
 import { registerWebhookCommand } from './register-webhook';
 import { deleteWebhookCommand } from './delete-webhook';
+import { broadcastCommand } from './broadcast';
+import { whatsappChatCommand } from './chat';
+import { widgetCommand } from './widget';
+import { channelsCommand, assignCommand } from './channels';
 
 export const whatsappCommands = new Command('whatsapp')
-  .description('Comandos relacionados con mensajes de WhatsApp')
+  .description('Comandos de WhatsApp: mensajes, templates, broadcast y mas')
   .addCommand(sendMessageCommand)
   .addCommand(sendTemplateCommand)
   .addCommand(registerWebhookCommand)
-  .addCommand(deleteWebhookCommand); 
+  .addCommand(deleteWebhookCommand)
+  .addCommand(broadcastCommand)
+  .addCommand(whatsappChatCommand)
+  .addCommand(widgetCommand)
+  .addCommand(channelsCommand)
+  .addCommand(assignCommand);

package/src/commands/whatsapp/send-template.ts

@@ -2,16 +2,21 @@ import { Command } from 'commander';
 import { Message } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials';
 import { logger } from '../../utils/logger';
-import { TemplateCommandOptions } from '../../types/message';
+import { createSpinner } from '../../utils/ui';
 
 export const sendTemplateCommand = new Command('send-template')
-  .description('Envía una plantilla de WhatsApp')
-  .requiredOption('-p, --phone <number>', 'Número de teléfono del destinatario (con código de país, ej: 51912345678)')
-  .requiredOption('-t, --template <name>', 'Nombre de la plantilla a enviar')
+  .description('Envia un mensaje de template de WhatsApp con variables')
+  .requiredOption('-p, --phone <number>', 'Numero de telefono (con codigo de pais)')
+  .requiredOption('-t, --template <name>', 'Nombre del template')
+  .option('--var <vars...>', 'Variables del body (formato: name=valor)')
+  .option('--header-var <vars...>', 'Variables del header (formato: name=valor)')
+  .option('--file-url <url>', 'URL del archivo adjunto')
+  .option('--file-name <name>', 'Nombre del archivo adjunto')
   .option('--dev', 'Usar ambiente de desarrollo', false)
-  .action(async (options: TemplateCommandOptions) => {
+  .action(async (options: any) => {
     try {
       const credentials = await getStoredCredentials();
+
       const messageClient = new Message({
         workspaceId: credentials.workspace,
         apiKey: credentials.apiKey,
@@ -19,26 +24,59 @@ export const sendTemplateCommand = new Command('send-template')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      logger.info('\n📱 Enviando plantilla de WhatsApp...');
-      logger.info(`A: ${options.phone}`);
-      logger.info(`Plantilla: ${options.template}`);
-      
-      const response = await messageClient.onConversation({
+      // Parsear variables
+      const variablesBody = parseVariables(options.var);
+      const variablesHeader = parseVariables(options.headerVar);
+
+      // Archivo adjunto
+      const file = options.fileUrl ? {
+        fileUrl: options.fileUrl,
+        fileName: options.fileName || 'archivo',
+      } : undefined;
+
+      logger.title('Enviando template WhatsApp');
+      logger.label('Destino', options.phone);
+      logger.label('Template', options.template);
+      if (variablesBody.length > 0) {
+        logger.label('Variables body', variablesBody.map(v => `${v.variable}=${v.value}`).join(', '));
+      }
+      if (variablesHeader.length > 0) {
+        logger.label('Variables header', variablesHeader.map(v => `${v.variable}=${v.value}`).join(', '));
+      }
+      if (file) {
+        logger.label('Archivo', file.fileUrl);
+      }
+
+      const spinner = createSpinner('Enviando...');
+      spinner.start();
+
+      const params: any = {
         to: options.phone,
-        template: options.template
-      });
+        template: options.template,
+      };
+      if (variablesBody.length > 0) params.variablesBody = variablesBody;
+      if (variablesHeader.length > 0) params.variablesHeader = variablesHeader;
+      if (file) params.file = file;
+
+      const response = await messageClient.onConversation(params);
+
+      spinner.succeed('Template enviado exitosamente');
 
-      logger.success('Plantilla enviada exitosamente');
-      logger.info('\n📋 Detalles:');
-      logger.info(JSON.stringify(response, null, 2));
-      
       if (options.dev) {
-        logger.warning('\nAmbiente: desarrollo');
+        logger.warning('Ambiente: desarrollo');
       }
 
     } catch (error: unknown) {
-      const message = error instanceof Error ? error.message : 'Error desconocido al enviar la plantilla';
+      const message = (error as Error)?.message || 'Error desconocido al enviar el template';
       logger.error(message);
       process.exit(1);
     }
-  }); 
+  });
+
+function parseVariables(vars: string[] | undefined): { variable: string; value: string }[] {
+  if (!vars) return [];
+  return vars.map(v => {
+    const [variable, ...rest] = v.split('=');
+    return { variable: variable.trim(), value: rest.join('=').trim() };
+  }).filter(v => v.variable && v.value);
+}

package/src/commands/whatsapp/send.ts

@@ -3,17 +3,17 @@ import { Message } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials';
 import { logger } from '../../utils/logger';
 import { DirectMessageCommandOptions } from '../../types/message';
+import { createSpinner } from '../../utils/ui';
 
 export const sendMessageCommand = new Command('send-message')
-  .description('Envía un mensaje de WhatsApp')
-  .requiredOption('-t, --to <phone>', 'Número de teléfono del destinatario (con código de país, ej: 51912345678)')
+  .description('Envia un mensaje directo de WhatsApp')
+  .requiredOption('-t, --to <phone>', 'Numero de telefono (con codigo de pais, ej: 51912345678)')
   .requiredOption('-m, --message <text>', 'Mensaje a enviar')
   .option('--dev', 'Usar ambiente de desarrollo', false)
   .action(async (options: DirectMessageCommandOptions) => {
     try {
-      // Obtener credenciales guardadas
       const credentials = await getStoredCredentials();
-      
+
       const messageClient = new Message({
         workspaceId: credentials.workspace,
         apiKey: credentials.apiKey,
@@ -21,21 +21,22 @@ export const sendMessageCommand = new Command('send-message')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      logger.info('\n📱 Enviando mensaje de WhatsApp...');
-      logger.info(`A: ${options.to}`);
-      logger.info(`Mensaje: ${options.message}`);
-      
+      logger.title('Enviando mensaje WhatsApp');
+      logger.label('Destino', options.to);
+      logger.label('Mensaje', options.message);
+
+      const spinner = createSpinner('Enviando...');
+      spinner.start();
+
       const response = await messageClient.onWhatsappMessage({
         message: options.message,
         to: options.to
       });
 
-      logger.success('Mensaje enviado exitosamente');
-      logger.info('\n📋 Detalles:');
-      logger.info(JSON.stringify(response, null, 2));
-      
+      spinner.succeed('Mensaje enviado exitosamente');
+
       if (options.dev) {
-        logger.warning('\nAmbiente: desarrollo');
+        logger.warning('Ambiente: desarrollo');
       }
 
     } catch (error: unknown) {
@@ -43,4 +44,4 @@ export const sendMessageCommand = new Command('send-message')
       logger.error(message);
       process.exit(1);
     }
-  }); 
+  });

package/src/commands/whatsapp/widget.ts

@@ -0,0 +1,67 @@
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner } from '../../utils/ui';
+
+const widgetGroup = new Command('widget')
+  .description('Gestionar widget de WhatsApp');
+
+widgetGroup.command('enable')
+  .description('Activar widget de WhatsApp en un agente')
+  .argument('<agentId>', 'ID del agente')
+  .requiredOption('-u, --url <url>', 'URL de WhatsApp (ej: https://wa.me/51912345678)')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, options: any) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const agent = new Agent({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const spinner = createSpinner('Activando widget WhatsApp...');
+      spinner.start();
+      await agent.updateAgent(agentId, {
+        enableWhatsappWidget: true,
+        urlWhatsappWidget: options.url,
+      });
+      spinner.succeed('Widget WhatsApp activado');
+      logger.label('URL', options.url);
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+widgetGroup.command('disable')
+  .description('Desactivar widget de WhatsApp de un agente')
+  .argument('<agentId>', 'ID del agente')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, options: any) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const agent = new Agent({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const spinner = createSpinner('Desactivando widget WhatsApp...');
+      spinner.start();
+      await agent.updateAgent(agentId, { enableWhatsappWidget: false });
+      spinner.succeed('Widget WhatsApp desactivado');
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+export const widgetCommand = widgetGroup;

package/src/utils/banner.ts

@@ -0,0 +1,94 @@
+import chalk from 'chalk';
+import { getStoredCredentials } from './credentials';
+
+const VERSION = '0.2.0';
+
+// ASCII art del logo Plazbot (burbujas de chat)
+const logo = [
+  '    ╭──────────╮     ',
+  '    │  ● ● ●   │     ',
+  '    ╰────┬─────╯     ',
+  '   ╭─────┴────────╮  ',
+  '   │   ╭─╮  ╭─╮   │  ',
+  '   │   ╰─╯  ╰─╯   │  ',
+  '   │    ╰────╯     │  ',
+  '   ╰───────────────╯  ',
+];
+
+const coloredLogo = logo.map(line =>
+  chalk.hex('#2E8B57')(line)
+);
+
+export async function showBanner(): Promise<void> {
+  const width = 70;
+
+  // Intentar cargar credenciales
+  let credentials: { email?: string; workspace?: string; zone?: string } | null = null;
+  try {
+    credentials = await getStoredCredentials();
+  } catch {
+    // No hay credenciales guardadas
+  }
+
+  console.log();
+  console.log(chalk.hex('#4CAF50')('─'.repeat(width)));
+  console.log();
+
+  // Layout de 2 columnas
+  const leftWidth = 30;
+  const rightStart = leftWidth + 4;
+
+  // Línea del título
+  const title = chalk.bold.hex('#4CAF50')(`  Plazbot CLI v${VERSION}`);
+
+  // Info columna derecha
+  const rightColumn: string[] = [];
+
+  if (credentials) {
+    rightColumn.push(chalk.bold.hex('#4CAF50')('Workspace conectado'));
+    rightColumn.push(chalk.gray(`  ${credentials.workspace || 'N/A'}`));
+    rightColumn.push(chalk.gray(`  ${credentials.email || ''}`));
+    rightColumn.push(chalk.gray(`  Zona: ${credentials.zone || 'N/A'}`));
+    rightColumn.push('');
+    rightColumn.push(chalk.hex('#4CAF50')('─'.repeat(35)));
+    rightColumn.push('');
+    rightColumn.push(chalk.bold.hex('#4CAF50')('Comandos rapidos'));
+    rightColumn.push(chalk.white('  plazbot agent list'));
+    rightColumn.push(chalk.white('  plazbot agent create'));
+    rightColumn.push(chalk.white('  plazbot agent chat -a <id>'));
+    rightColumn.push(chalk.white('  plazbot whatsapp send-message'));
+  } else {
+    rightColumn.push(chalk.bold.hex('#FFA726')('No conectado'));
+    rightColumn.push('');
+    rightColumn.push(chalk.bold.hex('#4CAF50')('Para comenzar'));
+    rightColumn.push(chalk.white('  plazbot init -e <email> -k <key> -w <workspace> -z <zone>'));
+    rightColumn.push('');
+    rightColumn.push(chalk.hex('#4CAF50')('─'.repeat(35)));
+    rightColumn.push('');
+    rightColumn.push(chalk.bold.hex('#4CAF50')('Documentacion'));
+    rightColumn.push(chalk.gray('  https://docs.plazbot.com'));
+  }
+
+  // Imprimir título
+  console.log(title);
+  console.log();
+
+  // Imprimir logo + info lado a lado
+  const maxLines = Math.max(coloredLogo.length, rightColumn.length);
+  for (let i = 0; i < maxLines; i++) {
+    const left = i < coloredLogo.length ? coloredLogo[i] : ' '.repeat(leftWidth);
+    const right = i < rightColumn.length ? rightColumn[i] : '';
+    // Pad left column
+    const paddedLeft = left.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding = ' '.repeat(Math.max(0, leftWidth - paddedLeft.length));
+    console.log(`${left}${padding}  ${right}`);
+  }
+
+  console.log();
+  console.log(chalk.hex('#4CAF50')('─'.repeat(width)));
+  console.log();
+}
+
+export function showMiniHeader(command: string): void {
+  console.log(chalk.hex('#4CAF50')(`\n  Plazbot`) + chalk.gray(` > ${command}\n`));
+}

package/src/utils/logger.ts

@@ -1,21 +1,40 @@
+import chalk from 'chalk';
+
 export const logger = {
   info: (message: string) => {
-    console.log(message);
+    console.log(chalk.white(message));
   },
   success: (message: string) => {
-    console.log(`\n✅ ${message}`);
+    console.log(chalk.hex('#66BB6A')(`\n  ✔ ${message}`));
   },
   warning: (message: string) => {
-    console.log(`\n⚠️  ${message}`);
+    console.log(chalk.hex('#FFA726')(`\n  ⚠ ${message}`));
   },
   error: (error: Error | string) => {
     const message = error instanceof Error ? error.message : error;
-    console.error(`\n❌ Error: ${message}`);
+    console.error(chalk.hex('#EF5350')(`\n  ✖ Error: ${message}`));
   },
   divider: (length: number = 50) => {
-    console.log('─'.repeat(length));
+    console.log(chalk.gray('─'.repeat(length)));
   },
   doubleDivider: (length: number = 50) => {
-    console.log('═'.repeat(length));
+    console.log(chalk.gray('═'.repeat(length)));
+  },
+  label: (key: string, value: string) => {
+    console.log(`  ${chalk.gray(key + ':')} ${chalk.white(value)}`);
+  },
+  title: (text: string) => {
+    console.log(chalk.bold.hex('#4CAF50')(`\n  ${text}`));
+    console.log(chalk.gray('  ' + '─'.repeat(40)));
+  },
+  dim: (message: string) => {
+    console.log(chalk.gray(`  ${message}`));
+  },
+  json: (data: any) => {
+    const formatted = JSON.stringify(data, null, 2)
+      .split('\n')
+      .map(line => '  ' + line)
+      .join('\n');
+    console.log(chalk.gray(formatted));
   }
-}; 
+};