coalesce-transform-mcp 0.1.0

package/dist/schemas/node-payloads.js

@@ -0,0 +1,147 @@
+import { z } from "zod";
+export const StorageLocationInputSchema = z
+    .object({
+    locationName: z
+        .string()
+        .optional()
+        .describe("Common storage location field used in hydrated node bodies."),
+    name: z
+        .string()
+        .optional()
+        .describe("Alternative storage location name field used by some node types."),
+    database: z.string().optional().describe("Optional database for the storage location."),
+    schema: z.string().optional().describe("Optional schema for the storage location."),
+})
+    .passthrough();
+const ColumnReferenceInputSchema = z
+    .object({
+    nodeID: z.string().optional(),
+    columnID: z.string().optional(),
+    columnName: z.string().optional(),
+    stepCounter: z.string().optional(),
+    columnCounter: z.string().optional(),
+})
+    .passthrough();
+const ColumnSourceInputSchema = z
+    .object({
+    name: z.string().optional(),
+    transform: z.string().optional(),
+    columnReferences: z.array(ColumnReferenceInputSchema).optional(),
+})
+    .passthrough();
+export const WorkspaceNodeColumnInputSchema = z
+    .object({
+    name: z.string().describe("Column name."),
+    transform: z
+        .string()
+        .optional()
+        .describe("Optional SQL expression or source reference for the column."),
+    dataType: z.string().optional().describe("Optional Coalesce data type."),
+    description: z.string().optional().describe("Optional column description."),
+    nullable: z.boolean().optional().describe("Optional nullability flag."),
+    columnID: z
+        .string()
+        .optional()
+        .describe("Existing Coalesce column ID when preserving hydrated metadata."),
+    columnReference: ColumnReferenceInputSchema
+        .optional()
+        .describe("Optional lineage reference preserved from hydrated node bodies."),
+    sources: z
+        .array(ColumnSourceInputSchema)
+        .optional()
+        .describe("Optional lineage/source entries used by hydrated metadata."),
+    placement: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Optional placement/order metadata."),
+})
+    .passthrough();
+const SourceMappingDependencyInputSchema = z
+    .object({
+    locationName: z.string().optional(),
+    nodeName: z.string().optional(),
+    nodeID: z.string().optional(),
+})
+    .passthrough();
+const SourceMappingJoinInputSchema = z
+    .object({
+    joinCondition: z
+        .string()
+        .optional()
+        .describe("Optional FROM/JOIN/WHERE clause stored on the mapping entry."),
+})
+    .passthrough();
+const SourceMappingCustomSqlInputSchema = z
+    .object({
+    customSQL: z.string().optional(),
+})
+    .passthrough();
+const SourceMappingNoLinkRefInputSchema = z
+    .union([z.string(), z.object({}).passthrough()]);
+const SourceMappingInputSchema = z
+    .object({
+    name: z.string().optional(),
+    aliases: z
+        .record(z.string())
+        .optional()
+        .describe("Optional alias-to-node lookup map used by hydrated source mappings."),
+    dependencies: z
+        .array(SourceMappingDependencyInputSchema)
+        .optional()
+        .describe("Optional predecessor dependency records."),
+    join: SourceMappingJoinInputSchema.optional(),
+    customSQL: SourceMappingCustomSqlInputSchema.optional(),
+    noLinkRefs: z.array(SourceMappingNoLinkRefInputSchema).optional(),
+})
+    .passthrough();
+export const WorkspaceNodeMetadataInputSchema = z
+    .object({
+    columns: z
+        .array(WorkspaceNodeColumnInputSchema)
+        .optional()
+        .describe("Hydrated mapping-grid columns for the node."),
+    sourceMapping: z
+        .array(SourceMappingInputSchema)
+        .optional()
+        .describe("Hydrated source/join mapping entries for the node."),
+    enabledColumnTestIDs: z
+        .array(z.string())
+        .optional()
+        .describe("Enabled column test IDs preserved by the Coalesce PUT API."),
+})
+    .passthrough();
+export const NodeConfigInputSchema = z
+    .object({
+    preSQL: z.string().optional().describe("Optional pre-SQL hook."),
+    postSQL: z.string().optional().describe("Optional post-SQL hook."),
+    testsEnabled: z.boolean().optional().describe("Enable or disable node tests."),
+    materializationType: z
+        .string()
+        .optional()
+        .describe("Optional materialization type such as table or view."),
+    insertStrategy: z
+        .string()
+        .optional()
+        .describe("Optional insert strategy for nodes that support it."),
+    truncateBefore: z
+        .boolean()
+        .optional()
+        .describe("Optional truncate-before-load toggle."),
+})
+    .passthrough();
+export const WorkspaceNodeWriteInputSchema = z
+    .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    nodeType: z.string().optional(),
+    table: z.string().optional(),
+    database: z.string().optional(),
+    schema: z.string().optional(),
+    locationName: z.string().optional(),
+    materializationType: z.string().optional(),
+    storageLocations: z.array(StorageLocationInputSchema).optional(),
+    config: NodeConfigInputSchema.optional(),
+    metadata: WorkspaceNodeMetadataInputSchema.optional(),
+})
+    .passthrough();

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CoalesceClient } from "./client.js";
+export declare const SERVER_NAME = "coalesce-transform-mcp";
+export declare const SERVER_VERSION: string;
+export declare const SERVER_INSTRUCTIONS: string;
+export declare function registerServerSurface(server: McpServer, client: CoalesceClient): void;
+export declare function createCoalesceMcpServer(client: CoalesceClient): McpServer;

package/dist/server.js

@@ -0,0 +1,63 @@
+import { createRequire } from "node:module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerEnvironmentTools } from "./mcp/environments.js";
+import { registerNodeTools } from "./mcp/nodes.js";
+import { registerPipelineTools } from "./mcp/pipelines.js";
+import { registerRunTools } from "./mcp/runs.js";
+import { registerProjectTools } from "./mcp/projects.js";
+import { registerGitAccountTools } from "./mcp/git-accounts.js";
+import { registerUserTools } from "./mcp/users.js";
+import { registerNodeTypeCorpusTools } from "./mcp/node-type-corpus.js";
+import { registerRepoNodeTypeTools } from "./mcp/repo-node-types.js";
+import { registerJobTools } from "./mcp/jobs.js";
+import { registerSubgraphTools } from "./mcp/subgraphs.js";
+import { registerCacheTools } from "./mcp/cache.js";
+import { registerRunAndWait } from "./workflows/run-and-wait.js";
+import { registerRetryAndWait } from "./workflows/retry-and-wait.js";
+import { registerGetRunDetails } from "./workflows/get-run-details.js";
+import { registerGetEnvironmentOverview } from "./workflows/get-environment-overview.js";
+import { registerResources } from "./resources/index.js";
+import { registerPrompts } from "./prompts/index.js";
+import { ensureJsonToolOutputSchemas } from "./coalesce/types.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+export const SERVER_NAME = "coalesce-transform-mcp";
+export const SERVER_VERSION = version;
+export const SERVER_INSTRUCTIONS = [
+    "Resolve IDs before mutating projects, workspaces, environments, jobs, runs, or nodes.",
+    "Always use plan-pipeline before creating pipeline nodes, and wait for explicit user approval before calling creation tools.",
+    "Inspect warning, validation, resultsError, incomplete, timedOut, and cleanupFailures fields before continuing.",
+    "Prefer run-and-wait or retry-and-wait when the user wants an end-to-end run outcome in one call.",
+    "Large payloads may be exposed through coalesce://cache resource URIs; read the resource rather than assuming inline JSON.",
+].join("\n");
+export function registerServerSurface(server, client) {
+    ensureJsonToolOutputSchemas(server);
+    registerEnvironmentTools(server, client);
+    registerNodeTools(server, client);
+    registerPipelineTools(server, client);
+    registerRunTools(server, client);
+    registerProjectTools(server, client);
+    registerGitAccountTools(server, client);
+    registerUserTools(server, client);
+    registerNodeTypeCorpusTools(server, client);
+    registerRepoNodeTypeTools(server, client);
+    registerJobTools(server, client);
+    registerSubgraphTools(server, client);
+    registerCacheTools(server, client);
+    registerRunAndWait(server, client);
+    registerRetryAndWait(server, client);
+    registerGetRunDetails(server, client);
+    registerGetEnvironmentOverview(server, client);
+    registerResources(server);
+    registerPrompts(server);
+}
+export function createCoalesceMcpServer(client) {
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    }, {
+        instructions: SERVER_INSTRUCTIONS,
+    });
+    registerServerSurface(server, client);
+    return server;
+}

package/dist/services/cache/snapshots.d.ts

@@ -0,0 +1,108 @@
+import type { CoalesceClient, QueryParams } from "../../client.js";
+import type { NodeSummary } from "../workspace/analysis.js";
+type PaginatedParams = {
+    pageSize?: number;
+    orderBy?: string;
+    orderByDirection?: "asc" | "desc";
+};
+type FetchPage = (params: QueryParams) => Promise<unknown>;
+type PaginatedCollectionResult = {
+    items: unknown[];
+    pageCount: number;
+    pageSize: number;
+    orderBy: string;
+    orderByDirection?: "asc" | "desc";
+};
+type CacheWriteOptions = {
+    baseDir?: string;
+};
+type StreamToDiskOptions = {
+    ndjsonPath: string;
+    metaPath: string;
+    itemTransform?: (item: unknown) => unknown;
+};
+type StreamToDiskResult = {
+    totalItems: number;
+    pageCount: number;
+    pageSize: number;
+    orderBy: string;
+    orderByDirection?: "asc" | "desc";
+    cachedAt: string;
+};
+export declare function streamAllPaginatedToDisk(fetchPage: FetchPage, baseParams: QueryParams, params: PaginatedParams, options: StreamToDiskOptions): Promise<StreamToDiskResult>;
+export declare function fetchAllWorkspaceNodes(client: CoalesceClient, params: {
+    workspaceID: string;
+    detail?: boolean;
+} & PaginatedParams): Promise<PaginatedCollectionResult>;
+export declare function fetchAllEnvironmentNodes(client: CoalesceClient, params: {
+    environmentID: string;
+    detail?: boolean;
+} & PaginatedParams): Promise<PaginatedCollectionResult>;
+export declare function fetchAllRuns(client: CoalesceClient, params: {
+    runType?: "deploy" | "refresh";
+    runStatus?: "completed" | "failed" | "canceled" | "running" | "waitingToRun";
+    environmentID?: string;
+    detail?: boolean;
+} & PaginatedParams): Promise<PaginatedCollectionResult>;
+export declare function fetchAllOrgUsers(client: CoalesceClient, params: PaginatedParams): Promise<PaginatedCollectionResult>;
+export declare function toNodeSummaries(nodes: unknown[]): NodeSummary[];
+export declare function cacheWorkspaceNodes(client: CoalesceClient, params: {
+    workspaceID: string;
+    detail?: boolean;
+} & PaginatedParams, options?: CacheWriteOptions): Promise<{
+    workspaceID: string;
+    detail: boolean;
+    totalNodes: number;
+    pageCount: number;
+    pageSize: number;
+    orderBy: string;
+    orderByDirection?: "asc" | "desc";
+    filePath: string;
+    metaPath: string;
+    cachedAt: string;
+}>;
+export declare function cacheEnvironmentNodes(client: CoalesceClient, params: {
+    environmentID: string;
+    detail?: boolean;
+} & PaginatedParams, options?: CacheWriteOptions): Promise<{
+    environmentID: string;
+    detail: boolean;
+    totalNodes: number;
+    pageCount: number;
+    pageSize: number;
+    orderBy: string;
+    orderByDirection?: "asc" | "desc";
+    filePath: string;
+    metaPath: string;
+    cachedAt: string;
+}>;
+export declare function cacheRuns(client: CoalesceClient, params: {
+    runType?: "deploy" | "refresh";
+    runStatus?: "completed" | "failed" | "canceled" | "running" | "waitingToRun";
+    environmentID?: string;
+    detail?: boolean;
+} & PaginatedParams, options?: CacheWriteOptions): Promise<{
+    detail: boolean;
+    totalRuns: number;
+    pageCount: number;
+    pageSize: number;
+    orderBy: string;
+    orderByDirection?: "asc" | "desc";
+    filePath: string;
+    metaPath: string;
+    cachedAt: string;
+    runType?: "deploy" | "refresh";
+    runStatus?: "completed" | "failed" | "canceled" | "running" | "waitingToRun";
+    environmentID?: string;
+}>;
+export declare function cacheOrgUsers(client: CoalesceClient, params: PaginatedParams, options?: CacheWriteOptions): Promise<{
+    totalUsers: number;
+    pageCount: number;
+    pageSize: number;
+    orderBy: string;
+    orderByDirection?: "asc" | "desc";
+    filePath: string;
+    metaPath: string;
+    cachedAt: string;
+}>;
+export {};

package/dist/services/cache/snapshots.js

@@ -0,0 +1,275 @@
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { listEnvironmentNodes, listWorkspaceNodes } from "../../coalesce/api/nodes.js";
+import { listRuns } from "../../coalesce/api/runs.js";
+import { listOrgUsers } from "../../coalesce/api/users.js";
+import { sanitizeResponse, validatePathSegment } from "../../coalesce/types.js";
+import { isPlainObject } from "../../utils.js";
+import { CACHE_DIR_NAME } from "../../cache-dir.js";
+const DEFAULT_PAGE_SIZE = 250;
+function parseCollectionPage(response) {
+    if (!isPlainObject(response)) {
+        throw new Error("Paginated collection response was not an object");
+    }
+    return {
+        data: Array.isArray(response.data) ? response.data : [],
+        next: typeof response.next === "string" && response.next.trim().length > 0
+            ? response.next
+            : undefined,
+    };
+}
+async function fetchAllPaginatedToMemory(fetchPage, baseParams, params) {
+    const items = [];
+    const seenCursors = new Set();
+    const pageSize = Math.max(1, Math.floor(params.pageSize ?? DEFAULT_PAGE_SIZE));
+    const orderBy = params.orderBy ?? "id";
+    const orderByDirection = params.orderByDirection;
+    let next;
+    let isFirstPage = true;
+    let pageCount = 0;
+    while (isFirstPage || next) {
+        const response = await fetchPage({
+            ...baseParams,
+            limit: pageSize,
+            orderBy,
+            ...(orderByDirection ? { orderByDirection } : {}),
+            ...(next ? { startingFrom: next } : {}),
+        });
+        const page = parseCollectionPage(response);
+        items.push(...page.data);
+        pageCount += 1;
+        if (page.next) {
+            if (seenCursors.has(page.next)) {
+                throw new Error(`Pagination repeated cursor ${page.next}`);
+            }
+            seenCursors.add(page.next);
+        }
+        next = page.next;
+        isFirstPage = false;
+    }
+    return {
+        items,
+        pageCount,
+        pageSize,
+        orderBy,
+        ...(orderByDirection ? { orderByDirection } : {}),
+    };
+}
+export async function streamAllPaginatedToDisk(fetchPage, baseParams, params, options) {
+    const { ndjsonPath, metaPath, itemTransform } = options;
+    const seenCursors = new Set();
+    const pageSize = Math.max(1, Math.floor(params.pageSize ?? DEFAULT_PAGE_SIZE));
+    const orderBy = params.orderBy ?? "id";
+    const orderByDirection = params.orderByDirection;
+    const cachedAt = new Date().toISOString();
+    // Ensure parent directory exists
+    mkdirSync(dirname(ndjsonPath), { recursive: true });
+    // Write empty file to start (truncates any previous file)
+    writeFileSync(ndjsonPath, "", "utf8");
+    let totalItems = 0;
+    let next;
+    let isFirstPage = true;
+    let pageCount = 0;
+    while (isFirstPage || next) {
+        const response = await fetchPage({
+            ...baseParams,
+            limit: pageSize,
+            orderBy,
+            ...(orderByDirection ? { orderByDirection } : {}),
+            ...(next ? { startingFrom: next } : {}),
+        });
+        const page = parseCollectionPage(response);
+        pageCount += 1;
+        // Write each item as a single NDJSON line
+        for (const item of page.data) {
+            const transformed = itemTransform ? itemTransform(item) : item;
+            appendFileSync(ndjsonPath, JSON.stringify(transformed) + "\n", "utf8");
+            totalItems += 1;
+        }
+        if (page.next) {
+            if (seenCursors.has(page.next)) {
+                throw new Error(`Pagination repeated cursor ${page.next}`);
+            }
+            seenCursors.add(page.next);
+        }
+        next = page.next;
+        isFirstPage = false;
+    }
+    // Write meta file only on successful completion
+    const meta = {
+        totalItems,
+        pageCount,
+        pageSize,
+        orderBy,
+        ...(orderByDirection ? { orderByDirection } : {}),
+        cachedAt,
+    };
+    writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
+    return meta;
+}
+function ensureDirectory(...parts) {
+    const directory = join(...parts);
+    mkdirSync(directory, { recursive: true });
+    return directory;
+}
+function buildNodeCacheFileName(scope, id, detail) {
+    const safeID = validatePathSegment(id, `${scope}ID`);
+    if (detail) {
+        return `${scope}-${safeID}-nodes.ndjson`;
+    }
+    return `${scope}-${safeID}-nodes-summary.ndjson`;
+}
+function buildRunsCacheFileName(params) {
+    const parts = ["runs"];
+    if (params.environmentID) {
+        parts.push(`env-${validatePathSegment(params.environmentID, "environmentID")}`);
+    }
+    if (params.runType) {
+        parts.push(params.runType);
+    }
+    if (params.runStatus) {
+        parts.push(params.runStatus);
+    }
+    parts.push(params.detail === true ? "detail" : "summary");
+    return `${parts.join("-")}.ndjson`;
+}
+export async function fetchAllWorkspaceNodes(client, params) {
+    return fetchAllPaginatedToMemory((queryParams) => listWorkspaceNodes(client, queryParams), {
+        workspaceID: validatePathSegment(params.workspaceID, "workspaceID"),
+        ...(params.detail !== undefined ? { detail: params.detail } : {}),
+    }, params);
+}
+export async function fetchAllEnvironmentNodes(client, params) {
+    return fetchAllPaginatedToMemory((queryParams) => listEnvironmentNodes(client, queryParams), {
+        environmentID: validatePathSegment(params.environmentID, "environmentID"),
+        ...(params.detail !== undefined ? { detail: params.detail } : {}),
+    }, params);
+}
+export async function fetchAllRuns(client, params) {
+    return fetchAllPaginatedToMemory((queryParams) => listRuns(client, queryParams), {
+        ...(params.runType ? { runType: params.runType } : {}),
+        ...(params.runStatus ? { runStatus: params.runStatus } : {}),
+        ...(params.environmentID
+            ? { environmentID: validatePathSegment(params.environmentID, "environmentID") }
+            : {}),
+        ...(params.detail !== undefined ? { detail: params.detail } : {}),
+    }, params);
+}
+export async function fetchAllOrgUsers(client, params) {
+    return fetchAllPaginatedToMemory((queryParams) => listOrgUsers(client, queryParams), {}, params);
+}
+export function toNodeSummaries(nodes) {
+    return nodes.flatMap((node) => {
+        if (!isPlainObject(node)) {
+            return [];
+        }
+        if (typeof node.nodeType !== "string" || typeof node.name !== "string") {
+            return [];
+        }
+        return [
+            {
+                nodeType: node.nodeType,
+                name: node.name,
+            },
+        ];
+    });
+}
+export async function cacheWorkspaceNodes(client, params, options) {
+    const detail = params.detail ?? true;
+    const baseDir = options?.baseDir ?? process.cwd();
+    const directory = ensureDirectory(baseDir, CACHE_DIR_NAME, "nodes");
+    const baseName = buildNodeCacheFileName("workspace", params.workspaceID, detail);
+    const ndjsonPath = join(directory, baseName);
+    const metaPath = join(directory, baseName.replace(/\.ndjson$/, ".meta.json"));
+    const result = await streamAllPaginatedToDisk((queryParams) => listWorkspaceNodes(client, queryParams), {
+        workspaceID: validatePathSegment(params.workspaceID, "workspaceID"),
+        ...(detail !== undefined ? { detail } : {}),
+    }, params, { ndjsonPath, metaPath });
+    return {
+        workspaceID: params.workspaceID,
+        detail,
+        totalNodes: result.totalItems,
+        pageCount: result.pageCount,
+        pageSize: result.pageSize,
+        orderBy: result.orderBy,
+        ...(result.orderByDirection ? { orderByDirection: result.orderByDirection } : {}),
+        filePath: ndjsonPath,
+        metaPath,
+        cachedAt: result.cachedAt,
+    };
+}
+export async function cacheEnvironmentNodes(client, params, options) {
+    const detail = params.detail ?? true;
+    const baseDir = options?.baseDir ?? process.cwd();
+    const directory = ensureDirectory(baseDir, CACHE_DIR_NAME, "nodes");
+    const baseName = buildNodeCacheFileName("environment", params.environmentID, detail);
+    const ndjsonPath = join(directory, baseName);
+    const metaPath = join(directory, baseName.replace(/\.ndjson$/, ".meta.json"));
+    const result = await streamAllPaginatedToDisk((queryParams) => listEnvironmentNodes(client, queryParams), {
+        environmentID: validatePathSegment(params.environmentID, "environmentID"),
+        ...(detail !== undefined ? { detail } : {}),
+    }, params, { ndjsonPath, metaPath });
+    return {
+        environmentID: params.environmentID,
+        detail,
+        totalNodes: result.totalItems,
+        pageCount: result.pageCount,
+        pageSize: result.pageSize,
+        orderBy: result.orderBy,
+        ...(result.orderByDirection ? { orderByDirection: result.orderByDirection } : {}),
+        filePath: ndjsonPath,
+        metaPath,
+        cachedAt: result.cachedAt,
+    };
+}
+export async function cacheRuns(client, params, options) {
+    const detail = params.detail ?? false;
+    const baseDir = options?.baseDir ?? process.cwd();
+    const directory = ensureDirectory(baseDir, CACHE_DIR_NAME, "runs");
+    const baseName = buildRunsCacheFileName({ ...params, detail });
+    const ndjsonPath = join(directory, baseName);
+    const metaPath = join(directory, baseName.replace(/\.ndjson$/, ".meta.json"));
+    const result = await streamAllPaginatedToDisk((queryParams) => listRuns(client, queryParams), {
+        ...(params.runType ? { runType: params.runType } : {}),
+        ...(params.runStatus ? { runStatus: params.runStatus } : {}),
+        ...(params.environmentID
+            ? { environmentID: validatePathSegment(params.environmentID, "environmentID") }
+            : {}),
+        ...(detail !== undefined ? { detail } : {}),
+    }, params, {
+        ndjsonPath,
+        metaPath,
+        itemTransform: (item) => sanitizeResponse(item),
+    });
+    return {
+        detail,
+        totalRuns: result.totalItems,
+        pageCount: result.pageCount,
+        pageSize: result.pageSize,
+        orderBy: result.orderBy,
+        ...(result.orderByDirection ? { orderByDirection: result.orderByDirection } : {}),
+        filePath: ndjsonPath,
+        metaPath,
+        cachedAt: result.cachedAt,
+        ...(params.runType ? { runType: params.runType } : {}),
+        ...(params.runStatus ? { runStatus: params.runStatus } : {}),
+        ...(params.environmentID ? { environmentID: params.environmentID } : {}),
+    };
+}
+export async function cacheOrgUsers(client, params, options) {
+    const baseDir = options?.baseDir ?? process.cwd();
+    const directory = ensureDirectory(baseDir, CACHE_DIR_NAME, "users");
+    const ndjsonPath = join(directory, "org-users.ndjson");
+    const metaPath = join(directory, "org-users.meta.json");
+    const result = await streamAllPaginatedToDisk((queryParams) => listOrgUsers(client, queryParams), {}, params, { ndjsonPath, metaPath });
+    return {
+        totalUsers: result.totalItems,
+        pageCount: result.pageCount,
+        pageSize: result.pageSize,
+        orderBy: result.orderBy,
+        ...(result.orderByDirection ? { orderByDirection: result.orderByDirection } : {}),
+        filePath: ndjsonPath,
+        metaPath,
+        cachedAt: result.cachedAt,
+    };
+}

package/dist/services/config/context-analyzer.d.ts

@@ -0,0 +1,14 @@
+export interface NodeContext {
+    hasMultipleSources: boolean;
+    hasAggregates: boolean;
+    hasTimestampColumns: boolean;
+    hasType2Pattern: boolean;
+    materializationType: "table" | "view";
+    columnPatterns: {
+        timestamps: string[];
+        dates: string[];
+        businessKeys: string[];
+        changeTrackingCandidates: string[];
+    };
+}
+export declare function analyzeNodeContext(node: Record<string, unknown>): NodeContext;