@fuzzle/opencode-accountant 0.13.14 → 0.13.15-next.1

package/dist/index.js

@@ -25298,23 +25298,30 @@ function generateDividendEntry(dividend, logger) {
 `;
   return entry;
 }
-function generateSplitEntry(action, oldQuantity, newQuantity, logger) {
+function generateSplitEntry(action, oldQuantity, newQuantity, totalCostBasis, currency, logger) {
   const date5 = formatDate(action.date);
   const ratio = action.ratio || newQuantity / oldQuantity;
   const splitType = ratio > 1 ? "Split" : "Reverse Split";
   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 postings = [
     {
       account: `assets:investments:stocks:${action.symbol}`,
-      amount: `-${formatQuantity(oldQuantity)} ${commodity}`
+      amount: `-${formatQuantity(oldQuantity)} ${commodity} @@ ${totalCost}`
+    },
+    {
+      account: "equity:conversion",
+      amount: `${formatQuantity(oldQuantity)} ${commodity} @@ ${totalCost}`
+    },
+    {
+      account: "equity:conversion",
+      amount: `-${formatQuantity(newQuantity)} ${commodity} @@ ${totalCost}`
     },
-    { account: "equity:conversion", amount: `${formatQuantity(oldQuantity)} ${commodity}` },
-    { account: "equity:conversion", amount: `-${formatQuantity(newQuantity)} ${commodity}` },
     {
       account: `assets:investments:stocks:${action.symbol}`,
-      amount: `${formatQuantity(newQuantity)} ${commodity}`
+      amount: `${formatQuantity(newQuantity)} ${commodity} @@ ${totalCost}`
     }
   ];
   let entry = `${date5} ${description}
@@ -25355,7 +25362,7 @@ function generateWorthlessEntry(action, removedLots, logger) {
 `;
   return entry;
 }
-function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossCurrencyOutgoingIsins, logger) {
+function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossCurrencyOutgoingIsins, costInfo, logger) {
   const date5 = formatDate(group.date);
   const outSymbols = crossCurrencyOutgoingSymbols ?? group.outgoing.map((a) => a.symbol);
   const inSymbols = group.incoming.map((a) => a.symbol);
@@ -25365,22 +25372,29 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
   const oldIsins = (crossCurrencyOutgoingIsins ?? group.outgoing.map((a) => a.isin)).filter(Boolean);
   const newIsins = group.incoming.map((a) => a.isin).filter(Boolean);
   const postings = [];
-  for (const out of group.outgoing) {
+  for (let i2 = 0;i2 < group.outgoing.length; i2++) {
+    const out = group.outgoing[i2];
     const qty = formatQuantity(Math.abs(out.quantity));
     const commodity = formatCommodity(out.symbol);
+    const costAnnotation = costInfo && costInfo.outgoingTotalCosts[i2] != null ? ` @@ ${formatAmount2(costInfo.outgoingTotalCosts[i2], costInfo.currency)}` : "";
     postings.push({
       account: `assets:investments:stocks:${out.symbol}`,
-      amount: `-${qty} ${commodity}`
+      amount: `-${qty} ${commodity}${costAnnotation}`
     });
-    postings.push({ account: "equity:conversion", amount: `${qty} ${commodity}` });
+    postings.push({ account: "equity:conversion", amount: `${qty} ${commodity}${costAnnotation}` });
   }
-  for (const inc of group.incoming) {
+  for (let i2 = 0;i2 < group.incoming.length; i2++) {
+    const inc = group.incoming[i2];
     const qty = formatQuantity(Math.abs(inc.quantity));
     const commodity = formatCommodity(inc.symbol);
-    postings.push({ account: "equity:conversion", amount: `-${qty} ${commodity}` });
+    const costAnnotation = costInfo && costInfo.incomingTotalCosts[i2] != null ? ` @@ ${formatAmount2(costInfo.incomingTotalCosts[i2], costInfo.currency)}` : "";
+    postings.push({
+      account: "equity:conversion",
+      amount: `-${qty} ${commodity}${costAnnotation}`
+    });
     postings.push({
       account: `assets:investments:stocks:${inc.symbol}`,
-      amount: `${qty} ${commodity}`
+      amount: `${qty} ${commodity}${costAnnotation}`
     });
   }
   let entry = `${date5} ${description}
@@ -25624,9 +25638,12 @@ function processNonMergerAction(action, inventory, entries, logger) {
       const oldQty = getHeldQuantity(inventory, action.symbol);
       const newQty = Math.abs(qty);
       if (oldQty > 0) {
+        const lots = inventory[action.symbol] || [];
+        const totalCostBasis = lots.reduce((sum, lot) => sum + lot.quantity * lot.costBasis, 0);
+        const currency = lots[0]?.currency || "CAD";
         const ratio = newQty / oldQty;
         adjustLotsForSplit(inventory, action.symbol, ratio, logger);
-        const entry = generateSplitEntry(action, oldQty, newQty, logger);
+        const entry = generateSplitEntry(action, oldQty, newQty, totalCostBasis, currency, logger);
         entries.push(entry);
       } else {
         logger?.warn(`Reverse split for ${action.symbol} but no lots found`);
@@ -25652,36 +25669,6 @@ function processNonMergerAction(action, inventory, entries, logger) {
     }
   }
 }
-function processCorporateActions(actions, inventory, lotInventoryPath, projectDir, logger) {
-  const entries = [];
-  actions.sort((a, b) => formatDate(a.date).localeCompare(formatDate(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);
-  mergerGroups.sort((a, b) => formatDate(a.date).localeCompare(formatDate(b.date)));
-  let mi = 0;
-  let oi = 0;
-  while (mi < mergerGroups.length || oi < otherActions.length) {
-    const mergerDate = mi < mergerGroups.length ? formatDate(mergerGroups[mi].date) : "\uFFFF";
-    const otherDate = oi < otherActions.length ? formatDate(otherActions[oi].date) : "\uFFFF";
-    if (mergerDate <= otherDate) {
-      const groupEntries = processMultiWayMerger(mergerGroups[mi], inventory, lotInventoryPath, projectDir, logger);
-      entries.push(...groupEntries);
-      mi++;
-    } else {
-      processNonMergerAction(otherActions[oi], inventory, entries, logger);
-      oi++;
-    }
-  }
-  return entries;
-}
 function groupMergerActions(actions) {
   const groupMap = new Map;
   for (const action of actions) {
@@ -25713,11 +25700,13 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
     const pendingState = loadPendingMerger(projectDir, lotInventoryPath, group.key, logger);
     if (pendingState) {
       const totalIncomingQty2 = group.incoming.reduce((sum, a) => sum + Math.abs(a.quantity), 0);
+      const incomingTotalCosts2 = [];
       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;
+        incomingTotalCosts2.push(allocatedCost);
         const lot = {
           date: formatDate(inc.date),
           quantity: absQty,
@@ -25732,7 +25721,12 @@ 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, pendingState.outgoingIsins, logger);
+      const costInfo2 = {
+        outgoingTotalCosts: [],
+        incomingTotalCosts: incomingTotalCosts2,
+        currency: pendingState.currency
+      };
+      const entry2 = generateMultiWayMergerEntry(group, pendingState.outgoingSymbols, pendingState.outgoingIsins, costInfo2, logger);
       entries.push(entry2);
       removePendingMerger(projectDir, lotInventoryPath, group.key, logger);
     } else {
@@ -25743,18 +25737,23 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
   let totalCostBasis = 0;
   let outgoingCurrency = "";
   const outgoingSymbols = [];
+  const outgoingTotalCosts = [];
   for (const out of group.outgoing) {
     outgoingSymbols.push(out.symbol);
     const lots = inventory[out.symbol];
+    let symbolCost = 0;
     if (lots) {
       for (const lot of lots) {
-        totalCostBasis += lot.quantity * lot.costBasis;
+        symbolCost += lot.quantity * lot.costBasis;
         if (!outgoingCurrency && lot.currency) {
           outgoingCurrency = lot.currency;
         }
       }
     }
+    totalCostBasis += symbolCost;
+    outgoingTotalCosts.push(symbolCost);
   }
+  const costCurrency = outgoingCurrency || "CAD";
   if (group.outgoing.length > 0 && group.incoming.length === 0) {
     for (const out of group.outgoing) {
       removeLots(inventory, out.symbol, logger);
@@ -25766,9 +25765,14 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
       outgoingIsins: group.outgoing.map((a) => a.isin),
       outgoingQuantities: group.outgoing.map((a) => Math.abs(a.quantity)),
       totalCostBasis,
-      currency: outgoingCurrency || "CAD"
+      currency: costCurrency
     }, logger);
-    const entry2 = generateMultiWayMergerEntry(group, undefined, undefined, logger);
+    const costInfo2 = {
+      outgoingTotalCosts,
+      incomingTotalCosts: [],
+      currency: costCurrency
+    };
+    const entry2 = generateMultiWayMergerEntry(group, undefined, undefined, costInfo2, logger);
     entries.push(entry2);
     logger?.info(`Cross-currency merger outgoing: ${outgoingSymbols.join(", ")} -> pending (cost basis: ${totalCostBasis.toFixed(2)})`);
     return entries;
@@ -25779,16 +25783,18 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
     logger?.debug(`Merger outgoing: removed ${absQty} ${out.symbol}`);
   }
   const totalIncomingQty = group.incoming.reduce((sum, a) => sum + Math.abs(a.quantity), 0);
+  const incomingTotalCosts = [];
   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;
+    incomingTotalCosts.push(allocatedCost);
     const lot = {
       date: formatDate(inc.date),
       quantity: absQty,
       costBasis: costBasisPerUnit,
-      currency: outgoingCurrency || "CAD",
+      currency: costCurrency,
       isin: inc.isin,
       orderNum: inc.orderNum
     };
@@ -25798,7 +25804,12 @@ 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, undefined, logger);
+  const costInfo = {
+    outgoingTotalCosts,
+    incomingTotalCosts,
+    currency: costCurrency
+  };
+  const entry = generateMultiWayMergerEntry(group, undefined, undefined, costInfo, logger);
   entries.push(entry);
   return entries;
 }
@@ -26013,57 +26024,86 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
   logger?.logStep("route", "success", `Simple: ${stats.simpleTransactions}, Trades: ${stats.trades}, Dividends: ${stats.dividends}, Corporate: ${stats.corporateActions}, Forex: ${stats.forexTransactions}, Skipped: ${stats.skipped}`);
   logger?.endSection();
   const journalEntries = [];
-  if (trades.length > 0) {
-    logger?.startSection("Trade Processing", 2);
-    trades.sort((a, b) => formatDate(a.date).localeCompare(formatDate(b.date)));
-    for (const trade of trades) {
-      try {
-        if (trade.type === "Buy") {
-          const tradeInfo = {
-            date: formatDate(trade.date),
-            orderNum: trade.orderNum,
-            symbol: trade.symbol,
-            isin: trade.isin,
-            quantity: trade.quantity,
-            unitPrice: trade.unitPrice,
-            currency: trade.currency
-          };
-          addLot(inventory, tradeInfo, logger);
-          const entry = generateBuyEntry(trade, logger);
-          journalEntries.push(entry);
-          logger?.logStep("trade-buy", "success", `Buy ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency}`);
-        } else if (trade.type === "Sell") {
-          const consumed = consumeLotsFIFO(inventory, trade.symbol, trade.quantity, logger);
-          const entry = generateSellEntry(trade, consumed, logger);
+  const timeline = [];
+  for (const trade of trades) {
+    timeline.push({ kind: "trade", sortDate: formatDate(trade.date), trade });
+  }
+  for (const dividend of dividends) {
+    timeline.push({ kind: "dividend", sortDate: formatDate(dividend.date), dividend });
+  }
+  const mergerActions = [];
+  const otherCorpActions = [];
+  for (const action of corporateActions) {
+    if (MERGER_LIKE_TYPES.has(action.type)) {
+      mergerActions.push(action);
+    } else {
+      otherCorpActions.push(action);
+    }
+  }
+  const mergerGroups = groupMergerActions(mergerActions);
+  for (const group of mergerGroups) {
+    timeline.push({ kind: "mergerGroup", sortDate: formatDate(group.date), group });
+  }
+  for (const action of otherCorpActions) {
+    timeline.push({ kind: "corpAction", sortDate: formatDate(action.date), action });
+  }
+  timeline.sort((a, b) => a.sortDate.localeCompare(b.sortDate));
+  if (timeline.length > 0) {
+    logger?.startSection("Chronological Event Processing", 2);
+    for (const event of timeline) {
+      switch (event.kind) {
+        case "trade": {
+          const trade = event.trade;
+          try {
+            if (trade.type === "Buy") {
+              const tradeInfo = {
+                date: formatDate(trade.date),
+                orderNum: trade.orderNum,
+                symbol: trade.symbol,
+                isin: trade.isin,
+                quantity: trade.quantity,
+                unitPrice: trade.unitPrice,
+                currency: trade.currency
+              };
+              addLot(inventory, tradeInfo, logger);
+              const entry = generateBuyEntry(trade, logger);
+              journalEntries.push(entry);
+              logger?.logStep("trade-buy", "success", `Buy ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency}`);
+            } else if (trade.type === "Sell") {
+              const consumed = consumeLotsFIFO(inventory, trade.symbol, trade.quantity, logger);
+              const entry = generateSellEntry(trade, consumed, logger);
+              journalEntries.push(entry);
+              const totalCost = consumed.reduce((sum, c) => sum + c.totalCost, 0);
+              const gain = trade.quantity * trade.unitPrice - totalCost;
+              logger?.logStep("trade-sell", "success", `Sell ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency}, gain: ${gain.toFixed(2)}`);
+            }
+          } catch (error45) {
+            const message = error45 instanceof Error ? error45.message : String(error45);
+            logger?.logStep("trade", "error", `Failed to process trade: ${message}`);
+            logger?.error(`Trade processing error for ${trade.symbol}`, error45 instanceof Error ? error45 : undefined);
+          }
+          break;
+        }
+        case "dividend": {
+          const dividend = event.dividend;
+          const entry = generateDividendEntry(dividend, logger);
           journalEntries.push(entry);
-          const totalCost = consumed.reduce((sum, c) => sum + c.totalCost, 0);
-          const gain = trade.quantity * trade.unitPrice - totalCost;
-          logger?.logStep("trade-sell", "success", `Sell ${trade.quantity} ${trade.symbol} @ ${trade.unitPrice} ${trade.currency}, gain: ${gain.toFixed(2)}`);
+          logger?.logStep("dividend", "success", `Dividend ${dividend.symbol}: ${dividend.netAmount} ${dividend.currency} (tax: ${dividend.withholdingTax})`);
+          break;
+        }
+        case "mergerGroup": {
+          const groupEntries = processMultiWayMerger(event.group, inventory, lotInventoryPath, projectDir, logger);
+          journalEntries.push(...groupEntries);
+          break;
+        }
+        case "corpAction": {
+          processNonMergerAction(event.action, inventory, journalEntries, logger);
+          break;
         }
-      } catch (error45) {
-        const message = error45 instanceof Error ? error45.message : String(error45);
-        logger?.logStep("trade", "error", `Failed to process trade: ${message}`);
-        logger?.error(`Trade processing error for ${trade.symbol}`, error45 instanceof Error ? error45 : undefined);
       }
     }
     logger?.endSection();
   }
-  if (dividends.length > 0) {
-    logger?.startSection("Dividend Processing", 2);
-    for (const dividend of dividends) {
-      const entry = generateDividendEntry(dividend, logger);
-      journalEntries.push(entry);
-      logger?.logStep("dividend", "success", `Dividend ${dividend.symbol}: ${dividend.netAmount} ${dividend.currency} (tax: ${dividend.withholdingTax})`);
-    }
-    logger?.endSection();
-  }
-  if (corporateActions.length > 0) {
-    logger?.startSection("Corporate Actions Processing", 2);
-    const corpEntries = processCorporateActions(corporateActions, inventory, lotInventoryPath, projectDir, logger);
-    journalEntries.push(...corpEntries);
-    logger?.logStep("corporate", "success", `Processed ${corporateActions.length} corporate actions`);
-    logger?.endSection();
-  }
   logger?.logStep("save-inventory", "start", "Saving lot inventory");
   saveLotInventory(projectDir, lotInventoryPath, inventory, logger);
   logger?.logStep("save-inventory", "success", "Lot inventory saved");

package/package.json

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