@fuzzle/opencode-accountant 0.6.1 → 0.7.0-next.1

package/dist/index.js

@@ -4249,7 +4249,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs15 from "fs";
+import * as fs16 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 (!fs15.existsSync(yearJournalPath)) {
+  if (!fs16.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs15.readFileSync(yearJournalPath, "utf-8");
+  const content = fs16.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4278,10 +4278,10 @@ function loadExistingAccounts(yearJournalPath) {
   return accounts.sort();
 }
 function extractRulePatternsFromFile(rulesPath) {
-  if (!fs15.existsSync(rulesPath)) {
+  if (!fs16.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs15.readFileSync(rulesPath, "utf-8");
+  const content = fs16.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -17272,6 +17272,11 @@ function validateDetectionRule(providerName, index, rule) {
       }
     }
   }
+  if (ruleObj.closingBalanceField !== undefined) {
+    if (typeof ruleObj.closingBalanceField !== "string" || ruleObj.closingBalanceField === "") {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].closingBalanceField must be a non-empty string`);
+    }
+  }
   return {
     filenamePattern: ruleObj.filenamePattern,
     header: ruleObj.header,
@@ -17279,7 +17284,8 @@ function validateDetectionRule(providerName, index, rule) {
     skipRows: ruleObj.skipRows,
     delimiter: ruleObj.delimiter,
     renamePattern: ruleObj.renamePattern,
-    metadata: ruleObj.metadata
+    metadata: ruleObj.metadata,
+    closingBalanceField: ruleObj.closingBalanceField
   };
 }
 function validateProviderConfig(name, config2) {
@@ -17386,6 +17392,25 @@ function parseCSVPreview(content, skipRows = 0, delimiter = ",") {
     firstRow: result.data[0]
   };
 }
+function extractLastRowField(content, skipRows, delimiter, fieldName) {
+  let csvContent = content;
+  if (skipRows > 0) {
+    const lines = content.split(`
+`);
+    csvContent = lines.slice(skipRows).join(`
+`);
+  }
+  const result = import_papaparse.default.parse(csvContent, {
+    header: true,
+    skipEmptyLines: true,
+    delimiter
+  });
+  if (result.data.length === 0)
+    return;
+  const lastRow = result.data[result.data.length - 1];
+  const value = lastRow[fieldName];
+  return value ? value.trim() : undefined;
+}
 function normalizeHeader(fields) {
   return fields.map((f) => f.trim()).join(",");
 }
@@ -17416,6 +17441,12 @@ function detectProvider(filename, content, config2) {
         continue;
       }
       const metadata = extractMetadata(content, skipRows, delimiter, rule.metadata);
+      if (rule.closingBalanceField) {
+        const closingBalance = extractLastRowField(content, skipRows, delimiter, rule.closingBalanceField);
+        if (closingBalance) {
+          metadata["closing-balance"] = closingBalance;
+        }
+      }
       const outputFilename = generateOutputFilename(rule.renamePattern, metadata);
       const normalizedCurrency = providerConfig.currencies[rawCurrency];
       if (!normalizedCurrency) {
@@ -24581,7 +24612,7 @@ function formatJournalEntry(match2) {
   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}`);
+    lines.push(`    expenses:fees:btc       ${feeAmount} ${feeCurrency}`, `    equity:bitcoin:conversion  -${feeAmount} ${feeCurrency}`);
   }
   return lines.join(`
 `);
@@ -24666,6 +24697,80 @@ function generateBtcPurchaseJournal(fiatCsvPaths, btcCsvPath, yearJournalPath, l
   };
 }
 
+// src/utils/btcCsvPreprocessor.ts
+import * as fs15 from "fs";
+var ORIGINAL_HEADER = "Symbol,Type,Quantity,Price,Value,Fees,Date";
+var PREPROCESSED_HEADER = "Symbol,Type,Quantity,Price,Value,Fees,Date,Fees_BTC,Total_BTC,Price_Amount";
+var FEE_BTC_DECIMALS = 8;
+function calculateFeeBtc(fees, price) {
+  if (price.amount === 0)
+    return 0;
+  return fees.amount / price.amount;
+}
+function formatPriceAmount(price) {
+  return `${price.amount} ${price.currency}`;
+}
+function preprocessRevolutBtcCsv(csvPath, logger) {
+  const content = fs15.readFileSync(csvPath, "utf-8");
+  const lines = content.trim().split(`
+`);
+  if (lines.length < 2) {
+    return { rowsProcessed: 0, sendRowsEnriched: 0, alreadyPreprocessed: false };
+  }
+  const header = lines[0].trim();
+  if (header === PREPROCESSED_HEADER) {
+    logger?.info("CSV already preprocessed, skipping");
+    return { rowsProcessed: lines.length - 1, sendRowsEnriched: 0, alreadyPreprocessed: true };
+  }
+  if (header !== ORIGINAL_HEADER) {
+    throw new Error(`Unexpected CSV header. Expected:
+  ${ORIGINAL_HEADER}
+Got:
+  ${header}`);
+  }
+  const outputLines = [PREPROCESSED_HEADER];
+  let sendRowsEnriched = 0;
+  for (let i2 = 1;i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (line.trim() === "")
+      continue;
+    const fields = parseCryptoCsvLine(line);
+    if (fields.length < 7) {
+      outputLines.push(line + ",,,");
+      continue;
+    }
+    const type2 = fields[1];
+    const quantityStr = fields[2];
+    const priceStr = fields[3];
+    const feesStr = fields[5];
+    let feesBtc = "";
+    let totalBtc = "";
+    let priceAmount = "";
+    try {
+      const price = parseBtcPrice(priceStr);
+      priceAmount = formatPriceAmount(price);
+      if (type2 === "Send") {
+        const fees = parseBtcPrice(feesStr);
+        const feeBtc = calculateFeeBtc(fees, price);
+        const quantity = parseFloat(quantityStr);
+        feesBtc = feeBtc.toFixed(FEE_BTC_DECIMALS);
+        totalBtc = (quantity + feeBtc).toFixed(FEE_BTC_DECIMALS);
+        sendRowsEnriched++;
+      }
+    } catch {
+      logger?.debug(`Row ${i2}: could not parse price/fees, leaving computed columns empty`);
+    }
+    outputLines.push(`${line},${feesBtc},${totalBtc},${priceAmount}`);
+  }
+  const outputContent = outputLines.join(`
+`) + `
+`;
+  fs15.writeFileSync(csvPath, outputContent);
+  const rowsProcessed = outputLines.length - 1;
+  logger?.info(`Preprocessed ${rowsProcessed} rows (${sendRowsEnriched} Send rows enriched)`);
+  return { rowsProcessed, sendRowsEnriched, alreadyPreprocessed: false };
+}
+
 // src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
@@ -24733,6 +24838,38 @@ async function executeClassifyStep(context, logger) {
   logger?.endSection();
   return contextIds;
 }
+function executePreprocessBtcStep(context, contextIds, logger) {
+  let btcCsvPath;
+  for (const contextId of contextIds) {
+    const importCtx = loadContext(context.directory, contextId);
+    if (importCtx.provider === "revolut" && importCtx.currency === "btc") {
+      btcCsvPath = path12.join(context.directory, importCtx.filePath);
+      break;
+    }
+  }
+  if (!btcCsvPath) {
+    logger?.info("No revolut BTC CSV found, skipping preprocessing");
+    return;
+  }
+  logger?.startSection("Step 1a: Preprocess BTC CSV");
+  logger?.logStep("BTC Preprocess", "start");
+  try {
+    const result = preprocessRevolutBtcCsv(btcCsvPath, logger);
+    const message = result.alreadyPreprocessed ? "BTC CSV already preprocessed" : `Preprocessed ${result.rowsProcessed} rows (${result.sendRowsEnriched} Send rows enriched)`;
+    logger?.logStep("BTC Preprocess", "success", message);
+    context.result.steps.btcPreprocess = buildStepResult(true, message, result);
+  } catch (error45) {
+    const errorMessage = `BTC CSV preprocessing failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    logger?.error(errorMessage);
+    logger?.logStep("BTC Preprocess", "error", errorMessage);
+    context.result.steps.btcPreprocess = buildStepResult(false, errorMessage);
+    context.result.error = errorMessage;
+    context.result.hint = "Check the BTC CSV format \u2014 expected Revolut crypto account statement";
+    throw new Error(errorMessage);
+  } finally {
+    logger?.endSection();
+  }
+}
 async function executeBtcPurchaseStep(context, contextIds, logger) {
   const fiatCsvPaths = [];
   let btcCsvPath;
@@ -25077,6 +25214,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
       logger.info("No files classified, nothing to import");
       return buildPipelineSuccessResult(result, "No files to import");
     }
+    executePreprocessBtcStep(context, contextIds, logger);
     await executeBtcPurchaseStep(context, contextIds, logger);
     let totalTransactions = 0;
     for (const contextId of contextIds) {
@@ -25158,7 +25296,7 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -25166,8 +25304,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs16.existsSync(importBase)) {
-      fs16.mkdirSync(importBase, { recursive: true });
+    if (!fs17.existsSync(importBase)) {
+      fs17.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25178,19 +25316,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs16.existsSync(fullPath)) {
-        fs16.mkdirSync(fullPath, { recursive: true });
+      if (!fs17.existsSync(fullPath)) {
+        fs17.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs16.existsSync(gitkeepPath)) {
-        fs16.writeFileSync(gitkeepPath, "");
+      if (!fs17.existsSync(gitkeepPath)) {
+        fs17.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs16.existsSync(gitignorePath)) {
+    if (!fs17.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -25208,7 +25346,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs16.writeFileSync(gitignorePath, gitignoreContent);
+      fs17.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];
@@ -25285,13 +25423,13 @@ 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";
+import * as fs18 from "fs";
 function findFiatCsvPaths(directory, pendingDir, provider) {
   const providerDir = path14.join(directory, pendingDir, provider);
-  if (!fs17.existsSync(providerDir))
+  if (!fs18.existsSync(providerDir))
     return [];
   const csvPaths = [];
-  const entries = fs17.readdirSync(providerDir, { withFileTypes: true });
+  const entries = fs18.readdirSync(providerDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;

package/docs/tools/import-pipeline.md

@@ -6,14 +6,18 @@ This tool is **restricted to the accountant agent only**.
 
 ## Overview
 
-The pipeline automates five sequential steps:
+The pipeline automates these sequential steps:
 
 1. **Classify** - Detect provider/currency, create contexts, organize files
+1a. **Preprocess BTC CSV** _(Revolut only)_ - Add computed columns (fees in BTC, total, clean price) for hledger rules
+1b. **Generate BTC Purchases** _(Revolut only)_ - Cross-reference fiat + BTC CSVs for equity conversion entries
 2. **Account Declarations** - Ensure all accounts exist in year journals
 3. **Dry Run** - Validate transactions, check for unknown accounts
 4. **Import** - Add transactions to journals, move files to done
 5. **Reconcile** - Verify balances match expectations
 
+Steps 1a and 1b are Revolut-specific and are automatically skipped when no Revolut BTC CSV is present.
+
 **Key behavior**: The pipeline processes files via **import contexts**. Each classified CSV gets a unique context ID, and subsequent steps operate on these contexts **sequentially** with **fail-fast** error handling.
 
 ## Arguments
@@ -156,6 +160,34 @@ When reconciliation fails:
 
 See [classify-statements](classify-statements.md) for details.
 
+### Step 1a: Preprocess BTC CSV
+
+**Purpose**: Add computed columns to Revolut BTC CSVs for use in hledger rules
+
+**What happens**:
+
+1. Finds Revolut BTC contexts from classification
+2. For each Send row, calculates: `fee_btc = fees_chf / price_chf_per_btc`
+3. Adds three columns to the CSV (in-place): `Fees_BTC`, `Total_BTC`, `Price_Amount`
+4. Idempotent — skips if CSV is already preprocessed
+
+**Why**: hledger CSV rules don't support division. BTC Send transactions need the fee split into a separate BTC amount, which requires dividing the CHF fee by the CHF/BTC price.
+
+**Skipped when**: No Revolut BTC CSV is present among the classified files.
+
+### Step 1b: Generate BTC Purchase Entries
+
+**Purpose**: Cross-reference Revolut fiat and BTC CSVs to generate equity conversion journal entries for BTC purchases
+
+**What happens**:
+
+1. Finds matching Revolut fiat and BTC CSV pairs from contexts
+2. Matches fiat transfer rows to BTC Buy rows by timestamp
+3. Generates equity conversion journal entries (fiat → equity → BTC)
+4. Appends entries to year journal, skipping duplicates
+
+**Skipped when**: No fiat+BTC CSV pair is found among the classified files.
+
 ### Step 2: Account Declarations
 
 **Purpose**: Ensure all accounts referenced in rules files are declared in year journals
@@ -262,6 +294,19 @@ See [reconcile-statement](reconcile-statement.md) for details.
 │  └──────────────────────────────────────────────────────────┘ │
 │                                                                 │
 │  OUTPUT: ["uuid-1", "uuid-2"]                                 │
+└────────────────────────────────────────────────────────────────┘
+                            │
+                            ▼
+┌────────────────────────────────────────────────────────────────┐
+│  STEP 1a: Preprocess BTC CSV (if revolut/btc context exists)  │
+│  • Add Fees_BTC, Total_BTC, Price_Amount columns              │
+└────────────────────────────────────────────────────────────────┘
+                            │
+                            ▼
+┌────────────────────────────────────────────────────────────────┐
+│  STEP 1b: Generate BTC Purchase Entries                        │
+│  • Cross-reference fiat + BTC CSVs                             │
+│  • Generate equity conversion journal entries                  │
 └────────────────────────────────────────────────────────────────┘
                             │
                             ▼

package/package.json

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