renovate-mcp 0.1.0

package/dist/tools/previewCustomManager.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { previewCustomManager, } from "../lib/customManagerPreview.js";
+const managerSchema = z
+    .object({
+    customType: z.string(),
+    fileMatch: z.array(z.string()).min(1),
+    matchStrings: z.array(z.string()).min(1),
+    matchStringsStrategy: z.string().optional(),
+    depNameTemplate: z.string().optional(),
+    packageNameTemplate: z.string().optional(),
+    currentValueTemplate: z.string().optional(),
+    currentDigestTemplate: z.string().optional(),
+    datasourceTemplate: z.string().optional(),
+    versioningTemplate: z.string().optional(),
+    registryUrlTemplate: z.string().optional(),
+    depTypeTemplate: z.string().optional(),
+    extractVersionTemplate: z.string().optional(),
+    autoReplaceStringTemplate: z.string().optional(),
+})
+    .passthrough();
+export function registerPreviewCustomManager(server) {
+    server.registerTool("preview_custom_manager", {
+        title: "Preview a Renovate custom manager (regex)",
+        description: [
+            "Preview a Renovate `customManagers` entry against a local repo — fast, offline, no `renovate` invocation. Designed for iterating on a regex: shows which files match `fileMatch`, which lines match each `matchStrings` regex (with named capture groups), and what dep info the template fields produce.",
+            "",
+            "Limitations vs. a real Renovate run:",
+            "  - Only `customType: \"regex\"` is supported.",
+            "  - `matchStringsStrategy` other than `any` (the default) is not implemented; a warning is emitted.",
+            "  - Template substitution handles only `{{groupName}}` references, not full Handlebars helpers.",
+            "  - `.gitignore` is not honored; `node_modules/` and `.git/` are always skipped.",
+            "",
+            "Run the `dry_run` tool afterwards for full-fidelity confirmation.",
+        ].join("\n"),
+        inputSchema: {
+            repoPath: z.string().describe("Absolute path to the repository root"),
+            manager: managerSchema.describe("A single Renovate customManagers entry. NOTE: `fileMatch` is an array of REGEX strings matched against POSIX-style relative paths (not globs)."),
+            maxFilesScanned: z
+                .number()
+                .int()
+                .positive()
+                .max(100_000)
+                .optional()
+                .describe("Safety cap on files walked (default 2000)"),
+            maxHitsPerFile: z
+                .number()
+                .int()
+                .positive()
+                .max(10_000)
+                .optional()
+                .describe("Safety cap on matches per file (default 100)"),
+        },
+    }, async ({ repoPath, manager, maxFilesScanned, maxHitsPerFile }) => {
+        if (manager.customType !== "regex") {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `preview_custom_manager only supports customType=\"regex\" (got \"${manager.customType}\"). For other custom manager types, use dry_run.`,
+                    },
+                ],
+            };
+        }
+        try {
+            const result = await previewCustomManager(repoPath, manager, {
+                maxFilesScanned,
+                maxHitsPerFile,
+            });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [
+                    { type: "text", text: err.message },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/readConfig.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerReadConfig(server: McpServer): void;

package/dist/tools/readConfig.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { locateConfig } from "../lib/configLocations.js";
+export function registerReadConfig(server) {
+    server.registerTool("read_config", {
+        title: "Read Renovate config",
+        description: "Locate and parse the Renovate configuration in a repository. Searches for renovate.json, renovate.json5, .renovaterc(.json|.json5), .github/renovate.json, .gitlab/renovate.json, and the 'renovate' field of package.json — in that priority order.",
+        inputSchema: {
+            repoPath: z.string().describe("Absolute path to the repository root"),
+        },
+    }, async ({ repoPath }) => {
+        const located = await locateConfig(repoPath);
+        if (!located) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No Renovate configuration found in ${repoPath}. Create one with write_config.`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        path: located.relPath,
+                        format: located.format,
+                        config: located.config,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/resolveConfig.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerResolveConfig(server: McpServer): void;

package/dist/tools/resolveConfig.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { locateConfig } from "../lib/configLocations.js";
+import { resolveConfig } from "../lib/presetResolver.js";
+export function registerResolveConfig(server) {
+    server.registerTool("resolve_config", {
+        title: "Resolve Renovate config (expand presets)",
+        description: "Expand every preset referenced by `extends` and return the fully resolved config. Built-in presets resolve offline against the committed catalogue. External presets (`github>`, `gitlab>`, `bitbucket>`, `gitea>`, `local>`, npm) are listed in `presetsUnresolved` by default; pass `externalPresets: true` to fetch `github>` / `gitlab>` over HTTPS (with optional `GITHUB_TOKEN` / `GITLAB_TOKEN` / `RENOVATE_TOKEN` for private repos). Pass either `repoPath` (reads the repo's config) or `configContent` (an inline config object).",
+        inputSchema: {
+            repoPath: z
+                .string()
+                .optional()
+                .describe("Absolute path to the repository root. The tool will locate the repo's renovate config automatically."),
+            configContent: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe("Inline config object to resolve — use instead of repoPath."),
+            externalPresets: z
+                .boolean()
+                .optional()
+                .describe("When true, fetch external presets (github>, gitlab>) over HTTPS. Credentials are read from GITHUB_TOKEN / GITLAB_TOKEN / RENOVATE_TOKEN env vars. Default false."),
+        },
+    }, async ({ repoPath, configContent, externalPresets }) => {
+        if (!repoPath && !configContent) {
+            return {
+                isError: true,
+                content: [
+                    { type: "text", text: "Provide either repoPath or configContent." },
+                ],
+            };
+        }
+        let source;
+        let sourcePath;
+        if (configContent) {
+            source = configContent;
+        }
+        else {
+            const located = await locateConfig(repoPath);
+            if (!located) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No Renovate configuration found in ${repoPath}.`,
+                        },
+                    ],
+                };
+            }
+            source = located.config;
+            sourcePath = located.relPath;
+        }
+        const { resolved, presetsResolved, presetsUnresolved } = await resolveConfig(source, {
+            fetchExternal: externalPresets ?? false,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ...(sourcePath ? { path: sourcePath } : {}),
+                        resolved,
+                        presetsResolved,
+                        presetsUnresolved,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/validateConfig.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerValidateConfig(server: McpServer): void;

package/dist/tools/validateConfig.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { run, resolveRenovateTool, formatMissingBinaryError } from "../lib/renovateCli.js";
+export function registerValidateConfig(server) {
+    server.registerTool("validate_config", {
+        title: "Validate Renovate config",
+        description: "Validate a Renovate configuration against the official schema using renovate-config-validator. Pass either configPath (file on disk) or configContent (inline JSON object). Returns validation output and a boolean `valid`.",
+        inputSchema: {
+            configPath: z
+                .string()
+                .optional()
+                .describe("Absolute path to a config file to validate"),
+            configContent: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe("Inline config object to validate (written to a temp file)"),
+            strict: z
+                .boolean()
+                .optional()
+                .describe("Treat warnings as errors"),
+        },
+    }, async ({ configPath, configContent, strict }) => {
+        if (!configPath && !configContent) {
+            return {
+                isError: true,
+                content: [
+                    { type: "text", text: "Provide either configPath or configContent." },
+                ],
+            };
+        }
+        let target = configPath;
+        let cleanup;
+        if (!target) {
+            const tmp = path.join(tmpdir(), `renovate-mcp-${randomUUID()}.json`);
+            await fs.writeFile(tmp, JSON.stringify(configContent, null, 2));
+            target = tmp;
+            cleanup = async () => {
+                await fs.unlink(tmp).catch(() => undefined);
+            };
+        }
+        try {
+            const bin = resolveRenovateTool("renovate-config-validator");
+            const args = [];
+            if (strict)
+                args.push("--strict");
+            args.push(target);
+            const result = await run(bin, args, { timeoutMs: 30_000 });
+            const valid = result.exitCode === 0;
+            const output = (result.stdout + result.stderr).trim();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ valid, output }, null, 2),
+                    },
+                ],
+                isError: !valid,
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: formatMissingBinaryError("renovate-config-validator", err),
+                    },
+                ],
+            };
+        }
+        finally {
+            await cleanup?.();
+        }
+    });
+}

package/dist/tools/writeConfig.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerWriteConfig(server: McpServer): void;

package/dist/tools/writeConfig.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { run, resolveRenovateTool, formatMissingBinaryError } from "../lib/renovateCli.js";
+export function registerWriteConfig(server) {
+    server.registerTool("write_config", {
+        title: "Write Renovate config",
+        description: "Write a Renovate config to disk. Runs renovate-config-validator first — refuses to write if validation fails unless force=true.",
+        inputSchema: {
+            repoPath: z.string().describe("Absolute path to the repository root"),
+            config: z.record(z.string(), z.unknown()).describe("The Renovate config object"),
+            filename: z
+                .string()
+                .default("renovate.json")
+                .describe("Target filename relative to repoPath (default renovate.json)"),
+            force: z
+                .boolean()
+                .default(false)
+                .describe("Write even if validation fails"),
+        },
+    }, async ({ repoPath, config, filename, force }) => {
+        const repoAbs = path.resolve(repoPath);
+        const target = path.resolve(repoAbs, filename);
+        const rel = path.relative(repoAbs, target);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: "filename escapes repoPath" }],
+            };
+        }
+        const payload = JSON.stringify(config, null, 2) + "\n";
+        const tmp = `${target}.renovate-mcp-tmp`;
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(tmp, payload);
+        let valid = false;
+        let validationOutput = "";
+        let validatorMissing = false;
+        try {
+            const bin = resolveRenovateTool("renovate-config-validator");
+            const v = await run(bin, [tmp], { timeoutMs: 30_000 });
+            validationOutput = (v.stdout + v.stderr).trim();
+            valid = v.exitCode === 0;
+        }
+        catch (err) {
+            validatorMissing = true;
+            validationOutput = formatMissingBinaryError("renovate-config-validator", err);
+        }
+        if (!valid && !force) {
+            await fs.unlink(tmp).catch(() => undefined);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            wrote: false,
+                            reason: validatorMissing ? "validator-unavailable" : "validation-failed",
+                            validationOutput,
+                            hint: validatorMissing
+                                ? "Install renovate-config-validator (or set RENOVATE_CONFIG_VALIDATOR_BIN), then retry. Pass force=true to skip validation entirely."
+                                : "Pass force=true to write anyway.",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        await fs.rename(tmp, target);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        wrote: true,
+                        path: rel,
+                        bytes: payload.length,
+                        valid,
+                        validationOutput: valid ? undefined : validationOutput,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "renovate-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for designing Renovate configurations interactively.",
+  "type": "module",
+  "bin": {
+    "renovate-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "generate:presets": "node scripts/generate-presets.mjs",
+    "prepack": "npm run build && chmod +x dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "renovate",
+    "renovatebot",
+    "claude",
+    "llm",
+    "dependencies"
+  ],
+  "author": "Timo Hankamer",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tibuntu/renovate-mcp.git"
+  },
+  "homepage": "https://github.com/tibuntu/renovate-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/tibuntu/renovate-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "json5": "^2.2.3",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "renovate": "^43.139.5",
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.0"
+  },
+  "license": "MIT"
+}