@dizzlkheinz/ynab-mcpb 0.12.1

package/dist/tools/reconcileAdapter.js

@@ -0,0 +1,167 @@
+import { toMoneyValue, toMoneyValueFromDecimal } from '../utils/money.js';
+import { formatHumanReadableReport, } from './reconciliation/reportFormatter.js';
+const OUTPUT_VERSION = '2.0';
+const SCHEMA_URL = 'https://raw.githubusercontent.com/dizzlkheinz/ynab-mcp-mcpb/master/docs/schemas/reconciliation-v2.json';
+const toBankTransactionView = (txn, currency) => ({
+    ...txn,
+    amount_money: toMoneyValueFromDecimal(txn.amount, currency),
+});
+const toYNABTransactionView = (txn, currency) => ({
+    ...txn,
+    amount_money: toMoneyValue(txn.amount, currency),
+});
+const convertMatch = (match, currency) => ({
+    ...match,
+    bank_transaction: toBankTransactionView(match.bank_transaction, currency),
+    ynab_transaction: match.ynab_transaction
+        ? toYNABTransactionView(match.ynab_transaction, currency)
+        : undefined,
+    candidates: match.candidates?.map((candidate) => ({
+        ...candidate,
+        ynab_transaction: toYNABTransactionView(candidate.ynab_transaction, currency),
+    })),
+});
+const convertInsight = (insight) => ({
+    id: insight.id,
+    type: insight.type,
+    severity: insight.severity,
+    title: insight.title,
+    description: insight.description,
+    evidence: insight.evidence ?? {},
+});
+const convertSummary = (analysis) => ({
+    statement_date_range: analysis.summary.statement_date_range,
+    bank_transactions_count: analysis.summary.bank_transactions_count,
+    ynab_transactions_count: analysis.summary.ynab_transactions_count,
+    auto_matched: analysis.summary.auto_matched,
+    suggested_matches: analysis.summary.suggested_matches,
+    unmatched_bank: analysis.summary.unmatched_bank,
+    unmatched_ynab: analysis.summary.unmatched_ynab,
+    current_cleared_balance: analysis.summary.current_cleared_balance,
+    target_statement_balance: analysis.summary.target_statement_balance,
+    discrepancy: analysis.summary.discrepancy,
+    discrepancy_explanation: analysis.summary.discrepancy_explanation,
+});
+const convertBalanceInfo = (analysis) => {
+    const discrepancyMilli = analysis.balance_info.discrepancy.value_milliunits;
+    const direction = discrepancyMilli === 0 ? 'balanced' : discrepancyMilli > 0 ? 'ynab_higher' : 'bank_higher';
+    return {
+        current_cleared: analysis.balance_info.current_cleared,
+        current_uncleared: analysis.balance_info.current_uncleared,
+        current_total: analysis.balance_info.current_total,
+        target_statement: analysis.balance_info.target_statement,
+        discrepancy: analysis.balance_info.discrepancy,
+        discrepancy_direction: direction,
+        on_track: analysis.balance_info.on_track,
+    };
+};
+const convertAccountSnapshot = (snapshot, currency) => ({
+    balance: toMoneyValue(snapshot.balance, currency),
+    cleared_balance: toMoneyValue(snapshot.cleared_balance, currency),
+    uncleared_balance: toMoneyValue(snapshot.uncleared_balance, currency),
+});
+const convertPrecisionCalculations = (precision, currency) => ({
+    bank_statement_balance: toMoneyValue(precision.bank_statement_balance_milliunits, currency),
+    ynab_calculated_balance: toMoneyValue(precision.ynab_calculated_balance_milliunits, currency),
+    discrepancy: toMoneyValue(precision.discrepancy_milliunits, currency),
+    discrepancy_decimal: toMoneyValueFromDecimal(precision.discrepancy_dollars, currency),
+});
+const convertLikelyCausesLegacy = (analysis, currency) => ({
+    confidence_level: analysis.confidence_level,
+    risk_assessment: analysis.risk_assessment,
+    likely_causes: analysis.likely_causes.map((cause) => ({
+        type: cause.cause_type.toLowerCase(),
+        description: cause.description,
+        confidence: cause.confidence,
+        suggested_action: cause.suggested_resolution,
+        amount: toMoneyValue(cause.amount_milliunits, currency),
+        evidence: cause.evidence,
+    })),
+});
+const convertBalanceReconciliationLegacy = (balance, currency) => {
+    if (!balance)
+        return undefined;
+    const result = {
+        status: balance.status,
+    };
+    if (balance.precision_calculations) {
+        result.precision_calculations = convertPrecisionCalculations(balance.precision_calculations, currency);
+    }
+    if (balance.discrepancy_analysis) {
+        result.discrepancy_analysis = convertLikelyCausesLegacy(balance.discrepancy_analysis, currency);
+    }
+    if (balance.final_verification) {
+        result.final_verification = balance.final_verification;
+    }
+    return result;
+};
+const convertExecution = (execution, currency) => {
+    const result = {
+        summary: execution.summary,
+        account_balance: {
+            before: convertAccountSnapshot(execution.account_balance.before, currency),
+            after: convertAccountSnapshot(execution.account_balance.after, currency),
+        },
+        actions_taken: execution.actions_taken,
+        recommendations: execution.recommendations,
+    };
+    if (execution.balance_reconciliation) {
+        result.balance_reconciliation = convertBalanceReconciliationLegacy(execution.balance_reconciliation, currency);
+    }
+    if (execution.bulk_operation_details) {
+        result.bulk_operation_details = execution.bulk_operation_details;
+    }
+    return result;
+};
+const buildHumanNarrative = (analysis, options, execution) => {
+    const formatterOptions = {
+        accountName: options.accountName,
+        accountId: options.accountId,
+        currencyCode: options.currencyCode,
+        includeDetailedMatches: false,
+        maxUnmatchedToShow: 5,
+        maxInsightsToShow: 3,
+    };
+    return formatHumanReadableReport(analysis, formatterOptions, execution);
+};
+export const buildReconciliationPayload = (analysis, options = {}, execution) => {
+    const currency = options.currencyCode ?? 'USD';
+    const executionView = execution ? convertExecution(execution, currency) : undefined;
+    const structured = {
+        version: OUTPUT_VERSION,
+        schema_url: SCHEMA_URL,
+        generated_at: new Date().toISOString(),
+        account: {
+            id: options.accountId,
+            name: options.accountName,
+        },
+        summary: convertSummary(analysis),
+        balance: convertBalanceInfo(analysis),
+        insights: analysis.insights.map(convertInsight),
+        next_steps: analysis.next_steps,
+        matches: {
+            auto: analysis.auto_matches.map((match) => convertMatch(match, currency)),
+            suggested: analysis.suggested_matches.map((match) => convertMatch(match, currency)),
+        },
+        unmatched: {
+            bank: analysis.unmatched_bank.map((txn) => toBankTransactionView(txn, currency)),
+            ynab: analysis.unmatched_ynab.map((txn) => toYNABTransactionView(txn, currency)),
+        },
+    };
+    if (analysis.recommendations && analysis.recommendations.length > 0) {
+        structured['recommendations'] = analysis.recommendations;
+    }
+    if (options.csvFormat) {
+        structured['csv_format'] = options.csvFormat;
+    }
+    if (executionView) {
+        structured['execution'] = executionView;
+    }
+    if (options.auditMetadata) {
+        structured['audit'] = options.auditMetadata;
+    }
+    return {
+        human: buildHumanNarrative(analysis, options, execution),
+        structured,
+    };
+};

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

@@ -0,0 +1,3 @@
+import type * as ynab from 'ynab';
+import type { ReconciliationAnalysis, MatchingConfig } from './types.js';
+export declare function analyzeReconciliation(csvContent: string, csvFilePath: string | undefined, ynabTransactions: ynab.TransactionDetail[], statementBalance: number, config?: MatchingConfig, currency?: string, accountId?: string, budgetId?: string, invertBankAmounts?: boolean): ReconciliationAnalysis;