@fuzzle/opencode-accountant 0.4.6-next.1 → 0.5.0-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();
@@ -17058,10 +17080,10 @@ function buildPricehistArgs(startDate, endDate, currencyConfig) {
   return cmdArgs;
 }
 function buildErrorResult(error45) {
-  return JSON.stringify({ error: error45 });
+  return buildToolErrorResult(error45);
 }
 function buildSuccessResult(results, endDate, backfill) {
-  return JSON.stringify({
+  return buildToolSuccessResult({
     success: results.every((r) => !("error" in r)),
     endDate,
     backfill,
@@ -17150,7 +17172,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,17 +17427,14 @@ 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 });
-  }
+  ensureDirectory(path5.join(directory, ".memory"));
 }
 function createContext(directory, params) {
   const now = new Date().toISOString();
@@ -17437,7 +17456,7 @@ function createContext(directory, params) {
   };
   ensureMemoryDir(directory);
   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 +17475,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 +17498,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,
@@ -17498,19 +17516,14 @@ function buildSuccessResult2(classified, unrecognized, message) {
   });
 }
 function buildErrorResult2(error45, hint) {
-  return JSON.stringify({
-    success: false,
-    error: error45,
-    hint,
+  return buildToolErrorResult(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,
+  return buildToolErrorResult(error45, undefined, {
     collisions,
     classified: [],
     unrecognized: []
@@ -17521,7 +17534,7 @@ function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   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 +17546,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 +17582,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 +17607,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)
@@ -17649,7 +17662,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 +21447,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 +21924,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 +21942,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 +22945,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 +22963,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 +23153,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 +23219,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 +23239,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 +23289,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;
@@ -23414,10 +23427,7 @@ function findMatchingCsvRow(posting, csvRows, config2) {
 
 // src/tools/import-statements.ts
 function buildErrorResult3(error45, hint) {
-  const result = {
-    success: false,
-    error: error45,
-    hint,
+  return buildToolErrorResult(error45, hint, {
     files: [],
     summary: {
       filesProcessed: 0,
@@ -23427,28 +23437,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 +23459,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 +23513,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 +23562,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) {
@@ -23609,7 +23605,7 @@ 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)) {
+  if (!fs10.existsSync(csvPath)) {
     return buildErrorResult3(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
   }
   const csvFiles = [csvPath];
@@ -23644,8 +23640,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 +23756,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,
+  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 {
@@ -23792,7 +23784,7 @@ 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: `CSV file not found: ${importContext.filePath}`,
@@ -23830,7 +23822,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) {
@@ -23908,7 +23900,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) {
@@ -24116,13 +24108,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 +24149,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 +24214,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 +24223,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 +24338,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 +24393,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 +24578,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 +24722,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 +24751,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 +24772,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 +24782,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 +24833,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 +24841,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 +24853,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 +24883,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.4.6-next.1",
+  "version": "0.5.0-next.1",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",