@fuzzle/opencode-accountant 0.0.16 → 0.0.17-next.1

package/dist/index.js

@@ -1342,28 +1342,28 @@ 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");
+  var fs3 = __require("fs");
 
   class FileUtils {
     readFile(fileInputName, encoding) {
-      return fs6.readFileSync(fileInputName, encoding).toString();
+      return fs3.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());
+      if (fs3.promises && typeof fs3.promises.readFile === "function") {
+        return fs3.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
       }
-      return new Promise((resolve2, reject) => {
-        fs6.readFile(fileInputName, encoding, (err, data) => {
+      return new Promise((resolve, reject) => {
+        fs3.readFile(fileInputName, encoding, (err, data) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve2(data.toString());
+          resolve(data.toString());
         });
       });
     }
     writeFile(json3, fileOutputName) {
-      fs6.writeFile(fileOutputName, json3, function(err) {
+      fs3.writeFile(fileOutputName, json3, function(err) {
         if (err) {
           throw err;
         } else {
@@ -1372,14 +1372,14 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFileAsync(json3, fileOutputName) {
-      if (fs6.promises && typeof fs6.promises.writeFile === "function") {
-        return fs6.promises.writeFile(fileOutputName, json3);
+      if (fs3.promises && typeof fs3.promises.writeFile === "function") {
+        return fs3.promises.writeFile(fileOutputName, json3);
       }
-      return new Promise((resolve2, reject) => {
-        fs6.writeFile(fileOutputName, json3, (err) => {
+      return new Promise((resolve, reject) => {
+        fs3.writeFile(fileOutputName, json3, (err) => {
           if (err)
             return reject(err);
-          resolve2();
+          resolve();
         });
       });
     }
@@ -1800,7 +1800,7 @@ var require_browserApi = __commonJS((exports, module) => {
       if (!file2) {
         return Promise.reject(new Error("file is not defined!!!"));
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         if (typeof FileReader === "undefined") {
           reject(new Error("FileReader is not available in this environment"));
           return;
@@ -1811,7 +1811,7 @@ var require_browserApi = __commonJS((exports, module) => {
           try {
             const text = reader.result;
             const result = this.csvToJson.csvToJson(String(text));
-            resolve2(result);
+            resolve(result);
           } catch (err) {
             reject(err);
           }
@@ -1941,7 +1941,7 @@ var require_convert_csv_to_json = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -16981,6 +16981,21 @@ var {$ } = globalThis.Bun;
 import * as path2 from "path";
 import * as fs2 from "fs";
 
+// src/utils/agentRestriction.ts
+function checkAccountantAgent(agent, toolPrompt, additionalFields) {
+  if (agent === "accountant") {
+    return null;
+  }
+  const errorResponse = {
+    success: false,
+    error: "This tool is restricted to the accountant agent only.",
+    hint: `Use: Task(subagent_type='accountant', prompt='${toolPrompt}')`,
+    caller: agent || "main assistant",
+    ...additionalFields
+  };
+  return JSON.stringify(errorResponse);
+}
+
 // src/utils/pricesConfig.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -17090,12 +17105,9 @@ function updateJournalWithPrices(journalPath, newPriceLines) {
 `);
 }
 async function updatePricesCore(directory, agent, backfill, priceFetcher = defaultPriceFetcher, configLoader = loadPricesConfig) {
-  if (agent !== "accountant") {
-    return JSON.stringify({
-      error: "This tool is restricted to the accountant agent only.",
-      hint: "Use: Task(subagent_type='accountant', prompt='update prices')",
-      caller: agent || "main assistant"
-    });
+  const restrictionError = checkAccountantAgent(agent, "update prices");
+  if (restrictionError) {
+    return restrictionError;
   }
   let config2;
   try {
@@ -17176,1130 +17188,20 @@ var update_prices_default = tool({
     return updatePricesCore(directory, agent, backfill || false);
   }
 });
-// src/tools/classify-statements.ts
-import * as path4 from "path";
-import * as fs4 from "fs";
-
-// src/utils/importConfig.ts
-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",
-  "rules"
-];
-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");
-  }
-  const pathsObj = paths;
-  for (const field of REQUIRED_PATH_FIELDS) {
-    if (typeof pathsObj[field] !== "string" || pathsObj[field] === "") {
-      throw new Error(`Invalid config: 'paths.${field}' is required`);
-    }
-  }
-  return {
-    import: pathsObj.import,
-    pending: pathsObj.pending,
-    done: pathsObj.done,
-    unrecognized: pathsObj.unrecognized,
-    rules: pathsObj.rules
-  };
-}
-function validateDetectionRule(providerName, index, rule) {
-  if (typeof rule !== "object" || rule === null) {
-    throw new Error(`Invalid config: provider '${providerName}' detect[${index}] must be an object`);
-  }
-  const ruleObj = rule;
-  for (const field of REQUIRED_DETECTION_FIELDS) {
-    if (typeof ruleObj[field] !== "string" || ruleObj[field] === "") {
-      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].${field} is required`);
-    }
-  }
-  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,
-    skipRows: ruleObj.skipRows,
-    delimiter: ruleObj.delimiter,
-    renamePattern: ruleObj.renamePattern,
-    metadata: ruleObj.metadata
-  };
-}
-function validateProviderConfig(name, config2) {
-  if (typeof config2 !== "object" || config2 === null) {
-    throw new Error(`Invalid config for provider '${name}': expected an object`);
-  }
-  const configObj = config2;
-  if (!Array.isArray(configObj.detect) || configObj.detect.length === 0) {
-    throw new Error(`Invalid config for provider '${name}': 'detect' must be a non-empty array`);
-  }
-  const detect = [];
-  for (let i2 = 0;i2 < configObj.detect.length; i2++) {
-    detect.push(validateDetectionRule(name, i2, configObj.detect[i2]));
-  }
-  if (typeof configObj.currencies !== "object" || configObj.currencies === null) {
-    throw new Error(`Invalid config for provider '${name}': 'currencies' must be an object`);
-  }
-  const currenciesObj = configObj.currencies;
-  const currencies = {};
-  for (const [key, value] of Object.entries(currenciesObj)) {
-    if (typeof value !== "string") {
-      throw new Error(`Invalid config for provider '${name}': currencies.${key} must be a string`);
-    }
-    currencies[key] = value;
-  }
-  if (Object.keys(currencies).length === 0) {
-    throw new Error(`Invalid config for provider '${name}': 'currencies' must contain at least one mapping`);
-  }
-  return { detect, currencies };
-}
-function loadImportConfig(directory) {
-  const configPath = path3.join(directory, CONFIG_FILE2);
-  if (!fs3.existsSync(configPath)) {
-    throw new Error(`Configuration file not found: ${CONFIG_FILE2}. Please create this file to configure statement imports.`);
-  }
-  let parsed;
-  try {
-    const content = fs3.readFileSync(configPath, "utf-8");
-    parsed = jsYaml.load(content);
-  } catch (err) {
-    if (err instanceof jsYaml.YAMLException) {
-      throw new Error(`Failed to parse ${CONFIG_FILE2}: ${err.message}`);
-    }
-    throw err;
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`Invalid config: ${CONFIG_FILE2} must contain a YAML object`);
-  }
-  const parsedObj = parsed;
-  if (!parsedObj.paths) {
-    throw new Error("Invalid config: 'paths' section is required");
-  }
-  const paths = validatePaths(parsedObj.paths);
-  if (!parsedObj.providers || typeof parsedObj.providers !== "object") {
-    throw new Error("Invalid config: 'providers' section is required");
-  }
-  const providersObj = parsedObj.providers;
-  if (Object.keys(providersObj).length === 0) {
-    throw new Error("Invalid config: 'providers' section must contain at least one provider");
-  }
-  const providers = {};
-  for (const [name, config2] of Object.entries(providersObj)) {
-    providers[name] = validateProviderConfig(name, config2);
-  }
-  return { paths, providers };
-}
-
 // src/utils/providerDetector.ts
 var import_papaparse = __toESM(require_papaparse(), 1);
-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,
-    delimiter
-  });
-  return {
-    fields: result.meta.fields,
-    firstRow: result.data[0]
-  };
-}
-function normalizeHeader(fields) {
-  return fields.map((f) => f.trim()).join(",");
-}
-function detectProvider(filename, content, config2) {
-  for (const [providerName, providerConfig] of Object.entries(config2.providers)) {
-    for (const rule of providerConfig.detect) {
-      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;
-      }
-      if (!firstRow) {
-        continue;
-      }
-      const rawCurrency = firstRow[rule.currencyField];
-      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,
-          outputFilename,
-          metadata: Object.keys(metadata).length > 0 ? metadata : undefined
-        };
-      }
-      return {
-        provider: providerName,
-        currency: normalizedCurrency,
-        rule,
-        outputFilename,
-        metadata: Object.keys(metadata).length > 0 ? metadata : undefined
-      };
-    }
-  }
-  return null;
-}
-
-// src/tools/classify-statements.ts
-function findCSVFiles(importsDir) {
-  if (!fs4.existsSync(importsDir)) {
-    return [];
-  }
-  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
-    const fullPath = path4.join(importsDir, file2);
-    return fs4.statSync(fullPath).isFile();
-  });
-}
-function ensureDirectory(dirPath) {
-  if (!fs4.existsSync(dirPath)) {
-    fs4.mkdirSync(dirPath, { recursive: true });
-  }
-}
-async function classifyStatementsCore(directory, agent, configLoader = loadImportConfig) {
-  if (agent !== "accountant") {
-    return JSON.stringify({
-      success: false,
-      error: "This tool is restricted to the accountant agent only.",
-      hint: "Use: Task(subagent_type='accountant', prompt='classify statements')",
-      caller: agent || "main assistant",
-      classified: [],
-      unrecognized: []
-    });
-  }
-  let config2;
-  try {
-    config2 = configLoader(directory);
-  } catch (err) {
-    return JSON.stringify({
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-      classified: [],
-      unrecognized: []
-    });
-  }
-  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 csvFiles = findCSVFiles(importsDir);
-  if (csvFiles.length === 0) {
-    return JSON.stringify({
-      success: true,
-      classified: [],
-      unrecognized: [],
-      message: `No CSV files found in ${config2.paths.import}`
-    });
-  }
-  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);
-      fs4.renameSync(move.sourcePath, move.targetPath);
-      classified.push({
-        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);
-      fs4.renameSync(move.sourcePath, move.targetPath);
-      unrecognized.push({
-        filename: move.filename,
-        targetPath: path4.join(config2.paths.unrecognized, move.filename)
-      });
-    }
-  }
-  return JSON.stringify({
-    success: true,
-    classified,
-    unrecognized,
-    summary: {
-      total: csvFiles.length,
-      classified: classified.length,
-      unrecognized: unrecognized.length
-    }
-  });
-}
-var classify_statements_default = tool({
-  description: "ACCOUNTANT AGENT ONLY: Classifies bank statement CSV files from the imports directory by detecting their provider and currency, then moves them to the appropriate pending import directories.",
-  args: {},
-  async execute(_params, context) {
-    const { directory, agent } = context;
-    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;
-}
-function extractTransactionYears(hledgerOutput) {
-  const years = new Set;
-  const lines = hledgerOutput.split(`
-`);
-  for (const line of lines) {
-    const match = line.match(/^(\d{4})-\d{2}-\d{2}\s+/);
-    if (match) {
-      years.add(parseInt(match[1], 10));
-    }
-  }
-  return years;
-}
-async function validateLedger(mainJournalPath, executor = defaultHledgerExecutor) {
-  const errors3 = [];
-  const checkResult = await executor(["check", "--strict", "-f", mainJournalPath]);
-  if (checkResult.exitCode !== 0) {
-    const errorMsg = checkResult.stderr.trim() || checkResult.stdout.trim();
-    errors3.push(`hledger check --strict failed: ${errorMsg}`);
-  }
-  const balResult = await executor(["bal", "-f", mainJournalPath]);
-  if (balResult.exitCode !== 0) {
-    const errorMsg = balResult.stderr.trim() || balResult.stdout.trim();
-    errors3.push(`hledger bal failed: ${errorMsg}`);
-  }
-  return { valid: errors3.length === 0, errors: errors3 };
-}
-
-// 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 ensureYearJournalExists(directory, year) {
-  const ledgerDir = path6.join(directory, "ledger");
-  const yearJournalPath = path6.join(ledgerDir, `${year}.journal`);
-  const mainJournalPath = path6.join(directory, ".hledger.journal");
-  if (!fs7.existsSync(ledgerDir)) {
-    fs7.mkdirSync(ledgerDir, { recursive: true });
-  }
-  if (!fs7.existsSync(yearJournalPath)) {
-    fs7.writeFileSync(yearJournalPath, `; ${year} transactions
-`);
-  }
-  if (!fs7.existsSync(mainJournalPath)) {
-    throw new Error(`.hledger.journal not found at ${mainJournalPath}. Create it first with appropriate includes.`);
-  }
-  const mainJournalContent = fs7.readFileSync(mainJournalPath, "utf-8");
-  const includeDirective = `include ledger/${year}.journal`;
-  const lines = mainJournalContent.split(`
-`);
-  const includeExists = lines.some((line) => {
-    const trimmed = line.trim();
-    return trimmed === includeDirective || trimmed.startsWith(includeDirective + " ");
-  });
-  if (!includeExists) {
-    const newContent = mainJournalContent.trimEnd() + `
-` + includeDirective + `
-`;
-    fs7.writeFileSync(mainJournalPath, newContent);
-  }
-  return yearJournalPath;
-}
-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;
-    const years = extractTransactionYears(result.stdout);
-    if (years.size > 1) {
-      const yearList = Array.from(years).sort().join(", ");
-      filesWithErrors++;
-      fileResults.push({
-        csv: path6.relative(directory, csvFile),
-        rulesFile: path6.relative(directory, rulesFile),
-        totalTransactions: transactionCount,
-        matchedTransactions: matchedCount,
-        unknownPostings: [],
-        error: `CSV contains transactions from multiple years (${yearList}). Split the CSV by year before importing.`
-      });
-      continue;
-    }
-    const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
-    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) {
-          posting.csvRow = findMatchingCsvRow({
-            date: posting.date,
-            description: posting.description,
-            amount: posting.amount
-          }, csvRows, rulesConfig);
-        }
-      } 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,
-      transactionYear
-    });
-  }
-  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 fileResult of fileResults) {
-    const csvFile = path6.join(directory, fileResult.csv);
-    const rulesFile = fileResult.rulesFile ? path6.join(directory, fileResult.rulesFile) : null;
-    if (!rulesFile)
-      continue;
-    const year = fileResult.transactionYear;
-    if (!year) {
-      return JSON.stringify({
-        success: false,
-        files: fileResults,
-        summary: {
-          filesProcessed: csvFiles.length,
-          filesWithErrors: 1,
-          filesWithoutRules,
-          totalTransactions,
-          matched: totalMatched,
-          unknown: totalUnknown
-        },
-        error: `No transactions found in ${fileResult.csv}`
-      });
-    }
-    let yearJournalPath;
-    try {
-      yearJournalPath = ensureYearJournalExists(directory, year);
-    } catch (error45) {
-      return JSON.stringify({
-        success: false,
-        files: fileResults,
-        summary: {
-          filesProcessed: csvFiles.length,
-          filesWithErrors: 1,
-          filesWithoutRules,
-          totalTransactions,
-          matched: totalMatched,
-          unknown: totalUnknown
-        },
-        error: error45 instanceof Error ? error45.message : String(error45)
-      });
-    }
-    const result = await hledgerExecutor([
-      "import",
-      "-f",
-      yearJournalPath,
-      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 ${fileResult.csv}: ${result.stderr.trim()}`
-      });
-    }
-    importedFiles.push(csvFile);
-  }
-  const mainJournalPath = path6.join(directory, ".hledger.journal");
-  const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
-  if (!validationResult.valid) {
-    return JSON.stringify({
-      success: false,
-      files: fileResults,
-      summary: {
-        filesProcessed: csvFiles.length,
-        filesWithErrors: 1,
-        filesWithoutRules,
-        totalTransactions,
-        matched: totalMatched,
-        unknown: totalUnknown
-      },
-      error: `Ledger validation failed after import: ${validationResult.errors.join("; ")}`,
-      hint: "The import created invalid transactions. Check your rules file configuration (e.g., balance vs balance2 for balance assertions). CSV files have NOT been moved to done."
-    });
-  }
-  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 = dirname4(fileURLToPath(import.meta.url));
-var AGENT_FILE = join7(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var AGENT_FILE = join3(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
     tool: {
       "update-prices": update_prices_default,
-      "classify-statements": classify_statements_default,
-      "import-statements": import_statements_default
+      "classify-statements": classifyStatements,
+      "import-statements": importStatements
     },
     config: async (config2) => {
       if (agent) {