@gabrielerandelli/minus-tracker 0.7.0 → 0.8.1

package/dist/cli/index.js

@@ -9,6 +9,9 @@ var 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}`,
+  errorCannotReadFile: (path7) => `Impossibile leggere il file: ${path7}`,
+  errorCannotLoadSidecar: (path7) => `Impossibile caricare il sidecar: ${path7}`,
+  errorCannotWriteExport: (path7) => `Impossibile scrivere l'export della dichiarazione: ${path7}`,
   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`,
@@ -88,7 +91,7 @@ var it = {
   quadroRMRitenuta: "Ritenuta estera (credito)",
   quadroRMCedole: "[RM-C]  Cedole obbligazionarie",
   dichiarazioneDisclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale.",
-  warnNoDichiarazioneSidecar: "Eseguire prima: minus-tracker classify <file>",
+  warnNoDichiarazioneSidecar: "Suggerimento: esegui prima 'minus-tracker classify <file>' per abilitare il Quadro RT/RM.",
   warnNoCarryForwardProvided: "(eventuali perdite pregresse non applicate)"
 };
 
@@ -98,6 +101,9 @@ var en = {
   errorInvalidCsv: "Invalid CSV: unable to parse",
   errorMissingColumn: (col) => `Missing required column: ${col}`,
   errorNoOpenLots: (isin, date) => `No open lots for ISIN ${isin} on ${date}`,
+  errorCannotReadFile: (path7) => `Cannot read file: ${path7}`,
+  errorCannotLoadSidecar: (path7) => `Cannot load sidecar: ${path7}`,
+  errorCannotWriteExport: (path7) => `Cannot write dichiarazione export: ${path7}`,
   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`,
@@ -177,7 +183,7 @@ var en = {
   quadroRMRitenuta: "Foreign withholding (credit)",
   quadroRMCedole: "[RM-C]  Bond coupons",
   dichiarazioneDisclaimer: "minus-tracker \xE8 un ausilio al calcolo, non consulenza fiscale.",
-  warnNoDichiarazioneSidecar: "Run first: minus-tracker classify <file>",
+  warnNoDichiarazioneSidecar: "Tip: run 'minus-tracker classify <file>' first to enable Quadro RT/RM.",
   warnNoCarryForwardProvided: "(prior-year losses not applied)"
 };
 
@@ -1246,7 +1252,7 @@ function classifyByType(isin, securityType, product, warnings) {
     };
   }
   warnings.push(
-    `Unrecognized type: ${securityType}. Please classify manually.`
+    `Unrecognized type for ${isin}: ${securityType}. Please classify manually.`
   );
   return {
     product,
@@ -1259,6 +1265,84 @@ function classifyByType(isin, securityType, product, warnings) {
     source: "user"
   };
 }
+var ASSET_CLASS_DEFAULTS = {
+  ETF: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  Stock: {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  ETC: {
+    assetClass: "ETC",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  GovtBondWL: {
+    assetClass: "GovtBondWL",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.125,
+    whiteListed: true
+  },
+  GovtBondOther: {
+    assetClass: "GovtBondOther",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: false
+  },
+  CorpBond: {
+    assetClass: "CorpBond",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Derivative: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  LeverageCert: {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  CapProtectedCert: {
+    assetClass: "CapProtectedCert",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  }
+};
+function buildEntryFromAssetClass(assetClass, product) {
+  const mapped = ASSET_CLASS_DEFAULTS[assetClass];
+  return {
+    product,
+    assetClass: mapped.assetClass,
+    bucketGain: mapped.bucketGain,
+    bucketLoss: mapped.bucketLoss,
+    taxRate: mapped.taxRate,
+    whiteListed: mapped.whiteListed,
+    confirmedByUser: true,
+    source: "user"
+  };
+}
 var Classifier = class {
   interactive;
   constructor(options) {
@@ -1280,7 +1364,7 @@ var Classifier = class {
     }
     return parsed.classifications;
   }
-  async classify(transactions, sidecarPath, _httpPost = httpsPost) {
+  async classify(transactions, sidecarPath, options, _httpPost = httpsPost) {
     const isinToProduct = /* @__PURE__ */ new Map();
     for (const tx of transactions) {
       if (tx.isin && !isinToProduct.has(tx.isin)) {
@@ -1288,13 +1372,21 @@ var Classifier = class {
       }
     }
     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;
+    if (sidecarPath !== void 0) {
+      if (fs3.existsSync(sidecarPath)) {
+        const existingMap = await this.load(sidecarPath);
+        for (const [isin, entry] of Object.entries(existingMap)) {
+          if (entry.confirmedByUser) {
+            confirmed[isin] = entry;
+          }
         }
       }
+    } else if (options?.existingClassification) {
+      Object.assign(confirmed, options.existingClassification);
+    }
+    for (const [isin, assetClass] of Object.entries(options?.overrides ?? {})) {
+      const product = isinToProduct.get(isin) ?? isin;
+      confirmed[isin] = buildEntryFromAssetClass(assetClass, product);
     }
     const toProcess = [];
     for (const isin of isinToProduct.keys()) {
@@ -1304,76 +1396,100 @@ var Classifier = class {
     }
     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));
+    if (options?.offline) {
+      for (const isin of toProcess) {
+        const product = isinToProduct.get(isin) ?? isin;
+        warnings.push(
+          `Unrecognized type for ${isin}: unknown. Please classify manually.`
+        );
+        newEntries[isin] = {
+          product,
+          assetClass: "Stock",
+          bucketGain: "B",
+          bucketLoss: "B",
+          taxRate: 0,
+          whiteListed: null,
+          confirmedByUser: false,
+          source: "user"
+        };
       }
-      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;
+    } else {
+      const BATCH_SIZE = 10;
+      const totalBatches = Math.ceil(toProcess.length / BATCH_SIZE);
+      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");
           }
-        } catch {
+        }
+        if (response === null) {
           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 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 for ${isin}: 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 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 batchIndex = i / BATCH_SIZE;
+        options?.onBatchProgress?.(batchIndex + 1, totalBatches);
       }
     }
     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");
+    if (sidecarPath !== void 0) {
+      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;
   }
@@ -1579,8 +1695,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
   try {
     csv = fs4.readFileSync(filePath, "utf8");
   } catch {
-    stderr.write(`Cannot read file: ${filePath}
-`);
+    stderr.write(s.errorCannotReadFile(filePath) + "\n");
     return 1;
   }
   const method = flags["method"] ?? "LIFO";
@@ -1595,8 +1710,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
       const classifier = new Classifier({ interactive: false });
       classification = await classifier.load(sidecarPath);
     } catch {
-      stderr.write(`Cannot load sidecar: ${sidecarPath}
-`);
+      stderr.write(s.errorCannotLoadSidecar(sidecarPath) + "\n");
       return 1;
     }
   }
@@ -1666,8 +1780,7 @@ async function runCalc(positional, flags, s, stdout, stderr) {
     try {
       await report.dichiarazione.exportTo(exportPath);
     } catch {
-      stderr.write(`Cannot write dichiarazione export: ${exportPath}
-`);
+      stderr.write(s.errorCannotWriteExport(exportPath) + "\n");
       return 1;
     }
   }
@@ -1759,18 +1872,45 @@ function getSnapshotPath() {
   }
   return path4.join(configDir, "minus-tracker", "ecb-rates.json");
 }
+function countMissingBusinessDays(startDate, endDate, dates) {
+  let missing = 0;
+  const cursor = /* @__PURE__ */ new Date(startDate + "T00:00:00Z");
+  const end = /* @__PURE__ */ new Date(endDate + "T00:00:00Z");
+  while (cursor <= end) {
+    const day = cursor.getUTCDay();
+    const iso = cursor.toISOString().slice(0, 10);
+    if (day !== 0 && day !== 6 && dates[iso] === void 0) missing++;
+    cursor.setUTCDate(cursor.getUTCDate() + 1);
+  }
+  return missing;
+}
 function getCoverage(snapshot) {
   let start = "9999-12-31";
   let end = "0000-01-01";
   const currencies = [];
+  const gapEntries = [];
   for (const [ccy, dates] of Object.entries(snapshot)) {
     currencies.push(ccy);
-    for (const d of Object.keys(dates)) {
+    const keys = Object.keys(dates).sort();
+    for (const d of keys) {
       if (d < start) start = d;
       if (d > end) end = d;
     }
+    if (keys.length > 0) {
+      const missing = countMissingBusinessDays(
+        keys[0],
+        keys[keys.length - 1],
+        dates
+      );
+      if (missing > 0) gapEntries.push(`${ccy}: ${missing}`);
+    }
   }
-  return { start, end, currencies: currencies.sort().join(", ") };
+  return {
+    start,
+    end,
+    currencies: currencies.sort().join(", "),
+    gaps: gapEntries.sort().join(", ")
+  };
 }
 async function fetchEcbData(currency) {
   return new Promise((resolve2, reject) => {
@@ -1834,9 +1974,9 @@ async function updateRates(snapshotPath, stdout, stderr, s) {
 async function runRates(positional, flags, s, stdout, stderr) {
   if (flags["check"]) {
     const snapshot = getActiveSnapshot();
-    const { start, end, currencies } = getCoverage(snapshot);
+    const { start, end, currencies, gaps } = getCoverage(snapshot);
     stdout.write(s.ratesCoverage(start, end, currencies) + "\n");
-    stdout.write(s.ratesGapsNone + "\n");
+    stdout.write((gaps ? s.ratesGaps(gaps) : s.ratesGapsNone) + "\n");
     return 0;
   }
   if (flags["update"]) {
@@ -2402,7 +2542,9 @@ async function main() {
       range: { type: "string" },
       keep: { type: "boolean", default: false },
       "output-dir": { type: "string" },
-      offline: { type: "boolean", default: false }
+      offline: { type: "boolean", default: false },
+      "carry-forward": { type: "string", multiple: true },
+      "export-dichiarazione": { type: "string" }
     },
     allowPositionals: true,
     strict: false