normattiva-mcp 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,21 +1,741 @@
 #!/usr/bin/env node
+
+// dist/index.js
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { registerTools } from "./tools.js";
-import { registerResources } from "./resources.js";
-import { registerPrompts } from "./prompts.js";
-async function main() {
-    const server = new McpServer({
-        name: "normattiva-mcp",
-        version: "0.1.0",
+
+// ../core/dist/tools.js
+import { McpError as McpError2, ErrorCode as ErrorCode2 } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+
+// ../core/dist/api.js
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+var BASE_URL = "https://api.normattiva.it/t/normattiva.api";
+var COMMON_HEADERS = {
+  Accept: "application/json, text/plain, */*",
+  "Accept-Language": "it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7",
+  Origin: "https://dati.normattiva.it",
+  "User-Agent": "normattiva-mcp/0.1.2 (+https://www.npmjs.com/package/normattiva-mcp)"
+};
+var REQUEST_TIMEOUT_MS = 2e4;
+async function request(path, init) {
+  const url = BASE_URL + path;
+  let res;
+  try {
+    res = await fetch(url, {
+      ...init,
+      signal: init?.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      headers: { ...COMMON_HEADERS, ...init?.headers }
+    });
+  } catch (err) {
+    throw new McpError(ErrorCode.InternalError, `Network error contacting Normattiva: ${err.message}`);
+  }
+  if (!res.ok) {
+    let detail = "";
+    let apiCode;
+    try {
+      const body = await res.json();
+      apiCode = body.code;
+      detail = body.message ?? body.description ?? body.error ?? JSON.stringify(body);
+    } catch {
+      detail = await res.text().catch(() => "");
+    }
+    const isClientError = res.status === 400 || res.status === 404 || res.status === 422 || apiCode !== void 0 && /^1[0-9]{3}$/.test(apiCode);
+    const mcpCode = isClientError ? ErrorCode.InvalidRequest : ErrorCode.InternalError;
+    const codeTag = apiCode ? ` [code=${apiCode}]` : "";
+    throw new McpError(mcpCode, `Normattiva API ${res.status}${codeTag}: ${detail || res.statusText}`);
+  }
+  return await res.json();
+}
+function postJson(path, body) {
+  return request(path, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+}
+function ricercaAvanzata(body) {
+  return postJson("/bff-opendata/v1/api/v1/ricerca/avanzata", body);
+}
+async function dettaglioAtto(body) {
+  try {
+    return await postJson("/bff-opendata/v1/api/v1/atto/dettaglio-atto", body);
+  } catch (err) {
+    if (err instanceof McpError && err.code === ErrorCode.InvalidRequest && /non\s+trovat[oa]/i.test(err.message)) {
+      return { success: false, message: err.message };
+    }
+    throw err;
+  }
+}
+function ricercaAggiornati(body) {
+  return postJson("/bff-opendata/v1/api/v1/ricerca/aggiornati", body);
+}
+function memoize(fn) {
+  let cache;
+  return () => {
+    if (!cache) {
+      cache = fn().catch((err) => {
+        cache = void 0;
+        throw err;
+      });
+    }
+    return cache;
+  };
+}
+var getDenominazioni = memoize(() => request("/bff-opendata/v1/api/v1/tipologiche/denominazione-atto"));
+var getClassiProvvedimento = memoize(() => request("/bff-opendata/v1/api/v1/tipologiche/classe-provvedimento"));
+var getCollezioniPredefinite = memoize(() => request("/bff-opendata/v1/api/v1/collections/collection-predefinite"));
+var getRicerchePredefinite = memoize(() => request("/bff-opendata/v1/api/v1/ricerca/predefinita"));
+
+// ../core/dist/html.js
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  hellip: "\u2026",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  bull: "\u2022",
+  middot: "\xB7",
+  euro: "\u20AC",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  agrave: "\xE0",
+  egrave: "\xE8",
+  eacute: "\xE9",
+  igrave: "\xEC",
+  ograve: "\xF2",
+  ugrave: "\xF9",
+  Agrave: "\xC0",
+  Egrave: "\xC8",
+  Eacute: "\xC9",
+  Igrave: "\xCC",
+  Ograve: "\xD2",
+  Ugrave: "\xD9",
+  sect: "\xA7",
+  para: "\xB6",
+  deg: "\xB0"
+};
+function decodeEntity(entity) {
+  const numeric = /^&#(x?)([0-9a-f]+);$/i.exec(entity);
+  if (numeric && numeric[2]) {
+    const code = parseInt(numeric[2], numeric[1] ? 16 : 10);
+    if (Number.isFinite(code) && code > 0 && code <= 1114111) {
+      try {
+        return String.fromCodePoint(code);
+      } catch {
+        return entity;
+      }
+    }
+    return entity;
+  }
+  const named = /^&([a-z]+);$/i.exec(entity);
+  if (named && named[1]) {
+    return NAMED_ENTITIES[named[1]] ?? entity;
+  }
+  return entity;
+}
+function htmlToText(html) {
+  return html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<a\b[^>]*?\bhref=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, inner) => {
+    const urn = /urn:[a-z]+(?::[^\s"'&<>]+)+/i.exec(href);
+    return urn ? `${inner} [${urn[0]}]` : inner;
+  }).replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|h[1-6]|li|tr|article|section)>/gi, "\n").replace(/<div\b/gi, "\n<div").replace(/<[^>]+>/g, "").replace(/&(?:#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, decodeEntity).replace(/[ \t]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// ../core/dist/tools.js
+var dateString = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use ISO date YYYY-MM-DD");
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function jsonContent(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function registerTools(server, _ctx) {
+  server.registerTool("search_acts", {
+    title: "Search Italian legislation (Normattiva)",
+    description: "Search Italian legislation on Normattiva by free text, title, act type, year/number, date range, or vigenza class. Returns metadata for each matching atto including codice_redazionale and data_gu, which are required to fetch article text via read_article. The denominazione parameter expects an Italian act-type label like 'LEGGE' or 'DECRETO LEGISLATIVO' \u2014 see resource normattiva://tipologiche/denominazioni for the full list.",
+    inputSchema: {
+      testo: z.string().optional().describe("Keywords searched in the act body."),
+      titolo: z.string().optional().describe("Keywords searched in the act title."),
+      denominazione: z.string().optional().describe("Italian act-type label, e.g. 'LEGGE', 'DECRETO LEGISLATIVO', 'DECRETO DEL PRESIDENTE DELLA REPUBBLICA'."),
+      anno: z.number().int().optional().describe("Year of the provvedimento."),
+      numero: z.string().optional().describe("Number of the provvedimento."),
+      mese: z.number().int().min(1).max(12).optional(),
+      giorno: z.number().int().min(1).max(31).optional(),
+      data_emanazione_da: dateString.optional(),
+      data_emanazione_a: dateString.optional(),
+      data_pubblicazione_da: dateString.optional(),
+      data_pubblicazione_a: dateString.optional(),
+      classe: z.enum(["1", "2", "3"]).optional().describe("Vigenza class: 1=senza aggiornamenti (single-version atto), 2=aggiornato, 3=abrogato."),
+      codice_tipo: z.string().optional().describe("Faceted filter: act-type code (e.g. 'PLE' for LEGGE)."),
+      data_vigenza: dateString.optional().describe("Restrict results to atti in force on this date (YYYY-MM-DD). Maps to the spec's 'vigenza' field."),
+      page: z.number().int().min(1).default(1),
+      per_page: z.number().int().min(1).max(50).default(5),
+      order: z.enum(["recente", "vecchio"]).default("recente")
+    }
+  }, async (args) => {
+    const body = {
+      orderType: args.order,
+      paginazione: {
+        paginaCorrente: args.page,
+        numeroElementiPerPagina: args.per_page
+      }
+    };
+    if (args.testo)
+      body.testoRicerca = args.testo;
+    if (args.titolo)
+      body.titoloRicerca = args.titolo;
+    if (args.denominazione)
+      body.denominazioneAtto = args.denominazione;
+    if (args.anno !== void 0)
+      body.annoProvvedimento = String(args.anno);
+    if (args.numero)
+      body.numeroProvvedimento = args.numero;
+    if (args.mese !== void 0)
+      body.meseProvvedimento = String(args.mese);
+    if (args.giorno !== void 0)
+      body.giornoProvvedimento = String(args.giorno);
+    if (args.data_emanazione_da)
+      body.dataInizioEmanazione = args.data_emanazione_da;
+    if (args.data_emanazione_a)
+      body.dataFineEmanazione = args.data_emanazione_a;
+    if (args.data_pubblicazione_da)
+      body.dataInizioPubProvvedimento = args.data_pubblicazione_da;
+    if (args.data_pubblicazione_a)
+      body.dataFinePubProvvedimento = args.data_pubblicazione_a;
+    if (args.classe)
+      body.classeProvvedimento = args.classe;
+    if (args.data_vigenza)
+      body.vigenza = args.data_vigenza;
+    if (args.codice_tipo)
+      body.filtriMap = { codice_tipo_provvedimento: args.codice_tipo };
+    const data = await ricercaAvanzata(body);
+    return jsonContent({
+      totale_atti: data.numeroAttiTrovati ?? 0,
+      pagine_totali: data.numeroPagine ?? 0,
+      pagina_corrente: data.paginaCorrente ?? args.page,
+      atti: (data.listaAtti ?? []).map((a) => ({
+        anno: a.annoProvvedimento,
+        numero: a.numeroProvvedimento,
+        denominazione: a.denominazioneAtto,
+        descrizione: a.descrizioneAtto,
+        titolo: a.titoloAtto,
+        codice_redazionale: a.codiceRedazionale,
+        data_gu: a.dataGU,
+        data_emanazione: a.dataEmanazione,
+        data_pubblicazione: a.dataPubblicazione,
+        classe: a.classeProvvedimento
+      }))
     });
-    registerTools(server);
-    registerResources(server);
-    registerPrompts(server);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+  });
+  server.registerTool("read_article", {
+    title: "Read one article of an Italian act",
+    description: "Fetches the text of a single article of a specific atto, at a given date of vigenza. Prefer calling search_acts first to obtain codice_redazionale and data_gu, then list_articles to discover which article numbers exist, and finally read_article on the relevant ones (you may call it in parallel for multiple articles of the same atto). Returns plain text by default; pass format='html' for the original markup (which preserves amendment markers). The text format inlines URN citations as 'L. 5/2003 [urn:nir:stato:legge:2003-06-05;131]'. When the article does not exist (wrong sotto_articolo, id_gruppo or articolo number) the tool returns {found:false, reason, ...} instead of throwing \u2014 successful responses include {found:true}. Note: 'bis'/'ter' suffixes require sotto_articolo (1=base, 2=bis, 3=ter, ...), and some atti (e.g. structured codes) require a non-zero id_gruppo whose value is not synchronously discoverable.",
+    inputSchema: {
+      data_gu: dateString.describe("Publication date in Gazzetta Ufficiale (from search_acts)."),
+      codice_redazionale: z.string().describe("Editorial code of the atto (from search_acts)."),
+      articolo: z.number().int().describe("Article number."),
+      sotto_articolo: z.number().int().min(1).default(1).describe("Article suffix index. 1 = base article (e.g. 'art. 13'), 2 = bis, 3 = ter, 4 = quater, ..."),
+      sotto_articolo_1: z.number().int().default(0),
+      data_vigenza: dateString.default(todayIso).describe("Date at which to read the article (defaults to today)."),
+      id_gruppo: z.number().int().default(0),
+      progressivo: z.number().int().default(0),
+      versione: z.number().int().default(0).describe("Version selector. 0 (default) is the standard choice and pairs with data_vigenza to return the in-force text on that date."),
+      format: z.enum(["text", "html"]).default("text")
+    }
+  }, async (args) => {
+    const data = await dettaglioAtto({
+      dataGU: args.data_gu,
+      codiceRedazionale: args.codice_redazionale,
+      idArticolo: args.articolo,
+      sottoArticolo: args.sotto_articolo,
+      sottoArticolo1: args.sotto_articolo_1,
+      dataVigenza: args.data_vigenza,
+      idGruppo: args.id_gruppo,
+      progressivo: args.progressivo,
+      versione: args.versione
+    });
+    if (!data.success || !data.data?.atto) {
+      return jsonContent({
+        found: false,
+        reason: "no-such-article",
+        message: data.message ?? null,
+        richiesta: {
+          articolo: args.articolo,
+          sotto_articolo: args.sotto_articolo,
+          codice_redazionale: args.codice_redazionale,
+          data_gu: args.data_gu,
+          data_vigenza: args.data_vigenza,
+          id_gruppo: args.id_gruppo
+        }
+      });
+    }
+    const atto = data.data.atto;
+    const html = atto.articoloHtml ?? "";
+    const articolo_testo = args.format === "html" ? html : htmlToText(html);
+    return jsonContent({
+      found: true,
+      titolo: atto.titolo,
+      tipo: atto.tipoProvvedimentoDescrizione,
+      codice_tipo: atto.tipoProvvedimentoCodice,
+      format: args.format,
+      articolo: articolo_testo,
+      data_inizio_vigenza: atto.articoloDataInizioVigenza,
+      data_fine_vigenza: atto.articoloDataFineVigenza
+    });
+  });
+  server.registerTool("list_articles", {
+    title: "List articles of an Italian act (sequential probe)",
+    description: "Discovers which articles exist in an atto by probing dettaglio-atto sequentially from articolo=1. Normattiva OpenData has no synchronous table-of-contents endpoint, so this is a best-effort enumeration. By default only base articles (sotto_articolo=1) are discovered; pass include_suffixes=true to also probe bis/ter/quater/... for each base article (extra round-trips, stops at the first miss per article). Articles inside structured groups (id_gruppo!=0) are not discovered automatically. Each probe is a real API call. The base probe stops early once a full chunk yields no results after at least one article has been found. Use this before read_article when you need to know the article range.",
+    inputSchema: {
+      data_gu: dateString.describe("Publication date in Gazzetta Ufficiale (from search_acts)."),
+      codice_redazionale: z.string().describe("Editorial code of the atto (from search_acts)."),
+      data_vigenza: dateString.default(todayIso).describe("Date at which to test article existence (defaults to today)."),
+      max_articoli: z.number().int().min(1).max(200).default(30).describe("Hard cap on the highest article number to probe."),
+      id_gruppo: z.number().int().default(0).describe("Article-group id (default 0). Non-zero values target a specific group inside a structured atto."),
+      include_suffixes: z.boolean().default(false).describe("If true, after finding base articles also probe sotto_articolo=2,3,... for each one until the first miss, discovering bis/ter/quater/... Adds 1-N extra calls per base article.")
+    }
+  }, async (args) => {
+    const CHUNK = 5;
+    const ABROGATED_RE = /\(\(\s*ARTICOLO\s+ABROGATO/i;
+    const SUFFIX_LABELS = [
+      "base",
+      "bis",
+      "ter",
+      "quater",
+      "quinquies",
+      "sexies",
+      "septies",
+      "octies",
+      "novies",
+      "decies"
+    ];
+    const MAX_SUFFIX_INDEX = SUFFIX_LABELS.length;
+    const found = [];
+    let probedUpTo = 0;
+    let stoppedEarly = false;
+    for (let start = 1; start <= args.max_articoli; start += CHUNK) {
+      const end = Math.min(start + CHUNK - 1, args.max_articoli);
+      const batch = await Promise.all(Array.from({ length: end - start + 1 }, (_, i) => start + i).map(async (n) => {
+        try {
+          const data = await dettaglioAtto({
+            dataGU: args.data_gu,
+            codiceRedazionale: args.codice_redazionale,
+            idArticolo: n,
+            sottoArticolo: 1,
+            sottoArticolo1: 0,
+            dataVigenza: args.data_vigenza,
+            idGruppo: args.id_gruppo,
+            progressivo: 0,
+            versione: 0
+          });
+          if (!data.success || !data.data?.atto?.articoloHtml) {
+            return { articolo: n, ok: false };
+          }
+          const html = data.data.atto.articoloHtml;
+          const isArticle = /<h2[^>]*class="[^"]*article-num-akn[^"]*"[^>]*>\s*Art\.\s/i.test(html);
+          const text = htmlToText(html);
+          const preview = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).slice(0, 4).join(" \u2014 ").slice(0, 200);
+          return {
+            articolo: n,
+            ok: true,
+            titolo: preview,
+            is_preamble: !isArticle,
+            is_abrogated: ABROGATED_RE.test(text)
+          };
+        } catch (err) {
+          if (err instanceof McpError2 && err.code === ErrorCode2.InvalidRequest) {
+            return { articolo: n, ok: false };
+          }
+          throw err;
+        }
+      }));
+      probedUpTo = end;
+      const hits = batch.filter((b) => b.ok);
+      for (const h of hits) {
+        if (h.ok) {
+          const entry = {
+            articolo: h.articolo,
+            titolo: h.titolo
+          };
+          if (h.is_preamble)
+            entry.is_preamble = true;
+          if (h.is_abrogated)
+            entry.is_abrogated = true;
+          found.push(entry);
+        }
+      }
+      if (hits.length === 0 && found.length > 0) {
+        stoppedEarly = true;
+        break;
+      }
+    }
+    const suffixHits = [];
+    if (args.include_suffixes && found.length > 0) {
+      let live = found.filter((f) => !f.is_preamble).map((f) => f.articolo);
+      for (let sa = 2; sa <= MAX_SUFFIX_INDEX && live.length > 0; sa++) {
+        const round = await Promise.all(live.map(async (n) => {
+          try {
+            const data = await dettaglioAtto({
+              dataGU: args.data_gu,
+              codiceRedazionale: args.codice_redazionale,
+              idArticolo: n,
+              sottoArticolo: sa,
+              sottoArticolo1: 0,
+              dataVigenza: args.data_vigenza,
+              idGruppo: args.id_gruppo,
+              progressivo: 0,
+              versione: 0
+            });
+            if (!data.success || !data.data?.atto?.articoloHtml) {
+              return { articolo: n, hit: false };
+            }
+            const text = htmlToText(data.data.atto.articoloHtml);
+            const preview = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).slice(0, 4).join(" \u2014 ").slice(0, 200);
+            return {
+              articolo: n,
+              hit: true,
+              titolo: preview,
+              is_abrogated: ABROGATED_RE.test(text)
+            };
+          } catch (err) {
+            if (err instanceof McpError2 && err.code === ErrorCode2.InvalidRequest) {
+              return { articolo: n, hit: false };
+            }
+            throw err;
+          }
+        }));
+        const nextLive = [];
+        for (const r of round) {
+          if (r.hit) {
+            const sx = {
+              articolo: r.articolo,
+              sotto_articolo: sa,
+              suffisso: SUFFIX_LABELS[sa - 1] ?? `sotto_articolo_${sa}`,
+              titolo: r.titolo
+            };
+            if (r.is_abrogated)
+              sx.is_abrogated = true;
+            suffixHits.push(sx);
+            nextLive.push(r.articolo);
+          }
+        }
+        live = nextLive;
+      }
+    }
+    const articoli = [];
+    for (const base of found) {
+      articoli.push(base);
+      const itsSuffixes = suffixHits.filter((s) => s.articolo === base.articolo).sort((a, b) => (a.sotto_articolo ?? 0) - (b.sotto_articolo ?? 0));
+      for (const sx of itsSuffixes)
+        articoli.push(sx);
+    }
+    return jsonContent({
+      codice_redazionale: args.codice_redazionale,
+      data_gu: args.data_gu,
+      data_vigenza: args.data_vigenza,
+      id_gruppo: args.id_gruppo,
+      probed_up_to: probedUpTo,
+      stopped_early: stoppedEarly,
+      truncated: !stoppedEarly && probedUpTo === args.max_articoli,
+      include_suffixes: args.include_suffixes,
+      articoli_trovati: articoli.length,
+      articoli
+    });
+  });
+  server.registerTool("recent_updates", {
+    title: "Atti recently modified on Normattiva",
+    description: "Lists Italian normative acts whose text was modified within a date window. Useful for monitoring legislative changes. The window must be at most 12 months wide and data_fine cannot precede data_inizio.",
+    inputSchema: {
+      data_inizio: dateString.describe("Start of the modification window (YYYY-MM-DD)."),
+      data_fine: dateString.describe("End of the modification window (YYYY-MM-DD), max 12 months after data_inizio.")
+    }
+  }, async ({ data_inizio, data_fine }) => {
+    const data = await ricercaAggiornati({
+      dataInizioAggiornamento: `${data_inizio}T00:00:00.000Z`,
+      dataFineAggiornamento: `${data_fine}T23:59:59.999Z`
+    });
+    return jsonContent({
+      numero_atti: data.numeroAttiTrovati ?? 0,
+      atti: (data.listaAtti ?? []).map((a) => ({
+        descrizione: a.descrizioneAtto,
+        titolo: a.titoloAtto,
+        codice_redazionale: a.codiceRedazionale,
+        data_gu: a.dataGU,
+        data_ultima_modifica: a.dataUltimaModifica,
+        ultimi_atti_modificanti: a.ultimiAttiModificanti ? a.ultimiAttiModificanti.trim().split(/\s+/) : []
+      }))
+    });
+  });
+  server.registerTool("read_act", {
+    title: "Read an entire Italian act in one call",
+    description: "Fetches every article of an atto sequentially and returns them aggregated, capped by max_chars (default 80000 \u2248 20k Claude tokens). Useful when you want the whole law text without orchestrating list_articles + N parallel read_article calls. Probes from articolo_da onward, includes bis/ter when include_suffixes=true, and stops at the first empty chunk or when adding the next unit would exceed max_chars. Truncation is reported via {truncated, truncated_reason, articolo_successivo} so the caller can resume by re-invoking with articolo_da set to that value. Each article entry mirrors read_article output (testo + vigenza dates + is_abrogated flag).",
+    inputSchema: {
+      data_gu: dateString.describe("Publication date in Gazzetta Ufficiale (from search_acts)."),
+      codice_redazionale: z.string().describe("Editorial code of the atto (from search_acts)."),
+      data_vigenza: dateString.default(todayIso).describe("Date at which to read the atto (defaults to today)."),
+      format: z.enum(["text", "html"]).default("text"),
+      max_chars: z.number().int().min(1e3).max(5e5).default(8e4).describe("Soft cap on the total number of characters across all aggregated articles. Checked before adding each unit. Default \u2248 20k Claude tokens."),
+      max_articoli: z.number().int().min(1).max(200).default(50).describe("Hard cap on how many base article numbers to probe past articolo_da."),
+      articolo_da: z.number().int().min(1).default(1).describe("Starting article number. Set to articolo_successivo from a previous truncated response to resume."),
+      include_suffixes: z.boolean().default(false).describe("If true, after each base article also fetch its bis/ter/quater/... chain. Each suffix counts against max_chars. If the budget runs out mid-chain, the remaining suffixes of that article are skipped \u2014 fetch them with read_article if needed."),
+      id_gruppo: z.number().int().default(0).describe("Article-group id. Non-zero values target a specific group inside a structured atto.")
+    }
+  }, async (args) => {
+    const CHUNK = 5;
+    const SUFFIX_LABELS = [
+      "base",
+      "bis",
+      "ter",
+      "quater",
+      "quinquies",
+      "sexies",
+      "septies",
+      "octies",
+      "novies",
+      "decies"
+    ];
+    const ABROGATED_RE = /\(\(\s*ARTICOLO\s+ABROGATO/i;
+    const articoli = [];
+    let totalChars = 0;
+    let attoTitolo;
+    let attoTipo;
+    let attoCodiceTipo;
+    let probedUpTo = args.articolo_da - 1;
+    let stoppedEarly = false;
+    let truncatedReason = null;
+    let articoloSuccessivo = null;
+    const fetchUnit = async (n, sa) => {
+      try {
+        const data = await dettaglioAtto({
+          dataGU: args.data_gu,
+          codiceRedazionale: args.codice_redazionale,
+          idArticolo: n,
+          sottoArticolo: sa,
+          sottoArticolo1: 0,
+          dataVigenza: args.data_vigenza,
+          idGruppo: args.id_gruppo,
+          progressivo: 0,
+          versione: 0
+        });
+        if (!data.success || !data.data?.atto?.articoloHtml)
+          return null;
+        const atto = data.data.atto;
+        const html = atto.articoloHtml;
+        if (typeof html !== "string")
+          return null;
+        attoTitolo ??= atto.titolo;
+        attoTipo ??= atto.tipoProvvedimentoDescrizione;
+        attoCodiceTipo ??= atto.tipoProvvedimentoCodice;
+        const isArticle = /<h2[^>]*class="[^"]*article-num-akn[^"]*"[^>]*>\s*Art\.\s/i.test(html);
+        const testo = args.format === "html" ? html : htmlToText(html);
+        return {
+          testo,
+          isArticle,
+          // The '((ARTICOLO ABROGATO' marker is plain text in both formats —
+          // test on the raw HTML to avoid an extra conversion when format=html.
+          isAbrogated: ABROGATED_RE.test(html),
+          atto
+        };
+      } catch (err) {
+        if (err instanceof McpError2 && err.code === ErrorCode2.InvalidRequest)
+          return null;
+        throw err;
+      }
+    };
+    const upperBound = args.articolo_da + args.max_articoli - 1;
+    outer: for (let start = args.articolo_da; start <= upperBound; start += CHUNK) {
+      const end = Math.min(start + CHUNK - 1, upperBound);
+      const numbers = Array.from({ length: end - start + 1 }, (_, i) => start + i);
+      const baseResults = await Promise.all(numbers.map((n) => fetchUnit(n, 1).then((r) => ({ n, r }))));
+      probedUpTo = end;
+      const hits = baseResults.filter((x) => x.r !== null);
+      if (hits.length === 0 && articoli.length > 0) {
+        stoppedEarly = true;
+        break;
+      }
+      for (const { n, r } of baseResults) {
+        if (!r)
+          continue;
+        if (totalChars + r.testo.length > args.max_chars && articoli.length > 0) {
+          truncatedReason = "max_chars";
+          articoloSuccessivo = n;
+          break outer;
+        }
+        const entry = {
+          articolo: n,
+          testo: r.testo,
+          data_inizio_vigenza: r.atto.articoloDataInizioVigenza,
+          data_fine_vigenza: r.atto.articoloDataFineVigenza
+        };
+        if (!r.isArticle)
+          entry.is_preamble = true;
+        if (r.isAbrogated)
+          entry.is_abrogated = true;
+        articoli.push(entry);
+        totalChars += r.testo.length;
+        if (args.include_suffixes && r.isArticle) {
+          for (let sa = 2; sa < SUFFIX_LABELS.length; sa++) {
+            const sx = await fetchUnit(n, sa);
+            if (!sx)
+              break;
+            if (totalChars + sx.testo.length > args.max_chars) {
+              truncatedReason = "max_chars";
+              articoloSuccessivo = n + 1;
+              entry.suffixes_truncated = true;
+              break outer;
+            }
+            const sxEntry = {
+              articolo: n,
+              sotto_articolo: sa,
+              suffisso: SUFFIX_LABELS[sa - 1] ?? `sotto_articolo_${sa}`,
+              testo: sx.testo,
+              data_inizio_vigenza: sx.atto.articoloDataInizioVigenza,
+              data_fine_vigenza: sx.atto.articoloDataFineVigenza
+            };
+            if (sx.isAbrogated)
+              sxEntry.is_abrogated = true;
+            articoli.push(sxEntry);
+            totalChars += sx.testo.length;
+          }
+        }
+      }
+    }
+    const exhaustedRange = truncatedReason === null && probedUpTo >= upperBound && !stoppedEarly;
+    return jsonContent({
+      titolo: attoTitolo ?? null,
+      tipo: attoTipo ?? null,
+      codice_tipo: attoCodiceTipo ?? null,
+      codice_redazionale: args.codice_redazionale,
+      data_gu: args.data_gu,
+      data_vigenza: args.data_vigenza,
+      format: args.format,
+      articolo_da: args.articolo_da,
+      probed_up_to: probedUpTo,
+      stopped_early: stoppedEarly,
+      truncated: truncatedReason !== null || exhaustedRange,
+      truncated_reason: truncatedReason ?? (exhaustedRange ? "max_articoli" : null),
+      articolo_successivo: articoloSuccessivo ?? (exhaustedRange ? upperBound + 1 : null),
+      char_count: totalChars,
+      articoli_inclusi: articoli.length,
+      include_suffixes: args.include_suffixes,
+      articoli
+    });
+  });
+}
+
+// ../core/dist/resources.js
+function jsonResource(uri, data) {
+  return {
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function registerResources(server, _ctx) {
+  server.registerResource("denominazioni", "normattiva://tipologiche/denominazioni", {
+    title: "Codici denominazione atto",
+    description: "List of valid act-type codes accepted by Normattiva (label = code, value = full Italian description). Use the value (e.g. 'LEGGE') for the denominazione parameter of search_acts.",
+    mimeType: "application/json"
+  }, async (uri) => jsonResource(uri, await getDenominazioni()));
+  server.registerResource("classi-provvedimento", "normattiva://tipologiche/classi-provvedimento", {
+    title: "Classi di provvedimento (vigenza)",
+    description: "Vigenza class codes: 1 = atto senza aggiornamenti, 2 = aggiornato, 3 = abrogato. Use the label as the classe parameter of search_acts.",
+    mimeType: "application/json"
+  }, async (uri) => jsonResource(uri, await getClassiProvvedimento()));
+  server.registerResource("collezioni-predefinite", "normattiva://collezioni-predefinite", {
+    title: "Collezioni preconfezionate Normattiva",
+    description: "Predefined collections of acts available on Normattiva, with the number of acts in each.",
+    mimeType: "application/json"
+  }, async (uri) => jsonResource(uri, await getCollezioniPredefinite()));
+  server.registerResource("ricerche-predefinite", "normattiva://ricerche-predefinite", {
+    title: "Ricerche predefinite Normattiva",
+    description: "Predefined searches with their preset filters (date ranges, classe, etc.).",
+    mimeType: "application/json"
+  }, async (uri) => jsonResource(uri, await getRicerchePredefinite()));
+}
+
+// ../core/dist/prompts.js
+import { z as z2 } from "zod";
+function registerPrompts(server, _ctx) {
+  server.registerPrompt("ricerca-articolo", {
+    title: "Cerca un articolo per argomento",
+    description: "Cerca atti normativi italiani su un argomento e legge gli articoli pi\xF9 rilevanti.",
+    argsSchema: {
+      argomento: z2.string().describe("Argomento di interesse, es. 'protezione dei dati personali'.")
+    }
+  }, ({ argomento }) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Voglio capire la normativa italiana su: ${argomento}.
+
+Procedi cos\xEC:
+1. Usa lo strumento search_acts per individuare gli atti normativi pi\xF9 rilevanti sull'argomento.
+2. Identifica l'atto (o gli atti) pi\xF9 pertinenti dai risultati.
+3. Usa read_article per leggere gli articoli pi\xF9 probabilmente rilevanti \u2014 fino a circa 10 articoli, scelti in base ai titoli/descrizioni.
+4. Fornisci una sintesi chiara con i riferimenti normativi (atto, articolo) per ogni punto.`
+        }
+      }
+    ]
+  }));
+  server.registerPrompt("monitoraggio-modifiche", {
+    title: "Monitora modifiche normative recenti",
+    description: "Recupera gli atti normativi italiani modificati negli ultimi N giorni e ne fornisce un riepilogo.",
+    argsSchema: {
+      giorni: z2.string().regex(/^\d+$/, "Numero di giorni come stringa intera").default("7").describe("Quanti giorni indietro guardare (default 7).")
+    }
+  }, ({ giorni }) => {
+    const n = Number.parseInt(giorni ?? "7", 10);
+    const oggi = /* @__PURE__ */ new Date();
+    const inizio = new Date(oggi.getTime() - n * 24 * 60 * 60 * 1e3);
+    const fmt = (d) => d.toISOString().slice(0, 10);
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Recupera con recent_updates gli atti normativi italiani modificati tra il ${fmt(inizio)} e il ${fmt(oggi)}. Raggruppa i risultati per tipologia di atto e fornisci un riepilogo delle modifiche pi\xF9 rilevanti, evidenziando gli atti modificanti principali.`
+          }
+        }
+      ]
+    };
+  });
+}
+
+// dist/index.js
+async function main() {
+  const server = new McpServer({
+    name: "normattiva-mcp",
+    version: "0.1.2"
+  });
+  const ctx = {};
+  registerTools(server, ctx);
+  registerResources(server, ctx);
+  registerPrompts(server, ctx);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 }
 main().catch((err) => {
-    console.error("[normattiva-mcp] fatal:", err);
-    process.exit(1);
+  console.error("[normattiva-mcp] fatal:", err);
+  process.exit(1);
 });