@dizzlkheinz/ynab-mcpb 0.12.1

package/test-reconcile-tool.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * Test script for reconcile_account_v2 tool
+ *
+ * Usage:
+ *   node test-reconcile-tool.js <csv-file> <budget-id> <account-id> <statement-balance>
+ *
+ * Example:
+ *   node test-reconcile-tool.js test.csv last-used checking -1500.00
+ */
+
+import { API } from 'ynab';
+import { handleReconcileAccountV2 } from './dist/tools/reconciliation/index.js';
+import { readFileSync } from 'fs';
+
+async function testReconciliation() {
+  // Parse arguments
+  const csvFile = process.argv[2];
+  const budgetId = process.argv[3] || 'last-used';
+  const accountId = process.argv[4];
+  const statementBalance = parseFloat(process.argv[5] || '0');
+
+  if (!csvFile || !accountId) {
+    console.error(
+      'Usage: node test-reconcile-tool.js <csv-file> <budget-id> <account-id> <statement-balance>',
+    );
+    console.error('Example: node test-reconcile-tool.js test.csv last-used checking -1500.00');
+    process.exit(1);
+  }
+
+  // Check for YNAB token
+  const token = process.env.YNAB_ACCESS_TOKEN;
+  if (!token) {
+    console.error('❌ YNAB_ACCESS_TOKEN environment variable not set');
+    process.exit(1);
+  }
+
+  // Initialize YNAB API
+  const ynabAPI = new API(token);
+
+  console.log('🔍 Testing reconcile_account_v2...\n');
+  console.log(`CSV File: ${csvFile}`);
+  console.log(`Budget ID: ${budgetId}`);
+  console.log(`Account ID: ${accountId}`);
+  console.log(`Statement Balance: $${statementBalance}`);
+  console.log('\n---\n');
+
+  try {
+    // Read CSV content
+    const csvContent = readFileSync(csvFile, 'utf-8');
+
+    // Call the tool
+    const result = await handleReconcileAccountV2(ynabAPI, {
+      budget_id: budgetId,
+      account_id: accountId,
+      csv_data: csvContent,
+      statement_balance: statementBalance,
+      date_tolerance_days: 2,
+      amount_tolerance_cents: 1,
+      auto_match_threshold: 90,
+      suggestion_threshold: 60,
+    });
+
+    // Parse and display results
+    const analysis = JSON.parse(result.content[0].text);
+
+    console.log('✅ Analysis Complete!\n');
+    console.log('📊 Summary:');
+    console.log(`  Bank Transactions: ${analysis.summary.bank_transactions_count}`);
+    console.log(`  YNAB Transactions: ${analysis.summary.ynab_transactions_count}`);
+    console.log(`  Auto-Matched: ${analysis.summary.auto_matched} (≥90% confidence)`);
+    console.log(`  Suggested Matches: ${analysis.summary.suggested_matches} (60-89% confidence)`);
+    console.log(`  Unmatched Bank: ${analysis.summary.unmatched_bank}`);
+    console.log(`  Unmatched YNAB: ${analysis.summary.unmatched_ynab}`);
+    console.log('\n💰 Balance:');
+    console.log(`  Current Cleared: $${analysis.balance_info.current_cleared.toFixed(2)}`);
+    console.log(`  Target Statement: $${analysis.balance_info.target_statement.toFixed(2)}`);
+    console.log(`  Discrepancy: $${analysis.balance_info.discrepancy.toFixed(2)}`);
+    console.log(`  On Track: ${analysis.balance_info.on_track ? '✅' : '❌'}`);
+
+    if (analysis.auto_matches.length > 0) {
+      console.log('\n✨ Auto-Matched Transactions:');
+      analysis.auto_matches.slice(0, 5).forEach((match, i) => {
+        console.log(
+          `  ${i + 1}. ${match.bank_transaction.payee} - $${match.bank_transaction.amount.toFixed(2)}`,
+        );
+        console.log(`     → Matched to YNAB: ${match.ynab_transaction.payee_name}`);
+        console.log(`     Confidence: ${match.confidence_score}%`);
+      });
+      if (analysis.auto_matches.length > 5) {
+        console.log(`  ... and ${analysis.auto_matches.length - 5} more`);
+      }
+    }
+
+    if (analysis.suggested_matches.length > 0) {
+      console.log('\n💡 Suggested Matches (need review):');
+      analysis.suggested_matches.slice(0, 3).forEach((match, i) => {
+        console.log(
+          `  ${i + 1}. ${match.bank_transaction.payee} - $${match.bank_transaction.amount.toFixed(2)}`,
+        );
+        if (match.candidates && match.candidates.length > 0) {
+          console.log(
+            `     Top candidate: ${match.candidates[0].ynab_transaction.payee_name} (${match.candidates[0].confidence}%)`,
+          );
+        }
+      });
+      if (analysis.suggested_matches.length > 3) {
+        console.log(`  ... and ${analysis.suggested_matches.length - 3} more`);
+      }
+    }
+
+    if (analysis.unmatched_bank.length > 0) {
+      console.log('\n❓ Unmatched Bank Transactions (not in YNAB):');
+      analysis.unmatched_bank.slice(0, 3).forEach((txn, i) => {
+        console.log(`  ${i + 1}. ${txn.payee} - $${txn.amount.toFixed(2)} on ${txn.date}`);
+      });
+      if (analysis.unmatched_bank.length > 3) {
+        console.log(`  ... and ${analysis.unmatched_bank.length - 3} more`);
+      }
+    }
+
+    if (analysis.insights && analysis.insights.length > 0) {
+      console.log('\n💡 Insights:');
+      analysis.insights.forEach((insight) => {
+        const icon =
+          insight.severity === 'critical' ? '🔴' : insight.severity === 'warning' ? '⚠️' : 'ℹ️';
+        console.log(`  ${icon} ${insight.title}`);
+        console.log(`     ${insight.description}`);
+      });
+    }
+
+    console.log('\n📋 Next Steps:');
+    analysis.next_steps.forEach((step, i) => {
+      console.log(`  ${i + 1}. ${step}`);
+    });
+
+    console.log('\n✅ Test complete!');
+    console.log('\nFull results saved to: reconcile-analysis-result.json');
+
+    // Save full results
+    require('fs').writeFileSync(
+      'reconcile-analysis-result.json',
+      JSON.stringify(analysis, null, 2),
+    );
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+testReconciliation();

package/test-reconcile-with-csv.cjs

@@ -0,0 +1,89 @@
+/**
+ * Test reconciliation with merged CSV data
+ * Run this script using the YNAB MCP server in your other context
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read the CSV files
+const downloadsPath = path.join(process.env.USERPROFILE, 'Downloads');
+const csv1Path = path.join(downloadsPath, 'accountactivity.csv');
+const csv2Path = path.join(downloadsPath, 'accountactivity1.csv');
+const csv3Path = path.join(downloadsPath, 'accountactivity2.csv');
+
+let csv1, csv2, csv3;
+try {
+  csv1 = fs.readFileSync(csv1Path, 'utf-8');
+  csv2 = fs.readFileSync(csv2Path, 'utf-8');
+  csv3 = fs.readFileSync(csv3Path, 'utf-8');
+} catch (error) {
+  console.error('Error reading CSV files:', error.message);
+  process.exit(1);
+}
+// Merge CSVs (skip header from second and third files)
+const lines1 = csv1.split('\n');
+const lines2 = csv2.split('\n');
+const lines3 = csv3.split('\n');
+
+// Get header from first file
+const header = lines1[0];
+
+// Get data rows (skip header from all files, skip empty lines)
+const data1 = lines1.slice(1).filter(line => line.trim());
+const data2 = lines2.slice(1).filter(line => line.trim());
+const data3 = lines3.slice(1).filter(line => line.trim());
+
+// Combine and deduplicate
+const allData = [...data1, ...data2, ...data3];
+const uniqueData = [...new Set(allData)];
+
+// Reconstruct CSV
+const mergedCsv = [header, ...uniqueData].join('\n');
+
+const BUDGET_ID = process.env.YNAB_BUDGET_ID || '00dd8b56-cca8-4a1f-a3ea-02b13df8c2ff';
+const ACCOUNT_ID = process.env.YNAB_ACCOUNT_ID || '083f96c0-ed01-497d-93ab-f94c5ba89509';
+const STATEMENT_BALANCE = parseFloat(process.env.STATEMENT_BALANCE || '-1234.91');
+if (isNaN(STATEMENT_BALANCE)) {
+  console.error('Invalid STATEMENT_BALANCE value');
+  process.exit(1);
+}const STATEMENT_DATE = process.env.STATEMENT_DATE || '2025-01-11';
+
+const reconciliationCall = {
+  tool: 'reconcile_account',
+  params: {
+    budget_id: BUDGET_ID,
+    account_id: ACCOUNT_ID,
+    statement_balance: STATEMENT_BALANCE,
+    statement_date: STATEMENT_DATE,
+    csv_data: mergedCsv,
+    csv_format: {
+      date_column: 'Transaction Date',
+      description_column: 'Description',
+      amount_column: 'Amount',
+      date_format: 'YYYY-MM-DD',
+      has_header: true,
+      delimiter: ','
+    },
+    dry_run: false,
+    auto_create_transactions: true,
+    auto_update_cleared_status: true,
+    auto_unclear_missing: true,
+    include_structured_data: false
+  }
+};    auto_update_cleared_status: true,
+    auto_unclear_missing: true,
+    include_structured_data: false
+  }
+};
+const mergedCsvPath = path.join(downloadsPath, 'accountactivity-merged.csv');
+try {
+  fs.writeFileSync(mergedCsvPath, mergedCsv);
+  console.log(`\n\nMerged CSV saved to: ${mergedCsvPath}`);
+} catch (error) {
+  console.error('Error saving merged CSV:', error.message);
+}
+// Also save the merged CSV for reference
+const mergedCsvPath = path.join(downloadsPath, 'accountactivity-merged.csv');
+fs.writeFileSync(mergedCsvPath, mergedCsv);
+console.log(`\n\nMerged CSV saved to: ${mergedCsvPath}`);

package/test-statement.csv

@@ -0,0 +1,8 @@
+Date,Description,Amount
+2025-10-23,EvoCarShare,-2.24
+2025-10-22,Amazon.ca*NU6MP0D91,-23.47
+2025-10-22,Amazon.ca*NU1G88CB2,-9.49
+2025-10-20,OXIO.CA,-54.88
+2025-10-20,PAYMENT - THANK YOU,1097.27
+2025-10-20,BURGER KING # 6271,-23.09
+2025-10-30,EvoCarShare,-22.22

package/test_debug.js

@@ -0,0 +1,47 @@
+import { handleCreateTransaction } from './dist/tools/transactionTools.js';
+import * as ynab from 'ynab';
+import { vi } from 'vitest';
+
+const mockYnabAPI = {
+  transactions: {
+    createTransaction: async () => ({
+      data: {
+        transaction: {
+          id: 'new-transaction-123',
+          date: '2024-01-01',
+          amount: -50000,
+          memo: null,
+          cleared: 'cleared',
+          approved: true,
+          flag_color: 'red',
+          account_id: 'account-456',
+        },
+      },
+    }),
+  },
+  accounts: {
+    getAccountById: async () => ({
+      data: {
+        account: {
+          id: 'account-456',
+          balance: 100000,
+          cleared_balance: 95000,
+        },
+      },
+    }),
+  },
+};
+
+const params = {
+  budget_id: 'budget-123',
+  account_id: 'account-456',
+  amount: -50000,
+  date: '2024-01-01',
+};
+
+try {
+  const result = await handleCreateTransaction(mockYnabAPI, params);
+  console.log('Result:', JSON.stringify(result, null, 2));
+} catch (error) {
+  console.error('Error:', error);
+}

package/test_simple.mjs

@@ -0,0 +1,16 @@
+// Simplified test to debug the issue
+const mockResponse = {
+  data: {
+    transaction: {
+      id: 'new-transaction-123',
+      date: '2024-01-01',
+      amount: -50000,
+      account_id: 'account-456',
+    },
+    server_knowledge: 1,
+  },
+};
+
+console.log('Mock response:', JSON.stringify(mockResponse, null, 2));
+console.log('Transaction:', mockResponse.data.transaction);
+console.log('Server knowledge:', mockResponse.data.server_knowledge);

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": false,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/tsconfig.prod.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "sourceMap": false,
+    "declarationMap": false,
+    "removeComments": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "src/__tests__/**/*",
+    "scripts/**/*"
+  ]
+}

package/vitest-reporters/split-json-reporter.ts

@@ -0,0 +1,211 @@
+import type { Reporter, File, Vitest } from 'vitest';
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+
+/**
+ * Custom Vitest reporter that splits test results into multiple JSON files
+ * by project (unit, integration, e2e) and generates summary files
+ */
+export default class SplitJsonReporter implements Reporter {
+  ctx!: Vitest;
+  private results = new Map<string, File[]>();
+
+  onInit(ctx: Vitest) {
+    this.ctx = ctx;
+  }
+
+  async onFinished(files?: File[]) {
+    if (!files) return;
+
+    const outputDir = join(process.cwd(), 'test-results');
+    await mkdir(outputDir, { recursive: true });
+
+    // Group files by project
+    const projectResults = new Map<string, File[]>();
+    const failedTests: any[] = [];
+    const summary = {
+      numTotalTestSuites: 0,
+      numPassedTestSuites: 0,
+      numFailedTestSuites: 0,
+      numTotalTests: 0,
+      numPassedTests: 0,
+      numFailedTests: 0,
+      startTime: Date.now(),
+      success: true,
+      projects: {} as Record<string, any>,
+    };
+
+    for (const file of files) {
+      const projectName = (file.projectName as string) || 'default';
+
+      if (!projectResults.has(projectName)) {
+        projectResults.set(projectName, []);
+      }
+      projectResults.get(projectName)!.push(file);
+
+      // Update summary
+      summary.numTotalTestSuites++;
+      const allTasks = this.getAllTasks(file);
+      const failedTasks = allTasks.filter((t) => t.result?.state === 'fail');
+
+      if (failedTasks.length > 0) {
+        summary.numFailedTestSuites++;
+        summary.success = false;
+
+        // Collect failed test details
+        failedTasks.forEach((task) => {
+          failedTests.push({
+            project: projectName,
+            file: file.filepath,
+            suite: task.suite?.name,
+            test: task.name,
+            error: task.result?.errors?.[0]?.message,
+            duration: task.result?.duration,
+          });
+        });
+      } else {
+        summary.numPassedTestSuites++;
+      }
+
+      summary.numTotalTests += allTasks.length;
+      summary.numPassedTests += allTasks.filter((t) => t.result?.state === 'pass').length;
+      summary.numFailedTests += failedTasks.length;
+    }
+
+    // Write per-project JSON files
+    for (const [projectName, projectFiles] of projectResults.entries()) {
+      const projectData = {
+        project: projectName,
+        numTestSuites: projectFiles.length,
+        numPassedTestSuites: projectFiles.filter((f) => {
+          const tasks = this.getAllTasks(f);
+          return tasks.every((t) => t.result?.state === 'pass');
+        }).length,
+        numFailedTestSuites: projectFiles.filter((f) => {
+          const tasks = this.getAllTasks(f);
+          return tasks.some((t) => t.result?.state === 'fail');
+        }).length,
+        testSuites: projectFiles.map((file) => ({
+          name: file.filepath,
+          status: this.getFileStatus(file),
+          duration: file.result?.duration || 0,
+          tests: this.getAllTasks(file).map((task) => ({
+            name: task.name,
+            status: task.result?.state || 'unknown',
+            duration: task.result?.duration || 0,
+            errors: task.result?.errors?.map((e) => ({
+              message: e.message,
+              stack: e.stack,
+            })),
+          })),
+        })),
+      };
+
+      // Calculate project summary
+      summary.projects[projectName] = {
+        total: projectFiles.length,
+        passed: projectData.numPassedTestSuites,
+        failed: projectData.numFailedTestSuites,
+      };
+
+      await writeFile(
+        join(outputDir, `${projectName}-tests.json`),
+        JSON.stringify(projectData, null, 2),
+        'utf-8',
+      );
+    }
+
+    // Write summary file
+    await writeFile(join(outputDir, 'summary.json'), JSON.stringify(summary, null, 2), 'utf-8');
+
+    // Write failed tests file (only if there are failures)
+    if (failedTests.length > 0) {
+      await writeFile(
+        join(outputDir, 'failed-tests.json'),
+        JSON.stringify({ numFailedTests: failedTests.length, failures: failedTests }, null, 2),
+        'utf-8',
+      );
+    }
+
+    // Write passed tests summary
+    const passedSummary = {
+      numPassedTests: summary.numPassedTests,
+      numPassedTestSuites: summary.numPassedTestSuites,
+      projects: Object.entries(summary.projects).map(([name, stats]) => ({
+        name,
+        passed: (stats as any).passed,
+      })),
+    };
+
+    await writeFile(
+      join(outputDir, 'passed-tests-summary.json'),
+      JSON.stringify(passedSummary, null, 2),
+      'utf-8',
+    );
+
+    // Write pointer file at test-results.json location
+    const pointerContent = {
+      message:
+        'Test results have been split into multiple files for better performance and readability.',
+      location: './test-results/',
+      files: {
+        'summary.json': 'High-level overview with totals and project breakdowns',
+        'unit-tests.json': 'All unit test results',
+        'integration-tests.json': 'All integration test results',
+        'e2e-tests.json': 'All end-to-end test results',
+        'failed-tests.json': 'Detailed failure information (only present if tests failed)',
+        'passed-tests-summary.json': 'Summary of passed tests',
+        'index.html': 'Interactive HTML report (open in browser)',
+      },
+      quickStats: {
+        total: summary.numTotalTests,
+        passed: summary.numPassedTests,
+        failed: summary.numFailedTests,
+        success: summary.success,
+      },
+      note: 'For detailed results, see the files in the test-results/ directory.',
+    };
+
+    await writeFile(
+      join(process.cwd(), 'test-results.json'),
+      JSON.stringify(pointerContent, null, 2),
+      'utf-8',
+    );
+
+    console.log('\n📊 Test results written to test-results/');
+    console.log(`   - summary.json (overview)`);
+    console.log(`   - *-tests.json (${projectResults.size} project file(s))`);
+    if (failedTests.length > 0) {
+      console.log(`   - failed-tests.json (${failedTests.length} failure(s))`);
+    }
+    console.log(`   - passed-tests-summary.json`);
+    console.log(`   - index.html (interactive report)`);
+    console.log(`\n💡 test-results.json contains a pointer to the detailed results`);
+  }
+
+  private getAllTasks(file: File): any[] {
+    const tasks: any[] = [];
+
+    const collectTasks = (suite: any) => {
+      if (suite.tasks) {
+        for (const task of suite.tasks) {
+          if (task.type === 'test') {
+            tasks.push(task);
+          } else if (task.type === 'suite') {
+            collectTasks(task);
+          }
+        }
+      }
+    };
+
+    collectTasks(file);
+    return tasks;
+  }
+
+  private getFileStatus(file: File): string {
+    const tasks = this.getAllTasks(file);
+    if (tasks.some((t) => t.result?.state === 'fail')) return 'failed';
+    if (tasks.every((t) => t.result?.state === 'pass')) return 'passed';
+    return 'unknown';
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,96 @@
+import { defineConfig } from 'vitest/config';
+
+const integrationFiles = ['src/**/*.integration.test.ts'];
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    setupFiles: ['src/__tests__/setup.ts'],
+    exclude: ['src/__tests__/testRunner.ts'],
+    // Use projects to target unit/integration/e2e groups (Vitest v3)
+    projects: [
+      {
+        test: {
+          name: 'unit',
+          include: ['src/**/*.{test,spec}.ts'],
+          exclude: [
+            'src/**/*.integration.test.ts',
+            'src/**/*.e2e.test.ts',
+            'src/server/__tests__/YNABMCPServer.test.ts',
+          ],
+        },
+      },
+      {
+        test: {
+          name: 'integration:core',
+          include: integrationFiles,
+          env: {
+            INTEGRATION_TEST_TIER: 'core',
+          },
+          testTimeout: 30000,
+          hookTimeout: 10000,
+        },
+      },
+      {
+        test: {
+          name: 'integration:domain',
+          include: integrationFiles,
+          env: {
+            INTEGRATION_TEST_TIER: 'domain',
+          },
+          testTimeout: 60000,
+          hookTimeout: 15000,
+        },
+      },
+      {
+        test: {
+          name: 'integration:full',
+          include: integrationFiles,
+          env: {
+            INTEGRATION_TEST_TIER: 'full',
+          },
+          testTimeout: 120000,
+          hookTimeout: 30000,
+          fileParallelism: false,
+          maxWorkers: 1,
+        },
+      },
+      {
+        test: {
+          name: 'e2e',
+          include: ['src/**/*.e2e.test.ts'],
+        },
+      },
+    ],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: [
+        'src/**/*.{test,spec}.ts',
+        'src/**/*.d.ts',
+        'src/index.ts', // Entry point excluded from coverage
+        'src/__tests__/**/*.ts', // Test utilities excluded from coverage
+      ],
+      reporter: ['text', 'json', 'html'],
+      reportsDirectory: './coverage',
+      thresholds: {
+        global: {
+          branches: 80,
+          functions: 80,
+          lines: 80,
+          statements: 80,
+        },
+      },
+    },
+    reporters: ['verbose', 'html', './vitest-reporters/split-json-reporter.ts'],
+    outputFile: {
+      html: './test-results/index.html',
+    },
+  },
+  resolve: {
+    alias: {
+      '@': '/src',
+    },
+  },
+});