@dizzlkheinz/ynab-mcpb 0.12.2 → 0.15.0

package/dist/tools/reconciliation/analyzer.js

@@ -1,296 +1,39 @@
-import { randomUUID } from 'crypto';
-import * as bankParser from '../compareTransactions/parser.js';
-import { findMatches } from './matcher.js';
-import { DEFAULT_MATCHING_CONFIG } from './types.js';
-import { toMoneyValueFromDecimal } from '../../utils/money.js';
+import { parseCSV } from './csvParser.js';
+import { findMatches, normalizeConfig, DEFAULT_CONFIG } from './matcher.js';
+import { normalizeYNABTransactions } from './ynabAdapter.js';
+import { toMoneyValue } from '../../utils/money.js';
 import { generateRecommendations } from './recommendationEngine.js';
-function convertYNABTransaction(apiTxn) {
-    return {
-        id: apiTxn.id,
-        date: apiTxn.date,
-        amount: apiTxn.amount,
-        payee_name: apiTxn.payee_name || null,
-        category_name: apiTxn.category_name || null,
-        cleared: apiTxn.cleared,
-        approved: apiTxn.approved,
-        memo: apiTxn.memo || null,
+function mapToTransactionMatch(result) {
+    const candidates = result.candidates.map((c) => ({
+        ynab_transaction: c.ynabTransaction,
+        confidence: c.scores.combined,
+        match_reason: c.matchReasons.join(', '),
+        explanation: c.matchReasons.join(', '),
+    }));
+    const match = {
+        bankTransaction: result.bankTransaction,
+        candidates,
+        confidence: result.confidence,
+        confidenceScore: result.confidenceScore,
+        matchReason: result.bestMatch?.matchReasons.join(', ') ?? 'No match found',
+        actionHint: result.confidence === 'high' ? 'approve' : 'review',
     };
-}
-const FALLBACK_CSV_FORMAT = {
-    date_column: 'Date',
-    amount_column: 'Amount',
-    description_column: 'Description',
-    date_format: 'MM/DD/YYYY',
-    has_header: true,
-    delimiter: ',',
-};
-const ENABLE_COMBINATION_MATCHING = true;
-const DAYS_IN_MS = 24 * 60 * 60 * 1000;
-function toDollars(milliunits) {
-    return milliunits / 1000;
-}
-function amountTolerance(config) {
-    const toleranceCents = config.amountToleranceCents ?? DEFAULT_MATCHING_CONFIG.amountToleranceCents ?? 1;
-    return Math.max(0, toleranceCents) / 100;
-}
-function dateTolerance(config) {
-    return config.dateToleranceDays ?? DEFAULT_MATCHING_CONFIG.dateToleranceDays ?? 2;
-}
-function daysBetween(dateA, dateB) {
-    const a = new Date(`${dateA}T00:00:00Z`).getTime();
-    const b = new Date(`${dateB}T00:00:00Z`).getTime();
-    if (Number.isNaN(a) || Number.isNaN(b))
-        return Number.POSITIVE_INFINITY;
-    return Math.abs(a - b) / DAYS_IN_MS;
-}
-function withinDateTolerance(bankDate, ynabTxns, toleranceDays) {
-    return ynabTxns.every((txn) => daysBetween(bankDate, txn.date) <= toleranceDays);
-}
-function hasMatchingSign(bankAmount, ynabTxns) {
-    const bankSign = Math.sign(bankAmount);
-    const sumSign = Math.sign(ynabTxns.reduce((sum, txn) => sum + toDollars(txn.amount), 0));
-    return bankSign === sumSign || Math.abs(bankAmount) === 0;
-}
-function computeCombinationConfidence(diff, tolerance, legCount) {
-    const safeTolerance = tolerance > 0 ? tolerance : 0.01;
-    const ratio = diff / safeTolerance;
-    let base = legCount === 2 ? 75 : 70;
-    if (ratio <= 0.25) {
-        base += 5;
-    }
-    else if (ratio <= 0.5) {
-        base += 3;
-    }
-    else if (ratio >= 0.9) {
-        base -= 5;
-    }
-    return Math.max(65, Math.min(80, Math.round(base)));
-}
-function formatDifference(diff) {
-    return formatCurrency(diff);
-}
-function findCombinationMatches(unmatchedBank, unmatchedYNAB, config) {
-    if (!ENABLE_COMBINATION_MATCHING || unmatchedBank.length === 0 || unmatchedYNAB.length === 0) {
-        return { matches: [], insights: [] };
-    }
-    const tolerance = amountTolerance(config);
-    const toleranceDays = dateTolerance(config);
-    const matches = [];
-    const insights = [];
-    const seenCombinations = new Set();
-    for (const bankTxn of unmatchedBank) {
-        const viableYnab = unmatchedYNAB.filter((txn) => hasMatchingSign(bankTxn.amount, [txn]));
-        if (viableYnab.length < 2)
-            continue;
-        const evaluated = [];
-        const addIfValid = (combo) => {
-            const sum = combo.reduce((acc, txn) => acc + toDollars(txn.amount), 0);
-            const diff = Math.abs(sum - bankTxn.amount);
-            if (diff > tolerance)
-                return;
-            if (!withinDateTolerance(bankTxn.date, combo, toleranceDays))
-                return;
-            if (!hasMatchingSign(bankTxn.amount, combo))
-                return;
-            evaluated.push({ txns: combo, diff, sum });
-        };
-        const n = viableYnab.length;
-        for (let i = 0; i < n - 1; i++) {
-            for (let j = i + 1; j < n; j++) {
-                addIfValid([viableYnab[i], viableYnab[j]]);
-            }
-        }
-        if (n >= 3) {
-            for (let i = 0; i < n - 2; i++) {
-                for (let j = i + 1; j < n - 1; j++) {
-                    for (let k = j + 1; k < n; k++) {
-                        addIfValid([viableYnab[i], viableYnab[j], viableYnab[k]]);
-                    }
-                }
-            }
-        }
-        if (evaluated.length === 0)
-            continue;
-        evaluated.sort((a, b) => a.diff - b.diff);
-        const recordedSizes = new Set();
-        for (const combo of evaluated) {
-            if (recordedSizes.has(combo.txns.length))
-                continue;
-            const comboIds = combo.txns.map((txn) => txn.id).sort();
-            const key = `${bankTxn.id}|${comboIds.join('+')}`;
-            if (seenCombinations.has(key))
-                continue;
-            seenCombinations.add(key);
-            recordedSizes.add(combo.txns.length);
-            const score = computeCombinationConfidence(combo.diff, tolerance, combo.txns.length);
-            const candidateConfidence = Math.max(60, score - 5);
-            const descriptionTotal = formatCurrency(combo.sum);
-            const diffLabel = formatDifference(combo.diff);
-            matches.push({
-                bank_transaction: bankTxn,
-                confidence: 'medium',
-                confidence_score: score,
-                match_reason: 'combination_match',
-                top_confidence: score,
-                candidates: combo.txns.map((txn) => ({
-                    ynab_transaction: txn,
-                    confidence: candidateConfidence,
-                    match_reason: 'combination_component',
-                    explanation: `Part of combination totaling ${descriptionTotal} (difference ${diffLabel}).`,
-                })),
-                action_hint: 'review_combination',
-                recommendation: `Combination of ${combo.txns.length} YNAB transactions totals ${descriptionTotal} versus ` +
-                    `${formatCurrency(bankTxn.amount)} on the bank statement.`,
-            });
-            const insightId = `combination-${bankTxn.id}-${comboIds.join('+')}`;
-            insights.push({
-                id: insightId,
-                type: 'combination_match',
-                severity: 'info',
-                title: `Combination of ${combo.txns.length} transactions matches ${formatCurrency(bankTxn.amount)}`,
-                description: `${combo.txns.length} YNAB transactions totaling ${descriptionTotal} align with ` +
-                    `${formatCurrency(bankTxn.amount)} from ${bankTxn.payee}. Difference ${diffLabel}.`,
-                evidence: {
-                    bank_transaction_id: bankTxn.id,
-                    bank_amount: bankTxn.amount,
-                    ynab_transaction_ids: comboIds,
-                    ynab_amounts_milliunits: combo.txns.map((txn) => txn.amount),
-                    combination_size: combo.txns.length,
-                    difference: combo.diff,
-                },
-            });
-        }
-    }
-    return { matches, insights };
-}
-function isParsedCSVData(result) {
-    return (typeof result === 'object' &&
-        result !== null &&
-        !Array.isArray(result) &&
-        'transactions' in result);
-}
-function normalizeDate(value) {
-    if (value instanceof Date) {
-        return value.toISOString().split('T')[0];
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed)
-            return trimmed;
-        const parsed = new Date(trimmed);
-        if (!Number.isNaN(parsed.getTime())) {
-            return parsed.toISOString().split('T')[0];
-        }
-        return trimmed;
-    }
-    return new Date().toISOString().split('T')[0];
-}
-function normalizeAmount(record) {
-    const raw = record['amount'];
-    if (typeof raw === 'number') {
-        if (record['date'] instanceof Date || 'raw_amount' in record || 'raw_date' in record) {
-            return Math.round(raw) / 1000;
-        }
-        return raw;
-    }
-    if (typeof raw === 'string') {
-        const cleaned = raw.replace(/[$,\s]/g, '');
-        const parsed = Number.parseFloat(cleaned);
-        return Number.isFinite(parsed) ? parsed : 0;
-    }
-    return 0;
-}
-function normalizePayee(record) {
-    const candidates = [record['payee'], record['description'], record['memo']];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string' && candidate.trim()) {
-            return candidate.trim();
-        }
-    }
-    return 'Unknown Payee';
-}
-function determineRow(record, index) {
-    if (typeof record['original_csv_row'] === 'number') {
-        return record['original_csv_row'];
-    }
-    if (typeof record['row_number'] === 'number') {
-        return record['row_number'];
-    }
-    return index + 1;
-}
-function convertParserRecord(record, index) {
-    const data = typeof record === 'object' && record !== null ? record : {};
-    const dateValue = normalizeDate(data['date']);
-    const amountValue = normalizeAmount(data);
-    const payeeValue = normalizePayee(data);
-    const memoValue = typeof data['memo'] === 'string' && data['memo'].trim() ? data['memo'].trim() : undefined;
-    const originalRow = determineRow(data, index);
-    const transaction = {
-        id: randomUUID(),
-        date: dateValue,
-        amount: amountValue,
-        payee: payeeValue,
-        original_csv_row: originalRow,
-    };
-    if (memoValue !== undefined) {
-        transaction.memo = memoValue;
-    }
-    return transaction;
-}
-function parseBankStatement(csvContent, csvFilePath) {
-    const content = csvFilePath ? bankParser.readCSVFile(csvFilePath) : csvContent;
-    let format = FALLBACK_CSV_FORMAT;
-    let autoDetect;
-    try {
-        autoDetect = bankParser
-            .autoDetectCSVFormat;
-    }
-    catch {
-        autoDetect = undefined;
-    }
-    if (typeof autoDetect === 'function') {
-        try {
-            format = autoDetect(content);
-        }
-        catch {
-            format = FALLBACK_CSV_FORMAT;
-        }
+    if (result.bestMatch) {
+        match.ynabTransaction = result.bestMatch.ynabTransaction;
     }
-    const rawResult = bankParser.parseBankCSV(content, format);
-    const records = isParsedCSVData(rawResult) ? rawResult.transactions : rawResult;
-    return records.map(convertParserRecord);
-}
-function categorizeMatches(matches) {
-    const autoMatches = [];
-    const suggestedMatches = [];
-    const unmatchedBank = [];
-    for (const match of matches) {
-        if (match.confidence === 'high') {
-            autoMatches.push(match);
-        }
-        else if (match.confidence === 'medium') {
-            suggestedMatches.push(match);
-        }
-        else {
-            unmatchedBank.push(match.bank_transaction);
-        }
+    if (result.candidates[0]) {
+        match.topConfidence = result.candidates[0].scores.combined;
     }
-    return { autoMatches, suggestedMatches, unmatchedBank };
-}
-function findUnmatchedYNAB(ynabTransactions, matches) {
-    const matchedIds = new Set();
-    for (const match of matches) {
-        if (match.ynab_transaction) {
-            matchedIds.add(match.ynab_transaction.id);
-        }
+    if (result.confidence === 'none') {
+        match.recommendation = 'This bank transaction is not in YNAB. Consider adding it.';
     }
-    return ynabTransactions.filter((txn) => !matchedIds.has(txn.id));
+    return match;
 }
-function calculateBalances(ynabTransactions, statementBalance, currency) {
+function calculateBalances(ynabTransactions, statementBalanceDecimal, currency) {
     let clearedBalance = 0;
     let unclearedBalance = 0;
     for (const txn of ynabTransactions) {
-        const amount = txn.amount / 1000;
+        const amount = txn.amount;
         if (txn.cleared === 'cleared' || txn.cleared === 'reconciled') {
             clearedBalance += amount;
         }
@@ -298,15 +41,16 @@ function calculateBalances(ynabTransactions, statementBalance, currency) {
             unclearedBalance += amount;
         }
     }
+    const statementBalanceMilli = Math.round(statementBalanceDecimal * 1000);
     const totalBalance = clearedBalance + unclearedBalance;
-    const discrepancy = clearedBalance - statementBalance;
+    const discrepancy = clearedBalance - statementBalanceMilli;
     return {
-        current_cleared: toMoneyValueFromDecimal(clearedBalance, currency),
-        current_uncleared: toMoneyValueFromDecimal(unclearedBalance, currency),
-        current_total: toMoneyValueFromDecimal(totalBalance, currency),
-        target_statement: toMoneyValueFromDecimal(statementBalance, currency),
-        discrepancy: toMoneyValueFromDecimal(discrepancy, currency),
-        on_track: Math.abs(discrepancy) < 0.01,
+        current_cleared: toMoneyValue(clearedBalance, currency),
+        current_uncleared: toMoneyValue(unclearedBalance, currency),
+        current_total: toMoneyValue(totalBalance, currency),
+        target_statement: toMoneyValue(statementBalanceMilli, currency),
+        discrepancy: toMoneyValue(discrepancy, currency),
+        on_track: Math.abs(discrepancy) < 10,
     };
 }
 function generateSummary(bankTransactions, ynabTransactions, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances) {
@@ -363,23 +107,23 @@ function generateNextSteps(summary) {
     }
     return steps;
 }
-function formatCurrency(amount) {
+function formatCurrency(amountMilli, currency = 'USD') {
     const formatter = new Intl.NumberFormat('en-US', {
         style: 'currency',
-        currency: 'USD',
+        currency: currency,
         minimumFractionDigits: 2,
         maximumFractionDigits: 2,
     });
-    return formatter.format(amount);
+    return formatter.format(amountMilli / 1000);
 }
-function repeatAmountInsights(unmatchedBank) {
+function repeatAmountInsights(unmatchedBank, currency = 'USD') {
     const insights = [];
     if (unmatchedBank.length === 0) {
         return insights;
     }
     const frequency = new Map();
     for (const txn of unmatchedBank) {
-        const key = txn.amount.toFixed(2);
+        const key = txn.amount;
         const entry = frequency.get(key) ?? { amount: txn.amount, txns: [] };
         entry.txns.push(txn);
         frequency.set(key, entry);
@@ -392,72 +136,29 @@ function repeatAmountInsights(unmatchedBank) {
     }
     const top = repeated[0];
     insights.push({
-        id: `repeat-${top.amount.toFixed(2)}`,
+        id: `repeat-${top.amount}`,
         type: 'repeat_amount',
         severity: top.txns.length >= 4 ? 'critical' : 'warning',
-        title: `${top.txns.length} unmatched transactions at ${formatCurrency(top.amount)}`,
-        description: `The bank statement shows ${top.txns.length} unmatched transaction(s) at ${formatCurrency(top.amount)}. ` +
+        title: `${top.txns.length} unmatched transactions at ${formatCurrency(top.amount, currency)}`,
+        description: `The bank statement shows ${top.txns.length} unmatched transaction(s) at ${formatCurrency(top.amount, currency)}. ` +
             'Repeated amounts are usually the quickest wins — reconcile these first.',
         evidence: {
             amount: top.amount,
             occurrences: top.txns.length,
             dates: top.txns.map((txn) => txn.date),
-            csv_rows: top.txns.map((txn) => txn.original_csv_row),
+            csv_rows: top.txns.map((txn) => txn.sourceRow),
         },
     });
     return insights;
 }
-function nearMatchInsights(matches, config) {
+function anomalyInsights(balances) {
     const insights = [];
-    for (const match of matches) {
-        if (!match.candidates || match.candidates.length === 0)
-            continue;
-        if (match.confidence === 'high')
-            continue;
-        const topCandidate = match.candidates[0];
-        const score = topCandidate.confidence;
-        const highSignal = (match.confidence === 'medium' && score >= config.autoMatchThreshold - 5) ||
-            (match.confidence === 'low' && score >= config.suggestionThreshold) ||
-            (match.confidence === 'none' && score >= config.suggestionThreshold);
-        if (!highSignal)
-            continue;
-        const bankTxn = match.bank_transaction;
-        const ynabTxn = topCandidate.ynab_transaction;
-        insights.push({
-            id: `near-${bankTxn.id}`,
-            type: 'near_match',
-            severity: score >= config.autoMatchThreshold ? 'warning' : 'info',
-            title: `${formatCurrency(bankTxn.amount)} nearly matches ${formatCurrency(ynabTxn.amount / 1000)}`,
-            description: `Bank transaction on ${bankTxn.date} (${formatCurrency(bankTxn.amount)}) nearly matches ` +
-                `${ynabTxn.payee_name ?? 'unknown payee'} on ${ynabTxn.date}. Confidence ${score}% — review and confirm.`,
-            evidence: {
-                bank_transaction: {
-                    id: bankTxn.id,
-                    date: bankTxn.date,
-                    amount: bankTxn.amount,
-                    payee: bankTxn.payee,
-                },
-                candidate: {
-                    id: ynabTxn.id,
-                    date: ynabTxn.date,
-                    amount_milliunits: ynabTxn.amount,
-                    payee_name: ynabTxn.payee_name,
-                    confidence: score,
-                    reasons: topCandidate.match_reason,
-                },
-            },
-        });
-    }
-    return insights.slice(0, 3);
-}
-function anomalyInsights(summary, balances) {
-    const insights = [];
-    const discrepancyAbs = Math.abs(balances.discrepancy.value);
-    if (discrepancyAbs >= 1) {
+    const discrepancyAbs = Math.abs(balances.discrepancy.value_milliunits);
+    if (discrepancyAbs >= 1000) {
         insights.push({
             id: 'balance-gap',
             type: 'anomaly',
-            severity: discrepancyAbs >= 100 ? 'critical' : 'warning',
+            severity: discrepancyAbs >= 100000 ? 'critical' : 'warning',
             title: `Cleared balance off by ${balances.discrepancy.value_display}`,
             description: `YNAB cleared balance is ${balances.current_cleared.value_display} but the statement expects ` +
                 `${balances.target_statement.value_display}. Focus on closing this gap.`,
@@ -468,22 +169,9 @@ function anomalyInsights(summary, balances) {
             },
         });
     }
-    if (summary.unmatched_bank >= 5) {
-        insights.push({
-            id: 'bulk-missing-bank',
-            type: 'anomaly',
-            severity: summary.unmatched_bank >= 10 ? 'critical' : 'warning',
-            title: `${summary.unmatched_bank} bank transactions still unmatched`,
-            description: `There are ${summary.unmatched_bank} bank transactions without a match. ` +
-                'Consider bulk importing or reviewing by date sequence.',
-            evidence: {
-                unmatched_bank: summary.unmatched_bank,
-            },
-        });
-    }
     return insights;
 }
-function detectInsights(matches, unmatchedBank, summary, balances, config) {
+function detectInsights(unmatchedBank, _summary, balances, currency, csvErrors = [], csvWarnings = []) {
     const insights = [];
     const seen = new Set();
     const addUnique = (insight) => {
@@ -492,62 +180,90 @@ function detectInsights(matches, unmatchedBank, summary, balances, config) {
         seen.add(insight.id);
         insights.push(insight);
     };
-    for (const insight of repeatAmountInsights(unmatchedBank)) {
-        addUnique(insight);
+    if (csvErrors.length > 0) {
+        addUnique({
+            id: 'csv-parse-errors',
+            type: 'anomaly',
+            severity: csvErrors.length >= 5 ? 'critical' : 'warning',
+            title: `${csvErrors.length} CSV parsing error(s)`,
+            description: csvErrors
+                .slice(0, 3)
+                .map((e) => `Row ${e.row}: ${e.message}`)
+                .join('; ') + (csvErrors.length > 3 ? ` (+${csvErrors.length - 3} more)` : ''),
+            evidence: {
+                error_count: csvErrors.length,
+                errors: csvErrors.slice(0, 5),
+            },
+        });
+    }
+    if (csvWarnings.length > 0) {
+        addUnique({
+            id: 'csv-parse-warnings',
+            type: 'anomaly',
+            severity: 'info',
+            title: `${csvWarnings.length} CSV parsing warning(s)`,
+            description: csvWarnings
+                .slice(0, 3)
+                .map((w) => `Row ${w.row}: ${w.message}`)
+                .join('; ') + (csvWarnings.length > 3 ? ` (+${csvWarnings.length - 3} more)` : ''),
+            evidence: {
+                warning_count: csvWarnings.length,
+                warnings: csvWarnings.slice(0, 5),
+            },
+        });
     }
-    for (const insight of nearMatchInsights(matches, config)) {
+    for (const insight of repeatAmountInsights(unmatchedBank, currency)) {
         addUnique(insight);
     }
-    for (const insight of anomalyInsights(summary, balances)) {
+    for (const insight of anomalyInsights(balances)) {
         addUnique(insight);
     }
     return insights.slice(0, 5);
 }
-function mergeInsights(base, additional) {
-    if (additional.length === 0) {
-        return base;
-    }
-    const seen = new Set(base.map((insight) => insight.id));
-    const merged = [...base];
-    for (const insight of additional) {
-        if (seen.has(insight.id))
-            continue;
-        seen.add(insight.id);
-        merged.push(insight);
-    }
-    return merged.slice(0, 5);
-}
-export function analyzeReconciliation(csvContent, csvFilePath, ynabTransactions, statementBalance, config = DEFAULT_MATCHING_CONFIG, currency = 'USD', accountId, budgetId, invertBankAmounts = false) {
-    let bankTransactions = parseBankStatement(csvContent, csvFilePath);
-    if (invertBankAmounts) {
-        bankTransactions = bankTransactions.map((txn) => ({
-            ...txn,
-            amount: -txn.amount,
-        }));
-    }
-    const convertedYNABTxns = ynabTransactions.map(convertYNABTransaction);
-    const matches = findMatches(bankTransactions, convertedYNABTxns, config);
-    const { autoMatches, suggestedMatches, unmatchedBank } = categorizeMatches(matches);
-    const unmatchedYNAB = findUnmatchedYNAB(convertedYNABTxns, matches);
-    let combinationMatches = [];
-    let combinationInsights = [];
-    if (ENABLE_COMBINATION_MATCHING) {
-        const combinationResult = findCombinationMatches(unmatchedBank, unmatchedYNAB, config);
-        combinationMatches = combinationResult.matches;
-        combinationInsights = combinationResult.insights;
+export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTransactions, statementBalance, config = DEFAULT_CONFIG, currency = 'USD', accountId, budgetId, invertBankAmounts = false, csvOptions) {
+    let parseResult;
+    if (typeof csvContentOrParsed === 'string') {
+        parseResult = parseCSV(csvContentOrParsed, {
+            ...csvOptions,
+            invertAmounts: invertBankAmounts,
+        });
     }
-    const enrichedSuggestedMatches = [...suggestedMatches, ...combinationMatches];
-    const balances = calculateBalances(convertedYNABTxns, statementBalance, currency);
-    const summary = generateSummary(bankTransactions, convertedYNABTxns, autoMatches, enrichedSuggestedMatches, unmatchedBank, unmatchedYNAB, balances);
+    else {
+        parseResult = csvContentOrParsed;
+    }
+    const newBankTransactions = parseResult.transactions;
+    const csvParseErrors = parseResult.errors;
+    const csvParseWarnings = parseResult.warnings;
+    const newYNABTransactions = normalizeYNABTransactions(ynabTransactions);
+    const normalizedConfig = normalizeConfig(config);
+    const newMatches = findMatches(newBankTransactions, newYNABTransactions, normalizedConfig);
+    const matches = newMatches.map(mapToTransactionMatch);
+    const autoMatches = matches.filter((m) => m.confidence === 'high');
+    const autoMatchedYnabIds = new Set();
+    autoMatches.forEach((m) => {
+        if (m.ynabTransaction)
+            autoMatchedYnabIds.add(m.ynabTransaction.id);
+    });
+    const suggestedMatches = matches.filter((m) => m.confidence === 'medium' &&
+        (!m.ynabTransaction || !autoMatchedYnabIds.has(m.ynabTransaction.id)));
+    const unmatchedBankMatches = matches.filter((m) => m.confidence === 'low' || m.confidence === 'none');
+    const unmatchedBank = unmatchedBankMatches.map((m) => m.bankTransaction);
+    const matchedYnabIds = new Set();
+    matches.forEach((m) => {
+        if (m.ynabTransaction)
+            matchedYnabIds.add(m.ynabTransaction.id);
+    });
+    const unmatchedYNAB = newYNABTransactions.filter((t) => !matchedYnabIds.has(t.id));
+    const balances = calculateBalances(newYNABTransactions, statementBalance, currency);
+    const summary = generateSummary(matches.map((m) => m.bankTransaction), newYNABTransactions, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances);
     const nextSteps = generateNextSteps(summary);
-    const baseInsights = detectInsights(matches, unmatchedBank, summary, balances, config);
-    const insights = mergeInsights(baseInsights, combinationInsights);
+    const insights = detectInsights(unmatchedBank, summary, balances, currency, csvParseErrors, csvParseWarnings);
     const analysis = {
         success: true,
         phase: 'analysis',
         summary,
         auto_matches: autoMatches,
-        suggested_matches: enrichedSuggestedMatches,
+        suggested_matches: suggestedMatches,
         unmatched_bank: unmatchedBank,
         unmatched_ynab: unmatchedYNAB,
         balance_info: balances,
@@ -559,7 +275,7 @@ export function analyzeReconciliation(csvContent, csvFilePath, ynabTransactions,
             account_id: accountId,
             budget_id: budgetId,
             analysis,
-            matching_config: config,
+            matching_config: normalizedConfig,
         });
         analysis.recommendations = recommendations;
     }

package/dist/tools/reconciliation/csvParser.d.ts

@@ -0,0 +1,51 @@
+import type { BankTransaction } from '../../types/reconciliation.js';
+export interface CSVParseResult {
+    transactions: BankTransaction[];
+    errors: ParseError[];
+    warnings: ParseWarning[];
+    meta: {
+        detectedDelimiter: string;
+        detectedColumns: string[];
+        totalRows: number;
+        validRows: number;
+        skippedRows: number;
+    };
+}
+export interface ParseError {
+    row: number;
+    field: string;
+    message: string;
+    rawValue: string;
+}
+export interface ParseWarning {
+    row: number;
+    message: string;
+}
+export interface BankPreset {
+    name: string;
+    dateColumn: string | string[];
+    amountColumn?: string | string[];
+    debitColumn?: string;
+    creditColumn?: string;
+    descriptionColumn: string | string[];
+    amountMultiplier?: number;
+    dateFormat?: 'YMD' | 'MDY' | 'DMY';
+    header?: boolean;
+}
+export declare const BANK_PRESETS: Record<string, BankPreset>;
+export interface ParseCSVOptions {
+    preset?: string;
+    invertAmounts?: boolean;
+    columns?: {
+        date?: string;
+        amount?: string;
+        debit?: string;
+        credit?: string;
+        description?: string;
+    };
+    dateFormat?: 'YMD' | 'MDY' | 'DMY';
+    header?: boolean;
+    maxRows?: number;
+    maxBytes?: number;
+}
+export declare function parseCSV(content: string, options?: ParseCSVOptions): CSVParseResult;