@jaypie/mcp 0.3.2 → 0.3.4

package/dist/index.js

@@ -9,1212 +9,21 @@ import { z } from 'zod';
 import * as fs from 'node:fs/promises';
 import matter from 'gray-matter';
 import { gt } from 'semver';
-import * as https from 'node:https';
-import { Llm } from '@jaypie/llm';
-import { spawn } from 'node:child_process';
-import * as os from 'node:os';
+import { g as getDatadogCredentials, s as searchDatadogLogs, a as aggregateDatadogLogs, l as listDatadogMonitors, b as getDatadogSyntheticResults, c as listDatadogSynthetics, q as queryDatadogMetrics, d as searchDatadogRum, e as debugLlmCall, f as listLlmProviders, h as listAwsProfiles, i as listStepFunctionExecutions, j as stopStepFunctionExecution, k as listLambdaFunctions, m as getLambdaFunction, n as filterLogEvents, o as listS3Objects, p as describeStack, r as describeDynamoDBTable, t as scanDynamoDB, u as queryDynamoDB, v as getDynamoDBItem, w as listSQSQueues, x as getSQSQueueAttributes, y as receiveSQSMessage, z as purgeSQSQueue } from './aws-B3dW_-bD.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { randomUUID } from 'node:crypto';
+import 'node:https';
+import '@jaypie/llm';
+import 'node:child_process';
+import 'node:os';
 
-/**
- * Datadog API integration module
- */
-const nullLogger$1 = {
-    info: () => { },
-    error: () => { },
-};
-/**
- * Get Datadog credentials from environment variables
- */
-function getDatadogCredentials() {
-    const apiKey = process.env.DATADOG_API_KEY || process.env.DD_API_KEY;
-    const appKey = process.env.DATADOG_APP_KEY ||
-        process.env.DATADOG_APPLICATION_KEY ||
-        process.env.DD_APP_KEY ||
-        process.env.DD_APPLICATION_KEY;
-    if (!apiKey || !appKey) {
-        return null;
-    }
-    return { apiKey, appKey };
-}
-/**
- * Build query string from environment variables and options
- */
-function buildDatadogQuery(options) {
-    const ddEnv = process.env.DD_ENV;
-    const ddService = process.env.DD_SERVICE;
-    const ddSource = process.env.DD_SOURCE;
-    const ddQuery = process.env.DD_QUERY;
-    const queryParts = [];
-    // Add source (parameter > env var > default 'lambda')
-    const effectiveSource = options.source || ddSource || "lambda";
-    queryParts.push(`source:${effectiveSource}`);
-    // Add env (parameter > env var)
-    const effectiveEnv = options.env || ddEnv;
-    if (effectiveEnv) {
-        queryParts.push(`env:${effectiveEnv}`);
-    }
-    // Add service (parameter > env var)
-    const effectiveService = options.service || ddService;
-    if (effectiveService) {
-        queryParts.push(`service:${effectiveService}`);
-    }
-    // Add base query from DD_QUERY if available
-    if (ddQuery) {
-        queryParts.push(ddQuery);
-    }
-    // Add user-provided query terms
-    if (options.query) {
-        queryParts.push(options.query);
-    }
-    return queryParts.join(" ");
-}
-/**
- * Search Datadog logs
- */
-async function searchDatadogLogs(credentials, options = {}, logger = nullLogger$1) {
-    const effectiveQuery = buildDatadogQuery(options);
-    const effectiveFrom = options.from || "now-15m";
-    const effectiveTo = options.to || "now";
-    const effectiveLimit = Math.min(options.limit || 50, 1000);
-    const effectiveSort = options.sort || "-timestamp";
-    logger.info(`Effective query: ${effectiveQuery}`);
-    logger.info(`Search params: from=${effectiveFrom}, to=${effectiveTo}, limit=${effectiveLimit}, sort=${effectiveSort}`);
-    const requestBody = JSON.stringify({
-        filter: {
-            query: effectiveQuery,
-            from: effectiveFrom,
-            to: effectiveTo,
-        },
-        page: {
-            limit: effectiveLimit,
-        },
-        sort: effectiveSort,
-    });
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path: "/api/v2/logs/events/search",
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-                "Content-Length": Buffer.byteLength(requestBody),
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    if (res.statusCode === 400) {
-                        errorMessage = `Invalid query syntax. Check your query: "${effectiveQuery}". Datadog error: ${data}`;
-                    }
-                    else if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have logs_read permission.";
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
-                    }
-                    resolve({
-                        success: false,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        logs: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    const logs = (response.data || []).map((log) => {
-                        const attrs = log.attributes || {};
-                        return {
-                            id: log.id,
-                            timestamp: attrs.timestamp,
-                            status: attrs.status,
-                            service: attrs.service,
-                            message: attrs.message,
-                            attributes: attrs.attributes,
-                        };
-                    });
-                    logger.info(`Retrieved ${logs.length} log entries`);
-                    resolve({
-                        success: true,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        logs,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog response:", parseError);
-                    resolve({
-                        success: false,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        logs: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                query: effectiveQuery,
-                timeRange: { from: effectiveFrom, to: effectiveTo },
-                logs: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.write(requestBody);
-        req.end();
-    });
-}
-/**
- * Aggregate Datadog logs using the Analytics API
- * Groups logs by specified fields and computes aggregations
- */
-async function aggregateDatadogLogs(credentials, options, logger = nullLogger$1) {
-    const effectiveQuery = buildDatadogQuery(options);
-    const effectiveFrom = options.from || "now-15m";
-    const effectiveTo = options.to || "now";
-    const groupBy = options.groupBy;
-    const compute = options.compute || [{ aggregation: "count" }];
-    logger.info(`Analytics query: ${effectiveQuery}`);
-    logger.info(`Group by: ${groupBy.join(", ")}`);
-    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
-    // Build compute array - each item needs aggregation and type
-    const computeItems = compute.map((c) => {
-        const item = {
-            aggregation: c.aggregation,
-            type: "total",
-        };
-        if (c.metric) {
-            item.metric = c.metric;
-        }
-        return item;
-    });
-    // Build group_by with proper sort configuration
-    const groupByItems = groupBy.map((field) => {
-        const item = {
-            facet: field,
-            limit: 100,
-            sort: {
-                type: "measure",
-                order: "desc",
-                aggregation: compute[0]?.aggregation || "count",
-            },
-        };
-        return item;
-    });
-    const requestBody = JSON.stringify({
-        filter: {
-            query: effectiveQuery,
-            from: effectiveFrom,
-            to: effectiveTo,
-        },
-        group_by: groupByItems,
-        compute: computeItems,
-        page: {
-            limit: 100,
-        },
-    });
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path: "/api/v2/logs/analytics/aggregate",
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-                "Content-Length": Buffer.byteLength(requestBody),
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog Analytics API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    if (res.statusCode === 400) {
-                        errorMessage = `Invalid query or groupBy fields. Verify facet names exist: ${groupBy.join(", ")}. Datadog error: ${data}`;
-                    }
-                    else if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have logs_read permission.";
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
-                    }
-                    resolve({
-                        success: false,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        groupBy,
-                        buckets: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    const buckets = (response.data?.buckets || []).map((bucket) => ({
-                        by: bucket.by || {},
-                        computes: bucket.computes || {},
-                    }));
-                    logger.info(`Retrieved ${buckets.length} aggregation buckets`);
-                    resolve({
-                        success: true,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        groupBy,
-                        buckets,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog analytics response:", parseError);
-                    resolve({
-                        success: false,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        groupBy,
-                        buckets: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                query: effectiveQuery,
-                timeRange: { from: effectiveFrom, to: effectiveTo },
-                groupBy,
-                buckets: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.write(requestBody);
-        req.end();
-    });
-}
-/**
- * List Datadog monitors with optional filtering
- */
-async function listDatadogMonitors(credentials, options = {}, logger = nullLogger$1) {
-    logger.info("Fetching Datadog monitors");
-    const queryParams = new URLSearchParams();
-    if (options.tags && options.tags.length > 0) {
-        queryParams.set("tags", options.tags.join(","));
-    }
-    if (options.monitorTags && options.monitorTags.length > 0) {
-        queryParams.set("monitor_tags", options.monitorTags.join(","));
-    }
-    if (options.name) {
-        queryParams.set("name", options.name);
-    }
-    const queryString = queryParams.toString();
-    const path = `/api/v1/monitor${queryString ? `?${queryString}` : ""}`;
-    logger.info(`Request path: ${path}`);
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path,
-            method: "GET",
-            headers: {
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog Monitors API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have monitors_read permission.";
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again.";
-                    }
-                    resolve({
-                        success: false,
-                        monitors: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    let monitors = response.map((monitor) => ({
-                        id: monitor.id,
-                        name: monitor.name,
-                        type: monitor.type,
-                        status: monitor.overall_state || "Unknown",
-                        message: monitor.message,
-                        tags: monitor.tags || [],
-                        priority: monitor.priority,
-                        query: monitor.query,
-                        overallState: monitor.overall_state,
-                    }));
-                    // Filter by status if specified
-                    if (options.status && options.status.length > 0) {
-                        monitors = monitors.filter((m) => options.status.includes(m.status));
-                    }
-                    logger.info(`Retrieved ${monitors.length} monitors`);
-                    resolve({
-                        success: true,
-                        monitors,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog monitors response:", parseError);
-                    resolve({
-                        success: false,
-                        monitors: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                monitors: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.end();
-    });
-}
-/**
- * List Datadog Synthetic tests
- */
-async function listDatadogSynthetics(credentials, options = {}, logger = nullLogger$1) {
-    logger.info("Fetching Datadog Synthetic tests");
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path: "/api/v1/synthetics/tests",
-            method: "GET",
-            headers: {
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog Synthetics API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again.";
-                    }
-                    resolve({
-                        success: false,
-                        tests: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    let tests = (response.tests || []).map((test) => ({
-                        publicId: test.public_id,
-                        name: test.name,
-                        type: test.type,
-                        status: test.status,
-                        tags: test.tags || [],
-                        locations: test.locations || [],
-                        message: test.message,
-                    }));
-                    // Filter by type if specified
-                    if (options.type) {
-                        tests = tests.filter((t) => t.type === options.type);
-                    }
-                    // Filter by tags if specified
-                    if (options.tags && options.tags.length > 0) {
-                        tests = tests.filter((t) => options.tags.some((tag) => t.tags.includes(tag)));
-                    }
-                    logger.info(`Retrieved ${tests.length} synthetic tests`);
-                    resolve({
-                        success: true,
-                        tests,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog synthetics response:", parseError);
-                    resolve({
-                        success: false,
-                        tests: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                tests: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.end();
-    });
-}
-/**
- * Get recent results for a specific Synthetic test
- */
-async function getDatadogSyntheticResults(credentials, publicId, logger = nullLogger$1) {
-    logger.info(`Fetching results for Synthetic test: ${publicId}`);
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path: `/api/v1/synthetics/tests/${publicId}/results`,
-            method: "GET",
-            headers: {
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog Synthetics Results API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
-                    }
-                    else if (res.statusCode === 404) {
-                        errorMessage = `Synthetic test '${publicId}' not found. Use datadog_synthetics (without testId) to list available tests.`;
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again.";
-                    }
-                    resolve({
-                        success: false,
-                        publicId,
-                        results: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    const results = (response.results || []).map((result) => ({
-                        publicId,
-                        resultId: result.result_id,
-                        status: result.status,
-                        checkTime: result.check_time,
-                        passed: result.result?.passed ?? result.status === 0,
-                        location: result.dc_id?.toString(),
-                    }));
-                    logger.info(`Retrieved ${results.length} synthetic results`);
-                    resolve({
-                        success: true,
-                        publicId,
-                        results,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog synthetic results:", parseError);
-                    resolve({
-                        success: false,
-                        publicId,
-                        results: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                publicId,
-                results: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.end();
-    });
-}
-/**
- * Query Datadog metrics
- */
-async function queryDatadogMetrics(credentials, options, logger = nullLogger$1) {
-    logger.info(`Querying metrics: ${options.query}`);
-    logger.info(`Time range: ${options.from} to ${options.to}`);
-    const queryParams = new URLSearchParams({
-        query: options.query,
-        from: options.from.toString(),
-        to: options.to.toString(),
-    });
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path: `/api/v1/query?${queryParams.toString()}`,
-            method: "GET",
-            headers: {
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog Metrics API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    if (res.statusCode === 400) {
-                        errorMessage = `Invalid metric query. Check format: 'aggregation:metric.name{tags}'. Query: "${options.query}". Datadog error: ${data}`;
-                    }
-                    else if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have metrics_read permission.";
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again, or reduce your time range.";
-                    }
-                    resolve({
-                        success: false,
-                        query: options.query,
-                        timeRange: { from: options.from, to: options.to },
-                        series: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    const series = (response.series || []).map((s) => ({
-                        metric: s.metric,
-                        scope: s.scope,
-                        pointlist: s.pointlist,
-                        unit: s.unit?.[0]?.name,
-                    }));
-                    logger.info(`Retrieved ${series.length} metric series`);
-                    resolve({
-                        success: true,
-                        query: options.query,
-                        timeRange: { from: options.from, to: options.to },
-                        series,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog metrics response:", parseError);
-                    resolve({
-                        success: false,
-                        query: options.query,
-                        timeRange: { from: options.from, to: options.to },
-                        series: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                query: options.query,
-                timeRange: { from: options.from, to: options.to },
-                series: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.end();
-    });
-}
-/**
- * Search Datadog RUM events
- */
-async function searchDatadogRum(credentials, options = {}, logger = nullLogger$1) {
-    const effectiveQuery = options.query || "*";
-    const effectiveFrom = options.from || "now-15m";
-    const effectiveTo = options.to || "now";
-    const effectiveLimit = Math.min(options.limit || 50, 1000);
-    const effectiveSort = options.sort || "-timestamp";
-    logger.info(`RUM query: ${effectiveQuery}`);
-    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
-    const requestBody = JSON.stringify({
-        filter: {
-            query: effectiveQuery,
-            from: effectiveFrom,
-            to: effectiveTo,
-        },
-        page: {
-            limit: effectiveLimit,
-        },
-        sort: effectiveSort,
-    });
-    return new Promise((resolve) => {
-        const requestOptions = {
-            hostname: "api.datadoghq.com",
-            port: 443,
-            path: "/api/v2/rum/events/search",
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "DD-API-KEY": credentials.apiKey,
-                "DD-APPLICATION-KEY": credentials.appKey,
-                "Content-Length": Buffer.byteLength(requestBody),
-            },
-        };
-        const req = https.request(requestOptions, (res) => {
-            let data = "";
-            res.on("data", (chunk) => {
-                data += chunk.toString();
-            });
-            res.on("end", () => {
-                logger.info(`Response status: ${res.statusCode}`);
-                if (res.statusCode !== 200) {
-                    logger.error(`Datadog RUM API error: ${res.statusCode}`);
-                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
-                    // Check for specific "No valid indexes" error which means no RUM app is configured
-                    if (data.includes("No valid indexes")) {
-                        errorMessage =
-                            "No RUM application found. Ensure you have a RUM application configured in Datadog and it has collected data. " +
-                                "You can create a RUM application at https://app.datadoghq.com/rum/list";
-                    }
-                    else if (res.statusCode === 400) {
-                        errorMessage = `Invalid RUM query. Check syntax: "${effectiveQuery}". Datadog error: ${data}`;
-                    }
-                    else if (res.statusCode === 403) {
-                        errorMessage =
-                            "Access denied. Verify your API and Application keys have rum_read permission.";
-                    }
-                    else if (res.statusCode === 429) {
-                        errorMessage =
-                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
-                    }
-                    resolve({
-                        success: false,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        events: [],
-                        error: errorMessage,
-                    });
-                    return;
-                }
-                try {
-                    const response = JSON.parse(data);
-                    const events = (response.data || []).map((event) => {
-                        const attrs = event.attributes?.attributes || {};
-                        return {
-                            id: event.id,
-                            type: event.type,
-                            timestamp: event.attributes?.timestamp,
-                            sessionId: attrs.session?.id,
-                            viewUrl: attrs.view?.url,
-                            viewName: attrs.view?.name,
-                            errorMessage: attrs.error?.message,
-                            errorType: attrs.error?.type,
-                            attributes: attrs,
-                        };
-                    });
-                    logger.info(`Retrieved ${events.length} RUM events`);
-                    resolve({
-                        success: true,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        events,
-                    });
-                }
-                catch (parseError) {
-                    logger.error("Failed to parse Datadog RUM response:", parseError);
-                    resolve({
-                        success: false,
-                        query: effectiveQuery,
-                        timeRange: { from: effectiveFrom, to: effectiveTo },
-                        events: [],
-                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
-                    });
-                }
-            });
-        });
-        req.on("error", (error) => {
-            logger.error("Request error:", error);
-            resolve({
-                success: false,
-                query: effectiveQuery,
-                timeRange: { from: effectiveFrom, to: effectiveTo },
-                events: [],
-                error: `Connection error: ${error.message}`,
-            });
-        });
-        req.write(requestBody);
-        req.end();
-    });
-}
-
-/**
- * LLM debugging utilities for inspecting raw provider responses
- */
-// Default models for each provider
-const DEFAULT_MODELS = {
-    anthropic: "claude-sonnet-4-20250514",
-    gemini: "gemini-2.0-flash",
-    openai: "gpt-4o-mini",
-    openrouter: "openai/gpt-4o-mini",
-};
-/**
- * Make a debug LLM call and return the raw response data for inspection
- */
-async function debugLlmCall(params, log) {
-    const { provider, message } = params;
-    const model = params.model || DEFAULT_MODELS[provider];
-    log.info(`Making debug LLM call to ${provider} with model ${model}`);
-    try {
-        const llm = new Llm(provider, { model });
-        const result = await llm.operate(message, {
-            user: "[jaypie-mcp] Debug LLM Call",
-        });
-        if (result.error) {
-            return {
-                success: false,
-                provider,
-                model,
-                error: `${result.error.title}: ${result.error.detail || "Unknown error"}`,
-            };
-        }
-        // Calculate total reasoning tokens
-        const reasoningTokens = result.usage.reduce((sum, u) => sum + (u.reasoning || 0), 0);
-        return {
-            success: true,
-            provider,
-            model,
-            content: typeof result.content === "string"
-                ? result.content
-                : JSON.stringify(result.content),
-            reasoning: result.reasoning,
-            reasoningTokens,
-            history: result.history,
-            rawResponses: result.responses,
-            usage: result.usage,
-        };
-    }
-    catch (error) {
-        log.error(`Error calling ${provider}:`, error);
-        return {
-            success: false,
-            provider,
-            model,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * List available providers and their default/reasoning models
- */
-function listLlmProviders() {
-    return {
-        providers: [
-            {
-                name: "openai",
-                defaultModel: DEFAULT_MODELS.openai,
-                reasoningModels: ["o3-mini", "o1-preview", "o1-mini"],
-            },
-            {
-                name: "anthropic",
-                defaultModel: DEFAULT_MODELS.anthropic,
-                reasoningModels: [], // Anthropic doesn't expose reasoning the same way
-            },
-            {
-                name: "gemini",
-                defaultModel: DEFAULT_MODELS.gemini,
-                reasoningModels: [], // Gemini has thoughtsTokenCount but unclear on content
-            },
-            {
-                name: "openrouter",
-                defaultModel: DEFAULT_MODELS.openrouter,
-                reasoningModels: ["openai/o3-mini", "openai/o1-preview"],
-            },
-        ],
-    };
-}
-
-/**
- * AWS CLI integration module
- * Provides a structured interface for common AWS operations via the AWS CLI
- */
-const nullLogger = {
-    info: () => { },
-    error: () => { },
-};
-/**
- * Parse AWS CLI error messages into user-friendly descriptions
- */
-function parseAwsError(stderr, service, command) {
-    if (stderr.includes("ExpiredToken") || stderr.includes("Token has expired")) {
-        return "AWS credentials have expired. Run 'aws sso login' or refresh your credentials.";
-    }
-    if (stderr.includes("NoCredentialProviders") ||
-        stderr.includes("Unable to locate credentials")) {
-        return "No AWS credentials found. Configure credentials with 'aws configure' or 'aws sso login'.";
-    }
-    if (stderr.includes("AccessDenied") || stderr.includes("Access Denied")) {
-        return `Access denied for ${service}:${command}. Check your IAM permissions.`;
-    }
-    if (stderr.includes("ResourceNotFoundException")) {
-        return `Resource not found. Check that the specified resource exists in the correct region.`;
-    }
-    if (stderr.includes("ValidationException")) {
-        const match = stderr.match(/ValidationException[^:]*:\s*(.+)/);
-        return match
-            ? `Validation error: ${match[1].trim()}`
-            : "Validation error in request parameters.";
-    }
-    if (stderr.includes("ThrottlingException") ||
-        stderr.includes("Rate exceeded")) {
-        return "AWS API rate limit exceeded. Wait a moment and try again.";
-    }
-    if (stderr.includes("InvalidParameterValue")) {
-        const match = stderr.match(/InvalidParameterValue[^:]*:\s*(.+)/);
-        return match
-            ? `Invalid parameter: ${match[1].trim()}`
-            : "Invalid parameter value provided.";
-    }
-    return stderr.trim();
-}
-/**
- * Parse relative time strings like 'now-1h' to Unix timestamps
- */
-function parseRelativeTime(timeStr) {
-    const now = Date.now();
-    if (timeStr === "now") {
-        return now;
-    }
-    // Handle relative time like 'now-15m', 'now-1h', 'now-1d'
-    const relativeMatch = timeStr.match(/^now-(\d+)([smhd])$/);
-    if (relativeMatch) {
-        const value = parseInt(relativeMatch[1], 10);
-        const unit = relativeMatch[2];
-        const multipliers = {
-            s: 1000,
-            m: 60 * 1000,
-            h: 60 * 60 * 1000,
-            d: 24 * 60 * 60 * 1000,
-        };
-        return now - value * multipliers[unit];
-    }
-    // Handle ISO 8601 format
-    const parsed = Date.parse(timeStr);
-    if (!isNaN(parsed)) {
-        return parsed;
-    }
-    // Default to the current time if parsing fails
-    return now;
-}
-/**
- * Execute an AWS CLI command and return parsed JSON output
- */
-async function executeAwsCommand(service, command, args, options = {}, logger = nullLogger) {
-    const fullArgs = [service, command, ...args, "--output", "json"];
-    if (options.profile) {
-        fullArgs.push("--profile", options.profile);
-    }
-    if (options.region) {
-        fullArgs.push("--region", options.region);
-    }
-    logger.info(`Executing: aws ${fullArgs.join(" ")}`);
-    return new Promise((resolve) => {
-        const proc = spawn("aws", fullArgs);
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.on("data", (data) => {
-            stdout += data.toString();
-        });
-        proc.stderr.on("data", (data) => {
-            stderr += data.toString();
-        });
-        proc.on("close", (code) => {
-            if (code !== 0) {
-                logger.error(`AWS CLI error: ${stderr}`);
-                resolve({
-                    success: false,
-                    error: parseAwsError(stderr, service, command),
-                });
-                return;
-            }
-            // Handle empty output (some commands return nothing on success)
-            if (!stdout.trim()) {
-                resolve({ success: true });
-                return;
-            }
-            try {
-                const data = JSON.parse(stdout);
-                resolve({ success: true, data });
-            }
-            catch {
-                // Some commands return plain text
-                resolve({ success: true, data: stdout.trim() });
-            }
-        });
-        proc.on("error", (error) => {
-            if (error.message.includes("ENOENT")) {
-                resolve({
-                    success: false,
-                    error: "AWS CLI not found. Install it from https://aws.amazon.com/cli/",
-                });
-            }
-            else {
-                resolve({ success: false, error: error.message });
-            }
-        });
-    });
-}
-/**
- * List available AWS profiles from ~/.aws/config and ~/.aws/credentials
- */
-async function listAwsProfiles(logger = nullLogger) {
-    const profiles = [];
-    const homeDir = os.homedir();
-    try {
-        // Parse ~/.aws/config
-        const configPath = path.join(homeDir, ".aws", "config");
-        try {
-            const configContent = await fs.readFile(configPath, "utf-8");
-            const profileRegex = /\[profile\s+([^\]]+)\]|\[default\]/g;
-            let match;
-            while ((match = profileRegex.exec(configContent)) !== null) {
-                const name = match[1] || "default";
-                profiles.push({
-                    name,
-                    source: "config",
-                });
-            }
-            logger.info(`Found ${profiles.length} profiles in config`);
-        }
-        catch {
-            logger.info("No ~/.aws/config file found");
-        }
-        // Parse ~/.aws/credentials
-        const credentialsPath = path.join(homeDir, ".aws", "credentials");
-        try {
-            const credentialsContent = await fs.readFile(credentialsPath, "utf-8");
-            const profileRegex = /\[([^\]]+)\]/g;
-            let match;
-            while ((match = profileRegex.exec(credentialsContent)) !== null) {
-                const name = match[1];
-                // Only add if not already in the list
-                if (!profiles.find((p) => p.name === name)) {
-                    profiles.push({
-                        name,
-                        source: "credentials",
-                    });
-                }
-            }
-            logger.info(`Total profiles after credentials: ${profiles.length}`);
-        }
-        catch {
-            logger.info("No ~/.aws/credentials file found");
-        }
-        return { success: true, data: profiles };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logger.error(`Error listing profiles: ${errorMessage}`);
-        return { success: false, error: errorMessage };
-    }
-}
-// Step Functions operations
-async function listStepFunctionExecutions(options, logger = nullLogger) {
-    const args = ["--state-machine-arn", options.stateMachineArn];
-    if (options.statusFilter) {
-        args.push("--status-filter", options.statusFilter);
-    }
-    if (options.maxResults) {
-        args.push("--max-results", String(options.maxResults));
-    }
-    return executeAwsCommand("stepfunctions", "list-executions", args, { profile: options.profile, region: options.region }, logger);
-}
-async function stopStepFunctionExecution(options, logger = nullLogger) {
-    const args = ["--execution-arn", options.executionArn];
-    if (options.cause) {
-        args.push("--cause", options.cause);
-    }
-    return executeAwsCommand("stepfunctions", "stop-execution", args, { profile: options.profile, region: options.region }, logger);
-}
-// Lambda operations
-async function listLambdaFunctions(options = {}, logger = nullLogger) {
-    const args = [];
-    if (options.maxResults) {
-        args.push("--max-items", String(options.maxResults));
-    }
-    const result = await executeAwsCommand("lambda", "list-functions", args, { profile: options.profile, region: options.region }, logger);
-    // Filter by prefix if specified
-    if (result.success && result.data && options.functionNamePrefix) {
-        result.data.Functions = result.data.Functions.filter((f) => f.FunctionName.startsWith(options.functionNamePrefix));
-    }
-    return result;
-}
-async function getLambdaFunction(options, logger = nullLogger) {
-    return executeAwsCommand("lambda", "get-function", ["--function-name", options.functionName], { profile: options.profile, region: options.region }, logger);
-}
-// CloudWatch Logs operations
-async function filterLogEvents(options, logger = nullLogger) {
-    const args = ["--log-group-name", options.logGroupName];
-    if (options.filterPattern) {
-        args.push("--filter-pattern", options.filterPattern);
-    }
-    if (options.startTime) {
-        const startMs = parseRelativeTime(options.startTime);
-        args.push("--start-time", String(startMs));
-    }
-    if (options.endTime) {
-        const endMs = parseRelativeTime(options.endTime);
-        args.push("--end-time", String(endMs));
-    }
-    {
-        args.push("--limit", String(options.limit));
-    }
-    return executeAwsCommand("logs", "filter-log-events", args, { profile: options.profile, region: options.region }, logger);
-}
-// S3 operations
-async function listS3Objects(options, logger = nullLogger) {
-    const args = ["--bucket", options.bucket];
-    if (options.prefix) {
-        args.push("--prefix", options.prefix);
-    }
-    if (options.maxResults) {
-        args.push("--max-items", String(options.maxResults));
-    }
-    return executeAwsCommand("s3api", "list-objects-v2", args, { profile: options.profile, region: options.region }, logger);
-}
-// CloudFormation operations
-async function describeStack(options, logger = nullLogger) {
-    return executeAwsCommand("cloudformation", "describe-stacks", ["--stack-name", options.stackName], { profile: options.profile, region: options.region }, logger);
-}
-// DynamoDB operations
-async function describeDynamoDBTable(options, logger = nullLogger) {
-    return executeAwsCommand("dynamodb", "describe-table", ["--table-name", options.tableName], { profile: options.profile, region: options.region }, logger);
-}
-async function scanDynamoDB(options, logger = nullLogger) {
-    const args = ["--table-name", options.tableName];
-    if (options.filterExpression) {
-        args.push("--filter-expression", options.filterExpression);
-    }
-    if (options.expressionAttributeValues) {
-        args.push("--expression-attribute-values", options.expressionAttributeValues);
-    }
-    {
-        args.push("--limit", String(options.limit));
-    }
-    return executeAwsCommand("dynamodb", "scan", args, { profile: options.profile, region: options.region }, logger);
-}
-async function queryDynamoDB(options, logger = nullLogger) {
-    const args = [
-        "--table-name",
-        options.tableName,
-        "--key-condition-expression",
-        options.keyConditionExpression,
-        "--expression-attribute-values",
-        options.expressionAttributeValues,
-    ];
-    if (options.indexName) {
-        args.push("--index-name", options.indexName);
-    }
-    if (options.filterExpression) {
-        args.push("--filter-expression", options.filterExpression);
-    }
-    if (options.limit) {
-        args.push("--limit", String(options.limit));
-    }
-    if (options.scanIndexForward === false) {
-        args.push("--no-scan-index-forward");
-    }
-    return executeAwsCommand("dynamodb", "query", args, { profile: options.profile, region: options.region }, logger);
-}
-async function getDynamoDBItem(options, logger = nullLogger) {
-    return executeAwsCommand("dynamodb", "get-item", ["--table-name", options.tableName, "--key", options.key], { profile: options.profile, region: options.region }, logger);
-}
-// SQS operations
-async function listSQSQueues(options = {}, logger = nullLogger) {
-    const args = [];
-    if (options.queueNamePrefix) {
-        args.push("--queue-name-prefix", options.queueNamePrefix);
-    }
-    return executeAwsCommand("sqs", "list-queues", args, { profile: options.profile, region: options.region }, logger);
-}
-async function getSQSQueueAttributes(options, logger = nullLogger) {
-    return executeAwsCommand("sqs", "get-queue-attributes", ["--queue-url", options.queueUrl, "--attribute-names", "All"], { profile: options.profile, region: options.region }, logger);
-}
-async function receiveSQSMessage(options, logger = nullLogger) {
-    const args = ["--queue-url", options.queueUrl];
-    {
-        args.push("--max-number-of-messages", String(options.maxNumberOfMessages));
-    }
-    {
-        args.push("--visibility-timeout", String(options.visibilityTimeout));
-    }
-    args.push("--attribute-names", "All");
-    return executeAwsCommand("sqs", "receive-message", args, { profile: options.profile, region: options.region }, logger);
-}
-async function purgeSQSQueue(options, logger = nullLogger) {
-    return executeAwsCommand("sqs", "purge-queue", ["--queue-url", options.queueUrl], { profile: options.profile, region: options.region }, logger);
-}
-
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.3.2#f7a87775"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.3.4#a6510094"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
 const PROMPTS_PATH = path.join(__dirname$1, "..", "prompts");
 const RELEASE_NOTES_PATH = path.join(__dirname$1, "..", "release-notes");
+const SKILLS_PATH = path.join(__dirname$1, "..", "skills");
 // Logger utility
 function createLogger(verbose) {
     return {
@@ -1331,6 +140,42 @@ function filterReleaseNotesSince(notes, sinceVersion) {
         }
     });
 }
+function isValidSkillAlias(alias) {
+    const normalized = alias.toLowerCase().trim();
+    // Reject if contains path separators or traversal
+    if (normalized.includes("/") ||
+        normalized.includes("\\") ||
+        normalized.includes("..")) {
+        return false;
+    }
+    // Only allow alphanumeric, hyphens, underscores
+    return /^[a-z0-9_-]+$/.test(normalized);
+}
+async function parseSkillFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const alias = path.basename(filePath, ".md");
+        if (content.startsWith("---")) {
+            const parsed = matter(content);
+            const frontMatter = parsed.data;
+            return {
+                alias,
+                description: frontMatter.description,
+            };
+        }
+        return { alias };
+    }
+    catch {
+        return { alias: path.basename(filePath, ".md") };
+    }
+}
+function formatSkillListItem(skill) {
+    const { alias, description } = skill;
+    if (description) {
+        return `* ${alias} - ${description}`;
+    }
+    return `* ${alias}`;
+}
 /**
  * Creates and configures an MCP server instance with Jaypie tools
  * @param options - Configuration options (or legacy version string)
@@ -1350,7 +195,7 @@ function createMcpServer(options = {}) {
         capabilities: {},
     });
     log.info("Registering tools...");
-    server.tool("list_prompts", "List available Jaypie development prompts and guides. Use this FIRST when starting work on a Jaypie project to discover relevant documentation. Returns filenames, descriptions, and which file patterns each prompt applies to (e.g., 'Required for packages/express/**').", {}, async () => {
+    server.tool("list_prompts", "[DEPRECATED: Use skill('index') instead] List available Jaypie development prompts and guides. Use this FIRST when starting work on a Jaypie project to discover relevant documentation. Returns filenames, descriptions, and which file patterns each prompt applies to (e.g., 'Required for packages/express/**').", {}, async () => {
         log.info("Tool called: list_prompts");
         log.info(`Reading directory: ${PROMPTS_PATH}`);
         try {
@@ -1382,7 +227,7 @@ function createMcpServer(options = {}) {
         }
     });
     log.info("Registered tool: list_prompts");
-    server.tool("read_prompt", "Read a Jaypie prompt/guide by filename. Call list_prompts first to see available prompts. These contain best practices, templates, code patterns, and step-by-step guides for Jaypie development tasks.", {
+    server.tool("read_prompt", "[DEPRECATED: Use skill(alias) instead] Read a Jaypie prompt/guide by filename. Call list_prompts first to see available prompts. These contain best practices, templates, code patterns, and step-by-step guides for Jaypie development tasks.", {
         filename: z
             .string()
             .describe("The prompt filename from list_prompts (e.g., 'Jaypie_Express_Package.md', 'Development_Process.md')"),
@@ -1426,6 +271,124 @@ function createMcpServer(options = {}) {
         }
     });
     log.info("Registered tool: read_prompt");
+    // Skill tool - new unified documentation access
+    server.tool("skill", "Access Jaypie development documentation. Pass a skill alias (e.g., 'aws', 'tests', 'errors') to get that documentation. Pass 'index' or no argument to list all available skills.", {
+        alias: z
+            .string()
+            .optional()
+            .describe("Skill alias (e.g., 'aws', 'tests', 'errors'). Omit or use 'index' to list all skills."),
+    }, async ({ alias }) => {
+        const effectiveAlias = alias?.toLowerCase().trim() || "index";
+        log.info(`Tool called: skill (alias: ${effectiveAlias})`);
+        // Validate alias for path traversal
+        if (!isValidSkillAlias(effectiveAlias)) {
+            log.error(`Invalid skill alias: ${effectiveAlias}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: Invalid skill alias "${alias}". Aliases may only contain letters, numbers, hyphens, and underscores.`,
+                    },
+                ],
+            };
+        }
+        try {
+            // Handle index: return index.md content plus list of all skills
+            if (effectiveAlias === "index") {
+                let indexContent = "";
+                // Try to read index.md if it exists
+                try {
+                    const indexPath = path.join(SKILLS_PATH, "index.md");
+                    const rawContent = await fs.readFile(indexPath, "utf-8");
+                    // Strip frontmatter if present
+                    if (rawContent.startsWith("---")) {
+                        const parsed = matter(rawContent);
+                        indexContent = parsed.content.trim();
+                    }
+                    else {
+                        indexContent = rawContent;
+                    }
+                }
+                catch {
+                    // No index.md, that's fine
+                }
+                // Get list of all skills
+                const files = await fs.readdir(SKILLS_PATH);
+                const mdFiles = files.filter((file) => file.endsWith(".md") && file !== "index.md");
+                const skills = await Promise.all(mdFiles.map((file) => parseSkillFile(path.join(SKILLS_PATH, file))));
+                // Sort alphabetically
+                skills.sort((a, b) => a.alias.localeCompare(b.alias));
+                const skillList = skills.map(formatSkillListItem).join("\n");
+                const resultText = indexContent
+                    ? `${indexContent}\n\n## Available Skills\n\n${skillList}`
+                    : `# Jaypie Skills\n\n## Available Skills\n\n${skillList}`;
+                log.info("Successfully returned skill index");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: resultText,
+                        },
+                    ],
+                };
+            }
+            // Read specific skill file
+            const skillPath = path.join(SKILLS_PATH, `${effectiveAlias}.md`);
+            log.info(`Reading skill file: ${skillPath}`);
+            const content = await fs.readFile(skillPath, "utf-8");
+            log.info(`Successfully read skill ${effectiveAlias} (${content.length} bytes)`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: content,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                log.error(`Skill not found: ${effectiveAlias}`);
+                // Suggest available skills
+                try {
+                    const files = await fs.readdir(SKILLS_PATH);
+                    const available = files
+                        .filter((f) => f.endsWith(".md"))
+                        .map((f) => f.replace(".md", ""))
+                        .sort()
+                        .join(", ");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: Skill "${effectiveAlias}" not found.\n\nAvailable skills: ${available}\n\nUse skill("index") to see all skills with descriptions.`,
+                            },
+                        ],
+                    };
+                }
+                catch {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: Skill "${effectiveAlias}" not found. Use skill("index") to list available skills.`,
+                            },
+                        ],
+                    };
+                }
+            }
+            log.error("Error reading skill:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error reading skill: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    });
+    log.info("Registered tool: skill");
     server.tool("version", `Prints the current version and hash, \`${BUILD_VERSION_STRING}\``, {}, async () => {
         log.info("Tool called: version");
         return {
@@ -1482,9 +445,7 @@ function createMcpServer(options = {}) {
                 flatNotes = filterReleaseNotesSince(flatNotes, sinceVersion);
             }
             if (flatNotes.length === 0) {
-                const filterDesc = sinceVersion
-                    ? ` newer than ${sinceVersion}`
-                    : "";
+                const filterDesc = sinceVersion ? ` newer than ${sinceVersion}` : "";
                 return {
                     content: [
                         {
@@ -1521,12 +482,8 @@ function createMcpServer(options = {}) {
     });
     log.info("Registered tool: list_release_notes");
     server.tool("read_release_note", "Read the full content of a specific release note. Call list_release_notes first to see available versions.", {
-        package: z
-            .string()
-            .describe("Package name (e.g., 'jaypie', 'mcp')"),
-        version: z
-            .string()
-            .describe("Version number (e.g., '1.2.3')"),
+        package: z.string().describe("Package name (e.g., 'jaypie', 'mcp')"),
+        version: z.string().describe("Version number (e.g., '1.2.3')"),
     }, async ({ package: packageName, version }) => {
         log.info(`Tool called: read_release_note (package: ${packageName}, version: ${version})`);
         try {