mercury_banking 0.5.37 → 0.6.0

data/lib/mercury_banking/cli/reconciliation.rb

@@ -1,406 +1,319 @@
+# frozen_string_literal: true
+
 module MercuryBanking
   module CLI
     # Module for reconciliation-related commands
     module Reconciliation
-      # Add reconciliation-related commands to the CLI class
-      def self.included(base)
-        base.class_eval do
-          desc 'reconcile ACCOUNT_ID_OR_NUMBER TRANSACTION_ID', 'Mark a transaction as reconciled'
-          def reconcile(account_identifier, transaction_id)
-            with_api_client do |client|
-              # Determine if we're dealing with an account ID or account number
-              account_id = nil
-              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
-                begin
-                  account = client.find_account_by_number(account_identifier)
-                  account_id = account["id"]
-                rescue => e
-                  # If not found by number, assume it's an ID
-                  account_id = account_identifier
-                  account = client.get_account(account_id)
-                end
-              else
-                account_id = account_identifier
-                account = client.get_account(account_id)
-              end
-              
-              # Get the transaction to verify it exists
-              transaction = client.transaction(account_id, transaction_id)
-              
-              # Mark the transaction as reconciled
-              reconciliation = MercuryBanking::Reconciliation.new
-              result = reconciliation.mark_reconciled(account_id, transaction_id)
-              
-              if options[:json]
-                puts JSON.pretty_generate({
-                  'account_id' => account_id,
-                  'transaction_id' => transaction_id,
-                  'reconciled' => true,
-                  'already_reconciled' => !result
-                })
-              else
-                if result
-                  puts "Transaction #{transaction_id} marked as reconciled."
-                else
-                  puts "Transaction #{transaction_id} was already reconciled."
-                end
-              end
+      # Helper module for account operations
+      module AccountHelpers
+        # Resolve account identifier to account ID
+        def resolve_account_id(client, account_identifier)
+          if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
+            begin
+              account = client.find_account_by_number(account_identifier)
+              account["id"]
+            rescue StandardError
+              # If not found by number, assume it's an ID
+              account_id = account_identifier
+              client.get_account(account_id) # Just verify the account exists
+              account_id
             end
+          else
+            account_id = account_identifier
+            client.get_account(account_id) # Just verify the account exists
+            account_id
           end
-          
-          desc 'unreconcile ACCOUNT_ID_OR_NUMBER TRANSACTION_ID', 'Mark a transaction as unreconciled'
-          def unreconcile(account_identifier, transaction_id)
-            with_api_client do |client|
-              # Determine if we're dealing with an account ID or account number
-              account_id = nil
-              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
-                begin
-                  account = client.find_account_by_number(account_identifier)
-                  account_id = account["id"]
-                rescue => e
-                  # If not found by number, assume it's an ID
-                  account_id = account_identifier
-                  account = client.get_account(account_id)
-                end
-              else
-                account_id = account_identifier
-                account = client.get_account(account_id)
-              end
-              
-              # Get the transaction to verify it exists
-              transaction = client.transaction(account_id, transaction_id)
-              
-              # Mark the transaction as unreconciled
-              reconciliation = MercuryBanking::Reconciliation.new
-              result = reconciliation.mark_unreconciled(account_id, transaction_id)
-              
-              if options[:json]
-                puts JSON.pretty_generate({
-                  'account_id' => account_id,
-                  'transaction_id' => transaction_id,
-                  'reconciled' => false,
-                  'was_reconciled' => result
-                })
-              else
-                if result
-                  puts "Transaction #{transaction_id} marked as unreconciled."
-                else
-                  puts "Transaction #{transaction_id} was not reconciled."
-                end
-              end
+        end
+      end
+
+      # Helper module for transaction operations
+      module TransactionHelpers
+        # Filter transactions by date
+        def filter_transactions_by_date(transactions, _start_date, end_date)
+          filtered_transactions = transactions
+
+          # Filter by end date if specified
+          if end_date
+            end_date_obj = Date.parse(end_date)
+            filtered_transactions = filtered_transactions.select do |t|
+              transaction_date = Date.parse(t["postedAt"] || t["createdAt"])
+              transaction_date <= end_date_obj
             end
           end
-          
-          desc 'reconciliation_status ACCOUNT_ID_OR_NUMBER', 'Show reconciliation status for an account'
-          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
-          method_option :end, type: :string, desc: 'End date for transactions (YYYY-MM-DD)'
-          method_option :format, type: :string, default: 'table', enum: ['table', 'json'], desc: 'Output format (table or json)'
-          def reconciliation_status(account_identifier)
-            with_api_client do |client|
-              # Determine if we're dealing with an account ID or account number
-              account_id = nil
-              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
-                begin
-                  account = client.find_account_by_number(account_identifier)
-                  account_id = account["id"]
-                rescue => e
-                  # If not found by number, assume it's an ID
-                  account_id = account_identifier
-                  account = client.get_account(account_id)
-                end
-              else
-                account_id = account_identifier
-                account = client.get_account(account_id)
-              end
-              
-              # Get transactions for the account
-              start_date = options[:start]
-              end_date = options[:end]
-              
-              transactions = client.get_transactions(account_id, start_date)
-              
-              # Filter by end date if specified
-              if end_date
-                end_date_obj = Date.parse(end_date)
-                transactions = transactions.select do |t|
-                  transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
-                  transaction_date <= end_date_obj
-                end
-              end
-              
-              # Get reconciliation status
-              reconciliation = MercuryBanking::Reconciliation.new
-              status = reconciliation.get_reconciliation_status(account_id, transactions)
-              summary = reconciliation.get_reconciliation_summary(account_id, transactions)
-              
-              if options[:json] || options[:format] == 'json'
-                puts JSON.pretty_generate({
-                  'account_id' => account_id,
-                  'account_name' => account['name'],
-                  'summary' => summary,
-                  'transactions' => status
-                })
-              else
-                # Display summary
-                puts "Reconciliation Status for #{account['name']} (#{account['accountNumber']})"
-                puts "Period: #{start_date} to #{end_date || 'present'}"
-                puts
-                puts "Summary:"
-                puts "- Total Transactions: #{summary[:total_transactions]}"
-                puts "- Reconciled: #{summary[:reconciled_count]} ($#{format("%.2f", summary[:reconciled_amount])})"
-                puts "- Unreconciled: #{summary[:unreconciled_count]} ($#{format("%.2f", summary[:unreconciled_amount])})"
-                puts
-                
-                # Display transactions
-                rows = status.map do |t|
-                  date = t[:date] ? Time.parse(t[:date]).strftime("%Y-%m-%d") : "Unknown"
-                  description = t[:description].length > 30 ? "#{t[:description][0..27]}..." : t[:description]
-                  amount = format("$%.2f", t[:amount])
-                  reconciled = t[:reconciled] ? "✓" : " "
-                  reconciled_at = t[:reconciled_at] || ""
-                  
-                  [t[:transaction_id], date, description, amount, reconciled, reconciled_at]
-                end
-                
-                table = ::Terminal::Table.new(
-                  headings: ['Transaction ID', 'Date', 'Description', 'Amount', 'Reconciled', 'Reconciled At'],
-                  rows: rows
-                )
-                
-                puts table
-              end
+
+          filtered_transactions
+        end
+      end
+
+      # Helper module for display operations
+      module DisplayHelpers
+        # Display reconciliation table
+        def display_reconciliation_table(account, status, summary, start_date, end_date)
+          puts "Reconciliation Status for #{account['name']} (#{account['accountNumber']})"
+          puts "Period: #{start_date} to #{end_date || 'present'}"
+          puts
+          puts "Summary:"
+          puts "- Total Transactions: #{summary[:total_transactions]}"
+          puts "- Reconciled: #{summary[:reconciled_count]} ($#{format('%.2f', summary[:reconciled_amount])})"
+          puts "- Unreconciled: #{summary[:unreconciled_count]} ($#{format('%.2f', summary[:unreconciled_amount])})"
+          puts
+
+          # Display transactions
+          rows = status.map do |t|
+            date = t[:date] ? Time.parse(t[:date]).strftime("%Y-%m-%d") : "Unknown"
+            description = t[:description].length > 30 ? "#{t[:description][0..27]}..." : t[:description]
+            amount = format("$%.2f", t[:amount])
+            reconciled = t[:reconciled] ? "✓" : " "
+            reconciled_at = t[:reconciled_at] || ""
+
+            [t[:transaction_id], date, description, amount, reconciled, reconciled_at]
+          end
+
+          table = ::Terminal::Table.new(
+            headings: ['Transaction ID', 'Date', 'Description', 'Amount', 'Reconciled', 'Reconciled At'],
+            rows: rows
+          )
+
+          puts table
+        end
+
+        # Display debug information
+        def display_debug_info(account_id, account, reconcile_date, transactions, unreconciled)
+          puts "Debug information:"
+          puts "- Account ID: #{account_id}"
+          puts "- Account Name: #{account['name']}"
+          puts "- Reconcile Date: #{reconcile_date}"
+          puts "- Total Transactions: #{transactions.length}"
+          puts "- Unreconciled Transactions: #{unreconciled.length}"
+        end
+
+        # Display reconciliation information
+        def display_reconciliation_info(account, reconcile_date, start_date, unreconciled, options)
+          if options[:json]
+            result = {
+              'account_id' => account['id'],
+              'account_name' => account['name'],
+              'reconcile_date' => reconcile_date.to_s,
+              'total_transactions' => unreconciled.length,
+              'transactions_to_reconcile' => unreconciled.map { |t| t[:transaction_id] },
+              'dry_run' => options[:dry_run]
+            }
+            puts JSON.pretty_generate(result)
+          else
+            puts "Reconciling transactions for #{account['name']} (#{account['accountNumber']})"
+            puts "Date range: #{start_date} to #{reconcile_date}"
+            puts "Found #{unreconciled.length} unreconciled transactions"
+            puts
+          end
+        end
+      end
+
+      # Helper module for reconciliation operations
+      module ReconciliationHelpers
+        # Reconcile transactions
+        def reconcile_transactions(account_id, unreconciled, reconciliation, options)
+          reconciled_count = 0
+          unreconciled.each do |transaction|
+            transaction_id = transaction[:transaction_id]
+            if reconciliation.mark_reconciled(account_id, transaction_id)
+              reconciled_count += 1
+              puts "Reconciled transaction #{transaction_id}" unless options[:json]
             end
           end
-          
-          desc 'reconcile_all ACCOUNT_ID_OR_NUMBER', 'Mark all transactions as reconciled up to a specified date'
-          method_option :date, type: :string, desc: 'Date up to which to reconcile transactions (YYYY-MM-DD). Defaults to current date.'
-          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
-          method_option :dry_run, type: :boolean, default: false, desc: 'Show what would be reconciled without making changes'
-          method_option :json, type: :boolean, default: false, desc: 'Output in JSON format'
-          method_option :debug, type: :boolean, default: false, desc: 'Show debug information'
-          def reconcile_all(account_identifier)
-            with_api_client do |client|
-              # Determine if we're dealing with an account ID or account number
-              account_id = nil
-              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
-                begin
-                  account = client.find_account_by_number(account_identifier)
-                  account_id = account["id"]
-                rescue => e
-                  # If not found by number, assume it's an ID
-                  account_id = account_identifier
-                  account = client.get_account(account_id)
-                end
-              else
-                account_id = account_identifier
-                account = client.get_account(account_id)
-              end
-              
-              # Get transactions for the account
-              start_date = options[:start]
-              puts "Fetching transactions for account #{account['name']} (#{account['accountNumber']}) since #{start_date}..." if options[:debug]
-              transactions = client.get_transactions(account_id, start_date)
-              puts "Found #{transactions.size} total transactions" if options[:debug]
-              
-              # Filter by date if specified
-              cutoff_date = options[:date] ? Date.parse(options[:date]) : Date.today
-              puts "Using cutoff date: #{cutoff_date}" if options[:debug]
-              
-              # Filter transactions that are on or before the cutoff date
-              transactions_to_reconcile = transactions.select do |t|
-                transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
-                transaction_date <= cutoff_date
-              end
-              puts "Found #{transactions_to_reconcile.size} transactions on or before cutoff date" if options[:debug]
-              
-              if transactions_to_reconcile.empty?
+
+          return if options[:json]
+
+          puts
+          puts "Reconciled #{reconciled_count} transactions"
+        end
+      end
+
+      # Module for reconcile command
+      module ReconcileCommand
+        def self.included(base)
+          base.class_eval do
+            desc 'reconcile ACCOUNT_ID_OR_NUMBER TRANSACTION_ID', 'Mark a transaction as reconciled'
+            def reconcile(account_identifier, transaction_id)
+              with_api_client do |client|
+                # Resolve account identifier to account ID
+                account_id = resolve_account_id(client, account_identifier)
+
+                # Verify the transaction exists but don't need to store it
+                client.transaction(account_id, transaction_id)
+
+                # Mark the transaction as reconciled
+                reconciliation = MercuryBanking::Reconciliation.new
+                result = reconciliation.mark_reconciled(account_id, transaction_id)
+
                 if options[:json]
                   puts JSON.pretty_generate({
-                    'account_id' => account_id,
-                    'account_name' => account['name'],
-                    'transactions_reconciled' => 0,
-                    'message' => "No transactions found to reconcile."
-                  })
+                                              'account_id' => account_id,
+                                              'transaction_id' => transaction_id,
+                                              'reconciled' => true,
+                                              'already_reconciled' => !result
+                                            })
+                elsif result
+                  puts "Transaction #{transaction_id} marked as reconciled."
                 else
-                  puts "No transactions found to reconcile for #{account['name']} (#{account['accountNumber']})."
+                  puts "Transaction #{transaction_id} was already reconciled."
                 end
-                return
               end
-              
-              # Get already reconciled transactions
-              reconciliation = MercuryBanking::Reconciliation.new
-              reconciled_ids = reconciliation.get_reconciled_transactions(account_id)
-              puts "Found #{reconciled_ids.size} already reconciled transactions" if options[:debug]
-              
-              # Filter out already reconciled transactions
-              transactions_to_reconcile = transactions_to_reconcile.reject { |t| reconciled_ids.include?(t["id"]) }
-              puts "Found #{transactions_to_reconcile.size} transactions to reconcile" if options[:debug]
-              
-              if transactions_to_reconcile.empty?
+            end
+          end
+        end
+      end
+
+      # Module for unreconcile command
+      module UnreconcileCommand
+        def self.included(base)
+          base.class_eval do
+            desc 'unreconcile ACCOUNT_ID_OR_NUMBER TRANSACTION_ID', 'Mark a transaction as unreconciled'
+            def unreconcile(account_identifier, transaction_id)
+              with_api_client do |client|
+                # Resolve account identifier to account ID
+                account_id = resolve_account_id(client, account_identifier)
+
+                # Verify the transaction exists but don't need to store it
+                client.transaction(account_id, transaction_id)
+
+                # Mark the transaction as unreconciled
+                reconciliation = MercuryBanking::Reconciliation.new
+                result = reconciliation.mark_unreconciled(account_id, transaction_id)
+
                 if options[:json]
                   puts JSON.pretty_generate({
-                    'account_id' => account_id,
-                    'account_name' => account['name'],
-                    'transactions_reconciled' => 0,
-                    'message' => "All transactions are already reconciled up to #{cutoff_date}."
-                  })
+                                              'account_id' => account_id,
+                                              'transaction_id' => transaction_id,
+                                              'reconciled' => false,
+                                              'was_reconciled' => result
+                                            })
+                elsif result
+                  puts "Transaction #{transaction_id} marked as unreconciled."
                 else
-                  puts "All transactions are already reconciled up to #{cutoff_date} for #{account['name']} (#{account['accountNumber']})."
-                end
-                return
-              end
-              
-              # Display what will be reconciled
-              if options[:json]
-                transactions_data = transactions_to_reconcile.map do |t|
-                  {
-                    'id' => t["id"],
-                    'date' => t["postedAt"] || t["createdAt"],
-                    'description' => t["bankDescription"] || t["externalMemo"] || "Unknown transaction",
-                    'amount' => t["amount"]
-                  }
-                end
-                
-                puts JSON.pretty_generate({
-                  'account_id' => account_id,
-                  'account_name' => account['name'],
-                  'cutoff_date' => cutoff_date.to_s,
-                  'transactions_to_reconcile' => transactions_data,
-                  'dry_run' => options[:dry_run]
-                })
-              else
-                puts "Reconciliation for #{account['name']} (#{account['accountNumber']})"
-                puts "Transactions to reconcile up to #{cutoff_date}:"
-                puts
-                
-                total_amount = 0
-                
-                rows = transactions_to_reconcile.map do |t|
-                  date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : Time.parse(t["createdAt"]).strftime("%Y-%m-%d")
-                  description = t["bankDescription"] || t["externalMemo"] || "Unknown transaction"
-                  description = description.length > 30 ? "#{description[0..27]}..." : description
-                  amount = t["amount"]
-                  total_amount += amount
-                  
-                  [t["id"], date, description, format("$%.2f", amount)]
+                  puts "Transaction #{transaction_id} was not reconciled."
                 end
-                
-                table = ::Terminal::Table.new(
-                  headings: ['Transaction ID', 'Date', 'Description', 'Amount'],
-                  rows: rows
-                )
-                
-                puts table
-                puts
-                puts "Total transactions: #{transactions_to_reconcile.size}"
-                puts "Total amount: #{format("$%.2f", total_amount)}"
-                puts
-                puts "This is a #{options[:dry_run] ? 'DRY RUN' : 'LIVE RUN'}"
               end
-              
-              # Mark transactions as reconciled if not a dry run
-              unless options[:dry_run]
-                reconciled_count = 0
-                
-                transactions_to_reconcile.each do |t|
-                  result = reconciliation.mark_reconciled(account_id, t["id"])
-                  reconciled_count += 1 if result
-                end
-                
-                if options[:json]
+            end
+          end
+        end
+      end
+
+      # Module for reconciliation_status command
+      module ReconciliationStatusCommand
+        def self.included(base)
+          base.class_eval do
+            desc 'reconciliation_status ACCOUNT_ID_OR_NUMBER', 'Show reconciliation status for an account'
+            method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
+            method_option :end, type: :string, desc: 'End date for transactions (YYYY-MM-DD)'
+            method_option :format, type: :string, default: 'table', enum: %w[table json],
+                                   desc: 'Output format (table or json)'
+            def reconciliation_status(account_identifier)
+              with_api_client do |client|
+                # Resolve account identifier to account ID
+                account_id = resolve_account_id(client, account_identifier)
+                account = client.get_account(account_id)
+
+                # Get transactions for the account
+                start_date = options[:start]
+                end_date = options[:end]
+
+                transactions = client.get_transactions(account_id, start_date)
+
+                # Filter transactions by date
+                transactions = filter_transactions_by_date(transactions, start_date, end_date)
+
+                # Get reconciliation status
+                reconciliation = MercuryBanking::Reconciliation.new
+                status = reconciliation.get_reconciliation_status(account_id, transactions)
+                summary = reconciliation.get_reconciliation_summary(account_id, transactions)
+
+                if options[:json] || options[:format] == 'json'
                   puts JSON.pretty_generate({
-                    'account_id' => account_id,
-                    'account_name' => account['name'],
-                    'transactions_reconciled' => reconciled_count,
-                    'message' => "Successfully reconciled #{reconciled_count} transactions."
-                  })
+                                              'account_id' => account_id,
+                                              'account_name' => account['name'],
+                                              'summary' => summary,
+                                              'transactions' => status
+                                            })
                 else
-                  puts "Successfully reconciled #{reconciled_count} transactions."
-                end
-              else
-                if !options[:json]
-                  puts "Dry run completed. No transactions were reconciled."
-                  puts "Run without --dry-run to reconcile these transactions."
+                  display_reconciliation_table(account, status, summary, start_date, end_date)
                 end
               end
             end
           end
-          
-          desc 'export_reconciled ACCOUNT_ID_OR_NUMBER', 'Export reconciled transactions to a ledger file'
-          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
-          method_option :end, type: :string, desc: 'End date for transactions (YYYY-MM-DD)'
-          method_option :format, type: :string, default: 'ledger', enum: ['ledger', 'beancount', 'hledger', 'csv'], desc: 'Export format'
-          method_option :output, type: :string, desc: 'Output file path (defaults to reconciled_transactions.<format>)'
-          method_option :all, type: :boolean, default: false, desc: 'Export all transactions with reconciliation status'
-          def export_reconciled(account_identifier)
-            with_api_client do |client|
-              # Determine if we're dealing with an account ID or account number
-              account_id = nil
-              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
-                begin
-                  account = client.find_account_by_number(account_identifier)
-                  account_id = account["id"]
-                rescue => e
-                  # If not found by number, assume it's an ID
-                  account_id = account_identifier
-                  account = client.get_account(account_id)
-                end
-              else
-                account_id = account_identifier
+        end
+      end
+
+      # Module for reconcile_all command
+      module ReconcileAllCommand
+        def self.included(base)
+          base.class_eval do
+            desc 'reconcile_all ACCOUNT_ID_OR_NUMBER', 'Mark all transactions as reconciled up to a specified date'
+            method_option :date, type: :string,
+                                 desc: 'Date up to which to reconcile transactions (YYYY-MM-DD). Defaults to current date.'
+            method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
+            method_option :dry_run, type: :boolean, default: false,
+                                    desc: 'Show what would be reconciled without making changes'
+            method_option :json, type: :boolean, default: false, desc: 'Output in JSON format'
+            method_option :debug, type: :boolean, default: false, desc: 'Show debug information'
+            def reconcile_all(account_identifier)
+              with_api_client do |client|
+                # Resolve account identifier to account ID
+                account_id = resolve_account_id(client, account_identifier)
                 account = client.get_account(account_id)
-              end
-              
-              # Get transactions for the account
-              start_date = options[:start]
-              end_date = options[:end]
-              format = options[:format]
-              export_all = options[:all]
-              
-              transactions = client.get_transactions(account_id, start_date)
-              
-              # Filter by end date if specified
-              if end_date
-                end_date_obj = Date.parse(end_date)
-                transactions = transactions.select do |t|
-                  transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
-                  transaction_date <= end_date_obj
+
+                # Get the date up to which to reconcile transactions
+                reconcile_date = options[:date] ? Date.parse(options[:date]) : Date.today
+                start_date = options[:start]
+
+                # Get transactions for the account
+                transactions = client.get_transactions(account_id, start_date)
+
+                # Filter transactions up to the reconcile date
+                transactions_to_reconcile = transactions.select do |t|
+                  transaction_date = Date.parse(t["postedAt"] || t["createdAt"])
+                  transaction_date <= reconcile_date
                 end
+
+                # Get current reconciliation status
+                reconciliation = MercuryBanking::Reconciliation.new
+                status = reconciliation.get_reconciliation_status(account_id, transactions_to_reconcile)
+
+                # Filter for unreconciled transactions
+                unreconciled = status.reject { |t| t[:reconciled] }
+
+                # Display debug information if requested
+                display_debug_info(account_id, account, reconcile_date, transactions_to_reconcile, unreconciled) if options[:debug]
+
+                # Display reconciliation information
+                display_reconciliation_info(account, reconcile_date, start_date, unreconciled, options)
+
+                # If this is a dry run, don't actually reconcile anything
+                if options[:dry_run]
+                  puts "DRY RUN: No transactions will be reconciled"
+                  return
+                end
+
+                # Reconcile transactions
+                reconcile_transactions(account_id, unreconciled, reconciliation, options)
               end
-              
-              # Get reconciled transactions
-              reconciliation = MercuryBanking::Reconciliation.new
-              reconciled_ids = reconciliation.get_reconciled_transactions(account_id)
-              
-              # Filter transactions if not exporting all
-              unless export_all
-                transactions = transactions.select { |t| reconciled_ids.include?(t["id"]) }
-              end
-              
-              if transactions.empty?
-                puts "No #{export_all ? '' : 'reconciled '}transactions found to export."
-                return
-              end
-              
-              # Determine output file path
-              output_file = options[:output] || "reconciled_transactions.#{format}"
-              
-              # Export transactions in the specified format
-              case format
-              when 'ledger'
-                export_to_ledger(transactions, output_file, reconciled_ids, false)
-              when 'beancount'
-                export_to_beancount(transactions, output_file, reconciled_ids, false)
-              when 'hledger'
-                export_to_hledger(transactions, output_file, reconciled_ids)
-              when 'csv'
-                export_to_csv(transactions, output_file, reconciled_ids)
-              end
-              
-              puts "Exported #{transactions.count} transaction(s) to #{output_file} in #{format} format."
             end
           end
         end
       end
+
+      # Add reconciliation-related commands to the CLI class
+      def self.included(base)
+        base.class_eval do
+          include MercuryBanking::CLI::Reconciliation::AccountHelpers
+          include MercuryBanking::CLI::Reconciliation::TransactionHelpers
+          include MercuryBanking::CLI::Reconciliation::DisplayHelpers
+          include MercuryBanking::CLI::Reconciliation::ReconciliationHelpers
+          include MercuryBanking::CLI::Reconciliation::ReconcileCommand
+          include MercuryBanking::CLI::Reconciliation::UnreconcileCommand
+          include MercuryBanking::CLI::Reconciliation::ReconciliationStatusCommand
+          include MercuryBanking::CLI::Reconciliation::ReconcileAllCommand
+        end
+      end
     end
   end
-end 
+end