@fuzzle/opencode-accountant 0.0.10 → 0.0.11

package/agent/accountant.md

@@ -19,7 +19,7 @@ permission:
   todoread: allow
   todowrite: allow
   webfetch: deny
-  write: allow  
+  write: allow
 ---
 
 ## Repository Structure
@@ -55,3 +55,27 @@ When working with accounting tasks:
 1. **Unintended edits** - If a balance is off, check the journal for unintended edits
 1. **Statement tracking** - Move processed statements to `statements/{provider}/YYYY`
 1. **Consistency** - Maintain consistent formatting and naming conventions across all files
+
+## Statement Import Workflow
+
+Use the `import-statements` tool to import bank statements. The workflow:
+
+1. **Prepare**: Drop CSV files into `statements/import/`
+2. **Classify**: Run `classify-statements` tool to move files to `doc/agent/todo/import/<provider>/<currency>/`
+3. **Validate (check mode)**: Run `import-statements(checkOnly: true)` to validate transactions
+   - Tool runs `hledger print` dry run to check for unknown postings
+   - Unknown postings appear as `income:unknown` or `expenses:unknown`
+4. **Handle unknowns**: If unknown postings found:
+   - Tool returns full CSV row data for each unknown posting
+   - Analyze the CSV row data to understand the transaction
+   - Create or update rules file with `if` directives to match the transaction
+   - Repeat step 3 until all postings are matched
+5. **Import**: Once all transactions have matching rules, run `import-statements(checkOnly: false)`
+6. **Complete**: Transactions imported to journal, CSVs moved to `doc/agent/done/import/`
+
+### Rules Files
+
+- Rules files are in `config/rules/` directory
+- Match CSV to rules file via the `source` directive in each `.rules` file
+- Use field names from the `fields` directive for matching
+- Unknown account pattern: `income:unknown` (positive amounts) / `expenses:unknown` (negative amounts)

package/dist/index.js

@@ -1340,6 +1340,606 @@ var require_papaparse = __commonJS((exports, module) => {
   });
 });
 
+// node_modules/convert-csv-to-json/src/util/fileUtils.js
+var require_fileUtils = __commonJS((exports, module) => {
+  var fs6 = __require("fs");
+
+  class FileUtils {
+    readFile(fileInputName, encoding) {
+      return fs6.readFileSync(fileInputName, encoding).toString();
+    }
+    readFileAsync(fileInputName, encoding = "utf8") {
+      if (fs6.promises && typeof fs6.promises.readFile === "function") {
+        return fs6.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      }
+      return new Promise((resolve2, reject) => {
+        fs6.readFile(fileInputName, encoding, (err, data) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve2(data.toString());
+        });
+      });
+    }
+    writeFile(json3, fileOutputName) {
+      fs6.writeFile(fileOutputName, json3, function(err) {
+        if (err) {
+          throw err;
+        } else {
+          console.log("File saved: " + fileOutputName);
+        }
+      });
+    }
+    writeFileAsync(json3, fileOutputName) {
+      if (fs6.promises && typeof fs6.promises.writeFile === "function") {
+        return fs6.promises.writeFile(fileOutputName, json3);
+      }
+      return new Promise((resolve2, reject) => {
+        fs6.writeFile(fileOutputName, json3, (err) => {
+          if (err)
+            return reject(err);
+          resolve2();
+        });
+      });
+    }
+  }
+  module.exports = new FileUtils;
+});
+
+// node_modules/convert-csv-to-json/src/util/stringUtils.js
+var require_stringUtils = __commonJS((exports, module) => {
+  class StringUtils {
+    static PATTERNS = {
+      INTEGER: /^-?\d+$/,
+      FLOAT: /^-?\d*\.\d+$/,
+      WHITESPACE: /\s/g
+    };
+    static BOOLEAN_VALUES = {
+      TRUE: "true",
+      FALSE: "false"
+    };
+    trimPropertyName(shouldTrimAll, propertyName) {
+      if (!propertyName) {
+        return "";
+      }
+      return shouldTrimAll ? propertyName.replace(StringUtils.PATTERNS.WHITESPACE, "") : propertyName.trim();
+    }
+    getValueFormatByType(value) {
+      if (this.isEmpty(value)) {
+        return String();
+      }
+      if (this.isBoolean(value)) {
+        return this.convertToBoolean(value);
+      }
+      if (this.isInteger(value)) {
+        return this.convertInteger(value);
+      }
+      if (this.isFloat(value)) {
+        return this.convertFloat(value);
+      }
+      return String(value);
+    }
+    hasContent(values = []) {
+      return Array.isArray(values) && values.some((value) => Boolean(value));
+    }
+    isEmpty(value) {
+      return value === undefined || value === "";
+    }
+    isBoolean(value) {
+      const normalizedValue = value.toLowerCase();
+      return normalizedValue === StringUtils.BOOLEAN_VALUES.TRUE || normalizedValue === StringUtils.BOOLEAN_VALUES.FALSE;
+    }
+    isInteger(value) {
+      return StringUtils.PATTERNS.INTEGER.test(value);
+    }
+    isFloat(value) {
+      return StringUtils.PATTERNS.FLOAT.test(value);
+    }
+    hasLeadingZero(value) {
+      const isPositiveWithLeadingZero = value.length > 1 && value[0] === "0";
+      const isNegativeWithLeadingZero = value.length > 2 && value[0] === "-" && value[1] === "0";
+      return isPositiveWithLeadingZero || isNegativeWithLeadingZero;
+    }
+    convertToBoolean(value) {
+      return JSON.parse(value.toLowerCase());
+    }
+    convertInteger(value) {
+      if (this.hasLeadingZero(value)) {
+        return String(value);
+      }
+      const num = Number(value);
+      return Number.isSafeInteger(num) ? num : String(value);
+    }
+    convertFloat(value) {
+      const num = Number(value);
+      return Number.isFinite(num) ? num : String(value);
+    }
+  }
+  module.exports = new StringUtils;
+});
+
+// node_modules/convert-csv-to-json/src/util/jsonUtils.js
+var require_jsonUtils = __commonJS((exports, module) => {
+  class JsonUtil {
+    validateJson(json3) {
+      try {
+        JSON.parse(json3);
+      } catch (err) {
+        throw Error(`Parsed csv has generated an invalid json!!!
+` + err);
+      }
+    }
+  }
+  module.exports = new JsonUtil;
+});
+
+// node_modules/convert-csv-to-json/src/csvToJson.js
+var require_csvToJson = __commonJS((exports, module) => {
+  var fileUtils = require_fileUtils();
+  var stringUtils = require_stringUtils();
+  var jsonUtils = require_jsonUtils();
+  var newLine = /\r?\n/;
+  var defaultFieldDelimiter = ";";
+
+  class CsvToJson {
+    formatValueByType(active) {
+      this.printValueFormatByType = active;
+      return this;
+    }
+    supportQuotedField(active) {
+      this.isSupportQuotedField = active;
+      return this;
+    }
+    fieldDelimiter(delimiter) {
+      this.delimiter = delimiter;
+      return this;
+    }
+    trimHeaderFieldWhiteSpace(active) {
+      this.isTrimHeaderFieldWhiteSpace = active;
+      return this;
+    }
+    indexHeader(indexHeaderValue) {
+      if (isNaN(indexHeaderValue)) {
+        throw new Error("The index Header must be a Number!");
+      }
+      this.indexHeaderValue = indexHeaderValue;
+      return this;
+    }
+    parseSubArray(delimiter = "*", separator = ",") {
+      this.parseSubArrayDelimiter = delimiter;
+      this.parseSubArraySeparator = separator;
+    }
+    encoding(encoding) {
+      this.encoding = encoding;
+      return this;
+    }
+    generateJsonFileFromCsv(fileInputName, fileOutputName) {
+      let jsonStringified = this.getJsonFromCsvStringified(fileInputName);
+      fileUtils.writeFile(jsonStringified, fileOutputName);
+    }
+    getJsonFromCsvStringified(fileInputName) {
+      let json3 = this.getJsonFromCsv(fileInputName);
+      let jsonStringified = JSON.stringify(json3, undefined, 1);
+      jsonUtils.validateJson(jsonStringified);
+      return jsonStringified;
+    }
+    getJsonFromCsv(fileInputName) {
+      let parsedCsv = fileUtils.readFile(fileInputName, this.encoding);
+      return this.csvToJson(parsedCsv);
+    }
+    csvStringToJson(csvString) {
+      return this.csvToJson(csvString);
+    }
+    csvStringToJsonStringified(csvString) {
+      let json3 = this.csvStringToJson(csvString);
+      let jsonStringified = JSON.stringify(json3, undefined, 1);
+      jsonUtils.validateJson(jsonStringified);
+      return jsonStringified;
+    }
+    csvToJson(parsedCsv) {
+      this.validateInputConfig();
+      let lines = parsedCsv.split(newLine);
+      let fieldDelimiter = this.getFieldDelimiter();
+      let index = this.getIndexHeader();
+      let headers;
+      if (this.isSupportQuotedField) {
+        headers = this.split(lines[index]);
+      } else {
+        headers = lines[index].split(fieldDelimiter);
+      }
+      while (!stringUtils.hasContent(headers) && index <= lines.length) {
+        index = index + 1;
+        headers = lines[index].split(fieldDelimiter);
+      }
+      let jsonResult = [];
+      for (let i2 = index + 1;i2 < lines.length; i2++) {
+        let currentLine;
+        if (this.isSupportQuotedField) {
+          currentLine = this.split(lines[i2]);
+        } else {
+          currentLine = lines[i2].split(fieldDelimiter);
+        }
+        if (stringUtils.hasContent(currentLine)) {
+          jsonResult.push(this.buildJsonResult(headers, currentLine));
+        }
+      }
+      return jsonResult;
+    }
+    getFieldDelimiter() {
+      if (this.delimiter) {
+        return this.delimiter;
+      }
+      return defaultFieldDelimiter;
+    }
+    getIndexHeader() {
+      if (this.indexHeaderValue !== null && !isNaN(this.indexHeaderValue)) {
+        return this.indexHeaderValue;
+      }
+      return 0;
+    }
+    buildJsonResult(headers, currentLine) {
+      let jsonObject = {};
+      for (let j = 0;j < headers.length; j++) {
+        let propertyName = stringUtils.trimPropertyName(this.isTrimHeaderFieldWhiteSpace, headers[j]);
+        let value = currentLine[j];
+        if (this.isParseSubArray(value)) {
+          value = this.buildJsonSubArray(value);
+        }
+        if (this.printValueFormatByType && !Array.isArray(value)) {
+          value = stringUtils.getValueFormatByType(currentLine[j]);
+        }
+        jsonObject[propertyName] = value;
+      }
+      return jsonObject;
+    }
+    buildJsonSubArray(value) {
+      let extractedValues = value.substring(value.indexOf(this.parseSubArrayDelimiter) + 1, value.lastIndexOf(this.parseSubArrayDelimiter));
+      extractedValues.trim();
+      value = extractedValues.split(this.parseSubArraySeparator);
+      if (this.printValueFormatByType) {
+        for (let i2 = 0;i2 < value.length; i2++) {
+          value[i2] = stringUtils.getValueFormatByType(value[i2]);
+        }
+      }
+      return value;
+    }
+    isParseSubArray(value) {
+      if (this.parseSubArrayDelimiter) {
+        if (value && (value.indexOf(this.parseSubArrayDelimiter) === 0 && value.lastIndexOf(this.parseSubArrayDelimiter) === value.length - 1)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    validateInputConfig() {
+      if (this.isSupportQuotedField) {
+        if (this.getFieldDelimiter() === '"') {
+          throw new Error('When SupportQuotedFields is enabled you cannot defined the field delimiter as quote -> ["]');
+        }
+        if (this.parseSubArraySeparator === '"') {
+          throw new Error('When SupportQuotedFields is enabled you cannot defined the field parseSubArraySeparator as quote -> ["]');
+        }
+        if (this.parseSubArrayDelimiter === '"') {
+          throw new Error('When SupportQuotedFields is enabled you cannot defined the field parseSubArrayDelimiter as quote -> ["]');
+        }
+      }
+    }
+    hasQuotes(line) {
+      return line.includes('"');
+    }
+    split(line) {
+      if (line.length == 0) {
+        return [];
+      }
+      let delim = this.getFieldDelimiter();
+      let subSplits = [""];
+      if (this.hasQuotes(line)) {
+        let chars = line.split("");
+        let subIndex = 0;
+        let startQuote = false;
+        let isDouble = false;
+        chars.forEach((c, i2, arr) => {
+          if (isDouble) {
+            subSplits[subIndex] += c;
+            isDouble = false;
+            return;
+          }
+          if (c != '"' && c != delim) {
+            subSplits[subIndex] += c;
+          } else if (c == delim && startQuote) {
+            subSplits[subIndex] += c;
+          } else if (c == delim) {
+            subIndex++;
+            subSplits[subIndex] = "";
+            return;
+          } else {
+            if (arr[i2 + 1] === '"') {
+              isDouble = true;
+            } else {
+              if (!startQuote) {
+                startQuote = true;
+              } else {
+                startQuote = false;
+              }
+            }
+          }
+        });
+        if (startQuote) {
+          throw new Error("Row contains mismatched quotes!");
+        }
+        return subSplits;
+      } else {
+        return line.split(delim);
+      }
+    }
+  }
+  module.exports = new CsvToJson;
+});
+
+// node_modules/convert-csv-to-json/src/csvToJsonAsync.js
+var require_csvToJsonAsync = __commonJS((exports, module) => {
+  var fileUtils = require_fileUtils();
+  var csvToJson = require_csvToJson();
+
+  class CsvToJsonAsync {
+    constructor() {
+      this.csvToJson = csvToJson;
+    }
+    formatValueByType(active) {
+      this.csvToJson.formatValueByType(active);
+      return this;
+    }
+    supportQuotedField(active) {
+      this.csvToJson.supportQuotedField(active);
+      return this;
+    }
+    fieldDelimiter(delimiter) {
+      this.csvToJson.fieldDelimiter(delimiter);
+      return this;
+    }
+    trimHeaderFieldWhiteSpace(active) {
+      this.csvToJson.trimHeaderFieldWhiteSpace(active);
+      return this;
+    }
+    indexHeader(indexHeader) {
+      this.csvToJson.indexHeader(indexHeader);
+      return this;
+    }
+    parseSubArray(delimiter = "*", separator = ",") {
+      this.csvToJson.parseSubArray(delimiter, separator);
+      return this;
+    }
+    encoding(encoding) {
+      this.csvToJson.encoding = encoding;
+      return this;
+    }
+    async generateJsonFileFromCsv(fileInputName, fileOutputName) {
+      const jsonStringified = await this.getJsonFromCsvStringified(fileInputName);
+      await fileUtils.writeFileAsync(jsonStringified, fileOutputName);
+    }
+    async getJsonFromCsvStringified(fileInputName) {
+      const json3 = await this.getJsonFromCsvAsync(fileInputName);
+      return JSON.stringify(json3, undefined, 1);
+    }
+    async getJsonFromCsvAsync(inputFileNameOrCsv, options = {}) {
+      if (inputFileNameOrCsv === null || inputFileNameOrCsv === undefined) {
+        throw new Error("inputFileNameOrCsv is not defined!!!");
+      }
+      if (options.raw) {
+        if (inputFileNameOrCsv === "") {
+          return [];
+        }
+        return this.csvToJson.csvToJson(inputFileNameOrCsv);
+      }
+      const parsedCsv = await fileUtils.readFileAsync(inputFileNameOrCsv, this.csvToJson.encoding || "utf8");
+      return this.csvToJson.csvToJson(parsedCsv);
+    }
+    csvStringToJsonAsync(csvString, options = { raw: true }) {
+      return this.getJsonFromCsvAsync(csvString, options);
+    }
+    async csvStringToJsonStringifiedAsync(csvString) {
+      const json3 = await this.csvStringToJsonAsync(csvString);
+      return JSON.stringify(json3, undefined, 1);
+    }
+  }
+  module.exports = new CsvToJsonAsync;
+});
+
+// node_modules/convert-csv-to-json/src/browserApi.js
+var require_browserApi = __commonJS((exports, module) => {
+  var csvToJson = require_csvToJson();
+
+  class BrowserApi {
+    constructor() {
+      this.csvToJson = csvToJson;
+    }
+    formatValueByType(active = true) {
+      this.csvToJson.formatValueByType(active);
+      return this;
+    }
+    supportQuotedField(active = false) {
+      this.csvToJson.supportQuotedField(active);
+      return this;
+    }
+    fieldDelimiter(delimiter) {
+      this.csvToJson.fieldDelimiter(delimiter);
+      return this;
+    }
+    trimHeaderFieldWhiteSpace(active = false) {
+      this.csvToJson.trimHeaderFieldWhiteSpace(active);
+      return this;
+    }
+    indexHeader(index) {
+      this.csvToJson.indexHeader(index);
+      return this;
+    }
+    parseSubArray(delimiter = "*", separator = ",") {
+      this.csvToJson.parseSubArray(delimiter, separator);
+      return this;
+    }
+    csvStringToJson(csvString) {
+      if (csvString === undefined || csvString === null) {
+        throw new Error("csvString is not defined!!!");
+      }
+      return this.csvToJson.csvToJson(csvString);
+    }
+    csvStringToJsonStringified(csvString) {
+      if (csvString === undefined || csvString === null) {
+        throw new Error("csvString is not defined!!!");
+      }
+      return this.csvToJson.csvStringToJsonStringified(csvString);
+    }
+    csvStringToJsonAsync(csvString) {
+      return Promise.resolve(this.csvStringToJson(csvString));
+    }
+    csvStringToJsonStringifiedAsync(csvString) {
+      return Promise.resolve(this.csvStringToJsonStringified(csvString));
+    }
+    parseFile(file2, options = {}) {
+      if (!file2) {
+        return Promise.reject(new Error("file is not defined!!!"));
+      }
+      return new Promise((resolve2, reject) => {
+        if (typeof FileReader === "undefined") {
+          reject(new Error("FileReader is not available in this environment"));
+          return;
+        }
+        const reader = new FileReader;
+        reader.onerror = () => reject(reader.error || new Error("Failed to read file"));
+        reader.onload = () => {
+          try {
+            const text = reader.result;
+            const result = this.csvToJson.csvToJson(String(text));
+            resolve2(result);
+          } catch (err) {
+            reject(err);
+          }
+        };
+        if (options.encoding) {
+          reader.readAsText(file2, options.encoding);
+        } else {
+          reader.readAsText(file2);
+        }
+      });
+    }
+  }
+  module.exports = new BrowserApi;
+});
+
+// node_modules/convert-csv-to-json/index.js
+var require_convert_csv_to_json = __commonJS((exports) => {
+  var csvToJson = require_csvToJson();
+  var encodingOps = {
+    utf8: "utf8",
+    ucs2: "ucs2",
+    utf16le: "utf16le",
+    latin1: "latin1",
+    ascii: "ascii",
+    base64: "base64",
+    hex: "hex"
+  };
+  exports.formatValueByType = function(active = true) {
+    csvToJson.formatValueByType(active);
+    return this;
+  };
+  exports.supportQuotedField = function(active = false) {
+    csvToJson.supportQuotedField(active);
+    return this;
+  };
+  exports.fieldDelimiter = function(delimiter) {
+    csvToJson.fieldDelimiter(delimiter);
+    return this;
+  };
+  exports.trimHeaderFieldWhiteSpace = function(active = false) {
+    csvToJson.trimHeaderFieldWhiteSpace(active);
+    return this;
+  };
+  exports.indexHeader = function(index) {
+    csvToJson.indexHeader(index);
+    return this;
+  };
+  exports.parseSubArray = function(delimiter, separator) {
+    csvToJson.parseSubArray(delimiter, separator);
+    return this;
+  };
+  exports.customEncoding = function(encoding) {
+    csvToJson.encoding = encoding;
+    return this;
+  };
+  exports.utf8Encoding = function utf8Encoding() {
+    csvToJson.encoding = encodingOps.utf8;
+    return this;
+  };
+  exports.ucs2Encoding = function() {
+    csvToJson.encoding = encodingOps.ucs2;
+    return this;
+  };
+  exports.utf16leEncoding = function() {
+    csvToJson.encoding = encodingOps.utf16le;
+    return this;
+  };
+  exports.latin1Encoding = function() {
+    csvToJson.encoding = encodingOps.latin1;
+    return this;
+  };
+  exports.asciiEncoding = function() {
+    csvToJson.encoding = encodingOps.ascii;
+    return this;
+  };
+  exports.base64Encoding = function() {
+    this.csvToJson = encodingOps.base64;
+    return this;
+  };
+  exports.hexEncoding = function() {
+    this.csvToJson = encodingOps.hex;
+    return this;
+  };
+  exports.generateJsonFileFromCsv = function(inputFileName, outputFileName) {
+    if (!inputFileName) {
+      throw new Error("inputFileName is not defined!!!");
+    }
+    if (!outputFileName) {
+      throw new Error("outputFileName is not defined!!!");
+    }
+    csvToJson.generateJsonFileFromCsv(inputFileName, outputFileName);
+  };
+  exports.getJsonFromCsv = function(inputFileName) {
+    if (!inputFileName) {
+      throw new Error("inputFileName is not defined!!!");
+    }
+    return csvToJson.getJsonFromCsv(inputFileName);
+  };
+  var csvToJsonAsync = require_csvToJsonAsync();
+  Object.assign(exports, {
+    getJsonFromCsvAsync: function(input, options) {
+      return csvToJsonAsync.getJsonFromCsvAsync(input, options);
+    },
+    csvStringToJsonAsync: function(input, options) {
+      return csvToJsonAsync.csvStringToJsonAsync(input, options);
+    },
+    csvStringToJsonStringifiedAsync: function(input) {
+      return csvToJsonAsync.csvStringToJsonStringifiedAsync(input);
+    },
+    generateJsonFileFromCsvAsync: function(input, output) {
+      return csvToJsonAsync.generateJsonFileFromCsv(input, output);
+    }
+  });
+  exports.csvStringToJson = function(csvString) {
+    return csvToJson.csvStringToJson(csvString);
+  };
+  exports.csvStringToJsonStringified = function(csvString) {
+    if (csvString === undefined || csvString === null) {
+      throw new Error("csvString is not defined!!!");
+    }
+    return csvToJson.csvStringToJsonStringified(csvString);
+  };
+  exports.jsonToCsv = function(inputFileName, outputFileName) {
+    csvToJson.generateJsonFileFromCsv(inputFileName, outputFileName);
+  };
+  exports.browser = require_browserApi();
+});
+
 // src/index.ts
 import { dirname as dirname4, join as join7 } from "path";
 import { fileURLToPath } from "url";
@@ -16976,7 +17576,7 @@ var classify_statements_default = tool({
   }
 });
 // src/tools/import-statements.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path6 from "path";
 
 // src/utils/rulesMatcher.ts
@@ -17090,10 +17690,222 @@ function countTransactions(hledgerOutput) {
   return count;
 }
 
+// src/utils/rulesParser.ts
+function parseSkipRows(rulesContent) {
+  const match = rulesContent.match(/^skip\s+(\d+)/m);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function parseSeparator(rulesContent) {
+  const match = rulesContent.match(/^separator\s+(.)/m);
+  return match ? match[1] : ",";
+}
+function parseFieldNames(rulesContent) {
+  const match = rulesContent.match(/^fields\s+(.+)$/m);
+  if (!match) {
+    return [];
+  }
+  return match[1].split(",").map((field) => field.trim());
+}
+function parseDateFormat(rulesContent) {
+  const match = rulesContent.match(/^date-format\s+(.+)$/m);
+  return match ? match[1].trim() : "%Y-%m-%d";
+}
+function parseDateField(rulesContent, fieldNames) {
+  const match = rulesContent.match(/^date\s+%(\w+|\d+)/m);
+  if (!match) {
+    return fieldNames[0] || "date";
+  }
+  const value = match[1];
+  if (/^\d+$/.test(value)) {
+    const index = parseInt(value, 10) - 1;
+    return fieldNames[index] || value;
+  }
+  return value;
+}
+function parseAmountFields(rulesContent, fieldNames) {
+  const result = {};
+  const simpleMatch = rulesContent.match(/^amount\s+(-?)%(\w+|\d+)/m);
+  if (simpleMatch) {
+    const fieldRef = simpleMatch[2];
+    if (/^\d+$/.test(fieldRef)) {
+      const index = parseInt(fieldRef, 10) - 1;
+      result.single = fieldNames[index] || fieldRef;
+    } else {
+      result.single = fieldRef;
+    }
+  }
+  const debitMatch = rulesContent.match(/if\s+%(\w+)\s+\.\s*\n\s*amount\s+-?%\1/m);
+  if (debitMatch) {
+    result.debit = debitMatch[1];
+  }
+  const creditMatch = rulesContent.match(/if\s+%(\w+)\s+\.\s*\n\s*amount\s+%\1(?!\w)/m);
+  if (creditMatch && creditMatch[1] !== result.debit) {
+    result.credit = creditMatch[1];
+  }
+  if (result.debit || result.credit) {
+    delete result.single;
+  }
+  if (!result.single && !result.debit && !result.credit) {
+    result.single = "amount";
+  }
+  return result;
+}
+function parseRulesFile(rulesContent) {
+  const fieldNames = parseFieldNames(rulesContent);
+  return {
+    skipRows: parseSkipRows(rulesContent),
+    separator: parseSeparator(rulesContent),
+    fieldNames,
+    dateFormat: parseDateFormat(rulesContent),
+    dateField: parseDateField(rulesContent, fieldNames),
+    amountFields: parseAmountFields(rulesContent, fieldNames)
+  };
+}
+
+// src/utils/csvParser.ts
+var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 1);
+import * as fs6 from "fs";
+function parseCsvFile(csvPath, config2) {
+  const csvContent = fs6.readFileSync(csvPath, "utf-8");
+  const lines = csvContent.split(`
+`);
+  const headerIndex = config2.skipRows;
+  if (headerIndex >= lines.length) {
+    return [];
+  }
+  const headerLine = lines[headerIndex];
+  const dataLines = lines.slice(headerIndex + 1).filter((line) => line.trim() !== "");
+  const csvWithHeader = [headerLine, ...dataLines].join(`
+`);
+  const rawRows = import_convert_csv_to_json.default.indexHeader(0).fieldDelimiter(config2.separator).supportQuotedField(true).csvStringToJson(csvWithHeader);
+  const fieldNames = config2.fieldNames.length > 0 ? config2.fieldNames : Object.keys(rawRows[0] || {});
+  const mappedRows = [];
+  for (const parsedRow of rawRows) {
+    const row = {};
+    const values = Object.values(parsedRow);
+    for (let i2 = 0;i2 < fieldNames.length && i2 < values.length; i2++) {
+      row[fieldNames[i2]] = values[i2];
+    }
+    mappedRows.push(row);
+  }
+  return mappedRows;
+}
+function parseAmountValue(amountStr) {
+  const cleaned = amountStr.replace(/[A-Z]{3}\s*/g, "").trim();
+  return parseFloat(cleaned) || 0;
+}
+function getRowAmount(row, amountFields) {
+  if (amountFields.single) {
+    return parseAmountValue(row[amountFields.single] || "0");
+  }
+  const debitValue = amountFields.debit ? parseAmountValue(row[amountFields.debit] || "0") : 0;
+  const creditValue = amountFields.credit ? parseAmountValue(row[amountFields.credit] || "0") : 0;
+  if (debitValue !== 0) {
+    return -Math.abs(debitValue);
+  }
+  if (creditValue !== 0) {
+    return Math.abs(creditValue);
+  }
+  return 0;
+}
+function parseDateToIso(dateStr, dateFormat) {
+  if (!dateStr)
+    return "";
+  if (dateFormat === "%Y-%m-%d" || dateFormat === "%F") {
+    return dateStr.trim();
+  }
+  if (dateFormat === "%d.%m.%Y") {
+    const parts = dateStr.split(".");
+    if (parts.length === 3) {
+      return `${parts[2]}-${parts[1].padStart(2, "0")}-${parts[0].padStart(2, "0")}`;
+    }
+  }
+  if (dateFormat === "%m/%d/%Y") {
+    const parts = dateStr.split("/");
+    if (parts.length === 3) {
+      return `${parts[2]}-${parts[0].padStart(2, "0")}-${parts[1].padStart(2, "0")}`;
+    }
+  }
+  if (dateFormat === "%d/%m/%Y") {
+    const parts = dateStr.split("/");
+    if (parts.length === 3) {
+      return `${parts[2]}-${parts[1].padStart(2, "0")}-${parts[0].padStart(2, "0")}`;
+    }
+  }
+  return dateStr.trim();
+}
+function looksLikeTransactionId(fieldName, value) {
+  if (!value || value.trim() === "")
+    return false;
+  const idFieldPatterns = [
+    /transaction/i,
+    /trans_?no/i,
+    /trans_?id/i,
+    /reference/i,
+    /ref_?no/i,
+    /ref_?id/i,
+    /booking_?id/i,
+    /payment_?id/i,
+    /order_?id/i
+  ];
+  const nameMatches = idFieldPatterns.some((pattern) => pattern.test(fieldName));
+  if (!nameMatches)
+    return false;
+  const trimmedValue = value.trim();
+  const looksLikeId = /^[A-Za-z0-9_-]+$/.test(trimmedValue) && trimmedValue.length >= 3;
+  return looksLikeId;
+}
+function findTransactionId(row) {
+  for (const [field, value] of Object.entries(row)) {
+    if (looksLikeTransactionId(field, value)) {
+      return { field, value: value.trim() };
+    }
+  }
+  return null;
+}
+function findMatchingCsvRow(posting, csvRows, config2) {
+  const postingAmount = parseAmountValue(posting.amount);
+  let candidates = csvRows.filter((row) => {
+    const rowDate = parseDateToIso(row[config2.dateField] || "", config2.dateFormat);
+    const rowAmount = getRowAmount(row, config2.amountFields);
+    if (rowDate !== posting.date)
+      return false;
+    if (Math.abs(rowAmount - postingAmount) > 0.001)
+      return false;
+    return true;
+  });
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  if (candidates.length === 0) {
+    throw new Error(`Bug: Could not find CSV row for posting: ${posting.date} ${posting.description} ${posting.amount}. ` + `This indicates a mismatch between hledger output and CSV parsing.`);
+  }
+  for (const candidate of candidates) {
+    const txId = findTransactionId(candidate);
+    if (txId) {
+      const withSameTxId = candidates.filter((row) => row[txId.field] === txId.value);
+      if (withSameTxId.length === 1) {
+        return withSameTxId[0];
+      }
+    }
+  }
+  const descriptionLower = posting.description.toLowerCase();
+  const descMatches = candidates.filter((row) => {
+    return Object.values(row).some((value) => value && value.toLowerCase().includes(descriptionLower));
+  });
+  if (descMatches.length === 1) {
+    return descMatches[0];
+  }
+  if (descMatches.length > 1) {
+    return descMatches[0];
+  }
+  return candidates[0];
+}
+
 // src/tools/import-statements.ts
 function findPendingCsvFiles(pendingDir, provider, currency) {
   const csvFiles = [];
-  if (!fs6.existsSync(pendingDir)) {
+  if (!fs7.existsSync(pendingDir)) {
     return csvFiles;
   }
   let searchPath = pendingDir;
@@ -17103,11 +17915,11 @@ function findPendingCsvFiles(pendingDir, provider, currency) {
       searchPath = path6.join(searchPath, currency);
     }
   }
-  if (!fs6.existsSync(searchPath)) {
+  if (!fs7.existsSync(searchPath)) {
     return csvFiles;
   }
   function scanDirectory(directory) {
-    const entries = fs6.readdirSync(directory, { withFileTypes: true });
+    const entries = fs7.readdirSync(directory, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path6.join(directory, entry.name);
       if (entry.isDirectory()) {
@@ -17194,6 +18006,25 @@ async function importStatementsCore(directory, agent, options, configLoader = lo
     const unknownPostings = parseUnknownPostings(result.stdout);
     const transactionCount = countTransactions(result.stdout);
     const matchedCount = transactionCount - unknownPostings.length;
+    if (unknownPostings.length > 0) {
+      try {
+        const rulesContent = fs7.readFileSync(rulesFile, "utf-8");
+        const rulesConfig = parseRulesFile(rulesContent);
+        const csvRows = parseCsvFile(csvFile, rulesConfig);
+        for (const posting of unknownPostings) {
+          const csvRow = findMatchingCsvRow({
+            date: posting.date,
+            description: posting.description,
+            amount: posting.amount
+          }, csvRows, rulesConfig);
+          posting.csvRow = csvRow;
+        }
+      } catch {
+        for (const posting of unknownPostings) {
+          posting.csvRow = undefined;
+        }
+      }
+    }
     totalTransactions += transactionCount;
     totalMatched += matchedCount;
     totalUnknown += unknownPostings.length;
@@ -17272,10 +18103,10 @@ async function importStatementsCore(directory, agent, options, configLoader = lo
     const relativePath = path6.relative(pendingDir, csvFile);
     const destPath = path6.join(doneDir, relativePath);
     const destDir = path6.dirname(destPath);
-    if (!fs6.existsSync(destDir)) {
-      fs6.mkdirSync(destDir, { recursive: true });
+    if (!fs7.existsSync(destDir)) {
+      fs7.mkdirSync(destDir, { recursive: true });
     }
-    fs6.renameSync(csvFile, destPath);
+    fs7.renameSync(csvFile, destPath);
   }
   return JSON.stringify({
     success: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzzle/opencode-accountant",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",
@@ -28,6 +28,7 @@
   ],
   "dependencies": {
     "@opencode-ai/plugin": "latest",
+    "convert-csv-to-json": "^3.20.0",
     "js-yaml": "^4.1.0",
     "papaparse": "^5.5.3"
   },