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

package/dist/index.js

@@ -25298,32 +25298,49 @@ 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 postings = [
+  const totalCost = formatAmount2(totalCostBasis, currency);
+  const conversionAccount = `equity:conversion:${currency.toLowerCase()}`;
+  const outgoingPostings = [
     {
       account: `assets:investments:stocks:${action.symbol}`,
-      amount: `-${formatQuantity(oldQuantity)} ${commodity}`
+      amount: `-${formatQuantity(oldQuantity)} ${commodity} @@ ${totalCost}`
+    },
+    {
+      account: conversionAccount,
+      amount: totalCost
+    }
+  ];
+  const incomingPostings = [
+    {
+      account: conversionAccount,
+      amount: formatAmount2(-totalCostBasis, currency)
     },
-    { 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}`
     }
   ];
+  const metadata = `    ; swissquote:order:${action.orderNum} isin:${action.isin}
+` + `    ; Ratio: ${ratio.toFixed(4)} (${oldQuantity} -> ${newQuantity})
+`;
   let entry = `${date5} ${description}
 `;
-  entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
+  entry += metadata;
+  entry += formatPostings(outgoingPostings) + `
 `;
-  entry += `    ; Ratio: ${ratio.toFixed(4)} (${oldQuantity} -> ${newQuantity})
+  entry += `
 `;
-  entry += formatPostings(postings) + `
+  entry += `${date5} ${description}
+`;
+  entry += metadata;
+  entry += formatPostings(incomingPostings) + `
 `;
   return entry;
 }
@@ -25355,7 +25372,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);
@@ -25364,36 +25381,89 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
   logger?.debug(`Generating multi-way merger entry: ${outSymbols.join(", ")} -> ${inSymbols.join(", ")}`);
   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) {
+  let metadata = `    ; swissquote:order:${group.orderNum}
+`;
+  if (oldIsins.length > 0 || newIsins.length > 0) {
+    metadata += `    ; Old ISIN: ${oldIsins.join(", ") || "n/a"}, New ISINs: ${newIsins.join(", ") || "n/a"}
+`;
+  }
+  const entries = [];
+  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);
-    postings.push({
-      account: `assets:investments:stocks:${out.symbol}`,
-      amount: `-${qty} ${commodity}`
-    });
-    postings.push({ account: "equity:conversion", amount: `${qty} ${commodity}` });
+    if (costInfo && costInfo.outgoingTotalCosts[i2] != null) {
+      const costAmount = formatAmount2(costInfo.outgoingTotalCosts[i2], costInfo.currency);
+      const postings = [
+        {
+          account: `assets:investments:stocks:${out.symbol}`,
+          amount: `-${qty} ${commodity} @@ ${costAmount}`
+        },
+        {
+          account: `equity:conversion:${costInfo.currency.toLowerCase()}`,
+          amount: costAmount
+        }
+      ];
+      let sub = `${date5} ${description}
+`;
+      sub += metadata;
+      sub += formatPostings(postings) + `
+`;
+      entries.push(sub);
+    } else {
+      const postings = [
+        {
+          account: `assets:investments:stocks:${out.symbol}`,
+          amount: `-${qty} ${commodity}`
+        }
+      ];
+      let sub = `${date5} ${description}
+`;
+      sub += metadata;
+      sub += formatPostings(postings) + `
+`;
+      entries.push(sub);
+    }
   }
-  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}` });
-    postings.push({
-      account: `assets:investments:stocks:${inc.symbol}`,
-      amount: `${qty} ${commodity}`
-    });
-  }
-  let entry = `${date5} ${description}
+    if (costInfo && costInfo.incomingTotalCosts[i2] != null) {
+      const costAmount = formatAmount2(costInfo.incomingTotalCosts[i2], costInfo.currency);
+      const postings = [
+        {
+          account: `equity:conversion:${costInfo.currency.toLowerCase()}`,
+          amount: formatAmount2(-costInfo.incomingTotalCosts[i2], costInfo.currency)
+        },
+        {
+          account: `assets:investments:stocks:${inc.symbol}`,
+          amount: `${qty} ${commodity} @@ ${costAmount}`
+        }
+      ];
+      let sub = `${date5} ${description}
 `;
-  entry += `    ; swissquote:order:${group.orderNum}
+      sub += metadata;
+      sub += formatPostings(postings) + `
 `;
-  if (oldIsins.length > 0 || newIsins.length > 0) {
-    entry += `    ; Old ISIN: ${oldIsins.join(", ") || "n/a"}, New ISINs: ${newIsins.join(", ") || "n/a"}
+      entries.push(sub);
+    } else {
+      const postings = [
+        {
+          account: `assets:investments:stocks:${inc.symbol}`,
+          amount: `${qty} ${commodity}`
+        }
+      ];
+      let sub = `${date5} ${description}
 `;
-  }
-  entry += formatPostings(postings) + `
+      sub += metadata;
+      sub += formatPostings(postings) + `
 `;
-  return entry;
+      entries.push(sub);
+    }
+  }
+  return entries.join(`
+`);
 }
 function generateRightsDistributionEntry(action, logger) {
   const date5 = formatDate(action.date);
@@ -25416,28 +25486,23 @@ function generateRightsDistributionEntry(action, logger) {
 `;
   return entry;
 }
-function generatePendingMergerWorthlessEntry(date5, orderNum, outgoingSymbols, outgoingIsins, outgoingQuantities, totalCostBasis, currency, logger) {
+function generateDirectWorthlessEntry(date5, orderNum, outgoingSymbols, outgoingIsins, outgoingQuantities, outgoingTotalCosts, totalCostBasis, currency, logger) {
   const formattedDate = formatDate(date5);
   const symbols = outgoingSymbols.join(" + ");
-  const description = escapeDescription(`Worthless: ${symbols} (unresolved merger)`);
-  logger?.debug(`Generating pending merger worthless entry: ${symbols}, loss: ${totalCostBasis.toFixed(2)} ${currency}`);
+  const description = escapeDescription(`Worthless liquidation: ${symbols}`);
+  logger?.debug(`Generating direct worthless entry: ${symbols}, loss: ${totalCostBasis.toFixed(2)} ${currency}`);
   const postings = [];
-  if (outgoingQuantities.length > 0) {
-    const totalQty = outgoingQuantities.reduce((a, b) => a + b, 0);
-    for (let i2 = 0;i2 < outgoingSymbols.length; i2++) {
-      const symbol2 = outgoingSymbols[i2];
-      const quantity = outgoingQuantities[i2] || 0;
-      if (quantity <= 0)
-        continue;
-      const proportion = totalQty > 0 ? quantity / totalQty : 0;
-      const costForSymbol = totalCostBasis * proportion;
-      const costBasisPerUnit = costForSymbol / quantity;
-      const commodity = formatCommodity(symbol2);
-      postings.push({
-        account: "equity:conversion",
-        amount: `-${formatQuantity(quantity)} ${commodity} @ ${formatPrice(costBasisPerUnit)} ${currency}`
-      });
-    }
+  for (let i2 = 0;i2 < outgoingSymbols.length; i2++) {
+    const symbol2 = outgoingSymbols[i2];
+    const quantity = outgoingQuantities[i2] || 0;
+    const cost = outgoingTotalCosts[i2] || 0;
+    if (quantity <= 0)
+      continue;
+    const commodity = formatCommodity(symbol2);
+    postings.push({
+      account: `assets:investments:stocks:${symbol2}`,
+      amount: `-${formatQuantity(quantity)} ${commodity} @@ ${formatAmount2(cost, currency)}`
+    });
   }
   postings.push({
     account: "expenses:losses:capital",
@@ -25447,7 +25512,7 @@ function generatePendingMergerWorthlessEntry(date5, orderNum, outgoingSymbols, o
 `;
   entry += `    ; swissquote:order:${orderNum}
 `;
-  entry += `    ; Pending merger resolved as worthless - total loss: ${totalCostBasis.toFixed(2)} ${currency}
+  entry += `    ; total loss: ${totalCostBasis.toFixed(2)} ${currency}
 `;
   if (outgoingIsins.length > 0) {
     entry += `    ; Original ISINs: ${outgoingIsins.join(", ")}
@@ -25624,9 +25689,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`);
@@ -25682,12 +25750,25 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
   if (group.outgoing.length === 0 && group.incoming.length > 0) {
     const pendingState = loadPendingMerger(projectDir, lotInventoryPath, group.key, logger);
     if (pendingState) {
+      for (let i2 = 0;i2 < pendingState.outgoingSymbols.length; i2++) {
+        group.outgoing.push({
+          date: pendingState.date,
+          orderNum: pendingState.orderNum,
+          type: "Internal exchange of securities",
+          symbol: pendingState.outgoingSymbols[i2],
+          name: "",
+          isin: pendingState.outgoingIsins[i2] || "",
+          quantity: -(pendingState.outgoingQuantities[i2] || 0)
+        });
+      }
       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,
@@ -25702,7 +25783,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: pendingState.outgoingTotalCosts || [],
+        incomingTotalCosts: incomingTotalCosts2,
+        currency: pendingState.currency
+      };
+      const entry2 = generateMultiWayMergerEntry(group, undefined, undefined, costInfo2, logger);
       entries.push(entry2);
       removePendingMerger(projectDir, lotInventoryPath, group.key, logger);
     } else {
@@ -25713,18 +25799,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);
@@ -25735,11 +25826,10 @@ function processMultiWayMerger(group, inventory, lotInventoryPath, projectDir, l
       outgoingSymbols,
       outgoingIsins: group.outgoing.map((a) => a.isin),
       outgoingQuantities: group.outgoing.map((a) => Math.abs(a.quantity)),
+      outgoingTotalCosts,
       totalCostBasis,
-      currency: outgoingCurrency || "CAD"
+      currency: costCurrency
     }, 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;
   }
@@ -25749,16 +25839,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
     };
@@ -25768,7 +25860,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;
 }
@@ -25830,7 +25927,7 @@ function resolveRemainingPendingMergers(projectDir, lotInventoryPath, logger) {
         continue;
       }
       const year = parseInt(dateMatch[1], 10);
-      const entry = generatePendingMergerWorthlessEntry(state.date, state.orderNum, state.outgoingSymbols, state.outgoingIsins, state.outgoingQuantities || [], state.totalCostBasis, state.currency, logger);
+      const entry = generateDirectWorthlessEntry(state.date, state.orderNum, state.outgoingSymbols, state.outgoingIsins, state.outgoingQuantities || [], state.outgoingTotalCosts || [], state.totalCostBasis, state.currency, logger);
       const journalFile = path13.join(projectDir, "ledger", "investments", `${year}-${state.currency.toLowerCase()}.journal`);
       if (!entriesByJournal.has(journalFile)) {
         entriesByJournal.set(journalFile, []);
@@ -26137,7 +26234,7 @@ async function preprocessSwissquote(csvPath, projectDir, currency, year, lotInve
     investmentAccounts.add("income:capital-gains:realized");
     investmentAccounts.add("income:capital-gains:rights-distribution");
     investmentAccounts.add("expenses:losses:capital");
-    investmentAccounts.add("equity:conversion");
+    investmentAccounts.add(`equity:conversion:${currency.toLowerCase()}`);
     investmentAccounts.add("equity:rounding");
     ensureInvestmentAccountDeclarations(accountJournalPath, investmentAccounts, logger);
   }

package/package.json

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