spltty 0.1.0

data/lib/spltty_cli/commands/add.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "date"
+
+module SplttyCLI
+  module Commands
+    # `spltty add` — append one expense row to a ledger, applying payment-method
+    # defaults from config and offering to create the ledger/file if missing.
+    class Add < Dry::CLI::Command
+      desc "Append an expense entry to a ledger"
+
+      argument :title, required: false, desc: "Expense description (positional, e.g. \"Leite 1L\")"
+
+      option :ledger,       aliases: ["-l"], desc: "Ledger name (default: config default_ledger)"
+      option :date,         aliases: ["-d"], desc: "Date: DD-MM or DD/MM (this year), DD/MM/YYYY, MM-DD-YYYY, or YYYY-MM-DD (default: today or card bill day)"
+      option :value,        aliases: ["-v"], desc: "Amount in R$ (e.g. 129.90)"
+      option :paid_by,      aliases: ["-p"], desc: "Who fronted the money (Thiago/Camila/...)"
+      option :method,       aliases: ["-m"], desc: "Payment method: full name, its slug (e.g. mc-3278), or a one-off like cash/Pix"
+      option :responsible,  aliases: ["-r"], desc: "Who bears the cost: a split-group name (Both/...) or a person (Thiago/Camila/...)"
+      option :paid_responsible, aliases: ["-pr"], desc: "Shortcut: set both Paid By and Responsible (overridden by -p/-r)"
+      option :source,       aliases: ["-s"], desc: "Provenance (text/audio/filename)", default: "text"
+      option :orig_value,   aliases: ["-o"], desc: "Original amount (montreal schema only)"
+      option :currency,     aliases: ["-c"], desc: "Original currency, e.g. CAD (montreal schema only)"
+      option :create_ledger, type: :boolean, default: false,
+                             desc: "Create --ledger when it does not exist yet (required with --yes)"
+      option :yes,          aliases: ["-y"], type: :boolean, default: false,
+                            desc: "Skip prompts/confirmation (non-interactive)"
+      option :config,       aliases: ["-C"], desc: "Path to config.json (default: the workspace's .spltty/config.json)"
+      option :accounts_dir, aliases: ["-A"], desc: "Override the accounts directory"
+
+      example [
+        %("Leite 1L" -l Casa -v 14.20 -p Thiago -m cash),
+        %("Coffee" -l CASA -v 12.90 -m "Mastercard 9759" -y),
+        %("Metro" -l MONTREAL -o 3.75 -c CAD -v 14.20 -p Camila -m Wise -y),
+        "   # fully interactive (prompts for what's missing)",
+      ]
+
+      def call(**opts)
+        AddRunner.new(opts).run
+      rescue Prompt::Abort, Config::Error, ArgumentError => e
+        warn "spltty add: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Orchestrates the add flow. Extracted from the command so it is unit-testable.
+    class AddRunner
+      def initialize(opts)
+        @opts = opts
+        @interactive = !opts[:yes]
+        @dirty = false
+      end
+
+      def run
+        @config = SplttyCLI.load_config(@opts)
+        print_discovery(Discovery.sync(@config))
+
+        name, entry = resolve_ledger
+        montreal = Ledger.montreal?(entry)
+
+        method_name, method_cfg = resolve_method
+        date = resolve_date(method_cfg)
+
+        values = gather(entry, montreal, method_name, method_cfg, date)
+
+        path = Ledger.target_path(@config, name, entry, date)
+        ensure_file(name, entry, path, date)
+
+        text = File.read(path)
+        parsed = Table.parse(text)
+        row = Table.format_row(parsed, values)
+
+        preview(name, path, row)
+        if @interactive && !Prompt.confirm("Append this row?", default: true)
+          puts "Aborted — nothing written."
+          return
+        end
+
+        File.write(path, Table.insert_row(text, parsed, row))
+        @config.save if @dirty
+        puts "Appended to #{path}"
+        puts row
+      end
+
+      private
+
+      def resolve_ledger
+        name = (@opts[:ledger] || @config.default_ledger).to_s
+        name = Prompt.ask("Ledger", required: true) if name.empty?
+        key, entry = Ledger.config_entry(@config, name)
+        return [key, entry] if entry
+
+        resolve_unknown_ledger(key)
+      end
+
+      # An unknown ledger name is far more often a typo (`-l CAS`) than a new
+      # account, and a typo silently scaffolds a junk ledger that then shows up
+      # in every totals run. So: offer to create it, but list the existing
+      # ledgers alongside so the slip can be corrected in place.
+      # Returns [name, entry].
+      def resolve_unknown_ledger(name)
+        return [name, create_ledger(name)] if @opts[:create_ledger]
+
+        known = @config.ledgers.keys
+        unless @interactive
+          hint = known.empty? ? "no ledgers exist yet" : "known ledgers: #{known.join(', ')}"
+          raise Prompt::Abort, "unknown ledger #{name.inspect} (#{hint}) — " \
+                               "pass --create-ledger to create it"
+        end
+
+        warn "Ledger #{name.inspect} is not known yet."
+        if known.empty?
+          raise Prompt::Abort, "ledger #{name.inspect} does not exist" unless Prompt.confirm("Create it?", default: true)
+
+          return [name, create_ledger(name)]
+        end
+
+        choice = Prompt.choose("Which ledger?", ["Create a new ledger #{name.inspect}"] + known, default: 1)
+        return [name, create_ledger(name)] if choice.zero?
+
+        key = known[choice - 1]
+        [key, @config.ledgers[key]]
+      end
+
+      # Register a new ledger in config (the entries file itself is scaffolded
+      # later, by ensure_file). Monthly is the house default, matching
+      # `spltty install`.
+      def create_ledger(name)
+        type = "monthly"
+        schema = "standard"
+        if @interactive
+          type = Prompt.confirm("Monthly (one file per month)? (n = single file)", default: true) ? "monthly" : "single"
+          schema = Prompt.confirm("Multi-currency (extra Orig. Value + Cur. columns)?", default: false) ? "montreal" : "standard"
+        end
+        entry = { "type" => type, "schema" => schema }
+        type == "monthly" ? entry["dir"] = name : entry["file"] = "#{name}.ledger.md"
+        @config.ledgers[name] = entry
+        @dirty = true
+        warn "Creating ledger #{name.inspect} (#{type})."
+        entry
+      end
+
+      def resolve_method
+        name = @opts[:method]
+        name = Prompt.ask("Payment Method") if missing?(name) && @interactive
+        method_name, method_cfg = @config.payment_method(name.to_s)
+        [method_name.to_s, method_cfg]
+      end
+
+      def resolve_date(method_cfg)
+        return parse_date(@opts[:date].to_s) unless missing?(@opts[:date])
+
+        today = Date.today
+        return bill_date(today, method_cfg["bill_day"]) if method_cfg && method_cfg["bill_day"]
+
+        today
+      rescue Date::Error, ArgumentError
+        raise Prompt::Abort, "invalid --date: #{@opts[:date].inspect}"
+      end
+
+      # Flexible date input:
+      #   YYYY-MM-DD        -> ISO (as stored)
+      #   MM-DD-YYYY        -> American (dash + year)
+      #   DD-MM / DD/MM     -> day/month in the current year
+      #   DD/MM/YYYY        -> day/month/year
+      # Anything else falls back to Ruby's Date.parse.
+      def parse_date(str)
+        s = str.strip
+        year = Date.today.year
+        case s
+        when /\A(\d{4})-(\d{1,2})-(\d{1,2})\z/     then Date.new(::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i, ::Regexp.last_match(3).to_i)
+        when /\A(\d{1,2})-(\d{1,2})-(\d{4})\z/     then Date.new(::Regexp.last_match(3).to_i, ::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i)
+        when %r{\A(\d{1,2})/(\d{1,2})/(\d{4})\z}   then Date.new(::Regexp.last_match(3).to_i, ::Regexp.last_match(2).to_i, ::Regexp.last_match(1).to_i)
+        when /\A(\d{1,2})-(\d{1,2})\z/             then Date.new(year, ::Regexp.last_match(2).to_i, ::Regexp.last_match(1).to_i)
+        when %r{\A(\d{1,2})/(\d{1,2})\z}           then Date.new(year, ::Regexp.last_match(2).to_i, ::Regexp.last_match(1).to_i)
+        else Date.parse(s)
+        end
+      end
+
+      def bill_date(ref, day)
+        return Date.new(ref.year, ref.month, -1) if day.to_s == "last"
+
+        Date.new(ref.year, ref.month, day.to_i)
+      end
+
+      # Build the row. Fields supplied by flag (or a payment-method / ledger
+      # default) are used as-is; only genuinely missing required fields prompt in
+      # interactive mode. A confirmation step follows in `run`.
+      def gather(entry, montreal, method_name, method_cfg, date)
+        values = { "Date" => date.strftime(@config.date_format) }
+
+        values["Title"] = need(:title, "Title")
+
+        if montreal
+          values["Orig. Value"] = money(need(:orig_value, "Orig. Value"))
+          cur = @opts[:currency] || (entry && entry["default_currency"]) || "CAD"
+          values["Cur."] = cur.to_s.upcase
+        end
+
+        values["Value (R$)"] = money(need(:value, "Value (R$)"))
+
+        both = @opts[:paid_responsible]
+
+        paid_by = @opts[:paid_by] || both || method_cfg&.dig("paid_by")
+        paid_by = Prompt.ask("Paid By", required: true) if missing?(paid_by) && @interactive
+        values["Paid By"] = require_value!(paid_by, "Paid By (--paid-by / --paid-responsible)")
+
+        values["Payment Method"] = method_name
+
+        values["Responsible"] = @opts[:responsible] || both || method_cfg&.dig("responsible") ||
+                                (entry && entry["default_responsible"]) || "Both"
+
+        values["Source"] = @opts[:source] || "text"
+
+        values
+      end
+
+      def missing?(val)
+        val.nil? || val.to_s.strip.empty?
+      end
+
+      # Return a required field's value: use the flag if present, otherwise prompt
+      # (interactive) or error (non-interactive).
+      def need(key, label)
+        val = @opts[key]
+        return val unless missing?(val)
+        return Prompt.ask(label, required: true) if @interactive
+
+        raise Prompt::Abort, "missing required option --#{key.to_s.tr('_', '-')}"
+      end
+
+      # Normalize an amount string to two decimals. Accepts "12.5", "12,50", and
+      # "1.234,56" (dot thousands + comma decimal).
+      def money(str)
+        s = str.to_s.strip
+        raise Prompt::Abort, "missing amount" if s.empty?
+
+        s = s.include?(".") && s.include?(",") ? s.delete(".").tr(",", ".") : s.tr(",", ".")
+        format("%.2f", Float(s))
+      rescue ArgumentError
+        raise Prompt::Abort, "invalid amount: #{str.inspect}"
+      end
+
+      def require_value!(val, label)
+        raise Prompt::Abort, "missing #{label}" if val.nil? || val.to_s.strip.empty?
+
+        val
+      end
+
+      def ensure_file(name, entry, path, date)
+        return if File.exist?(path)
+
+        if @interactive && !Prompt.confirm("File #{path} doesn't exist. Create it?", default: true)
+          raise Prompt::Abort, "target file does not exist: #{path}"
+        end
+
+        Ledger.scaffold(path, Ledger.title(name, entry, date),
+                        Ledger.notes_pointer(name, entry), Ledger.schema(entry))
+        warn "Created #{path}"
+      end
+
+      def preview(name, path, row)
+        warn ""
+        warn "Ledger : #{name}  (#{path})"
+        warn "Row    : #{row}"
+      end
+
+      def print_discovery(result)
+        warn "Discovered ledgers added to config: #{result[:added].join(', ')}" if result[:added].any?
+        warn "Ledgers in config but missing on disk: #{result[:missing].join(', ')}" if result[:missing].any?
+      end
+    end
+  end
+end

data/lib/spltty_cli/commands/groups.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SplttyCLI
+  module Commands
+    # `spltty groups` — list global split groups and each ledger's own groups.
+    class Groups < Dry::CLI::Command
+      desc "List split groups (global + per-ledger)"
+
+      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)
+
+        printed = false
+        unless config.groups.empty?
+          puts "Global groups:"
+          print_groups(config.groups)
+          printed = true
+        end
+
+        config.ledgers.each do |name, entry|
+          groups = entry["groups"]
+          next unless groups.is_a?(Hash) && !groups.empty?
+
+          puts "#{name}:"
+          print_groups(groups)
+          printed = true
+        end
+
+        puts "No split groups defined." unless printed
+      rescue Config::Error => e
+        warn "spltty groups: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def print_groups(groups)
+        width = groups.keys.map(&:length).max
+        groups.each do |name, hash|
+          puts format("  %-#{width}s  %s", name, SplttyCLI::Groups.format(hash))
+        end
+      end
+    end
+  end
+end

data/lib/spltty_cli/commands/groups_add.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SplttyCLI
+  module Commands
+    # `spltty groups add` — define or update a split group. For a ledger the
+    # group is written into that ledger's notes header (the source of truth) and
+    # then reconciled into config via NotesSync. With --global it is written
+    # straight into the config's global groups (globals never live in a header).
+    class GroupsAdd < Dry::CLI::Command
+      desc "Add or update a split group (in a ledger header, or --global)"
+
+      argument :name, required: true, desc: "Group name (e.g. \"Both\")"
+
+      option :split,        aliases: ["-s"], desc: "Participants as NAME:PCT,NAME:PCT (e.g. Thiago:70,Camila:30)"
+      option :ledger,       aliases: ["-l"], desc: "Ledger whose header owns this group"
+      option :global,       aliases: ["-g"], type: :boolean, default: false, desc: "Store as a global group instead"
+      option :config,       aliases: ["-C"], desc: "Path to config.json (default: cli/config.json)"
+      option :accounts_dir, aliases: ["-A"], desc: "Override the accounts directory"
+
+      example [
+        %(Both -s Thiago:70,Camila:30 -l CASA),
+        %(Both -s Thiago:50,Camila:50 --global),
+      ]
+
+      def call(name:, **opts)
+        config = SplttyCLI.load_config(opts)
+        hash = SplttyCLI::Groups.parse_split(opts[:split])
+        SplttyCLI::Groups.validate(name, hash)
+
+        if opts[:global]
+          config.groups[name] = hash
+          config.save
+          puts "Added global group #{name.inspect}: #{SplttyCLI::Groups.format(hash)}"
+          return
+        end
+
+        raise Config::Error, "specify --ledger NAME or --global" if blank?(opts[:ledger])
+
+        Discovery.sync(config)
+        key = config.ledger_key(opts[:ledger]) or
+          raise Config::Error, "unknown ledger #{opts[:ledger].inspect}"
+        entry = config.ledgers[key]
+        path = Notes.path_for(config.accounts_dir, key, entry)
+        raise Config::Error, "no notes file for #{key} at #{path}" unless File.exist?(path)
+
+        parsed = Notes.parse(path)
+        fm = parsed[:frontmatter]
+        spltty = (fm["spltty"] ||= {})
+        groups = (spltty["groups"] ||= {})
+        groups[name] = hash
+        Notes.write(path, fm, parsed[:body])
+
+        NotesSync.run(config)
+        config.save
+        puts "Added group #{name.inspect} to #{key}: #{SplttyCLI::Groups.format(hash)}"
+      rescue ArgumentError => e
+        warn "spltty groups add: #{e.message}"
+        exit 1
+      rescue Config::Error => e
+        warn "spltty groups add: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end

data/lib/spltty_cli/commands/groups_rm.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SplttyCLI
+  module Commands
+    # `spltty groups rm` — remove a split group from a ledger header (source of
+    # truth, then reconciled via NotesSync) or from the global groups (--global).
+    class GroupsRm < Dry::CLI::Command
+      desc "Remove a split group (from a ledger header, or --global)"
+
+      argument :name, required: true, desc: "Group name to remove"
+
+      option :ledger,       aliases: ["-l"], desc: "Ledger whose header owns this group"
+      option :global,       aliases: ["-g"], type: :boolean, default: false, desc: "Remove from the global groups instead"
+      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(name:, **opts)
+        config = SplttyCLI.load_config(opts)
+
+        if opts[:global]
+          removed = config.groups.delete(name)
+          config.save
+          puts removed ? "Removed global group #{name.inspect}" : "No global group #{name.inspect}"
+          return
+        end
+
+        raise Config::Error, "specify --ledger NAME or --global" if blank?(opts[:ledger])
+
+        Discovery.sync(config)
+        key = config.ledger_key(opts[:ledger]) or
+          raise Config::Error, "unknown ledger #{opts[:ledger].inspect}"
+        entry = config.ledgers[key]
+        path = Notes.path_for(config.accounts_dir, key, entry)
+        raise Config::Error, "no notes file for #{key} at #{path}" unless File.exist?(path)
+
+        parsed = Notes.parse(path)
+        groups = parsed[:frontmatter].dig("spltty", "groups")
+        unless groups.is_a?(Hash) && groups.key?(name)
+          puts "No group #{name.inspect} in #{key}"
+          return
+        end
+
+        groups.delete(name)
+        if groups.empty?
+          parsed[:frontmatter]["spltty"].delete("groups")
+          parsed[:frontmatter].delete("spltty") if parsed[:frontmatter]["spltty"].empty?
+        end
+        Notes.write(path, parsed[:frontmatter], parsed[:body])
+
+        # Apply the deletion to config directly: when the header's last group is
+        # removed the "groups" key vanishes, and NotesSync's absent-key guard
+        # would otherwise leave the stale copy in config.
+        if entry["groups"].is_a?(Hash)
+          entry["groups"].delete(name)
+          entry.delete("groups") if entry["groups"].empty?
+        end
+
+        NotesSync.run(config)
+        config.save
+        puts "Removed group #{name.inspect} from #{key}"
+      rescue Config::Error => e
+        warn "spltty groups rm: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end

data/lib/spltty_cli/commands/help.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SplttyCLI
+  module Commands
+    # `spltty help` — print every command with its aliases and options, read
+    # straight from each command's dry-cli metadata.
+    class Help < Dry::CLI::Command
+      desc "Show all commands and their options"
+
+      def call(**)
+        puts "spltty — append entries to the expense ledgers under accounts/"
+        puts
+        puts "Usage:"
+        puts "  spltty COMMAND [options]"
+        puts
+        puts "Commands:"
+        SplttyCLI::COMMAND_SPECS.each { |spec| print_command(spec) }
+        puts "Run `spltty COMMAND --help` for details on a single command."
+      end
+
+      private
+
+      def print_command(spec)
+        klass = spec[:klass]
+        puts
+        puts "  #{spec[:name]}"
+        puts "    #{klass.description}" if klass.description
+        klass.arguments.each do |arg|
+          label = "<#{arg.name}>#{arg.required? ? '' : ' (optional)'}"
+          puts "      #{label.ljust(32)} #{arg.desc}"
+        end
+        klass.options.each do |opt|
+          puts "      #{flag(opt).ljust(32)} #{opt.desc}"
+        end
+      end
+
+      def flag(opt)
+        name = "--#{opt.name.to_s.tr('_', '-')}"
+        name += ", #{opt.aliases.join(', ')}" unless opt.aliases.empty?
+        name
+      end
+    end
+  end
+end