renovate-mcp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerCheckSetup } from "./tools/checkSetup.js";
+import { registerReadConfig } from "./tools/readConfig.js";
+import { registerValidateConfig } from "./tools/validateConfig.js";
+import { registerResolveConfig } from "./tools/resolveConfig.js";
+import { registerPreviewCustomManager } from "./tools/previewCustomManager.js";
+import { registerDryRun } from "./tools/dryRun.js";
+import { registerWriteConfig } from "./tools/writeConfig.js";
+import { registerPresetResources } from "./resources/presets.js";
+import { checkSetup, describeSetup } from "./lib/setupCheck.js";
+const BASE_INSTRUCTIONS = [
+    "Design and debug Renovate configurations interactively.",
+    "",
+    "Workflow:",
+    "  1. read_config            — inspect the current config in a repo",
+    "  2. resolve_config         — expand built-in presets to see what a config actually becomes (offline)",
+    "  3. preview_custom_manager — iterate on a regex-based customManagers entry; shows file/line hits and extracted deps",
+    "  4. validate_config        — check a proposed config against Renovate's schema",
+    "  5. dry_run                — preview what Renovate would actually do (no PRs)",
+    "  6. write_config           — save the agreed-upon config (validates first)",
+    "",
+    "If any tool fails unexpectedly, call check_setup to diagnose CLI availability.",
+    "Built-in preset reference is available at renovate://presets.",
+].join("\n");
+const setup = await checkSetup();
+const instructions = setup.ok
+    ? BASE_INSTRUCTIONS
+    : [BASE_INSTRUCTIONS, "", "Startup setup check:", describeSetup(setup)].join("\n");
+const SERVER_VERSION = "0.1.0"; // x-release-please-version
+const server = new McpServer({ name: "renovate-mcp", version: SERVER_VERSION }, { instructions });
+registerCheckSetup(server);
+registerReadConfig(server);
+registerResolveConfig(server);
+registerPreviewCustomManager(server);
+registerValidateConfig(server);
+registerDryRun(server);
+registerWriteConfig(server);
+registerPresetResources(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/lib/configLocations.d.ts

@@ -0,0 +1,9 @@
+export type ConfigFormat = "json" | "json5" | "package.json";
+export interface LocatedConfig {
+    absPath: string;
+    relPath: string;
+    format: ConfigFormat;
+    raw: string;
+    config: Record<string, unknown>;
+}
+export declare function locateConfig(repoPath: string): Promise<LocatedConfig | null>;

package/dist/lib/configLocations.js

@@ -0,0 +1,61 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import JSON5 from "json5";
+const CANDIDATES = [
+    { path: "renovate.json", format: "json" },
+    { path: "renovate.json5", format: "json5" },
+    { path: ".github/renovate.json", format: "json" },
+    { path: ".github/renovate.json5", format: "json5" },
+    { path: ".gitlab/renovate.json", format: "json" },
+    { path: ".gitlab/renovate.json5", format: "json5" },
+    { path: ".renovaterc", format: "json" },
+    { path: ".renovaterc.json", format: "json" },
+    { path: ".renovaterc.json5", format: "json5" },
+];
+export async function locateConfig(repoPath) {
+    for (const candidate of CANDIDATES) {
+        const abs = path.join(repoPath, candidate.path);
+        try {
+            const raw = await fs.readFile(abs, "utf8");
+            const config = candidate.format === "json5" ? JSON5.parse(raw) : JSON.parse(raw);
+            if (!isPlainObject(config)) {
+                throw new Error(`${candidate.path} does not contain a JSON object`);
+            }
+            return {
+                absPath: abs,
+                relPath: candidate.path,
+                format: candidate.format,
+                raw,
+                config,
+            };
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    const pkgAbs = path.join(repoPath, "package.json");
+    try {
+        const raw = await fs.readFile(pkgAbs, "utf8");
+        const pkg = JSON.parse(raw);
+        if (isPlainObject(pkg) &&
+            "renovate" in pkg &&
+            isPlainObject(pkg.renovate)) {
+            return {
+                absPath: pkgAbs,
+                relPath: "package.json",
+                format: "package.json",
+                raw,
+                config: pkg.renovate,
+            };
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    return null;
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}

package/dist/lib/customManagerPreview.d.ts

@@ -0,0 +1,49 @@
+export interface CustomManager {
+    customType: string;
+    fileMatch: string[];
+    matchStrings: string[];
+    matchStringsStrategy?: string;
+    depNameTemplate?: string;
+    packageNameTemplate?: string;
+    currentValueTemplate?: string;
+    currentDigestTemplate?: string;
+    datasourceTemplate?: string;
+    versioningTemplate?: string;
+    registryUrlTemplate?: string;
+    depTypeTemplate?: string;
+    extractVersionTemplate?: string;
+    autoReplaceStringTemplate?: string;
+}
+export interface PreviewHit {
+    file: string;
+    matchStringIndex: number;
+    line: number;
+    match: string;
+    groups: Record<string, string>;
+}
+export interface ExtractedDep {
+    file: string;
+    line: number;
+    depName?: string;
+    packageName?: string;
+    currentValue?: string;
+    currentDigest?: string;
+    datasource?: string;
+    versioning?: string;
+    registryUrl?: string;
+    depType?: string;
+    extractVersion?: string;
+    autoReplaceString?: string;
+}
+export interface PreviewOptions {
+    maxFilesScanned?: number;
+    maxHitsPerFile?: number;
+}
+export interface PreviewResult {
+    filesScanned: number;
+    filesMatched: string[];
+    hits: PreviewHit[];
+    extractedDeps: ExtractedDep[];
+    warnings: string[];
+}
+export declare function previewCustomManager(repoPath: string, manager: CustomManager, options?: PreviewOptions): Promise<PreviewResult>;

package/dist/lib/customManagerPreview.js

@@ -0,0 +1,153 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const DEFAULT_MAX_FILES_SCANNED = 2000;
+const DEFAULT_MAX_HITS_PER_FILE = 100;
+const SKIP_DIRS = new Set([".git", "node_modules"]);
+const TEMPLATE_FIELD_MAP = [
+    ["depNameTemplate", "depName"],
+    ["packageNameTemplate", "packageName"],
+    ["currentValueTemplate", "currentValue"],
+    ["currentDigestTemplate", "currentDigest"],
+    ["datasourceTemplate", "datasource"],
+    ["versioningTemplate", "versioning"],
+    ["registryUrlTemplate", "registryUrl"],
+    ["depTypeTemplate", "depType"],
+    ["extractVersionTemplate", "extractVersion"],
+    ["autoReplaceStringTemplate", "autoReplaceString"],
+];
+export async function previewCustomManager(repoPath, manager, options = {}) {
+    const warnings = [];
+    const maxFilesScanned = options.maxFilesScanned ?? DEFAULT_MAX_FILES_SCANNED;
+    const maxHitsPerFile = options.maxHitsPerFile ?? DEFAULT_MAX_HITS_PER_FILE;
+    if (manager.matchStringsStrategy && manager.matchStringsStrategy !== "any") {
+        warnings.push(`matchStringsStrategy='${manager.matchStringsStrategy}' is not yet supported by this preview tool; treating as 'any'. Run dry_run for full-fidelity behavior.`);
+    }
+    const fileMatchRes = manager.fileMatch.map((s) => compileRegex(s));
+    const matchStringRes = manager.matchStrings.map((s) => compileRegex(s, "gm"));
+    const filesMatched = [];
+    let filesScanned = 0;
+    for await (const rel of walk(repoPath)) {
+        if (filesScanned >= maxFilesScanned) {
+            warnings.push(`Stopped after scanning ${maxFilesScanned} files. Increase maxFilesScanned to widen the search.`);
+            break;
+        }
+        filesScanned++;
+        if (fileMatchRes.some((re) => re.test(rel))) {
+            filesMatched.push(rel);
+        }
+    }
+    const hits = [];
+    const extractedDeps = [];
+    for (const rel of filesMatched) {
+        const abs = path.join(repoPath, rel);
+        let content;
+        try {
+            content = await fs.readFile(abs, "utf8");
+        }
+        catch (err) {
+            warnings.push(`Could not read ${rel}: ${err.message}`);
+            continue;
+        }
+        let perFileHits = 0;
+        for (let i = 0; i < matchStringRes.length; i++) {
+            const re = matchStringRes[i];
+            // RegExp objects with the `g` flag are stateful — reset before iterating
+            // each file so that previous calls don't shift lastIndex.
+            re.lastIndex = 0;
+            for (const m of content.matchAll(re)) {
+                if (perFileHits >= maxHitsPerFile) {
+                    warnings.push(`${rel}: capped at ${maxHitsPerFile} hits. Increase maxHitsPerFile to see more.`);
+                    break;
+                }
+                const groups = (m.groups ?? {});
+                const line = lineNumberAt(content, m.index ?? 0);
+                const matchStr = m[0];
+                hits.push({ file: rel, matchStringIndex: i, line, match: matchStr, groups });
+                extractedDeps.push(buildExtractedDep(rel, line, groups, manager));
+                perFileHits++;
+            }
+            if (perFileHits >= maxHitsPerFile)
+                break;
+        }
+    }
+    return { filesScanned, filesMatched, hits, extractedDeps, warnings };
+}
+function buildExtractedDep(file, line, groups, manager) {
+    const dep = { file, line };
+    // Named capture groups are the baseline — Renovate populates dep fields
+    // directly from groups whose names match dep keys.
+    for (const [, depKey] of TEMPLATE_FIELD_MAP) {
+        if (depKey in groups) {
+            const v = groups[depKey];
+            if (v !== undefined)
+                dep[depKey] = v;
+        }
+    }
+    // Templates override matching named groups.
+    for (const [tmplKey, depKey] of TEMPLATE_FIELD_MAP) {
+        const tmpl = manager[tmplKey];
+        if (typeof tmpl === "string") {
+            dep[depKey] = applyTemplate(tmpl, groups);
+        }
+    }
+    return dep;
+}
+/**
+ * Simple `{{var}}` substitution. Renovate uses full Handlebars; we cover the
+ * common case where templates reference named capture groups directly. Helpers
+ * like `{{#if}}` or `{{lookup}}` are not implemented — those degrade to a
+ * literal placeholder, which the user will notice in the preview.
+ */
+function applyTemplate(tmpl, groups) {
+    return tmpl.replace(/\{\{\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\}\}/g, (_, name) => groups[name] ?? "");
+}
+function compileRegex(source, extraFlags = "") {
+    try {
+        // De-duplicate flags in case the source already had `g`/`m`.
+        const seen = new Set();
+        const flags = (extraFlags).split("").filter((c) => {
+            if (seen.has(c))
+                return false;
+            seen.add(c);
+            return true;
+        }).join("");
+        return new RegExp(source, flags);
+    }
+    catch (err) {
+        throw new Error(`Invalid regex /${source}/: ${err.message}`);
+    }
+}
+function lineNumberAt(content, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < content.length; i++) {
+        if (content.charCodeAt(i) === 10 /* \n */)
+            line++;
+    }
+    return line;
+}
+async function* walk(root) {
+    const stack = [""];
+    while (stack.length > 0) {
+        const relDir = stack.pop();
+        const absDir = path.join(root, relDir);
+        let entries;
+        try {
+            entries = await fs.readdir(absDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                stack.push(path.join(relDir, entry.name));
+            }
+            else if (entry.isFile()) {
+                // Always emit POSIX-style paths so users on macOS/Linux/Windows write
+                // the same fileMatch regexes.
+                yield path.join(relDir, entry.name).split(path.sep).join("/");
+            }
+        }
+    }
+}

package/dist/lib/externalPresetFetcher.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedPreset } from "./presetResolver.js";
+export interface FetchOptions {
+    timeoutMs?: number;
+    cache?: Map<string, Promise<FetchResult>>;
+    /** Injectable for tests. Defaults to globalThis.fetch. */
+    fetchImpl?: typeof fetch;
+}
+export type FetchResult = {
+    ok: true;
+    body: Record<string, unknown>;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function fetchExternalPreset(parsed: ParsedPreset, options?: FetchOptions): Promise<FetchResult>;

package/dist/lib/externalPresetFetcher.js

@@ -0,0 +1,130 @@
+const DEFAULT_TIMEOUT_MS = 10_000;
+export async function fetchExternalPreset(parsed, options = {}) {
+    const cache = options.cache;
+    const cacheKey = parsed.key;
+    if (cache?.has(cacheKey)) {
+        return cache.get(cacheKey);
+    }
+    const promise = dispatch(parsed, options);
+    cache?.set(cacheKey, promise);
+    return promise;
+}
+function dispatch(parsed, options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    switch (parsed.source) {
+        case "github":
+            return fetchGitHub(parsed, timeoutMs, fetchImpl);
+        case "gitlab":
+            return fetchGitLab(parsed, timeoutMs, fetchImpl);
+        case "bitbucket":
+        case "gitea":
+            return Promise.resolve({
+                ok: false,
+                reason: `${parsed.source}> presets are not yet supported. Track progress in issue #10.`,
+            });
+        case "local":
+            return Promise.resolve({
+                ok: false,
+                reason: "local> presets require platform/repo context that resolve_config does not have; out of scope.",
+            });
+        case "npm":
+            return Promise.resolve({
+                ok: false,
+                reason: "npm-hosted presets are not yet supported. Host the preset on GitHub or GitLab, or track progress in issue #10.",
+            });
+        default:
+            return Promise.resolve({
+                ok: false,
+                reason: `Unknown preset source: ${parsed.source ?? "(none)"}`,
+            });
+    }
+}
+async function fetchGitHub(parsed, timeoutMs, fetchImpl) {
+    if (!parsed.repoPath || !parsed.repoPath.includes("/")) {
+        return { ok: false, reason: `Invalid github preset: ${parsed.original}` };
+    }
+    const file = presetFileName(parsed);
+    const ref = parsed.ref ?? "HEAD";
+    const url = `https://api.github.com/repos/${parsed.repoPath}/contents/${encodeFilePath(file)}?ref=${encodeURIComponent(ref)}`;
+    const token = process.env.GITHUB_TOKEN || process.env.RENOVATE_TOKEN;
+    const headers = {
+        Accept: "application/vnd.github.raw",
+        "User-Agent": "renovate-mcp",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return fetchJson(url, headers, timeoutMs, parsed.original, fetchImpl);
+}
+async function fetchGitLab(parsed, timeoutMs, fetchImpl) {
+    if (!parsed.repoPath) {
+        return { ok: false, reason: `Invalid gitlab preset: ${parsed.original}` };
+    }
+    const file = presetFileName(parsed);
+    const ref = parsed.ref ?? "HEAD";
+    const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(parsed.repoPath)}/repository/files/${encodeURIComponent(file)}/raw?ref=${encodeURIComponent(ref)}`;
+    const token = process.env.GITLAB_TOKEN || process.env.RENOVATE_TOKEN;
+    const headers = { "User-Agent": "renovate-mcp" };
+    if (token)
+        headers["PRIVATE-TOKEN"] = token;
+    return fetchJson(url, headers, timeoutMs, parsed.original, fetchImpl);
+}
+function presetFileName(parsed) {
+    if (parsed.subpath)
+        return ensureJson(parsed.subpath);
+    if (parsed.presetName)
+        return ensureJson(parsed.presetName);
+    return "default.json";
+}
+function ensureJson(name) {
+    return /\.(json5?|jsonc)$/i.test(name) ? name : `${name}.json`;
+}
+function encodeFilePath(file) {
+    return file.split("/").map(encodeURIComponent).join("/");
+}
+async function fetchJson(url, headers, timeoutMs, presetName, fetchImpl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(url, { headers, signal: controller.signal });
+        if (!res.ok) {
+            return {
+                ok: false,
+                reason: `HTTP ${res.status}${res.statusText ? ` ${res.statusText}` : ""} when fetching ${presetName}`,
+            };
+        }
+        const text = await res.text();
+        try {
+            const body = JSON.parse(text);
+            if (!body || typeof body !== "object" || Array.isArray(body)) {
+                return {
+                    ok: false,
+                    reason: `Preset body for ${presetName} is not a JSON object.`,
+                };
+            }
+            return { ok: true, body: body };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                reason: `Preset body for ${presetName} is not valid JSON: ${e.message}`,
+            };
+        }
+    }
+    catch (e) {
+        const err = e;
+        if (err.name === "AbortError") {
+            return {
+                ok: false,
+                reason: `Timed out after ${timeoutMs}ms fetching ${presetName}`,
+            };
+        }
+        return {
+            ok: false,
+            reason: `Network error fetching ${presetName}: ${err.message}`,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/lib/presetResolver.d.ts

@@ -0,0 +1,41 @@
+export interface UnresolvedPreset {
+    preset: string;
+    reason: string;
+}
+export interface ResolveResult {
+    resolved: Record<string, unknown>;
+    presetsResolved: string[];
+    presetsUnresolved: UnresolvedPreset[];
+}
+export interface ResolveOptions {
+    /** When true, fetch external presets (github>, gitlab>, …) over the network. */
+    fetchExternal?: boolean;
+    /** Per-request fetch timeout; forwarded to the external fetcher. */
+    timeoutMs?: number;
+}
+export type ExternalSource = "github" | "gitlab" | "bitbucket" | "gitea" | "local" | "npm";
+export interface ParsedPreset {
+    /** Canonical identifier used as map key and for cycle detection. */
+    key: string;
+    /** Original un-normalized string as it appeared in `extends`. */
+    original: string;
+    args: string[];
+    /** For external (non-builtin) presets. */
+    source?: ExternalSource;
+    /** Git sources: "owner/repo". npm: the package name. */
+    repoPath?: string;
+    /** Optional `:presetName` fragment. */
+    presetName?: string;
+    /** Optional `//subpath` fragment. */
+    subpath?: string;
+    /** Optional `#ref` (branch/tag/commit) fragment. */
+    ref?: string;
+}
+/**
+ * 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 declare function resolveConfig(config: Record<string, unknown>, options?: ResolveOptions): Promise<ResolveResult>;
+export declare function parsePreset(raw: string): ParsedPreset;