@fuzzle/opencode-accountant 0.5.2 → 0.5.4

package/agent/accountant.md

@@ -3,13 +3,13 @@ description: Specialized agent for hledger accounting tasks and transaction mana
 prompt: You are an accounting specialist with expertise in hledger and double-entry bookkeeping. Your role is to help maintain accurate financial records following the user's conventions.
 mode: subagent
 temperature: 0.1
-steps: 8
+maxSteps: 8
 tools:
   bash: true
   edit: true
   write: true
   # MCP tools available: import-pipeline, fetch-currency-prices
-permission:
+permissions:
   bash: allow
   edit: allow
   glob: allow
@@ -151,13 +151,13 @@ The following are MCP tools available to you. Always call these tools directly -
 
 **Arguments:**
 
-| Argument         | Type    | Default | Description                                                                    |
-| ---------------- | ------- | ------- | ------------------------------------------------------------------------------ |
-| `provider`       | string  | -       | Logger metadata (does not filter CSV selection — use classify step for that)    |
-| `currency`       | string  | -       | Logger metadata (does not filter CSV selection — use classify step for that)    |
-| `skipClassify`   | boolean | `false` | Skip classification step                                                       |
-| `closingBalance` | string  | -       | Manual closing balance for reconciliation                                      |
-| `account`        | string  | -       | Manual account override (auto-detected from rules)                             |
+| Argument         | Type    | Default | Description                                                                  |
+| ---------------- | ------- | ------- | ---------------------------------------------------------------------------- |
+| `provider`       | string  | -       | Logger metadata (does not filter CSV selection — use classify step for that) |
+| `currency`       | string  | -       | Logger metadata (does not filter CSV selection — use classify step for that) |
+| `skipClassify`   | boolean | `false` | Skip classification step                                                     |
+| `closingBalance` | string  | -       | Manual closing balance for reconciliation                                    |
+| `account`        | string  | -       | Manual account override (auto-detected from rules)                           |
 
 **Behavior:**
 

package/dist/index.js

@@ -2677,6 +2677,12 @@ var init_js_yaml = __esm(() => {
 
 // src/utils/agentLoader.ts
 import * as fs from "fs";
+function validateAgentFields(data, filePath) {
+  const unknownFields = Object.keys(data).filter((key) => !VALID_AGENT_FIELDS.has(key));
+  if (unknownFields.length > 0) {
+    console.warn(`Warning: Unknown fields in ${filePath} frontmatter: ${unknownFields.join(", ")}. ` + `Valid fields are: ${Array.from(VALID_AGENT_FIELDS).join(", ")}`);
+  }
+}
 function loadAgent(filePath) {
   if (!fs.existsSync(filePath)) {
     return null;
@@ -2686,7 +2692,12 @@ 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;
+  validateAgentFields(data, filePath);
   const { description, ...optional } = data;
   return {
     description,
@@ -2694,8 +2705,19 @@ function loadAgent(filePath) {
     ...Object.fromEntries(Object.entries(optional).filter(([, v]) => v !== undefined))
   };
 }
+var VALID_AGENT_FIELDS;
 var init_agentLoader = __esm(() => {
   init_js_yaml();
+  VALID_AGENT_FIELDS = new Set([
+    "description",
+    "mode",
+    "model",
+    "temperature",
+    "maxSteps",
+    "disable",
+    "tools",
+    "permissions"
+  ]);
 });
 
 // node_modules/papaparse/papaparse.js
@@ -16943,6 +16965,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 });
@@ -23238,6 +23267,10 @@ function calculateDifference(expected, actual) {
   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);
@@ -23261,13 +23294,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 = {};
@@ -23277,6 +23310,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) {
@@ -23400,23 +23438,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 = [];
@@ -23592,12 +23623,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) {
@@ -23898,7 +23924,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",
@@ -24435,7 +24461,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;
     }
   }
@@ -24473,6 +24500,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");
@@ -24496,39 +24554,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.2",
+  "version": "0.5.4",
   "description": "An OpenCode accounting agent, specialized in double-entry-bookkepping with hledger",
   "author": {
     "name": "ali bengali",