@fullqueso/mcp-bc-gastos 1.14.1 → 1.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullqueso/mcp-bc-gastos",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "description": "MCP server for Business Central operational expense analysis, bank reconciliation, POS reconciliation, accounts receivable/payable, multi-payment draft visibility, payroll, inventory cost analysis, and manager reports - Full Queso franchise stores",
   "main": "server.js",
   "bin": {

package/tools/inventario/item-card.js

@@ -4,7 +4,7 @@ import { logger } from '../../utils/logger.js';
 export const itemCardTool = {
   name: 'get_item_card',
   description:
-    'Datos maestros de ítems de inventario: unitCost, costingMethod, inventory qty, unitPrice, categoría. Filtra por número de ítem, búsqueda por nombre, o categoría.',
+    'Datos maestros de ítems de inventario: unitCost (BC), calculated_unit_cost (real desde últimas entradas), inventory qty, unitPrice, categoría. El calculated_unit_cost es más confiable que unitCost cuando hay entradas con fechas erróneas.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -64,25 +64,95 @@ export async function handleItemCard(bcClient, args) {
     data = data.filter((item) => item.displayName && item.displayName.toLowerCase().includes(search));
   }
 
-  const items = data.map((item) => ({
-    number: item.number,
-    name: item.displayName,
-    type: item.type,
-    category: item.itemCategoryCode || null,
-    unit_cost: round2(item.unitCost || 0),
-    unit_price: round2(item.unitPrice || 0),
-    inventory: round2(item.inventory || 0),
-    blocked: item.blocked || false,
-  }));
+  // Calculate real unit cost from recent inbound ledger entries
+  const itemNumbers = data.map((item) => item.number);
+  const calculatedCosts = await getCalculatedCosts(bcClient, companyId, itemNumbers);
+
+  const items = data.map((item) => {
+    const calc = calculatedCosts[item.number];
+    const bcCost = round5(item.unitCost || 0);
+    const calcCost = calc ? calc.unit_cost : bcCost;
+    const hasDiscrepancy = Math.abs(bcCost - calcCost) > 0.01;
+
+    return {
+      number: item.number,
+      name: item.displayName,
+      type: item.type,
+      category: item.itemCategoryCode || null,
+      unit_cost_bc: bcCost,
+      calculated_unit_cost: round5(calcCost),
+      cost_discrepancy: hasDiscrepancy,
+      unit_price: round2(item.unitPrice || 0),
+      margin_pct: item.unitPrice > 0 ? round2(((item.unitPrice - calcCost) / item.unitPrice) * 100) : 0,
+      inventory: round2(item.inventory || 0),
+      blocked: item.blocked || false,
+      ...(calc ? { cost_source: calc.source, cost_sample_size: calc.sample_size } : {}),
+    };
+  });
 
   return {
     store: store.code,
     store_name: store.name,
     total_items: items.length,
+    note: 'calculated_unit_cost = weighted avg from last 3 inbound entries (Assembly Output / Purchase). More reliable than unit_cost_bc when BC has entries with incorrect posting dates.',
     items,
   };
 }
 
+/**
+ * Fetch the most recent inbound entries per item and compute current unit cost.
+ * Uses the last 10 Assembly Output / Purchase entries (most recent cost, not historical avg).
+ * Excludes future-dated entries and Sales Returns.
+ */
+async function getCalculatedCosts(bcClient, companyId, itemNumbers) {
+  if (itemNumbers.length === 0) return {};
+
+  const results = {};
+  const todayStr = new Date().toISOString().split('T')[0];
+  const typeFilter = `(entryType eq 'Purchase' or entryType eq 'Assembly_x0020_Output' or entryType eq 'Positive_x0020_Adjmt_x002E_')`;
+
+  // Fetch per item (need $top per item, can't batch with $top)
+  const fetches = itemNumbers.map(async (itemNo) => {
+    const filter = `itemNumber eq '${itemNo}' and ${typeFilter} and postingDate le ${todayStr}`;
+    const url = bcClient.buildApiUrl(companyId, 'itemLedgerEntries', {
+      $filter: filter,
+      $select: 'itemNumber,quantity,costAmountActual,postingDate',
+      $orderby: 'postingDate desc',
+      $top: '10',
+    });
+    try {
+      const entries = await bcClient.apiCall(url);
+      if (entries.length === 0) return;
+
+      // Use last 3 inbound entries (most current cost)
+      const recent = entries.slice(0, 3);
+      const totalQty = recent.reduce((s, e) => s + (e.quantity || 0), 0);
+      const totalCost = recent.reduce((s, e) => s + (e.costAmountActual || 0), 0);
+      if (totalQty > 0) {
+        results[itemNo] = {
+          unit_cost: round5(totalCost / totalQty),
+          source: `last_3_inbound`,
+          sample_size: recent.length,
+          latest_date: recent[0].postingDate,
+        };
+      }
+    } catch (err) {
+      logger.info(`Cost calc failed for ${itemNo}: ${err.message}`);
+    }
+  });
+
+  // Run in batches of 5 to avoid rate limiting
+  for (let i = 0; i < fetches.length; i += 5) {
+    await Promise.all(fetches.slice(i, i + 5));
+  }
+
+  return results;
+}
+
 function round2(n) {
   return Math.round(n * 100) / 100;
 }
+
+function round5(n) {
+  return Math.round(n * 100000) / 100000;
+}