renovate-mcp 1.1.1 → 1.2.0

package/README.md

@@ -31,6 +31,7 @@ Restart your client and try the prompt: *"List the namespaces available under `r
 ## What you can do
 
 - **Read and explain configs** — locate the active `renovate.json*`, expand every `extends` preset offline, and trace which preset set each field.
+- **Discover presets from intent** — describe what you want ("automerge patches, group dev deps") and get ranked built-in (and your own local-repo) presets, plus a draft config skeleton when nothing fits.
 - **Preview custom managers** before running Renovate — regex and JSONata, with file/line hits and extracted dep info.
 - **Validate and lint** — schema validation plus a semantic lint pass for Renovate-specific footguns (unwrapped regexes, unknown manager names, deprecated keys).
 - **Dry-run** against a local checkout or a remote GitHub/GitLab — see exactly which PRs Renovate would open.
@@ -38,13 +39,14 @@ Restart your client and try the prompt: *"List the namespaces available under `r
 
 ## Tools & resources
 
-Thirteen tools and three resource templates. Each tool name below links to its full reference in [`docs/tools.md`](docs/tools.md).
+Fourteen tools and three resource templates. Each tool name below links to its full reference in [`docs/tools.md`](docs/tools.md).
 
 | Tool | Purpose |
 | --- | --- |
 | [`check_setup`](docs/tools.md#check_setup) | Report Renovate CLI + validator availability, versions, install hints, and a `platformContext` block for env diagnosis. Also runs at startup. Pass an optional `repoPath` to add a `repoContext` block diagnosing the repo's git origin, config endpoint/platform, endpoint reachability, and token coverage. |
 | [`get_version`](docs/tools.md#get_version) | Report the renovate-mcp server version and whether it's a released or local/dev build. |
 | [`read_config`](docs/tools.md#read_config) | Locate and parse a repo's Renovate config in Renovate's own discovery order. |
+| [`suggest_presets`](docs/tools.md#suggest_presets) | Search built-in (and optional local-repo) presets by natural-language intent; ranks matches and sketches an unvalidated draft config skeleton for multi-facet or weakly-covered intents. Offline. |
 | [`resolve_config`](docs/tools.md#resolve_config) | Expand every `extends` preset offline. Opt in to fetching `github>` / `gitlab>` presets over HTTPS. |
 | [`explain_config`](docs/tools.md#explain_config) | Inverse of `resolve_config`: annotate every leaf field with the chain of presets that set it. |
 | [`resolve_config_diff`](docs/tools.md#resolve_config_diff) | Offline structural diff of two fully-resolved configs — changed fields plus an order-insensitive set diff of array keys (`packageRules`, `customManagers`, …). The refactor-friendly counterpart to `dry_run_diff`. |
@@ -64,7 +66,7 @@ Thirteen tools and three resource templates. Each tool name below links to its f
 - **Linux or macOS.** Windows is not supported — `package.json` declares `"os": ["darwin", "linux"]`, so `npm i` surfaces an `EBADPLATFORM` warning on Windows and the server exits with a clear stderr message at startup. Use WSL2 or a Linux/macOS host instead.
 - **Node.js ≥ 24** (aligns with Renovate's own engine requirement).
 
-Renovate ships bundled — the `renovate` package is a runtime dependency, so `validate_config`, `dry_run`, and `write_config` work out of the box with no separate install. The offline tools (`read_config`, `resolve_config`, `explain_config`, `resolve_config_diff`, `preview_custom_manager`, `lint_config`) never spawn Renovate at all.
+Renovate ships bundled — the `renovate` package is a runtime dependency, so `validate_config`, `dry_run`, and `write_config` work out of the box with no separate install. The offline tools (`read_config`, `suggest_presets`, `resolve_config`, `explain_config`, `resolve_config_diff`, `preview_custom_manager`, `lint_config`) never spawn Renovate at all.
 
 **Optional env vars:**
 
@@ -125,11 +127,12 @@ Once the server is wired up, try prompts like these. Written for Claude but work
 - "Resolve my config and list anything that landed in `presetsUnresolved`, with the reason for each."
 - "Why is my `prCreation` set to `not-pending`? Use `explain_config` to trace which preset set it."
 
-**Browsing presets**
+**Discovering & browsing presets**
 
+- "I want to automerge patch and minor updates and group my dev dependencies — suggest presets for that, search my `../renovate-presets` repo too, and draft a config I can validate."
 - "List the presets in the `config` namespace." (uses the `renovate://presets/config` sub-resource — cheaper than pulling the whole index)
 - "What does `config:recommended` actually enable? Show me its expanded JSON."
-- "Find a built-in preset that pins GitHub Actions digests."
+- "Find a built-in preset that pins GitHub Actions digests." (or use `suggest_presets` with that intent)
 
 **Self-hosted GitLab / GitHub Enterprise** (env set per [Platform setup](#platform-setup))
 

package/dist/index.js

@@ -8,6 +8,7 @@ import { registerLintConfig } from "./tools/lintConfig.js";
 import { registerResolveConfig } from "./tools/resolveConfig.js";
 import { registerExplainConfig } from "./tools/explainConfig.js";
 import { registerResolveConfigDiff } from "./tools/resolveConfigDiff.js";
+import { registerSuggestPresets } from "./tools/suggestPresets.js";
 import { registerPreviewCustomManager } from "./tools/previewCustomManager.js";
 import { registerDryRun } from "./tools/dryRun.js";
 import { registerDryRunDiff } from "./tools/dryRunDiff.js";
@@ -32,16 +33,17 @@ const BASE_INSTRUCTIONS = [
     "",
     "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. explain_config         — inverse of resolve_config: trace which preset set each field (offline)",
-    "  4. resolve_config_diff    — offline structural diff of two resolved configs (changed fields + array/packageRules set diffs); use this over dry_run_diff for config refactors, especially when registries are unreachable",
-    "  5. preview_custom_manager — iterate on a regex-based customManagers entry; shows file/line hits and extracted deps",
-    "  6. validate_config        — check a proposed config against Renovate's schema",
-    "  7. lint_config            — semantic lint pass: catches Renovate-specific footguns schema validation misses (e.g. malformed /…/ regex patterns)",
-    "  8. dry_run                — preview what Renovate would actually do (no PRs)",
-    "  9. dry_run_diff           — semantic diff between two dry_run reports (added/removed/changed updates)",
-    " 10. migrate_config         — apply Renovate's built-in migrations (deprecated keys → current schema) and return the migrated config",
-    " 11. write_config           — save the agreed-upon config (validates first)",
+    "  2. suggest_presets        — go from a natural-language intent to candidate built-in/local presets + an unvalidated draft skeleton (offline); then validate_config + lint_config",
+    "  3. resolve_config         — expand built-in presets to see what a config actually becomes (offline)",
+    "  4. explain_config         — inverse of resolve_config: trace which preset set each field (offline)",
+    "  5. resolve_config_diff    — offline structural diff of two resolved configs (changed fields + array/packageRules set diffs); use this over dry_run_diff for config refactors, especially when registries are unreachable",
+    "  6. preview_custom_manager — iterate on a regex-based customManagers entry; shows file/line hits and extracted deps",
+    "  7. validate_config        — check a proposed config against Renovate's schema",
+    "  8. lint_config            — semantic lint pass: catches Renovate-specific footguns schema validation misses (e.g. malformed /…/ regex patterns)",
+    "  9. dry_run                — preview what Renovate would actually do (no PRs)",
+    " 10. dry_run_diff           — semantic diff between two dry_run reports (added/removed/changed updates)",
+    " 11. migrate_config         — apply Renovate's built-in migrations (deprecated keys → current schema) and return the migrated config",
+    " 12. write_config           — save the agreed-upon config (validates first)",
     "",
     "Before the first repo-touching tool call in a session (read_config, resolve_config, dry_run, write_config, …), call check_setup with the same repoPath. It surfaces token / endpoint / connectivity problems up front (e.g. \"set GITHUB_TOKEN or github-actions deps will be skipped\") instead of waiting for dry_run to fail. Skip if the user has already confirmed setup or is doing offline-only work that doesn't depend on git origin or registries.",
     "If any tool fails unexpectedly, call check_setup to diagnose CLI availability.",
@@ -64,6 +66,7 @@ registerReadConfig(server);
 registerResolveConfig(server);
 registerExplainConfig(server);
 registerResolveConfigDiff(server);
+registerSuggestPresets(server);
 registerPreviewCustomManager(server);
 registerValidateConfig(server);
 registerLintConfig(server);

package/dist/lib/inputLimits.d.ts

@@ -4,6 +4,7 @@ export declare const TOKEN_MAX_BYTES = 1024;
 export declare const ENDPOINT_MAX_BYTES = 2048;
 export declare const REPOSITORY_MAX_BYTES = 256;
 export declare const FILENAME_MAX_BYTES = 512;
+export declare const QUERY_MAX_BYTES = 2048;
 export declare const CONFIG_JSON_MAX_BYTES = 1000000;
 export declare const REPORT_JSON_MAX_BYTES = 10000000;
 export declare const HOST_RULES_MAX_ITEMS = 256;
@@ -13,6 +14,7 @@ export declare const tokenString: (description: string) => z.ZodString;
 export declare const endpointString: (description: string) => z.ZodString;
 export declare const repositoryString: (description: string) => z.ZodString;
 export declare const filenameString: (description: string) => z.ZodString;
+export declare const queryString: (description: string) => z.ZodString;
 export declare const configRecord: (description: string) => z.ZodRecord<z.ZodString, z.ZodUnknown>;
 export declare const reportRecord: (description: string) => z.ZodRecord<z.ZodString, z.ZodUnknown>;
 export declare const hostRuleRecord: (description: string) => z.ZodRecord<z.ZodString, z.ZodUnknown>;

package/dist/lib/inputLimits.js

@@ -9,6 +9,7 @@ export const TOKEN_MAX_BYTES = 1024;
 export const ENDPOINT_MAX_BYTES = 2048;
 export const REPOSITORY_MAX_BYTES = 256;
 export const FILENAME_MAX_BYTES = 512;
+export const QUERY_MAX_BYTES = 2048;
 export const CONFIG_JSON_MAX_BYTES = 1_000_000;
 export const REPORT_JSON_MAX_BYTES = 10_000_000;
 export const HOST_RULES_MAX_ITEMS = 256;
@@ -18,6 +19,7 @@ export const tokenString = (description) => z.string().max(TOKEN_MAX_BYTES).desc
 export const endpointString = (description) => z.string().max(ENDPOINT_MAX_BYTES).describe(description);
 export const repositoryString = (description) => z.string().max(REPOSITORY_MAX_BYTES).describe(description);
 export const filenameString = (description) => z.string().max(FILENAME_MAX_BYTES).describe(description);
+export const queryString = (description) => z.string().min(1).max(QUERY_MAX_BYTES).describe(description);
 const refineJsonSize = (limit) => (value) => {
     try {
         return JSON.stringify(value).length <= limit;

package/dist/lib/presetSuggester.d.ts

@@ -0,0 +1,125 @@
+export interface CorpusPreset {
+    name: string;
+    namespace: string;
+    description: string | null;
+    body: Record<string, unknown>;
+    /** Set only for local presets — the source filename relative to presetsPath. */
+    file?: string;
+}
+export interface SuggestMatch {
+    name: string;
+    namespace: string;
+    description: string | null;
+    /** 0..1 relevance score, rounded for stable output. */
+    score: number;
+    /** Which fields a query token matched: any of name/namespace/description/body. */
+    matchedOn: string[];
+    file?: string;
+    body?: Record<string, unknown>;
+}
+export type Coverage = "strong" | "partial" | "weak";
+interface CorpusEntry {
+    preset: CorpusPreset;
+    nameText: string;
+    namespaceText: string;
+    descText: string;
+    bodyText: string;
+    allText: string;
+}
+export type Corpus = CorpusEntry[];
+/**
+ * Lowercase, split camelCase identifiers, split on non-alphanumeric runs, and
+ * drop short tokens + stopwords. Returns tokens in order (may contain dupes;
+ * callers dedupe as needed).
+ */
+export declare function tokenize(text: string): string[];
+export declare function buildCorpus(presets: CorpusPreset[]): Corpus;
+export interface RankOptions {
+    namespace?: string;
+    limit?: number;
+    minScore?: number;
+    includeBody?: boolean;
+}
+/**
+ * Rank a corpus against a free-text query.
+ *
+ * Score = Σ (field-weight × IDF) over distinct query tokens, normalized by the
+ * maximum achievable (every token hitting the name). Field weighting favors
+ * name > namespace > description > body; the load-of-the-pool IDF downweights
+ * tokens that appear in many presets (e.g. "group"), so a preset matching a
+ * rare, specific token outranks one that only shares a ubiquitous one. Matching
+ * is substring-based (handles camelCase names like `automergeMinor`); this is a
+ * recall aid, not a stemmed IR engine.
+ */
+export declare function rankCorpus(query: string, corpus: Corpus, opts?: RankOptions): SuggestMatch[];
+export declare function coverageOf(bestScore: number): Coverage;
+export interface IndexOptions {
+    maxFilesIndexed?: number;
+    maxPresetsIndexed?: number;
+}
+export interface IndexResult {
+    presets: CorpusPreset[];
+    warnings: string[];
+}
+/**
+ * Index a local presets repo: flat `*.json`/`*.json5` files, one preset per
+ * file. Name = filename without extension; namespace = "local"; description =
+ * top-level `description` → first `packageRules[].description` → null. Parses
+ * with JSON5 (parse-only side of the json5/jsonc-parser split). Malformed files
+ * become warnings, never crashes. Subdirectories are not recursed.
+ */
+export declare function indexLocalPresets(presetsPath: string, opts?: IndexOptions): Promise<IndexResult>;
+/** The committed built-in preset catalogue, built into a searchable corpus once. */
+export declare function getBuiltInCorpus(): Corpus;
+export interface DraftContribution {
+    extends?: string[];
+    packageRules?: Record<string, unknown>[];
+    topLevel?: Record<string, unknown>;
+    note?: string;
+}
+export interface Facet {
+    id: string;
+    /** Tested against the lowercased raw query (substring match, so phrases work). */
+    test: (q: string) => boolean;
+    build: (q: string) => DraftContribution;
+}
+export declare const FACETS: Facet[];
+export declare function detectFacets(query: string): {
+    id: string;
+    contribution: DraftContribution;
+}[];
+export interface Draft {
+    config: Record<string, unknown>;
+    unvalidated: true;
+    hint: string;
+    facets: string[];
+    notes: string[];
+}
+/**
+ * Assemble an unvalidated draft Renovate config from the facets a query
+ * triggers. `config` is the pasteable/validatable Renovate config; the
+ * surrounding fields (`unvalidated`, `hint`, `facets`, `notes`) are metadata —
+ * pass `draft.config` (not the whole draft) to validate_config.
+ */
+export declare function assembleDraft(query: string): Draft;
+export interface SuggestOptions {
+    presetsPath?: string;
+    namespace?: string;
+    limit?: number;
+    minScore?: number;
+    includeBody?: boolean;
+    includeDraft?: boolean;
+    maxFilesIndexed?: number;
+    maxPresetsIndexed?: number;
+}
+export interface SuggestResult {
+    query: string;
+    builtIn: SuggestMatch[];
+    local: SuggestMatch[];
+    bestScore: number;
+    coverage: Coverage;
+    draft?: Draft;
+    warnings: string[];
+}
+export declare function suggestPresets(query: string, opts?: SuggestOptions): Promise<SuggestResult>;
+export {};

package/dist/lib/presetSuggester.js

@@ -0,0 +1,453 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import JSON5 from "json5";
+import { PRESETS, PRESET_NAMES } from "../data/presets.generated.js";
+// Conservative stopword set: true function words and natural-language filler
+// that carry no Renovate signal. Ubiquitous *Renovate* tokens (group, config,
+// all, …) are NOT listed here — the IDF weighting downweights them instead, so
+// they still contribute when nothing rarer is present.
+const STOPWORDS = new Set([
+    "the", "a", "an", "and", "or", "of", "to", "for", "with", "my", "our", "your",
+    "into", "on", "in", "is", "it", "that", "this", "then", "so", "but", "by", "as",
+    "at", "be", "i", "want", "wants", "wanted", "would", "like", "please", "need",
+    "needs", "should", "just", "only", "also", "when", "while", "via", "per", "do",
+    "does", "me", "we", "us", "can", "could",
+]);
+const FIELD_WEIGHT = { name: 5, namespace: 4, description: 2, body: 1 };
+const DEFAULT_LIMIT = 10;
+const DEFAULT_MIN_SCORE = 0.12;
+const STRONG_THRESHOLD = 0.6;
+const PARTIAL_THRESHOLD = 0.3;
+const DEFAULT_MAX_FILES_INDEXED = 2000;
+const DEFAULT_MAX_PRESETS_INDEXED = 500;
+const PRESET_EXT = /\.(json|json5)$/i;
+function splitCamel(s) {
+    return s
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+}
+/**
+ * Lowercase, split camelCase identifiers, split on non-alphanumeric runs, and
+ * drop short tokens + stopwords. Returns tokens in order (may contain dupes;
+ * callers dedupe as needed).
+ */
+export function tokenize(text) {
+    const spaced = splitCamel(text).toLowerCase();
+    const out = [];
+    for (const part of spaced.split(/[^a-z0-9]+/)) {
+        if (part.length < 2)
+            continue;
+        if (STOPWORDS.has(part))
+            continue;
+        out.push(part);
+    }
+    return out;
+}
+export function buildCorpus(presets) {
+    return presets.map((preset) => {
+        const nameText = preset.name.toLowerCase();
+        const namespaceText = preset.namespace.toLowerCase();
+        const descText = (preset.description ?? "").toLowerCase();
+        let bodyText = "";
+        try {
+            bodyText = JSON.stringify(preset.body ?? {}).toLowerCase();
+        }
+        catch {
+            bodyText = "";
+        }
+        return {
+            preset,
+            nameText,
+            namespaceText,
+            descText,
+            bodyText,
+            allText: `${nameText} ${namespaceText} ${descText} ${bodyText}`,
+        };
+    });
+}
+function round(n) {
+    return Math.round(n * 10000) / 10000;
+}
+/**
+ * Rank a corpus against a free-text query.
+ *
+ * Score = Σ (field-weight × IDF) over distinct query tokens, normalized by the
+ * maximum achievable (every token hitting the name). Field weighting favors
+ * name > namespace > description > body; the load-of-the-pool IDF downweights
+ * tokens that appear in many presets (e.g. "group"), so a preset matching a
+ * rare, specific token outranks one that only shares a ubiquitous one. Matching
+ * is substring-based (handles camelCase names like `automergeMinor`); this is a
+ * recall aid, not a stemmed IR engine.
+ */
+export function rankCorpus(query, corpus, opts = {}) {
+    const includeBody = opts.includeBody ?? false;
+    const limit = opts.limit ?? DEFAULT_LIMIT;
+    const minScore = opts.minScore ?? DEFAULT_MIN_SCORE;
+    const tokens = Array.from(new Set(tokenize(query)));
+    const pool = opts.namespace
+        ? corpus.filter((e) => e.preset.namespace === opts.namespace)
+        : corpus;
+    if (tokens.length === 0 || pool.length === 0)
+        return [];
+    const N = pool.length;
+    const idf = new Map();
+    for (const t of tokens) {
+        let df = 0;
+        for (const e of pool)
+            if (e.allText.includes(t))
+                df++;
+        idf.set(t, Math.log(1 + N / (1 + df)));
+    }
+    const maxPossible = tokens.reduce((sum, t) => sum + FIELD_WEIGHT.name * idf.get(t), 0);
+    const scored = [];
+    for (const e of pool) {
+        const matchedOn = new Set();
+        let raw = 0;
+        let nameHits = 0;
+        for (const t of tokens) {
+            let w = 0;
+            if (e.nameText.includes(t)) {
+                w = Math.max(w, FIELD_WEIGHT.name);
+                matchedOn.add("name");
+                nameHits++;
+            }
+            if (e.namespaceText.includes(t)) {
+                w = Math.max(w, FIELD_WEIGHT.namespace);
+                matchedOn.add("namespace");
+            }
+            if (e.descText.includes(t)) {
+                w = Math.max(w, FIELD_WEIGHT.description);
+                matchedOn.add("description");
+            }
+            if (e.bodyText.includes(t)) {
+                w = Math.max(w, FIELD_WEIGHT.body);
+                matchedOn.add("body");
+            }
+            raw += w * idf.get(t);
+        }
+        let score = maxPossible > 0 ? raw / maxPossible : 0;
+        // Name-overlap confidence boost: a preset whose NAME contains several of the
+        // query's terms is very likely the one the user means, even when the query
+        // carries filler words ("automerge minor updates" → automergeMinor). Pull the
+        // score toward 1 in proportion to how many distinct query tokens hit the name.
+        if (nameHits >= 2) {
+            score += (1 - score) * Math.min(0.15 * nameHits, 0.45);
+        }
+        if (score < minScore)
+            continue;
+        const match = {
+            name: e.preset.name,
+            namespace: e.preset.namespace,
+            description: e.preset.description,
+            score: round(score),
+            matchedOn: Array.from(matchedOn).sort(),
+        };
+        if (e.preset.file)
+            match.file = e.preset.file;
+        if (includeBody)
+            match.body = e.preset.body;
+        scored.push(match);
+    }
+    scored.sort((a, b) => b.score - a.score || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return scored.slice(0, limit);
+}
+export function coverageOf(bestScore) {
+    if (bestScore >= STRONG_THRESHOLD)
+        return "strong";
+    if (bestScore >= PARTIAL_THRESHOLD)
+        return "partial";
+    return "weak";
+}
+function deriveDescription(body) {
+    const top = body.description;
+    if (typeof top === "string")
+        return top;
+    if (Array.isArray(top) && top.every((x) => typeof x === "string"))
+        return top.join(" ");
+    const rules = body.packageRules;
+    if (Array.isArray(rules)) {
+        for (const r of rules) {
+            if (r && typeof r === "object") {
+                const d = r.description;
+                if (typeof d === "string")
+                    return d;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Index a local presets repo: flat `*.json`/`*.json5` files, one preset per
+ * file. Name = filename without extension; namespace = "local"; description =
+ * top-level `description` → first `packageRules[].description` → null. Parses
+ * with JSON5 (parse-only side of the json5/jsonc-parser split). Malformed files
+ * become warnings, never crashes. Subdirectories are not recursed.
+ */
+export async function indexLocalPresets(presetsPath, opts = {}) {
+    const maxFiles = opts.maxFilesIndexed ?? DEFAULT_MAX_FILES_INDEXED;
+    const maxPresets = opts.maxPresetsIndexed ?? DEFAULT_MAX_PRESETS_INDEXED;
+    const warnings = [];
+    const entries = await readdir(presetsPath, { withFileTypes: true });
+    const files = entries
+        .filter((e) => e.isFile() && PRESET_EXT.test(e.name))
+        .map((e) => e.name)
+        .sort();
+    let scanned = files;
+    if (files.length > maxFiles) {
+        warnings.push(`Found ${files.length} preset files; only the first ${maxFiles} were scanned (maxFilesIndexed cap).`);
+        scanned = files.slice(0, maxFiles);
+    }
+    const presets = [];
+    for (const file of scanned) {
+        if (presets.length >= maxPresets) {
+            warnings.push(`Indexed ${maxPresets} presets; remaining files skipped (maxPresetsIndexed cap).`);
+            break;
+        }
+        const full = path.join(presetsPath, file);
+        let raw;
+        try {
+            raw = await readFile(full, "utf8");
+        }
+        catch (err) {
+            warnings.push(`Could not read ${file}: ${err.message}`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON5.parse(raw);
+        }
+        catch (err) {
+            warnings.push(`Could not parse ${file} as JSON/JSON5: ${err.message}`);
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            warnings.push(`Skipped ${file}: not a JSON object.`);
+            continue;
+        }
+        const body = parsed;
+        presets.push({
+            name: file.replace(PRESET_EXT, ""),
+            namespace: "local",
+            description: deriveDescription(body),
+            body,
+            file,
+        });
+    }
+    return { presets, warnings };
+}
+let builtInCorpus = null;
+/** The committed built-in preset catalogue, built into a searchable corpus once. */
+export function getBuiltInCorpus() {
+    if (!builtInCorpus) {
+        const presets = PRESET_NAMES.map((name) => {
+            const p = PRESETS[name];
+            return { name, namespace: p.namespace, description: p.description, body: p.body };
+        });
+        builtInCorpus = buildCorpus(presets);
+    }
+    return builtInCorpus;
+}
+function has(q, ...subs) {
+    return subs.some((s) => q.includes(s));
+}
+export const FACETS = [
+    {
+        id: "automerge",
+        test: (q) => has(q, "automerge", "auto-merge", "auto merge"),
+        build: (q) => {
+            if (has(q, "all", "everything"))
+                return { extends: [":automergeAll"] };
+            if (has(q, "major"))
+                return {
+                    extends: [":automergeMajor"],
+                    note: "Automerging major updates is risky — confirm with dry_run first.",
+                };
+            if (has(q, "minor"))
+                return { extends: [":automergeMinor"] };
+            if (has(q, "patch"))
+                return { extends: [":automergePatch"] };
+            return {
+                extends: [":automergeMinor"],
+                note: "Defaulted to minor+patch automerge; use :automergePatch to restrict to patch only.",
+            };
+        },
+    },
+    {
+        id: "groupDevDeps",
+        // Require "dev" adjacent to "dep" so "development"/"devops"/"developer"
+        // don't spuriously trigger a devDependencies grouping rule.
+        test: (q) => has(q, "group", "combine", "batch", "bundle") &&
+            has(q, "devdep", "dev dep", "dev-dep", "dev dependenc", "devdependenc"),
+        build: () => ({
+            packageRules: [
+                {
+                    description: "Group devDependency updates into a single PR.",
+                    matchDepTypes: ["devDependencies"],
+                    groupName: "dev dependencies",
+                },
+            ],
+        }),
+    },
+    {
+        id: "groupNonMajor",
+        test: (q) => has(q, "group", "combine", "batch", "bundle") && has(q, "non-major", "nonmajor", "non major"),
+        build: () => ({ extends: ["group:allNonMajor"] }),
+    },
+    {
+        id: "groupMonorepo",
+        test: (q) => has(q, "monorepo"),
+        build: () => ({
+            extends: ["group:recommended"],
+            note: "group:recommended pulls in Renovate's curated monorepo groupings.",
+        }),
+    },
+    {
+        id: "schedule",
+        test: (q) => has(q, "schedule", "weekend", "weekly", "monthly", "off hours", "off-hours", "nonoffice", "non-office", "office hours", "business hours", "after hours", "out of hours"),
+        build: (q) => {
+            if (has(q, "monthly"))
+                return { extends: ["schedule:monthly"] };
+            // Renovate only ships schedule:nonOfficeHours (runs OUTSIDE work hours).
+            // Match only clearly-outside-work phrasings — bare "office hours" /
+            // "business hours" mean DURING work, which has no preset, so let them
+            // fall through to the weekly default rather than returning the opposite.
+            if (has(q, "non-office", "nonoffice", "off hours", "off-hours", "after hours", "out of hours", "outside office", "outside business"))
+                return { extends: ["schedule:nonOfficeHours"] };
+            if (has(q, "weekend", "weekly"))
+                return { extends: ["schedule:weekly"] };
+            return {
+                extends: ["schedule:weekly"],
+                note: "Defaulted to weekly; see the schedule:* presets for other cadences (no preset exists for 'during office hours').",
+            };
+        },
+    },
+    {
+        id: "pinDigests",
+        test: (q) => has(q, "pin") && has(q, "digest", "sha"),
+        build: (q) => {
+            if (has(q, "action", "github", "workflow"))
+                return { extends: ["helpers:pinGitHubActionDigests"] };
+            if (has(q, "docker", "image", "container"))
+                return { extends: ["docker:pinDigests"] };
+            return {
+                extends: ["docker:pinDigests", "helpers:pinGitHubActionDigests"],
+                note: "Digest pinning is datasource-specific; included Docker + GitHub Actions presets — keep the ones you need.",
+            };
+        },
+    },
+    {
+        id: "semanticCommits",
+        test: (q) => has(q, "semantic", "conventional") && has(q, "commit"),
+        build: () => ({ topLevel: { semanticCommits: "enabled" } }),
+    },
+    {
+        id: "disableMajor",
+        test: (q) => has(q, "disable", "without", "skip", "ignore") && has(q, "major"),
+        build: () => ({ extends: [":disableMajorUpdates"] }),
+    },
+    {
+        id: "separateMajor",
+        test: (q) => has(q, "separate", "split") && has(q, "major"),
+        build: () => ({ extends: [":separateMajorReleases"] }),
+    },
+    {
+        id: "lockfileMaintenance",
+        test: (q) => has(q, "lockfile", "lock file", "lock-file") ||
+            (has(q, "lock") && has(q, "maintenance", "maintain", "refresh")),
+        build: () => ({ extends: [":maintainLockFilesWeekly"] }),
+    },
+    {
+        id: "labels",
+        test: (q) => has(q, "label"),
+        build: () => ({
+            topLevel: { labels: ["dependencies"] },
+            note: "Placeholder label 'dependencies' — rename to match your repo's convention.",
+        }),
+    },
+];
+export function detectFacets(query) {
+    const q = query.toLowerCase();
+    const out = [];
+    for (const facet of FACETS) {
+        if (facet.test(q))
+            out.push({ id: facet.id, contribution: facet.build(q) });
+    }
+    return out;
+}
+const DRAFT_HINT = "Unvalidated starting point. Pass draft.config to validate_config, then lint_config, before adopting it.";
+/**
+ * Assemble an unvalidated draft Renovate config from the facets a query
+ * triggers. `config` is the pasteable/validatable Renovate config; the
+ * surrounding fields (`unvalidated`, `hint`, `facets`, `notes`) are metadata —
+ * pass `draft.config` (not the whole draft) to validate_config.
+ */
+export function assembleDraft(query) {
+    const detected = detectFacets(query);
+    const extendsList = [];
+    const packageRules = [];
+    const topLevel = {};
+    const notes = [];
+    const facets = [];
+    for (const { id, contribution } of detected) {
+        facets.push(id);
+        if (contribution.extends) {
+            for (const e of contribution.extends)
+                if (!extendsList.includes(e))
+                    extendsList.push(e);
+        }
+        if (contribution.packageRules)
+            packageRules.push(...contribution.packageRules);
+        if (contribution.topLevel)
+            Object.assign(topLevel, contribution.topLevel);
+        if (contribution.note)
+            notes.push(contribution.note);
+    }
+    const config = {};
+    if (extendsList.length)
+        config.extends = extendsList;
+    Object.assign(config, topLevel);
+    if (packageRules.length)
+        config.packageRules = packageRules;
+    // Cross-facet sanity: disabling and separating major updates are mutually
+    // exclusive. validate_config/lint_config won't flag this (it's schema-valid),
+    // so surface it in the draft notes.
+    if (facets.includes("disableMajor") && facets.includes("separateMajor")) {
+        notes.push(":disableMajorUpdates and :separateMajorReleases conflict — you can't separate major updates you've disabled. Keep one.");
+    }
+    if (facets.length === 0) {
+        notes.push("Couldn't infer preset structure from this query. Describe the intent in more detail (mention automerge, grouping, scheduling, digest pinning, semantic commits, etc.), or browse renovate://presets.");
+    }
+    return { config, unvalidated: true, hint: DRAFT_HINT, facets, notes };
+}
+export async function suggestPresets(query, opts = {}) {
+    const rankOpts = {
+        namespace: opts.namespace,
+        limit: opts.limit,
+        minScore: opts.minScore,
+        includeBody: opts.includeBody,
+    };
+    const warnings = [];
+    const builtIn = rankCorpus(query, getBuiltInCorpus(), rankOpts);
+    let local = [];
+    if (opts.presetsPath) {
+        const idx = await indexLocalPresets(opts.presetsPath, {
+            maxFilesIndexed: opts.maxFilesIndexed,
+            maxPresetsIndexed: opts.maxPresetsIndexed,
+        });
+        warnings.push(...idx.warnings);
+        local = rankCorpus(query, buildCorpus(idx.presets), rankOpts);
+    }
+    const bestScore = Math.max(builtIn[0]?.score ?? 0, local[0]?.score ?? 0);
+    const coverage = coverageOf(bestScore);
+    const result = { query, builtIn, local, bestScore, coverage, warnings };
+    if (opts.includeDraft ?? true) {
+        const draft = assembleDraft(query);
+        // Emit the draft when it adds something a single top match can't: a gap to
+        // fill (coverage not strong) OR genuine composition (>=2 facets). A single
+        // strongly-covered facet needs no draft — the top match already says it.
+        if (coverage !== "strong" || draft.facets.length >= 2) {
+            result.draft = draft;
+        }
+    }
+    return result;
+}

package/dist/lib/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SERVER_VERSION = "1.1.1";
+export declare const SERVER_VERSION = "1.2.0";
 export type BuildMode = "local" | "released";
 export interface VersionInfo {
     version: string;

package/dist/lib/version.js

@@ -1,5 +1,5 @@
 import { fileURLToPath } from "node:url";
-export const SERVER_VERSION = "1.1.1"; // x-release-please-version
+export const SERVER_VERSION = "1.2.0"; // x-release-please-version
 // "released" = the server is running from a `node_modules/` install (global
 // `npm i -g`, project-local `npm i`, or `npx renovate-mcp`). Anything else —
 // most commonly an MCP config of `{"command": "node", "args": [".../dist/index.js"]}`

package/dist/tools/suggestPresets.d.ts

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

package/dist/tools/suggestPresets.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { suggestPresets } from "../lib/presetSuggester.js";
+import { pathString, queryString } from "../lib/inputLimits.js";
+export function registerSuggestPresets(server) {
+    server.registerTool("suggest_presets", {
+        title: "Suggest Renovate presets from a natural-language intent",
+        description: [
+            "Search Renovate presets by intent — fast, offline, no `renovate` invocation, no network. Given a free-text goal (e.g. \"automerge patch and minor updates and group my dev dependencies\"), it ranks matching presets from the committed built-in catalogue and, optionally, a local presets repo you point at. When no strong match exists it also sketches an unvalidated draft config from recognized intent.",
+            "",
+            "Returns:",
+            "  - `builtIn` / `local`: ranked matches `{ name, namespace, description, score, matchedOn, body? }`. Scoring is lexical (field-weighted name>namespace>description>body, with IDF rarity weighting so ubiquitous tokens like \"group\" don't drown specific matches) — a recall aid, not a stemmed search engine.",
+            "  - `coverage` (strong | partial | weak) + `bestScore`: how well the best existing preset covers the intent.",
+            "  - `draft` (only when coverage is not strong, unless `includeDraft:false`): `{ config, unvalidated:true, hint, facets, notes }`. `config` is a pasteable Renovate config assembled from a small curated facet taxonomy.",
+            "",
+            "This tool never validates the draft (that would require the Renovate CLI). Pass `draft.config` to `validate_config`, then `lint_config`, before adopting it — and fetch `renovate://preset/{name}` for a matched preset's full expanded body.",
+        ].join("\n"),
+        inputSchema: {
+            query: queryString("The intent to search for, in natural language (e.g. \"automerge patch updates and group dev dependencies\")."),
+            presetsPath: pathString("Absolute path to a local presets repo to index alongside the built-in catalogue (flat *.json / *.json5 files, one preset per file). Optional.").optional(),
+            namespace: z
+                .string()
+                .max(128)
+                .optional()
+                .describe("Restrict matches to a single namespace (e.g. \"config\", \"group\", \"schedule\"; \"local\" for local-repo presets)."),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(100)
+                .optional()
+                .describe("Max number of matches returned per corpus (default 10)."),
+            minScore: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe("Drop matches scoring below this 0..1 threshold (default 0.12)."),
+            includeBody: z
+                .boolean()
+                .optional()
+                .describe("Inline each matched preset's full body (default false). When false, fetch renovate://preset/{name} for a body."),
+            includeDraft: z
+                .boolean()
+                .optional()
+                .describe("Emit a draft skeleton when coverage is not strong (default true). Set false for discovery-only results."),
+            maxFilesIndexed: z
+                .number()
+                .int()
+                .positive()
+                .max(100_000)
+                .optional()
+                .describe("Safety cap on preset files scanned in presetsPath (default 2000)."),
+            maxPresetsIndexed: z
+                .number()
+                .int()
+                .positive()
+                .max(100_000)
+                .optional()
+                .describe("Safety cap on presets indexed from presetsPath (default 500)."),
+        },
+    }, async ({ query, presetsPath, namespace, limit, minScore, includeBody, includeDraft, maxFilesIndexed, maxPresetsIndexed, }) => {
+        try {
+            const result = await suggestPresets(query, {
+                presetsPath,
+                namespace,
+                limit,
+                minScore,
+                includeBody,
+                includeDraft,
+                maxFilesIndexed,
+                maxPresetsIndexed,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `suggest_presets failed: ${err.message}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "renovate-mcp",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "MCP server for designing Renovate configurations interactively.",
   "type": "module",
   "bin": {