fix(senato-votes): elimina i 403 da query troppo lunga (chunking + query compatta) (#76)

aborruso · claude · web-flow · commit 3d2ff2eecea3 · 2026-07-25T16:07:15.000+02:00
* fix(senato-votes): spezza le OR-chain in query da 25 termini (#72) L'endpoint Senato respinge con 403 le richieste con query string oltre ~2 KB, e il POST è sempre rifiutato: l'unica strada è tenere corta la GET. Con 53 fiducie in leg. 19 la OR-chain su osr:fase superava la soglia e --keyword falliva sistematicamente. Due i punti interessati: il supplemento fiducie e il Fallback 1. Il merge resta first-wins, quindi l'esito non dipende dai confini dei blocchi. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(senato-votes): compatta la query principale sotto i 2047 byte (#72) Il chunking non bastava: la query principale sfora da sola con keyword multi-parola (2059 byte con "corte dei conti", limite 2047), e lì non c'è nessuna lista da spezzare. Indentazione rimossa e header prefissi ridotto ai due usati: 2081 -> 1926 byte di URL. La keyword entra tre volte nella query, quindi il margine non è infinito: assertQueryFits blocca in partenza le query troppo lunghe con un messaggio che dice cosa fare, invece del 403 opaco. Soglia misurata al byte per bisezione (2047 passa, 2048 no), con query di controllo a 200 prima e dopo: non è il blocco per frequenza. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(skill-cli): distingui i due 403 del Senato (dimensione vs frequenza) Stesso codice e stessa pagina di errore per due cause opposte: nel primo caso ritentare è inutile (va accorciata la query), nel secondo è dannoso. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(review): riferimento corretto alla soglia e test fedele al client - il commento sulla query compatta rimandava a SENATO_MAX_OR_TERMS, che riguarda il chunking: il vincolo qui è SENATO_MAX_REQUEST_URI - l'asserzione sulla dimensione usava encodeURIComponent su un frammento; ora sta accanto agli helper, misura con senatoRequestUriLength (stesso encoding del client) su una query intera con i suoi prefissi Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs: rimanda a SENATO_MAX_REQUEST_URI invece del valore approssimato Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
diff --git a/skills/italian-parliament-cli/SKILL.md b/skills/italian-parliament-cli/SKILL.md
@@ -115,6 +115,7 @@ Regole d'oro:
 - **Prova più sinonimi e radici di parola** prima di concludere. Preferisci la **radice** breve che copre più forme: `elett` → elettorale/elettori, `elez` → elezione/elezioni (occhio: `elezioni` al plurale non matcha un titolo con `elezione` al singolare — la radice sì); `ambient` → ambiente/ambientale. Se il tool matcha a confini di parola (es. `aic --keyword`), usa più keyword separate.
 - **Vuoto ≠ assente.** Se non trovi nulla, riformula con un sinonimo o una radice prima di dire all'utente che il dato non c'è. Solo dopo 2-3 varianti fallite l'assenza è credibile.
 - **Sindacato ispettivo (Senato) non è ricercabile per argomento**: `sindacato-ispettivo --keyword` non filtra sull'oggetto perché il LOD Senato non espone l'oggetto/testo dell'atto (solo tipo, numero, data, firmatari). Il testo vive solo nella pagina HTML esterna. Non promettere ricerche tematiche su questo tool.
+- **Sul Senato la keyword corta conviene due volte.** Oltre a matchare più forme, evita di sbattere contro il limite di dimensione delle richieste (vedi Tips): sui tool Senato la keyword entra tre volte nella query, quindi una frase lunga la fa crescere in fretta.
 
 ## Grounding (non inventare)
 
@@ -133,3 +134,7 @@ Quando ricostruisci iter, voti o schede, il rischio è la **confabulazione su sc
 - **Senato confidence votes have empty `ddl_uri` at the source**, but `senato-votes list --ddl-uri <uri>` **now returns the *fiducia* anyway** (it resolves the DDL's seduta dates and re-links the confidence vote of that day). Still check `ddl_uri` on any "final" vote found by date: it may belong to a different act (unified text). `--ddl-uri` **derives the legislature from the DDL**, so a historical DDL (e.g. leg.18 `http://dati.senato.it/ddl/52988`) works without passing `--legislature`.
 - **Senato — quando c'è il voto individuale**: `senato-vote-detail` dà il sì/no del singolo senatore solo per i voti di **merito** (`type` = `elettronica`, `nominale con appello`, `controprova`). Per `segreta` (voto segreto) e `verifica numero legale` (conteggio del quorum) restituisce solo le presenze (`Presente non votante`, `In congedo/missione`), **mai** una scelta espressa (né `Favorevole`, né `Contrario`, né `Astenuto`): la scelta non è nel dato. Non dedurre il voto individuale su queste due modalità.
 - **Question time Camera per sede**: le interrogazioni a risposta immediata hanno la sede nel label in modo regolare, e `aic --type` matcha anche sul label. Quindi la sede è già filtrabile senza campo dedicato: `aic list --type "immediata in assemblea"` = question time in Aula, `aic list --type "immediata in commissione"` = in commissione (combinabile con `--keyword <tema>`).
+- **Senato: due errori diversi si presentano allo stesso modo.** L'endpoint del Senato accetta richieste fino a **2047 byte** di URL e rifiuta le più lunghe, ma risponde `403` sia in quel caso sia quando le richieste sono troppo ravvicinate — e la pagina di errore è identica. Regola pratica:
+  - **"Query troppo lunga per l'endpoint del Senato"** (errore della CLI, prima di uscire in rete): accorcia la keyword — una radice breve basta, il match è per sottostringa — oppure restringi l'intervallo di date. Ritentare identico non serve a nulla.
+  - **`403` restituito dall'endpoint**: sono troppe richieste ravvicinate. Aspetta qualche minuto, non ritentare a raffica. La CLI già distanzia di 2 secondi le proprie chiamate al Senato: il blocco arriva quando si sommano più comandi o test in sequenza.
+  - Nota: il limite riguarda **solo il Senato**. La Camera accetta richieste molto più grandi.
diff --git a/src/core/chunk.test.ts b/src/core/chunk.test.ts
@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { chunk } from "./chunk.js";
+
+describe("chunk", () => {
+  it("spezza in blocchi della dimensione richiesta", () => {
+    expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it("preserva l'ordine originale", () => {
+    const nums = Array.from({ length: 53 }, (_, i) => i);
+    expect(chunk(nums, 25).flat()).toEqual(nums);
+  });
+
+  it("restituisce un solo blocco se la lista è più corta della dimensione", () => {
+    expect(chunk(["a", "b"], 25)).toEqual([["a", "b"]]);
+  });
+
+  it("restituisce lista vuota su input vuoto (nessuna query a vuoto)", () => {
+    expect(chunk([], 25)).toEqual([]);
+  });
+
+  it("rifiuta una dimensione non valida", () => {
+    expect(() => chunk([1, 2], 0)).toThrow();
+  });
+});
diff --git a/src/core/chunk.ts b/src/core/chunk.ts
@@ -0,0 +1,18 @@
+/**
+ * Spezza una lista in blocchi di al più `size` elementi, preservando l'ordine.
+ *
+ * Serve a tenere corte le query SPARQL costruite come OR-chain su una lista di
+ * lunghezza variabile (`FILTER(STR(?x) = "a" || STR(?x) = "b" || ...)`):
+ * l'endpoint del Senato respinge con 403 le richieste oltre
+ * `SENATO_MAX_REQUEST_URI` byte, e il POST non è un'alternativa (è sempre
+ * rifiutato). Con una lista che cresce — es. le fiducie di un'intera
+ * legislatura — la query supera la soglia e il tool smette di funzionare.
+ */
+export function chunk<T>(items: readonly T[], size: number): T[][] {
+  if (size < 1) throw new Error("chunk: size deve essere >= 1");
+  const out: T[][] = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
diff --git a/src/core/senato-query-size.test.ts b/src/core/senato-query-size.test.ts
@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import {
+  SENATO_MAX_OR_TERMS,
+  SENATO_MAX_REQUEST_URI,
+  senatoRequestUriLength,
+  assertQueryFits,
+} from "./senato-query-size.js";
+import { chunk } from "./chunk.js";
+import { OSR_PREFIXES } from "./prefixes.js";
+
+describe("senato-query-size", () => {
+  it("misura la request-URI con l'encoding usato dal client", () => {
+    // "/sparql?" + "query=" + "a" + "&format=application%2Fjson"
+    // (URLSearchParams encoda anche lo slash: 26 byte, non 24)
+    expect(senatoRequestUriLength("a")).toBe(8 + 6 + 1 + 26);
+  });
+
+  it("lascia passare una query sotto la soglia", () => {
+    expect(() => assertQueryFits("SELECT ?s WHERE { ?s ?p ?o }")).not.toThrow();
+  });
+
+  it("blocca la query oltre la soglia con un messaggio che dice cosa fare", () => {
+    const q = `SELECT ?s WHERE { ?s ?p "${"x".repeat(SENATO_MAX_REQUEST_URI)}" }`;
+    expect(() => assertQueryFits(q, "corte dei conti")).toThrow(
+      /Query troppo lunga.*corte dei conti/s,
+    );
+  });
+
+  it("la OR-chain delle fiducie sfora intera, a blocchi di SENATO_MAX_OR_TERMS no", () => {
+    // 53 fiducie in leg. 19: è il caso reale che mandava --keyword in 403.
+    const nums = Array.from({ length: 53 }, (_, i) => String(1000 + i));
+    const query = (batch: string[]) => `${OSR_PREFIXES}
+SELECT ?ddl ?f WHERE {
+  ?ddl a osr:Ddl ; osr:legislatura 19 ; osr:fase ?f .
+  FILTER(${batch.map((n) => `STR(?f) = "S.${n}"`).join(" || ")})
+}`;
+    expect(senatoRequestUriLength(query(nums))).toBeGreaterThan(
+      SENATO_MAX_REQUEST_URI,
+    );
+    for (const batch of chunk(nums, SENATO_MAX_OR_TERMS)) {
+      expect(() => assertQueryFits(query(batch))).not.toThrow();
+    }
+  });
+
+  it("il confine è esattamente 2047 accettata / 2048 rifiutata", () => {
+    // padding calibrato sulla lunghezza reale, non stimato
+    const fill = (target: number) => {
+      let q = "SELECT ?s WHERE { ?s ?p ?o }";
+      while (senatoRequestUriLength(q) < target) q += "x";
+      return q;
+    };
+    const alLimite = fill(SENATO_MAX_REQUEST_URI);
+    expect(senatoRequestUriLength(alLimite)).toBe(2047);
+    expect(() => assertQueryFits(alLimite)).not.toThrow();
+    expect(() => assertQueryFits(alLimite + "x")).toThrow();
+  });
+});
diff --git a/src/core/senato-query-size.ts b/src/core/senato-query-size.ts
@@ -0,0 +1,45 @@
+/**
+ * Vincoli di dimensione delle richieste all'endpoint SPARQL del Senato.
+ *
+ * Il front-end di `dati.senato.it` accetta una request-URI (`/sparql?query=…`)
+ * fino a **2047 byte** e respinge da 2048 in su con una pagina 403 HTML, non
+ * con un errore SPARQL né con un 414. Misurato per bisezione il 25/7/2026, con
+ * query di controllo a 200 subito prima e subito dopo: non è il blocco per
+ * frequenza, che invece respinge anche le richieste minime. Il POST è sempre
+ * rifiutato, quindi non c'è modo di aggirare il limite spostando la query nel
+ * corpo: l'unica strada è tenere corta la GET.
+ */
+export const SENATO_MAX_REQUEST_URI = 2047;
+
+/**
+ * Massimo numero di termini in una OR-chain (`FILTER(STR(?x) = "a" || …)`) per
+ * singola query. 45 termini sfiorano la soglia, 50 la superano: 25 lascia
+ * margine anche quando il resto della query cresce, al costo di una query in
+ * più ogni 25 elementi.
+ */
+export const SENATO_MAX_OR_TERMS = 25;
+
+/**
+ * Lunghezza della request-URI che il client produrrebbe per questa query,
+ * calcolata con lo stesso encoding di `URLSearchParams` usato in `client.ts`.
+ */
+export function senatoRequestUriLength(query: string): number {
+  const params = new URLSearchParams({ query, format: "application/json" });
+  return "/sparql?".length + params.toString().length;
+}
+
+/**
+ * Blocca in partenza le query troppo lunghe con un messaggio che dice cosa
+ * fare, invece di lasciare arrivare un 403 opaco — indistinguibile, lato
+ * client, dal blocco per frequenza.
+ */
+export function assertQueryFits(query: string, keyword?: string): void {
+  const len = senatoRequestUriLength(query);
+  if (len <= SENATO_MAX_REQUEST_URI) return;
+  const perche = keyword
+    ? ` La parola chiave "${keyword}" pesa circa tre volte la sua lunghezza: accorciala (una radice più corta basta, il match è per sottostringa)`
+    : " Restringi i filtri";
+  throw new Error(
+    `Query troppo lunga per l'endpoint del Senato: ${len} byte di request-URI, il massimo accettato è ${SENATO_MAX_REQUEST_URI}.${perche} oppure aggiungi un intervallo di date più stretto.`,
+  );
+}
diff --git a/src/tools/senato-votes.ts b/src/tools/senato-votes.ts
@@ -4,6 +4,11 @@ import { OSR_PREFIXES } from "../core/prefixes.js";
 import { flattenBindings } from "../core/flatten.js";
 import { actHtmlUrl, ddlRssUrl } from "../core/html-url.js";
 import { extractBillNumber } from "../core/bill-number.js";
+import { chunk } from "../core/chunk.js";
+import {
+  SENATO_MAX_OR_TERMS,
+  assertQueryFits,
+} from "../core/senato-query-size.js";
 import type { Tool } from "./types.js";
 
 /**
@@ -347,22 +352,24 @@ WHERE {
         .filter((v) => v.bill_number);
       if (cand.length === 0) return [];
       const nums = [...new Set(cand.map((v) => v.bill_number))];
-      const filter = nums.map((n) => `STR(?f) = "S.${n}"`).join(" || ");
-      const fq = `${OSR_PREFIXES}
+      const byNum = new Map<string, { ddl: string; titolo: string }>();
+      for (const batch of chunk(nums, SENATO_MAX_OR_TERMS)) {
+        const filter = batch.map((n) => `STR(?f) = "S.${n}"`).join(" || ");
+        const fq = `${OSR_PREFIXES}
 SELECT ?ddl ?f ?titolo ?titoloBreve WHERE {
   ?ddl a osr:Ddl ; osr:legislatura ${effectiveLeg} ; osr:fase ?f .
   OPTIONAL { ?ddl osr:titolo ?titolo }
   OPTIONAL { ?ddl osr:titoloBreve ?titoloBreve }
   FILTER(${filter})
 }`;
-      const byNum = new Map<string, { ddl: string; titolo: string }>();
-      for (const r of flattenBindings(await snQuery(fq))) {
-        const num = (r.f ?? "").replace(/^S\./, "");
-        if (num && r.ddl && !byNum.has(num))
-          byNum.set(num, {
-            ddl: r.ddl,
-            titolo: `${r.titolo ?? ""} ${r.titoloBreve ?? ""}`,
-          });
+        for (const r of flattenBindings(await snQuery(fq))) {
+          const num = (r.f ?? "").replace(/^S\./, "");
+          if (num && r.ddl && !byNum.has(num))
+            byNum.set(num, {
+              ddl: r.ddl,
+              titolo: `${r.titolo ?? ""} ${r.titoloBreve ?? ""}`,
+            });
+        }
       }
       const kw = input.keyword!.toLowerCase();
       return cand.filter((v) => {
@@ -457,30 +464,34 @@ SELECT DISTINCT ?date ?label WHERE {
     // set è piccolo: niente LIMIT/OFFSET server, paginiamo in TS dopo il
     // post-filtro (altrimenti il LIMIT taglierebbe prima del filtro).
     const paginate = input.ddlUri ? "" : `LIMIT ${input.limit}\nOFFSET ${input.offset}`;
-    const coreSelect = `SELECT DISTINCT ?v ?date ?numero ?tipo ?label ?esito
-                ?favorevoli ?contrari ?astenuti ?presenti ?votanti ?maggioranza
-                ?ddl ?oggetto
+    // Query scritta compatta di proposito: indentazione e a capo finiscono
+    // nella request-URI, che oltre SENATO_MAX_REQUEST_URI byte viene respinta
+    // con 403 (di qui assertQueryFits, sotto). La keyword entra tre volte — label, titolo e
+    // titoloBreve del DDL — quindi la lunghezza cresce di ~3 volte la keyword:
+    // il margine recuperato qui è ciò che permette le keyword multi-parola.
+    const coreSelect = `SELECT DISTINCT ?v ?date ?numero ?tipo ?label ?esito ?favorevoli ?contrari ?astenuti ?presenti ?votanti ?maggioranza ?ddl ?oggetto
 WHERE {
-  ?v a osr:Votazione ; osr:legislatura ${effectiveLeg} ; osr:seduta ?s .
-  OPTIONAL { ?s osr:dataSeduta ?date }
-  ${ddlTopicPattern}
-  ${needsLabel ? `?v rdfs:label ?label . ${labelFilter}` : "OPTIONAL { ?v rdfs:label ?label }"}
-  OPTIONAL { ?v osr:numero ?numero }
-  OPTIONAL { ?v osr:tipoVotazione ?tipo }
-  OPTIONAL { ?v osr:esito ?esito }
-  OPTIONAL { ?v osr:favorevoli ?favorevoli }
-  OPTIONAL { ?v osr:contrari ?contrari }
-  OPTIONAL { ?v osr:astenuti ?astenuti }
-  OPTIONAL { ?v osr:presenti ?presenti }
-  OPTIONAL { ?v osr:votanti ?votanti }
-  OPTIONAL { ?v osr:maggioranza ?maggioranza }
-  OPTIONAL { ?v osr:oggetto ?oggetto . OPTIONAL { ?oggetto osr:relativoA ?ddl } }
-  ${ddlDateFilter}
-  ${dateFromFilter}
-  ${dateToFilter}
+?v a osr:Votazione ; osr:legislatura ${effectiveLeg} ; osr:seduta ?s .
+OPTIONAL { ?s osr:dataSeduta ?date }
+${ddlTopicPattern}
+${needsLabel ? `?v rdfs:label ?label . ${labelFilter}` : "OPTIONAL { ?v rdfs:label ?label }"}
+OPTIONAL { ?v osr:numero ?numero } OPTIONAL { ?v osr:tipoVotazione ?tipo } OPTIONAL { ?v osr:esito ?esito }
+OPTIONAL { ?v osr:favorevoli ?favorevoli } OPTIONAL { ?v osr:contrari ?contrari } OPTIONAL { ?v osr:astenuti ?astenuti }
+OPTIONAL { ?v osr:presenti ?presenti } OPTIONAL { ?v osr:votanti ?votanti } OPTIONAL { ?v osr:maggioranza ?maggioranza }
+OPTIONAL { ?v osr:oggetto ?oggetto . OPTIONAL { ?oggetto osr:relativoA ?ddl } }
+${ddlDateFilter}
+${dateFromFilter}
+${dateToFilter}
 }`;
 
-    const query = `${OSR_PREFIXES}\n${coreSelect}\nORDER BY DESC(?date) DESC(?numero)\n${paginate}`;
+    const body = `${coreSelect}\nORDER BY DESC(?date) DESC(?numero)\n${paginate}`;
+    // Header prefissi minimo invece di OSR_PREFIXES (che ne dichiara quattro,
+    // ~180 byte): qui servono osr: e rdfs:, e xsd: solo quando un filtro data
+    // tipizza il letterale.
+    const query = `PREFIX osr: <http://dati.senato.it/osr/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>${body.includes("xsd:") ? '\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>' : ""}
+${body}`;
+    assertQueryFits(query, input.keyword);
 
     const results = await snQuery(query);
     const raw = flattenBindings(results);
@@ -526,22 +537,25 @@ WHERE {
     }
     // Fallback 1: alcuni voti (tipicamente le fiducie) non hanno osr:oggetto e
     // quindi nessun ddl_uri via grafo, ma citano il DDL nel label. Risolviamo il
-    // numero → URI in un'unica query via osr:fase="S.<num>" (univoco intra-leg;
-    // niente VALUES batch su Virtuoso → OR-chain). Solo per i label che citano
-    // davvero un DDL (bill_number non vuoto).
+    // numero → URI via osr:fase="S.<num>" (univoco intra-leg; niente VALUES
+    // batch su Virtuoso → OR-chain, spezzata in query da SENATO_MAX_OR_TERMS
+    // per non superare la soglia dei 2 KB). Solo per i label che citano davvero
+    // un DDL (bill_number non vuoto).
     let needing = [...byUri.values()].filter((v) => !v.ddl_uri && v.bill_number);
     const nums = [...new Set(needing.map((v) => v.bill_number))];
     if (nums.length) {
-      const filter = nums.map((n) => `STR(?f) = "S.${n}"`).join(" || ");
-      const fbQuery = `${OSR_PREFIXES}
+      const byFase = new Map<string, string>();
+      for (const batch of chunk(nums, SENATO_MAX_OR_TERMS)) {
+        const filter = batch.map((n) => `STR(?f) = "S.${n}"`).join(" || ");
+        const fbQuery = `${OSR_PREFIXES}
 SELECT ?ddl ?f WHERE {
   ?ddl a osr:Ddl ; osr:legislatura ${effectiveLeg} ; osr:fase ?f .
   FILTER(${filter})
 }`;
-      const byFase = new Map<string, string>();
-      for (const r of flattenBindings(await snQuery(fbQuery))) {
-        const num = (r.f ?? "").replace(/^S\./, "");
-        if (num && r.ddl && !byFase.has(num)) byFase.set(num, r.ddl);
+        for (const r of flattenBindings(await snQuery(fbQuery))) {
+          const num = (r.f ?? "").replace(/^S\./, "");
+          if (num && r.ddl && !byFase.has(num)) byFase.set(num, r.ddl);
+        }
       }
       for (const v of needing) {
         const ddl = byFase.get(v.bill_number);
