@aborruso/ckan-mcp-server 0.3.1

package/dist/index.js

@@ -0,0 +1,1277 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createServer() {
+  return new McpServer({
+    name: "ckan-mcp-server",
+    version: "0.1.0"
+  });
+}
+
+// src/tools/package.ts
+import { z as z2 } from "zod";
+
+// src/types.ts
+import { z } from "zod";
+var ResponseFormat = /* @__PURE__ */ ((ResponseFormat2) => {
+  ResponseFormat2["MARKDOWN"] = "markdown";
+  ResponseFormat2["JSON"] = "json";
+  return ResponseFormat2;
+})(ResponseFormat || {});
+var ResponseFormatSchema = z.nativeEnum(ResponseFormat).default("markdown" /* MARKDOWN */).describe("Output format: 'markdown' for human-readable or 'json' for machine-readable");
+var CHARACTER_LIMIT = 5e4;
+
+// src/utils/http.ts
+import axios from "axios";
+async function makeCkanRequest(serverUrl, action, params = {}) {
+  const baseUrl = serverUrl.replace(/\/$/, "");
+  const url = `${baseUrl}/api/3/action/${action}`;
+  try {
+    const response = await axios.get(url, {
+      params,
+      timeout: 3e4,
+      headers: {
+        "User-Agent": "CKAN-MCP-Server/1.0"
+      }
+    });
+    if (response.data && response.data.success === true) {
+      return response.data.result;
+    } else {
+      throw new Error(`CKAN API returned success=false: ${JSON.stringify(response.data)}`);
+    }
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      const axiosError = error;
+      if (axiosError.response) {
+        const status = axiosError.response.status;
+        const data = axiosError.response.data;
+        const errorMsg = data?.error?.message || data?.error || "Unknown error";
+        throw new Error(`CKAN API error (${status}): ${errorMsg}`);
+      } else if (axiosError.code === "ECONNABORTED") {
+        throw new Error(`Request timeout connecting to ${serverUrl}`);
+      } else if (axiosError.code === "ENOTFOUND") {
+        throw new Error(`Server not found: ${serverUrl}`);
+      } else {
+        throw new Error(`Network error: ${axiosError.message}`);
+      }
+    }
+    throw error;
+  }
+}
+
+// src/utils/formatting.ts
+function truncateText(text, limit = CHARACTER_LIMIT) {
+  if (text.length <= limit) {
+    return text;
+  }
+  return text.substring(0, limit) + `
+
+... [Response truncated at ${limit} characters]`;
+}
+function formatDate(dateStr) {
+  try {
+    return new Date(dateStr).toLocaleString("it-IT");
+  } catch {
+    return dateStr;
+  }
+}
+
+// src/portals.json
+var portals_default = {
+  portals: [
+    {
+      id: "dati-gov-it",
+      name: "dati.gov.it",
+      api_url: "https://www.dati.gov.it/opendata",
+      api_url_aliases: [
+        "https://dati.gov.it/opendata",
+        "http://www.dati.gov.it/opendata",
+        "http://dati.gov.it/opendata"
+      ],
+      dataset_view_url: "https://www.dati.gov.it/view-dataset/dataset?id={id}",
+      organization_view_url: "https://www.dati.gov.it/view-dataset?organization={name}"
+    }
+  ],
+  defaults: {
+    dataset_view_url: "{server_url}/dataset/{name}",
+    organization_view_url: "{server_url}/organization/{name}"
+  }
+};
+
+// src/utils/url-generator.ts
+function normalizeUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function getDatasetViewUrl(serverUrl, pkg) {
+  const cleanServerUrl = normalizeUrl(serverUrl);
+  const portal = portals_default.portals.find((p) => {
+    const mainUrl = normalizeUrl(p.api_url);
+    const aliases = (p.api_url_aliases || []).map(normalizeUrl);
+    return mainUrl === cleanServerUrl || aliases.includes(cleanServerUrl);
+  });
+  const template = portal?.dataset_view_url || portals_default.defaults.dataset_view_url;
+  return template.replace("{server_url}", cleanServerUrl).replace("{id}", pkg.id).replace("{name}", pkg.name);
+}
+function getOrganizationViewUrl(serverUrl, org) {
+  const cleanServerUrl = normalizeUrl(serverUrl);
+  const portal = portals_default.portals.find((p) => {
+    const mainUrl = normalizeUrl(p.api_url);
+    const aliases = (p.api_url_aliases || []).map(normalizeUrl);
+    return mainUrl === cleanServerUrl || aliases.includes(cleanServerUrl);
+  });
+  const template = portal?.organization_view_url || portals_default.defaults.organization_view_url;
+  return template.replace("{server_url}", cleanServerUrl).replace("{id}", org.id).replace("{name}", org.name);
+}
+
+// src/tools/package.ts
+function registerPackageTools(server2) {
+  server2.registerTool(
+    "ckan_package_search",
+    {
+      title: "Search CKAN Datasets",
+      description: `Search for datasets (packages) on a CKAN server using Solr query syntax.
+
+Supports full Solr search capabilities including filters, facets, and sorting.
+Use this to discover datasets matching specific criteria.
+
+Args:
+  - server_url (string): Base URL of CKAN server (e.g., "https://dati.gov.it")
+  - q (string): Search query using Solr syntax (default: "*:*" for all)
+  - fq (string): Filter query (e.g., "organization:comune-palermo")
+  - rows (number): Number of results to return (default: 10, max: 1000)
+  - start (number): Offset for pagination (default: 0)
+  - sort (string): Sort field and direction (e.g., "metadata_modified desc")
+  - facet_field (array): Fields to facet on (e.g., ["organization", "tags"])
+  - facet_limit (number): Max facet values per field (default: 50)
+  - include_drafts (boolean): Include draft datasets (default: false)
+  - response_format ('markdown' | 'json'): Output format
+
+Returns:
+  Search results with:
+  - count: Number of results found
+  - results: Array of dataset objects
+  - facets: Facet counts (if facet_field specified)
+  - search_facets: Detailed facet information
+
+Query Syntax (parameter q):
+  Boolean operators:
+    - AND / &&: "water AND climate"
+    - OR / ||: "health OR sanit\xE0"
+    - NOT / !: "data NOT personal"
+    - +required -excluded: "+title:water -title:sea"
+    - Grouping: "(title:water OR title:climate) AND tags:environment"
+
+  Wildcards:
+    - *: "title:environment*" (matches environmental, environments, etc.)
+    - Note: Left truncation (*water) not supported
+
+  Fuzzy search (edit distance):
+    - ~: "title:rest~" or "title:rest~1" (finds "test", "best", "rest")
+
+  Proximity search (words within N positions):
+    - "phrase"~N: "title:"climate change"~5"
+
+  Range queries:
+    - Inclusive [a TO b]: "num_resources:[5 TO 10]"
+    - Exclusive {a TO b}: "num_resources:{0 TO 100}"
+    - One side open: "metadata_modified:[2024-01-01T00:00:00Z TO *]"
+
+  Date math:
+    - NOW-1YEAR, NOW-6MONTHS, NOW-7DAYS, NOW-1HOUR
+    - NOW/DAY, NOW/MONTH (round down)
+    - Combined: "metadata_modified:[NOW-2MONTHS TO NOW]"
+    - Example: "metadata_created:[NOW-1YEAR TO *]"
+
+  Field existence:
+    - Exists: "field:*" or "field:[* TO *]"
+    - Not exists: "NOT field:*" or "-field:*"
+
+  Boosting (relevance scoring):
+    - Boost term: "title:water^2 OR notes:water" (title matches score higher)
+    - Constant score: "title:water^=1.5"
+
+Examples:
+  - Search all: { q: "*:*" }
+  - By tag: { q: "tags:sanit\xE0" }
+  - Boolean: { q: "(title:water OR title:climate) AND NOT title:sea" }
+  - Wildcard: { q: "title:environment*" }
+  - Fuzzy: { q: "title:health~2" }
+  - Proximity: { q: "notes:"open data"~3" }
+  - Date range: { q: "metadata_modified:[2024-01-01T00:00:00Z TO 2024-12-31T23:59:59Z]" }
+  - Date math: { q: "metadata_modified:[NOW-6MONTHS TO *]" }
+  - Field exists: { q: "organization:* AND num_resources:[1 TO *]" }
+  - Boosting: { q: "title:climate^2 OR notes:climate" }
+  - Filter org: { fq: "organization:regione-siciliana" }
+  - Get facets: { facet_field: ["organization"], rows: 0 }`,
+      inputSchema: z2.object({
+        server_url: z2.string().url("Must be a valid URL").describe("Base URL of the CKAN server"),
+        q: z2.string().optional().default("*:*").describe("Search query in Solr syntax"),
+        fq: z2.string().optional().describe("Filter query in Solr syntax"),
+        rows: z2.number().int().min(0).max(1e3).optional().default(10).describe("Number of results to return"),
+        start: z2.number().int().min(0).optional().default(0).describe("Offset for pagination"),
+        sort: z2.string().optional().describe("Sort field and direction (e.g., 'metadata_modified desc')"),
+        facet_field: z2.array(z2.string()).optional().describe("Fields to facet on"),
+        facet_limit: z2.number().int().min(1).optional().default(50).describe("Maximum facet values per field"),
+        include_drafts: z2.boolean().optional().default(false).describe("Include draft datasets"),
+        response_format: ResponseFormatSchema
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (params) => {
+      try {
+        const apiParams = {
+          q: params.q,
+          rows: params.rows,
+          start: params.start,
+          include_private: params.include_drafts
+        };
+        if (params.fq) apiParams.fq = params.fq;
+        if (params.sort) apiParams.sort = params.sort;
+        if (params.facet_field && params.facet_field.length > 0) {
+          apiParams["facet.field"] = JSON.stringify(params.facet_field);
+          apiParams["facet.limit"] = params.facet_limit;
+        }
+        const result = await makeCkanRequest(
+          params.server_url,
+          "package_search",
+          apiParams
+        );
+        if (params.response_format === "json" /* JSON */) {
+          return {
+            content: [{ type: "text", text: truncateText(JSON.stringify(result, null, 2)) }],
+            structuredContent: result
+          };
+        }
+        let markdown = `# CKAN Package Search Results
+
+**Server**: ${params.server_url}
+**Query**: ${params.q}
+${params.fq ? `**Filter**: ${params.fq}
+` : ""}
+**Total Results**: ${result.count}
+**Showing**: ${result.results.length} results (from ${params.start})
+
+`;
+        if (result.facets && Object.keys(result.facets).length > 0) {
+          markdown += `## Facets
+
+`;
+          for (const [field, values] of Object.entries(result.facets)) {
+            markdown += `### ${field}
+
+`;
+            const facetValues = values;
+            const sorted = Object.entries(facetValues).sort((a, b) => b[1] - a[1]).slice(0, 10);
+            for (const [value, count] of sorted) {
+              markdown += `- **${value}**: ${count}
+`;
+            }
+            markdown += "\n";
+          }
+        }
+        if (result.results && result.results.length > 0) {
+          markdown += `## Datasets
+
+`;
+          for (const pkg of result.results) {
+            markdown += `### ${pkg.title || pkg.name}
+
+`;
+            markdown += `- **ID**: \`${pkg.id}\`
+`;
+            markdown += `- **Name**: \`${pkg.name}\`
+`;
+            if (pkg.organization) {
+              markdown += `- **Organization**: ${pkg.organization.title || pkg.organization.name}
+`;
+            }
+            if (pkg.notes) {
+              const notes = pkg.notes.substring(0, 200);
+              markdown += `- **Description**: ${notes}${pkg.notes.length > 200 ? "..." : ""}
+`;
+            }
+            if (pkg.tags && pkg.tags.length > 0) {
+              const tags = pkg.tags.slice(0, 5).map((t) => t.name).join(", ");
+              markdown += `- **Tags**: ${tags}${pkg.tags.length > 5 ? ", ..." : ""}
+`;
+            }
+            markdown += `- **Resources**: ${pkg.num_resources || 0}
+`;
+            markdown += `- **Modified**: ${formatDate(pkg.metadata_modified)}
+`;
+            markdown += `- **Link**: ${getDatasetViewUrl(params.server_url, pkg)}
+
+`;
+          }
+        } else {
+          markdown += `No datasets found matching your query.
+`;
+        }
+        if (result.count > params.start + params.rows) {
+          const nextStart = params.start + params.rows;
+          markdown += `
+---
+**More results available**: Use \`start: ${nextStart}\` to see next page.
+`;
+        }
+        return {
+          content: [{ type: "text", text: truncateText(markdown) }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error searching packages: ${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "ckan_package_show",
+    {
+      title: "Show CKAN Dataset Details",
+      description: `Get complete metadata for a specific dataset (package).
+
+Returns full details including resources, organization, tags, and all metadata fields.
+
+Args:
+  - server_url (string): Base URL of CKAN server
+  - id (string): Dataset ID or name (machine-readable slug)
+  - include_tracking (boolean): Include view/download statistics (default: false)
+  - response_format ('markdown' | 'json'): Output format
+
+Returns:
+  Complete dataset object with all metadata and resources
+
+Examples:
+  - { server_url: "https://dati.gov.it", id: "dataset-name" }
+  - { server_url: "...", id: "abc-123-def", include_tracking: true }`,
+      inputSchema: z2.object({
+        server_url: z2.string().url().describe("Base URL of the CKAN server"),
+        id: z2.string().min(1).describe("Dataset ID or name"),
+        include_tracking: z2.boolean().optional().default(false).describe("Include tracking statistics"),
+        response_format: ResponseFormatSchema
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await makeCkanRequest(
+          params.server_url,
+          "package_show",
+          {
+            id: params.id,
+            include_tracking: params.include_tracking
+          }
+        );
+        if (params.response_format === "json" /* JSON */) {
+          return {
+            content: [{ type: "text", text: truncateText(JSON.stringify(result, null, 2)) }],
+            structuredContent: result
+          };
+        }
+        let markdown = `# Dataset: ${result.title || result.name}
+
+`;
+        markdown += `**Server**: ${params.server_url}
+`;
+        markdown += `**Link**: ${getDatasetViewUrl(params.server_url, result)}
+
+`;
+        markdown += `## Basic Information
+
+`;
+        markdown += `- **ID**: \`${result.id}\`
+`;
+        markdown += `- **Name**: \`${result.name}\`
+`;
+        if (result.author) markdown += `- **Author**: ${result.author}
+`;
+        if (result.author_email) markdown += `- **Author Email**: ${result.author_email}
+`;
+        if (result.maintainer) markdown += `- **Maintainer**: ${result.maintainer}
+`;
+        if (result.maintainer_email) markdown += `- **Maintainer Email**: ${result.maintainer_email}
+`;
+        markdown += `- **License**: ${result.license_title || result.license_id || "Not specified"}
+`;
+        markdown += `- **State**: ${result.state}
+`;
+        markdown += `- **Created**: ${formatDate(result.metadata_created)}
+`;
+        markdown += `- **Modified**: ${formatDate(result.metadata_modified)}
+
+`;
+        if (result.organization) {
+          markdown += `## Organization
+
+`;
+          markdown += `- **Name**: ${result.organization.title || result.organization.name}
+`;
+          markdown += `- **ID**: \`${result.organization.id}\`
+
+`;
+        }
+        if (result.notes) {
+          markdown += `## Description
+
+${result.notes}
+
+`;
+        }
+        if (result.tags && result.tags.length > 0) {
+          markdown += `## Tags
+
+`;
+          markdown += result.tags.map((t) => `- ${t.name}`).join("\n") + "\n\n";
+        }
+        if (result.groups && result.groups.length > 0) {
+          markdown += `## Groups
+
+`;
+          for (const group of result.groups) {
+            markdown += `- **${group.title || group.name}** (\`${group.name}\`)
+`;
+          }
+          markdown += "\n";
+        }
+        if (result.resources && result.resources.length > 0) {
+          markdown += `## Resources (${result.resources.length})
+
+`;
+          for (const resource of result.resources) {
+            markdown += `### ${resource.name || "Unnamed Resource"}
+
+`;
+            markdown += `- **ID**: \`${resource.id}\`
+`;
+            markdown += `- **Format**: ${resource.format || "Unknown"}
+`;
+            if (resource.description) markdown += `- **Description**: ${resource.description}
+`;
+            markdown += `- **URL**: ${resource.url}
+`;
+            if (resource.size) {
+              const formatBytes = (bytes) => {
+                if (!bytes || bytes === 0) return "0 B";
+                const k = 1024;
+                const sizes = ["B", "KB", "MB", "GB"];
+                const i = Math.floor(Math.log(bytes) / Math.log(k));
+                return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+              };
+              markdown += `- **Size**: ${formatBytes(resource.size)}
+`;
+            }
+            if (resource.mimetype) markdown += `- **MIME Type**: ${resource.mimetype}
+`;
+            markdown += `- **Created**: ${formatDate(resource.created)}
+`;
+            if (resource.last_modified) markdown += `- **Modified**: ${formatDate(resource.last_modified)}
+`;
+            if (resource.datastore_active !== void 0) {
+              markdown += `- **DataStore**: ${resource.datastore_active ? "\u2705 Available" : "\u274C Not available"}
+`;
+            }
+            markdown += "\n";
+          }
+        }
+        if (result.extras && result.extras.length > 0) {
+          markdown += `## Extra Fields
+
+`;
+          for (const extra of result.extras) {
+            markdown += `- **${extra.key}**: ${extra.value}
+`;
+          }
+          markdown += "\n";
+        }
+        return {
+          content: [{ type: "text", text: truncateText(markdown) }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error fetching package: ${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/organization.ts
+import { z as z3 } from "zod";
+function registerOrganizationTools(server2) {
+  server2.registerTool(
+    "ckan_organization_list",
+    {
+      title: "List CKAN Organizations",
+      description: `List all organizations on a CKAN server.
+
+Organizations are entities that publish and manage datasets.
+
+Args:
+  - server_url (string): Base URL of CKAN server
+  - all_fields (boolean): Return full objects vs just names (default: false)
+  - sort (string): Sort field (default: "name asc")
+  - limit (number): Maximum results (default: 100). Use 0 to get only the count via faceting
+  - offset (number): Pagination offset (default: 0)
+  - response_format ('markdown' | 'json'): Output format
+
+Returns:
+  List of organizations with metadata. When limit=0, returns only the count of organizations with datasets.`,
+      inputSchema: z3.object({
+        server_url: z3.string().url(),
+        all_fields: z3.boolean().optional().default(false),
+        sort: z3.string().optional().default("name asc"),
+        limit: z3.number().int().min(0).optional().default(100),
+        offset: z3.number().int().min(0).optional().default(0),
+        response_format: ResponseFormatSchema
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        if (params.limit === 0) {
+          const searchResult = await makeCkanRequest(
+            params.server_url,
+            "package_search",
+            {
+              rows: 0,
+              "facet.field": JSON.stringify(["organization"]),
+              "facet.limit": -1
+            }
+          );
+          const orgCount = searchResult.search_facets?.organization?.items?.length || 0;
+          if (params.response_format === "json" /* JSON */) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ count: orgCount }, null, 2) }],
+              structuredContent: { count: orgCount }
+            };
+          }
+          const markdown2 = `# CKAN Organizations Count
+
+**Server**: ${params.server_url}
+**Total organizations (with datasets)**: ${orgCount}
+`;
+          return {
+            content: [{ type: "text", text: markdown2 }]
+          };
+        }
+        const result = await makeCkanRequest(
+          params.server_url,
+          "organization_list",
+          {
+            all_fields: params.all_fields,
+            sort: params.sort,
+            limit: params.limit,
+            offset: params.offset
+          }
+        );
+        if (params.response_format === "json" /* JSON */) {
+          const output = Array.isArray(result) ? { count: result.length, organizations: result } : result;
+          return {
+            content: [{ type: "text", text: truncateText(JSON.stringify(output, null, 2)) }],
+            structuredContent: output
+          };
+        }
+        let markdown = `# CKAN Organizations
+
+`;
+        markdown += `**Server**: ${params.server_url}
+`;
+        markdown += `**Total**: ${Array.isArray(result) ? result.length : "Unknown"}
+
+`;
+        if (Array.isArray(result)) {
+          if (params.all_fields) {
+            for (const org of result) {
+              markdown += `## ${org.title || org.name}
+
+`;
+              markdown += `- **ID**: \`${org.id}\`
+`;
+              markdown += `- **Name**: \`${org.name}\`
+`;
+              if (org.description) markdown += `- **Description**: ${org.description.substring(0, 200)}
+`;
+              markdown += `- **Datasets**: ${org.package_count || 0}
+`;
+              markdown += `- **Created**: ${formatDate(org.created)}
+`;
+              markdown += `- **Link**: ${getOrganizationViewUrl(params.server_url, org)}
+
+`;
+            }
+          } else {
+            markdown += result.map((name) => `- ${name}`).join("\n");
+          }
+        }
+        return {
+          content: [{ type: "text", text: truncateText(markdown) }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error listing organizations: ${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "ckan_organization_show",
+    {
+      title: "Show CKAN Organization Details",
+      description: `Get details of a specific organization.
+
+Args:
+  - server_url (string): Base URL of CKAN server
+  - id (string): Organization ID or name
+  - include_datasets (boolean): Include list of datasets (default: true)
+  - include_users (boolean): Include list of users (default: false)
+  - response_format ('markdown' | 'json'): Output format
+
+Returns:
+  Organization details with optional datasets and users`,
+      inputSchema: z3.object({
+        server_url: z3.string().url(),
+        id: z3.string().min(1),
+        include_datasets: z3.boolean().optional().default(true),
+        include_users: z3.boolean().optional().default(false),
+        response_format: ResponseFormatSchema
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await makeCkanRequest(
+          params.server_url,
+          "organization_show",
+          {
+            id: params.id,
+            include_datasets: params.include_datasets,
+            include_users: params.include_users
+          }
+        );
+        if (params.response_format === "json" /* JSON */) {
+          return {
+            content: [{ type: "text", text: truncateText(JSON.stringify(result, null, 2)) }],
+            structuredContent: result
+          };
+        }
+        let markdown = `# Organization: ${result.title || result.name}
+
+`;
+        markdown += `**Server**: ${params.server_url}
+`;
+        markdown += `**Link**: ${getOrganizationViewUrl(params.server_url, result)}
+
+`;
+        markdown += `## Details
+
+`;
+        markdown += `- **ID**: \`${result.id}\`
+`;
+        markdown += `- **Name**: \`${result.name}\`
+`;
+        markdown += `- **Datasets**: ${result.package_count || 0}
+`;
+        markdown += `- **Created**: ${formatDate(result.created)}
+`;
+        markdown += `- **State**: ${result.state}
+
+`;
+        if (result.description) {
+          markdown += `## Description
+
+${result.description}
+
+`;
+        }
+        if (result.packages && result.packages.length > 0) {
+          markdown += `## Datasets (${result.packages.length})
+
+`;
+          for (const pkg of result.packages.slice(0, 20)) {
+            markdown += `- **${pkg.title || pkg.name}** (\`${pkg.name}\`)
+`;
+          }
+          if (result.packages.length > 20) {
+            markdown += `
+... and ${result.packages.length - 20} more datasets
+`;
+          }
+          markdown += "\n";
+        }
+        if (result.users && result.users.length > 0) {
+          markdown += `## Users (${result.users.length})
+
+`;
+          for (const user of result.users) {
+            markdown += `- **${user.name}** (${user.capacity})
+`;
+          }
+          markdown += "\n";
+        }
+        return {
+          content: [{ type: "text", text: truncateText(markdown) }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error fetching organization: ${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "ckan_organization_search",
+    {
+      title: "Search CKAN Organizations by Name",
+      description: `Search for organizations by name pattern.
+
+This tool provides a simpler interface than package_search for finding organizations.
+Wildcards are automatically added around the search pattern.
+
+Args:
+  - server_url (string): Base URL of CKAN server
+  - pattern (string): Search pattern (e.g., "toscana", "salute")
+  - response_format ('markdown' | 'json'): Output format
+
+Returns:
+  List of matching organizations with dataset counts
+
+Examples:
+  - { server_url: "https://www.dati.gov.it/opendata", pattern: "toscana" }
+  - { server_url: "https://catalog.data.gov", pattern: "health" }`,
+      inputSchema: z3.object({
+        server_url: z3.string().url(),
+        pattern: z3.string().min(1).describe("Search pattern (wildcards added automatically)"),
+        response_format: ResponseFormatSchema
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (params) => {
+      try {
+        const query = `organization:*${params.pattern}*`;
+        const result = await makeCkanRequest(
+          params.server_url,
+          "package_search",
+          {
+            q: query,
+            rows: 0,
+            "facet.field": JSON.stringify(["organization"]),
+            "facet.limit": 500
+          }
+        );
+        const orgFacets = result.search_facets?.organization?.items || [];
+        const totalDatasets = result.count || 0;
+        if (params.response_format === "json" /* JSON */) {
+          const jsonResult = {
+            count: orgFacets.length,
+            total_datasets: totalDatasets,
+            organizations: orgFacets.map((item) => ({
+              name: item.name,
+              display_name: item.display_name,
+              dataset_count: item.count
+            }))
+          };
+          return {
+            content: [{ type: "text", text: truncateText(JSON.stringify(jsonResult, null, 2)) }],
+            structuredContent: jsonResult
+          };
+        }
+        let markdown = `# CKAN Organization Search Results
+
+`;
+        markdown += `**Server**: ${params.server_url}
+`;
+        markdown += `**Pattern**: "${params.pattern}"
+`;
+        markdown += `**Organizations Found**: ${orgFacets.length}
+`;
+        markdown += `**Total Datasets**: ${totalDatasets}
+
+`;
+        if (orgFacets.length === 0) {
+          markdown += `No organizations found matching pattern "${params.pattern}".
+`;
+        } else {
+          markdown += `## Matching Organizations
+
+`;
+          markdown += `| Organization | Datasets |
+`;
+          markdown += `|--------------|----------|
+`;
+          for (const org of orgFacets) {
+            markdown += `| ${org.display_name || org.name} | ${org.count} |
+`;
+          }
+        }
+        return {
+          content: [{ type: "text", text: truncateText(markdown) }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error searching organizations: ${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/datastore.ts
+import { z as z4 } from "zod";
+function registerDatastoreTools(server2) {
+  server2.registerTool(
+    "ckan_datastore_search",
+    {
+      title: "Search CKAN DataStore",
+      description: `Query data from a CKAN DataStore resource.
+
+The DataStore allows SQL-like queries on tabular data. Not all resources have DataStore enabled.
+
+Args:
+  - server_url (string): Base URL of CKAN server
+  - resource_id (string): ID of the DataStore resource
+  - q (string): Full-text search query (optional)
+  - filters (object): Key-value filters (e.g., { "anno": 2023 })
+  - limit (number): Max rows to return (default: 100, max: 32000)
+  - offset (number): Pagination offset (default: 0)
+  - fields (array): Specific fields to return (optional)
+  - sort (string): Sort field with direction (e.g., "anno desc")
+  - distinct (boolean): Return distinct values (default: false)
+  - response_format ('markdown' | 'json'): Output format
+
+Returns:
+  DataStore records matching query
+
+Examples:
+  - { server_url: "...", resource_id: "abc-123", limit: 50 }
+  - { server_url: "...", resource_id: "...", filters: { "regione": "Sicilia" } }
+  - { server_url: "...", resource_id: "...", sort: "anno desc", limit: 100 }`,
+      inputSchema: z4.object({
+        server_url: z4.string().url(),
+        resource_id: z4.string().min(1),
+        q: z4.string().optional(),
+        filters: z4.record(z4.any()).optional(),
+        limit: z4.number().int().min(1).max(32e3).optional().default(100),
+        offset: z4.number().int().min(0).optional().default(0),
+        fields: z4.array(z4.string()).optional(),
+        sort: z4.string().optional(),
+        distinct: z4.boolean().optional().default(false),
+        response_format: ResponseFormatSchema
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const apiParams = {
+          resource_id: params.resource_id,
+          limit: params.limit,
+          offset: params.offset,
+          distinct: params.distinct
+        };
+        if (params.q) apiParams.q = params.q;
+        if (params.filters) apiParams.filters = JSON.stringify(params.filters);
+        if (params.fields) apiParams.fields = params.fields.join(",");
+        if (params.sort) apiParams.sort = params.sort;
+        const result = await makeCkanRequest(
+          params.server_url,
+          "datastore_search",
+          apiParams
+        );
+        if (params.response_format === "json" /* JSON */) {
+          return {
+            content: [{ type: "text", text: truncateText(JSON.stringify(result, null, 2)) }],
+            structuredContent: result
+          };
+        }
+        let markdown = `# DataStore Query Results
+
+`;
+        markdown += `**Server**: ${params.server_url}
+`;
+        markdown += `**Resource ID**: \`${params.resource_id}\`
+`;
+        markdown += `**Total Records**: ${result.total || 0}
+`;
+        markdown += `**Returned**: ${result.records ? result.records.length : 0} records
+
+`;
+        if (result.fields && result.fields.length > 0) {
+          markdown += `## Fields
+
+`;
+          markdown += result.fields.map((f) => `- **${f.id}** (${f.type})`).join("\n") + "\n\n";
+        }
+        if (result.records && result.records.length > 0) {
+          markdown += `## Records
+
+`;
+          const fields = result.fields.map((f) => f.id);
+          const displayFields = fields.slice(0, 8);
+          markdown += `| ${displayFields.join(" | ")} |
+`;
+          markdown += `| ${displayFields.map(() => "---").join(" | ")} |
+`;
+          for (const record of result.records.slice(0, 50)) {
+            const values = displayFields.map((field) => {
+              const val = record[field];
+              if (val === null || val === void 0) return "-";
+              const str = String(val);
+              return str.length > 50 ? str.substring(0, 47) + "..." : str;
+            });
+            markdown += `| ${values.join(" | ")} |
+`;
+          }
+          if (result.records.length > 50) {
+            markdown += `
+... and ${result.records.length - 50} more records
+`;
+          }
+          markdown += "\n";
+        }
+        if (result.total && result.total > params.offset + (result.records?.length || 0)) {
+          const nextOffset = params.offset + params.limit;
+          markdown += `**More results available**: Use \`offset: ${nextOffset}\` for next page.
+`;
+        }
+        return {
+          content: [{ type: "text", text: truncateText(markdown) }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error querying DataStore: ${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/status.ts
+import { z as z5 } from "zod";
+function registerStatusTools(server2) {
+  server2.registerTool(
+    "ckan_status_show",
+    {
+      title: "Check CKAN Server Status",
+      description: `Check if a CKAN server is available and get version information.
+
+Useful to verify server accessibility before making other requests.
+
+Args:
+  - server_url (string): Base URL of CKAN server
+
+Returns:
+  Server status and version information`,
+      inputSchema: z5.object({
+        server_url: z5.string().url().describe("Base URL of the CKAN server")
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await makeCkanRequest(
+          params.server_url,
+          "status_show",
+          {}
+        );
+        const markdown = `# CKAN Server Status
+
+**Server**: ${params.server_url}
+**Status**: \u2705 Online
+**CKAN Version**: ${result.ckan_version || "Unknown"}
+**Site Title**: ${result.site_title || "N/A"}
+**Site URL**: ${result.site_url || "N/A"}
+`;
+        return {
+          content: [{ type: "text", text: markdown }],
+          structuredContent: result
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `Server appears to be offline or not a valid CKAN instance:
+${error instanceof Error ? error.message : String(error)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/resources/dataset.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/resources/uri.ts
+function parseCkanUri(uri) {
+  const hostname = uri.hostname;
+  if (!hostname) {
+    throw new Error("Invalid ckan:// URI: missing server hostname");
+  }
+  const pathParts = uri.pathname.split("/").filter((p) => p.length > 0);
+  if (pathParts.length < 2) {
+    throw new Error(
+      `Invalid ckan:// URI: expected /{type}/{id}, got ${uri.pathname}`
+    );
+  }
+  const [type, ...idParts] = pathParts;
+  const id = idParts.join("/");
+  if (!type || !id) {
+    throw new Error("Invalid ckan:// URI: missing type or id");
+  }
+  const server2 = `https://${hostname}`;
+  return { server: server2, type, id };
+}
+
+// src/resources/dataset.ts
+function registerDatasetResource(server2) {
+  server2.registerResource(
+    "ckan-dataset",
+    new ResourceTemplate("ckan://{server}/dataset/{id}", { list: void 0 }),
+    {
+      title: "CKAN Dataset",
+      description: "Access dataset metadata from any CKAN server. URI format: ckan://{server}/dataset/{id}",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      try {
+        const { server: serverUrl } = parseCkanUri(uri);
+        const id = variables.id;
+        const result = await makeCkanRequest(serverUrl, "package_show", {
+          id
+        });
+        const content = truncateText(JSON.stringify(result, null, 2));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: content
+            }
+          ]
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Error fetching dataset: ${errorMessage}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/resource.ts
+import { ResourceTemplate as ResourceTemplate2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResourceResource(server2) {
+  server2.registerResource(
+    "ckan-resource",
+    new ResourceTemplate2("ckan://{server}/resource/{id}", { list: void 0 }),
+    {
+      title: "CKAN Resource",
+      description: "Access resource metadata and download URL from any CKAN server. URI format: ckan://{server}/resource/{id}",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      try {
+        const { server: serverUrl } = parseCkanUri(uri);
+        const id = variables.id;
+        const result = await makeCkanRequest(serverUrl, "resource_show", {
+          id
+        });
+        const content = truncateText(JSON.stringify(result, null, 2));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: content
+            }
+          ]
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Error fetching resource: ${errorMessage}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/organization.ts
+import { ResourceTemplate as ResourceTemplate3 } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerOrganizationResource(server2) {
+  server2.registerResource(
+    "ckan-organization",
+    new ResourceTemplate3("ckan://{server}/organization/{name}", {
+      list: void 0
+    }),
+    {
+      title: "CKAN Organization",
+      description: "Access organization metadata from any CKAN server. URI format: ckan://{server}/organization/{name}",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      try {
+        const { server: serverUrl } = parseCkanUri(uri);
+        const name = variables.name;
+        const result = await makeCkanRequest(
+          serverUrl,
+          "organization_show",
+          {
+            id: name,
+            include_datasets: false
+          }
+        );
+        const content = truncateText(JSON.stringify(result, null, 2));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: content
+            }
+          ]
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Error fetching organization: ${errorMessage}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerAllResources(server2) {
+  registerDatasetResource(server2);
+  registerResourceResource(server2);
+  registerOrganizationResource(server2);
+}
+
+// src/transport/stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function runStdio(server2) {
+  const transport2 = new StdioServerTransport();
+  await server2.connect(transport2);
+  console.error("CKAN MCP server running on stdio");
+}
+
+// src/transport/http.ts
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+async function runHTTP(server2) {
+  const app = express();
+  app.use(express.json());
+  app.post("/mcp", async (req, res) => {
+    const transport2 = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+    res.on("close", () => transport2.close());
+    await server2.connect(transport2);
+    await transport2.handleRequest(req, res, req.body);
+  });
+  const port = parseInt(process.env.PORT || "3000");
+  app.listen(port, () => {
+    console.error(`CKAN MCP server running on http://localhost:${port}/mcp`);
+  });
+}
+
+// src/index.ts
+var server = createServer();
+registerPackageTools(server);
+registerOrganizationTools(server);
+registerDatastoreTools(server);
+registerStatusTools(server);
+registerAllResources(server);
+var transport = process.env.TRANSPORT || "stdio";
+if (transport === "http") {
+  runHTTP(server).catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+  });
+} else {
+  runStdio(server).catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+  });
+}