mcp-server-sibra 1.0.0

package/README.md

@@ -0,0 +1,129 @@
+# 🚌 Serveur MCP Sibra — Annecy
+
+Serveur [Model Context Protocol](https://modelcontextprotocol.io) pour interroger
+les horaires de bus du réseau **Sibra** (Grand Annecy) depuis Claude.
+
+---
+
+## Fonctionnalités
+
+| Outil | Description |
+|---|---|
+| `list_lines` | Liste toutes les lignes du réseau |
+| `search_stops` | Recherche un arrêt par nom |
+| `next_departures` | Prochains départs depuis un arrêt |
+| `line_schedule` | Premier/dernier départ d'une ligne |
+
+---
+
+## Installation
+
+### Prérequis
+
+- Node.js ≥ 18
+- npm
+
+### 1. Installer les dépendances et compiler
+
+```bash
+npm install
+npm run build
+```
+
+### 2. Télécharger les données GTFS Sibra
+
+Les données proviennent du [Point d'Accès National aux données de mobilité](https://transport.data.gouv.fr/datasets/offre-de-transports-sibra-a-annecy-gtfs), sous licence **ODbL**.
+
+Le serveur **télécharge automatiquement** le fichier GTFS au premier démarrage
+et le met en cache dans `.cache/gtfs-sibra.zip` (renouvellement toutes les 24h).
+
+Ou téléchargez manuellement :
+```bash
+mkdir -p .cache
+curl -L -o .cache/gtfs-sibra.zip \
+  "https://www.data.gouv.fr/api/1/datasets/r/8b12f6db-9aa7-43dc-a179-013998a1c4c0"
+```
+
+---
+ 
+## Connexion à Claude Desktop
+
+Ajoutez cette configuration dans `claude_desktop_config.json` :
+
+**macOS** : `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Windows** : `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "sibra-annecy": {
+      "command": "node",
+      "args": ["/chemin/absolu/vers/sibra-mcp/build/index.js"]
+    }
+  }
+}
+```
+
+Remplacez `/chemin/absolu/vers/sibra-mcp` par le chemin réel sur votre machine.
+
+---
+
+## Test rapide (MCP Inspector)
+
+```bash
+npx @modelcontextprotocol/inspector node build/index.js
+```
+
+---
+
+## Exemples de questions à poser à Claude
+
+> "Quelles sont les lignes de bus Sibra ?"
+
+> "À quelle heure part le prochain bus depuis la Gare d'Annecy ?"
+
+> "Quels sont les horaires de la ligne 1 aujourd'hui ?"
+
+> "Cherche l'arrêt 'Courier' sur le réseau Sibra"
+
+---
+
+## Variable d'environnement
+
+| Variable | Description |
+|---|---|
+| `GTFS_FILE` | Chemin vers un fichier GTFS zip local (contourne le téléchargement) |
+
+```bash
+GTFS_FILE=/path/to/gtfs.zip node build/index.js
+```
+
+---
+
+## Structure du projet
+
+```
+sibra-mcp/
+├── src/
+│   ├── index.ts     # Serveur MCP + 4 outils
+│   └── gtfs.ts      # Chargeur et parseur GTFS
+├── build/           # Code compilé (généré par npm run build)
+├── .cache/          # Cache GTFS (généré automatiquement)
+├── tsconfig.json
+└── package.json
+```
+
+---
+
+## Données
+
+- **Source** : [transport.data.gouv.fr — Sibra](https://transport.data.gouv.fr/datasets/offre-de-transports-sibra-a-annecy-gtfs)
+- **Format** : GTFS (General Transit Feed Specification)
+- **Licence** : [ODbL](https://opendatacommons.org/licenses/odbl/)
+- **Producteur** : Sibra / CA du Grand Annecy
+
+## Étapes suivantes
+
+- Ajouter le module **bornes de recharge IRVE**
+- Ajouter le module **Vélonecy** (vélos en libre-service)
+- Ajouter la disponibilité **temps réel** (GTFS-RT si Sibra le publie)

package/build/gtfs.js

@@ -0,0 +1,242 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as https from "https";
+import { fileURLToPath } from "url";
+import AdmZip from "adm-zip";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const GTFS_URL = "https://www.data.gouv.fr/api/1/datasets/r/8b12f6db-9aa7-43dc-a179-013998a1c4c0";
+const CACHE_DIR = path.join(__dirname, "..", ".cache");
+const CACHE_FILE = path.join(CACHE_DIR, "gtfs-sibra.zip");
+const CACHE_MAX_AGE_HOURS = 24;
+// Optionally point to a local zip: GTFS_FILE=/path/to/gtfs.zip node build/index.js
+const LOCAL_OVERRIDE = './gtfs-sibra.zip';
+function parseCSV(content) {
+    const lines = content.replace(/\r/g, "").split("\n");
+    if (lines.length < 2)
+        return [];
+    const headers = lines[0]
+        .split(",")
+        .map((h) => h.trim().replace(/^"/, "").replace(/"$/, ""));
+    const result = [];
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const values = [];
+        let cur = "";
+        let inQ = false;
+        for (const ch of line) {
+            if (ch === '"') {
+                inQ = !inQ;
+            }
+            else if (ch === "," && !inQ) {
+                values.push(cur);
+                cur = "";
+            }
+            else {
+                cur += ch;
+            }
+        }
+        values.push(cur);
+        const row = {};
+        headers.forEach((h, idx) => {
+            row[h] = (values[idx] ?? "").trim();
+        });
+        result.push(row);
+    }
+    return result;
+}
+function isCacheValid() {
+    if (!fs.existsSync(CACHE_FILE))
+        return false;
+    const stat = fs.statSync(CACHE_FILE);
+    const ageHours = (Date.now() - stat.mtimeMs) / 3_600_000;
+    return ageHours < CACHE_MAX_AGE_HOURS;
+}
+async function downloadGTFS() {
+    return new Promise((resolve, reject) => {
+        const doGet = (url) => {
+            https
+                .get(url, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    return doGet(res.headers.location);
+                }
+                if (res.statusCode !== 200) {
+                    reject(new Error(`HTTP ${res.statusCode} en téléchargeant le GTFS`));
+                    return;
+                }
+                const chunks = [];
+                res.on("data", (c) => chunks.push(c));
+                res.on("end", () => resolve(Buffer.concat(chunks)));
+                res.on("error", reject);
+            })
+                .on("error", reject);
+        };
+        doGet(GTFS_URL);
+    });
+}
+async function downloadGTFSWithRetry(retries = 3) {
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            return await downloadGTFS();
+        }
+        catch (err) {
+            if (attempt === retries)
+                throw err;
+            process.stderr.write(`Tentative ${attempt} échouée, nouvel essai...\n`);
+            await new Promise((r) => setTimeout(r, 1000 * attempt));
+        }
+    }
+    throw new Error("Unreachable");
+}
+async function getZipBuffer() {
+    // 1. Env var override (useful for testing)
+    if (LOCAL_OVERRIDE && fs.existsSync(LOCAL_OVERRIDE)) {
+        process.stderr.write(`Utilisation du fichier GTFS local : ${LOCAL_OVERRIDE}\n`);
+        return fs.readFileSync(LOCAL_OVERRIDE);
+    }
+    // 2. Cache on disk
+    if (!fs.existsSync(CACHE_DIR))
+        fs.mkdirSync(CACHE_DIR, { recursive: true });
+    if (!isCacheValid()) {
+        process.stderr.write("Téléchargement du GTFS Sibra depuis data.gouv.fr...\n");
+        const buf = await downloadGTFSWithRetry();
+        fs.writeFileSync(CACHE_FILE, buf);
+        return buf;
+    }
+    process.stderr.write("Utilisation du cache GTFS local.\n");
+    return fs.readFileSync(CACHE_FILE);
+}
+export async function loadGtfs() {
+    const buf = await getZipBuffer();
+    const zip = new AdmZip(buf);
+    const readFile = (name) => {
+        const entry = zip.getEntry(name);
+        if (!entry)
+            return "";
+        return zip.readAsText(entry);
+    };
+    const stops = new Map();
+    for (const row of parseCSV(readFile("stops.txt"))) {
+        stops.set(row.stop_id, {
+            stop_id: row.stop_id,
+            stop_name: row.stop_name,
+            stop_lat: parseFloat(row.stop_lat),
+            stop_lon: parseFloat(row.stop_lon),
+        });
+    }
+    const routes = new Map();
+    for (const row of parseCSV(readFile("routes.txt"))) {
+        routes.set(row.route_id, {
+            route_id: row.route_id,
+            route_short_name: row.route_short_name,
+            route_long_name: row.route_long_name,
+            route_color: row.route_color,
+        });
+    }
+    const trips = new Map();
+    for (const row of parseCSV(readFile("trips.txt"))) {
+        trips.set(row.trip_id, {
+            trip_id: row.trip_id,
+            route_id: row.route_id,
+            service_id: row.service_id,
+            trip_headsign: row.trip_headsign,
+            direction_id: row.direction_id,
+        });
+    }
+    const stopTimes = parseCSV(readFile("stop_times.txt")).map((row) => ({
+        trip_id: row.trip_id,
+        arrival_time: row.arrival_time,
+        departure_time: row.departure_time,
+        stop_id: row.stop_id,
+        stop_sequence: parseInt(row.stop_sequence, 10),
+    }));
+    const calendarDates = parseCSV(readFile("calendar_dates.txt")).map((row) => ({
+        service_id: row.service_id,
+        date: row.date,
+        exception_type: row.exception_type,
+    }));
+    const calendars = new Map();
+    for (const row of parseCSV(readFile("calendar.txt"))) {
+        calendars.set(row.service_id, {
+            service_id: row.service_id,
+            monday: row.monday === "1",
+            tuesday: row.tuesday === "1",
+            wednesday: row.wednesday === "1",
+            thursday: row.thursday === "1",
+            friday: row.friday === "1",
+            saturday: row.saturday === "1",
+            sunday: row.sunday === "1",
+            start_date: row.start_date,
+            end_date: row.end_date,
+        });
+    }
+    const stopTimesByStop = new Map();
+    const stopTimesByTrip = new Map();
+    for (const st of stopTimes) {
+        if (!stopTimesByStop.has(st.stop_id))
+            stopTimesByStop.set(st.stop_id, []);
+        stopTimesByStop.get(st.stop_id).push(st);
+        if (!stopTimesByTrip.has(st.trip_id))
+            stopTimesByTrip.set(st.trip_id, []);
+        stopTimesByTrip.get(st.trip_id).push(st);
+    }
+    return {
+        stops,
+        routes,
+        trips,
+        stopTimes,
+        stopTimesByStop,
+        stopTimesByTrip,
+        calendarDates,
+        calendars,
+        loadedAt: new Date(),
+    };
+}
+/** Return today as YYYYMMDD */
+export function todayStr() {
+    return new Date().toISOString().slice(0, 10).replace(/-/g, "");
+}
+/** Day-of-week key from YYYYMMDD */
+export function dayOfWeek(dateStr) {
+    const d = new Date(`${dateStr.slice(0, 4)}-${dateStr.slice(4, 6)}-${dateStr.slice(6, 8)}`);
+    const days = [
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    ];
+    return days[d.getDay()];
+}
+/** Get active service_ids for a given date */
+export function activeServices(gtfs, dateStr) {
+    const active = new Set();
+    const dow = dayOfWeek(dateStr);
+    for (const [sid, cal] of gtfs.calendars) {
+        if (dateStr >= cal.start_date &&
+            dateStr <= cal.end_date &&
+            cal[dow]) {
+            active.add(sid);
+        }
+    }
+    for (const cd of gtfs.calendarDates) {
+        if (cd.date === dateStr) {
+            if (cd.exception_type === "1")
+                active.add(cd.service_id);
+            if (cd.exception_type === "2")
+                active.delete(cd.service_id);
+        }
+    }
+    return active;
+}
+/** Normalise time like "25:10:00" → "HH:MM" */
+export function fmtTime(t) {
+    if (!t)
+        return "";
+    const [h, m] = t.split(":");
+    return `${h.padStart(2, "0")}:${m}`;
+}

package/build/index.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { loadGtfs, activeServices, fmtTime, todayStr, } from "./gtfs.js";
+let gtfs = null;
+async function getGtfs() {
+    if (!gtfs) {
+        process.stderr.write("Chargement des données GTFS Sibra...\n");
+        gtfs = await loadGtfs();
+        process.stderr.write(`GTFS chargé : ${gtfs.stops.size} arrêts, ${gtfs.routes.size} lignes, ${gtfs.trips.size} courses\n`);
+    }
+    return gtfs;
+}
+// ─── Server ───────────────────────────────────────────────────────────────────
+const server = new McpServer({
+    name: "sibra-annecy",
+    version: "1.0.0",
+});
+// ─── Tool 1 : Lister les lignes ───────────────────────────────────────────────
+server.registerTool("list_lines", {
+    description: "Liste toutes les lignes de bus du réseau Sibra d'Annecy avec leur nom court, nom long et destination.",
+    inputSchema: z.object({}),
+}, async () => {
+    const g = await getGtfs();
+    const lines = [...g.routes.values()]
+        .sort((a, b) => {
+        const na = parseInt(a.route_short_name) || 999;
+        const nb = parseInt(b.route_short_name) || 999;
+        return na !== nb ? na - nb : a.route_short_name.localeCompare(b.route_short_name);
+    })
+        .map((r) => `Ligne ${r.route_short_name} — ${r.route_long_name}`)
+        .join("\n");
+    return {
+        content: [{ type: "text", text: `Lignes du réseau Sibra :\n\n${lines}` }],
+    };
+});
+// ─── Tool 2 : Rechercher des arrêts ──────────────────────────────────────────
+server.registerTool("search_stops", {
+    description: "Recherche des arrêts de bus Sibra par nom (recherche partielle, insensible à la casse).",
+    inputSchema: z.object({
+        query: z.string().describe("Nom ou partie du nom de l'arrêt recherché"),
+    }),
+}, async ({ query }) => {
+    const g = await getGtfs();
+    const q = query.toLowerCase();
+    const results = [...g.stops.values()]
+        .filter((s) => s.stop_name.toLowerCase().includes(q))
+        .slice(0, 20)
+        .map((s) => `${s.stop_name} (id: ${s.stop_id})`)
+        .join("\n");
+    if (!results) {
+        return {
+            content: [{ type: "text", text: `Aucun arrêt trouvé pour "${query}".` }],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Arrêts correspondant à "${query}" :\n\n${results}`,
+            },
+        ],
+    };
+});
+// ─── Tool 3 : Prochains départs depuis un arrêt ───────────────────────────────
+server.registerTool("next_departures", {
+    description: "Donne les prochains départs depuis un arrêt Sibra pour une heure et date données. Si aucune heure n'est précisée, utilise l'heure actuelle.",
+    inputSchema: z.object({
+        stop_name: z
+            .string()
+            .describe("Nom (ou partie du nom) de l'arrêt, ex: 'Gare', 'Courier'"),
+        time: z
+            .string()
+            .optional()
+            .describe("Heure de départ au format HH:MM (défaut: maintenant)"),
+        date: z
+            .string()
+            .optional()
+            .describe("Date au format YYYYMMDD (défaut: aujourd'hui)"),
+        limit: z
+            .number()
+            .optional()
+            .describe("Nombre max de résultats (défaut: 10)"),
+    }),
+}, async ({ stop_name, time, date, limit = 10 }) => {
+    const g = await getGtfs();
+    const dateStr = date ?? todayStr();
+    const nowTime = time ??
+        new Date().toLocaleTimeString("fr-FR", {
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+    // Find matching stops
+    const q = stop_name.toLowerCase();
+    const matchingStops = [...g.stops.values()].filter((s) => s.stop_name.toLowerCase().includes(q));
+    if (matchingStops.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Arrêt "${stop_name}" introuvable. Utilisez search_stops pour trouver le nom exact.`,
+                },
+            ],
+        };
+    }
+    if (matchingStops.length > 5) {
+        const names = matchingStops
+            .slice(0, 5)
+            .map((s) => s.stop_name)
+            .join(", ");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Plusieurs arrêts correspondent à "${stop_name}": ${names}… Précisez le nom.`,
+                },
+            ],
+        };
+    }
+    const activeServiceIds = activeServices(g, dateStr);
+    const departures = [];
+    for (const stop of matchingStops) {
+        for (const st of g.stopTimesByStop.get(stop.stop_id) ?? []) {
+            const trip = g.trips.get(st.trip_id);
+            if (!trip || !activeServiceIds.has(trip.service_id))
+                continue;
+            const deptTime = fmtTime(st.departure_time);
+            if (deptTime < nowTime)
+                continue;
+            const route = g.routes.get(trip.route_id);
+            departures.push({
+                time: deptTime,
+                line: route?.route_short_name ?? trip.route_id,
+                headsign: trip.trip_headsign ?? "",
+            });
+        }
+    }
+    departures.sort((a, b) => a.time.localeCompare(b.time));
+    const top = departures.slice(0, limit);
+    if (top.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Aucun départ trouvé depuis "${matchingStops[0].stop_name}" après ${nowTime} le ${dateStr}.`,
+                },
+            ],
+        };
+    }
+    const stopLabel = matchingStops.length === 1
+        ? matchingStops[0].stop_name
+        : matchingStops.map((s) => s.stop_name).join(" / ");
+    const rows = top
+        .map((d) => `  ${d.time}  →  Ligne ${d.line.padEnd(4)}  ${d.headsign}`)
+        .join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Prochains départs depuis **${stopLabel}** après ${nowTime} (${dateStr}) :\n\n${rows}`,
+            },
+        ],
+    };
+});
+// ─── Tool 4 : Horaires complets d'une ligne ───────────────────────────────────
+server.registerTool("line_schedule", {
+    description: "Affiche les premiers et derniers départs d'une ligne Sibra pour un jour donné, avec les principaux arrêts.",
+    inputSchema: z.object({
+        line: z.string().describe("Numéro ou nom de la ligne, ex: '1', '2', 'T1'"),
+        date: z
+            .string()
+            .optional()
+            .describe("Date au format YYYYMMDD (défaut: aujourd'hui)"),
+    }),
+}, async ({ line, date }) => {
+    const g = await getGtfs();
+    const dateStr = date ?? todayStr();
+    // Find route
+    const q = line.toLowerCase();
+    const matchingRoutes = [...g.routes.values()].filter((r) => r.route_short_name.toLowerCase() === q ||
+        r.route_long_name.toLowerCase().includes(q));
+    if (matchingRoutes.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Ligne "${line}" introuvable. Utilisez list_lines pour voir les lignes disponibles.`,
+                },
+            ],
+        };
+    }
+    const route = matchingRoutes[0];
+    const activeServiceIds = activeServices(g, dateStr);
+    // Get trips for this route on this date
+    const routeTrips = [...g.trips.values()].filter((t) => t.route_id === route.route_id && activeServiceIds.has(t.service_id));
+    if (routeTrips.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Aucune course pour la ligne ${route.route_short_name} le ${dateStr}. Jour férié ou hors période de validité ?`,
+                },
+            ],
+        };
+    }
+    const summaries = [];
+    for (const trip of routeTrips) {
+        const times = (g.stopTimesByTrip.get(trip.trip_id) ?? [])
+            .slice()
+            .sort((a, b) => a.stop_sequence - b.stop_sequence);
+        if (times.length === 0)
+            continue;
+        summaries.push({
+            headsign: trip.trip_headsign ?? "",
+            firstTime: fmtTime(times[0].departure_time),
+            lastTime: fmtTime(times[times.length - 1].arrival_time),
+            direction: trip.direction_id === "1" ? "Retour" : "Aller",
+        });
+    }
+    summaries.sort((a, b) => a.firstTime.localeCompare(b.firstTime));
+    // Group by direction/headsign
+    const groups = new Map();
+    for (const s of summaries) {
+        const key = `${s.direction} → ${s.headsign}`;
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(s);
+    }
+    let text = `**Ligne ${route.route_short_name}** — ${route.route_long_name}\nDate : ${dateStr} | ${summaries.length} courses\n\n`;
+    for (const [label, trips] of groups) {
+        const first = trips[0].firstTime;
+        const last = trips[trips.length - 1].firstTime;
+        text += `${label}\n  Premier départ : ${first}  |  Dernier départ : ${last}  |  ${trips.length} passages\n\n`;
+    }
+    return {
+        content: [{ type: "text", text }],
+    };
+});
+// ─── Tool 5 : Arrêts d'une course ────────────────────────────────────────────
+server.registerTool("trip_stops", {
+    description: "Affiche tous les arrêts d'une course Sibra avec les heures de passage, à partir d'un arrêt de départ et d'une heure donnés.",
+    inputSchema: z.object({
+        stop_name: z.string().describe("Nom (ou partie du nom) de l'arrêt de départ"),
+        line: z.string().describe("Numéro de la ligne, ex: '1', 'T1'"),
+        time: z.string().optional().describe("Heure de départ au format HH:MM (défaut: maintenant)"),
+        date: z.string().optional().describe("Date au format YYYYMMDD (défaut: aujourd'hui)"),
+    }),
+}, async ({ stop_name, line, time, date }) => {
+    const g = await getGtfs();
+    const dateStr = date ?? todayStr();
+    const nowTime = time ??
+        new Date().toLocaleTimeString("fr-FR", {
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+    const q = line.toLowerCase();
+    const route = [...g.routes.values()].find((r) => r.route_short_name.toLowerCase() === q || r.route_long_name.toLowerCase().includes(q));
+    if (!route) {
+        return { content: [{ type: "text", text: `Ligne "${line}" introuvable. Utilisez list_lines.` }] };
+    }
+    const sq = stop_name.toLowerCase();
+    const matchingStop = [...g.stops.values()].find((s) => s.stop_name.toLowerCase().includes(sq));
+    if (!matchingStop) {
+        return { content: [{ type: "text", text: `Arrêt "${stop_name}" introuvable. Utilisez search_stops.` }] };
+    }
+    const activeServiceIds = activeServices(g, dateStr);
+    // Find the next trip of this line stopping at this stop after nowTime
+    const candidates = (g.stopTimesByStop.get(matchingStop.stop_id) ?? [])
+        .filter((st) => {
+        const trip = g.trips.get(st.trip_id);
+        return (trip &&
+            trip.route_id === route.route_id &&
+            activeServiceIds.has(trip.service_id) &&
+            fmtTime(st.departure_time) >= nowTime);
+    })
+        .sort((a, b) => fmtTime(a.departure_time).localeCompare(fmtTime(b.departure_time)));
+    if (candidates.length === 0) {
+        return { content: [{ type: "text", text: `Aucune course ligne ${route.route_short_name} depuis "${matchingStop.stop_name}" après ${nowTime}.` }] };
+    }
+    const tripId = candidates[0].trip_id;
+    const trip = g.trips.get(tripId);
+    const allStops = (g.stopTimesByTrip.get(tripId) ?? [])
+        .slice()
+        .sort((a, b) => a.stop_sequence - b.stop_sequence);
+    const rows = allStops.map((st) => {
+        const s = g.stops.get(st.stop_id);
+        const marker = st.stop_id === matchingStop.stop_id ? " ◄" : "";
+        return `  ${fmtTime(st.departure_time)}  ${s?.stop_name ?? st.stop_id}${marker}`;
+    }).join("\n");
+    return {
+        content: [{
+                type: "text",
+                text: `**Ligne ${route.route_short_name}** → ${trip.trip_headsign ?? ""}\nDate : ${dateStr}\n\n${rows}`,
+            }],
+    };
+});
+// ─── Start ────────────────────────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write("Serveur MCP Sibra démarré (stdio)\n");
+}
+main().catch((err) => {
+    process.stderr.write(`Erreur fatale : ${err}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "mcp-server-sibra",
+  "version": "1.0.0",
+  "description": "MCP server for Sibra bus network schedules (Grand Annecy, France)",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "mcp-server-sibra": "build/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "adm-zip": "^0.5.16",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}