@stephendolan/ynab-cli 2.6.0 → 2.8.0

package/dist/cli.js

@@ -187,6 +187,92 @@ function applyTransactionFilters(transactions, filters) {
   }
   return filtered;
 }
+function summarizeTransactions(transactions, options) {
+  let totalAmount = 0;
+  const dates = [];
+  const byPayee = /* @__PURE__ */ new Map();
+  const byCategory = /* @__PURE__ */ new Map();
+  const byCleared = /* @__PURE__ */ new Map();
+  const byApproval = /* @__PURE__ */ new Map();
+  for (const t of transactions) {
+    totalAmount += t.amount;
+    dates.push(t.date);
+    const payeeKey = t.payee_id || t.payee_name || "(none)";
+    const payeeEntry = byPayee.get(payeeKey) || {
+      payee_id: t.payee_id || null,
+      payee_name: t.payee_name || null,
+      count: 0,
+      total_amount: 0
+    };
+    payeeEntry.count++;
+    payeeEntry.total_amount += t.amount;
+    byPayee.set(payeeKey, payeeEntry);
+    const catKey = t.category_id || t.category_name || "(uncategorized)";
+    const catEntry = byCategory.get(catKey) || {
+      category_id: t.category_id || null,
+      category_name: t.category_name || null,
+      count: 0,
+      total_amount: 0
+    };
+    catEntry.count++;
+    catEntry.total_amount += t.amount;
+    byCategory.set(catKey, catEntry);
+    const clearedEntry = byCleared.get(t.cleared) || { count: 0, total_amount: 0 };
+    clearedEntry.count++;
+    clearedEntry.total_amount += t.amount;
+    byCleared.set(t.cleared, clearedEntry);
+    const approvalKey = String(t.approved);
+    const approvalEntry = byApproval.get(approvalKey) || { count: 0, total_amount: 0 };
+    approvalEntry.count++;
+    approvalEntry.total_amount += t.amount;
+    byApproval.set(approvalKey, approvalEntry);
+  }
+  const sortByAbsAmount = (entries) => entries.sort((a, b) => Math.abs(b.total_amount) - Math.abs(a.total_amount));
+  const truncate = (entries, rollupFactory) => {
+    const top = options?.top;
+    if (!top || top <= 0 || entries.length <= top) return entries;
+    const kept = entries.slice(0, top);
+    const rest = entries.slice(top);
+    const rollup = rollupFactory({
+      count: rest.reduce((sum, e) => sum + e.count, 0),
+      total_amount: rest.reduce((sum, e) => sum + e.total_amount, 0)
+    });
+    return [...kept, rollup];
+  };
+  const payeeBreakdown = sortByAbsAmount([...byPayee.values()]);
+  const categoryBreakdown = sortByAbsAmount([...byCategory.values()]);
+  return {
+    total_count: transactions.length,
+    total_amount: totalAmount,
+    date_range: dates.length > 0 ? {
+      from: dates.reduce((a, b) => a < b ? a : b),
+      to: dates.reduce((a, b) => a > b ? a : b)
+    } : null,
+    by_payee: truncate(payeeBreakdown, (e) => ({ payee_id: null, payee_name: "(other)", ...e })),
+    by_category: truncate(categoryBreakdown, (e) => ({ category_id: null, category_name: "(other)", ...e })),
+    by_cleared_status: [...byCleared.entries()].map(([status, entry]) => ({ status, ...entry })),
+    by_approval_status: [...byApproval.entries()].map(([approved, entry]) => ({ approved: approved === "true", ...entry }))
+  };
+}
+function findTransferCandidates(source, allTransactions, options) {
+  const sourceAmount = Math.abs(source.amount);
+  const sourceDateMs = new Date(source.date).getTime();
+  const msPerDay = 864e5;
+  function daysBetween(t) {
+    return Math.abs(new Date(t.date).getTime() - sourceDateMs) / msPerDay;
+  }
+  return allTransactions.filter((t) => {
+    if (t.account_id === source.account_id) return false;
+    if (Math.abs(t.amount) !== sourceAmount) return false;
+    if (Math.sign(t.amount) === Math.sign(source.amount)) return false;
+    return daysBetween(t) <= options.maxDays;
+  }).map((t) => ({
+    transaction: t,
+    already_linked: !!t.transfer_transaction_id,
+    date_difference_days: Math.round(daysBetween(t)),
+    has_transfer_payee: !!t.payee_name?.startsWith("Transfer :")
+  })).sort((a, b) => a.date_difference_days - b.date_difference_days);
+}
 function applyFieldSelection(items, fields) {
   if (!fields) return items;
   const fieldList = fields.split(",").map((f) => f.trim());
@@ -216,6 +302,7 @@ function outputJson(data, options = {}) {
 
 // src/commands/auth.ts
 import { Command } from "commander";
+import { createInterface } from "readline";
 
 // src/lib/auth.ts
 import { Entry } from "@napi-rs/keyring";
@@ -593,6 +680,18 @@ var YnabClient = class {
       return response.data.transaction;
     });
   }
+  async updateTransactions(transactions, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.updateTransactions(id, transactions);
+      return {
+        transactions: response.data.transactions,
+        transaction_ids: response.data.transaction_ids,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
   async deleteTransaction(transactionId, budgetId) {
     return this.withErrorHandling(async () => {
       const api = await this.getApi();
@@ -705,11 +804,42 @@ function buildUpdateObject(options, mapping) {
 }
 
 // src/commands/auth.ts
+function readTokenFromStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data.trim()));
+    process.stdin.on("error", reject);
+  });
+}
+function promptForToken() {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stderr
+    });
+    process.stderr.write("Enter YNAB Personal Access Token: ");
+    rl.question("", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
 function createAuthCommand() {
   const cmd = new Command("auth").description("Authentication management");
-  cmd.command("login").description("Configure access token").requiredOption("-t, --token <token>", "YNAB Personal Access Token").action(
+  cmd.command("login").description("Configure access token").option("-t, --token <token>", "YNAB Personal Access Token").action(
     withErrorHandling(async (options) => {
-      const token = options.token.trim();
+      let token;
+      if (options.token) {
+        token = options.token.trim();
+      } else if (!process.stdin.isTTY) {
+        token = await readTokenFromStdin();
+      } else {
+        token = await promptForToken();
+      }
       if (!token) {
         throw new YnabCliError("Access token cannot be empty", 400);
       }
@@ -836,7 +966,10 @@ function createAccountsCommand() {
       outputJson(account);
     })
   );
-  cmd.command("transactions").description("List transactions for account").argument("<id>", "Account ID").option("-b, --budget <id>", "Budget ID").option("--since <date>", "Filter transactions since date").option("--type <type>", "Filter by transaction type").action(
+  cmd.command("transactions").description("List transactions for account").argument("<id>", "Account ID").option("-b, --budget <id>", "Budget ID").option("--since <date>", "Filter transactions since date").option("--type <type>", "Filter by transaction type").option(
+    "--fields <fields>",
+    "Comma-separated list of fields to include (e.g., id,date,amount,memo)"
+  ).action(
     withErrorHandling(
       async (id, options) => {
         const result = await client.getTransactionsByAccount(id, {
@@ -844,7 +977,8 @@ function createAccountsCommand() {
           sinceDate: options.since ? parseDate(options.since) : void 0,
           type: options.type
         });
-        outputJson(result?.transactions);
+        const transactions = result?.transactions || [];
+        outputJson(applyFieldSelection(transactions, options.fields));
       }
     )
   );
@@ -916,7 +1050,10 @@ function createCategoriesCommand() {
       }
     )
   );
-  cmd.command("transactions").description("List transactions for category").argument("<id>", "Category ID").option("-b, --budget <id>", "Budget ID").option("--since <date>", "Filter transactions since date").option("--type <type>", "Filter by transaction type").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(
+  cmd.command("transactions").description("List transactions for category").argument("<id>", "Category ID").option("-b, --budget <id>", "Budget ID").option("--since <date>", "Filter transactions since date").option("--type <type>", "Filter by transaction type").option("--last-knowledge <number>", "Last knowledge of server", parseInt).option(
+    "--fields <fields>",
+    "Comma-separated list of fields to include (e.g., id,date,amount,memo)"
+  ).action(
     withErrorHandling(
       async (id, options) => {
         const result = await client.getTransactionsByCategory(id, {
@@ -925,7 +1062,8 @@ function createCategoriesCommand() {
           type: options.type,
           lastKnowledgeOfServer: options.lastKnowledge
         });
-        outputJson(result?.transactions);
+        const transactions = result?.transactions || [];
+        outputJson(applyFieldSelection(transactions, options.fields));
       }
     )
   );
@@ -934,6 +1072,7 @@ function createCategoriesCommand() {
 
 // src/commands/transactions.ts
 import { Command as Command6 } from "commander";
+import dayjs2 from "dayjs";
 
 // src/lib/schemas.ts
 function validateTransactionSplits(data) {
@@ -956,6 +1095,44 @@ function validateTransactionSplits(data) {
     };
   });
 }
+var BATCH_UPDATE_FIELDS = [
+  "id",
+  "import_id",
+  "account_id",
+  "date",
+  "amount",
+  "payee_id",
+  "payee_name",
+  "category_id",
+  "memo",
+  "cleared",
+  "approved",
+  "flag_color"
+];
+function validateBatchUpdates(data) {
+  if (!Array.isArray(data)) {
+    throw new YnabCliError("Batch updates must be an array", 400);
+  }
+  return data.map((item, index) => {
+    if (typeof item !== "object" || item === null) {
+      throw new YnabCliError(`Update at index ${index} must be an object`, 400);
+    }
+    const update = item;
+    if (!update.id && !update.import_id) {
+      throw new YnabCliError(
+        `Update at index ${index} must have either "id" or "import_id"`,
+        400
+      );
+    }
+    const result = {};
+    for (const field of BATCH_UPDATE_FIELDS) {
+      if (update[field] !== void 0) {
+        result[field] = update[field];
+      }
+    }
+    return result;
+  });
+}
 function validateApiData(data) {
   if (typeof data !== "object" || data === null || Array.isArray(data)) {
     throw new YnabCliError("API data must be an object", 400);
@@ -964,6 +1141,18 @@ function validateApiData(data) {
 }
 
 // src/commands/transactions.ts
+async function fetchTransactions(options) {
+  const params = {
+    budgetId: options.budget,
+    sinceDate: options.since ? parseDate(options.since) : void 0,
+    type: options.type,
+    lastKnowledgeOfServer: options.lastKnowledge
+  };
+  if (options.account) return client.getTransactionsByAccount(options.account, params);
+  if (options.category) return client.getTransactionsByCategory(options.category, params);
+  if (options.payee) return client.getTransactionsByPayee(options.payee, params);
+  return client.getTransactions(params);
+}
 function buildTransactionData(options) {
   if (!options.account) {
     throw new YnabCliError("--account is required in non-interactive mode", 400);
@@ -991,25 +1180,27 @@ function createTransactionsCommand() {
   ).option("--min-amount <amount>", "Minimum amount in currency units (e.g., 10.50)", parseFloat).option("--max-amount <amount>", "Maximum amount in currency units (e.g., 100.00)", parseFloat).option(
     "--fields <fields>",
     "Comma-separated list of fields to include (e.g., id,date,amount,memo)"
-  ).action(
+  ).option("--last-knowledge <number>", "Last server knowledge for delta requests. When used, output includes server_knowledge.", parseInt).option("--limit <number>", "Maximum number of transactions to return", parseInt).action(
     withErrorHandling(
       async (options) => {
-        const params = {
-          budgetId: options.budget,
-          sinceDate: options.since ? parseDate(options.since) : void 0,
-          type: options.type
-        };
-        const result = options.account ? await client.getTransactionsByAccount(options.account, params) : options.category ? await client.getTransactionsByCategory(options.category, params) : options.payee ? await client.getTransactionsByPayee(options.payee, params) : await client.getTransactions(params);
+        const result = await fetchTransactions(options);
         const transactions = result?.transactions || [];
-        const filtered = applyTransactionFilters(transactions, {
+        let filtered = applyTransactionFilters(transactions, {
           until: options.until ? parseDate(options.until) : void 0,
           approved: options.approved,
           status: options.status,
           minAmount: options.minAmount,
           maxAmount: options.maxAmount
         });
+        if (options.limit && options.limit > 0) {
+          filtered = filtered.slice(0, options.limit);
+        }
         const selected = applyFieldSelection(filtered, options.fields);
-        outputJson(selected);
+        if (options.lastKnowledge !== void 0) {
+          outputJson({ transactions: selected, server_knowledge: result?.server_knowledge });
+        } else {
+          outputJson(selected);
+        }
       }
     )
   );
@@ -1135,6 +1326,33 @@ function createTransactionsCommand() {
       }
     )
   );
+  cmd.command("batch-update").description(
+    "Update multiple transactions in a single API call. Amounts should be in dollars (e.g., -21.40)."
+  ).requiredOption(
+    "--transactions <json>",
+    'JSON array of transaction updates. Each must have "id" or "import_id". Example: [{"id": "tx1", "approved": true, "category_id": "cat1"}]'
+  ).option("-b, --budget <id>", "Budget ID").action(
+    withErrorHandling(
+      async (options) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(options.transactions);
+        } catch {
+          throw new YnabCliError("Invalid JSON in --transactions parameter", 400);
+        }
+        const updates = validateBatchUpdates(parsed);
+        const transactionsInMilliunits = updates.map((update) => ({
+          ...update,
+          ...update.amount !== void 0 ? { amount: amountToMilliunits(update.amount) } : {}
+        }));
+        const result = await client.updateTransactions(
+          { transactions: transactionsInMilliunits },
+          options.budget
+        );
+        outputJson(result);
+      }
+    )
+  );
   cmd.command("search").description("Search transactions").option("-b, --budget <id>", "Budget ID").option("--memo <text>", "Search in memo field").option("--payee-name <name>", "Search in payee name").option("--amount <amount>", "Search for exact amount in currency units", parseFloat).option("--since <date>", "Search transactions since date").option("--until <date>", "Search transactions until date").option("--approved <value>", "Filter by approval status: true or false").option(
     "--status <statuses>",
     "Filter by cleared status: cleared, uncleared, reconciled (comma-separated)"
@@ -1177,6 +1395,49 @@ function createTransactionsCommand() {
       }
     )
   );
+  cmd.command("summary").description("Summarize transactions with aggregate counts by payee, category, and status").option("-b, --budget <id>", "Budget ID").option("--account <id>", "Filter by account ID").option("--category <id>", "Filter by category ID").option("--payee <id>", "Filter by payee ID").option("--since <date>", "Filter transactions since date").option("--until <date>", "Filter transactions until date").option("--type <type>", "Filter by transaction type").option("--approved <value>", "Filter by approval status: true or false").option(
+    "--status <statuses>",
+    "Filter by cleared status: cleared, uncleared, reconciled (comma-separated)"
+  ).option("--min-amount <amount>", "Minimum amount in currency units", parseFloat).option("--max-amount <amount>", "Maximum amount in currency units", parseFloat).option("--top <number>", "Limit payee/category breakdowns to top N entries", parseInt).action(
+    withErrorHandling(
+      async (options) => {
+        const result = await fetchTransactions(options);
+        const transactions = result?.transactions || [];
+        const filtered = applyTransactionFilters(transactions, {
+          until: options.until ? parseDate(options.until) : void 0,
+          approved: options.approved,
+          status: options.status,
+          minAmount: options.minAmount,
+          maxAmount: options.maxAmount
+        });
+        const summary = summarizeTransactions(
+          filtered,
+          options.top ? { top: options.top } : void 0
+        );
+        outputJson(summary);
+      }
+    )
+  );
+  cmd.command("find-transfers").description("Find candidate transfer matches for a transaction across accounts").argument("<id>", "Transaction ID").option("-b, --budget <id>", "Budget ID").option("--days <number>", "Maximum date difference in days (default: 3)", parseInt).option("--since <date>", "Search transactions since date (defaults to source date minus --days)").action(
+    withErrorHandling(
+      async (id, options) => {
+        const maxDays = options.days ?? 3;
+        const source = await client.getTransaction(id, options.budget);
+        const sinceDate = options.since ? parseDate(options.since) : dayjs2(source.date).subtract(maxDays, "day").format("YYYY-MM-DD");
+        const result = await client.getTransactions({
+          budgetId: options.budget,
+          sinceDate
+        });
+        const allTransactions = result?.transactions || [];
+        const candidates = findTransferCandidates(
+          source,
+          allTransactions,
+          { maxDays }
+        );
+        outputJson({ source, candidates });
+      }
+    )
+  );
   return cmd;
 }
 
@@ -1255,7 +1516,10 @@ function createPayeesCommand() {
       outputJson(locations);
     })
   );
-  cmd.command("transactions").description("List transactions for payee").argument("<id>", "Payee ID").option("-b, --budget <id>", "Budget ID").option("--since <date>", "Filter transactions since date").option("--type <type>", "Filter by transaction type").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(
+  cmd.command("transactions").description("List transactions for payee").argument("<id>", "Payee ID").option("-b, --budget <id>", "Budget ID").option("--since <date>", "Filter transactions since date").option("--type <type>", "Filter by transaction type").option("--last-knowledge <number>", "Last knowledge of server", parseInt).option(
+    "--fields <fields>",
+    "Comma-separated list of fields to include (e.g., id,date,amount,memo)"
+  ).action(
     withErrorHandling(
       async (id, options) => {
         const result = await client.getTransactionsByPayee(id, {
@@ -1264,7 +1528,8 @@ function createPayeesCommand() {
           type: options.type,
           lastKnowledgeOfServer: options.lastKnowledge
         });
-        outputJson(result?.transactions);
+        const transactions = result?.transactions || [];
+        outputJson(applyFieldSelection(transactions, options.fields));
       }
     )
   );
@@ -1348,6 +1613,9 @@ var toolRegistry = [
   { name: "update_transaction", description: "Update an existing transaction" },
   { name: "delete_transaction", description: "Delete a transaction" },
   { name: "import_transactions", description: "Trigger import of linked bank transactions" },
+  { name: "batch_update_transactions", description: "Update multiple transactions in a single API call" },
+  { name: "summarize_transactions", description: "Get aggregate summary of transactions by payee, category, and status" },
+  { name: "find_transfer_candidates", description: "Find candidate transfer matches for a transaction across accounts" },
   { name: "list_transactions_by_account", description: "List transactions for a specific account" },
   { name: "list_transactions_by_category", description: "List transactions for a specific category" },
   { name: "list_transactions_by_payee", description: "List transactions for a specific payee" },
@@ -1460,9 +1728,18 @@ server.tool(
   {
     budgetId: z.string().optional().describe("Budget ID (uses default if not specified)"),
     sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)"),
-    type: z.enum(["uncategorized", "unapproved"]).optional().describe("Filter by transaction type")
+    type: z.enum(["uncategorized", "unapproved"]).optional().describe("Filter by transaction type"),
+    lastKnowledgeOfServer: z.number().optional().describe("Delta sync: only return changes since this server knowledge value. Response includes server_knowledge for next call."),
+    limit: z.number().optional().describe("Maximum number of transactions to return"),
+    fields: z.string().optional().describe("Comma-separated list of fields to include (e.g., id,date,amount,memo)")
   },
-  async ({ budgetId, sinceDate, type }) => currencyResponse(await client.getTransactions({ budgetId, sinceDate, type }))
+  async ({ budgetId, sinceDate, type, lastKnowledgeOfServer, limit, fields }) => {
+    const result = await client.getTransactions({ budgetId, sinceDate, type, lastKnowledgeOfServer });
+    let transactions = result?.transactions || [];
+    if (limit && limit > 0) transactions = transactions.slice(0, limit);
+    const selected = fields ? applyFieldSelection(transactions, fields) : transactions;
+    return currencyResponse({ transactions: selected, server_knowledge: result?.server_knowledge });
+  }
 );
 server.tool(
   "get_transaction",
@@ -1548,15 +1825,111 @@ server.tool(
   { budgetId: z.string().optional().describe("Budget ID (uses default if not specified)") },
   async ({ budgetId }) => jsonResponse(await client.importTransactions(budgetId))
 );
+server.tool(
+  "batch_update_transactions",
+  "Update multiple transactions in a single API call. Amounts in dollars.",
+  {
+    transactions: z.array(z.object({
+      id: z.string().optional().nullable().describe("Transaction ID (required if no import_id)"),
+      import_id: z.string().optional().nullable().describe("Import ID (required if no id)"),
+      account_id: z.string().optional().describe("Account ID"),
+      date: z.string().optional().describe("Transaction date (YYYY-MM-DD)"),
+      amount: z.number().optional().describe("Amount in dollars (negative for outflow)"),
+      payee_id: z.string().optional().nullable().describe("Payee ID"),
+      payee_name: z.string().optional().nullable().describe("Payee name"),
+      category_id: z.string().optional().nullable().describe("Category ID"),
+      memo: z.string().optional().nullable().describe("Transaction memo"),
+      cleared: z.enum(["cleared", "uncleared", "reconciled"]).optional().describe("Cleared status"),
+      approved: z.boolean().optional().describe("Whether the transaction is approved"),
+      flag_color: z.enum(["red", "orange", "yellow", "green", "blue", "purple"]).optional().nullable().describe("Flag color")
+    })).describe("Array of transaction updates"),
+    budgetId: z.string().optional().describe("Budget ID (uses default if not specified)")
+  },
+  async ({ transactions, budgetId }) => {
+    const transactionsInMilliunits = transactions.map((update) => ({
+      ...update,
+      ...update.amount !== void 0 ? { amount: amountToMilliunits(update.amount) } : {}
+    }));
+    return currencyResponse(
+      await client.updateTransactions(
+        { transactions: transactionsInMilliunits },
+        budgetId
+      )
+    );
+  }
+);
+server.tool(
+  "summarize_transactions",
+  "Get aggregate summary of transactions by payee, category, and status",
+  {
+    budgetId: z.string().optional().describe("Budget ID (uses default if not specified)"),
+    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)"),
+    untilDate: z.string().optional().describe("Only return transactions on or before this date (YYYY-MM-DD)"),
+    type: z.enum(["uncategorized", "unapproved"]).optional().describe("Filter by transaction type"),
+    approved: z.enum(["true", "false"]).optional().describe("Filter by approval status"),
+    status: z.string().optional().describe("Filter by cleared status: cleared, uncleared, reconciled (comma-separated)"),
+    minAmount: z.number().optional().describe("Minimum amount in dollars"),
+    maxAmount: z.number().optional().describe("Maximum amount in dollars"),
+    top: z.number().optional().describe("Limit payee/category breakdowns to top N entries")
+  },
+  async ({ budgetId, sinceDate, untilDate, type, approved, status, minAmount, maxAmount, top }) => {
+    const result = await client.getTransactions({ budgetId, sinceDate, type });
+    const transactions = result?.transactions || [];
+    const filtered = applyTransactionFilters(transactions, {
+      until: untilDate,
+      approved,
+      status,
+      minAmount,
+      maxAmount
+    });
+    const summary = summarizeTransactions(
+      filtered,
+      top ? { top } : void 0
+    );
+    return currencyResponse(summary);
+  }
+);
+server.tool(
+  "find_transfer_candidates",
+  "Find candidate transfer matches for a transaction across accounts",
+  {
+    transactionId: z.string().describe("Transaction ID to find transfers for"),
+    budgetId: z.string().optional().describe("Budget ID (uses default if not specified)"),
+    maxDays: z.number().optional().describe("Maximum date difference in days (default: 3)"),
+    sinceDate: z.string().optional().describe("Search transactions since date (defaults to source date minus maxDays)")
+  },
+  async ({ transactionId, budgetId, maxDays: maxDaysParam, sinceDate }) => {
+    const days = maxDaysParam ?? 3;
+    const source = await client.getTransaction(transactionId, budgetId);
+    if (!sinceDate) {
+      const d = new Date(source.date);
+      d.setDate(d.getDate() - days);
+      sinceDate = d.toISOString().split("T")[0];
+    }
+    const result = await client.getTransactions({ budgetId, sinceDate });
+    const allTransactions = result?.transactions || [];
+    const candidates = findTransferCandidates(
+      source,
+      allTransactions,
+      { maxDays: days }
+    );
+    return currencyResponse({ source, candidates });
+  }
+);
 server.tool(
   "list_transactions_by_account",
   "List transactions for a specific account",
   {
     accountId: z.string().describe("Account ID"),
     budgetId: z.string().optional().describe("Budget ID (uses default if not specified)"),
-    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)")
+    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)"),
+    fields: z.string().optional().describe("Comma-separated list of fields to include (e.g., id,date,amount,memo)")
   },
-  async ({ accountId, budgetId, sinceDate }) => currencyResponse(await client.getTransactionsByAccount(accountId, { budgetId, sinceDate }))
+  async ({ accountId, budgetId, sinceDate, fields }) => {
+    const result = await client.getTransactionsByAccount(accountId, { budgetId, sinceDate });
+    if (!fields) return currencyResponse(result);
+    return currencyResponse(applyFieldSelection(result?.transactions || [], fields));
+  }
 );
 server.tool(
   "list_transactions_by_category",
@@ -1564,9 +1937,14 @@ server.tool(
   {
     categoryId: z.string().describe("Category ID"),
     budgetId: z.string().optional().describe("Budget ID (uses default if not specified)"),
-    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)")
+    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)"),
+    fields: z.string().optional().describe("Comma-separated list of fields to include (e.g., id,date,amount,memo)")
   },
-  async ({ categoryId, budgetId, sinceDate }) => currencyResponse(await client.getTransactionsByCategory(categoryId, { budgetId, sinceDate }))
+  async ({ categoryId, budgetId, sinceDate, fields }) => {
+    const result = await client.getTransactionsByCategory(categoryId, { budgetId, sinceDate });
+    if (!fields) return currencyResponse(result);
+    return currencyResponse(applyFieldSelection(result?.transactions || [], fields));
+  }
 );
 server.tool(
   "list_transactions_by_payee",
@@ -1574,9 +1952,14 @@ server.tool(
   {
     payeeId: z.string().describe("Payee ID"),
     budgetId: z.string().optional().describe("Budget ID (uses default if not specified)"),
-    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)")
+    sinceDate: z.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD)"),
+    fields: z.string().optional().describe("Comma-separated list of fields to include (e.g., id,date,amount,memo)")
   },
-  async ({ payeeId, budgetId, sinceDate }) => currencyResponse(await client.getTransactionsByPayee(payeeId, { budgetId, sinceDate }))
+  async ({ payeeId, budgetId, sinceDate, fields }) => {
+    const result = await client.getTransactionsByPayee(payeeId, { budgetId, sinceDate });
+    if (!fields) return currencyResponse(result);
+    return currencyResponse(applyFieldSelection(result?.transactions || [], fields));
+  }
 );
 server.tool(
   "list_payees",
@@ -1697,7 +2080,7 @@ function createMcpCommand() {
 
 // src/cli.ts
 var program = new Command12();
-program.name("ynab").description("A command-line interface for You Need a Budget (YNAB)").version("2.6.0").option("-c, --compact", "Minified JSON output (single line)").hook("preAction", (thisCommand) => {
+program.name("ynab").description("A command-line interface for You Need a Budget (YNAB)").version("2.8.0").option("-c, --compact", "Minified JSON output (single line)").hook("preAction", (thisCommand) => {
   const options = thisCommand.opts();
   setOutputOptions({
     compact: options.compact