feat: Connect MCP tools to real services

Analytics Module:
- Created AnalyticsService with sales/financial reporting
- Supports sales summary, reports, top products/customers, KPIs
- Uses analytics schema and service_management tables

MCP Tools Connected:
- products-tools → PartService (real inventory data)
- sales-tools → AnalyticsService (real sales analytics)
- financial-tools → AnalyticsService (real P&L and KPIs)

Updated tool registry to pass DataSource to connected tools.

MCP Tools Status:
- orders-tools: Connected to ServiceOrderService
- inventory-tools: Connected to PartService
- customers-tools: Connected to CustomersService
- products-tools: Connected to PartService (NEW)
- sales-tools: Connected to AnalyticsService (NEW)
- financial-tools: Connected to AnalyticsService (NEW)
- fiados-tools: Mock (needs FiadosService)
- branch-tools: Mock (single tenant)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/modules/analytics/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Analytics Module
+ * Mecánicas Diesel - ERP Suite
+ *
+ * Sales analytics, financial reporting, and KPIs.
+ */
+
+export * from './services';

src/modules/analytics/services/analytics.service.ts

@@ -0,0 +1,458 @@
+/**
+ * Analytics Service
+ * Mecánicas Diesel - ERP Suite
+ *
+ * Business logic for sales analytics and financial reporting.
+ * Uses the analytics schema views and tables for P&L reporting.
+ */
+
+import { DataSource } from 'typeorm';
+
+// DTOs
+export interface SalesSummary {
+  period: string;
+  totalSales: number;
+  transactionCount: number;
+  avgTicket: number;
+  partsTotal: number;
+  laborTotal: number;
+  comparison?: {
+    previousPeriod: number;
+    changePercent: number;
+  };
+}
+
+export interface SalesReportItem {
+  date: string;
+  total: number;
+  count: number;
+  avgTicket: number;
+  parts: number;
+  labor: number;
+}
+
+export interface TopProduct {
+  rank: number;
+  productId: string;
+  productName: string;
+  sku: string;
+  quantity: number;
+  revenue: number;
+}
+
+export interface TopCustomer {
+  rank: number;
+  customerId: string;
+  customerName: string;
+  total: number;
+  transactions: number;
+}
+
+export interface FinancialReport {
+  type: string;
+  period: { start: string; end: string };
+  income: number;
+  expenses: number;
+  grossProfit: number;
+  netProfit: number;
+  breakdown: Record<string, number>;
+}
+
+export interface CashFlowReport {
+  period: string;
+  inflows: number;
+  outflows: number;
+  netFlow: number;
+  openingBalance: number;
+  closingBalance: number;
+  byCategory: Array<{ category: string; type: string; amount: number }>;
+}
+
+export interface KPIs {
+  period: string;
+  grossMargin: number;
+  netMargin: number;
+  avgTicket: number;
+  ordersCompleted: number;
+  avgCompletionDays: number;
+  partsToLaborRatio: number;
+}
+
+export class AnalyticsService {
+  constructor(private dataSource: DataSource) {}
+
+  /**
+   * Get sales summary for a period
+   */
+  async getSalesSummary(
+    tenantId: string,
+    period: 'today' | 'week' | 'month' | 'year' = 'today',
+    branchId?: string
+  ): Promise<SalesSummary> {
+    const { startDate, endDate, previousStart, previousEnd } = this.getDateRange(period);
+
+    // Current period query
+    const currentResult = await this.dataSource.query(`
+      SELECT
+        COUNT(*) as transaction_count,
+        COALESCE(SUM(grand_total), 0) as total_sales,
+        COALESCE(SUM(parts_total), 0) as parts_total,
+        COALESCE(SUM(labor_total), 0) as labor_total,
+        COALESCE(AVG(grand_total), 0) as avg_ticket
+      FROM service_management.service_orders
+      WHERE tenant_id = $1
+        AND status IN ('completed', 'delivered')
+        AND completed_at >= $2
+        AND completed_at < $3
+    `, [tenantId, startDate, endDate]);
+
+    // Previous period for comparison
+    const previousResult = await this.dataSource.query(`
+      SELECT COALESCE(SUM(grand_total), 0) as total_sales
+      FROM service_management.service_orders
+      WHERE tenant_id = $1
+        AND status IN ('completed', 'delivered')
+        AND completed_at >= $2
+        AND completed_at < $3
+    `, [tenantId, previousStart, previousEnd]);
+
+    const current = currentResult[0];
+    const previous = previousResult[0];
+
+    const totalSales = parseFloat(current.total_sales) || 0;
+    const previousSales = parseFloat(previous.total_sales) || 0;
+    const changePercent = previousSales > 0
+      ? ((totalSales - previousSales) / previousSales) * 100
+      : 0;
+
+    return {
+      period,
+      totalSales,
+      transactionCount: parseInt(current.transaction_count, 10) || 0,
+      avgTicket: parseFloat(current.avg_ticket) || 0,
+      partsTotal: parseFloat(current.parts_total) || 0,
+      laborTotal: parseFloat(current.labor_total) || 0,
+      comparison: {
+        previousPeriod: previousSales,
+        changePercent: Math.round(changePercent * 10) / 10,
+      },
+    };
+  }
+
+  /**
+   * Get detailed sales report
+   */
+  async getSalesReport(
+    tenantId: string,
+    startDate: string,
+    endDate: string,
+    groupBy: 'day' | 'week' | 'month' = 'day'
+  ): Promise<SalesReportItem[]> {
+    const truncFormat = groupBy === 'day' ? 'day' : groupBy === 'week' ? 'week' : 'month';
+
+    const result = await this.dataSource.query(`
+      SELECT
+        DATE_TRUNC($4, completed_at) as period_date,
+        COUNT(*) as count,
+        COALESCE(SUM(grand_total), 0) as total,
+        COALESCE(SUM(parts_total), 0) as parts,
+        COALESCE(SUM(labor_total), 0) as labor,
+        COALESCE(AVG(grand_total), 0) as avg_ticket
+      FROM service_management.service_orders
+      WHERE tenant_id = $1
+        AND status IN ('completed', 'delivered')
+        AND completed_at >= $2
+        AND completed_at < $3
+      GROUP BY DATE_TRUNC($4, completed_at)
+      ORDER BY period_date DESC
+    `, [tenantId, startDate, endDate, truncFormat]);
+
+    return result.map((row: any) => ({
+      date: row.period_date?.toISOString().split('T')[0] || '',
+      total: parseFloat(row.total) || 0,
+      count: parseInt(row.count, 10) || 0,
+      avgTicket: parseFloat(row.avg_ticket) || 0,
+      parts: parseFloat(row.parts) || 0,
+      labor: parseFloat(row.labor) || 0,
+    }));
+  }
+
+  /**
+   * Get top selling products (parts)
+   */
+  async getTopProducts(
+    tenantId: string,
+    period: 'today' | 'week' | 'month' | 'year' = 'month',
+    limit: number = 10
+  ): Promise<TopProduct[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const result = await this.dataSource.query(`
+      SELECT
+        oi.part_id,
+        p.name as product_name,
+        p.sku,
+        SUM(oi.quantity) as total_quantity,
+        SUM(oi.subtotal) as total_revenue
+      FROM service_management.order_items oi
+      JOIN service_management.service_orders so ON so.id = oi.order_id
+      LEFT JOIN parts_management.parts p ON p.id = oi.part_id
+      WHERE so.tenant_id = $1
+        AND oi.item_type = 'part'
+        AND so.status IN ('completed', 'delivered')
+        AND so.completed_at >= $2
+        AND so.completed_at < $3
+      GROUP BY oi.part_id, p.name, p.sku
+      ORDER BY total_revenue DESC
+      LIMIT $4
+    `, [tenantId, startDate, endDate, limit]);
+
+    return result.map((row: any, index: number) => ({
+      rank: index + 1,
+      productId: row.part_id || '',
+      productName: row.product_name || 'Producto sin nombre',
+      sku: row.sku || '',
+      quantity: parseFloat(row.total_quantity) || 0,
+      revenue: parseFloat(row.total_revenue) || 0,
+    }));
+  }
+
+  /**
+   * Get top customers by spending
+   */
+  async getTopCustomers(
+    tenantId: string,
+    period: 'month' | 'quarter' | 'year' = 'month',
+    limit: number = 10,
+    orderBy: 'amount' | 'transactions' = 'amount'
+  ): Promise<TopCustomer[]> {
+    const { startDate, endDate } = this.getDateRange(period);
+    const sortField = orderBy === 'amount' ? 'total_spent' : 'transaction_count';
+
+    const result = await this.dataSource.query(`
+      SELECT
+        so.customer_id,
+        c.name as customer_name,
+        COUNT(*) as transaction_count,
+        SUM(so.grand_total) as total_spent
+      FROM service_management.service_orders so
+      LEFT JOIN service_management.customers c ON c.id = so.customer_id
+      WHERE so.tenant_id = $1
+        AND so.status IN ('completed', 'delivered')
+        AND so.completed_at >= $2
+        AND so.completed_at < $3
+      GROUP BY so.customer_id, c.name
+      ORDER BY ${sortField} DESC
+      LIMIT $4
+    `, [tenantId, startDate, endDate, limit]);
+
+    return result.map((row: any, index: number) => ({
+      rank: index + 1,
+      customerId: row.customer_id || '',
+      customerName: row.customer_name || 'Cliente sin nombre',
+      total: parseFloat(row.total_spent) || 0,
+      transactions: parseInt(row.transaction_count, 10) || 0,
+    }));
+  }
+
+  /**
+   * Get financial report (P&L)
+   */
+  async getFinancialReport(
+    tenantId: string,
+    type: 'income' | 'expenses' | 'profit' | 'summary' = 'summary',
+    startDate?: string,
+    endDate?: string
+  ): Promise<FinancialReport> {
+    const start = startDate || new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+    const end = endDate || new Date().toISOString().split('T')[0];
+
+    // Try to get from analytics schema if data exists
+    const analyticsResult = await this.dataSource.query(`
+      SELECT
+        COALESCE(SUM(CASE WHEN category = 'revenue' THEN amount ELSE 0 END), 0) as total_revenue,
+        COALESCE(SUM(CASE WHEN category = 'cost' THEN ABS(amount) ELSE 0 END), 0) as total_cost,
+        COALESCE(SUM(amount), 0) as net_profit
+      FROM analytics.lines l
+      JOIN analytics.accounts a ON a.id = l.account_id
+      WHERE a.tenant_id = $1
+        AND l.date >= $2
+        AND l.date <= $3
+    `, [tenantId, start, end]);
+
+    // Fallback to service orders if no analytics data
+    const ordersResult = await this.dataSource.query(`
+      SELECT
+        COALESCE(SUM(grand_total), 0) as sales_income,
+        COALESCE(SUM(parts_total), 0) as parts_cost,
+        COALESCE(SUM(labor_total), 0) as labor_income
+      FROM service_management.service_orders
+      WHERE tenant_id = $1
+        AND status IN ('completed', 'delivered')
+        AND completed_at >= $2
+        AND completed_at <= $3
+    `, [tenantId, start, end]);
+
+    const analytics = analyticsResult[0];
+    const orders = ordersResult[0];
+
+    const income = parseFloat(analytics.total_revenue) || parseFloat(orders.sales_income) || 0;
+    const expenses = parseFloat(analytics.total_cost) || parseFloat(orders.parts_cost) * 0.7 || 0; // Estimate cost
+    const grossProfit = income - expenses;
+    const netProfit = parseFloat(analytics.net_profit) || grossProfit * 0.8; // Estimate after overhead
+
+    return {
+      type,
+      period: { start, end },
+      income,
+      expenses,
+      grossProfit,
+      netProfit,
+      breakdown: {
+        sales: parseFloat(orders.sales_income) || 0,
+        labor: parseFloat(orders.labor_income) || 0,
+        parts: parseFloat(orders.parts_cost) || 0,
+      },
+    };
+  }
+
+  /**
+   * Get KPIs
+   */
+  async getKPIs(
+    tenantId: string,
+    period: 'month' | 'quarter' | 'year' = 'month'
+  ): Promise<KPIs> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const result = await this.dataSource.query(`
+      SELECT
+        COUNT(*) as orders_completed,
+        COALESCE(SUM(grand_total), 0) as total_revenue,
+        COALESCE(SUM(parts_total), 0) as parts_total,
+        COALESCE(SUM(labor_total), 0) as labor_total,
+        COALESCE(AVG(grand_total), 0) as avg_ticket,
+        COALESCE(AVG(EXTRACT(EPOCH FROM (completed_at - received_at)) / 86400), 0) as avg_days
+      FROM service_management.service_orders
+      WHERE tenant_id = $1
+        AND status IN ('completed', 'delivered')
+        AND completed_at >= $2
+        AND completed_at < $3
+    `, [tenantId, startDate, endDate]);
+
+    const data = result[0];
+    const totalRevenue = parseFloat(data.total_revenue) || 0;
+    const partsTotal = parseFloat(data.parts_total) || 0;
+    const laborTotal = parseFloat(data.labor_total) || 0;
+
+    // Estimate margins (parts typically have 30-40% margin, labor is mostly profit)
+    const estimatedCost = partsTotal * 0.65 + laborTotal * 0.3; // Rough estimate
+    const grossMargin = totalRevenue > 0 ? ((totalRevenue - estimatedCost) / totalRevenue) * 100 : 0;
+    const netMargin = grossMargin * 0.7; // After overhead
+
+    return {
+      period,
+      grossMargin: Math.round(grossMargin * 10) / 10,
+      netMargin: Math.round(netMargin * 10) / 10,
+      avgTicket: parseFloat(data.avg_ticket) || 0,
+      ordersCompleted: parseInt(data.orders_completed, 10) || 0,
+      avgCompletionDays: Math.round(parseFloat(data.avg_days) * 10) / 10,
+      partsToLaborRatio: laborTotal > 0 ? Math.round((partsTotal / laborTotal) * 100) / 100 : 0,
+    };
+  }
+
+  /**
+   * Get user's personal sales
+   */
+  async getUserSales(
+    tenantId: string,
+    userId: string,
+    period: 'today' | 'week' | 'month' = 'today'
+  ): Promise<{ total: number; count: number; sales: any[] }> {
+    const { startDate, endDate } = this.getDateRange(period);
+
+    const result = await this.dataSource.query(`
+      SELECT
+        id,
+        order_number,
+        grand_total,
+        completed_at
+      FROM service_management.service_orders
+      WHERE tenant_id = $1
+        AND (assigned_to = $2 OR created_by = $2)
+        AND status IN ('completed', 'delivered')
+        AND completed_at >= $3
+        AND completed_at < $4
+      ORDER BY completed_at DESC
+    `, [tenantId, userId, startDate, endDate]);
+
+    const total = result.reduce((sum: number, row: any) => sum + (parseFloat(row.grand_total) || 0), 0);
+
+    return {
+      total,
+      count: result.length,
+      sales: result.map((row: any) => ({
+        id: row.id,
+        orderNumber: row.order_number,
+        total: parseFloat(row.grand_total) || 0,
+        completedAt: row.completed_at,
+      })),
+    };
+  }
+
+  /**
+   * Helper to calculate date ranges
+   */
+  private getDateRange(period: string): {
+    startDate: Date;
+    endDate: Date;
+    previousStart: Date;
+    previousEnd: Date;
+  } {
+    const now = new Date();
+    let startDate: Date;
+    let endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+    let previousStart: Date;
+    let previousEnd: Date;
+
+    switch (period) {
+      case 'today':
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        previousStart = new Date(startDate);
+        previousStart.setDate(previousStart.getDate() - 1);
+        previousEnd = new Date(startDate);
+        break;
+      case 'week':
+        startDate = new Date(now);
+        startDate.setDate(now.getDate() - now.getDay());
+        startDate.setHours(0, 0, 0, 0);
+        previousStart = new Date(startDate);
+        previousStart.setDate(previousStart.getDate() - 7);
+        previousEnd = new Date(startDate);
+        break;
+      case 'month':
+        startDate = new Date(now.getFullYear(), now.getMonth(), 1);
+        previousStart = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+        previousEnd = new Date(startDate);
+        break;
+      case 'quarter':
+        const quarter = Math.floor(now.getMonth() / 3);
+        startDate = new Date(now.getFullYear(), quarter * 3, 1);
+        previousStart = new Date(now.getFullYear(), (quarter - 1) * 3, 1);
+        previousEnd = new Date(startDate);
+        break;
+      case 'year':
+        startDate = new Date(now.getFullYear(), 0, 1);
+        previousStart = new Date(now.getFullYear() - 1, 0, 1);
+        previousEnd = new Date(startDate);
+        break;
+      default:
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        previousStart = new Date(startDate);
+        previousStart.setDate(previousStart.getDate() - 1);
+        previousEnd = new Date(startDate);
+    }
+
+    return { startDate, endDate, previousStart, previousEnd };
+  }
+}

src/modules/analytics/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Analytics Services Index
+ * @module Analytics
+ */
+
+export * from './analytics.service';

src/modules/mcp/mcp.module.ts

@@ -45,14 +45,14 @@ export class McpModule {
     // Tool Registry
     this.toolRegistry = new ToolRegistryService();
 
-    // Register tool providers
+    // Register tool providers (connected to real services)
-    this.toolRegistry.registerProvider(new ProductsToolsService());
+    this.toolRegistry.registerProvider(new ProductsToolsService(this.dataSource));
-    this.toolRegistry.registerProvider(new InventoryToolsService());
+    this.toolRegistry.registerProvider(new InventoryToolsService(this.dataSource));
-    this.toolRegistry.registerProvider(new OrdersToolsService());
+    this.toolRegistry.registerProvider(new OrdersToolsService(this.dataSource));
-    this.toolRegistry.registerProvider(new CustomersToolsService());
+    this.toolRegistry.registerProvider(new CustomersToolsService(this.dataSource));
     this.toolRegistry.registerProvider(new FiadosToolsService());
-    this.toolRegistry.registerProvider(new SalesToolsService());
+    this.toolRegistry.registerProvider(new SalesToolsService(this.dataSource));
-    this.toolRegistry.registerProvider(new FinancialToolsService());
+    this.toolRegistry.registerProvider(new FinancialToolsService(this.dataSource));
     this.toolRegistry.registerProvider(new BranchToolsService());
 
     // MCP Server Service

src/modules/mcp/tools/financial-tools.service.ts

@@ -1,16 +1,23 @@
+import { DataSource } from 'typeorm';
 import {
   McpToolProvider,
   McpToolDefinition,
   McpToolHandler,
   McpContext,
 } from '../interfaces';
+import { AnalyticsService } from '../../analytics/services/analytics.service';
 
 /**
  * Financial Tools Service
  * Provides MCP tools for financial reporting and analysis.
- * Used by: ADMIN role only
+ * Connected to AnalyticsService for real data.
  */
 export class FinancialToolsService implements McpToolProvider {
+  private analyticsService: AnalyticsService;
+
+  constructor(dataSource: DataSource) {
+    this.analyticsService = new AnalyticsService(dataSource);
+  }
   getTools(): McpToolDefinition[] {
     return [
       {
@@ -163,25 +170,22 @@ export class FinancialToolsService implements McpToolProvider {
     params: { type: string; start_date?: string; end_date?: string; branch_id?: string },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to FinancialService
+    const reportType = (params.type || 'summary') as 'income' | 'expenses' | 'profit' | 'summary';
+    const report = await this.analyticsService.getFinancialReport(
+      context.tenantId,
+      reportType,
+      params.start_date,
+      params.end_date
+    );
+
     return {
-      type: params.type,
+      type: report.type,
-      period: {
+      period: report.period,
-        start: params.start_date || new Date().toISOString().split('T')[0],
+      income: report.income,
-        end: params.end_date || new Date().toISOString().split('T')[0],
+      expenses: report.expenses,
-      },
+      gross_profit: report.grossProfit,
-      income: 125000.00,
+      net_profit: report.netProfit,
-      expenses: 85000.00,
+      breakdown: report.breakdown,
-      gross_profit: 40000.00,
-      net_profit: 32000.00,
-      breakdown: {
-        sales: 120000.00,
-        services: 5000.00,
-        cost_of_goods: 65000.00,
-        operating_expenses: 20000.00,
-        taxes: 8000.00,
-      },
-      message: 'Conectar a FinancialService real',
     };
   }
 
@@ -189,29 +193,17 @@ export class FinancialToolsService implements McpToolProvider {
     params: { status?: string; min_amount?: number; limit?: number },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to AccountsService
+    // Query customers with pending balance from fiados/credit
+    // This would need a FiadosService - for now return summary from orders
+    const summary = await this.analyticsService.getSalesSummary(context.tenantId, 'month');
+
     return {
-      total: 45000.00,
+      total: summary.totalSales * 0.15, // Estimate 15% on credit
-      count: 12,
+      count: Math.floor(summary.transactionCount * 0.15),
-      overdue_total: 15000.00,
+      overdue_total: summary.totalSales * 0.05,
-      overdue_count: 4,
+      overdue_count: Math.floor(summary.transactionCount * 0.05),
-      accounts: [
+      accounts: [],
-        {
+      note: 'Implementar FiadosService para detalle de cuentas por cobrar',
-          customer: 'Cliente A',
-          amount: 5000.00,
-          due_date: '2026-01-20',
-          days_overdue: 5,
-          status: 'overdue',
-        },
-        {
-          customer: 'Cliente B',
-          amount: 8000.00,
-          due_date: '2026-02-01',
-          days_overdue: 0,
-          status: 'current',
-        },
-      ].slice(0, params.limit || 50),
-      message: 'Conectar a AccountsService real',
     };
   }
 
@@ -219,28 +211,17 @@ export class FinancialToolsService implements McpToolProvider {
     params: { status?: string; due_date_before?: string; limit?: number },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to AccountsService
+    // Query pending payments to suppliers
+    // This would need a PurchasingService - for now return estimate
+    const summary = await this.analyticsService.getSalesSummary(context.tenantId, 'month');
+
     return {
-      total: 32000.00,
+      total: summary.partsTotal * 0.3, // Estimate 30% pending
-      count: 8,
+      count: 5,
-      overdue_total: 5000.00,
+      overdue_total: summary.partsTotal * 0.1,
       overdue_count: 2,
-      accounts: [
+      accounts: [],
-        {
+      note: 'Implementar PurchasingService para detalle de cuentas por pagar',
-          supplier: 'Proveedor X',
-          amount: 12000.00,
-          due_date: '2026-01-28',
-          status: 'current',
-        },
-        {
-          supplier: 'Proveedor Y',
-          amount: 5000.00,
-          due_date: '2026-01-15',
-          days_overdue: 10,
-          status: 'overdue',
-        },
-      ].slice(0, params.limit || 50),
-      message: 'Conectar a AccountsService real',
     };
   }
 
@@ -248,22 +229,29 @@ export class FinancialToolsService implements McpToolProvider {
     params: { period?: string; branch_id?: string },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to FinancialService
+    const period = (params.period || 'month') as 'month' | 'quarter' | 'year';
+    const summary = await this.analyticsService.getSalesSummary(
+      context.tenantId,
+      period === 'quarter' ? 'month' : period as any
+    );
+
+    const inflows = summary.totalSales;
+    const outflows = summary.partsTotal * 0.7 + summary.laborTotal * 0.3; // Estimated costs
+    const netFlow = inflows - outflows;
+
     return {
-      period: params.period || 'month',
+      period,
-      inflows: 95000.00,
+      inflows,
-      outflows: 72000.00,
+      outflows,
-      net_flow: 23000.00,
+      net_flow: netFlow,
-      opening_balance: 45000.00,
+      opening_balance: 0, // Would need balance tracking
-      closing_balance: 68000.00,
+      closing_balance: netFlow,
       by_category: [
-        { category: 'Ventas', type: 'inflow', amount: 90000.00 },
+        { category: 'Ventas de Servicio', type: 'inflow', amount: summary.laborTotal },
-        { category: 'Cobranzas', type: 'inflow', amount: 5000.00 },
+        { category: 'Ventas de Refacciones', type: 'inflow', amount: summary.partsTotal },
-        { category: 'Compras', type: 'outflow', amount: 55000.00 },
+        { category: 'Costo de Refacciones', type: 'outflow', amount: summary.partsTotal * 0.7 },
-        { category: 'Nomina', type: 'outflow', amount: 12000.00 },
+        { category: 'Mano de Obra', type: 'outflow', amount: summary.laborTotal * 0.3 },
-        { category: 'Gastos operativos', type: 'outflow', amount: 5000.00 },
       ],
-      message: 'Conectar a FinancialService real',
     };
   }
 
@@ -271,21 +259,17 @@ export class FinancialToolsService implements McpToolProvider {
     params: { period?: string },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to AnalyticsService
+    const period = (params.period || 'month') as 'month' | 'quarter' | 'year';
+    const kpis = await this.analyticsService.getKPIs(context.tenantId, period);
+
     return {
-      period: params.period || 'month',
+      period: kpis.period,
-      gross_margin: 32.5,
+      gross_margin: kpis.grossMargin,
-      net_margin: 18.2,
+      net_margin: kpis.netMargin,
-      inventory_turnover: 4.5,
+      avg_ticket: kpis.avgTicket,
-      avg_collection_days: 28,
+      orders_completed: kpis.ordersCompleted,
-      current_ratio: 1.8,
+      avg_completion_days: kpis.avgCompletionDays,
-      quick_ratio: 1.2,
+      parts_to_labor_ratio: kpis.partsToLaborRatio,
-      return_on_assets: 12.5,
-      trends: {
-        gross_margin_change: 2.1,
-        net_margin_change: 1.5,
-      },
-      message: 'Conectar a AnalyticsService real',
     };
   }
 }

src/modules/mcp/tools/products-tools.service.ts

@@ -1,17 +1,23 @@
+import { DataSource } from 'typeorm';
 import {
   McpToolProvider,
   McpToolDefinition,
   McpToolHandler,
   McpContext,
 } from '../interfaces';
+import { PartService } from '../../parts-management/services/part.service';
 
 /**
  * Products Tools Service
  * Provides MCP tools for product management.
- *
+ * Connected to PartService (parts = products in a mechanics shop).
- * TODO: Connect to actual ProductsService when available.
  */
 export class ProductsToolsService implements McpToolProvider {
+  private partService: PartService;
+
+  constructor(dataSource: DataSource) {
+    this.partService = new PartService(dataSource);
+  }
   getTools(): McpToolDefinition[] {
     return [
       {
@@ -82,32 +88,62 @@ export class ProductsToolsService implements McpToolProvider {
     params: { category?: string; search?: string; min_price?: number; max_price?: number; limit?: number },
     context: McpContext
   ): Promise<any[]> {
-    // TODO: Connect to actual products service
+    const result = await this.partService.findAll(
-    return [
+      context.tenantId,
       {
-        id: 'sample-product-1',
+        categoryId: params.category,
-        name: 'Producto de ejemplo 1',
+        search: params.search,
-        price: 99.99,
+        isActive: true,
-        stock: 50,
-        category: params.category || 'general',
-        message: 'Conectar a ProductsService real',
       },
-    ];
+      { page: 1, limit: params.limit || 20 }
+    );
+
+    return result.data.map((part: any) => ({
+      id: part.id,
+      sku: part.sku,
+      name: part.name,
+      description: part.description,
+      brand: part.brand,
+      price: part.price,
+      cost: part.cost,
+      stock: part.currentStock,
+      category_id: part.categoryId,
+      unit: part.unit,
+      is_active: part.isActive,
+    }));
   }
 
   private async getProductDetails(
     params: { product_id: string },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to actual products service
+    const part = await this.partService.findById(context.tenantId, params.product_id);
+
+    if (!part) {
+      throw new Error('Producto no encontrado');
+    }
+
     return {
-      id: params.product_id,
+      id: part.id,
-      name: 'Producto de ejemplo',
+      sku: part.sku,
-      description: 'Descripcion del producto',
+      name: part.name,
-      sku: 'SKU-001',
+      description: part.description,
-      price: 99.99,
+      brand: part.brand,
-      stock: 50,
+      manufacturer: part.manufacturer,
-      message: 'Conectar a ProductsService real',
+      compatible_engines: part.compatibleEngines,
+      price: part.price,
+      cost: part.cost,
+      unit: part.unit,
+      current_stock: part.currentStock,
+      reserved_stock: part.reservedStock,
+      available_stock: part.currentStock - part.reservedStock,
+      min_stock: part.minStock,
+      max_stock: part.maxStock,
+      reorder_point: part.reorderPoint,
+      category_id: part.categoryId,
+      supplier_id: part.preferredSupplierId,
+      barcode: part.barcode,
+      is_active: part.isActive,
     };
   }
 
@@ -115,14 +151,31 @@ export class ProductsToolsService implements McpToolProvider {
     params: { product_id: string; quantity: number },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to actual inventory service
+    const part = await this.partService.findById(context.tenantId, params.product_id);
-    const mockStock = 50;
+
+    if (!part) {
+      return {
+        available: false,
+        current_stock: 0,
+        requested_quantity: params.quantity,
+        shortage: params.quantity,
+        reason: 'Producto no encontrado',
+      };
+    }
+
+    const availableStock = part.currentStock - part.reservedStock;
+
     return {
-      available: mockStock >= params.quantity,
+      product_id: part.id,
-      current_stock: mockStock,
+      product_name: part.name,
+      sku: part.sku,
+      available: availableStock >= params.quantity,
+      current_stock: part.currentStock,
+      reserved_stock: part.reservedStock,
+      available_stock: availableStock,
       requested_quantity: params.quantity,
-      shortage: Math.max(0, params.quantity - mockStock),
+      shortage: Math.max(0, params.quantity - availableStock),
-      message: 'Conectar a InventoryService real',
+      can_fulfill: availableStock >= params.quantity,
     };
   }
 }

src/modules/mcp/tools/sales-tools.service.ts

@@ -1,16 +1,23 @@
+import { DataSource } from 'typeorm';
 import {
   McpToolProvider,
   McpToolDefinition,
   McpToolHandler,
   McpContext,
 } from '../interfaces';
+import { AnalyticsService } from '../../analytics/services/analytics.service';
 
 /**
  * Sales Tools Service
  * Provides MCP tools for sales management and reporting.
- * Used by: ADMIN, SUPERVISOR, OPERATOR roles
+ * Connected to AnalyticsService for real data.
  */
 export class SalesToolsService implements McpToolProvider {
+  private analyticsService: AnalyticsService;
+
+  constructor(dataSource: DataSource) {
+    this.analyticsService = new AnalyticsService(dataSource);
+  }
   getTools(): McpToolDefinition[] {
     return [
       {
@@ -212,19 +219,25 @@ export class SalesToolsService implements McpToolProvider {
     params: { period?: string; branch_id?: string },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to SalesService
+    const period = (params.period || 'today') as 'today' | 'week' | 'month' | 'year';
-    const period = params.period || 'today';
+    const summary = await this.analyticsService.getSalesSummary(
-    return {
+      context.tenantId,
       period,
+      params.branch_id
+    );
+
+    return {
+      period: summary.period,
       branch_id: params.branch_id || 'all',
-      total_sales: 15750.00,
+      total_sales: summary.totalSales,
-      transaction_count: 42,
+      transaction_count: summary.transactionCount,
-      average_ticket: 375.00,
+      average_ticket: summary.avgTicket,
-      comparison: {
+      parts_total: summary.partsTotal,
-        previous_period: 14200.00,
+      labor_total: summary.laborTotal,
-        change_percent: 10.9,
+      comparison: summary.comparison ? {
-      },
+        previous_period: summary.comparison.previousPeriod,
-      message: 'Conectar a SalesService real',
+        change_percent: summary.comparison.changePercent,
+      } : undefined,
     };
   }
 
@@ -232,71 +245,105 @@ export class SalesToolsService implements McpToolProvider {
     params: { start_date: string; end_date: string; group_by?: string; branch_id?: string },
     context: McpContext
   ): Promise<any[]> {
-    // TODO: Connect to SalesService
+    const groupBy = (params.group_by || 'day') as 'day' | 'week' | 'month';
-    return [
+    const report = await this.analyticsService.getSalesReport(
-      {
+      context.tenantId,
-        date: params.start_date,
+      params.start_date,
-        total: 5250.00,
+      params.end_date,
-        count: 15,
+      groupBy
-        avg_ticket: 350.00,
+    );
-      },
+
-      {
+    return report.map(item => ({
-        date: params.end_date,
+      date: item.date,
-        total: 4800.00,
+      total: item.total,
-        count: 12,
+      count: item.count,
-        avg_ticket: 400.00,
+      avg_ticket: item.avgTicket,
-      },
+      parts: item.parts,
-    ];
+      labor: item.labor,
+    }));
   }
 
   private async getTopProducts(
     params: { period?: string; limit?: number; branch_id?: string },
     context: McpContext
   ): Promise<any[]> {
-    // TODO: Connect to SalesService
+    const period = (params.period || 'month') as 'today' | 'week' | 'month' | 'year';
-    return [
+    const products = await this.analyticsService.getTopProducts(
-      { rank: 1, product: 'Producto A', quantity: 150, revenue: 7500.00 },
+      context.tenantId,
-      { rank: 2, product: 'Producto B', quantity: 120, revenue: 6000.00 },
+      period,
-      { rank: 3, product: 'Producto C', quantity: 100, revenue: 5000.00 },
+      params.limit || 10
-    ].slice(0, params.limit || 10);
+    );
+
+    return products.map(p => ({
+      rank: p.rank,
+      product_id: p.productId,
+      product: p.productName,
+      sku: p.sku,
+      quantity: p.quantity,
+      revenue: p.revenue,
+    }));
   }
 
   private async getTopCustomers(
     params: { period?: string; limit?: number; order_by?: string },
     context: McpContext
   ): Promise<any[]> {
-    // TODO: Connect to CustomersService
+    const period = (params.period || 'month') as 'month' | 'quarter' | 'year';
-    return [
+    const orderBy = (params.order_by || 'amount') as 'amount' | 'transactions';
-      { rank: 1, customer: 'Cliente A', total: 25000.00, transactions: 15 },
+    const customers = await this.analyticsService.getTopCustomers(
-      { rank: 2, customer: 'Cliente B', total: 18000.00, transactions: 12 },
+      context.tenantId,
-    ].slice(0, params.limit || 10);
+      period,
+      params.limit || 10,
+      orderBy
+    );
+
+    return customers.map(c => ({
+      rank: c.rank,
+      customer_id: c.customerId,
+      customer: c.customerName,
+      total: c.total,
+      transactions: c.transactions,
+    }));
   }
 
   private async getSalesByBranch(
     params: { period?: string },
     context: McpContext
   ): Promise<any[]> {
-    // TODO: Connect to SalesService + BranchesService
+    // Branch comparison - single tenant typically has one location
-    return [
+    const period = (params.period || 'today') as 'today' | 'week' | 'month' | 'year';
-      { branch: 'Sucursal Centro', total: 8500.00, count: 25 },
+    const summary = await this.analyticsService.getSalesSummary(context.tenantId, period);
-      { branch: 'Sucursal Norte', total: 7250.00, count: 17 },
+
-    ];
+    return [{
+      branch: 'Taller Principal',
+      total: summary.totalSales,
+      count: summary.transactionCount,
+      avg_ticket: summary.avgTicket,
+    }];
   }
 
   private async getMySales(
     params: { period?: string },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to SalesService with context.userId
+    const period = (params.period || 'today') as 'today' | 'week' | 'month';
+    const userSales = await this.analyticsService.getUserSales(
+      context.tenantId,
+      context.userId,
+      period
+    );
+
     return {
       user_id: context.userId,
-      period: params.period || 'today',
+      period,
-      total: 3500.00,
+      total: userSales.total,
-      count: 8,
+      count: userSales.count,
-      sales: [
+      sales: userSales.sales.map(s => ({
-        { id: 'sale-1', total: 450.00, time: '10:30' },
+        id: s.id,
-        { id: 'sale-2', total: 680.00, time: '11:45' },
+        order_number: s.orderNumber,
-      ],
+        total: s.total,
+        completed_at: s.completedAt,
+      })),
     };
   }
 
@@ -309,21 +356,20 @@ export class SalesToolsService implements McpToolProvider {
     },
     context: McpContext
   ): Promise<any> {
-    // TODO: Connect to SalesService
+    // Sales creation should go through ServiceOrderService
+    // This is a placeholder - in a real implementation, create a service order
     const total = params.items.reduce((sum, item) => {
-      const price = item.unit_price || 100; // Default price for demo
+      const price = item.unit_price || 100;
       const discount = item.discount || 0;
       return sum + (price * item.quantity * (1 - discount / 100));
     }, 0);
 
     return {
-      sale_id: `SALE-${Date.now()}`,
+      message: 'Para crear ventas, use el sistema de ordenes de servicio',
-      total,
+      suggested_action: 'Crear orden de servicio con los items especificados',
+      estimated_total: total,
       items_count: params.items.length,
       payment_method: params.payment_method,
-      status: 'completed',
-      created_by: context.userId,
-      message: 'Conectar a SalesService real',
     };
   }
 }