pr-checkmate 3.2.3 → 4.0.0

package/dist/esm/mcp/config-tools.js

@@ -0,0 +1,310 @@
+/**
+ * Setting pr-checkmate up for one specific repository, by the agent that is
+ * already sitting in it.
+ *
+ * The slow part of adopting a gate is not turning it on; it is deciding what to do
+ * about the findings an existing codebase already has. The documented answer is a
+ * strict workflow with a permissive config, then promoting checks one at a time as
+ * they go clean. That is a procedure an agent can carry out — if it can see the
+ * baseline — so these tools hand it exactly that: what the repository looks like,
+ * what it fails today, and a config that makes the gate real from day one without
+ * turning the first run into three thousand red lines.
+ *
+ * Nothing here writes except `write_config`, and that one validates first, merges
+ * over what is already there, and never replaces a value the user chose.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { IGNORED_DIRS } from '../config/constants.js';
+import { loadProjectConfig } from '../config/loader.js';
+import { suggestName } from '../core/checks/quality/config-validation.js';
+import { REGISTRY } from '../core/registry.js';
+import { detectLanguageUsage } from '../utils/detect-language.js';
+import { findOwnPackageRoot } from '../utils/own-deps.js';
+import { review } from './review.js';
+const CONFIG_FILE = 'pr-checkmate.json';
+const LEVELS = new Set(['error', 'warn', 'off']);
+const FAIL_ON = new Set(['error', 'warn', 'never']);
+/** Directories that hold code nobody on the team wrote by hand. Not in the default ignore list. */
+const GENERATED_DIRS = ['generated', '__generated__', 'vendor', 'third_party', 'third-party'];
+/**
+ * Checks whose failure is never "existing debt". A conflict marker is a file that
+ * does not run; a leaked secret is already exposed. Proposing `warn` for these
+ * would make the gate quietly agree to ship them, so they are reported as things
+ * to fix, and left blocking.
+ */
+const NEVER_DOWNGRADE = new Set(['Merge Conflict', 'Security Scan']);
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** The schema shipped with the package, or `undefined` when this install does not carry it. */
+function loadSchema() {
+    const root = findOwnPackageRoot();
+    if (!root)
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(path.join(root, 'pr-checkmate.schema.json'), 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveRef(node, schema) {
+    const ref = node.$ref?.replace('#/$defs/', '');
+    return ref && schema.$defs?.[ref] ? { ...schema.$defs[ref], ...node, $ref: undefined } : node;
+}
+/** First sentence, so a listing of sixty keys stays a listing. */
+const firstSentence = (text = '') => {
+    const cut = text.search(/(?<=[.!?])\s/);
+    return (cut === -1 ? text : text.slice(0, cut)).slice(0, 200);
+};
+/** What a key means, from the schema that ships with the package. */
+export function explainConfig(key) {
+    const schema = loadSchema();
+    if (!schema?.properties) {
+        return { text: 'The configuration schema is not available in this install.', isError: true };
+    }
+    if (!key) {
+        const rows = Object.entries(schema.properties)
+            .filter(([name]) => name !== '$schema')
+            .map(([name, node]) => {
+            const resolved = resolveRef(node, schema);
+            return `- ${name}${resolved.description ? ` — ${firstSentence(resolved.description)}` : ''}`;
+        });
+        return {
+            text: `Keys of ${CONFIG_FILE} (pass one as "key" for details; nested keys use dots, e.g. "prSize.maxLines"):\n${rows.join('\n')}`,
+        };
+    }
+    let node = schema;
+    for (const part of key.split('.')) {
+        node = node?.properties?.[part] ? resolveRef(node.properties[part], schema) : undefined;
+        if (!node)
+            break;
+    }
+    if (!node) {
+        const near = suggestName(key.split('.')[0], Object.keys(schema.properties));
+        return {
+            text: `No such key "${key}".${near ? ` Did you mean "${near}"?` : ''}`,
+            isError: true,
+        };
+    }
+    const lines = [`${key}${node.type ? ` (${node.type})` : ''}`];
+    if (node.description)
+        lines.push(node.description);
+    if (node.default !== undefined)
+        lines.push(`default: ${JSON.stringify(node.default)}`);
+    if (node.enum)
+        lines.push(`one of: ${node.enum.map(v => JSON.stringify(v)).join(', ')}`);
+    for (const [name, child] of Object.entries(node.properties ?? {})) {
+        const resolved = resolveRef(child, schema);
+        lines.push(`- ${key}.${name}${resolved.description ? ` — ${firstSentence(resolved.description)}` : ''}`);
+    }
+    return { text: lines.join('\n') };
+}
+/** Problems in a proposed `severity` map: names that are not checks, levels that are not levels. */
+function validateSeverity(severity) {
+    if (severity === undefined)
+        return [];
+    if (!isRecord(severity)) {
+        return ['"severity" must be an object of check name → "error" | "warn" | "off"'];
+    }
+    const problems = [];
+    const names = REGISTRY.map(c => c.name);
+    for (const [check, level] of Object.entries(severity)) {
+        if (!names.includes(check)) {
+            const near = suggestName(check, names);
+            problems.push(`severity: no check named "${check}"${near ? ` — did you mean "${near}"?` : ''}`);
+        }
+        if (typeof level !== 'string' || !LEVELS.has(level)) {
+            problems.push(`severity.${check}: "${String(level)}" is not one of error, warn, off`);
+        }
+    }
+    return problems;
+}
+/** Problems in a proposed config, phrased so the agent can correct them. Empty means it is acceptable. */
+export function validateConfig(config, cwd) {
+    const problems = [];
+    const schema = loadSchema();
+    const known = Object.keys(schema?.properties ?? {});
+    if (known.length > 0) {
+        for (const key of Object.keys(config)) {
+            if (known.includes(key) || key.startsWith('//'))
+                continue;
+            const near = suggestName(key, known);
+            problems.push(`unknown key "${key}"${near ? ` — did you mean "${near}"?` : ''}`);
+        }
+    }
+    problems.push(...validateSeverity(config.severity));
+    for (const [key, block] of Object.entries(config)) {
+        if (isRecord(block) && typeof block.failOn === 'string' && !FAIL_ON.has(block.failOn)) {
+            problems.push(`${key}.failOn: "${block.failOn}" is not one of error, warn, never`);
+        }
+    }
+    const sources = config.sourcePath === undefined ? [] : [config.sourcePath].flat();
+    for (const source of sources) {
+        if (typeof source !== 'string' || !fs.existsSync(path.resolve(cwd, source))) {
+            problems.push(`sourcePath: "${String(source)}" does not exist in this repository`);
+        }
+    }
+    return problems;
+}
+/** `{a:{b:1,c:2}}` under `a` → `a.b`, `a.c`: what was added, not just where it hangs. */
+function leafPaths(value, here) {
+    return isRecord(value) && Object.keys(value).length > 0
+        ? Object.entries(value).flatMap(([k, v]) => leafPaths(v, `${here}.${k}`))
+        : [here];
+}
+/**
+ * Merge `incoming` into `existing`. A value that is already set and differs is
+ * kept — the file is the user's — and listed, so the agent can ask rather than
+ * overwrite. Objects merge key by key; arrays and scalars are leaves.
+ */
+function mergeKeepingExisting(existing, incoming, trail, overwrite, report) {
+    const out = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+        const here = [...trail, key].join('.');
+        if (!(key in existing)) {
+            out[key] = value;
+            report.added.push(...leafPaths(value, here));
+        }
+        else if (isRecord(existing[key]) && isRecord(value)) {
+            out[key] = mergeKeepingExisting(existing[key], value, [...trail, key], overwrite, report);
+        }
+        else if (JSON.stringify(existing[key]) === JSON.stringify(value)) {
+            continue;
+        }
+        else if (overwrite) {
+            out[key] = value;
+            report.added.push(`${here} (replaced)`);
+        }
+        else {
+            report.kept.push(here);
+        }
+    }
+    return out;
+}
+/** Validate and write `config` into the repository's `pr-checkmate.json`. */
+export function writeConfig(cwd, config, overwrite) {
+    if (!isRecord(config))
+        return { text: '"config" must be a JSON object.', isError: true };
+    const problems = validateConfig(config, cwd);
+    if (problems.length > 0) {
+        return {
+            text: `Not written — fix these first:\n${problems.map(p => `- ${p}`).join('\n')}`,
+            isError: true,
+        };
+    }
+    const file = path.join(cwd, CONFIG_FILE);
+    let existing = {};
+    if (fs.existsSync(file)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (isRecord(parsed))
+                existing = parsed;
+            else
+                throw new Error('not an object');
+        }
+        catch {
+            // A file we cannot read is a file we must not replace: the user may be mid-edit.
+            return {
+                text: `${CONFIG_FILE} exists but is not valid JSON; fix it by hand first.`,
+                isError: true,
+            };
+        }
+    }
+    const report = { added: [], kept: [] };
+    const merged = mergeKeepingExisting(existing, config, [], overwrite, report);
+    if (report.added.length === 0) {
+        return {
+            text: `Nothing to write: ${CONFIG_FILE} already holds these values.${report.kept.length > 0 ? ` Left as the user set them: ${report.kept.join(', ')} (pass overwrite: true only if they asked for the change).` : ''}`,
+            structured: { written: false, added: [], kept: report.kept },
+        };
+    }
+    // Point editors at the schema when this repository has the package installed:
+    // that line is what makes every other key discoverable by autocomplete.
+    const schemaPath = './node_modules/pr-checkmate/pr-checkmate.schema.json';
+    const withSchema = !('$schema' in merged) && fs.existsSync(path.join(cwd, schemaPath))
+        ? { $schema: schemaPath, ...merged }
+        : merged;
+    fs.writeFileSync(file, `${JSON.stringify(withSchema, null, 2)}\n`);
+    return {
+        text: [
+            `${existing && Object.keys(existing).length > 0 ? 'Updated' : 'Created'} ${CONFIG_FILE}:`,
+            ...report.added.map(k => `  + ${k}`),
+            ...(report.kept.length > 0
+                ? [
+                    `Left as the user set them: ${report.kept.join(', ')} (overwrite: true replaces them — only if asked).`,
+                ]
+                : []),
+        ].join('\n'),
+        structured: { written: true, added: report.added, kept: report.kept },
+    };
+}
+/**
+ * Look at the repository and propose a config.
+ *
+ * The baseline is a whole-repository run of the fast checks. A check that already
+ * fails is proposed as `warn`: the gate is on from the first commit, the existing
+ * debt is visible, and nothing new can slip in unnoticed — then each check is
+ * promoted back to blocking as it reaches zero. Proposing `error` everywhere would
+ * make the first CI run red for reasons nobody on the pull request caused, and the
+ * usual response to that is to switch the whole tool off.
+ */
+export async function suggestConfig(cwd) {
+    const current = loadProjectConfig(cwd);
+    const usage = await detectLanguageUsage(cwd, current.ignoreDirs ?? IGNORED_DIRS, current.detect);
+    const languages = usage.map(u => `${u.lang} (${u.files} file${u.files === 1 ? '' : 's'})`);
+    const hasConfig = fs.existsSync(path.join(cwd, CONFIG_FILE));
+    const proposed = {};
+    const notes = [];
+    const generated = GENERATED_DIRS.filter(d => fs.existsSync(path.join(cwd, d)) && !(current.ignoreDirs ?? IGNORED_DIRS).includes(d));
+    if (generated.length > 0) {
+        proposed.excludePaths = generated.map(d => `${d}/**`);
+        notes.push(`Excluded ${generated.join(', ')}: code nobody maintains by hand only produces findings no one can act on.`);
+    }
+    const baseline = await review({ cwd, scope: 'full' });
+    const severity = {};
+    const skipped = [];
+    for (const r of baseline.report.results) {
+        if (r.status === 'fail' && NEVER_DOWNGRADE.has(r.name)) {
+            notes.push(`${r.name} fails today (${r.details ?? 'findings'}) and is NOT proposed as a warning: fix it${r.name === 'Security Scan' ? ' and rotate whatever was exposed' : ''} instead of silencing it.`);
+        }
+        else if (r.status === 'fail') {
+            severity[r.name] = 'warn';
+            notes.push(`${r.name} fails today (${r.details ?? 'findings'}) → warn, so existing debt does not block every PR. Promote it back to "error" once it is clean.`);
+        }
+        else if (r.status === 'skip' && /tooling unavailable/.test(r.details ?? '')) {
+            skipped.push(r.name);
+        }
+    }
+    if (Object.keys(severity).length > 0)
+        proposed.severity = severity;
+    if (skipped.length > 0) {
+        notes.push(`Could not run ${skipped.join(', ')}: tooling not available here (run "pr-checkmate install" and ask again for a complete baseline).`);
+    }
+    const clean = baseline.report.results.filter(r => r.status === 'pass').length;
+    notes.push(`Baseline: ${clean} check(s) pass, ${baseline.report.summary.failed} fail, ${baseline.report.summary.warned} warn (fast checks only; "verify" adds the slow ones).`);
+    if (hasConfig)
+        notes.push(`${CONFIG_FILE} already exists: write_config keeps every value already set and only adds the rest.`);
+    if (Object.keys(proposed).length === 0) {
+        notes.push('The defaults already fit this repository: no config file is needed. Everything is on and blocking where it should be.');
+    }
+    return { proposed, notes, languages };
+}
+/** `suggest_config` as the text an agent reads. */
+export function formatSuggestion(s) {
+    const body = Object.keys(s.proposed).length > 0
+        ? `\nProposed ${CONFIG_FILE}:\n${JSON.stringify(s.proposed, null, 2)}\n`
+        : '\n';
+    return {
+        text: [
+            `Languages: ${s.languages.join(', ') || 'none detected'}`,
+            ...s.notes.map(n => `- ${n}`),
+            body,
+            Object.keys(s.proposed).length > 0
+                ? 'Show this to the user and, if they agree, call write_config with it. Do not write it unasked.'
+                : '',
+        ]
+            .filter(Boolean)
+            .join('\n'),
+        structured: { languages: s.languages, proposed: s.proposed, notes: s.notes },
+    };
+}

package/dist/esm/mcp/dependency.d.ts

@@ -0,0 +1,33 @@
+export type Ecosystem = 'npm' | 'pypi';
+/**
+ * `avoid`   — do not add it (does not exist, no such version, known serious advisory)
+ * `review`  — a person should look first (new, rarely used, deprecated, install script…)
+ * `ok`      — nothing found
+ * `unknown` — a lookup failed, so nothing can be said
+ */
+export type Verdict = 'avoid' | 'review' | 'ok' | 'unknown';
+export interface DependencyReport {
+    name: string;
+    ecosystem: Ecosystem;
+    version?: string;
+    verdict: Verdict;
+    reasons: string[];
+    facts: Record<string, string | number | boolean>;
+}
+/** The slice of a fetch the checks need; injectable so tests never touch the network. */
+export type FetchJson = (url: string, init?: RequestInit) => Promise<{
+    ok: boolean;
+    status: number;
+    body?: unknown;
+    error?: string;
+}>;
+/** The famous package `name` is suspiciously close to, if any. A name that *is* the famous one is not a match. */
+export declare function lookalikeOf(name: string, ecosystem: Ecosystem): string | undefined;
+/** Is `name` safe to add? Never throws: every failure becomes part of the verdict. */
+export declare function checkDependency(name: string, opts?: {
+    version?: string;
+    ecosystem?: Ecosystem;
+    fetchJson?: FetchJson;
+}): Promise<DependencyReport>;
+/** The report as the text an agent reads. */
+export declare function formatDependency(r: DependencyReport): string;