@fuzzle/opencode-accountant 0.15.0-next.1 → 0.15.1-next.1

package/dist/index.js

@@ -4280,7 +4280,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as crypto from "crypto";
 function clearSuggestionCache() {
   Object.keys(suggestionCache).forEach((key) => delete suggestionCache[key]);
@@ -4290,10 +4290,10 @@ function hashTransaction(posting) {
   return crypto.createHash("md5").update(data).digest("hex");
 }
 function loadExistingAccounts(yearJournalPath) {
-  if (!fs22.existsSync(yearJournalPath)) {
+  if (!fs23.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs22.readFileSync(yearJournalPath, "utf-8");
+  const content = fs23.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4309,10 +4309,10 @@ function loadExistingAccounts(yearJournalPath) {
   return accounts.sort();
 }
 function extractRulePatternsFromFile(rulesPath) {
-  if (!fs22.existsSync(rulesPath)) {
+  if (!fs23.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs22.readFileSync(rulesPath, "utf-8");
+  const content = fs23.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -4547,7 +4547,7 @@ var init_accountSuggester = __esm(() => {
 
 // src/index.ts
 init_agentLoader();
-import { dirname as dirname9, join as join17 } from "path";
+import { dirname as dirname10, join as join18 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -17370,7 +17370,7 @@ var REQUIRED_PATH_FIELDS = [
   "unrecognized",
   "rules"
 ];
-var REQUIRED_DETECTION_FIELDS = ["header", "currencyField"];
+var REQUIRED_DETECTION_FIELDS = ["header"];
 function validatePaths(paths) {
   if (typeof paths !== "object" || paths === null) {
     throw new Error("Invalid config: 'paths' must be an object");
@@ -17445,6 +17445,11 @@ function validateDetectionRule(providerName, index, rule) {
       }
     }
   }
+  const hasCurrencyField = typeof ruleObj.currencyField === "string" && ruleObj.currencyField !== "";
+  const hasCurrencyMetadata = Array.isArray(ruleObj.metadata) && ruleObj.metadata.some((m) => m.field === "currency");
+  if (!hasCurrencyField && !hasCurrencyMetadata) {
+    throw new Error(`Invalid config: provider '${providerName}' detect[${index}] must have either currencyField or a metadata entry with field: "currency"`);
+  }
   if (ruleObj.closingBalanceField !== undefined) {
     if (typeof ruleObj.closingBalanceField !== "string" || ruleObj.closingBalanceField === "") {
       throw new Error(`Invalid config: provider '${providerName}' detect[${index}].closingBalanceField must be a non-empty string`);
@@ -17646,12 +17651,18 @@ function detectProvider(filename, content, config2) {
       if (!firstRow) {
         continue;
       }
-      const rawCurrency = firstRow[rule.currencyField];
+      const headerMetadata = extractMetadata(content, skipRows, delimiter, rule.metadata);
+      const metadata = { ...filenameMetadata, ...headerMetadata };
+      let rawCurrency;
+      if (rule.currencyField) {
+        rawCurrency = firstRow[rule.currencyField];
+      }
+      if (!rawCurrency && metadata["currency"]) {
+        rawCurrency = metadata["currency"];
+      }
       if (!rawCurrency) {
         continue;
       }
-      const headerMetadata = extractMetadata(content, skipRows, delimiter, rule.metadata);
-      const metadata = { ...filenameMetadata, ...headerMetadata };
       if (rule.closingBalanceField) {
         const closingBalance = extractRowField(content, skipRows, delimiter, rule.closingBalanceField, rule.closingBalanceRow ?? "last");
         if (closingBalance) {
@@ -24266,8 +24277,8 @@ Note: This tool requires a contextId from a prior classify/import step.`,
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs23 from "fs";
-import * as path17 from "path";
+import * as fs24 from "fs";
+import * as path18 from "path";
 
 // src/utils/accountDeclarations.ts
 init_journalMatchers();
@@ -24552,6 +24563,32 @@ function formatPostings(postings) {
   }).join(`
 `);
 }
+function formatAmount(amount, currency) {
+  const formatted = Math.abs(amount).toFixed(2);
+  const sign = amount < 0 ? "-" : "";
+  return `${sign}${formatted} ${currency}`;
+}
+function escapeDescription(desc) {
+  return desc.replace(/[;|]/g, "-").trim();
+}
+function formatCommodity(symbol2) {
+  return `"${symbol2.toUpperCase()}"`;
+}
+function formatQuantity(qty) {
+  return qty.toFixed(6).replace(/\.?0+$/, "");
+}
+function formatPrice(price) {
+  const full = price.toFixed(6).replace(/0+$/, "");
+  const [integer2, decimal = ""] = full.split(".");
+  return `${integer2}.${decimal.padEnd(2, "0")}`;
+}
+function formatJournalFile(entries, header) {
+  const headerBlock = header ? `${header}
+
+` : "";
+  return headerBlock + entries.join(`
+`);
+}
 
 // src/utils/btcPurchaseGenerator.ts
 function parseRevolutFiatDatetime(dateStr) {
@@ -24772,9 +24809,9 @@ function formatJournalEntry(match2) {
   const hasFees = btcRow.fees.amount > 0;
   const netFiatAmount = hasFees ? fiatRow.amount - btcRow.fees.amount : fiatRow.amount;
   const effectivePrice = hasFees ? netFiatAmount / btcRow.quantity : btcRow.price.amount;
-  const fiatAmount = formatAmount(fiatRow.amount);
-  const netFiat = formatAmount(netFiatAmount);
-  const btcPrice = formatAmount(effectivePrice);
+  const fiatAmount = formatAmount2(fiatRow.amount);
+  const netFiat = formatAmount2(netFiatAmount);
+  const btcPrice = formatAmount2(effectivePrice);
   const pair = `${fiatCurrency.toLowerCase()}-btc`;
   const equityFiat = `equity:conversion:${pair}:${fiatCurrency.toLowerCase()}`;
   const equityBtc = `equity:conversion:${pair}:btc`;
@@ -24786,7 +24823,7 @@ function formatJournalEntry(match2) {
     }
   ];
   if (hasFees) {
-    const feeAmount = formatAmount(btcRow.fees.amount);
+    const feeAmount = formatAmount2(btcRow.fees.amount);
     const feeCurrency = btcRow.fees.currency;
     postings.push({
       account: `expenses:fees:revolut:${feeCurrency.toLowerCase()}`,
@@ -24797,7 +24834,7 @@ function formatJournalEntry(match2) {
   return `${date5} Bitcoin purchase
 ${formatPostings(postings)}`;
 }
-function formatAmount(amount) {
+function formatAmount2(amount) {
   return amount.toFixed(2);
 }
 function formatBtcQuantity(quantity) {
@@ -24812,7 +24849,7 @@ function formatDateIso(date5) {
 }
 function isDuplicate(match2, journalContent) {
   const date5 = match2.fiatRow.dateStr;
-  const amount = formatAmount(match2.fiatRow.amount);
+  const amount = formatAmount2(match2.fiatRow.amount);
   const currency = match2.fiatRow.currency;
   const pattern = `${date5} Bitcoin purchase`;
   if (!journalContent.includes(pattern))
@@ -24862,7 +24899,7 @@ function generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, l
     }
     if (isDuplicate(match2, journalContent)) {
       skippedDuplicates++;
-      logger?.debug(`Skipping duplicate: ${match2.fiatRow.dateStr} ${formatAmount(match2.fiatRow.amount)} ${match2.fiatRow.currency}`);
+      logger?.debug(`Skipping duplicate: ${match2.fiatRow.dateStr} ${formatAmount2(match2.fiatRow.amount)} ${match2.fiatRow.currency}`);
       continue;
     }
     newEntries.push(formatJournalEntry(match2));
@@ -25019,7 +25056,7 @@ function normalizeSymbol(symbol2) {
   return symbol2.toLowerCase();
 }
 
-// src/utils/swissquoteLotTracker.ts
+// src/utils/lotTracker.ts
 import * as fs17 from "fs";
 import * as path12 from "path";
 var DEFAULT_LOT_INVENTORY_PATH = "ledger/investments/lot-inventory/{symbol}-lot.json";
@@ -25196,11 +25233,6 @@ function getHeldQuantity(inventory, symbol2) {
 }
 
 // src/utils/swissquoteJournalGenerator.ts
-function formatAmount2(amount, currency) {
-  const formatted = Math.abs(amount).toFixed(2);
-  const sign = amount < 0 ? "-" : "";
-  return `${sign}${formatted} ${currency}`;
-}
 function formatDate(dateStr) {
   const match2 = dateStr.match(/^(\d{2})-(\d{2})-(\d{4})/);
   if (!match2) {
@@ -25209,20 +25241,6 @@ function formatDate(dateStr) {
   const [, day, month, year] = match2;
   return `${year}-${month}-${day}`;
 }
-function escapeDescription(desc) {
-  return desc.replace(/[;|]/g, "-").trim();
-}
-function formatCommodity(symbol2) {
-  return `"${symbol2.toUpperCase()}"`;
-}
-function formatQuantity(qty) {
-  return qty.toFixed(6).replace(/\.?0+$/, "");
-}
-function formatPrice(price) {
-  const full = price.toFixed(6).replace(/0+$/, "");
-  const [integer2, decimal = ""] = full.split(".");
-  return `${integer2}.${decimal.padEnd(2, "0")}`;
-}
 function generateBuyEntry(trade, logger) {
   const date5 = formatDate(trade.date);
   const description = escapeDescription(`Buy ${trade.symbol} - ${trade.name}`);
@@ -25241,12 +25259,12 @@ function generateBuyEntry(trade, logger) {
   if (fees > 0) {
     postings.push({
       account: "expenses:fees:trading:swissquote",
-      amount: formatAmount2(fees, trade.currency)
+      amount: formatAmount(fees, trade.currency)
     });
   }
   postings.push({
     account: `assets:broker:swissquote:${trade.currency.toLowerCase()}`,
-    amount: formatAmount2(-cashOut, trade.currency)
+    amount: formatAmount(-cashOut, trade.currency)
   });
   const computedNet = Math.round((trade.quantity * trade.unitPrice + fees) * 100);
   const brokerNet = Math.round(cashOut * 100);
@@ -25254,7 +25272,7 @@ function generateBuyEntry(trade, logger) {
   if (roundingCents !== 0) {
     postings.push({
       account: "equity:rounding",
-      amount: formatAmount2(roundingCents / 100, trade.currency)
+      amount: formatAmount(roundingCents / 100, trade.currency)
     });
     logger?.debug(`Rounding adjustment: ${roundingCents / 100} ${trade.currency}`);
   }
@@ -25288,23 +25306,23 @@ function generateSellEntry(trade, consumed, logger) {
   }
   postings.push({
     account: `assets:broker:swissquote:${trade.currency.toLowerCase()}`,
-    amount: formatAmount2(cashIn, trade.currency)
+    amount: formatAmount(cashIn, trade.currency)
   });
   if (fees > 0) {
     postings.push({
       account: "expenses:fees:trading:swissquote",
-      amount: formatAmount2(fees, trade.currency)
+      amount: formatAmount(fees, trade.currency)
     });
   }
   if (gain >= 0) {
     postings.push({
       account: "income:capital-gains:realized",
-      amount: formatAmount2(-gain, trade.currency)
+      amount: formatAmount(-gain, trade.currency)
     });
   } else {
     postings.push({
       account: "expenses:losses:capital",
-      amount: formatAmount2(-gain, trade.currency)
+      amount: formatAmount(-gain, trade.currency)
     });
   }
   const computedNet = Math.round((trade.quantity * trade.unitPrice - fees) * 100);
@@ -25313,7 +25331,7 @@ function generateSellEntry(trade, consumed, logger) {
   if (roundingCents !== 0) {
     postings.push({
       account: "equity:rounding",
-      amount: formatAmount2(roundingCents / 100, trade.currency)
+      amount: formatAmount(roundingCents / 100, trade.currency)
     });
     logger?.debug(`Rounding adjustment: ${roundingCents / 100} ${trade.currency}`);
   }
@@ -25335,18 +25353,18 @@ function generateDividendEntry(dividend, logger) {
   const postings = [
     {
       account: `assets:broker:swissquote:${dividend.currency.toLowerCase()}`,
-      amount: formatAmount2(dividend.netAmount, dividend.currency)
+      amount: formatAmount(dividend.netAmount, dividend.currency)
     }
   ];
   if (dividend.withholdingTax > 0) {
     postings.push({
       account: "expenses:taxes:withholding",
-      amount: formatAmount2(dividend.withholdingTax, dividend.currency)
+      amount: formatAmount(dividend.withholdingTax, dividend.currency)
     });
   }
   postings.push({
     account: `income:dividends:${dividend.symbol}`,
-    amount: formatAmount2(-dividend.grossAmount, dividend.currency)
+    amount: formatAmount(-dividend.grossAmount, dividend.currency)
   });
   let entry = `${date5} ${description}
 `;
@@ -25363,7 +25381,7 @@ function generateSplitEntry(action, oldQuantity, newQuantity, totalCostBasis, cu
   const description = escapeDescription(`${splitType}: ${action.symbol} (${action.name})`);
   logger?.debug(`Generating ${splitType} entry: ${oldQuantity} -> ${newQuantity} ${action.symbol}`);
   const commodity = formatCommodity(action.symbol);
-  const totalCost = formatAmount2(totalCostBasis, currency);
+  const totalCost = formatAmount(totalCostBasis, currency);
   const conversionAccount = `equity:conversion:${currency.toLowerCase()}`;
   const outgoingPostings = [
     {
@@ -25378,7 +25396,7 @@ function generateSplitEntry(action, oldQuantity, newQuantity, totalCostBasis, cu
   const incomingPostings = [
     {
       account: conversionAccount,
-      amount: formatAmount2(-totalCostBasis, currency)
+      amount: formatAmount(-totalCostBasis, currency)
     },
     {
       account: `assets:investments:stocks:${action.symbol}`,
@@ -25419,7 +25437,7 @@ function generateWorthlessEntry(action, removedLots, logger) {
       amount: `-${qty} ${commodity} @ ${price} ${currency}`
     });
   }
-  postings.push({ account: "expenses:losses:capital", amount: formatAmount2(totalCost, currency) });
+  postings.push({ account: "expenses:losses:capital", amount: formatAmount(totalCost, currency) });
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
@@ -25451,7 +25469,7 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
     const qty = formatQuantity(Math.abs(out.quantity));
     const commodity = formatCommodity(out.symbol);
     if (costInfo && costInfo.outgoingTotalCosts[i2] != null) {
-      const costAmount = formatAmount2(costInfo.outgoingTotalCosts[i2], costInfo.currency);
+      const costAmount = formatAmount(costInfo.outgoingTotalCosts[i2], costInfo.currency);
       const postings = [
         {
           account: `assets:investments:stocks:${out.symbol}`,
@@ -25488,11 +25506,11 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
     const qty = formatQuantity(Math.abs(inc.quantity));
     const commodity = formatCommodity(inc.symbol);
     if (costInfo && costInfo.incomingTotalCosts[i2] != null) {
-      const costAmount = formatAmount2(costInfo.incomingTotalCosts[i2], costInfo.currency);
+      const costAmount = formatAmount(costInfo.incomingTotalCosts[i2], costInfo.currency);
       const postings = [
         {
           account: `equity:conversion:${costInfo.currency.toLowerCase()}`,
-          amount: formatAmount2(-costInfo.incomingTotalCosts[i2], costInfo.currency)
+          amount: formatAmount(-costInfo.incomingTotalCosts[i2], costInfo.currency)
         },
         {
           account: `assets:investments:stocks:${inc.symbol}`,
@@ -25522,7 +25540,7 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
   }
   if (group.cashSettlement) {
     const cashCurrency = group.cashSettlement.currency.toLowerCase();
-    const cashAmount = formatAmount2(group.cashSettlement.amount, group.cashSettlement.currency);
+    const cashAmount = formatAmount(group.cashSettlement.amount, group.cashSettlement.currency);
     let sub = `${date5} ${description}
 `;
     sub += metadata;
@@ -25571,12 +25589,12 @@ function generateDirectWorthlessEntry(date5, orderNum, outgoingSymbols, outgoing
     const commodity = formatCommodity(symbol2);
     postings.push({
       account: `assets:investments:stocks:${symbol2}`,
-      amount: `-${formatQuantity(quantity)} ${commodity} @@ ${formatAmount2(cost, currency)}`
+      amount: `-${formatQuantity(quantity)} ${commodity} @@ ${formatAmount(cost, currency)}`
     });
   }
   postings.push({
     account: "expenses:losses:capital",
-    amount: formatAmount2(totalCostBasis, currency)
+    amount: formatAmount(totalCostBasis, currency)
   });
   let entry = `${formattedDate} ${description}
 `;
@@ -25592,14 +25610,11 @@ function generateDirectWorthlessEntry(date5, orderNum, outgoingSymbols, outgoing
 `;
   return entry;
 }
-function formatJournalFile(entries, year, currency) {
+function formatJournalFile2(entries, year, currency) {
   const header = `; Swissquote ${currency.toUpperCase()} investment transactions for ${year}
 ; Generated by opencode-accountant
-; This file is auto-generated - do not edit manually
-
-`;
-  return header + entries.join(`
-`);
+; This file is auto-generated - do not edit manually`;
+  return formatJournalFile(entries, header);
 }
 
 // src/utils/mergerFmvConfig.ts
@@ -26090,7 +26105,7 @@ function resolveRemainingPendingMergers(projectDir, lotInventoryPath, logger) {
       const parts = basename5.split("-");
       const yearStr = parts[0];
       const currency = parts.slice(1).join("-");
-      const header = formatJournalFile(journalEntries, parseInt(yearStr, 10), currency);
+      const header = formatJournalFile2(journalEntries, parseInt(yearStr, 10), currency);
       fs19.writeFileSync(journalFile, header);
     }
     journalFilesUpdated.push(journalFile);
@@ -26364,7 +26379,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
       fs19.mkdirSync(investmentsDir, { recursive: true });
     }
     journalFile = path14.join(investmentsDir, `${year}-${currency}.journal`);
-    const journalContent = formatJournalFile(journalEntries, year, currency);
+    const journalContent = formatJournalFile2(journalEntries, year, currency);
     if (fs19.existsSync(journalFile)) {
       fs19.appendFileSync(journalFile, `
 ` + journalEntries.join(`
@@ -26803,6 +26818,426 @@ function generateSwissquoteForexJournal(allForexRows, yearJournalPath, logger) {
   };
 }
 
+// src/utils/ibkrCsvPreprocessor.ts
+var import_papaparse3 = __toESM(require_papaparse(), 1);
+import * as fs22 from "fs";
+import * as path17 from "path";
+
+// src/utils/ibkrJournalGenerator.ts
+function generateIbkrBuyEntry(trade, logger) {
+  const description = escapeDescription(`Buy ${trade.symbol} - ${trade.description}`);
+  const qty = formatQuantity(trade.quantity);
+  const totalCost = Math.abs(trade.grossAmount);
+  const fees = Math.abs(trade.commission);
+  const cashOut = Math.abs(trade.netAmount);
+  logger?.debug(`Generating IBKR Buy entry: ${qty} ${trade.symbol} @@ ${totalCost} ${trade.currency}`);
+  const commodity = formatCommodity(trade.symbol);
+  const postings = [
+    {
+      account: `assets:investments:stocks:${trade.symbol}`,
+      amount: `${qty} ${commodity} @@ ${formatAmount(totalCost, trade.currency)}`
+    }
+  ];
+  if (fees > 0) {
+    postings.push({
+      account: "expenses:fees:trading:ibkr",
+      amount: formatAmount(fees, trade.currency)
+    });
+  }
+  postings.push({
+    account: `assets:broker:ibkr:${trade.currency.toLowerCase()}`,
+    amount: formatAmount(-cashOut, trade.currency)
+  });
+  let entry = `${trade.date} ${description}
+`;
+  entry += `    ; ibkr:account:${trade.account}
+`;
+  entry += formatPostings(postings) + `
+`;
+  return entry;
+}
+function generateIbkrSellEntry(trade, consumed, logger) {
+  const description = escapeDescription(`Sell ${trade.symbol} - ${trade.description}`);
+  const qty = formatQuantity(trade.quantity);
+  const fees = Math.abs(trade.commission);
+  const cashIn = trade.netAmount;
+  const totalCostBasis = consumed.reduce((sum, c) => sum + c.totalCost, 0);
+  const saleProceeds = Math.abs(trade.grossAmount);
+  const capitalGain = saleProceeds - totalCostBasis;
+  logger?.debug(`Generating IBKR Sell entry: ${qty} ${trade.symbol}, gain: ${capitalGain.toFixed(2)}`);
+  const commodity = formatCommodity(trade.symbol);
+  const lotDetails = consumed.map((c) => `${c.lot.date}: ${formatQuantity(c.quantity)}@${formatPrice(c.lot.costBasis)}`).join(", ");
+  const postings = [];
+  for (const c of consumed) {
+    const lotQty = formatQuantity(c.quantity);
+    const lotPrice = formatPrice(c.lot.costBasis);
+    postings.push({
+      account: `assets:investments:stocks:${trade.symbol}`,
+      amount: `-${lotQty} ${commodity} @ ${lotPrice} ${trade.currency}`
+    });
+  }
+  postings.push({
+    account: `assets:broker:ibkr:${trade.currency.toLowerCase()}`,
+    amount: formatAmount(cashIn, trade.currency)
+  });
+  if (fees > 0) {
+    postings.push({
+      account: "expenses:fees:trading:ibkr",
+      amount: formatAmount(fees, trade.currency)
+    });
+  }
+  if (capitalGain >= 0) {
+    postings.push({
+      account: "income:capital-gains:realized",
+      amount: formatAmount(-capitalGain, trade.currency)
+    });
+  } else {
+    postings.push({
+      account: "expenses:losses:capital",
+      amount: formatAmount(-capitalGain, trade.currency)
+    });
+  }
+  let entry = `${trade.date} ${description}
+`;
+  entry += `    ; ibkr:account:${trade.account}
+`;
+  entry += `    ; FIFO lots: ${lotDetails}
+`;
+  entry += formatPostings(postings) + `
+`;
+  return entry;
+}
+function generateIbkrDividendEntry(dividend, logger) {
+  const description = escapeDescription(`Dividend ${dividend.symbol}`);
+  logger?.debug(`Generating IBKR Dividend entry: ${dividend.symbol}, net: ${dividend.netAmount} ${dividend.currency}`);
+  const postings = [
+    {
+      account: `assets:broker:ibkr:${dividend.currency.toLowerCase()}`,
+      amount: formatAmount(dividend.netAmount, dividend.currency)
+    }
+  ];
+  if (dividend.withholdingTax > 0) {
+    postings.push({
+      account: "expenses:taxes:withholding",
+      amount: formatAmount(dividend.withholdingTax, dividend.currency)
+    });
+  }
+  postings.push({
+    account: `income:dividends:${dividend.symbol}`,
+    amount: formatAmount(-dividend.grossAmount, dividend.currency)
+  });
+  let entry = `${dividend.date} ${description}
+`;
+  entry += `    ; ibkr:account:${dividend.account}
+`;
+  entry += formatPostings(postings) + `
+`;
+  return entry;
+}
+function generateIbkrAdjustmentEntry(adjustment, logger) {
+  const description = escapeDescription(adjustment.description);
+  logger?.debug(`Generating IBKR Adjustment entry: ${adjustment.amount} ${adjustment.currency}`);
+  const postings = [
+    {
+      account: `assets:broker:ibkr:${adjustment.currency.toLowerCase()}`,
+      amount: formatAmount(adjustment.amount, adjustment.currency)
+    }
+  ];
+  if (adjustment.amount < 0) {
+    postings.push({
+      account: "expenses:fx-losses:ibkr",
+      amount: formatAmount(Math.abs(adjustment.amount), adjustment.currency)
+    });
+  } else {
+    postings.push({
+      account: "income:fx-gains:ibkr",
+      amount: formatAmount(-adjustment.amount, adjustment.currency)
+    });
+  }
+  let entry = `${adjustment.date} ${description}
+`;
+  entry += `    ; ibkr:account:${adjustment.account}
+`;
+  entry += formatPostings(postings) + `
+`;
+  return entry;
+}
+
+// src/utils/ibkrCsvPreprocessor.ts
+var TRADE_TYPES2 = new Set(["Buy", "Sell"]);
+var DIVIDEND_TYPE = "Dividend";
+var TAX_TYPE = "Foreign Tax Withholding";
+var ADJUSTMENT_TYPE = "Adjustment";
+var FOREX_TYPE = "Forex Trade Component";
+var DEPOSIT_TYPE = "Deposit";
+function parseIbkrCsv(content) {
+  const transactions = [];
+  const result = import_papaparse3.default.parse(content, {
+    header: false,
+    skipEmptyLines: true
+  });
+  for (const row of result.data) {
+    const values = Object.values(row);
+    if (values[0] !== "Transaction History" || values[1] !== "Data") {
+      continue;
+    }
+    const date5 = values[2]?.trim() || "";
+    const account = values[3]?.trim() || "";
+    const description = values[4]?.trim() || "";
+    const transactionType = values[5]?.trim() || "";
+    const symbol2 = values[6]?.trim() || "";
+    const quantity = parseFloat(values[7] || "0") || 0;
+    const price = parseFloat(values[8] || "0") || 0;
+    const priceCurrency = values[9]?.trim() || "";
+    const grossAmount = parseFloat(values[10] || "0") || 0;
+    const commission = parseFloat(values[11] || "0") || 0;
+    const netAmount = parseFloat(values[12] || "0") || 0;
+    if (!date5 || !transactionType)
+      continue;
+    transactions.push({
+      date: date5,
+      account,
+      description,
+      transactionType,
+      symbol: symbol2,
+      quantity,
+      price,
+      priceCurrency,
+      grossAmount,
+      commission,
+      netAmount
+    });
+  }
+  return transactions;
+}
+function groupDividends(transactions) {
+  const dividendMap = new Map;
+  for (const txn of transactions) {
+    if (txn.transactionType !== DIVIDEND_TYPE && txn.transactionType !== TAX_TYPE)
+      continue;
+    const key = `${txn.date}:${txn.symbol}`;
+    if (!dividendMap.has(key)) {
+      dividendMap.set(key, {});
+    }
+    const group = dividendMap.get(key);
+    if (txn.transactionType === DIVIDEND_TYPE) {
+      group.dividend = txn;
+    } else {
+      group.tax = txn;
+    }
+  }
+  const groups = [];
+  for (const [, group] of dividendMap) {
+    if (!group.dividend)
+      continue;
+    const grossAmount = Math.abs(group.dividend.netAmount);
+    const withholdingTax = group.tax ? Math.abs(group.tax.netAmount) : 0;
+    groups.push({
+      date: group.dividend.date,
+      symbol: group.dividend.symbol,
+      account: group.dividend.account,
+      grossAmount,
+      withholdingTax
+    });
+  }
+  groups.sort((a, b) => a.date.localeCompare(b.date));
+  return groups;
+}
+async function preprocessIbkr(csvPath, directory, currency, year, lotInventoryPath, logger) {
+  const csvDir = path17.dirname(csvPath);
+  const csvBasename = path17.basename(csvPath, ".csv");
+  const journalPath = path17.join(directory, "ledger", "investments", `${year}-ibkr-${currency}.journal`);
+  if (fs22.existsSync(journalPath)) {
+    logger?.info(`IBKR journal already exists: ${journalPath}, skipping preprocessing`);
+    return {
+      simpleTransactionsCsv: null,
+      journalFile: journalPath,
+      stats: {
+        totalRows: 0,
+        deposits: 0,
+        trades: 0,
+        dividends: 0,
+        adjustments: 0,
+        skippedForex: 0
+      },
+      alreadyPreprocessed: true
+    };
+  }
+  const content = fs22.readFileSync(csvPath, "utf-8");
+  const transactions = parseIbkrCsv(content);
+  logger?.info(`Parsed ${transactions.length} IBKR transactions from ${path17.basename(csvPath)}`);
+  const deposits = [];
+  const trades = [];
+  const dividendTxns = [];
+  const adjustments = [];
+  let skippedForex = 0;
+  for (const txn of transactions) {
+    if (TRADE_TYPES2.has(txn.transactionType)) {
+      trades.push(txn);
+    } else if (txn.transactionType === DIVIDEND_TYPE || txn.transactionType === TAX_TYPE) {
+      dividendTxns.push(txn);
+    } else if (txn.transactionType === ADJUSTMENT_TYPE) {
+      adjustments.push(txn);
+    } else if (txn.transactionType === DEPOSIT_TYPE) {
+      deposits.push(txn);
+    } else if (txn.transactionType === FOREX_TYPE) {
+      skippedForex++;
+    } else {
+      logger?.warn(`Unknown IBKR transaction type: ${txn.transactionType}`);
+    }
+  }
+  trades.sort((a, b) => a.date.localeCompare(b.date));
+  const inventory = loadLotInventory(directory, lotInventoryPath, logger);
+  const tradedSymbols = new Set;
+  const usedAccounts = new Set;
+  const journalEntries = [];
+  for (const trade of trades) {
+    tradedSymbols.add(trade.symbol);
+    const totalCost = Math.abs(trade.grossAmount);
+    const unitPrice = trade.quantity !== 0 ? totalCost / Math.abs(trade.quantity) : 0;
+    const tradeEntry = {
+      date: trade.date,
+      account: trade.account,
+      description: trade.description,
+      type: trade.transactionType,
+      symbol: trade.symbol,
+      quantity: Math.abs(trade.quantity),
+      grossAmount: trade.grossAmount,
+      commission: trade.commission,
+      netAmount: trade.netAmount,
+      currency: currency.toUpperCase()
+    };
+    if (trade.transactionType === "Buy") {
+      const tradeInfo = {
+        date: trade.date,
+        orderNum: "",
+        symbol: trade.symbol,
+        isin: "",
+        quantity: Math.abs(trade.quantity),
+        unitPrice,
+        currency: currency.toUpperCase()
+      };
+      addLot(inventory, tradeInfo, logger);
+      journalEntries.push(generateIbkrBuyEntry(tradeEntry, logger));
+      usedAccounts.add(`assets:investments:stocks:${trade.symbol}`);
+      usedAccounts.add(`assets:broker:ibkr:${currency}`);
+      usedAccounts.add("expenses:fees:trading:ibkr");
+    } else {
+      const consumed = consumeLotsFIFO(inventory, trade.symbol, Math.abs(trade.quantity), logger);
+      journalEntries.push(generateIbkrSellEntry(tradeEntry, consumed, logger));
+      usedAccounts.add(`assets:investments:stocks:${trade.symbol}`);
+      usedAccounts.add(`assets:broker:ibkr:${currency}`);
+      usedAccounts.add("expenses:fees:trading:ibkr");
+      usedAccounts.add("income:capital-gains:realized");
+    }
+  }
+  const dividendGroups = groupDividends(dividendTxns);
+  for (const group of dividendGroups) {
+    const netAmount = group.grossAmount - group.withholdingTax;
+    const dividendEntry = {
+      date: group.date,
+      account: group.account,
+      symbol: group.symbol,
+      grossAmount: group.grossAmount,
+      withholdingTax: group.withholdingTax,
+      netAmount,
+      currency: currency.toUpperCase()
+    };
+    journalEntries.push(generateIbkrDividendEntry(dividendEntry, logger));
+    usedAccounts.add(`assets:broker:ibkr:${currency}`);
+    usedAccounts.add(`income:dividends:${group.symbol}`);
+    if (group.withholdingTax > 0) {
+      usedAccounts.add("expenses:taxes:withholding");
+    }
+  }
+  adjustments.sort((a, b) => a.date.localeCompare(b.date));
+  for (const adj of adjustments) {
+    const adjustmentEntry = {
+      date: adj.date,
+      account: adj.account,
+      description: adj.description || "FX Translations P&L",
+      amount: adj.netAmount,
+      currency: currency.toUpperCase()
+    };
+    journalEntries.push(generateIbkrAdjustmentEntry(adjustmentEntry, logger));
+    usedAccounts.add(`assets:broker:ibkr:${currency}`);
+    if (adj.netAmount < 0) {
+      usedAccounts.add("expenses:fx-losses:ibkr");
+    } else {
+      usedAccounts.add("income:fx-gains:ibkr");
+    }
+  }
+  saveLotInventory(directory, lotInventoryPath, inventory, logger);
+  let journalFilePath = null;
+  if (journalEntries.length > 0) {
+    const yearJournalPath = ensureYearJournalExists(directory, year);
+    const header = `; IBKR ${currency.toUpperCase()} investment transactions for ${year}
+; Generated by opencode-accountant
+; This file is auto-generated - do not edit manually`;
+    const journalContent = formatJournalFile(journalEntries, header);
+    const investmentsDir = path17.join(directory, "ledger", "investments");
+    if (!fs22.existsSync(investmentsDir)) {
+      fs22.mkdirSync(investmentsDir, { recursive: true });
+    }
+    fs22.writeFileSync(journalPath, journalContent);
+    journalFilePath = journalPath;
+    const yearJournalContent = fs22.readFileSync(yearJournalPath, "utf-8");
+    const includeDirective = `include investments/${path17.basename(journalPath)}`;
+    if (!yearJournalContent.includes(includeDirective)) {
+      fs22.writeFileSync(yearJournalPath, yearJournalContent.trimEnd() + `
+` + includeDirective + `
+`);
+    }
+    if (tradedSymbols.size > 0) {
+      const commodityJournalPath = path17.join(directory, "ledger", "investments", "commodities.journal");
+      ensureCommodityDeclarations(commodityJournalPath, tradedSymbols, logger);
+    }
+    if (usedAccounts.size > 0) {
+      const accountJournalPath = path17.join(directory, "ledger", "investments", "accounts.journal");
+      ensureInvestmentAccountDeclarations(accountJournalPath, usedAccounts, logger);
+    }
+    logger?.info(`Generated IBKR journal: ${journalPath} with ${journalEntries.length} entries`);
+  }
+  let simpleTransactionsCsvPath = null;
+  if (deposits.length > 0) {
+    const filteredCsvPath = path17.join(csvDir, `${csvBasename}-filtered.csv`);
+    const csvHeader = "Date,Account,Description,Transaction Type,Symbol,Quantity,Price,Price Currency,Gross Amount,Commission,Net Amount";
+    const csvRows = deposits.map((d) => [
+      d.date,
+      d.account,
+      `"${d.description.replace(/"/g, '""')}"`,
+      d.transactionType,
+      d.symbol,
+      d.quantity || "",
+      d.price || "",
+      d.priceCurrency,
+      d.grossAmount || "",
+      d.commission || "",
+      d.netAmount
+    ].join(","));
+    fs22.writeFileSync(filteredCsvPath, csvHeader + `
+` + csvRows.join(`
+`) + `
+`);
+    simpleTransactionsCsvPath = filteredCsvPath;
+    logger?.info(`Generated filtered CSV for deposits: ${filteredCsvPath} (${deposits.length} rows)`);
+  }
+  const dividendCount = dividendGroups.length;
+  return {
+    simpleTransactionsCsv: simpleTransactionsCsvPath,
+    journalFile: journalFilePath,
+    stats: {
+      totalRows: transactions.length,
+      deposits: deposits.length,
+      trades: trades.length,
+      dividends: dividendCount,
+      adjustments: adjustments.length,
+      skippedForex
+    },
+    alreadyPreprocessed: false
+  };
+}
+
 // src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
@@ -26875,7 +27310,7 @@ function executePreprocessFiatStep(context, contextIds, logger) {
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "revolut" && importCtx.currency !== "btc") {
-      fiatCsvPaths.push(path17.join(context.directory, importCtx.filePath));
+      fiatCsvPaths.push(path18.join(context.directory, importCtx.filePath));
     }
   }
   if (fiatCsvPaths.length === 0) {
@@ -26919,7 +27354,7 @@ function executePreprocessBtcStep(context, contextIds, logger) {
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "revolut" && importCtx.currency === "btc") {
-      btcCsvPath = path17.join(context.directory, importCtx.filePath);
+      btcCsvPath = path18.join(context.directory, importCtx.filePath);
       break;
     }
   }
@@ -26953,7 +27388,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider !== "revolut")
       continue;
-    const csvPath = path17.join(context.directory, importCtx.filePath);
+    const csvPath = path18.join(context.directory, importCtx.filePath);
     if (importCtx.currency === "btc") {
       btcCsvPath = csvPath;
     } else {
@@ -26966,7 +27401,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1b: Generate BTC Purchase Entries");
   logger?.logStep("BTC Purchases", "start");
-  const btcFilename = path17.basename(btcCsvPath);
+  const btcFilename = path18.basename(btcCsvPath);
   const yearMatch = btcFilename.match(/(\d{4})-\d{2}-\d{2}/);
   const year = yearMatch ? parseInt(yearMatch[1], 10) : new Date().getFullYear();
   const yearJournalPath = ensureYearJournalExists(context.directory, year);
@@ -26993,7 +27428,7 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
       continue;
     if (importCtx.currency === "btc")
       continue;
-    const csvPath = path17.join(context.directory, importCtx.filePath);
+    const csvPath = path18.join(context.directory, importCtx.filePath);
     fiatContexts.push({ contextId, csvPath });
   }
   if (fiatContexts.length < 2) {
@@ -27002,7 +27437,7 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1e: Generate Currency Exchange Entries");
   logger?.logStep("Currency Exchanges", "start");
-  const firstFilename = path17.basename(fiatContexts[0].csvPath);
+  const firstFilename = path18.basename(fiatContexts[0].csvPath);
   const yearMatch = firstFilename.match(/(\d{4})-\d{2}-\d{2}/);
   const year = yearMatch ? parseInt(yearMatch[1], 10) : new Date().getFullYear();
   const yearJournalPath = ensureYearJournalExists(context.directory, year);
@@ -27018,9 +27453,9 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
         continue;
       const filteredCsvPath = filterExchangeRows(csvPath, indices, logger);
       updateContext(context.directory, contextId, {
-        filePath: path17.relative(context.directory, filteredCsvPath)
+        filePath: path18.relative(context.directory, filteredCsvPath)
       });
-      logger?.info(`Updated context ${contextId} to use filtered CSV: ${path17.basename(filteredCsvPath)}`);
+      logger?.info(`Updated context ${contextId} to use filtered CSV: ${path18.basename(filteredCsvPath)}`);
     }
   }
   const message = result.entriesAdded > 0 ? `Generated ${result.entriesAdded} currency exchange entries (${result.matchCount} matched, ${result.skippedDuplicates} skipped)` : `No new currency exchange entries (${result.matchCount} matched, ${result.skippedDuplicates} duplicates)`;
@@ -27037,7 +27472,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "swissquote") {
-      const csvPath = path17.join(context.directory, importCtx.filePath);
+      const csvPath = path18.join(context.directory, importCtx.filePath);
       const toDateMatch = importCtx.filename.match(/to-\d{4}(\d{4})\./);
       let year = new Date().getFullYear();
       if (toDateMatch) {
@@ -27061,11 +27496,11 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
   const lotInventoryPath = swissquoteProvider?.lotInventoryPath ?? DEFAULT_LOT_INVENTORY_PATH;
   const symbolMapPath = swissquoteProvider?.symbolMapPath ?? "config/import/symbolMap.yaml";
   let symbolMap = {};
-  const symbolMapFullPath = path17.join(context.directory, symbolMapPath);
-  if (fs23.existsSync(symbolMapFullPath)) {
+  const symbolMapFullPath = path18.join(context.directory, symbolMapPath);
+  if (fs24.existsSync(symbolMapFullPath)) {
     try {
       const yaml = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
-      const content = fs23.readFileSync(symbolMapFullPath, "utf-8");
+      const content = fs24.readFileSync(symbolMapFullPath, "utf-8");
       const parsed = yaml.load(content);
       if (parsed && typeof parsed === "object") {
         symbolMap = parsed;
@@ -27089,7 +27524,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     let lastJournalFile = null;
     const allForexRows = [];
     for (const sqCtx of swissquoteContexts) {
-      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path17.basename(sqCtx.csvPath)}`);
+      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path18.basename(sqCtx.csvPath)}`);
       const result = await preprocessSwissquote(sqCtx.csvPath, context.directory, sqCtx.currency, sqCtx.year, lotInventoryPath, symbolMap, logger);
       totalStats.totalRows += result.stats.totalRows;
       totalStats.simpleTransactions += result.stats.simpleTransactions;
@@ -27104,9 +27539,9 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
       }
       if (result.simpleTransactionsCsv) {
         updateContext(context.directory, sqCtx.contextId, {
-          filePath: path17.relative(context.directory, result.simpleTransactionsCsv)
+          filePath: path18.relative(context.directory, result.simpleTransactionsCsv)
         });
-        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path17.basename(result.simpleTransactionsCsv)}`);
+        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path18.basename(result.simpleTransactionsCsv)}`);
       }
       logger?.logStep("Swissquote Preprocess", "success", `Processed: ${result.stats.trades} trades, ${result.stats.dividends} dividends, ${result.stats.corporateActions} corporate actions, ${result.stats.forexTransactions} forex`);
     }
@@ -27116,11 +27551,11 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     }
     if (allForexRows.length > 0) {
       const firstCtx = swissquoteContexts[0];
-      const yearJournalPath = path17.join(context.directory, "ledger", `${firstCtx.year}.journal`);
+      const yearJournalPath = path18.join(context.directory, "ledger", `${firstCtx.year}.journal`);
       logger?.info(`Generating forex journal entries for ${allForexRows.length} forex rows...`);
       const forexResult = generateSwissquoteForexJournal(allForexRows, yearJournalPath, logger);
       if (forexResult.accountsUsed.size > 0) {
-        const accountJournalPath = path17.join(context.directory, "ledger", "investments", "accounts.journal");
+        const accountJournalPath = path18.join(context.directory, "ledger", "investments", "accounts.journal");
         ensureInvestmentAccountDeclarations(accountJournalPath, forexResult.accountsUsed, logger);
       }
       logger?.logStep("Swissquote Forex", "success", `Matched ${forexResult.matchCount} forex pairs, added ${forexResult.entriesAdded} entries` + (forexResult.skippedDuplicates > 0 ? `, skipped ${forexResult.skippedDuplicates} duplicates` : "") + (forexResult.unmatchedRows > 0 ? `, ${forexResult.unmatchedRows} unmatched rows` : ""));
@@ -27142,13 +27577,92 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     logger?.endSection();
   }
 }
+async function executeIbkrPreprocessStep(context, contextIds, logger) {
+  const ibkrContexts = [];
+  for (const contextId of contextIds) {
+    const importCtx = loadContext(context.directory, contextId);
+    if (importCtx.provider === "ibkr") {
+      const csvPath = path18.join(context.directory, importCtx.filePath);
+      const dateMatch = importCtx.filename.match(/(\d{4})\d{4}\./);
+      let year = new Date().getFullYear();
+      if (dateMatch) {
+        year = parseInt(dateMatch[1], 10);
+      }
+      ibkrContexts.push({
+        contextId,
+        csvPath,
+        currency: importCtx.currency,
+        year
+      });
+    }
+  }
+  if (ibkrContexts.length === 0) {
+    logger?.info("No IBKR CSV found, skipping preprocessing");
+    return;
+  }
+  logger?.startSection("Step 1f: Preprocess IBKR CSV");
+  const config2 = context.configLoader(context.directory);
+  const ibkrProvider = config2.providers?.["ibkr"];
+  const lotInventoryPath = ibkrProvider?.lotInventoryPath ?? DEFAULT_LOT_INVENTORY_PATH;
+  try {
+    let totalStats = {
+      totalRows: 0,
+      deposits: 0,
+      trades: 0,
+      dividends: 0,
+      adjustments: 0,
+      skippedForex: 0
+    };
+    let lastJournalFile = null;
+    ibkrContexts.sort((a, b) => {
+      const dateA = path18.basename(a.csvPath).match(/(\d{8})\./)?.[1] || "";
+      const dateB = path18.basename(b.csvPath).match(/(\d{8})\./)?.[1] || "";
+      return dateA.localeCompare(dateB);
+    });
+    for (const ibkrCtx of ibkrContexts) {
+      logger?.logStep("IBKR Preprocess", "start", `Processing ${path18.basename(ibkrCtx.csvPath)}`);
+      const result = await preprocessIbkr(ibkrCtx.csvPath, context.directory, ibkrCtx.currency, ibkrCtx.year, lotInventoryPath, logger);
+      totalStats.totalRows += result.stats.totalRows;
+      totalStats.deposits += result.stats.deposits;
+      totalStats.trades += result.stats.trades;
+      totalStats.dividends += result.stats.dividends;
+      totalStats.adjustments += result.stats.adjustments;
+      totalStats.skippedForex += result.stats.skippedForex;
+      if (result.journalFile) {
+        lastJournalFile = result.journalFile;
+      }
+      if (result.simpleTransactionsCsv) {
+        updateContext(context.directory, ibkrCtx.contextId, {
+          filePath: path18.relative(context.directory, result.simpleTransactionsCsv)
+        });
+        logger?.info(`Updated context ${ibkrCtx.contextId} to use filtered CSV: ${path18.basename(result.simpleTransactionsCsv)}`);
+      }
+      logger?.logStep("IBKR Preprocess", "success", `Processed: ${result.stats.trades} trades, ${result.stats.dividends} dividends, ${result.stats.adjustments} adjustments, ${result.stats.skippedForex} forex skipped`);
+    }
+    const message = `Preprocessed ${totalStats.totalRows} rows: ${totalStats.trades} trades, ${totalStats.dividends} dividends, ${totalStats.adjustments} adjustments, ${totalStats.deposits} deposits, ${totalStats.skippedForex} forex skipped`;
+    context.result.steps.ibkrPreprocess = buildStepResult(true, message, {
+      ...totalStats,
+      journalFile: lastJournalFile
+    });
+  } catch (error45) {
+    const errorMessage = `IBKR preprocessing failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    logger?.error(errorMessage);
+    logger?.logStep("IBKR Preprocess", "error", errorMessage);
+    context.result.steps.ibkrPreprocess = buildStepResult(false, errorMessage);
+    context.result.error = errorMessage;
+    context.result.hint = "Check the IBKR CSV format and lot inventory state";
+    throw new Error(errorMessage);
+  } finally {
+    logger?.endSection();
+  }
+}
 async function executeAccountDeclarationsStep(context, contextId, logger) {
   logger?.startSection("Step 2: Check Account Declarations");
   logger?.logStep("Check Accounts", "start");
   const config2 = context.configLoader(context.directory);
-  const rulesDir = path17.join(context.directory, config2.paths.rules);
+  const rulesDir = path18.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path17.join(context.directory, importCtx.filePath);
+  const csvPath = path18.join(context.directory, importCtx.filePath);
   const csvFiles = [csvPath];
   const rulesMapping = loadRulesMapping(rulesDir);
   const matchedRulesFiles = new Set;
@@ -27171,7 +27685,7 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No accounts found in rules files", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path18.relative(context.directory, f))
     });
     return;
   }
@@ -27195,7 +27709,7 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
     context.result.steps.accountDeclarations = buildStepResult(true, "No transactions found, skipping account declarations", {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path18.relative(context.directory, f))
     });
     return;
   }
@@ -27206,12 +27720,12 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
     context.result.steps.accountDeclarations = buildStepResult(false, `Failed to create year journal: ${error45 instanceof Error ? error45.message : String(error45)}`, {
       accountsAdded: [],
       journalUpdated: "",
-      rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path18.relative(context.directory, f))
     });
     return;
   }
   const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
-  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path17.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path18.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
   logger?.logStep("Check Accounts", "success", message);
   if (result.added.length > 0) {
     for (const account of result.added) {
@@ -27220,17 +27734,17 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   }
   context.result.steps.accountDeclarations = buildStepResult(true, message, {
     accountsAdded: result.added,
-    journalUpdated: path17.relative(context.directory, yearJournalPath),
-    rulesScanned: Array.from(matchedRulesFiles).map((f) => path17.relative(context.directory, f))
+    journalUpdated: path18.relative(context.directory, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path18.relative(context.directory, f))
   });
   logger?.endSection();
 }
 async function buildSuggestionContext(context, contextId, logger) {
   const { loadExistingAccounts: loadExistingAccounts2, extractRulePatternsFromFile: extractRulePatternsFromFile2 } = await Promise.resolve().then(() => (init_accountSuggester(), exports_accountSuggester));
   const config2 = context.configLoader(context.directory);
-  const rulesDir = path17.join(context.directory, config2.paths.rules);
+  const rulesDir = path18.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path17.join(context.directory, importCtx.filePath);
+  const csvPath = path18.join(context.directory, importCtx.filePath);
   const rulesMapping = loadRulesMapping(rulesDir);
   const rulesFile = findRulesForCsv(csvPath, rulesMapping);
   if (!rulesFile) {
@@ -27446,6 +27960,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     await executeBtcPurchaseStep(context, contextIds, logger);
     await executeCurrencyExchangeStep(context, contextIds, logger);
     await executeSwissquotePreprocessStep(context, contextIds, logger);
+    await executeIbkrPreprocessStep(context, contextIds, logger);
     if (context.generatedAccounts.size > 0) {
       const firstCtx = contextIds.map((id) => loadContext(context.directory, id)).find((c) => c.provider === "revolut");
       if (firstCtx) {
@@ -27459,8 +27974,8 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
       }
     }
     const importConfig = loadImportConfig(context.directory);
-    const pendingDir = path17.join(context.directory, importConfig.paths.pending);
-    const doneDir = path17.join(context.directory, importConfig.paths.done);
+    const pendingDir = path18.join(context.directory, importConfig.paths.pending);
+    const doneDir = path18.join(context.directory, importConfig.paths.done);
     const orderedContextIds = [...contextIds].sort((a, b) => {
       const ctxA = loadContext(context.directory, a);
       const ctxB = loadContext(context.directory, b);
@@ -27483,8 +27998,8 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
         totalTransactions += context.result.steps.import?.details?.summary?.totalTransactions || 0;
       } catch (error45) {
         if (error45 instanceof NoTransactionsError) {
-          const csvPath = path17.join(context.directory, importContext.filePath);
-          if (fs23.existsSync(csvPath)) {
+          const csvPath = path18.join(context.directory, importContext.filePath);
+          if (fs24.existsSync(csvPath)) {
             moveCsvToDone(csvPath, pendingDir, doneDir);
             logger.info(`No transactions to import for ${importContext.filename}, moved to done`);
           } else {
@@ -27565,16 +28080,16 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs24 from "fs";
-import * as path18 from "path";
+import * as fs25 from "fs";
+import * as path19 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path18.join(directory, "import");
-    if (!fs24.existsSync(importBase)) {
-      fs24.mkdirSync(importBase, { recursive: true });
+    const importBase = path19.join(directory, "import");
+    if (!fs25.existsSync(importBase)) {
+      fs25.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -27584,20 +28099,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path18.join(directory, dirPath);
-      if (!fs24.existsSync(fullPath)) {
-        fs24.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path19.join(directory, dirPath);
+      if (!fs25.existsSync(fullPath)) {
+        fs25.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path18.join(fullPath, ".gitkeep");
-      if (!fs24.existsSync(gitkeepPath)) {
-        fs24.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path18.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path19.join(fullPath, ".gitkeep");
+      if (!fs25.existsSync(gitkeepPath)) {
+        fs25.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path19.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path18.join(importBase, ".gitignore");
+    const gitignorePath = path19.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs24.existsSync(gitignorePath)) {
+    if (!fs25.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -27615,7 +28130,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs24.writeFileSync(gitignorePath, gitignoreContent);
+      fs25.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -27691,32 +28206,32 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/tools/generate-btc-purchases.ts
-import * as path19 from "path";
-import * as fs25 from "fs";
+import * as path20 from "path";
+import * as fs26 from "fs";
 function findFiatCsvPaths(directory, pendingDir, provider) {
-  const providerDir = path19.join(directory, pendingDir, provider);
-  if (!fs25.existsSync(providerDir))
+  const providerDir = path20.join(directory, pendingDir, provider);
+  if (!fs26.existsSync(providerDir))
     return [];
   const csvPaths = [];
-  const entries = fs25.readdirSync(providerDir, { withFileTypes: true });
+  const entries = fs26.readdirSync(providerDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "btc")
       continue;
-    const csvFiles = findCsvFiles(path19.join(providerDir, entry.name), { fullPaths: true });
+    const csvFiles = findCsvFiles(path20.join(providerDir, entry.name), { fullPaths: true });
     csvPaths.push(...csvFiles);
   }
   return csvPaths;
 }
 function findBtcCsvPath(directory, pendingDir, provider) {
-  const btcDir = path19.join(directory, pendingDir, provider, "btc");
+  const btcDir = path20.join(directory, pendingDir, provider, "btc");
   const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
   return csvFiles[0];
 }
 function determineYear(csvPaths) {
   for (const csvPath of csvPaths) {
-    const match2 = path19.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
+    const match2 = path20.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
     if (match2)
       return parseInt(match2[1], 10);
   }
@@ -27769,7 +28284,7 @@ async function generateBtcPurchases(directory, agent, options = {}, configLoader
       skippedDuplicates: result.skippedDuplicates,
       unmatchedFiat: result.unmatchedFiat.length,
       unmatchedBtc: result.unmatchedBtc.length,
-      yearJournal: path19.relative(directory, yearJournalPath)
+      yearJournal: path20.relative(directory, yearJournalPath)
     });
   } catch (err) {
     logger.error("Failed to generate BTC purchases", err);
@@ -27811,8 +28326,8 @@ to produce equity conversion entries for Bitcoin purchases.
   }
 });
 // src/index.ts
-var __dirname2 = dirname9(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join17(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname10(fileURLToPath3(import.meta.url));
+var AGENT_FILE = join18(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzzle/opencode-accountant",
-  "version": "0.15.0-next.1",
+  "version": "0.15.1-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",