@dizzlkheinz/ynab-mcpb 0.18.4 → 0.19.0

package/dist/tools/transactionUtils.d.ts

@@ -1,9 +1,9 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import type { SaveTransactionsResponseData } from 'ynab/dist/models/SaveTransactionsResponseData.js';
-import type { DeltaCache } from '../server/deltaCache.js';
-import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
-import type { CategorySource, TransactionCacheInvalidationOptions, CorrelationPayload, CorrelationPayloadInput, BulkTransactionInput, BulkTransactionResult, BulkCreateResponse, BulkUpdateResponse } from './transactionSchemas.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type * as ynab from "ynab";
+import type { SaveTransactionsResponseData } from "ynab/dist/models/SaveTransactionsResponseData.js";
+import type { DeltaCache } from "../server/deltaCache.js";
+import type { ServerKnowledgeStore } from "../server/serverKnowledgeStore.js";
+import type { BulkCreateResponse, BulkTransactionInput, BulkTransactionResult, BulkUpdateResponse, CategorySource, CorrelationPayload, CorrelationPayloadInput, TransactionCacheInvalidationOptions } from "./transactionSchemas.js";
 export declare function ensureTransaction<T>(transaction: T | undefined, errorMessage: string): T;
 export declare function appendCategoryIds(source: CategorySource | undefined, target: Set<string>): void;
 export declare function collectCategoryIdsFromSources(...sources: (CategorySource | undefined)[]): Set<string>;

package/dist/tools/transactionUtils.js

@@ -1,8 +1,8 @@
-import { createHash } from 'crypto';
-import { ValidationError } from '../types/index.js';
-import { responseFormatter } from '../server/responseFormatter.js';
-import { cacheManager, CacheManager } from '../server/cacheManager.js';
-import { globalRequestLogger } from '../server/requestLogger.js';
+import { createHash } from "node:crypto";
+import { CacheManager, cacheManager } from "../server/cacheManager.js";
+import { globalRequestLogger } from "../server/requestLogger.js";
+import { responseFormatter } from "../server/responseFormatter.js";
+import { ValidationError } from "../types/index.js";
 const FULL_RESPONSE_THRESHOLD = 64 * 1024;
 const SUMMARY_RESPONSE_THRESHOLD = 96 * 1024;
 const MAX_RESPONSE_BYTES = 100 * 1024;
@@ -47,44 +47,44 @@ export function setsEqual(a, b) {
 }
 export const toMonthKey = (date) => `${date.slice(0, 7)}-01`;
 export function invalidateTransactionCaches(deltaCache, knowledgeStore, budgetId, serverKnowledge, affectedAccountIds, affectedMonths, options = {}) {
-    deltaCache.invalidate(budgetId, 'transactions');
-    cacheManager.delete(CacheManager.generateKey('transactions', 'list', budgetId));
+    deltaCache.invalidate(budgetId, "transactions");
+    cacheManager.delete(CacheManager.generateKey("transactions", "list", budgetId));
     for (const accountId of affectedAccountIds) {
-        const accountPrefix = CacheManager.generateKey('transactions', 'account', budgetId, accountId);
+        const accountPrefix = CacheManager.generateKey("transactions", "account", budgetId, accountId);
         cacheManager.deleteByPrefix(accountPrefix);
     }
     const invalidateAccountsList = options.accountTotalsChanged ?? true;
     if (invalidateAccountsList) {
-        cacheManager.delete(CacheManager.generateKey('accounts', 'list', budgetId));
+        cacheManager.delete(CacheManager.generateKey("accounts", "list", budgetId));
     }
     for (const accountId of affectedAccountIds) {
-        cacheManager.delete(CacheManager.generateKey('account', 'get', budgetId, accountId));
+        cacheManager.delete(CacheManager.generateKey("account", "get", budgetId, accountId));
     }
     const affectedCategoryIds = options.affectedCategoryIds ?? new Set();
     const shouldInvalidateCategories = options.invalidateAllCategories || affectedCategoryIds.size > 0;
     if (shouldInvalidateCategories) {
-        cacheManager.delete(CacheManager.generateKey('categories', 'list', budgetId));
+        cacheManager.delete(CacheManager.generateKey("categories", "list", budgetId));
         for (const categoryId of affectedCategoryIds) {
-            cacheManager.delete(CacheManager.generateKey('category', 'get', budgetId, categoryId));
+            cacheManager.delete(CacheManager.generateKey("category", "get", budgetId, categoryId));
         }
     }
     const shouldInvalidateMonths = options.invalidateMonths ?? affectedMonths.size > 0;
     if (shouldInvalidateMonths) {
-        cacheManager.delete(CacheManager.generateKey('months', 'list', budgetId));
-        deltaCache.invalidate(budgetId, 'months');
+        cacheManager.delete(CacheManager.generateKey("months", "list", budgetId));
+        deltaCache.invalidate(budgetId, "months");
         for (const month of affectedMonths) {
-            cacheManager.delete(CacheManager.generateKey('month', 'get', budgetId, month));
+            cacheManager.delete(CacheManager.generateKey("month", "get", budgetId, month));
         }
     }
     if (serverKnowledge !== undefined) {
-        const transactionCacheKey = CacheManager.generateKey('transactions', 'list', budgetId);
+        const transactionCacheKey = CacheManager.generateKey("transactions", "list", budgetId);
         knowledgeStore.update(transactionCacheKey, serverKnowledge);
         if (invalidateAccountsList) {
-            const accountsCacheKey = CacheManager.generateKey('accounts', 'list', budgetId);
+            const accountsCacheKey = CacheManager.generateKey("accounts", "list", budgetId);
             knowledgeStore.update(accountsCacheKey, serverKnowledge);
         }
         if (shouldInvalidateMonths && affectedMonths.size > 0) {
-            const monthsCacheKey = CacheManager.generateKey('months', 'list', budgetId);
+            const monthsCacheKey = CacheManager.generateKey("months", "list", budgetId);
             knowledgeStore.update(monthsCacheKey, serverKnowledge);
         }
     }
@@ -94,18 +94,21 @@ export function generateCorrelationKey(transaction) {
         return transaction.import_id;
     }
     const segments = [
-        `account:${transaction.account_id ?? ''}`,
-        `date:${transaction.date ?? ''}`,
+        `account:${transaction.account_id ?? ""}`,
+        `date:${transaction.date ?? ""}`,
         `amount:${transaction.amount ?? 0}`,
-        `payee:${transaction.payee_id ?? transaction.payee_name ?? ''}`,
-        `category:${transaction.category_id ?? ''}`,
-        `memo:${transaction.memo ?? ''}`,
-        `cleared:${transaction.cleared ?? ''}`,
+        `payee:${transaction.payee_id ?? transaction.payee_name ?? ""}`,
+        `category:${transaction.category_id ?? ""}`,
+        `memo:${transaction.memo ?? ""}`,
+        `cleared:${transaction.cleared ?? ""}`,
         `approved:${transaction.approved ?? false}`,
-        `flag:${transaction.flag_color ?? ''}`,
+        `flag:${transaction.flag_color ?? ""}`,
     ];
-    const normalized = segments.join('|');
-    const hash = createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+    const normalized = segments.join("|");
+    const hash = createHash("sha256")
+        .update(normalized)
+        .digest("hex")
+        .slice(0, 16);
     return `hash:${hash}`;
 }
 export function toCorrelationPayload(transaction) {
@@ -152,7 +155,7 @@ export function correlateResults(requests, responseData, duplicateImportIds) {
             continue;
         }
         const key = generateCorrelationKey(transaction);
-        if (key.startsWith('hash:')) {
+        if (key.startsWith("hash:")) {
             register(createdByHash, key, transaction.id);
         }
         else {
@@ -174,36 +177,37 @@ export function correlateResults(requests, responseData, duplicateImportIds) {
     for (const [index, transaction] of requests.entries()) {
         const normalizedRequest = toCorrelationPayload(transaction);
         const correlationKey = generateCorrelationKey(normalizedRequest);
-        if (transaction.import_id && duplicateImportIds.has(transaction.import_id)) {
+        if (transaction.import_id &&
+            duplicateImportIds.has(transaction.import_id)) {
             correlatedResults.push({
                 request_index: index,
-                status: 'duplicate',
+                status: "duplicate",
                 correlation_key: correlationKey,
             });
             continue;
         }
         let transactionId;
-        if (correlationKey.startsWith('hash:')) {
+        if (correlationKey.startsWith("hash:")) {
             transactionId = popId(createdByHash, correlationKey);
         }
         else {
             transactionId = popId(createdByImportId, correlationKey);
         }
-        if (!transactionId && !correlationKey.startsWith('hash:')) {
+        if (!transactionId && !correlationKey.startsWith("hash:")) {
             const hashKey = generateCorrelationKey(toCorrelationPayload({ ...transaction, import_id: undefined }));
             transactionId = popId(createdByHash, hashKey);
         }
         if (transactionId) {
             const successResult = {
                 request_index: index,
-                status: 'created',
+                status: "created",
                 correlation_key: correlationKey,
             };
             successResult.transaction_id = transactionId;
             correlatedResults.push(successResult);
             continue;
         }
-        globalRequestLogger.logError('ynab:create_transactions', 'correlate_results', {
+        globalRequestLogger.logError("ynab:create_transactions", "correlate_results", {
             request_index: index,
             correlation_key: correlationKey,
             request: {
@@ -212,19 +216,19 @@ export function correlateResults(requests, responseData, duplicateImportIds) {
                 amount: transaction.amount,
                 import_id: transaction.import_id,
             },
-        }, 'correlation_failed');
+        }, "correlation_failed");
         correlatedResults.push({
             request_index: index,
-            status: 'failed',
+            status: "failed",
             correlation_key: correlationKey,
-            error_code: 'correlation_failed',
-            error: 'Unable to correlate request transaction with YNAB response',
+            error_code: "correlation_failed",
+            error: "Unable to correlate request transaction with YNAB response",
         });
     }
     return correlatedResults;
 }
 export function estimatePayloadSize(payload) {
-    return Buffer.byteLength(JSON.stringify(payload), 'utf8');
+    return Buffer.byteLength(JSON.stringify(payload), "utf8");
 }
 export function finalizeResponse(response) {
     const appendMessage = (message, addition) => {
@@ -236,15 +240,15 @@ export function finalizeResponse(response) {
         }
         return `${message} ${addition}`;
     };
-    const fullSize = estimatePayloadSize({ ...response, mode: 'full' });
+    const fullSize = estimatePayloadSize({ ...response, mode: "full" });
     if (fullSize <= FULL_RESPONSE_THRESHOLD) {
-        return { ...response, mode: 'full' };
+        return { ...response, mode: "full" };
     }
     const { transactions, ...summaryResponse } = response;
     const summaryPayload = {
         ...summaryResponse,
-        message: appendMessage(response.message, 'Response downgraded to summary to stay under size limits.'),
-        mode: 'summary',
+        message: appendMessage(response.message, "Response downgraded to summary to stay under size limits."),
+        mode: "summary",
     };
     if (estimatePayloadSize(summaryPayload) <= SUMMARY_RESPONSE_THRESHOLD) {
         return summaryPayload;
@@ -258,13 +262,16 @@ export function finalizeResponse(response) {
             correlation_key: result.correlation_key,
             error: result.error,
         })),
-        message: appendMessage(summaryResponse.message, 'Response downgraded to ids_only to meet 100KB limit.'),
-        mode: 'ids_only',
+        message: appendMessage(summaryResponse.message, "Response downgraded to ids_only to meet 100KB limit."),
+        mode: "ids_only",
     };
     if (estimatePayloadSize(idsOnlyPayload) <= MAX_RESPONSE_BYTES) {
         return idsOnlyPayload;
     }
-    throw new ValidationError('RESPONSE_TOO_LARGE: Unable to format bulk create response within 100KB limit', `Batch size: ${response.summary.total_requested} transactions`, ['Reduce the batch size and retry', 'Consider splitting into multiple smaller batches']);
+    throw new ValidationError("RESPONSE_TOO_LARGE: Unable to format bulk create response within 100KB limit", `Batch size: ${response.summary.total_requested} transactions`, [
+        "Reduce the batch size and retry",
+        "Consider splitting into multiple smaller batches",
+    ]);
 }
 export function finalizeBulkUpdateResponse(response) {
     const appendMessage = (message, addition) => {
@@ -278,13 +285,13 @@ export function finalizeBulkUpdateResponse(response) {
     };
     const fullSize = estimatePayloadSize(response);
     if (fullSize <= FULL_RESPONSE_THRESHOLD) {
-        return { ...response, mode: 'full' };
+        return { ...response, mode: "full" };
     }
     const { transactions, ...summaryResponse } = response;
     const summaryPayload = {
         ...summaryResponse,
-        message: appendMessage(response.message, 'Response downgraded to summary to stay under size limits.'),
-        mode: 'summary',
+        message: appendMessage(response.message, "Response downgraded to summary to stay under size limits."),
+        mode: "summary",
     };
     if (estimatePayloadSize(summaryPayload) <= SUMMARY_RESPONSE_THRESHOLD) {
         return summaryPayload;
@@ -306,38 +313,46 @@ export function finalizeBulkUpdateResponse(response) {
             }
             return simplified;
         }),
-        message: appendMessage(summaryResponse.message, 'Response downgraded to ids_only to meet 100KB limit.'),
-        mode: 'ids_only',
+        message: appendMessage(summaryResponse.message, "Response downgraded to ids_only to meet 100KB limit."),
+        mode: "ids_only",
     };
     if (estimatePayloadSize(idsOnlyPayload) <= MAX_RESPONSE_BYTES) {
         return idsOnlyPayload;
     }
-    throw new ValidationError('RESPONSE_TOO_LARGE: Unable to format bulk update response within 100KB limit', `Batch size: ${response.summary.total_requested} transactions`, ['Reduce the batch size and retry', 'Consider splitting into multiple smaller batches']);
+    throw new ValidationError("RESPONSE_TOO_LARGE: Unable to format bulk update response within 100KB limit", `Batch size: ${response.summary.total_requested} transactions`, [
+        "Reduce the batch size and retry",
+        "Consider splitting into multiple smaller batches",
+    ]);
 }
 export function handleTransactionError(error, defaultMessage) {
     let errorMessage = defaultMessage;
     if (error instanceof Error) {
-        if (error.message.includes('401') || error.message.includes('Unauthorized')) {
-            errorMessage = 'Invalid or expired YNAB access token';
+        if (error.message.includes("401") ||
+            error.message.includes("Unauthorized")) {
+            errorMessage = "Invalid or expired YNAB access token";
         }
-        else if (error.message.includes('403') || error.message.includes('Forbidden')) {
-            errorMessage = 'Insufficient permissions to access YNAB data';
+        else if (error.message.includes("403") ||
+            error.message.includes("Forbidden")) {
+            errorMessage = "Insufficient permissions to access YNAB data";
         }
-        else if (error.message.includes('404') || error.message.includes('Not Found')) {
-            errorMessage = 'Budget, account, category, or transaction not found';
+        else if (error.message.includes("404") ||
+            error.message.includes("Not Found")) {
+            errorMessage = "Budget, account, category, or transaction not found";
         }
-        else if (error.message.includes('429') || error.message.includes('Too Many Requests')) {
-            errorMessage = 'Rate limit exceeded. Please try again later';
+        else if (error.message.includes("429") ||
+            error.message.includes("Too Many Requests")) {
+            errorMessage = "Rate limit exceeded. Please try again later";
         }
-        else if (error.message.includes('500') || error.message.includes('Internal Server Error')) {
-            errorMessage = 'YNAB service is currently unavailable';
+        else if (error.message.includes("500") ||
+            error.message.includes("Internal Server Error")) {
+            errorMessage = "YNAB service is currently unavailable";
         }
     }
     return {
         isError: true,
         content: [
             {
-                type: 'text',
+                type: "text",
                 text: responseFormatter.format({
                     error: {
                         message: errorMessage,

package/dist/tools/transactionWriteTools.d.ts

@@ -0,0 +1,20 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type * as ynab from "ynab";
+import type { DeltaCache } from "../server/deltaCache.js";
+import type { ServerKnowledgeStore } from "../server/serverKnowledgeStore.js";
+import type { ToolRegistry } from "../server/toolRegistry.js";
+import type { ToolContext } from "../types/toolRegistration.js";
+import { type CreateReceiptSplitTransactionParams, type CreateTransactionParams, type CreateTransactionsParams, type DeleteTransactionParams, type UpdateTransactionParams, type UpdateTransactionsParams } from "./transactionSchemas.js";
+export declare function handleCreateTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateTransactionParams): Promise<CallToolResult>;
+export declare function handleCreateTransaction(ynabAPI: ynab.API, params: CreateTransactionParams): Promise<CallToolResult>;
+export declare function handleCreateReceiptSplitTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateReceiptSplitTransactionParams): Promise<CallToolResult>;
+export declare function handleCreateReceiptSplitTransaction(ynabAPI: ynab.API, params: CreateReceiptSplitTransactionParams): Promise<CallToolResult>;
+export declare function handleUpdateTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateTransactionParams): Promise<CallToolResult>;
+export declare function handleUpdateTransaction(ynabAPI: ynab.API, params: UpdateTransactionParams): Promise<CallToolResult>;
+export declare function handleDeleteTransaction(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: DeleteTransactionParams): Promise<CallToolResult>;
+export declare function handleDeleteTransaction(ynabAPI: ynab.API, params: DeleteTransactionParams): Promise<CallToolResult>;
+export declare function handleCreateTransactions(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateTransactionsParams): Promise<CallToolResult>;
+export declare function handleCreateTransactions(ynabAPI: ynab.API, params: CreateTransactionsParams): Promise<CallToolResult>;
+export declare function handleUpdateTransactions(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateTransactionsParams): Promise<CallToolResult>;
+export declare function handleUpdateTransactions(ynabAPI: ynab.API, params: UpdateTransactionsParams): Promise<CallToolResult>;
+export declare function registerTransactionWriteTools(registry: ToolRegistry, context: ToolContext): void;