@fuzzle/opencode-accountant 0.0.9 → 0.0.10-next.1

package/dist/index.js

@@ -1340,8 +1340,608 @@ 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 dirname2, join as join5 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -16584,7 +17184,13 @@ 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 = ["import", "pending", "done", "unrecognized"];
+var REQUIRED_PATH_FIELDS = [
+  "import",
+  "pending",
+  "done",
+  "unrecognized",
+  "rules"
+];
 var REQUIRED_DETECTION_FIELDS = ["header", "currencyField"];
 function validatePaths(paths) {
   if (typeof paths !== "object" || paths === null) {
@@ -16600,7 +17206,8 @@ function validatePaths(paths) {
     import: pathsObj.import,
     pending: pathsObj.pending,
     done: pathsObj.done,
-    unrecognized: pathsObj.unrecognized
+    unrecognized: pathsObj.unrecognized,
+    rules: pathsObj.rules
   };
 }
 function validateDetectionRule(providerName, index, rule) {
@@ -16968,15 +17575,600 @@ var classify_statements_default = tool({
     return classifyStatementsCore(directory, agent);
   }
 });
+// src/tools/import-statements.ts
+import * as fs7 from "fs";
+import * as path6 from "path";
+
+// src/utils/rulesMatcher.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function parseSourceDirective(content) {
+  const match = content.match(/^source\s+([^\n#]+)/m);
+  if (!match) {
+    return null;
+  }
+  return match[1].trim();
+}
+function resolveSourcePath(sourcePath, rulesFilePath) {
+  if (path5.isAbsolute(sourcePath)) {
+    return sourcePath;
+  }
+  const rulesDir = path5.dirname(rulesFilePath);
+  return path5.resolve(rulesDir, sourcePath);
+}
+function loadRulesMapping(rulesDir) {
+  const mapping = {};
+  if (!fs5.existsSync(rulesDir)) {
+    return mapping;
+  }
+  const files = fs5.readdirSync(rulesDir);
+  for (const file2 of files) {
+    if (!file2.endsWith(".rules")) {
+      continue;
+    }
+    const rulesFilePath = path5.join(rulesDir, file2);
+    const stat = fs5.statSync(rulesFilePath);
+    if (!stat.isFile()) {
+      continue;
+    }
+    const content = fs5.readFileSync(rulesFilePath, "utf-8");
+    const sourcePath = parseSourceDirective(content);
+    if (!sourcePath) {
+      continue;
+    }
+    const absoluteCsvPath = resolveSourcePath(sourcePath, rulesFilePath);
+    mapping[absoluteCsvPath] = rulesFilePath;
+  }
+  return mapping;
+}
+function findRulesForCsv(csvPath, mapping) {
+  if (mapping[csvPath]) {
+    return mapping[csvPath];
+  }
+  const normalizedCsvPath = path5.normalize(csvPath);
+  for (const [mappedCsv, rulesFile] of Object.entries(mapping)) {
+    if (path5.normalize(mappedCsv) === normalizedCsvPath) {
+      return rulesFile;
+    }
+  }
+  return null;
+}
+
+// src/utils/hledgerExecutor.ts
+var {$: $2 } = globalThis.Bun;
+async function defaultHledgerExecutor(cmdArgs) {
+  try {
+    const result = await $2`hledger ${cmdArgs}`.quiet().nothrow();
+    return {
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+      exitCode: result.exitCode
+    };
+  } catch (error45) {
+    return {
+      stdout: "",
+      stderr: error45 instanceof Error ? error45.message : String(error45),
+      exitCode: 1
+    };
+  }
+}
+function parseUnknownPostings(hledgerOutput) {
+  const unknownPostings = [];
+  const lines = hledgerOutput.split(`
+`);
+  let currentDate = "";
+  let currentDescription = "";
+  for (const line of lines) {
+    const headerMatch = line.match(/^(\d{4}-\d{2}-\d{2})\s+(.+)$/);
+    if (headerMatch) {
+      currentDate = headerMatch[1];
+      currentDescription = headerMatch[2].trim();
+      continue;
+    }
+    const postingMatch = line.match(/^\s+(income:unknown|expenses:unknown)\s+([^\s]+(?:\s+[^\s=]+)?)\s*(?:=\s*(.+))?$/);
+    if (postingMatch && currentDate) {
+      unknownPostings.push({
+        date: currentDate,
+        description: currentDescription,
+        amount: postingMatch[2].trim(),
+        account: postingMatch[1],
+        balance: postingMatch[3]?.trim()
+      });
+    }
+  }
+  return unknownPostings;
+}
+function countTransactions(hledgerOutput) {
+  const lines = hledgerOutput.split(`
+`);
+  let count = 0;
+  for (const line of lines) {
+    if (/^\d{4}-\d{2}-\d{2}\s+/.test(line)) {
+      count++;
+    }
+  }
+  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 (!fs7.existsSync(pendingDir)) {
+    return csvFiles;
+  }
+  let searchPath = pendingDir;
+  if (provider) {
+    searchPath = path6.join(searchPath, provider);
+    if (currency) {
+      searchPath = path6.join(searchPath, currency);
+    }
+  }
+  if (!fs7.existsSync(searchPath)) {
+    return csvFiles;
+  }
+  function scanDirectory(directory) {
+    const entries = fs7.readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path6.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".csv")) {
+        csvFiles.push(fullPath);
+      }
+    }
+  }
+  scanDirectory(searchPath);
+  return csvFiles.sort();
+}
+async function importStatementsCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
+  if (agent !== "accountant") {
+    return JSON.stringify({
+      success: false,
+      error: `This tool is restricted to the accountant agent only. Called by: ${agent || "main assistant"}`,
+      hint: "Use: Task(subagent_type='accountant', prompt='import statements')"
+    });
+  }
+  let config2;
+  try {
+    config2 = configLoader(directory);
+  } catch (error45) {
+    return JSON.stringify({
+      success: false,
+      error: `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`,
+      hint: 'Ensure config/import/providers.yaml exists with required paths including "rules"'
+    });
+  }
+  const pendingDir = path6.join(directory, config2.paths.pending);
+  const rulesDir = path6.join(directory, config2.paths.rules);
+  const doneDir = path6.join(directory, config2.paths.done);
+  const rulesMapping = loadRulesMapping(rulesDir);
+  const csvFiles = findPendingCsvFiles(pendingDir, options.provider, options.currency);
+  if (csvFiles.length === 0) {
+    return JSON.stringify({
+      success: true,
+      files: [],
+      summary: {
+        filesProcessed: 0,
+        filesWithErrors: 0,
+        filesWithoutRules: 0,
+        totalTransactions: 0,
+        matched: 0,
+        unknown: 0
+      },
+      message: "No CSV files found to process"
+    });
+  }
+  const fileResults = [];
+  let totalTransactions = 0;
+  let totalMatched = 0;
+  let totalUnknown = 0;
+  let filesWithErrors = 0;
+  let filesWithoutRules = 0;
+  for (const csvFile of csvFiles) {
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (!rulesFile) {
+      filesWithoutRules++;
+      fileResults.push({
+        csv: path6.relative(directory, csvFile),
+        rulesFile: null,
+        totalTransactions: 0,
+        matchedTransactions: 0,
+        unknownPostings: [],
+        error: "No matching rules file found"
+      });
+      continue;
+    }
+    const result = await hledgerExecutor(["print", "-f", csvFile, "--rules-file", rulesFile]);
+    if (result.exitCode !== 0) {
+      filesWithErrors++;
+      fileResults.push({
+        csv: path6.relative(directory, csvFile),
+        rulesFile: path6.relative(directory, rulesFile),
+        totalTransactions: 0,
+        matchedTransactions: 0,
+        unknownPostings: [],
+        error: `hledger error: ${result.stderr.trim() || "Unknown error"}`
+      });
+      continue;
+    }
+    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;
+    fileResults.push({
+      csv: path6.relative(directory, csvFile),
+      rulesFile: path6.relative(directory, rulesFile),
+      totalTransactions: transactionCount,
+      matchedTransactions: matchedCount,
+      unknownPostings
+    });
+  }
+  const hasUnknowns = totalUnknown > 0;
+  const hasErrors = filesWithErrors > 0 || filesWithoutRules > 0;
+  if (options.checkOnly !== false) {
+    const result = {
+      success: !hasUnknowns && !hasErrors,
+      files: fileResults,
+      summary: {
+        filesProcessed: csvFiles.length,
+        filesWithErrors,
+        filesWithoutRules,
+        totalTransactions,
+        matched: totalMatched,
+        unknown: totalUnknown
+      }
+    };
+    if (hasUnknowns) {
+      result.message = `Found ${totalUnknown} transaction(s) with unknown accounts. Add rules to categorize them.`;
+    } else if (hasErrors) {
+      result.message = `Some files had errors. Check the file results for details.`;
+    } else {
+      result.message = "All transactions matched. Ready to import with checkOnly: false";
+    }
+    return JSON.stringify(result);
+  }
+  if (hasUnknowns || hasErrors) {
+    return JSON.stringify({
+      success: false,
+      files: fileResults,
+      summary: {
+        filesProcessed: csvFiles.length,
+        filesWithErrors,
+        filesWithoutRules,
+        totalTransactions,
+        matched: totalMatched,
+        unknown: totalUnknown
+      },
+      error: "Cannot import: some transactions have unknown accounts or files have errors",
+      hint: "Run with checkOnly: true to see details, then add missing rules"
+    });
+  }
+  const importedFiles = [];
+  for (const csvFile of csvFiles) {
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (!rulesFile)
+      continue;
+    const result = await hledgerExecutor(["import", csvFile, "--rules-file", rulesFile]);
+    if (result.exitCode !== 0) {
+      return JSON.stringify({
+        success: false,
+        files: fileResults,
+        summary: {
+          filesProcessed: csvFiles.length,
+          filesWithErrors: 1,
+          filesWithoutRules,
+          totalTransactions,
+          matched: totalMatched,
+          unknown: totalUnknown
+        },
+        error: `Import failed for ${path6.relative(directory, csvFile)}: ${result.stderr.trim()}`
+      });
+    }
+    importedFiles.push(csvFile);
+  }
+  for (const csvFile of importedFiles) {
+    const relativePath = path6.relative(pendingDir, csvFile);
+    const destPath = path6.join(doneDir, relativePath);
+    const destDir = path6.dirname(destPath);
+    if (!fs7.existsSync(destDir)) {
+      fs7.mkdirSync(destDir, { recursive: true });
+    }
+    fs7.renameSync(csvFile, destPath);
+  }
+  return JSON.stringify({
+    success: true,
+    files: fileResults.map((f) => ({
+      ...f,
+      imported: true
+    })),
+    summary: {
+      filesProcessed: csvFiles.length,
+      filesWithErrors: 0,
+      filesWithoutRules: 0,
+      totalTransactions,
+      matched: totalMatched,
+      unknown: 0
+    },
+    message: `Successfully imported ${totalTransactions} transaction(s) from ${importedFiles.length} file(s)`
+  });
+}
+var import_statements_default = tool({
+  description: `Import classified bank statement CSVs into hledger using rules files.
+
+This tool processes CSV files in the pending import directory and uses hledger's CSV import capabilities with matching rules files.
+
+**Check Mode (checkOnly: true, default):**
+- Runs hledger print to preview transactions
+- Identifies transactions with 'income:unknown' or 'expenses:unknown' accounts
+- These indicate missing rules that need to be added
+
+**Import Mode (checkOnly: false):**
+- First validates all transactions have known accounts
+- If any unknowns exist, aborts and reports them
+- If all clean, imports transactions and moves CSVs to done directory
+
+**Workflow:**
+1. Run with checkOnly: true (or no args)
+2. If unknowns found, add rules to the appropriate .rules file
+3. Repeat until no unknowns
+4. Run with checkOnly: false to import`,
+  args: {
+    provider: tool.schema.string().optional().describe('Filter by provider (e.g., "revolut", "ubs"). If omitted, process all providers.'),
+    currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur"). If omitted, process all currencies for the provider.'),
+    checkOnly: tool.schema.boolean().optional().describe("If true (default), only check for unknown accounts without importing. Set to false to perform actual import.")
+  },
+  async execute(params, context) {
+    const { directory, agent } = context;
+    return importStatementsCore(directory, agent, {
+      provider: params.provider,
+      currency: params.currency,
+      checkOnly: params.checkOnly
+    });
+  }
+});
 // src/index.ts
-var __dirname2 = dirname2(fileURLToPath(import.meta.url));
-var AGENT_FILE = join5(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname4(fileURLToPath(import.meta.url));
+var AGENT_FILE = join7(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
     tool: {
       "update-prices": update_prices_default,
-      "classify-statements": classify_statements_default
+      "classify-statements": classify_statements_default,
+      "import-statements": import_statements_default
     },
     config: async (config2) => {
       if (agent) {