@fuzzle/opencode-accountant 0.13.0 → 0.13.1-next.1

package/dist/index.js

@@ -24456,6 +24456,24 @@ function createImportLogger(directory, worktreeId, provider) {
 
 // src/utils/btcPurchaseGenerator.ts
 import * as fs14 from "fs";
+
+// src/utils/journalFormatting.ts
+var MIN_GAP = 5;
+var INDENT = "    ";
+function formatPostings(postings) {
+  const maxAccountLen = postings.reduce((max, p) => Math.max(max, p.account.length), 0);
+  return postings.map((p) => {
+    const gap = Math.max(MIN_GAP, maxAccountLen - p.account.length + MIN_GAP);
+    const line = `${INDENT}${p.account}${" ".repeat(gap)}${p.amount}`;
+    if (p.comment) {
+      return `${line}  ${p.comment}`;
+    }
+    return line;
+  }).join(`
+`);
+}
+
+// src/utils/btcPurchaseGenerator.ts
 function parseRevolutFiatDatetime(dateStr) {
   const [datePart, timePart] = dateStr.split(" ");
   if (!datePart || !timePart) {
@@ -24669,30 +24687,33 @@ function formatJournalEntry(match2) {
   const { fiatRow, btcRow } = match2;
   const date5 = fiatRow.dateStr;
   const fiatCurrency = fiatRow.currency;
-  const fiatAmount = formatAmount(fiatRow.amount);
   const btcQuantity = formatBtcQuantity(btcRow.quantity);
-  const btcPrice = formatAmount(btcRow.price.amount);
   const priceCurrency = btcRow.price.currency;
   const hasFees = btcRow.fees.amount > 0;
   const isBaseCurrency = fiatCurrency === "CHF";
+  const netFiatAmount = hasFees ? fiatRow.amount - btcRow.fees.amount : fiatRow.amount;
+  const effectivePrice = hasFees ? netFiatAmount / btcRow.quantity : btcRow.price.amount;
+  const fiatAmount = formatAmount(fiatRow.amount);
+  const netFiat = formatAmount(netFiatAmount);
+  const btcPrice = formatAmount(effectivePrice);
   const pair = `${fiatCurrency.toLowerCase()}-btc`;
   const equityFiat = `equity:conversion:${pair}:${fiatCurrency.toLowerCase()}`;
   const equityBtc = `equity:conversion:${pair}:btc`;
-  const assetCostAnnotation = isBaseCurrency ? `  @  ${btcPrice} ${priceCurrency}` : "";
-  const lines = [
-    `${date5} Bitcoin purchase`,
-    `    assets:bank:revolut:${fiatCurrency.toLowerCase()}    -${fiatAmount} ${fiatCurrency}`,
-    `    ${equityFiat}   ${fiatAmount} ${fiatCurrency}`,
-    `    ${equityBtc}  -${btcQuantity} BTC`,
-    `    assets:bank:revolut:btc     ${btcQuantity} BTC${assetCostAnnotation}`
+  const costAnnotation = isBaseCurrency ? `  @  ${btcPrice} ${priceCurrency}` : "";
+  const postings = [
+    {
+      account: `assets:bank:revolut:${fiatCurrency.toLowerCase()}`,
+      amount: `-${fiatAmount} ${fiatCurrency}`
+    }
   ];
   if (hasFees) {
     const feeAmount = formatAmount(btcRow.fees.amount);
     const feeCurrency = btcRow.fees.currency;
-    lines.push(`    expenses:fees:btc       ${feeAmount} ${feeCurrency}`, `    ${equityFiat}  -${feeAmount} ${feeCurrency}`);
+    postings.push({ account: "expenses:fees:btc", amount: `${feeAmount} ${feeCurrency}` });
   }
-  return lines.join(`
-`);
+  postings.push({ account: equityFiat, amount: `${netFiat} ${fiatCurrency}` }, { account: equityBtc, amount: `-${btcQuantity} BTC` }, { account: "assets:bank:revolut:btc", amount: `${btcQuantity} BTC${costAnnotation}` });
+  return `${date5} Bitcoin purchase
+${formatPostings(postings)}`;
 }
 function formatAmount(amount) {
   return amount.toFixed(2);
@@ -24745,8 +24766,18 @@ function generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, l
   }
   const newEntries = [];
   let skippedDuplicates = 0;
+  const accountsUsed = new Set;
   const sortedMatches = [...matches].sort((a, b) => a.fiatRow.date.getTime() - b.fiatRow.date.getTime());
   for (const match2 of sortedMatches) {
+    const fiat = match2.fiatRow.currency.toLowerCase();
+    const pair = `${fiat}-btc`;
+    accountsUsed.add(`assets:bank:revolut:${fiat}`);
+    accountsUsed.add(`equity:conversion:${pair}:${fiat}`);
+    accountsUsed.add(`equity:conversion:${pair}:btc`);
+    accountsUsed.add("assets:bank:revolut:btc");
+    if (match2.btcRow.fees.amount > 0) {
+      accountsUsed.add("expenses:fees:btc");
+    }
     if (isDuplicate(match2, journalContent)) {
       skippedDuplicates++;
       logger?.debug(`Skipping duplicate: ${match2.fiatRow.dateStr} ${formatAmount(match2.fiatRow.amount)} ${match2.fiatRow.currency}`);
@@ -24770,7 +24801,8 @@ function generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, l
     entriesAdded: newEntries.length,
     skippedDuplicates,
     unmatchedFiat,
-    unmatchedBtc
+    unmatchedBtc,
+    accountsUsed
   };
 }
 
@@ -25119,17 +25151,27 @@ function generateBuyEntry(trade, logger) {
   const cashOut = totalCost + fees;
   logger?.debug(`Generating Buy entry: ${qty} ${trade.symbol} @ ${price} ${trade.currency}`);
   const commodity = formatCommodity(trade.symbol);
+  const postings = [
+    {
+      account: `assets:investments:stocks:${trade.symbol}`,
+      amount: `${qty} ${commodity} @ ${price} ${trade.currency}`
+    }
+  ];
+  if (fees > 0) {
+    postings.push({
+      account: "expenses:fees:trading:swissquote",
+      amount: formatAmount2(fees, trade.currency)
+    });
+  }
+  postings.push({
+    account: `assets:broker:swissquote:${trade.currency.toLowerCase()}`,
+    amount: formatAmount2(-cashOut, trade.currency)
+  });
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${trade.orderNum} isin:${trade.isin}
 `;
-  entry += `    assets:investments:stocks:${trade.symbol}    ${qty} ${commodity} @ ${price} ${trade.currency}
-`;
-  if (fees > 0) {
-    entry += `    expenses:fees:trading:swissquote    ${formatAmount2(fees, trade.currency)}
-`;
-  }
-  entry += `    assets:broker:swissquote:${trade.currency.toLowerCase()}    ${formatAmount2(-cashOut, trade.currency)}
+  entry += formatPostings(postings) + `
 `;
   return entry;
 }
@@ -25144,49 +25186,72 @@ function generateSellEntry(trade, consumed, logger) {
   const gain = calculateCapitalGain(consumed, salePrice, trade.quantity);
   logger?.debug(`Generating Sell entry: ${qty} ${trade.symbol} @ ${salePrice} ${trade.currency}, gain: ${gain.toFixed(2)}`);
   const commodity = formatCommodity(trade.symbol);
-  let entry = `${date5} ${description}
-`;
-  entry += `    ; swissquote:order:${trade.orderNum} isin:${trade.isin}
-`;
   const lotDetails = consumed.map((c) => `${c.lot.date}: ${formatQuantity(c.quantity)}@${formatPrice(c.lot.costBasis)}`).join(", ");
-  entry += `    ; FIFO lots: ${lotDetails}
-`;
+  const postings = [];
   for (const c of consumed) {
     const lotQty = formatQuantity(c.quantity);
     const lotPrice = formatPrice(c.lot.costBasis);
-    entry += `    assets:investments:stocks:${trade.symbol}    -${lotQty} ${commodity} @ ${lotPrice} ${trade.currency}
-`;
+    postings.push({
+      account: `assets:investments:stocks:${trade.symbol}`,
+      amount: `-${lotQty} ${commodity} @ ${lotPrice} ${trade.currency}`
+    });
   }
-  entry += `    assets:broker:swissquote:${trade.currency.toLowerCase()}    ${formatAmount2(cashIn, trade.currency)}
-`;
+  postings.push({
+    account: `assets:broker:swissquote:${trade.currency.toLowerCase()}`,
+    amount: formatAmount2(cashIn, trade.currency)
+  });
   if (fees > 0) {
-    entry += `    expenses:fees:trading:swissquote    ${formatAmount2(fees, trade.currency)}
-`;
+    postings.push({
+      account: "expenses:fees:trading:swissquote",
+      amount: formatAmount2(fees, trade.currency)
+    });
   }
   if (gain >= 0) {
-    entry += `    income:capital-gains:realized    ${formatAmount2(-gain, trade.currency)}
-`;
+    postings.push({
+      account: "income:capital-gains:realized",
+      amount: formatAmount2(-gain, trade.currency)
+    });
   } else {
-    entry += `    expenses:losses:capital    ${formatAmount2(-gain, trade.currency)}
-`;
+    postings.push({
+      account: "expenses:losses:capital",
+      amount: formatAmount2(-gain, trade.currency)
+    });
   }
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${trade.orderNum} isin:${trade.isin}
+`;
+  entry += `    ; FIFO lots: ${lotDetails}
+`;
+  entry += formatPostings(postings) + `
+`;
   return entry;
 }
 function generateDividendEntry(dividend, logger) {
   const date5 = formatDate(dividend.date);
   const description = escapeDescription(`Dividend ${dividend.symbol} - ${dividend.name}`);
   logger?.debug(`Generating Dividend entry: ${dividend.symbol}, net: ${dividend.netAmount} ${dividend.currency}`);
+  const postings = [
+    {
+      account: `assets:broker:swissquote:${dividend.currency.toLowerCase()}`,
+      amount: formatAmount2(dividend.netAmount, dividend.currency)
+    }
+  ];
+  if (dividend.withholdingTax > 0) {
+    postings.push({
+      account: "expenses:taxes:withholding",
+      amount: formatAmount2(dividend.withholdingTax, dividend.currency)
+    });
+  }
+  postings.push({
+    account: `income:dividends:${dividend.symbol}`,
+    amount: formatAmount2(-dividend.grossAmount, dividend.currency)
+  });
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${dividend.orderNum} isin:${dividend.isin}
 `;
-  entry += `    assets:broker:swissquote:${dividend.currency.toLowerCase()}    ${formatAmount2(dividend.netAmount, dividend.currency)}
-`;
-  if (dividend.withholdingTax > 0) {
-    entry += `    expenses:taxes:withholding    ${formatAmount2(dividend.withholdingTax, dividend.currency)}
-`;
-  }
-  entry += `    income:dividends:${dividend.symbol}    ${formatAmount2(-dividend.grossAmount, dividend.currency)}
+  entry += formatPostings(postings) + `
 `;
   return entry;
 }
@@ -25196,20 +25261,26 @@ function generateSplitEntry(action, oldQuantity, newQuantity, logger) {
   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 = [
+    {
+      account: `assets:investments:stocks:${action.symbol}`,
+      amount: `-${formatQuantity(oldQuantity)} ${commodity}`
+    },
+    { account: "equity:conversion", amount: `${formatQuantity(oldQuantity)} ${commodity}` },
+    { account: "equity:conversion", amount: `-${formatQuantity(newQuantity)} ${commodity}` },
+    {
+      account: `assets:investments:stocks:${action.symbol}`,
+      amount: `${formatQuantity(newQuantity)} ${commodity}`
+    }
+  ];
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
 `;
   entry += `    ; Ratio: ${ratio.toFixed(4)} (${oldQuantity} -> ${newQuantity})
 `;
-  const commodity = formatCommodity(action.symbol);
-  entry += `    assets:investments:stocks:${action.symbol}    -${formatQuantity(oldQuantity)} ${commodity}
-`;
-  entry += `    equity:conversion    ${formatQuantity(oldQuantity)} ${commodity}
-`;
-  entry += `    equity:conversion    -${formatQuantity(newQuantity)} ${commodity}
-`;
-  entry += `    assets:investments:stocks:${action.symbol}    ${formatQuantity(newQuantity)} ${commodity}
+  entry += formatPostings(postings) + `
 `;
   return entry;
 }
@@ -25220,20 +25291,24 @@ function generateWorthlessEntry(action, removedLots, logger) {
   const totalCost = removedLots.reduce((sum, lot) => sum + lot.quantity * lot.costBasis, 0);
   const currency = removedLots[0]?.currency || "USD";
   logger?.debug(`Generating Worthless entry: ${totalQuantity} ${action.symbol}, loss: ${totalCost} ${currency}`);
+  const commodity = formatCommodity(action.symbol);
+  const postings = [];
+  for (const lot of removedLots) {
+    const qty = formatQuantity(lot.quantity);
+    const price = formatPrice(lot.costBasis);
+    postings.push({
+      account: `assets:investments:stocks:${action.symbol}`,
+      amount: `-${qty} ${commodity} @ ${price} ${currency}`
+    });
+  }
+  postings.push({ account: "expenses:losses:capital", amount: formatAmount2(totalCost, currency) });
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
 `;
   entry += `    ; Total loss: ${totalCost.toFixed(2)} ${currency}
 `;
-  const commodity = formatCommodity(action.symbol);
-  for (const lot of removedLots) {
-    const qty = formatQuantity(lot.quantity);
-    const price = formatPrice(lot.costBasis);
-    entry += `    assets:investments:stocks:${action.symbol}    -${qty} ${commodity} @ ${price} ${currency}
-`;
-  }
-  entry += `    expenses:losses:capital    ${formatAmount2(totalCost, currency)}
+  entry += formatPostings(postings) + `
 `;
   return entry;
 }
@@ -25244,32 +25319,37 @@ function generateMultiWayMergerEntry(group, crossCurrencyOutgoingSymbols, crossC
   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 = (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"}
-`;
-  }
+  const postings = [];
   for (const out of group.outgoing) {
     const qty = formatQuantity(Math.abs(out.quantity));
     const commodity = formatCommodity(out.symbol);
-    entry += `    assets:investments:stocks:${out.symbol}    -${qty} ${commodity}
-`;
-    entry += `    equity:conversion    ${qty} ${commodity}
-`;
+    postings.push({
+      account: `assets:investments:stocks:${out.symbol}`,
+      amount: `-${qty} ${commodity}`
+    });
+    postings.push({ account: "equity:conversion", amount: `${qty} ${commodity}` });
   }
   for (const inc of group.incoming) {
     const qty = formatQuantity(Math.abs(inc.quantity));
     const commodity = formatCommodity(inc.symbol);
-    entry += `    equity:conversion    -${qty} ${commodity}
+    postings.push({ account: "equity:conversion", amount: `-${qty} ${commodity}` });
+    postings.push({
+      account: `assets:investments:stocks:${inc.symbol}`,
+      amount: `${qty} ${commodity}`
+    });
+  }
+  let entry = `${date5} ${description}
+`;
+  entry += `    ; swissquote:order:${group.orderNum}
 `;
-    entry += `    assets:investments:stocks:${inc.symbol}    ${qty} ${commodity}
+  if (oldIsins.length > 0 || newIsins.length > 0) {
+    entry += `    ; Old ISIN: ${oldIsins.join(", ") || "n/a"}, New ISINs: ${newIsins.join(", ") || "n/a"}
 `;
   }
+  entry += formatPostings(postings) + `
+`;
   return entry;
 }
 function generateRightsDistributionEntry(action, logger) {
@@ -25278,13 +25358,18 @@ function generateRightsDistributionEntry(action, logger) {
   const description = escapeDescription(`Rights Distribution: ${action.symbol} - ${action.name}`);
   logger?.debug(`Generating Rights Distribution entry: ${qty} ${action.symbol}`);
   const commodity = formatCommodity(action.symbol);
+  const postings = [
+    {
+      account: `assets:investments:stocks:${action.symbol}`,
+      amount: `${qty} ${commodity} @ 0.00 CAD`
+    },
+    { account: "income:capital-gains:rights-distribution", amount: "0.00 CAD" }
+  ];
   let entry = `${date5} ${description}
 `;
   entry += `    ; swissquote:order:${action.orderNum} isin:${action.isin}
 `;
-  entry += `    assets:investments:stocks:${action.symbol}    ${qty} ${commodity} @ 0.00 CAD
-`;
-  entry += `    income:capital-gains:rights-distribution    0.00 CAD
+  entry += formatPostings(postings) + `
 `;
   return entry;
 }
@@ -25985,14 +26070,20 @@ function formatExchangeEntry(match2) {
   const pair = `${sourceCurrency.toLowerCase()}-${targetCurrency.toLowerCase()}`;
   const equitySource = `equity:conversion:${pair}:${sourceCurrency.toLowerCase()}`;
   const equityTarget = `equity:conversion:${pair}:${targetCurrency.toLowerCase()}`;
-  return [
-    `${date5} ${description}`,
-    `    assets:bank:revolut:${sourceCurrency.toLowerCase()}    -${sourceAmount} ${sourceCurrency}`,
-    `    ${equitySource}   ${sourceAmount} ${sourceCurrency}`,
-    `    ${equityTarget}  -${targetAmount} ${targetCurrency}`,
-    `    assets:bank:revolut:${targetCurrency.toLowerCase()}     ${targetAmount} ${targetCurrency}`
-  ].join(`
-`);
+  const postings = [
+    {
+      account: `assets:bank:revolut:${sourceCurrency.toLowerCase()}`,
+      amount: `-${sourceAmount} ${sourceCurrency}`
+    },
+    { account: equitySource, amount: `${sourceAmount} ${sourceCurrency}` },
+    { account: equityTarget, amount: `-${targetAmount} ${targetCurrency}` },
+    {
+      account: `assets:bank:revolut:${targetCurrency.toLowerCase()}`,
+      amount: `${targetAmount} ${targetCurrency}`
+    }
+  ];
+  return `${date5} ${description}
+${formatPostings(postings)}`;
 }
 function formatAmount3(amount) {
   return amount.toFixed(2);
@@ -26054,7 +26145,13 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
   }
   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 };
+    return {
+      matchCount: 0,
+      entriesAdded: 0,
+      skippedDuplicates: 0,
+      matchedRowIndices: new Map,
+      accountsUsed: new Set
+    };
   }
   logger?.info("Matching exchange pairs across CSVs...");
   const matches = matchExchangePairs(rowsByCsv);
@@ -26065,8 +26162,16 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
   }
   const newEntries = [];
   let skippedDuplicates = 0;
+  const accountsUsed = new Set;
   const sortedMatches = [...matches].sort((a, b) => a.source.date.getTime() - b.source.date.getTime());
   for (const match2 of sortedMatches) {
+    const source = match2.source.currency.toLowerCase();
+    const target = match2.target.currency.toLowerCase();
+    const pair = `${source}-${target}`;
+    accountsUsed.add(`assets:bank:revolut:${source}`);
+    accountsUsed.add(`equity:conversion:${pair}:${source}`);
+    accountsUsed.add(`equity:conversion:${pair}:${target}`);
+    accountsUsed.add(`assets:bank:revolut:${target}`);
     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}`);
@@ -26098,7 +26203,8 @@ function generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger)
     matchCount: matches.length,
     entriesAdded: newEntries.length,
     skippedDuplicates,
-    matchedRowIndices
+    matchedRowIndices,
+    accountsUsed
   };
 }
 
@@ -26270,6 +26376,9 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   const year = yearMatch ? parseInt(yearMatch[1], 10) : new Date().getFullYear();
   const yearJournalPath = ensureYearJournalExists(context.directory, year);
   const result = generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, logger);
+  for (const account of result.accountsUsed) {
+    context.generatedAccounts.add(account);
+  }
   const message = result.entriesAdded > 0 ? `Generated ${result.entriesAdded} BTC purchase entries (${result.matchCount} matched, ${result.skippedDuplicates} skipped)` : `No new BTC purchase entries (${result.matchCount} matched, ${result.skippedDuplicates} duplicates)`;
   logger?.logStep("BTC Purchases", "success", message);
   logger?.endSection();
@@ -26304,6 +26413,9 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
   const yearJournalPath = ensureYearJournalExists(context.directory, year);
   const fiatCsvPaths = fiatContexts.map((c) => c.csvPath);
   const result = generateCurrencyExchangeJournal(fiatCsvPaths, yearJournalPath, logger);
+  for (const account of result.accountsUsed) {
+    context.generatedAccounts.add(account);
+  }
   if (result.matchedRowIndices.size > 0) {
     for (const { contextId, csvPath } of fiatContexts) {
       const indices = result.matchedRowIndices.get(csvPath);
@@ -26706,7 +26818,8 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     options,
     configLoader,
     hledgerExecutor,
-    result
+    result,
+    generatedAccounts: new Set
   };
   try {
     const contextIds = await executeClassifyStep(context, logger);
@@ -26719,6 +26832,18 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     await executeBtcPurchaseStep(context, contextIds, logger);
     await executeCurrencyExchangeStep(context, contextIds, logger);
     await executeSwissquotePreprocessStep(context, contextIds, logger);
+    if (context.generatedAccounts.size > 0) {
+      const firstCtx = contextIds.map((id) => loadContext(context.directory, id)).find((c) => c.provider === "revolut");
+      if (firstCtx) {
+        const yearMatch = firstCtx.filePath.match(/(\d{4})-\d{2}-\d{2}/);
+        const year = yearMatch ? parseInt(yearMatch[1], 10) : new Date().getFullYear();
+        const yearJournalPath = ensureYearJournalExists(context.directory, year);
+        const declResult = ensureAccountDeclarations(yearJournalPath, context.generatedAccounts);
+        if (declResult.added.length > 0) {
+          logger.info(`Declared ${declResult.added.length} account(s) from generated entries: ${declResult.added.join(", ")}`);
+        }
+      }
+    }
     const importConfig = loadImportConfig(context.directory);
     const orderedContextIds = [...contextIds].sort((a, b) => {
       const ctxA = loadContext(context.directory, a);

package/package.json

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