phpstan-mcp-mx 0.8.0 → 0.10.0

package/dist/tools.js

@@ -1,103 +1,7 @@
-import { z } from 'zod';
-import { BaselineError, describeIncludedBaseline, renderBaseline, summariseBaseline } from './baseline.js';
-import { DEFAULT_BASE, GitError, changedPhpFiles } from './changed.js';
-import { PhpstanError, analyse, clearResultCache, diagnose, generateBaseline, loadDefaultMemoryLimit, loadMaxParallel, } from './phpstan.js';
-import { DEFAULT_LIMIT, MAX_LIMIT, buildReport, displayPath, renderReport } from './report.js';
-import { ProjectError, discoverProjects, resolveNewWithin, resolveProject, resolveWithin } from './project.js';
-import { TmpDirError, loadTmpDirMode } from './tmpdir.js';
-import { ROOTS_ENV_VAR } from './roots.js';
-import { VERSION } from './version.js';
-/** Env-variabele die schrijvende tools vrijgeeft. */
-export const WRITES_ENV_VAR = 'PHPSTAN_MCP_ALLOW_WRITES';
-/**
- * Of schrijvende tools geregistreerd mogen worden. Alleen "1" en "true" tellen; al
- * het andere staat uit. Dat faalt de veilige kant op: een typfout laat schrijven
- * uit, en de opstartregel zegt wat er geldt.
- *
- * Niet registreren en niet weigeren-bij-de-aanroep: een tool die bestaat maar altijd
- * nee zegt, kost het model een ronde en context om dat te ontdekken.
- */
-export function writesAllowed(env = process.env) {
-    const configured = env[WRITES_ENV_VAR]?.trim().toLowerCase();
-    return configured === '1' || configured === 'true';
-}
-/**
- * Nullable veld als `anyOf` in plaats van `type: [..., "null"]`. Zod's `.nullable()`
- * levert de array-vorm op; die is geldig JSON Schema, maar meerdere MCP-clients
- * lezen `type` als één string en laten de constraint dan vallen of weigeren de tool.
- *
- * Let op de `z.literal(null)`: zod vouwt zowel `.nullable()` als een union met
- * `z.null()` terug naar diezelfde array-vorm. Alleen de literal levert echt `anyOf`
- * op (met een overbodige maar onschadelijke `const: null` erbij).
- */
-function nullable(schema) {
-    return z.union([schema, z.literal(null)]);
-}
-const projectArgument = z
-    .string()
-    .describe('Absoluut pad naar de projectroot, zoals list_projects het teruggeeft');
-const analysisShape = {
-    project: z.string(),
-    totals: z.object({ fileErrors: z.number(), generalErrors: z.number() }),
-    generalErrors: z
-        .array(z.string())
-        .describe('Fouten die niet aan een bestand hangen, zoals een crash of configuratiefout'),
-    warnings: z
-        .array(z.string())
-        .describe('Wat PHPStan naast het resultaat meldde. Staat hier "Result is incomplete", dan ' +
-        'dekt de analyse niet het hele project en is een schone uitslag geen bewijs'),
-    notices: z
-        .array(z.string())
-        .describe('Meldingen van deze server zelf, zoals een baseline die meedoet — dan rapporteert ' +
-        'PHPStan alleen wat er nieuw bij komt'),
-    omitted: z
-        .object({ warnings: z.number(), generalErrors: z.number() })
-        .describe('Hoeveel meldingen weggelaten zijn omdat het er te veel waren'),
-    summary: z
-        .object({
-        filesWithFindings: z.number(),
-        byFile: z.array(z.object({ file: z.string(), count: z.number() })),
-        byIdentifier: z.array(z.object({ identifier: z.string(), count: z.number() })),
-    })
-        .describe('Tellingen over álle bevindingen, ook die buiten deze pagina vallen'),
-    findings: z.array(z.object({
-        file: z.string().describe('Pad relatief aan de projectroot'),
-        line: nullable(z.number()),
-        message: z.string(),
-        identifier: nullable(z.string()),
-        tip: nullable(z.string()),
-    })),
-    page: z
-        .object({
-        offset: z.number(),
-        limit: z.number(),
-        returned: z.number(),
-        total: z.number(),
-        hasMore: z.boolean(),
-    })
-        .describe('Welk deel van de bevindingen dit antwoord bevat'),
-    filter: nullable(z.array(z.string())).describe('Op welke identifiers deze pagina beperkt is, of null als er niet gefilterd is'),
-};
-const configArgument = z
-    .string()
-    .optional()
-    .describe('Ander configbestand dan PHPStan zelf zou pakken, bijv. "phpstan-strict.neon". ' +
-    'Moet binnen het project liggen');
-const windowShape = {
-    identifiers: z
-        .array(z.string())
-        .optional()
-        .describe('Beperk de bevindingen tot deze identifiers, bijv. ["argument.type"]. ' +
-        '"missingType" matcht de hele groep. De samenvatting blijft over alles tellen'),
-    offset: z.number().int().min(0).optional().describe('Sla de eerste N bevindingen over'),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(MAX_LIMIT)
-        .optional()
-        .describe(`Hoeveel bevindingen dit antwoord bevat (standaard ${String(DEFAULT_LIMIT)})`),
-};
+import { registerAnalyseChanged, registerAnalyseFile, registerAnalyseProject, } from './tools/analysis.js';
+import { registerBaselineSummary, registerDiagnose, registerListProjects, registerServerConfig, } from './tools/inspect.js';
+import { registerPrompts } from './tools/prompts.js';
+import { registerClearResultCache, registerGenerateBaseline, writesAllowed, } from './tools/writes.js';
 /** Hangt alle tools aan de server. */
 export function registerTools(server, roots) {
     registerListProjects(server, roots);
@@ -112,575 +16,4 @@ export function registerTools(server, roots) {
         registerGenerateBaseline(server, roots);
     registerPrompts(server);
 }
-function registerBaselineSummary(server, roots) {
-    server.registerTool('baseline_summary', {
-        title: 'Baseline samenvatten',
-        description: 'Leest de phpstan-baseline*.neon van een project en telt wat er genegeerd wordt, ' +
-            'per identifier en per bestand. Draait geen analyse. Let op: wat hier in staat is ' +
-            'precies wat analyse_project NIET meldt — een project dat zijn baseline includet, ' +
-            'rapporteert alleen de fouten die er nieuw bij komen.',
-        inputSchema: { project: projectArgument },
-        outputSchema: {
-            project: z.string(),
-            files: z.array(z.object({ file: z.string(), entries: z.number(), errors: z.number() })),
-            totals: z.object({ entries: z.number(), errors: z.number() }),
-            byIdentifier: z.array(z.object({ identifier: z.string(), count: z.number() })),
-            byPath: z.array(z.object({ path: z.string(), count: z.number() })),
-        },
-        annotations: readOnly(),
-    }, ({ project }) => {
-        try {
-            const summary = summariseBaseline(resolveProject(project, roots));
-            return {
-                content: [{ type: 'text', text: renderBaseline(summary) }],
-                structuredContent: { ...summary },
-            };
-        }
-        catch (error) {
-            return toFailure(error);
-        }
-    });
-}
-function registerDiagnose(server, roots) {
-    server.registerTool('diagnose_project', {
-        title: 'PHPStan-opstelling opvragen',
-        description: 'Vraagt PHPStan zelf om zijn opstelling in dit project: PHP- en PHPStan-versie, de ' +
-            'configs die Composer-pakketten meebrengen (zoals Larastan) en of de turbo-extensie ' +
-            'aanstaat. Draait geen analyse. Gebruik dit als een project zich anders gedraagt dan ' +
-            'een ander project, vóórdat je aan de code gaat twijfelen.',
-        inputSchema: {
-            project: projectArgument,
-            timeoutSeconds: z.number().int().positive().max(1800).optional(),
-        },
-        outputSchema: {
-            project: z.string(),
-            output: z.string().describe('PHPStans eigen tekst, ongewijzigd'),
-        },
-        annotations: readOnly(),
-    }, async (args, extra) => {
-        try {
-            const resolved = resolveProject(args.project, roots);
-            const diagnosis = await diagnose(resolved, {
-                ...(args.timeoutSeconds === undefined ? {} : { timeoutMs: args.timeoutSeconds * 1000 }),
-                signal: extra.signal,
-            });
-            return {
-                content: [{ type: 'text', text: diagnosis.output }],
-                structuredContent: { ...diagnosis },
-            };
-        }
-        catch (error) {
-            return toFailure(error);
-        }
-    });
-}
-/**
- * Eén prompt met het werkpatroon. Er zijn zes tools waarvan drie op elkaar lijken;
- * zonder dit moet het model de juiste volgorde uit de losse beschrijvingen
- * reconstrueren, en dan is `analyse_project` op een groot project de eerste gok.
- */
-function registerServerConfig(server, roots) {
-    server.registerTool('server_config', {
-        title: 'Instellingen van deze server',
-        description: 'Geeft de instellingen terug waarmee deze server draait: welke projectmappen binnen ' +
-            'bereik liggen, de standaard geheugenlimiet, hoeveel analyses er tegelijk mogen, waar ' +
-            'de tijdelijke bestanden heen gaan en of schrijvende tools aanstaan. Gebruik dit als ' +
-            'iets geweigerd wordt of trager gaat dan verwacht, vóórdat je aan het project twijfelt.',
-        inputSchema: {},
-        outputSchema: {
-            version: z.string(),
-            roots: z.array(z.object({
-                raw: z.string().describe('Zoals opgegeven in de env-variabele'),
-                path: nullable(z.string()).describe('Het geresolvede pad, of null als de root onbruikbaar is'),
-                problem: nullable(z.string()),
-            })),
-            memoryLimit: nullable(z.string()).describe('Standaard --memory-limit, of null als die niet gezet is'),
-            maxParallel: nullable(z.number()).describe('Hoeveel analyses tegelijk; null als de waarde geweigerd is'),
-            tmpDir: nullable(z.string()).describe('"project" of "shared"'),
-            writesAllowed: z.boolean().describe('Of generate_baseline geregistreerd is'),
-            problems: z
-                .array(z.string())
-                .describe('Instellingen die geweigerd zijn; die velden staan dan op null'),
-        },
-        annotations: readOnly(),
-    }, () => {
-        // Elke waarde apart uitlezen: de loaders weigeren een onbruikbare waarde met
-        // een uitleg, en juist die uitleg is hier het antwoord. Eén mislukte
-        // instelling mag de rest niet onzichtbaar maken.
-        const problems = [];
-        const config = {
-            version: VERSION,
-            roots: roots.map((root) => ({ raw: root.raw, path: root.path, problem: root.problem })),
-            memoryLimit: setting(() => loadDefaultMemoryLimit() ?? null, problems),
-            maxParallel: setting(() => loadMaxParallel(), problems),
-            tmpDir: setting(() => loadTmpDirMode(), problems),
-            writesAllowed: writesAllowed(),
-            problems,
-        };
-        return {
-            content: [{ type: 'text', text: renderConfig(config) }],
-            structuredContent: { ...config },
-        };
-    });
-}
-/**
- * Leest één instelling en vangt een geweigerde waarde op als melding in plaats van
- * als exception. Bewust geen doorgeefluik naar process.env: in diezelfde omgeving
- * zitten tokens en van alles, en die horen niet in een toolantwoord.
- */
-function setting(read, problems) {
-    try {
-        return read();
-    }
-    catch (error) {
-        problems.push(error instanceof Error ? error.message : String(error));
-        return null;
-    }
-}
-function renderConfig(config) {
-    const lines = [`phpstan-mcp ${config.version}`, '', 'Projectmappen:'];
-    if (config.roots.length === 0) {
-        lines.push(`  (geen; zet ${ROOTS_ENV_VAR})`);
-    }
-    else {
-        for (const root of config.roots) {
-            lines.push(`  ${root.path ?? root.raw}${root.problem === null ? '' : `  — ${root.problem}`}`);
-        }
-    }
-    lines.push('', `Geheugenlimiet:      ${config.memoryLimit ?? 'niet gezet (die van PHP zelf)'}`, `Tegelijk:            ${config.maxParallel === null ? 'onbekend' : String(config.maxParallel)}`, `Tijdelijke map:      ${config.tmpDir === null ? 'onbekend' : config.tmpDir}`, `Schrijvende tools:   ${config.writesAllowed ? 'aan (generate_baseline bestaat)' : 'uit'}`);
-    if (config.problems.length > 0) {
-        lines.push('', 'Geweigerde instellingen:');
-        for (const problem of config.problems)
-            lines.push(`- ${problem}`);
-    }
-    return lines.join('\n');
-}
-function registerClearResultCache(server, roots) {
-    server.registerTool('clear_result_cache', {
-        title: 'Resultcache legen',
-        description: 'Leegt PHPStans resultcache, zodat de volgende analyse alles opnieuw doorrekent. ' +
-            'Gebruik dit als een uitslag niet klopt met de code — bijvoorbeeld na een wijziging ' +
-            'aan een extensie of een geïncludeerde config. Let op: die cache ligt standaard niet ' +
-            'in het project maar in de tijdelijke map van het systeem, en wordt dan gedeeld met ' +
-            'elk ander project dat geen eigen tmpDir zet. Het antwoord noemt de map die geleegd is.',
-        inputSchema: {
-            project: projectArgument,
-            config: configArgument,
-            timeoutSeconds: z.number().int().positive().max(1800).optional(),
-        },
-        outputSchema: { project: z.string(), output: z.string() },
-        annotations: clears(),
-    }, async (args, extra) => {
-        try {
-            const resolved = resolveProject(args.project, roots);
-            const cleared = await clearResultCache(resolved, {
-                ...(args.config === undefined ? {} : { config: resolveWithin(resolved, args.config) }),
-                ...(args.timeoutSeconds === undefined ? {} : { timeoutMs: args.timeoutSeconds * 1000 }),
-                signal: extra.signal,
-            });
-            return {
-                content: [{ type: 'text', text: cleared.output }],
-                structuredContent: { ...cleared },
-            };
-        }
-        catch (error) {
-            return toFailure(error);
-        }
-    });
-}
-/** Standaardnaam, dezelfde die PHPStan zelf gebruikt. */
-const DEFAULT_BASELINE = 'phpstan-baseline.neon';
-function registerGenerateBaseline(server, roots) {
-    server.registerTool('generate_baseline', {
-        title: 'Baseline genereren',
-        description: 'Zet alle huidige fouten in een baseline-bestand, zodat een volgende analyse alleen ' +
-            'meldt wat er nieuw bij komt. Bedoeld om een bestaand project onder PHPStan te ' +
-            'krijgen, niet om fouten weg te werken: wat hierin komt, wordt daarna niet meer ' +
-            'gemeld. Overschrijft een bestaande baseline. Het bestand moet nog wel in de config ' +
-            'geïncludeerd worden voordat het effect heeft.',
-        inputSchema: {
-            project: projectArgument,
-            file: z
-                .string()
-                .optional()
-                .describe(`Doelbestand binnen het project (standaard ${DEFAULT_BASELINE})`),
-            paths: z.array(z.string()).optional().describe('Paden binnen het project'),
-            level: z.string().optional().describe('Level-override, 0 t/m 10 of "max"'),
-            config: configArgument,
-            allowEmpty: z
-                .boolean()
-                .optional()
-                .describe('Ook schrijven als er niets te negeren valt; anders weigert PHPStan'),
-            memoryLimit: z.string().optional(),
-            timeoutSeconds: z.number().int().positive().max(1800).optional(),
-        },
-        outputSchema: {
-            project: z.string(),
-            file: z.string(),
-            errors: z.number().describe('Hoeveel fouten er in de baseline gezet zijn'),
-            output: z.string(),
-        },
-        annotations: writes(),
-    }, async (args, extra) => {
-        try {
-            const resolved = resolveProject(args.project, roots);
-            const generated = await generateBaseline(resolved, {
-                file: resolveNewWithin(resolved, args.file ?? DEFAULT_BASELINE),
-                ...(args.paths === undefined
-                    ? {}
-                    : { paths: args.paths.map((path) => resolveWithin(resolved, path)) }),
-                ...(args.allowEmpty === undefined ? {} : { allowEmpty: args.allowEmpty }),
-                ...common(resolved, args),
-                signal: extra.signal,
-            });
-            return {
-                content: [{ type: 'text', text: renderGenerated(resolved, generated) }],
-                structuredContent: { ...generated },
-            };
-        }
-        catch (error) {
-            return toFailure(error);
-        }
-    });
-}
-/** De uitkomst plus wat er nog moet gebeuren voordat de baseline iets doet. */
-function renderGenerated(project, generated) {
-    const naam = displayPath(project.path, generated.file);
-    return [
-        `${String(generated.errors)} fout(en) in ${naam} gezet.`,
-        '',
-        `Deze fouten worden vanaf nu niet meer gemeld zodra ${naam} in de configuratie staat:`,
-        '',
-        'includes:',
-        `    - ${naam}`,
-    ].join('\n');
-}
-function registerPrompts(server) {
-    server.registerPrompt('phpstan_wijziging_nakijken', {
-        title: 'Eigen wijziging nakijken met PHPStan',
-        description: 'Het werkpatroon om je eigen wijziging na te kijken zonder het hele project door te rekenen.',
-        argsSchema: {
-            project: z
-                .string()
-                .optional()
-                .describe('Absoluut pad naar de projectroot; laat leeg om eerst list_projects te doen'),
-        },
-    }, ({ project }) => ({
-        messages: [
-            {
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: [
-                        project === undefined || project === ''
-                            ? 'Roep eerst `list_projects` aan en kies het project waar ik in werk.'
-                            : `Werk in het project ${project}.`,
-                        '',
-                        'Ga daarna zo te werk:',
-                        '1. `analyse_changed` met dat project — dat pakt alleen wat git gewijzigd heeft,',
-                        '   inclusief bestanden die nog niet toegevoegd zijn. Doe dit ook als het project',
-                        '   groot is; `analyse_project` zonder paden rekent alles door.',
-                        '2. Staat er "LET OP" of "Ter info" boven het rapport, lees dat eerst: een',
-                        '   onvolledige analyse of een baseline die meedoet maakt een schone uitslag',
-                        '   onbetrouwbaar.',
-                        '3. Repareer de bevindingen bij de bron. Verzwak geen types naar `mixed` en voeg',
-                        '   niets aan de baseline toe.',
-                        '4. Draai `analyse_changed` opnieuw tot het schoon is. Blijven er veel',
-                        '   bevindingen van één soort over, gebruik dan `identifiers` om er per soort',
-                        '   door te lopen.',
-                        '',
-                        'Gedraagt het project zich onverklaarbaar, draai dan `diagnose_project` voordat',
-                        'je aan de code twijfelt.',
-                    ].join('\n'),
-                },
-            },
-        ],
-    }));
-}
-function registerListProjects(server, roots) {
-    server.registerTool('list_projects', {
-        title: 'PHP-projecten opsommen',
-        description: 'Somt de PHP-projecten op die deze server mag analyseren, met per project of ' +
-            'PHPStan geïnstalleerd is en welk configbestand er ligt. Gebruik het `path` uit ' +
-            'het resultaat als `project`-argument voor de andere tools.',
-        inputSchema: {},
-        outputSchema: {
-            projects: z.array(z.object({
-                path: z.string(),
-                root: z.string(),
-                hasPhpstan: z.boolean(),
-                config: nullable(z.string()),
-                hasGit: z.boolean().describe('Of analyse_changed hier bruikbaar is'),
-            })),
-            problems: z.array(z.object({ root: z.string(), problem: z.string() })),
-        },
-        annotations: readOnly(),
-    }, () => {
-        if (roots.length === 0) {
-            return failure(`Er zijn geen projectmappen geconfigureerd. Zet ${ROOTS_ENV_VAR} in de ` +
-                'MCP-serverconfiguratie op de absolute paden die geanalyseerd mogen worden, ' +
-                'gescheiden door een dubbele punt.');
-        }
-        const projects = discoverProjects(roots);
-        const problems = roots
-            .filter((root) => root.problem !== null)
-            .map((root) => ({ root: root.raw, problem: root.problem }));
-        return {
-            content: [{ type: 'text', text: renderProjects(projects, problems) }],
-            structuredContent: { projects, problems },
-        };
-    });
-}
-function registerAnalyseProject(server, roots) {
-    server.registerTool('analyse_project', {
-        title: 'Project analyseren',
-        description: 'Draait PHPStan over (een deel van) een project en geeft de bevindingen terug. ' +
-            'Zonder `paths` wordt geanalyseerd wat in phpstan.neon staat.',
-        inputSchema: {
-            project: projectArgument,
-            paths: z
-                .array(z.string())
-                .optional()
-                .describe('Paden binnen het project; leeg betekent: volg de configuratie'),
-            level: z.string().optional().describe('Level-override, 0 t/m 10 of "max"'),
-            config: configArgument,
-            memoryLimit: z
-                .string()
-                .optional()
-                .describe('Bijv. "1G", als PHPStan op de PHP-limiet klapt; overrulet de serverstandaard'),
-            timeoutSeconds: z.number().int().positive().max(1800).optional(),
-            ...windowShape,
-        },
-        outputSchema: analysisShape,
-        annotations: readOnly(),
-    }, async (args, extra) => runAnalysis(roots, args.project, (resolved) => ({
-        options: {
-            // Elk pad door resolveWithin, ook al komt het rechtstreeks uit de
-            // aanroep. Ongefilterd doorgeven was op twee manieren mis: een pad
-            // buiten het project liet PHPStan bestanden lezen waar de whitelist
-            // juist over gaat, en een "pad" als --generate-baseline=x werd door
-            // PHPStan als vlag gelezen en schreef dat bestand echt weg
-            // (nagemeten). Na resolveWithin is elk pad absoluut en bestaat het,
-            // dus het kan geen vlag meer zijn.
-            ...(args.paths === undefined
-                ? {}
-                : { paths: args.paths.map((path) => resolveWithin(resolved, path)) }),
-            ...common(resolved, args),
-        },
-    }), window(args), extra.signal));
-}
-function registerAnalyseChanged(server, roots) {
-    server.registerTool('analyse_changed', {
-        title: 'Gewijzigde bestanden analyseren',
-        description: 'Draait PHPStan over de PHP-bestanden die in dit project gewijzigd zijn volgens git, ' +
-            'inclusief bestanden die nog niet toegevoegd zijn. Bedoeld om te zien of een eigen ' +
-            'wijziging fouten oplevert, zonder het hele project door te rekenen. Vergelijkt ' +
-            `standaard met ${DEFAULT_BASE}; geef \`base\` mee (bijv. "main") voor de hele branch.`,
-        inputSchema: {
-            project: projectArgument,
-            base: z
-                .string()
-                .optional()
-                .describe(`Commit, branch of tag om tegen te vergelijken (standaard ${DEFAULT_BASE})`),
-            staged: z
-                .boolean()
-                .optional()
-                .describe('Alleen wat gestaged is (git diff --cached), voor een check vóór een commit'),
-            level: z.string().optional().describe('Level-override, 0 t/m 10 of "max"'),
-            config: configArgument,
-            memoryLimit: z.string().optional(),
-            timeoutSeconds: z.number().int().positive().max(1800).optional(),
-            ...windowShape,
-        },
-        outputSchema: analysisShape,
-        annotations: readOnly(),
-    }, async (args, extra) => runAnalysis(roots, args.project, async (resolved) => {
-        const changed = await changedPhpFiles(resolved, args.base, args.staged);
-        if (changed.files.length === 0) {
-            return { nothingToDo: describeNothingChanged(changed) };
-        }
-        return {
-            options: { paths: [...changed.files], ...common(resolved, args) },
-            heading: describeChanged(resolved, changed),
-        };
-    }, window(args), extra.signal));
-}
-/** Waarom er niets geanalyseerd is; de overgeslagen paden horen daar bij. */
-function describeNothingChanged(changed) {
-    const wat = changed.staged ? 'gestagede' : 'gewijzigde';
-    const lines = [`Geen ${wat} PHP-bestanden ten opzichte van ${changed.base}.`];
-    if (changed.skipped.length > 0)
-        lines.push('', ...skippedLines(changed));
-    return lines.join('\n');
-}
-/** Wat er geanalyseerd is, zodat zichtbaar is waarop het rapport eronder betrekking heeft. */
-function describeChanged(resolved, changed) {
-    const waar = changed.staged ? 'gestaged ten opzichte van' : 'gewijzigd ten opzichte van';
-    const lines = [
-        `${String(changed.files.length)} PHP-bestand(en) ${waar} ${changed.base}:`,
-        ...changed.files.map((file) => `  ${displayPath(resolved.path, file)}`),
-    ];
-    if (changed.skipped.length > 0)
-        lines.push('', ...skippedLines(changed));
-    return lines.join('\n');
-}
-function skippedLines(changed) {
-    return [
-        'Overgeslagen, dus niet meegenomen in dit rapport:',
-        ...changed.skipped.map((entry) => `  ${entry.path}: ${entry.reason}`),
-    ];
-}
-function registerAnalyseFile(server, roots) {
-    server.registerTool('analyse_file', {
-        title: 'Bestand of map analyseren',
-        description: 'Draait PHPStan over één bestand of map binnen een project. Het pad mag relatief ' +
-            'aan de projectroot zijn of absoluut, maar moet binnen het project liggen.',
-        inputSchema: {
-            project: projectArgument,
-            path: z.string().describe('Bestand of map binnen het project, bijv. "app/Models/User.php"'),
-            level: z.string().optional().describe('Level-override, 0 t/m 10 of "max"'),
-            config: configArgument,
-            memoryLimit: z.string().optional(),
-            timeoutSeconds: z.number().int().positive().max(1800).optional(),
-            ...windowShape,
-        },
-        outputSchema: analysisShape,
-        annotations: readOnly(),
-    }, async (args, extra) => runAnalysis(roots, args.project, (resolved) => ({
-        options: {
-            paths: [resolveWithin(resolved, args.path)],
-            ...common(resolved, args),
-        },
-    }), window(args), extra.signal));
-}
-/**
- * Zet de gedeelde argumenten om in AnalyseOptions. `config` gaat door resolveWithin:
- * een neon mag `bootstrapFiles` en extensies bevatten, dus een vrij te kiezen
- * configpad zou anders een route zijn om willekeurige PHP-code te laten uitvoeren —
- * langs de whitelist heen die `project` juist wél afdwingt.
- */
-function common(resolved, args) {
-    return {
-        ...(args.level === undefined ? {} : { level: args.level }),
-        ...(args.config === undefined ? {} : { config: resolveWithin(resolved, args.config) }),
-        ...(args.memoryLimit === undefined ? {} : { memoryLimit: args.memoryLimit }),
-        ...(args.timeoutSeconds === undefined ? {} : { timeoutMs: args.timeoutSeconds * 1000 }),
-    };
-}
-function window(args) {
-    return {
-        offset: args.offset,
-        limit: args.limit,
-        ...(args.identifiers === undefined ? {} : { identifiers: args.identifiers }),
-    };
-}
-/**
- * Resolvet het project één keer en geeft het aan `plan`, zodat een tool die zelf nog
- * paden binnen dat project moet valideren dat op hetzelfde geresolvede project doet.
- * Eerder resolveerde analyse_file het project en deed runAnalysis dat daarna nog
- * een keer.
- */
-async function runAnalysis(roots, project, plan, window, signal) {
-    try {
-        const resolved = resolveProject(project, roots);
-        const chosen = await plan(resolved);
-        if ('nothingToDo' in chosen) {
-            // Toch het volledige rapportschema teruggeven: een client die op
-            // structuredContent vertrouwt moet niet ineens een ander soort antwoord
-            // krijgen omdat er niets te doen was.
-            const empty = buildReport({
-                project: resolved.path,
-                findings: [],
-                generalErrors: [],
-                warnings: [],
-                totals: { fileErrors: 0, generalErrors: 0 },
-            }, {});
-            return {
-                content: [{ type: 'text', text: chosen.nothingToDo }],
-                structuredContent: { ...empty },
-            };
-        }
-        // Het signaal komt uit het MCP-verzoek zelf: annuleert de client, dan wordt de
-        // procesgroep opgeruimd in plaats van dat PHPStan doorrekent voor niemand.
-        const result = await analyse(resolved, {
-            ...chosen.options,
-            ...(signal === undefined ? {} : { signal }),
-        });
-        const report = buildReport(result, window, collectNotices(resolved));
-        const heading = chosen.heading === undefined ? '' : `${chosen.heading}\n\n`;
-        return {
-            content: [{ type: 'text', text: heading + renderReport(report) }],
-            structuredContent: { ...report },
-        };
-    }
-    catch (error) {
-        return toFailure(error);
-    }
-}
-/**
- * Wat deze server zelf bij een analyse te melden heeft. Nu alleen de baseline: doet
- * die mee, dan rapporteert PHPStan alleen wat er nieuw bij komt, en dan is een
- * schone uitslag geen schone code. Dat staat in de toolbeschrijving, maar niet in
- * het antwoord waar het model naar kijkt.
- */
-function collectNotices(project) {
-    const baseline = describeIncludedBaseline(project);
-    return baseline === null ? [] : [baseline];
-}
-function renderProjects(projects, problems) {
-    const lines = [];
-    if (projects.length === 0) {
-        lines.push('Geen PHP-projecten gevonden onder de geconfigureerde mappen.');
-    }
-    else {
-        lines.push(`${projects.length} project(en):`);
-        for (const project of projects) {
-            const config = project.config ?? 'geen config';
-            const phpstan = project.hasPhpstan ? 'phpstan aanwezig' : 'phpstan NIET geïnstalleerd';
-            const git = project.hasGit ? 'git' : 'geen git';
-            lines.push(`- ${project.path} (${phpstan}, ${config}, ${git})`);
-        }
-    }
-    if (problems.length > 0) {
-        lines.push('', 'Overgeslagen regels uit de configuratie:');
-        for (const problem of problems)
-            lines.push(`- ${problem.root}: ${problem.problem}`);
-    }
-    return lines.join('\n');
-}
-/**
- * Analyseren verandert de broncode niet. PHPStan schrijft wel zijn resultcache weg,
- * maar dat is geen wijziging waar de gebruiker iets van merkt.
- */
-function readOnly() {
-    return { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-}
-/**
- * Verandert wel iets, maar niet aan de broncode. `idempotentHint` staat aan omdat
- * twee keer legen hetzelfde oplevert; `destructiveHint` omdat er data weggaat die
- * PHPStan daarna opnieuw moet opbouwen.
- */
-function clears() {
-    return { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false };
-}
-/**
- * Schrijft een bestand in het project. Niet idempotent: draai je het opnieuw nadat
- * er fouten bij zijn gekomen, dan staat er iets anders in.
- */
-function writes() {
-    return { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
-}
-function toFailure(error) {
-    if (error instanceof ProjectError ||
-        error instanceof PhpstanError ||
-        error instanceof BaselineError ||
-        error instanceof GitError ||
-        error instanceof TmpDirError) {
-        return failure(error.message);
-    }
-    throw error;
-}
-function failure(text) {
-    return { isError: true, content: [{ type: 'text', text }] };
-}
 //# sourceMappingURL=tools.js.map