@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/metadata/list-chores.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf } from "../format.js";
+import { ChoreItemSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerListChores = defineTool({
+    name: "tm1_list_chores",
+    description: [
+        "List chores in the TM1 server with schedule and assigned processes. compact=true replaces processes[] with processCount; processNameContains filters by referenced process.",
+        "Paginated (default 50/page).",
+    ],
+    annotations: READ_ONLY,
+    output: pageShapeFor(ChoreItemSchema),
+    input: {
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+        compact: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Replace processes[] with processCount (default: false)."),
+        processNameContains: z
+            .string()
+            .optional()
+            .describe("Return only chores whose steps reference a process name containing this substring (case-insensitive)."),
+    },
+    handler: async ({ limit, offset, fetchAll, format, compact, processNameContains }, tm1Client) => {
+        const chores = await tm1Client.chores.list();
+        const filtered = (() => {
+            if (processNameContains === undefined || processNameContains.length === 0)
+                return chores;
+            const needle = processNameContains.toLowerCase();
+            return chores.filter((c) => c.processes.some((p) => p.name.toLowerCase().includes(needle)));
+        })();
+        const projected = compact
+            ? filtered.map((c) => ({
+                name: c.name,
+                active: c.active,
+                startTime: c.startTime,
+                frequency: c.frequency,
+                processCount: c.processes.length,
+            }))
+            : filtered;
+        const page = paginate(projected, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "name",
+            "active",
+            "startTime",
+            "frequency",
+            {
+                header: "processes",
+                get: (c) => "processes" in c
+                    ? c.processes.map((p) => p.name).join(", ")
+                    : `${c.processCount} (compact)`,
+            },
+        ]);
+        return pageResponse(page, format, { title: "Chores", columns });
+    },
+});
+//# sourceMappingURL=list-chores.js.map

package/dist/tools/metadata/list-cubes.d.ts

@@ -0,0 +1,2 @@
+export declare const registerListCubes: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-cubes.d.ts.map

package/dist/tools/metadata/list-cubes.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { compileUserRegex } from "../../lib/safe-regex.js";
+import { compareByName } from "../../tm1-client/services/odata-page.js";
+import { defineTool } from "../define-tool.js";
+import { READ_ONLY } from "../annotations.js";
+import { pageShapeFor } from "../schemas/common.js";
+import { CubeItemSchema } from "../schemas/items.js";
+import { PAGINATION_SCHEMA, paginate, pageFromServer, } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf, } from "../format.js";
+export const registerListCubes = defineTool({
+    name: "tm1_list_cubes",
+    description: [
+        "List cubes in the TM1 server. Control cubes ('}'-prefixed) excluded unless includeControl=true.",
+        "Combinable name filters (nameExact/nameContains/nameRegex) and projection toggles (includeDimensions, includeRules) trim payload on wide models.",
+        "Paginated (default 50/page).",
+    ],
+    annotations: READ_ONLY,
+    output: pageShapeFor(CubeItemSchema),
+    input: {
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include TM1 control cubes whose names start with '}' (default: false)."),
+        includeDimensions: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include the dimensions[] array per cube (default: true). Set false for compact output on wide cubes."),
+        includeRules: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include hasRules:boolean per cube (default: false). Triggers one extra OData $select=Rules; useful for audits to skip cubes without rules."),
+        nameExact: z
+            .string()
+            .optional()
+            .describe("Return only the cube whose name matches exactly (case-sensitive). Fast-path for known cube names; overrides nameContains/nameRegex when set."),
+        nameContains: z
+            .string()
+            .optional()
+            .describe("Case-insensitive substring filter on cube name."),
+        nameRegex: z
+            .string()
+            .optional()
+            .describe("JS regex (case-insensitive) on cube name. Invalid patterns return an error."),
+    },
+    handler: async ({ limit, offset, fetchAll, format, includeControl, includeDimensions, includeRules, nameExact, nameContains, nameRegex, }, tm1Client) => {
+        const project = (list) => list.map((c) => {
+            const out = { name: c.name };
+            if (includeDimensions)
+                out.dimensions = c.dimensions;
+            if (includeRules)
+                out.hasRules = c.hasRules ?? false;
+            return out;
+        });
+        const fullScan = async () => {
+            let cubes = await tm1Client.cubes.list({ includeRules });
+            if (!includeControl) {
+                cubes = cubes.filter((c) => !c.name.startsWith("}"));
+            }
+            if (nameExact !== undefined) {
+                cubes = cubes.filter((c) => c.name === nameExact);
+            }
+            else {
+                if (nameContains !== undefined && nameContains.length > 0) {
+                    const needle = nameContains.toLowerCase();
+                    cubes = cubes.filter((c) => c.name.toLowerCase().includes(needle));
+                }
+                if (nameRegex !== undefined && nameRegex.length > 0) {
+                    const re = compileUserRegex(nameRegex, "i", "nameRegex");
+                    cubes = cubes.filter((c) => re.test(c.name));
+                }
+            }
+            // Match the pushed-down path's $orderby=Name so a given offset means
+            // the same row whichever path served it.
+            return project(cubes.sort(compareByName));
+        };
+        // nameRegex has no OData equivalent, so it must run client-side — and a
+        // client-side filter makes @odata.count count rows the caller can never
+        // reach. nameExact takes precedence over nameContains/nameRegex
+        // (documented), so when it is set the others are not active filters.
+        const usesNameRegex = nameExact === undefined &&
+            nameRegex !== undefined &&
+            nameRegex.length > 0;
+        const canPushDown = !fetchAll && limit > 0 && !usesNameRegex;
+        let page;
+        if (canPushDown) {
+            const { items, total } = await tm1Client.cubes.list({
+                includeRules,
+                includeControl,
+                ...(nameExact !== undefined
+                    ? { nameExact }
+                    : nameContains !== undefined
+                        ? { nameContains }
+                        : {}),
+                page: { top: limit, skip: offset },
+            });
+            // No @odata.count means no honest total, so redo it as a full scan
+            // rather than invent one.
+            page =
+                total === undefined
+                    ? paginate(await fullScan(), limit, offset, fetchAll)
+                    : pageFromServer(project(items), total, offset);
+        }
+        else {
+            page = paginate(await fullScan(), limit, offset, fetchAll);
+        }
+        const columns = columnsOf([
+            "name",
+            // `?? []` would be redundant: an absent array and an empty one both
+            // render as an empty cell.
+            ...(includeDimensions ? ["dimensions"] : []),
+            ...(includeRules
+                ? [
+                    {
+                        header: "hasRules",
+                        get: (c) => c.hasRules ?? false,
+                    },
+                ]
+                : []),
+        ]);
+        return pageResponse(page, format, { title: "Cubes", columns });
+    },
+});
+//# sourceMappingURL=list-cubes.js.map

package/dist/tools/metadata/list-dimensions.d.ts

@@ -0,0 +1,2 @@
+export declare const registerListDimensions: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-dimensions.d.ts.map

package/dist/tools/metadata/list-dimensions.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { decodeTm1Timestamp, normalizeChangedSince, } from "../../tm1-client/services/dimension-service.js";
+import { compareByName } from "../../tm1-client/services/odata-page.js";
+import { PAGINATION_SCHEMA, paginate, pageFromServer } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf, } from "../format.js";
+import { DimensionItemSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerListDimensions = defineTool({
+    name: "tm1_list_dimensions",
+    description: [
+        "List dimensions (with their hierarchy names) in the TM1 server. Control dimensions ('}'-prefixed) excluded unless includeControl=true.",
+        "Optional per-dimension enrichment: includeElementCount/includeElementStats (sizing + per-type breakdown for orphan/double-hierarchy audits), includeLastUpdated/changedSince (schema-change stamp — bumped on metadata edits, NOT on data writes).",
+        "Paginated (default 50/page).",
+    ],
+    annotations: READ_ONLY,
+    output: pageShapeFor(DimensionItemSchema),
+    input: {
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include TM1 control dimensions whose names start with '}' (default: false)"),
+        includeElementCount: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Attach `elementCounts: { hierarchyName: number }` per dimension via OData $count. Single extra server-side aggregation, no N+1. Default false."),
+        includeElementStats: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Attach `elementStats: { hierarchyName: { total, numeric, consolidated, string, maxLevel } }` per dimension. Single round-trip, payload scales with total element count. Use for double-hierarchy audits and orphan detection. Overrides includeElementCount when set. Default false."),
+        includeLastUpdated: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Attach `lastUpdated` (server-local ISO, no Z) per dimension from }DimensionProperties.LAST_TIME_UPDATED — a schema-change stamp. One extra MDX round-trip. Default false."),
+        changedSince: z
+            .string()
+            .optional()
+            .describe("Return only dimensions modified at/after this date or datetime (server-local, e.g. '2026-04-01' or '2026-04-01T08:30:00'). Implies includeLastUpdated. Needs at least a full date."),
+    },
+    handler: async ({ limit, offset, fetchAll, format, includeControl, includeElementCount, includeElementStats, includeLastUpdated, changedSince, }, tm1Client) => {
+        // changedSince filters against }DimensionProperties client-side, so with
+        // it active @odata.count would count dimensions the caller never sees.
+        // includeLastUpdated alone only enriches rows and drops none, so it stays
+        // eligible — the stamp lookup is by name and works on a page just as well.
+        const canPushDown = !fetchAll && limit > 0 && changedSince === undefined;
+        const paged = canPushDown
+            ? await tm1Client.dimensions.list({
+                includeElementCount,
+                includeElementStats,
+                includeControl,
+                page: { top: limit, skip: offset },
+            })
+            : undefined;
+        const serverTotal = paged?.total;
+        // Ineligible, or the server omitted @odata.count: fall back to the full
+        // scan rather than report a total we cannot stand behind.
+        let dimensions = paged !== undefined && serverTotal !== undefined
+            ? paged.items
+            : (await tm1Client.dimensions.list({
+                includeElementCount,
+                includeElementStats,
+            }))
+                .filter((d) => includeControl || !d.name.startsWith("}"))
+                // Match the pushed-down path's $orderby=Name so a given offset
+                // means the same row whichever path served it.
+                .sort(compareByName);
+        const wantLastUpdated = includeLastUpdated || changedSince !== undefined;
+        if (wantLastUpdated) {
+            // Invalid changedSince throws TM1Error(VALIDATION_ERROR); the index.ts
+            // proxy formats it into the uniform error envelope.
+            const since = changedSince !== undefined
+                ? normalizeChangedSince(changedSince)
+                : undefined;
+            // }DimensionProperties is a control cube — a caller without read rights
+            // gets a security error. When changedSince was requested the filter
+            // can't be honoured, so surface it; when only includeLastUpdated was
+            // asked, degrade to lastUpdated:null so the base dimension list survives.
+            let stamps;
+            try {
+                stamps = await tm1Client.dimensions.getLastUpdatedMap();
+            }
+            catch (err) {
+                if (since !== undefined)
+                    throw err;
+                stamps = new Map();
+            }
+            dimensions = dimensions.map((d) => ({
+                ...d,
+                lastUpdated: decodeTm1Timestamp(stamps.get(d.name) ?? null),
+            }));
+            if (since !== undefined) {
+                dimensions = dimensions.filter((d) => {
+                    const raw = stamps.get(d.name);
+                    return raw !== undefined && raw >= since;
+                });
+            }
+        }
+        const page = serverTotal !== undefined
+            ? pageFromServer(dimensions, serverTotal, offset)
+            : paginate(dimensions, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "name",
+            "hierarchies",
+            ...(includeElementStats
+                ? [
+                    {
+                        header: "elementStats",
+                        get: (d) => d.elementStats ?? {},
+                    },
+                ]
+                : includeElementCount
+                    ? [
+                        {
+                            header: "elementCounts",
+                            get: (d) => d.elementCounts ?? {},
+                        },
+                    ]
+                    : []),
+            ...(wantLastUpdated ? ["lastUpdated"] : []),
+        ]);
+        return pageResponse(page, format, { title: "Dimensions", columns });
+    },
+});
+//# sourceMappingURL=list-dimensions.js.map

package/dist/tools/metadata/list-processes-grouped.d.ts

@@ -0,0 +1,2 @@
+export declare const registerListProcessesGrouped: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-processes-grouped.d.ts.map

package/dist/tools/metadata/list-processes-grouped.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { compileUserRegex } from "../../lib/safe-regex.js";
+import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
+import { ProcessesGroupedResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerListProcessesGrouped = defineTool({
+    name: "tm1_list_processes_grouped",
+    description: [
+        "Group TI processes by name prefix to give a structural overview without listing every process.",
+        "Returns groups sorted by count descending. Use tm1_list_processes(nameContains=...) to drill into a group.",
+        "prefixSegments controls how many '_'-delimited segments form the group key (default 1: '020_Parameter_...' → '020').",
+        "Set includeNames=true to get the full process list per group for targeted follow-up.",
+    ],
+    annotations: READ_ONLY,
+    output: ProcessesGroupedResultSchema,
+    input: {
+        ...FORMAT_SCHEMA,
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include control processes ('}'-prefixed). Default: false."),
+        prefixSegments: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .default(1)
+            .describe("Number of '_'-delimited segments to use as group key. Default 1: '020_Param_Load' → '020'. Use 2 for '020_Param'."),
+        includeNames: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Add processes[] array of names to each group. Default false — summary only."),
+        minCount: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Only return groups with at least this many processes. Useful to hide one-off processes."),
+        excludePattern: z
+            .string()
+            .optional()
+            .describe("JS-compatible regex (case-insensitive) — drop processes whose name matches before grouping. E.g. '^Bedrock\\.' to hide Bedrock utility processes."),
+    },
+    handler: async ({ format, includeControl, prefixSegments, includeNames, minCount, excludePattern, }, tm1Client) => {
+        let processes = await tm1Client.processes.list();
+        if (!includeControl)
+            processes = processes.filter((p) => !p.name.startsWith("}"));
+        if (excludePattern) {
+            const re = compileUserRegex(excludePattern, "i", "excludePattern");
+            processes = processes.filter((p) => !re.test(p.name));
+        }
+        const groupMap = new Map();
+        for (const p of processes) {
+            const segments = p.name.split("_");
+            const prefix = segments.slice(0, prefixSegments).join("_");
+            const group = groupMap.get(prefix);
+            if (group)
+                group.push(p.name);
+            else
+                groupMap.set(prefix, [p.name]);
+        }
+        let groups = Array.from(groupMap.entries())
+            .map(([prefix, names]) => ({
+            prefix,
+            count: names.length,
+            ...(includeNames ? { processes: names.sort() } : {}),
+        }))
+            .sort((a, b) => b.count - a.count);
+        if (minCount !== undefined)
+            groups = groups.filter((g) => g.count >= minCount);
+        const payload = {
+            totalProcesses: processes.length,
+            groupCount: groups.length,
+            prefixSegments,
+            groups,
+        };
+        const columns = columnsOf([
+            "prefix",
+            "count",
+            ...(includeNames
+                ? [
+                    {
+                        header: "processes",
+                        get: (g) => ("processes" in g ? g.processes : []),
+                    },
+                ]
+                : []),
+        ]);
+        return payloadResponse(payload, format, (p) => `## Processes grouped by prefix\n\n${p.totalProcesses} processes · ${p.groupCount} groups · prefixSegments=${p.prefixSegments}\n\n${renderTable(p.groups, columns)}`);
+    },
+});
+//# sourceMappingURL=list-processes-grouped.js.map

package/dist/tools/metadata/list-processes.d.ts

@@ -0,0 +1,2 @@
+export declare const registerListProcesses: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-processes.d.ts.map

package/dist/tools/metadata/list-processes.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { compileUserRegex } from "../../lib/safe-regex.js";
+import { compareByName } from "../../tm1-client/services/odata-page.js";
+import { PAGINATION_SCHEMA, paginate, pageFromServer, } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf } from "../format.js";
+import { ProcessItemSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerListProcesses = defineTool({
+    name: "tm1_list_processes",
+    description: [
+        "List TurboIntegrator processes (with parameters) in the TM1 server. Control processes ('}'-prefixed) excluded unless includeControl=true.",
+        "Name filters (nameContains/nameRegex/nameNotContains/excludePattern) and fields=['name'] projection trim payload on large models.",
+        "Paginated (default 50/page).",
+    ],
+    annotations: READ_ONLY,
+    output: pageShapeFor(ProcessItemSchema),
+    input: {
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include TM1 control processes whose names start with '}' (default: false)"),
+        nameContains: z
+            .string()
+            .optional()
+            .describe("Case-insensitive substring filter on process name."),
+        nameRegex: z
+            .string()
+            .optional()
+            .describe("JS-compatible regex tested against process name (case-insensitive)."),
+        nameNotContains: z
+            .string()
+            .optional()
+            .describe("Case-insensitive substring filter — drop processes whose name contains this substring (e.g. 'TEST', '###NSCH')."),
+        excludePattern: z
+            .string()
+            .optional()
+            .describe("JS-compatible regex (case-insensitive) — drop processes whose name matches. Useful for separator dummies and test patterns, e.g. '^[#-]|^Bedrock\\\\.'."),
+        fields: z
+            .array(z.enum(["name", "parameters"]))
+            .optional()
+            .describe("Projection. Default: all fields. Use ['name'] to skip parameters[] and shrink payload ~10x."),
+    },
+    handler: async ({ limit, offset, fetchAll, format, includeControl, nameContains, nameRegex, nameNotContains, excludePattern, fields, }, tm1Client) => {
+        const project = (list) => fields && !fields.includes("parameters")
+            ? list.map((p) => ({ name: p.name }))
+            : list;
+        const fullScan = async () => {
+            let processes = await tm1Client.processes.list();
+            if (!includeControl)
+                processes = processes.filter((p) => !p.name.startsWith("}"));
+            if (nameContains) {
+                const needle = nameContains.toLowerCase();
+                processes = processes.filter((p) => p.name.toLowerCase().includes(needle));
+            }
+            if (nameRegex) {
+                const re = compileUserRegex(nameRegex, "i", "nameRegex");
+                processes = processes.filter((p) => re.test(p.name));
+            }
+            if (nameNotContains) {
+                const needle = nameNotContains.toLowerCase();
+                processes = processes.filter((p) => !p.name.toLowerCase().includes(needle));
+            }
+            if (excludePattern) {
+                const re = compileUserRegex(excludePattern, "i", "excludePattern");
+                processes = processes.filter((p) => !re.test(p.name));
+            }
+            // Match the pushed-down path's $orderby=Name so a given offset means
+            // the same row whichever path served it.
+            return project(processes.sort(compareByName));
+        };
+        // Regex filters have no OData equivalent and must run client-side, which
+        // would make @odata.count count rows the caller can never reach.
+        const canPushDown = !fetchAll && limit > 0 && !nameRegex && !excludePattern;
+        let page;
+        if (canPushDown) {
+            const { items, total } = await tm1Client.processes.list({
+                includeControl,
+                ...(nameContains ? { nameContains } : {}),
+                ...(nameNotContains ? { nameNotContains } : {}),
+                page: { top: limit, skip: offset },
+            });
+            // No @odata.count means no honest total, so redo it as a full scan.
+            page =
+                total === undefined
+                    ? paginate(await fullScan(), limit, offset, fetchAll)
+                    : pageFromServer(project(items), total, offset);
+        }
+        else {
+            page = paginate(await fullScan(), limit, offset, fetchAll);
+        }
+        const columns = columnsOf([
+            "name",
+            {
+                header: "parameters",
+                get: (p) => "parameters" in p
+                    ? (p.parameters?.map((x) => x.name).join(", ") ?? "")
+                    : "—",
+            },
+        ]);
+        return pageResponse(page, format, { title: "Processes", columns });
+    },
+});
+//# sourceMappingURL=list-processes.js.map

package/dist/tools/metadata/resolve-default-members.d.ts

@@ -0,0 +1,2 @@
+export declare const registerResolveDefaultMembers: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=resolve-default-members.d.ts.map

package/dist/tools/metadata/resolve-default-members.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { DefaultMembersBulkResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerResolveDefaultMembers = defineTool({
+    name: "tm1_resolve_default_members",
+    description: [
+        "Resolve N hierarchies' effective default members in parallel from one tool call; pass items:[{dimensionName}] with a single entry for a one-off lookup.",
+        "Designed for view-construction workflows where 8+ slicer dimensions previously required dozens of sequential round-trips.",
+        "Each result carries its own source/confidence/alternatives so callers can audit per-dimension reliability.",
+        "Per-item failures surface as result entries with an `error` field instead of `resolved`; the call itself does not fail unless input is empty/invalid.",
+    ],
+    annotations: READ_ONLY,
+    output: DefaultMembersBulkResultSchema,
+    input: {
+        items: z
+            .array(z.object({
+            dimensionName: z.string(),
+            hierarchyName: z.string().optional(),
+        }))
+            .min(1)
+            .max(64)
+            .describe("List of {dimensionName, hierarchyName?} pairs. Capped at 64 per call to bound parallelism."),
+    },
+    handler: async ({ items }, tm1Client) => {
+        const settled = await Promise.allSettled(items.map((it) => tm1Client.dimensions.resolveDefaultMember(it.dimensionName, it.hierarchyName)));
+        const results = settled.map((s, i) => {
+            if (s.status === "fulfilled")
+                return s.value;
+            const err = s.reason;
+            const item = items[i]; // settled.length === items.length
+            const message = err instanceof Error ? err.message : String(err);
+            const code = err instanceof TM1Error ? err.code : TM1ErrorCode.TM1_ERROR;
+            return {
+                dimension: item.dimensionName,
+                hierarchy: item.hierarchyName ?? item.dimensionName,
+                error: { code, message },
+            };
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify({ results }) }],
+        };
+    },
+});
+//# sourceMappingURL=resolve-default-members.js.map

package/dist/tools/model-building/check-cube-rule.d.ts

@@ -0,0 +1,2 @@
+export declare const registerCheckCubeRule: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=check-cube-rule.d.ts.map

package/dist/tools/model-building/check-cube-rule.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { RULES_SOURCE_SCHEMA, resolveRulesText } from "./rules-source.js";
+export const registerCheckCubeRule = defineTool({
+    name: "tm1_check_cube_rule",
+    description: [
+        "Validate the syntax of a TM1 cube rule WITHOUT applying it.",
+        "Returns 'valid' or a list of syntax errors with line numbers.",
+        "Takes the same sources as tm1_set_cube_rules — rules, edits or filePath — and checks the full resulting text, so an edits patch is validated exactly as it would be installed. tm1_set_cube_rules runs this check itself before writing.",
+    ],
+    annotations: READ_ONLY,
+    output: {
+        ok: z.boolean(),
+        cube: z.string(),
+        lineCount: z.number().int(),
+        errorCount: z.number().int(),
+        errors: z.array(z.object({
+            lineNumber: z.number().int().optional(),
+            message: z.string(),
+        })),
+    },
+    input: {
+        cubeName: z.string().describe("Cube name (case-sensitive)"),
+        ...RULES_SOURCE_SCHEMA,
+    },
+    handler: async ({ cubeName, rules, edits, filePath }, tm1Client) => {
+        const { text } = await resolveRulesText(tm1Client, cubeName, {
+            rules,
+            edits,
+            filePath,
+        });
+        const errors = await tm1Client.cubes.checkRule(cubeName, text);
+        const ok = errors.length === 0;
+        const payload = {
+            ok,
+            cube: cubeName,
+            lineCount: text.split("\n").length,
+            errorCount: errors.length,
+            errors: errors.map((e) => ({
+                lineNumber: e.lineNumber,
+                message: e.message,
+            })),
+        };
+        return {
+            isError: !ok || undefined,
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+        };
+    },
+});
+//# sourceMappingURL=check-cube-rule.js.map

package/dist/tools/model-building/clear-cube.d.ts

@@ -0,0 +1,2 @@
+export declare const registerClearCube: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=clear-cube.d.ts.map