@fuzzle/opencode-accountant 0.5.6 → 0.6.0-next.1

package/dist/index.js

@@ -4249,7 +4249,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as crypto from "crypto";
 function clearSuggestionCache() {
   Object.keys(suggestionCache).forEach((key) => delete suggestionCache[key]);
@@ -4259,10 +4259,10 @@ function hashTransaction(posting) {
   return crypto.createHash("md5").update(data).digest("hex");
 }
 function loadExistingAccounts(yearJournalPath) {
-  if (!fs14.existsSync(yearJournalPath)) {
+  if (!fs15.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs14.readFileSync(yearJournalPath, "utf-8");
+  const content = fs15.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4278,10 +4278,10 @@ function loadExistingAccounts(yearJournalPath) {
   return accounts.sort();
 }
 function extractRulePatternsFromFile(rulesPath) {
-  if (!fs14.existsSync(rulesPath)) {
+  if (!fs15.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs14.readFileSync(rulesPath, "utf-8");
+  const content = fs15.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -4515,7 +4515,7 @@ var init_accountSuggester = __esm(() => {
 
 // src/index.ts
 init_agentLoader();
-import { dirname as dirname4, join as join12 } from "path";
+import { dirname as dirname4, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // node_modules/zod/v4/classic/external.js
@@ -24351,6 +24351,321 @@ function createImportLogger(directory, worktreeId, provider) {
   return logger;
 }
 
+// src/utils/btcPurchaseGenerator.ts
+import * as fs14 from "fs";
+function parseRevolutFiatDatetime(dateStr) {
+  const [datePart, timePart] = dateStr.split(" ");
+  if (!datePart || !timePart) {
+    throw new Error(`Invalid fiat datetime: ${dateStr}`);
+  }
+  return new Date(`${datePart}T${timePart}`);
+}
+function parseRevolutCryptoDate(dateStr) {
+  const match2 = dateStr.match(/^(\w+)\s+(\d+),\s+(\d{4}),\s+(\d+):(\d+):(\d+)\s+(AM|PM)$/);
+  if (!match2) {
+    throw new Error(`Invalid crypto date: ${dateStr}`);
+  }
+  const [, monthName, day, year, hours, minutes, seconds, ampm] = match2;
+  const months = {
+    Jan: 0,
+    Feb: 1,
+    Mar: 2,
+    Apr: 3,
+    May: 4,
+    Jun: 5,
+    Jul: 6,
+    Aug: 7,
+    Sep: 8,
+    Oct: 9,
+    Nov: 10,
+    Dec: 11
+  };
+  const month = months[monthName];
+  if (month === undefined) {
+    throw new Error(`Unknown month: ${monthName}`);
+  }
+  let hour = parseInt(hours, 10);
+  if (ampm === "PM" && hour !== 12)
+    hour += 12;
+  if (ampm === "AM" && hour === 12)
+    hour = 0;
+  return new Date(parseInt(year, 10), month, parseInt(day, 10), hour, parseInt(minutes, 10), parseInt(seconds, 10));
+}
+function parseBtcPrice(priceStr) {
+  const trimmed = priceStr.trim();
+  if (trimmed.startsWith("\u20AC")) {
+    const numStr2 = trimmed.slice(1).replace(/,/g, "");
+    return { amount: parseFloat(numStr2), currency: "EUR" };
+  }
+  const match2 = trimmed.match(/^([\d,.]+)\s+(\w+)$/);
+  if (!match2) {
+    throw new Error(`Invalid price format: ${priceStr}`);
+  }
+  const numStr = match2[1].replace(/,/g, "");
+  return { amount: parseFloat(numStr), currency: match2[2] };
+}
+function parseBtcAmount(amountStr) {
+  return parseBtcPrice(amountStr);
+}
+function parseFiatTransfers(csvPath) {
+  const content = fs14.readFileSync(csvPath, "utf-8");
+  const lines = content.trim().split(`
+`);
+  if (lines.length < 2)
+    return [];
+  const rows = [];
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const fields = parseSimpleCsvLine(line);
+    if (fields.length < 9)
+      continue;
+    const [type2, , startedDate, , description, amount, , currency] = fields;
+    const isTransfer = type2 === "Exchange" && description === "Transfer to Revolut Digital Assets Europe Ltd" || type2 === "REVX_TRANSFER";
+    if (!isTransfer)
+      continue;
+    const date5 = parseRevolutFiatDatetime(startedDate);
+    const dateIso = formatDateIso(date5);
+    rows.push({
+      type: type2,
+      date: date5,
+      dateStr: dateIso,
+      description,
+      amount: Math.abs(parseFloat(amount)),
+      currency
+    });
+  }
+  return rows;
+}
+function parseBtcRows(csvPath) {
+  const content = fs14.readFileSync(csvPath, "utf-8");
+  const lines = content.trim().split(`
+`);
+  if (lines.length < 2)
+    return [];
+  const rows = [];
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const fields = parseCryptoCsvLine(line);
+    if (fields.length < 7)
+      continue;
+    const [symbol2, type2, quantity, price, value, fees, dateStr] = fields;
+    if (type2 !== "Buy" && type2 !== "Other")
+      continue;
+    const date5 = parseRevolutCryptoDate(dateStr);
+    const dateIso = formatDateIso(date5);
+    if (type2 === "Other") {
+      rows.push({
+        symbol: symbol2,
+        type: type2,
+        quantity: 0,
+        price: { amount: 0, currency: "" },
+        value: parseBtcAmount(value),
+        fees: parseBtcAmount(fees),
+        date: date5,
+        dateStr: dateIso
+      });
+    } else {
+      rows.push({
+        symbol: symbol2,
+        type: type2,
+        quantity: parseFloat(quantity),
+        price: parseBtcPrice(price),
+        value: parseBtcAmount(value),
+        fees: parseBtcAmount(fees),
+        date: date5,
+        dateStr: dateIso
+      });
+    }
+  }
+  return rows;
+}
+function parseSimpleCsvLine(line) {
+  return line.split(",");
+}
+function parseCryptoCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === "," && !inQuotes) {
+      fields.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function matchTransfers(fiatRows, btcRows) {
+  const matches = [];
+  const matchedFiatIndices = new Set;
+  const matchedBtcIndices = new Set;
+  for (let fi = 0;fi < fiatRows.length; fi++) {
+    const fiat = fiatRows[fi];
+    if (fiat.type !== "Exchange")
+      continue;
+    for (let bi = 0;bi < btcRows.length; bi++) {
+      if (matchedBtcIndices.has(bi))
+        continue;
+      const btc = btcRows[bi];
+      if (btc.type !== "Buy")
+        continue;
+      if (datesMatchToSecond(fiat.date, btc.date)) {
+        matches.push({ fiatRow: fiat, btcRow: btc });
+        matchedFiatIndices.add(fi);
+        matchedBtcIndices.add(bi);
+        break;
+      }
+    }
+  }
+  for (let fi = 0;fi < fiatRows.length; fi++) {
+    if (matchedFiatIndices.has(fi))
+      continue;
+    const fiat = fiatRows[fi];
+    if (fiat.type !== "REVX_TRANSFER")
+      continue;
+    for (let bi = 0;bi < btcRows.length; bi++) {
+      if (matchedBtcIndices.has(bi))
+        continue;
+      const other = btcRows[bi];
+      if (other.type !== "Other")
+        continue;
+      if (!datesMatchToSecond(fiat.date, other.date))
+        continue;
+      for (let bj = 0;bj < btcRows.length; bj++) {
+        if (matchedBtcIndices.has(bj))
+          continue;
+        const buy = btcRows[bj];
+        if (buy.type !== "Buy")
+          continue;
+        const timeDiff = Math.abs(buy.date.getTime() - other.date.getTime()) / 1000;
+        if (timeDiff > 120)
+          continue;
+        if (Math.abs(buy.value.amount - fiat.amount) < 0.01) {
+          matches.push({ fiatRow: fiat, btcRow: buy });
+          matchedFiatIndices.add(fi);
+          matchedBtcIndices.add(bi);
+          matchedBtcIndices.add(bj);
+          break;
+        }
+      }
+      break;
+    }
+  }
+  const unmatchedFiat = fiatRows.filter((_, i2) => !matchedFiatIndices.has(i2));
+  const unmatchedBtc = btcRows.filter((_, i2) => !matchedBtcIndices.has(i2));
+  return { matches, unmatchedFiat, unmatchedBtc };
+}
+function datesMatchToSecond(a, b) {
+  return Math.abs(a.getTime() - b.getTime()) < 1000;
+}
+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 lines = [
+    `${date5} Bitcoin purchase`,
+    `    assets:bank:revolut:${fiatCurrency.toLowerCase()}    -${fiatAmount} ${fiatCurrency}`,
+    `    equity:bitcoin:conversion   ${fiatAmount} ${fiatCurrency}`,
+    `    equity:bitcoin:conversion  -${btcQuantity} BTC  @  ${btcPrice} ${priceCurrency}`,
+    `    assets:bank:revolut:btc     ${btcQuantity} BTC  @  ${btcPrice} ${priceCurrency}`
+  ];
+  if (hasFees) {
+    const feeAmount = formatAmount(btcRow.fees.amount);
+    const feeCurrency = btcRow.fees.currency;
+    lines.push(`    expenses:fees:bitcoin       ${feeAmount} ${feeCurrency}`, `    equity:bitcoin:conversion  -${feeAmount} ${feeCurrency}`);
+  }
+  return lines.join(`
+`);
+}
+function formatAmount(amount) {
+  return amount.toFixed(2);
+}
+function formatBtcQuantity(quantity) {
+  const str2 = quantity.toFixed(8);
+  return str2;
+}
+function formatDateIso(date5) {
+  const y = date5.getFullYear();
+  const m = String(date5.getMonth() + 1).padStart(2, "0");
+  const d = String(date5.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function isDuplicate(match2, journalContent) {
+  const date5 = match2.fiatRow.dateStr;
+  const amount = formatAmount(match2.fiatRow.amount);
+  const currency = match2.fiatRow.currency;
+  const pattern = `${date5} Bitcoin purchase`;
+  if (!journalContent.includes(pattern))
+    return false;
+  const amountPattern = `-${amount} ${currency}`;
+  const idx = journalContent.indexOf(pattern);
+  const chunk = journalContent.slice(idx, idx + 500);
+  return chunk.includes(amountPattern);
+}
+function generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, logger) {
+  logger?.info("Parsing BTC crypto CSV...");
+  const allBtcRows = parseBtcRows(btcCsvPath);
+  logger?.info(`Found ${allBtcRows.length} Buy/Other rows in BTC CSV`);
+  logger?.info("Parsing fiat CSVs...");
+  const allFiatRows = [];
+  for (const csvPath of fiatCsvPaths) {
+    const fiatRows = parseFiatTransfers(csvPath);
+    logger?.info(`Found ${fiatRows.length} BTC transfer rows in ${csvPath}`);
+    allFiatRows.push(...fiatRows);
+  }
+  logger?.info("Matching fiat transfers to BTC purchases...");
+  const { matches, unmatchedFiat, unmatchedBtc } = matchTransfers(allFiatRows, allBtcRows);
+  logger?.info(`Matched ${matches.length} BTC purchases`);
+  if (unmatchedFiat.length > 0) {
+    logger?.warn(`${unmatchedFiat.length} unmatched fiat transfer(s)`);
+  }
+  if (unmatchedBtc.length > 0) {
+    logger?.info(`${unmatchedBtc.length} unmatched BTC row(s) (may be Send, or non-fiat)`);
+  }
+  let journalContent = "";
+  if (fs14.existsSync(yearJournalPath)) {
+    journalContent = fs14.readFileSync(yearJournalPath, "utf-8");
+  }
+  const newEntries = [];
+  let skippedDuplicates = 0;
+  const sortedMatches = [...matches].sort((a, b) => a.fiatRow.date.getTime() - b.fiatRow.date.getTime());
+  for (const match2 of sortedMatches) {
+    if (isDuplicate(match2, journalContent)) {
+      skippedDuplicates++;
+      logger?.debug(`Skipping duplicate: ${match2.fiatRow.dateStr} ${formatAmount(match2.fiatRow.amount)} ${match2.fiatRow.currency}`);
+      continue;
+    }
+    newEntries.push(formatJournalEntry(match2));
+  }
+  if (newEntries.length > 0) {
+    const appendContent = `
+` + newEntries.join(`
+
+`) + `
+`;
+    fs14.appendFileSync(yearJournalPath, appendContent);
+    logger?.info(`Appended ${newEntries.length} new BTC purchase entries to ${yearJournalPath}`);
+  } else {
+    logger?.info("No new BTC purchase entries to add");
+  }
+  return {
+    matchCount: matches.length,
+    entriesAdded: newEntries.length,
+    skippedDuplicates,
+    unmatchedFiat,
+    unmatchedBtc
+  };
+}
+
 // src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
@@ -24418,6 +24733,42 @@ async function executeClassifyStep(context, logger) {
   logger?.endSection();
   return contextIds;
 }
+async function executeBtcPurchaseStep(context, contextIds, logger) {
+  const fiatCsvPaths = [];
+  let btcCsvPath;
+  for (const contextId of contextIds) {
+    const importCtx = loadContext(context.directory, contextId);
+    if (importCtx.provider !== "revolut")
+      continue;
+    const csvPath = path12.join(context.directory, importCtx.filePath);
+    if (importCtx.currency === "btc") {
+      btcCsvPath = csvPath;
+    } else {
+      fiatCsvPaths.push(csvPath);
+    }
+  }
+  if (!btcCsvPath || fiatCsvPaths.length === 0) {
+    logger?.info("No revolut fiat+btc CSV pair found, skipping BTC purchase generation");
+    return;
+  }
+  logger?.startSection("Step 1b: Generate BTC Purchase Entries");
+  logger?.logStep("BTC Purchases", "start");
+  const btcFilename = path12.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);
+  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
+  });
+}
 async function executeAccountDeclarationsStep(context, contextId, logger) {
   logger?.startSection("Step 2: Check Account Declarations");
   logger?.logStep("Check Accounts", "start");
@@ -24726,6 +25077,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
       logger.info("No files classified, nothing to import");
       return buildPipelineSuccessResult(result, "No files to import");
     }
+    await executeBtcPurchaseStep(context, contextIds, logger);
     let totalTransactions = 0;
     for (const contextId of contextIds) {
       const importContext = loadContext(context.directory, contextId);
@@ -24806,7 +25158,7 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -24814,8 +25166,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs15.existsSync(importBase)) {
-      fs15.mkdirSync(importBase, { recursive: true });
+    if (!fs16.existsSync(importBase)) {
+      fs16.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -24826,19 +25178,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs15.existsSync(fullPath)) {
-        fs15.mkdirSync(fullPath, { recursive: true });
+      if (!fs16.existsSync(fullPath)) {
+        fs16.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs15.existsSync(gitkeepPath)) {
-        fs15.writeFileSync(gitkeepPath, "");
+      if (!fs16.existsSync(gitkeepPath)) {
+        fs16.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs15.existsSync(gitignorePath)) {
+    if (!fs16.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -24856,7 +25208,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs15.writeFileSync(gitignorePath, gitignoreContent);
+      fs16.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -24931,9 +25283,129 @@ You can now drop CSV files into import/incoming/ and run import-pipeline.`);
 `);
   }
 });
+// src/tools/generate-btc-purchases.ts
+import * as path14 from "path";
+import * as fs17 from "fs";
+function findFiatCsvPaths(directory, pendingDir, provider) {
+  const providerDir = path14.join(directory, pendingDir, provider);
+  if (!fs17.existsSync(providerDir))
+    return [];
+  const csvPaths = [];
+  const entries = fs17.readdirSync(providerDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "btc")
+      continue;
+    const csvFiles = findCsvFiles(path14.join(providerDir, entry.name), { fullPaths: true });
+    csvPaths.push(...csvFiles);
+  }
+  return csvPaths;
+}
+function findBtcCsvPath(directory, pendingDir, provider) {
+  const btcDir = path14.join(directory, pendingDir, provider, "btc");
+  const csvFiles = findCsvFiles(btcDir, { fullPaths: true });
+  return csvFiles[0];
+}
+function determineYear(csvPaths) {
+  for (const csvPath of csvPaths) {
+    const match2 = path14.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: path14.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 = dirname4(fileURLToPath3(import.meta.url));
-var AGENT_FILE = join12(__dirname2, "..", "agent", "accountant.md");
+var AGENT_FILE = join13(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
@@ -24942,7 +25414,8 @@ var AccountantPlugin = async () => {
       "classify-statements": classify_statements_default,
       "import-statements": import_statements_default,
       "reconcile-statements": reconcile_statement_default,
-      "import-pipeline": import_pipeline_default
+      "import-pipeline": import_pipeline_default,
+      "generate-btc-purchases": generate_btc_purchases_default
     },
     config: async (config2) => {
       if (agent) {

package/package.json

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