isc-transforms-mcp 1.0.2 → 1.0.4

package/dist/index.js

@@ -338,6 +338,58 @@ export async function buildMcpServer(cfg) {
         });
         return { content: [{ type: "text", text: asText({ count: items.length, types: listTransformTypes(), items }) }] };
     });
+    // ── 7b. Full operation catalog (all ops + schemas in one call) ───────────
+    server.registerTool(tn("isc.transforms.operationCatalog"), {
+        title: "Full Transform Operation Catalog",
+        description: "Returns EVERYTHING the LLM needs to build any SailPoint ISC transform — all 39 operation types " +
+            "in a single response. For each operation: type key, title, required attributes (with types), " +
+            "optional attributes, attribute constraints, doc URL, scaffold example, and JSON Schema. " +
+            "Call this FIRST before building any transform. Use it to decide which operation(s) to use, " +
+            "understand what attributes are required, and see a working scaffold to start from. " +
+            "This eliminates the need to call catalog, getSchema, and scaffold separately. " +
+            "OFFLINE — no ISC tenant required.",
+        inputSchema: z.object({
+            operation_types: z
+                .array(z.string())
+                .optional()
+                .describe("Optional list of specific operation types to return (e.g. ['dateCompare','dateMath','conditional']). " +
+                "Omit to return all 39 operations."),
+        }),
+    }, async ({ operation_types }) => {
+        const allTypes = listTransformTypes();
+        const requested = operation_types && operation_types.length > 0
+            ? operation_types
+                .map((t) => toCanonicalType(t) ?? t)
+                .filter((t) => allTypes.includes(t))
+            : allTypes;
+        const items = requested.map((t) => {
+            const s = TRANSFORM_CATALOG[t];
+            const schema = getOperationSchema(t);
+            return {
+                type: s.type,
+                title: s.title,
+                doc_url: s.docUrl,
+                required_attributes: s.requiredAttributes ?? [],
+                attributes_optional: Boolean(s.attributesOptional),
+                is_rule_backed: Boolean(s.injectedAttributes),
+                scaffold: s.scaffold(`my-${t}-transform`),
+                json_schema: schema ?? null,
+            };
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: asText({
+                        instruction: "Use this catalog to select the right operation type(s) for the requirement. " +
+                            "Check required_attributes to know what you must supply. " +
+                            "Use scaffold as your starting JSON shape. " +
+                            "Validate and lint the result after building.",
+                        total_operations: items.length,
+                        operations: items,
+                    }),
+                }],
+        };
+    });
     // ── 8. Get JSON Schema for an operation ──────────────────────────────────
     server.registerTool(tn("isc.transforms.getSchema"), {
         title: "Get Operation JSON Schema",

package/dist/transforms/lint.js

@@ -45,7 +45,7 @@ const ALLOWED_ATTRS = {
     rightPad: new Set(["length", "padding", "input"]),
     rule: "open", // rule-specific attributes vary
     split: new Set(["delimiter", "index", "input"]),
-    static: new Set(["value"]),
+    static: "open", // value + any named VTL dynamic variable keys allowed per docs
     substring: new Set(["begin", "end", "input"]),
     trim: new Set(["input"]),
     upper: new Set(["input"]),
@@ -704,9 +704,12 @@ function lintSubstring(attrs) {
 // ---------------------------------------------------------------------------
 function lintStatic(attrs) {
     const msgs = [];
-    if (attrs?.value !== undefined && typeof attrs.value !== "string") {
+    // Presence check is handled by checkRequired (spec.requiredAttributes).
+    // Here we only validate the type when value is present.
+    if (attrs?.value !== undefined && attrs?.value !== null && typeof attrs.value !== "string") {
         push(msgs, "error", "value must be a string.", "attributes.value");
     }
+    // Any other keys in attributes are valid dynamic VTL variable definitions — no unknown-attribute errors.
     return msgs;
 }
 // ---------------------------------------------------------------------------
@@ -835,5 +838,51 @@ export function lintTransform(input) {
         messages.push(...lintRandom(requestedType, attrs));
     if (requestedType === "rfc5646")
         messages.push(...lintRfc5646(attrs));
+    // --- Recursive nested transform lint ---
+    // Recursively lint every nested transform found inside attributes.
+    // We start from normalized.attributes (not the root) to avoid double-linting root.
+    if (normalized.attributes && typeof normalized.attributes === "object") {
+        messages.push(...lintNestedTransforms(normalized.attributes, "attributes"));
+    }
     return { normalized, messages };
 }
+/**
+ * Recursively walks a subtree (starting from a transform's attributes object)
+ * and lints every nested object that carries a 'type' field — i.e. nested transforms.
+ * Reports errors with a path prefix so the user knows exactly where the problem is.
+ */
+function lintNestedTransforms(subtree, path) {
+    if (!subtree || typeof subtree !== "object")
+        return [];
+    const msgs = [];
+    if (Array.isArray(subtree)) {
+        subtree.forEach((item, idx) => {
+            const itemPath = `${path}[${idx}]`;
+            if (item && typeof item === "object" && typeof item.type === "string") {
+                // lintTransform already recurses into the nested transform's own attributes,
+                // so we only call it here — no additional recursion needed.
+                const result = lintTransform(item);
+                result.messages.forEach((m) => msgs.push({ ...m, path: `${itemPath}${m.path ? "." + m.path : ""}` }));
+            }
+            else if (item && typeof item === "object") {
+                msgs.push(...lintNestedTransforms(item, itemPath));
+            }
+        });
+        return msgs;
+    }
+    for (const [key, value] of Object.entries(subtree)) {
+        const childPath = `${path}.${key}`;
+        if (value && typeof value === "object" && typeof value.type === "string") {
+            // Nested transform object — lintTransform handles further recursion internally.
+            const result = lintTransform(value);
+            result.messages.forEach((m) => msgs.push({ ...m, path: `${childPath}${m.path ? "." + m.path : ""}` }));
+        }
+        else if (Array.isArray(value)) {
+            msgs.push(...lintNestedTransforms(value, childPath));
+        }
+        else if (value && typeof value === "object") {
+            msgs.push(...lintNestedTransforms(value, childPath));
+        }
+    }
+    return msgs;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isc-transforms-mcp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "MCP server for SailPoint Identity Security Cloud (ISC) Transform authoring — scaffold, strict lint, catalog, and safe upsert to live tenants.",
   "author": {