@fuzzle/opencode-accountant 0.5.0 → 0.5.1-next.1

package/dist/index.js

@@ -2676,12 +2676,12 @@ var init_js_yaml = __esm(() => {
 });
 
 // src/utils/agentLoader.ts
-import { existsSync, readFileSync } from "fs";
+import * as fs from "fs";
 function loadAgent(filePath) {
-  if (!existsSync(filePath)) {
+  if (!fs.existsSync(filePath)) {
     return null;
   }
-  const content = readFileSync(filePath, "utf-8");
+  const content = fs.readFileSync(filePath, "utf-8");
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match) {
     throw new Error(`Invalid frontmatter format in ${filePath}`);
@@ -4231,7 +4231,7 @@ __export(exports_accountSuggester, {
   extractRulePatternsFromFile: () => extractRulePatternsFromFile,
   clearSuggestionCache: () => clearSuggestionCache
 });
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as crypto from "crypto";
 function clearSuggestionCache() {
   Object.keys(suggestionCache).forEach((key) => delete suggestionCache[key]);
@@ -4240,11 +4240,11 @@ function hashTransaction(posting) {
   const data = `${posting.description}|${posting.amount}|${posting.account}`;
   return crypto.createHash("md5").update(data).digest("hex");
 }
-async function loadExistingAccounts(yearJournalPath) {
-  if (!fs13.existsSync(yearJournalPath)) {
+function loadExistingAccounts(yearJournalPath) {
+  if (!fs14.existsSync(yearJournalPath)) {
     return [];
   }
-  const content = fs13.readFileSync(yearJournalPath, "utf-8");
+  const content = fs14.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const accounts = [];
@@ -4259,11 +4259,11 @@ async function loadExistingAccounts(yearJournalPath) {
   }
   return accounts.sort();
 }
-async function extractRulePatternsFromFile(rulesPath) {
-  if (!fs13.existsSync(rulesPath)) {
+function extractRulePatternsFromFile(rulesPath) {
+  if (!fs14.existsSync(rulesPath)) {
     return [];
   }
-  const content = fs13.readFileSync(rulesPath, "utf-8");
+  const content = fs14.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   const patterns = [];
@@ -16844,16 +16844,16 @@ function checkAccountantAgent(agent, toolPrompt, additionalFields) {
 
 // src/utils/yamlLoader.ts
 init_js_yaml();
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 function loadYamlConfig(directory, configFile, validator, notFoundMessage) {
   const configPath = path.join(directory, configFile);
-  if (!fs.existsSync(configPath)) {
+  if (!fs2.existsSync(configPath)) {
     throw new Error(notFoundMessage || `Configuration file not found: ${configFile}. Please create this file to configure the feature.`);
   }
   let parsed;
   try {
-    const content = fs.readFileSync(configPath, "utf-8");
+    const content = fs2.readFileSync(configPath, "utf-8");
     parsed = jsYaml.load(content);
   } catch (err) {
     if (err instanceof jsYaml.YAMLException) {
@@ -16910,14 +16910,14 @@ function loadPricesConfig(directory) {
 }
 
 // src/utils/journalUtils.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path3 from "path";
 
 // src/utils/fileUtils.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as path2 from "path";
 function findCsvFiles(baseDir, options = {}) {
-  if (!fs2.existsSync(baseDir)) {
+  if (!fs3.existsSync(baseDir)) {
     return [];
   }
   let searchDir = baseDir;
@@ -16927,13 +16927,13 @@ function findCsvFiles(baseDir, options = {}) {
       searchDir = path2.join(searchDir, options.subsubdir);
     }
   }
-  if (!fs2.existsSync(searchDir)) {
+  if (!fs3.existsSync(searchDir)) {
     return [];
   }
   const csvFiles = [];
   if (options.recursive) {
     let scanDirectory = function(dir) {
-      const entries = fs2.readdirSync(dir, { withFileTypes: true });
+      const entries = fs3.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path2.join(dir, entry.name);
         if (entry.isDirectory()) {
@@ -16945,12 +16945,12 @@ function findCsvFiles(baseDir, options = {}) {
     };
     scanDirectory(searchDir);
   } else {
-    const entries = fs2.readdirSync(searchDir);
+    const entries = fs3.readdirSync(searchDir);
     for (const name of entries) {
       if (!name.toLowerCase().endsWith(".csv"))
         continue;
       const fullPath = path2.join(searchDir, name);
-      if (fs2.statSync(fullPath).isFile()) {
+      if (fs3.statSync(fullPath).isFile()) {
         csvFiles.push(options.fullPaths ? fullPath : name);
       }
     }
@@ -16958,8 +16958,8 @@ function findCsvFiles(baseDir, options = {}) {
   return csvFiles.sort();
 }
 function ensureDirectory(dirPath) {
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  if (!fs3.existsSync(dirPath)) {
+    fs3.mkdirSync(dirPath, { recursive: true });
   }
 }
 
@@ -16969,8 +16969,8 @@ function extractDateFromPriceLine(line) {
 }
 function updatePriceJournal(journalPath, newPriceLines) {
   let existingLines = [];
-  if (fs3.existsSync(journalPath)) {
-    existingLines = fs3.readFileSync(journalPath, "utf-8").split(`
+  if (fs4.existsSync(journalPath)) {
+    existingLines = fs4.readFileSync(journalPath, "utf-8").split(`
 `).filter((line) => line.trim() !== "");
   }
   const priceMap = new Map;
@@ -16985,7 +16985,7 @@ function updatePriceJournal(journalPath, newPriceLines) {
       priceMap.set(date5, line);
   }
   const sortedLines = Array.from(priceMap.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, line]) => line);
-  fs3.writeFileSync(journalPath, sortedLines.join(`
+  fs4.writeFileSync(journalPath, sortedLines.join(`
 `) + `
 `);
 }
@@ -16993,17 +16993,15 @@ function ensureYearJournalExists(directory, year) {
   const ledgerDir = path3.join(directory, "ledger");
   const yearJournalPath = path3.join(ledgerDir, `${year}.journal`);
   const mainJournalPath = path3.join(directory, ".hledger.journal");
-  if (!fs3.existsSync(ledgerDir)) {
-    fs3.mkdirSync(ledgerDir, { recursive: true });
-  }
-  if (!fs3.existsSync(yearJournalPath)) {
-    fs3.writeFileSync(yearJournalPath, `; ${year} transactions
+  ensureDirectory(ledgerDir);
+  if (!fs4.existsSync(yearJournalPath)) {
+    fs4.writeFileSync(yearJournalPath, `; ${year} transactions
 `);
   }
-  if (!fs3.existsSync(mainJournalPath)) {
+  if (!fs4.existsSync(mainJournalPath)) {
     throw new Error(`.hledger.journal not found at ${mainJournalPath}. Create it first with appropriate includes.`);
   }
-  const mainJournalContent = fs3.readFileSync(mainJournalPath, "utf-8");
+  const mainJournalContent = fs4.readFileSync(mainJournalPath, "utf-8");
   const includeDirective = `include ledger/${year}.journal`;
   const lines = mainJournalContent.split(`
 `);
@@ -17015,7 +17013,7 @@ function ensureYearJournalExists(directory, year) {
     const newContent = mainJournalContent.trimEnd() + `
 ` + includeDirective + `
 `;
-    fs3.writeFileSync(mainJournalPath, newContent);
+    fs4.writeFileSync(mainJournalPath, newContent);
   }
   return yearJournalPath;
 }
@@ -17035,6 +17033,30 @@ function getNextDay(dateStr) {
   return formatDateISO(date5);
 }
 
+// src/utils/resultHelpers.ts
+function buildToolErrorResult(error45, hint, extra) {
+  const result = {
+    success: false,
+    error: error45
+  };
+  if (hint) {
+    result.hint = hint;
+  }
+  if (extra) {
+    Object.assign(result, extra);
+  }
+  return JSON.stringify(result);
+}
+function buildToolSuccessResult(data) {
+  const result = {
+    success: true
+  };
+  if (data) {
+    Object.assign(result, data);
+  }
+  return JSON.stringify(result);
+}
+
 // src/tools/fetch-currency-prices.ts
 async function defaultPriceFetcher(cmdArgs) {
   const result = await $`pricehist ${cmdArgs}`.quiet();
@@ -17057,11 +17079,8 @@ function buildPricehistArgs(startDate, endDate, currencyConfig) {
   }
   return cmdArgs;
 }
-function buildErrorResult(error45) {
-  return JSON.stringify({ error: error45 });
-}
 function buildSuccessResult(results, endDate, backfill) {
-  return JSON.stringify({
+  return buildToolSuccessResult({
     success: results.every((r) => !("error" in r)),
     endDate,
     backfill,
@@ -17094,7 +17113,7 @@ async function fetchCurrencyPrices(directory, agent, backfill, priceFetcher = de
     config2 = configLoader(directory);
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    return buildErrorResult(errorMessage);
+    return buildToolErrorResult(errorMessage);
   }
   const endDate = getYesterday();
   const defaultBackfillDate = getDefaultBackfillDate();
@@ -17150,7 +17169,7 @@ var fetch_currency_prices_default = tool({
   }
 });
 // src/tools/classify-statements.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path6 from "path";
 
 // src/utils/importConfig.ts
@@ -17405,18 +17424,12 @@ function detectProvider(filename, content, config2) {
 }
 
 // src/utils/importContext.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path5 from "path";
 import { randomUUID } from "crypto";
 function getContextPath(directory, contextId) {
   return path5.join(directory, ".memory", `${contextId}.json`);
 }
-function ensureMemoryDir(directory) {
-  const memoryDir = path5.join(directory, ".memory");
-  if (!fs4.existsSync(memoryDir)) {
-    fs4.mkdirSync(memoryDir, { recursive: true });
-  }
-}
 function createContext(directory, params) {
   const now = new Date().toISOString();
   const context = {
@@ -17435,9 +17448,9 @@ function createContext(directory, params) {
     closingBalance: params.closingBalance,
     account: params.account
   };
-  ensureMemoryDir(directory);
+  ensureDirectory(path5.join(directory, ".memory"));
   const contextPath = getContextPath(directory, context.id);
-  fs4.writeFileSync(contextPath, JSON.stringify(context, null, 2), "utf-8");
+  fs5.writeFileSync(contextPath, JSON.stringify(context, null, 2), "utf-8");
   return context;
 }
 function validateContext(context, contextId) {
@@ -17456,10 +17469,10 @@ function validateContext(context, contextId) {
 }
 function loadContext(directory, contextId) {
   const contextPath = getContextPath(directory, contextId);
-  if (!fs4.existsSync(contextPath)) {
+  if (!fs5.existsSync(contextPath)) {
     throw new Error(`Context not found: ${contextId}`);
   }
-  const content = fs4.readFileSync(contextPath, "utf-8");
+  const content = fs5.readFileSync(contextPath, "utf-8");
   let context;
   try {
     context = JSON.parse(content);
@@ -17479,14 +17492,13 @@ function updateContext(directory, contextId, updates) {
     updatedAt: new Date().toISOString()
   };
   const contextPath = getContextPath(directory, contextId);
-  fs4.writeFileSync(contextPath, JSON.stringify(updatedContext, null, 2), "utf-8");
+  fs5.writeFileSync(contextPath, JSON.stringify(updatedContext, null, 2), "utf-8");
   return updatedContext;
 }
 
 // src/tools/classify-statements.ts
 function buildSuccessResult2(classified, unrecognized, message) {
-  return JSON.stringify({
-    success: true,
+  return buildToolSuccessResult({
     classified,
     unrecognized,
     message,
@@ -17497,31 +17509,12 @@ function buildSuccessResult2(classified, unrecognized, message) {
     }
   });
 }
-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 content = fs6.readFileSync(sourcePath, "utf-8");
     const detection = detectProvider(filename, content, config2);
     let targetPath;
     let targetFilename;
@@ -17533,7 +17526,7 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
       targetFilename = filename;
       targetPath = path6.join(unrecognizedDir, filename);
     }
-    if (fs5.existsSync(targetPath)) {
+    if (fs6.existsSync(targetPath)) {
       collisions.push({
         filename,
         existingPath: targetPath
@@ -17569,7 +17562,7 @@ function executeMoves(plannedMoves, config2, unrecognizedDir, directory) {
     if (move.detection) {
       const targetDir = path6.dirname(move.targetPath);
       ensureDirectory(targetDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.renameSync(move.sourcePath, move.targetPath);
       const targetPath = path6.join(config2.paths.pending, move.detection.provider, move.detection.currency, move.targetFilename);
       const metadata = extractMetadata2(move.detection);
       const context = createContext(directory, {
@@ -17594,7 +17587,7 @@ function executeMoves(plannedMoves, config2, unrecognizedDir, directory) {
       });
     } else {
       ensureDirectory(unrecognizedDir);
-      fs5.renameSync(move.sourcePath, move.targetPath);
+      fs6.renameSync(move.sourcePath, move.targetPath);
       unrecognized.push({
         filename: move.filename,
         targetPath: path6.join(config2.paths.unrecognized, move.filename)
@@ -17616,7 +17609,10 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
     config2 = configLoader(directory);
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    return buildErrorResult2(errorMessage);
+    return buildToolErrorResult(errorMessage, undefined, {
+      classified: [],
+      unrecognized: []
+    });
   }
   const importsDir = path6.join(directory, config2.paths.import);
   const pendingDir = path6.join(directory, config2.paths.pending);
@@ -17627,7 +17623,12 @@ async function classifyStatements(directory, agent, configLoader = loadImportCon
   }
   const { plannedMoves, collisions } = planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2);
   if (collisions.length > 0) {
-    return buildCollisionError(collisions);
+    const error45 = `Cannot classify: ${collisions.length} file(s) would overwrite existing pending files.`;
+    return buildToolErrorResult(error45, undefined, {
+      collisions,
+      classified: [],
+      unrecognized: []
+    });
   }
   const { classified, unrecognized } = executeMoves(plannedMoves, config2, unrecognizedDir, directory);
   return buildSuccessResult2(classified, unrecognized);
@@ -17649,7 +17650,7 @@ For each CSV file:
   }
 });
 // src/tools/import-statements.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path9 from "path";
 
 // node_modules/minimatch/dist/esm/index.js
@@ -21434,8 +21435,8 @@ class PathScurryBase {
   #children;
   nocase;
   #fs;
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs6);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs7);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -21911,8 +21912,8 @@ class PathScurryWin32 extends PathScurryBase {
   parseRootPath(dir) {
     return win32.parse(dir).root.toUpperCase();
   }
-  newRoot(fs6) {
-    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   isAbsolute(p) {
     return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -21929,8 +21930,8 @@ class PathScurryPosix extends PathScurryBase {
   parseRootPath(_dir) {
     return "/";
   }
-  newRoot(fs6) {
-    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+  newRoot(fs7) {
+    return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
   }
   isAbsolute(p) {
     return p.startsWith("/");
@@ -22932,7 +22933,7 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/utils/rulesMatcher.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path8 from "path";
 function parseSourceDirective(content) {
   const match2 = content.match(/^source\s+([^\n#]+)/m);
@@ -22950,22 +22951,22 @@ function resolveSourcePath(sourcePath, rulesFilePath) {
 }
 function loadRulesMapping(rulesDir) {
   const mapping = {};
-  if (!fs6.existsSync(rulesDir)) {
+  if (!fs7.existsSync(rulesDir)) {
     return mapping;
   }
-  const files = fs6.readdirSync(rulesDir);
+  const files = fs7.readdirSync(rulesDir);
   for (const file2 of files) {
     if (!file2.endsWith(".rules")) {
       continue;
     }
     const rulesFilePath = path8.join(rulesDir, file2);
-    const stat = fs6.statSync(rulesFilePath);
+    const stat = fs7.statSync(rulesFilePath);
     if (!stat.isFile()) {
       continue;
     }
     let content;
     try {
-      content = fs6.readFileSync(rulesFilePath, "utf-8");
+      content = fs7.readFileSync(rulesFilePath, "utf-8");
     } catch {
       continue;
     }
@@ -23140,7 +23141,7 @@ async function getAccountBalance(mainJournalPath, account, asOfDate, executor =
 }
 
 // src/utils/rulesParser.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 function parseSkipRows(rulesContent) {
   const match2 = rulesContent.match(/^skip\s+(\d+)/m);
   return match2 ? parseInt(match2[1], 10) : 0;
@@ -23206,7 +23207,7 @@ function parseAccount1(rulesContent) {
 }
 function getAccountFromRulesFile(rulesFilePath) {
   try {
-    const content = fs7.readFileSync(rulesFilePath, "utf-8");
+    const content = fs8.readFileSync(rulesFilePath, "utf-8");
     return parseAccount1(content);
   } catch {
     return null;
@@ -23226,7 +23227,7 @@ function parseRulesFile(rulesContent) {
 
 // src/utils/csvParser.ts
 var import_papaparse2 = __toESM(require_papaparse(), 1);
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 // src/utils/balanceUtils.ts
 function parseAmountValue(amountStr) {
@@ -23276,7 +23277,7 @@ function balancesMatch(balance1, balance2) {
 // src/utils/csvParser.ts
 var AMOUNT_MATCH_TOLERANCE = 0.001;
 function parseCsvFile(csvPath, config2) {
-  const csvContent = fs8.readFileSync(csvPath, "utf-8");
+  const csvContent = fs9.readFileSync(csvPath, "utf-8");
   const lines = csvContent.split(`
 `);
   const headerIndex = config2.skipRows;
@@ -23413,11 +23414,8 @@ function findMatchingCsvRow(posting, csvRows, config2) {
 }
 
 // src/tools/import-statements.ts
-function buildErrorResult3(error45, hint) {
-  const result = {
-    success: false,
-    error: error45,
-    hint,
+function buildErrorResult(error45, hint) {
+  return buildToolErrorResult(error45, hint, {
     files: [],
     summary: {
       filesProcessed: 0,
@@ -23427,28 +23425,16 @@ function buildErrorResult3(error45, hint) {
       matched: 0,
       unknown: 0
     }
-  };
-  return JSON.stringify(result);
+  });
 }
 function buildErrorResultWithDetails(error45, files, summary, hint) {
-  return JSON.stringify({
-    success: false,
-    error: error45,
-    hint,
-    files,
-    summary
-  });
+  return buildToolErrorResult(error45, hint, { files, summary });
 }
 function buildSuccessResult3(files, summary, message) {
-  return JSON.stringify({
-    success: true,
-    files,
-    summary,
-    message
-  });
+  return buildToolSuccessResult({ files, summary, message });
 }
 function findCsvFromRulesFile(rulesFile) {
-  const content = fs9.readFileSync(rulesFile, "utf-8");
+  const content = fs10.readFileSync(rulesFile, "utf-8");
   const match2 = content.match(/^source\s+([^\n#]+)/m);
   if (!match2) {
     return null;
@@ -23461,8 +23447,8 @@ function findCsvFromRulesFile(rulesFile) {
     return null;
   }
   matches.sort((a, b) => {
-    const aStat = fs9.statSync(a);
-    const bStat = fs9.statSync(b);
+    const aStat = fs10.statSync(a);
+    const bStat = fs10.statSync(b);
     return bStat.mtime.getTime() - aStat.mtime.getTime();
   });
   return matches[0];
@@ -23515,10 +23501,8 @@ async function executeImports(fileResults, directory, pendingDir, doneDir, hledg
     const relativePath = path9.relative(pendingDir, csvFile);
     const destPath = path9.join(doneDir, relativePath);
     const destDir = path9.dirname(destPath);
-    if (!fs9.existsSync(destDir)) {
-      fs9.mkdirSync(destDir, { recursive: true });
-    }
-    fs9.renameSync(csvFile, destPath);
+    ensureDirectory(destDir);
+    fs10.renameSync(csvFile, destPath);
   }
   return {
     success: true,
@@ -23566,7 +23550,7 @@ async function processCsvFile(csvFile, rulesMapping, directory, hledgerExecutor)
   const transactionYear = years.size === 1 ? Array.from(years)[0] : undefined;
   if (unknownPostings.length > 0) {
     try {
-      const rulesContent = fs9.readFileSync(rulesFile, "utf-8");
+      const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
       const rulesConfig = parseRulesFile(rulesContent);
       const csvRows = parseCsvFile(csvFile, rulesConfig);
       for (const posting of unknownPostings) {
@@ -23601,7 +23585,7 @@ async function importStatements(directory, agent, options, configLoader = loadIm
     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"');
+    return buildErrorResult(errorMessage, 'Ensure config/import/providers.yaml exists with required paths including "rules"');
   }
   const pendingDir = path9.join(directory, config2.paths.pending);
   const rulesDir = path9.join(directory, config2.paths.rules);
@@ -23609,8 +23593,8 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   const rulesMapping = loadRulesMapping(rulesDir);
   const importContext = loadContext(directory, options.contextId);
   const csvPath = path9.join(directory, importContext.filePath);
-  if (!fs9.existsSync(csvPath)) {
-    return buildErrorResult3(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
+  if (!fs10.existsSync(csvPath)) {
+    return buildErrorResult(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
   }
   const csvFiles = [csvPath];
   const fileResults = [];
@@ -23644,8 +23628,8 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   }
   for (const [_rulesFile, matchingCSVs] of rulesFileToCSVs.entries()) {
     matchingCSVs.sort((a, b) => {
-      const aStat = fs9.statSync(a);
-      const bStat = fs9.statSync(b);
+      const aStat = fs10.statSync(a);
+      const bStat = fs10.statSync(b);
       return bStat.mtime.getTime() - aStat.mtime.getTime();
     });
     const newestCSV = matchingCSVs[0];
@@ -23760,22 +23744,18 @@ Note: This tool is typically called via import-pipeline for the full workflow.`,
   }
 });
 // src/tools/reconcile-statement.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path10 from "path";
-function buildErrorResult4(params) {
-  const result = {
-    success: false,
+function buildErrorResult2(params) {
+  return buildToolErrorResult(params.error, params.hint, {
     account: params.account ?? "",
     expectedBalance: params.expectedBalance ?? "",
     actualBalance: params.actualBalance ?? "",
     lastTransactionDate: params.lastTransactionDate ?? "",
     csvFile: params.csvFile ?? "",
     difference: params.difference,
-    metadata: params.metadata,
-    error: params.error,
-    hint: params.hint
-  };
-  return JSON.stringify(result);
+    metadata: params.metadata
+  });
 }
 function loadConfiguration(directory, configLoader) {
   try {
@@ -23783,7 +23763,7 @@ function loadConfiguration(directory, configLoader) {
     return { config: config2 };
   } catch (error45) {
     return {
-      error: buildErrorResult4({
+      error: buildErrorResult2({
         error: `Failed to load configuration: ${error45 instanceof Error ? error45.message : String(error45)}`,
         hint: "Ensure config/import/providers.yaml exists"
       })
@@ -23792,9 +23772,9 @@ function loadConfiguration(directory, configLoader) {
 }
 function verifyCsvExists(directory, importContext) {
   const csvFile = path10.join(directory, importContext.filePath);
-  if (!fs10.existsSync(csvFile)) {
+  if (!fs11.existsSync(csvFile)) {
     return {
-      error: buildErrorResult4({
+      error: buildErrorResult2({
         error: `CSV file not found: ${importContext.filePath}`,
         hint: `The file may have been moved or deleted. Context ID: ${importContext.id}`
       })
@@ -23830,7 +23810,7 @@ function getBalanceFromCsvAnalysis(csvFile, rulesDir) {
 }
 function extractCsvMetadata(csvFile, config2) {
   try {
-    const content = fs10.readFileSync(csvFile, "utf-8");
+    const content = fs11.readFileSync(csvFile, "utf-8");
     const filename = path10.basename(csvFile);
     const detectionResult = detectProvider(filename, content, config2);
     if (detectionResult?.metadata) {
@@ -23861,7 +23841,7 @@ function determineClosingBalance(csvFile, config2, importContext, manualClosingB
   const exampleBalance = `${currency} <amount>`;
   const retryCmd = buildRetryCommand(importContext.id, exampleBalance);
   return {
-    error: buildErrorResult4({
+    error: buildErrorResult2({
       csvFile: relativeCsvPath,
       error: "No closing balance found in CSV metadata or data",
       hint: `Provide closingBalance parameter manually. Example retry: ${retryCmd}`,
@@ -23891,7 +23871,7 @@ function determineAccount(csvFile, rulesDir, importContext, manualAccount, relat
   if (!account) {
     const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or retry with: ${buildRetryCommand(importContext.id, undefined, "assets:bank:...")}` : `Create a rules file in ${rulesDir} with 'account1' directive or retry with: ${buildRetryCommand(importContext.id, undefined, "assets:bank:...")}`;
     return {
-      error: buildErrorResult4({
+      error: buildErrorResult2({
         csvFile: relativeCsvPath,
         error: "Could not determine account from rules file",
         hint: rulesHint,
@@ -23908,7 +23888,7 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
     if (!rulesFile) {
       return null;
     }
-    const rulesContent = fs10.readFileSync(rulesFile, "utf-8");
+    const rulesContent = fs11.readFileSync(rulesFile, "utf-8");
     const rulesConfig = parseRulesFile(rulesContent);
     const csvRows = parseCsvFile(csvFile, rulesConfig);
     if (csvRows.length === 0) {
@@ -23974,7 +23954,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   try {
     importContext = loadContext(directory, options.contextId);
   } catch {
-    return buildErrorResult4({
+    return buildErrorResult2({
       error: `Failed to load import context: ${options.contextId}`,
       hint: "Ensure the context ID is valid and the context file exists in .memory/"
     });
@@ -24003,7 +23983,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   const { account } = accountResult;
   const lastTransactionDate = await getLastTransactionDate(mainJournalPath, account, hledgerExecutor);
   if (!lastTransactionDate) {
-    return buildErrorResult4({
+    return buildErrorResult2({
       csvFile: relativeCsvPath,
       account,
       error: "No transactions found for account",
@@ -24013,7 +23993,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   }
   const actualBalance = await getAccountBalance(mainJournalPath, account, lastTransactionDate, hledgerExecutor);
   if (actualBalance === null) {
-    return buildErrorResult4({
+    return buildErrorResult2({
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
@@ -24026,7 +24006,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   try {
     doBalancesMatch = balancesMatch(closingBalance, actualBalance);
   } catch (error45) {
-    return buildErrorResult4({
+    return buildErrorResult2({
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
@@ -24055,7 +24035,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   try {
     difference = calculateDifference(closingBalance, actualBalance);
   } catch (error45) {
-    return buildErrorResult4({
+    return buildErrorResult2({
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
@@ -24065,7 +24045,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
       metadata
     });
   }
-  return buildErrorResult4({
+  return buildErrorResult2({
     csvFile: relativeCsvPath,
     account,
     lastTransactionDate,
@@ -24116,13 +24096,13 @@ Note: This tool requires a contextId from a prior classify/import step.`,
 import * as path12 from "path";
 
 // src/utils/accountDeclarations.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function extractAccountsFromRulesFile(rulesPath) {
   const accounts = new Set;
-  if (!fs11.existsSync(rulesPath)) {
+  if (!fs12.existsSync(rulesPath)) {
     return accounts;
   }
-  const content = fs11.readFileSync(rulesPath, "utf-8");
+  const content = fs12.readFileSync(rulesPath, "utf-8");
   const lines = content.split(`
 `);
   for (const line of lines) {
@@ -24157,10 +24137,10 @@ function sortAccountDeclarations(accounts) {
   return Array.from(accounts).sort((a, b) => a.localeCompare(b));
 }
 function ensureAccountDeclarations(yearJournalPath, accounts) {
-  if (!fs11.existsSync(yearJournalPath)) {
+  if (!fs12.existsSync(yearJournalPath)) {
     throw new Error(`Year journal not found: ${yearJournalPath}`);
   }
-  const content = fs11.readFileSync(yearJournalPath, "utf-8");
+  const content = fs12.readFileSync(yearJournalPath, "utf-8");
   const lines = content.split(`
 `);
   const existingAccounts = new Set;
@@ -24222,7 +24202,7 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
     newContent.push("");
   }
   newContent.push(...otherLines);
-  fs11.writeFileSync(yearJournalPath, newContent.join(`
+  fs12.writeFileSync(yearJournalPath, newContent.join(`
 `));
   return {
     added: Array.from(missingAccounts).sort(),
@@ -24231,7 +24211,7 @@ function ensureAccountDeclarations(yearJournalPath, accounts) {
 }
 
 // src/utils/logger.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import path11 from "path";
 var LOG_LINE_LIMIT = 50;
 
@@ -24346,8 +24326,8 @@ class MarkdownLogger {
     if (this.buffer.length === 0)
       return;
     try {
-      await fs12.mkdir(path11.dirname(this.logPath), { recursive: true });
-      await fs12.writeFile(this.logPath, this.buffer.join(`
+      await fs13.mkdir(path11.dirname(this.logPath), { recursive: true });
+      await fs13.writeFile(this.logPath, this.buffer.join(`
 `), "utf-8");
     } catch {}
   }
@@ -24401,12 +24381,12 @@ function buildStepResult(success2, message, details) {
   }
   return result;
 }
-function buildSuccessResult4(result, summary) {
+function buildPipelineSuccessResult(result, summary) {
   result.success = true;
   result.summary = summary;
   return JSON.stringify(result);
 }
-function buildErrorResult5(result, error45, hint) {
+function buildPipelineErrorResult(result, error45, hint) {
   result.success = false;
   result.error = error45;
   if (hint) {
@@ -24586,9 +24566,9 @@ async function executeDryRunStep(context, contextId, logger) {
           } catch {}
         }
         const suggestionContext = {
-          existingAccounts: yearJournalPath ? await loadExistingAccounts2(yearJournalPath) : [],
+          existingAccounts: yearJournalPath ? loadExistingAccounts2(yearJournalPath) : [],
           rulesFilePath: firstRulesFile,
-          existingRules: firstRulesFile ? await extractRulePatternsFromFile2(firstRulesFile) : undefined,
+          existingRules: firstRulesFile ? extractRulePatternsFromFile2(firstRulesFile) : undefined,
           yearJournalPath,
           logger
         };
@@ -24730,7 +24710,7 @@ async function executeReconcileStep(context, contextId, logger) {
 function handleNoTransactions(result) {
   result.steps.import = buildStepResult(true, "No transactions to import");
   result.steps.reconcile = buildStepResult(true, "Reconciliation skipped (no transactions)");
-  return buildSuccessResult4(result, "No transactions found to import");
+  return buildPipelineSuccessResult(result, "No transactions found to import");
 }
 async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "import pipeline");
@@ -24759,7 +24739,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     const contextIds = await executeClassifyStep(context, logger);
     if (contextIds.length === 0) {
       logger.info("No files classified, nothing to import");
-      return buildSuccessResult4(result, "No files to import");
+      return buildPipelineSuccessResult(result, "No files to import");
     }
     let totalTransactions = 0;
     for (const contextId of contextIds) {
@@ -24780,7 +24760,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     }
     logger.info(`Log file: ${logger.getLogPath()}`);
     logger.endSection();
-    return buildSuccessResult4(result, `Successfully imported ${totalTransactions} transaction(s) from ${contextIds.length} file(s)`);
+    return buildPipelineSuccessResult(result, `Successfully imported ${totalTransactions} transaction(s) from ${contextIds.length} file(s)`);
   } catch (error45) {
     logger.error("Pipeline step failed", error45);
     logger.info(`Log file: ${logger.getLogPath()}`);
@@ -24790,7 +24770,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
     if (!result.error) {
       result.error = error45 instanceof Error ? error45.message : String(error45);
     }
-    return buildErrorResult5(result, result.error, result.hint);
+    return buildPipelineErrorResult(result, result.error, result.hint);
   } finally {
     logger.endSection();
     await logger.flush();
@@ -24841,7 +24821,7 @@ This tool orchestrates the full import workflow:
   }
 });
 // src/tools/init-directories.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -24849,8 +24829,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs14.existsSync(importBase)) {
-      fs14.mkdirSync(importBase, { recursive: true });
+    if (!fs15.existsSync(importBase)) {
+      fs15.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -24861,19 +24841,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs14.existsSync(fullPath)) {
-        fs14.mkdirSync(fullPath, { recursive: true });
+      if (!fs15.existsSync(fullPath)) {
+        fs15.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs14.existsSync(gitkeepPath)) {
-        fs14.writeFileSync(gitkeepPath, "");
+      if (!fs15.existsSync(gitkeepPath)) {
+        fs15.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs14.existsSync(gitignorePath)) {
+    if (!fs15.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -24891,7 +24871,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs14.writeFileSync(gitignorePath, gitignoreContent);
+      fs15.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];

package/package.json

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