coalesce-transform-mcp 0.1.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { validateConfig, createClient } from "./client.js";
+import { createCoalesceMcpServer } from "./server.js";
+const config = validateConfig();
+const client = createClient(config);
+const server = createCoalesceMcpServer(client);
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/mcp/cache.d.ts

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

package/dist/mcp/cache.js

@@ -0,0 +1,137 @@
+import { rmSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { DESTRUCTIVE_ANNOTATIONS, IDEMPOTENT_WRITE_ANNOTATIONS, buildJsonToolResponse, handleToolError, } from "../coalesce/types.js";
+import { getCacheDir, CACHE_DIR_NAME } from "../cache-dir.js";
+import { cacheEnvironmentNodes, cacheOrgUsers, cacheRuns, cacheWorkspaceNodes, } from "../services/cache/snapshots.js";
+const SnapshotPaginationShape = {
+    pageSize: z
+        .number()
+        .int()
+        .positive()
+        .max(1000)
+        .optional()
+        .describe("Optional API page size used while collecting the full snapshot. Defaults to 250."),
+    orderBy: z
+        .string()
+        .optional()
+        .describe("Optional sort field used for paginated collection. Defaults to id."),
+    orderByDirection: z
+        .enum(["asc", "desc"])
+        .optional()
+        .describe("Optional sort direction used for paginated collection."),
+};
+export function registerCacheTools(server, client) {
+    server.tool("cache-workspace-nodes", "Fetch every page of workspace nodes from the Coalesce API, save the collected snapshot to disk, and return only cache metadata. Use this when the full node list would be too large for chat context or will be reused across multiple steps.", {
+        workspaceID: z.string().describe("The workspace ID"),
+        detail: z
+            .boolean()
+            .optional()
+            .describe("When true, fetches expanded node details. Defaults to true."),
+        ...SnapshotPaginationShape,
+    }, IDEMPOTENT_WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await cacheWorkspaceNodes(client, params);
+            return buildJsonToolResponse("cache-workspace-nodes", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("cache-environment-nodes", "Fetch every page of environment nodes from the Coalesce API, save the collected snapshot to disk, and return only cache metadata. Use this when the full node list would be too large for chat context or will be reused across multiple steps.", {
+        environmentID: z.string().describe("The environment ID"),
+        detail: z
+            .boolean()
+            .optional()
+            .describe("When true, fetches expanded node details. Defaults to true."),
+        ...SnapshotPaginationShape,
+    }, IDEMPOTENT_WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await cacheEnvironmentNodes(client, params);
+            return buildJsonToolResponse("cache-environment-nodes", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("cache-runs", "Fetch every page of list-runs results from the Coalesce API, save the collected snapshot to disk, and return only cache metadata. Use this when the run list would be too large for chat context or should be preserved outside the conversation.", {
+        runType: z.enum(["deploy", "refresh"]).optional().describe("Optional run type filter"),
+        runStatus: z
+            .enum(["completed", "failed", "canceled", "running", "waitingToRun"])
+            .optional()
+            .describe("Optional run status filter"),
+        environmentID: z.string().optional().describe("Optional environment ID filter"),
+        detail: z
+            .boolean()
+            .optional()
+            .describe("When true, fetches expanded run details. Defaults to false."),
+        ...SnapshotPaginationShape,
+    }, IDEMPOTENT_WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await cacheRuns(client, params);
+            return buildJsonToolResponse("cache-runs", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("cache-org-users", "Fetch every page of organization users from the Coalesce API, save the collected snapshot to disk, and return only cache metadata. Use this when the user list would be too large for chat context or should be preserved outside the conversation.", SnapshotPaginationShape, IDEMPOTENT_WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await cacheOrgUsers(client, params);
+            return buildJsonToolResponse("cache-org-users", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("clear_coalesce_transform_mcp_data_cache", "Delete all cached data files created by this MCP server, including snapshots, auto-cached responses, and plan summaries. " +
+        "Returns a summary of what was deleted. Use this when the user wants to free disk space or start fresh.", {}, DESTRUCTIVE_ANNOTATIONS, async () => {
+        try {
+            const cacheDir = getCacheDir();
+            if (!existsSync(cacheDir)) {
+                return buildJsonToolResponse("clear_coalesce_transform_mcp_data_cache", {
+                    deleted: false,
+                    message: `No cache directory found at ${CACHE_DIR_NAME}/`,
+                });
+            }
+            // Count files and measure size before deleting
+            let fileCount = 0;
+            let totalBytes = 0;
+            function countFiles(dir) {
+                try {
+                    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                        const entryPath = join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            countFiles(entryPath);
+                        }
+                        else if (entry.isFile()) {
+                            fileCount++;
+                            try {
+                                totalBytes += statSync(entryPath).size;
+                            }
+                            catch {
+                                // skip unreadable files
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // skip unreadable dirs
+                }
+            }
+            countFiles(cacheDir);
+            rmSync(cacheDir, { recursive: true, force: true });
+            const sizeMB = (totalBytes / (1024 * 1024)).toFixed(2);
+            return buildJsonToolResponse("clear_coalesce_transform_mcp_data_cache", {
+                deleted: true,
+                fileCount,
+                totalBytes,
+                sizeMB: `${sizeMB} MB`,
+                message: `Deleted ${fileCount} files (${sizeMB} MB) from ${CACHE_DIR_NAME}/`,
+            });
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/mcp/environments.d.ts

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

package/dist/mcp/environments.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { listEnvironments, getEnvironment, createEnvironment, deleteEnvironment, } from "../coalesce/api/environments.js";
+import { PaginationParams, buildJsonToolResponse, handleToolError, READ_ONLY_ANNOTATIONS, WRITE_ANNOTATIONS, DESTRUCTIVE_ANNOTATIONS, } from "../coalesce/types.js";
+export function registerEnvironmentTools(server, client) {
+    server.tool("list-environments", "List all available Coalesce environments", PaginationParams.extend({
+        detail: z.boolean().optional().describe("When true, returns expanded environment info"),
+    }).shape, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const result = await listEnvironments(client, params);
+            return buildJsonToolResponse("list-environments", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("get-environment", "Get details of a specific Coalesce environment", {
+        environmentID: z.string().describe("The environment ID"),
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const result = await getEnvironment(client, params);
+            return buildJsonToolResponse("get-environment", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("create-environment", "Create a new Coalesce environment within a project.", {
+        project: z.string().describe("The project ID to create the environment in"),
+        name: z.string().describe("Name for the new environment"),
+        oauthEnabled: z.boolean().optional().describe("Whether OAuth is enabled. Defaults to false."),
+        devEnv: z.boolean().optional().describe("Defaults to false."),
+        connectionAccount: z.string().optional().describe("Optional connection account identifier"),
+        runTimeParameters: z.record(z.unknown()).optional().describe("Optional runtime parameters"),
+        tagColors: z
+            .object({
+            backgroundColor: z.string().optional(),
+            textColor: z.string().optional(),
+        })
+            .optional()
+            .describe("Optional tag colors for the environment"),
+    }, WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await createEnvironment(client, params);
+            return buildJsonToolResponse("create-environment", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("delete-environment", "Delete a Coalesce environment. This is a destructive operation — the environment and its configuration will be permanently removed.", {
+        environmentID: z.string().describe("The environment ID to delete"),
+    }, DESTRUCTIVE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await deleteEnvironment(client, params);
+            return buildJsonToolResponse("delete-environment", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/mcp/git-accounts.d.ts

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

package/dist/mcp/git-accounts.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { listGitAccounts, getGitAccount, createGitAccount, updateGitAccount, deleteGitAccount, } from "../coalesce/api/git-accounts.js";
+import { buildJsonToolResponse, handleToolError, READ_ONLY_ANNOTATIONS, WRITE_ANNOTATIONS, IDEMPOTENT_WRITE_ANNOTATIONS, DESTRUCTIVE_ANNOTATIONS, } from "../coalesce/types.js";
+export function registerGitAccountTools(server, client) {
+    const accountOwnerParam = z.string().optional().describe("User ID of the account owner (org admins can manage other users' accounts)");
+    server.tool("list-git-accounts", "List all Coalesce git accounts", {
+        accountOwner: accountOwnerParam,
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const result = await listGitAccounts(client, params);
+            return buildJsonToolResponse("list-git-accounts", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("get-git-account", "Get details of a specific Coalesce git account", {
+        gitAccountID: z.string().describe("The git account ID"),
+        accountOwner: accountOwnerParam,
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const result = await getGitAccount(client, params);
+            return buildJsonToolResponse("get-git-account", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("create-git-account", "Create a new Coalesce git account", {
+        body: z
+            .record(z.unknown())
+            .describe("The git account creation request body"),
+        accountOwner: accountOwnerParam,
+    }, WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await createGitAccount(client, params);
+            return buildJsonToolResponse("create-git-account", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("update-git-account", "Update an existing Coalesce git account (partial update — only provided fields are changed)", {
+        gitAccountID: z.string().describe("The git account ID"),
+        body: z
+            .record(z.unknown())
+            .describe("The git account update request body (partial — only include fields to change)"),
+        accountOwner: accountOwnerParam,
+    }, IDEMPOTENT_WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await updateGitAccount(client, params);
+            return buildJsonToolResponse("update-git-account", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("delete-git-account", "Delete a Coalesce git account", {
+        gitAccountID: z.string().describe("The git account ID"),
+        accountOwner: accountOwnerParam,
+    }, DESTRUCTIVE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await deleteGitAccount(client, params);
+            return buildJsonToolResponse("delete-git-account", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/mcp/jobs.d.ts

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

package/dist/mcp/jobs.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { listEnvironmentJobs, createWorkspaceJob, getEnvironmentJob, updateWorkspaceJob, deleteWorkspaceJob, } from "../coalesce/api/jobs.js";
+import { PaginationParams, buildJsonToolResponse, handleToolError, READ_ONLY_ANNOTATIONS, WRITE_ANNOTATIONS, DESTRUCTIVE_ANNOTATIONS, } from "../coalesce/types.js";
+export function registerJobTools(server, client) {
+    server.tool("list-jobs", "List all jobs in a Coalesce environment.", PaginationParams.extend({
+        environmentID: z.string().describe("The environment ID"),
+    }).shape, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const result = await listEnvironmentJobs(client, params);
+            return buildJsonToolResponse("list-jobs", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("create-workspace-job", "Create a job in a Coalesce workspace. A job defines which nodes to include/exclude when running.\n\nThe includeSelector and excludeSelector use the format:\n  { location: LOCATION_NAME name: NODE_NAME } OR { location: LOCATION_NAME name: NODE_NAME }\n\nUse locationName from node details (e.g., 'ETL_STAGE', 'ANALYTICS'), NOT database.schema.", {
+        workspaceID: z.string().describe("The workspace ID"),
+        name: z.string().describe("Name for the job"),
+        includeSelector: z
+            .string()
+            .describe("Node selector string. Format: '{ location: LOC name: NAME } OR { location: LOC name: NAME }'. Use empty string to include nothing."),
+        excludeSelector: z
+            .string()
+            .describe("Node exclusion selector string. Same format as includeSelector. Use empty string to exclude nothing."),
+    }, WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await createWorkspaceJob(client, params);
+            return buildJsonToolResponse("create-workspace-job", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("get-job", "Get details of a specific job. Jobs are read via the environment endpoint.", {
+        environmentID: z.string().describe("The environment ID"),
+        jobID: z.string().describe("The job ID"),
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const result = await getEnvironmentJob(client, params);
+            return buildJsonToolResponse("get-job", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("update-workspace-job", "Update a job in a Coalesce workspace. Replaces the job's name, includeSelector, and excludeSelector.\n\nThe includeSelector and excludeSelector use the format:\n  { location: LOCATION_NAME name: NODE_NAME } OR { location: LOCATION_NAME name: NODE_NAME }\n\nUse locationName from node details (e.g., 'ETL_STAGE', 'ANALYTICS'), NOT database.schema.", {
+        workspaceID: z.string().describe("The workspace ID"),
+        jobID: z.string().describe("The job ID to update"),
+        name: z.string().describe("Updated name for the job"),
+        includeSelector: z
+            .string()
+            .describe("Node selector string. Format: '{ location: LOC name: NAME } OR { location: LOC name: NAME }'."),
+        excludeSelector: z
+            .string()
+            .describe("Node exclusion selector string. Same format as includeSelector. Use empty string to exclude nothing."),
+    }, WRITE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await updateWorkspaceJob(client, params);
+            return buildJsonToolResponse("update-workspace-job", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("delete-workspace-job", "Delete a job from a Coalesce workspace. This is a destructive operation — the job definition will be permanently removed.", {
+        workspaceID: z.string().describe("The workspace ID"),
+        jobID: z.string().describe("The job ID to delete"),
+    }, DESTRUCTIVE_ANNOTATIONS, async (params) => {
+        try {
+            const result = await deleteWorkspaceJob(client, params);
+            return buildJsonToolResponse("delete-workspace-job", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/mcp/node-type-corpus.d.ts

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

package/dist/mcp/node-type-corpus.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import { loadNodeTypeCorpusSnapshot, } from "../services/corpus/loader.js";
+import { summarizeNodeTypeCorpus, searchNodeTypeCorpusVariants, getNodeTypeCorpusVariant, buildVariantSummary, } from "../services/corpus/search.js";
+import { validateVariantTemplateGeneration } from "../services/corpus/templates.js";
+import { buildSetWorkspaceNodeTemplateFromDefinition, compareGeneratedTemplateToWorkspaceNode, renderYaml, } from "../services/templates/nodes.js";
+import { filterSqlOverrideControls, sanitizeNodeDefinitionSqlOverridePolicy, } from "../services/policies/sql-override.js";
+import { getWorkspaceNode } from "../coalesce/api/nodes.js";
+import { buildJsonToolResponse, handleToolError, READ_ONLY_ANNOTATIONS, } from "../coalesce/types.js";
+import { isPlainObject } from "../utils.js";
+function sanitizeVariantForResponse(variant) {
+    if (!variant.nodeDefinition) {
+        return {
+            ...variant,
+            primitiveSignature: filterSqlOverrideControls(variant.primitiveSignature),
+            controlSignature: filterSqlOverrideControls(variant.controlSignature),
+            unsupportedPrimitives: filterSqlOverrideControls(variant.unsupportedPrimitives),
+        };
+    }
+    const sanitized = sanitizeNodeDefinitionSqlOverridePolicy(variant.nodeDefinition);
+    return {
+        ...variant,
+        primitiveSignature: filterSqlOverrideControls(variant.primitiveSignature),
+        controlSignature: filterSqlOverrideControls(variant.controlSignature),
+        unsupportedPrimitives: filterSqlOverrideControls(variant.unsupportedPrimitives),
+        nodeDefinition: sanitized.nodeDefinition,
+        nodeMetadataSpec: renderYaml(sanitized.nodeDefinition),
+        warnings: sanitized.warnings,
+    };
+}
+export function registerNodeTypeCorpusTools(server, client) {
+    server.tool("search-node-type-variants", "Search the generated node-type corpus snapshot by normalized family, package, primitive, or support status. This tool queries the committed snapshot and does not require access to the original external node source repo at runtime.", {
+        normalizedFamily: z
+            .string()
+            .optional()
+            .describe("Case-insensitive exact match against the normalized family name."),
+        packageName: z
+            .string()
+            .optional()
+            .describe("Case-insensitive exact match against one of the package names that carries the variant."),
+        primitive: z
+            .string()
+            .optional()
+            .describe("Case-insensitive match against a primitive used in the node definition, such as tabular or materializationSelector."),
+        supportStatus: z
+            .enum(["supported", "partial"])
+            .or(z.literal("parse_error"))
+            .optional()
+            .describe("Filter by current MCP support classification."),
+        limit: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Maximum number of matches to return. Defaults to 25, max 200."),
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const snapshot = loadNodeTypeCorpusSnapshot();
+            const result = {
+                summary: summarizeNodeTypeCorpus(snapshot),
+                ...searchNodeTypeCorpusVariants(snapshot, params),
+            };
+            return buildJsonToolResponse("search-node-type-variants", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("get-node-type-variant", "Get one node-type corpus variant from the committed snapshot by variantKey. Use search-node-type-variants first when you need discovery.", {
+        variantKey: z.string().describe("The exact node-type corpus variant key."),
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            const snapshot = loadNodeTypeCorpusSnapshot();
+            const variant = getNodeTypeCorpusVariant(snapshot, params.variantKey);
+            return buildJsonToolResponse("get-node-type-variant", sanitizeVariantForResponse(variant));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("generate-set-workspace-node-template-from-variant", "Generate a set-workspace-node body template from a node-type corpus variant stored in the committed snapshot. This avoids requiring the original external node source repo at runtime, rejects partial variants unless allowPartial=true, and can optionally compare the inferred template against a live workspace node. SQL override controls are removed from returned templates because they are disallowed in this project.", {
+        variantKey: z.string().describe("The exact node-type corpus variant key."),
+        nodeName: z
+            .string()
+            .optional()
+            .describe("Optional node name to inject into the generated template."),
+        nodeType: z
+            .string()
+            .optional()
+            .describe("Optional nodeType override. Defaults to the variant definition capitalized field."),
+        locationName: z
+            .string()
+            .optional()
+            .describe("Optional storage location name to include in the template."),
+        database: z
+            .string()
+            .optional()
+            .describe("Optional database value to include in the template."),
+        schema: z
+            .string()
+            .optional()
+            .describe("Optional schema value to include in the template."),
+        allowPartial: z
+            .boolean()
+            .optional()
+            .describe("When true, allow best-effort generation for variants currently marked partial."),
+        workspaceID: z
+            .string()
+            .optional()
+            .describe("Optional workspace ID for comparing inferred mappings to a live workspace node."),
+        nodeID: z
+            .string()
+            .optional()
+            .describe("Optional node ID for comparing inferred mappings to a live workspace node."),
+    }, READ_ONLY_ANNOTATIONS, async (params) => {
+        try {
+            if ((params.workspaceID && !params.nodeID) || (!params.workspaceID && params.nodeID)) {
+                throw new Error("workspaceID and nodeID must be provided together when requesting a live node comparison.");
+            }
+            const snapshot = loadNodeTypeCorpusSnapshot();
+            const variant = getNodeTypeCorpusVariant(snapshot, params.variantKey);
+            validateVariantTemplateGeneration(variant, {
+                allowPartial: params.allowPartial,
+            });
+            const sanitizedVariant = sanitizeVariantForResponse(variant);
+            if (!sanitizedVariant.nodeDefinition || !isPlainObject(sanitizedVariant.nodeDefinition)) {
+                throw new Error("Sanitized node definition was not an object.");
+            }
+            const generated = buildSetWorkspaceNodeTemplateFromDefinition(variant.nodeDefinition, {
+                nodeName: params.nodeName,
+                nodeType: params.nodeType,
+                locationName: params.locationName,
+                database: params.database,
+                schema: params.schema,
+            });
+            const filteredUnsupportedPrimitives = filterSqlOverrideControls(variant.unsupportedPrimitives);
+            const warnings = Array.from(new Set(variant.supportStatus === "partial"
+                ? [
+                    `Best-effort template only. This variant uses unsupported primitives: ${filteredUnsupportedPrimitives.length > 0
+                        ? filteredUnsupportedPrimitives.join(", ")
+                        : "none after SQL override controls were removed"}.`,
+                    ...generated.warnings,
+                ]
+                : generated.warnings));
+            let comparison;
+            if (params.workspaceID && params.nodeID) {
+                const workspaceNode = await getWorkspaceNode(client, {
+                    workspaceID: params.workspaceID,
+                    nodeID: params.nodeID,
+                });
+                if (!isPlainObject(workspaceNode)) {
+                    throw new Error("Workspace node comparison target was not an object");
+                }
+                comparison = {
+                    workspaceID: params.workspaceID,
+                    nodeID: params.nodeID,
+                    result: compareGeneratedTemplateToWorkspaceNode(generated, workspaceNode),
+                };
+            }
+            const result = {
+                variant: buildVariantSummary(variant),
+                nodeMetadataSpecYaml: sanitizedVariant.nodeMetadataSpec,
+                ...generated,
+                warnings,
+                setWorkspaceNodeBodyTemplateYaml: renderYaml(generated.setWorkspaceNodeBodyTemplate),
+                ...(comparison ? { comparison } : {}),
+            };
+            return buildJsonToolResponse("generate-set-workspace-node-template-from-variant", result);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/mcp/nodes.d.ts

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