@fuzzle/opencode-accountant 0.16.6 → 0.16.7-next.1

package/dist/index.js

@@ -17225,6 +17225,35 @@ stocks:
 }
 
 // src/utils/dateUtils.ts
+var PROVIDER_YEAR_PATTERNS = {
+  swissquote: { pattern: /to-\d{4}(\d{4})\./, group: 1 },
+  ibkr: { pattern: /(\d{4})\d{4}\./, group: 1 }
+};
+var DEFAULT_YEAR_PATTERN = /(\d{4})-\d{2}-\d{2}/;
+function getTransactionYear(ctx) {
+  if (ctx.untilDate) {
+    const year = parseInt(ctx.untilDate.slice(0, 4), 10);
+    if (!isNaN(year))
+      return year;
+  }
+  if (ctx.fromDate) {
+    const year = parseInt(ctx.fromDate.slice(0, 4), 10);
+    if (!isNaN(year))
+      return year;
+  }
+  const providerPattern = PROVIDER_YEAR_PATTERNS[ctx.provider];
+  if (providerPattern) {
+    const match = ctx.filename.match(providerPattern.pattern);
+    if (match) {
+      return parseInt(match[providerPattern.group], 10);
+    }
+  }
+  const defaultMatch = ctx.filePath.match(DEFAULT_YEAR_PATTERN);
+  if (defaultMatch) {
+    return parseInt(defaultMatch[1], 10);
+  }
+  return new Date().getFullYear();
+}
 function formatDateISO(date5) {
   return date5.toISOString().split("T")[0];
 }
@@ -17741,10 +17770,10 @@ function getContextPath(directory, contextId) {
 function createContext(directory, params) {
   const now = new Date().toISOString();
   const context = {
+    ...params,
     id: randomUUID(),
     createdAt: now,
-    updatedAt: now,
-    ...params
+    updatedAt: now
   };
   ensureDirectory(path5.join(directory, ".memory"));
   const contextPath = getContextPath(directory, context.id);
@@ -17760,7 +17789,7 @@ function validateContext(context, contextId) {
     "currency"
   ];
   for (const field of requiredFields) {
-    if (!context[field]) {
+    if (typeof context[field] !== "string" || context[field] === "") {
       throw new Error(`Invalid context ${contextId}: missing required field '${field}'`);
     }
   }
@@ -24453,6 +24482,7 @@ class MarkdownLogger {
   autoFlush;
   sectionDepth = 0;
   pendingFlush = null;
+  flushedOnce = false;
   constructor(config2) {
     this.autoFlush = config2.autoFlush ?? true;
     this.context = config2.context || {};
@@ -24548,8 +24578,16 @@ class MarkdownLogger {
       return;
     try {
       await fs13.mkdir(path11.dirname(this.logPath), { recursive: true });
-      await fs13.writeFile(this.logPath, this.buffer.join(`
+      if (this.flushedOnce) {
+        await fs13.appendFile(this.logPath, `
+` + this.buffer.join(`
 `), "utf-8");
+      } else {
+        await fs13.writeFile(this.logPath, this.buffer.join(`
+`), "utf-8");
+        this.flushedOnce = true;
+      }
+      this.buffer = [];
     } catch {}
   }
   getLogPath() {
@@ -26903,6 +26941,16 @@ function generateIbkrBuyEntry(trade, logger) {
     account: `assets:broker:ibkr:${trade.currency.toLowerCase()}`,
     amount: formatAmount(-cashOut, trade.currency)
   });
+  const computedNetCents = Math.round(totalCost * 100) + Math.round(fees * 100);
+  const brokerNetCents = Math.round(cashOut * 100);
+  const roundingCents = brokerNetCents - computedNetCents;
+  if (roundingCents !== 0) {
+    postings.push({
+      account: "equity:rounding",
+      amount: formatAmount(roundingCents / 100, trade.currency)
+    });
+    logger?.debug(`Rounding adjustment: ${roundingCents / 100} ${trade.currency}`);
+  }
   let entry = `${trade.date} ${description}
 `;
   entry += `    ; ibkr:account:${trade.account}
@@ -26952,6 +27000,16 @@ function generateIbkrSellEntry(trade, consumed, logger) {
       amount: formatAmount(-capitalGain, trade.currency)
     });
   }
+  const computedNetCents = Math.round(saleProceeds * 100) - Math.round(fees * 100);
+  const brokerNetCents = Math.round(Math.abs(cashIn) * 100);
+  const roundingCents = computedNetCents - brokerNetCents;
+  if (roundingCents !== 0) {
+    postings.push({
+      account: "equity:rounding",
+      amount: formatAmount(roundingCents / 100, trade.currency)
+    });
+    logger?.debug(`Rounding adjustment: ${roundingCents / 100} ${trade.currency}`);
+  }
   let entry = `${trade.date} ${description}
 `;
   entry += `    ; ibkr:account:${trade.account}
@@ -26981,6 +27039,16 @@ function generateIbkrDividendEntry(dividend, logger) {
     account: `income:dividends:${dividend.symbol}`,
     amount: formatAmount(-dividend.grossAmount, dividend.currency)
   });
+  const computedNetCents = Math.round(dividend.grossAmount * 100) - Math.round(dividend.withholdingTax * 100);
+  const brokerNetCents = Math.round(dividend.netAmount * 100);
+  const roundingCents = brokerNetCents - computedNetCents;
+  if (roundingCents !== 0) {
+    postings.push({
+      account: "equity:rounding",
+      amount: formatAmount(roundingCents / 100, dividend.currency)
+    });
+    logger?.debug(`Rounding adjustment: ${roundingCents / 100} ${dividend.currency}`);
+  }
   let entry = `${dividend.date} ${description}
 `;
   entry += `    ; ibkr:account:${dividend.account}
@@ -27131,8 +27199,6 @@ async function preprocessIbkr(csvPath, directory, currency, year, lotInventoryPa
   const usedAccounts = new Set;
   const journalEntries = [];
   for (const trade of trades) {
-    rawSum += trade.netAmount;
-    roundedSum += round2(trade.netAmount);
     const totalCost = Math.abs(trade.grossAmount);
     const unitPrice = trade.quantity !== 0 ? totalCost / Math.abs(trade.quantity) : 0;
     const tradeEntry = {
@@ -27185,8 +27251,6 @@ async function preprocessIbkr(csvPath, directory, currency, year, lotInventoryPa
   const dividendGroups = groupDividends(dividendTxns);
   for (const group of dividendGroups) {
     const netAmount = group.grossAmount - group.withholdingTax;
-    rawSum += netAmount;
-    roundedSum += round2(netAmount);
     const dividendEntry = {
       date: group.date,
       account: group.account,
@@ -27231,6 +27295,7 @@ async function preprocessIbkr(csvPath, directory, currency, year, lotInventoryPa
       const commodityJournalPath = path17.join(directory, "ledger", "investments", "commodities.journal");
       ensureCommodityDeclarations(commodityJournalPath, tradedSymbols, logger);
     }
+    usedAccounts.add("equity:rounding");
     if (usedAccounts.size > 0) {
       const accountJournalPath = path17.join(directory, "ledger", "investments", "accounts.journal");
       ensureInvestmentAccountDeclarations(accountJournalPath, usedAccounts, logger);
@@ -27309,6 +27374,19 @@ class NoTransactionsError extends Error {
     this.name = "NoTransactionsError";
   }
 }
+function cachedLoadContext(pipeCtx, contextId) {
+  const cached2 = pipeCtx.contextCache.get(contextId);
+  if (cached2)
+    return cached2;
+  const ctx = loadContext(pipeCtx.directory, contextId);
+  pipeCtx.contextCache.set(contextId, ctx);
+  return ctx;
+}
+function cachedUpdateContext(pipeCtx, contextId, updates) {
+  const updated = updateContext(pipeCtx.directory, contextId, updates);
+  pipeCtx.contextCache.set(contextId, updated);
+  return updated;
+}
 function buildStepResult(success2, message, details) {
   const result = { success: success2, message };
   if (details !== undefined) {
@@ -27372,7 +27450,7 @@ async function executeClassifyStep(context, logger) {
 function executePreprocessFiatStep(context, contextIds, logger) {
   const fiatCsvPaths = [];
   for (const contextId of contextIds) {
-    const importCtx = loadContext(context.directory, contextId);
+    const importCtx = cachedLoadContext(context, contextId);
     if (importCtx.provider === "revolut" && importCtx.currency !== "btc") {
       fiatCsvPaths.push(path18.join(context.directory, importCtx.filePath));
     }
@@ -27416,7 +27494,7 @@ function executePreprocessFiatStep(context, contextIds, logger) {
 function executePreprocessBtcStep(context, contextIds, logger) {
   let btcCsvPath;
   for (const contextId of contextIds) {
-    const importCtx = loadContext(context.directory, contextId);
+    const importCtx = cachedLoadContext(context, contextId);
     if (importCtx.provider === "revolut" && importCtx.currency === "btc") {
       btcCsvPath = path18.join(context.directory, importCtx.filePath);
       break;
@@ -27449,7 +27527,7 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   const fiatCsvPaths = [];
   let btcCsvPath;
   for (const contextId of contextIds) {
-    const importCtx = loadContext(context.directory, contextId);
+    const importCtx = cachedLoadContext(context, contextId);
     if (importCtx.provider !== "revolut")
       continue;
     const csvPath = path18.join(context.directory, importCtx.filePath);
@@ -27465,29 +27543,39 @@ async function executeBtcPurchaseStep(context, contextIds, logger) {
   }
   logger?.startSection("Step 1b: Generate BTC Purchase Entries");
   logger?.logStep("BTC Purchases", "start");
-  const btcFilename = path18.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);
-  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();
-  context.result.steps.btcPurchases = buildStepResult(true, message, {
-    matchCount: result.matchCount,
-    entriesAdded: result.entriesAdded,
-    skippedDuplicates: result.skippedDuplicates,
-    unmatchedFiat: result.unmatchedFiat.length,
-    unmatchedBtc: result.unmatchedBtc.length
-  });
+  try {
+    const btcCtx = contextIds.map((id) => cachedLoadContext(context, id)).find((c) => c.provider === "revolut" && c.currency === "btc");
+    const year = getTransactionYear(btcCtx);
+    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);
+    context.result.steps.btcPurchases = buildStepResult(true, message, {
+      matchCount: result.matchCount,
+      entriesAdded: result.entriesAdded,
+      skippedDuplicates: result.skippedDuplicates,
+      unmatchedFiat: result.unmatchedFiat.length,
+      unmatchedBtc: result.unmatchedBtc.length
+    });
+  } catch (error45) {
+    const errorMessage = `BTC purchase generation failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    logger?.error(errorMessage);
+    logger?.logStep("BTC Purchases", "error", errorMessage);
+    context.result.steps.btcPurchases = buildStepResult(false, errorMessage);
+    context.result.error = errorMessage;
+    context.result.hint = "Check the Revolut fiat and BTC CSV formats";
+    throw new Error(errorMessage);
+  } finally {
+    logger?.endSection();
+  }
 }
 async function executeCurrencyExchangeStep(context, contextIds, logger) {
   const fiatContexts = [];
   for (const contextId of contextIds) {
-    const importCtx = loadContext(context.directory, contextId);
+    const importCtx = cachedLoadContext(context, contextId);
     if (importCtx.provider !== "revolut")
       continue;
     if (importCtx.currency === "btc")
@@ -27499,49 +27587,55 @@ async function executeCurrencyExchangeStep(context, contextIds, logger) {
     logger?.info("Need at least 2 Revolut fiat CSVs for exchange matching, skipping");
     return;
   }
-  logger?.startSection("Step 1e: Generate Currency Exchange Entries");
+  logger?.startSection("Step 1d: Generate Currency Exchange Entries");
   logger?.logStep("Currency Exchanges", "start");
-  const firstFilename = path18.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);
-  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);
-      if (!indices || indices.size === 0)
-        continue;
-      const filteredCsvPath = filterExchangeRows(csvPath, indices, logger);
-      updateContext(context.directory, contextId, {
-        filePath: path18.relative(context.directory, filteredCsvPath)
-      });
-      logger?.info(`Updated context ${contextId} to use filtered CSV: ${path18.basename(filteredCsvPath)}`);
+  try {
+    const firstFiatCtx = cachedLoadContext(context, fiatContexts[0].contextId);
+    const year = getTransactionYear(firstFiatCtx);
+    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);
+        if (!indices || indices.size === 0)
+          continue;
+        const filteredCsvPath = filterExchangeRows(csvPath, indices, logger);
+        cachedUpdateContext(context, contextId, {
+          filePath: path18.relative(context.directory, filteredCsvPath)
+        });
+        logger?.info(`Updated context ${contextId} to use filtered CSV: ${path18.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);
+    context.result.steps.currencyExchanges = buildStepResult(true, message, {
+      matchCount: result.matchCount,
+      entriesAdded: result.entriesAdded,
+      skippedDuplicates: result.skippedDuplicates
+    });
+  } catch (error45) {
+    const errorMessage = `Currency exchange generation failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    logger?.error(errorMessage);
+    logger?.logStep("Currency Exchanges", "error", errorMessage);
+    context.result.steps.currencyExchanges = buildStepResult(false, errorMessage);
+    context.result.error = errorMessage;
+    context.result.hint = "Check the Revolut fiat CSV formats";
+    throw new Error(errorMessage);
+  } finally {
+    logger?.endSection();
   }
-  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);
+    const importCtx = cachedLoadContext(context, contextId);
     if (importCtx.provider === "swissquote") {
       const csvPath = path18.join(context.directory, importCtx.filePath);
-      const toDateMatch = importCtx.filename.match(/to-\d{4}(\d{4})\./);
-      let year = new Date().getFullYear();
-      if (toDateMatch) {
-        year = parseInt(toDateMatch[1], 10);
-      }
+      const year = getTransactionYear(importCtx);
       swissquoteContexts.push({
         contextId,
         csvPath,
@@ -27554,7 +27648,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
     logger?.info("No Swissquote CSV found, skipping preprocessing");
     return;
   }
-  logger?.startSection("Step 1d: Preprocess Swissquote CSV");
+  logger?.startSection("Step 1e: Preprocess Swissquote CSV");
   const config2 = context.configLoader(context.directory);
   const swissquoteProvider = config2.providers?.["swissquote"];
   const lotInventoryPath = swissquoteProvider?.lotInventoryPath ?? DEFAULT_LOT_INVENTORY_PATH;
@@ -27602,7 +27696,7 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
         lastJournalFile = result.journalFile;
       }
       if (result.simpleTransactionsCsv) {
-        updateContext(context.directory, sqCtx.contextId, {
+        cachedUpdateContext(context, sqCtx.contextId, {
           filePath: path18.relative(context.directory, result.simpleTransactionsCsv)
         });
         logger?.info(`Updated context ${sqCtx.contextId} to use filtered CSV: ${path18.basename(result.simpleTransactionsCsv)}`);
@@ -27644,14 +27738,10 @@ async function executeSwissquotePreprocessStep(context, contextIds, logger) {
 async function executeIbkrPreprocessStep(context, contextIds, logger) {
   const ibkrContexts = [];
   for (const contextId of contextIds) {
-    const importCtx = loadContext(context.directory, contextId);
+    const importCtx = cachedLoadContext(context, contextId);
     if (importCtx.provider === "ibkr") {
       const csvPath = path18.join(context.directory, importCtx.filePath);
-      const dateMatch = importCtx.filename.match(/(\d{4})\d{4}\./);
-      let year = new Date().getFullYear();
-      if (dateMatch) {
-        year = parseInt(dateMatch[1], 10);
-      }
+      const year = getTransactionYear(importCtx);
       ibkrContexts.push({
         contextId,
         csvPath,
@@ -27696,7 +27786,7 @@ async function executeIbkrPreprocessStep(context, contextIds, logger) {
         lastJournalFile = result.journalFile;
       }
       if (result.simpleTransactionsCsv) {
-        updateContext(context.directory, ibkrCtx.contextId, {
+        cachedUpdateContext(context, ibkrCtx.contextId, {
           filePath: path18.relative(context.directory, result.simpleTransactionsCsv)
         });
         logger?.info(`Updated context ${ibkrCtx.contextId} to use filtered CSV: ${path18.basename(result.simpleTransactionsCsv)}`);
@@ -27725,7 +27815,7 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   logger?.logStep("Check Accounts", "start");
   const config2 = context.configLoader(context.directory);
   const rulesDir = path18.join(context.directory, config2.paths.rules);
-  const importCtx = loadContext(context.directory, contextId);
+  const importCtx = cachedLoadContext(context, contextId);
   const csvPath = path18.join(context.directory, importCtx.filePath);
   const csvFiles = [csvPath];
   const rulesMapping = loadRulesMapping(rulesDir);
@@ -27807,7 +27897,7 @@ 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 = path18.join(context.directory, config2.paths.rules);
-  const importCtx = loadContext(context.directory, contextId);
+  const importCtx = cachedLoadContext(context, contextId);
   const csvPath = path18.join(context.directory, importCtx.filePath);
   const rulesMapping = loadRulesMapping(rulesDir);
   const rulesFile = findRulesForCsv(csvPath, rulesMapping);
@@ -27869,7 +27959,7 @@ function formatUnknownPostingsLog(postings) {
   return log;
 }
 async function executeImportStep(context, contextId, logger) {
-  const importContext = loadContext(context.directory, contextId);
+  const importContext = cachedLoadContext(context, contextId);
   logger?.startSection(`Step 3: Import Transactions (${importContext.accountNumber || contextId})`);
   logger?.logStep("Import", "start");
   const importResult = await importStatements(context.directory, context.agent, {
@@ -27907,7 +27997,7 @@ async function executeImportStep(context, contextId, logger) {
     error: importParsed.error
   });
   if (importParsed.success) {
-    updateContext(context.directory, contextId, {
+    cachedUpdateContext(context, contextId, {
       rulesFile: importParsed.files?.[0]?.rulesFile,
       yearJournal: importParsed.files?.[0]?.yearJournal,
       transactionCount: importParsed.summary?.totalTransactions
@@ -27935,7 +28025,7 @@ async function executeImportStep(context, contextId, logger) {
   logger?.endSection();
 }
 async function executeReconcileStep(context, contextId, logger) {
-  const importContext = loadContext(context.directory, contextId);
+  const importContext = cachedLoadContext(context, contextId);
   logger?.startSection(`Step 4: Reconcile Balance (${importContext.accountNumber || contextId})`);
   logger?.logStep("Reconcile", "start");
   const reconcileResult = await reconcileStatement(context.directory, context.agent, {
@@ -27964,7 +28054,7 @@ async function executeReconcileStep(context, contextId, logger) {
     error: reconcileParsed.error
   });
   if (reconcileParsed.success) {
-    updateContext(context.directory, contextId, {
+    cachedUpdateContext(context, contextId, {
       reconciledAccount: reconcileParsed.account,
       actualBalance: reconcileParsed.actualBalance,
       lastTransactionDate: reconcileParsed.lastTransactionDate,
@@ -28011,7 +28101,8 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     configLoader,
     hledgerExecutor,
     result,
-    generatedAccounts: new Set
+    generatedAccounts: new Set,
+    contextCache: new Map
   };
   try {
     const contextIds = await executeClassifyStep(context, logger);
@@ -28026,10 +28117,9 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     await executeSwissquotePreprocessStep(context, contextIds, logger);
     await executeIbkrPreprocessStep(context, contextIds, logger);
     if (context.generatedAccounts.size > 0) {
-      const firstCtx = contextIds.map((id) => loadContext(context.directory, id)).find((c) => c.provider === "revolut");
+      const firstCtx = contextIds.map((id) => cachedLoadContext(context, 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 year = getTransactionYear(firstCtx);
         const yearJournalPath = ensureYearJournalExists(context.directory, year);
         const declResult = ensureAccountDeclarations(yearJournalPath, context.generatedAccounts);
         if (declResult.added.length > 0) {
@@ -28037,12 +28127,12 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
         }
       }
     }
-    const importConfig = loadImportConfig(context.directory);
+    const importConfig = context.configLoader(context.directory);
     const pendingDir = path18.join(context.directory, importConfig.paths.pending);
     const doneDir = path18.join(context.directory, importConfig.paths.done);
     const orderedContextIds = [...contextIds].sort((a, b) => {
-      const ctxA = loadContext(context.directory, a);
-      const ctxB = loadContext(context.directory, b);
+      const ctxA = cachedLoadContext(context, a);
+      const ctxB = cachedLoadContext(context, b);
       const orderA = importConfig.providers[ctxA.provider]?.importOrder ?? 0;
       const orderB = importConfig.providers[ctxB.provider]?.importOrder ?? 0;
       if (orderA !== orderB)
@@ -28053,7 +28143,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     });
     let totalTransactions = 0;
     for (const contextId of orderedContextIds) {
-      const importContext = loadContext(context.directory, contextId);
+      const importContext = cachedLoadContext(context, contextId);
       logger.info(`Processing: ${importContext.filename} (${importContext.accountNumber || "unknown account"})`);
       try {
         await executeAccountDeclarationsStep(context, contextId, logger);
@@ -28143,17 +28233,137 @@ This tool orchestrates the full import workflow:
     });
   }
 });
-// src/tools/init-directories.ts
-import * as fs25 from "fs";
+// src/tools/generate-btc-purchases.ts
 import * as path19 from "path";
+import * as fs25 from "fs";
+function findFiatCsvPaths(directory, pendingDir, provider) {
+  const providerDir = path19.join(directory, pendingDir, provider);
+  if (!fs25.existsSync(providerDir))
+    return [];
+  const csvPaths = [];
+  const entries = fs25.readdirSync(providerDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "btc")
+      continue;
+    const csvFiles = findCsvFiles(path19.join(providerDir, entry.name), { fullPaths: true });
+    csvPaths.push(...csvFiles);
+  }
+  return csvPaths;
+}
+function findBtcCsvPath(directory, pendingDir, provider) {
+  const btcDir = path19.join(directory, pendingDir, provider, "btc");
+  const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
+  return csvFiles[0];
+}
+function determineYear(csvPaths) {
+  for (const csvPath of csvPaths) {
+    const match2 = path19.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
+    if (match2)
+      return parseInt(match2[1], 10);
+  }
+  return new Date().getFullYear();
+}
+async function generateBtcPurchases(directory, agent, options = {}, configLoader = loadImportConfig) {
+  const restrictionError = checkAccountantAgent(agent, "generate BTC purchases");
+  if (restrictionError)
+    return restrictionError;
+  const logger = createImportLogger(directory, undefined, "btc-purchases");
+  try {
+    logger.startSection("Generate BTC Purchase Entries", 1);
+    let config2;
+    try {
+      config2 = configLoader(directory);
+    } catch (err) {
+      return buildToolErrorResult(err instanceof Error ? err.message : String(err));
+    }
+    const provider = options.provider || "revolut";
+    const fiatCsvPaths = findFiatCsvPaths(directory, config2.paths.pending, provider);
+    if (fiatCsvPaths.length === 0) {
+      logger.info("No fiat CSV files found in pending directories");
+      return buildToolSuccessResult({
+        message: "No fiat CSV files found in pending directories",
+        matchCount: 0,
+        entriesAdded: 0
+      });
+    }
+    logger.info(`Found ${fiatCsvPaths.length} fiat CSV file(s)`);
+    const btcCsvPath = findBtcCsvPath(directory, config2.paths.pending, provider);
+    if (!btcCsvPath) {
+      logger.info("No BTC CSV file found in pending btc directory");
+      return buildToolSuccessResult({
+        message: "No BTC CSV file found in pending btc directory",
+        matchCount: 0,
+        entriesAdded: 0
+      });
+    }
+    logger.info(`Found BTC CSV: ${btcCsvPath}`);
+    const allCsvPaths = [...fiatCsvPaths, btcCsvPath];
+    const year = determineYear(allCsvPaths);
+    const yearJournalPath = ensureYearJournalExists(directory, year);
+    logger.info(`Year journal: ${yearJournalPath}`);
+    const result = generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, logger);
+    logger.logStep("Generate BTC Purchases", "success", `${result.entriesAdded} entries added`);
+    logger.endSection();
+    return buildToolSuccessResult({
+      matchCount: result.matchCount,
+      entriesAdded: result.entriesAdded,
+      skippedDuplicates: result.skippedDuplicates,
+      unmatchedFiat: result.unmatchedFiat.length,
+      unmatchedBtc: result.unmatchedBtc.length,
+      yearJournal: path19.relative(directory, yearJournalPath)
+    });
+  } catch (err) {
+    logger.error("Failed to generate BTC purchases", err);
+    return buildToolErrorResult(err instanceof Error ? err.message : String(err));
+  } finally {
+    logger.endSection();
+    await logger.flush();
+  }
+}
+var generate_btc_purchases_default = tool({
+  description: `ACCOUNTANT AGENT ONLY: Generate BTC purchase journal entries from Revolut CSVs.
+
+Cross-references Revolut fiat account CSVs (CHF/EUR/USD) with BTC crypto CSV
+to produce equity conversion entries for Bitcoin purchases.
+
+**What it does:**
+- Scans pending directories for fiat and BTC CSV files
+- Matches fiat "Transfer to Digital Assets" rows with BTC "Buy" rows by timestamp
+- Handles REVX_TRANSFER \u2192 Other \u2192 Buy multi-step purchase flows
+- Generates hledger journal entries with equity conversion postings
+- Deduplicates to prevent double entries on re-run
+- Appends entries to the year journal
+
+**Prerequisites:**
+- CSV files must be classified (in import/pending/revolut/{currency}/)
+- hledger rules files should have skip directives for BTC-related rows
+
+**Usage:**
+- generate-btc-purchases (scans revolut pending dirs)
+- generate-btc-purchases --provider revolut`,
+  args: {
+    provider: tool.schema.string().optional().describe('Provider name (default: "revolut")')
+  },
+  async execute(params, context) {
+    const { directory, agent } = context;
+    return generateBtcPurchases(directory, agent, {
+      provider: params.provider
+    });
+  }
+});
+// src/tools/init-directories.ts
+import * as fs26 from "fs";
+import * as path20 from "path";
 async function initDirectories(directory) {
   try {
     const config2 = loadImportConfig(directory);
     const directoriesCreated = [];
     const gitkeepFiles = [];
-    const importBase = path19.join(directory, "import");
-    if (!fs25.existsSync(importBase)) {
-      fs25.mkdirSync(importBase, { recursive: true });
+    const importBase = path20.join(directory, "import");
+    if (!fs26.existsSync(importBase)) {
+      fs26.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -28163,20 +28373,20 @@ async function initDirectories(directory) {
       { key: "unrecognized", path: config2.paths.unrecognized }
     ];
     for (const { path: dirPath } of pathsToCreate) {
-      const fullPath = path19.join(directory, dirPath);
-      if (!fs25.existsSync(fullPath)) {
-        fs25.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path20.join(directory, dirPath);
+      if (!fs26.existsSync(fullPath)) {
+        fs26.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
-      const gitkeepPath = path19.join(fullPath, ".gitkeep");
-      if (!fs25.existsSync(gitkeepPath)) {
-        fs25.writeFileSync(gitkeepPath, "");
-        gitkeepFiles.push(path19.join(dirPath, ".gitkeep"));
+      const gitkeepPath = path20.join(fullPath, ".gitkeep");
+      if (!fs26.existsSync(gitkeepPath)) {
+        fs26.writeFileSync(gitkeepPath, "");
+        gitkeepFiles.push(path20.join(dirPath, ".gitkeep"));
       }
     }
-    const gitignorePath = path19.join(importBase, ".gitignore");
+    const gitignorePath = path20.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs25.existsSync(gitignorePath)) {
+    if (!fs26.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -28194,7 +28404,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs25.writeFileSync(gitignorePath, gitignoreContent);
+      fs26.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -28269,126 +28479,7 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
 `);
   }
 });
-// src/tools/generate-btc-purchases.ts
-import * as path20 from "path";
-import * as fs26 from "fs";
-function findFiatCsvPaths(directory, pendingDir, provider) {
-  const providerDir = path20.join(directory, pendingDir, provider);
-  if (!fs26.existsSync(providerDir))
-    return [];
-  const csvPaths = [];
-  const entries = fs26.readdirSync(providerDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    if (entry.name === "btc")
-      continue;
-    const csvFiles = findCsvFiles(path20.join(providerDir, entry.name), { fullPaths: true });
-    csvPaths.push(...csvFiles);
-  }
-  return csvPaths;
-}
-function findBtcCsvPath(directory, pendingDir, provider) {
-  const btcDir = path20.join(directory, pendingDir, provider, "btc");
-  const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
-  return csvFiles[0];
-}
-function determineYear(csvPaths) {
-  for (const csvPath of csvPaths) {
-    const match2 = path20.basename(csvPath).match(/(\d{4})-\d{2}-\d{2}/);
-    if (match2)
-      return parseInt(match2[1], 10);
-  }
-  return new Date().getFullYear();
-}
-async function generateBtcPurchases(directory, agent, options = {}, configLoader = loadImportConfig) {
-  const restrictionError = checkAccountantAgent(agent, "generate BTC purchases");
-  if (restrictionError)
-    return restrictionError;
-  const logger = createImportLogger(directory, undefined, "btc-purchases");
-  try {
-    logger.startSection("Generate BTC Purchase Entries", 1);
-    let config2;
-    try {
-      config2 = configLoader(directory);
-    } catch (err) {
-      return buildToolErrorResult(err instanceof Error ? err.message : String(err));
-    }
-    const provider = options.provider || "revolut";
-    const fiatCsvPaths = findFiatCsvPaths(directory, config2.paths.pending, provider);
-    if (fiatCsvPaths.length === 0) {
-      logger.info("No fiat CSV files found in pending directories");
-      return buildToolSuccessResult({
-        message: "No fiat CSV files found in pending directories",
-        matchCount: 0,
-        entriesAdded: 0
-      });
-    }
-    logger.info(`Found ${fiatCsvPaths.length} fiat CSV file(s)`);
-    const btcCsvPath = findBtcCsvPath(directory, config2.paths.pending, provider);
-    if (!btcCsvPath) {
-      logger.info("No BTC CSV file found in pending btc directory");
-      return buildToolSuccessResult({
-        message: "No BTC CSV file found in pending btc directory",
-        matchCount: 0,
-        entriesAdded: 0
-      });
-    }
-    logger.info(`Found BTC CSV: ${btcCsvPath}`);
-    const allCsvPaths = [...fiatCsvPaths, btcCsvPath];
-    const year = determineYear(allCsvPaths);
-    const yearJournalPath = ensureYearJournalExists(directory, year);
-    logger.info(`Year journal: ${yearJournalPath}`);
-    const result = generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, logger);
-    logger.logStep("Generate BTC Purchases", "success", `${result.entriesAdded} entries added`);
-    logger.endSection();
-    return buildToolSuccessResult({
-      matchCount: result.matchCount,
-      entriesAdded: result.entriesAdded,
-      skippedDuplicates: result.skippedDuplicates,
-      unmatchedFiat: result.unmatchedFiat.length,
-      unmatchedBtc: result.unmatchedBtc.length,
-      yearJournal: path20.relative(directory, yearJournalPath)
-    });
-  } catch (err) {
-    logger.error("Failed to generate BTC purchases", err);
-    return buildToolErrorResult(err instanceof Error ? err.message : String(err));
-  } finally {
-    logger.endSection();
-    await logger.flush();
-  }
-}
-var generate_btc_purchases_default = tool({
-  description: `ACCOUNTANT AGENT ONLY: Generate BTC purchase journal entries from Revolut CSVs.
 
-Cross-references Revolut fiat account CSVs (CHF/EUR/USD) with BTC crypto CSV
-to produce equity conversion entries for Bitcoin purchases.
-
-**What it does:**
-- Scans pending directories for fiat and BTC CSV files
-- Matches fiat "Transfer to Digital Assets" rows with BTC "Buy" rows by timestamp
-- Handles REVX_TRANSFER \u2192 Other \u2192 Buy multi-step purchase flows
-- Generates hledger journal entries with equity conversion postings
-- Deduplicates to prevent double entries on re-run
-- Appends entries to the year journal
-
-**Prerequisites:**
-- CSV files must be classified (in import/pending/revolut/{currency}/)
-- hledger rules files should have skip directives for BTC-related rows
-
-**Usage:**
-- generate-btc-purchases (scans revolut pending dirs)
-- generate-btc-purchases --provider revolut`,
-  args: {
-    provider: tool.schema.string().optional().describe('Provider name (default: "revolut")')
-  },
-  async execute(params, context) {
-    const { directory, agent } = context;
-    return generateBtcPurchases(directory, agent, {
-      provider: params.provider
-    });
-  }
-});
 // src/index.ts
 var __dirname2 = dirname10(fileURLToPath3(import.meta.url));
 var AGENT_FILE = join18(__dirname2, "..", "agent", "accountant.md");
@@ -28401,7 +28492,8 @@ var AccountantPlugin = async () => {
       "import-statements": import_statements_default,
       "reconcile-statements": reconcile_statement_default,
       "import-pipeline": import_pipeline_default,
-      "generate-btc-purchases": generate_btc_purchases_default
+      "generate-btc-purchases": generate_btc_purchases_default,
+      "init-directories": init_directories_default
     },
     config: async (config2) => {
       if (agent) {

package/package.json

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