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

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

@@ -1341,7 +1341,7 @@ var require_papaparse = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { dirname, join as join5 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -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
       };
     }
   }
@@ -16759,35 +16848,6 @@ function findCSVFiles(importsDir) {
     return fs4.statSync(fullPath).isFile();
   });
 }
-function checkPendingFiles(directory, pendingBasePath) {
-  const pendingDir = path4.join(directory, pendingBasePath);
-  const pendingFiles = [];
-  if (!fs4.existsSync(pendingDir)) {
-    return [];
-  }
-  const providers = fs4.readdirSync(pendingDir);
-  for (const provider of providers) {
-    const providerPath = path4.join(pendingDir, provider);
-    if (!fs4.statSync(providerPath).isDirectory())
-      continue;
-    const currencies = fs4.readdirSync(providerPath);
-    for (const currency of currencies) {
-      const currencyPath = path4.join(providerPath, currency);
-      if (!fs4.statSync(currencyPath).isDirectory())
-        continue;
-      const files = fs4.readdirSync(currencyPath).filter((f) => f.toLowerCase().endsWith(".csv"));
-      for (const file2 of files) {
-        pendingFiles.push({
-          provider,
-          currency,
-          filename: file2,
-          path: path4.join(currencyPath, file2)
-        });
-      }
-    }
-  }
-  return pendingFiles;
-}
 function ensureDirectory(dirPath) {
   if (!fs4.existsSync(dirPath)) {
     fs4.mkdirSync(dirPath, { recursive: true });
@@ -16815,52 +16875,77 @@ 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);
-  if (pendingFiles.length > 0) {
-    return JSON.stringify({
-      success: false,
-      error: `Found ${pendingFiles.length} pending file(s) that must be processed before classifying new statements.`,
-      pendingFiles,
-      classified: [],
-      unrecognized: []
-    });
-  }
   const csvFiles = findCSVFiles(importsDir);
   if (csvFiles.length === 0) {
     return JSON.stringify({
       success: true,
       classified: [],
       unrecognized: [],
-      message: `No CSV files found in ${config2.paths.imports}`
+      message: `No CSV files found in ${config2.paths.import}`
     });
   }
-  const classified = [];
-  const unrecognized = [];
+  const plannedMoves = [];
+  const collisions = [];
   for (const filename of csvFiles) {
     const sourcePath = path4.join(importsDir, filename);
     const content = fs4.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
+    let targetPath;
+    let targetFilename;
     if (detection) {
+      targetFilename = detection.outputFilename || filename;
       const targetDir = path4.join(pendingDir, detection.provider, detection.currency);
+      targetPath = path4.join(targetDir, targetFilename);
+    } else {
+      targetFilename = filename;
+      targetPath = path4.join(unrecognizedDir, filename);
+    }
+    if (fs4.existsSync(targetPath)) {
+      collisions.push({
+        filename,
+        existingPath: targetPath
+      });
+    }
+    plannedMoves.push({
+      filename,
+      sourcePath,
+      targetPath,
+      targetFilename,
+      detection
+    });
+  }
+  if (collisions.length > 0) {
+    return JSON.stringify({
+      success: false,
+      error: `Cannot classify: ${collisions.length} file(s) would overwrite existing pending files.`,
+      collisions,
+      classified: [],
+      unrecognized: []
+    });
+  }
+  const classified = [];
+  const unrecognized = [];
+  for (const move of plannedMoves) {
+    if (move.detection) {
+      const targetDir = path4.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      const targetPath = path4.join(targetDir, filename);
-      fs4.renameSync(sourcePath, targetPath);
+      fs4.renameSync(move.sourcePath, move.targetPath);
       classified.push({
-        filename,
-        provider: detection.provider,
-        currency: detection.currency,
-        targetPath: path4.join(config2.paths.pending, detection.provider, detection.currency, filename)
+        filename: move.targetFilename,
+        originalFilename: move.detection.outputFilename ? move.filename : undefined,
+        provider: move.detection.provider,
+        currency: move.detection.currency,
+        targetPath: path4.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      const targetPath = path4.join(unrecognizedDir, filename);
-      fs4.renameSync(sourcePath, targetPath);
+      fs4.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
-        filename,
-        targetPath: path4.join(config2.paths.unrecognized, filename)
+        filename: move.filename,
+        targetPath: path4.join(config2.paths.unrecognized, move.filename)
       });
     }
   }
@@ -16884,7 +16969,7 @@ var classify_statements_default = tool({
   }
 });
 // src/index.ts
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
 var AGENT_FILE = join5(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);

package/package.json

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