@dizzlkheinz/ynab-mcpb 0.12.2 → 0.15.0

package/dist/tools/reconciliation/csvParser.js

@@ -0,0 +1,413 @@
+import Papa from 'papaparse';
+import * as chrono from 'chrono-node';
+import { randomUUID } from 'crypto';
+export const BANK_PRESETS = {
+    td: {
+        name: 'TD Canada Trust',
+        header: false,
+        dateColumn: ['0', 'Date'],
+        amountColumn: ['Amount'],
+        debitColumn: '2',
+        creditColumn: '3',
+        descriptionColumn: ['1', 'Description'],
+        dateFormat: 'MDY',
+    },
+    rbc: {
+        name: 'RBC Royal Bank',
+        dateColumn: ['Transaction Date', 'Date'],
+        debitColumn: 'Debit',
+        creditColumn: 'Credit',
+        descriptionColumn: ['Description 1', 'Description', 'Transaction'],
+        dateFormat: 'YMD',
+    },
+    scotiabank: {
+        name: 'Scotiabank',
+        dateColumn: ['Date', 'Transaction Date'],
+        amountColumn: ['Amount'],
+        descriptionColumn: ['Description', 'Transaction Details'],
+        dateFormat: 'DMY',
+    },
+    wealthsimple: {
+        name: 'Wealthsimple',
+        dateColumn: ['Date'],
+        amountColumn: ['Amount'],
+        descriptionColumn: ['Description', 'Payee'],
+        amountMultiplier: 1,
+        dateFormat: 'YMD',
+    },
+    tangerine: {
+        name: 'Tangerine',
+        dateColumn: ['Date', 'Transaction date'],
+        amountColumn: ['Amount'],
+        descriptionColumn: ['Name', 'Transaction name', 'Memo'],
+        dateFormat: 'MDY',
+    },
+};
+function autoDetectFormat(content) {
+    const preview = Papa.parse(content, {
+        preview: 5,
+        header: false,
+        skipEmptyLines: true,
+    });
+    if (preview.errors.length > 0 || preview.data.length === 0)
+        return undefined;
+    const rows = preview.data;
+    const firstRow = rows[0];
+    if (!firstRow)
+        return undefined;
+    const headerMatch = detectPreset(firstRow);
+    if (headerMatch) {
+        const key = Object.keys(BANK_PRESETS).find((k) => BANK_PRESETS[k] === headerMatch);
+        if (key)
+            return { preset: key, header: true };
+    }
+    if (checkTDPattern(rows)) {
+        return { preset: 'td', header: false };
+    }
+    return undefined;
+}
+function checkTDPattern(rows) {
+    const validRows = rows.filter((r) => r.length >= 4);
+    if (validRows.length === 0)
+        return false;
+    let matchCount = 0;
+    for (const row of validRows) {
+        if (!/^\d{1,2}\/\d{1,2}\/\d{4}$/.test(row[0] || ''))
+            continue;
+        const isDebitNumeric = !row[2] || /^-?[\d,.]+$/.test(row[2]);
+        const isCreditNumeric = !row[3] || /^-?[\d,.]+$/.test(row[3]);
+        if (isDebitNumeric && isCreditNumeric) {
+            matchCount++;
+        }
+    }
+    return matchCount > validRows.length / 2;
+}
+export function parseCSV(content, options = {}) {
+    const errors = [];
+    const warnings = [];
+    const MAX_BYTES = options.maxBytes ?? 10 * 1024 * 1024;
+    if (content.length > MAX_BYTES) {
+        throw new Error(`File size exceeds limit of ${Math.round(MAX_BYTES / 1024 / 1024)}MB`);
+    }
+    let detectedPreset = options.preset;
+    let detectedHeader = options.header;
+    if (!detectedPreset || detectedHeader === undefined) {
+        const autoResult = autoDetectFormat(content);
+        if (autoResult) {
+            if (!detectedPreset) {
+                detectedPreset = autoResult.preset;
+            }
+            if (detectedHeader === undefined && autoResult.header !== undefined) {
+                detectedHeader = autoResult.header;
+            }
+        }
+    }
+    let hasHeader = true;
+    if (detectedHeader !== undefined) {
+        hasHeader = detectedHeader;
+    }
+    else if (detectedPreset) {
+        const preset = BANK_PRESETS[detectedPreset];
+        if (preset && preset.header !== undefined) {
+            hasHeader = preset.header;
+        }
+    }
+    const maxRows = options.maxRows ?? 10000;
+    const parsed = Papa.parse(content, {
+        header: hasHeader,
+        preview: maxRows + (hasHeader ? 1 : 0),
+        dynamicTyping: false,
+        skipEmptyLines: true,
+        transformHeader: (h) => h.trim(),
+    });
+    if (parsed.errors.length > 0) {
+        for (const err of parsed.errors) {
+            errors.push({
+                row: err.row ?? 0,
+                field: 'csv',
+                message: err.message,
+                rawValue: '',
+            });
+        }
+    }
+    const rows = parsed.data;
+    let columns = [];
+    if (hasHeader) {
+        columns = parsed.meta.fields ?? [];
+    }
+    else {
+        const maxLen = rows.reduce((max, row) => Math.max(max, Array.isArray(row) ? row.length : 0), 0);
+        columns = Array.from({ length: maxLen }, (_, i) => String(i));
+    }
+    const preset = detectedPreset
+        ? BANK_PRESETS[detectedPreset]
+        : hasHeader
+            ? detectPreset(columns)
+            : undefined;
+    const dateCandidates = options.columns?.date
+        ? [options.columns.date]
+        : (preset?.dateColumn ?? ['Date', 'Transaction Date', 'Posted Date']);
+    const descCandidates = options.columns?.description
+        ? [options.columns.description]
+        : (preset?.descriptionColumn ?? ['Description', 'Payee', 'Merchant', 'Name']);
+    const dateCol = findColumn(columns, dateCandidates, !hasHeader);
+    const descCol = findColumn(columns, descCandidates, !hasHeader);
+    let amountCol = null;
+    let debitCol = null;
+    let creditCol = null;
+    if (options.columns?.debit && options.columns?.credit) {
+        debitCol = findColumn(columns, [options.columns.debit], !hasHeader);
+        creditCol = findColumn(columns, [options.columns.credit], !hasHeader);
+    }
+    else if (preset?.debitColumn &&
+        preset?.creditColumn &&
+        !options.columns?.amount &&
+        (hasHeader ? !preset?.amountColumn : true)) {
+        debitCol = findColumn(columns, [preset.debitColumn], !hasHeader);
+        creditCol = findColumn(columns, [preset.creditColumn], !hasHeader);
+    }
+    else {
+        const amountCandidates = options.columns?.amount
+            ? [options.columns.amount]
+            : (preset?.amountColumn ?? ['Amount', 'CAD$', 'Value']);
+        amountCol = findColumn(columns, amountCandidates, !hasHeader);
+    }
+    if (!dateCol) {
+        errors.push({
+            row: 0,
+            field: 'date',
+            message: `Could not identify date column from: ${columns.join(', ')}. Try using preset option (td, rbc, scotiabank, etc.) or specify columns manually with columns.date`,
+            rawValue: columns.join(', '),
+        });
+    }
+    if (!amountCol && (!debitCol || !creditCol)) {
+        if (!debitCol && !creditCol) {
+            errors.push({
+                row: 0,
+                field: 'amount',
+                message: `Could not identify amount column from: ${columns.join(', ')}. Try using preset option or specify columns manually with columns.amount (or columns.debit/credit for split columns)`,
+                rawValue: columns.join(', '),
+            });
+        }
+        else if (!debitCol || !creditCol) {
+            errors.push({
+                row: 0,
+                field: 'amount',
+                message: `Could not identify debit/credit columns pair from: ${columns.join(', ')}. Found ${debitCol ? 'debit' : 'credit'} but missing ${debitCol ? 'credit' : 'debit'}. Specify both with columns.debit and columns.credit`,
+                rawValue: columns.join(', '),
+            });
+        }
+    }
+    const transactions = [];
+    const dateFormat = options.dateFormat ?? preset?.dateFormat;
+    for (let i = 0; i < Math.min(rows.length, maxRows); i++) {
+        const row = rows[i];
+        if (!row)
+            continue;
+        const getValue = (colName) => {
+            if (!colName)
+                return '';
+            if (Array.isArray(row)) {
+                const idx = parseInt(colName, 10);
+                return String(row[idx] ?? '');
+            }
+            return String(row[colName] ?? '');
+        };
+        const rowNum = i + (hasHeader ? 2 : 1);
+        const rowWarnings = [];
+        const rawDate = getValue(dateCol)?.trim() ?? '';
+        const parsedDate = parseDate(rawDate, dateFormat);
+        if (!parsedDate) {
+            errors.push({
+                row: rowNum,
+                field: 'date',
+                message: `Could not parse date: "${rawDate}"`,
+                rawValue: rawDate,
+            });
+            continue;
+        }
+        const dateStr = formatLocalDate(parsedDate);
+        let amountMilliunits;
+        let rawAmount;
+        if (amountCol) {
+            rawAmount = getValue(amountCol)?.trim() ?? '';
+            amountMilliunits = dollarStringToMilliunits(rawAmount);
+        }
+        else if (debitCol && creditCol) {
+            const debit = getValue(debitCol)?.trim() ?? '';
+            const credit = getValue(creditCol)?.trim() ?? '';
+            rawAmount = debit || credit;
+            const debitMilliunits = dollarStringToMilliunits(debit);
+            const creditMilliunits = dollarStringToMilliunits(credit);
+            if (Math.abs(debitMilliunits) > 0 && Math.abs(creditMilliunits) > 0) {
+                const warning = `Both Debit (${debit}) and Credit (${credit}) have values - using Debit`;
+                rowWarnings.push(warning);
+                warnings.push({ row: rowNum, message: warning });
+            }
+            if (Math.abs(debitMilliunits) > 0) {
+                amountMilliunits = -Math.abs(debitMilliunits);
+            }
+            else if (Math.abs(creditMilliunits) > 0) {
+                amountMilliunits = Math.abs(creditMilliunits);
+            }
+            else {
+                amountMilliunits = 0;
+            }
+            if (debitMilliunits < 0) {
+                const warning = `Debit column contains negative value (${debit}) - treating as positive debit`;
+                rowWarnings.push(warning);
+                warnings.push({ row: rowNum, message: warning });
+            }
+        }
+        else {
+            continue;
+        }
+        if (!Number.isFinite(amountMilliunits)) {
+            errors.push({
+                row: rowNum,
+                field: 'amount',
+                message: `Invalid amount: "${rawAmount}"`,
+                rawValue: rawAmount,
+            });
+            continue;
+        }
+        const multiplier = options.invertAmounts ? -1 : (preset?.amountMultiplier ?? 1);
+        amountMilliunits *= multiplier;
+        let rawDesc = getValue(descCol)?.trim() ?? '';
+        rawDesc = rawDesc
+            .replace(/[\u0000-\u001F\u007F-\u009F]/g, '')
+            .replace(/[\u202A-\u202E\u2066-\u2069]/g, '')
+            .replace(/[\u200B-\u200D\uFEFF]/g, '')
+            .replace(/[\u2028-\u2029]/g, '')
+            .substring(0, 500);
+        transactions.push({
+            id: randomUUID(),
+            date: dateStr,
+            amount: amountMilliunits,
+            payee: rawDesc || 'Unknown',
+            sourceRow: rowNum,
+            raw: {
+                date: rawDate,
+                amount: rawAmount,
+                description: rawDesc,
+            },
+            ...(rowWarnings.length > 0 && { warnings: rowWarnings }),
+        });
+    }
+    return {
+        transactions,
+        errors,
+        warnings,
+        meta: {
+            detectedDelimiter: parsed.meta.delimiter || ',',
+            detectedColumns: columns,
+            totalRows: rows.length,
+            validRows: transactions.length,
+            skippedRows: rows.length - transactions.length,
+        },
+    };
+}
+function parseDate(raw, formatHint) {
+    if (!raw)
+        return null;
+    const isoMatch = raw.match(/^(\d{4})-(\d{2})-(\d{2})/);
+    if (isoMatch) {
+        const [, year, month, day] = isoMatch;
+        return new Date(Date.UTC(parseInt(year), parseInt(month) - 1, parseInt(day)));
+    }
+    const numericMatch = raw.match(/^(\d{1,4})[/-](\d{1,2})[/-](\d{1,4})$/);
+    if (numericMatch && formatHint) {
+        const [, a, b, c] = numericMatch;
+        let year, month, day;
+        switch (formatHint) {
+            case 'YMD':
+                year = parseInt(a);
+                month = parseInt(b);
+                day = parseInt(c);
+                break;
+            case 'MDY':
+                month = parseInt(a);
+                day = parseInt(b);
+                year = parseInt(c);
+                break;
+            case 'DMY':
+                day = parseInt(a);
+                month = parseInt(b);
+                year = parseInt(c);
+                break;
+        }
+        if (year < 100)
+            year += 2000;
+        if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+            return new Date(Date.UTC(year, month - 1, day));
+        }
+    }
+    const parsed = chrono.parseDate(raw);
+    if (parsed) {
+        return new Date(Date.UTC(parsed.getFullYear(), parsed.getMonth(), parsed.getDate()));
+    }
+    return null;
+}
+function formatLocalDate(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function findColumn(available, candidates, exactIndex = false) {
+    const candidateList = Array.isArray(candidates) ? candidates : [candidates];
+    for (const candidate of candidateList) {
+        if (exactIndex) {
+            if (available.includes(candidate))
+                return candidate;
+        }
+        else {
+            const lower = candidate.toLowerCase();
+            const found = available.find((col) => col.toLowerCase() === lower);
+            if (found)
+                return found;
+        }
+    }
+    if (!exactIndex) {
+        for (const candidate of candidateList) {
+            const lower = candidate.toLowerCase();
+            const found = available.find((col) => col.toLowerCase().includes(lower));
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function detectPreset(columns) {
+    const colSet = new Set(columns.map((c) => c.toLowerCase()));
+    if (colSet.has('description 1') || colSet.has('account type')) {
+        return BANK_PRESETS['rbc'];
+    }
+    if (columns.some((c) => c.toLowerCase().includes('cad$'))) {
+        return BANK_PRESETS['td'];
+    }
+    if (colSet.has('date') && colSet.has('description') && colSet.has('amount')) {
+        return BANK_PRESETS['td'];
+    }
+    return undefined;
+}
+const CURRENCY_SYMBOLS = /[$€£¥]/g;
+const CURRENCY_CODES = /\b(CAD|USD|EUR|GBP)\b/gi;
+function dollarStringToMilliunits(str) {
+    if (!str)
+        return 0;
+    let cleaned = str.replace(CURRENCY_SYMBOLS, '').replace(CURRENCY_CODES, '').trim();
+    if (cleaned.startsWith('(') && cleaned.endsWith(')')) {
+        cleaned = '-' + cleaned.slice(1, -1);
+    }
+    if (/^-?\d{1,3}(\.\d{3})+,\d{2}$/.test(cleaned)) {
+        cleaned = cleaned.replace(/\./g, '').replace(',', '.');
+    }
+    if (cleaned.includes('.')) {
+        cleaned = cleaned.replace(/,/g, '');
+    }
+    const dollars = parseFloat(cleaned);
+    if (!Number.isFinite(dollars))
+        return 0;
+    return Math.round(dollars * 1000);
+}

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

@@ -56,6 +56,14 @@ export interface ExecutionResult {
     bulk_operation_details?: BulkOperationDetails;
 }
 export declare function executeReconciliation(options: ExecutionOptions): Promise<ExecutionResult>;
+export interface NormalizedYnabError {
+    status?: number;
+    name?: string;
+    message: string;
+    detail?: string;
+}
+export declare function normalizeYnabError(error: unknown): NormalizedYnabError;
+export declare function shouldPropagateYnabError(error: NormalizedYnabError): boolean;
 declare function buildBalanceReconciliation(args: {
     ynabAPI: ynab.API;
     budgetId: string;