@fuzzle/opencode-accountant 0.3.0 → 0.4.0

package/README.md

@@ -201,9 +201,10 @@ The `import-pipeline` tool provides an atomic, safe import workflow using git wo
    - Creates an isolated git worktree
    - Syncs CSV files from main repo to worktree
    - Classifies CSV files by provider/currency
+   - Extracts accounts from rules and creates declarations in year journal
    - Validates all transactions have matching rules
    - Imports transactions to the appropriate year journal
-   - Reconciles closing balance (if available in CSV metadata)
+   - Reconciles closing balance (auto-detected from CSV metadata or data analysis)
    - Merges changes back to main branch with `--no-ff`
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
@@ -237,13 +238,30 @@ The tool will use that rules file when processing `transactions.csv`.
 
 See the hledger documentation for details on rules file format and syntax.
 
+#### Account Declarations
+
+The pipeline automatically manages account declarations:
+
+- Scans rules files matched to the CSVs being imported
+- Extracts all accounts (account1 and account2 directives)
+- Creates or updates year journal files with sorted account declarations
+- Ensures `hledger check --strict` validation passes
+
+**No manual account setup required.** Account declarations are created proactively before import attempts.
+
 #### Unknown Postings
 
 When a transaction doesn't match any `if` pattern in the rules file, hledger assigns it to `income:unknown` or `expenses:unknown` depending on the transaction direction. The pipeline will fail at the validation step, reporting the unknown postings so you can add appropriate rules before retrying.
 
 #### Closing Balance Reconciliation
 
-For providers that include closing balance in CSV metadata (e.g., UBS), the tool automatically validates that the imported transactions result in the correct balance. Configure metadata extraction in `providers.yaml`:
+The import pipeline automatically detects closing balance using the following fallback chain:
+
+1. **CSV Metadata Extraction**: For providers with closing balance in metadata (e.g., UBS)
+2. **CSV Data Analysis**: Extracts balance from the last transaction row if metadata unavailable
+3. **Manual Override**: Use the `closingBalance` parameter when automatic detection fails
+
+Configure metadata extraction in `providers.yaml`:
 
 ```yaml
 metadata:
@@ -258,7 +276,10 @@ metadata:
     column: 1
 ```
 
-For providers without closing balance in metadata (e.g., Revolut), provide it manually via the `closingBalance` argument.
+**Note:** For most CSV formats, the closing balance will be detected automatically. Manual override is only needed when:
+
+- CSV has no balance information in metadata or data
+- The auto-detected balance has low confidence
 
 ## Development
 

package/agent/accountant.md

@@ -89,9 +89,10 @@ The `import-pipeline` tool provides an **atomic, safe workflow** using git workt
 3. **Automatic Processing**: The tool creates an isolated git worktree and:
    - Syncs CSV files from main repo to worktree
    - Classifies CSV files by provider/currency
+   - Extracts required accounts from rules files and updates year journal
    - Validates all transactions have matching rules
    - Imports transactions to the appropriate year journal
-   - Reconciles closing balance (if available in CSV metadata)
+   - Reconciles closing balance (auto-detected from CSV metadata or data, or manual override)
    - Merges changes back to main branch with `--no-ff`
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
@@ -108,6 +109,25 @@ The `import-pipeline` tool provides an **atomic, safe workflow** using git workt
 - Use field names from the `fields` directive for matching
 - Unknown account pattern: `income:unknown` (positive amounts) / `expenses:unknown` (negative amounts)
 
+### Automatic Account Declarations
+
+The import pipeline automatically:
+
+- Scans matched rules files for all account references (account1, account2 directives)
+- Creates/updates year journal files (e.g., ledger/2026.journal) with sorted account declarations
+- Prevents `hledger check --strict` failures due to missing account declarations
+- No manual account setup required
+
+### Automatic Balance Detection
+
+The reconciliation step attempts to extract closing balance from:
+
+1. CSV header metadata (e.g., UBS "Closing balance:" row)
+2. CSV data analysis (balance field in last transaction row)
+3. Manual override via `closingBalance` parameter (fallback)
+
+For most providers, manual balance input is no longer required.
+
 ## Tool Usage Reference
 
 The following are MCP tools available to you. Always call these tools directly - do not attempt to replicate their behavior with shell commands.
@@ -138,12 +158,13 @@ The following are MCP tools available to you. Always call these tools directly -
 1. Creates isolated git worktree
 2. Syncs CSV files from main repo to worktree
 3. Classifies CSV files (unless `skipClassify: true`)
-4. Validates all transactions have matching rules (dry run)
-5. Imports transactions to year journal
-6. Reconciles closing balance against CSV metadata or manual value
-7. Merges to main with `--no-ff` commit
-8. Deletes processed CSV files from main repo's import/incoming
-9. Cleans up worktree
+4. Extracts accounts from matched rules and updates year journal with declarations
+5. Validates all transactions have matching rules (dry run)
+6. Imports transactions to year journal
+7. Reconciles closing balance (auto-detected from CSV metadata/data or manual override)
+8. Merges to main with `--no-ff` commit
+9. Deletes processed CSV files from main repo's import/incoming
+10. Cleans up worktree
 
 **Output:** Returns step-by-step results with success/failure for each phase
 

package/dist/index.js

@@ -24191,12 +24191,6 @@ function buildErrorResult4(params) {
     ...params
   });
 }
-function buildSuccessResult4(params) {
-  return JSON.stringify({
-    success: true,
-    ...params
-  });
-}
 function validateWorktree(directory, worktreeChecker) {
   if (!worktreeChecker(directory)) {
     return buildErrorResult4({
@@ -24235,7 +24229,7 @@ function findCsvToReconcile(doneDir, options) {
   const relativePath = path11.relative(path11.dirname(path11.dirname(doneDir)), csvFile);
   return { csvFile, relativePath };
 }
-function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
+function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
   let metadata;
   try {
     const content = fs11.readFileSync(csvFile, "utf-8");
@@ -24254,17 +24248,41 @@ function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
     }
   }
   if (!closingBalance) {
+    const csvAnalysis = tryExtractClosingBalanceFromCSV(csvFile, rulesDir);
+    if (csvAnalysis && csvAnalysis.confidence === "high") {
+      closingBalance = csvAnalysis.balance;
+      return { closingBalance, metadata, fromCSVAnalysis: true };
+    }
+  }
+  if (!closingBalance) {
+    const retryCmd = buildRetryCommand(options, "CHF 2324.79", options.account);
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
-        error: "No closing balance found in CSV metadata",
-        hint: "Provide closingBalance parameter manually",
+        error: "No closing balance found in CSV metadata or data",
+        hint: `Provide closingBalance parameter manually. Example retry: ${retryCmd}`,
         metadata
       })
     };
   }
   return { closingBalance, metadata };
 }
+function buildRetryCommand(options, closingBalance, account) {
+  const parts = ["import-pipeline"];
+  if (options.provider) {
+    parts.push(`--provider ${options.provider}`);
+  }
+  if (options.currency) {
+    parts.push(`--currency ${options.currency}`);
+  }
+  if (closingBalance) {
+    parts.push(`--closingBalance "${closingBalance}"`);
+  }
+  if (account) {
+    parts.push(`--account "${account}"`);
+  }
+  return parts.join(" ");
+}
 function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata) {
   let account = options.account;
   if (!account) {
@@ -24277,7 +24295,7 @@ function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata)
   if (!account) {
     const rulesMapping = loadRulesMapping(rulesDir);
     const rulesFile = findRulesForCsv(csvFile, rulesMapping);
-    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or use --account parameter` : `Create a rules file in ${rulesDir} with 'account1' directive or use --account parameter`;
+    const rulesHint = rulesFile ? `Add 'account1 assets:bank:...' to ${rulesFile} or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}` : `Create a rules file in ${rulesDir} with 'account1' directive or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}`;
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
@@ -24289,6 +24307,70 @@ function determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata)
   }
   return { account };
 }
+function tryExtractClosingBalanceFromCSV(csvFile, rulesDir) {
+  try {
+    const rulesMapping = loadRulesMapping(rulesDir);
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (!rulesFile) {
+      return null;
+    }
+    const rulesContent = fs11.readFileSync(rulesFile, "utf-8");
+    const rulesConfig = parseRulesFile(rulesContent);
+    const csvRows = parseCsvFile(csvFile, rulesConfig);
+    if (csvRows.length === 0) {
+      return null;
+    }
+    const balanceFieldNames = [
+      "balance",
+      "Balance",
+      "BALANCE",
+      "closing_balance",
+      "Closing Balance",
+      "account_balance",
+      "Account Balance",
+      "saldo",
+      "Saldo",
+      "SALDO"
+    ];
+    const lastRow = csvRows[csvRows.length - 1];
+    let balanceField;
+    let balanceValue;
+    for (const fieldName of balanceFieldNames) {
+      if (lastRow[fieldName] !== undefined && lastRow[fieldName].trim() !== "") {
+        balanceField = fieldName;
+        balanceValue = lastRow[fieldName];
+        break;
+      }
+    }
+    if (balanceValue && balanceField) {
+      const numericValue = parseAmountValue(balanceValue);
+      let currency = "";
+      const balanceCurrencyMatch = balanceValue.match(/[A-Z]{3}/);
+      if (balanceCurrencyMatch) {
+        currency = balanceCurrencyMatch[0];
+      }
+      if (!currency) {
+        const amountField = rulesConfig.amountFields.single || rulesConfig.amountFields.credit || rulesConfig.amountFields.debit;
+        if (amountField) {
+          const amountStr = lastRow[amountField] || "";
+          const currencyMatch = amountStr.match(/[A-Z]{3}/);
+          if (currencyMatch) {
+            currency = currencyMatch[0];
+          }
+        }
+      }
+      const balanceStr = currency ? `${currency} ${numericValue.toFixed(2)}` : numericValue.toFixed(2);
+      return {
+        balance: balanceStr,
+        confidence: "high",
+        method: `Extracted from ${balanceField} field in last CSV row`
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function reconcileStatement(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor, worktreeChecker = isInWorktree) {
   const restrictionError = checkAccountantAgent(agent, "reconcile statement");
   if (restrictionError) {
@@ -24311,11 +24393,11 @@ async function reconcileStatement(directory, agent, options, configLoader = load
     return csvResult.error;
   }
   const { csvFile, relativePath: relativeCsvPath } = csvResult;
-  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath);
+  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir);
   if ("error" in balanceResult) {
     return balanceResult.error;
   }
-  const { closingBalance, metadata } = balanceResult;
+  const { closingBalance, metadata, fromCSVAnalysis } = balanceResult;
   const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
   if ("error" in accountResult) {
     return accountResult.error;
@@ -24357,14 +24439,19 @@ async function reconcileStatement(directory, agent, options, configLoader = load
     });
   }
   if (doBalancesMatch) {
-    return buildSuccessResult4({
+    const result = {
+      success: true,
       csvFile: relativeCsvPath,
       account,
       lastTransactionDate,
       expectedBalance: closingBalance,
       actualBalance,
       metadata
-    });
+    };
+    if (fromCSVAnalysis) {
+      result.note = `Closing balance auto-detected from CSV data (no metadata available). Account: ${account}`;
+    }
+    return JSON.stringify(result);
   }
   let difference;
   try {
@@ -24429,8 +24516,125 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path12 from "path";
+
+// src/utils/accountDeclarations.ts
+import * as fs12 from "fs";
+function extractAccountsFromRulesFile(rulesPath) {
+  const accounts = new Set;
+  if (!fs12.existsSync(rulesPath)) {
+    return accounts;
+  }
+  const content = fs12.readFileSync(rulesPath, "utf-8");
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed.startsWith(";") || trimmed === "") {
+      continue;
+    }
+    const account1Match = trimmed.match(/^account1\s+(.+?)(?:\s+|$)/);
+    if (account1Match) {
+      accounts.add(account1Match[1].trim());
+      continue;
+    }
+    const account2Match = trimmed.match(/account2\s+(.+?)(?:\s+|$)/);
+    if (account2Match) {
+      accounts.add(account2Match[1].trim());
+      continue;
+    }
+  }
+  return accounts;
+}
+function getAllAccountsFromRules(rulesPaths) {
+  const allAccounts = new Set;
+  for (const rulesPath of rulesPaths) {
+    const accounts = extractAccountsFromRulesFile(rulesPath);
+    for (const account of accounts) {
+      allAccounts.add(account);
+    }
+  }
+  return allAccounts;
+}
+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");
+  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);
+      }
+      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);
+      }
+      continue;
+    }
+    if (trimmed === "") {
+      if (inAccountSection && !accountSectionEnded) {
+        accountLines.push(line);
+      } else {
+        otherLines.push(line);
+      }
+      continue;
+    }
+    if (inAccountSection) {
+      accountSectionEnded = true;
+    }
+    otherLines.push(line);
+  }
+  const missingAccounts = new Set;
+  for (const account of accounts) {
+    if (!existingAccounts.has(account)) {
+      missingAccounts.add(account);
+    }
+  }
+  if (missingAccounts.size === 0) {
+    return { added: [], updated: false };
+  }
+  const allAccounts = new Set([...existingAccounts, ...missingAccounts]);
+  const sortedAccounts = sortAccountDeclarations(allAccounts);
+  const newAccountLines = sortedAccounts.map((account) => `account ${account}`);
+  const newContent = [];
+  newContent.push(...commentLines);
+  if (newAccountLines.length > 0) {
+    newContent.push("");
+    newContent.push(...newAccountLines);
+    newContent.push("");
+  }
+  newContent.push(...otherLines);
+  fs12.writeFileSync(yearJournalPath, newContent.join(`
+`));
+  return {
+    added: Array.from(missingAccounts).sort(),
+    updated: true
+  };
+}
+
+// src/tools/import-pipeline.ts
 class NoTransactionsError extends Error {
   constructor() {
     super("No transactions to import");
@@ -24444,7 +24648,7 @@ function buildStepResult(success2, message, details) {
   }
   return result;
 }
-function buildSuccessResult5(result, summary) {
+function buildSuccessResult4(result, summary) {
   result.success = true;
   result.summary = summary;
   return JSON.stringify(result);
@@ -24470,7 +24674,7 @@ function buildCommitMessage(provider, currency, fromDate, untilDate, transaction
 }
 function cleanupIncomingFiles(worktree, context) {
   const incomingDir = path12.join(worktree.mainRepoPath, "import/incoming");
-  if (!fs12.existsSync(incomingDir)) {
+  if (!fs13.existsSync(incomingDir)) {
     return;
   }
   const importStep = context.result.steps.import;
@@ -24487,9 +24691,9 @@ function cleanupIncomingFiles(worktree, context) {
       continue;
     const filename = path12.basename(fileResult.csv);
     const filePath = path12.join(incomingDir, filename);
-    if (fs12.existsSync(filePath)) {
+    if (fs13.existsSync(filePath)) {
       try {
-        fs12.unlinkSync(filePath);
+        fs13.unlinkSync(filePath);
         deletedCount++;
       } catch (error45) {
         console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
@@ -24520,6 +24724,86 @@ async function executeClassifyStep(context, worktree) {
   };
   context.result.steps.classify = buildStepResult(success2, message, details);
 }
+async function executeAccountDeclarationsStep(context, worktree) {
+  const config2 = context.configLoader(worktree.path);
+  const pendingDir = path12.join(worktree.path, config2.paths.pending);
+  const rulesDir = path12.join(worktree.path, config2.paths.rules);
+  const csvFiles = findCsvFiles(pendingDir, context.options.provider, context.options.currency);
+  if (csvFiles.length === 0) {
+    context.result.steps.accountDeclarations = buildStepResult(true, "No CSV files to process", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: []
+    });
+    return;
+  }
+  const rulesMapping = loadRulesMapping(rulesDir);
+  const matchedRulesFiles = new Set;
+  for (const csvFile of csvFiles) {
+    const rulesFile = findRulesForCsv(csvFile, rulesMapping);
+    if (rulesFile) {
+      matchedRulesFiles.add(rulesFile);
+    }
+  }
+  if (matchedRulesFiles.size === 0) {
+    context.result.steps.accountDeclarations = buildStepResult(true, "No matching rules files found", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: []
+    });
+    return;
+  }
+  const allAccounts = getAllAccountsFromRules(Array.from(matchedRulesFiles));
+  if (allAccounts.size === 0) {
+    context.result.steps.accountDeclarations = buildStepResult(true, "No accounts found in rules files", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+    });
+    return;
+  }
+  let transactionYear;
+  for (const rulesFile of matchedRulesFiles) {
+    try {
+      const result2 = await context.hledgerExecutor(["print", "-f", rulesFile]);
+      if (result2.exitCode === 0) {
+        const years = extractTransactionYears(result2.stdout);
+        if (years.size > 0) {
+          transactionYear = Array.from(years)[0];
+          break;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (!transactionYear) {
+    context.result.steps.accountDeclarations = buildStepResult(false, "Could not determine transaction year from CSV files", {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+    });
+    return;
+  }
+  let yearJournalPath;
+  try {
+    yearJournalPath = ensureYearJournalExists(worktree.path, transactionYear);
+  } catch (error45) {
+    context.result.steps.accountDeclarations = buildStepResult(false, `Failed to create year journal: ${error45 instanceof Error ? error45.message : String(error45)}`, {
+      accountsAdded: [],
+      journalUpdated: "",
+      rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+    });
+    return;
+  }
+  const result = ensureAccountDeclarations(yearJournalPath, allAccounts);
+  const message = result.added.length > 0 ? `Added ${result.added.length} account declaration(s) to ${path12.relative(worktree.path, yearJournalPath)}` : "All required accounts already declared";
+  context.result.steps.accountDeclarations = buildStepResult(true, message, {
+    accountsAdded: result.added,
+    journalUpdated: path12.relative(worktree.path, yearJournalPath),
+    rulesScanned: Array.from(matchedRulesFiles).map((f) => path12.relative(worktree.path, f))
+  });
+}
 async function executeDryRunStep(context, worktree) {
   const inWorktree = () => true;
   const dryRunResult = await importStatements(worktree.path, context.agent, {
@@ -24612,7 +24896,7 @@ function handleNoTransactions(result) {
   result.steps.import = buildStepResult(true, "No transactions to import");
   result.steps.reconcile = buildStepResult(true, "Reconciliation skipped (no transactions)");
   result.steps.merge = buildStepResult(true, "Merge skipped (no changes)");
-  return buildSuccessResult5(result, "No transactions found to import");
+  return buildSuccessResult4(result, "No transactions found to import");
 }
 async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "import pipeline");
@@ -24656,6 +24940,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
       }
       try {
         await executeClassifyStep(context, worktree);
+        await executeAccountDeclarationsStep(context, worktree);
         await executeDryRunStep(context, worktree);
         await executeImportStep(context, worktree);
         await executeReconcileStep(context, worktree);
@@ -24693,7 +24978,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
           };
         }
         const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
-        return buildSuccessResult5(result, `Successfully imported ${transactionCount} transaction(s)`);
+        return buildSuccessResult4(result, `Successfully imported ${transactionCount} transaction(s)`);
       } catch (error45) {
         result.steps.cleanup = buildStepResult(true, "Worktree cleaned up after failure (CSV files preserved for retry)", {
           cleanedAfterFailure: true,
@@ -24758,7 +25043,7 @@ This tool orchestrates the full import workflow in an isolated git worktree:
   }
 });
 // src/tools/init-directories.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -24766,8 +25051,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs13.existsSync(importBase)) {
-      fs13.mkdirSync(importBase, { recursive: true });
+    if (!fs14.existsSync(importBase)) {
+      fs14.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -24778,19 +25063,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs13.existsSync(fullPath)) {
-        fs13.mkdirSync(fullPath, { recursive: true });
+      if (!fs14.existsSync(fullPath)) {
+        fs14.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs13.existsSync(gitkeepPath)) {
-        fs13.writeFileSync(gitkeepPath, "");
+      if (!fs14.existsSync(gitkeepPath)) {
+        fs14.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs13.existsSync(gitignorePath)) {
+    if (!fs14.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -24808,7 +25093,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs13.writeFileSync(gitignorePath, gitignoreContent);
+      fs14.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];

package/package.json

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