@jaypie/mcp 0.3.0 → 0.3.2

package/dist/index.js

@@ -8,6 +8,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 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';
@@ -1208,11 +1209,12 @@ 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.0#8cd307b1"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.3.2#f7a87775"
     ;
 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");
 // Logger utility
 function createLogger(verbose) {
     return {
@@ -1260,6 +1262,75 @@ function formatPromptListItem(prompt) {
         return `* ${filename}`;
     }
 }
+async function parseReleaseNoteFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const filename = path.basename(filePath, ".md");
+        if (content.startsWith("---")) {
+            const parsed = matter(content);
+            const frontMatter = parsed.data;
+            return {
+                date: frontMatter.date,
+                filename,
+                summary: frontMatter.summary,
+                version: frontMatter.version || filename,
+            };
+        }
+        return { filename, version: filename };
+    }
+    catch {
+        return { filename: path.basename(filePath, ".md") };
+    }
+}
+function formatReleaseNoteListItem(note) {
+    const { date, packageName, summary, version } = note;
+    const parts = [`* ${packageName}@${version}`];
+    if (date) {
+        parts.push(`(${date})`);
+    }
+    if (summary) {
+        parts.push(`- ${summary}`);
+    }
+    return parts.join(" ");
+}
+async function getPackageReleaseNotes(packageName) {
+    const packageDir = path.join(RELEASE_NOTES_PATH, packageName);
+    try {
+        const files = await fs.readdir(packageDir);
+        const mdFiles = files.filter((file) => file.endsWith(".md"));
+        const notes = await Promise.all(mdFiles.map(async (file) => {
+            const parsed = await parseReleaseNoteFile(path.join(packageDir, file));
+            return { ...parsed, packageName };
+        }));
+        // Sort by version descending (newest first)
+        return notes.sort((a, b) => {
+            if (!a.version || !b.version)
+                return 0;
+            try {
+                return gt(a.version, b.version) ? -1 : 1;
+            }
+            catch {
+                // If semver comparison fails, fall back to string comparison
+                return b.version.localeCompare(a.version);
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function filterReleaseNotesSince(notes, sinceVersion) {
+    return notes.filter((note) => {
+        if (!note.version)
+            return false;
+        try {
+            return gt(note.version, sinceVersion);
+        }
+        catch {
+            return false;
+        }
+    });
+}
 /**
  * Creates and configures an MCP server instance with Jaypie tools
  * @param options - Configuration options (or legacy version string)
@@ -1367,6 +1438,135 @@ function createMcpServer(options = {}) {
         };
     });
     log.info("Registered tool: version");
+    // Release Notes Tools
+    server.tool("list_release_notes", "List available release notes for Jaypie packages. Filter by package name and/or get only versions newer than a specified version.", {
+        package: z
+            .string()
+            .optional()
+            .describe("Filter by package name (e.g., 'jaypie', 'mcp'). If not provided, lists release notes for all packages."),
+        since_version: z
+            .string()
+            .optional()
+            .describe("Only show versions newer than this (e.g., '1.0.0'). Uses semver comparison."),
+    }, async ({ package: packageFilter, since_version: sinceVersion }) => {
+        log.info("Tool called: list_release_notes");
+        log.info(`Release notes directory: ${RELEASE_NOTES_PATH}`);
+        try {
+            // Get list of package directories
+            const entries = await fs.readdir(RELEASE_NOTES_PATH, {
+                withFileTypes: true,
+            });
+            const packageDirs = entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name);
+            log.info(`Found ${packageDirs.length} package directories`);
+            // Filter by package if specified
+            const packagesToList = packageFilter
+                ? packageDirs.filter((pkg) => pkg === packageFilter)
+                : packageDirs;
+            if (packagesToList.length === 0 && packageFilter) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No release notes found for package "${packageFilter}".`,
+                        },
+                    ],
+                };
+            }
+            // Get release notes for each package
+            const allNotes = await Promise.all(packagesToList.map((pkg) => getPackageReleaseNotes(pkg)));
+            let flatNotes = allNotes.flat();
+            // Filter by since_version if specified
+            if (sinceVersion) {
+                flatNotes = filterReleaseNotesSince(flatNotes, sinceVersion);
+            }
+            if (flatNotes.length === 0) {
+                const filterDesc = sinceVersion
+                    ? ` newer than ${sinceVersion}`
+                    : "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No release notes found${filterDesc}.`,
+                        },
+                    ],
+                };
+            }
+            const formattedList = flatNotes
+                .map(formatReleaseNoteListItem)
+                .join("\n");
+            log.info(`Successfully listed ${flatNotes.length} release notes`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formattedList,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            log.error("Error listing release notes:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error listing release notes: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    });
+    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')"),
+    }, async ({ package: packageName, version }) => {
+        log.info(`Tool called: read_release_note (package: ${packageName}, version: ${version})`);
+        try {
+            const filePath = path.join(RELEASE_NOTES_PATH, packageName, `${version}.md`);
+            log.info(`Reading file: ${filePath}`);
+            const content = await fs.readFile(filePath, "utf-8");
+            log.info(`Successfully read release note for ${packageName}@${version} (${content.length} bytes)`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: content,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                log.error(`Release note not found: ${packageName}@${version}`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: Release note for "${packageName}@${version}" not found. Use list_release_notes to see available versions.`,
+                        },
+                    ],
+                };
+            }
+            log.error("Error reading release note:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error reading release note: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    });
+    log.info("Registered tool: read_release_note");
     // Datadog Logs Tool
     server.tool("datadog_logs", "Search and retrieve individual Datadog log entries. Use this to view actual log messages and details. For aggregated counts/statistics (e.g., 'how many errors by service?'), use datadog_log_analytics instead. Requires DATADOG_API_KEY and DATADOG_APP_KEY environment variables.", {
         query: z