@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/model-building/clear-cube.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerClearCube = defineTool({
+    name: "tm1_clear_cube",
+    description: [
+        "Clear a subset of cells from a cube. For each dimension, pass either specific element names or an empty array to select all elements (wildcard).",
+        "The dimensions array must match the cube's dimension order. Consolidated elements expand to their leaves. Prefer TI for reproducible loads — this is for ad-hoc resets.",
+        "Irreversible: cleared cells return zero/empty on next read. Safety: pass confirm=<cube name verbatim>. Mismatched confirm rejects the call.",
+        "Before: tm1_sample_cells to confirm the slice you intend to wipe.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        cubeName: z.string().describe("Cube to clear"),
+        dimensions: z.array(z.string()).describe("Cube's dimensions in order"),
+        tuples: z
+            .array(z.array(z.string()))
+            .describe("Per-dimension element lists (same length as dimensions). Empty array = all elements on that dimension."),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ cubeName, dimensions, tuples, confirm }, tm1Client) => {
+        requireConfirm(confirm, cubeName, "cube");
+        if (dimensions.length !== tuples.length) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `dimensions (${dimensions.length}) and tuples (${tuples.length}) must have the same length.`,
+                    },
+                ],
+            };
+        }
+        await tm1Client.cubes.clear(cubeName, dimensions, tuples);
+        const summary = dimensions
+            // dimensions.length === tuples.length is guarded above
+            .map((d, i) => `${d}=${tuples[i].length === 0 ? "*" : tuples[i].join("|")}`)
+            .join(", ");
+        return actionResponse({ success: true, cubeName, summary });
+    },
+});
+//# sourceMappingURL=clear-cube.js.map

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

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

package/dist/tools/model-building/create-cube.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerCreateCube = defineTool({
+    name: "tm1_create_cube",
+    description: [
+        "Create a new TM1 cube with the specified dimensions.",
+        "The dimension order matters for performance: put dimensions used most often in WHERE clauses first.",
+        "All referenced dimensions must exist before calling this tool.",
+        "Fails if a cube with the same name already exists — no idempotent variant; delete first with tm1_delete_cube if you intend to replace.",
+        "After: tm1_set_cube_rules for calculations, tm1_create_mdx_view for default slices.",
+    ],
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        cubeName: z.string().describe("Cube name"),
+        dimensions: z
+            .array(z.string())
+            .min(2)
+            .describe("Ordered list of dimension names. Order affects query performance."),
+    },
+    handler: async ({ cubeName, dimensions }, tm1Client) => {
+        await tm1Client.cubes.create(cubeName, dimensions);
+        return actionResponse({
+            success: true,
+            cubeName,
+            dimensionCount: dimensions.length,
+            dimensions,
+        });
+    },
+});
+//# sourceMappingURL=create-cube.js.map

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

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

package/dist/tools/model-building/delete-cube.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { actionResponse } from "../format.js";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { withToolHint } from "../error-format.js";
+export const registerDeleteCube = defineTool({
+    name: "tm1_delete_cube",
+    description: [
+        "Delete a TM1 cube and all its data. This action is irreversible.",
+        "Safety: pass confirm=<cube name verbatim>. Mismatched confirm rejects the call.",
+        "Before: tm1_analyze_object_usage to find rules or processes referencing the cube; tm1_get_cube_stats to size the data loss.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        cubeName: z.string().describe("Cube name (case-sensitive)"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ cubeName, confirm }, tm1Client) => {
+        requireConfirm(confirm, cubeName, "cube");
+        await withToolHint(tm1Client.cubes.delete(cubeName), "Cube delete failed. Common causes: cube still referenced by TI processes / chores / rules (run tm1_analyze_object_usage to inspect), insufficient permissions, or cube does not exist (tm1_list_cubes to verify name + casing).");
+        return actionResponse({ success: true, cubeName });
+    },
+});
+//# sourceMappingURL=delete-cube.js.map

package/dist/tools/model-building/get-all-cube-rules.d.ts

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

package/dist/tools/model-building/get-all-cube-rules.js

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import { CubeRulesSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+// Default cap for full-rules responses. Whole-model rule dumps flood the
+// context window; 50 cubes is plenty for a first look, and the response
+// reports truncated=true so agents know to raise limit (or pass 0 for all).
+const DEFAULT_LIMIT = 50;
+// Best-effort summary parser. TM1 rule grammar is loose; the goal is a useful
+// approximation, not perfect parse. Strips block (/* */) and line (#) comments
+// before counting, splits on the FEEDERS; section boundary, and extracts cube
+// references from DB('Cube', ...) calls.
+function summarize(rulesText) {
+    const lines = rulesText.split(/\r?\n/);
+    let commentLineCount = 0;
+    let feederBoundary = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("#"))
+            commentLineCount++;
+        if (feederBoundary < 0 && /^FEEDERS\s*;/i.test(trimmed))
+            feederBoundary = i;
+    }
+    const stripBlock = (s) => s.replace(/\/\*[\s\S]*?\*\//g, "");
+    const stripLine = (s) => s.replace(/^[ \t]*#.*$/gm, "");
+    const rulesPart = feederBoundary >= 0 ? lines.slice(0, feederBoundary).join("\n") : rulesText;
+    const feedersPart = feederBoundary >= 0 ? lines.slice(feederBoundary + 1).join("\n") : "";
+    const cleanRules = stripLine(stripBlock(rulesPart));
+    const cleanFeeders = stripLine(stripBlock(feedersPart));
+    const ruleCount = (cleanRules.match(/;/g) ?? []).length;
+    const feederCount = (cleanFeeders.match(/=>/g) ?? []).length;
+    const cubeRefs = new Set();
+    for (const m of stripBlock(rulesText).matchAll(/\bDB\s*\(\s*['"]([^'"]+)['"]/gi)) {
+        cubeRefs.add(m[1]);
+    }
+    return {
+        lineCount: lines.length,
+        ruleCount,
+        feederCount,
+        commentLineCount,
+        referencedCubes: [...cubeRefs].sort(),
+    };
+}
+export const registerGetAllCubeRules = defineTool({
+    name: "tm1_get_all_cube_rules",
+    description: [
+        "Bulk-load rules text for every cube in one call.",
+        "Cubes without rules are returned with empty rulesText.",
+        "Control cubes (names starting with '}') excluded by default.",
+        "Full-rules responses are capped at 50 cubes by default (ordered by name; truncated=true when capped — raise limit or pass limit=0 for all).",
+        "Use summary=true to replace rulesText with aggregate metrics (lineCount, ruleCount, feederCount, commentLineCount, referencedCubes) — typical 50–100x payload shrink for rules surveys; summary mode surveys ALL cubes by default.",
+    ],
+    annotations: READ_ONLY,
+    output: {
+        count: z
+            .number()
+            .int()
+            .describe("Total cubes matched before limit (lower bound if countIsExact=false)"),
+        countIsExact: z
+            .boolean()
+            .describe("False when count is only a lower bound"),
+        returned: z.number().int().describe("Cubes in this response after limit"),
+        truncated: z.boolean().describe("True when limit dropped cubes"),
+        cubes: z.array(CubeRulesSchema).describe("Per-cube rule bundles"),
+    },
+    input: {
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include TM1 control cubes whose names start with '}' (default: false)"),
+        onlyWithRules: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Return only cubes that have non-empty rules text (default: false)"),
+        summary: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Drop rulesText, return aggregate metrics per cube instead (default: false)"),
+        limit: z
+            .number()
+            .int()
+            .min(0)
+            .max(500)
+            .optional()
+            .describe("Max cubes returned (default 50, max 500, 0 = all). Summary mode defaults to 0 (full survey)."),
+    },
+    handler: async ({ includeControl, onlyWithRules, summary, limit }, tm1Client) => {
+        // Full-rules mode default-caps at DEFAULT_LIMIT; summary mode defaults
+        // to the whole model (metrics are cheap and a partial survey would be
+        // misleading). Explicit limit wins in both modes; 0 = no cap.
+        const cap = limit ?? (summary ? 0 : DEFAULT_LIMIT);
+        let sliced;
+        let count;
+        let countIsExact;
+        let truncated;
+        if (cap > 0 && !onlyWithRules) {
+            // Server-side cap: $top=cap+1 sentinel detects truncation even if the
+            // server omits @odata.count; $orderby=Name keeps the cut stable.
+            const { items, total } = await tm1Client.cubes.getAllRules(includeControl, cap + 1);
+            truncated = items.length > cap;
+            sliced = truncated ? items.slice(0, cap) : items;
+            // Truncated without @odata.count only proves "more than cap" — then
+            // count is a lower bound, flagged via countIsExact.
+            countIsExact = !truncated || total !== undefined;
+            count = total ?? items.length;
+        }
+        else {
+            // onlyWithRules can't be expressed server-side (whitespace-only rules
+            // must not count), so that path fetches all and caps client-side —
+            // count/truncated then reflect the post-filter set, like before.
+            let all = await tm1Client.cubes.getAllRules(includeControl);
+            if (onlyWithRules)
+                all = all.filter((c) => c.rulesText.trim().length > 0);
+            count = all.length;
+            countIsExact = true;
+            truncated = cap > 0 && all.length > cap;
+            if (truncated) {
+                // Match the server-capped path's deterministic name-ordered cut.
+                all = [...all].sort((a, b) => a.cubeName.localeCompare(b.cubeName));
+            }
+            sliced = truncated ? all.slice(0, cap) : all;
+        }
+        const cubes = summary
+            ? sliced.map((c) => ({
+                cubeName: c.cubeName,
+                skipCheck: c.skipCheck,
+                ...summarize(c.rulesText),
+            }))
+            : sliced;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        count,
+                        countIsExact,
+                        returned: cubes.length,
+                        truncated,
+                        cubes,
+                    }),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=get-all-cube-rules.js.map

package/dist/tools/model-building/get-cube-rules.d.ts

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

package/dist/tools/model-building/get-cube-rules.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { CubeRulesSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { outlineRules, sliceLines, splitLines, } from "../../lib/rules-outline.js";
+export const registerGetCubeRules = defineTool({
+    name: "tm1_get_cube_rules",
+    description: [
+        "Get the current rules text for a TM1 cube. Returns empty string if no rules are defined.",
+        "Large rule files: outline=true lists the section markers (SKIPCHECK, FEEDERS, comment headers) with line numbers and lineCount; then lineRange=[from, to] reads just that slice.",
+    ],
+    annotations: READ_ONLY,
+    output: CubeRulesSchema,
+    input: {
+        cubeName: z.string().describe("Cube name (case-sensitive)"),
+        outline: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Return section markers with 1-based line numbers and lineCount instead of the text."),
+        lineRange: z
+            .array(z.number().int().positive())
+            .length(2)
+            .optional()
+            .describe("[from, to], 1-based inclusive: return only these lines, verbatim (clamped to the text)."),
+    },
+    handler: async ({ cubeName, outline, lineRange }, tm1Client) => {
+        if (outline && lineRange !== undefined) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "outline and lineRange are mutually exclusive — pass one.",
+            });
+        }
+        const [from, to] = lineRange ?? [];
+        if (from !== undefined && to !== undefined && from > to) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `lineRange [${from}, ${to}] is inverted — from must be ≤ to.`,
+            });
+        }
+        const rules = await tm1Client.cubes.getRules(cubeName);
+        const text = rules.rulesText ?? "";
+        let output = { ...rules };
+        if (outline) {
+            const { outline: entries, truncated } = outlineRules(text);
+            const { rulesText: _omit, ...rest } = rules;
+            output = {
+                ...rest,
+                lineCount: text === "" ? 0 : splitLines(text).length,
+                outline: entries,
+                ...(truncated ? { outlineTruncated: true } : {}),
+            };
+        }
+        else if (from !== undefined && to !== undefined) {
+            const slice = sliceLines(text, from, to);
+            output = {
+                ...rules,
+                rulesText: slice.text,
+                lineCount: splitLines(text).length,
+                lineRange: [slice.from, slice.to],
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(output) }],
+        };
+    },
+});
+//# sourceMappingURL=get-cube-rules.js.map

package/dist/tools/model-building/rules-source.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { TM1Client } from "../../tm1-client.js";
+import { type RulesEdit } from "../../lib/rules-patch.js";
+export declare const RULES_SOURCE_SCHEMA: {
+    rules: z.ZodOptional<z.ZodString>;
+    edits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        find: z.ZodString;
+        replace: z.ZodString;
+    }, z.core.$strip>>>;
+    filePath: z.ZodOptional<z.ZodString>;
+};
+export interface RulesSource {
+    rules?: string | undefined;
+    edits?: RulesEdit[] | undefined;
+    filePath?: string | undefined;
+}
+export declare function resolveRulesText(tm1Client: TM1Client, cubeName: string, { rules, edits, filePath }: RulesSource): Promise<{
+    text: string;
+    mode: "full" | "patch" | "file";
+}>;
+//# sourceMappingURL=rules-source.d.ts.map

package/dist/tools/model-building/rules-source.js

@@ -0,0 +1,49 @@
+// The three ways a caller hands over rule text — full `rules`, an `edits`
+// patch against the stored text, or a host `filePath` — resolved to the one
+// full text TM1 will see. Shared by tm1_set_cube_rules (what gets written)
+// and tm1_check_cube_rule (what gets validated), so a patch can be checked
+// exactly as it will be installed without the caller rebuilding the file.
+import { promises as fs } from "node:fs";
+import { z } from "zod";
+import { applyRulesPatch } from "../../lib/rules-patch.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { resolveLocalPath } from "../local-file.js";
+export const RULES_SOURCE_SCHEMA = {
+    rules: z
+        .string()
+        .optional()
+        .describe("Full rules text. Put SKIPCHECK; first and a FEEDERS; section after the rule statements — SKIPCHECK is a line in this text, there is no separate switch for it."),
+    edits: z
+        .array(z.object({ find: z.string(), replace: z.string() }))
+        .min(1)
+        .optional()
+        .describe("Patch: applied in order to the current rules; each find must occur exactly once (quote a get_cube_rules lineRange slice verbatim). Line endings are normalized."),
+    filePath: z
+        .string()
+        .optional()
+        .describe("Absolute host path of a full rules file. Disabled unless TM1_LOCAL_FILE_ROOT is set; must resolve within it."),
+};
+export async function resolveRulesText(tm1Client, cubeName, { rules, edits, filePath }) {
+    const sources = [rules, edits, filePath].filter((s) => s !== undefined);
+    if (sources.length !== 1) {
+        throw new TM1Error({
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `Pass exactly one of rules, edits or filePath (got ${sources.length}).`,
+        });
+    }
+    if (edits !== undefined) {
+        const current = await tm1Client.cubes.getRules(cubeName);
+        return {
+            text: applyRulesPatch(current.rulesText ?? "", edits),
+            mode: "patch",
+        };
+    }
+    if (filePath !== undefined) {
+        return {
+            text: await fs.readFile(resolveLocalPath(filePath), "utf8"),
+            mode: "file",
+        };
+    }
+    return { text: rules, mode: "full" };
+}
+//# sourceMappingURL=rules-source.js.map

package/dist/tools/model-building/search-rules.d.ts

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

package/dist/tools/model-building/search-rules.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+import { compileUserRegex } from "../../lib/safe-regex.js";
+import { FORMAT_SCHEMA, wrappedPageResponse, columnsOf } from "../format.js";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { READ_ONLY } from "../annotations.js";
+import { SearchRulesResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerSearchRules = defineTool({
+    name: "tm1_search_rules",
+    description: [
+        "Regex search across cube rules text.",
+        "Returns matches with cube name and line number.",
+        "Use tm1_get_cube_rules on a hit to inspect the full rules.",
+        "Analogue of tm1_search_code for TI processes.",
+    ],
+    annotations: READ_ONLY,
+    output: SearchRulesResultSchema,
+    input: {
+        pattern: z
+            .string()
+            .describe("Regex pattern (JavaScript flavor). Anchors and groups supported."),
+        cubes: z
+            .array(z.string())
+            .optional()
+            .describe("Limit search to these cube names (case-sensitive). Default: all cubes."),
+        caseSensitive: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Case-sensitive match (default false)"),
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include control cubes ('}'-prefixed). Default false."),
+        includeFeeders: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include lines after the FEEDERS marker. Set false to restrict to rule lines only."),
+        context: z
+            .number()
+            .int()
+            .min(0)
+            .max(10)
+            .optional()
+            .default(0)
+            .describe("Lines of surrounding context above and below each match (default 0). Max 10."),
+        maxMatchesPerCube: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .default(50)
+            .describe("Cap matches per cube (default 50)"),
+        maxTotalMatches: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .default(500)
+            .describe("Hard cap on total matches (default 500)"),
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ pattern, cubes: cubeFilter, caseSensitive, includeControl, includeFeeders, context: ctxLines, maxMatchesPerCube, maxTotalMatches, limit, offset, fetchAll, format, }, tm1Client) => {
+        const flags = caseSensitive ? "g" : "gi";
+        const regex = compileUserRegex(pattern, flags);
+        const allRules = await tm1Client.cubes.getAllRules(includeControl);
+        const cubeSet = cubeFilter && cubeFilter.length > 0 ? new Set(cubeFilter) : null;
+        const FEEDERS_RE = /^\s*FEEDERS\s*;?\s*$/i;
+        const matches = [];
+        let truncated = false;
+        let cubesScanned = 0;
+        outer: for (const cubeRules of allRules) {
+            if (cubeSet && !cubeSet.has(cubeRules.cubeName))
+                continue;
+            if (!cubeRules.rulesText)
+                continue;
+            cubesScanned++;
+            const lines = cubeRules.rulesText.split(/\r?\n/);
+            let inFeeders = false;
+            let perCube = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const raw = lines[i];
+                if (FEEDERS_RE.test(raw))
+                    inFeeders = true;
+                if (inFeeders && !includeFeeders)
+                    continue;
+                regex.lastIndex = 0;
+                if (!regex.test(raw))
+                    continue;
+                const ctx = [];
+                if (ctxLines > 0) {
+                    for (let c = Math.max(0, i - ctxLines); c <= Math.min(lines.length - 1, i + ctxLines); c++) {
+                        if (c !== i)
+                            ctx.push(lines[c].trim().slice(0, 200));
+                    }
+                }
+                matches.push({
+                    cube: cubeRules.cubeName,
+                    line: i + 1,
+                    text: raw.trim().slice(0, 240),
+                    context: ctx,
+                });
+                perCube++;
+                if (matches.length >= maxTotalMatches) {
+                    truncated = true;
+                    break outer;
+                }
+                if (perCube >= maxMatchesPerCube)
+                    break;
+            }
+        }
+        const page = paginate(matches, limit, offset, fetchAll);
+        const wrapper = {
+            pattern,
+            caseSensitive,
+            cubesScanned,
+            matchCount: matches.length,
+            truncated,
+            includeFeeders,
+            ...page,
+        };
+        const columns = columnsOf(["cube", "line", "text"]);
+        return wrappedPageResponse(wrapper, page, format, {
+            title: `Rules search: ${pattern}`,
+            columns,
+        });
+    },
+});
+//# sourceMappingURL=search-rules.js.map

package/dist/tools/model-building/set-cube-rules.d.ts

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

package/dist/tools/model-building/set-cube-rules.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { invalidateCallgraphCache } from "../../lib/callgraph/tm1-adapter.js";
+import { TM1ErrorCode } from "../../types.js";
+import { withToolHint } from "../error-format.js";
+import { actionResponse } from "../format.js";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { IDEMPOTENT_DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { RULES_SOURCE_SCHEMA, resolveRulesText } from "./rules-source.js";
+export const registerSetCubeRules = defineTool({
+    name: "tm1_set_cube_rules",
+    description: [
+        "Create or replace the rules for a TM1 cube.",
+        "SKIPCHECK; belongs at the top and FEEDERS; before all feeder definitions — SKIPCHECK is what makes feeders take effect, so rules with feeders need it.",
+        "Pass exactly one source: rules (the full text — replaces everything), edits (find/replace patch against the current text; each find must match exactly once, else nothing is written), or filePath (full text from a host file under TM1_LOCAL_FILE_ROOT).",
+        "The full resulting text is syntax-checked before anything is written (preflight). After: tm1_get_cube_rules to read back; the callgraph cache is dropped automatically.",
+    ],
+    annotations: IDEMPOTENT_DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        cubeName: z.string().describe("Cube name (case-sensitive)"),
+        ...RULES_SOURCE_SCHEMA,
+        ...CONFIRM_SCHEMA,
+        preflight: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Before writing, syntax-check the full text as it will be installed (tm1.CheckRules) and abort on any error. Default true."),
+    },
+    handler: async ({ cubeName, rules, edits, filePath, confirm, preflight }, tm1Client) => {
+        // Replaces the cube's ENTIRE rule file; the previous text is not
+        // recoverable through this API. Guards against accidental invocation —
+        // not a security control.
+        requireConfirm(confirm, cubeName, "cube");
+        const { text, mode } = await resolveRulesText(tm1Client, cubeName, {
+            rules,
+            edits,
+            filePath,
+        });
+        // TM1 11.8 stores rule text with syntax errors without complaint (verified
+        // live: `['X'] = N: ['A'] * 2 +;` saved and read back). The cube then
+        // computes nothing for those cells until someone notices. CheckRules is
+        // the only gate, so it runs here rather than being left to the caller.
+        if (preflight) {
+            const errors = await tm1Client.cubes.checkRule(cubeName, text);
+            if (errors.length > 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                stage: "preflight",
+                                check: "syntax",
+                                cubeName,
+                                code: TM1ErrorCode.VALIDATION_ERROR,
+                                message: `Preflight rule check failed: ${errors.length} error(s). Nothing was written.`,
+                                hint: "Fix the lines in errors[] (lineNumber is in the full resulting text, after edits are applied). preflight:false skips the check; TM1 would store the broken text.",
+                                errors,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        await withToolHint(tm1Client.cubes.updateRules(cubeName, text), `Inspect details for the offending line.`);
+        const lineCount = text.split("\n").length;
+        // Rule changes shift call edges (DB(), feeders) — drop callgraph TTL early.
+        const { cleared: callgraphEntriesCleared } = invalidateCallgraphCache();
+        return actionResponse({
+            success: true,
+            cubeName,
+            mode,
+            lineCount,
+            ...(edits !== undefined ? { editsApplied: edits.length } : {}),
+            callgraphEntriesCleared,
+        });
+    },
+});
+//# sourceMappingURL=set-cube-rules.js.map

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

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