@fuzzle/opencode-accountant 0.0.7-next.1 → 0.0.8

package/README.md

@@ -93,10 +93,10 @@ The `classify-statements` tool classifies bank statement CSV files by provider a
 
 ```yaml
 paths:
-  imports: statements/imports
+  import: statements/import
   pending: doc/agent/todo/import
   done: doc/agent/done/import
-  unrecognized: statements/imports/unrecognized
+  unrecognized: statements/import/unrecognized
 
 providers:
   revolut:
@@ -112,6 +112,23 @@ providers:
       EUR: eur
       USD: usd
       BTC: btc
+
+  ubs:
+    detect:
+      - header: 'Trade date,Trade time,Booking date,Value date,Currency,Debit,Credit,Individual amount,Balance,Transaction no.,Description1,Description2,Description3,Footnotes'
+        currencyField: Currency
+        skipRows: 9
+        delimiter: ';'
+        renamePattern: 'transactions-ubs-{accountnumber}.csv'
+        metadata:
+          - field: accountnumber
+            row: 0
+            column: 1
+            normalize: spaces-to-dashes
+    currencies:
+      CHF: chf
+      EUR: eur
+      USD: usd
 ```
 
 #### Configuration Options
@@ -120,19 +137,32 @@ providers:
 
 | Field          | Description                                     |
 | -------------- | ----------------------------------------------- |
-| `imports`      | Drop zone for new CSV files                     |
+| `import`       | Drop zone for new CSV files                     |
 | `pending`      | Base path for classified files awaiting import  |
 | `done`         | Base path for archived files after import       |
 | `unrecognized` | Directory for files that couldn't be classified |
 
 **Provider Detection Rules:**
 
-| Field             | Description                                           |
-| ----------------- | ----------------------------------------------------- |
-| `filenamePattern` | Regex pattern to match against filename               |
-| `header`          | Expected CSV header row (exact match)                 |
-| `currencyField`   | Column name containing the currency/symbol            |
-| `currencies`      | Map of raw currency values to normalized folder names |
+| Field             | Required | Description                                                |
+| ----------------- | -------- | ---------------------------------------------------------- |
+| `filenamePattern` | No       | Regex pattern to match against filename                    |
+| `header`          | Yes      | Expected CSV header row (exact match)                      |
+| `currencyField`   | Yes      | Column name containing the currency/symbol                 |
+| `skipRows`        | No       | Number of rows to skip before header (default: 0)          |
+| `delimiter`       | No       | CSV delimiter character (default: `,`)                     |
+| `renamePattern`   | No       | Output filename pattern with `{placeholder}` substitutions |
+| `metadata`        | No       | Array of metadata extraction rules (see below)             |
+| `currencies`      | Yes      | Map of raw currency values to normalized folder names      |
+
+**Metadata Extraction Rules:**
+
+| Field       | Required | Description                                             |
+| ----------- | -------- | ------------------------------------------------------- |
+| `field`     | Yes      | Placeholder name to use in `renamePattern`              |
+| `row`       | Yes      | Row index within `skipRows` to extract from (0-indexed) |
+| `column`    | Yes      | Column index to extract from (0-indexed)                |
+| `normalize` | No       | Normalization type: `spaces-to-dashes`                  |
 
 #### Directory Structure
 

package/dist/index.js

@@ -16584,12 +16584,8 @@ import * as fs4 from "fs";
 import * as fs3 from "fs";
 import * as path3 from "path";
 var CONFIG_FILE2 = "config/import/providers.yaml";
-var REQUIRED_PATH_FIELDS = ["imports", "pending", "done", "unrecognized"];
-var REQUIRED_DETECTION_FIELDS = [
-  "filenamePattern",
-  "header",
-  "currencyField"
-];
+var REQUIRED_PATH_FIELDS = ["import", "pending", "done", "unrecognized"];
+var REQUIRED_DETECTION_FIELDS = ["header", "currencyField"];
 function validatePaths(paths) {
   if (typeof paths !== "object" || paths === null) {
     throw new Error("Invalid config: 'paths' must be an object");
@@ -16601,7 +16597,7 @@ function validatePaths(paths) {
     }
   }
   return {
-    imports: pathsObj.imports,
+    import: pathsObj.import,
     pending: pathsObj.pending,
     done: pathsObj.done,
     unrecognized: pathsObj.unrecognized
@@ -16617,15 +16613,59 @@ function validateDetectionRule(providerName, index, rule) {
       throw new Error(`Invalid config: provider '${providerName}' detect[${index}].${field} is required`);
     }
   }
-  try {
-    new RegExp(ruleObj.filenamePattern);
-  } catch {
-    throw new Error(`Invalid config: provider '${providerName}' detect[${index}].filenamePattern is not a valid regex`);
+  if (ruleObj.filenamePattern !== undefined) {
+    if (typeof ruleObj.filenamePattern !== "string") {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].filenamePattern must be a string`);
+    }
+    try {
+      new RegExp(ruleObj.filenamePattern);
+    } catch {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].filenamePattern is not a valid regex`);
+    }
+  }
+  if (ruleObj.skipRows !== undefined) {
+    if (typeof ruleObj.skipRows !== "number" || ruleObj.skipRows < 0) {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].skipRows must be a non-negative number`);
+    }
+  }
+  if (ruleObj.delimiter !== undefined) {
+    if (typeof ruleObj.delimiter !== "string" || ruleObj.delimiter.length !== 1) {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].delimiter must be a single character`);
+    }
+  }
+  if (ruleObj.renamePattern !== undefined) {
+    if (typeof ruleObj.renamePattern !== "string") {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].renamePattern must be a string`);
+    }
+  }
+  if (ruleObj.metadata !== undefined) {
+    if (!Array.isArray(ruleObj.metadata)) {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].metadata must be an array`);
+    }
+    for (let i2 = 0;i2 < ruleObj.metadata.length; i2++) {
+      const meta = ruleObj.metadata[i2];
+      if (typeof meta.field !== "string" || meta.field === "") {
+        throw new Error(`Invalid config: provider '${providerName}' detect[${index}].metadata[${i2}].field is required`);
+      }
+      if (typeof meta.row !== "number" || meta.row < 0) {
+        throw new Error(`Invalid config: provider '${providerName}' detect[${index}].metadata[${i2}].row must be a non-negative number`);
+      }
+      if (typeof meta.column !== "number" || meta.column < 0) {
+        throw new Error(`Invalid config: provider '${providerName}' detect[${index}].metadata[${i2}].column must be a non-negative number`);
+      }
+      if (meta.normalize !== undefined && meta.normalize !== "spaces-to-dashes") {
+        throw new Error(`Invalid config: provider '${providerName}' detect[${index}].metadata[${i2}].normalize must be 'spaces-to-dashes'`);
+      }
+    }
   }
   return {
     filenamePattern: ruleObj.filenamePattern,
     header: ruleObj.header,
-    currencyField: ruleObj.currencyField
+    currencyField: ruleObj.currencyField,
+    skipRows: ruleObj.skipRows,
+    delimiter: ruleObj.delimiter,
+    renamePattern: ruleObj.renamePattern,
+    metadata: ruleObj.metadata
   };
 }
 function validateProviderConfig(name, config2) {
@@ -16695,11 +16735,50 @@ function loadImportConfig(directory) {
 
 // src/utils/providerDetector.ts
 var import_papaparse = __toESM(require_papaparse(), 1);
-function parseCSVPreview(content) {
-  const result = import_papaparse.default.parse(content, {
+function extractMetadata(content, skipRows, delimiter, metadataConfig) {
+  if (!metadataConfig || metadataConfig.length === 0 || skipRows === 0) {
+    return {};
+  }
+  const lines = content.split(`
+`).slice(0, skipRows);
+  const metadata = {};
+  for (const config2 of metadataConfig) {
+    if (config2.row >= lines.length)
+      continue;
+    const columns = lines[config2.row].split(delimiter);
+    if (config2.column >= columns.length)
+      continue;
+    let value = columns[config2.column].trim();
+    if (config2.normalize === "spaces-to-dashes") {
+      value = value.replace(/\s+/g, "-");
+    }
+    metadata[config2.field] = value;
+  }
+  return metadata;
+}
+function generateOutputFilename(renamePattern, metadata) {
+  if (!renamePattern) {
+    return;
+  }
+  let filename = renamePattern;
+  for (const [key, value] of Object.entries(metadata)) {
+    filename = filename.replace(`{${key}}`, value);
+  }
+  return filename;
+}
+function parseCSVPreview(content, skipRows = 0, delimiter = ",") {
+  let csvContent = content;
+  if (skipRows > 0) {
+    const lines = content.split(`
+`);
+    csvContent = lines.slice(skipRows).join(`
+`);
+  }
+  const result = import_papaparse.default.parse(csvContent, {
     header: true,
     preview: 1,
-    skipEmptyLines: true
+    skipEmptyLines: true,
+    delimiter
   });
   return {
     fields: result.meta.fields,
@@ -16710,17 +16789,21 @@ function normalizeHeader(fields) {
   return fields.map((f) => f.trim()).join(",");
 }
 function detectProvider(filename, content, config2) {
-  const { fields, firstRow } = parseCSVPreview(content);
-  if (!fields || fields.length === 0) {
-    return null;
-  }
-  const actualHeader = normalizeHeader(fields);
   for (const [providerName, providerConfig] of Object.entries(config2.providers)) {
     for (const rule of providerConfig.detect) {
-      const filenameRegex = new RegExp(rule.filenamePattern);
-      if (!filenameRegex.test(filename)) {
+      if (rule.filenamePattern !== undefined) {
+        const filenameRegex = new RegExp(rule.filenamePattern);
+        if (!filenameRegex.test(filename)) {
+          continue;
+        }
+      }
+      const skipRows = rule.skipRows ?? 0;
+      const delimiter = rule.delimiter ?? ",";
+      const { fields, firstRow } = parseCSVPreview(content, skipRows, delimiter);
+      if (!fields || fields.length === 0) {
         continue;
       }
+      const actualHeader = normalizeHeader(fields);
       if (actualHeader !== rule.header) {
         continue;
       }
@@ -16731,18 +16814,24 @@ function detectProvider(filename, content, config2) {
       if (!rawCurrency) {
         continue;
       }
+      const metadata = extractMetadata(content, skipRows, delimiter, rule.metadata);
+      const outputFilename = generateOutputFilename(rule.renamePattern, metadata);
       const normalizedCurrency = providerConfig.currencies[rawCurrency];
       if (!normalizedCurrency) {
         return {
           provider: providerName,
           currency: rawCurrency.toLowerCase(),
-          rule
+          rule,
+          outputFilename,
+          metadata: Object.keys(metadata).length > 0 ? metadata : undefined
         };
       }
       return {
         provider: providerName,
         currency: normalizedCurrency,
-        rule
+        rule,
+        outputFilename,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined
       };
     }
   }
@@ -16815,7 +16904,7 @@ async function classifyStatementsCore(directory, agent, configLoader = loadImpor
       unrecognized: []
     });
   }
-  const importsDir = path4.join(directory, config2.paths.imports);
+  const importsDir = path4.join(directory, config2.paths.import);
   const pendingDir = path4.join(directory, config2.paths.pending);
   const unrecognizedDir = path4.join(directory, config2.paths.unrecognized);
   const pendingFiles = checkPendingFiles(directory, config2.paths.pending);
@@ -16834,7 +16923,7 @@ async function classifyStatementsCore(directory, agent, configLoader = loadImpor
       success: true,
       classified: [],
       unrecognized: [],
-      message: `No CSV files found in ${config2.paths.imports}`
+      message: `No CSV files found in ${config2.paths.import}`
     });
   }
   const classified = [];
@@ -16844,15 +16933,17 @@ async function classifyStatementsCore(directory, agent, configLoader = loadImpor
     const content = fs4.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     if (detection) {
+      const targetFilename = detection.outputFilename || filename;
       const targetDir = path4.join(pendingDir, detection.provider, detection.currency);
       ensureDirectory(targetDir);
-      const targetPath = path4.join(targetDir, filename);
+      const targetPath = path4.join(targetDir, targetFilename);
       fs4.renameSync(sourcePath, targetPath);
       classified.push({
-        filename,
+        filename: targetFilename,
+        originalFilename: detection.outputFilename ? filename : undefined,
         provider: detection.provider,
         currency: detection.currency,
-        targetPath: path4.join(config2.paths.pending, detection.provider, detection.currency, filename)
+        targetPath: path4.join(config2.paths.pending, detection.provider, detection.currency, targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);

package/package.json

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