@fuzzle/opencode-accountant 0.1.0 → 0.1.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 fs3 = __require("fs");
+  var fs8 = __require("fs");
 
   class FileUtils {
     readFile(fileInputName, encoding) {
-      return fs3.readFileSync(fileInputName, encoding).toString();
+      return fs8.readFileSync(fileInputName, encoding).toString();
     }
     readFileAsync(fileInputName, encoding = "utf8") {
-      if (fs3.promises && typeof fs3.promises.readFile === "function") {
-        return fs3.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
+      if (fs8.promises && typeof fs8.promises.readFile === "function") {
+        return fs8.promises.readFile(fileInputName, encoding).then((buf) => buf.toString());
       }
-      return new Promise((resolve, reject) => {
-        fs3.readFile(fileInputName, encoding, (err, data) => {
+      return new Promise((resolve2, reject) => {
+        fs8.readFile(fileInputName, encoding, (err, data) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve(data.toString());
+          resolve2(data.toString());
         });
       });
     }
     writeFile(json3, fileOutputName) {
-      fs3.writeFile(fileOutputName, json3, function(err) {
+      fs8.writeFile(fileOutputName, json3, function(err) {
         if (err) {
           throw err;
         } else {
@@ -1372,14 +1372,14 @@ var require_fileUtils = __commonJS((exports, module) => {
       });
     }
     writeFileAsync(json3, fileOutputName) {
-      if (fs3.promises && typeof fs3.promises.writeFile === "function") {
-        return fs3.promises.writeFile(fileOutputName, json3);
+      if (fs8.promises && typeof fs8.promises.writeFile === "function") {
+        return fs8.promises.writeFile(fileOutputName, json3);
       }
-      return new Promise((resolve, reject) => {
-        fs3.writeFile(fileOutputName, json3, (err) => {
+      return new Promise((resolve2, reject) => {
+        fs8.writeFile(fileOutputName, json3, (err) => {
           if (err)
             return reject(err);
-          resolve();
+          resolve2();
         });
       });
     }
@@ -1800,7 +1800,7 @@ var require_browserApi = __commonJS((exports, module) => {
       if (!file2) {
         return Promise.reject(new Error("file is not defined!!!"));
       }
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, 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));
-            resolve(result);
+            resolve2(result);
           } catch (err) {
             reject(err);
           }
@@ -1941,7 +1941,7 @@ var require_convert_csv_to_json = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { dirname, join as join3 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -16976,10 +16976,9 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
-// src/tools/update-prices.ts
+// src/tools/fetch-currency-prices.ts
 var {$ } = globalThis.Bun;
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path3 from "path";
 
 // src/utils/agentRestriction.ts
 function checkAccountantAgent(agent, toolPrompt, additionalFields) {
@@ -17056,15 +17055,141 @@ function loadPricesConfig(directory) {
   return { currencies };
 }
 
-// src/tools/update-prices.ts
-async function defaultPriceFetcher(cmdArgs) {
-  const result = await $`pricehist ${cmdArgs}`.quiet();
-  return result.stdout.toString().trim();
+// src/utils/journalUtils.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function extractDateFromPriceLine(line) {
+  return line.split(" ")[1];
+}
+function updatePriceJournal(journalPath, newPriceLines) {
+  let existingLines = [];
+  if (fs2.existsSync(journalPath)) {
+    existingLines = fs2.readFileSync(journalPath, "utf-8").split(`
+`).filter((line) => line.trim() !== "");
+  }
+  const priceMap = new Map;
+  for (const line of existingLines) {
+    const date5 = extractDateFromPriceLine(line);
+    if (date5)
+      priceMap.set(date5, line);
+  }
+  for (const line of newPriceLines) {
+    const date5 = extractDateFromPriceLine(line);
+    if (date5)
+      priceMap.set(date5, line);
+  }
+  const sortedLines = Array.from(priceMap.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, line]) => line);
+  fs2.writeFileSync(journalPath, sortedLines.join(`
+`) + `
+`);
+}
+function findCsvFiles(directory, provider, currency) {
+  const csvFiles = [];
+  if (!fs2.existsSync(directory)) {
+    return csvFiles;
+  }
+  let searchPath = directory;
+  if (provider) {
+    searchPath = path2.join(searchPath, provider);
+    if (currency) {
+      searchPath = path2.join(searchPath, currency);
+    }
+  }
+  if (!fs2.existsSync(searchPath)) {
+    return csvFiles;
+  }
+  function scanDirectory(dir) {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".csv")) {
+        csvFiles.push(fullPath);
+      }
+    }
+  }
+  scanDirectory(searchPath);
+  return csvFiles.sort();
+}
+function ensureYearJournalExists(directory, year) {
+  const ledgerDir = path2.join(directory, "ledger");
+  const yearJournalPath = path2.join(ledgerDir, `${year}.journal`);
+  const mainJournalPath = path2.join(directory, ".hledger.journal");
+  if (!fs2.existsSync(ledgerDir)) {
+    fs2.mkdirSync(ledgerDir, { recursive: true });
+  }
+  if (!fs2.existsSync(yearJournalPath)) {
+    fs2.writeFileSync(yearJournalPath, `; ${year} transactions
+`);
+  }
+  if (!fs2.existsSync(mainJournalPath)) {
+    throw new Error(`.hledger.journal not found at ${mainJournalPath}. Create it first with appropriate includes.`);
+  }
+  const mainJournalContent = fs2.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 + `
+`;
+    fs2.writeFileSync(mainJournalPath, newContent);
+  }
+  return yearJournalPath;
+}
+
+// src/utils/dateUtils.ts
+function formatDateISO(date5) {
+  return date5.toISOString().split("T")[0];
 }
 function getYesterday() {
   const d = new Date;
   d.setDate(d.getDate() - 1);
-  return d.toISOString().split("T")[0];
+  return formatDateISO(d);
+}
+function getNextDay(dateStr) {
+  const date5 = new Date(dateStr);
+  date5.setDate(date5.getDate() + 1);
+  return formatDateISO(date5);
+}
+
+// src/tools/fetch-currency-prices.ts
+async function defaultPriceFetcher(cmdArgs) {
+  const result = await $`pricehist ${cmdArgs}`.quiet();
+  return result.stdout.toString().trim();
+}
+function buildPricehistArgs(startDate, endDate, currencyConfig) {
+  const cmdArgs = [
+    "fetch",
+    "-o",
+    "ledger",
+    "-s",
+    startDate,
+    "-e",
+    endDate,
+    currencyConfig.source,
+    currencyConfig.pair
+  ];
+  if (currencyConfig.fmt_base) {
+    cmdArgs.push("--fmt-base", currencyConfig.fmt_base);
+  }
+  return cmdArgs;
+}
+function buildErrorResult(error45) {
+  return JSON.stringify({ error: error45 });
+}
+function buildSuccessResult(results, endDate, backfill) {
+  return JSON.stringify({
+    success: results.every((r) => !("error" in r)),
+    endDate,
+    backfill,
+    results
+  });
 }
 function parsePriceLine(line) {
   const match = line.match(/^P (\d{4}-\d{2}-\d{2})(?: \d{2}:\d{2}:\d{2})? .+$/);
@@ -17082,30 +17207,8 @@ function filterPriceLinesByDateRange(priceLines, startDate, endDate) {
     return parsed.date >= startDate && parsed.date <= endDate;
   }).sort((a, b) => a.date.localeCompare(b.date)).map((parsed) => parsed.formattedLine);
 }
-function updateJournalWithPrices(journalPath, newPriceLines) {
-  let existingLines = [];
-  if (fs2.existsSync(journalPath)) {
-    existingLines = fs2.readFileSync(journalPath, "utf-8").split(`
-`).filter((line) => line.trim() !== "");
-  }
-  const priceMap = new Map;
-  for (const line of existingLines) {
-    const date5 = line.split(" ")[1];
-    if (date5)
-      priceMap.set(date5, line);
-  }
-  for (const line of newPriceLines) {
-    const date5 = line.split(" ")[1];
-    if (date5)
-      priceMap.set(date5, line);
-  }
-  const sortedLines = Array.from(priceMap.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, line]) => line);
-  fs2.writeFileSync(journalPath, sortedLines.join(`
-`) + `
-`);
-}
-async function updatePricesCore(directory, agent, backfill, priceFetcher = defaultPriceFetcher, configLoader = loadPricesConfig) {
-  const restrictionError = checkAccountantAgent(agent, "update prices");
+async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = defaultPriceFetcher, configLoader = loadPricesConfig) {
+  const restrictionError = checkAccountantAgent(agent, "fetch currency prices");
   if (restrictionError) {
     return restrictionError;
   }
@@ -17113,9 +17216,8 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
   try {
     config2 = configLoader(directory);
   } catch (err) {
-    return JSON.stringify({
-      error: err instanceof Error ? err.message : String(err)
-    });
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return buildErrorResult(errorMessage);
   }
   const endDate = getYesterday();
   const defaultBackfillDate = getDefaultBackfillDate();
@@ -17123,20 +17225,7 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
   for (const [ticker, currencyConfig] of Object.entries(config2.currencies)) {
     try {
       const startDate = backfill ? currencyConfig.backfill_date || defaultBackfillDate : endDate;
-      const cmdArgs = [
-        "fetch",
-        "-o",
-        "ledger",
-        "-s",
-        startDate,
-        "-e",
-        endDate,
-        currencyConfig.source,
-        currencyConfig.pair
-      ];
-      if (currencyConfig.fmt_base) {
-        cmdArgs.push("--fmt-base", currencyConfig.fmt_base);
-      }
+      const cmdArgs = buildPricehistArgs(startDate, endDate, currencyConfig);
       const output = await priceFetcher(cmdArgs);
       const rawPriceLines = output.split(`
 `).filter((line) => line.startsWith("P "));
@@ -17155,8 +17244,8 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
         });
         continue;
       }
-      const journalPath = path2.join(directory, "ledger", "currencies", currencyConfig.file);
-      updateJournalWithPrices(journalPath, priceLines);
+      const journalPath = path3.join(directory, "ledger", "currencies", currencyConfig.file);
+      updatePriceJournal(journalPath, priceLines);
       const latestPriceLine = priceLines[priceLines.length - 1];
       results.push({
         ticker,
@@ -17170,14 +17259,9 @@ async function updatePricesCore(directory, agent, backfill, priceFetcher = defau
       });
     }
   }
-  return JSON.stringify({
-    success: results.every((r) => !("error" in r)),
-    endDate,
-    backfill: !!backfill,
-    results
-  });
+  return buildSuccessResult(results, endDate, backfill);
 }
-var update_prices_default = tool({
+var fetch_currency_prices_default = tool({
   description: "ACCOUNTANT AGENT ONLY: Fetches end-of-day prices for all configured currencies (from config/prices.yaml) and appends them to the corresponding price journals in ledger/currencies/.",
   args: {
     backfill: tool.schema.boolean().optional().describe("If true, fetch history from each currency's configured backfill_date (or Jan 1 of current year if not specified)")
@@ -17185,23 +17269,1442 @@ var update_prices_default = tool({
   async execute(params, context) {
     const { directory, agent } = context;
     const { backfill } = params;
-    return updatePricesCore(directory, agent, backfill || false);
+    return fetchCurrencyPrices(directory, agent, backfill || false);
   }
 });
+// src/tools/classify-statements.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+
+// src/utils/importConfig.ts
+import * as fs3 from "fs";
+import * as path4 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 = path4.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);
-// src/utils/csvParser.ts
-var import_convert_csv_to_json = __toESM(require_convert_csv_to_json(), 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/utils/worktreeManager.ts
+import { spawnSync } from "child_process";
+function execGit(args, cwd) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || result.stdout || `git ${args[0]} failed`);
+  }
+  return (result.stdout || "").trim();
+}
+function isInWorktree(directory) {
+  try {
+    const gitDir = execGit(["rev-parse", "--git-dir"], directory);
+    return gitDir.includes(".git/worktrees/");
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/fileUtils.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+function findCSVFiles(importsDir) {
+  if (!fs4.existsSync(importsDir)) {
+    return [];
+  }
+  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
+    const fullPath = path5.join(importsDir, file2);
+    return fs4.statSync(fullPath).isFile();
+  });
+}
+function ensureDirectory(dirPath) {
+  if (!fs4.existsSync(dirPath)) {
+    fs4.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+// src/tools/classify-statements.ts
+function buildSuccessResult2(classified, unrecognized, message) {
+  return JSON.stringify({
+    success: true,
+    classified,
+    unrecognized,
+    message,
+    summary: {
+      total: classified.length + unrecognized.length,
+      classified: classified.length,
+      unrecognized: unrecognized.length
+    }
+  });
+}
+function buildErrorResult2(error45, hint) {
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    hint,
+    classified: [],
+    unrecognized: []
+  });
+}
+function buildCollisionError(collisions) {
+  const error45 = `Cannot classify: ${collisions.length} file(s) would overwrite existing pending files.`;
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    collisions,
+    classified: [],
+    unrecognized: []
+  });
+}
+function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
+  const plannedMoves = [];
+  const collisions = [];
+  for (const filename of csvFiles) {
+    const sourcePath = path6.join(importsDir, filename);
+    const content = fs5.readFileSync(sourcePath, "utf-8");
+    const detection = detectProvider(filename, content, config2);
+    let targetPath;
+    let targetFilename;
+    if (detection) {
+      targetFilename = detection.outputFilename || filename;
+      const targetDir = path6.join(pendingDir, detection.provider, detection.currency);
+      targetPath = path6.join(targetDir, targetFilename);
+    } else {
+      targetFilename = filename;
+      targetPath = path6.join(unrecognizedDir, filename);
+    }
+    if (fs5.existsSync(targetPath)) {
+      collisions.push({
+        filename,
+        existingPath: targetPath
+      });
+    }
+    plannedMoves.push({
+      filename,
+      sourcePath,
+      targetPath,
+      targetFilename,
+      detection
+    });
+  }
+  return { plannedMoves, collisions };
+}
+function executeMoves(plannedMoves, config2, unrecognizedDir) {
+  const classified = [];
+  const unrecognized = [];
+  for (const move of plannedMoves) {
+    if (move.detection) {
+      const targetDir = path6.dirname(move.targetPath);
+      ensureDirectory(targetDir);
+      fs5.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: path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename)
+      });
+    } else {
+      ensureDirectory(unrecognizedDir);
+      fs5.renameSync(move.sourcePath, move.targetPath);
+      unrecognized.push({
+        filename: move.filename,
+        targetPath: path6.join(config2.paths.unrecognized, move.filename)
+      });
+    }
+  }
+  return { classified, unrecognized };
+}
+async function classifyStatements(directory, agent, configLoader = loadImportConfig, worktreeChecker = isInWorktree) {
+  const restrictionError = checkAccountantAgent(agent, "classify statements", {
+    classified: [],
+    unrecognized: []
+  });
+  if (restrictionError) {
+    return restrictionError;
+  }
+  if (!worktreeChecker(directory)) {
+    return buildErrorResult2("classify-statements must be run inside an import worktree", "Use import-pipeline tool to orchestrate the full workflow");
+  }
+  let config2;
+  try {
+    config2 = configLoader(directory);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return buildErrorResult2(errorMessage);
+  }
+  const importsDir = path6.join(directory, config2.paths.import);
+  const pendingDir = path6.join(directory, config2.paths.pending);
+  const unrecognizedDir = path6.join(directory, config2.paths.unrecognized);
+  const csvFiles = findCSVFiles(importsDir);
+  if (csvFiles.length === 0) {
+    return buildSuccessResult2([], [], `No CSV files found in ${config2.paths.import}`);
+  }
+  const { plannedMoves, collisions } = planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2);
+  if (collisions.length > 0) {
+    return buildCollisionError(collisions);
+  }
+  const { classified, unrecognized } = executeMoves(plannedMoves, config2, unrecognizedDir);
+  return buildSuccessResult2(classified, unrecognized);
+}
+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 classifyStatements(directory, agent);
+  }
+});
+// src/tools/import-statements.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
+
+// src/utils/rulesMatcher.ts
+import * as fs6 from "fs";
+import * as path7 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 (path7.isAbsolute(sourcePath)) {
+    return sourcePath;
+  }
+  const rulesDir = path7.dirname(rulesFilePath);
+  return path7.resolve(rulesDir, sourcePath);
+}
+function loadRulesMapping(rulesDir) {
+  const mapping = {};
+  if (!fs6.existsSync(rulesDir)) {
+    return mapping;
+  }
+  const files = fs6.readdirSync(rulesDir);
+  for (const file2 of files) {
+    if (!file2.endsWith(".rules")) {
+      continue;
+    }
+    const rulesFilePath = path7.join(rulesDir, file2);
+    const stat = fs6.statSync(rulesFilePath);
+    if (!stat.isFile()) {
+      continue;
+    }
+    const content = fs6.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 = path7.normalize(csvPath);
+  for (const [mappedCsv, rulesFile] of Object.entries(mapping)) {
+    if (path7.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 };
+}
+async function getLastTransactionDate(mainJournalPath, account, executor = defaultHledgerExecutor) {
+  const result = await executor(["register", account, "-f", mainJournalPath, "-O", "csv"]);
+  if (result.exitCode !== 0 || !result.stdout.trim()) {
+    return null;
+  }
+  const lines = result.stdout.trim().split(`
+`);
+  if (lines.length < 2) {
+    return null;
+  }
+  const lastLine = lines[lines.length - 1];
+  const match = lastLine.match(/^"?\d+"?,"?(\d{4}-\d{2}-\d{2})"?/);
+  return match ? match[1] : null;
+}
+async function getAccountBalance(mainJournalPath, account, asOfDate, executor = defaultHledgerExecutor) {
+  const nextDay = getNextDay(asOfDate);
+  const result = await executor([
+    "bal",
+    account,
+    "-f",
+    mainJournalPath,
+    "-e",
+    nextDay,
+    "-N",
+    "--flat"
+  ]);
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  const output = result.stdout.trim();
+  if (!output) {
+    return "0";
+  }
+  const match = output.match(/^\s*(.+?)\s{2,}/);
+  return match ? match[1].trim() : output.trim();
+}
+
+// src/utils/rulesParser.ts
+import * as fs7 from "fs";
+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 parseAccount1(rulesContent) {
+  const match = rulesContent.match(/^account1\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+function getAccountFromRulesFile(rulesFilePath) {
+  try {
+    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    return parseAccount1(content);
+  } catch {
+    return null;
+  }
+}
+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 fs8 from "fs";
+
+// src/utils/balanceUtils.ts
+function parseAmountValue(amountStr) {
+  const cleaned = amountStr.replace(/[A-Z]{3}\s*/g, "").replace(/,/g, "").trim();
+  return parseFloat(cleaned) || 0;
+}
+function parseBalance(balance) {
+  const match = balance.match(/([A-Z]{3})\s*([-\d.,]+)|([+-]?[\d.,]+)\s*([A-Z]{3})/);
+  if (!match) {
+    const numMatch = balance.match(/^([+-]?[\d.,]+)$/);
+    if (numMatch) {
+      return { currency: "", amount: parseFloat(numMatch[1].replace(/,/g, "")) };
+    }
+    return null;
+  }
+  const currency = match[1] || match[4];
+  const amountStr = match[2] || match[3];
+  const amount = parseFloat(amountStr.replace(/,/g, ""));
+  return { currency, amount };
+}
+function calculateDifference(expected, actual) {
+  const expectedParsed = parseBalance(expected);
+  const actualParsed = parseBalance(actual);
+  if (!expectedParsed || !actualParsed) {
+    throw new Error(`Cannot parse balances: expected="${expected}", actual="${actual}"`);
+  }
+  if (expectedParsed.currency && actualParsed.currency && expectedParsed.currency !== actualParsed.currency) {
+    throw new Error(`Currency mismatch: expected ${expectedParsed.currency}, got ${actualParsed.currency}`);
+  }
+  const diff = actualParsed.amount - expectedParsed.amount;
+  const sign = diff >= 0 ? "+" : "";
+  const currency = expectedParsed.currency || actualParsed.currency;
+  return currency ? `${currency} ${sign}${diff.toFixed(2)}` : `${sign}${diff.toFixed(2)}`;
+}
+function balancesMatch(balance1, balance2) {
+  const parsed1 = parseBalance(balance1);
+  const parsed2 = parseBalance(balance2);
+  if (!parsed1 || !parsed2) {
+    return false;
+  }
+  if (parsed1.currency && parsed2.currency && parsed1.currency !== parsed2.currency) {
+    throw new Error(`Currency mismatch: ${parsed1.currency} vs ${parsed2.currency}`);
+  }
+  return parsed1.amount === parsed2.amount;
+}
+
+// src/utils/csvParser.ts
+function parseCsvFile(csvPath, config2) {
+  const csvContent = fs8.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 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 buildErrorResult3(error45, hint) {
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    hint
+  });
+}
+function buildErrorResultWithDetails(error45, files, summary, hint) {
+  return JSON.stringify({
+    success: false,
+    error: error45,
+    hint,
+    files,
+    summary
+  });
+}
+function buildSuccessResult3(files, summary, message) {
+  return JSON.stringify({
+    success: true,
+    files,
+    summary,
+    message
+  });
+}
+async function executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor) {
+  const importedFiles = [];
+  for (const fileResult of fileResults) {
+    const csvFile = path8.join(directory, fileResult.csv);
+    const rulesFile = fileResult.rulesFile ? path8.join(directory, fileResult.rulesFile) : null;
+    if (!rulesFile)
+      continue;
+    const year = fileResult.transactionYear;
+    if (!year) {
+      return {
+        success: false,
+        error: `No transactions found in ${fileResult.csv}`
+      };
+    }
+    let yearJournalPath;
+    try {
+      yearJournalPath = ensureYearJournalExists(directory, year);
+    } catch (error45) {
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+    const result = await hledgerExecutor([
+      "import",
+      "-f",
+      yearJournalPath,
+      csvFile,
+      "--rules-file",
+      rulesFile
+    ]);
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        error: `Import failed for ${fileResult.csv}: ${result.stderr.trim()}`
+      };
+    }
+    importedFiles.push(csvFile);
+  }
+  const mainJournalPath = path8.join(directory, ".hledger.journal");
+  const validationResult = await validateLedger(mainJournalPath, hledgerExecutor);
+  if (!validationResult.valid) {
+    return {
+      success: false,
+      error: `Ledger validation failed after import: ${validationResult.errors.join("; ")}`,
+      hint: "The import created invalid transactions. Check your rules file configuration. CSV files have NOT been moved to done."
+    };
+  }
+  for (const csvFile of importedFiles) {
+    const relativePath = path8.relative(pendingDir, csvFile);
+    const destPath = path8.join(doneDir, relativePath);
+    const destDir = path8.dirname(destPath);
+    if (!fs9.existsSync(destDir)) {
+      fs9.mkdirSync(destDir, { recursive: true });
+    }
+    fs9.renameSync(csvFile, destPath);
+  }
+  return {
+    success: true,
+    importedCount: importedFiles.length
+  };
+}
+async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor) {
+  const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+  if (!rulesFile) {
+    return {
+      csv: path8.relative(directory, csvFile),
+      rulesFile: null,
+      totalTransactions: 0,
+      matchedTransactions: 0,
+      unknownPostings: [],
+      error: "No matching rules file found"
+    };
+  }
+  const result = await hledgerExecutor(["print", "-f", csvFile, "--rules-file", rulesFile]);
+  if (result.exitCode !== 0) {
+    return {
+      csv: path8.relative(directory, csvFile),
+      rulesFile: path8.relative(directory, rulesFile),
+      totalTransactions: 0,
+      matchedTransactions: 0,
+      unknownPostings: [],
+      error: `hledger error: ${result.stderr.trim() || "Unknown error"}`
+    };
+  }
+  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(", ");
+    return {
+      csv: path8.relative(directory, csvFile),
+      rulesFile: path8.relative(directory, rulesFile),
+      totalTransactions: transactionCount,
+      matchedTransactions: matchedCount,
+      unknownPostings: [],
+      error: `CSV contains transactions from multiple years (${yearList}). Split the CSV by year before importing.`
+    };
+  }
+  const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
+  if (unknownPostings.length > 0) {
+    try {
+      const rulesContent = fs9.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;
+      }
+    }
+  }
+  return {
+    csv: path8.relative(directory, csvFile),
+    rulesFile: path8.relative(directory, rulesFile),
+    totalTransactions: transactionCount,
+    matchedTransactions: matchedCount,
+    unknownPostings,
+    transactionYear
+  };
+}
+async function importStatements(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+  const restrictionError = checkAccountantAgent(agent, "import statements");
+  if (restrictionError) {
+    return restrictionError;
+  }
+  if (!worktreeChecker(directory)) {
+    return buildErrorResult3("import-statements must be run inside an import worktree", "Use import-pipeline tool to orchestrate the full workflow");
+  }
+  let config2;
+  try {
+    config2 = configLoader(directory);
+  } catch (error45) {
+    const errorMessage = `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    return buildErrorResult3(errorMessage, 'Ensure config/import/providers.yaml exists with required paths including "rules"');
+  }
+  const pendingDir = path8.join(directory, config2.paths.pending);
+  const rulesDir = path8.join(directory, config2.paths.rules);
+  const doneDir = path8.join(directory, config2.paths.done);
+  const rulesMapping = loadRulesMapping(rulesDir);
+  const csvFiles = findCsvFiles(pendingDir, options.provider, options.currency);
+  if (csvFiles.length === 0) {
+    return buildSuccessResult3([], {
+      filesProcessed: 0,
+      filesWithErrors: 0,
+      filesWithoutRules: 0,
+      totalTransactions: 0,
+      matched: 0,
+      unknown: 0
+    }, "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 fileResult = await processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor);
+    fileResults.push(fileResult);
+    if (fileResult.error) {
+      if (fileResult.rulesFile === null) {
+        filesWithoutRules++;
+      } else {
+        filesWithErrors++;
+      }
+    }
+    totalTransactions += fileResult.totalTransactions;
+    totalMatched += fileResult.matchedTransactions;
+    totalUnknown += fileResult.unknownPostings.length;
+  }
+  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 buildErrorResultWithDetails("Cannot import: some transactions have unknown accounts or files have errors", fileResults, {
+      filesProcessed: csvFiles.length,
+      filesWithErrors,
+      filesWithoutRules,
+      totalTransactions,
+      matched: totalMatched,
+      unknown: totalUnknown
+    }, "Run with checkOnly: true to see details, then add missing rules");
+  }
+  const importResult = await executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor);
+  if (!importResult.success) {
+    return buildErrorResultWithDetails(importResult.error, fileResults, {
+      filesProcessed: csvFiles.length,
+      filesWithErrors: 1,
+      filesWithoutRules,
+      totalTransactions,
+      matched: totalMatched,
+      unknown: totalUnknown
+    }, importResult.hint);
+  }
+  return buildSuccessResult3(fileResults.map((f) => ({
+    ...f,
+    imported: true
+  })), {
+    filesProcessed: csvFiles.length,
+    filesWithErrors: 0,
+    filesWithoutRules: 0,
+    totalTransactions,
+    matched: totalMatched,
+    unknown: 0
+  }, `Successfully imported ${totalTransactions} transaction(s) from ${importResult.importedCount} file(s)`);
+}
+var import_statements_default = tool({
+  description: `ACCOUNTANT AGENT ONLY: 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 importStatements(directory, agent, {
+      provider: params.provider,
+      currency: params.currency,
+      checkOnly: params.checkOnly
+    });
+  }
+});
+// src/tools/reconcile-statement.ts
+import * as fs10 from "fs";
+import * as path9 from "path";
+function buildErrorResult4(params) {
+  return JSON.stringify({
+    success: false,
+    ...params
+  });
+}
+function buildSuccessResult4(params) {
+  return JSON.stringify({
+    success: true,
+    ...params
+  });
+}
+function validateWorktree(directory, worktreeChecker) {
+  if (!worktreeChecker(directory)) {
+    return buildErrorResult4({
+      error: "reconcile-statement must be run inside an import worktree",
+      hint: "Use import-pipeline tool to orchestrate the full workflow"
+    });
+  }
+  return null;
+}
+function loadConfiguration(directory, configLoader) {
+  try {
+    const config2 = configLoader(directory);
+    return { config: config2 };
+  } catch (error45) {
+    return {
+      error: buildErrorResult4({
+        error: `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`,
+        hint: "Ensure config/import/providers.yaml exists"
+      })
+    };
+  }
+}
+function findCsvToReconcile(doneDir, options) {
+  const csvFiles = findCsvFiles(doneDir, options.provider, options.currency);
+  if (csvFiles.length === 0) {
+    const providerFilter = options.provider ? ` --provider=${options.provider}` : "";
+    const currencyFilter = options.currency ? ` --currency=${options.currency}` : "";
+    return {
+      error: buildErrorResult4({
+        error: `No CSV files found in ${doneDir}`,
+        hint: `Run: import-statements${providerFilter}${currencyFilter}`
+      })
+    };
+  }
+  const csvFile = csvFiles[csvFiles.length - 1];
+  const relativePath = path9.relative(path9.dirname(path9.dirname(doneDir)), csvFile);
+  return { csvFile, relativePath };
+}
+function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
+  let metadata;
+  try {
+    const content = fs10.readFileSync(csvFile, "utf-8");
+    const filename = path9.basename(csvFile);
+    const detectionResult = detectProvider(filename, content, config2);
+    metadata = detectionResult?.metadata;
+  } catch {
+    metadata = undefined;
+  }
+  let closingBalance = options.closingBalance;
+  if (!closingBalance && metadata?.closing_balance) {
+    closingBalance = metadata.closing_balance;
+    if (metadata.currency && !closingBalance.includes(metadata.currency)) {
+      closingBalance = `${metadata.currency} ${closingBalance}`;
+    }
+  }
+  if (!closingBalance) {
+    return {
+      error: buildErrorResult4({
+        csvFile: relativeCsvPath,
+        error: "No closing balance found in CSV metadata",
+        hint: "Provide closingBalance parameter manually",
+        metadata
+      })
+    };
+  }
+  return { closingBalance, metadata };
+}
+function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata) {
+  let account = options.account;
+  if (!account) {
+    const rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (rulesFile) {
+      account = getAccountFromRulesFile(rulesFile) ?? undefined;
+    }
+  }
+  if (!account) {
+    const rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or use --account parameter` : `Create a rules file in ${rulesDir} with 'account1' directive or use --account parameter`;
+    return {
+      error: buildErrorResult4({
+        csvFile: relativeCsvPath,
+        error: "Could not determine account from rules file",
+        hint: rulesHint,
+        metadata
+      })
+    };
+  }
+  return { account };
+}
+async function reconcileStatementCore(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
+  const restrictionError = checkAccountantAgent(agent, "reconcile statement");
+  if (restrictionError) {
+    return restrictionError;
+  }
+  const worktreeError = validateWorktree(directory, worktreeChecker);
+  if (worktreeError) {
+    return worktreeError;
+  }
+  const configResult = loadConfiguration(directory, configLoader);
+  if ("error" in configResult) {
+    return configResult.error;
+  }
+  const { config: config2 } = configResult;
+  const doneDir = path9.join(directory, config2.paths.done);
+  const rulesDir = path9.join(directory, config2.paths.rules);
+  const mainJournalPath = path9.join(directory, ".hledger.journal");
+  const csvResult = findCsvToReconcile(doneDir, options);
+  if ("error" in csvResult) {
+    return csvResult.error;
+  }
+  const { csvFile, relativePath: relativeCsvPath } = csvResult;
+  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath);
+  if ("error" in balanceResult) {
+    return balanceResult.error;
+  }
+  const { closingBalance, metadata } = balanceResult;
+  const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
+  if ("error" in accountResult) {
+    return accountResult.error;
+  }
+  const { account } = accountResult;
+  const lastTransactionDate = await getLastTransactionDate(mainJournalPath, account, hledgerExecutor);
+  if (!lastTransactionDate) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      error: "No transactions found for account",
+      hint: "Ensure import completed successfully",
+      metadata
+    });
+  }
+  const actualBalance = await getAccountBalance(mainJournalPath, account, lastTransactionDate, hledgerExecutor);
+  if (actualBalance === null) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      error: "Failed to query account balance from hledger",
+      hint: `Check journal syntax: hledger check -f ${mainJournalPath}`,
+      metadata
+    });
+  }
+  let doBalancesMatch;
+  try {
+    doBalancesMatch = balancesMatch(closingBalance, actualBalance);
+  } catch (error45) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      expectedBalance: closingBalance,
+      actualBalance,
+      error: `Cannot parse balances for comparison: ${error45 instanceof Error ? error45.message : String(error45)}`,
+      metadata
+    });
+  }
+  if (doBalancesMatch) {
+    return buildSuccessResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      expectedBalance: closingBalance,
+      actualBalance,
+      metadata
+    });
+  }
+  let difference;
+  try {
+    difference = calculateDifference(closingBalance, actualBalance);
+  } catch (error45) {
+    return buildErrorResult4({
+      csvFile: relativeCsvPath,
+      account,
+      lastTransactionDate,
+      expectedBalance: closingBalance,
+      actualBalance,
+      error: `Failed to calculate difference: ${error45 instanceof Error ? error45.message : String(error45)}`,
+      metadata
+    });
+  }
+  return buildErrorResult4({
+    csvFile: relativeCsvPath,
+    account,
+    lastTransactionDate,
+    expectedBalance: closingBalance,
+    actualBalance,
+    difference,
+    error: `Balance mismatch: expected ${closingBalance}, got ${actualBalance} (difference: ${difference})`,
+    hint: "Check for missing transactions, duplicate imports, or incorrect rules",
+    metadata
+  });
+}
+var reconcile_statement_default = tool({
+  description: `ACCOUNTANT AGENT ONLY: Reconcile imported bank statement against closing balance.
+
+This tool validates that the imported transactions result in the correct closing balance.
+It must be run inside an import worktree (use import-pipeline for the full workflow).
+
+**Workflow:**
+1. Finds the most recently imported CSV in the done directory
+2. Extracts closing balance from CSV metadata (or uses manual override)
+3. Determines the account from the matching rules file (or uses manual override)
+4. Queries hledger for the actual balance as of the last transaction date
+5. Compares expected vs actual balance
+
+**Balance Sources:**
+- Automatic: Extracted from CSV header metadata (e.g., UBS files have "Closing balance:" row)
+- Manual: Provided via closingBalance parameter (required for providers like Revolut)
+
+**Account Detection:**
+- Automatic: Parsed from account1 directive in matching rules file
+- Manual: Provided via account parameter`,
+  args: {
+    provider: tool.schema.string().optional().describe('Filter by provider (e.g., "ubs", "revolut")'),
+    currency: tool.schema.string().optional().describe('Filter by currency (e.g., "chf", "eur")'),
+    closingBalance: tool.schema.string().optional().describe('Manual closing balance (e.g., "CHF 2324.79"). Required if not in CSV metadata.'),
+    account: tool.schema.string().optional().describe('Manual account (e.g., "assets:bank:ubs:checking"). Auto-detected from rules file if not provided.')
+  },
+  async execute(params, context) {
+    const { directory, agent } = context;
+    return reconcileStatementCore(directory, agent, {
+      provider: params.provider,
+      currency: params.currency,
+      closingBalance: params.closingBalance,
+      account: params.account
+    });
+  }
+});
 // src/index.ts
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var AGENT_FILE = join3(__dirname2, "..", "agent", "accountant.md");
+var __dirname2 = dirname5(fileURLToPath(import.meta.url));
+var AGENT_FILE = join10(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
     tool: {
-      "update-prices": update_prices_default,
-      "classify-statements": classifyStatements,
-      "import-statements": importStatements
+      "fetch-currency-prices": fetch_currency_prices_default,
+      "classify-statements": classify_statements_default,
+      "import-statements": import_statements_default,
+      "reconcile-statements": reconcile_statement_default
     },
     config: async (config2) => {
       if (agent) {