@mortice/mapwright 0.8.0

package/dist/extractors/typescript.js

@@ -0,0 +1,387 @@
+import ts from "typescript";
+import path from "node:path";
+import { readFileSync } from "node:fs";
+import { parseDocTags } from "./docTags.js";
+import { createExternalPackageId, resolveTypeScriptModuleTarget } from "../catalogue/moduleResolution.js";
+import { truncateEvidenceText } from "../catalogue/evidence.js";
+import { implementationFingerprint, relationshipIdentityId, signatureFingerprint, symbolIdentityId } from "../catalogue/identity.js";
+export function extractTypeScriptSymbols(workspaceRoot, file, packageRecord) {
+    const absolute = path.resolve(workspaceRoot, file.path);
+    const sourceText = readFileSync(absolute, "utf8");
+    const sourceFile = ts.createSourceFile(file.path, sourceText, ts.ScriptTarget.ES2022, true);
+    const symbols = [];
+    const relationships = [];
+    const diagnostics = [];
+    const symbolIdsByName = new Map();
+    const packageId = packageRecord?.id ?? "package:unknown";
+    const modulePath = file.path;
+    const symbolProvenance = file.isGenerated ? "generated_declaration" : "authored_source";
+    const importStatements = [];
+    const exportStatements = [];
+    const pushSymbol = (node, kind, name, exported, parentId, containerPath = "") => {
+        const jsDoc = ts.getJSDocCommentsAndTags(node)
+            .map((n) => n.getText(sourceFile))
+            .join("\n");
+        const parsed = jsDoc ? parseDocTags(jsDoc, file.path) : { summary: "", tags: [], diagnostics: [] };
+        diagnostics.push(...parsed.diagnostics);
+        const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        const nodeText = node.getText(sourceFile);
+        const signature = nodeText.split(/\r?\n/)[0].trim().slice(0, 300);
+        const symbolId = symbolIdentityId({
+            language: file.language,
+            kind,
+            packageId,
+            modulePath,
+            qualifiedContainerPath: containerPath,
+            declaredName: name
+        });
+        const symbol = {
+            id: symbolId,
+            name,
+            qualifiedName: `${file.path}::${name}`,
+            kind,
+            language: file.language,
+            filePath: file.path,
+            packageId,
+            modulePath,
+            qualifiedContainerPath: containerPath,
+            range: {
+                startLine: start.line + 1,
+                startColumn: start.character + 1,
+                endLine: end.line + 1,
+                endColumn: end.character + 1
+            },
+            signature,
+            signatureFingerprint: signatureFingerprint([kind, signature]),
+            implementationFingerprint: implementationFingerprint([kind, nodeText]),
+            canonicalSymbolId: symbolId,
+            duplicateOf: null,
+            symbolProvenance,
+            visibility: exported ? "published" : "private",
+            exported,
+            doc: {
+                present: Boolean(jsDoc),
+                text: parsed.summary,
+                tags: parsed.tags
+            },
+            capabilities: parsed.tags.filter((t) => t.tag === "capability").map((t) => t.value),
+            parents: parentId ? [parentId] : [],
+            children: [],
+            confidence: 0.9,
+            provenance: {
+                source: "typescript-ast",
+                extractors: ["typescript"]
+            }
+        };
+        symbols.push(symbol);
+        const currentIds = symbolIdsByName.get(name) ?? [];
+        currentIds.push(symbolId);
+        symbolIdsByName.set(name, currentIds.sort());
+        file.symbols.push(symbolId);
+        relationships.push({
+            id: relationshipIdentityId({
+                type: "defines",
+                fromKind: "file",
+                fromId: file.path,
+                toKind: "symbol",
+                toId: symbolId,
+                discriminant: null
+            }),
+            type: "defines",
+            from: { kind: "file", id: file.path },
+            to: { kind: "symbol", id: symbolId },
+            confidence: 1,
+            provenance: { source: "typescript-ast" }
+        });
+        if (parentId) {
+            const parent = symbols.find((item) => item.id === parentId);
+            parent?.children.push(symbolId);
+            relationships.push({
+                id: relationshipIdentityId({
+                    type: "contains",
+                    fromKind: "symbol",
+                    fromId: parentId,
+                    toKind: "symbol",
+                    toId: symbolId,
+                    discriminant: null
+                }),
+                type: "contains",
+                from: { kind: "symbol", id: parentId },
+                to: { kind: "symbol", id: symbolId },
+                confidence: 0.95,
+                provenance: { source: "typescript-ast" }
+            });
+        }
+        if (exported) {
+            relationships.push({
+                id: relationshipIdentityId({
+                    type: "exports",
+                    fromKind: "file",
+                    fromId: file.path,
+                    toKind: "symbol",
+                    toId: symbolId,
+                    discriminant: null
+                }),
+                type: "exports",
+                from: { kind: "file", id: file.path },
+                to: { kind: "symbol", id: symbolId },
+                evidence: {
+                    filePath: file.path,
+                    startLine: start.line + 1,
+                    endLine: end.line + 1,
+                    text: truncateEvidenceText(symbol.signature)
+                },
+                confidence: 0.95,
+                provenance: { source: "typescript-ast" }
+            });
+        }
+        return symbolId;
+    };
+    const childContainerPath = (parent) => {
+        return parent.qualifiedContainerPath ? `${parent.qualifiedContainerPath}.${parent.name}` : parent.name;
+    };
+    const visit = (node, parentId, containerPath = "") => {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            pushSymbol(node, "function", node.name.text, hasExport(node), parentId, containerPath);
+        }
+        else if (ts.isClassDeclaration(node) && node.name) {
+            const classId = pushSymbol(node, "class", node.name.text, hasExport(node), parentId, containerPath);
+            const classSymbol = symbols.find((item) => item.id === classId);
+            const memberContainerPath = classSymbol ? childContainerPath(classSymbol) : node.name.text;
+            for (const member of node.members) {
+                if ((ts.isMethodDeclaration(member) || ts.isPropertyDeclaration(member)) && member.name) {
+                    const memberName = member.name.getText(sourceFile);
+                    pushSymbol(member, ts.isMethodDeclaration(member) ? "method" : "variable", memberName, false, classId, memberContainerPath);
+                }
+            }
+        }
+        else if (ts.isInterfaceDeclaration(node)) {
+            pushSymbol(node, "interface", node.name.text, hasExport(node), parentId, containerPath);
+        }
+        else if (ts.isTypeAliasDeclaration(node)) {
+            pushSymbol(node, "type", node.name.text, hasExport(node), parentId, containerPath);
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            pushSymbol(node, "enum", node.name.text, hasExport(node), parentId, containerPath);
+        }
+        else if (ts.isVariableStatement(node)) {
+            const exported = hasExport(node);
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    pushSymbol(decl, "constant", decl.name.text, exported, parentId, containerPath);
+                }
+            }
+        }
+        else if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : undefined;
+            if (moduleSpecifier) {
+                const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+                const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+                const importKind = node.importClause?.isTypeOnly
+                    ? "type"
+                    : node.importClause?.namedBindings && ts.isNamespaceImport(node.importClause.namedBindings)
+                        ? "namespace"
+                        : node.importClause
+                            ? "static"
+                            : "side-effect";
+                importStatements.push({
+                    moduleSpecifier,
+                    startLine: start.line + 1,
+                    endLine: end.line + 1,
+                    text: node.getText(sourceFile),
+                    importKind
+                });
+            }
+        }
+        else if (ts.isExportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : undefined;
+            const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+            const exportedNames = node.exportClause && ts.isNamedExports(node.exportClause)
+                ? node.exportClause.elements.map((element) => (element.propertyName ?? element.name).text)
+                : node.exportClause && ts.isNamespaceExport(node.exportClause)
+                    ? [node.exportClause.name.text]
+                    : [];
+            exportStatements.push({
+                moduleSpecifier,
+                startLine: start.line + 1,
+                endLine: end.line + 1,
+                text: node.getText(sourceFile),
+                exportedNames
+            });
+        }
+        else if (ts.isExportAssignment(node)) {
+            const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+            const targetId = ts.isIdentifier(node.expression) ? symbolIdsByName.get(node.expression.text)?.[0] : undefined;
+            const to = targetId ? { kind: "symbol", id: targetId } : { kind: "file", id: file.path };
+            relationships.push({
+                id: relationshipIdentityId({
+                    type: "exports",
+                    fromKind: "file",
+                    fromId: file.path,
+                    toKind: to.kind,
+                    toId: to.id,
+                    discriminant: "default"
+                }),
+                type: "exports",
+                from: { kind: "file", id: file.path },
+                to,
+                localDiscriminant: "default",
+                evidence: {
+                    filePath: file.path,
+                    startLine: start.line + 1,
+                    endLine: end.line + 1,
+                    text: truncateEvidenceText(node.getText(sourceFile))
+                },
+                confidence: 0.8,
+                provenance: { source: "typescript-ast" }
+            });
+        }
+        ts.forEachChild(node, (child) => visit(child, parentId, containerPath));
+    };
+    visit(sourceFile);
+    for (const statement of importStatements) {
+        const localTarget = resolveTypeScriptModuleTarget(workspaceRoot, file.path, statement.moduleSpecifier);
+        if (statement.moduleSpecifier.startsWith(".")) {
+            if (localTarget) {
+                relationships.push({
+                    id: relationshipIdentityId({
+                        type: "imports",
+                        fromKind: "file",
+                        fromId: file.path,
+                        toKind: "file",
+                        toId: localTarget,
+                        discriminant: statement.importKind
+                    }),
+                    type: "imports",
+                    from: { kind: "file", id: file.path },
+                    to: { kind: "file", id: localTarget },
+                    localDiscriminant: statement.importKind,
+                    evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.endLine, text: truncateEvidenceText(statement.text) },
+                    confidence: 0.95,
+                    provenance: { source: "typescript-ast" }
+                });
+            }
+            else {
+                diagnostics.push({
+                    id: `diag:${file.path}:${statement.startLine}:unresolved_import:${statement.moduleSpecifier}`,
+                    severity: "warning",
+                    category: "resolution",
+                    code: "unresolved_import",
+                    message: `Unresolved local import ${statement.moduleSpecifier}.`,
+                    filePath: file.path,
+                    range: { startLine: statement.startLine, endLine: statement.endLine },
+                    target: { kind: "file", id: file.path },
+                    provenance: { source: "typescript-ast" }
+                });
+            }
+            continue;
+        }
+        const externalId = createExternalPackageId(statement.moduleSpecifier);
+        relationships.push({
+            id: relationshipIdentityId({
+                type: "imports",
+                fromKind: "file",
+                fromId: file.path,
+                toKind: "externalPackage",
+                toId: externalId,
+                discriminant: statement.importKind
+            }),
+            type: "imports",
+            from: { kind: "file", id: file.path },
+            to: { kind: "externalPackage", id: externalId },
+            localDiscriminant: statement.importKind,
+            evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.endLine, text: truncateEvidenceText(statement.text) },
+            confidence: 0.8,
+            provenance: { source: "typescript-ast" }
+        });
+    }
+    for (const statement of exportStatements) {
+        if (statement.moduleSpecifier) {
+            const localTarget = resolveTypeScriptModuleTarget(workspaceRoot, file.path, statement.moduleSpecifier);
+            if (statement.moduleSpecifier.startsWith(".")) {
+                if (localTarget) {
+                    relationships.push({
+                        id: relationshipIdentityId({
+                            type: "exports",
+                            fromKind: "file",
+                            fromId: file.path,
+                            toKind: "file",
+                            toId: localTarget,
+                            discriminant: "re-export"
+                        }),
+                        type: "exports",
+                        from: { kind: "file", id: file.path },
+                        to: { kind: "file", id: localTarget },
+                        localDiscriminant: "re-export",
+                        evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.endLine, text: truncateEvidenceText(statement.text) },
+                        confidence: 0.9,
+                        provenance: { source: "typescript-ast" }
+                    });
+                }
+                else {
+                    diagnostics.push({
+                        id: `diag:${file.path}:${statement.startLine}:unresolved_import:${statement.moduleSpecifier}`,
+                        severity: "warning",
+                        category: "resolution",
+                        code: "unresolved_import",
+                        message: `Unresolved local export source ${statement.moduleSpecifier}.`,
+                        filePath: file.path,
+                        range: { startLine: statement.startLine, endLine: statement.endLine },
+                        target: { kind: "file", id: file.path },
+                        provenance: { source: "typescript-ast" }
+                    });
+                }
+            }
+            else {
+                const externalId = createExternalPackageId(statement.moduleSpecifier);
+                relationships.push({
+                    id: relationshipIdentityId({
+                        type: "exports",
+                        fromKind: "file",
+                        fromId: file.path,
+                        toKind: "externalPackage",
+                        toId: externalId,
+                        discriminant: "re-export"
+                    }),
+                    type: "exports",
+                    from: { kind: "file", id: file.path },
+                    to: { kind: "externalPackage", id: externalId },
+                    localDiscriminant: "re-export",
+                    evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.endLine, text: truncateEvidenceText(statement.text) },
+                    confidence: 0.75,
+                    provenance: { source: "typescript-ast" }
+                });
+            }
+            continue;
+        }
+        for (const exportedName of statement.exportedNames) {
+            const matchingIds = symbolIdsByName.get(exportedName) ?? [];
+            for (const symbolId of matchingIds) {
+                relationships.push({
+                    id: relationshipIdentityId({
+                        type: "exports",
+                        fromKind: "file",
+                        fromId: file.path,
+                        toKind: "symbol",
+                        toId: symbolId,
+                        discriminant: "named"
+                    }),
+                    type: "exports",
+                    from: { kind: "file", id: file.path },
+                    to: { kind: "symbol", id: symbolId },
+                    localDiscriminant: "named",
+                    evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.endLine, text: truncateEvidenceText(statement.text) },
+                    confidence: 0.9,
+                    provenance: { source: "typescript-ast" }
+                });
+            }
+        }
+    }
+    return { symbols, relationships, diagnostics };
+}
+function hasExport(node) {
+    return Boolean(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./catalogue/indexer.js";
+export * from "./catalogue/schema.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./catalogue/indexer.js";
+export * from "./catalogue/schema.js";

package/dist/mcp/resources.d.ts

@@ -0,0 +1,18 @@
+import type { CatalogueSnapshot } from "../catalogue/schema.js";
+import type { ComparisonSnapshot } from "../comparison/schema.js";
+export declare const RESOURCE_URIS: {
+    readonly overview: "mapwright://workspace/overview";
+    readonly files: "mapwright://files";
+    readonly symbols: "mapwright://symbols";
+    readonly capabilities: "mapwright://capabilities";
+    readonly publicApis: "mapwright://public-apis";
+    readonly examples: "mapwright://examples";
+    readonly packages: "mapwright://packages";
+    readonly relationships: "mapwright://relationships";
+    readonly diagnostics: "mapwright://diagnostics";
+    readonly comparisonSummary: "mapwright://comparison/summary";
+    readonly comparisonChanges: "mapwright://comparison/changes";
+    readonly comparisonCompatibility: "mapwright://comparison/compatibility";
+};
+export declare function readResource(snapshot: CatalogueSnapshot, uri: string): unknown;
+export declare function readComparisonResource(comparison: ComparisonSnapshot | undefined, uri: string): unknown;

package/dist/mcp/resources.js

@@ -0,0 +1,57 @@
+import { getWorkspaceOverview } from "../queries/overview.js";
+import { selectCapabilities, selectDiagnostics, selectExamples, selectFiles, selectPackages, selectPublicApis, selectRelationships, selectSymbols, toResourceEnvelope } from "../queries/lists.js";
+import { getChangeSummary, getCompatibilityReport, listChanges } from "../queries/changes.js";
+import { comparisonNotLoadedFailure } from "./tools.js";
+export const RESOURCE_URIS = {
+    overview: "mapwright://workspace/overview",
+    files: "mapwright://files",
+    symbols: "mapwright://symbols",
+    capabilities: "mapwright://capabilities",
+    publicApis: "mapwright://public-apis",
+    examples: "mapwright://examples",
+    packages: "mapwright://packages",
+    relationships: "mapwright://relationships",
+    diagnostics: "mapwright://diagnostics",
+    comparisonSummary: "mapwright://comparison/summary",
+    comparisonChanges: "mapwright://comparison/changes",
+    comparisonCompatibility: "mapwright://comparison/compatibility"
+};
+export function readResource(snapshot, uri) {
+    switch (uri) {
+        case RESOURCE_URIS.overview:
+            return getWorkspaceOverview(snapshot);
+        case RESOURCE_URIS.files:
+            return toResourceEnvelope("files", selectFiles(snapshot));
+        case RESOURCE_URIS.symbols:
+            return toResourceEnvelope("symbols", selectSymbols(snapshot));
+        case RESOURCE_URIS.capabilities:
+            return toResourceEnvelope("capabilities", selectCapabilities(snapshot));
+        case RESOURCE_URIS.publicApis:
+            return toResourceEnvelope("publicApis", selectPublicApis(snapshot));
+        case RESOURCE_URIS.examples:
+            return toResourceEnvelope("examples", selectExamples(snapshot));
+        case RESOURCE_URIS.packages:
+            return toResourceEnvelope("packages", selectPackages(snapshot));
+        case RESOURCE_URIS.relationships:
+            return toResourceEnvelope("relationships", selectRelationships(snapshot));
+        case RESOURCE_URIS.diagnostics:
+            return toResourceEnvelope("diagnostics", selectDiagnostics(snapshot));
+        default:
+            return { error: "unknown_resource" };
+    }
+}
+export function readComparisonResource(comparison, uri) {
+    if (!comparison) {
+        return comparisonNotLoadedFailure();
+    }
+    switch (uri) {
+        case RESOURCE_URIS.comparisonSummary:
+            return getChangeSummary(comparison);
+        case RESOURCE_URIS.comparisonChanges:
+            return listChanges(comparison, { offset: 0, limit: 50 });
+        case RESOURCE_URIS.comparisonCompatibility:
+            return getCompatibilityReport(comparison, { offset: 0, limit: 50 });
+        default:
+            return { error: "unknown_resource" };
+    }
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function startServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { catalogueNotLoadedFailure, registerTools } from "./tools.js";
+import { RESOURCE_URIS, readResource, readComparisonResource } from "./resources.js";
+import { MAPWRIGHT_GENERATOR_NAME, MAPWRIGHT_GENERATOR_VERSION } from "../catalogue/version.js";
+export async function startServer() {
+    let snapshot;
+    let comparison;
+    const readLoadedResource = (uri) => {
+        if (!snapshot) {
+            return catalogueNotLoadedFailure();
+        }
+        return readResource(snapshot, uri);
+    };
+    const readLoadedComparison = (uri) => readComparisonResource(comparison, uri);
+    const server = new McpServer({
+        name: MAPWRIGHT_GENERATOR_NAME,
+        version: MAPWRIGHT_GENERATOR_VERSION
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {}
+        },
+        instructions: "Mortice Mapwright provides an agent-readable catalogue of files, symbols, capabilities, public APIs, relationships, tests, and diagnostics."
+    });
+    registerTools(server, {
+        onSnapshotChange: (nextSnapshot) => {
+            snapshot = nextSnapshot;
+        },
+        onComparisonChange: (nextComparison) => {
+            comparison = nextComparison;
+        }
+    });
+    server.registerResource("workspace-overview", RESOURCE_URIS.overview, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.overview, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.overview)) }]
+    }));
+    server.registerResource("files", RESOURCE_URIS.files, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.files, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.files)) }]
+    }));
+    server.registerResource("symbols", RESOURCE_URIS.symbols, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.symbols, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.symbols)) }]
+    }));
+    server.registerResource("capabilities", RESOURCE_URIS.capabilities, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.capabilities, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.capabilities)) }]
+    }));
+    server.registerResource("public-apis", RESOURCE_URIS.publicApis, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.publicApis, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.publicApis)) }]
+    }));
+    server.registerResource("examples", RESOURCE_URIS.examples, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.examples, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.examples)) }]
+    }));
+    server.registerResource("packages", RESOURCE_URIS.packages, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.packages, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.packages)) }]
+    }));
+    server.registerResource("relationships", RESOURCE_URIS.relationships, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.relationships, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.relationships)) }]
+    }));
+    server.registerResource("diagnostics", RESOURCE_URIS.diagnostics, { mimeType: "application/json" }, async () => ({
+        contents: [{ uri: RESOURCE_URIS.diagnostics, text: JSON.stringify(readLoadedResource(RESOURCE_URIS.diagnostics)) }]
+    }));
+    server.registerResource("comparison-summary", RESOURCE_URIS.comparisonSummary, { mimeType: "application/json" }, async () => ({
+        contents: [
+            {
+                uri: RESOURCE_URIS.comparisonSummary,
+                text: JSON.stringify(readLoadedComparison(RESOURCE_URIS.comparisonSummary))
+            }
+        ]
+    }));
+    server.registerResource("comparison-changes", RESOURCE_URIS.comparisonChanges, { mimeType: "application/json" }, async () => ({
+        contents: [
+            {
+                uri: RESOURCE_URIS.comparisonChanges,
+                text: JSON.stringify(readLoadedComparison(RESOURCE_URIS.comparisonChanges))
+            }
+        ]
+    }));
+    server.registerResource("comparison-compatibility", RESOURCE_URIS.comparisonCompatibility, { mimeType: "application/json" }, async () => ({
+        contents: [
+            {
+                uri: RESOURCE_URIS.comparisonCompatibility,
+                text: JSON.stringify(readLoadedComparison(RESOURCE_URIS.comparisonCompatibility))
+            }
+        ]
+    }));
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+    startServer().catch((error) => {
+        process.stderr.write(`Mapwright MCP server failed: ${String(error)}\n`);
+        process.exit(1);
+    });
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { CatalogueSnapshot } from "../catalogue/schema.js";
+import { type ComparisonSnapshot } from "../comparison/schema.js";
+export declare const CATALOGUE_NOT_LOADED_CODE = "catalogue_not_loaded";
+export declare const CATALOGUE_NOT_LOADED_MESSAGE = "Run load_committed_catalogue or index_workspace first.";
+export declare const COMPARISON_NOT_LOADED_CODE = "comparison_not_loaded";
+export declare const COMPARISON_NOT_LOADED_MESSAGE = "Run compare_catalogues or load_comparison first.";
+export declare function success(data: unknown, warnings?: string[]): Record<string, unknown>;
+export declare function failure(code: string, message: string): Record<string, unknown>;
+export declare function catalogueNotLoadedFailure(): Record<string, unknown>;
+export declare function comparisonNotLoadedFailure(): Record<string, unknown>;
+export declare function catalogueNotLoadedContent(): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+};
+export interface RegisterToolsOptions {
+    initialSnapshot?: CatalogueSnapshot;
+    initialWorkspace?: string;
+    onSnapshotChange?: (snapshot: CatalogueSnapshot, workspaceRoot: string) => void;
+    onComparisonChange?: (comparison: ComparisonSnapshot | undefined) => void;
+}
+export declare function registerTools(server: {
+    registerTool: (name: string, config: {
+        description?: string;
+        inputSchema?: Record<string, z.ZodTypeAny>;
+    }, cb: (args: any) => Promise<any>) => void;
+}, options?: RegisterToolsOptions): void;