@dizzlkheinz/ynab-mcpb 0.15.0 → 0.16.0

package/dist/server/YNABMCPServer.d.ts

@@ -69,7 +69,7 @@ export declare class YNABMCPServer {
         }[];
     }>;
     handleListResources(): Promise<{
-        resources: import("./resources.js").ResourceDefinition[];
+        resources: import("@modelcontextprotocol/sdk/types.js").Resource[];
     }>;
     handleReadResource(params: {
         uri: string;
@@ -139,11 +139,7 @@ export declare class YNABMCPServer {
         } | undefined;
         isError?: boolean | undefined;
     } | {
-        contents: {
-            uri: string;
-            mimeType: string;
-            text: string;
-        }[];
+        contents: import("@modelcontextprotocol/sdk/types.js").ResourceContents[];
     }>;
     handleListPrompts(): Promise<{
         prompts: import("./prompts.js").PromptDefinition[];

package/dist/server/YNABMCPServer.js

@@ -3,7 +3,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import * as ynab from 'ynab';
 import { AuthenticationError, ConfigurationError, ValidationError as ConfigValidationError, } from '../utils/errors.js';
 import { ValidationError } from '../types/index.js';
@@ -99,6 +99,7 @@ export class YNABMCPServer {
         this.resourceManager = new ResourceManager({
             ynabAPI: this.ynabAPI,
             responseFormatter,
+            cacheManager,
         });
         this.promptManager = new PromptManager();
         this.serverKnowledgeStore = new ServerKnowledgeStore();
@@ -158,6 +159,9 @@ export class YNABMCPServer {
         this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
             return this.resourceManager.listResources();
         });
+        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+            return this.resourceManager.listResourceTemplates();
+        });
         this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             const { uri } = request.params;
             try {

package/dist/server/resources.d.ts

@@ -1,39 +1,43 @@
 import type * as ynab from 'ynab';
+import { ResourceTemplate as MCPResourceTemplate, Resource as MCPResource, ResourceContents } from '@modelcontextprotocol/sdk/types.js';
+import { CacheManager } from './cacheManager.js';
 interface ResponseFormatter {
     format(data: unknown): string;
 }
-export type ResourceHandler = (uri: string, dependencies: ResourceDependencies) => Promise<{
-    contents: {
-        uri: string;
-        mimeType: string;
-        text: string;
-    }[];
-}>;
+export type ResourceHandler = (uri: string, dependencies: ResourceDependencies) => Promise<ResourceContents[]>;
+export type TemplateHandler = (uri: string, params: Record<string, string>, dependencies: ResourceDependencies) => Promise<ResourceContents[]>;
 export interface ResourceDefinition {
     uri: string;
     name: string;
     description: string;
     mimeType: string;
 }
+export interface ResourceTemplateDefinition extends MCPResourceTemplate {
+    handler: TemplateHandler;
+}
 export interface ResourceDependencies {
     ynabAPI: ynab.API;
     responseFormatter: ResponseFormatter;
+    cacheManager: CacheManager;
 }
 export declare class ResourceManager {
     private dependencies;
     private resourceHandlers;
     private resourceDefinitions;
+    private resourceTemplates;
     constructor(dependencies: ResourceDependencies);
     registerResource(definition: ResourceDefinition, handler: ResourceHandler): void;
+    registerTemplate(definition: ResourceTemplateDefinition): void;
     listResources(): {
-        resources: ResourceDefinition[];
+        resources: MCPResource[];
+    };
+    listResourceTemplates(): {
+        resourceTemplates: MCPResourceTemplate[];
     };
     readResource(uri: string): Promise<{
-        contents: {
-            uri: string;
-            mimeType: string;
-            text: string;
-        }[];
+        contents: ResourceContents[];
     }>;
+    private matchTemplate;
+    private validateTemplateDefinition;
 }
 export {};

package/dist/server/resources.js

@@ -1,49 +1,60 @@
+import { CacheManager, CACHE_TTLS } from './cacheManager.js';
 const defaultResourceHandlers = {
-    'ynab://budgets': async (uri, { ynabAPI, responseFormatter }) => {
-        try {
-            const response = await ynabAPI.budgets.getBudgets();
-            const budgets = response.data.budgets.map((budget) => ({
-                id: budget.id,
-                name: budget.name,
-                last_modified_on: budget.last_modified_on,
-                first_month: budget.first_month,
-                last_month: budget.last_month,
-                currency_format: budget.currency_format,
-            }));
-            return {
-                contents: [
-                    {
-                        uri: uri,
-                        mimeType: 'application/json',
-                        text: responseFormatter.format({ budgets }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch budgets: ${error}`);
-        }
+    'ynab://budgets': async (uri, { ynabAPI, responseFormatter, cacheManager }) => {
+        const cacheKey = CacheManager.generateKey('resources', 'budgets', 'list');
+        return cacheManager.wrap(cacheKey, {
+            ttl: CACHE_TTLS.BUDGETS,
+            loader: async () => {
+                try {
+                    const response = await ynabAPI.budgets.getBudgets();
+                    const budgets = response.data.budgets.map((budget) => ({
+                        id: budget.id,
+                        name: budget.name,
+                        last_modified_on: budget.last_modified_on,
+                        first_month: budget.first_month,
+                        last_month: budget.last_month,
+                        currency_format: budget.currency_format,
+                    }));
+                    return [
+                        {
+                            uri: uri,
+                            mimeType: 'application/json',
+                            text: responseFormatter.format({ budgets }),
+                        },
+                    ];
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    throw new Error(`Failed to fetch budgets: ${message}`);
+                }
+            },
+        });
     },
-    'ynab://user': async (uri, { ynabAPI, responseFormatter }) => {
-        try {
-            const response = await ynabAPI.user.getUser();
-            const userInfo = response.data.user;
-            const user = {
-                id: userInfo.id,
-            };
-            return {
-                contents: [
-                    {
-                        uri: uri,
-                        mimeType: 'application/json',
-                        text: responseFormatter.format({ user }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch user info: ${error}`);
-        }
+    'ynab://user': async (uri, { ynabAPI, responseFormatter, cacheManager }) => {
+        const cacheKey = CacheManager.generateKey('resources', 'user');
+        return cacheManager.wrap(cacheKey, {
+            ttl: CACHE_TTLS.USER_INFO,
+            loader: async () => {
+                try {
+                    const response = await ynabAPI.user.getUser();
+                    const userInfo = response.data.user;
+                    const user = {
+                        id: userInfo.id,
+                    };
+                    return [
+                        {
+                            uri: uri,
+                            mimeType: 'application/json',
+                            text: responseFormatter.format({ user }),
+                        },
+                    ];
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    throw new Error(`Failed to fetch user info: ${message}`);
+                }
+            },
+        });
     },
 };
 const defaultResourceDefinitions = [
@@ -60,26 +71,204 @@ const defaultResourceDefinitions = [
         mimeType: 'application/json',
     },
 ];
+const defaultResourceTemplates = [
+    {
+        uriTemplate: 'ynab://budgets/{budget_id}',
+        name: 'Budget Details',
+        description: 'Detailed information for a specific budget',
+        mimeType: 'application/json',
+        handler: async (uri, params, { ynabAPI, responseFormatter, cacheManager }) => {
+            const budget_id = params['budget_id'];
+            if (!budget_id)
+                throw new Error('Missing budget_id parameter');
+            const cacheKey = CacheManager.generateKey('resources', 'budgets', 'get', budget_id);
+            return cacheManager.wrap(cacheKey, {
+                ttl: CACHE_TTLS.BUDGETS,
+                loader: async () => {
+                    try {
+                        const response = await ynabAPI.budgets.getBudgetById(budget_id);
+                        return [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: responseFormatter.format(response.data.budget),
+                            },
+                        ];
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        throw new Error(`Failed to fetch budget ${budget_id}: ${message}`);
+                    }
+                },
+            });
+        },
+    },
+    {
+        uriTemplate: 'ynab://budgets/{budget_id}/accounts',
+        name: 'Budget Accounts',
+        description: 'List of accounts for a specific budget',
+        mimeType: 'application/json',
+        handler: async (uri, params, { ynabAPI, responseFormatter, cacheManager }) => {
+            const budget_id = params['budget_id'];
+            if (!budget_id)
+                throw new Error('Missing budget_id parameter');
+            const cacheKey = CacheManager.generateKey('resources', 'accounts', 'list', budget_id);
+            return cacheManager.wrap(cacheKey, {
+                ttl: CACHE_TTLS.ACCOUNTS,
+                loader: async () => {
+                    try {
+                        const response = await ynabAPI.accounts.getAccounts(budget_id);
+                        return [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: responseFormatter.format(response.data.accounts),
+                            },
+                        ];
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        throw new Error(`Failed to fetch accounts for budget ${budget_id}: ${message}`);
+                    }
+                },
+            });
+        },
+    },
+    {
+        uriTemplate: 'ynab://budgets/{budget_id}/accounts/{account_id}',
+        name: 'Account Details',
+        description: 'Detailed information for a specific account within a budget',
+        mimeType: 'application/json',
+        handler: async (uri, params, { ynabAPI, responseFormatter, cacheManager }) => {
+            const budget_id = params['budget_id'];
+            const account_id = params['account_id'];
+            if (!budget_id)
+                throw new Error('Missing budget_id parameter');
+            if (!account_id)
+                throw new Error('Missing account_id parameter');
+            const cacheKey = CacheManager.generateKey('resources', 'accounts', 'get', budget_id, account_id);
+            return cacheManager.wrap(cacheKey, {
+                ttl: CACHE_TTLS.ACCOUNTS,
+                loader: async () => {
+                    try {
+                        const response = await ynabAPI.accounts.getAccountById(budget_id, account_id);
+                        return [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: responseFormatter.format(response.data.account),
+                            },
+                        ];
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        throw new Error(`Failed to fetch account ${account_id} in budget ${budget_id}: ${message}`);
+                    }
+                },
+            });
+        },
+    },
+];
 export class ResourceManager {
     constructor(dependencies) {
         this.dependencies = dependencies;
         this.resourceHandlers = { ...defaultResourceHandlers };
         this.resourceDefinitions = [...defaultResourceDefinitions];
+        this.resourceTemplates = [];
+        defaultResourceTemplates.forEach((template) => this.registerTemplate(template));
     }
     registerResource(definition, handler) {
         this.resourceDefinitions.push(definition);
         this.resourceHandlers[definition.uri] = handler;
     }
+    registerTemplate(definition) {
+        this.validateTemplateDefinition(definition);
+        this.resourceTemplates.push(definition);
+    }
     listResources() {
         return {
-            resources: this.resourceDefinitions,
+            resources: this.resourceDefinitions.map((r) => ({
+                uri: r.uri,
+                name: r.name,
+                description: r.description,
+                mimeType: r.mimeType,
+            })),
+        };
+    }
+    listResourceTemplates() {
+        return {
+            resourceTemplates: this.resourceTemplates.map((t) => ({
+                uriTemplate: t.uriTemplate,
+                name: t.name,
+                description: t.description,
+                mimeType: t.mimeType,
+            })),
         };
     }
     async readResource(uri) {
         const handler = this.resourceHandlers[uri];
-        if (!handler) {
-            throw new Error(`Unknown resource: ${uri}`);
+        if (handler) {
+            return { contents: await handler(uri, this.dependencies) };
+        }
+        for (const template of this.resourceTemplates) {
+            const params = this.matchTemplate(template.uriTemplate, uri);
+            if (params) {
+                try {
+                    return { contents: await template.handler(uri, params, this.dependencies) };
+                }
+                catch (error) {
+                    throw new Error(`Failed to resolve template resource ${uri}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        throw new Error(`Unknown resource: ${uri}`);
+    }
+    matchTemplate(template, uri) {
+        if (!/^[a-z0-9:/\-_{}]+$/i.test(template)) {
+            throw new Error('Invalid template format: contains unsafe characters');
+        }
+        const paramNames = [];
+        const regexPattern = template
+            .replace(/[.*+?^$()|[\]\\]/g, '\\$&')
+            .replace(/{([a-z_][a-z0-9_]*)}/gi, (_, name) => {
+            paramNames.push(name);
+            return '([^/]+)';
+        });
+        const regex = new RegExp(`^${regexPattern}$`);
+        const match = uri.match(regex);
+        if (match) {
+            const result = {};
+            paramNames.forEach((name, i) => {
+                const value = match[i + 1];
+                if (value) {
+                    if (value.includes('..') || value.includes('\\')) {
+                        throw new Error(`Invalid parameter value: ${name}=${value}`);
+                    }
+                    result[name] = value;
+                }
+            });
+            return result;
+        }
+        return null;
+    }
+    validateTemplateDefinition(definition) {
+        const { uriTemplate } = definition;
+        if (!/^[a-z0-9:/\-_{}]+$/i.test(uriTemplate)) {
+            throw new Error(`Invalid template format: contains unsafe characters (${uriTemplate})`);
+        }
+        const placeholderPattern = /{([^}]+)}/g;
+        const paramNames = [];
+        let match;
+        while ((match = placeholderPattern.exec(uriTemplate)) !== null) {
+            const paramName = match[1] ?? '';
+            if (!/^[a-z_][a-z0-9_]*$/i.test(paramName)) {
+                throw new Error(`Invalid template parameter name '${paramName}' in template ${uriTemplate}`);
+            }
+            paramNames.push(paramName);
+        }
+        const uniqueNames = new Set(paramNames);
+        if (uniqueNames.size !== paramNames.length) {
+            throw new Error(`Duplicate parameter names detected in template ${uriTemplate}`);
         }
-        return await handler(uri, this.dependencies);
     }
 }

package/dist/tools/reconcileAdapter.d.ts

@@ -6,6 +6,7 @@ interface AdapterOptions {
     currencyCode?: string;
     csvFormat?: CsvFormatPayload;
     auditMetadata?: Record<string, unknown>;
+    notes?: string[];
 }
 interface DualChannelPayload {
     human: string;

package/dist/tools/reconcileAdapter.js

@@ -126,6 +126,7 @@ const buildHumanNarrative = (analysis, options, execution) => {
         includeDetailedMatches: false,
         maxUnmatchedToShow: 5,
         maxInsightsToShow: 3,
+        notes: options.notes,
     };
     return formatHumanReadableReport(analysis, formatterOptions, execution);
 };

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

@@ -2,4 +2,8 @@ import type * as ynab from 'ynab';
 import { type ParseCSVOptions, type CSVParseResult } from './csvParser.js';
 import { type MatchingConfig } from './matcher.js';
 import type { ReconciliationAnalysis } from './types.js';
-export declare function analyzeReconciliation(csvContentOrParsed: string | CSVParseResult, _csvFilePath: string | undefined, ynabTransactions: ynab.TransactionDetail[], statementBalance: number, config?: MatchingConfig, currency?: string, accountId?: string, budgetId?: string, invertBankAmounts?: boolean, csvOptions?: ParseCSVOptions): ReconciliationAnalysis;
+export declare function analyzeReconciliation(csvContentOrParsed: string | CSVParseResult, _csvFilePath: string | undefined, ynabTransactions: ynab.TransactionDetail[], statementBalance: number, config?: MatchingConfig, currency?: string, accountId?: string, budgetId?: string, invertBankAmounts?: boolean, csvOptions?: ParseCSVOptions, accountSnapshot?: {
+    balance?: number;
+    cleared_balance?: number;
+    uncleared_balance?: number;
+}): ReconciliationAnalysis;

package/dist/tools/reconciliation/analyzer.js

@@ -29,20 +29,22 @@ function mapToTransactionMatch(result) {
     }
     return match;
 }
-function calculateBalances(ynabTransactions, statementBalanceDecimal, currency) {
-    let clearedBalance = 0;
-    let unclearedBalance = 0;
+function calculateBalances(ynabTransactions, statementBalanceDecimal, currency, accountSnapshot) {
+    let computedCleared = 0;
+    let computedUncleared = 0;
     for (const txn of ynabTransactions) {
         const amount = txn.amount;
         if (txn.cleared === 'cleared' || txn.cleared === 'reconciled') {
-            clearedBalance += amount;
+            computedCleared += amount;
         }
         else {
-            unclearedBalance += amount;
+            computedUncleared += amount;
         }
     }
+    const clearedBalance = accountSnapshot?.cleared_balance ?? computedCleared;
+    const unclearedBalance = accountSnapshot?.uncleared_balance ?? computedUncleared;
+    const totalBalance = accountSnapshot?.balance ?? clearedBalance + unclearedBalance;
     const statementBalanceMilli = Math.round(statementBalanceDecimal * 1000);
-    const totalBalance = clearedBalance + unclearedBalance;
     const discrepancy = clearedBalance - statementBalanceMilli;
     return {
         current_cleared: toMoneyValue(clearedBalance, currency),
@@ -220,7 +222,7 @@ function detectInsights(unmatchedBank, _summary, balances, currency, csvErrors =
     }
     return insights.slice(0, 5);
 }
-export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTransactions, statementBalance, config = DEFAULT_CONFIG, currency = 'USD', accountId, budgetId, invertBankAmounts = false, csvOptions) {
+export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTransactions, statementBalance, config = DEFAULT_CONFIG, currency = 'USD', accountId, budgetId, invertBankAmounts = false, csvOptions, accountSnapshot) {
     let parseResult;
     if (typeof csvContentOrParsed === 'string') {
         parseResult = parseCSV(csvContentOrParsed, {
@@ -254,7 +256,7 @@ export function analyzeReconciliation(csvContentOrParsed, _csvFilePath, ynabTran
             matchedYnabIds.add(m.ynabTransaction.id);
     });
     const unmatchedYNAB = newYNABTransactions.filter((t) => !matchedYnabIds.has(t.id));
-    const balances = calculateBalances(newYNABTransactions, statementBalance, currency);
+    const balances = calculateBalances(newYNABTransactions, statementBalance, currency, accountSnapshot);
     const summary = generateSummary(matches.map((m) => m.bankTransaction), newYNABTransactions, autoMatches, suggestedMatches, unmatchedBank, unmatchedYNAB, balances);
     const nextSteps = generateNextSteps(summary);
     const insights = detectInsights(unmatchedBank, summary, balances, currency, csvParseErrors, csvParseWarnings);

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

@@ -33,9 +33,12 @@ export interface BankPreset {
     header?: boolean;
 }
 export declare const BANK_PRESETS: Record<string, BankPreset>;
+export declare const SAFE_DELIMITERS: readonly [",", ";", "\t", "|", " "];
+export type SafeDelimiter = (typeof SAFE_DELIMITERS)[number];
 export interface ParseCSVOptions {
     preset?: string;
     invertAmounts?: boolean;
+    delimiter?: string;
     columns?: {
         date?: string;
         amount?: string;

package/dist/tools/reconciliation/csvParser.js

@@ -43,6 +43,12 @@ export const BANK_PRESETS = {
         dateFormat: 'MDY',
     },
 };
+export const SAFE_DELIMITERS = [',', ';', '\t', '|', ' '];
+function validateDelimiter(delimiter) {
+    if (!SAFE_DELIMITERS.includes(delimiter)) {
+        throw new Error(`Unsafe delimiter "${delimiter}". Allowed delimiters: ${SAFE_DELIMITERS.join(', ')}`);
+    }
+}
 function autoDetectFormat(content) {
     const preview = Papa.parse(content, {
         preview: 5,
@@ -85,6 +91,9 @@ function checkTDPattern(rows) {
 export function parseCSV(content, options = {}) {
     const errors = [];
     const warnings = [];
+    if (options.delimiter) {
+        validateDelimiter(options.delimiter);
+    }
     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`);
@@ -119,6 +128,7 @@ export function parseCSV(content, options = {}) {
         dynamicTyping: false,
         skipEmptyLines: true,
         transformHeader: (h) => h.trim(),
+        ...(options.delimiter ? { delimiter: options.delimiter } : {}),
     });
     if (parsed.errors.length > 0) {
         for (const err of parsed.errors) {
@@ -231,14 +241,44 @@ export function parseCSV(content, options = {}) {
         let rawAmount;
         if (amountCol) {
             rawAmount = getValue(amountCol)?.trim() ?? '';
-            amountMilliunits = dollarStringToMilliunits(rawAmount);
+            const parsedAmount = parseAmount(rawAmount);
+            if (!parsedAmount.valid) {
+                errors.push({
+                    row: rowNum,
+                    field: 'amount',
+                    message: parsedAmount.reason ?? `Invalid amount: "${rawAmount}"`,
+                    rawValue: rawAmount,
+                });
+                continue;
+            }
+            amountMilliunits = parsedAmount.valueMilliunits;
         }
         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);
+            const parsedDebit = parseAmount(debit);
+            const parsedCredit = parseAmount(credit);
+            if (!parsedDebit.valid && debit) {
+                errors.push({
+                    row: rowNum,
+                    field: 'amount',
+                    message: parsedDebit.reason ?? `Invalid debit amount: "${debit}"`,
+                    rawValue: debit,
+                });
+                continue;
+            }
+            if (!parsedCredit.valid && credit) {
+                errors.push({
+                    row: rowNum,
+                    field: 'amount',
+                    message: parsedCredit.reason ?? `Invalid credit amount: "${credit}"`,
+                    rawValue: credit,
+                });
+                continue;
+            }
+            const debitMilliunits = parsedDebit.valid ? parsedDebit.valueMilliunits : 0;
+            const creditMilliunits = parsedCredit.valid ? parsedCredit.valueMilliunits : 0;
             if (Math.abs(debitMilliunits) > 0 && Math.abs(creditMilliunits) > 0) {
                 const warning = `Both Debit (${debit}) and Credit (${credit}) have values - using Debit`;
                 rowWarnings.push(warning);
@@ -251,7 +291,13 @@ export function parseCSV(content, options = {}) {
                 amountMilliunits = Math.abs(creditMilliunits);
             }
             else {
-                amountMilliunits = 0;
+                errors.push({
+                    row: rowNum,
+                    field: 'amount',
+                    message: 'Missing debit/credit amount',
+                    rawValue: `${debit}|${credit}`,
+                });
+                continue;
             }
             if (debitMilliunits < 0) {
                 const warning = `Debit column contains negative value (${debit}) - treating as positive debit`;
@@ -262,15 +308,6 @@ export function parseCSV(content, options = {}) {
         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() ?? '';
@@ -393,9 +430,10 @@ function detectPreset(columns) {
 }
 const CURRENCY_SYMBOLS = /[$€£¥]/g;
 const CURRENCY_CODES = /\b(CAD|USD|EUR|GBP)\b/gi;
-function dollarStringToMilliunits(str) {
-    if (!str)
-        return 0;
+function parseAmount(str) {
+    if (!str || !str.trim()) {
+        return { valid: false, valueMilliunits: 0, reason: 'Missing amount value' };
+    }
     let cleaned = str.replace(CURRENCY_SYMBOLS, '').replace(CURRENCY_CODES, '').trim();
     if (cleaned.startsWith('(') && cleaned.endsWith(')')) {
         cleaned = '-' + cleaned.slice(1, -1);
@@ -407,7 +445,8 @@ function dollarStringToMilliunits(str) {
         cleaned = cleaned.replace(/,/g, '');
     }
     const dollars = parseFloat(cleaned);
-    if (!Number.isFinite(dollars))
-        return 0;
-    return Math.round(dollars * 1000);
+    if (!Number.isFinite(dollars)) {
+        return { valid: false, valueMilliunits: 0, reason: `Invalid amount: "${str}"` };
+    }
+    return { valid: true, valueMilliunits: Math.round(dollars * 1000) };
 }