@dizzlkheinz/ynab-mcpb 0.18.3 → 0.19.0

package/src/tools/reconciliation/recommendationEngine.ts

@@ -1,30 +1,34 @@
-import { randomUUID } from 'crypto';
+import { randomUUID } from "node:crypto";
+import {
+	fromMilli,
+	toMoneyValue,
+	toMoneyValueFromDecimal,
+} from "../../utils/money.js";
 import type {
-  ActionableRecommendation,
-  CreateTransactionRecommendation,
-  UpdateClearedRecommendation,
-  ReviewDuplicateRecommendation,
-  ManualReviewRecommendation,
-  RecommendationContext,
-  ReconciliationInsight,
-  TransactionMatch,
-  BankTransaction,
-  YNABTransaction,
-} from './types.js';
-import { toMoneyValue, toMoneyValueFromDecimal, fromMilli } from '../../utils/money.js';
-
-const RECOMMENDATION_VERSION = '1.0';
+	ActionableRecommendation,
+	BankTransaction,
+	CreateTransactionRecommendation,
+	ManualReviewRecommendation,
+	RecommendationContext,
+	ReconciliationInsight,
+	ReviewDuplicateRecommendation,
+	TransactionMatch,
+	UpdateClearedRecommendation,
+	YNABTransaction,
+} from "./types.js";
+
+const RECOMMENDATION_VERSION = "1.0";
 
 /**
  * Confidence scores for different recommendation types
  */
 const CONFIDENCE = {
-  CREATE_EXACT_MATCH: 0.95,
-  NEAR_MATCH_REVIEW: 0.7,
-  REPEAT_AMOUNT: 0.75,
-  ANOMALY_REVIEW: 0.5,
-  UNMATCHED_BANK: 0.8,
-  UPDATE_CLEARED: 0.6,
+	CREATE_EXACT_MATCH: 0.95,
+	NEAR_MATCH_REVIEW: 0.7,
+	REPEAT_AMOUNT: 0.75,
+	ANOMALY_REVIEW: 0.5,
+	UNMATCHED_BANK: 0.8,
+	UPDATE_CLEARED: 0.6,
 } as const;
 
 /**
@@ -56,44 +60,44 @@ const PRIORITY_ORDER = { high: 3, medium: 2, low: 1 } as const;
  * // Returns recommendations like create_transaction, update_cleared, etc.
  */
 export function generateRecommendations(
-  context: RecommendationContext,
+	context: RecommendationContext,
 ): ActionableRecommendation[] {
-  const recommendations: ActionableRecommendation[] = [];
+	const recommendations: ActionableRecommendation[] = [];
 
-  // Process insights from analyzer
-  for (const insight of context.analysis.insights) {
-    const recs = processInsight(insight, context);
-    recommendations.push(...recs);
-  }
+	// Process insights from analyzer
+	for (const insight of context.analysis.insights) {
+		const recs = processInsight(insight, context);
+		recommendations.push(...recs);
+	}
 
-  // Process unmatched transactions
-  const unmatchedRecs = processUnmatchedTransactions(context);
-  recommendations.push(...unmatchedRecs);
+	// Process unmatched transactions
+	const unmatchedRecs = processUnmatchedTransactions(context);
+	recommendations.push(...unmatchedRecs);
 
-  // Sort by priority and confidence
-  return sortRecommendations(recommendations);
+	// Sort by priority and confidence
+	return sortRecommendations(recommendations);
 }
 
 /**
  * Process a single insight into recommendations
  */
 function processInsight(
-  insight: ReconciliationInsight,
-  context: RecommendationContext,
+	insight: ReconciliationInsight,
+	context: RecommendationContext,
 ): ActionableRecommendation[] {
-  switch (insight.type) {
-    case 'near_match':
-      return [createNearMatchRecommendation(insight, context)];
+	switch (insight.type) {
+		case "near_match":
+			return [createNearMatchRecommendation(insight, context)];
 
-    case 'repeat_amount':
-      return createRepeatAmountRecommendations(insight, context);
+		case "repeat_amount":
+			return createRepeatAmountRecommendations(insight, context);
 
-    case 'anomaly':
-      return [createManualReviewRecommendation(insight, context)];
+		case "anomaly":
+			return [createManualReviewRecommendation(insight, context)];
 
-    default:
-      return [];
-  }
+		default:
+			return [];
+	}
 }
 
 /**
@@ -136,274 +140,281 @@ function processInsight(
  * ); // Returns: create_transaction
  */
 function createSuggestedMatchRecommendation(
-  match: TransactionMatch,
-  context: RecommendationContext,
-): CreateTransactionRecommendation | ReviewDuplicateRecommendation | ManualReviewRecommendation {
-  const bankTxn = match.bankTransaction;
-
-  // If there's a suggested YNAB transaction, review as possible duplicate
-  if (match.ynabTransaction && match.confidence !== 'none') {
-    return {
-      id: randomUUID(),
-      action_type: 'review_duplicate',
-      priority: 'high',
-      confidence: Math.max(0, Math.min(1, match.confidenceScore / 100)),
-      message: `Review possible match: ${bankTxn.payee}`,
-      reason: match.matchReason,
-      estimated_impact: toMoneyValueFromDecimal(
-        0,
-        context.analysis.balance_info.current_cleared.currency,
-      ),
-      account_id: context.account_id,
-      metadata: {
-        version: RECOMMENDATION_VERSION,
-        created_at: new Date().toISOString(),
-      },
-      parameters: {
-        candidate_ids: [match.ynabTransaction.id],
-        bank_transaction: bankTxn,
-        suggested_match_id: match.ynabTransaction.id,
-      },
-    };
-  }
-
-  // Check for combination matches (multiple YNAB transactions that together match the bank transaction)
-  const isCombinationMatch = (match.candidates?.length ?? 0) > 1;
-
-  if (isCombinationMatch) {
-    return createCombinationReviewRecommendation(match, context);
-  }
-
-  // Otherwise suggest creating new transaction
-  const parameters: CreateTransactionRecommendation['parameters'] = {
-    account_id: context.account_id,
-    date: bankTxn.date,
-    amount: bankTxn.amount, // Amount is already milliunits
-    payee_name: bankTxn.payee,
-    cleared: 'cleared',
-    approved: true,
-  };
-
-  if (bankTxn.memo) {
-    parameters.memo = bankTxn.memo;
-  }
-
-  return {
-    id: randomUUID(),
-    action_type: 'create_transaction',
-    priority: 'high',
-    confidence: CONFIDENCE.CREATE_EXACT_MATCH,
-    message: `Create transaction for ${bankTxn.payee}`,
-    reason: `This transaction exactly matches your discrepancy`,
-    estimated_impact: toMoneyValue(
-      bankTxn.amount,
-      context.analysis.balance_info.current_cleared.currency,
-    ),
-    account_id: context.account_id,
-    metadata: {
-      version: RECOMMENDATION_VERSION,
-      created_at: new Date().toISOString(),
-    },
-    parameters,
-  };
+	match: TransactionMatch,
+	context: RecommendationContext,
+):
+	| CreateTransactionRecommendation
+	| ReviewDuplicateRecommendation
+	| ManualReviewRecommendation {
+	const bankTxn = match.bankTransaction;
+
+	// If there's a suggested YNAB transaction, review as possible duplicate
+	if (match.ynabTransaction && match.confidence !== "none") {
+		return {
+			id: randomUUID(),
+			action_type: "review_duplicate",
+			priority: "high",
+			confidence: Math.max(0, Math.min(1, match.confidenceScore / 100)),
+			message: `Review possible match: ${bankTxn.payee}`,
+			reason: match.matchReason,
+			estimated_impact: toMoneyValueFromDecimal(
+				0,
+				context.analysis.balance_info.current_cleared.currency,
+			),
+			account_id: context.account_id,
+			metadata: {
+				version: RECOMMENDATION_VERSION,
+				created_at: new Date().toISOString(),
+			},
+			parameters: {
+				candidate_ids: [match.ynabTransaction.id],
+				bank_transaction: bankTxn,
+				suggested_match_id: match.ynabTransaction.id,
+			},
+		};
+	}
+
+	// Check for combination matches (multiple YNAB transactions that together match the bank transaction)
+	const isCombinationMatch = (match.candidates?.length ?? 0) > 1;
+
+	if (isCombinationMatch) {
+		return createCombinationReviewRecommendation(match, context);
+	}
+
+	// Otherwise suggest creating new transaction
+	const parameters: CreateTransactionRecommendation["parameters"] = {
+		account_id: context.account_id,
+		date: bankTxn.date,
+		amount: bankTxn.amount, // Amount is already milliunits
+		payee_name: bankTxn.payee,
+		cleared: "cleared",
+		approved: true,
+	};
+
+	if (bankTxn.memo) {
+		parameters.memo = bankTxn.memo;
+	}
+
+	return {
+		id: randomUUID(),
+		action_type: "create_transaction",
+		priority: "high",
+		confidence: CONFIDENCE.CREATE_EXACT_MATCH,
+		message: `Create transaction for ${bankTxn.payee}`,
+		reason: "This transaction exactly matches your discrepancy",
+		estimated_impact: toMoneyValue(
+			bankTxn.amount,
+			context.analysis.balance_info.current_cleared.currency,
+		),
+		account_id: context.account_id,
+		metadata: {
+			version: RECOMMENDATION_VERSION,
+			created_at: new Date().toISOString(),
+		},
+		parameters,
+	};
 }
 
 /**
  * Create recommendation for combination match (multiple YNAB transactions matching one bank transaction)
  */
 function createCombinationReviewRecommendation(
-  match: TransactionMatch,
-  context: RecommendationContext,
+	match: TransactionMatch,
+	context: RecommendationContext,
 ): ManualReviewRecommendation {
-  const bankTxn = match.bankTransaction;
-  const candidateIds = match.candidates?.map((candidate) => candidate.ynab_transaction.id) ?? [];
-
-  // Calculate total amount from candidates for context (convert from milliunits to decimal)
-  const candidateTotalAmount =
-    match.candidates?.reduce((sum, candidate) => {
-      const amount = candidate.ynab_transaction.amount;
-      if (!Number.isFinite(amount)) {
-        console.warn(`Invalid candidate amount: ${amount}`);
-        return sum;
-      }
-      return sum + fromMilli(amount);
-    }, 0) ?? 0;
-
-  return {
-    id: randomUUID(),
-    action_type: 'manual_review',
-    priority: 'medium',
-    confidence: CONFIDENCE.NEAR_MATCH_REVIEW,
-    message: `Review combination match: ${bankTxn.payee}`,
-    reason:
-      match.recommendation ??
-      'Multiple YNAB transactions appear to match this bank transaction. Review before creating anything new.',
-    estimated_impact: toMoneyValueFromDecimal(
-      0,
-      context.analysis.balance_info.current_cleared.currency,
-    ),
-    account_id: context.account_id,
-    metadata: {
-      version: RECOMMENDATION_VERSION,
-      created_at: new Date().toISOString(),
-      bank_transaction_amount: toMoneyValue(
-        bankTxn.amount,
-        context.analysis.balance_info.current_cleared.currency,
-      ),
-      candidate_total_amount: toMoneyValueFromDecimal(
-        candidateTotalAmount,
-        context.analysis.balance_info.current_cleared.currency,
-      ),
-      candidate_count: match.candidates?.length ?? 0,
-    },
-    parameters: {
-      issue_type: 'complex_match',
-      related_transactions: [
-        {
-          source: 'bank',
-          id: bankTxn.id,
-          description: bankTxn.payee,
-        },
-        ...candidateIds.map((id) => ({
-          source: 'ynab' as const,
-          id,
-          description:
-            match.candidates?.find((c) => c.ynab_transaction.id === id)?.ynab_transaction.payee ??
-            'Unknown',
-        })),
-      ],
-    },
-  };
+	const bankTxn = match.bankTransaction;
+	const candidateIds =
+		match.candidates?.map((candidate) => candidate.ynab_transaction.id) ?? [];
+
+	// Calculate total amount from candidates for context (convert from milliunits to decimal)
+	const candidateTotalAmount =
+		match.candidates?.reduce((sum, candidate) => {
+			const amount = candidate.ynab_transaction.amount;
+			if (!Number.isFinite(amount)) {
+				console.warn(`Invalid candidate amount: ${amount}`);
+				return sum;
+			}
+			return sum + fromMilli(amount);
+		}, 0) ?? 0;
+
+	return {
+		id: randomUUID(),
+		action_type: "manual_review",
+		priority: "medium",
+		confidence: CONFIDENCE.NEAR_MATCH_REVIEW,
+		message: `Review combination match: ${bankTxn.payee}`,
+		reason:
+			match.recommendation ??
+			"Multiple YNAB transactions appear to match this bank transaction. Review before creating anything new.",
+		estimated_impact: toMoneyValueFromDecimal(
+			0,
+			context.analysis.balance_info.current_cleared.currency,
+		),
+		account_id: context.account_id,
+		metadata: {
+			version: RECOMMENDATION_VERSION,
+			created_at: new Date().toISOString(),
+			bank_transaction_amount: toMoneyValue(
+				bankTxn.amount,
+				context.analysis.balance_info.current_cleared.currency,
+			),
+			candidate_total_amount: toMoneyValueFromDecimal(
+				candidateTotalAmount,
+				context.analysis.balance_info.current_cleared.currency,
+			),
+			candidate_count: match.candidates?.length ?? 0,
+		},
+		parameters: {
+			issue_type: "complex_match",
+			related_transactions: [
+				{
+					source: "bank",
+					id: bankTxn.id,
+					description: bankTxn.payee,
+				},
+				...candidateIds.map((id) => ({
+					source: "ynab" as const,
+					id,
+					description:
+						match.candidates?.find((c) => c.ynab_transaction.id === id)
+							?.ynab_transaction.payee ?? "Unknown",
+				})),
+			],
+		},
+	};
 }
 
 /**
  * Create recommendation for near match insight (possible duplicate)
  */
 function createNearMatchRecommendation(
-  insight: ReconciliationInsight,
-  context: RecommendationContext,
+	insight: ReconciliationInsight,
+	context: RecommendationContext,
 ): ManualReviewRecommendation {
-  return {
-    id: randomUUID(),
-    action_type: 'manual_review',
-    priority: 'medium',
-    confidence: CONFIDENCE.NEAR_MATCH_REVIEW,
-    message: `Review: ${insight.title}`,
-    reason: insight.description,
-    estimated_impact: toMoneyValueFromDecimal(
-      0,
-      context.analysis.balance_info.current_cleared.currency,
-    ),
-    account_id: context.account_id,
-    source_insight_id: insight.id,
-    metadata: {
-      version: RECOMMENDATION_VERSION,
-      created_at: new Date().toISOString(),
-      current_discrepancy: context.analysis.balance_info.discrepancy,
-      insight_severity: insight.severity,
-    },
-    parameters: {
-      issue_type: 'complex_match',
-    },
-  };
+	return {
+		id: randomUUID(),
+		action_type: "manual_review",
+		priority: "medium",
+		confidence: CONFIDENCE.NEAR_MATCH_REVIEW,
+		message: `Review: ${insight.title}`,
+		reason: insight.description,
+		estimated_impact: toMoneyValueFromDecimal(
+			0,
+			context.analysis.balance_info.current_cleared.currency,
+		),
+		account_id: context.account_id,
+		source_insight_id: insight.id,
+		metadata: {
+			version: RECOMMENDATION_VERSION,
+			created_at: new Date().toISOString(),
+			current_discrepancy: context.analysis.balance_info.discrepancy,
+			insight_severity: insight.severity,
+		},
+		parameters: {
+			issue_type: "complex_match",
+		},
+	};
 }
 
 /**
  * Create recommendations for repeat amount pattern
  */
 function createRepeatAmountRecommendations(
-  insight: ReconciliationInsight,
-  context: RecommendationContext,
+	insight: ReconciliationInsight,
+	context: RecommendationContext,
 ): ManualReviewRecommendation[] {
-  // For repeat amounts, suggest manual review since we need to identify the specific transactions
-  return [
-    {
-      id: randomUUID(),
-      action_type: 'manual_review',
-      priority: 'medium',
-      confidence: CONFIDENCE.REPEAT_AMOUNT,
-      message: `Review recurring pattern: ${insight.title}`,
-      reason: insight.description,
-      estimated_impact: toMoneyValueFromDecimal(
-        0,
-        context.analysis.balance_info.current_cleared.currency,
-      ),
-      account_id: context.account_id,
-      source_insight_id: insight.id,
-      metadata: {
-        version: RECOMMENDATION_VERSION,
-        created_at: new Date().toISOString(),
-        current_discrepancy: context.analysis.balance_info.discrepancy,
-        insight_severity: insight.severity,
-      },
-      parameters: {
-        issue_type: 'complex_match',
-      },
-    },
-  ];
+	// For repeat amounts, suggest manual review since we need to identify the specific transactions
+	return [
+		{
+			id: randomUUID(),
+			action_type: "manual_review",
+			priority: "medium",
+			confidence: CONFIDENCE.REPEAT_AMOUNT,
+			message: `Review recurring pattern: ${insight.title}`,
+			reason: insight.description,
+			estimated_impact: toMoneyValueFromDecimal(
+				0,
+				context.analysis.balance_info.current_cleared.currency,
+			),
+			account_id: context.account_id,
+			source_insight_id: insight.id,
+			metadata: {
+				version: RECOMMENDATION_VERSION,
+				created_at: new Date().toISOString(),
+				current_discrepancy: context.analysis.balance_info.discrepancy,
+				insight_severity: insight.severity,
+			},
+			parameters: {
+				issue_type: "complex_match",
+			},
+		},
+	];
 }
 
 /**
  * Create manual review recommendation (fallback)
  */
 function createManualReviewRecommendation(
-  insight: ReconciliationInsight,
-  context: RecommendationContext,
+	insight: ReconciliationInsight,
+	context: RecommendationContext,
 ): ManualReviewRecommendation {
-  return {
-    id: randomUUID(),
-    action_type: 'manual_review',
-    priority: 'low',
-    confidence: CONFIDENCE.ANOMALY_REVIEW,
-    message: `Review: ${insight.title}`,
-    reason: insight.description,
-    estimated_impact: toMoneyValueFromDecimal(
-      0,
-      context.analysis.balance_info.current_cleared.currency,
-    ),
-    account_id: context.account_id,
-    source_insight_id: insight.id,
-    metadata: {
-      version: RECOMMENDATION_VERSION,
-      created_at: new Date().toISOString(),
-      current_discrepancy: context.analysis.balance_info.discrepancy,
-      insight_severity: insight.severity,
-    },
-    parameters: {
-      issue_type: insight.severity === 'critical' ? 'large_discrepancy' : 'unknown',
-    },
-  };
+	return {
+		id: randomUUID(),
+		action_type: "manual_review",
+		priority: "low",
+		confidence: CONFIDENCE.ANOMALY_REVIEW,
+		message: `Review: ${insight.title}`,
+		reason: insight.description,
+		estimated_impact: toMoneyValueFromDecimal(
+			0,
+			context.analysis.balance_info.current_cleared.currency,
+		),
+		account_id: context.account_id,
+		source_insight_id: insight.id,
+		metadata: {
+			version: RECOMMENDATION_VERSION,
+			created_at: new Date().toISOString(),
+			current_discrepancy: context.analysis.balance_info.discrepancy,
+			insight_severity: insight.severity,
+		},
+		parameters: {
+			issue_type:
+				insight.severity === "critical" ? "large_discrepancy" : "unknown",
+		},
+	};
 }
 
 /**
  * Process unmatched transactions into recommendations
  */
-function processUnmatchedTransactions(context: RecommendationContext): ActionableRecommendation[] {
-  const recommendations: ActionableRecommendation[] = [];
-
-  // Unmatched bank transactions → create_transaction
-  for (const bankTxn of context.analysis.unmatched_bank) {
-    recommendations.push(createUnmatchedBankRecommendation(bankTxn, context));
-  }
-
-  // Suggested matches → review as potential duplicates or auto-match
-  const matchesForReview = [
-    ...context.analysis.suggested_matches,
-    ...context.analysis.auto_matches,
-  ];
-
-  for (const match of matchesForReview) {
-    recommendations.push(createSuggestedMatchRecommendation(match, context));
-  }
-
-  // Unmatched YNAB uncleared → update_cleared (lower priority)
-  for (const ynabTxn of context.analysis.unmatched_ynab) {
-    if (ynabTxn.cleared === 'uncleared') {
-      recommendations.push(createUpdateClearedRecommendation(ynabTxn, context));
-    }
-  }
-
-  return recommendations;
+function processUnmatchedTransactions(
+	context: RecommendationContext,
+): ActionableRecommendation[] {
+	const recommendations: ActionableRecommendation[] = [];
+
+	// Unmatched bank transactions → create_transaction
+	for (const bankTxn of context.analysis.unmatched_bank) {
+		recommendations.push(createUnmatchedBankRecommendation(bankTxn, context));
+	}
+
+	// Suggested matches → review as potential duplicates or auto-match
+	const matchesForReview = [
+		...context.analysis.suggested_matches,
+		...context.analysis.auto_matches,
+	];
+
+	for (const match of matchesForReview) {
+		recommendations.push(createSuggestedMatchRecommendation(match, context));
+	}
+
+	// Unmatched YNAB uncleared → update_cleared (lower priority)
+	for (const ynabTxn of context.analysis.unmatched_ynab) {
+		if (ynabTxn.cleared === "uncleared") {
+			recommendations.push(createUpdateClearedRecommendation(ynabTxn, context));
+		}
+	}
+
+	return recommendations;
 }
 
 /**
@@ -418,40 +429,40 @@ function processUnmatchedTransactions(context: RecommendationContext): Actionabl
  * @returns create_transaction recommendation with medium priority and 0.8 confidence
  */
 function createUnmatchedBankRecommendation(
-  txn: BankTransaction,
-  context: RecommendationContext,
+	txn: BankTransaction,
+	context: RecommendationContext,
 ): CreateTransactionRecommendation {
-  const parameters: CreateTransactionRecommendation['parameters'] = {
-    account_id: context.account_id,
-    date: txn.date,
-    amount: txn.amount, // Amount is already milliunits
-    payee_name: txn.payee,
-    cleared: 'cleared',
-    approved: true,
-  };
-
-  if (txn.memo) {
-    parameters.memo = txn.memo;
-  }
-
-  return {
-    id: randomUUID(),
-    action_type: 'create_transaction',
-    priority: 'medium',
-    confidence: CONFIDENCE.UNMATCHED_BANK,
-    message: `Create missing transaction: ${txn.payee}`,
-    reason: 'Transaction appears on bank statement but not in YNAB',
-    estimated_impact: toMoneyValue(
-      txn.amount,
-      context.analysis.balance_info.current_cleared.currency,
-    ),
-    account_id: context.account_id,
-    metadata: {
-      version: RECOMMENDATION_VERSION,
-      created_at: new Date().toISOString(),
-    },
-    parameters,
-  };
+	const parameters: CreateTransactionRecommendation["parameters"] = {
+		account_id: context.account_id,
+		date: txn.date,
+		amount: txn.amount, // Amount is already milliunits
+		payee_name: txn.payee,
+		cleared: "cleared",
+		approved: true,
+	};
+
+	if (txn.memo) {
+		parameters.memo = txn.memo;
+	}
+
+	return {
+		id: randomUUID(),
+		action_type: "create_transaction",
+		priority: "medium",
+		confidence: CONFIDENCE.UNMATCHED_BANK,
+		message: `Create missing transaction: ${txn.payee}`,
+		reason: "Transaction appears on bank statement but not in YNAB",
+		estimated_impact: toMoneyValue(
+			txn.amount,
+			context.analysis.balance_info.current_cleared.currency,
+		),
+		account_id: context.account_id,
+		metadata: {
+			version: RECOMMENDATION_VERSION,
+			created_at: new Date().toISOString(),
+		},
+		parameters,
+	};
 }
 
 /**
@@ -467,44 +478,45 @@ function createUnmatchedBankRecommendation(
  * @returns update_cleared recommendation with low priority and 0.6 confidence
  */
 function createUpdateClearedRecommendation(
-  txn: YNABTransaction,
-  context: RecommendationContext,
+	txn: YNABTransaction,
+	context: RecommendationContext,
 ): UpdateClearedRecommendation {
-  return {
-    id: randomUUID(),
-    action_type: 'update_cleared',
-    priority: 'low',
-    confidence: CONFIDENCE.UPDATE_CLEARED,
-    message: `Mark transaction as cleared: ${txn.payee || 'Unknown'}`,
-    reason: 'Transaction exists in YNAB but not yet cleared',
-    estimated_impact: toMoneyValueFromDecimal(
-      0,
-      context.analysis.balance_info.current_cleared.currency,
-    ),
-    account_id: context.account_id,
-    metadata: {
-      version: RECOMMENDATION_VERSION,
-      created_at: new Date().toISOString(),
-    },
-    parameters: {
-      transaction_id: txn.id,
-      cleared: 'cleared',
-    },
-  };
+	return {
+		id: randomUUID(),
+		action_type: "update_cleared",
+		priority: "low",
+		confidence: CONFIDENCE.UPDATE_CLEARED,
+		message: `Mark transaction as cleared: ${txn.payee || "Unknown"}`,
+		reason: "Transaction exists in YNAB but not yet cleared",
+		estimated_impact: toMoneyValueFromDecimal(
+			0,
+			context.analysis.balance_info.current_cleared.currency,
+		),
+		account_id: context.account_id,
+		metadata: {
+			version: RECOMMENDATION_VERSION,
+			created_at: new Date().toISOString(),
+		},
+		parameters: {
+			transaction_id: txn.id,
+			cleared: "cleared",
+		},
+	};
 }
 
 /**
  * Sort recommendations by priority and confidence
  */
 function sortRecommendations(
-  recommendations: ActionableRecommendation[],
+	recommendations: ActionableRecommendation[],
 ): ActionableRecommendation[] {
-  return recommendations.sort((a, b) => {
-    // Sort by priority first
-    const priorityDiff = PRIORITY_ORDER[b.priority] - PRIORITY_ORDER[a.priority];
-    if (priorityDiff !== 0) return priorityDiff;
-
-    // Then by confidence
-    return b.confidence - a.confidence;
-  });
+	return recommendations.sort((a, b) => {
+		// Sort by priority first
+		const priorityDiff =
+			PRIORITY_ORDER[b.priority] - PRIORITY_ORDER[a.priority];
+		if (priorityDiff !== 0) return priorityDiff;
+
+		// Then by confidence
+		return b.confidence - a.confidence;
+	});
 }