isc-transforms-mcp 1.0.1 → 1.0.3

package/README.md

@@ -134,7 +134,7 @@ The 4 tools below connect to a live ISC tenant and require an **Enterprise licen
 | `isc_transforms_upsert` | Create or update with dry-run preview + JSON-Patch diff + lint before write |
 | `isc_transforms_findReferences` | Scan identity profiles for every place a transform is referenced |
 
-**Enterprise plan coming soon** — join the waitlist by opening an [issue](https://github.com/simplifyauth/isc-transforms-mcp/issues) or emailing coalfieldexpress@gmail.com.
+**Enterprise plan coming soon** — [join the waitlist](https://docs.google.com/forms/d/e/1FAIpQLScrSaxD8sev0NuX0t5RXo5B9M0qIz8FQW5Wps2WJAF7fqbs4w/viewform) to be notified when it launches.
 
 Once you have a license key, add it to your Claude Desktop config:
 

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

@@ -835,5 +835,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,11 +1,11 @@
 {
   "name": "isc-transforms-mcp",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "description": "MCP server for SailPoint Identity Security Cloud (ISC) Transform authoring — scaffold, strict lint, catalog, and safe upsert to live tenants.",
   "author": {
     "name": "Amit",
-    "email": "coalfieldexpress@gmail.com"
+    "email": "amit@simplifyauth.com"
   },
   "license": "MIT",
   "keywords": [