@gabrielerandelli/minus-tracker 0.7.0 → 0.8.1

package/dist/mcp/index.js

@@ -0,0 +1,1885 @@
+#!/usr/bin/env node
+
+// src/mcp/server.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import * as path2 from "path";
+import * as fs3 from "fs";
+import { Ajv } from "ajv";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/schemas.generated.ts
+var parseTransactionsInputSchema = {
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "csv": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "csv"
+  ],
+  "additionalProperties": false,
+  "definitions": {}
+};
+var classifyInstrumentsInputSchema = {
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "transactions": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Transaction"
+      }
+    },
+    "existingClassification": {
+      "$ref": "#/definitions/ClassificationMap"
+    },
+    "overrides": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/AssetClass"
+      }
+    },
+    "offline": {
+      "type": "boolean"
+    }
+  },
+  "required": [
+    "transactions"
+  ],
+  "additionalProperties": false,
+  "definitions": {
+    "Transaction": {
+      "type": "object",
+      "properties": {
+        "isin": {
+          "type": "string"
+        },
+        "product": {
+          "type": "string"
+        },
+        "date": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "BUY",
+            "SELL"
+          ]
+        },
+        "quantity": {
+          "type": "number"
+        },
+        "pricePerUnit": {
+          "type": "number"
+        },
+        "currency": {
+          "type": "string"
+        },
+        "totalLocal": {
+          "type": "number"
+        },
+        "totalEUR": {
+          "type": "number"
+        },
+        "feesEUR": {
+          "type": "number"
+        },
+        "fxRate": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "isin",
+        "product",
+        "date",
+        "type",
+        "quantity",
+        "pricePerUnit",
+        "currency",
+        "totalLocal",
+        "totalEUR",
+        "feesEUR"
+      ],
+      "additionalProperties": false
+    },
+    "ClassificationMap": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/ClassificationEntry"
+      }
+    },
+    "ClassificationEntry": {
+      "type": "object",
+      "properties": {
+        "product": {
+          "type": "string"
+        },
+        "assetClass": {
+          "$ref": "#/definitions/AssetClass"
+        },
+        "bucketGain": {
+          "type": "string",
+          "enum": [
+            "A",
+            "B"
+          ]
+        },
+        "bucketLoss": {
+          "type": "string",
+          "enum": [
+            "A",
+            "B"
+          ]
+        },
+        "taxRate": {
+          "type": "number"
+        },
+        "whiteListed": {
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "confirmedByUser": {
+          "type": "boolean"
+        },
+        "source": {
+          "type": "string",
+          "enum": [
+            "openfigi",
+            "user"
+          ]
+        }
+      },
+      "required": [
+        "product",
+        "assetClass",
+        "bucketGain",
+        "bucketLoss",
+        "taxRate",
+        "whiteListed",
+        "confirmedByUser",
+        "source"
+      ],
+      "additionalProperties": false
+    },
+    "AssetClass": {
+      "type": "string",
+      "enum": [
+        "ETF",
+        "Stock",
+        "ETC",
+        "GovtBondWL",
+        "GovtBondOther",
+        "CorpBond",
+        "Derivative",
+        "LeverageCert",
+        "CapProtectedCert"
+      ]
+    }
+  }
+};
+var calculateGainsInputSchema = {
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "transactions": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Transaction"
+      }
+    },
+    "method": {
+      "$ref": "#/definitions/LotMethod"
+    },
+    "parseWarnings": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "classification": {
+      "$ref": "#/definitions/ClassificationMap"
+    },
+    "carryForward": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/CarryForward"
+      }
+    },
+    "incomeRows": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/IncomeRow"
+      }
+    }
+  },
+  "required": [
+    "transactions",
+    "method"
+  ],
+  "additionalProperties": false,
+  "definitions": {
+    "Transaction": {
+      "type": "object",
+      "properties": {
+        "isin": {
+          "type": "string"
+        },
+        "product": {
+          "type": "string"
+        },
+        "date": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "BUY",
+            "SELL"
+          ]
+        },
+        "quantity": {
+          "type": "number"
+        },
+        "pricePerUnit": {
+          "type": "number"
+        },
+        "currency": {
+          "type": "string"
+        },
+        "totalLocal": {
+          "type": "number"
+        },
+        "totalEUR": {
+          "type": "number"
+        },
+        "feesEUR": {
+          "type": "number"
+        },
+        "fxRate": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "isin",
+        "product",
+        "date",
+        "type",
+        "quantity",
+        "pricePerUnit",
+        "currency",
+        "totalLocal",
+        "totalEUR",
+        "feesEUR"
+      ],
+      "additionalProperties": false
+    },
+    "LotMethod": {
+      "type": "string",
+      "enum": [
+        "LIFO",
+        "FIFO"
+      ]
+    },
+    "ClassificationMap": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/ClassificationEntry"
+      }
+    },
+    "ClassificationEntry": {
+      "type": "object",
+      "properties": {
+        "product": {
+          "type": "string"
+        },
+        "assetClass": {
+          "$ref": "#/definitions/AssetClass"
+        },
+        "bucketGain": {
+          "type": "string",
+          "enum": [
+            "A",
+            "B"
+          ]
+        },
+        "bucketLoss": {
+          "type": "string",
+          "enum": [
+            "A",
+            "B"
+          ]
+        },
+        "taxRate": {
+          "type": "number"
+        },
+        "whiteListed": {
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "confirmedByUser": {
+          "type": "boolean"
+        },
+        "source": {
+          "type": "string",
+          "enum": [
+            "openfigi",
+            "user"
+          ]
+        }
+      },
+      "required": [
+        "product",
+        "assetClass",
+        "bucketGain",
+        "bucketLoss",
+        "taxRate",
+        "whiteListed",
+        "confirmedByUser",
+        "source"
+      ],
+      "additionalProperties": false
+    },
+    "AssetClass": {
+      "type": "string",
+      "enum": [
+        "ETF",
+        "Stock",
+        "ETC",
+        "GovtBondWL",
+        "GovtBondOther",
+        "CorpBond",
+        "Derivative",
+        "LeverageCert",
+        "CapProtectedCert"
+      ]
+    },
+    "CarryForward": {
+      "type": "object",
+      "properties": {
+        "year": {
+          "type": "number"
+        },
+        "amount": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "year",
+        "amount"
+      ],
+      "additionalProperties": false
+    },
+    "IncomeRow": {
+      "type": "object",
+      "properties": {
+        "isin": {
+          "type": "string"
+        },
+        "product": {
+          "type": "string"
+        },
+        "date": {
+          "type": "string"
+        },
+        "incomeType": {
+          "type": "string",
+          "enum": [
+            "dividend",
+            "coupon"
+          ]
+        },
+        "grossAmount": {
+          "type": "number"
+        },
+        "withholdingTax": {
+          "type": "number"
+        },
+        "currency": {
+          "type": "string"
+        },
+        "fxRate": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "isin",
+        "product",
+        "date",
+        "incomeType",
+        "grossAmount",
+        "withholdingTax",
+        "currency"
+      ],
+      "additionalProperties": false
+    }
+  }
+};
+
+// 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;
+  }
+};
+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/rates/index.ts
+import { fileURLToPath } from "url";
+import * as path from "path";
+import * as fs from "fs";
+var _bundled = void 0;
+function getBundledSnapshot() {
+  if (_bundled !== void 0) return _bundled;
+  const __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+  const bundledPath = path.join(__dirname2, "../data/ecb-rates.json");
+  try {
+    _bundled = JSON.parse(
+      fs.readFileSync(bundledPath, "utf8")
+    );
+  } catch {
+    _bundled = null;
+  }
+  return _bundled;
+}
+function getUserSnapshot() {
+  const platform = process.platform;
+  let configDir;
+  if (platform === "win32") {
+    configDir = process.env.APPDATA ?? path.join(process.env.USERPROFILE ?? "~", "AppData", "Roaming");
+  } else {
+    configDir = process.env.XDG_CONFIG_HOME ?? path.join(process.env.HOME ?? "~", ".config");
+  }
+  const userPath = path.join(configDir, "minus-tracker", "ecb-rates.json");
+  try {
+    return JSON.parse(fs.readFileSync(userPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function getActiveSnapshot() {
+  const bundled = getBundledSnapshot();
+  const user = getUserSnapshot();
+  if (!bundled && !user) {
+    throw new Error(
+      "No ECB rates snapshot available. Run `minus-tracker rates --update` to fetch rates."
+    );
+  }
+  if (!bundled) return user;
+  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`;
+    case "MISSING_ISIN_INCOME":
+      return `Row ${w.row}: blank ISIN on income row \u2014 skipped`;
+    case "ORPHAN_WITHHOLDING":
+      return `Withholding row for ${w.isin} on ${w.date}: no matching income row \u2014 skipped`;
+  }
+}
+
+// src/parser/index.ts
+var REQUIRED_COLUMNS = [
+  "ISIN",
+  "Quantity",
+  "Price",
+  "Date",
+  "Local value",
+  "Local value currency",
+  "Transaction costs",
+  "Transaction costs currency",
+  "Product"
+];
+var INCOME_KEYWORDS = ["DIVIDEND", "COUPON", "INTEREST", "CEDOLA"];
+var TAX_KEYWORDS = ["DIVIDEND TAX", "WITHHOLDING", "RITENUTA"];
+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;
+  _incomeRows = [];
+  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 = [];
+    this._incomeRows = [];
+    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 = [];
+    const incomeCandidates = [];
+    const withholdingCandidates = [];
+    for (let r = 1; r < rows.length; r++) {
+      const row = rows[r];
+      const rowIndex = r + 1;
+      if (row.every((cell) => cell.trim() === "")) continue;
+      const get = (col) => (row[colIndex[col]] ?? "").trim();
+      const isin = get("ISIN");
+      const product = get("Product");
+      const qtyStr = get("Quantity");
+      const rawQty = parseFloat(qtyStr);
+      const qtyIsZeroOrBlank = qtyStr === "" || isNaN(rawQty) || rawQty === 0;
+      if (qtyIsZeroOrBlank) {
+        const upperProduct = product.toUpperCase();
+        const isTaxKeyword = TAX_KEYWORDS.some((k) => upperProduct.includes(k));
+        const isIncomeKeyword = !isTaxKeyword && INCOME_KEYWORDS.some((k) => upperProduct.includes(k));
+        if (isTaxKeyword || isIncomeKeyword) {
+          const rawLocalValue = parseFloat(get("Local value"));
+          const localValue = isNaN(rawLocalValue) ? 0 : rawLocalValue;
+          const isoDate2 = parseDate(get("Date"));
+          if (isTaxKeyword && localValue < 0) {
+            if (!isin) {
+              this._warningEntries.push({
+                code: "MISSING_ISIN_INCOME",
+                row: rowIndex
+              });
+              continue;
+            }
+            withholdingCandidates.push({
+              isin,
+              date: isoDate2,
+              amount: Math.abs(localValue),
+              row: rowIndex
+            });
+            continue;
+          }
+          if (isIncomeKeyword && localValue > 0) {
+            if (!isin) {
+              this._warningEntries.push({
+                code: "MISSING_ISIN_INCOME",
+                row: rowIndex
+              });
+              continue;
+            }
+            const incomeType = upperProduct.includes(
+              "DIVIDEND"
+            ) ? "dividend" : "coupon";
+            incomeCandidates.push({
+              isin,
+              product,
+              date: isoDate2,
+              incomeType,
+              localValue,
+              currency: get("Local value currency"),
+              row: rowIndex
+            });
+            continue;
+          }
+        }
+      }
+      if (!isin) {
+        this._warningEntries.push({ code: "MISSING_ISIN", row: rowIndex });
+        continue;
+      }
+      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(get("Date"));
+      const currency = get("Local value currency");
+      const rawTotalLocal = parseFloat(get("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(get("Transaction costs"));
+      const feesEUR = Math.abs(isNaN(rawFees) ? 0 : rawFees);
+      const pricePerUnit = parseFloat(get("Price"));
+      transactions.push({
+        isin,
+        product,
+        date: isoDate,
+        type,
+        quantity,
+        pricePerUnit,
+        currency,
+        totalLocal,
+        totalEUR,
+        feesEUR,
+        fxRate
+      });
+    }
+    const withholdingByKey = /* @__PURE__ */ new Map();
+    for (const w of withholdingCandidates) {
+      const key = `${w.isin}|${w.date}`;
+      const existing = withholdingByKey.get(key);
+      withholdingByKey.set(key, {
+        isin: w.isin,
+        date: w.date,
+        amount: (existing?.amount ?? 0) + w.amount
+      });
+    }
+    const consumedKeys = /* @__PURE__ */ new Set();
+    const incomeRows = [];
+    for (const c of incomeCandidates) {
+      const key = `${c.isin}|${c.date}`;
+      const matchedWithholding = withholdingByKey.get(key);
+      let grossAmount;
+      let withholdingTax;
+      let fxRate;
+      if (c.currency === "EUR") {
+        grossAmount = Math.abs(c.localValue);
+        withholdingTax = matchedWithholding?.amount ?? 0;
+        fxRate = void 0;
+      } else {
+        const rate = lookupRate(c.currency, c.date, snapshot);
+        if (rate === null) {
+          if (snapshot[c.currency] === void 0) {
+            this._warningEntries.push({
+              code: "UNSUPPORTED_CURRENCY",
+              row: c.row,
+              currency: c.currency
+            });
+          } else {
+            this._warningEntries.push({
+              code: "NO_ECB_RATE",
+              row: c.row,
+              currency: c.currency,
+              date: c.date
+            });
+          }
+          continue;
+        }
+        grossAmount = Math.abs(c.localValue) / rate;
+        withholdingTax = matchedWithholding ? matchedWithholding.amount / rate : 0;
+        fxRate = rate;
+      }
+      if (matchedWithholding) consumedKeys.add(key);
+      incomeRows.push({
+        isin: c.isin,
+        product: c.product,
+        date: c.date,
+        incomeType: c.incomeType,
+        grossAmount,
+        withholdingTax,
+        currency: c.currency,
+        fxRate
+      });
+    }
+    for (const [key, w] of withholdingByKey) {
+      if (!consumedKeys.has(key)) {
+        this._warningEntries.push({
+          code: "ORPHAN_WITHHOLDING",
+          isin: w.isin,
+          date: w.date
+        });
+      }
+    }
+    this._incomeRows = incomeRows;
+    return transactions;
+  }
+  get warnings() {
+    return this._warningEntries.map(warningToEnglish);
+  }
+  get warningEntries() {
+    return this._warningEntries;
+  }
+  get incomeRows() {
+    return this._incomeRows;
+  }
+};
+
+// src/mcp/errors.ts
+function toErrorResult(fields) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(fields) }]
+  };
+}
+function toParseErrorResult(err) {
+  return toErrorResult({
+    code: err.code,
+    columnName: err.columnName,
+    message: err.message
+  });
+}
+function toClassificationErrorResult(err) {
+  return toErrorResult({
+    code: err.code,
+    message: err.message
+  });
+}
+function toCalculationErrorResult(err) {
+  return toErrorResult({
+    code: "CALCULATION_ERROR",
+    isin: err.isin,
+    date: err.date,
+    message: err.message
+  });
+}
+
+// src/mcp/tools/parse-transactions.ts
+async function handleParseTransactions(args) {
+  const parser = new DEGIROParser();
+  try {
+    const transactions = parser.parse(args.csv);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            transactions,
+            warnings: parser.warnings,
+            incomeRows: parser.incomeRows
+          })
+        }
+      ]
+    };
+  } catch (err) {
+    if (err instanceof ParseError) return toParseErrorResult(err);
+    throw err;
+  }
+}
+
+// src/classifier/index.ts
+import * as fs2 from "fs";
+import * as https from "https";
+function httpsPost(url, body, timeoutMs) {
+  return new Promise((resolve, 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", () => resolve({ 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 for ${isin}: ${securityType}. Please classify manually.`
+  );
+  return {
+    product,
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null,
+    confirmedByUser: false,
+    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) {
+    this.interactive = options?.interactive ?? true;
+  }
+  async load(sidecarPath) {
+    if (!fs2.existsSync(sidecarPath)) {
+      throw new ClassificationError("SIDECAR_NOT_FOUND");
+    }
+    let parsed;
+    try {
+      const raw = fs2.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, options, _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 (sidecarPath !== void 0) {
+      if (fs2.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()) {
+      if (!(isin in confirmed)) {
+        toProcess.push(isin);
+      }
+    }
+    const warnings = [];
+    const newEntries = {};
+    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"
+        };
+      }
+    } 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((resolve) => setTimeout(resolve, 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 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 batchIndex = i / BATCH_SIZE;
+        options?.onBatchProgress?.(batchIndex + 1, totalBatches);
+      }
+    }
+    const mergedMap = { ...newEntries, ...confirmed };
+    if (sidecarPath !== void 0) {
+      const sidecarContent = JSON.stringify(
+        {
+          version: 1,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          classifications: mergedMap,
+          warnings
+        },
+        null,
+        2
+      );
+      try {
+        fs2.writeFileSync(sidecarPath, sidecarContent, "utf-8");
+      } catch {
+        throw new ClassificationError("WRITE_ERROR");
+      }
+    }
+    return mergedMap;
+  }
+};
+
+// src/mcp/tools/classify-instruments.ts
+function buildUnresolvedWarnings(classification) {
+  const warnings = [];
+  for (const [isin, entry] of Object.entries(classification)) {
+    if (!entry.confirmedByUser && entry.source === "user") {
+      warnings.push(
+        `Unrecognized type for ${isin}: unknown. Please classify manually.`
+      );
+    }
+  }
+  return warnings;
+}
+async function handleClassifyInstruments(args, extra, _httpPost) {
+  const progressToken = extra?._meta?.progressToken;
+  const sendNotification = extra?.sendNotification;
+  const onBatchProgress = progressToken !== void 0 && sendNotification ? (done, total) => {
+    void sendNotification({
+      method: "notifications/progress",
+      params: { progressToken, progress: done, total }
+    });
+  } : void 0;
+  const classifier = new Classifier({ interactive: false });
+  try {
+    const classification = await classifier.classify(
+      args.transactions,
+      void 0,
+      {
+        existingClassification: args.existingClassification,
+        overrides: args.overrides,
+        offline: args.offline,
+        onBatchProgress
+      },
+      _httpPost
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            classification,
+            warnings: buildUnresolvedWarnings(classification)
+          })
+        }
+      ]
+    };
+  } catch (err) {
+    if (err instanceof ClassificationError)
+      return toClassificationErrorResult(err);
+    throw err;
+  }
+}
+
+// src/dichiarazione/engine.ts
+import { writeFile } from "fs/promises";
+function roundHalfUp(x) {
+  return Math.sign(x) * Math.round(Math.abs(x) * 100) / 100;
+}
+function buildQuadroRT(bucketB, carryForward, taxYear) {
+  const plusvalenze = bucketB.plusvalenze;
+  const minusvalenze = bucketB.minusvalenze;
+  const differenza = roundHalfUp(plusvalenze - minusvalenze);
+  if (differenza > 0) {
+    const sorted = [...carryForward].sort((a, b) => a.year - b.year);
+    let remaining = differenza;
+    const carryForwardApplied = [];
+    for (const entry of sorted) {
+      if (taxYear - entry.year > 4) continue;
+      const consumed = Math.min(entry.amount, remaining);
+      if (consumed > 0) {
+        carryForwardApplied.push({
+          annoOrigine: entry.year,
+          importo: roundHalfUp(consumed)
+        });
+        remaining -= consumed;
+      }
+    }
+    const imponibileNetto = roundHalfUp(remaining);
+    const imposta = roundHalfUp(imponibileNetto * 0.26);
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza,
+      carryForwardApplied,
+      imponibileNetto,
+      imposta,
+      carryForwardRiportato: []
+    };
+  } else if (differenza < 0) {
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza,
+      carryForwardApplied: [],
+      imponibileNetto: 0,
+      imposta: 0,
+      carryForwardRiportato: [
+        { annoOrigine: taxYear, importo: roundHalfUp(Math.abs(differenza)) }
+      ]
+    };
+  } else {
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza: 0,
+      carryForwardApplied: [],
+      imponibileNetto: 0,
+      imposta: 0,
+      carryForwardRiportato: []
+    };
+  }
+}
+function buildQuadroRM(bucketA, incomeRows, taxYear) {
+  const groups = bucketA?.groups ?? [];
+  const group26 = groups.find((g) => g.taxRate === 0.26);
+  const group125 = groups.find((g) => g.taxRate === 0.125);
+  const capitaleAliquota26 = {
+    plusvalenze: group26?.plusvalenze ?? 0,
+    imposta: group26?.imposta ?? 0
+  };
+  const capitaleAliquota125 = {
+    plusvalenze: group125?.plusvalenze ?? 0,
+    imposta: group125?.imposta ?? 0
+  };
+  const dividendiEsteri = incomeRows.filter((r) => r.incomeType === "dividend").map((r) => ({
+    isin: r.isin,
+    prodotto: r.product,
+    lordo: r.grossAmount,
+    rittenutaEstera: r.withholdingTax
+  }));
+  const cedole = incomeRows.filter((r) => r.incomeType === "coupon").map((r) => ({
+    isin: r.isin,
+    prodotto: r.product,
+    importo: r.grossAmount,
+    rittenutaEstera: r.withholdingTax
+  }));
+  return {
+    capitaleAliquota26,
+    capitaleAliquota125,
+    dividendiEsteri,
+    cedole
+  };
+}
+function buildDichiarazioneReport(quadroRT, quadroRM, taxYear) {
+  const version = 1;
+  const modello = "Redditi PF";
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version,
+    annoImposta: taxYear,
+    modello,
+    generatedAt,
+    quadroRT,
+    quadroRM,
+    exportTo: async (path3) => {
+      await writeFile(
+        path3,
+        JSON.stringify(
+          {
+            version,
+            annoImposta: taxYear,
+            modello,
+            generatedAt,
+            quadroRT,
+            quadroRM
+          },
+          null,
+          2
+        )
+      );
+    }
+  };
+}
+
+// src/calculator/index.ts
+function roundHalfUp2(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;
+  _options;
+  constructor(transactions, parseWarnings, options) {
+    this._transactions = transactions;
+    this._parseWarnings = parseWarnings ?? [];
+    this._options = options ?? {};
+  }
+  /**
+   * 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) => {
+      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: roundHalfUp2(buyCostEUR),
+            sellProceedsEUR: roundHalfUp2(sellProceedsEUR),
+            gainLossEUR: roundHalfUp2(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);
+    }
+    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: roundHalfUp2(g.plusvalenze),
+        imposta: roundHalfUp2(g.plusvalenze * taxRate)
+      }));
+      const bucketAReport = {
+        groups: bucketAGroups,
+        totalImposta: roundHalfUp2(
+          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 = roundHalfUp2(bPlusvalenze);
+      bMinusvalenze = roundHalfUp2(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 = roundHalfUp2(carryForwardApplied);
+      const bNetResult = roundHalfUp2(
+        bPlusvalenze - bMinusvalenze - carryForwardApplied
+      );
+      const carryForwardRemaining = roundHalfUp2(Math.max(0, -bNetResult));
+      const bucketBReport = {
+        plusvalenze: bPlusvalenze,
+        minusvalenze: bMinusvalenze,
+        carryForwardApplied,
+        carryForwardRemaining,
+        netResult: bNetResult
+      };
+      const allIncomeRows = this._options.incomeRows ?? [];
+      const filteredIncomeRows = allIncomeRows.filter(
+        (row) => new Date(row.date).getFullYear() === taxYear
+      );
+      if (filteredIncomeRows.length < allIncomeRows.length) {
+        warnings.push(`Income rows outside tax year ${taxYear} were skipped.`);
+      }
+      const quadroRT = buildQuadroRT(
+        bucketBReport,
+        this._options.carryForward ?? [],
+        taxYear
+      );
+      const quadroRM = buildQuadroRM(
+        bucketAGroups.length > 0 ? bucketAReport : void 0,
+        filteredIncomeRows,
+        taxYear
+      );
+      const dichiarazioneReport = buildDichiarazioneReport(
+        quadroRT,
+        quadroRM,
+        taxYear
+      );
+      return {
+        method,
+        taxYear,
+        plusvalenze: roundHalfUp2(plusvalenze),
+        minusvalenze: roundHalfUp2(minusvalenze),
+        netResult: roundHalfUp2(plusvalenze - minusvalenze),
+        lots: matchedLots,
+        ratesUsed,
+        warnings,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        bucketA: bucketAGroups.length > 0 ? bucketAReport : void 0,
+        bucketB: bucketBReport,
+        dichiarazione: dichiarazioneReport
+      };
+    } 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,
+      plusvalenze: roundHalfUp2(plusvalenze),
+      minusvalenze: roundHalfUp2(minusvalenze),
+      netResult: roundHalfUp2(plusvalenze - minusvalenze),
+      lots: matchedLots,
+      ratesUsed,
+      warnings,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/mcp/tools/calculate-gains.ts
+async function handleCalculateGains(args) {
+  try {
+    const report = new Calculator(args.transactions, args.parseWarnings ?? [], {
+      classification: args.classification,
+      carryForward: args.carryForward,
+      incomeRows: args.incomeRows
+    }).calculateGains(args.method);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(report)
+        }
+      ]
+    };
+  } catch (err) {
+    if (err instanceof CalculationError) return toCalculationErrorResult(err);
+    throw err;
+  }
+}
+
+// src/mcp/server.ts
+var __dirname = path2.dirname(fileURLToPath2(import.meta.url));
+function getPackageVersion() {
+  const pkgPath = path2.join(__dirname, "../../package.json");
+  const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+  return pkg.version;
+}
+var TOOLS = [
+  {
+    name: "parse_transactions",
+    description: "Parse a DEGIRO transactions CSV export into Transaction[].",
+    inputSchema: parseTransactionsInputSchema
+  },
+  {
+    name: "classify_instruments",
+    description: "Classify transactions' ISINs into asset classes (stateless mode).",
+    inputSchema: classifyInstrumentsInputSchema
+  },
+  {
+    name: "calculate_gains",
+    description: "Calculate LIFO/FIFO capital gains from transactions.",
+    inputSchema: calculateGainsInputSchema
+  }
+];
+var TOOL_NAMES = new Set(TOOLS.map((t) => t.name));
+var ajv = new Ajv({ allErrors: true, strict: false });
+var VALIDATORS = {
+  parse_transactions: ajv.compile(parseTransactionsInputSchema),
+  classify_instruments: ajv.compile(classifyInstrumentsInputSchema),
+  calculate_gains: ajv.compile(calculateGainsInputSchema)
+};
+var server = new Server(
+  { name: "minus-tracker-mcp", version: getPackageVersion() },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: TOOLS
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request2, extra) => {
+  const { name, arguments: args } = request2.params;
+  if (!TOOL_NAMES.has(name)) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: `Unknown tool: ${name}` }]
+    };
+  }
+  const validate = VALIDATORS[name];
+  if (validate && !validate(args)) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            code: "VALIDATION_ERROR",
+            errors: validate.errors
+          })
+        }
+      ]
+    };
+  }
+  switch (name) {
+    case "parse_transactions":
+      return handleParseTransactions(args);
+    case "classify_instruments":
+      return handleClassifyInstruments(
+        args,
+        {
+          _meta: request2.params._meta,
+          sendNotification: extra.sendNotification
+        }
+      );
+    case "calculate_gains":
+      return handleCalculateGains(args);
+    default:
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Unknown tool: ${name}` }]
+      };
+  }
+});
+
+// src/mcp/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+await server.connect(new StdioServerTransport());
+//# sourceMappingURL=index.js.map