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

package/dist/index.js

@@ -2686,17 +2686,16 @@ function loadAgent(filePath) {
   if (!match) {
     throw new Error(`Invalid frontmatter format in ${filePath}`);
   }
-  const data = jsYaml.load(match[1]);
+  const raw = jsYaml.load(match[1]);
+  if (typeof raw !== "object" || raw === null || typeof raw.description !== "string") {
+    throw new Error(`Invalid frontmatter in ${filePath}: must be an object with a "description" string`);
+  }
+  const data = raw;
+  const { description, ...optional } = data;
   return {
-    description: data.description,
+    description,
     prompt: match[2].trim(),
-    ...data.mode && { mode: data.mode },
-    ...data.model && { model: data.model },
-    ...data.temperature !== undefined && { temperature: data.temperature },
-    ...data.maxSteps !== undefined && { maxSteps: data.maxSteps },
-    ...data.disable !== undefined && { disable: data.disable },
-    ...data.tools && { tools: data.tools },
-    ...data.permissions && { permissions: data.permissions }
+    ...Object.fromEntries(Object.entries(optional).filter(([, v]) => v !== undefined))
   };
 }
 var init_agentLoader = __esm(() => {
@@ -4293,94 +4292,63 @@ function extractRulePatternsFromFile(rulesPath) {
   }
   return patterns;
 }
-function buildBatchSuggestionPrompt(postings, context) {
-  let prompt = `You are an accounting assistant helping categorize bank transactions.
-
-`;
-  prompt += `I have ${postings.length} transaction(s) that need account classification:
-
-`;
-  if (context.existingAccounts.length > 0) {
-    prompt += `## Existing Account Hierarchy
+function buildAccountHierarchySection(accounts) {
+  if (accounts.length === 0)
+    return "";
+  return `## Existing Account Hierarchy
 
-`;
-    prompt += context.existingAccounts.map((acc) => `- ${acc}`).join(`
-`);
-    prompt += `
+${accounts.map((acc) => `- ${acc}`).join(`
+`)}
 
 `;
-  }
-  if (context.existingRules && context.existingRules.length > 0) {
-    prompt += `## Example Classification Patterns from Rules
+}
+function buildRuleExamplesSection(rules) {
+  if (!rules || rules.length === 0)
+    return "";
+  const sampleSize = Math.min(EXAMPLE_PATTERN_SAMPLE_SIZE, rules.length);
+  const lines = rules.slice(0, sampleSize).map((p) => `- If description matches "${p.condition}" \u2192 ${p.account}`);
+  return `## Example Classification Patterns from Rules
 
-`;
-    const sampleSize = Math.min(EXAMPLE_PATTERN_SAMPLE_SIZE, context.existingRules.length);
-    for (let i2 = 0;i2 < sampleSize; i2++) {
-      const pattern = context.existingRules[i2];
-      prompt += `- If description matches "${pattern.condition}" \u2192 ${pattern.account}
-`;
-    }
-    prompt += `
-`;
-  }
-  prompt += `## Transactions to Classify
+${lines.join(`
+`)}
 
 `;
-  postings.forEach((posting, index) => {
-    prompt += `Transaction ${index + 1}:
-`;
-    prompt += `- Type: ${posting.account === "income:unknown" ? "Income" : "Expense"}
-`;
-    prompt += `- Date: ${posting.date}
-`;
-    prompt += `- Description: ${posting.description}
-`;
-    prompt += `- Amount: ${posting.amount}
-`;
+}
+function buildTransactionsSection(postings) {
+  const lines = postings.map((posting, index) => {
+    const parts = [
+      `Transaction ${index + 1}:`,
+      `- Type: ${posting.account === "income:unknown" ? "Income" : "Expense"}`,
+      `- Date: ${posting.date}`,
+      `- Description: ${posting.description}`,
+      `- Amount: ${posting.amount}`
+    ];
     if (posting.csvRow) {
-      prompt += `- CSV Data: ${JSON.stringify(posting.csvRow)}
-`;
+      parts.push(`- CSV Data: ${JSON.stringify(posting.csvRow)}`);
     }
-    prompt += `
-`;
+    return parts.join(`
+`);
   });
-  prompt += `## Task
+  return `## Transactions to Classify
 
-`;
-  prompt += `For EACH transaction, suggest the most appropriate account. You may:
-`;
-  prompt += `1. Suggest an existing account from the hierarchy above
-`;
-  prompt += `2. Propose a NEW account following the existing naming patterns
-
-`;
-  prompt += `## Response Format
+${lines.join(`
 
-`;
-  prompt += `Respond with suggestions for ALL transactions in this exact format:
-
-`;
-  prompt += `TRANSACTION 1:
-`;
-  prompt += `ACCOUNT: {account_name}
-`;
-  prompt += `CONFIDENCE: {high|medium|low}
-`;
-  prompt += `REASONING: {brief one-sentence explanation}
-
-`;
-  prompt += `TRANSACTION 2:
-`;
-  prompt += `ACCOUNT: {account_name}
-`;
-  prompt += `CONFIDENCE: {high|medium|low}
-`;
-  prompt += `REASONING: {brief one-sentence explanation}
+`)}
 
 `;
-  prompt += `... (continue for all transactions)
-`;
-  return prompt;
+}
+function buildBatchSuggestionPrompt(postings, context) {
+  return [
+    `You are an accounting assistant helping categorize bank transactions.
+`,
+    `I have ${postings.length} transaction(s) that need account classification:
+`,
+    buildAccountHierarchySection(context.existingAccounts),
+    buildRuleExamplesSection(context.existingRules),
+    buildTransactionsSection(postings),
+    RESPONSE_FORMAT_SECTION
+  ].join(`
+`);
 }
 function parseBatchSuggestionResponse(response) {
   const suggestions = [];
@@ -4399,20 +4367,36 @@ function parseBatchSuggestionResponse(response) {
   }
   return suggestions;
 }
-async function suggestAccountsForPostingsBatch(postings, context) {
-  if (postings.length === 0) {
-    return [];
-  }
-  const uncachedPostings = [];
-  const cachedResults = new Map;
+function partitionByCacheStatus(postings) {
+  const uncached = [];
+  const cached2 = new Map;
   postings.forEach((posting, index) => {
     const hash2 = hashTransaction(posting);
     if (suggestionCache[hash2]) {
-      cachedResults.set(index, suggestionCache[hash2]);
+      cached2.set(index, suggestionCache[hash2]);
     } else {
-      uncachedPostings.push(posting);
+      uncached.push(posting);
     }
   });
+  return { uncached, cached: cached2 };
+}
+function mergeSuggestions(postings, cachedResults, newSuggestions) {
+  let uncachedIndex = 0;
+  return postings.map((posting, index) => {
+    const suggestion = cachedResults.get(index) || newSuggestions[uncachedIndex++];
+    return {
+      ...posting,
+      suggestedAccount: suggestion?.account,
+      suggestionConfidence: suggestion?.confidence,
+      suggestionReasoning: suggestion?.reasoning
+    };
+  });
+}
+async function suggestAccountsForPostingsBatch(postings, context) {
+  if (postings.length === 0) {
+    return [];
+  }
+  const { uncached: uncachedPostings, cached: cachedResults } = partitionByCacheStatus(postings);
   context.logger?.info(`Account suggestions: ${cachedResults.size} cached, ${uncachedPostings.length} to generate`);
   let newSuggestions = [];
   if (uncachedPostings.length > 0) {
@@ -4445,19 +4429,7 @@ ${userPrompt}`;
       return postings;
     }
   }
-  const results = [];
-  let uncachedIndex = 0;
-  postings.forEach((posting, index) => {
-    const cachedSuggestion = cachedResults.get(index);
-    const suggestion = cachedSuggestion || newSuggestions[uncachedIndex++];
-    results.push({
-      ...posting,
-      suggestedAccount: suggestion?.account,
-      suggestionConfidence: suggestion?.confidence,
-      suggestionReasoning: suggestion?.reasoning
-    });
-  });
-  return results;
+  return mergeSuggestions(postings, cachedResults, newSuggestions);
 }
 function generateMockSuggestions(postings) {
   let response = "";
@@ -4492,10 +4464,34 @@ function generateMockSuggestions(postings) {
   });
   return response;
 }
-var EXAMPLE_PATTERN_SAMPLE_SIZE = 10, suggestionCache;
+var EXAMPLE_PATTERN_SAMPLE_SIZE = 10, suggestionCache, RESPONSE_FORMAT_SECTION;
 var init_accountSuggester = __esm(() => {
   init_agentLoader();
   suggestionCache = {};
+  RESPONSE_FORMAT_SECTION = [
+    `## Task
+`,
+    "For EACH transaction, suggest the most appropriate account. You may:",
+    "1. Suggest an existing account from the hierarchy above",
+    `2. Propose a NEW account following the existing naming patterns
+`,
+    `## Response Format
+`,
+    `Respond with suggestions for ALL transactions in this exact format:
+`,
+    "TRANSACTION 1:",
+    "ACCOUNT: {account_name}",
+    "CONFIDENCE: {high|medium|low}",
+    `REASONING: {brief one-sentence explanation}
+`,
+    "TRANSACTION 2:",
+    "ACCOUNT: {account_name}",
+    "CONFIDENCE: {high|medium|low}",
+    `REASONING: {brief one-sentence explanation}
+`,
+    "... (continue for all transactions)"
+  ].join(`
+`);
 });
 
 // src/index.ts
@@ -16920,13 +16916,7 @@ function findCsvFiles(baseDir, options = {}) {
   if (!fs3.existsSync(baseDir)) {
     return [];
   }
-  let searchDir = baseDir;
-  if (options.subdir) {
-    searchDir = path2.join(searchDir, options.subdir);
-    if (options.subsubdir) {
-      searchDir = path2.join(searchDir, options.subsubdir);
-    }
-  }
+  const searchDir = path2.join(...[baseDir, options.subdir, options.subsubdir].filter((p) => !!p));
   if (!fs3.existsSync(searchDir)) {
     return [];
   }
@@ -16957,6 +16947,13 @@ function findCsvFiles(baseDir, options = {}) {
   }
   return csvFiles.sort();
 }
+function sortByMtimeNewestFirst(files) {
+  return [...files].sort((a, b) => {
+    const aStat = fs3.statSync(a);
+    const bStat = fs3.statSync(b);
+    return bStat.mtime.getTime() - aStat.mtime.getTime();
+  });
+}
 function ensureDirectory(dirPath) {
   if (!fs3.existsSync(dirPath)) {
     fs3.mkdirSync(dirPath, { recursive: true });
@@ -17079,9 +17076,6 @@ function buildPricehistArgs(startDate, endDate, currencyConfig) {
   }
   return cmdArgs;
 }
-function buildErrorResult(error45) {
-  return buildToolErrorResult(error45);
-}
 function buildSuccessResult(results, endDate, backfill) {
   return buildToolSuccessResult({
     success: results.every((r) => !("error" in r)),
@@ -17116,7 +17110,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();
@@ -17433,28 +17427,15 @@ import { randomUUID } from "crypto";
 function getContextPath(directory, contextId) {
   return path5.join(directory, ".memory", `${contextId}.json`);
 }
-function ensureMemoryDir(directory) {
-  ensureDirectory(path5.join(directory, ".memory"));
-}
 function createContext(directory, params) {
   const now = new Date().toISOString();
   const context = {
     id: randomUUID(),
     createdAt: now,
     updatedAt: now,
-    filename: params.filename,
-    filePath: params.filePath,
-    provider: params.provider,
-    currency: params.currency,
-    accountNumber: params.accountNumber,
-    originalFilename: params.originalFilename,
-    fromDate: params.fromDate,
-    untilDate: params.untilDate,
-    openingBalance: params.openingBalance,
-    closingBalance: params.closingBalance,
-    account: params.account
-  };
-  ensureMemoryDir(directory);
+    ...params
+  };
+  ensureDirectory(path5.join(directory, ".memory"));
   const contextPath = getContextPath(directory, context.id);
   fs5.writeFileSync(contextPath, JSON.stringify(context, null, 2), "utf-8");
   return context;
@@ -17515,20 +17496,6 @@ function buildSuccessResult2(classified, unrecognized, message) {
     }
   });
 }
-function buildErrorResult2(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 buildToolErrorResult(error45, undefined, {
-    collisions,
-    classified: [],
-    unrecognized: []
-  });
-}
 function planMoves(csvFiles, importsDir, pendingDir, unrecognizedDir, config2) {
   const plannedMoves = [];
   const collisions = [];
@@ -17629,7 +17596,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);
@@ -17640,7 +17610,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);
@@ -23025,6 +23000,7 @@ function findRulesForCsv(csvPath, mapping) {
 // src/utils/hledgerExecutor.ts
 var {$: $2 } = globalThis.Bun;
 var STDERR_TRUNCATE_LENGTH = 500;
+var TX_HEADER_PATTERN = /^(\d{4})-(\d{2}-\d{2})\s+(.+)$/;
 async function defaultHledgerExecutor(cmdArgs) {
   try {
     const result = await $2`hledger ${cmdArgs}`.quiet().nothrow();
@@ -23059,10 +23035,10 @@ function parseUnknownPostings(hledgerOutput) {
   let currentDate = "";
   let currentDescription = "";
   for (const line of lines) {
-    const headerMatch = line.match(/^(\d{4}-\d{2}-\d{2})\s+(.+)$/);
+    const headerMatch = line.match(TX_HEADER_PATTERN);
     if (headerMatch) {
-      currentDate = headerMatch[1];
-      currentDescription = headerMatch[2].trim();
+      currentDate = `${headerMatch[1]}-${headerMatch[2]}`;
+      currentDescription = headerMatch[3].trim();
       continue;
     }
     const postingMatch = line.match(/^\s+(income:unknown|expenses:unknown)\s+([^\s]+(?:\s+[^\s=]+)?)\s*(?:=\s*(.+))?$/);
@@ -23083,7 +23059,7 @@ function countTransactions(hledgerOutput) {
 `);
   let count = 0;
   for (const line of lines) {
-    if (/^\d{4}-\d{2}-\d{2}\s+/.test(line)) {
+    if (TX_HEADER_PATTERN.test(line)) {
       count++;
     }
   }
@@ -23094,7 +23070,7 @@ function extractTransactionYears(hledgerOutput) {
   const lines = hledgerOutput.split(`
 `);
   for (const line of lines) {
-    const match2 = line.match(/^(\d{4})-\d{2}-\d{2}\s+/);
+    const match2 = line.match(TX_HEADER_PATTERN);
     if (match2) {
       years.add(parseInt(match2[1], 10));
     }
@@ -23154,6 +23130,13 @@ async function getAccountBalance(mainJournalPath, account, asOfDate, executor =
 
 // src/utils/rulesParser.ts
 import * as fs8 from "fs";
+function resolveFieldRef(fieldRef, fieldNames) {
+  if (/^\d+$/.test(fieldRef)) {
+    const index = parseInt(fieldRef, 10) - 1;
+    return fieldNames[index] || fieldRef;
+  }
+  return fieldRef;
+}
 function parseSkipRows(rulesContent) {
   const match2 = rulesContent.match(/^skip\s+(\d+)/m);
   return match2 ? parseInt(match2[1], 10) : 0;
@@ -23178,24 +23161,13 @@ function parseDateField(rulesContent, fieldNames) {
   if (!match2) {
     return fieldNames[0] || "date";
   }
-  const value = match2[1];
-  if (/^\d+$/.test(value)) {
-    const index = parseInt(value, 10) - 1;
-    return fieldNames[index] || value;
-  }
-  return value;
+  return resolveFieldRef(match2[1], fieldNames);
 }
 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;
-    }
+    result.single = resolveFieldRef(simpleMatch[2], fieldNames);
   }
   const debitMatch = rulesContent.match(/if\s+%(\w+)\s+\.\s*\n\s*amount\s+-?%\1/m);
   if (debitMatch) {
@@ -23260,29 +23232,34 @@ function parseBalance(balance) {
   const amount = parseFloat(amountStr.replace(/,/g, ""));
   return { currency, amount };
 }
+function validateCurrencies(a, b) {
+  if (a.currency && b.currency && a.currency !== b.currency) {
+    throw new Error(`Currency mismatch: ${a.currency} vs ${b.currency}`);
+  }
+}
 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}`);
-  }
+  validateCurrencies(expectedParsed, actualParsed);
   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 formatBalance(amount, currency) {
+  const formattedAmount = amount.toFixed(2);
+  return currency ? `${currency} ${formattedAmount}` : formattedAmount;
+}
 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}`);
-  }
+  validateCurrencies(parsed1, parsed2);
   return parsed1.amount === parsed2.amount;
 }
 
@@ -23299,13 +23276,13 @@ function parseCsvFile(csvPath, config2) {
   const csvWithHeader = lines.slice(headerIndex).join(`
 `);
   const useFieldNames = config2.fieldNames.length > 0;
-  const result = import_papaparse2.default.parse(csvWithHeader, {
-    header: !useFieldNames,
-    delimiter: config2.separator,
-    skipEmptyLines: true
-  });
   if (useFieldNames) {
-    const rawRows = result.data;
+    const result2 = import_papaparse2.default.parse(csvWithHeader, {
+      header: false,
+      delimiter: config2.separator,
+      skipEmptyLines: true
+    });
+    const rawRows = result2.data;
     const dataRows = rawRows.slice(1);
     return dataRows.map((values) => {
       const row = {};
@@ -23315,6 +23292,11 @@ function parseCsvFile(csvPath, config2) {
       return row;
     });
   }
+  const result = import_papaparse2.default.parse(csvWithHeader, {
+    header: true,
+    delimiter: config2.separator,
+    skipEmptyLines: true
+  });
   return result.data;
 }
 function getRowAmount(row, amountFields) {
@@ -23375,8 +23357,7 @@ function looksLikeTransactionId(fieldName, value) {
   if (!nameMatches)
     return false;
   const trimmedValue = value.trim();
-  const looksLikeId = /^[A-Za-z0-9_-]+$/.test(trimmedValue) && trimmedValue.length >= 3;
-  return looksLikeId;
+  return /^[A-Za-z0-9_-]+$/.test(trimmedValue) && trimmedValue.length >= 3;
 }
 function findTransactionId(row) {
   for (const [field, value] of Object.entries(row)) {
@@ -23393,9 +23374,7 @@ function findMatchingCsvRow(posting, csvRows, config2) {
     const rowAmount = getRowAmount(row, config2.amountFields);
     if (rowDate !== posting.date)
       return false;
-    if (Math.abs(rowAmount - postingAmount) > AMOUNT_MATCH_TOLERANCE)
-      return false;
-    return true;
+    return Math.abs(rowAmount - postingAmount) <= AMOUNT_MATCH_TOLERANCE;
   });
   if (candidates.length === 1) {
     return candidates[0];
@@ -23416,17 +23395,11 @@ function findMatchingCsvRow(posting, csvRows, config2) {
   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];
+  return descMatches[0] || candidates[0];
 }
 
 // src/tools/import-statements.ts
-function buildErrorResult3(error45, hint) {
+function buildErrorResult(error45, hint) {
   return buildToolErrorResult(error45, hint, {
     files: [],
     summary: {
@@ -23447,23 +23420,16 @@ function buildSuccessResult3(files, summary, message) {
 }
 function findCsvFromRulesFile(rulesFile) {
   const content = fs10.readFileSync(rulesFile, "utf-8");
-  const match2 = content.match(/^source\s+([^\n#]+)/m);
-  if (!match2) {
+  const sourcePath = parseSourceDirective(content);
+  if (!sourcePath) {
     return null;
   }
-  const sourcePath = match2[1].trim();
-  const rulesDir = path9.dirname(rulesFile);
-  const absolutePattern = path9.resolve(rulesDir, sourcePath);
+  const absolutePattern = resolveSourcePath(sourcePath, rulesFile);
   const matches = glob.sync(absolutePattern);
   if (matches.length === 0) {
     return null;
   }
-  matches.sort((a, b) => {
-    const aStat = fs10.statSync(a);
-    const bStat = fs10.statSync(b);
-    return bStat.mtime.getTime() - aStat.mtime.getTime();
-  });
-  return matches[0];
+  return sortByMtimeNewestFirst(matches)[0];
 }
 async function executeImports(fileResults, directory, pendingDir, doneDir, hledgerExecutor) {
   const importedFiles = [];
@@ -23597,7 +23563,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);
@@ -23606,7 +23572,7 @@ async function importStatements(directory, agent, options, configLoader = loadIm
   const importContext = loadContext(directory, options.contextId);
   const csvPath = path9.join(directory, importContext.filePath);
   if (!fs10.existsSync(csvPath)) {
-    return buildErrorResult3(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
+    return buildErrorResult(`CSV file not found: ${importContext.filePath}`, "The file may have been moved or deleted");
   }
   const csvFiles = [csvPath];
   const fileResults = [];
@@ -23639,12 +23605,7 @@ async function importStatements(directory, agent, options, configLoader = loadIm
     totalUnknown += fileResult.unknownPostings.length;
   }
   for (const [_rulesFile, matchingCSVs] of rulesFileToCSVs.entries()) {
-    matchingCSVs.sort((a, b) => {
-      const aStat = fs10.statSync(a);
-      const bStat = fs10.statSync(b);
-      return bStat.mtime.getTime() - aStat.mtime.getTime();
-    });
-    const newestCSV = matchingCSVs[0];
+    const newestCSV = sortByMtimeNewestFirst(matchingCSVs)[0];
     const fileResult = await processCsvFile(newestCSV, rulesMapping, directory, hledgerExecutor);
     fileResults.push(fileResult);
     if (fileResult.error) {
@@ -23758,7 +23719,7 @@ Note: This tool is typically called via import-pipeline for the full workflow.`,
 // src/tools/reconcile-statement.ts
 import * as fs11 from "fs";
 import * as path10 from "path";
-function buildErrorResult4(params) {
+function buildErrorResult2(params) {
   return buildToolErrorResult(params.error, params.hint, {
     account: params.account ?? "",
     expectedBalance: params.expectedBalance ?? "",
@@ -23775,7 +23736,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"
       })
@@ -23786,7 +23747,7 @@ function verifyCsvExists(directory, importContext) {
   const csvFile = path10.join(directory, importContext.filePath);
   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}`
       })
@@ -23853,7 +23814,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}`,
@@ -23883,7 +23844,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,
@@ -23945,7 +23906,7 @@ function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
           }
         }
       }
-      const balanceStr = currency ? `${currency} ${numericValue.toFixed(2)}` : numericValue.toFixed(2);
+      const balanceStr = formatBalance(numericValue, currency || undefined);
       return {
         balance: balanceStr,
         confidence: "high",
@@ -23966,7 +23927,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/"
     });
@@ -23995,7 +23956,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",
@@ -24005,7 +23966,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,
@@ -24018,7 +23979,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   try {
     doBalancesMatch = balancesMatch(closingBalance, actualBalance);
   } catch (error45) {
-    return buildErrorResult4({
+    return buildErrorResult2({
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
@@ -24047,7 +24008,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
   try {
     difference = calculateDifference(closingBalance, actualBalance);
   } catch (error45) {
-    return buildErrorResult4({
+    return buildErrorResult2({
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
@@ -24057,7 +24018,7 @@ async function reconcileStatement(directory, agent, options, configLoader = load
       metadata
     });
   }
-  return buildErrorResult4({
+  return buildErrorResult2({
     csvFile: relativeCsvPath,
     account,
     lastTransactionDate,
@@ -24130,7 +24091,6 @@ function extractAccountsFromRulesFile(rulesPath) {
     const account2Match = trimmed.match(/account2\s+(.+?)(?:\s+|$)/);
     if (account2Match) {
       accounts.add(account2Match[1].trim());
-      continue;
     }
   }
   return accounts;
@@ -24148,52 +24108,46 @@ function getAllAccountsFromRules(rulesPaths) {
 function sortAccountDeclarations(accounts) {
   return Array.from(accounts).sort((a, b) => a.localeCompare(b));
 }
-function ensureAccountDeclarations(yearJournalPath, accounts) {
-  if (!fs12.existsSync(yearJournalPath)) {
-    throw new Error(`Year journal not found: ${yearJournalPath}`);
-  }
-  const content = fs12.readFileSync(yearJournalPath, "utf-8");
+function parseJournalSections(content) {
   const lines = content.split(`
 `);
   const existingAccounts = new Set;
   const commentLines = [];
-  const accountLines = [];
   const otherLines = [];
   let inAccountSection = false;
   let accountSectionEnded = false;
   for (const line of lines) {
     const trimmed = line.trim();
     if (trimmed.startsWith(";") || trimmed.startsWith("#")) {
-      if (!accountSectionEnded) {
-        commentLines.push(line);
-      } else {
-        otherLines.push(line);
-      }
+      (accountSectionEnded ? otherLines : commentLines).push(line);
       continue;
     }
     if (trimmed.startsWith("account ")) {
       inAccountSection = true;
       const accountMatch = trimmed.match(/^account\s+(.+?)(?:\s+|$)/);
       if (accountMatch) {
-        const accountName = accountMatch[1].trim();
-        existingAccounts.add(accountName);
-        accountLines.push(line);
+        existingAccounts.add(accountMatch[1].trim());
       }
       continue;
     }
     if (trimmed === "") {
-      if (inAccountSection && !accountSectionEnded) {
-        accountLines.push(line);
-      } else {
-        otherLines.push(line);
-      }
+      if (inAccountSection && !accountSectionEnded)
+        continue;
+      otherLines.push(line);
       continue;
     }
-    if (inAccountSection) {
+    if (inAccountSection)
       accountSectionEnded = true;
-    }
     otherLines.push(line);
   }
+  return { existingAccounts, commentLines, otherLines };
+}
+function ensureAccountDeclarations(yearJournalPath, accounts) {
+  if (!fs12.existsSync(yearJournalPath)) {
+    throw new Error(`Year journal not found: ${yearJournalPath}`);
+  }
+  const content = fs12.readFileSync(yearJournalPath, "utf-8");
+  const { existingAccounts, commentLines, otherLines } = parseJournalSections(content);
   const missingAccounts = new Set;
   for (const account of accounts) {
     if (!existingAccounts.has(account)) {
@@ -24259,14 +24213,10 @@ class MarkdownLogger {
     }
   }
   info(message) {
-    this.buffer.push(message);
-    if (this.autoFlush)
-      this.flushAsync();
+    this.log(message);
   }
   warn(message) {
-    this.buffer.push(`\u26A0\uFE0F **WARNING**: ${message}`);
-    if (this.autoFlush)
-      this.flushAsync();
+    this.log(`\u26A0\uFE0F **WARNING**: ${message}`);
   }
   error(message, error45) {
     this.buffer.push(`\u274C **ERROR**: ${message}`);
@@ -24282,13 +24232,10 @@ class MarkdownLogger {
       this.buffer.push("```");
       this.buffer.push("");
     }
-    if (this.autoFlush)
-      this.flushAsync();
+    this.autoFlushIfEnabled();
   }
   debug(message) {
-    this.buffer.push(`\uD83D\uDD0D ${message}`);
-    if (this.autoFlush)
-      this.flushAsync();
+    this.log(`\uD83D\uDD0D ${message}`);
   }
   logStep(stepName, status, details) {
     const icon = status === "success" ? "\u2705" : status === "error" ? "\u274C" : "\u25B6\uFE0F";
@@ -24298,8 +24245,7 @@ class MarkdownLogger {
       this.buffer.push(`  ${details}`);
     }
     this.buffer.push("");
-    if (this.autoFlush)
-      this.flushAsync();
+    this.autoFlushIfEnabled();
   }
   logCommand(command, output) {
     this.buffer.push("```bash");
@@ -24317,16 +24263,14 @@ class MarkdownLogger {
     }
     this.buffer.push("```");
     this.buffer.push("");
-    if (this.autoFlush)
-      this.flushAsync();
+    this.autoFlushIfEnabled();
   }
   logResult(data) {
     this.buffer.push("```json");
     this.buffer.push(JSON.stringify(data, null, 2));
     this.buffer.push("```");
     this.buffer.push("");
-    if (this.autoFlush)
-      this.flushAsync();
+    this.autoFlushIfEnabled();
   }
   setContext(key, value) {
     this.context[key] = value;
@@ -24346,6 +24290,15 @@ class MarkdownLogger {
   getLogPath() {
     return this.logPath;
   }
+  log(message) {
+    this.buffer.push(message);
+    this.autoFlushIfEnabled();
+  }
+  autoFlushIfEnabled() {
+    if (!this.autoFlush)
+      return;
+    this.flushAsync();
+  }
   flushAsync() {
     this.pendingFlush = this.flush().catch(() => {});
   }
@@ -24490,7 +24443,8 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
           break;
         }
       }
-    } catch {
+    } catch (error45) {
+      logger?.debug(`Failed to extract year from rules file ${rulesFile}: ${error45 instanceof Error ? error45.message : String(error45)}`);
       continue;
     }
   }
@@ -24528,6 +24482,37 @@ async function executeAccountDeclarationsStep(context, contextId, logger) {
   });
   logger?.endSection();
 }
+async function buildSuggestionContext(context, contextId, logger) {
+  const { loadExistingAccounts: loadExistingAccounts2, extractRulePatternsFromFile: extractRulePatternsFromFile2 } = await Promise.resolve().then(() => (init_accountSuggester(), exports_accountSuggester));
+  const config2 = context.configLoader(context.directory);
+  const rulesDir = path12.join(context.directory, config2.paths.rules);
+  const importCtx = loadContext(context.directory, contextId);
+  const csvPath = path12.join(context.directory, importCtx.filePath);
+  const rulesMapping = loadRulesMapping(rulesDir);
+  const rulesFile = findRulesForCsv(csvPath, rulesMapping);
+  if (!rulesFile) {
+    return { existingAccounts: [], logger };
+  }
+  let yearJournalPath;
+  try {
+    const result = await context.hledgerExecutor(["print", "-f", rulesFile]);
+    if (result.exitCode === 0) {
+      const years = extractTransactionYears(result.stdout);
+      if (years.size > 0) {
+        yearJournalPath = ensureYearJournalExists(context.directory, Array.from(years)[0]);
+      }
+    }
+  } catch (error45) {
+    logger?.debug(`Could not determine year journal: ${error45 instanceof Error ? error45.message : String(error45)}`);
+  }
+  return {
+    existingAccounts: yearJournalPath ? loadExistingAccounts2(yearJournalPath) : [],
+    rulesFilePath: rulesFile,
+    existingRules: extractRulePatternsFromFile2(rulesFile),
+    yearJournalPath,
+    logger
+  };
+}
 async function executeDryRunStep(context, contextId, logger) {
   logger?.startSection("Step 3: Dry Run Import");
   logger?.logStep("Dry Run", "start");
@@ -24551,39 +24536,8 @@ async function executeDryRunStep(context, contextId, logger) {
     }
     if (allUnknownPostings.length > 0) {
       try {
-        const {
-          suggestAccountsForPostingsBatch: suggestAccountsForPostingsBatch2,
-          loadExistingAccounts: loadExistingAccounts2,
-          extractRulePatternsFromFile: extractRulePatternsFromFile2
-        } = await Promise.resolve().then(() => (init_accountSuggester(), exports_accountSuggester));
-        const config2 = context.configLoader(context.directory);
-        const rulesDir = path12.join(context.directory, config2.paths.rules);
-        const importCtx = loadContext(context.directory, contextId);
-        const csvPath = path12.join(context.directory, importCtx.filePath);
-        const rulesMapping = loadRulesMapping(rulesDir);
-        let yearJournalPath;
-        let firstRulesFile;
-        const rulesFile = findRulesForCsv(csvPath, rulesMapping);
-        if (rulesFile) {
-          firstRulesFile = rulesFile;
-          try {
-            const result = await context.hledgerExecutor(["print", "-f", rulesFile]);
-            if (result.exitCode === 0) {
-              const years = extractTransactionYears(result.stdout);
-              if (years.size > 0) {
-                const transactionYear = Array.from(years)[0];
-                yearJournalPath = ensureYearJournalExists(context.directory, transactionYear);
-              }
-            }
-          } catch {}
-        }
-        const suggestionContext = {
-          existingAccounts: yearJournalPath ? loadExistingAccounts2(yearJournalPath) : [],
-          rulesFilePath: firstRulesFile,
-          existingRules: firstRulesFile ? extractRulePatternsFromFile2(firstRulesFile) : undefined,
-          yearJournalPath,
-          logger
-        };
+        const { suggestAccountsForPostingsBatch: suggestAccountsForPostingsBatch2 } = await Promise.resolve().then(() => (init_accountSuggester(), exports_accountSuggester));
+        const suggestionContext = await buildSuggestionContext(context, contextId, logger);
         postingsWithSuggestions = await suggestAccountsForPostingsBatch2(allUnknownPostings, suggestionContext);
       } catch (error45) {
         logger?.error(`[ERROR] Failed to generate account suggestions: ${error45 instanceof Error ? error45.message : String(error45)}`);

package/package.json

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