@fullqueso/mcp-bc-gastos 1.19.0 → 1.23.0

package/scripts/generate-month-closing-xlsx.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""Generate month-end bank closing workbook from generate_closing_journal JSON.
+
+Usage:
+    python3 generate-month-closing-xlsx.py <input.json> <output.xlsx>
+
+Input JSON shape: { state: {...}, journal: {...} }   (written by generate-closing-journal.js)
+Sheets:
+    - Resumen
+    - Asiento_<BANK> per bank in journal.banks
+    - Cuestionario (unknown line classifications)
+    - Confirmaciones (POS, intercompany, vendors confirmed/declined)
+"""
+
+import json
+import sys
+
+try:
+    from openpyxl import Workbook
+    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+    from openpyxl.utils import get_column_letter
+except ImportError:
+    print("Error: openpyxl required. pip3 install openpyxl", file=sys.stderr)
+    sys.exit(1)
+
+BOLD = Font(bold=True)
+BOLD_W = Font(bold=True, color="FFFFFF")
+HEADER_FILL = PatternFill(start_color="305496", end_color="305496", fill_type="solid")
+RESIDUAL_FILL = PatternFill(start_color="FFE699", end_color="FFE699", fill_type="solid")
+WARN_FILL = PatternFill(start_color="F4B084", end_color="F4B084", fill_type="solid")
+TOTAL_FILL = PatternFill(start_color="D9E2F3", end_color="D9E2F3", fill_type="solid")
+THIN = Border(bottom=Side(style="thin", color="BFBFBF"))
+NUM = '#,##0.00'
+
+
+def autosize(ws, widths):
+    for i, w in enumerate(widths, start=1):
+        ws.column_dimensions[get_column_letter(i)].width = w
+
+
+def write_header(ws, row, headers):
+    for i, h in enumerate(headers, start=1):
+        c = ws.cell(row=row, column=i, value=h)
+        c.font = BOLD_W
+        c.fill = HEADER_FILL
+        c.alignment = Alignment(horizontal="center")
+
+
+def sheet_resumen(wb, state, journal):
+    ws = wb.create_sheet("Resumen")
+    ws["A1"] = f"Cierre Mensual — {state.get('store')} {state.get('month')}"
+    ws["A1"].font = Font(bold=True, size=14)
+    ws["A2"] = f"Statement date: {state.get('statement_date')}"
+    ws["A3"] = f"Status: {state.get('status')}"
+    ws["A4"] = f"Generated: {state.get('updated_at')}"
+
+    row = 6
+    ws.cell(row=row, column=1, value="Banco").font = BOLD
+    ws.cell(row=row, column=2, value="GL").font = BOLD
+    ws.cell(row=row, column=3, value="Apertura").font = BOLD
+    ws.cell(row=row, column=4, value="Cierre Statement").font = BOLD
+    ws.cell(row=row, column=5, value="Cierre Calculado").font = BOLD
+    ws.cell(row=row, column=6, value="Diferencia").font = BOLD
+    ws.cell(row=row, column=7, value="Filas").font = BOLD
+    ws.cell(row=row, column=8, value="Balanceado").font = BOLD
+    row += 1
+    for b in journal.get("banks", []):
+        ws.cell(row=row, column=1, value=b["bank_account"])
+        ws.cell(row=row, column=2, value=b["gl_account"])
+        ws.cell(row=row, column=3, value=b["opening_balance"]).number_format = NUM
+        ws.cell(row=row, column=4, value=b["statement_ending"]).number_format = NUM
+        ws.cell(row=row, column=5, value=b["computed_ending"]).number_format = NUM
+        gap = ws.cell(row=row, column=6, value=b["gap_to_clearing"])
+        gap.number_format = NUM
+        if abs(b["gap_to_clearing"] or 0) > 0.5:
+            gap.fill = RESIDUAL_FILL
+        ws.cell(row=row, column=7, value=b["summary"]["rows"])
+        ws.cell(row=row, column=8, value="Sí" if b["summary"]["balanced"] else "NO")
+        row += 1
+
+    row += 1
+    ws.cell(row=row, column=1, value="Total Débito").font = BOLD
+    ws.cell(row=row, column=2, value=journal["totals"]["debit"]).number_format = NUM
+    row += 1
+    ws.cell(row=row, column=1, value="Total Crédito").font = BOLD
+    ws.cell(row=row, column=2, value=journal["totals"]["credit"]).number_format = NUM
+    row += 1
+    ws.cell(row=row, column=1, value="Balanceado global").font = BOLD
+    ws.cell(row=row, column=2, value="Sí" if journal.get("balanced") else "NO")
+
+    if journal.get("warnings"):
+        row += 2
+        ws.cell(row=row, column=1, value="Advertencias").font = BOLD
+        row += 1
+        for w in journal["warnings"]:
+            c = ws.cell(row=row, column=1, value=w)
+            c.fill = WARN_FILL
+            row += 1
+
+    autosize(ws, [22, 8, 16, 18, 18, 14, 8, 12])
+
+
+def sheet_journal_per_bank(wb, bank):
+    safe = bank["bank_account"].replace("-", "_")[:25]
+    ws = wb.create_sheet(f"Asiento_{safe}")
+    ws["A1"] = f"Asiento Propuesto — {bank['bank_account']}  (GL {bank['gl_account']})"
+    ws["A1"].font = Font(bold=True, size=12)
+    ws["A2"] = (
+        f"Apertura: {bank['opening_balance']:,.2f}   "
+        f"Cierre statement: {bank['statement_ending']:,.2f}   "
+        f"Diferencia: {bank['gap_to_clearing']:,.2f}"
+    )
+    headers = [
+        "Fecha", "Doc No", "Tipo Cuenta", "Cuenta", "Contraparte",
+        "Descripción", "Débito VES", "Crédito VES", "Banco",
+    ]
+    write_header(ws, 4, headers)
+    row = 5
+    for r in bank.get("rows", []):
+        cells = [
+            r.get("posting_date"),
+            r.get("document_no"),
+            r.get("account_type"),
+            r.get("account_no"),
+            r.get("counterparty", ""),
+            r.get("description", ""),
+            r.get("debit_ves", 0),
+            r.get("credit_ves", 0),
+            r.get("bank_account", ""),
+        ]
+        for i, v in enumerate(cells, start=1):
+            c = ws.cell(row=row, column=i, value=v)
+            c.border = THIN
+            if i in (7, 8):
+                c.number_format = NUM
+            if r.get("is_residual"):
+                c.fill = RESIDUAL_FILL
+        row += 1
+    # totals
+    ws.cell(row=row + 1, column=6, value="Total").font = BOLD
+    td = ws.cell(row=row + 1, column=7, value=bank["summary"]["total_debit"])
+    tc = ws.cell(row=row + 1, column=8, value=bank["summary"]["total_credit"])
+    td.number_format = NUM
+    tc.number_format = NUM
+    td.fill = TOTAL_FILL
+    tc.fill = TOTAL_FILL
+    autosize(ws, [12, 18, 14, 12, 18, 50, 14, 14, 16])
+
+
+def sheet_cuestionario(wb, state):
+    ws = wb.create_sheet("Cuestionario")
+    q = state.get("questionnaire", {})
+    headers = [
+        "Banco", "Fecha", "Descripción", "Monto VES", "Categoría",
+        "Sugerencia GL", "Confianza", "Clasificación usuario", "Memo", "Guardar feedback",
+    ]
+    write_header(ws, 1, headers)
+    row = 2
+    for ln in q.get("unknown_lines", []):
+        sug = ln.get("suggestion") or {}
+        cls = ln.get("user_classification") or {}
+        cells = [
+            ln.get("bank_account"),
+            ln.get("date"),
+            ln.get("description"),
+            ln.get("amount"),
+            ln.get("category"),
+            sug.get("gl_account") or "",
+            sug.get("confidence") or sug.get("source") or "",
+            cls.get("gl_account") or "",
+            cls.get("memo") or "",
+            "Sí" if cls.get("save_for_future") else "",
+        ]
+        for i, v in enumerate(cells, start=1):
+            c = ws.cell(row=row, column=i, value=v)
+            c.border = THIN
+            if i == 4:
+                c.number_format = NUM
+        row += 1
+    autosize(ws, [16, 12, 50, 14, 22, 12, 12, 12, 30, 14])
+
+
+def sheet_confirmaciones(wb, state):
+    ws = wb.create_sheet("Confirmaciones")
+    q = state.get("questionnaire", {})
+    headers = [
+        "Grupo", "Contraparte", "Nombre", "Documento", "Fecha",
+        "Monto VES", "Monto USD", "Días", "Premisa", "Confirmado", "Banco asignado",
+    ]
+    write_header(ws, 1, headers)
+    row = 2
+    routing = q.get("routing", {}) or {}
+
+    def add(group, e):
+        nonlocal row
+        cells = [
+            group,
+            e.get("counterparty_no"),
+            e.get("counterparty_name") or "",
+            e.get("document_number") or "",
+            e.get("posting_date"),
+            e.get("amount_ves"),
+            e.get("amount_usd"),
+            e.get("days_old"),
+            e.get("premise"),
+            (
+                "Sí" if e.get("confirmed") is True
+                else "No" if e.get("confirmed") is False
+                else "(pendiente)"
+            ),
+            routing.get(e.get("counterparty_no"), ""),
+        ]
+        for i, v in enumerate(cells, start=1):
+            c = ws.cell(row=row, column=i, value=v)
+            c.border = THIN
+            if i in (6, 7) and isinstance(v, (int, float)):
+                c.number_format = NUM
+        row += 1
+
+    for e in q.get("pos_entries", []):
+        add("POS", e)
+    for e in q.get("intercompany_entries", []):
+        add("Intercompañía", e)
+    for e in q.get("vendor_entries", []):
+        add("Proveedor", e)
+
+    autosize(ws, [14, 18, 36, 18, 12, 16, 14, 8, 22, 14, 18])
+
+
+def sheet_detalle_lineas(wb, state):
+    """One row per bank statement line with full match metadata for manual review.
+
+    Use this sheet to verify that auto-matches are correct before approving.
+    Filter by Banco column to focus on one account at a time.
+    """
+    ws = wb.create_sheet("Detalle Líneas Banco")
+    q = state.get("questionnaire", {}) or {}
+    headers = [
+        "Banco", "Fecha", "Doc No", "Tipo",
+        "Monto VES", "Categoría Original",
+        "Match Source", "Confianza",
+        "GL Sugerida", "Categoría Match", "Acción Sugerida",
+        "GL Usuario", "Memo Usuario",
+        "Grupo Match", "Razón", "Descripción Completa",
+    ]
+    write_header(ws, 1, headers)
+    row = 2
+    # Sort by bank then date for review-friendly order
+    lines = sorted(
+        q.get("unknown_lines", []),
+        key=lambda l: ((l.get("bank_account") or ""), (l.get("date") or "")),
+    )
+    for ln in lines:
+        sug = ln.get("match_suggestion") or {}
+        target = sug.get("target") or {}
+        cls = ln.get("user_classification") or {}
+        # Grupo Match: aggregate_pattern (UBII) or counterparty / target line id
+        grupo = (
+            target.get("aggregate_pattern")
+            or target.get("counterparty_no")
+            or target.get("invoice_no")
+            or target.get("mp_no")
+            or target.get("line_id")
+            or ""
+        )
+        cells = [
+            ln.get("bank_account"),
+            ln.get("date"),
+            ln.get("document_no") or "",
+            ln.get("type") or "",
+            ln.get("amount"),
+            ln.get("category") or "",
+            sug.get("source") or "",
+            sug.get("confidence") or "",
+            target.get("gl_account") or "",
+            target.get("category") or target.get("label") or "",
+            sug.get("recommended_action") or "",
+            cls.get("gl_account") or "",
+            cls.get("memo") or "",
+            grupo,
+            (sug.get("reason") or "")[:200],
+            ln.get("description") or "",
+        ]
+        for i, v in enumerate(cells, start=1):
+            c = ws.cell(row=row, column=i, value=v)
+            c.border = THIN
+            if i == 5 and isinstance(v, (int, float)):
+                c.number_format = NUM
+            # Highlight: residual to clearing or apply_in_bc
+            if (sug.get("recommended_action") in ("apply_in_bc", "apply_mp_draft")):
+                c.fill = TOTAL_FILL
+            elif not sug:
+                c.fill = RESIDUAL_FILL  # unclassified
+        row += 1
+    # Freeze the header
+    ws.freeze_panes = "A2"
+    # Auto-filter so the user can sort/filter in Excel
+    if row > 2:
+        ws.auto_filter.ref = f"A1:{chr(ord('A') + len(headers) - 1)}{row - 1}"
+    autosize(ws, [16, 12, 18, 8, 14, 22, 14, 11, 12, 30, 18, 12, 28, 22, 50, 60])
+
+
+def main(in_path, out_path):
+    with open(in_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    state = data.get("state", {})
+    journal = data.get("journal", {})
+
+    wb = Workbook()
+    wb.remove(wb.active)
+    sheet_resumen(wb, state, journal)
+    for b in journal.get("banks", []):
+        sheet_journal_per_bank(wb, b)
+    sheet_detalle_lineas(wb, state)
+    sheet_cuestionario(wb, state)
+    sheet_confirmaciones(wb, state)
+    wb.save(out_path)
+    print(f"Wrote {out_path}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print("Usage: generate-month-closing-xlsx.py <input.json> <output.xlsx>", file=sys.stderr)
+        sys.exit(2)
+    main(sys.argv[1], sys.argv[2])

package/scripts/test-closing-flow.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// End-to-end integration test for the auto-matching closing workflow.
+//   start_month_closing → get_closing_match_results → submit_closing_answers
+//   (bulk approvals + mark_apply_in_bc) → reconcile_closing_with_bc →
+//   generate_closing_journal
+//
+// Usage: node scripts/test-closing-flow.js [--store FQ01] [--month 2025-12]
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import dotenv from 'dotenv';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const envPath = join(__dirname, '..', '.env');
+if (existsSync(envPath)) dotenv.config({ path: envPath });
+
+const { BCClient } = await import('../lib/bc-client.js');
+const mod = await import('../tools/cierre-mensual/index.js');
+
+const STORE = (process.argv.indexOf('--store') >= 0 && process.argv[process.argv.indexOf('--store') + 1]) || 'FQ01';
+const MONTH = (process.argv.indexOf('--month') >= 0 && process.argv[process.argv.indexOf('--month') + 1]) || '2025-12';
+
+const bc = new BCClient();
+
+console.error(`\n=== ${STORE} ${MONTH} — full closing flow test ===\n`);
+
+console.error('[1/5] start_month_closing (force_refresh=true)');
+const start = await mod.handleStartMonthClosing(bc, { store: STORE, month: MONTH, force_refresh: true });
+console.error('  match_results_summary:', JSON.stringify(start.match_results_summary, null, 2));
+
+console.error('\n[2/5] get_closing_match_results by_category (top 6)');
+const cats = await mod.handleGetClosingMatchResults(null, { store: STORE, month: MONTH, list: 'by_category' });
+for (const c of cats.by_category.slice(0, 6)) {
+  console.error(`  ${c.category.padEnd(50)} count=${String(c.count).padStart(5)} VES=${c.total_abs_ves.toLocaleString().padStart(15)} sources=${c.sources.join(',')}`);
+}
+
+console.error('\n[3/5] submit: approve top categories + mark apply_in_bc + classify a few unclassified');
+const topCategories = cats.by_category.slice(0, 6).map((c) => c.category);
+const apply = await mod.handleGetClosingMatchResults(null, { store: STORE, month: MONTH, list: 'apply_in_bc', limit: 200 });
+const unclassified = await mod.handleGetClosingMatchResults(null, { store: STORE, month: MONTH, list: 'unclassified', limit: 5 });
+const lineClassifications = unclassified.items.map((x) => ({
+  line_id: x.line_id, gl_account: '67100', memo: 'Manual: ' + (x.description || '').slice(0, 40), save_for_future: true,
+}));
+const subRes = await mod.handleSubmitClosingAnswers(null, {
+  store: STORE, month: MONTH, user: 'test@fullqueso.com',
+  answers: {
+    approve_category_bulk: topCategories,
+    mark_apply_in_bc: apply.items.map((x) => x.line_id),
+    line_classifications: lineClassifications,
+  },
+});
+console.error('  status=' + subRes.status, 'pending_count=' + subRes.pending_count);
+console.error('  pending_breakdown:', subRes.pending_breakdown);
+
+console.error('\n[4/5] reconcile_closing_with_bc');
+const recon = await mod.handleReconcileWithBc(bc, { store: STORE, month: MONTH });
+console.error('  drift summary:', recon.summary);
+
+console.error('\n[5/5] generate_closing_journal (allow_partial=true)');
+const j = await mod.handleGenerateClosingJournal(bc, { store: STORE, month: MONTH, output_dir: '/tmp', allow_partial: true });
+console.error('  xlsx_path:', j.xlsx_path);
+console.error('  balanced:', j.journal_summary?.balanced);
+console.error('  totals: debit=' + j.journal_summary?.total_debit, 'credit=' + j.journal_summary?.total_credit);
+console.error('  banks:');
+for (const b of j.journal_summary?.banks || []) {
+  console.error(`     ${b.bank_account} rows=${b.rows} debit=${b.total_debit} credit=${b.total_credit} gap=${b.gap_to_clearing}`);
+}
+console.error('  apply_in_bc roster size:', j.journal_summary?.apply_in_bc_count);
+
+console.error('\n✓ End-to-end test complete.\n');

package/scripts/test-closing-fq01-dec25.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// End-to-end integration test for the entry-level month-end closing workflow.
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import dotenv from 'dotenv';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const envPath = join(__dirname, '..', '.env');
+if (existsSync(envPath)) dotenv.config({ path: envPath });
+
+const { BCClient } = await import('../lib/bc-client.js');
+const {
+  handleStartMonthClosing,
+  handleSubmitClosingAnswers,
+  handleGenerateClosingJournal,
+  handleGetClosingQuestionnaire,
+} = await import('../tools/cierre-mensual/index.js');
+
+const bc = new BCClient();
+
+console.error('\n=== TEST: start_month_closing FQ01 (force_refresh) ===');
+const startRes = await handleStartMonthClosing(bc, { store: 'FQ01', month: '2025-12', force_refresh: true });
+console.error(JSON.stringify({
+  status: startRes.status, month: startRes.month,
+  banks_count: startRes.banks?.length,
+  q: startRes.questionnaire_summary,
+}, null, 2));
+
+console.error('\n=== TEST: get_closing_questionnaire summary ===');
+const sumRes = await handleGetClosingQuestionnaire(bc, { store: 'FQ01', month: '2025-12', bucket: 'summary' });
+console.error(JSON.stringify({ buckets: sumRes.buckets, unknown_lines: sumRes.unknown_lines }, null, 2));
+
+console.error('\n=== TEST: counterparties view ===');
+const cpRes = await handleGetClosingQuestionnaire(bc, { store: 'FQ01', month: '2025-12', bucket: 'counterparties' });
+console.error('POS:', JSON.stringify(cpRes.counterparties.pos_entries.map((g) => ({ cp: g.counterparty_no, name: g.counterparty_name, entries: g.entries, ves: g.total_ves, usd: g.total_usd, oldest: g.oldest_doc_date, latest: g.latest_doc_date })), null, 2));
+console.error('Intercompany:', JSON.stringify(cpRes.counterparties.intercompany_entries.map((g) => ({ cp: g.counterparty_no, name: g.counterparty_name, entries: g.entries, ves: g.total_ves, usd: g.total_usd })), null, 2));
+console.error('Vendors:', cpRes.counterparties.vendor_entries.length, 'groups');
+
+console.error('\n=== TEST: pos_entries first 5 ===');
+const posRes = await handleGetClosingQuestionnaire(bc, { store: 'FQ01', month: '2025-12', bucket: 'pos_entries', limit: 5, sort: 'amount_ves_desc' });
+console.error(JSON.stringify({ total: posRes.total, entries: posRes.entries }, null, 2));
+
+// Confirm all POS via counterparty_bulk shortcut, route to MN0001
+console.error('\n=== TEST: submit (bulk confirm POS to MN0001) ===');
+const posCPs = cpRes.counterparties.pos_entries.map((g) => g.counterparty_no);
+const bulk = {};
+for (const cp of posCPs) bulk[cp] = true;
+const routing = {};
+for (const cp of posCPs) routing[cp] = 'FQ01-MN0001';
+const subRes = await handleSubmitClosingAnswers(bc, {
+  store: 'FQ01', month: '2025-12',
+  answers: { counterparty_bulk: bulk, routing },
+});
+console.error(JSON.stringify({ status: subRes.status, pending_count: subRes.pending_count, pending_breakdown: subRes.pending_breakdown }, null, 2));
+
+console.error('\n=== TEST: summary after POS confirmation ===');
+const sumRes2 = await handleGetClosingQuestionnaire(bc, { store: 'FQ01', month: '2025-12', bucket: 'summary' });
+console.error(JSON.stringify({ buckets: sumRes2.buckets }, null, 2));
+
+console.error('\n=== TEST: generate_closing_journal (allow_partial=true) ===');
+const genRes = await handleGenerateClosingJournal(bc, {
+  store: 'FQ01', month: '2025-12', output_dir: '/tmp', allow_partial: true,
+});
+console.error(JSON.stringify({
+  status: genRes.status,
+  xlsx_path: genRes.xlsx_path,
+  xlsx_error: genRes.xlsx_error?.slice(0, 300),
+  summary: {
+    balanced: genRes.journal_summary.balanced,
+    total_debit: genRes.journal_summary.total_debit,
+    total_credit: genRes.journal_summary.total_credit,
+    banks: genRes.journal_summary.banks,
+    warnings_count: genRes.journal_summary.warnings.length,
+    unassigned_rows: genRes.journal_summary.unassigned_rows,
+  },
+}, null, 2));

package/server.js

@@ -86,12 +86,29 @@ import {
   salesAnalysisTool, handleSalesAnalysis,
   productPerformanceTool, handleProductPerformance,
   salesStoreComparisonTool, handleSalesStoreComparison,
+  itemSalesDetailTool, handleItemSalesDetail,
 } from './tools/ventas/index.js';
 
 // Reports tools
 import { managerReportTool, handleGenerateManagerReport } from './tools/reports/manager-report.js';
 import { cxpReportTool, handleGenerateCxpReport } from './tools/reports/cxp-report.js';
 
+// Cierre mensual (month-end bank reconciliation closing)
+import {
+  startMonthClosingTool, handleStartMonthClosing,
+  submitClosingAnswersTool, handleSubmitClosingAnswers,
+  generateClosingJournalTool, handleGenerateClosingJournal,
+  getClosingQuestionnaireTool, handleGetClosingQuestionnaire,
+  getClosingMatchResultsTool, handleGetClosingMatchResults,
+  reconcileWithBcTool, handleReconcileWithBc,
+} from './tools/cierre-mensual/index.js';
+
+// Financials (P&L / Financial Statements) + Cash Flow (FCF)
+import {
+  financialStatementsTool, handleFinancialStatements,
+  cashFlowTool, handleCashFlow,
+} from './tools/financials/index.js';
+
 const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
 const bcClient = new BCClient();
 
@@ -161,9 +178,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       salesAnalysisTool,
       productPerformanceTool,
       salesStoreComparisonTool,
+      itemSalesDetailTool,
       // Reports
       managerReportTool,
       cxpReportTool,
+      // Cierre mensual (month-end bank reconciliation closing)
+      startMonthClosingTool,
+      submitClosingAnswersTool,
+      generateClosingJournalTool,
+      getClosingQuestionnaireTool,
+      getClosingMatchResultsTool,
+      reconcileWithBcTool,
+      // Financials (P&L / Financial Statements) + Cash Flow (FCF)
+      financialStatementsTool,
+      cashFlowTool,
     ],
   };
 });
@@ -314,6 +342,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'compare_sales_by_store':
         result = await handleSalesStoreComparison(bcClient, args);
         break;
+      case 'get_item_sales_detail':
+        result = await handleItemSalesDetail(bcClient, args);
+        break;
       // Reports
       case 'generate_manager_report':
         result = await handleGenerateManagerReport(bcClient, args);
@@ -321,6 +352,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'generate_cxp_report':
         result = await handleGenerateCxpReport(bcClient, args);
         break;
+      // Cierre mensual (month-end bank reconciliation closing)
+      case 'start_month_closing':
+        result = await handleStartMonthClosing(bcClient, args);
+        break;
+      case 'submit_closing_answers':
+        result = await handleSubmitClosingAnswers(bcClient, args);
+        break;
+      case 'generate_closing_journal':
+        result = await handleGenerateClosingJournal(bcClient, args);
+        break;
+      case 'get_closing_questionnaire':
+        result = await handleGetClosingQuestionnaire(bcClient, args);
+        break;
+      case 'get_closing_match_results':
+        result = await handleGetClosingMatchResults(bcClient, args);
+        break;
+      case 'reconcile_closing_with_bc':
+        result = await handleReconcileWithBc(bcClient, args);
+        break;
+      // Financials (P&L / Financial Statements) + Cash Flow (FCF)
+      case 'get_financial_statements':
+        result = await handleFinancialStatements(bcClient, args);
+        break;
+      case 'get_cash_flow':
+        result = await handleCashFlow(bcClient, args);
+        break;
       default:
         return {
           content: [{ type: 'text', text: `Herramienta desconocida: ${name}` }],

package/tools/auditoria/bank-ledger-entries.js

@@ -45,9 +45,9 @@ export async function handleBankLedgerEntries(bcClient, args) {
   const storeInfo = stores[0];
 
   const filterParts = [
-    `Bank_Account_No eq '${bank_account}'`,
-    `Posting_Date ge ${date_from}`,
-    `Posting_Date le ${date_to}`,
+    `Bank_Account_No eq '${bcClient._sanitizeOData(bank_account)}'`,
+    `Posting_Date ge ${bcClient._sanitizeOData(date_from)}`,
+    `Posting_Date le ${bcClient._sanitizeOData(date_to)}`,
   ];
   if (openOnly) {
     filterParts.push('Open eq true');

package/tools/auditoria/find-potential-matches.js

@@ -83,7 +83,7 @@ export async function handleFindPotentialMatches(bcClient, args) {
 
   // Fetch open bank ledger entries within date range
   const url = bcClient.buildODataUrl(store, 'BankAccountLedgerEntries', {
-    $filter: `Bank_Account_No eq '${bankAccount}' and Open eq true and Posting_Date ge ${dateFrom} and Posting_Date le ${dateTo}`,
+    $filter: `Bank_Account_No eq '${bcClient._sanitizeOData(bankAccount)}' and Open eq true and Posting_Date ge ${bcClient._sanitizeOData(dateFrom)} and Posting_Date le ${bcClient._sanitizeOData(dateTo)}`,
     $orderby: 'Posting_Date desc',
   });
 

package/tools/auditoria/gl-account-entries.js

@@ -39,7 +39,7 @@ export async function handleGLAccountEntries(bcClient, args) {
   const storeInfo = stores[0];
 
   const url = bcClient.buildApiUrl(storeInfo.companyId, 'generalLedgerEntries', {
-    $filter: `postingDate ge ${date_from} and postingDate le ${date_to} and accountNumber eq '${gl_account}'`,
+    $filter: `postingDate ge ${bcClient._sanitizeOData(date_from)} and postingDate le ${bcClient._sanitizeOData(date_to)} and accountNumber eq '${bcClient._sanitizeOData(gl_account)}'`,
     $select: 'entryNumber,postingDate,documentNumber,accountNumber,description,debitAmount,creditAmount',
     $orderby: 'postingDate asc',
   });

package/tools/auditoria/list-bank-accounts.js

@@ -24,21 +24,32 @@ export async function handleListBankAccounts(bcClient, args) {
   const stores = resolveStores([store]);
   const storeInfo = stores[0];
 
-  // Standard API bankAccounts — no 'balance' field available
-  const url = bcClient.buildApiUrl(storeInfo.companyId, 'bankAccounts', {
-    $select: 'number,displayName,bankAccountNumber,currencyCode,blocked',
-    $orderby: 'number',
-  });
+  // Fetch bank accounts + posting groups in parallel via OData
+  // Bank_Account_Card_Excel has: No, Name, Bank_Account_No, Currency_Code,
+  //   Bank_Acc_Posting_Group, Blocked, Balance, Last_Statement_No
+  // Bank_Account_Posting_Groups_Excel has: Code, G_L_Account_No
+  const [cardRows, pgRows] = await Promise.all([
+    bcClient.odataCall(bcClient.buildODataUrl(store, 'Bank_Account_Card_Excel')),
+    bcClient.odataCall(bcClient.buildODataUrl(store, 'Bank_Account_Posting_Groups_Excel')),
+  ]);
 
-  const accounts = await bcClient.apiCallAllPages(url);
+  // Build posting group → GL account lookup
+  const glByGroup = {};
+  for (const pg of pgRows) {
+    if (pg.Code) glByGroup[pg.Code] = pg.G_L_Account_No || null;
+  }
 
-  const bankAccounts = accounts
-    .filter((acct) => !acct.blocked)
+  const bankAccounts = cardRows
+    .filter((acct) => !acct.Blocked)
     .map((acct) => ({
-      number: acct.number,
-      name: acct.displayName,
-      bank_account_number: acct.bankAccountNumber || '',
-      currency: acct.currencyCode || 'VES',
+      number: acct.No,
+      name: acct.Name,
+      bank_account_number: acct.Bank_Account_No || '',
+      currency: acct.Currency_Code || 'VES',
+      bankAccPostingGroup: acct.Bank_Acc_Posting_Group || null,
+      glAccount: acct.Bank_Acc_Posting_Group
+        ? (glByGroup[acct.Bank_Acc_Posting_Group] ?? null)
+        : null,
     }));
 
   return {

package/tools/auditoria/pm-receipts.js

@@ -38,8 +38,8 @@ export async function handlePmReceipts(bcClient, args) {
   const stores = resolveStores([store]);
   const storeInfo = stores[0];
 
-  // Query customer ledger entries for the 3 PM customers
-  const pmCustomers = ['FQ01-CN0006-1', 'FQ01-CN0006-2', 'FQ01-CN0007'];
+  // Query customer ledger entries for the 4 same-day-settled POS customers
+  const pmCustomers = ['FQ01-CN0005', 'FQ01-CN0006-1', 'FQ01-CN0006-2', 'FQ01-CN0007'];
 
   const allEntries = [];
 
@@ -47,8 +47,8 @@ export async function handlePmReceipts(bcClient, args) {
     // Use Beta API — query Payment entries for this customer
     const url = bcClient.buildBetaApiUrl(storeInfo.companyId, 'customerLedgerEntries', {
       $filter: [
-        `postingDate ge ${date_from}`,
-        `postingDate le ${date_to}`,
+        `postingDate ge ${bcClient._sanitizeOData(date_from)}`,
+        `postingDate le ${bcClient._sanitizeOData(date_to)}`,
         `customerNumber eq '${customer}'`,
         `documentType eq 'Payment'`,
       ].join(' and '),