cjeu-mcp 1.0.0 → 1.1.0

package/dist/cellar.d.ts

@@ -19,3 +19,11 @@ export declare function lookupManifestations(celex: string): Promise<{
     pdfUrl: string;
     htmlUrl: string;
 }>;
+/**
+ * Download a document as bytes (PDF preferred, HTML fallback).
+ * Returns { data, format } or null if unavailable.
+ */
+export declare function downloadDocument(pdfUrl: string, htmlUrl: string): Promise<{
+    data: Buffer;
+    format: "pdf" | "html";
+} | null>;

package/dist/cellar.js

@@ -113,6 +113,50 @@ LIMIT 1`;
         return { pdfUrl: "", htmlUrl: "" };
     }
 }
+/**
+ * Download a document as bytes (PDF preferred, HTML fallback).
+ * Returns { data, format } or null if unavailable.
+ */
+export async function downloadDocument(pdfUrl, htmlUrl) {
+    // 1. Try PDF manifestation
+    if (pdfUrl) {
+        try {
+            const resp = await fetchWithTimeout(pdfUrl, {
+                headers: { "User-Agent": "cjeu-mcp/1.0", Accept: "*/*" },
+            });
+            if (resp.ok) {
+                const buf = Buffer.from(await resp.arrayBuffer());
+                if (buf.length > 0 && buf.subarray(0, 5).toString() === "%PDF-") {
+                    return { data: buf, format: "pdf" };
+                }
+            }
+        }
+        catch (e) {
+            log(`PDF download failed for ${pdfUrl}: ${e}`);
+        }
+    }
+    // 2. Try HTML manifestation
+    if (htmlUrl) {
+        try {
+            const resp = await fetchWithTimeout(htmlUrl, {
+                headers: {
+                    "User-Agent": "cjeu-mcp/1.0",
+                    Accept: "application/xhtml+xml, text/html",
+                },
+            });
+            if (resp.ok) {
+                const text = await resp.text();
+                if (text.trim() && !text.includes("awsWafCookie")) {
+                    return { data: Buffer.from(text, "utf-8"), format: "html" };
+                }
+            }
+        }
+        catch (e) {
+            log(`HTML download failed for ${htmlUrl}: ${e}`);
+        }
+    }
+    return null;
+}
 /**
  * Extract clean legal text from an HTML document using cheerio.
  * Strips navigation, headers, footers, metadata — keeps only the legal content.

package/dist/index.js

@@ -3,8 +3,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { parseCaseNumber } from "./celex.js";
-import { queryCellar, queryFirstInstance, searchByKeyword, } from "./sparql.js";
-import { fetchDocumentText, getPdfUrls, lookupManifestations, } from "./cellar.js";
+import { queryCellar, queryCellarByCelex, queryFirstInstance, searchByKeyword, } from "./sparql.js";
+import { fetchDocumentText, getPdfUrls, lookupManifestations, downloadDocument, } from "./cellar.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import archiver from "archiver";
 function log(msg) {
     process.stderr.write(`[cjeu-mcp] ${msg}\n`);
 }
@@ -204,6 +208,135 @@ server.tool("search_by_keyword", "Search CJEU case law by keyword in title/subje
     }
 });
 // ---------------------------------------------------------------------------
+// Tool 4: download_documents
+// ---------------------------------------------------------------------------
+const TYPE_TO_FRENCH = {
+    Judgment: "Arret",
+    Order: "Ordonnance",
+    "Opinion of Advocate General": "ConclusionDeAvocatGeneral",
+    "View of Advocate General": "ConclusionDeAvocatGeneral",
+    "First Instance Judgment": "ArretDePremiereInstance",
+};
+function expandHome(p) {
+    if (p.startsWith("~/") || p === "~") {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    return p;
+}
+function sanitizeForPath(caseNumber) {
+    return caseNumber.replace(/\//g, "-");
+}
+server.tool("download_documents", "Download all documents for a CJEU case as PDFs (or HTML fallback) and create a ZIP archive", {
+    caseNumber: z.string().describe("CJEU case number, e.g. C-131/12"),
+    outputDir: z
+        .string()
+        .default("~/Downloads/CJEU")
+        .describe("Folder to save documents to"),
+}, async ({ caseNumber, outputDir }) => {
+    const parsed = parseCaseNumber(caseNumber);
+    if (!parsed) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Could not parse case number: "${caseNumber}". Use format like C-131/12 or T-29/10.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const { prefix, numberPadded, fullYear, formatted } = parsed;
+    const yearStr = String(fullYear);
+    const caseDirName = sanitizeForPath(formatted);
+    log(`download_documents: ${formatted} -> ${outputDir}`);
+    // Find documents
+    let docs = await queryCellar(yearStr, numberPadded);
+    // Also fetch first-instance judgments for C- cases
+    if (prefix === "C") {
+        try {
+            const fiCelexNumbers = await queryFirstInstance(yearStr, numberPadded);
+            for (const fiCelex of fiCelexNumbers) {
+                const fiDocs = await queryCellarByCelex(fiCelex);
+                for (const d of fiDocs) {
+                    if (d.typeLabel === "Judgment") {
+                        d.typeLabel = "First Instance Judgment";
+                        docs.push(d);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            log(`First instance query failed: ${e}`);
+        }
+    }
+    if (docs.length === 0) {
+        return {
+            content: [
+                { type: "text", text: `No documents found for case ${formatted}.` },
+            ],
+        };
+    }
+    // Create output directory
+    const resolvedDir = expandHome(outputDir);
+    const caseDir = path.join(resolvedDir, caseDirName);
+    fs.mkdirSync(caseDir, { recursive: true });
+    // Pre-count types to know which need numbering
+    const typeCountsTotal = {};
+    for (const doc of docs) {
+        if (!doc.pdfAvailable && !doc.htmlAvailable)
+            continue;
+        const frenchName = TYPE_TO_FRENCH[doc.typeLabel] ?? doc.typeLabel.replace(/\s+/g, "");
+        typeCountsTotal[frenchName] = (typeCountsTotal[frenchName] ?? 0) + 1;
+    }
+    const typeCurrent = {};
+    const files = [];
+    for (const doc of docs) {
+        if (!doc.pdfAvailable && !doc.htmlAvailable) {
+            log(`Skipping ${doc.celex}: no PDF or HTML available`);
+            continue;
+        }
+        const result = await downloadDocument(doc.pdfUrl, doc.htmlUrl);
+        if (!result) {
+            log(`Failed to download ${doc.celex}`);
+            continue;
+        }
+        const frenchName = TYPE_TO_FRENCH[doc.typeLabel] ?? doc.typeLabel.replace(/\s+/g, "");
+        typeCurrent[frenchName] = (typeCurrent[frenchName] ?? 0) + 1;
+        const ext = result.format === "pdf" ? "pdf" : "html";
+        const needsNumber = (typeCountsTotal[frenchName] ?? 0) > 1;
+        const suffix = needsNumber ? `_${typeCurrent[frenchName]}` : "";
+        const fileName = `${caseDirName}_${frenchName}${suffix}.${ext}`;
+        const filePath = path.join(caseDir, fileName);
+        fs.writeFileSync(filePath, result.data);
+        files.push({
+            name: fileName,
+            type: doc.typeLabel,
+            date: doc.date,
+            format: result.format,
+        });
+    }
+    // Create ZIP
+    const zipPath = path.join(resolvedDir, `${caseDirName}.zip`);
+    await new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(zipPath);
+        const archive = archiver("zip", { zlib: { level: 9 } });
+        output.on("close", resolve);
+        archive.on("error", reject);
+        archive.pipe(output);
+        archive.directory(caseDir, caseDirName);
+        archive.finalize();
+    });
+    const result = {
+        caseNumber: formatted,
+        folder: caseDir + "/",
+        zipFile: zipPath,
+        files,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// ---------------------------------------------------------------------------
 // Start server
 // ---------------------------------------------------------------------------
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cjeu-mcp",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "MCP server for accessing EU Court of Justice case law — search cases, read judgments, AG opinions, and orders",
   "type": "module",
   "bin": {
@@ -12,19 +12,30 @@
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["mcp", "cjeu", "eu-law", "court-of-justice", "legal", "case-law"],
+  "keywords": [
+    "mcp",
+    "cjeu",
+    "eu-law",
+    "court-of-justice",
+    "legal",
+    "case-law"
+  ],
   "license": "MIT",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "archiver": "^7.0.1",
     "cheerio": "^1.0.0",
     "zod": "^3.24.0"
   },
   "devDependencies": {
-    "typescript": "^5.7.0",
-    "@types/node": "^22.0.0"
+    "@types/archiver": "^7.0.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
   }
 }