@dizzlkheinz/ynab-mcpb 0.13.1 → 0.15.1

package/dist/tools/reconciliation/index.js

@@ -1,11 +1,14 @@
+import { promises as fs } from 'fs';
 import { z } from 'zod/v4';
 import { withToolErrorHandling } from '../../types/index.js';
 import { analyzeReconciliation } from './analyzer.js';
 import { buildReconciliationPayload } from '../reconcileAdapter.js';
 import { executeReconciliation, } from './executor.js';
 import { responseFormatter } from '../../server/responseFormatter.js';
-import { extractDateRangeFromCSV, autoDetectCSVFormat } from '../compareTransactions/parser.js';
+import { parseCSV } from './csvParser.js';
 import { resolveDeltaFetcherArgs } from '../deltaSupport.js';
+import { detectSignInversion } from './signDetector.js';
+import { normalizeYNABTransactions } from './ynabAdapter.js';
 export { analyzeReconciliation } from './analyzer.js';
 export { findMatches, findBestMatch } from './matcher.js';
 export { normalizePayee, normalizedMatch, fuzzyMatch, payeeSimilarity } from './payeeNormalizer.js';
@@ -38,25 +41,17 @@ export const ReconcileAccountSchema = z
     csv_data: z.string().optional(),
     csv_format: z
         .object({
-        date_column: z.union([z.string(), z.number()]).optional().default('Date'),
+        date_column: z.union([z.string(), z.number()]).optional(),
         amount_column: z.union([z.string(), z.number()]).optional(),
         debit_column: z.union([z.string(), z.number()]).optional(),
         credit_column: z.union([z.string(), z.number()]).optional(),
-        description_column: z.union([z.string(), z.number()]).optional().default('Description'),
-        date_format: z.string().optional().default('MM/DD/YYYY'),
-        has_header: z.boolean().optional().default(true),
-        delimiter: z.string().optional().default(','),
+        description_column: z.union([z.string(), z.number()]).optional(),
+        date_format: z.string().optional(),
+        has_header: z.boolean().optional(),
+        delimiter: z.string().optional(),
     })
         .strict()
-        .optional()
-        .default(() => ({
-        date_column: 'Date',
-        amount_column: 'Amount',
-        description_column: 'Description',
-        date_format: 'MM/DD/YYYY',
-        has_header: true,
-        delimiter: ',',
-    })),
+        .optional(),
     statement_balance: z.number({
         message: 'Statement balance is required and must be a number',
     }),
@@ -65,9 +60,9 @@ export const ReconcileAccountSchema = z
     statement_date: z.string().optional(),
     expected_bank_balance: z.number().optional(),
     as_of_timezone: z.string().optional(),
-    date_tolerance_days: z.number().min(0).max(7).optional().default(5),
+    date_tolerance_days: z.number().min(0).max(7).optional().default(7),
     amount_tolerance_cents: z.number().min(0).max(100).optional().default(1),
-    auto_match_threshold: z.number().min(0).max(100).optional().default(90),
+    auto_match_threshold: z.number().min(0).max(100).optional().default(85),
     suggestion_threshold: z.number().min(0).max(100).optional().default(60),
     amount_tolerance: z.number().min(0).max(1).optional(),
     auto_create_transactions: z.boolean().optional().default(false),
@@ -95,11 +90,19 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
     const forceFullRefresh = params.force_full_refresh ?? true;
     return await withToolErrorHandling(async () => {
         const config = {
-            dateToleranceDays: params.date_tolerance_days,
-            amountToleranceCents: params.amount_tolerance_cents,
-            descriptionSimilarityThreshold: 0.8,
-            autoMatchThreshold: params.auto_match_threshold,
-            suggestionThreshold: params.suggestion_threshold,
+            weights: {
+                amount: 0.5,
+                date: 0.15,
+                payee: 0.35,
+            },
+            dateToleranceDays: params.date_tolerance_days ?? 5,
+            amountToleranceMilliunits: (params.amount_tolerance_cents ?? 1) * 10,
+            autoMatchThreshold: params.auto_match_threshold ?? 90,
+            suggestedMatchThreshold: params.suggestion_threshold ?? 60,
+            minimumCandidateScore: 40,
+            exactAmountBonus: 10,
+            exactDateBonus: 5,
+            exactPayeeBonus: 10,
         };
         const accountResult = forceFullRefresh
             ? await deltaFetcher.fetchAccountsFull(params.budget_id)
@@ -125,28 +128,70 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
             : params.statement_balance;
         const budgetResponse = await ynabAPI.budgets.getBudgetById(params.budget_id);
         const currencyCode = budgetResponse.data.budget?.currency_format?.iso_code ?? 'USD';
+        const dateFormat = mapCsvDateFormatToHint(params.csv_format?.date_format);
+        const csvOptions = {
+            columns: {
+                ...(params.csv_format?.date_column !== undefined && {
+                    date: String(params.csv_format.date_column),
+                }),
+                ...(params.csv_format?.amount_column !== undefined && {
+                    amount: String(params.csv_format.amount_column),
+                }),
+                ...(params.csv_format?.debit_column !== undefined && {
+                    debit: String(params.csv_format.debit_column),
+                }),
+                ...(params.csv_format?.credit_column !== undefined && {
+                    credit: String(params.csv_format.credit_column),
+                }),
+                ...(params.csv_format?.description_column !== undefined && {
+                    description: String(params.csv_format.description_column),
+                }),
+            },
+            ...(dateFormat && { dateFormat }),
+            ...(params.csv_format?.has_header !== undefined && {
+                header: params.csv_format.has_header,
+            }),
+        };
+        let csvContent = params.csv_data ?? '';
+        if (!csvContent && params.csv_file_path) {
+            try {
+                csvContent = await fs.readFile(params.csv_file_path, 'utf8');
+            }
+            catch (error) {
+                const message = error instanceof Error && error.message
+                    ? error.message
+                    : 'Unknown error while reading CSV file';
+                throw new Error(`Failed to read CSV file at path ${params.csv_file_path}: ${message}`);
+            }
+        }
         let sinceDate;
+        let parseResult;
         if (params.statement_start_date) {
             sinceDate = new Date(params.statement_start_date);
         }
         else {
             try {
-                const csvContent = params.csv_data || params.csv_file_path || '';
-                const csvFormat = params.csv_format || autoDetectCSVFormat(csvContent);
-                const parserFormat = {
-                    date_column: csvFormat.date_column || 'Date',
-                    amount_column: csvFormat.amount_column,
-                    debit_column: csvFormat.debit_column,
-                    credit_column: csvFormat.credit_column,
-                    description_column: csvFormat.description_column || 'Description',
-                    date_format: csvFormat.date_format || 'MM/DD/YYYY',
-                    has_header: csvFormat.has_header ?? true,
-                    delimiter: csvFormat.delimiter || ',',
-                };
-                const { minDate } = extractDateRangeFromCSV(csvContent, parserFormat);
-                const minDateObj = new Date(minDate);
-                minDateObj.setDate(minDateObj.getDate() - 7);
-                sinceDate = minDateObj;
+                parseResult = parseCSV(csvContent, {
+                    ...csvOptions,
+                    invertAmounts: shouldInvertBankAmounts,
+                });
+                if (parseResult.transactions.length > 0) {
+                    const dates = parseResult.transactions
+                        .map((t) => new Date(t.date).getTime())
+                        .filter((t) => !isNaN(t));
+                    if (dates.length > 0) {
+                        const minTime = Math.min(...dates);
+                        const minDateObj = new Date(minTime);
+                        minDateObj.setDate(minDateObj.getDate() - 7);
+                        sinceDate = minDateObj;
+                    }
+                    else {
+                        sinceDate = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
+                    }
+                }
+                else {
+                    sinceDate = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
+                }
             }
             catch {
                 sinceDate = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
@@ -157,6 +202,21 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
             ? await deltaFetcher.fetchTransactionsByAccountFull(params.budget_id, params.account_id, sinceDateString)
             : await deltaFetcher.fetchTransactionsByAccount(params.budget_id, params.account_id, sinceDateString);
         const ynabTransactions = transactionsResult.data;
+        let finalInvertAmounts = shouldInvertBankAmounts;
+        if (params.invert_bank_amounts === undefined && csvContent) {
+            const rawParseResult = parseCSV(csvContent, {
+                ...csvOptions,
+                invertAmounts: false,
+            });
+            if (rawParseResult.transactions.length > 0 && ynabTransactions.length > 0) {
+                const normalizedYNAB = normalizeYNABTransactions(ynabTransactions);
+                const needsInversion = detectSignInversion(rawParseResult.transactions, normalizedYNAB);
+                finalInvertAmounts = needsInversion;
+                if (needsInversion !== shouldInvertBankAmounts && parseResult) {
+                    parseResult = undefined;
+                }
+            }
+        }
         const auditMetadata = {
             data_freshness: getDataFreshness(transactionsResult, forceFullRefresh),
             data_source: getAuditDataSource(transactionsResult, forceFullRefresh),
@@ -170,12 +230,12 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
                 delta_merge_applied: transactionsResult.usedDelta,
             },
         };
-        const analysis = analyzeReconciliation(params.csv_data || params.csv_file_path || '', params.csv_file_path, ynabTransactions, adjustedStatementBalance, config, currencyCode, params.account_id, params.budget_id, shouldInvertBankAmounts);
         const initialAccount = {
             balance: accountData.balance,
             cleared_balance: accountData.cleared_balance,
             uncleared_balance: accountData.uncleared_balance,
         };
+        const analysis = analyzeReconciliation(parseResult ?? csvContent, params.csv_file_path, ynabTransactions, adjustedStatementBalance, config, currencyCode, params.account_id, params.budget_id, finalInvertAmounts, csvOptions, initialAccount);
         let executionData;
         const wantsBalanceVerification = Boolean(params.statement_date);
         const shouldExecute = params.auto_create_transactions ||
@@ -222,6 +282,22 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
         };
     }, 'ynab:reconcile_account', 'analyzing account reconciliation');
 }
+function mapCsvDateFormatToHint(format) {
+    if (!format) {
+        return undefined;
+    }
+    const normalized = format.toUpperCase().replace(/[^YMD]/g, '');
+    if (normalized === 'YYYYMMDD' || normalized === 'YYMMDD' || normalized === 'YMD') {
+        return 'YMD';
+    }
+    if (normalized === 'MMDDYYYY' || normalized === 'MDY') {
+        return 'MDY';
+    }
+    if (normalized === 'DDMMYYYY' || normalized === 'DMY') {
+        return 'DMY';
+    }
+    return undefined;
+}
 function mapCsvFormatForPayload(format) {
     if (!format) {
         return undefined;

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

@@ -1,3 +1,24 @@
-import type { BankTransaction, YNABTransaction, TransactionMatch, MatchingConfig } from './types.js';
-export declare function findBestMatch(bankTxn: BankTransaction, ynabTransactions: YNABTransaction[], usedIds: Set<string>, config: MatchingConfig): TransactionMatch;
-export declare function findMatches(bankTransactions: BankTransaction[], ynabTransactions: YNABTransaction[], config?: MatchingConfig): TransactionMatch[];
+import type { BankTransaction as CanonicalBankTransaction, NormalizedYNABTransaction } from '../../types/reconciliation.js';
+import { type MatchingConfig } from './types.js';
+export type { MatchingConfig };
+export interface MatchCandidate {
+    ynabTransaction: NormalizedYNABTransaction;
+    scores: {
+        amount: number;
+        date: number;
+        payee: number;
+        combined: number;
+    };
+    matchReasons: string[];
+}
+export interface MatchResult {
+    bankTransaction: CanonicalBankTransaction;
+    bestMatch: MatchCandidate | null;
+    candidates: MatchCandidate[];
+    confidence: 'high' | 'medium' | 'low' | 'none';
+    confidenceScore: number;
+}
+export declare const DEFAULT_CONFIG: MatchingConfig;
+export declare function normalizeConfig(config?: MatchingConfig): MatchingConfig;
+export declare function findMatches(bankTransactions: CanonicalBankTransaction[], ynabTransactions: NormalizedYNABTransaction[], config?: MatchingConfig): MatchResult[];
+export declare function findBestMatch(bankTransaction: CanonicalBankTransaction, ynabTransactions: NormalizedYNABTransaction[], usedYnabIds?: Set<string>, config?: MatchingConfig): MatchResult;

package/dist/tools/reconciliation/matcher.js

@@ -1,160 +1,202 @@
-import { normalizedMatch, payeeSimilarity } from './payeeNormalizer.js';
-import { DEFAULT_MATCHING_CONFIG } from './types.js';
-function amountsMatch(bankAmount, ynabAmount, toleranceCents) {
-    const ynabDollars = ynabAmount / 1000;
-    const difference = Math.round(Math.abs(bankAmount - ynabDollars) * 100) / 100;
-    const toleranceDollars = toleranceCents / 100;
-    return difference <= toleranceDollars;
-}
-function datesMatch(date1, date2, toleranceDays) {
-    const d1 = new Date(date1);
-    const d2 = new Date(date2);
-    const diffMs = Math.abs(d1.getTime() - d2.getTime());
-    const diffDays = diffMs / (1000 * 60 * 60 * 24);
-    return diffDays <= toleranceDays;
-}
-function calculateMatchScore(bankTxn, ynabTxn, config) {
-    const reasons = [];
-    let score = 0;
-    const amountMatch = amountsMatch(bankTxn.amount, ynabTxn.amount, config.amountToleranceCents);
-    if (!amountMatch) {
-        return { score: 0, reasons: ['Amount does not match'] };
-    }
-    score += 40;
-    reasons.push('Amount matches');
-    const dateWithinTolerance = datesMatch(bankTxn.date, ynabTxn.date, config.dateToleranceDays);
-    if (dateWithinTolerance) {
-        score += 40;
-        const daysDiff = Math.abs((new Date(bankTxn.date).getTime() - new Date(ynabTxn.date).getTime()) / (1000 * 60 * 60 * 24));
-        if (daysDiff === 0) {
-            reasons.push('Exact date match');
-        }
-        else {
-            reasons.push(`Date within ${Math.round(daysDiff)} days`);
-        }
+import * as fuzz from 'fuzzball';
+export const DEFAULT_CONFIG = {
+    weights: {
+        amount: 0.5,
+        date: 0.15,
+        payee: 0.35,
+    },
+    amountToleranceMilliunits: 10,
+    dateToleranceDays: 7,
+    autoMatchThreshold: 85,
+    suggestedMatchThreshold: 60,
+    minimumCandidateScore: 40,
+    exactAmountBonus: 10,
+    exactDateBonus: 5,
+    exactPayeeBonus: 10,
+};
+export function normalizeConfig(config) {
+    if (!config) {
+        return { ...DEFAULT_CONFIG };
     }
-    const payeeScore = payeeSimilarity(bankTxn.payee, ynabTxn.payee_name);
-    if (normalizedMatch(bankTxn.payee, ynabTxn.payee_name)) {
-        score += 20;
-        reasons.push('Payee exact match');
+    return {
+        weights: config.weights ?? DEFAULT_CONFIG.weights,
+        amountToleranceMilliunits: config.amountToleranceMilliunits ?? DEFAULT_CONFIG.amountToleranceMilliunits,
+        dateToleranceDays: config.dateToleranceDays ?? DEFAULT_CONFIG.dateToleranceDays,
+        autoMatchThreshold: config.autoMatchThreshold ?? DEFAULT_CONFIG.autoMatchThreshold,
+        suggestedMatchThreshold: config.suggestedMatchThreshold ?? DEFAULT_CONFIG.suggestedMatchThreshold,
+        minimumCandidateScore: config.minimumCandidateScore ?? DEFAULT_CONFIG.minimumCandidateScore,
+        exactAmountBonus: config.exactAmountBonus ?? DEFAULT_CONFIG.exactAmountBonus,
+        exactDateBonus: config.exactDateBonus ?? DEFAULT_CONFIG.exactDateBonus,
+        exactPayeeBonus: config.exactPayeeBonus ?? DEFAULT_CONFIG.exactPayeeBonus,
+    };
+}
+function matchSingle(bankTxn, ynabTransactions, usedIds, configInput) {
+    const config = normalizeConfig(configInput);
+    const candidates = findCandidates(bankTxn, ynabTransactions, usedIds, config);
+    const bestMatch = candidates.length > 0 ? candidates[0] : null;
+    const confidenceScore = bestMatch?.scores.combined ?? 0;
+    let confidence;
+    if (confidenceScore >= config.autoMatchThreshold) {
+        confidence = 'high';
+        if (bestMatch)
+            usedIds.add(bestMatch.ynabTransaction.id);
     }
-    else if (payeeScore >= 95) {
-        score += 15;
-        reasons.push(`Payee highly similar (${Math.round(payeeScore)}%)`);
+    else if (confidenceScore >= config.suggestedMatchThreshold) {
+        confidence = 'medium';
     }
-    else if (payeeScore >= 80) {
-        score += 10;
-        reasons.push(`Payee similar (${Math.round(payeeScore)}%)`);
+    else if (confidenceScore >= config.minimumCandidateScore) {
+        confidence = 'low';
     }
-    else if (payeeScore >= 60) {
-        score += 6;
-        reasons.push(`Payee somewhat similar (${Math.round(payeeScore)}%)`);
+    else {
+        confidence = 'none';
     }
-    return { score: Math.round(score), reasons };
+    return {
+        bankTransaction: bankTxn,
+        bestMatch,
+        candidates: candidates.slice(0, 3),
+        confidence,
+        confidenceScore,
+    };
 }
-function getPriority(ynabTxn) {
-    if (ynabTxn.cleared === 'uncleared')
-        return 10;
-    if (ynabTxn.cleared === 'cleared')
-        return 5;
-    if (ynabTxn.cleared === 'reconciled')
-        return 1;
-    return 0;
+export function findMatches(bankTransactions, ynabTransactions, config) {
+    const usedYnabIds = new Set();
+    const results = [];
+    for (const bankTxn of bankTransactions) {
+        results.push(matchSingle(bankTxn, ynabTransactions, usedYnabIds, config));
+    }
+    return results;
 }
-function findMatchCandidates(bankTxn, ynabTransactions, usedIds, config) {
+function findCandidates(bankTxn, ynabTransactions, usedIds, config) {
     const candidates = [];
     for (const ynabTxn of ynabTransactions) {
         if (usedIds.has(ynabTxn.id))
             continue;
-        if (bankTxn.amount > 0 !== ynabTxn.amount > 0)
+        const bankSign = Math.sign(bankTxn.amount);
+        const ynabSign = Math.sign(ynabTxn.amount);
+        if (bankSign !== ynabSign && bankSign !== 0 && ynabSign !== 0) {
+            continue;
+        }
+        const amountDiff = Math.abs(bankTxn.amount - ynabTxn.amount);
+        if (amountDiff > config.amountToleranceMilliunits) {
             continue;
-        const { score, reasons } = calculateMatchScore(bankTxn, ynabTxn, config);
-        if (score >= 30) {
+        }
+        const scores = calculateScores(bankTxn, ynabTxn, config);
+        if (scores.combined >= config.minimumCandidateScore) {
             candidates.push({
-                ynab_transaction: ynabTxn,
-                confidence: score,
-                match_reason: reasons.join(', '),
-                explanation: buildExplanation(bankTxn, ynabTxn, score, reasons),
+                ynabTransaction: ynabTxn,
+                scores,
+                matchReasons: buildMatchReasons(scores, config),
             });
         }
     }
     candidates.sort((a, b) => {
-        if (b.confidence !== a.confidence) {
-            return b.confidence - a.confidence;
+        const scoreDiff = b.scores.combined - a.scores.combined;
+        if (scoreDiff !== 0) {
+            return scoreDiff;
+        }
+        const aUncleared = a.ynabTransaction.cleared === 'uncleared' ? 1 : 0;
+        const bUncleared = b.ynabTransaction.cleared === 'uncleared' ? 1 : 0;
+        if (aUncleared !== bUncleared) {
+            return bUncleared - aUncleared;
+        }
+        const bankTime = new Date(bankTxn.date).getTime();
+        const aDiff = Math.abs(bankTime - new Date(a.ynabTransaction.date).getTime());
+        const bDiff = Math.abs(bankTime - new Date(b.ynabTransaction.date).getTime());
+        if (aDiff !== bDiff) {
+            return aDiff - bDiff;
         }
-        const priorityDiff = getPriority(b.ynab_transaction) - getPriority(a.ynab_transaction);
-        if (priorityDiff !== 0)
-            return priorityDiff;
-        const dateProximityA = Math.abs(new Date(bankTxn.date).getTime() - new Date(a.ynab_transaction.date).getTime());
-        const dateProximityB = Math.abs(new Date(bankTxn.date).getTime() - new Date(b.ynab_transaction.date).getTime());
-        return dateProximityA - dateProximityB;
+        return 0;
     });
     return candidates;
 }
-function buildExplanation(_bankTxn, ynabTxn, score, reasons) {
-    const parts = [];
-    parts.push(`Match confidence: ${score}%`);
-    parts.push(reasons.join(', '));
-    if (ynabTxn.cleared === 'uncleared') {
-        parts.push('(Uncleared - awaiting confirmation)');
-    }
-    return parts.join(' | ');
-}
-export function findBestMatch(bankTxn, ynabTransactions, usedIds, config) {
-    const candidates = findMatchCandidates(bankTxn, ynabTransactions, usedIds, config);
-    if (candidates.length === 0) {
-        return {
-            bank_transaction: bankTxn,
-            confidence: 'none',
-            confidence_score: 0,
-            match_reason: 'No matching transaction found in YNAB',
-            action_hint: 'add_to_ynab',
-            recommendation: 'This transaction appears on bank statement but not in YNAB',
-        };
-    }
-    const bestCandidate = candidates[0];
-    const bestScore = bestCandidate.confidence;
-    if (bestScore >= config.autoMatchThreshold) {
-        return {
-            bank_transaction: bankTxn,
-            ynab_transaction: bestCandidate.ynab_transaction,
-            confidence: 'high',
-            confidence_score: bestScore,
-            match_reason: bestCandidate.match_reason,
-        };
-    }
-    if (bestScore >= config.suggestionThreshold) {
-        return {
-            bank_transaction: bankTxn,
-            ynab_transaction: bestCandidate.ynab_transaction,
-            candidates: candidates.slice(0, 3),
-            confidence: 'medium',
-            confidence_score: bestScore,
-            match_reason: bestCandidate.match_reason,
-            top_confidence: bestScore,
-            action_hint: 'review_and_choose',
-        };
+function calculateScores(bankTxn, ynabTxn, config) {
+    const amountDiff = Math.abs(bankTxn.amount - ynabTxn.amount);
+    let amountScore;
+    if (amountDiff === 0) {
+        amountScore = 100;
+    }
+    else if (amountDiff <= config.amountToleranceMilliunits) {
+        amountScore = 95;
     }
+    else if (amountDiff <= 1000) {
+        amountScore = 80 - (amountDiff / 1000) * 20;
+    }
+    else {
+        amountScore = Math.max(0, 60 - (amountDiff / 1000) * 5);
+    }
+    const bankDate = new Date(bankTxn.date);
+    const ynabDate = new Date(ynabTxn.date);
+    const daysDiff = Math.abs(bankDate.getTime() - ynabDate.getTime()) / (1000 * 60 * 60 * 24);
+    let dateScore;
+    if (daysDiff < 0.5) {
+        dateScore = 100;
+    }
+    else if (daysDiff <= 1) {
+        dateScore = 95;
+    }
+    else if (daysDiff <= config.dateToleranceDays) {
+        dateScore = 90 - (daysDiff - 1) * (40 / config.dateToleranceDays);
+    }
+    else {
+        dateScore = Math.max(0, 50 - (daysDiff - config.dateToleranceDays) * 5);
+    }
+    const payeeScore = calculatePayeeScore(bankTxn.payee, ynabTxn.payee);
+    let combined = amountScore * config.weights.amount +
+        dateScore * config.weights.date +
+        payeeScore * config.weights.payee;
+    if (amountScore === 100)
+        combined += config.exactAmountBonus;
+    if (dateScore === 100)
+        combined += config.exactDateBonus;
+    if (payeeScore >= 95)
+        combined += config.exactPayeeBonus;
+    combined = Math.min(100, combined);
     return {
-        bank_transaction: bankTxn,
-        candidates: candidates.slice(0, 3),
-        confidence: 'low',
-        confidence_score: bestScore,
-        match_reason: 'Low confidence match',
-        top_confidence: bestScore,
-        action_hint: 'review_or_add_new',
-        recommendation: 'Consider reviewing candidates or adding as new transaction',
+        amount: Math.round(amountScore),
+        date: Math.round(dateScore),
+        payee: Math.round(payeeScore),
+        combined: Math.round(combined),
     };
 }
-export function findMatches(bankTransactions, ynabTransactions, config = DEFAULT_MATCHING_CONFIG) {
-    const matches = [];
-    const usedIds = new Set();
-    for (const bankTxn of bankTransactions) {
-        const match = findBestMatch(bankTxn, ynabTransactions, usedIds, config);
-        matches.push(match);
-        if (match.confidence === 'high' && match.ynab_transaction) {
-            usedIds.add(match.ynab_transaction.id);
-        }
+function calculatePayeeScore(bankPayee, ynabPayee) {
+    if (!ynabPayee)
+        return 30;
+    const scores = [
+        fuzz.token_set_ratio(bankPayee, ynabPayee),
+        fuzz.token_sort_ratio(bankPayee, ynabPayee),
+        fuzz.partial_ratio(bankPayee, ynabPayee),
+        fuzz.WRatio(bankPayee, ynabPayee),
+    ];
+    return Math.max(...scores);
+}
+function buildMatchReasons(scores, config) {
+    const reasons = [];
+    if (scores.amount === 100) {
+        reasons.push('Exact amount match');
+    }
+    else if (scores.amount >= 95) {
+        reasons.push('Amount within tolerance');
+    }
+    if (scores.date === 100) {
+        reasons.push('Same date');
+    }
+    else if (scores.date >= 90) {
+        reasons.push('Date within 1-2 days');
+    }
+    else if (scores.date >= 50) {
+        reasons.push(`Date within ${config.dateToleranceDays} days`);
     }
-    return matches;
+    if (scores.payee >= 95) {
+        reasons.push('Payee exact match');
+    }
+    else if (scores.payee >= 80) {
+        reasons.push('Payee highly similar');
+    }
+    else if (scores.payee >= 60) {
+        reasons.push('Payee somewhat similar');
+    }
+    return reasons;
+}
+export function findBestMatch(bankTransaction, ynabTransactions, usedYnabIds = new Set(), config) {
+    return matchSingle(bankTransaction, ynabTransactions, usedYnabIds, config);
 }