coalesce-transform-mcp 0.1.0

package/dist/services/config/context-analyzer.js

@@ -0,0 +1,76 @@
+export function analyzeNodeContext(node) {
+    const metadata = (node.metadata ?? {});
+    const sourceMapping = Array.isArray(metadata.sourceMapping)
+        ? metadata.sourceMapping
+        : [];
+    const columns = Array.isArray(metadata.columns)
+        ? metadata.columns
+        : [];
+    // Detect multiple sources from sourceMapping dependencies
+    const totalDependencies = sourceMapping.reduce((count, mapping) => {
+        return count + (Array.isArray(mapping?.dependencies) ? mapping.dependencies.length : 0);
+    }, 0);
+    // Detect aggregates
+    const aggregatePattern = /\b(COUNT|SUM|AVG|MIN|MAX|STDDEV|VARIANCE|LISTAGG|ARRAY_AGG)\s*\(/i;
+    const hasAggregates = columns.some((col) => aggregatePattern.test(typeof col.transform === "string" ? col.transform : ""));
+    // Detect timestamp columns
+    const timestampPattern = /_TS$|_TIMESTAMP$|TIMESTAMP_/i;
+    const datePattern = /_DATE$|_DT$|DATE_/i;
+    const colName = (col) => typeof col.name === "string" ? col.name : "";
+    const timestamps = columns
+        .filter((col) => timestampPattern.test(colName(col)))
+        .map(colName);
+    const dates = columns
+        .filter((col) => datePattern.test(colName(col)))
+        .map(colName);
+    const hasTimestampColumns = timestamps.length > 0 || dates.length > 0;
+    // Detect Type 2 SCD pattern (START_DATE, END_DATE, IS_CURRENT)
+    const hasStartDate = columns.some((col) => /START_DATE|EFFECTIVE_DATE/i.test(colName(col)));
+    const hasEndDate = columns.some((col) => /END_DATE|EXPIRY_DATE/i.test(colName(col)));
+    const hasCurrentFlag = columns.some((col) => /IS_CURRENT|CURRENT_FLAG/i.test(colName(col)));
+    const hasType2Pattern = hasStartDate && hasEndDate && hasCurrentFlag;
+    // Detect business key candidates: columns with ID/KEY/CODE patterns
+    const businessKeys = columns
+        .filter((col) => {
+        const name = colName(col);
+        return /_(ID|KEY|CODE|NUM)$/i.test(name) || /^(ID|KEY|CODE)_/i.test(name);
+    })
+        .map(colName);
+    // Detect change tracking candidates: non-key, non-aggregate, non-system columns
+    // These are columns that represent mutable business data
+    const systemColumnPattern = /^(SYS_|DW_|ETL_|LOAD_|CREATED_|UPDATED_|MODIFIED_|INSERT_|UPDATE_)/i;
+    const businessKeySet = new Set(businessKeys);
+    const changeTrackingCandidates = columns
+        .filter((col) => {
+        const name = colName(col);
+        if (businessKeySet.has(name))
+            return false;
+        if (systemColumnPattern.test(name))
+            return false;
+        if (aggregatePattern.test(typeof col.transform === "string" ? col.transform : ""))
+            return false;
+        if (col.isBusinessKey === true)
+            return false;
+        return name.length > 0;
+    })
+        .map(colName);
+    // Read actual materialization type from node config
+    const config = (node.config ?? {});
+    const rawMaterialization = typeof config.materializationType === "string"
+        ? config.materializationType.toLowerCase()
+        : "";
+    const materializationType = rawMaterialization.includes("view") ? "view" : "table";
+    return {
+        hasMultipleSources: totalDependencies > 1,
+        hasAggregates,
+        hasTimestampColumns,
+        hasType2Pattern,
+        materializationType,
+        columnPatterns: {
+            timestamps,
+            dates,
+            businessKeys,
+            changeTrackingCandidates,
+        },
+    };
+}

package/dist/services/config/field-classifier.d.ts

@@ -0,0 +1,23 @@
+export interface ConfigItem {
+    attributeName?: string;
+    type: string;
+    isRequired?: boolean | string;
+    default?: unknown;
+    enableIf?: string;
+    displayName?: string;
+}
+export interface ClassifiedFields {
+    required: string[];
+    conditionalRequired: string[];
+    optionalWithDefaults: string[];
+    contextual: string[];
+    columnSelectors: Array<{
+        attributeName: string;
+        displayName: string | undefined;
+        isRequired: boolean;
+    }>;
+}
+export declare function classifyConfigFields(config: Array<{
+    groupName: string;
+    items: ConfigItem[];
+}>): ClassifiedFields;

package/dist/services/config/field-classifier.js

@@ -0,0 +1,47 @@
+export function classifyConfigFields(config) {
+    const required = [];
+    const conditionalRequired = [];
+    const optionalWithDefaults = [];
+    const contextual = [];
+    const columnSelectors = [];
+    for (const group of config) {
+        for (const item of group.items) {
+            // Skip items without attributeName
+            if (!item.attributeName) {
+                continue;
+            }
+            // columnSelector items are column-level attributes, not node-level config
+            if (item.type === "columnSelector") {
+                columnSelectors.push({
+                    attributeName: item.attributeName,
+                    displayName: item.displayName,
+                    isRequired: item.isRequired === true,
+                });
+                continue;
+            }
+            // Classify required fields (isRequired === true)
+            if (item.isRequired === true) {
+                required.push(item.attributeName);
+            }
+            // Conditional required (isRequired is string)
+            else if (typeof item.isRequired === "string") {
+                conditionalRequired.push(item.attributeName);
+            }
+            // Optional with defaults (default !== undefined)
+            else if (item.default !== undefined) {
+                optionalWithDefaults.push(item.attributeName);
+            }
+            // Contextual (everything else)
+            else {
+                contextual.push(item.attributeName);
+            }
+        }
+    }
+    return {
+        required,
+        conditionalRequired,
+        optionalWithDefaults,
+        contextual,
+        columnSelectors,
+    };
+}

package/dist/services/config/intelligent.d.ts

@@ -0,0 +1,55 @@
+import type { CoalesceClient } from "../../client.js";
+export interface ConfigReview {
+    status: "complete" | "needs_attention" | "incomplete";
+    summary: string;
+    missingRequired: string[];
+    warnings: string[];
+    suggestions: string[];
+}
+export interface ConfigCompletionResult {
+    node: unknown;
+    schemaSource: "repo" | "corpus";
+    classification: {
+        required: string[];
+        conditionalRequired: string[];
+        optionalWithDefaults: string[];
+        contextual: string[];
+        columnSelectors: Array<{
+            attributeName: string;
+            displayName: string | undefined;
+            isRequired: boolean;
+        }>;
+    };
+    context: {
+        hasMultipleSources: boolean;
+        hasAggregates: boolean;
+        hasTimestampColumns: boolean;
+        hasType2Pattern: boolean;
+        materializationType: "table" | "view";
+    };
+    appliedConfig: Record<string, unknown>;
+    configChanges: {
+        required: Record<string, unknown>;
+        contextual: Record<string, unknown>;
+        preserved: Record<string, unknown>;
+        defaults: Record<string, unknown>;
+    };
+    columnAttributeChanges: {
+        applied: Array<{
+            columnName: string;
+            attribute: string;
+            value: boolean;
+        }>;
+        reasoning: string[];
+    };
+    reasoning: string[];
+    detectedPatterns: {
+        candidateColumns: string[];
+    };
+    configReview: ConfigReview;
+}
+export declare function completeNodeConfiguration(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+    repoPath?: string;
+}): Promise<ConfigCompletionResult>;

package/dist/services/config/intelligent.js

@@ -0,0 +1,306 @@
+import { getWorkspaceNode } from "../../coalesce/api/nodes.js";
+import { resolveNodeTypeSchema } from "./schema-resolver.js";
+import { analyzeNodeContext } from "./context-analyzer.js";
+import { classifyConfigFields } from "./field-classifier.js";
+import { applyIntelligenceRules } from "./rules.js";
+import { updateWorkspaceNode } from "../workspace/mutations.js";
+import { isPlainObject } from "../../utils.js";
+import { NODE_TYPE_INTENT } from "../pipelines/node-type-intent.js";
+import { inferFamily } from "../pipelines/node-type-selection.js";
+function getNodeMetadataColumns(node) {
+    const metadata = isPlainObject(node.metadata) ? node.metadata : undefined;
+    const columns = metadata?.["columns"];
+    if (!Array.isArray(columns)) {
+        return [];
+    }
+    return columns.filter(isPlainObject);
+}
+/**
+ * Intelligently determines which columns should receive a columnSelector attribute.
+ * Returns a map of columnName → true for columns that should be marked.
+ */
+function inferColumnSelectorAssignments(attributeName, columns, context) {
+    const assignments = new Map();
+    switch (attributeName) {
+        case "isBusinessKey": {
+            // Use columns already marked, or fall back to detected business key candidates
+            const alreadyMarked = columns.filter((c) => c.isBusinessKey === true);
+            if (alreadyMarked.length > 0) {
+                for (const col of alreadyMarked) {
+                    if (typeof col.name === "string") {
+                        assignments.set(col.name, true);
+                    }
+                }
+                return { assignments, reasoning: `Preserved ${alreadyMarked.length} existing isBusinessKey column(s)` };
+            }
+            // Infer from column name patterns
+            for (const candidateName of context.columnPatterns.businessKeys) {
+                assignments.set(candidateName, true);
+            }
+            if (assignments.size > 0) {
+                return { assignments, reasoning: `Inferred isBusinessKey from ID/KEY/CODE column name patterns: ${[...assignments.keys()].join(", ")}` };
+            }
+            return { assignments, reasoning: "No business key candidates detected — set isBusinessKey manually on the appropriate column(s)" };
+        }
+        case "isChangeTracking": {
+            // Use columns already marked, or fall back to detected candidates
+            const alreadyMarked = columns.filter((c) => c.isChangeTracking === true);
+            if (alreadyMarked.length > 0) {
+                for (const col of alreadyMarked) {
+                    if (typeof col.name === "string") {
+                        assignments.set(col.name, true);
+                    }
+                }
+                return { assignments, reasoning: `Preserved ${alreadyMarked.length} existing isChangeTracking column(s)` };
+            }
+            // For change tracking, mark non-key mutable columns
+            for (const candidateName of context.columnPatterns.changeTrackingCandidates) {
+                assignments.set(candidateName, true);
+            }
+            if (assignments.size > 0) {
+                return { assignments, reasoning: `Inferred isChangeTracking for non-key columns: ${[...assignments.keys()].join(", ")}` };
+            }
+            return { assignments, reasoning: "No change tracking candidates detected" };
+        }
+        default: {
+            // For unknown columnSelector attributes, preserve existing values only
+            const alreadyMarked = columns.filter((c) => c[attributeName] === true);
+            for (const col of alreadyMarked) {
+                if (typeof col.name === "string") {
+                    assignments.set(col.name, true);
+                }
+            }
+            return {
+                assignments,
+                reasoning: alreadyMarked.length > 0
+                    ? `Preserved ${alreadyMarked.length} existing ${attributeName} column(s)`
+                    : `Unknown columnSelector '${attributeName}' — skipped automatic assignment. Set manually if needed.`,
+            };
+        }
+    }
+}
+function inferFamilyFromNodeType(nodeType) {
+    return inferFamily([nodeType]);
+}
+/**
+ * Build a config review that summarizes the state of the node's configuration
+ * based on the node type's intent, what fields were filled, and what's still missing.
+ */
+function buildConfigReview(nodeType, appliedConfig, classification, context, columnAttributeApplied) {
+    const missingRequired = [];
+    const warnings = [];
+    const suggestions = [];
+    // Check for missing required fields that weren't filled
+    for (const fieldName of classification.required) {
+        if (!(fieldName in appliedConfig) || appliedConfig[fieldName] === undefined) {
+            missingRequired.push(fieldName);
+        }
+    }
+    // Intent-aware checks based on node type family
+    const family = inferFamilyFromNodeType(nodeType);
+    const intent = NODE_TYPE_INTENT[family];
+    // Check column-level attributes
+    const hasBusinessKeySelector = classification.columnSelectors.some((s) => s.attributeName === "isBusinessKey");
+    const businessKeysApplied = columnAttributeApplied.filter((a) => a.attribute === "isBusinessKey" && a.value);
+    if (intent.requiresSemanticConfig) {
+        // Node types that require semantic config need business keys
+        if (hasBusinessKeySelector && businessKeysApplied.length === 0 && context.columnPatterns.businessKeys.length === 0) {
+            warnings.push(`${family} nodes require business keys but none were detected or set. ` +
+                `Set isBusinessKey: true on the appropriate column(s) via replace-workspace-node-columns.`);
+        }
+        // Dimension/Persistent Stage with no change tracking
+        const hasChangeTrackingSelector = classification.columnSelectors.some((s) => s.attributeName === "isChangeTracking");
+        if (hasChangeTrackingSelector) {
+            const changeTrackingApplied = columnAttributeApplied.filter((a) => a.attribute === "isChangeTracking" && a.value);
+            if (changeTrackingApplied.length === 0 && context.columnPatterns.changeTrackingCandidates.length === 0) {
+                suggestions.push(`${family} supports change tracking but no isChangeTracking columns were detected. ` +
+                    `If CDC is needed, set isChangeTracking: true on mutable columns.`);
+            }
+        }
+    }
+    // Check for required columnSelectors that have no assignments
+    for (const selector of classification.columnSelectors) {
+        if (selector.isRequired) {
+            const applied = columnAttributeApplied.filter((a) => a.attribute === selector.attributeName && a.value);
+            if (applied.length === 0) {
+                missingRequired.push(`columnSelector:${selector.attributeName}`);
+            }
+        }
+    }
+    // Materialization-specific suggestions
+    if (context.materializationType === "view" && context.hasAggregates) {
+        suggestions.push("This view contains aggregations that recalculate on every query. " +
+            "Consider table materialization if performance is important.");
+    }
+    // Determine overall status
+    let status;
+    if (missingRequired.length > 0) {
+        status = "incomplete";
+    }
+    else if (warnings.length > 0) {
+        status = "needs_attention";
+    }
+    else {
+        status = "complete";
+    }
+    // Build summary
+    let summary;
+    if (status === "complete") {
+        summary = `Config is complete. All required fields are set.`;
+        if (suggestions.length > 0) {
+            summary += ` ${suggestions.length} optional suggestion(s) available.`;
+        }
+    }
+    else if (status === "needs_attention") {
+        summary = `Config has ${warnings.length} warning(s) that may need manual review.`;
+    }
+    else {
+        summary = `Config is incomplete — ${missingRequired.length} required field(s) missing: ${missingRequired.join(", ")}.`;
+    }
+    return { status, summary, missingRequired, warnings, suggestions };
+}
+export async function completeNodeConfiguration(client, params) {
+    // Step 1: Fetch node
+    const node = await getWorkspaceNode(client, {
+        workspaceID: params.workspaceID,
+        nodeID: params.nodeID,
+    });
+    if (!isPlainObject(node)) {
+        throw new Error("Node response was not an object");
+    }
+    const nodeType = typeof node.nodeType === "string" ? node.nodeType : "";
+    if (!nodeType) {
+        throw new Error("Node has no nodeType");
+    }
+    // Step 2: Resolve schema
+    const schemaResolution = await resolveNodeTypeSchema(nodeType, params.repoPath);
+    // Step 3: Analyze context
+    const context = analyzeNodeContext(node);
+    // Step 4: Classify fields (now separates columnSelector items)
+    const classification = classifyConfigFields(schemaResolution.schema.config);
+    // Step 5: Apply intelligence rules (get suggestions)
+    const rulesResult = applyIntelligenceRules(context);
+    // Step 6: Build config changes from rules and schema defaults
+    const existingConfig = isPlainObject(node.config) ? node.config : {};
+    const requiredChanges = {};
+    const contextualChanges = {};
+    const preservedFields = {};
+    const defaultChanges = {};
+    // Apply required field defaults from schema
+    for (const fieldName of classification.required) {
+        if (!(fieldName in existingConfig)) {
+            for (const group of schemaResolution.schema.config) {
+                for (const item of group.items) {
+                    if (item.attributeName === fieldName && item.default !== undefined) {
+                        requiredChanges[fieldName] = item.default;
+                    }
+                }
+            }
+        }
+        else {
+            preservedFields[fieldName] = existingConfig[fieldName];
+        }
+    }
+    // Apply schema defaults for optional fields that aren't set yet
+    for (const fieldName of classification.optionalWithDefaults) {
+        if (!(fieldName in existingConfig)) {
+            for (const group of schemaResolution.schema.config) {
+                for (const item of group.items) {
+                    if (item.attributeName === fieldName && item.default !== undefined) {
+                        defaultChanges[fieldName] = item.default;
+                    }
+                }
+            }
+        }
+    }
+    // Apply contextual suggestions from rules
+    for (const [key, value] of Object.entries(rulesResult.suggestions)) {
+        if (classification.contextual.includes(key) || classification.optionalWithDefaults.includes(key)) {
+            contextualChanges[key] = value;
+        }
+    }
+    // Merge all config changes (contextual overrides defaults when both apply)
+    const appliedConfig = {
+        ...existingConfig,
+        ...defaultChanges,
+        ...requiredChanges,
+        ...contextualChanges,
+    };
+    // Step 7: Handle columnSelector attributes (column-level)
+    const columns = getNodeMetadataColumns(node);
+    const columnAttributeApplied = [];
+    const columnAttributeReasoning = [];
+    let columnsModified = false;
+    for (const selector of classification.columnSelectors) {
+        const { assignments, reasoning } = inferColumnSelectorAssignments(selector.attributeName, columns, context);
+        columnAttributeReasoning.push(`${selector.attributeName}: ${reasoning}`);
+        for (const [colName, value] of assignments) {
+            const col = columns.find((c) => typeof c.name === "string" && c.name === colName);
+            if (col && col[selector.attributeName] !== value) {
+                col[selector.attributeName] = value;
+                columnsModified = true;
+                columnAttributeApplied.push({
+                    columnName: colName,
+                    attribute: selector.attributeName,
+                    value,
+                });
+            }
+        }
+    }
+    // Step 8: Update node with config changes and/or column attribute changes
+    const hasConfigChanges = Object.keys(requiredChanges).length > 0 ||
+        Object.keys(contextualChanges).length > 0 ||
+        Object.keys(defaultChanges).length > 0;
+    let updatedNode = node;
+    if (hasConfigChanges || columnsModified) {
+        const changes = {};
+        if (hasConfigChanges) {
+            changes.config = appliedConfig;
+        }
+        if (columnsModified) {
+            changes.metadata = { columns };
+        }
+        updatedNode = await updateWorkspaceNode(client, {
+            workspaceID: params.workspaceID,
+            nodeID: params.nodeID,
+            changes,
+        });
+    }
+    // Step 9: Detect candidate columns for reporting
+    const candidateColumns = columns
+        .filter((col) => {
+        const name = typeof col.name === "string" ? col.name : "";
+        return /_(ID|KEY|CODE|NUM)$/i.test(name) || /^(ID|KEY|CODE)_/i.test(name);
+    })
+        .flatMap((col) => (typeof col.name === "string" ? [col.name] : []));
+    // Step 10: Build config review — summarizes what's set, what's missing, and what needs attention
+    const configReview = buildConfigReview(nodeType, appliedConfig, classification, context, columnAttributeApplied);
+    return {
+        node: updatedNode,
+        schemaSource: schemaResolution.source,
+        classification,
+        context: {
+            hasMultipleSources: context.hasMultipleSources,
+            hasAggregates: context.hasAggregates,
+            hasTimestampColumns: context.hasTimestampColumns,
+            hasType2Pattern: context.hasType2Pattern,
+            materializationType: context.materializationType,
+        },
+        appliedConfig,
+        configChanges: {
+            required: requiredChanges,
+            contextual: contextualChanges,
+            preserved: preservedFields,
+            defaults: defaultChanges,
+        },
+        columnAttributeChanges: {
+            applied: columnAttributeApplied,
+            reasoning: columnAttributeReasoning,
+        },
+        reasoning: rulesResult.reasoning,
+        detectedPatterns: {
+            candidateColumns,
+        },
+        configReview,
+    };
+}

package/dist/services/config/rules.d.ts

@@ -0,0 +1,6 @@
+import type { NodeContext } from "./context-analyzer.js";
+export interface IntelligenceRulesResult {
+    suggestions: Record<string, unknown>;
+    reasoning: string[];
+}
+export declare function applyIntelligenceRules(context: NodeContext): IntelligenceRulesResult;

package/dist/services/config/rules.js

@@ -0,0 +1,44 @@
+export function applyIntelligenceRules(context) {
+    const suggestions = {};
+    const reasoning = [];
+    // Rule: Multi-source → insertStrategy (UNION vs UNION ALL based on aggregates)
+    if (context.hasMultipleSources) {
+        if (context.hasAggregates) {
+            suggestions.insertStrategy = "UNION";
+            reasoning.push("Multi-source node with aggregates suggests UNION to avoid duplicate aggregated rows");
+        }
+        else {
+            suggestions.insertStrategy = "UNION ALL";
+            reasoning.push("Multi-source node without aggregates suggests UNION ALL for better performance");
+        }
+    }
+    // Rule: aggregates → selectDistinct: false
+    if (context.hasAggregates) {
+        suggestions.selectDistinct = false;
+        reasoning.push("Aggregates are incompatible with SELECT DISTINCT; suggests selectDistinct: false");
+    }
+    // Rule: table materialization → truncateBefore: false (preserve data by default)
+    if (context.materializationType === "table") {
+        suggestions.truncateBefore = false;
+        reasoning.push("Table materialization suggests truncateBefore: false to preserve existing data");
+    }
+    // Rule: view materialization → selectDistinct is often useful
+    if (context.materializationType === "view" && !context.hasAggregates) {
+        suggestions.selectDistinct = false;
+        reasoning.push("View without aggregates — selectDistinct defaults to false; set to true only if deduplication is needed");
+    }
+    // Rule: Type 2 SCD pattern detected → suggest enableIf-dependent fields
+    if (context.hasType2Pattern) {
+        reasoning.push("Type 2 SCD pattern detected (START_DATE + END_DATE + IS_CURRENT columns). " +
+            "Verify that the node type's SCD config is set appropriately.");
+    }
+    // Rule: No timestamp/date columns in a table → note for auditing
+    if (context.materializationType === "table" && !context.hasTimestampColumns) {
+        reasoning.push("No timestamp or date columns detected. Consider adding audit columns " +
+            "(e.g., DW_LOAD_TS, DW_UPDATE_TS) for data lineage tracking.");
+    }
+    return {
+        suggestions,
+        reasoning,
+    };
+}

package/dist/services/config/schema-resolver.d.ts

@@ -0,0 +1,18 @@
+export interface NodeTypeSchema {
+    config: Array<{
+        groupName: string;
+        items: Array<{
+            attributeName?: string;
+            type: string;
+            isRequired?: boolean | string;
+            default?: unknown;
+            enableIf?: string;
+            displayName?: string;
+        }>;
+    }>;
+}
+export interface SchemaResolution {
+    source: "repo" | "corpus";
+    schema: NodeTypeSchema;
+}
+export declare function resolveNodeTypeSchema(nodeType: string, repoPath?: string): Promise<SchemaResolution>;

package/dist/services/config/schema-resolver.js

@@ -0,0 +1,80 @@
+import { getRepoNodeTypeDefinition } from "../repo/operations.js";
+import { loadNodeTypeCorpusSnapshot } from "../corpus/loader.js";
+import { searchNodeTypeCorpusVariants } from "../corpus/search.js";
+import { resolveOptionalRepoPathInput } from "../repo/path.js";
+import { isPlainObject } from "../../utils.js";
+function normalizeNodeTypeFamily(nodeType) {
+    return nodeType.trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function parseNodeTypeSchema(nodeDefinition, sourceLabel) {
+    if (!isPlainObject(nodeDefinition) || !Array.isArray(nodeDefinition.config)) {
+        throw new Error(`${sourceLabel} node definition does not contain a config array`);
+    }
+    const config = nodeDefinition.config.flatMap((group) => {
+        if (!isPlainObject(group) || !Array.isArray(group.items)) {
+            return [];
+        }
+        const items = group.items.flatMap((item) => {
+            if (!isPlainObject(item) || typeof item.type !== "string") {
+                return [];
+            }
+            return [{
+                    attributeName: typeof item.attributeName === "string" ? item.attributeName : undefined,
+                    type: item.type,
+                    isRequired: typeof item.isRequired === "boolean" || typeof item.isRequired === "string"
+                        ? item.isRequired
+                        : undefined,
+                    default: item.default,
+                    enableIf: typeof item.enableIf === "string" ? item.enableIf : undefined,
+                    displayName: typeof item.displayName === "string" ? item.displayName : undefined,
+                }];
+        });
+        return [{
+                groupName: typeof group.groupName === "string" ? group.groupName : "Config",
+                items,
+            }];
+    });
+    return { config };
+}
+export async function resolveNodeTypeSchema(nodeType, repoPath) {
+    // Resolve repoPath with COALESCE_REPO_PATH env var fallback
+    const resolvedRepoPath = resolveOptionalRepoPathInput(repoPath);
+    // Try repo first if path provided
+    if (resolvedRepoPath) {
+        try {
+            const def = await getRepoNodeTypeDefinition(resolvedRepoPath, nodeType);
+            return {
+                source: "repo",
+                schema: parseNodeTypeSchema(def.nodeDefinition, "Repo"),
+            };
+        }
+        catch (error) {
+            // Fall through to corpus
+        }
+    }
+    // Try corpus fallback
+    try {
+        const snapshot = loadNodeTypeCorpusSnapshot();
+        const normalizedFamily = normalizeNodeTypeFamily(nodeType);
+        const result = searchNodeTypeCorpusVariants(snapshot, {
+            normalizedFamily,
+            supportStatus: "supported",
+            limit: 1,
+        });
+        if (result.matches.length === 0) {
+            throw new Error(`No supported corpus variant found for normalized family '${normalizedFamily}'`);
+        }
+        const variant = snapshot.variants.find((v) => v.variantKey === result.matches[0].variantKey);
+        if (!variant?.nodeDefinition) {
+            throw new Error(`Corpus variant ${result.matches[0].variantKey} has no parseable definition`);
+        }
+        return {
+            source: "corpus",
+            schema: parseNodeTypeSchema(variant.nodeDefinition, "Corpus"),
+        };
+    }
+    catch (error) {
+        throw new Error(`Cannot resolve node type schema for '${nodeType}'. ` +
+            `Repo resolution failed${resolvedRepoPath ? "" : " (no repoPath provided, COALESCE_REPO_PATH not set)"} and corpus lookup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}