@fuzzle/opencode-accountant 0.10.8 → 0.11.0-next.1

package/dist/index.js

@@ -2739,6 +2739,19 @@ var init_agentLoader = __esm(() => {
   ]);
 });
 
+// src/utils/journalMatchers.ts
+function extractAccount(line, pattern) {
+  const match = line.match(pattern);
+  return match ? match[1].trim() : null;
+}
+var JOURNAL_ACCOUNT_DECL, RULES_ACCOUNT_DIRECTIVE, RULES_ACCOUNT2_DIRECTIVE, TX_HEADER_PATTERN;
+var init_journalMatchers = __esm(() => {
+  JOURNAL_ACCOUNT_DECL = /^account\s+(.+)$/;
+  RULES_ACCOUNT_DIRECTIVE = /^account\d+\s+(.+)$/;
+  RULES_ACCOUNT2_DIRECTIVE = /^\s*account2\s+(.+)$/;
+  TX_HEADER_PATTERN = /^(\d{4})-(\d{2}-\d{2})(\s+(.+))?$/;
+});
+
 // node_modules/papaparse/papaparse.js
 var require_papaparse = __commonJS((exports, module) => {
   (function(root, factory) {
@@ -4258,19 +4271,6 @@ var require_brace_expansion = __commonJS((exports, module) => {
   }
 });
 
-// src/utils/journalMatchers.ts
-function extractAccount(line, pattern) {
-  const match2 = line.match(pattern);
-  return match2 ? match2[1].trim() : null;
-}
-var JOURNAL_ACCOUNT_DECL, RULES_ACCOUNT_DIRECTIVE, RULES_ACCOUNT2_DIRECTIVE, TX_HEADER_PATTERN;
-var init_journalMatchers = __esm(() => {
-  JOURNAL_ACCOUNT_DECL = /^account\s+(.+)$/;
-  RULES_ACCOUNT_DIRECTIVE = /^account\d+\s+(.+)$/;
-  RULES_ACCOUNT2_DIRECTIVE = /^\s*account2\s+(.+)$/;
-  TX_HEADER_PATTERN = /^(\d{4})-(\d{2}-\d{2})(\s+(.+))?$/;
-});
-
 // src/utils/accountSuggester.ts
 var exports_accountSuggester = {};
 __export(exports_accountSuggester, {
@@ -4280,7 +4280,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs19 from "fs";
+import * as fs20 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 (!fs19.existsSync(yearJournalPath)) {
+  if (!fs20.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs19.readFileSync(yearJournalPath, "utf-8");
+  const content = fs20.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4309,10 +4309,10 @@ function loadExistingAccounts(yearJournalPath) {
   return accounts.sort();
 }
 function extractRulePatternsFromFile(rulesPath) {
-  if (!fs19.existsSync(rulesPath)) {
+  if (!fs20.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs19.readFileSync(rulesPath, "utf-8");
+  const content = fs20.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 dirname7, join as join15 } from "path";
+import { dirname as dirname8, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -17012,6 +17012,7 @@ function ensureDirectory(dirPath) {
 }
 
 // src/utils/journalUtils.ts
+init_journalMatchers();
 function extractDateFromPriceLine(line) {
   return line.split(" ")[1];
 }
@@ -17097,6 +17098,37 @@ function ensureCommodityDeclarations(commodityJournalPath, symbols, logger) {
   logger?.info(`Commodity declarations: added ${missing.length} (${missing.join(", ")})`);
   return { added: missing.sort(), updated: true };
 }
+function ensureInvestmentAccountDeclarations(accountJournalPath, accounts, logger) {
+  const existing = new Set;
+  if (fs4.existsSync(accountJournalPath)) {
+    const content2 = fs4.readFileSync(accountJournalPath, "utf-8");
+    for (const line of content2.split(`
+`)) {
+      const match = line.trim().match(JOURNAL_ACCOUNT_DECL);
+      if (match) {
+        existing.add(match[1]);
+      }
+    }
+  }
+  const missing = [];
+  for (const account of accounts) {
+    if (!existing.has(account)) {
+      missing.push(account);
+      existing.add(account);
+    }
+  }
+  if (missing.length === 0) {
+    return { added: [], updated: false };
+  }
+  const sorted = Array.from(existing).sort((a, b) => a.localeCompare(b));
+  const content = sorted.map((a) => `account ${a}`).join(`
+`) + `
+`;
+  ensureDirectory(path3.dirname(accountJournalPath));
+  fs4.writeFileSync(accountJournalPath, content);
+  logger?.info(`Account declarations: added ${missing.length} (${missing.join(", ")})`);
+  return { added: missing.sort(), updated: true };
+}
 
 // src/utils/dateUtils.ts
 function formatDateISO(date5) {
@@ -24160,8 +24192,8 @@ Note: This tool requires a contextId from a prior classify/import step.`,
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs20 from "fs";
-import * as path14 from "path";
+import * as fs21 from "fs";
+import * as path15 from "path";
 
 // src/utils/accountDeclarations.ts
 init_journalMatchers();
@@ -25033,7 +25065,7 @@ function removeLots(inventory, symbol2, logger) {
     return [];
   }
   const removedLots = [...lots];
-  delete inventory[symbol2];
+  inventory[symbol2] = [];
   const totalQuantity = removedLots.reduce((sum, lot) => sum + lot.quantity, 0);
   const totalCost = removedLots.reduce((sum, lot) => sum + lot.quantity * lot.costBasis, 0);
   logger?.info(`Removed ${removedLots.length} lots for ${symbol2}: ${totalQuantity} shares, cost basis ${totalCost}`);
@@ -25202,17 +25234,18 @@ function generateWorthlessEntry(action, removedLots, logger) {
 `;
   return entry;
 }
-function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, logger) {
+function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossCurrencyOutgoingIsins, logger) {
   const date5 = formatDate(group.date);
   const outSymbols = crossCurrencyOutgoingSymbols ?? group.outgoing.map((a) => a.symbol);
   const inSymbols = group.incoming.map((a) => a.symbol);
-  const description = escapeDescription(`Merger: ${outSymbols.join(" + ")} -> ${inSymbols.join(" + ")}`);
+  const descriptionParts = outSymbols.join(" + ");
+  const description = escapeDescription(inSymbols.length > 0 ? `Merger: ${descriptionParts} -> ${inSymbols.join(" + ")}` : `Merger: ${descriptionParts}`);
   logger?.debug(`Generating multi-way merger entry: ${outSymbols.join(", ")} -> ${inSymbols.join(", ")}`);
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${group.orderNum}
 `;
-  const oldIsins = group.outgoing.map((a) => a.isin).filter(Boolean);
+  const oldIsins = (crossCurrencyOutgoingIsins ?? group.outgoing.map((a) => a.isin)).filter(Boolean);
   const newIsins = group.incoming.map((a) => a.isin).filter(Boolean);
   if (oldIsins.length > 0 || newIsins.length > 0) {
     entry += `    ; Old ISIN: ${oldIsins.join(", ") || "n/a"}, New ISINs: ${newIsins.join(", ") || "n/a"}
@@ -25514,7 +25547,7 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
         inventory[inc.symbol].push(lot);
         logger?.info(`Cross-currency merger incoming: ${absQty} ${inc.symbol} @ ${costBasisPerUnit.toFixed(2)} ${pendingState.currency}`);
       }
-      const entry2 = generateMultiWayMergerEntry(group, pendingState.outgoingSymbols, logger);
+      const entry2 = generateMultiWayMergerEntry(group, pendingState.outgoingSymbols, pendingState.outgoingIsins, logger);
       entries.push(entry2);
       removePendingMerger(projectDir, lotInventoryPath, group.key, logger);
     } else {
@@ -25545,9 +25578,12 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
       date: group.date,
       orderNum: group.orderNum,
       outgoingSymbols,
+      outgoingIsins: group.outgoing.map((a) => a.isin),
       totalCostBasis,
       currency: outgoingCurrency || "CAD"
     }, logger);
+    const entry2 = generateMultiWayMergerEntry(group, undefined, undefined, logger);
+    entries.push(entry2);
     logger?.info(`Cross-currency merger outgoing: ${outgoingSymbols.join(", ")} -> pending (cost basis: ${totalCostBasis.toFixed(2)})`);
     return entries;
   }
@@ -25576,7 +25612,7 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
     inventory[inc.symbol].push(lot);
     logger?.debug(`Merger incoming: added ${absQty} ${inc.symbol} @ ${costBasisPerUnit.toFixed(2)}`);
   }
-  const entry = generateMultiWayMergerEntry(group, undefined, logger);
+  const entry = generateMultiWayMergerEntry(group, undefined, undefined, logger);
   entries.push(entry);
   return entries;
 }
@@ -25830,6 +25866,20 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
   if (stockSymbols.size > 0) {
     const commodityJournalPath = path13.join(projectDir, "ledger", "investments", "commodities.journal");
     ensureCommodityDeclarations(commodityJournalPath, stockSymbols, logger);
+    const accountJournalPath = path13.join(projectDir, "ledger", "investments", "accounts.journal");
+    const investmentAccounts = new Set;
+    for (const symbol2 of stockSymbols) {
+      investmentAccounts.add(`assets:investments:stocks:${symbol2}`);
+      investmentAccounts.add(`income:dividends:${symbol2}`);
+    }
+    investmentAccounts.add(`assets:broker:swissquote:${currency.toLowerCase()}`);
+    investmentAccounts.add("expenses:fees:trading:swissquote");
+    investmentAccounts.add("expenses:taxes:withholding");
+    investmentAccounts.add("income:capital-gains:realized");
+    investmentAccounts.add("income:capital-gains:rights-distribution");
+    investmentAccounts.add("expenses:losses:capital");
+    investmentAccounts.add("equity:conversion");
+    ensureInvestmentAccountDeclarations(accountJournalPath, investmentAccounts, logger);
   }
   logger?.logResult({
     totalRows: stats.totalRows,
@@ -25849,6 +25899,208 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
   };
 }
 
+// src/utils/currencyExchangeGenerator.ts
+import * as fs19 from "fs";
+import * as path14 from "path";
+function parseExchangeRows(csvPath) {
+  const content = fs19.readFileSync(csvPath, "utf-8");
+  const lines = content.trim().split(`
+`);
+  if (lines.length < 2)
+    return [];
+  const rows = [];
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const fields = line.split(",");
+    if (fields.length < 9)
+      continue;
+    const [type2, , startedDate, , description, amountStr, , currency] = fields;
+    if (type2 !== "EXCHANGE")
+      continue;
+    if (!description?.startsWith("Exchanged to"))
+      continue;
+    const rawAmount = parseFloat(amountStr);
+    const date5 = parseRevolutDatetime(startedDate);
+    const dateIso = formatDateIso2(date5);
+    rows.push({
+      date: date5,
+      dateStr: dateIso,
+      description,
+      amount: rawAmount,
+      currency,
+      lineIndex: i2,
+      csvPath
+    });
+  }
+  return rows;
+}
+function matchExchangePairs(rowsByCsv) {
+  const allRows = [];
+  for (const rows of rowsByCsv.values()) {
+    allRows.push(...rows);
+  }
+  const sources = allRows.filter((r) => r.amount > 0);
+  const targets = allRows.filter((r) => r.amount < 0);
+  const matches = [];
+  const matchedSourceIndices = new Set;
+  const matchedTargetIndices = new Set;
+  for (let si = 0;si < sources.length; si++) {
+    const source = sources[si];
+    for (let ti = 0;ti < targets.length; ti++) {
+      if (matchedTargetIndices.has(ti))
+        continue;
+      const target = targets[ti];
+      if (source.currency === target.currency)
+        continue;
+      if (!datesMatchToSecond2(source.date, target.date))
+        continue;
+      const targetCurrency = target.currency;
+      if (!source.description.includes(targetCurrency))
+        continue;
+      matches.push({
+        source,
+        target: { ...target, amount: Math.abs(target.amount) }
+      });
+      matchedSourceIndices.add(si);
+      matchedTargetIndices.add(ti);
+      break;
+    }
+  }
+  return matches;
+}
+function datesMatchToSecond2(a, b) {
+  return Math.abs(a.getTime() - b.getTime()) < 1000;
+}
+function formatExchangeEntry(match2) {
+  const { source, target } = match2;
+  const date5 = source.dateStr;
+  const description = source.description;
+  const sourceCurrency = source.currency;
+  const targetCurrency = target.currency;
+  const sourceAmount = formatAmount3(source.amount);
+  const targetAmount = formatAmount3(target.amount);
+  const rate = target.amount / source.amount;
+  const rateStr = formatRate(rate);
+  return [
+    `${date5} ${description}`,
+    `    assets:bank:revolut:${sourceCurrency.toLowerCase()}    -${sourceAmount} ${sourceCurrency} @ ${rateStr} ${targetCurrency}`,
+    `    equity:currency:conversion   ${sourceAmount} ${sourceCurrency}`,
+    `    equity:currency:conversion  -${targetAmount} ${targetCurrency}`,
+    `    assets:bank:revolut:${targetCurrency.toLowerCase()}     ${targetAmount} ${targetCurrency}`
+  ].join(`
+`);
+}
+function formatAmount3(amount) {
+  return amount.toFixed(2);
+}
+function formatRate(rate) {
+  return rate.toFixed(4);
+}
+function isDuplicate2(match2, journalContent) {
+  const date5 = match2.source.dateStr;
+  const description = match2.source.description;
+  const pattern = `${date5} ${description}`;
+  if (!journalContent.includes(pattern))
+    return false;
+  const sourceAmount = formatAmount3(match2.source.amount);
+  const sourceCurrency = match2.source.currency;
+  const amountPattern = `-${sourceAmount} ${sourceCurrency}`;
+  const idx = journalContent.indexOf(pattern);
+  const chunk = journalContent.slice(idx, idx + 500);
+  return chunk.includes(amountPattern);
+}
+function parseRevolutDatetime(dateStr) {
+  const [datePart, timePart] = dateStr.split(" ");
+  if (!datePart || !timePart) {
+    throw new Error(`Invalid datetime: ${dateStr}`);
+  }
+  return new Date(`${datePart}T${timePart}`);
+}
+function formatDateIso2(date5) {
+  const y = date5.getFullYear();
+  const m = String(date5.getMonth() + 1).padStart(2, "0");
+  const d = String(date5.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function filterExchangeRows(csvPath, rowIndicesToRemove, logger) {
+  const content = fs19.readFileSync(csvPath, "utf-8");
+  const lines = content.trim().split(`
+`);
+  const filteredLines = [lines[0]];
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    if (rowIndicesToRemove.has(i2))
+      continue;
+    filteredLines.push(lines[i2]);
+  }
+  const dir = path14.dirname(csvPath);
+  const basename6 = path14.basename(csvPath, ".csv");
+  const filteredPath = path14.join(dir, `${basename6}-filtered.csv`);
+  fs19.writeFileSync(filteredPath, filteredLines.join(`
+`) + `
+`);
+  logger?.info(`Filtered ${rowIndicesToRemove.size} exchange rows from ${path14.basename(csvPath)} \u2192 ${path14.basename(filteredPath)}`);
+  return filteredPath;
+}
+function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger) {
+  logger?.info("Parsing fiat CSVs for EXCHANGE rows...");
+  const rowsByCsv = new Map;
+  for (const csvPath of fiatCsvPaths) {
+    const rows = parseExchangeRows(csvPath);
+    if (rows.length > 0) {
+      rowsByCsv.set(csvPath, rows);
+      logger?.info(`Found ${rows.length} EXCHANGE rows in ${path14.basename(csvPath)}`);
+    }
+  }
+  if (rowsByCsv.size < 2) {
+    logger?.info("Need at least 2 CSVs with EXCHANGE rows to match pairs, skipping");
+    return { matchCount: 0, entriesAdded: 0, skippedDuplicates: 0, matchedRowIndices: new Map };
+  }
+  logger?.info("Matching exchange pairs across CSVs...");
+  const matches = matchExchangePairs(rowsByCsv);
+  logger?.info(`Matched ${matches.length} exchange pairs`);
+  let journalContent = "";
+  if (fs19.existsSync(yearJournalPath)) {
+    journalContent = fs19.readFileSync(yearJournalPath, "utf-8");
+  }
+  const newEntries = [];
+  let skippedDuplicates = 0;
+  const sortedMatches = [...matches].sort((a, b) => a.source.date.getTime() - b.source.date.getTime());
+  for (const match2 of sortedMatches) {
+    if (isDuplicate2(match2, journalContent)) {
+      skippedDuplicates++;
+      logger?.debug(`Skipping duplicate: ${match2.source.dateStr} ${formatAmount3(match2.source.amount)} ${match2.source.currency} \u2192 ${formatAmount3(match2.target.amount)} ${match2.target.currency}`);
+      continue;
+    }
+    newEntries.push(formatExchangeEntry(match2));
+  }
+  if (newEntries.length > 0) {
+    const appendContent = `
+` + newEntries.join(`
+
+`) + `
+`;
+    fs19.appendFileSync(yearJournalPath, appendContent);
+    logger?.info(`Appended ${newEntries.length} currency exchange entries to ${path14.basename(yearJournalPath)}`);
+  } else {
+    logger?.info("No new currency exchange entries to add");
+  }
+  const matchedRowIndices = new Map;
+  for (const match2 of matches) {
+    for (const row of [match2.source, match2.target]) {
+      if (!matchedRowIndices.has(row.csvPath)) {
+        matchedRowIndices.set(row.csvPath, new Set);
+      }
+      matchedRowIndices.get(row.csvPath).add(row.lineIndex);
+    }
+  }
+  return {
+    matchCount: matches.length,
+    entriesAdded: newEntries.length,
+    skippedDuplicates,
+    matchedRowIndices
+  };
+}
+
 // src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
@@ -25921,7 +26173,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(path14.join(context.directory, importCtx.filePath));
+      fiatCsvPaths.push(path15.join(context.directory, importCtx.filePath));
     }
   }
   if (fiatCsvPaths.length === 0) {
@@ -25965,7 +26217,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 = path14.join(context.directory, importCtx.filePath);
+      btcCsvPath = path15.join(context.directory, importCtx.filePath);
       break;
     }
   }
@@ -25999,7 +26251,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider !== "revolut")
       continue;
-    const csvPath = path14.join(context.directory, importCtx.filePath);
+    const csvPath = path15.join(context.directory, importCtx.filePath);
     if (importCtx.currency === "btc") {
       btcCsvPath = csvPath;
     } else {
@@ -26012,7 +26264,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1b: Generate BTC Purchase Entries");
   logger?.logStep("BTC Purchases", "start");
-  const btcFilename = path14.basename(btcCsvPath);
+  const btcFilename = path15.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);
@@ -26028,12 +26280,56 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
     unmatchedBtc: result.unmatchedBtc.length
   });
 }
+async function executeCurrencyExchangeStep(context, contextIds, logger) {
+  const fiatContexts = [];
+  for (const contextId of contextIds) {
+    const importCtx = loadContext(context.directory, contextId);
+    if (importCtx.provider !== "revolut")
+      continue;
+    if (importCtx.currency === "btc")
+      continue;
+    const csvPath = path15.join(context.directory, importCtx.filePath);
+    fiatContexts.push({ contextId, csvPath });
+  }
+  if (fiatContexts.length < 2) {
+    logger?.info("Need at least 2 Revolut fiat CSVs for exchange matching, skipping");
+    return;
+  }
+  logger?.startSection("Step 1e: Generate Currency Exchange Entries");
+  logger?.logStep("Currency Exchanges", "start");
+  const firstFilename = path15.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);
+  const fiatCsvPaths = fiatContexts.map((c) => c.csvPath);
+  const result = generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger);
+  if (result.matchedRowIndices.size > 0) {
+    for (const { contextId, csvPath } of fiatContexts) {
+      const indices = result.matchedRowIndices.get(csvPath);
+      if (!indices || indices.size === 0)
+        continue;
+      const filteredCsvPath = filterExchangeRows(csvPath, indices, logger);
+      updateContext(context.directory, contextId, {
+        filePath: path15.relative(context.directory, filteredCsvPath)
+      });
+      logger?.info(`Updated context ${contextId} to use filtered CSV: ${path15.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)`;
+  logger?.logStep("Currency Exchanges", "success", message);
+  logger?.endSection();
+  context.result.steps.currencyExchanges = buildStepResult(true, message, {
+    matchCount: result.matchCount,
+    entriesAdded: result.entriesAdded,
+    skippedDuplicates: result.skippedDuplicates
+  });
+}
 async function executeSwissquotePreprocessStep(context, contextIds, logger) {
   const swissquoteContexts = [];
   for (const contextId of contextIds) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "swissquote") {
-      const csvPath = path14.join(context.directory, importCtx.filePath);
+      const csvPath = path15.join(context.directory, importCtx.filePath);
       const toDateMatch = importCtx.filename.match(/to-\d{4}(\d{4})\./);
       let year = new Date().getFullYear();
       if (toDateMatch) {
@@ -26057,11 +26353,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 = path14.join(context.directory, symbolMapPath);
-  if (fs20.existsSync(symbolMapFullPath)) {
+  const symbolMapFullPath = path15.join(context.directory, symbolMapPath);
+  if (fs21.existsSync(symbolMapFullPath)) {
     try {
       const yaml = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
-      const content = fs20.readFileSync(symbolMapFullPath, "utf-8");
+      const content = fs21.readFileSync(symbolMapFullPath, "utf-8");
       const parsed = yaml.load(content);
       if (parsed && typeof parsed === "object") {
         symbolMap = parsed;
@@ -26083,7 +26379,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     };
     let lastJournalFile = null;
     for (const sqCtx of swissquoteContexts) {
-      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path14.basename(sqCtx.csvPath)}`);
+      logger?.logStep("Swissquote Preprocess", "start", `Processing ${path15.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;
@@ -26096,9 +26392,9 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
       }
       if (result.simpleTransactionsCsv) {
         updateContext(context.directory, sqCtx.contextId, {
-          filePath: path14.relative(context.directory, result.simpleTransactionsCsv)
+          filePath: path15.relative(context.directory, result.simpleTransactionsCsv)
         });
-        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path14.basename(result.simpleTransactionsCsv)}`);
+        logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path15.basename(result.simpleTransactionsCsv)}`);
       }
       logger?.logStep("Swissquote Preprocess", "success", `Processed: ${result.stats.trades} trades, ${result.stats.dividends} dividends, ${result.stats.corporateActions} corporate actions`);
     }
@@ -26123,9 +26419,9 @@ 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 = path14.join(context.directory, config2.paths.rules);
+  const rulesDir = path15.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path14.join(context.directory, importCtx.filePath);
+  const csvPath = path15.join(context.directory, importCtx.filePath);
   const csvFiles = [csvPath];
   const rulesMapping = loadRulesMapping(rulesDir);
   const matchedRulesFiles = new Set;
@@ -26148,7 +26444,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) => path14.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path15.relative(context.directory, f))
     });
     return;
   }
@@ -26172,7 +26468,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) => path14.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path15.relative(context.directory, f))
     });
     return;
   }
@@ -26183,12 +26479,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) => path14.relative(context.directory, f))
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path15.relative(context.directory, f))
     });
     return;
   }
   const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
-  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path14.relative(context.directory, yearJournalPath)}` : "All required accounts already declared";
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path15.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) {
@@ -26197,17 +26493,17 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   }
   context.result.steps.accountDeclarations = buildStepResult(true, message, {
     accountsAdded: result.added,
-    journalUpdated: path14.relative(context.directory, yearJournalPath),
-    rulesScanned: Array.from(matchedRulesFiles).map((f) => path14.relative(context.directory, f))
+    journalUpdated: path15.relative(context.directory, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path15.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 = path14.join(context.directory, config2.paths.rules);
+  const rulesDir = path15.join(context.directory, config2.paths.rules);
   const importCtx = loadContext(context.directory, contextId);
-  const csvPath = path14.join(context.directory, importCtx.filePath);
+  const csvPath = path15.join(context.directory, importCtx.filePath);
   const rulesMapping = loadRulesMapping(rulesDir);
   const rulesFile = findRulesForCsv(csvPath, rulesMapping);
   if (!rulesFile) {
@@ -26414,6 +26710,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     executePreprocessFiatStep(context, contextIds, logger);
     executePreprocessBtcStep(context, contextIds, logger);
     await executeBtcPurchaseStep(context, contextIds, logger);
+    await executeCurrencyExchangeStep(context, contextIds, logger);
     await executeSwissquotePreprocessStep(context, contextIds, logger);
     const importConfig = loadImportConfig(context.directory);
     const orderedContextIds = [...contextIds].sort((a, b) => {
@@ -26513,16 +26810,16 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs21 from "fs";
-import * as path15 from "path";
+import * as fs22 from "fs";
+import * as path16 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path15.join(directory, "import");
-    if (!fs21.existsSync(importBase)) {
-      fs21.mkdirSync(importBase, { recursive: true });
+    const importBase = path16.join(directory, "import");
+    if (!fs22.existsSync(importBase)) {
+      fs22.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -26532,20 +26829,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path15.join(directory, dirPath);
-      if (!fs21.existsSync(fullPath)) {
-        fs21.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path16.join(directory, dirPath);
+      if (!fs22.existsSync(fullPath)) {
+        fs22.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path15.join(fullPath, ".gitkeep");
-      if (!fs21.existsSync(gitkeepPath)) {
-        fs21.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path15.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path16.join(fullPath, ".gitkeep");
+      if (!fs22.existsSync(gitkeepPath)) {
+        fs22.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path16.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path15.join(importBase, ".gitignore");
+    const gitignorePath = path16.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs21.existsSync(gitignorePath)) {
+    if (!fs22.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -26563,7 +26860,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs21.writeFileSync(gitignorePath, gitignoreContent);
+      fs22.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -26639,32 +26936,32 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
   }
 });
 // src/tools/generate-btc-purchases.ts
-import * as path16 from "path";
-import * as fs22 from "fs";
+import * as path17 from "path";
+import * as fs23 from "fs";
 function findFiatCsvPaths(directory, pendingDir, provider) {
-  const providerDir = path16.join(directory, pendingDir, provider);
-  if (!fs22.existsSync(providerDir))
+  const providerDir = path17.join(directory, pendingDir, provider);
+  if (!fs23.existsSync(providerDir))
     return [];
   const csvPaths = [];
-  const entries = fs22.readdirSync(providerDir, { withFileTypes: true });
+  const entries = fs23.readdirSync(providerDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "btc")
       continue;
-    const csvFiles = findCsvFiles(path16.join(providerDir, entry.name), { fullPaths: true });
+    const csvFiles = findCsvFiles(path17.join(providerDir, entry.name), { fullPaths: true });
     csvPaths.push(...csvFiles);
   }
   return csvPaths;
 }
 function findBtcCsvPath(directory, pendingDir, provider) {
-  const btcDir = path16.join(directory, pendingDir, provider, "btc");
+  const btcDir = path17.join(directory, pendingDir, provider, "btc");
   const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
   return csvFiles[0];
 }
 function determineYear(csvPaths) {
   for (const csvPath of csvPaths) {
-    const match2 = path16.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
+    const match2 = path17.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
     if (match2)
       return parseInt(match2[1], 10);
   }
@@ -26717,7 +27014,7 @@ async function generateBtcPurchases(directory, agent, options = {}, configLoader
       skippedDuplicates: result.skippedDuplicates,
       unmatchedFiat: result.unmatchedFiat.length,
       unmatchedBtc: result.unmatchedBtc.length,
-      yearJournal: path16.relative(directory, yearJournalPath)
+      yearJournal: path17.relative(directory, yearJournalPath)
     });
   } catch (err) {
     logger.error("Failed to generate BTC purchases", err);
@@ -26759,8 +27056,8 @@ to produce equity conversion entries for Bitcoin purchases.
   }
 });
 // src/index.ts
-var __dirname2 = dirname7(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join15(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname8(fileURLToPath3(import.meta.url));
+var AGENT_FILE = join16(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {

package/docs/tools/import-pipeline.md

@@ -12,12 +12,13 @@ The pipeline automates these sequential steps:
    1a. **Preprocess Fiat CSV** _(Revolut only)_ - Add computed `Net_Amount` column (`Amount - Fee`) for hledger rules
    1b. **Preprocess BTC CSV** _(Revolut only)_ - Add computed columns (fees in BTC, total, clean price) for hledger rules
    1c. **Generate BTC Purchases** _(Revolut only)_ - Cross-reference fiat + BTC CSVs for equity conversion entries
+   1e. **Generate Currency Exchanges** _(Revolut only)_ - Cross-reference fiat CSVs for unified multi-currency exchange entries
    1d. **Preprocess Swissquote CSV** _(Swissquote only)_ - Generate FIFO capital gains entries for trades, dividends, and corporate actions
 2. **Account Declarations** - Ensure all accounts exist in year journals
 3. **Import** - Validate transactions, add to journals, move files to done
 4. **Reconcile** - Verify balances match expectations
 
-Steps 1a–1c are Revolut-specific and steps 1d is Swissquote-specific. These preprocessing steps are automatically skipped when no matching CSVs are present.
+Steps 1a–1c and 1e are Revolut-specific and step 1d is Swissquote-specific. These preprocessing steps are automatically skipped when no matching CSVs are present.
 
 **Key behavior**: The pipeline processes files via **import contexts**. Each classified CSV gets a unique context ID, and subsequent steps operate on these contexts **sequentially** with **fail-fast** error handling.
 
@@ -201,6 +202,34 @@ See [classify-statements](classify-statements.md) for details.
 
 **Skipped when**: No fiat+BTC CSV pair is found among the classified files.
 
+### Step 1e: Generate Currency Exchange Entries
+
+**Purpose**: Cross-reference Revolut fiat CSVs to generate unified 4-posting journal entries for currency exchanges (e.g., CHF to EUR)
+
+**What happens**:
+
+1. Finds all Revolut fiat contexts (provider=revolut, currency≠btc) from classification
+2. Parses each CSV for `EXCHANGE` rows with "Exchanged to" descriptions
+3. Matches source (debited) and target (credited) rows across CSVs by timestamp (within 1 second)
+4. Generates unified 4-posting journal entries using `equity:currency:conversion` with `@ cost` notation
+5. Appends entries to year journal, skipping duplicates
+6. Filters matched EXCHANGE rows from CSVs (writes `-filtered.csv`) so hledger import doesn't double-count them
+7. Updates import contexts to point to filtered CSVs
+
+**Journal entry format**:
+
+```journal
+2026-01-15 Exchanged to EUR
+    assets:bank:revolut:chf    -100.00 CHF @ 1.0713 EUR
+    equity:currency:conversion   100.00 CHF
+    equity:currency:conversion  -107.13 EUR
+    assets:bank:revolut:eur     107.13 EUR
+```
+
+**Why**: Revolut exports currency exchanges as two separate CSV rows — one per currency. Processing each through its own rules file produces two independent 2-posting transactions with a non-zero `equity:conversion` balance. This step intercepts EXCHANGE rows before hledger import, matches them across currencies, and generates a single unified transaction with explicit cost notation that keeps `equity:currency:conversion` balanced.
+
+**Skipped when**: Fewer than 2 Revolut fiat CSVs with EXCHANGE rows are present among the classified files.
+
 ### Step 1d: Preprocess Swissquote CSV
 
 **Purpose**: Generate FIFO capital gains journal entries for Swissquote investment transactions including trades, dividends, and corporate actions
@@ -356,6 +385,14 @@ See [reconcile-statement](reconcile-statement.md) for details.
                             │
                             ▼
 ┌──────────────────────────────────────────────────────────────┐
+│  STEP 1e: Generate Currency Exchange Entries                 │
+│  • Cross-reference fiat CSVs for EXCHANGE rows               │
+│  • Generate unified 4-posting entries with @ cost            │
+│  • Filter matched rows from CSVs                             │
+└──────────────────────────────────────────────────────────────┘
+                            │
+                            ▼
+┌──────────────────────────────────────────────────────────────┐
 │  STEP 1d: Preprocess Swissquote CSV (if swissquote context)  │
 │  • FIFO lot tracking for trades                              │
 │  • Capital gains calculation                                 │

package/package.json

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