@stephendolan/ynab-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,1202 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command11 } from "commander";
+
+// src/lib/utils.ts
+import { format, parseISO } from "date-fns";
+function milliunitsToAmount(milliunits) {
+  return milliunits / 1e3;
+}
+function amountToMilliunits(amount) {
+  return Math.round(amount * 1e3);
+}
+function isInteractive() {
+  return process.stdin.isTTY === true;
+}
+function convertMilliunitsToAmounts(data) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => convertMilliunitsToAmounts(item));
+  }
+  if (typeof data === "object") {
+    const converted = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (isAmountField(key) && typeof value === "number") {
+        converted[key] = milliunitsToAmount(value);
+      } else {
+        converted[key] = convertMilliunitsToAmounts(value);
+      }
+    }
+    return converted;
+  }
+  return data;
+}
+function isAmountField(fieldName) {
+  const amountFields = [
+    "amount",
+    "balance",
+    "cleared_balance",
+    "uncleared_balance",
+    "budgeted",
+    "activity",
+    "available",
+    "goal_target"
+  ];
+  return amountFields.includes(fieldName) || fieldName.endsWith("_amount");
+}
+function parseApprovedFilter(value) {
+  const normalized = value.toLowerCase();
+  if (normalized !== "true" && normalized !== "false") {
+    throw new Error(`--approved must be 'true' or 'false', got '${value}'`);
+  }
+  return normalized === "true";
+}
+function parseStatusFilter(value) {
+  const statuses = value.split(",").map((s) => s.trim().toLowerCase());
+  const validStatuses = ["cleared", "uncleared", "reconciled"];
+  for (const status of statuses) {
+    if (!validStatuses.includes(status)) {
+      throw new Error(`Invalid status '${status}'. Must be one of: ${validStatuses.join(", ")}`);
+    }
+  }
+  return statuses;
+}
+function applyTransactionFilters(transactions, filters) {
+  let filtered = transactions;
+  if (filters.until) {
+    filtered = filtered.filter((t) => t.date <= filters.until);
+  }
+  if (filters.approved !== void 0) {
+    const approvedValue = parseApprovedFilter(filters.approved);
+    filtered = filtered.filter((t) => t.approved === approvedValue);
+  }
+  if (filters.status) {
+    const statuses = parseStatusFilter(filters.status);
+    filtered = filtered.filter((t) => statuses.includes(t.cleared.toLowerCase()));
+  }
+  if (filters.minAmount !== void 0) {
+    const minMilliunits = amountToMilliunits(filters.minAmount);
+    filtered = filtered.filter((t) => t.amount >= minMilliunits);
+  }
+  if (filters.maxAmount !== void 0) {
+    const maxMilliunits = amountToMilliunits(filters.maxAmount);
+    filtered = filtered.filter((t) => t.amount <= maxMilliunits);
+  }
+  return filtered;
+}
+function applyFieldSelection(items, fields) {
+  if (!fields) return items;
+  const fieldList = fields.split(",").map((f) => f.trim());
+  return items.map((item) => {
+    const filtered = {};
+    fieldList.forEach((field) => {
+      if (field in item) {
+        filtered[field] = item[field];
+      }
+    });
+    return filtered;
+  });
+}
+
+// src/lib/output.ts
+var globalOutputOptions = {};
+function setOutputOptions(options) {
+  globalOutputOptions = options;
+}
+function outputJson(data, options = {}) {
+  const convertedData = convertMilliunitsToAmounts(data);
+  const mergedOptions = { ...globalOutputOptions, ...options };
+  const jsonString = mergedOptions.compact ? JSON.stringify(convertedData) : JSON.stringify(convertedData, null, 2);
+  console.log(jsonString);
+}
+function outputSuccess(data, options = {}) {
+  outputJson(data, options);
+}
+
+// src/commands/auth.ts
+import { Command } from "commander";
+
+// src/lib/auth.ts
+import keytar from "keytar";
+
+// src/lib/config.ts
+import Conf from "conf";
+var ConfigManager = class {
+  conf;
+  constructor() {
+    this.conf = new Conf({
+      projectName: "ynab-cli",
+      schema: {
+        defaultBudget: { type: "string" },
+        version: { type: "string", default: "1.0.0" }
+      },
+      defaults: { version: "1.0.0" }
+    });
+  }
+  getDefaultBudget() {
+    return this.conf.get("defaultBudget");
+  }
+  setDefaultBudget(budgetId) {
+    this.conf.set("defaultBudget", budgetId);
+  }
+  clearDefaultBudget() {
+    this.conf.delete("defaultBudget");
+  }
+  clear() {
+    this.conf.clear();
+  }
+};
+var config = new ConfigManager();
+
+// src/lib/auth.ts
+var SERVICE_NAME = "ynab-cli";
+var ACCOUNT_NAME = "access-token";
+var AuthManager = class {
+  async getAccessToken() {
+    return keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+  }
+  async setAccessToken(token) {
+    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
+  }
+  async deleteAccessToken() {
+    return keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+  }
+  async isAuthenticated() {
+    return await this.getAccessToken() !== null;
+  }
+  async logout() {
+    await this.deleteAccessToken();
+    config.clearDefaultBudget();
+  }
+};
+var auth = new AuthManager();
+
+// src/lib/prompts.ts
+import inquirer from "inquirer";
+async function promptForAccessToken() {
+  const { token } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "token",
+      message: "Enter your YNAB Personal Access Token:",
+      validate: (input) => !!input.trim() || "Access token is required"
+    }
+  ]);
+  return token;
+}
+async function promptForConfirmation(message) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: false
+    }
+  ]);
+  return confirmed;
+}
+async function promptForTransaction() {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "date",
+      message: "Date (YYYY-MM-DD):",
+      default: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+    },
+    {
+      type: "input",
+      name: "amount",
+      message: "Amount (in currency units, e.g., 10.50):",
+      validate: (input) => !isNaN(parseFloat(input)) || "Amount must be a valid number"
+    },
+    {
+      type: "input",
+      name: "payee_name",
+      message: "Payee name (optional):"
+    },
+    {
+      type: "input",
+      name: "memo",
+      message: "Memo (optional):"
+    }
+  ]);
+  return {
+    date: answers.date,
+    amount: amountToMilliunits(parseFloat(answers.amount)),
+    payee_name: answers.payee_name || void 0,
+    memo: answers.memo || void 0
+  };
+}
+
+// src/lib/api-client.ts
+import * as ynab from "ynab";
+
+// src/lib/errors.ts
+var YnabCliError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "YnabCliError";
+  }
+};
+var ERROR_STATUS_CODES = {
+  bad_request: 400,
+  not_authorized: 401,
+  subscription_lapsed: 403,
+  trial_expired: 403,
+  unauthorized_scope: 403,
+  data_limit_reached: 403,
+  not_found: 404,
+  resource_not_found: 404,
+  conflict: 409,
+  too_many_requests: 429,
+  internal_server_error: 500,
+  service_unavailable: 503
+};
+function sanitizeErrorMessage(message) {
+  const sensitivePatterns = [
+    /Bearer\s+[\w\-._~+/]+=*/gi,
+    /token[=:]\s*[\w\-._~+/]+=*/gi,
+    /api[_-]?key[=:]\s*[\w\-._~+/]+=*/gi,
+    /authorization:\s*bearer\s+[\w\-._~+/]+=*/gi
+  ];
+  let sanitized = message;
+  for (const pattern of sensitivePatterns) {
+    sanitized = sanitized.replace(pattern, "[REDACTED]");
+  }
+  return sanitized.length > 500 ? sanitized.substring(0, 500) + "..." : sanitized;
+}
+function sanitizeApiError(error) {
+  const detail = sanitizeErrorMessage(
+    String(error.detail || error.message || "An error occurred")
+  );
+  return {
+    name: error.name || "api_error",
+    detail,
+    id: error.id
+  };
+}
+function formatErrorResponse(name, detail, statusCode) {
+  outputJson({ error: { name, detail, statusCode } });
+  process.exit(1);
+}
+function handleYnabError(error) {
+  if (error.error) {
+    const ynabError = sanitizeApiError(error.error);
+    formatErrorResponse(
+      ynabError.name,
+      ynabError.detail,
+      ERROR_STATUS_CODES[ynabError.name] || 500
+    );
+  }
+  if (error instanceof YnabCliError) {
+    const sanitized2 = sanitizeErrorMessage(error.message);
+    formatErrorResponse("cli_error", sanitized2, error.statusCode || 1);
+  }
+  const sanitized = sanitizeErrorMessage(error.message || "An unexpected error occurred");
+  formatErrorResponse("unknown_error", sanitized, 1);
+}
+
+// src/lib/api-client.ts
+import dotenv from "dotenv";
+dotenv.config();
+var YnabClient = class {
+  api = null;
+  hasShownEnvVarWarning = false;
+  async getApi() {
+    if (this.api) {
+      return this.api;
+    }
+    const keychainToken = await auth.getAccessToken();
+    const accessToken = keychainToken || process.env.YNAB_API_KEY || null;
+    if (!accessToken) {
+      throw new YnabCliError(
+        "Not authenticated. Please run: ynab auth login or set YNAB_API_KEY environment variable",
+        401
+      );
+    }
+    if (!keychainToken && process.env.YNAB_API_KEY && !this.hasShownEnvVarWarning) {
+      console.warn(
+        "\x1B[33m\u26A0\uFE0F  WARNING: Using YNAB_API_KEY environment variable.\nEnvironment variables may be visible to other processes.\nFor better security, use: ynab auth login\x1B[0m\n"
+      );
+      this.hasShownEnvVarWarning = true;
+    }
+    this.api = new ynab.API(accessToken);
+    return this.api;
+  }
+  async getBudgetId(budgetIdOrDefault) {
+    const budgetId = budgetIdOrDefault || config.getDefaultBudget() || process.env.YNAB_BUDGET_ID;
+    if (!budgetId) {
+      throw new YnabCliError(
+        'No budget specified. Use --budget flag, set default with "ynab budgets set-default", or set YNAB_BUDGET_ID environment variable',
+        400
+      );
+    }
+    return budgetId;
+  }
+  async withErrorHandling(fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      handleYnabError(error);
+    }
+  }
+  async getUser() {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const response = await api.user.getUser();
+      return response.data.user;
+    });
+  }
+  async getBudgets(includeAccounts = false) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const response = await api.budgets.getBudgets(includeAccounts);
+      return {
+        budgets: response.data.budgets,
+        server_knowledge: 0
+      };
+    });
+  }
+  async getBudget(budgetId, lastKnowledgeOfServer) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.budgets.getBudgetById(id, lastKnowledgeOfServer);
+      return {
+        budget: response.data.budget,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getBudgetSettings(budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.budgets.getBudgetSettingsById(id);
+      return response.data.settings;
+    });
+  }
+  async getAccounts(budgetId, lastKnowledgeOfServer) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.accounts.getAccounts(id, lastKnowledgeOfServer);
+      return {
+        accounts: response.data.accounts,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getAccount(accountId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.accounts.getAccountById(id, accountId);
+      return response.data.account;
+    });
+  }
+  async createAccount(accountData, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.accounts.createAccount(id, accountData);
+      return response.data.account;
+    });
+  }
+  async getCategories(budgetId, lastKnowledgeOfServer) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.categories.getCategories(id, lastKnowledgeOfServer);
+      return {
+        category_groups: response.data.category_groups,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getCategory(categoryId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.categories.getCategoryById(id, categoryId);
+      return response.data.category;
+    });
+  }
+  async updateCategory(categoryId, data, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.categories.updateCategory(id, categoryId, data);
+      return response.data.category;
+    });
+  }
+  async getMonthCategory(month, categoryId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.categories.getMonthCategoryById(id, month, categoryId);
+      return response.data.category;
+    });
+  }
+  async updateMonthCategory(month, categoryId, data, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.categories.updateMonthCategory(id, month, categoryId, data);
+      return response.data.category;
+    });
+  }
+  async getPayees(budgetId, lastKnowledgeOfServer) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.payees.getPayees(id, lastKnowledgeOfServer);
+      return {
+        payees: response.data.payees,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getPayee(payeeId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.payees.getPayeeById(id, payeeId);
+      return response.data.payee;
+    });
+  }
+  async updatePayee(payeeId, data, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.payees.updatePayee(id, payeeId, data);
+      return response.data.payee;
+    });
+  }
+  async getPayeeLocations(budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.payeeLocations.getPayeeLocations(id);
+      return response.data.payee_locations;
+    });
+  }
+  async getPayeeLocation(payeeLocationId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.payeeLocations.getPayeeLocationById(id, payeeLocationId);
+      return response.data.payee_location;
+    });
+  }
+  async getPayeeLocationsByPayee(payeeId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.payeeLocations.getPayeeLocationsByPayee(id, payeeId);
+      return response.data.payee_locations;
+    });
+  }
+  async getBudgetMonths(budgetId, lastKnowledgeOfServer) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.months.getBudgetMonths(id, lastKnowledgeOfServer);
+      return {
+        months: response.data.months,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getBudgetMonth(month, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.months.getBudgetMonth(id, month);
+      return response.data.month;
+    });
+  }
+  async getTransactions(params) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(params.budgetId);
+      const response = await api.transactions.getTransactions(
+        id,
+        params.sinceDate,
+        params.type,
+        params.lastKnowledgeOfServer
+      );
+      return {
+        transactions: response.data.transactions,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getTransactionsByAccount(accountId, params) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(params.budgetId);
+      const response = await api.transactions.getTransactionsByAccount(
+        id,
+        accountId,
+        params.sinceDate,
+        params.type,
+        params.lastKnowledgeOfServer
+      );
+      return {
+        transactions: response.data.transactions,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getTransactionsByCategory(categoryId, params) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(params.budgetId);
+      const response = await api.transactions.getTransactionsByCategory(
+        id,
+        categoryId,
+        params.sinceDate,
+        params.type,
+        params.lastKnowledgeOfServer
+      );
+      return {
+        transactions: response.data.transactions,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getTransactionsByPayee(payeeId, params) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(params.budgetId);
+      const response = await api.transactions.getTransactionsByPayee(
+        id,
+        payeeId,
+        params.sinceDate,
+        params.type,
+        params.lastKnowledgeOfServer
+      );
+      return {
+        transactions: response.data.transactions,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getTransaction(transactionId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.getTransactionById(id, transactionId);
+      return response.data.transaction;
+    });
+  }
+  async createTransaction(transactionData, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.createTransaction(id, transactionData);
+      return response.data.transaction;
+    });
+  }
+  async createTransactions(transactionsData, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.createTransactions(id, transactionsData);
+      return response.data;
+    });
+  }
+  async updateTransaction(transactionId, transactionData, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.updateTransaction(
+        id,
+        transactionId,
+        transactionData
+      );
+      return response.data.transaction;
+    });
+  }
+  async updateTransactions(transactionsData, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.updateTransactions(id, transactionsData);
+      return response.data;
+    });
+  }
+  async deleteTransaction(transactionId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.deleteTransaction(id, transactionId);
+      return response.data.transaction;
+    });
+  }
+  async importTransactions(budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.transactions.importTransactions(id);
+      return response.data.transaction_ids;
+    });
+  }
+  async getScheduledTransactions(budgetId, lastKnowledgeOfServer) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.scheduledTransactions.getScheduledTransactions(
+        id,
+        lastKnowledgeOfServer
+      );
+      return {
+        scheduled_transactions: response.data.scheduled_transactions,
+        server_knowledge: response.data.server_knowledge
+      };
+    });
+  }
+  async getScheduledTransaction(scheduledTransactionId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.scheduledTransactions.getScheduledTransactionById(
+        id,
+        scheduledTransactionId
+      );
+      return response.data.scheduled_transaction;
+    });
+  }
+  async createScheduledTransaction(data, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.scheduledTransactions.createScheduledTransaction(id, data);
+      return response.data.scheduled_transaction;
+    });
+  }
+  async updateScheduledTransaction(scheduledTransactionId, data, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.scheduledTransactions.updateScheduledTransaction(
+        id,
+        scheduledTransactionId,
+        data
+      );
+      return response.data.scheduled_transaction;
+    });
+  }
+  async deleteScheduledTransaction(scheduledTransactionId, budgetId) {
+    return this.withErrorHandling(async () => {
+      const api = await this.getApi();
+      const id = await this.getBudgetId(budgetId);
+      const response = await api.scheduledTransactions.deleteScheduledTransaction(
+        id,
+        scheduledTransactionId
+      );
+      return response.data.scheduled_transaction;
+    });
+  }
+  async rawApiCall(method, path, data, budgetId) {
+    return this.withErrorHandling(async () => {
+      await this.getApi();
+      const fullPath = path.includes("{budget_id}") ? path.replace("{budget_id}", await this.getBudgetId(budgetId)) : path;
+      const url = `https://api.ynab.com/v1${fullPath}`;
+      const headers = {
+        Authorization: `Bearer ${await auth.getAccessToken()}`,
+        "Content-Type": "application/json"
+      };
+      const httpMethod = method.toUpperCase();
+      const hasBody = ["POST", "PUT", "PATCH"].includes(httpMethod);
+      if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(httpMethod)) {
+        throw new YnabCliError(`Unsupported HTTP method: ${method}`, 400);
+      }
+      const response = await fetch(url, {
+        method: httpMethod,
+        headers,
+        ...hasBody && { body: JSON.stringify(data) }
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw { error: sanitizeApiError(errorData.error || errorData) };
+      }
+      return await response.json();
+    });
+  }
+};
+var client = new YnabClient();
+
+// src/lib/command-utils.ts
+function withErrorHandling(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      handleYnabError(error);
+    }
+  };
+}
+async function confirmDelete(itemType, skipConfirmation = false) {
+  if (skipConfirmation || !isInteractive()) {
+    return true;
+  }
+  const confirmed = await promptForConfirmation(
+    `Are you sure you want to delete this ${itemType}?`
+  );
+  if (!confirmed) {
+    outputSuccess({ message: "Operation cancelled" });
+    return false;
+  }
+  return true;
+}
+function buildUpdateObject(options, mapping) {
+  const result = {};
+  for (const [optionKey, targetKey] of Object.entries(mapping)) {
+    if (options[optionKey] !== void 0) {
+      result[targetKey] = options[optionKey];
+    }
+  }
+  return result;
+}
+
+// src/commands/auth.ts
+function createAuthCommand() {
+  const cmd = new Command("auth").description("Authentication management");
+  cmd.command("login").description("Configure access token").action(withErrorHandling(async () => {
+    const token = await promptForAccessToken();
+    await auth.setAccessToken(token);
+    try {
+      const user = await client.getUser();
+      outputSuccess({
+        message: "Successfully authenticated",
+        user: { id: user?.id }
+      });
+    } catch (error) {
+      await auth.deleteAccessToken();
+      throw error;
+    }
+  }));
+  cmd.command("status").description("Check authentication status").action(withErrorHandling(async () => {
+    const isAuthenticated = await auth.isAuthenticated();
+    if (!isAuthenticated) {
+      outputJson({ authenticated: false, message: "Not authenticated" });
+      return;
+    }
+    try {
+      const user = await client.getUser();
+      outputSuccess({ authenticated: true, user: { id: user?.id } });
+    } catch (error) {
+      outputJson({ authenticated: false, message: "Token exists but is invalid" });
+    }
+  }));
+  cmd.command("logout").description("Remove stored credentials").action(withErrorHandling(async () => {
+    await auth.logout();
+    outputSuccess({ message: "Successfully logged out" });
+  }));
+  return cmd;
+}
+
+// src/commands/user.ts
+import { Command as Command2 } from "commander";
+function createUserCommand() {
+  const cmd = new Command2("user").description("User information");
+  cmd.command("info").description("Get authenticated user information").action(withErrorHandling(async () => {
+    const user = await client.getUser();
+    outputSuccess(user);
+  }));
+  return cmd;
+}
+
+// src/commands/budgets.ts
+import { Command as Command3 } from "commander";
+function createBudgetsCommand() {
+  const cmd = new Command3("budgets").description("Budget operations");
+  cmd.command("list").description("List all budgets").option("--include-accounts", "Include accounts in response").action(withErrorHandling(async (options) => {
+    const result = await client.getBudgets(options.includeAccounts);
+    outputSuccess(result?.budgets);
+  }));
+  cmd.command("view").description("View budget details (uses default if no id provided)").argument("[id]", "Budget ID").action(withErrorHandling(async (id) => {
+    const result = await client.getBudget(id);
+    outputSuccess(result?.budget);
+  }));
+  cmd.command("settings").description("View budget settings").argument("[id]", "Budget ID").action(withErrorHandling(async (id) => {
+    const settings = await client.getBudgetSettings(id);
+    outputSuccess(settings);
+  }));
+  cmd.command("set-default").description("Set default budget for commands").argument("<id>", "Budget ID").action(withErrorHandling(async (id) => {
+    const result = await client.getBudgets();
+    const budget = result?.budgets.find((b) => b.id === id);
+    if (!budget) {
+      throw new YnabCliError(`Budget with ID ${id} not found`, 404);
+    }
+    config.setDefaultBudget(id);
+    outputSuccess({
+      message: "Default budget set",
+      budget: { id: budget.id, name: budget.name }
+    });
+  }));
+  return cmd;
+}
+
+// src/commands/accounts.ts
+import { Command as Command4 } from "commander";
+function createAccountsCommand() {
+  const cmd = new Command4("accounts").description("Account operations");
+  cmd.command("list").description("List all accounts").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (options) => {
+    const result = await client.getAccounts(options.budget);
+    outputSuccess(result?.accounts);
+  }));
+  cmd.command("view").description("View account details").argument("<id>", "Account ID").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    const account = await client.getAccount(id, options.budget);
+    outputSuccess(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 (YYYY-MM-DD)").option("--type <type>", "Filter by transaction type").action(withErrorHandling(async (id, options) => {
+    const result = await client.getTransactionsByAccount(id, {
+      budgetId: options.budget,
+      sinceDate: options.since,
+      type: options.type
+    });
+    outputSuccess(result?.transactions);
+  }));
+  return cmd;
+}
+
+// src/commands/categories.ts
+import { Command as Command5 } from "commander";
+function createCategoriesCommand() {
+  const cmd = new Command5("categories").description("Category operations");
+  cmd.command("list").description("List all categories").option("-b, --budget <id>", "Budget ID").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(withErrorHandling(async (options) => {
+    const result = await client.getCategories(options.budget, options.lastKnowledge);
+    outputSuccess(result?.category_groups);
+  }));
+  cmd.command("view").description("View category details").argument("<id>", "Category ID").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    const category = await client.getCategory(id, options.budget);
+    outputSuccess(category);
+  }));
+  cmd.command("budget").description("Update category budget for a month").argument("<id>", "Category ID").requiredOption("--month <month>", "Month in YYYY-MM format").requiredOption("--amount <amount>", "Budget amount in currency units (e.g., 100.50)", parseFloat).option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    if (isNaN(options.amount)) {
+      throw new YnabCliError("Amount must be a valid number", 400);
+    }
+    const milliunits = amountToMilliunits(options.amount);
+    const category = await client.updateMonthCategory(
+      options.month,
+      id,
+      { category: { budgeted: milliunits } },
+      options.budget
+    );
+    outputSuccess(category);
+  }));
+  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 (YYYY-MM-DD)").option("--type <type>", "Filter by transaction type").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(withErrorHandling(async (id, options) => {
+    const result = await client.getTransactionsByCategory(id, {
+      budgetId: options.budget,
+      sinceDate: options.since,
+      type: options.type,
+      lastKnowledgeOfServer: options.lastKnowledge
+    });
+    outputSuccess(result?.transactions);
+  }));
+  return cmd;
+}
+
+// src/commands/transactions.ts
+import { Command as Command6 } from "commander";
+
+// src/lib/schemas.ts
+import { z } from "zod";
+var TransactionSplitSchema = z.array(
+  z.object({
+    amount: z.number(),
+    category_id: z.string().nullable().optional(),
+    memo: z.string().optional(),
+    payee_id: z.string().optional()
+  })
+);
+var ApiDataSchema = z.record(z.any());
+function validateJson(data, schema, fieldName) {
+  try {
+    return schema.parse(data);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const issues = error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+      throw new YnabCliError(`Invalid ${fieldName}: ${issues}`, 400);
+    }
+    throw error;
+  }
+}
+
+// src/commands/transactions.ts
+function buildTransactionData(options) {
+  if (!options.account) {
+    throw new YnabCliError("--account is required in non-interactive mode", 400);
+  }
+  if (options.amount === void 0) {
+    throw new YnabCliError("--amount is required in non-interactive mode", 400);
+  }
+  return {
+    account_id: options.account,
+    date: options.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    amount: amountToMilliunits(options.amount),
+    payee_name: options.payeeName,
+    payee_id: options.payeeId,
+    category_id: options.categoryId,
+    memo: options.memo,
+    cleared: options.cleared,
+    approved: options.approved
+  };
+}
+function createTransactionsCommand() {
+  const cmd = new Command6("transactions").description("Transaction operations");
+  cmd.command("list").description("List transactions").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 (YYYY-MM-DD)").option("--until <date>", "Filter transactions until date (YYYY-MM-DD)").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 for multiple)").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(withErrorHandling(async (options) => {
+    const params = {
+      budgetId: options.budget,
+      sinceDate: options.since,
+      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);
+    let transactions = result?.transactions || [];
+    transactions = applyTransactionFilters(transactions, {
+      until: options.until,
+      approved: options.approved,
+      status: options.status,
+      minAmount: options.minAmount,
+      maxAmount: options.maxAmount
+    });
+    transactions = applyFieldSelection(transactions, options.fields);
+    outputSuccess(transactions);
+  }));
+  cmd.command("view").description("View single transaction").argument("<id>", "Transaction ID").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    const transaction = await client.getTransaction(id, options.budget);
+    outputSuccess(transaction);
+  }));
+  cmd.command("create").description("Create transaction").option("-b, --budget <id>", "Budget ID").option("--account <id>", "Account ID").option("--date <date>", "Date (YYYY-MM-DD)").option("--amount <amount>", "Amount in currency units (e.g., 10.50)", parseFloat).option("--payee-name <name>", "Payee name").option("--payee-id <id>", "Payee ID").option("--category-id <id>", "Category ID").option("--memo <memo>", "Memo").option("--cleared <status>", "Cleared status (cleared, uncleared, reconciled)").option("--approved", "Mark as approved").action(withErrorHandling(async (options) => {
+    const shouldPrompt = isInteractive() && !options.account && !options.amount;
+    const transactionData = shouldPrompt ? await promptForTransaction() : buildTransactionData(options);
+    const transaction = await client.createTransaction(
+      { transaction: transactionData },
+      options.budget
+    );
+    outputSuccess(transaction);
+  }));
+  cmd.command("update").description("Update transaction").argument("<id>", "Transaction ID").option("-b, --budget <id>", "Budget ID").option("--account <id>", "Account ID").option("--date <date>", "Date (YYYY-MM-DD)").option("--amount <amount>", "Amount in currency units", parseFloat).option("--payee-name <name>", "Payee name").option("--payee-id <id>", "Payee ID").option("--category-id <id>", "Category ID").option("--memo <memo>", "Memo").option("--cleared <status>", "Cleared status").option("--approved", "Mark as approved").action(withErrorHandling(async (id, options) => {
+    const transactionData = buildUpdateObject(options, {
+      account: "account_id",
+      date: "date",
+      payeeName: "payee_name",
+      payeeId: "payee_id",
+      categoryId: "category_id",
+      memo: "memo",
+      cleared: "cleared",
+      approved: "approved"
+    });
+    if (options.amount !== void 0) {
+      transactionData.amount = amountToMilliunits(options.amount);
+    }
+    const transaction = await client.updateTransaction(
+      id,
+      { transaction: transactionData },
+      options.budget
+    );
+    outputSuccess(transaction);
+  }));
+  cmd.command("delete").description("Delete transaction").argument("<id>", "Transaction ID").option("-b, --budget <id>", "Budget ID").option("-y, --yes", "Skip confirmation").action(withErrorHandling(async (id, options) => {
+    if (!await confirmDelete("transaction", options.yes)) {
+      return;
+    }
+    const transaction = await client.deleteTransaction(id, options.budget);
+    outputSuccess({ message: "Transaction deleted", transaction });
+  }));
+  cmd.command("import").description("Import transactions").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (options) => {
+    const transactionIds = await client.importTransactions(options.budget);
+    outputSuccess({ transaction_ids: transactionIds });
+  }));
+  cmd.command("split").description("Split transaction into multiple categories").argument("<id>", "Transaction ID").requiredOption("--splits <json>", 'JSON array of splits: [{"amount": -21400, "category_id": "xxx", "memo": "..."}]').option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    let parsedSplits;
+    try {
+      parsedSplits = JSON.parse(options.splits);
+    } catch (error) {
+      throw new YnabCliError("Invalid JSON in --splits parameter", 400);
+    }
+    const splits = validateJson(parsedSplits, TransactionSplitSchema, "transaction splits");
+    const transaction = await client.updateTransaction(
+      id,
+      {
+        transaction: {
+          category_id: null,
+          subtransactions: splits
+        }
+      },
+      options.budget
+    );
+    outputSuccess(transaction);
+  }));
+  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 (YYYY-MM-DD)").option("--until <date>", "Search transactions until date (YYYY-MM-DD)").option("--approved <value>", "Filter by approval status: true or false").option("--status <statuses>", "Filter by cleared status: cleared, uncleared, reconciled (comma-separated)").option("--fields <fields>", "Comma-separated list of fields to include").action(withErrorHandling(async (options) => {
+    if (!options.memo && !options.payeeName && options.amount === void 0) {
+      throw new YnabCliError("At least one search criteria required: --memo, --payee-name, or --amount", 400);
+    }
+    const params = {
+      budgetId: options.budget,
+      sinceDate: options.since
+    };
+    const result = await client.getTransactions(params);
+    let transactions = result?.transactions || [];
+    if (options.memo) {
+      const searchTerm = options.memo.toLowerCase();
+      transactions = transactions.filter(
+        (t) => t.memo?.toLowerCase().includes(searchTerm)
+      );
+    }
+    if (options.payeeName) {
+      const searchTerm = options.payeeName.toLowerCase();
+      transactions = transactions.filter(
+        (t) => t.payee_name?.toLowerCase().includes(searchTerm)
+      );
+    }
+    if (options.amount !== void 0) {
+      const amountMilliunits = amountToMilliunits(options.amount);
+      transactions = transactions.filter((t) => t.amount === amountMilliunits);
+    }
+    transactions = applyTransactionFilters(transactions, {
+      until: options.until,
+      approved: options.approved,
+      status: options.status
+    });
+    transactions = applyFieldSelection(transactions, options.fields);
+    outputSuccess(transactions);
+  }));
+  return cmd;
+}
+
+// src/commands/scheduled.ts
+import { Command as Command7 } from "commander";
+function createScheduledCommand() {
+  const cmd = new Command7("scheduled").description("Scheduled transaction operations");
+  cmd.command("list").description("List all scheduled transactions").option("-b, --budget <id>", "Budget ID").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(withErrorHandling(async (options) => {
+    const result = await client.getScheduledTransactions(options.budget, options.lastKnowledge);
+    outputSuccess(result?.scheduled_transactions);
+  }));
+  cmd.command("view").description("View scheduled transaction").argument("<id>", "Scheduled transaction ID").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    const scheduledTransaction = await client.getScheduledTransaction(id, options.budget);
+    outputSuccess(scheduledTransaction);
+  }));
+  cmd.command("delete").description("Delete scheduled transaction").argument("<id>", "Scheduled transaction ID").option("-b, --budget <id>", "Budget ID").option("-y, --yes", "Skip confirmation").action(withErrorHandling(async (id, options) => {
+    if (!await confirmDelete("scheduled transaction", options.yes)) {
+      return;
+    }
+    const scheduledTransaction = await client.deleteScheduledTransaction(id, options.budget);
+    outputSuccess({
+      message: "Scheduled transaction deleted",
+      scheduled_transaction: scheduledTransaction
+    });
+  }));
+  return cmd;
+}
+
+// src/commands/payees.ts
+import { Command as Command8 } from "commander";
+function createPayeesCommand() {
+  const cmd = new Command8("payees").description("Payee operations");
+  cmd.command("list").description("List all payees").option("-b, --budget <id>", "Budget ID").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(withErrorHandling(async (options) => {
+    const result = await client.getPayees(options.budget, options.lastKnowledge);
+    outputSuccess(result?.payees);
+  }));
+  cmd.command("view").description("View payee details").argument("<id>", "Payee ID").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    const payee = await client.getPayee(id, options.budget);
+    outputSuccess(payee);
+  }));
+  cmd.command("update").description("Rename payee").argument("<id>", "Payee ID").requiredOption("--name <name>", "New payee name").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    if (!options.name?.trim()) {
+      throw new YnabCliError("Name cannot be empty", 400);
+    }
+    const payee = await client.updatePayee(
+      id,
+      { payee: { name: options.name } },
+      options.budget
+    );
+    outputSuccess(payee);
+  }));
+  cmd.command("locations").description("List locations for payee").argument("<id>", "Payee ID").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (id, options) => {
+    const locations = await client.getPayeeLocationsByPayee(id, options.budget);
+    outputSuccess(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 (YYYY-MM-DD)").option("--type <type>", "Filter by transaction type").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(withErrorHandling(async (id, options) => {
+    const result = await client.getTransactionsByPayee(id, {
+      budgetId: options.budget,
+      sinceDate: options.since,
+      type: options.type,
+      lastKnowledgeOfServer: options.lastKnowledge
+    });
+    outputSuccess(result?.transactions);
+  }));
+  return cmd;
+}
+
+// src/commands/months.ts
+import { Command as Command9 } from "commander";
+function createMonthsCommand() {
+  const cmd = new Command9("months").description("Monthly budget operations");
+  cmd.command("list").description("List all budget months").option("-b, --budget <id>", "Budget ID").option("--last-knowledge <number>", "Last knowledge of server", parseInt).action(withErrorHandling(async (options) => {
+    const result = await client.getBudgetMonths(options.budget, options.lastKnowledge);
+    outputSuccess(result?.months);
+  }));
+  cmd.command("view").description("View specific month details").argument("<month>", "Month in YYYY-MM format").option("-b, --budget <id>", "Budget ID").action(withErrorHandling(async (month, options) => {
+    const monthData = await client.getBudgetMonth(month, options.budget);
+    outputSuccess(monthData);
+  }));
+  return cmd;
+}
+
+// src/commands/api.ts
+import { Command as Command10 } from "commander";
+var VALID_HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+function createApiCommand() {
+  const cmd = new Command10("api").description("Raw API access");
+  cmd.argument("<method>", "HTTP method (GET, POST, PUT, PATCH, DELETE)").argument("<path>", "API path (e.g., /budgets or /budgets/{budget_id}/transactions)").option("-b, --budget <id>", "Budget ID (used to replace {budget_id} in path)").option("--data <json>", "JSON data for POST/PUT/PATCH requests").description("Make raw API calls to YNAB").action(withErrorHandling(async (method, path, options) => {
+    const upperMethod = method.toUpperCase();
+    if (!VALID_HTTP_METHODS.includes(upperMethod)) {
+      throw new YnabCliError(
+        `Invalid HTTP method: ${method}. Must be one of: ${VALID_HTTP_METHODS.join(", ")}`,
+        400
+      );
+    }
+    let data;
+    if (options.data) {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(options.data);
+      } catch (error) {
+        throw new YnabCliError("Invalid JSON in --data parameter", 400);
+      }
+      data = validateJson(parsedData, ApiDataSchema, "API data");
+    }
+    const result = await client.rawApiCall(upperMethod, path, data, options.budget);
+    outputJson(result);
+  }));
+  return cmd;
+}
+
+// src/cli.ts
+var program = new Command11();
+program.name("ynab").description("A command-line interface for You Need a Budget (YNAB)").version("1.0.0").option("-c, --compact", "Minified JSON output (single line)").hook("preAction", (thisCommand) => {
+  const options = thisCommand.opts();
+  setOutputOptions({
+    compact: options.compact
+  });
+});
+program.addCommand(createAuthCommand());
+program.addCommand(createUserCommand());
+program.addCommand(createBudgetsCommand());
+program.addCommand(createAccountsCommand());
+program.addCommand(createCategoriesCommand());
+program.addCommand(createTransactionsCommand());
+program.addCommand(createScheduledCommand());
+program.addCommand(createPayeesCommand());
+program.addCommand(createMonthsCommand());
+program.addCommand(createApiCommand());
+program.parse();
+//# sourceMappingURL=cli.js.map