spltty 0.1.0

data/lib/spltty_cli/commands/settle.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require "date"
+
+module SplttyCLI
+  module Commands
+    # `spltty settle [LEDGER...]` — record settlement rows.
+    # One ledger: a ledger-local cash settlement (full, or partial via -v),
+    # never touching other ledgers. No/many ledgers: offset mode — ledgers
+    # whose debt points opposite to the combined direction are zeroed with
+    # mirrored `offset` rows (no real money); cash is written only when -v is
+    # given, allocated smallest-ledger-first against what remains.
+    class Settle < Dry::CLI::Command
+      desc "Record a settlement (one ledger = cash; several/all = cross-ledger offsets + optional cash)"
+
+      argument :ledgers, type: :array, required: false,
+                         desc: "Ledger names (none = all non-reference; one = cash mode; several = offset mode)"
+
+      option :value,        aliases: ["-v"], desc: "Cash amount (single ledger: partial settle; offset mode: cash paid after offsets)"
+      option :method,       aliases: ["-m"], desc: "Payment method for cash rows", default: "Pix"
+      option :date,         aliases: ["-d"], desc: "Date for the settlement rows (default: today)"
+      option :source,       aliases: ["-s"], desc: "Provenance", default: "settle"
+      option :yes,          aliases: ["-y"], type: :boolean, default: false,
+                            desc: "Skip confirmation (non-interactive)"
+      option :config,       aliases: ["-C"], desc: "Path to config.json (default: cli/config.json)"
+      option :accounts_dir, aliases: ["-A"], desc: "Override the accounts directory"
+
+      example [
+        "CASA                # cash-settle CASA in full",
+        "MONTREAL -v 500 -y  # partial cash settle, non-interactive",
+        "                    # global offset mode: zero opposite-direction ledgers",
+        "-v 2000             # global: offsets + R$ 2000 cash, smallest ledger first",
+        "CASA CASAMENTO      # offset mode restricted to these two ledgers",
+      ]
+
+      def call(ledgers: [], **opts)
+        SettleRunner.new(ledgers, opts).run
+      rescue Prompt::Abort, Config::Error, ArgumentError => e
+        warn "spltty settle: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Orchestrates the settle flow. Extracted from the command so it is
+    # unit-testable (same pattern as AddRunner).
+    class SettleRunner
+      OFFSET_METHOD = "offset"
+
+      def initialize(requested, opts)
+        @requested = Array(requested)
+        @opts = opts
+        @interactive = !opts[:yes]
+      end
+
+      def run
+        @config = SplttyCLI.load_config(@opts)
+        Discovery.sync(@config)
+        NotesSync.run(@config)
+        @config.save
+
+        names = resolve_scope
+        transfers = names.to_h { |n| [n, ledger_transfer(n)] }
+
+        plan = @requested.length == 1 ? cash_plan(names.first, transfers) : offset_plan(transfers)
+        return if plan.nil? || plan.empty?
+
+        plan.each { |row| assert_person!(row[:debtor], row[:ledger]) && assert_person!(row[:creditor], row[:ledger]) }
+
+        preview(plan)
+        if @interactive && !Prompt.confirm("Record #{plan.length == 1 ? 'this settlement row' : "these #{plan.length} settlement rows"}?", default: true)
+          puts "Aborted — nothing written."
+          return
+        end
+
+        plan.each { |row| write_row(row) }
+        puts "Recorded #{plan.length} settlement row#{plan.length == 1 ? '' : 's'}."
+      end
+
+      private
+
+      # -> canonical ledger names in scope. No names = all non-missing,
+      # non-reference ledgers; explicit names are validated (reference ledgers
+      # may only be settled on their own).
+      def resolve_scope
+        if @requested.empty?
+          names = @config.ledgers.reject { |_, e| e["missing"] }.keys - SplttyCLI::Totals.reference_ledgers(@config)
+          raise Config::Error, "no ledgers found under #{@config.accounts_dir}" if names.empty?
+
+          return names
+        end
+
+        names = @requested.map do |n|
+          @config.ledger_key(n) or raise Config::Error, "unknown ledger #{n.inspect}"
+        end.uniq
+        names.each do |n|
+          raise Config::Error, "ledger #{n} is missing on disk" if @config.ledgers[n]["missing"]
+        end
+        if names.length > 1 && (refs = names & SplttyCLI::Totals.reference_ledgers(@config)).any?
+          raise Config::Error,
+                "reference ledger#{refs.length == 1 ? '' : 's'} #{refs.join(', ')} cannot join a cross-ledger settle — settle them on their own"
+        end
+        names
+      end
+
+      # The ledger's single outstanding transfer [debtor, creditor, amount], or
+      # nil when even. More than one transfer (3+ people) is out of scope.
+      def ledger_transfer(name)
+        tally = SplttyCLI::Totals.tally(SplttyCLI::Totals.ledger_rows(@config, name), SplttyCLI::Totals.resolver(@config, name))
+        transfers = SplttyCLI::Totals.settle(SplttyCLI::Totals.net(tally))
+        if transfers.length > 1
+          raise Config::Error, "#{name}: #{transfers.length} outstanding transfers — settle involves more than two people; record rows with `spltty add` instead"
+        end
+
+        transfers.first
+      end
+
+      # Single-ledger mode: a real cash payment of the ledger's outstanding
+      # (or -v part of it). -> plan rows, or nil after printing a no-op message.
+      def cash_plan(name, transfers)
+        debtor, creditor, outstanding = transfers[name]
+        if outstanding.nil?
+          puts "#{name}: already even — nothing to settle."
+          return nil
+        end
+
+        amount = outstanding
+        if @opts[:value]
+          amount = parse_amount(@opts[:value])
+          validate_amount!(amount, outstanding)
+          amount = outstanding if (outstanding - amount).abs <= SplttyCLI::Totals::EPS
+        end
+        [{ ledger: name, debtor: debtor, creditor: creditor, amount: amount,
+           kind: :cash, partial: amount < outstanding - SplttyCLI::Totals::EPS }]
+      end
+
+      # Offset mode: zero opposite-direction ledgers with mirrored offset rows,
+      # then allocate -v (if given) as cash — both smallest-ledger-first.
+      def offset_plan(transfers)
+        open = transfers.compact
+        if open.empty?
+          puts "Already even — nothing to settle."
+          return nil
+        end
+
+        debtor, creditor, combined = combined_transfer(transfers)
+        same, opposite = partition_directions(open, debtor, creditor)
+
+        # Same-direction remainders, consumed smallest-outstanding-first.
+        remainders = same.map { |name, (_d, _c, amt)| [name, amt] }.sort_by { |_, amt| amt }
+
+        plan = []
+        opposite.each do |name, (odebtor, ocreditor, oamt)|
+          allocate(remainders, oamt) do |target, take|
+            plan << { ledger: name, debtor: odebtor, creditor: ocreditor, amount: take,
+                      kind: :offset, partial: false, other: target }
+            plan << { ledger: target, debtor: debtor, creditor: creditor, amount: take,
+                      kind: :offset, partial: false, other: name }
+          end
+        end
+
+        if @opts[:value]
+          cash = parse_amount(@opts[:value])
+          raise Config::Error, "nothing left to pay — the offsets already even everything out" if combined <= SplttyCLI::Totals::EPS
+
+          validate_amount!(cash, combined)
+          cash = combined if (combined - cash).abs <= SplttyCLI::Totals::EPS
+          allocate(remainders.sort_by { |_, amt| amt }, cash) do |target, take, remaining|
+            plan << { ledger: target, debtor: debtor, creditor: creditor, amount: take,
+                      kind: :cash, partial: take < remaining - SplttyCLI::Totals::EPS }
+          end
+        elsif plan.empty?
+          puts "Outstanding: #{debtor} owes #{creditor} R$ #{SplttyCLI::Totals.fmt(combined)} — nothing to offset, nothing written. Pass -v to record a payment."
+          return nil
+        end
+        plan
+      end
+
+      # Combined transfer across the scope; direction falls back to the first
+      # open ledger when the set offsets to zero exactly.
+      def combined_transfer(transfers)
+        merged = Hash.new(0.0)
+        transfers.each do |_, t|
+          next if t.nil?
+
+          d, c, amt = t
+          merged[d] -= amt
+          merged[c] += amt
+        end
+        combined = SplttyCLI::Totals.settle(merged)
+        if combined.length > 1
+          raise Config::Error, "combined settlement needs #{combined.length} transfers (more than two people) — settle per ledger instead"
+        end
+        return combined.first if combined.first
+
+        d, c, = transfers.compact.first[1]
+        [d, c, 0.0]
+      end
+
+      def partition_directions(open, debtor, creditor)
+        same = {}
+        opposite = {}
+        open.each do |name, (d, c, _amt)|
+          if d == debtor && c == creditor
+            same[name] = open[name]
+          elsif d == creditor && c == debtor
+            opposite[name] = open[name]
+          else
+            raise Config::Error, "#{name}: transfer #{d} → #{c} does not line up with the combined #{debtor} → #{creditor} settlement"
+          end
+        end
+        [same, opposite]
+      end
+
+      # Consume `amount` from the remainders list in order, yielding
+      # (ledger, take, remaining-before-take) per allocation.
+      def allocate(remainders, amount)
+        need = amount
+        remainders.each do |entry|
+          break if need <= SplttyCLI::Totals::EPS
+          next if entry[1] <= SplttyCLI::Totals::EPS
+
+          take = [need, entry[1]].min
+          yield entry[0], take, entry[1]
+          entry[1] -= take
+          need -= take
+        end
+        raise Config::Error, "internal: could not allocate R$ #{SplttyCLI::Totals.fmt(need)} across the ledgers in scope" if need > SplttyCLI::Totals::EPS
+      end
+
+      def validate_amount!(amount, outstanding)
+        raise Config::Error, "--value must be positive (got #{@opts[:value].inspect})" if amount <= 0
+        if amount > outstanding + SplttyCLI::Totals::EPS
+          raise Config::Error, "--value R$ #{SplttyCLI::Totals.fmt(amount)} exceeds the outstanding R$ #{SplttyCLI::Totals.fmt(outstanding)}"
+        end
+      end
+
+      # Accepts "12.5", "12,50", and "1.234,56" like AddRunner#money.
+      def parse_amount(str)
+        s = str.to_s.strip
+        s = s.include?(".") && s.include?(",") ? s.delete(".").tr(",", ".") : s.tr(",", ".")
+        Float(s)
+      rescue ArgumentError
+        raise Config::Error, "invalid --value: #{str.inspect}"
+      end
+
+      # A settlement row must land on a person; a name that resolves to a split
+      # group would silently divide the offset and corrupt future nets.
+      def assert_person!(name, ledger)
+        if SplttyCLI::Totals.resolver(@config, ledger).call(name).is_a?(Hash)
+          raise Config::Error, "#{name.inspect} is a split group in #{ledger} — settlement rows must name a person"
+        end
+
+        true
+      end
+
+      def title(row)
+        if row[:kind] == :offset
+          "Settlement — offset vs #{row[:other]}"
+        else
+          "Settlement — #{row[:debtor]} → #{row[:creditor]}#{' (partial)' if row[:partial]}"
+        end
+      end
+
+      def row_method(row)
+        row[:kind] == :offset ? OFFSET_METHOD : (@opts[:method] || "Pix")
+      end
+
+      def preview(plan)
+        warn ""
+        warn "Settlement plan:"
+        plan.each do |row|
+          tag = row[:kind] == :offset ? "offset vs #{row[:other]}" : row_method(row)
+          tag += ", partial" if row[:partial]
+          warn format("  %-10s %s → %s  R$ %s  [%s]",
+                      row[:ledger], row[:debtor], row[:creditor], SplttyCLI::Totals.fmt(row[:amount]), tag)
+        end
+      end
+
+      # Persist one row through AddRunner (non-interactive): reuses ledger/month
+      # routing, file scaffolding, and aligned table writing.
+      def write_row(row)
+        amount = format("%.2f", row[:amount])
+        opts = {
+          title: title(row), ledger: row[:ledger], value: amount,
+          paid_by: row[:debtor], responsible: row[:creditor],
+          method: row_method(row), date: date_string,
+          source: @opts[:source] || "settle", yes: true,
+          config: @opts[:config], accounts_dir: @opts[:accounts_dir]
+        }
+        if Ledger.montreal?(@config.ledgers[row[:ledger]])
+          opts[:orig_value] = amount
+          opts[:currency] = "BRL"
+        end
+        AddRunner.new(opts).run
+      end
+
+      def date_string
+        @opts[:date] || Date.today.strftime("%Y-%m-%d")
+      end
+    end
+  end
+end

data/lib/spltty_cli/commands/sync.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SplttyCLI
+  module Commands
+    # `spltty sync` — reconcile ledger config between the `*.notes.md` frontmatter
+    # headers and config.json. Runs structural discovery, then the two-way
+    # notes<->config sync (see NotesSync), and reports what moved in each direction.
+    class Sync < Dry::CLI::Command
+      desc "Sync ledger config between notes-file headers and config.json"
+
+      option :config,       aliases: ["-C"], desc: "Path to config.json (default: cli/config.json)"
+      option :accounts_dir, aliases: ["-A"], desc: "Override the accounts directory"
+
+      def call(**opts)
+        config = SplttyCLI.load_config(opts)
+        Discovery.sync(config)
+        result = NotesSync.run(config)
+        config.save
+
+        if result[:to_config].empty? && result[:to_notes].empty? && result[:globalized].empty?
+          puts "Already in sync (accounts dir: #{config.accounts_dir})"
+          return
+        end
+
+        puts "Synced (accounts dir: #{config.accounts_dir}):"
+        unless result[:to_config].empty?
+          puts "  notes -> config: #{result[:to_config].join(', ')}"
+        end
+        unless result[:to_notes].empty?
+          puts "  config -> notes: #{result[:to_notes].join(', ')}"
+        end
+        unless result[:globalized].empty?
+          puts "  promoted to global groups: #{result[:globalized].join(', ')}"
+        end
+      rescue Config::Error => e
+        warn "spltty sync: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/spltty_cli/commands/totals.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SplttyCLI
+  module Commands
+    # `spltty totals [LEDGER...]` — per-person totals + settlement per ledger.
+    # Splits are resolved against split groups (ledger header groups, then global
+    # config groups); an unmatched Responsible value is a person (100%).
+    # `--combined` merges the non-reference ledgers into one settlement.
+    class Totals < Dry::CLI::Command
+      desc "Per-person totals & settlement (per ledger, or --combined)"
+
+      argument :ledgers, type: :array, required: false, desc: "Ledger names (default: all)"
+
+      option :combined, type: :boolean, default: false, desc: "Merge ledgers into one settlement"
+      option :config,       aliases: ["-C"], desc: "Path to config.json (default: cli/config.json)"
+      option :accounts_dir, aliases: ["-A"], desc: "Override the accounts directory"
+
+      def call(ledgers: [], **opts)
+        config = SplttyCLI.load_config(opts)
+        Discovery.sync(config)
+        NotesSync.run(config)
+        config.save
+
+        names = resolve_names(config, ledgers)
+        return if names.empty?
+
+        if opts[:combined]
+          combined(config, names)
+        else
+          names.each do |name|
+            rows = read_ledger(config, name)
+            reference = SplttyCLI::Totals.reference?(config, name)
+            print SplttyCLI::Totals.report(name, SplttyCLI::Totals.tally(rows, SplttyCLI::Totals.resolver(config, name)), reference: reference)
+          end
+        end
+      rescue ArgumentError => e
+        warn "spltty totals: #{e.message}"
+        exit 1
+      rescue Config::Error => e
+        warn "spltty totals: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def resolve_names(config, requested)
+        if requested.nil? || requested.empty?
+          available = config.ledgers.reject { |_, e| e["missing"] }.keys
+          if available.empty?
+            puts "No ledgers found under #{config.accounts_dir}"
+          end
+          return available
+        end
+
+        requested.map do |n|
+          config.ledger_key(n) or raise Config::Error, "unknown ledger #{n.inspect}"
+        end
+      end
+
+      def combined(config, names)
+        used = []
+        skipped = []
+        tallies = names.map do |name|
+          if SplttyCLI::Totals.reference?(config, name)
+            skipped << name
+            next nil
+          end
+          used << name
+          rows = read_ledger(config, name)
+          SplttyCLI::Totals.tally(rows, SplttyCLI::Totals.resolver(config, name))
+        end.compact
+
+        title = "COMBINED (#{used.length} ledger#{used.length == 1 ? '' : 's'}: #{used.join(', ')})"
+        print SplttyCLI::Totals.report(title, SplttyCLI::Totals.merge(tallies))
+        unless skipped.empty?
+          puts "Skipped reference ledgers (report these on their own): #{skipped.join(', ')}"
+        end
+      end
+
+      def read_ledger(config, name)
+        SplttyCLI::Totals.ledger_rows(config, name)
+      end
+    end
+  end
+end

data/lib/spltty_cli/config.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SplttyCLI
+  # Reads / writes the CLI-owned config.json. Holds user-authored payment
+  # methods and an auto-maintained `ledgers` cache (see Discovery). The
+  # `ledgers` key may be absent on load — it is created on demand.
+  class Config
+    class Error < StandardError; end
+
+    # Where a workspace keeps its config, relative to the workspace root.
+    # `spltty install` writes it; every other command finds it by walking up
+    # from the cwd (see .discover).
+    WORKSPACE_DIR = ".spltty"
+    WORKSPACE_FILE = "config.json"
+
+    DEFAULT = {
+      "accounts_dir"    => "../accounts",
+      "default_ledger"  => "expenses",
+      "date_format"     => "%Y-%m-%d",
+      "payment_methods" => {},
+    }.freeze
+
+    attr_reader :path, :data
+
+    def initialize(path, data)
+      @path = path
+      @data = data
+      @accounts_dir_override = nil
+    end
+
+    # Load config.json, or start from DEFAULT when the file does not exist yet
+    # (the ledgers block gets written on the first discovery run).
+    def self.load(path)
+      data =
+        if File.exist?(path)
+          begin
+            JSON.parse(File.read(path))
+          rescue JSON::ParserError => e
+            raise Error, "malformed config at #{path}: #{e.message}"
+          end
+        else
+          Marshal.load(Marshal.dump(DEFAULT))
+        end
+      raise Error, "config root must be a JSON object" unless data.is_a?(Hash)
+
+      new(path, data)
+    end
+
+    # Walk up from `start_dir` looking for `.spltty/config.json` — the same
+    # nearest-ancestor rule git uses for .git. Returns the absolute path of the
+    # first hit, or nil when there is no workspace above `start_dir`.
+    def self.discover(start_dir = Dir.pwd)
+      dir = File.expand_path(start_dir)
+      loop do
+        candidate = File.join(dir, WORKSPACE_DIR, WORKSPACE_FILE)
+        return candidate if File.file?(candidate)
+
+        parent = File.dirname(dir)
+        return nil if parent == dir # reached the filesystem root
+
+        dir = parent
+      end
+    end
+
+    # Absolute path of the config file for a workspace rooted at `dir`.
+    def self.workspace_path(dir)
+      File.join(File.expand_path(dir), WORKSPACE_DIR, WORKSPACE_FILE)
+    end
+
+    # Absolute accounts directory. Resolved relative to the config file unless an
+    # override (from --accounts-dir / env) was supplied.
+    def accounts_dir
+      base = @accounts_dir_override || @data["accounts_dir"] || "../accounts"
+      File.expand_path(base, File.dirname(@path))
+    end
+
+    # Override with an already-absolute path (App expands --accounts-dir vs cwd).
+    def accounts_dir=(absolute_path)
+      @accounts_dir_override = absolute_path
+    end
+
+    def default_ledger
+      @data["default_ledger"]
+    end
+
+    def date_format
+      @data["date_format"] || "%Y-%m-%d"
+    end
+
+    # The ledgers cache — created lazily so a minimal config (methods only) works.
+    def ledgers
+      @data["ledgers"] ||= {}
+    end
+
+    # Global split groups (shared across ledgers). Created lazily. Ledger-specific
+    # groups live under ledgers[name]["groups"]; these are the promoted globals.
+    def groups
+      @data["groups"] ||= {}
+    end
+
+    def payment_methods
+      @data["payment_methods"] ||= {}
+    end
+
+    # Everyone who can appear in a Paid By / Responsible cell. Recorded by
+    # `spltty install` and used to render the workspace CLAUDE.md; the split
+    # groups remain the authority on how a cost is divided.
+    def participants
+      @data["participants"] ||= []
+    end
+
+    # Resolve a payment method by its full name or its configured slug (both
+    # case-insensitive) → returns [canonical_name, cfg], or [name, nil] when
+    # unknown (e.g. one-off methods like "cash").
+    def payment_method(name)
+      return [nil, nil] if name.nil? || name.empty?
+
+      n = name.strip
+      key = payment_methods.keys.find { |k| k.casecmp?(n) }
+      key ||= payment_methods.keys.find do |k|
+        slug = payment_methods[k]["slug"]
+        slug && slug.casecmp?(n)
+      end
+      key ? [key, payment_methods[key]] : [name, nil]
+    end
+
+    # Case-insensitive resolution of a ledger name to its canonical config key.
+    def ledger_key(name)
+      return nil if name.nil? || name.empty?
+
+      ledgers.keys.find { |k| k.casecmp?(name) }
+    end
+
+    def save
+      File.write(@path, JSON.pretty_generate(@data) + "\n")
+    end
+  end
+end

data/lib/spltty_cli/discovery.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SplttyCLI
+  # Scan accounts/ for ledgers and reconcile them into the config cache.
+  #
+  # A ledger is either:
+  #   * a root file named "<NAME>.ledger.md"  -> single-file ledger, or
+  #   * a subfolder containing "YYYY-MM.md"   -> monthly ledger (e.g. CASA).
+  # Everything else (*.notes.md, README, plain *.md, other files) is ignored.
+  module Discovery
+    module_function
+
+    LEDGER_SUFFIX = ".ledger.md"
+    MONTH_FILE = /\A\d{4}-\d{2}\.md\z/
+
+    # Discover ledgers on disk. Returns an array of hashes:
+    #   { name:, type: "single"|"monthly", file: / dir:, schema:, notes: }
+    def scan(accounts_dir)
+      return [] unless Dir.exist?(accounts_dir)
+
+      found = []
+      Dir.children(accounts_dir).sort.each do |entry|
+        full = File.join(accounts_dir, entry)
+
+        if File.file?(full) && entry.end_with?(LEDGER_SUFFIX)
+          name = entry[0...-LEDGER_SUFFIX.length]
+          notes = "#{name}.notes.md"
+          found << {
+            name: name, type: "single", file: entry,
+            schema: detect_schema(full),
+            notes: (notes if File.exist?(File.join(accounts_dir, notes))),
+          }
+        elsif File.directory?(full)
+          months = Dir.children(full).select { |f| f =~ MONTH_FILE }.sort
+          next if months.empty?
+
+          notes = "notes.md"
+          found << {
+            name: entry, type: "monthly", dir: entry,
+            schema: detect_schema(File.join(full, months.last)),
+            notes: (notes if File.exist?(File.join(full, notes))),
+          }
+        end
+      end
+      found
+    end
+
+    # Schema from the table header: "montreal" if it carries the Orig. Value
+    # column, otherwise "standard". Defaults to standard when no header exists.
+    def detect_schema(file)
+      return "standard" unless file && File.exist?(file)
+
+      File.foreach(file) do |line|
+        next unless line.strip.start_with?("|")
+
+        return line.include?("Orig. Value") ? "montreal" : "standard"
+      end
+      "standard"
+    end
+
+    # Merge discovered ledgers into config.ledgers. Adds new ones, refreshes
+    # structural fields (type/file/dir/schema) on existing ones, and preserves
+    # user overrides (title, default_responsible, default_currency, notes).
+    # Flags config entries whose files vanished as "missing".
+    # Returns { added: [names], missing: [names], changed: bool }.
+    def sync(config)
+      before = JSON.generate(config.ledgers)
+      discovered = scan(config.accounts_dir)
+      names = discovered.map { |d| d[:name] }
+
+      discovered.each do |d|
+        entry = (config.ledgers[d[:name]] ||= {})
+        entry["type"] = d[:type]
+        entry["schema"] = d[:schema]
+        if d[:type] == "monthly"
+          entry["dir"] = d[:dir]
+          entry.delete("file")
+        else
+          entry["file"] = d[:file]
+          entry.delete("dir")
+        end
+        entry["notes"] ||= d[:notes] if d[:notes]
+        entry.delete("missing")
+      end
+
+      added = names - JSON.parse(before).keys
+      missing = config.ledgers.keys - names
+      missing.each { |m| config.ledgers[m]["missing"] = true }
+
+      { added: added, missing: missing, changed: JSON.generate(config.ledgers) != before }
+    end
+  end
+end