@fullqueso/mcp-bc-gastos 1.17.0 → 1.19.0

package/tools/inventario/inventory-change.js

@@ -0,0 +1,386 @@
+import { resolveStores } from '../../config/company-config.js';
+import { logger } from '../../utils/logger.js';
+import { isInventoryCategory } from './shared/cost-calculator.js';
+
+export const inventoryChangeTool = {
+  name: 'get_inventory_change',
+  description:
+    'Cambio de inventario WoW (semana) o MoM (mes). Reconstruye inventario de apertura/cierre por período, desglosado por itemCategoryCode y inventoryPostingGroupCode. Muestra movimientos por tipo (compras, ventas, ajustes, ensamblaje). Máximo 12 períodos.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      store: {
+        type: 'string',
+        enum: ['FQ01', 'FQ28', 'FQ88'],
+        description: 'Tienda a consultar.',
+      },
+      period: {
+        type: 'string',
+        enum: ['week', 'month'],
+        description: 'Tipo de período: week (lunes-domingo) o month (mes calendario).',
+      },
+      periods_back: {
+        type: 'number',
+        description: 'Cantidad de períodos a analizar (default: 4, máximo: 12).',
+      },
+      item_category: {
+        type: 'string',
+        description: 'Filtrar por itemCategoryCode (e.g. TERMINADO, INSUMO).',
+      },
+      classification: {
+        type: 'string',
+        description: 'Filtrar por inventoryPostingGroupCode (e.g. CONGELADOS, IMPORTADO, LOCAL).',
+      },
+    },
+    required: ['store', 'period'],
+  },
+};
+
+export async function handleInventoryChange(bcClient, args) {
+  const storeParam = args.store;
+  if (!storeParam) throw new Error('Parámetro requerido: store');
+  if (!args.period) throw new Error('Parámetro requerido: period');
+
+  const stores = resolveStores([storeParam]);
+  const store = stores[0];
+  const companyId = store.companyId;
+
+  const periodsBack = Math.min(args.periods_back || 4, 12);
+  const today = new Date();
+  const todayStr = today.toISOString().split('T')[0];
+
+  // Compute period boundaries
+  const periods = buildPeriods(args.period, periodsBack, today);
+  const earliestStart = periods[0].start;
+
+  // Fetch items
+  const itemFilters = [];
+  if (args.item_category) {
+    itemFilters.push(`itemCategoryCode eq '${args.item_category}'`);
+  }
+  if (args.classification) {
+    itemFilters.push(`inventoryPostingGroupCode eq '${args.classification}'`);
+  }
+
+  const itemParams = {
+    $select: 'number,displayName,itemCategoryCode,inventoryPostingGroupCode,unitCost,inventory',
+  };
+  if (itemFilters.length > 0) {
+    itemParams.$filter = itemFilters.join(' and ');
+  }
+
+  const itemUrl = bcClient.buildApiUrl(companyId, 'items', itemParams);
+  const items = await bcClient.apiCallAllPages(itemUrl);
+  logger.info(`${store.code}: ${items.length} items fetched`);
+
+  // Exclude items without inventoryPostingGroupCode and FQ-* categories — not real inventory
+  const inventoryItems = items.filter((item) =>
+    item.inventoryPostingGroupCode && isInventoryCategory(item.itemCategoryCode),
+  );
+  const excludedCount = items.length - inventoryItems.length;
+  if (excludedCount > 0) {
+    logger.info(`${store.code}: excluded ${excludedCount} items without inventoryPostingGroupCode`);
+  }
+
+  // Build item lookup
+  const itemLookup = {};
+  for (const item of inventoryItems) {
+    itemLookup[item.number] = {
+      name: item.displayName,
+      category: item.itemCategoryCode || 'SIN_CATEGORIA',
+      classification: item.inventoryPostingGroupCode,
+      unit_cost: item.unitCost || 0,
+      current_qty: item.inventory || 0,
+    };
+  }
+
+  const itemNumbers = new Set(Object.keys(itemLookup));
+
+  // Fetch all ledger entries for the full range
+  const ledgerFilters = [
+    `postingDate ge ${earliestStart}`,
+    `postingDate le ${todayStr}`,
+  ];
+
+  const ledgerUrl = bcClient.buildApiUrl(companyId, 'itemLedgerEntries', {
+    $filter: ledgerFilters.join(' and '),
+    $select: 'itemNumber,quantity,postingDate,entryType',
+  });
+
+  let entries = await bcClient.apiCallAllPages(ledgerUrl);
+  logger.info(`${store.code}: ${entries.length} ledger entries in range ${earliestStart} to ${todayStr}`);
+
+  // Filter to relevant items (if category/classification was applied)
+  if (itemFilters.length > 0) {
+    entries = entries.filter((e) => itemNumbers.has(e.itemNumber));
+    logger.info(`Filtered to ${entries.length} entries for selected items`);
+  }
+
+  // Bucket entries into periods
+  const periodEntries = periods.map(() => []);
+  for (const e of entries) {
+    const date = e.postingDate;
+    for (let i = 0; i < periods.length; i++) {
+      if (date >= periods[i].start && date <= periods[i].end) {
+        periodEntries[i].push(e);
+        break;
+      }
+    }
+  }
+
+  // Compute net change per item per period (for reconstruction)
+  // netChangePerItem[periodIdx][itemNumber] = sum of quantity
+  const netChangePerItem = periods.map(() => ({}));
+  for (let i = 0; i < periods.length; i++) {
+    for (const e of periodEntries[i]) {
+      netChangePerItem[i][e.itemNumber] = (netChangePerItem[i][e.itemNumber] || 0) + (e.quantity || 0);
+    }
+  }
+
+  // Reconstruct closing/opening per item per period, walking backwards
+  // closingQty[periodIdx][itemNumber] = inventory at end of period
+  const closingQty = periods.map(() => ({}));
+  const openingQty = periods.map(() => ({}));
+
+  const lastIdx = periods.length - 1;
+
+  // Last period closing = current inventory
+  for (const [itemNo, info] of Object.entries(itemLookup)) {
+    closingQty[lastIdx][itemNo] = info.current_qty;
+  }
+
+  // Walk backwards
+  for (let i = lastIdx; i >= 0; i--) {
+    for (const itemNo of itemNumbers) {
+      const closing = closingQty[i][itemNo] || 0;
+      const netChange = netChangePerItem[i][itemNo] || 0;
+      const opening = closing - netChange;
+      openingQty[i][itemNo] = opening;
+
+      // Closing of previous period = opening of this period
+      if (i > 0) {
+        closingQty[i - 1][itemNo] = opening;
+      }
+    }
+  }
+
+  // Build period results
+  const periodResults = [];
+  for (let i = 0; i < periods.length; i++) {
+    const p = periods[i];
+    const pEntries = periodEntries[i];
+
+    // Classify movements by item
+    const movementsByItem = {};
+    for (const e of pEntries) {
+      if (!movementsByItem[e.itemNumber]) {
+        movementsByItem[e.itemNumber] = { purchases_in: 0, sales_out: 0, adjustments: 0, assembly: 0, other: 0 };
+      }
+      const m = movementsByItem[e.itemNumber];
+      const qty = e.quantity || 0;
+
+      switch (e.entryType) {
+        case 'Purchase':
+          m.purchases_in += qty;
+          break;
+        case 'Sale':
+          m.sales_out += qty;
+          break;
+        case 'Positive_x0020_Adjmt_x002E_':
+        case 'Negative_x0020_Adjmt_x002E_':
+          m.adjustments += qty;
+          break;
+        case 'Assembly_x0020_Output':
+        case 'Assembly_x0020_Consumption':
+          m.assembly += qty;
+          break;
+        default:
+          m.other += qty;
+          break;
+      }
+    }
+
+    // Aggregate by category and classification
+    const byCategory = {};
+    const byClassification = {};
+    let totalOpening = 0;
+    let totalClosing = 0;
+    const totalMovements = { purchases_in: 0, sales_out: 0, adjustments: 0, assembly: 0, other: 0 };
+
+    for (const itemNo of itemNumbers) {
+      const info = itemLookup[itemNo];
+      const cat = info.category;
+      const cls = info.classification;
+      const opQty = openingQty[i][itemNo] || 0;
+      const clQty = closingQty[i][itemNo] || 0;
+      const mv = movementsByItem[itemNo] || { purchases_in: 0, sales_out: 0, adjustments: 0, assembly: 0, other: 0 };
+
+      totalOpening += opQty;
+      totalClosing += clQty;
+      for (const k of Object.keys(totalMovements)) totalMovements[k] += mv[k];
+
+      // by_category
+      if (!byCategory[cat]) {
+        byCategory[cat] = { opening_qty: 0, closing_qty: 0, movements: { purchases_in: 0, sales_out: 0, adjustments: 0, assembly: 0, other: 0 } };
+      }
+      byCategory[cat].opening_qty += opQty;
+      byCategory[cat].closing_qty += clQty;
+      for (const k of Object.keys(totalMovements)) byCategory[cat].movements[k] += mv[k];
+
+      // by_classification
+      if (!byClassification[cls]) {
+        byClassification[cls] = { opening_qty: 0, closing_qty: 0, movements: { purchases_in: 0, sales_out: 0, adjustments: 0, assembly: 0, other: 0 } };
+      }
+      byClassification[cls].opening_qty += opQty;
+      byClassification[cls].closing_qty += clQty;
+      for (const k of Object.keys(totalMovements)) byClassification[cls].movements[k] += mv[k];
+    }
+
+    // Finalize groups with net_change and change_pct
+    for (const group of Object.values(byCategory)) {
+      finalizeGroup(group);
+    }
+    for (const group of Object.values(byClassification)) {
+      finalizeGroup(group);
+    }
+
+    const totalNetChange = round5(totalClosing - totalOpening);
+    periodResults.push({
+      label: p.label,
+      start: p.start,
+      end: p.end,
+      is_partial: p.isPartial || false,
+      by_category: byCategory,
+      by_classification: byClassification,
+      totals: {
+        opening_qty: round5(totalOpening),
+        closing_qty: round5(totalClosing),
+        net_change: totalNetChange,
+        change_pct: totalOpening !== 0 ? round2((totalNetChange / Math.abs(totalOpening)) * 100) : null,
+        movements: roundMovements(totalMovements),
+      },
+    });
+  }
+
+  // Trend summary
+  const trendByCategory = buildTrendSummary(periodResults, 'by_category');
+  const trendByClassification = buildTrendSummary(periodResults, 'by_classification');
+
+  return {
+    store: store.code,
+    store_name: store.name,
+    period_type: args.period,
+    periods_analyzed: periods.length,
+    note: 'Inventario de apertura reconstruido restando movimientos desde inventario actual hacia atrás. sales_out es negativo (salida). adjustments incluye positivos y negativos.',
+    periods: periodResults,
+    trend_summary: {
+      by_category: trendByCategory,
+      by_classification: trendByClassification,
+    },
+  };
+}
+
+// --- Helpers ---
+
+function buildPeriods(type, count, today) {
+  const periods = [];
+  const todayStr = today.toISOString().split('T')[0];
+
+  if (type === 'month') {
+    for (let i = 0; i < count; i++) {
+      const d = new Date(today);
+      d.setDate(1);
+      d.setMonth(d.getMonth() - i);
+      const start = d.toISOString().split('T')[0];
+
+      const endD = new Date(d);
+      endD.setMonth(endD.getMonth() + 1);
+      endD.setDate(endD.getDate() - 1);
+      let end = endD.toISOString().split('T')[0];
+      const isPartial = end > todayStr;
+      if (isPartial) end = todayStr;
+
+      const label = start.substring(0, 7) + (isPartial ? ' (parcial)' : '');
+      periods.unshift({ label, start, end, isPartial });
+    }
+  } else {
+    // week — Monday to Sunday
+    const dayOfWeek = today.getDay();
+    const mondayOffset = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+    const thisMonday = new Date(today);
+    thisMonday.setDate(thisMonday.getDate() - mondayOffset);
+
+    for (let i = 0; i < count; i++) {
+      const monday = new Date(thisMonday);
+      monday.setDate(monday.getDate() - i * 7);
+      const sunday = new Date(monday);
+      sunday.setDate(sunday.getDate() + 6);
+
+      const start = monday.toISOString().split('T')[0];
+      let end = sunday.toISOString().split('T')[0];
+      const isPartial = end > todayStr;
+      if (isPartial) end = todayStr;
+
+      const label = `Sem ${start}` + (isPartial ? ' (parcial)' : '');
+      periods.unshift({ label, start, end, isPartial });
+    }
+  }
+
+  return periods;
+}
+
+function finalizeGroup(group) {
+  group.opening_qty = round5(group.opening_qty);
+  group.closing_qty = round5(group.closing_qty);
+  group.net_change = round5(group.closing_qty - group.opening_qty);
+  group.change_pct = group.opening_qty !== 0
+    ? round2((group.net_change / Math.abs(group.opening_qty)) * 100)
+    : null;
+  group.movements = roundMovements(group.movements);
+}
+
+function buildTrendSummary(periodResults, groupKey) {
+  const allGroups = new Set();
+  for (const p of periodResults) {
+    for (const g of Object.keys(p[groupKey])) allGroups.add(g);
+  }
+
+  const summary = {};
+  for (const group of allGroups) {
+    const changes = [];
+    for (const p of periodResults) {
+      if (p[groupKey][group] && p[groupKey][group].change_pct !== null) {
+        changes.push(p[groupKey][group].change_pct);
+      }
+    }
+    if (changes.length === 0) {
+      summary[group] = { direction: 'sin_datos', avg_change_pct: null };
+      continue;
+    }
+    const avg = round2(changes.reduce((s, c) => s + c, 0) / changes.length);
+    let direction = 'stable';
+    if (avg > 3) direction = 'growing';
+    else if (avg < -3) direction = 'shrinking';
+
+    summary[group] = { direction, avg_change_pct: avg };
+  }
+  return summary;
+}
+
+function roundMovements(m) {
+  return {
+    purchases_in: round5(m.purchases_in),
+    sales_out: round5(m.sales_out),
+    adjustments: round5(m.adjustments),
+    assembly: round5(m.assembly),
+    other: round5(m.other),
+  };
+}
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+function round5(n) {
+  return Math.round(n * 100000) / 100000;
+}

package/tools/inventario/inventory-levels.js

@@ -0,0 +1,214 @@
+import { resolveStores } from '../../config/company-config.js';
+import { logger } from '../../utils/logger.js';
+import { isInventoryCategory } from './shared/cost-calculator.js';
+
+export const inventoryLevelsTool = {
+  name: 'get_inventory_levels',
+  description:
+    'Niveles de inventario agrupados por itemCategoryCode y/o inventoryPostingGroupCode (congelados, importado, local). Soporta fecha de corte histórica (e.g. 1ero del mes post-ajuste). Devuelve matriz de clasificación con qty, costo, y top ítems por grupo.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      store: {
+        type: 'string',
+        enum: ['FQ01', 'FQ28', 'FQ88'],
+        description: 'Tienda a consultar.',
+      },
+      item_category: {
+        type: 'string',
+        description: 'Filtrar por itemCategoryCode (e.g. TERMINADO, INSUMO).',
+      },
+      classification: {
+        type: 'string',
+        description: 'Filtrar por inventoryPostingGroupCode (e.g. CONGELADOS, IMPORTADO, LOCAL).',
+      },
+      as_of_date: {
+        type: 'string',
+        description:
+          'Fecha de corte YYYY-MM-DD. Default: hoy. Si es fecha pasada, reconstruye inventario restando movimientos posteriores.',
+      },
+    },
+    required: ['store'],
+  },
+};
+
+export async function handleInventoryLevels(bcClient, args) {
+  const storeParam = args.store;
+  if (!storeParam) throw new Error('Parámetro requerido: store');
+
+  const stores = resolveStores([storeParam]);
+  const store = stores[0];
+  const companyId = store.companyId;
+
+  const today = new Date();
+  const todayStr = today.toISOString().split('T')[0];
+  const asOfDate = args.as_of_date || todayStr;
+  const isHistorical = asOfDate < todayStr;
+
+  // Fetch all items
+  const itemFilters = [];
+  if (args.item_category) {
+    itemFilters.push(`itemCategoryCode eq '${args.item_category}'`);
+  }
+  if (args.classification) {
+    itemFilters.push(`inventoryPostingGroupCode eq '${args.classification}'`);
+  }
+
+  const itemParams = {
+    $select: 'number,displayName,itemCategoryCode,inventoryPostingGroupCode,unitCost,unitPrice,inventory',
+  };
+  if (itemFilters.length > 0) {
+    itemParams.$filter = itemFilters.join(' and ');
+  }
+
+  const itemUrl = bcClient.buildApiUrl(companyId, 'items', itemParams);
+  let items = await bcClient.apiCallAllPages(itemUrl);
+  logger.info(`${store.code}: ${items.length} items fetched`);
+
+  // Build item map with current inventory
+  // Exclude items without inventoryPostingGroupCode — they are not real inventory
+  // (e.g. expense items like straws/cups that go direct to cost)
+  // Also exclude FQ-*/FQ_*/FQVENTA categories — sales/combo items, not inventory
+  const inventoryItems = items.filter((item) =>
+    item.inventoryPostingGroupCode && isInventoryCategory(item.itemCategoryCode),
+  );
+  const excludedCount = items.length - inventoryItems.length;
+  if (excludedCount > 0) {
+    logger.info(`${store.code}: excluded ${excludedCount} non-inventory items (no posting group or FQ-* category)`);
+  }
+
+  const itemMap = {};
+  for (const item of inventoryItems) {
+    itemMap[item.number] = {
+      number: item.number,
+      name: item.displayName,
+      category: item.itemCategoryCode || 'SIN_CATEGORIA',
+      classification: item.inventoryPostingGroupCode,
+      unit_cost: item.unitCost || 0,
+      unit_price: item.unitPrice || 0,
+      qty: item.inventory || 0,
+    };
+  }
+
+  // If historical, reconstruct inventory at as_of_date
+  if (isHistorical) {
+    const dayAfter = nextDay(asOfDate);
+    const ledgerFilters = [
+      `postingDate ge ${dayAfter}`,
+      `postingDate le ${todayStr}`,
+    ];
+
+    const ledgerUrl = bcClient.buildApiUrl(companyId, 'itemLedgerEntries', {
+      $filter: ledgerFilters.join(' and '),
+      $select: 'itemNumber,quantity',
+    });
+
+    const entries = await bcClient.apiCallAllPages(ledgerUrl);
+    logger.info(`${store.code}: ${entries.length} ledger entries after ${asOfDate} for reconstruction`);
+
+    // Build adjustment map: total movement after as_of_date per item
+    const adjustments = {};
+    for (const e of entries) {
+      adjustments[e.itemNumber] = (adjustments[e.itemNumber] || 0) + (e.quantity || 0);
+    }
+
+    // Reconstruct: historical = current - movements_after
+    for (const [itemNo, adj] of Object.entries(adjustments)) {
+      if (itemMap[itemNo]) {
+        itemMap[itemNo].qty = round5(itemMap[itemNo].qty - adj);
+      }
+    }
+  }
+
+  // Build classification matrix
+  const byCategory = {};
+  const byClassification = {};
+  const matrix = {};
+
+  for (const item of Object.values(itemMap)) {
+    const cat = item.category;
+    const cls = item.classification;
+    const costValue = round2(item.qty * item.unit_cost);
+
+    // by_category
+    if (!byCategory[cat]) {
+      byCategory[cat] = { item_count: 0, total_qty: 0, total_cost_value: 0, _items: [] };
+    }
+    byCategory[cat].item_count++;
+    byCategory[cat].total_qty = round5(byCategory[cat].total_qty + item.qty);
+    byCategory[cat].total_cost_value = round2(byCategory[cat].total_cost_value + costValue);
+    byCategory[cat]._items.push({ number: item.number, name: item.name, qty: item.qty, cost_value: costValue });
+
+    // by_classification
+    if (!byClassification[cls]) {
+      byClassification[cls] = { item_count: 0, total_qty: 0, total_cost_value: 0, _items: [] };
+    }
+    byClassification[cls].item_count++;
+    byClassification[cls].total_qty = round5(byClassification[cls].total_qty + item.qty);
+    byClassification[cls].total_cost_value = round2(byClassification[cls].total_cost_value + costValue);
+    byClassification[cls]._items.push({ number: item.number, name: item.name, qty: item.qty, cost_value: costValue });
+
+    // matrix: category → classification
+    if (!matrix[cat]) matrix[cat] = {};
+    if (!matrix[cat][cls]) {
+      matrix[cat][cls] = { item_count: 0, total_qty: 0, total_cost_value: 0 };
+    }
+    matrix[cat][cls].item_count++;
+    matrix[cat][cls].total_qty = round5(matrix[cat][cls].total_qty + item.qty);
+    matrix[cat][cls].total_cost_value = round2(matrix[cat][cls].total_cost_value + costValue);
+  }
+
+  // Add top 5 items per group, remove _items helper
+  for (const group of Object.values(byCategory)) {
+    group.top_items = group._items
+      .sort((a, b) => Math.abs(b.qty) - Math.abs(a.qty))
+      .slice(0, 5)
+      .map(({ number, name, qty, cost_value }) => ({ number, name, qty: round5(qty), cost_value: round2(cost_value) }));
+    delete group._items;
+  }
+  for (const group of Object.values(byClassification)) {
+    group.top_items = group._items
+      .sort((a, b) => Math.abs(b.qty) - Math.abs(a.qty))
+      .slice(0, 5)
+      .map(({ number, name, qty, cost_value }) => ({ number, name, qty: round5(qty), cost_value: round2(cost_value) }));
+    delete group._items;
+  }
+
+  // Grand totals
+  const allItems = Object.values(itemMap);
+  const grandTotal = {
+    categories: Object.keys(byCategory).length,
+    classifications: Object.keys(byClassification).length,
+    item_count: allItems.length,
+    total_qty: round5(allItems.reduce((s, i) => s + i.qty, 0)),
+    total_cost_value: round2(allItems.reduce((s, i) => s + i.qty * i.unit_cost, 0)),
+  };
+
+  return {
+    store: store.code,
+    store_name: store.name,
+    as_of_date: asOfDate,
+    is_historical: isHistorical,
+    note: isHistorical
+      ? 'Inventario histórico reconstruido restando movimientos posteriores a as_of_date. unitCost FIFO actual de BC. Excluye categorías FQ-* (venta/combos).'
+      : 'Inventario actual con unitCost FIFO de BC. Excluye categorías FQ-* (venta/combos).',
+    by_category: byCategory,
+    by_classification: byClassification,
+    matrix,
+    grand_total: grandTotal,
+  };
+}
+
+function nextDay(dateStr) {
+  const d = new Date(dateStr + 'T00:00:00');
+  d.setDate(d.getDate() + 1);
+  return d.toISOString().split('T')[0];
+}
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+function round5(n) {
+  return Math.round(n * 100000) / 100000;
+}

package/tools/inventario/item-card.js

@@ -1,5 +1,6 @@
 import { resolveStores } from '../../config/company-config.js';
 import { logger } from '../../utils/logger.js';
+import { getCalculatedCosts } from './shared/cost-calculator.js';
 
 export const itemCardTool = {
   name: 'get_item_card',
@@ -99,56 +100,6 @@ export async function handleItemCard(bcClient, args) {
   };
 }
 
-/**
- * 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;
 }