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

package/dist/index.js

@@ -2687,16 +2687,11 @@ function loadAgent(filePath) {
     throw new Error(`Invalid frontmatter format in ${filePath}`);
   }
   const data = jsYaml.load(match[1]);
+  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 +4288,63 @@ function extractRulePatternsFromFile(rulesPath) {
   }
   return patterns;
 }
-function buildBatchSuggestionPrompt(postings, context) {
-  let prompt = `You are an accounting assistant helping categorize bank transactions.
+function buildAccountHierarchySection(accounts) {
+  if (accounts.length === 0)
+    return "";
+  return `## Existing Account Hierarchy
 
-`;
-  prompt += `I have ${postings.length} transaction(s) that need account classification:
+${accounts.map((acc) => `- ${acc}`).join(`
+`)}
 
 `;
-  if (context.existingAccounts.length > 0) {
-    prompt += `## Existing Account Hierarchy
+}
+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
 
-`;
-    prompt += context.existingAccounts.map((acc) => `- ${acc}`).join(`
-`);
-    prompt += `
+${lines.join(`
+`)}
 
 `;
-  }
-  if (context.existingRules && context.existingRules.length > 0) {
-    prompt += `## 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
-
-`;
-  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
-
-`;
-  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
+  return `## Transactions to Classify
 
-`;
-  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 +4363,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 +4425,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 +4460,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 +16912,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 [];
   }
@@ -17436,17 +17422,7 @@ function createContext(directory, params) {
     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
+    ...params
   };
   ensureDirectory(path5.join(directory, ".memory"));
   const contextPath = getContextPath(directory, context.id);
@@ -23013,6 +22989,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();
@@ -23047,10 +23024,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*(.+))?$/);
@@ -23071,7 +23048,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++;
     }
   }
@@ -23082,7 +23059,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));
     }
@@ -23142,6 +23119,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;
@@ -23166,24 +23150,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) {
@@ -23248,15 +23221,18 @@ 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;
@@ -23268,9 +23244,7 @@ function balancesMatch(balance1, 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;
 }
 
@@ -23363,8 +23337,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)) {
@@ -23381,9 +23354,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];
@@ -23404,13 +23375,7 @@ 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
@@ -24118,7 +24083,6 @@ function extractAccountsFromRulesFile(rulesPath) {
     const account2Match = trimmed.match(/account2\s+(.+?)(?:\s+|$)/);
     if (account2Match) {
       accounts.add(account2Match[1].trim());
-      continue;
     }
   }
   return accounts;
@@ -24136,52 +24100,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)) {
@@ -24247,14 +24205,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}`);
@@ -24270,13 +24224,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";
@@ -24286,8 +24237,7 @@ class MarkdownLogger {
       this.buffer.push(`  ${details}`);
     }
     this.buffer.push("");
-    if (this.autoFlush)
-      this.flushAsync();
+    this.autoFlushIfEnabled();
   }
   logCommand(command, output) {
     this.buffer.push("```bash");
@@ -24305,16 +24255,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;
@@ -24334,6 +24282,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(() => {});
   }

package/package.json

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