@gabrielerandelli/minus-tracker 0.5.8 → 0.6.0

package/dist/cli/index.js

@@ -36,11 +36,34 @@ var it = {
   ratesGaps: (list) => `Lacune: ${list}`,
   ratesUpdateFetching: "Recupero dati BCE SDMX in corso...",
   ratesUpdateDone: (n) => `Completato. Aggiunte ${n} nuove date.`,
-  ratesSnapshotWritten: (path5) => `Snapshot scritto in ${path5}`,
+  ratesSnapshotWritten: (path7) => `Snapshot scritto in ${path7}`,
   ratesAutoUpdateStart: "Le rate BCE non sono aggiornate. Aggiornamento automatico in corso...",
   ratesAutoUpdateFailed: "Aggiornamento automatico fallito. Si procede con le rate disponibili.",
   configLangSet: (lang) => `Lingua impostata su: ${lang}`,
   configCurrentLang: (lang) => `Lingua corrente: ${lang}`,
+  classifyStarting: (n) => `Classificazione ISIN in corso... (${n} strumenti)`,
+  classifyDetected: (isin, product, bucket, rate) => `Rilevato: ${product} (${isin}) \u2192 ${bucket} | ${rate}`,
+  classifyConfirm: "[Y/n/?]: ",
+  classifyOverridePrompt: "Tipo di strumento:",
+  classifyDone: (confirmed, total) => `Classificazione completata (${confirmed}/${total} confermati).`,
+  classifyWritten: (path7) => `Scritto: ${path7}`,
+  classifyMergePrompt: (existing) => `File gi\xE0 esistente (${existing} ISIN confermati). Aggiungere i nuovi ISIN? [Y/n]: `,
+  classifyOfflineWarning: "Modalit\xE0 offline: ricerca OpenFIGI saltata.",
+  classifyUnknownType: (type) => `Tipo non riconosciuto: ${type}. Classificare manualmente.`,
+  classifyNonTtyError: "Modalit\xE0 interattiva richiede un terminale (TTY). Usa --offline per classificare senza terminale.",
+  bucketAHeader: "BUCKET A \u2014 REDDITI DA CAPITALE (non compensabili)",
+  bucketBHeader: "BUCKET B \u2014 REDDITI DIVERSI",
+  bucketAEtf: "ETF (OICR)",
+  bucketABtpWl: "BTP/WL",
+  bucketATotalTax: "TOTALE IMPOSTA",
+  bucketBCarryApplied: (year) => `RIPORTO ${year}`,
+  bucketBResult: "RISULTATO",
+  bucketBCarryNote: "(riportabile ai prossimi 4 anni)",
+  warnMixedBuckets: "Le perdite in Bucket B non compensano le plusvalenze in Bucket A.",
+  warnMixedAssets: "AVVISO: CSV contiene tipi di strumenti misti (es. ETF + Azioni).\n   Il calcolo a bucket unico pu\xF2 non essere fiscalmente corretto.\n   Esegui: minus-tracker classify trades.csv",
+  headerBucket: "BUCKET",
+  warnUnclassifiedIsin: (isin) => `ISIN ${isin} non trovato nella mappa di classificazione \u2014 assegnato a Bucket B.`,
+  carryForwardInvalidFormat: "Formato --carry-forward non valido. Usa: AAAA:importo (es. 2023:2500)",
   disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
 };
 
@@ -77,11 +100,34 @@ var en = {
   ratesGaps: (list) => `Gaps: ${list}`,
   ratesUpdateFetching: "Fetching ECB SDMX...",
   ratesUpdateDone: (n) => `Done. Added ${n} new dates.`,
-  ratesSnapshotWritten: (path5) => `Snapshot written to ${path5}`,
+  ratesSnapshotWritten: (path7) => `Snapshot written to ${path7}`,
   ratesAutoUpdateStart: "ECB rates are stale. Auto-updating\u2026",
   ratesAutoUpdateFailed: "Auto-update failed. Proceeding with available rates.",
   configLangSet: (lang) => `Language set to: ${lang}`,
   configCurrentLang: (lang) => `Current language: ${lang}`,
+  classifyStarting: (n) => `Classifying ISINs... (${n} instruments)`,
+  classifyDetected: (isin, product, bucket, rate) => `Detected: ${product} (${isin}) \u2192 ${bucket} | ${rate}`,
+  classifyConfirm: "[Y/n/?]: ",
+  classifyOverridePrompt: "Instrument type:",
+  classifyDone: (confirmed, total) => `Classification complete (${confirmed}/${total} confirmed).`,
+  classifyWritten: (path7) => `Written: ${path7}`,
+  classifyMergePrompt: (existing) => `File already exists (${existing} confirmed ISINs). Add new ISINs? [Y/n]: `,
+  classifyOfflineWarning: "Offline mode: OpenFIGI lookup skipped.",
+  classifyUnknownType: (type) => `Unrecognized type: ${type}. Please classify manually.`,
+  classifyNonTtyError: "Interactive mode requires a TTY. Use --offline to classify without a terminal.",
+  bucketAHeader: "BUCKET A \u2014 CAPITAL INCOME (non-offsettable)",
+  bucketBHeader: "BUCKET B \u2014 MISCELLANEOUS INCOME",
+  bucketAEtf: "ETF (OICR)",
+  bucketABtpWl: "Govt Bond WL",
+  bucketATotalTax: "TOTAL TAX",
+  bucketBCarryApplied: (year) => `CARRY ${year}`,
+  bucketBResult: "RESULT",
+  bucketBCarryNote: "(carriable over the next 4 years)",
+  warnMixedBuckets: "Bucket B losses do not offset Bucket A plusvalenze.",
+  warnMixedAssets: "WARNING: CSV contains mixed instrument types (e.g. ETFs + Stocks).\n   Single-bucket calculation may not be fiscally correct.\n   Run: minus-tracker classify trades.csv",
+  headerBucket: "BUCKET",
+  warnUnclassifiedIsin: (isin) => `ISIN ${isin} not found in classification map \u2014 assigned to Bucket B.`,
+  carryForwardInvalidFormat: "Invalid --carry-forward format. Use: YYYY:amount (e.g. 2023:2500)",
   disclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale."
 };
 
@@ -165,9 +211,21 @@ var CalculationError = class extends Error {
     this.date = date;
   }
 };
+var ClassificationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(
+      message ?? (code === "SIDECAR_NOT_FOUND" ? "Sidecar file not found" : code === "SIDECAR_VERSION" ? "Sidecar version mismatch" : code === "SIDECAR_MALFORMED" ? "Sidecar file is malformed JSON" : code === "NETWORK_ERROR" ? "Network error contacting OpenFIGI" : "Failed to write sidecar file")
+    );
+    this.name = "ClassificationError";
+    this.code = code;
+  }
+};
 
 // src/cli/commands/calc.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
 
 // src/rates/index.ts
 import { fileURLToPath } from "url";
@@ -453,13 +511,11 @@ function inferTaxYear(transactions) {
 var Calculator = class {
   _transactions;
   _parseWarnings;
-  /**
-   * @param transactions - Normalised Transaction objects from the CSV import step.
-   * @param parseWarnings - Warnings collected during the import step; forwarded into the report.
-   */
-  constructor(transactions, parseWarnings) {
+  _options;
+  constructor(transactions, parseWarnings, options) {
     this._transactions = transactions;
     this._parseWarnings = parseWarnings ?? [];
+    this._options = options ?? {};
   }
   /**
    * Run LIFO or FIFO lot-matching over the transaction list.
@@ -553,6 +609,104 @@ var Calculator = class {
       if (lot.gainLossEUR > 0) plusvalenze += lot.gainLossEUR;
       else minusvalenze += Math.abs(lot.gainLossEUR);
     }
+    if (this._options.classification) {
+      const classification = this._options.classification;
+      const unclassifiedIsins = /* @__PURE__ */ new Set();
+      for (const lot of matchedLots) {
+        const entry = classification[lot.isin];
+        if (!entry) {
+          lot.bucket = "B";
+          unclassifiedIsins.add(lot.isin);
+        } else if (entry.bucketGain === "A" && lot.gainLossEUR >= 0) {
+          lot.bucket = "A";
+        } else {
+          lot.bucket = "B";
+        }
+      }
+      for (const isin of unclassifiedIsins) {
+        warnings.push(
+          `ISIN ${isin} not found in classification map \u2014 assigned to Bucket B.`
+        );
+      }
+      const bucketALots = matchedLots.filter((l) => l.bucket === "A");
+      const groupsByRate = /* @__PURE__ */ new Map();
+      for (const lot of bucketALots) {
+        const entry = classification[lot.isin];
+        const rate = entry.taxRate;
+        if (!groupsByRate.has(rate))
+          groupsByRate.set(rate, { assetClasses: /* @__PURE__ */ new Set(), plusvalenze: 0 });
+        const g = groupsByRate.get(rate);
+        g.assetClasses.add(entry.assetClass);
+        g.plusvalenze += lot.gainLossEUR;
+      }
+      const bucketAGroups = [...groupsByRate.entries()].map(([taxRate, g]) => ({
+        taxRate,
+        assetClasses: [...g.assetClasses],
+        plusvalenze: roundHalfUp(g.plusvalenze),
+        imposta: roundHalfUp(g.plusvalenze * taxRate)
+      }));
+      const bucketAReport = {
+        groups: bucketAGroups,
+        totalImposta: roundHalfUp(
+          bucketAGroups.reduce((s, g) => s + g.imposta, 0)
+        )
+      };
+      const bucketBLots = matchedLots.filter((l) => l.bucket === "B");
+      let bPlusvalenze = 0;
+      let bMinusvalenze = 0;
+      for (const lot of bucketBLots) {
+        if (lot.gainLossEUR >= 0) bPlusvalenze += lot.gainLossEUR;
+        else bMinusvalenze += Math.abs(lot.gainLossEUR);
+      }
+      bPlusvalenze = roundHalfUp(bPlusvalenze);
+      bMinusvalenze = roundHalfUp(bMinusvalenze);
+      const carryForwards = [...this._options.carryForward ?? []].sort(
+        (a, b) => a.year - b.year
+      );
+      let remaining = bPlusvalenze - bMinusvalenze;
+      let carryForwardApplied = 0;
+      for (const entry of carryForwards) {
+        if (taxYear - entry.year > 4) continue;
+        if (remaining <= 0) break;
+        const consumed = Math.min(entry.amount, remaining);
+        carryForwardApplied += consumed;
+        remaining -= consumed;
+      }
+      carryForwardApplied = roundHalfUp(carryForwardApplied);
+      const bNetResult = roundHalfUp(
+        bPlusvalenze - bMinusvalenze - carryForwardApplied
+      );
+      const carryForwardRemaining = roundHalfUp(Math.max(0, -bNetResult));
+      const bucketBReport = {
+        plusvalenze: bPlusvalenze,
+        minusvalenze: bMinusvalenze,
+        carryForwardApplied,
+        carryForwardRemaining,
+        netResult: bNetResult
+      };
+      return {
+        method,
+        taxYear,
+        plusvalenze: roundHalfUp(plusvalenze),
+        minusvalenze: roundHalfUp(minusvalenze),
+        netResult: roundHalfUp(plusvalenze - minusvalenze),
+        lots: matchedLots,
+        ratesUsed,
+        warnings,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        bucketA: bucketAGroups.length > 0 ? bucketAReport : void 0,
+        bucketB: bucketBReport
+      };
+    } else {
+      const allIsins = [...new Set(this._transactions.map((t) => t.isin))];
+      const hasIePrefix = allIsins.some((isin) => isin.startsWith("IE"));
+      const hasOther = allIsins.some((isin) => !isin.startsWith("IE"));
+      if (hasIePrefix && hasOther) {
+        warnings.push(
+          "AVVISO: CSV contiene tipi di strumenti misti (es. ETF + Azioni).\n   Il calcolo a bucket unico pu\xF2 non essere fiscalmente corretto.\n   Esegui: minus-tracker classify trades.csv"
+        );
+      }
+    }
     return {
       method,
       taxYear,
@@ -567,6 +721,352 @@ var Calculator = class {
   }
 };
 
+// src/classifier/index.ts
+import * as fs3 from "fs";
+import * as https from "https";
+function httpsPost(url, body, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const u = new URL(url);
+    const req = https.request(
+      {
+        hostname: u.hostname,
+        path: u.pathname + u.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        }
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve2({ status: res.statusCode ?? 0, data }));
+      }
+    );
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+var GOVT_BOND_WHITELIST = /* @__PURE__ */ new Set([
+  "IT",
+  "DE",
+  "FR",
+  "AT",
+  "BE",
+  "NL",
+  "ES",
+  "PT",
+  "FI",
+  "IE",
+  "LU",
+  "GR",
+  "SK",
+  "SI",
+  "LT",
+  "LV",
+  "EE",
+  "MT",
+  "CY",
+  "US",
+  "GB",
+  "CH",
+  "NO",
+  "SE",
+  "DK",
+  "JP",
+  "CA",
+  "AU",
+  "NZ",
+  "SG",
+  "HK",
+  "KR"
+]);
+var SECURITY_TYPE_MAP = {
+  ETP: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  ETF: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  "Mutual Fund": {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  "Open-End Fund": {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  "Common Stock": {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Equity: {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Exchange Traded Commodity": {
+    assetClass: "ETC",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Corporate Bond": {
+    assetClass: "CorpBond",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Option: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Future: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Warrant: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  CFD: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Swap: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Leverage Certificate": {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Turbo Certificate": {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  "Capital Protected Certificate": {
+    assetClass: "CapProtectedCert",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  }
+};
+function isKnownType(t) {
+  return t === "Government Bond" || t in SECURITY_TYPE_MAP;
+}
+function classifyByType(isin, securityType, product, warnings) {
+  if (securityType === "Government Bond") {
+    const prefix = isin.slice(0, 2).toUpperCase();
+    const whiteListed = GOVT_BOND_WHITELIST.has(prefix);
+    return {
+      product,
+      assetClass: whiteListed ? "GovtBondWL" : "GovtBondOther",
+      bucketGain: "A",
+      bucketLoss: "B",
+      taxRate: whiteListed ? 0.125 : 0.26,
+      whiteListed,
+      confirmedByUser: false,
+      source: "openfigi"
+    };
+  }
+  const mapped = SECURITY_TYPE_MAP[securityType];
+  if (mapped) {
+    return {
+      product,
+      assetClass: mapped.assetClass,
+      bucketGain: mapped.bucketGain,
+      bucketLoss: mapped.bucketLoss,
+      taxRate: mapped.taxRate,
+      whiteListed: mapped.whiteListed,
+      confirmedByUser: false,
+      source: "openfigi"
+    };
+  }
+  warnings.push(
+    `Unrecognized type: ${securityType}. Please classify manually.`
+  );
+  return {
+    product,
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null,
+    confirmedByUser: false,
+    source: "user"
+  };
+}
+var Classifier = class {
+  interactive;
+  constructor(options) {
+    this.interactive = options?.interactive ?? true;
+  }
+  async load(sidecarPath) {
+    if (!fs3.existsSync(sidecarPath)) {
+      throw new ClassificationError("SIDECAR_NOT_FOUND");
+    }
+    let parsed;
+    try {
+      const raw = fs3.readFileSync(sidecarPath, "utf-8");
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new ClassificationError("SIDECAR_MALFORMED");
+    }
+    if (typeof parsed !== "object" || parsed === null || parsed["version"] !== 1) {
+      throw new ClassificationError("SIDECAR_VERSION");
+    }
+    return parsed.classifications;
+  }
+  async classify(transactions, sidecarPath, _httpPost = httpsPost) {
+    const isinToProduct = /* @__PURE__ */ new Map();
+    for (const tx of transactions) {
+      if (tx.isin && !isinToProduct.has(tx.isin)) {
+        isinToProduct.set(tx.isin, tx.product);
+      }
+    }
+    const confirmed = {};
+    if (fs3.existsSync(sidecarPath)) {
+      const existingMap = await this.load(sidecarPath);
+      for (const [isin, entry] of Object.entries(existingMap)) {
+        if (entry.confirmedByUser) {
+          confirmed[isin] = entry;
+        }
+      }
+    }
+    const toProcess = [];
+    for (const isin of isinToProduct.keys()) {
+      if (!(isin in confirmed)) {
+        toProcess.push(isin);
+      }
+    }
+    const warnings = [];
+    const newEntries = {};
+    const BATCH_SIZE = 10;
+    for (let i = 0; i < toProcess.length; i += BATCH_SIZE) {
+      if (i > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, 6e3));
+      }
+      const batch = toProcess.slice(i, i + BATCH_SIZE);
+      const requestBody = JSON.stringify(
+        batch.map((isin) => ({ idType: "ID_ISIN", idValue: isin }))
+      );
+      let response = null;
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          const r = await _httpPost(
+            "https://api.openfigi.com/v3/mapping",
+            requestBody,
+            1e4
+          );
+          if (r.status < 500) {
+            response = r;
+            break;
+          }
+        } catch {
+          throw new ClassificationError("NETWORK_ERROR");
+        }
+      }
+      if (response === null) {
+        throw new ClassificationError("NETWORK_ERROR");
+      }
+      const results = JSON.parse(response.data);
+      for (let j = 0; j < batch.length; j++) {
+        const isin = batch[j];
+        const result = results[j];
+        const product = isinToProduct.get(isin) ?? isin;
+        if (!result || result.error || !result.data || result.data.length === 0) {
+          warnings.push(
+            `Unrecognized type: unknown. Please classify manually.`
+          );
+          newEntries[isin] = {
+            product,
+            assetClass: "Stock",
+            bucketGain: "B",
+            bucketLoss: "B",
+            taxRate: 0,
+            whiteListed: null,
+            confirmedByUser: false,
+            source: "user"
+          };
+          continue;
+        }
+        const st = result.data[0]?.securityType;
+        const st2 = result.data[0]?.securityType2;
+        const typeToUse = st && isKnownType(st) ? st : st2 && isKnownType(st2) ? st2 : st ?? st2 ?? "Unknown";
+        newEntries[isin] = classifyByType(isin, typeToUse, product, warnings);
+      }
+    }
+    const mergedMap = { ...newEntries, ...confirmed };
+    const sidecarContent = JSON.stringify(
+      {
+        version: 1,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        classifications: mergedMap,
+        warnings
+      },
+      null,
+      2
+    );
+    try {
+      fs3.writeFileSync(sidecarPath, sidecarContent, "utf-8");
+    } catch {
+      throw new ClassificationError("WRITE_ERROR");
+    }
+    return mergedMap;
+  }
+};
+
 // src/cli/renderer.ts
 var SEPARATOR = "\u2500".repeat(72);
 function formatEUR(amount, locale) {
@@ -579,14 +1079,26 @@ function formatGainLoss(amount, locale) {
   const formatted = formatEUR(Math.abs(amount), locale);
   return amount >= 0 ? `+${formatted}` : `-${formatted}`;
 }
+function assetClassLabel(ac, s) {
+  if (ac === "ETF") return s.bucketAEtf;
+  if (ac === "GovtBondWL" || ac === "GovtBondOther") return s.bucketABtpWl;
+  return ac;
+}
 function renderReport(report, s) {
   const fmt = (n) => formatEUR(n, s.numberLocale);
   const lines = [];
+  const hasBuckets = !!(report.bucketA || report.bucketB);
   lines.push(
     `${s.headerMethod}: ${report.method} | ${s.headerTaxYear}: ${report.taxYear}`
   );
   lines.push("");
-  const headers = [
+  for (const w of report.warnings) {
+    if (w.startsWith("AVVISO:") || w.startsWith("WARNING:")) {
+      lines.push(w);
+      lines.push("");
+    }
+  }
+  const headerCols = [
     s.headerIsin.padEnd(14),
     s.headerProduct.padEnd(20),
     s.headerQty.padStart(5),
@@ -595,10 +1107,13 @@ function renderReport(report, s) {
     s.headerBuyEur.padStart(14),
     s.headerSellEur.padStart(13),
     s.headerGainLoss.padStart(17)
-  ].join("  ");
-  lines.push(headers);
+  ];
+  if (hasBuckets) {
+    headerCols.push(s.headerBucket.padStart(8));
+  }
+  lines.push(headerCols.join("  "));
   for (const lot of report.lots) {
-    const row = [
+    const rowCols = [
       lot.isin.padEnd(14),
       lot.product.substring(0, 20).padEnd(20),
       String(lot.quantity).padStart(5),
@@ -607,8 +1122,11 @@ function renderReport(report, s) {
       fmt(lot.buyCostEUR).padStart(14),
       fmt(lot.sellProceedsEUR).padStart(13),
       formatGainLoss(lot.gainLossEUR, s.numberLocale).padStart(17)
-    ].join("  ");
-    lines.push(row);
+    ];
+    if (hasBuckets) {
+      rowCols.push((lot.bucket ?? "").padStart(8));
+    }
+    lines.push(rowCols.join("  "));
   }
   lines.push("");
   lines.push(SEPARATOR);
@@ -619,15 +1137,51 @@ function renderReport(report, s) {
   lines.push(`${s.summaryWarnings}: ${report.warnings.length}`);
   lines.push(`${s.summaryGenerated}: ${report.generatedAt}`);
   lines.push("");
+  if (report.bucketA && report.bucketA.groups.length > 0) {
+    lines.push(SEPARATOR);
+    lines.push(s.bucketAHeader);
+    lines.push(SEPARATOR);
+    for (const g of report.bucketA.groups) {
+      const label = g.assetClasses.map((ac) => assetClassLabel(ac, s)).join(", ");
+      const rateDisplay = (g.taxRate * 100).toFixed(0);
+      lines.push(
+        `${label}: ${fmt(g.plusvalenze)} EUR \u2192 imposta: ${fmt(g.imposta)} EUR (${rateDisplay}%)`
+      );
+    }
+    lines.push(`${s.bucketATotalTax}: ${fmt(report.bucketA.totalImposta)} EUR`);
+    lines.push("");
+  }
+  if (report.bucketB) {
+    lines.push(SEPARATOR);
+    lines.push(s.bucketBHeader);
+    lines.push(SEPARATOR);
+    lines.push(`PLUSVALENZE: ${fmt(report.bucketB.plusvalenze)} EUR`);
+    lines.push(`MINUSVALENZE: ${fmt(report.bucketB.minusvalenze)} EUR`);
+    if (report.bucketB.carryForwardApplied > 0) {
+      lines.push(
+        `${s.bucketBCarryApplied(0)}: ${fmt(report.bucketB.carryForwardApplied)} EUR`
+      );
+    }
+    let resultLine = `${s.bucketBResult}: ${fmt(report.bucketB.netResult)} EUR`;
+    if (report.bucketB.carryForwardRemaining > 0) {
+      resultLine += ` ${s.bucketBCarryNote}`;
+    }
+    lines.push(resultLine);
+    lines.push("");
+  }
+  if (hasBuckets) {
+    lines.push(s.warnMixedBuckets);
+    lines.push("");
+  }
   lines.push(s.disclaimer);
   return lines.join("\n");
 }
 
 // src/cli/commands/rates.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path3 from "path";
 import * as os2 from "os";
-import * as https from "https";
+import * as https2 from "https";
 function getSnapshotPath() {
   const platform = process.platform;
   let configDir;
@@ -652,9 +1206,9 @@ function getCoverage(snapshot) {
   return { start, end, currencies: currencies.sort().join(", ") };
 }
 async function fetchEcbData(currency) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, 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) => {
+    https2.get(url, (res) => {
       let data = "";
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
@@ -669,7 +1223,7 @@ async function fetchEcbData(currency) {
             rates[date] = rate;
           }
         }
-        resolve(rates);
+        resolve2(rates);
       });
       res.on("error", reject);
     }).on("error", reject);
@@ -680,7 +1234,7 @@ async function updateRates(snapshotPath, stdout, stderr, s) {
   let existing = {};
   try {
     existing = JSON.parse(
-      fs3.readFileSync(snapshotPath, "utf8")
+      fs4.readFileSync(snapshotPath, "utf8")
     );
   } catch {
   }
@@ -701,8 +1255,8 @@ async function updateRates(snapshotPath, stdout, stderr, s) {
 `);
     }
   }
-  fs3.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
-  fs3.writeFileSync(
+  fs4.mkdirSync(path3.dirname(snapshotPath), { recursive: true });
+  fs4.writeFileSync(
     snapshotPath,
     JSON.stringify(existing, null, 2) + "\n",
     "utf8"
@@ -737,7 +1291,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
   }
   let csv;
   try {
-    csv = fs4.readFileSync(filePath, "utf8");
+    csv = fs5.readFileSync(filePath, "utf8");
   } catch {
     stderr.write(`Cannot read file: ${filePath}
 `);
@@ -766,6 +1320,51 @@ async function runCalc(positional, flags, s, stdout, stderr) {
     stderr.write("--method must be LIFO or FIFO\n");
     return 2;
   }
+  const sidecarPath = filePath.replace(/\.csv$/i, "") + ".classify.json";
+  let classification;
+  if (fs5.existsSync(sidecarPath)) {
+    try {
+      const classifier = new Classifier({ interactive: false });
+      classification = await classifier.load(sidecarPath);
+    } catch {
+      stderr.write(`Cannot load sidecar: ${sidecarPath}
+`);
+      return 1;
+    }
+  }
+  const rawCf = flags["carry-forward"];
+  const rawCarryForwards = Array.isArray(rawCf) ? rawCf : rawCf ? [rawCf] : [];
+  const cfRegex = /^\d{4}:\d+(\.\d+)?$/;
+  for (const cf of rawCarryForwards) {
+    if (!cfRegex.test(cf)) {
+      stderr.write(s.carryForwardInvalidFormat + "\n");
+      return 2;
+    }
+  }
+  const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? path4.join(os3.homedir(), ".config");
+  const cfConfigPath = path4.join(
+    xdgConfig,
+    "minus-tracker",
+    "carryforward.json"
+  );
+  const cfFromFile = {};
+  if (fs5.existsSync(cfConfigPath)) {
+    try {
+      const raw = JSON.parse(fs5.readFileSync(cfConfigPath, "utf-8"));
+      for (const entry of raw.losses ?? []) {
+        cfFromFile[entry.year] = entry.amount;
+      }
+    } catch {
+    }
+  }
+  const cfMerged = { ...cfFromFile };
+  for (const cf of rawCarryForwards) {
+    const [yearStr, amountStr] = cf.split(":");
+    cfMerged[parseInt(yearStr, 10)] = parseFloat(amountStr);
+  }
+  const carryForward = Object.entries(cfMerged).map(
+    ([year, amount]) => ({ year: parseInt(year, 10), amount })
+  );
   const parser = new DEGIROParser();
   let transactions;
   try {
@@ -781,7 +1380,10 @@ async function runCalc(positional, flags, s, stdout, stderr) {
     }
     throw err;
   }
-  const calculator = new Calculator(transactions, parser.warnings);
+  const calculator = new Calculator(transactions, parser.warnings, {
+    classification,
+    carryForward: carryForward.length > 0 ? carryForward : void 0
+  });
   const report = calculator.calculateGains(method);
   if (flags["json"]) {
     stdout.write(JSON.stringify(report, null, 2) + "\n");
@@ -792,7 +1394,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
 }
 
 // src/cli/commands/validate.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 async function runValidate(positional, flags, s, stdout, stderr) {
   const filePath = positional[0];
   if (!filePath) {
@@ -801,7 +1403,7 @@ async function runValidate(positional, flags, s, stdout, stderr) {
   }
   let csv;
   try {
-    csv = fs5.readFileSync(filePath, "utf8");
+    csv = fs6.readFileSync(filePath, "utf8");
   } catch {
     stderr.write(`Cannot read file: ${filePath}
 `);
@@ -868,9 +1470,9 @@ async function runConfig(positional, flags, s, stdout, stderr) {
 }
 
 // src/cli/commands/stress-test.ts
-import * as fs6 from "fs";
-import * as path4 from "path";
-import * as os3 from "os";
+import * as fs7 from "fs";
+import * as path5 from "path";
+import * as os4 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawnSync as spawnSync2 } from "child_process";
 
@@ -948,8 +1550,8 @@ function generateCsv(scenario) {
 
 // src/stress/runner.ts
 import { spawnSync } from "child_process";
-import { writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 function countWarnings(text) {
   if (!text) return 0;
   const match = text.match(/(?:warnings|avvertenze)\s*:\s*(\d+)/i);
@@ -1002,8 +1604,8 @@ function runCommand(cliBin, args, cmdLabel, expectedExitCode, outputShapeCheck)
 }
 function runScenario(scenario, csvContent, outputDir, cliBin) {
   const csvFileName = `${scenario.id}-${scenario.slug}.csv`;
-  const csvFile = join4(outputDir, csvFileName);
-  writeFileSync3(csvFile, csvContent, "utf8");
+  const csvFile = join5(outputDir, csvFileName);
+  writeFileSync4(csvFile, csvContent, "utf8");
   const results = [];
   results.push(
     runCommand(
@@ -1213,11 +1815,11 @@ async function runStressTest(_positionals, flags, stdout, stderr) {
     );
     return 2;
   }
-  const __dirname = path4.dirname(fileURLToPath2(import.meta.url));
-  const manifestPath = path4.join(__dirname, "../data/stress-manifest.json");
+  const __dirname = path5.dirname(fileURLToPath2(import.meta.url));
+  const manifestPath = path5.join(__dirname, "../data/stress-manifest.json");
   let manifest;
   try {
-    const raw = fs6.readFileSync(manifestPath, "utf8");
+    const raw = fs7.readFileSync(manifestPath, "utf8");
     manifest = JSON.parse(raw);
   } catch {
     stderr.write(`Error: could not load stress manifest at ${manifestPath}
@@ -1229,9 +1831,9 @@ async function runStressTest(_positionals, flags, stdout, stderr) {
   const outputDirFlag = flags["output-dir"];
   if (outputDirFlag) {
     outputDir = outputDirFlag;
-    fs6.mkdirSync(outputDir, { recursive: true });
+    fs7.mkdirSync(outputDir, { recursive: true });
   } else {
-    outputDir = fs6.mkdtempSync(path4.join(os3.tmpdir(), "minus-tracker-stress-"));
+    outputDir = fs7.mkdtempSync(path5.join(os4.tmpdir(), "minus-tracker-stress-"));
   }
   const ratesCheck = spawnSync2("node", [cliBin, "rates", "--check"], {
     encoding: "utf8",
@@ -1268,11 +1870,122 @@ async function runStressTest(_positionals, flags, stdout, stderr) {
     stdout.write(formatTable(report) + "\n");
   }
   if (!flags["keep"]) {
-    fs6.rmSync(outputDir, { recursive: true, force: true });
+    fs7.rmSync(outputDir, { recursive: true, force: true });
   }
   return report.failed === 0 ? 0 : 1;
 }
 
+// src/cli/commands/classify.ts
+import * as fs8 from "fs";
+import * as path6 from "path";
+async function runClassify(positional, flags, s, stdout, stderr) {
+  const offline = Boolean(flags["offline"]);
+  if (!process.stdin.isTTY && !offline) {
+    stderr.write(s.classifyNonTtyError + "\n");
+    return 2;
+  }
+  const csvPath = positional[0];
+  if (!csvPath) {
+    stderr.write("Usage: minus-tracker classify [--offline] <file.csv>\n");
+    return 2;
+  }
+  let csv;
+  try {
+    csv = fs8.readFileSync(csvPath, "utf8");
+  } catch {
+    stderr.write(`Cannot read file: ${csvPath}
+`);
+    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;
+  }
+  const base = csvPath.replace(/\.csv$/i, "");
+  const sidecarPath = base + ".classify.json";
+  if (offline) {
+    stdout.write(s.classifyOfflineWarning + "\n");
+    const isinToProduct = /* @__PURE__ */ new Map();
+    for (const tx of transactions) {
+      if (tx.isin && !isinToProduct.has(tx.isin)) {
+        isinToProduct.set(tx.isin, tx.product);
+      }
+    }
+    const classifications = {};
+    for (const [isin, product] of isinToProduct.entries()) {
+      classifications[isin] = {
+        product,
+        assetClass: "ETF",
+        bucketGain: "A",
+        bucketLoss: "B",
+        taxRate: 0.26,
+        whiteListed: null,
+        confirmedByUser: true,
+        source: "user"
+      };
+    }
+    const sidecarContent = JSON.stringify(
+      {
+        version: 1,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        classifications,
+        warnings: []
+      },
+      null,
+      2
+    );
+    try {
+      fs8.writeFileSync(sidecarPath, sidecarContent, "utf-8");
+    } catch {
+      stderr.write(`Cannot write sidecar: ${sidecarPath}
+`);
+      return 1;
+    }
+    stdout.write(s.classifyWritten(sidecarPath) + "\n");
+    return 0;
+  }
+  const classifier = new Classifier({ interactive: true });
+  if (fs8.existsSync(sidecarPath)) {
+    const existingMap = await classifier.load(sidecarPath);
+    const confirmedCount = Object.values(existingMap).filter(
+      (e) => e.confirmedByUser
+    ).length;
+    stdout.write(s.classifyMergePrompt(confirmedCount));
+    const answer = await readLine(process.stdin);
+    if (answer.trim().toLowerCase() === "n") {
+      return 0;
+    }
+  }
+  await classifier.classify(transactions, sidecarPath);
+  stdout.write(s.classifyWritten(path6.resolve(sidecarPath)) + "\n");
+  return 0;
+}
+function readLine(stream) {
+  return new Promise((resolve2) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      const nl = buf.indexOf("\n");
+      if (nl !== -1) {
+        stream.removeListener("data", onData);
+        resolve2(buf.slice(0, nl));
+      }
+    };
+    stream.on("data", onData);
+  });
+}
+
 // src/cli/index.ts
 async function main() {
   const { values, positionals } = parseArgs({
@@ -1287,7 +2000,8 @@ async function main() {
       show: { type: "boolean", default: false },
       range: { type: "string" },
       keep: { type: "boolean", default: false },
-      "output-dir": { type: "string" }
+      "output-dir": { type: "string" },
+      offline: { type: "boolean", default: false }
     },
     allowPositionals: true,
     strict: false
@@ -1317,14 +2031,20 @@ async function main() {
       case "stress-test":
         exitCode = await runStressTest(restPositionals, flags, stdout, stderr);
         break;
+      case "classify":
+        exitCode = await runClassify(restPositionals, flags, s, stdout, stderr);
+        break;
       default:
         stderr.write(
-          "Usage: minus-tracker <calc|validate|rates|config|stress-test> [options] [file]\n"
+          "Usage: minus-tracker <calc|validate|rates|config|stress-test|classify> [options] [file]\n"
         );
         exitCode = 2;
     }
   } catch (err) {
-    if (err instanceof ParseError) {
+    if (err instanceof ClassificationError) {
+      stderr.write(err.message + "\n");
+      exitCode = 1;
+    } else if (err instanceof ParseError) {
       if (err.code === "INVALID_CSV") {
         stderr.write(s.errorInvalidCsv + "\n");
       } else {