@gabrielerandelli/minus-tracker 0.5.6 → 0.5.8

package/dist/cli/index.js

@@ -36,7 +36,7 @@ var it = {
   ratesGaps: (list) => `Lacune: ${list}`,
   ratesUpdateFetching: "Recupero dati BCE SDMX in corso...",
   ratesUpdateDone: (n) => `Completato. Aggiunte ${n} nuove date.`,
-  ratesSnapshotWritten: (path4) => `Snapshot scritto in ${path4}`,
+  ratesSnapshotWritten: (path5) => `Snapshot scritto in ${path5}`,
   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}`,
@@ -77,7 +77,7 @@ var en = {
   ratesGaps: (list) => `Gaps: ${list}`,
   ratesUpdateFetching: "Fetching ECB SDMX...",
   ratesUpdateDone: (n) => `Done. Added ${n} new dates.`,
-  ratesSnapshotWritten: (path4) => `Snapshot written to ${path4}`,
+  ratesSnapshotWritten: (path5) => `Snapshot written to ${path5}`,
   ratesAutoUpdateStart: "ECB rates are stale. Auto-updating\u2026",
   ratesAutoUpdateFailed: "Auto-update failed. Proceeding with available rates.",
   configLangSet: (lang) => `Language set to: ${lang}`,
@@ -319,6 +319,17 @@ var DEGIROParser = class {
   constructor(snapshot) {
     this._snapshot = snapshot;
   }
+  /**
+   * Parse a DEGIRO Transactions CSV export string.
+   *
+   * @param csv - Raw UTF-8 string from the DEGIRO Transactions export.
+   * @returns Array of normalised Transaction objects. Empty if no data rows are found.
+   * @throws {ParseError} code `"INVALID_CSV"` — malformed CSV or binary content.
+   * @throws {ParseError} code `"MISSING_COLUMN"` (+ `columnName`) — required column absent.
+   *
+   * Rows with missing ISIN, unsupported currency, zero quantity, or no ECB rate within
+   * 3 trading days are skipped silently. Inspect `parser.warnings` for details.
+   */
   parse(csv) {
     this._warningEntries = [];
     if (typeof csv !== "string" || csv.includes("\0")) {
@@ -442,10 +453,23 @@ 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) {
     this._transactions = transactions;
     this._parseWarnings = parseWarnings ?? [];
   }
+  /**
+   * Run LIFO or FIFO lot-matching over the transaction list.
+   *
+   * @param method - `"LIFO"` or `"FIFO"`.
+   * @returns GainsReport with `plusvalenze`, `minusvalenze`, `netResult`, per-lot breakdown,
+   *          ECB rates used, and any accumulated warnings.
+   * @throws {CalculationError} when a SELL has no matching open buy lots.
+   *         `error.isin` and `error.date` identify the problematic transaction.
+   */
   calculateGains(method) {
     const warnings = [...this._parseWarnings];
     const sorted = [...this._transactions].sort((a, b) => {
@@ -843,6 +867,412 @@ async function runConfig(positional, flags, s, stdout, stderr) {
   return 2;
 }
 
+// src/cli/commands/stress-test.ts
+import * as fs6 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/stress/generator.ts
+function formatDate(isoDate) {
+  const [yyyy, mm, dd] = isoDate.split("-");
+  return `${dd}-${mm}-${yyyy}`;
+}
+function generateCsv(scenario) {
+  if (scenario.special === "invalid_csv") {
+    return "NOT_A_CSV\0
\ngarbage data";
+  }
+  const allColumns = [
+    "Date",
+    "Time",
+    "Product",
+    "ISIN",
+    "Exchange",
+    "Execution centre",
+    "Quantity",
+    "Price",
+    "Local value",
+    "Local value currency",
+    "Value",
+    "Value currency",
+    "Exchange rate",
+    "Transaction costs",
+    "Transaction costs currency",
+    "Total",
+    "Total currency",
+    "Order ID"
+  ];
+  let columns = allColumns;
+  if (scenario.special === "missing_col_isin") {
+    columns = columns.filter((c) => c !== "ISIN");
+  } else if (scenario.special === "missing_col_quantity") {
+    columns = columns.filter((c) => c !== "Quantity");
+  } else if (scenario.special === "missing_col_price") {
+    columns = columns.filter((c) => c !== "Price");
+  }
+  const buildRow = (values, includeColumns) => {
+    return includeColumns.map((col) => values[col] ?? "").join(",");
+  };
+  const header = columns.join(",");
+  const rows = [header];
+  for (let rowIndex = 0; rowIndex < scenario.transactions.length; rowIndex++) {
+    const tx = scenario.transactions[rowIndex];
+    const localValue = -tx.qty * tx.price;
+    const total = localValue - tx.fee;
+    const rowValues = {
+      Date: formatDate(tx.date),
+      Time: "09:00",
+      Product: tx.product,
+      ISIN: tx.isin,
+      Exchange: "XEUR",
+      "Execution centre": "XEUR",
+      Quantity: String(tx.qty),
+      Price: tx.price.toFixed(2),
+      "Local value": localValue.toFixed(2),
+      "Local value currency": tx.currency,
+      Value: localValue.toFixed(2),
+      "Value currency": "EUR",
+      "Exchange rate": "1",
+      "Transaction costs": (-Math.abs(tx.fee)).toFixed(2),
+      "Transaction costs currency": "EUR",
+      Total: total.toFixed(2),
+      "Total currency": "EUR",
+      "Order ID": `stress-${scenario.id}-${rowIndex}`
+    };
+    const row = buildRow(rowValues, columns);
+    rows.push(row);
+  }
+  return rows.join("\n");
+}
+
+// src/stress/runner.ts
+import { spawnSync } from "child_process";
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+function countWarnings(text) {
+  if (!text) return 0;
+  const match = text.match(/(?:warnings|avvertenze)\s*:\s*(\d+)/i);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function isValidJson(jsonStr) {
+  try {
+    const obj = JSON.parse(jsonStr);
+    return typeof obj === "object" && obj !== null && "plusvalenze" in obj && "minusvalenze" in obj && "lots" in obj;
+  } catch {
+    return false;
+  }
+}
+function runCommand(cliBin, args, cmdLabel, expectedExitCode, outputShapeCheck) {
+  const isJsFile = cliBin.endsWith(".js");
+  let result;
+  if (isJsFile) {
+    result = spawnSync("node", [cliBin, ...args], {
+      encoding: "utf8",
+      timeout: 15e3,
+      env: { ...process.env, MINUS_TRACKER_LANG: void 0 }
+    });
+  } else {
+    result = spawnSync(cliBin, args, {
+      encoding: "utf8",
+      timeout: 15e3,
+      env: { ...process.env, MINUS_TRACKER_LANG: void 0 }
+    });
+  }
+  const exitCode = result.status ?? 1;
+  const stdout = result.stdout || "";
+  const stderr = result.stderr || "";
+  const exitCodeMatch = exitCode === expectedExitCode;
+  const shapeCheck = outputShapeCheck(stdout, stderr, exitCode);
+  let pass = exitCodeMatch && shapeCheck.valid;
+  let failure;
+  if (!exitCodeMatch) {
+    failure = `exit code mismatch: expected ${expectedExitCode}, got ${exitCode}`;
+  } else if (!shapeCheck.valid) {
+    failure = shapeCheck.reason;
+  }
+  return {
+    cmd: cmdLabel,
+    exitCode,
+    stdout,
+    stderr,
+    pass,
+    failure
+  };
+}
+function runScenario(scenario, csvContent, outputDir, cliBin) {
+  const csvFileName = `${scenario.id}-${scenario.slug}.csv`;
+  const csvFile = join4(outputDir, csvFileName);
+  writeFileSync3(csvFile, csvContent, "utf8");
+  const results = [];
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", csvFile],
+      "calc",
+      scenario.expect.calc_exit,
+      (stdout) => {
+        if (scenario.expect.calc_exit === 0) {
+          const hasPlus = /plusvalenze|plusvalues/i.test(stdout);
+          return hasPlus ? { valid: true } : {
+            valid: false,
+            reason: "calc output missing plusvalenze/plusvalues (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", "--method", "FIFO", csvFile],
+      "calc --method FIFO",
+      scenario.expect.fifo_exit,
+      (stdout) => {
+        if (scenario.expect.fifo_exit === 0) {
+          const hasPlus = /plusvalenze|plusvalues/i.test(stdout);
+          return hasPlus ? { valid: true } : {
+            valid: false,
+            reason: "calc --method FIFO output missing plusvalenze/plusvalues (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", "--json", csvFile],
+      "calc --json",
+      scenario.expect.json_exit,
+      (stdout) => {
+        if (scenario.expect.json_exit === 0) {
+          const isValid = isValidJson(stdout);
+          return isValid ? { valid: true } : {
+            valid: false,
+            reason: "calc --json output is not valid JSON with required keys (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["calc", "--lang", "en", csvFile],
+      "calc --lang en",
+      scenario.expect.en_exit,
+      (stdout) => {
+        if (scenario.expect.en_exit === 0) {
+          const nonEmpty = stdout.trim().length > 0;
+          return nonEmpty ? { valid: true } : {
+            valid: false,
+            reason: "calc --lang en output is empty (exit 0)"
+          };
+        }
+        return { valid: true };
+      }
+    )
+  );
+  results.push(
+    runCommand(
+      cliBin,
+      ["validate", csvFile],
+      "validate",
+      scenario.expect.validate_exit,
+      (stdout) => {
+        if (scenario.expect.validate_exit !== 0) return { valid: true };
+        const nonEmpty = stdout.trim().length > 0;
+        return nonEmpty ? { valid: true } : {
+          valid: false,
+          reason: "validate output is empty"
+        };
+      }
+    )
+  );
+  const enCalcResult = results[3];
+  const actualWarningCount = countWarnings(enCalcResult.stdout);
+  const warningCheckPass = actualWarningCount >= scenario.expect.warning_count;
+  const pass = results.every((r) => r.pass) && warningCheckPass;
+  return {
+    id: scenario.id,
+    category: scenario.category,
+    slug: scenario.slug,
+    description: scenario.description,
+    csvFile,
+    results,
+    pass,
+    warningCheckPass,
+    expectedWarningCount: scenario.expect.warning_count,
+    actualWarningCount
+  };
+}
+
+// src/stress/reporter.ts
+function buildReport(results, rangeStart, rangeEnd) {
+  const passed = results.filter((r) => r.pass).length;
+  const failed = results.length - passed;
+  return {
+    totalScenarios: results.length,
+    passed,
+    failed,
+    results,
+    rangeStart,
+    rangeEnd
+  };
+}
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function formatTable(report) {
+  const lines = [];
+  lines.push("STRESS TEST \u2014 minus-tracker");
+  lines.push(
+    `Scenari: ${report.totalScenarios}  |  Passati: ${report.passed}  |  Falliti: ${report.failed}`
+  );
+  lines.push("");
+  const idCol = "ID";
+  const categoryCol = "CATEGORIA";
+  const descCol = "DESCRIZIONE";
+  const resultCol = "ESITO";
+  lines.push(formatRow(idCol, categoryCol, descCol, resultCol));
+  for (const result of report.results) {
+    const idStr = result.id.padStart(3, "0");
+    const status = result.pass ? "\u2713 PASS" : "\u2717 FAIL";
+    lines.push(formatRow(idStr, result.category, result.description, status));
+    if (!result.pass) {
+      for (const cmdResult of result.results) {
+        if (!cmdResult.pass) {
+          if (cmdResult.failure) {
+            let failureText = "";
+            if (cmdResult.failure.includes("exit code mismatch")) {
+              const match = cmdResult.failure.match(
+                /expected (\d+), got (\d+)/
+              );
+              if (match) {
+                failureText = `atteso exit ${match[1]}, ottenuto exit ${match[2]}`;
+              }
+            } else {
+              failureText = `output shape non valido \u2014 ${cmdResult.failure}`;
+            }
+            lines.push(`   \u2192 ${cmdResult.cmd}: ${failureText}`);
+          }
+        }
+      }
+      if (!result.warningCheckPass) {
+        lines.push(
+          `   \u2192 avvertenze: attese \u2265${result.expectedWarningCount}, trovate ${result.actualWarningCount}`
+        );
+      }
+    }
+  }
+  lines.push("");
+  lines.push(`PASSATI: ${report.passed}`);
+  lines.push(`FALLITI: ${report.failed}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatRow(id, category, description, esito) {
+  const idWidth = 4;
+  const categoryWidth = 22;
+  const descWidth = 40;
+  const esitoWidth = 8;
+  const idCol = id.padEnd(idWidth);
+  const categoryCol = truncateOrPad(category, categoryWidth);
+  const descCol = truncateOrPad(description, descWidth);
+  const esitoCol = esito.padEnd(esitoWidth);
+  return `${idCol}  ${categoryCol}  ${descCol}  ${esitoCol}`;
+}
+function truncateOrPad(str, maxWidth) {
+  if (str.length > maxWidth) {
+    return str.slice(0, maxWidth - 2) + "..";
+  }
+  return str.padEnd(maxWidth);
+}
+
+// src/cli/commands/stress-test.ts
+async function runStressTest(_positionals, flags, stdout, stderr) {
+  const rangeStr = flags["range"] ?? "1-100";
+  const rangeParts = rangeStr.split("-");
+  if (rangeParts.length !== 2) {
+    stderr.write(
+      `Error: --range must be in the form N-M (e.g. 1-100), got: "${rangeStr}"
+`
+    );
+    return 2;
+  }
+  const rangeStart = parseInt(rangeParts[0], 10);
+  const rangeEnd = parseInt(rangeParts[1], 10);
+  if (isNaN(rangeStart) || isNaN(rangeEnd) || rangeStart <= 0 || rangeEnd <= 0 || rangeStart > rangeEnd || rangeStart > 100 || rangeEnd > 100) {
+    stderr.write(
+      `Error: --range values must be positive integers between 1 and 100 with start \u2264 end, got: "${rangeStr}"
+`
+    );
+    return 2;
+  }
+  const __dirname = path4.dirname(fileURLToPath2(import.meta.url));
+  const manifestPath = path4.join(__dirname, "../data/stress-manifest.json");
+  let manifest;
+  try {
+    const raw = fs6.readFileSync(manifestPath, "utf8");
+    manifest = JSON.parse(raw);
+  } catch {
+    stderr.write(`Error: could not load stress manifest at ${manifestPath}
+`);
+    return 1;
+  }
+  const cliBin = process.argv[1];
+  let outputDir;
+  const outputDirFlag = flags["output-dir"];
+  if (outputDirFlag) {
+    outputDir = outputDirFlag;
+    fs6.mkdirSync(outputDir, { recursive: true });
+  } else {
+    outputDir = fs6.mkdtempSync(path4.join(os3.tmpdir(), "minus-tracker-stress-"));
+  }
+  const ratesCheck = spawnSync2("node", [cliBin, "rates", "--check"], {
+    encoding: "utf8",
+    timeout: 15e3
+  });
+  if ((ratesCheck.status ?? 1) !== 0) {
+    stderr.write("Warning: rates --check failed; ECB rates may be stale.\n");
+  }
+  const configShow = spawnSync2("node", [cliBin, "config", "--show"], {
+    encoding: "utf8",
+    timeout: 15e3
+  });
+  if ((configShow.status ?? 1) !== 0) {
+    stderr.write("Warning: config --show failed.\n");
+  }
+  const scenarios = manifest.scenarios.filter((s) => {
+    const id = parseInt(s.id, 10);
+    return id >= rangeStart && id <= rangeEnd;
+  });
+  const results = [];
+  for (const scenario of scenarios) {
+    const csv = generateCsv(scenario);
+    const result = runScenario(scenario, csv, outputDir, cliBin);
+    results.push(result);
+    stdout.write(
+      `  [${result.pass ? "\u2713" : "\u2717"}] ${scenario.id} ${scenario.slug}
+`
+    );
+  }
+  const report = buildReport(results, rangeStart, rangeEnd);
+  if (flags["json"]) {
+    stdout.write(formatJson(report) + "\n");
+  } else {
+    stdout.write(formatTable(report) + "\n");
+  }
+  if (!flags["keep"]) {
+    fs6.rmSync(outputDir, { recursive: true, force: true });
+  }
+  return report.failed === 0 ? 0 : 1;
+}
+
 // src/cli/index.ts
 async function main() {
   const { values, positionals } = parseArgs({
@@ -854,7 +1284,10 @@ async function main() {
       json: { type: "boolean", default: false },
       check: { type: "boolean", default: false },
       update: { type: "boolean", default: false },
-      show: { type: "boolean", default: false }
+      show: { type: "boolean", default: false },
+      range: { type: "string" },
+      keep: { type: "boolean", default: false },
+      "output-dir": { type: "string" }
     },
     allowPositionals: true,
     strict: false
@@ -881,9 +1314,12 @@ async function main() {
       case "config":
         exitCode = await runConfig(restPositionals, flags, s, stdout, stderr);
         break;
+      case "stress-test":
+        exitCode = await runStressTest(restPositionals, flags, stdout, stderr);
+        break;
       default:
         stderr.write(
-          "Usage: minus-tracker <calc|validate|rates|config> [options] [file]\n"
+          "Usage: minus-tracker <calc|validate|rates|config|stress-test> [options] [file]\n"
         );
         exitCode = 2;
     }