@fuzzle/opencode-accountant 0.3.0-next.1 → 0.3.0

package/README.md

@@ -201,10 +201,9 @@ 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 (auto-detected from CSV metadata or data analysis)
+   - Reconciles closing balance (if available in CSV metadata)
    - Merges changes back to main branch with `--no-ff`
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
@@ -238,30 +237,13 @@ 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
 
-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`:
+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`:
 
 ```yaml
 metadata:
@@ -276,10 +258,7 @@ metadata:
     column: 1
 ```
 
-**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
+For providers without closing balance in metadata (e.g., Revolut), provide it manually via the `closingBalance` argument.
 
 ## Development
 

package/agent/accountant.md

@@ -89,10 +89,9 @@ 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 (auto-detected from CSV metadata or data, or manual override)
+   - Reconciles closing balance (if available in CSV metadata)
    - Merges changes back to main branch with `--no-ff`
    - Deletes processed CSV files from main repo's import/incoming
    - Cleans up the worktree
@@ -109,25 +108,6 @@ 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.
@@ -158,13 +138,12 @@ 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. 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
+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
 
 **Output:** Returns step-by-step results with success/failure for each phase
 

package/dist/index.js

@@ -24191,6 +24191,12 @@ function buildErrorResult4(params) {
     ...params
   });
 }
+function buildSuccessResult4(params) {
+  return JSON.stringify({
+    success: true,
+    ...params
+  });
+}
 function validateWorktree(directory, worktreeChecker) {
   if (!worktreeChecker(directory)) {
     return buildErrorResult4({
@@ -24229,7 +24235,7 @@ function findCsvToReconcile(doneDir, options) {
   const relativePath = path11.relative(path11.dirname(path11.dirname(doneDir)), csvFile);
   return { csvFile, relativePath };
 }
-function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir) {
+function determineClosingBalance(csvFile, config2, options, relativeCsvPath) {
   let metadata;
   try {
     const content = fs11.readFileSync(csvFile, "utf-8");
@@ -24248,41 +24254,17 @@ function determineClosingBalance(csvFile, config2, options, relativeCsvPath, rul
     }
   }
   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 or data",
-        hint: `Provide closingBalance parameter manually. Example retry: ${retryCmd}`,
+        error: "No closing balance found in CSV metadata",
+        hint: "Provide closingBalance parameter manually",
         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) {
@@ -24295,7 +24277,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 retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}` : `Create a rules file in ${rulesDir} with 'account1' directive or retry with: ${buildRetryCommand(options, undefined, "assets:bank:...")}`;
+    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`;
     return {
       error: buildErrorResult4({
         csvFile: relativeCsvPath,
@@ -24307,70 +24289,6 @@ 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) {
@@ -24393,11 +24311,11 @@ async function reconcileStatement(directory, agent, options, configLoader = load
     return csvResult.error;
   }
   const { csvFile, relativePath: relativeCsvPath } = csvResult;
-  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath, rulesDir);
+  const balanceResult = determineClosingBalance(csvFile, config2, options, relativeCsvPath);
   if ("error" in balanceResult) {
     return balanceResult.error;
   }
-  const { closingBalance, metadata, fromCSVAnalysis } = balanceResult;
+  const { closingBalance, metadata } = balanceResult;
   const accountResult = determineAccount(csvFile, rulesDir, options, relativeCsvPath, metadata);
   if ("error" in accountResult) {
     return accountResult.error;
@@ -24439,19 +24357,14 @@ async function reconcileStatement(directory, agent, options, configLoader = load
     });
   }
   if (doBalancesMatch) {
-    const result = {
-      success: true,
+    return buildSuccessResult4({
       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 {
@@ -24516,125 +24429,8 @@ It must be run inside an import worktree (use import-pipeline for the full workf
   }
 });
 // src/tools/import-pipeline.ts
-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
+import * as path12 from "path";
 class NoTransactionsError extends Error {
   constructor() {
     super("No transactions to import");
@@ -24648,7 +24444,7 @@ function buildStepResult(success2, message, details) {
   }
   return result;
 }
-function buildSuccessResult4(result, summary) {
+function buildSuccessResult5(result, summary) {
   result.success = true;
   result.summary = summary;
   return JSON.stringify(result);
@@ -24674,7 +24470,7 @@ function buildCommitMessage(provider, currency, fromDate, untilDate, transaction
 }
 function cleanupIncomingFiles(worktree, context) {
   const incomingDir = path12.join(worktree.mainRepoPath, "import/incoming");
-  if (!fs13.existsSync(incomingDir)) {
+  if (!fs12.existsSync(incomingDir)) {
     return;
   }
   const importStep = context.result.steps.import;
@@ -24691,9 +24487,9 @@ function cleanupIncomingFiles(worktree, context) {
       continue;
     const filename = path12.basename(fileResult.csv);
     const filePath = path12.join(incomingDir, filename);
-    if (fs13.existsSync(filePath)) {
+    if (fs12.existsSync(filePath)) {
       try {
-        fs13.unlinkSync(filePath);
+        fs12.unlinkSync(filePath);
         deletedCount++;
       } catch (error45) {
         console.error(`[ERROR] Failed to delete ${filename}: ${error45 instanceof Error ? error45.message : String(error45)}`);
@@ -24724,86 +24520,6 @@ 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, {
@@ -24896,7 +24612,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 buildSuccessResult4(result, "No transactions found to import");
+  return buildSuccessResult5(result, "No transactions found to import");
 }
 async function importPipeline(directory, agent, options, configLoader = loadImportConfig, hledgerExecutor = defaultHledgerExecutor) {
   const restrictionError = checkAccountantAgent(agent, "import pipeline");
@@ -24940,7 +24656,6 @@ 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);
@@ -24978,7 +24693,7 @@ async function importPipeline(directory, agent, options, configLoader = loadImpo
           };
         }
         const transactionCount = context.result.steps.import?.details?.summary?.totalTransactions || 0;
-        return buildSuccessResult4(result, `Successfully imported ${transactionCount} transaction(s)`);
+        return buildSuccessResult5(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,
@@ -25043,7 +24758,7 @@ This tool orchestrates the full import workflow in an isolated git worktree:
   }
 });
 // src/tools/init-directories.ts
-import * as fs14 from "fs";
+import * as fs13 from "fs";
 import * as path13 from "path";
 async function initDirectories(directory) {
   try {
@@ -25051,8 +24766,8 @@ async function initDirectories(directory) {
     const directoriesCreated = [];
     const gitkeepFiles = [];
     const importBase = path13.join(directory, "import");
-    if (!fs14.existsSync(importBase)) {
-      fs14.mkdirSync(importBase, { recursive: true });
+    if (!fs13.existsSync(importBase)) {
+      fs13.mkdirSync(importBase, { recursive: true });
       directoriesCreated.push("import");
     }
     const pathsToCreate = [
@@ -25063,19 +24778,19 @@ async function initDirectories(directory) {
     ];
     for (const { path: dirPath } of pathsToCreate) {
       const fullPath = path13.join(directory, dirPath);
-      if (!fs14.existsSync(fullPath)) {
-        fs14.mkdirSync(fullPath, { recursive: true });
+      if (!fs13.existsSync(fullPath)) {
+        fs13.mkdirSync(fullPath, { recursive: true });
         directoriesCreated.push(dirPath);
       }
       const gitkeepPath = path13.join(fullPath, ".gitkeep");
-      if (!fs14.existsSync(gitkeepPath)) {
-        fs14.writeFileSync(gitkeepPath, "");
+      if (!fs13.existsSync(gitkeepPath)) {
+        fs13.writeFileSync(gitkeepPath, "");
         gitkeepFiles.push(path13.join(dirPath, ".gitkeep"));
       }
     }
     const gitignorePath = path13.join(importBase, ".gitignore");
     let gitignoreCreated = false;
-    if (!fs14.existsSync(gitignorePath)) {
+    if (!fs13.existsSync(gitignorePath)) {
       const gitignoreContent = `# Ignore CSV/PDF files in temporary directories
 /incoming/*.csv
 /incoming/*.pdf
@@ -25093,7 +24808,7 @@ async function initDirectories(directory) {
 .DS_Store
 Thumbs.db
 `;
-      fs14.writeFileSync(gitignorePath, gitignoreContent);
+      fs13.writeFileSync(gitignorePath, gitignoreContent);
       gitignoreCreated = true;
     }
     const parts = [];

package/package.json

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