@fuzzle/opencode-accountant 0.10.1 → 0.10.2-next.1

package/dist/index.js

@@ -29,6 +29,24 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // node_modules/js-yaml/dist/js-yaml.mjs
+var exports_js_yaml = {};
+__export(exports_js_yaml, {
+  types: () => types,
+  safeLoadAll: () => safeLoadAll,
+  safeLoad: () => safeLoad,
+  safeDump: () => safeDump,
+  loadAll: () => loadAll,
+  load: () => load,
+  dump: () => dump,
+  default: () => jsYaml,
+  YAMLException: () => YAMLException,
+  Type: () => Type,
+  Schema: () => Schema,
+  JSON_SCHEMA: () => JSON_SCHEMA,
+  FAILSAFE_SCHEMA: () => FAILSAFE_SCHEMA,
+  DEFAULT_SCHEMA: () => DEFAULT_SCHEMA,
+  CORE_SCHEMA: () => CORE_SCHEMA
+});
 function isNothing(subject) {
   return typeof subject === "undefined" || subject === null;
 }
@@ -23060,19 +23078,12 @@ function findRulesForCsv(csvPath, mapping) {
 
 // src/utils/hledgerExecutor.ts
 var {$: $2 } = globalThis.Bun;
-var STDERR_TRUNCATE_LENGTH = 500;
 var TX_HEADER_PATTERN = /^(\d{4})-(\d{2}-\d{2})(\s+(.+))?$/;
 async function defaultHledgerExecutor(cmdArgs) {
   try {
     const result = await $2`hledger ${cmdArgs}`.quiet().nothrow();
     const stdout = result.stdout.toString();
     const stderr = result.stderr.toString();
-    if (result.exitCode !== 0 && stderr) {
-      process.stderr.write(`[hledger] command failed (exit ${result.exitCode}): hledger ${cmdArgs.join(" ")}
-`);
-      process.stderr.write(`[hledger] stderr: ${stderr.slice(0, STDERR_TRUNCATE_LENGTH)}
-`);
-    }
     return {
       stdout,
       stderr,
@@ -23080,8 +23091,6 @@ async function defaultHledgerExecutor(cmdArgs) {
     };
   } catch (error45) {
     const errorMessage = error45 instanceof Error ? error45.message : String(error45);
-    process.stderr.write(`[hledger] exception: ${errorMessage}
-`);
     return {
       stdout: "",
       stderr: errorMessage,
@@ -24092,6 +24101,7 @@ 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";
 
 // src/utils/accountDeclarations.ts
@@ -24951,24 +24961,6 @@ function adjustLotsForSplit(inventory, symbol2, ratio, logger) {
   }
   logger?.info(`Adjusted ${lots.length} lots for ${symbol2} split (ratio: ${ratio})`);
 }
-function adjustLotsForMerger(inventory, oldSymbol, newSymbol, ratio, logger) {
-  const oldLots = inventory[oldSymbol];
-  if (!oldLots || oldLots.length === 0) {
-    logger?.warn(`No lots found for ${oldSymbol} during merger adjustment`);
-    return;
-  }
-  const newLots = oldLots.map((lot) => ({
-    ...lot,
-    quantity: lot.quantity * ratio,
-    costBasis: lot.costBasis / ratio
-  }));
-  if (!inventory[newSymbol]) {
-    inventory[newSymbol] = [];
-  }
-  inventory[newSymbol].push(...newLots);
-  delete inventory[oldSymbol];
-  logger?.info(`Merger: ${oldLots.length} lots moved from ${oldSymbol} to ${newSymbol} (ratio: ${ratio})`);
-}
 function removeLots(inventory, symbol2, logger) {
   const lots = inventory[symbol2];
   if (!lots || lots.length === 0) {
@@ -25088,27 +25080,6 @@ function generateDividendEntry(dividend, logger) {
 `;
   return entry;
 }
-function generateMergerEntry(action, oldQuantity, newQuantity, logger) {
-  const date5 = formatDate(action.date);
-  const newSymbol = action.newSymbol || "UNKNOWN";
-  const description = escapeDescription(`Merger: ${action.symbol} -> ${newSymbol}`);
-  logger?.debug(`Generating Merger entry: ${oldQuantity} ${action.symbol} -> ${newQuantity} ${newSymbol}`);
-  let entry = `${date5} ${description}
-`;
-  entry += `    ; swissquote:order:${action.orderNum}
-`;
-  entry += `    ; Old ISIN: ${action.isin}, New ISIN: ${action.newIsin || "unknown"}
-`;
-  entry += `    assets:investments:stocks:${action.symbol}    -${formatQuantity(oldQuantity)} ${action.symbol}
-`;
-  entry += `    equity:conversion    ${formatQuantity(oldQuantity)} ${action.symbol}
-`;
-  entry += `    equity:conversion    -${formatQuantity(newQuantity)} ${newSymbol}
-`;
-  entry += `    assets:investments:stocks:${newSymbol}    ${formatQuantity(newQuantity)} ${newSymbol}
-`;
-  return entry;
-}
 function generateSplitEntry(action, oldQuantity, newQuantity, logger) {
   const date5 = formatDate(action.date);
   const ratio = action.ratio || newQuantity / oldQuantity;
@@ -25154,6 +25125,53 @@ function generateWorthlessEntry(action, removedLots, logger) {
 `;
   return entry;
 }
+function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, 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(" + ")}`);
+  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 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"}
+`;
+  }
+  for (const out of group.outgoing) {
+    const qty = formatQuantity(Math.abs(out.quantity));
+    entry += `    assets:investments:stocks:${out.symbol}    -${qty} ${out.symbol}
+`;
+    entry += `    equity:conversion    ${qty} ${out.symbol}
+`;
+  }
+  for (const inc of group.incoming) {
+    const qty = formatQuantity(Math.abs(inc.quantity));
+    entry += `    equity:conversion    -${qty} ${inc.symbol}
+`;
+    entry += `    assets:investments:stocks:${inc.symbol}    ${qty} ${inc.symbol}
+`;
+  }
+  return entry;
+}
+function generateRightsDistributionEntry(action, logger) {
+  const date5 = formatDate(action.date);
+  const qty = formatQuantity(Math.abs(action.quantity));
+  const description = escapeDescription(`Rights Distribution: ${action.symbol} - ${action.name}`);
+  logger?.debug(`Generating Rights Distribution entry: ${qty} ${action.symbol}`);
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
+`;
+  entry += `    assets:investments:stocks:${action.symbol}    ${qty} ${action.symbol} @ 0.00 CAD
+`;
+  entry += `    income:capital-gains:rights-distribution    0.00 CAD
+`;
+  return entry;
+}
 function formatJournalFile(entries, year, currency) {
   const header = `; Swissquote ${currency.toUpperCase()} investment transactions for ${year}
 ; Generated by opencode-accountant
@@ -25172,8 +25190,15 @@ var SIMPLE_TRANSACTION_TYPES = new Set([
   "Forex debit",
   "Interest on debits",
   "Interest on credits",
+  "Interest on deposits",
   "Exchange fees",
-  "Exchange fees rectif."
+  "Exchange fees rectif.",
+  "Payment",
+  "Debit",
+  "Fees Tax Statement",
+  "Dividend (Reversed)",
+  "Reversal (Dividend)",
+  "Redemption"
 ]);
 var TRADE_TYPES = new Set(["Buy", "Sell"]);
 var DIVIDEND_TYPES = new Set(["Dividend"]);
@@ -25181,7 +25206,10 @@ var CORPORATE_ACTION_TYPES = new Set([
   "Merger",
   "Reverse Split",
   "Worthless Liquidation",
-  "Internal exchange of securities"
+  "Internal exchange of securities",
+  "Exchange of securities",
+  "Corporate Action",
+  "Rights Distribution"
 ]);
 var SKIP_TYPES = new Set([
   "Internal exchange",
@@ -25290,45 +25318,41 @@ function toCorporateActionEntry(txn) {
     symbol: txn.symbol,
     name: txn.name,
     isin: txn.isin,
-    quantity: Math.abs(parseNumber(txn.quantity))
+    quantity: parseNumber(txn.quantity)
   };
 }
-function processCorporateActions(actions, inventory, logger) {
+var MERGER_LIKE_TYPES = new Set([
+  "Merger",
+  "Internal exchange of securities",
+  "Exchange of securities",
+  "Corporate Action"
+]);
+function processCorporateActions(actions, inventory, lotInventoryPath, projectDir, logger) {
   const entries = [];
-  const pendingMergers = new Map;
   actions.sort((a, b) => a.date.localeCompare(b.date));
+  const mergerActions = [];
+  const otherActions = [];
   for (const action of actions) {
+    if (MERGER_LIKE_TYPES.has(action.type)) {
+      mergerActions.push(action);
+    } else {
+      otherActions.push(action);
+    }
+  }
+  const mergerGroups = groupMergerActions(mergerActions);
+  for (const group of mergerGroups) {
+    const groupEntries = processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, logger);
+    entries.push(...groupEntries);
+  }
+  for (const action of otherActions) {
     switch (action.type) {
-      case "Merger":
-      case "Internal exchange of securities": {
-        const key = `${action.date}-${action.orderNum}`;
-        if (action.quantity < 0 || pendingMergers.has(key)) {
-          const pending = pendingMergers.get(key);
-          if (pending && pending.outgoing) {
-            pending.incoming = action;
-            const oldQty = Math.abs(parseNumber(String(pending.outgoing.quantity)));
-            const newQty = Math.abs(parseNumber(String(action.quantity)));
-            const ratio = newQty / oldQty;
-            adjustLotsForMerger(inventory, pending.outgoing.symbol, action.symbol, ratio, logger);
-            const entry = generateMergerEntry({
-              ...pending.outgoing,
-              newSymbol: action.symbol,
-              newIsin: action.isin,
-              ratio
-            }, oldQty, newQty, logger);
-            entries.push(entry);
-            pendingMergers.delete(key);
-          } else {
-            pendingMergers.set(key, { outgoing: action });
-          }
-        } else {
-          pendingMergers.set(key, { outgoing: action });
-        }
-        break;
-      }
       case "Reverse Split": {
+        const qty = action.quantity;
+        if (qty < 0) {
+          continue;
+        }
         const oldQty = getHeldQuantity(inventory, action.symbol);
-        const newQty = action.quantity;
+        const newQty = Math.abs(qty);
         if (oldQty > 0) {
           const ratio = newQty / oldQty;
           adjustLotsForSplit(inventory, action.symbol, ratio, logger);
@@ -25349,14 +25373,170 @@ function processCorporateActions(actions, inventory, logger) {
         }
         break;
       }
+      case "Rights Distribution": {
+        if (action.quantity > 0) {
+          const entry = generateRightsDistributionEntry(action, logger);
+          entries.push(entry);
+        }
+        break;
+      }
     }
   }
-  for (const [key, pending] of pendingMergers.entries()) {
-    logger?.warn(`Unmatched merger entry: ${key} - ${pending.outgoing.symbol}`);
+  return entries;
+}
+function groupMergerActions(actions) {
+  const groupMap = new Map;
+  for (const action of actions) {
+    const key = `${action.date}-${action.orderNum}`;
+    if (!groupMap.has(key)) {
+      groupMap.set(key, {
+        key,
+        date: action.date,
+        orderNum: action.orderNum,
+        outgoing: [],
+        incoming: []
+      });
+    }
+    const group = groupMap.get(key);
+    if (action.quantity < 0) {
+      group.outgoing.push(action);
+    } else if (action.quantity > 0) {
+      group.incoming.push(action);
+    }
   }
+  return Array.from(groupMap.values());
+}
+function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, logger) {
+  const entries = [];
+  if (group.outgoing.length === 0 && group.incoming.length === 0) {
+    return entries;
+  }
+  if (group.outgoing.length === 0 && group.incoming.length > 0) {
+    const pendingState = loadPendingMerger(projectDir, lotInventoryPath, group.key, logger);
+    if (pendingState) {
+      const totalIncomingQty2 = group.incoming.reduce((sum, a) => sum + Math.abs(a.quantity), 0);
+      for (const inc of group.incoming) {
+        const absQty = Math.abs(inc.quantity);
+        const proportion = absQty / totalIncomingQty2;
+        const allocatedCost = pendingState.totalCostBasis * proportion;
+        const costBasisPerUnit = absQty > 0 ? allocatedCost / absQty : 0;
+        const lot = {
+          date: formatDate(inc.date),
+          quantity: absQty,
+          costBasis: costBasisPerUnit,
+          currency: pendingState.currency,
+          isin: inc.isin,
+          orderNum: inc.orderNum
+        };
+        if (!inventory[inc.symbol]) {
+          inventory[inc.symbol] = [];
+        }
+        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);
+      entries.push(entry2);
+      removePendingMerger(projectDir, lotInventoryPath, group.key, logger);
+    } else {
+      logger?.warn(`Incoming-only merger group ${group.key} with no pending state \u2014 skipping`);
+    }
+    return entries;
+  }
+  let totalCostBasis = 0;
+  let outgoingCurrency = "";
+  const outgoingSymbols = [];
+  for (const out of group.outgoing) {
+    outgoingSymbols.push(out.symbol);
+    const lots = inventory[out.symbol];
+    if (lots) {
+      for (const lot of lots) {
+        totalCostBasis += lot.quantity * lot.costBasis;
+        if (!outgoingCurrency && lot.currency) {
+          outgoingCurrency = lot.currency;
+        }
+      }
+    }
+  }
+  if (group.outgoing.length > 0 && group.incoming.length === 0) {
+    for (const out of group.outgoing) {
+      removeLots(inventory, out.symbol, logger);
+    }
+    savePendingMerger(projectDir, lotInventoryPath, group.key, {
+      date: group.date,
+      orderNum: group.orderNum,
+      outgoingSymbols,
+      totalCostBasis,
+      currency: outgoingCurrency || "CAD"
+    }, logger);
+    logger?.info(`Cross-currency merger outgoing: ${outgoingSymbols.join(", ")} -> pending (cost basis: ${totalCostBasis.toFixed(2)})`);
+    return entries;
+  }
+  for (const out of group.outgoing) {
+    const absQty = Math.abs(out.quantity);
+    removeLots(inventory, out.symbol, logger);
+    logger?.debug(`Merger outgoing: removed ${absQty} ${out.symbol}`);
+  }
+  const totalIncomingQty = group.incoming.reduce((sum, a) => sum + Math.abs(a.quantity), 0);
+  for (const inc of group.incoming) {
+    const absQty = Math.abs(inc.quantity);
+    const proportion = totalIncomingQty > 0 ? absQty / totalIncomingQty : 0;
+    const allocatedCost = totalCostBasis * proportion;
+    const costBasisPerUnit = absQty > 0 ? allocatedCost / absQty : 0;
+    const lot = {
+      date: formatDate(inc.date),
+      quantity: absQty,
+      costBasis: costBasisPerUnit,
+      currency: outgoingCurrency || "CAD",
+      isin: inc.isin,
+      orderNum: inc.orderNum
+    };
+    if (!inventory[inc.symbol]) {
+      inventory[inc.symbol] = [];
+    }
+    inventory[inc.symbol].push(lot);
+    logger?.debug(`Merger incoming: added ${absQty} ${inc.symbol} @ ${costBasisPerUnit.toFixed(2)}`);
+  }
+  const entry = generateMultiWayMergerEntry(group, undefined, logger);
+  entries.push(entry);
   return entries;
 }
-async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInventoryPath = DEFAULT_LOT_INVENTORY_PATH, logger) {
+function getPendingMergerDir(projectDir, lotInventoryPath) {
+  const lotDir = lotInventoryPath.replace(/{symbol}[^/]*$/, "");
+  return path13.join(projectDir, lotDir, "pending-mergers");
+}
+function savePendingMerger(projectDir, lotInventoryPath, key, state, logger) {
+  const dir = getPendingMergerDir(projectDir, lotInventoryPath);
+  if (!fs18.existsSync(dir)) {
+    fs18.mkdirSync(dir, { recursive: true });
+  }
+  const filePath = path13.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
+  fs18.writeFileSync(filePath, JSON.stringify(state, null, 2));
+  logger?.debug(`Saved pending merger state: ${key}`);
+}
+function loadPendingMerger(projectDir, lotInventoryPath, key, logger) {
+  const dir = getPendingMergerDir(projectDir, lotInventoryPath);
+  const filePath = path13.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
+  if (!fs18.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs18.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error45) {
+    const message = error45 instanceof Error ? error45.message : String(error45);
+    logger?.warn(`Failed to load pending merger state for ${key}: ${message}`);
+    return null;
+  }
+}
+function removePendingMerger(projectDir, lotInventoryPath, key, logger) {
+  const dir = getPendingMergerDir(projectDir, lotInventoryPath);
+  const filePath = path13.join(dir, `${key.replace(/[^a-zA-Z0-9-]/g, "_")}.json`);
+  if (fs18.existsSync(filePath)) {
+    fs18.unlinkSync(filePath);
+    logger?.debug(`Removed pending merger state: ${key}`);
+  }
+}
+async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInventoryPath = DEFAULT_LOT_INVENTORY_PATH, symbolMap = {}, logger) {
   logger?.startSection(`Swissquote Preprocessing: ${path13.basename(csvPath)}`);
   const stats = {
     totalRows: 0,
@@ -25392,14 +25572,22 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     };
   }
   const transactions = [];
+  const hasSymbolMap = Object.keys(symbolMap).length > 0;
   for (let i2 = 1;i2 < lines.length; i2++) {
     const txn = parseTransaction(lines[i2]);
     if (txn) {
+      if (hasSymbolMap && txn.symbol) {
+        txn.symbol = symbolMap[txn.symbol] ?? txn.symbol;
+      }
       transactions.push(txn);
     }
   }
   stats.totalRows = transactions.length;
-  logger?.logStep("parse-csv", "success", `Parsed ${stats.totalRows} transactions`);
+  if (hasSymbolMap) {
+    logger?.logStep("parse-csv", "success", `Parsed ${stats.totalRows} transactions (symbol map applied)`);
+  } else {
+    logger?.logStep("parse-csv", "success", `Parsed ${stats.totalRows} transactions`);
+  }
   logger?.logStep("load-inventory", "start", "Loading lot inventory");
   const inventory = loadLotInventory(projectDir, lotInventoryPath, logger);
   logger?.logStep("load-inventory", "success", "Lot inventory loaded");
@@ -25424,8 +25612,17 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
         stats.dividends++;
         break;
       case "corporate":
-        corporateActions.push(toCorporateActionEntry(txn));
-        stats.corporateActions++;
+        if (!txn.symbol || txn.symbol.trim() === "") {
+          if (txn.netAmount && txn.netAmount !== "-") {
+            simpleTransactions.push(txn);
+            stats.simpleTransactions++;
+          } else {
+            stats.skipped++;
+          }
+        } else {
+          corporateActions.push(toCorporateActionEntry(txn));
+          stats.corporateActions++;
+        }
         break;
       case "skip":
         stats.skipped++;
@@ -25481,7 +25678,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
   }
   if (corporateActions.length > 0) {
     logger?.startSection("Corporate Actions Processing", 2);
-    const corpEntries = processCorporateActions(corporateActions, inventory, logger);
+    const corpEntries = processCorporateActions(corporateActions, inventory, lotInventoryPath, projectDir, logger);
     journalEntries.push(...corpEntries);
     logger?.logStep("corporate", "success", `Processed ${corporateActions.length} corporate actions`);
     logger?.endSection();
@@ -25737,14 +25934,10 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     const importCtx = loadContext(context.directory, contextId);
     if (importCtx.provider === "swissquote") {
       const csvPath = path14.join(context.directory, importCtx.filePath);
-      const filenameMatch = importCtx.filename.match(/from-(\d{2})(\d{2})(\d{4})|(\d{4})-\d{2}-\d{2}/);
+      const toDateMatch = importCtx.filename.match(/to-\d{4}(\d{4})\./);
       let year = new Date().getFullYear();
-      if (filenameMatch) {
-        if (filenameMatch[3]) {
-          year = parseInt(filenameMatch[3], 10);
-        } else if (filenameMatch[4]) {
-          year = parseInt(filenameMatch[4], 10);
-        }
+      if (toDateMatch) {
+        year = parseInt(toDateMatch[1], 10);
       }
       swissquoteContexts.push({
         contextId,
@@ -25762,6 +25955,23 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
   const config2 = context.configLoader(context.directory);
   const swissquoteProvider = config2.providers?.["swissquote"];
   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)) {
+    try {
+      const yaml = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
+      const content = fs20.readFileSync(symbolMapFullPath, "utf-8");
+      const parsed = yaml.load(content);
+      if (parsed && typeof parsed === "object") {
+        symbolMap = parsed;
+        logger?.info(`Loaded symbol map with ${Object.keys(symbolMap).length} entries`);
+      }
+    } catch (error45) {
+      const message = error45 instanceof Error ? error45.message : String(error45);
+      logger?.warn(`Failed to load symbol map from ${symbolMapPath}: ${message}`);
+    }
+  }
   try {
     let totalStats = {
       totalRows: 0,
@@ -25774,7 +25984,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)}`);
-      const result = await preprocessSwissquote(sqCtx.csvPath, context.directory, sqCtx.currency, sqCtx.year, lotInventoryPath, logger);
+      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;
       totalStats.trades += result.stats.trades;
@@ -25792,7 +26002,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
       }
       logger?.logStep("Swissquote Preprocess", "success", `Processed: ${result.stats.trades} trades, ${result.stats.dividends} dividends, ${result.stats.corporateActions} corporate actions`);
     }
-    const message = `Preprocessed ${totalStats.totalRows} rows: ` + `${totalStats.trades} trades, ${totalStats.dividends} dividends, ` + `${totalStats.corporateActions} corporate actions, ${totalStats.simpleTransactions} simple`;
+    const message = `Preprocessed ${totalStats.totalRows} rows: ${totalStats.trades} trades, ${totalStats.dividends} dividends, ${totalStats.corporateActions} corporate actions, ${totalStats.simpleTransactions} simple`;
     context.result.steps.swissquotePreprocess = buildStepResult(true, message, {
       ...totalStats,
       journalFile: lastJournalFile
@@ -26203,7 +26413,7 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as path15 from "path";
 async function initDirectories(directory) {
   try {
@@ -26211,8 +26421,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path15.join(directory, "import");
-    if (!fs20.existsSync(importBase)) {
-      fs20.mkdirSync(importBase, { recursive: true });
+    if (!fs21.existsSync(importBase)) {
+      fs21.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -26223,19 +26433,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path15.join(directory, dirPath);
-      if (!fs20.existsSync(fullPath)) {
-        fs20.mkdirSync(fullPath, { recursive: true });
+      if (!fs21.existsSync(fullPath)) {
+        fs21.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path15.join(fullPath, ".gitkeep");
-      if (!fs20.existsSync(gitkeepPath)) {
-        fs20.writeFileSync(gitkeepPath, "");
+      if (!fs21.existsSync(gitkeepPath)) {
+        fs21.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path15.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path15.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs20.existsSync(gitignorePath)) {
+    if (!fs21.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -26253,7 +26463,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs20.writeFileSync(gitignorePath, gitignoreContent);
+      fs21.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -26330,13 +26540,13 @@ 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 fs21 from "fs";
+import * as fs22 from "fs";
 function findFiatCsvPaths(directory, pendingDir, provider) {
   const providerDir = path16.join(directory, pendingDir, provider);
-  if (!fs21.existsSync(providerDir))
+  if (!fs22.existsSync(providerDir))
     return [];
   const csvPaths = [];
-  const entries = fs21.readdirSync(providerDir, { withFileTypes: true });
+  const entries = fs22.readdirSync(providerDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;

package/docs/configuration/symbol-map.md

@@ -0,0 +1,70 @@
+# Symbol Map Configuration
+
+The symbol map allows you to map Swissquote's internal symbol names to canonical ticker symbols, matching your preferred naming convention (e.g., wealthfolio-style with exchange suffixes).
+
+## Purpose
+
+Swissquote CSV exports use various symbol formats:
+- Long descriptive names for corporate actions: `GOLD ROYALTY RG`, `VIZSLA ROYAL RG`
+- Short tickers without exchange suffixes: `FNV`, `FVI`, `VCU`
+- Warrant/CVR names: `VIZSLA WT 12.25`, `KINROSS GLD CVR`
+
+The symbol map normalizes these to canonical symbols used consistently across journal entries, lot inventory filenames, and account names.
+
+## File Location
+
+Default: `config/import/symbolMap.yaml` (relative to project root)
+
+Configurable via `symbolMapPath` in `providers.yaml`:
+
+```yaml
+providers:
+  swissquote:
+    symbolMapPath: config/import/symbolMap.yaml
+```
+
+## Format
+
+Simple YAML key-value pairs where keys are Swissquote symbols and values are canonical symbols:
+
+```yaml
+# Swissquote symbol -> canonical symbol
+FNV: FNV.TO
+FVI: FVI.TO
+GOLD ROYALTY RG: GROY
+VIZSLA ROYAL RG: VROY.V
+KINROSS GLD CVR: KGC-CVR
+VIZSLA WT 12.25: VROY-WT
+VIZSLA WT. 12.2: VROY-WT
+COLOSSUS MIN: CSI.TO
+```
+
+Both keys and values are plain strings. Keys must exactly match the `Symbol` column in the Swissquote CSV.
+
+## When Needed
+
+A symbol map is required when:
+- Swissquote uses long descriptive names (common in merger/corporate action entries) that contain spaces, which break hledger commodity parsing
+- You want exchange suffixes (`.TO`, `.V`) for TSX/TSXV-listed stocks
+- Multiple Swissquote names refer to the same security (e.g., `VIZSLA WT 12.25` and `VIZSLA WT. 12.2`)
+- You want consistency with another portfolio tool (e.g., wealthfolio)
+
+## Effect
+
+The symbol map is applied **early** in preprocessing, immediately after CSV parsing and before any trade, lot, or journal processing. This means:
+
+- **Journal entries** use mapped symbols in descriptions and account names
+- **Lot inventory files** use mapped symbols in filenames (e.g., `GROY-lot.json` instead of `GOLD ROYALTY RG-lot.json`)
+- **Dividend income accounts** use mapped symbols (e.g., `income:dividends:GROY`)
+- **Capital gains tracking** uses mapped symbols throughout
+
+## Example
+
+Given a Swissquote CSV with:
+```
+15-03-2022;12345678;Merger;GOLD ROYALTY RG;GOLD ROYALTY CORP;CA38071H1064;-1000;...
+```
+
+Without symbol map: creates `GOLD ROYALTY RG-lot.json` and journal entries with `GOLD ROYALTY RG` (breaks hledger).
+
+With symbol map (`GOLD ROYALTY RG: GROY`): creates `GROY-lot.json` and journal entries with `GROY`.

package/docs/tools/import-pipeline.md

@@ -208,13 +208,33 @@ See [classify-statements](classify-statements.md) for details.
 **What happens**:
 
 1. Finds Swissquote contexts from classification
-2. Parses CSV to identify transaction types (Buy, Sell, Dividend, Merger, Reverse Split, Worthless Liquidation, etc.)
-3. For Buy transactions: adds lots to per-symbol inventory files (`ledger/investments/lot-inventory/{symbol}-lot.json`)
-4. For Sell transactions: consumes lots using FIFO, calculates capital gains/losses
-5. For Dividends: generates dividend income entries with withholding tax
-6. For Corporate Actions: adjusts lot quantities (splits), transfers lots (mergers), or removes lots (worthless liquidations)
-7. Generates investment journal entries (`ledger/investments/{year}-investments.journal`)
-8. Outputs filtered CSV (simple transactions only) for hledger rules import
+2. Loads **symbol map** from `config/import/symbolMap.yaml` (if present) and applies it to all transaction symbols before processing
+3. Parses CSV to identify transaction types and routes them accordingly
+4. For Buy transactions: adds lots to per-symbol inventory files (`ledger/investments/lot-inventory/{symbol}-lot.json`)
+5. For Sell transactions: consumes lots using FIFO, calculates capital gains/losses
+6. For Dividends: generates dividend income entries with withholding tax
+7. For Corporate Actions:
+   - **Mergers** (including multi-way): groups by date+orderNum, partitions into outgoing/incoming, transfers cost basis proportionally
+   - **Reverse Splits**: adjusts lot quantities and cost basis
+   - **Worthless Liquidations**: removes lots and records capital loss
+   - **Rights Distributions**: adds shares at zero cost basis
+   - **Cross-currency mergers**: saves outgoing side to pending state, loads when incoming side is processed
+8. Generates per-year investment journal entries (`ledger/investments/{year}-{currency}.journal`) based on the CSV filename's date range
+9. Outputs filtered CSV (simple transactions only) for hledger rules import
+
+**Symbol Map**: Maps Swissquote's internal symbol names (e.g., `GOLD ROYALTY RG`, `VIZSLA WT 12.25`) to canonical ticker symbols (e.g., `GROY`, `VROY-WT`). Applied before any processing, so journal entries, lot inventory filenames, and account names all use the mapped symbols. See [Symbol Map Configuration](../configuration/symbol-map.md).
+
+**Per-Year Journals**: Each CSV writes to a journal file named `{year}-{currency}.journal` where the year is extracted from the `to-DDMMYYYY` portion of the filename (e.g., `swissquote-cad-transactions-01012013-to-31122013.csv` → `2013-cad.journal`).
+
+**Multi-Way Mergers**: Mergers can involve multiple incoming/outgoing securities (1→N, N→1, N→M). The preprocessor groups all entries sharing the same date+orderNum, collects total cost basis from outgoing lots, and distributes it proportionally across incoming symbols.
+
+**Cross-Currency Mergers**: When the outgoing and incoming sides of a merger appear in different currency CSV files, the outgoing side saves its state to `pending-mergers/` under the lot inventory directory. When the incoming side is processed later, it loads the pending state to create lots with the correct cost basis.
+
+**Supported Transaction Types**:
+- **Simple** (passed to rules import): Custody Fees, Forex credit/debit, Interest on debits/credits/deposits, Exchange fees, Payment, Debit, Fees Tax Statement, Dividend (Reversed), Reversal (Dividend), Redemption
+- **Trades**: Buy, Sell
+- **Dividends**: Dividend
+- **Corporate Actions**: Merger, Internal exchange of securities, Exchange of securities, Corporate Action, Reverse Split, Worthless Liquidation, Rights Distribution
 
 **Why**: hledger CSV rules can't perform FIFO lot matching, capital gains calculations, or handle complex corporate actions. The preprocessor handles these computations and generates proper journal entries, while passing through simple transactions (fees, forex, interest) for standard rules-based import.
 

package/package.json

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