renovate-mcp 0.1.0

package/dist/lib/presetResolver.js

@@ -0,0 +1,204 @@
+import { PRESETS } from "../data/presets.generated.js";
+import { fetchExternalPreset } from "./externalPresetFetcher.js";
+/**
+ * Resolve a Renovate config by expanding every preset in `extends`. Built-in
+ * presets resolve offline against the committed catalogue; external presets
+ * (`github>`, `gitlab>`, …) are only fetched when `fetchExternal` is true —
+ * otherwise they land in `presetsUnresolved` with a network reason.
+ */
+export async function resolveConfig(config, options = {}) {
+    const presetsResolved = [];
+    const presetsUnresolved = [];
+    const stack = [];
+    const ctx = {
+        fetchExternal: options.fetchExternal ?? false,
+        timeoutMs: options.timeoutMs,
+        cache: new Map(),
+    };
+    const resolved = await expand(config, presetsResolved, presetsUnresolved, stack, ctx);
+    return { resolved, presetsResolved, presetsUnresolved };
+}
+async function expand(input, resolvedList, unresolvedList, stack, ctx) {
+    const rawExtends = input.extends;
+    if (!Array.isArray(rawExtends) || rawExtends.length === 0) {
+        const { extends: _drop, ...rest } = input;
+        return rest;
+    }
+    let accumulated = {};
+    for (const entry of rawExtends) {
+        if (typeof entry !== "string") {
+            unresolvedList.push({
+                preset: String(entry),
+                reason: "Preset entry must be a string.",
+            });
+            continue;
+        }
+        const parsed = parsePreset(entry);
+        if (stack.includes(parsed.key)) {
+            unresolvedList.push({
+                preset: entry,
+                reason: `Cycle detected: ${[...stack, parsed.key].join(" → ")}`,
+            });
+            continue;
+        }
+        const body = await loadPresetBody(parsed, ctx, unresolvedList);
+        if (!body)
+            continue;
+        const substituted = applyArgs(body, parsed.args);
+        stack.push(parsed.key);
+        const subResolved = await expand(substituted, resolvedList, unresolvedList, stack, ctx);
+        stack.pop();
+        accumulated = mergeConfig(accumulated, subResolved);
+        resolvedList.push(entry);
+    }
+    const { extends: _drop, ...ownKeys } = input;
+    return mergeConfig(accumulated, ownKeys);
+}
+async function loadPresetBody(parsed, ctx, unresolvedList) {
+    if (!parsed.source) {
+        const preset = PRESETS[parsed.key];
+        if (!preset) {
+            unresolvedList.push({
+                preset: parsed.original,
+                reason: `Unknown built-in preset. Not present in the committed catalogue.`,
+            });
+            return null;
+        }
+        return preset.body;
+    }
+    if (!ctx.fetchExternal) {
+        unresolvedList.push({
+            preset: parsed.original,
+            reason: "External preset (github>, gitlab>, bitbucket>, gitea>, local>, or npm). Fetching requires network access and potentially credentials; pass externalPresets: true to enable.",
+        });
+        return null;
+    }
+    const result = await fetchExternalPreset(parsed, {
+        timeoutMs: ctx.timeoutMs,
+        cache: ctx.cache,
+    });
+    if (!result.ok) {
+        unresolvedList.push({ preset: parsed.original, reason: result.reason });
+        return null;
+    }
+    return result.body;
+}
+const SOURCE_PREFIX_RE = /^([a-z]+)>/i;
+const KNOWN_SOURCES = new Set([
+    "github",
+    "gitlab",
+    "bitbucket",
+    "gitea",
+    "local",
+    "npm",
+]);
+export function parsePreset(raw) {
+    const original = raw;
+    let rest = raw.trim();
+    // Trailing "(arg1, arg2)"
+    let args = [];
+    const argMatch = /\(([^)]*)\)\s*$/.exec(rest);
+    if (argMatch) {
+        args = argMatch[1]
+            .split(",")
+            .map((a) => a.trim())
+            .filter((a) => a.length > 0);
+        rest = rest.slice(0, argMatch.index).trim();
+    }
+    const srcMatch = SOURCE_PREFIX_RE.exec(rest);
+    if (srcMatch) {
+        return parseExternal(rest, original, args, srcMatch[1].toLowerCase());
+    }
+    // Built-in: `:foo` is shorthand for `default:foo`.
+    const key = rest.startsWith(":") ? `default${rest}` : rest;
+    // An entry with no `>` prefix and no `:` namespace is an npm preset.
+    if (!key.includes(":")) {
+        return {
+            key: `npm>${key}`,
+            original,
+            args,
+            source: "npm",
+            repoPath: key,
+        };
+    }
+    return { key, original, args };
+}
+function parseExternal(rest, original, args, sourceRaw) {
+    const source = (KNOWN_SOURCES.has(sourceRaw)
+        ? sourceRaw
+        : sourceRaw);
+    let spec = rest.slice(sourceRaw.length + 1);
+    let ref;
+    const hashIdx = spec.indexOf("#");
+    if (hashIdx !== -1) {
+        ref = spec.slice(hashIdx + 1);
+        spec = spec.slice(0, hashIdx);
+    }
+    let subpath;
+    const slashSlashIdx = spec.indexOf("//");
+    if (slashSlashIdx !== -1) {
+        subpath = spec.slice(slashSlashIdx + 2);
+        spec = spec.slice(0, slashSlashIdx);
+    }
+    let presetName;
+    const colonIdx = spec.indexOf(":");
+    if (colonIdx !== -1) {
+        presetName = spec.slice(colonIdx + 1);
+        spec = spec.slice(0, colonIdx);
+    }
+    const repoPath = spec;
+    let key = `${source}>${repoPath}`;
+    if (presetName)
+        key += `:${presetName}`;
+    if (subpath)
+        key += `//${subpath}`;
+    if (ref)
+        key += `#${ref}`;
+    return { key, original, args, source, repoPath, presetName, subpath, ref };
+}
+function applyArgs(value, args) {
+    if (typeof value === "string") {
+        return value.replace(/\{\{\s*arg(\d+)\s*\}\}/g, (_, idx) => {
+            const i = Number(idx);
+            return i < args.length ? args[i] : "";
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => applyArgs(v, args));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = applyArgs(v, args);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Merge two Renovate config objects. Rules:
+ *   - arrays → concatenate (matches `packageRules`, `matchManagers`, etc.)
+ *   - plain objects → recursive merge
+ *   - everything else → `b` wins
+ * Close enough to Renovate's `mergeChildConfig` for the purpose of showing a
+ * user what their config resolves to; not bit-identical.
+ */
+function mergeConfig(a, b) {
+    const out = { ...a };
+    for (const [key, bVal] of Object.entries(b)) {
+        const aVal = out[key];
+        if (Array.isArray(aVal) && Array.isArray(bVal)) {
+            out[key] = [...aVal, ...bVal];
+        }
+        else if (isPlainObject(aVal) && isPlainObject(bVal)) {
+            out[key] = mergeConfig(aVal, bVal);
+        }
+        else {
+            out[key] = bVal;
+        }
+    }
+    return out;
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}

package/dist/lib/renovateCli.d.ts

@@ -0,0 +1,31 @@
+export interface RunResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface RunOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    stdin?: string;
+}
+/**
+ * Spawn a command and capture stdout/stderr. Never throws on non-zero exit —
+ * caller inspects exitCode. Throws only for spawn errors (ENOENT etc.) and
+ * timeouts.
+ */
+export declare function run(cmd: string, args: string[], opts?: RunOptions): Promise<RunResult>;
+/**
+ * Resolve how to invoke a Renovate CLI tool. Users can override via env:
+ *   RENOVATE_BIN                  — path to the `renovate` binary
+ *   RENOVATE_CONFIG_VALIDATOR_BIN — path to the validator binary
+ * Otherwise we rely on PATH resolution (globally installed Renovate, or a
+ * `npm exec` from a project with Renovate installed locally).
+ */
+export declare function resolveRenovateTool(tool: "renovate" | "renovate-config-validator"): string;
+/**
+ * Centralized message for when a Renovate CLI binary can't be spawned (ENOENT,
+ * permission denied, etc.). Used by all tools that shell out so users get
+ * consistent, actionable hints instead of raw spawn errors.
+ */
+export declare function formatMissingBinaryError(tool: "renovate" | "renovate-config-validator", cause: Error): string;

package/dist/lib/renovateCli.js

@@ -0,0 +1,75 @@
+import { spawn } from "node:child_process";
+/**
+ * Spawn a command and capture stdout/stderr. Never throws on non-zero exit —
+ * caller inspects exitCode. Throws only for spawn errors (ENOENT etc.) and
+ * timeouts.
+ */
+export function run(cmd, args, opts = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd,
+            env: { ...process.env, ...opts.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timer;
+        let killed = false;
+        if (opts.timeoutMs) {
+            timer = setTimeout(() => {
+                killed = true;
+                child.kill("SIGKILL");
+            }, opts.timeoutMs);
+        }
+        child.stdout.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            stderr += d.toString();
+        });
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (killed) {
+                reject(new Error(`Command timed out after ${opts.timeoutMs}ms: ${cmd} ${args.join(" ")}`));
+                return;
+            }
+            resolve({ stdout, stderr, exitCode: code ?? -1 });
+        });
+        if (opts.stdin != null) {
+            child.stdin.end(opts.stdin);
+        }
+        else {
+            child.stdin.end();
+        }
+    });
+}
+/**
+ * Resolve how to invoke a Renovate CLI tool. Users can override via env:
+ *   RENOVATE_BIN                  — path to the `renovate` binary
+ *   RENOVATE_CONFIG_VALIDATOR_BIN — path to the validator binary
+ * Otherwise we rely on PATH resolution (globally installed Renovate, or a
+ * `npm exec` from a project with Renovate installed locally).
+ */
+export function resolveRenovateTool(tool) {
+    const envKey = tool === "renovate" ? "RENOVATE_BIN" : "RENOVATE_CONFIG_VALIDATOR_BIN";
+    return process.env[envKey] || tool;
+}
+/**
+ * Centralized message for when a Renovate CLI binary can't be spawned (ENOENT,
+ * permission denied, etc.). Used by all tools that shell out so users get
+ * consistent, actionable hints instead of raw spawn errors.
+ */
+export function formatMissingBinaryError(tool, cause) {
+    const envKey = tool === "renovate" ? "RENOVATE_BIN" : "RENOVATE_CONFIG_VALIDATOR_BIN";
+    return [
+        `Failed to run \`${tool}\`: ${cause.message}.`,
+        `Install Renovate globally with \`npm i -g renovate\`, or set ${envKey} to point at an existing binary.`,
+        "Call the `check_setup` tool for a full diagnostic.",
+    ].join(" ");
+}

package/dist/lib/setupCheck.d.ts

@@ -0,0 +1,18 @@
+export type RenovateBinary = "renovate" | "renovate-config-validator";
+export interface BinaryStatus {
+    tool: RenovateBinary;
+    command: string;
+    found: boolean;
+    version?: string;
+    error?: string;
+}
+export interface SetupStatus {
+    node: string;
+    renovate: BinaryStatus;
+    renovateConfigValidator: BinaryStatus;
+    envOverrides: Record<string, string>;
+    ok: boolean;
+    hints: string[];
+}
+export declare function checkSetup(): Promise<SetupStatus>;
+export declare function describeSetup(status: SetupStatus): string;

package/dist/lib/setupCheck.js

@@ -0,0 +1,82 @@
+import { run, resolveRenovateTool } from "./renovateCli.js";
+const VERSION_TIMEOUT_MS = 10_000;
+const INSTALL_HINT = "Install Renovate globally with `npm i -g renovate`, or set RENOVATE_BIN / RENOVATE_CONFIG_VALIDATOR_BIN to existing binaries.";
+async function checkBinary(tool) {
+    const command = resolveRenovateTool(tool);
+    try {
+        const result = await run(command, ["--version"], { timeoutMs: VERSION_TIMEOUT_MS });
+        if (result.exitCode !== 0) {
+            return {
+                tool,
+                command,
+                found: false,
+                error: (result.stderr || result.stdout).trim() || `exit code ${result.exitCode}`,
+            };
+        }
+        return {
+            tool,
+            command,
+            found: true,
+            version: result.stdout.trim() || undefined,
+        };
+    }
+    catch (err) {
+        return {
+            tool,
+            command,
+            found: false,
+            error: err.message,
+        };
+    }
+}
+export async function checkSetup() {
+    const [renovate, renovateConfigValidator] = await Promise.all([
+        checkBinary("renovate"),
+        checkBinary("renovate-config-validator"),
+    ]);
+    const envOverrides = {};
+    for (const key of ["RENOVATE_BIN", "RENOVATE_CONFIG_VALIDATOR_BIN"]) {
+        const v = process.env[key];
+        if (v)
+            envOverrides[key] = v;
+    }
+    const hints = [];
+    if (!renovate.found) {
+        hints.push(`renovate not reachable at \`${renovate.command}\`. ${INSTALL_HINT}`);
+    }
+    if (!renovateConfigValidator.found) {
+        hints.push(`renovate-config-validator not reachable at \`${renovateConfigValidator.command}\`. ${INSTALL_HINT}`);
+    }
+    return {
+        node: process.version,
+        renovate,
+        renovateConfigValidator,
+        envOverrides,
+        ok: renovate.found && renovateConfigValidator.found,
+        hints,
+    };
+}
+export function describeSetup(status) {
+    const lines = [];
+    lines.push(`Node: ${status.node}`);
+    lines.push(`renovate: ${formatBinary(status.renovate)}`);
+    lines.push(`renovate-config-validator: ${formatBinary(status.renovateConfigValidator)}`);
+    const overrideKeys = Object.keys(status.envOverrides);
+    if (overrideKeys.length > 0) {
+        lines.push("Env overrides:");
+        for (const key of overrideKeys)
+            lines.push(`  ${key}=${status.envOverrides[key]}`);
+    }
+    if (status.hints.length > 0) {
+        lines.push("");
+        lines.push("Hints:");
+        for (const h of status.hints)
+            lines.push(`  - ${h}`);
+    }
+    return lines.join("\n");
+}
+function formatBinary(s) {
+    if (s.found)
+        return `${s.version ?? "(version unknown)"} (${s.command})`;
+    return `MISSING — ${s.error ?? "unknown error"}`;
+}

package/dist/resources/presets.d.ts

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

package/dist/resources/presets.js

@@ -0,0 +1,82 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { PRESETS, PRESET_NAMES, RENOVATE_VERSION, } from "../data/presets.generated.js";
+export function registerPresetResources(server) {
+    server.registerResource("renovate-presets", "renovate://presets", {
+        title: "Renovate built-in preset index",
+        description: `Markdown index of all ${PRESET_NAMES.length} built-in Renovate presets (from renovate v${RENOVATE_VERSION}). Grouped by namespace. Fetch renovate://preset/{name} for a single preset's expanded JSON.`,
+        mimeType: "text/markdown",
+    }, async () => ({
+        contents: [
+            {
+                uri: "renovate://presets",
+                mimeType: "text/markdown",
+                text: renderIndex(),
+            },
+        ],
+    }));
+    server.registerResource("renovate-preset", new ResourceTemplate("renovate://preset/{name}", {
+        list: async () => ({
+            resources: PRESET_NAMES.map((name) => {
+                const preset = PRESETS[name];
+                return {
+                    uri: `renovate://preset/${name}`,
+                    name,
+                    description: preset.description ?? undefined,
+                    mimeType: "application/json",
+                };
+            }),
+        }),
+    }), {
+        title: "Renovate preset (expanded JSON)",
+        description: "Expanded JSON of a single built-in Renovate preset — its description and body (extends, packageRules, etc.).",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const raw = variables.name;
+        const name = typeof raw === "string" ? decodeURIComponent(raw) : "";
+        const preset = PRESETS[name];
+        if (!preset) {
+            throw new Error(`Unknown preset: ${name}. Fetch renovate://presets for the full list.`);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        name,
+                        namespace: preset.namespace,
+                        description: preset.description,
+                        body: preset.body,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}
+function renderIndex() {
+    const byNamespace = new Map();
+    for (const name of PRESET_NAMES) {
+        const preset = PRESETS[name];
+        const bucket = byNamespace.get(preset.namespace) ?? [];
+        bucket.push({ name, description: preset.description });
+        byNamespace.set(preset.namespace, bucket);
+    }
+    const namespaces = Array.from(byNamespace.keys()).sort();
+    const lines = [
+        "# Renovate built-in presets",
+        "",
+        `Snapshot from renovate v${RENOVATE_VERSION} — **${PRESET_NAMES.length} presets** across ${namespaces.length} namespaces.`,
+        "",
+        "Reference any of these in the `extends` array of your config. Fetch `renovate://preset/<name>` for the expanded JSON of a single preset.",
+        "",
+    ];
+    for (const ns of namespaces) {
+        const items = byNamespace.get(ns);
+        lines.push(`## \`${ns}\` (${items.length})`, "");
+        for (const { name, description } of items) {
+            lines.push(description ? `- \`${name}\` — ${description}` : `- \`${name}\``);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/tools/checkSetup.d.ts

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

package/dist/tools/checkSetup.js

@@ -0,0 +1,21 @@
+import { checkSetup, describeSetup } from "../lib/setupCheck.js";
+export function registerCheckSetup(server) {
+    server.registerTool("check_setup", {
+        title: "Check Renovate MCP setup",
+        description: "Report whether the Renovate CLI and config validator are reachable, their versions, and any env overrides in effect. Call this first when other tools fail with a spawn error or unexpected validation output.",
+        inputSchema: {},
+    }, async () => {
+        const status = await checkSetup();
+        const summary = describeSetup(status);
+        const payload = JSON.stringify(status, null, 2);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${summary}\n\n${payload}`,
+                },
+            ],
+            isError: !status.ok,
+        };
+    });
+}

package/dist/tools/dryRun.d.ts

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

package/dist/tools/dryRun.js

@@ -0,0 +1,88 @@
+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 registerDryRun(server) {
+    server.registerTool("dry_run", {
+        title: "Dry-run Renovate",
+        description: "Run Renovate in dry-run mode against a local repository to preview what it would do — no PRs opened, no git pushes. Uses --platform=local so no host token is required. Emits a structured JSON report of the updates Renovate would create.",
+        inputSchema: {
+            repoPath: z.string().describe("Absolute path to the repository root"),
+            dryRunMode: z
+                .enum(["extract", "lookup", "full"])
+                .default("full")
+                .describe("extract = detect manifests only; lookup = resolve latest versions; full = full simulation including branches/PRs (default)"),
+            logLevel: z.enum(["info", "debug"]).default("info"),
+            timeoutMs: z
+                .number()
+                .int()
+                .positive()
+                .max(15 * 60_000)
+                .default(5 * 60_000)
+                .describe("Max wait time in ms (default 5 minutes, capped at 15)"),
+        },
+    }, async ({ repoPath, dryRunMode, logLevel, timeoutMs }) => {
+        const reportPath = path.join(tmpdir(), `renovate-mcp-report-${randomUUID()}.json`);
+        const bin = resolveRenovateTool("renovate");
+        try {
+            const result = await run(bin, [
+                "--platform=local",
+                `--dry-run=${dryRunMode}`,
+                "--report-type=file",
+                `--report-path=${reportPath}`,
+            ], {
+                cwd: repoPath,
+                env: { LOG_LEVEL: logLevel, LOG_FORMAT: "json" },
+                timeoutMs,
+            });
+            let report = null;
+            try {
+                const raw = await fs.readFile(reportPath, "utf8");
+                report = JSON.parse(raw);
+            }
+            catch {
+                // no report produced (e.g., renovate errored before writing)
+            }
+            const summary = {
+                exitCode: result.exitCode,
+                hasReport: report !== null,
+                report,
+            };
+            // If no structured report, surface the last bit of stderr so Claude can
+            // debug without blowing up the context with Renovate's verbose logs.
+            if (!report) {
+                const tail = (result.stderr || result.stdout)
+                    .split(/\r?\n/)
+                    .filter(Boolean)
+                    .slice(-40)
+                    .join("\n");
+                summary.logTail = tail;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(summary, null, 2),
+                    },
+                ],
+                isError: result.exitCode !== 0,
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: formatMissingBinaryError("renovate", err),
+                    },
+                ],
+            };
+        }
+        finally {
+            await fs.unlink(reportPath).catch(() => undefined);
+        }
+    });
+}

package/dist/tools/previewCustomManager.d.ts

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