@gabrielerandelli/minus-tracker 0.5.1

package/dist/cli/index.js

@@ -0,0 +1,863 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { parseArgs } from "util";
+
+// src/i18n/it.ts
+var it = {
+  numberLocale: "it-IT",
+  errorInvalidCsv: "CSV non valido: impossibile analizzare il file",
+  errorMissingColumn: (col) => `Colonna obbligatoria mancante: ${col}`,
+  errorNoOpenLots: (isin, date) => `Nessun lotto aperto per ISIN ${isin} in data ${date}`,
+  warnMissingIsin: (row) => `Riga ${row}: ISIN mancante \u2014 riga ignorata`,
+  warnUnsupportedCurrency: (row, currency) => `Riga ${row}: valuta non supportata ${currency} \u2014 riga ignorata`,
+  warnNoEcbRate: (row, currency, date) => `Riga ${row}: nessun tasso BCE per ${currency} in data ${date} \u2014 riga ignorata`,
+  warnQuantityZero: (row) => `Riga ${row}: quantit\xE0 pari a 0 \u2014 riga ignorata`,
+  warnMultipleYears: "Il CSV contiene transazioni di pi\xF9 anni \u2014 filtra per un singolo anno per un calcolo accurato.",
+  headerMethod: "METODO",
+  headerTaxYear: "ANNO FISCALE",
+  headerIsin: "ISIN",
+  headerProduct: "TITOLO",
+  headerQty: "QT\xC0",
+  headerBuyDate: "DATA ACQUISTO",
+  headerSellDate: "DATA VENDITA",
+  headerBuyEur: "ACQUISTO EUR",
+  headerSellEur: "VENDITA EUR",
+  headerGainLoss: "GUADAGNO/PERDITA",
+  summaryPlusvalenze: "PLUSVALENZE",
+  summaryMinusvalenze: "MINUSVALENZE",
+  summaryNetResult: "RISULTATO NETTO",
+  summaryWarnings: "AVVERTENZE",
+  summaryGenerated: "Generato",
+  validateOk: (count, errors) => `OK: ${count} transazioni analizzate, ${errors} errori gravi`,
+  validateWarn: (count, reason) => `AVVISO: ${count} righe ignorate (${reason})`,
+  ratesCoverage: (start, end, currencies) => `Copertura: ${start} \u2192 ${end} | Valute: ${currencies}`,
+  ratesGapsNone: "Lacune: nessuna",
+  ratesGaps: (list) => `Lacune: ${list}`,
+  ratesUpdateFetching: "Recupero dati BCE SDMX in corso...",
+  ratesUpdateDone: (n) => `Completato. Aggiunte ${n} nuove date.`,
+  ratesSnapshotWritten: (path4) => `Snapshot scritto in ${path4}`,
+  configLangSet: (lang) => `Lingua impostata su: ${lang}`,
+  configCurrentLang: (lang) => `Lingua corrente: ${lang}`,
+  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
+};
+
+// src/i18n/en.ts
+var en = {
+  numberLocale: "en-US",
+  errorInvalidCsv: "Invalid CSV: unable to parse",
+  errorMissingColumn: (col) => `Missing required column: ${col}`,
+  errorNoOpenLots: (isin, date) => `No open lots for ISIN ${isin} on ${date}`,
+  warnMissingIsin: (row) => `Row ${row}: missing ISIN \u2014 skipped`,
+  warnUnsupportedCurrency: (row, currency) => `Row ${row}: unsupported currency ${currency} \u2014 skipped`,
+  warnNoEcbRate: (row, currency, date) => `Row ${row}: no ECB rate for ${currency} on ${date} \u2014 skipped`,
+  warnQuantityZero: (row) => `Row ${row}: quantity is 0 \u2014 skipped`,
+  warnMultipleYears: "CSV contains transactions from multiple years \u2014 filter to a single year for accurate reporting.",
+  headerMethod: "METHOD",
+  headerTaxYear: "TAX YEAR",
+  headerIsin: "ISIN",
+  headerProduct: "PRODUCT",
+  headerQty: "QTY",
+  headerBuyDate: "BUY DATE",
+  headerSellDate: "SELL DATE",
+  headerBuyEur: "BUY EUR",
+  headerSellEur: "SELL EUR",
+  headerGainLoss: "GAIN/LOSS",
+  summaryPlusvalenze: "PLUSVALENZE",
+  summaryMinusvalenze: "MINUSVALENZE",
+  summaryNetResult: "NET RESULT",
+  summaryWarnings: "WARNINGS",
+  summaryGenerated: "Generated",
+  validateOk: (count, errors) => `OK: ${count} transactions parsed, ${errors} hard errors`,
+  validateWarn: (count, reason) => `WARN: ${count} rows skipped (${reason})`,
+  ratesCoverage: (start, end, currencies) => `Coverage: ${start} \u2192 ${end} | Currencies: ${currencies}`,
+  ratesGapsNone: "Gaps: none",
+  ratesGaps: (list) => `Gaps: ${list}`,
+  ratesUpdateFetching: "Fetching ECB SDMX...",
+  ratesUpdateDone: (n) => `Done. Added ${n} new dates.`,
+  ratesSnapshotWritten: (path4) => `Snapshot written to ${path4}`,
+  configLangSet: (lang) => `Language set to: ${lang}`,
+  configCurrentLang: (lang) => `Current language: ${lang}`,
+  disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
+};
+
+// src/i18n/settings.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var SUPPORTED_LOCALES = ["it", "en"];
+function getConfigPath() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "minus-tracker", "config.json");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(xdg, "minus-tracker", "config.json");
+}
+function readConfig() {
+  try {
+    const raw = fs.readFileSync(getConfigPath(), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function saveLocale(lang) {
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  const existing = readConfig();
+  const updated = { ...existing, locale: lang };
+  fs.writeFileSync(configPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+}
+function resolveLocale(cliLang) {
+  if (cliLang !== void 0) {
+    if (!SUPPORTED_LOCALES.includes(cliLang)) {
+      process.stderr.write(`Unsupported locale "${cliLang}". Use: it, en
+`);
+      process.exit(2);
+    }
+    return cliLang;
+  }
+  const envLang = process.env.MINUS_TRACKER_LANG;
+  if (envLang !== void 0) {
+    if (!SUPPORTED_LOCALES.includes(envLang)) {
+      process.stderr.write(`Unsupported locale "${envLang}". Use: it, en
+`);
+      process.exit(2);
+    }
+    return envLang;
+  }
+  const config = readConfig();
+  if (config.locale && SUPPORTED_LOCALES.includes(config.locale)) {
+    return config.locale;
+  }
+  return "it";
+}
+
+// src/i18n/index.ts
+function getStrings(locale) {
+  return locale === "it" ? it : en;
+}
+
+// src/errors.ts
+var ParseError = class extends Error {
+  code;
+  columnName;
+  constructor(code, columnName) {
+    const msg = code === "INVALID_CSV" ? "Invalid CSV: unable to parse" : `Missing required column: ${columnName}`;
+    super(msg);
+    this.name = "ParseError";
+    this.code = code;
+    this.columnName = columnName;
+  }
+};
+var CalculationError = class extends Error {
+  isin;
+  date;
+  constructor(isin, date) {
+    super(`No open lots for ISIN ${isin} on ${date}`);
+    this.name = "CalculationError";
+    this.isin = isin;
+    this.date = date;
+  }
+};
+
+// src/cli/commands/calc.ts
+import * as fs3 from "fs";
+
+// src/rates/index.ts
+import { fileURLToPath } from "url";
+import * as path2 from "path";
+import * as fs2 from "fs";
+var _bundled = null;
+function getBundledSnapshot() {
+  if (_bundled) return _bundled;
+  const __dirname = path2.dirname(fileURLToPath(import.meta.url));
+  const bundledPath = path2.join(__dirname, "../data/ecb-rates.json");
+  _bundled = JSON.parse(fs2.readFileSync(bundledPath, "utf8"));
+  return _bundled;
+}
+function getUserSnapshot() {
+  const platform = process.platform;
+  let configDir;
+  if (platform === "win32") {
+    configDir = process.env.APPDATA ?? path2.join(process.env.USERPROFILE ?? "~", "AppData", "Roaming");
+  } else {
+    configDir = process.env.XDG_CONFIG_HOME ?? path2.join(process.env.HOME ?? "~", ".config");
+  }
+  const userPath = path2.join(configDir, "minus-tracker", "ecb-rates.json");
+  try {
+    return JSON.parse(fs2.readFileSync(userPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function getActiveSnapshot() {
+  const bundled = getBundledSnapshot();
+  const user = getUserSnapshot();
+  if (!user) return bundled;
+  const merged = {};
+  for (const ccy of /* @__PURE__ */ new Set([...Object.keys(bundled), ...Object.keys(user)])) {
+    merged[ccy] = { ...bundled[ccy] ?? {}, ...user[ccy] ?? {} };
+  }
+  return merged;
+}
+function subtractDays(isoDate, days) {
+  const d = /* @__PURE__ */ new Date(isoDate + "T00:00:00Z");
+  d.setUTCDate(d.getUTCDate() - days);
+  return d.toISOString().slice(0, 10);
+}
+function lookupRate(currency, date, snapshot) {
+  if (currency === "EUR") return 1;
+  const s = snapshot ?? getActiveSnapshot();
+  const currencyRates = s[currency];
+  if (!currencyRates) return null;
+  for (let i = 0; i <= 3; i++) {
+    const d = i === 0 ? date : subtractDays(date, i);
+    if (currencyRates[d] !== void 0) {
+      return currencyRates[d];
+    }
+  }
+  return null;
+}
+
+// src/parser/warnings.ts
+function warningToEnglish(w) {
+  switch (w.code) {
+    case "MISSING_ISIN":
+      return `Row ${w.row}: missing ISIN \u2014 skipped`;
+    case "UNSUPPORTED_CURRENCY":
+      return `Row ${w.row}: unsupported currency ${w.currency} \u2014 skipped`;
+    case "NO_ECB_RATE":
+      return `Row ${w.row}: no ECB rate for ${w.currency} on ${w.date} \u2014 skipped`;
+    case "QUANTITY_ZERO":
+      return `Row ${w.row}: quantity is 0 \u2014 skipped`;
+  }
+}
+
+// src/parser/index.ts
+var REQUIRED_COLUMNS = [
+  "ISIN",
+  "Quantity",
+  "Price",
+  "Date",
+  "Local value",
+  "Local value currency",
+  "Transaction costs",
+  "Transaction costs currency",
+  "Product"
+];
+function parseCSVRow(line) {
+  const fields = [];
+  let i = 0;
+  while (i <= line.length) {
+    if (i === line.length) break;
+    if (line[i] === '"') {
+      let field = "";
+      i++;
+      while (i < line.length) {
+        if (line[i] === '"' && i + 1 < line.length && line[i + 1] === '"') {
+          field += '"';
+          i += 2;
+        } else if (line[i] === '"') {
+          i++;
+          break;
+        } else {
+          field += line[i++];
+        }
+      }
+      fields.push(field);
+      if (i < line.length && line[i] === ",") i++;
+    } else {
+      const start = i;
+      while (i < line.length && line[i] !== ",") i++;
+      fields.push(line.slice(start, i));
+      if (i < line.length) i++;
+    }
+  }
+  return fields;
+}
+function parseCSV(input) {
+  const normalized = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized.split("\n").map(parseCSVRow);
+}
+function parseDate(ddmmyyyy) {
+  const [dd, mm, yyyy] = ddmmyyyy.split("-");
+  return `${yyyy}-${mm}-${dd}`;
+}
+var DEGIROParser = class {
+  _warningEntries = [];
+  _snapshot;
+  constructor(snapshot) {
+    this._snapshot = snapshot;
+  }
+  parse(csv) {
+    this._warningEntries = [];
+    if (typeof csv !== "string" || csv.includes("\0")) {
+      throw new ParseError("INVALID_CSV");
+    }
+    let rows;
+    try {
+      rows = parseCSV(csv);
+    } catch {
+      throw new ParseError("INVALID_CSV");
+    }
+    if (rows.length === 0) {
+      throw new ParseError("INVALID_CSV");
+    }
+    const header = rows[0];
+    const colIndex = {};
+    for (let i = 0; i < header.length; i++) {
+      colIndex[header[i].trim()] = i;
+    }
+    for (const col of REQUIRED_COLUMNS) {
+      if (colIndex[col] === void 0) {
+        throw new ParseError("MISSING_COLUMN", col);
+      }
+    }
+    const snapshot = this._snapshot ?? getActiveSnapshot();
+    const transactions = [];
+    for (let r = 1; r < rows.length; r++) {
+      const row = rows[r];
+      const rowIndex = r + 1;
+      if (row.every((cell) => cell.trim() === "")) continue;
+      const get2 = (col) => (row[colIndex[col]] ?? "").trim();
+      const isin = get2("ISIN");
+      if (!isin) {
+        this._warningEntries.push({ code: "MISSING_ISIN", row: rowIndex });
+        continue;
+      }
+      const rawQty = parseFloat(get2("Quantity"));
+      if (isNaN(rawQty) || rawQty === 0) {
+        this._warningEntries.push({ code: "QUANTITY_ZERO", row: rowIndex });
+        continue;
+      }
+      const type = rawQty > 0 ? "BUY" : "SELL";
+      const quantity = Math.abs(rawQty);
+      const isoDate = parseDate(get2("Date"));
+      const currency = get2("Local value currency");
+      const rawTotalLocal = parseFloat(get2("Local value"));
+      const totalLocal = isNaN(rawTotalLocal) ? 0 : rawTotalLocal;
+      let totalEUR;
+      let fxRate;
+      if (currency === "EUR") {
+        totalEUR = Math.abs(totalLocal);
+        fxRate = void 0;
+      } else {
+        const rate = lookupRate(currency, isoDate, snapshot);
+        if (rate === null) {
+          if (snapshot[currency] === void 0) {
+            this._warningEntries.push({
+              code: "UNSUPPORTED_CURRENCY",
+              row: rowIndex,
+              currency
+            });
+          } else {
+            this._warningEntries.push({
+              code: "NO_ECB_RATE",
+              row: rowIndex,
+              currency,
+              date: isoDate
+            });
+          }
+          continue;
+        }
+        totalEUR = Math.abs(totalLocal) / rate;
+        fxRate = rate;
+      }
+      const rawFees = parseFloat(get2("Transaction costs"));
+      const feesEUR = Math.abs(isNaN(rawFees) ? 0 : rawFees);
+      const pricePerUnit = parseFloat(get2("Price"));
+      const product = get2("Product");
+      transactions.push({
+        isin,
+        product,
+        date: isoDate,
+        type,
+        quantity,
+        pricePerUnit,
+        currency,
+        totalLocal,
+        totalEUR,
+        feesEUR,
+        fxRate
+      });
+    }
+    return transactions;
+  }
+  get warnings() {
+    return this._warningEntries.map(warningToEnglish);
+  }
+  get warningEntries() {
+    return this._warningEntries;
+  }
+};
+
+// src/calculator/index.ts
+function roundHalfUp(x) {
+  return Math.sign(x) * Math.round(Math.abs(x) * 100) / 100;
+}
+function inferTaxYear(transactions) {
+  const counts = {};
+  for (const t of transactions) {
+    const y = t.date.slice(0, 4);
+    counts[y] = (counts[y] ?? 0) + 1;
+  }
+  const years = Object.keys(counts);
+  if (years.length === 0)
+    return { year: (/* @__PURE__ */ new Date()).getFullYear(), multipleYears: false };
+  const year = parseInt(
+    years.reduce((a, b) => counts[a] >= counts[b] ? a : b)
+  );
+  return { year, multipleYears: years.length > 1 };
+}
+var Calculator = class {
+  _transactions;
+  _parseWarnings;
+  constructor(transactions, parseWarnings) {
+    this._transactions = transactions;
+    this._parseWarnings = parseWarnings ?? [];
+  }
+  calculateGains(method) {
+    const warnings = [...this._parseWarnings];
+    const sorted = [...this._transactions].sort((a, b) => {
+      if (a.date < b.date) return -1;
+      if (a.date > b.date) return 1;
+      if (a.type === "BUY" && b.type === "SELL") return -1;
+      if (a.type === "SELL" && b.type === "BUY") return 1;
+      return 0;
+    });
+    const { year: taxYear, multipleYears } = inferTaxYear(sorted);
+    if (multipleYears) {
+      warnings.push(
+        "CSV contains transactions from multiple years \u2014 filter to a single year for accurate reporting."
+      );
+    }
+    const openLots = /* @__PURE__ */ new Map();
+    const matchedLots = [];
+    const ratesUsed = {};
+    for (const tx of sorted) {
+      if (tx.fxRate !== void 0) {
+        ratesUsed[`${tx.currency}:${tx.date}`] = tx.fxRate;
+      }
+      if (tx.type === "BUY") {
+        const lot = {
+          date: tx.date,
+          quantity: tx.quantity,
+          pricePerUnitEUR: tx.totalEUR / tx.quantity,
+          feesEUR: tx.feesEUR,
+          originalQty: tx.quantity,
+          fxRate: tx.fxRate
+        };
+        if (!openLots.has(tx.isin)) openLots.set(tx.isin, []);
+        openLots.get(tx.isin).push(lot);
+      } else {
+        const lots = openLots.get(tx.isin);
+        if (!lots || lots.length === 0) {
+          throw new CalculationError(tx.isin, tx.date);
+        }
+        const sellPricePerUnitEUR = tx.totalEUR / tx.quantity;
+        let remainingSellQty = tx.quantity;
+        while (remainingSellQty > 0) {
+          if (!lots || lots.length === 0) {
+            throw new CalculationError(tx.isin, tx.date);
+          }
+          const lot = method === "LIFO" ? lots[lots.length - 1] : lots[0];
+          const matchedQty = Math.min(lot.quantity, remainingSellQty);
+          const allocatedBuyFeesEUR = lot.feesEUR * (matchedQty / lot.originalQty);
+          const allocatedSellFeesEUR = tx.feesEUR * (matchedQty / tx.quantity);
+          const buyCostEUR = lot.pricePerUnitEUR * matchedQty + allocatedBuyFeesEUR;
+          const sellProceedsEUR = sellPricePerUnitEUR * matchedQty - allocatedSellFeesEUR;
+          const gainLossEUR = sellProceedsEUR - buyCostEUR;
+          matchedLots.push({
+            isin: tx.isin,
+            product: tx.product,
+            quantity: matchedQty,
+            buyDate: lot.date,
+            sellDate: tx.date,
+            buyPriceEUR: lot.pricePerUnitEUR,
+            sellPriceEUR: sellPricePerUnitEUR,
+            buyCostEUR: roundHalfUp(buyCostEUR),
+            sellProceedsEUR: roundHalfUp(sellProceedsEUR),
+            gainLossEUR: roundHalfUp(gainLossEUR),
+            buyFxRate: lot.fxRate,
+            sellFxRate: tx.fxRate
+          });
+          lot.quantity -= matchedQty;
+          remainingSellQty -= matchedQty;
+          if (lot.quantity <= 0) {
+            if (method === "LIFO") {
+              lots.pop();
+            } else {
+              lots.shift();
+            }
+          }
+        }
+      }
+    }
+    let plusvalenze = 0;
+    let minusvalenze = 0;
+    for (const lot of matchedLots) {
+      if (lot.gainLossEUR > 0) plusvalenze += lot.gainLossEUR;
+      else minusvalenze += Math.abs(lot.gainLossEUR);
+    }
+    return {
+      method,
+      taxYear,
+      plusvalenze: roundHalfUp(plusvalenze),
+      minusvalenze: roundHalfUp(minusvalenze),
+      netResult: roundHalfUp(plusvalenze - minusvalenze),
+      lots: matchedLots,
+      ratesUsed,
+      warnings,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/cli/renderer.ts
+var SEPARATOR = "\u2500".repeat(72);
+function formatEUR(amount, locale) {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(amount);
+}
+function formatGainLoss(amount, locale) {
+  const formatted = formatEUR(Math.abs(amount), locale);
+  return amount >= 0 ? `+${formatted}` : `-${formatted}`;
+}
+function renderReport(report, s) {
+  const fmt = (n) => formatEUR(n, s.numberLocale);
+  const lines = [];
+  lines.push(
+    `${s.headerMethod}: ${report.method} | ${s.headerTaxYear}: ${report.taxYear}`
+  );
+  lines.push("");
+  const headers = [
+    s.headerIsin.padEnd(14),
+    s.headerProduct.padEnd(20),
+    s.headerQty.padStart(5),
+    s.headerBuyDate.padEnd(12),
+    s.headerSellDate.padEnd(12),
+    s.headerBuyEur.padStart(14),
+    s.headerSellEur.padStart(13),
+    s.headerGainLoss.padStart(17)
+  ].join("  ");
+  lines.push(headers);
+  for (const lot of report.lots) {
+    const row = [
+      lot.isin.padEnd(14),
+      lot.product.substring(0, 20).padEnd(20),
+      String(lot.quantity).padStart(5),
+      lot.buyDate.padEnd(12),
+      lot.sellDate.padEnd(12),
+      fmt(lot.buyCostEUR).padStart(14),
+      fmt(lot.sellProceedsEUR).padStart(13),
+      formatGainLoss(lot.gainLossEUR, s.numberLocale).padStart(17)
+    ].join("  ");
+    lines.push(row);
+  }
+  lines.push("");
+  lines.push(SEPARATOR);
+  lines.push(`${s.summaryPlusvalenze}:    ${fmt(report.plusvalenze)} EUR`);
+  lines.push(`${s.summaryMinusvalenze}:  ${fmt(report.minusvalenze)} EUR`);
+  lines.push(`${s.summaryNetResult}: ${fmt(report.netResult)} EUR`);
+  lines.push("");
+  lines.push(`${s.summaryWarnings}: ${report.warnings.length}`);
+  lines.push(`${s.summaryGenerated}: ${report.generatedAt}`);
+  lines.push("");
+  lines.push(s.disclaimer);
+  return lines.join("\n");
+}
+
+// src/cli/commands/calc.ts
+async function runCalc(positional, flags, s, stdout, stderr) {
+  const filePath = positional[0];
+  if (!filePath) {
+    stderr.write(
+      "Usage: minus-tracker calc [--method LIFO|FIFO] [--json] <file.csv>\n"
+    );
+    return 2;
+  }
+  let csv;
+  try {
+    csv = fs3.readFileSync(filePath, "utf8");
+  } catch {
+    stderr.write(`Cannot read file: ${filePath}
+`);
+    return 1;
+  }
+  const method = flags["method"] ?? "LIFO";
+  if (method !== "LIFO" && method !== "FIFO") {
+    stderr.write("--method must be LIFO or FIFO\n");
+    return 2;
+  }
+  const parser = new DEGIROParser();
+  let transactions;
+  try {
+    transactions = parser.parse(csv);
+  } catch (err) {
+    if (err instanceof ParseError) {
+      if (err.code === "INVALID_CSV") {
+        stderr.write(s.errorInvalidCsv + "\n");
+      } else {
+        stderr.write(s.errorMissingColumn(err.columnName) + "\n");
+      }
+      return 1;
+    }
+    throw err;
+  }
+  const calculator = new Calculator(transactions, parser.warnings);
+  const report = calculator.calculateGains(method);
+  if (flags["json"]) {
+    stdout.write(JSON.stringify(report, null, 2) + "\n");
+  } else {
+    stdout.write(renderReport(report, s) + "\n");
+  }
+  return 0;
+}
+
+// src/cli/commands/validate.ts
+import * as fs4 from "fs";
+async function runValidate(positional, flags, s, stdout, stderr) {
+  const filePath = positional[0];
+  if (!filePath) {
+    stderr.write("Usage: minus-tracker validate <file.csv>\n");
+    return 2;
+  }
+  let csv;
+  try {
+    csv = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    stderr.write(`Cannot read file: ${filePath}
+`);
+    return 1;
+  }
+  const parser = new DEGIROParser();
+  let transactions;
+  try {
+    transactions = parser.parse(csv);
+  } catch (err) {
+    if (err instanceof ParseError) {
+      if (err.code === "INVALID_CSV") {
+        stderr.write(s.errorInvalidCsv + "\n");
+      } else {
+        stderr.write(s.errorMissingColumn(err.columnName) + "\n");
+      }
+      return 1;
+    }
+    throw err;
+  }
+  stdout.write(s.validateOk(transactions.length, 0) + "\n");
+  for (const entry of parser.warningEntries) {
+    let reason;
+    switch (entry.code) {
+      case "MISSING_ISIN":
+        reason = s.warnMissingIsin(entry.row);
+        break;
+      case "UNSUPPORTED_CURRENCY":
+        reason = s.warnUnsupportedCurrency(entry.row, entry.currency);
+        break;
+      case "NO_ECB_RATE":
+        reason = s.warnNoEcbRate(entry.row, entry.currency, entry.date);
+        break;
+      case "QUANTITY_ZERO":
+        reason = s.warnQuantityZero(entry.row);
+        break;
+    }
+    stdout.write(reason + "\n");
+  }
+  return 0;
+}
+
+// src/cli/commands/rates.ts
+import * as fs5 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+import * as https from "https";
+function getSnapshotPath() {
+  const platform = process.platform;
+  let configDir;
+  if (platform === "win32") {
+    configDir = process.env.APPDATA ?? path3.join(os2.homedir(), "AppData", "Roaming");
+  } else {
+    configDir = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
+  }
+  return path3.join(configDir, "minus-tracker", "ecb-rates.json");
+}
+function getCoverage(snapshot) {
+  let start = "9999-12-31";
+  let end = "0000-01-01";
+  const currencies = [];
+  for (const [ccy, dates] of Object.entries(snapshot)) {
+    currencies.push(ccy);
+    for (const d of Object.keys(dates)) {
+      if (d < start) start = d;
+      if (d > end) end = d;
+    }
+  }
+  return { start, end, currencies: currencies.sort().join(", ") };
+}
+async function fetchEcbData(currency) {
+  return new Promise((resolve, reject) => {
+    const url = `https://data-api.ecb.europa.eu/service/data/EXR/D.${currency}.EUR.SP00.A?format=csvdata&startPeriod=2019-01-01`;
+    https.get(url, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        const rates = {};
+        const lines = data.split("\n");
+        for (const line of lines) {
+          const dateMatch = line.match(
+            /^(\d{4}-\d{2}-\d{2}),.*?,.*?,.*?,.*?,([\d.]+)/
+          );
+          if (dateMatch) {
+            rates[dateMatch[1]] = parseFloat(dateMatch[2]);
+          }
+        }
+        resolve(rates);
+      });
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+async function runRates(positional, flags, s, stdout, stderr) {
+  if (flags["check"]) {
+    const snapshot = getActiveSnapshot();
+    const { start, end, currencies } = getCoverage(snapshot);
+    stdout.write(s.ratesCoverage(start, end, currencies) + "\n");
+    stdout.write(s.ratesGapsNone + "\n");
+    return 0;
+  }
+  if (flags["update"]) {
+    stdout.write(s.ratesUpdateFetching + "\n");
+    const snapshotPath = getSnapshotPath();
+    let existing = {};
+    try {
+      existing = JSON.parse(
+        fs5.readFileSync(snapshotPath, "utf8")
+      );
+    } catch {
+    }
+    let addedCount = 0;
+    for (const currency of ["USD", "GBP", "CHF"]) {
+      try {
+        const newRates = await fetchEcbData(currency);
+        const existing_ccy = existing[currency] ?? {};
+        let added = 0;
+        for (const [date, rate] of Object.entries(newRates)) {
+          if (!existing_ccy[date]) added++;
+          existing_ccy[date] = rate;
+        }
+        existing[currency] = existing_ccy;
+        addedCount += added;
+      } catch {
+        stderr.write(`Failed to fetch ${currency} rates
+`);
+      }
+    }
+    fs5.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
+    fs5.writeFileSync(
+      snapshotPath,
+      JSON.stringify(existing, null, 2) + "\n",
+      "utf8"
+    );
+    stdout.write(s.ratesUpdateDone(addedCount) + "\n");
+    stdout.write(s.ratesSnapshotWritten(snapshotPath) + "\n");
+    return 0;
+  }
+  stderr.write("Usage: minus-tracker rates --check | --update\n");
+  return 2;
+}
+
+// src/cli/commands/config.ts
+var SUPPORTED_LOCALES2 = ["it", "en"];
+async function runConfig(positional, flags, s, stdout, stderr) {
+  if (flags["lang"] !== void 0) {
+    const lang = flags["lang"];
+    if (!SUPPORTED_LOCALES2.includes(lang)) {
+      stderr.write(`Unsupported locale "${lang}". Use: it, en
+`);
+      return 2;
+    }
+    saveLocale(lang);
+    stdout.write(s.configLangSet(lang) + "\n");
+    return 0;
+  }
+  if (flags["show"]) {
+    const locale = resolveLocale();
+    stdout.write(s.configCurrentLang(locale) + "\n");
+    return 0;
+  }
+  stderr.write("Usage: minus-tracker config --lang <it|en> | --show\n");
+  return 2;
+}
+
+// src/cli/index.ts
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      lang: { type: "string" },
+      method: { type: "string" },
+      year: { type: "string" },
+      json: { type: "boolean", default: false },
+      check: { type: "boolean", default: false },
+      update: { type: "boolean", default: false },
+      show: { type: "boolean", default: false }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const locale = resolveLocale(values.lang);
+  const s = getStrings(locale);
+  const command = positionals[0];
+  const restPositionals = positionals.slice(1);
+  const flags = values;
+  const stdout = process.stdout;
+  const stderr = process.stderr;
+  let exitCode = 0;
+  try {
+    switch (command) {
+      case "calc":
+        exitCode = await runCalc(restPositionals, flags, s, stdout, stderr);
+        break;
+      case "validate":
+        exitCode = await runValidate(restPositionals, flags, s, stdout, stderr);
+        break;
+      case "rates":
+        exitCode = await runRates(restPositionals, flags, s, stdout, stderr);
+        break;
+      case "config":
+        exitCode = await runConfig(restPositionals, flags, s, stdout, stderr);
+        break;
+      default:
+        stderr.write(
+          "Usage: minus-tracker <calc|validate|rates|config> [options] [file]\n"
+        );
+        exitCode = 2;
+    }
+  } catch (err) {
+    if (err instanceof ParseError) {
+      if (err.code === "INVALID_CSV") {
+        stderr.write(s.errorInvalidCsv + "\n");
+      } else {
+        stderr.write(s.errorMissingColumn(err.columnName) + "\n");
+      }
+      exitCode = 1;
+    } else if (err instanceof CalculationError) {
+      stderr.write(s.errorNoOpenLots(err.isin, err.date) + "\n");
+      exitCode = 1;
+    } else {
+      throw err;
+    }
+  }
+  process.exit(exitCode);
+}
+main().catch((err) => {
+  process.stderr.write(`Unhandled error: ${String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map