@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/sample-cells.d.ts

@@ -0,0 +1,48 @@
+import type { MdxResult, CellValue } from "../types.js";
+export type SampleCellFilter = string | string[];
+export interface SampleCellsBuildArgs {
+    cubeName: string;
+    /** Cube dimension names in declaration order (used for crossjoin layout). */
+    dimensions: string[];
+    /** Max rows after NON EMPTY. 0 = no HEAD (full result). */
+    maxCells: number;
+    /** Per-dimension filters: single string → WHERE; array → axis member set. */
+    filters?: Record<string, SampleCellFilter> | undefined;
+    /** Dimension placed on COLUMNS. Default: last cube dimension. */
+    axisDimension?: string | undefined;
+    /** If true, restrict unfiltered dims to leaf members (level 0). */
+    leavesOnly: boolean;
+    /**
+     * If true, sample string-valued cells: drop the NON EMPTY numeric suppression
+     * in favour of a `<> ""` FILTER, and include consolidations on unfiltered dims
+     * (overrides leavesOnly) because string values do not consolidate and may sit
+     * directly on C elements. Requires the column/measure to resolve to a single
+     * element. Default false (numeric NON EMPTY behaviour).
+     */
+    includeStrings?: boolean | undefined;
+}
+export interface SampleCellsBuildResult {
+    mdx: string;
+    /** Dimensions pinned via WHERE (single-string filters). */
+    whereDims: string[];
+    /** Dimensions on the ROW crossjoin axis. */
+    rowDims: string[];
+    /** Dimension placed on COLUMNS. */
+    columnDim: string;
+}
+export interface SampleCell {
+    coordinates: Record<string, string>;
+    value: CellValue;
+    formattedValue: string;
+}
+export declare function buildSampleCellsMdx(args: SampleCellsBuildArgs): SampleCellsBuildResult;
+export interface TransformArgs {
+    result: MdxResult;
+    whereCoords: Record<string, string>;
+}
+/**
+ * Convert flat MdxResult cells into self-describing {coordinates,value,formattedValue}.
+ * Assumes axes[0] = COLUMNS, axes[1] = ROWS (TM1 default ordering).
+ */
+export declare function transformSampleCells(args: TransformArgs): SampleCell[];
+//# sourceMappingURL=sample-cells.d.ts.map

package/dist/lib/sample-cells.js

@@ -0,0 +1,146 @@
+// Pure helpers for tm1_sample_cells: MDX construction and cellset transformation.
+// No I/O — kept pure for unit-testability.
+import { TM1Error, TM1ErrorCode } from "../types.js";
+import { escapeMdxName } from "./mdx.js";
+const memberRef = (dim, elem) => {
+    // Pre-qualified pass-through (e.g. caller passes "[Dim].[Elem]").
+    if (elem.startsWith("[") && elem.includes("].["))
+        return elem;
+    return `[${escapeMdxName(dim)}].[${escapeMdxName(elem)}]`;
+};
+export function buildSampleCellsMdx(args) {
+    const { cubeName, dimensions, maxCells, filters = {}, leavesOnly, includeStrings = false, } = args;
+    if (dimensions.length === 0) {
+        throw new TM1Error({
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `Cube '${cubeName}' has no dimensions`,
+        });
+    }
+    // dimensions.length === 0 is guarded above; the fallback is always defined.
+    const columnDim = args.axisDimension ?? dimensions[dimensions.length - 1];
+    if (!dimensions.includes(columnDim)) {
+        throw new TM1Error({
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `axisDimension '${columnDim}' is not a dimension of cube '${cubeName}' (dims: ${dimensions.join(", ")})`,
+        });
+    }
+    for (const key of Object.keys(filters)) {
+        if (!dimensions.includes(key)) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `Filter dimension '${key}' is not a dimension of cube '${cubeName}' (dims: ${dimensions.join(", ")})`,
+            });
+        }
+    }
+    const whereDims = [];
+    const whereParts = [];
+    const rowDims = [];
+    const rowSets = [];
+    for (const dim of dimensions) {
+        if (dim === columnDim)
+            continue;
+        const f = filters[dim];
+        if (typeof f === "string") {
+            whereDims.push(dim);
+            whereParts.push(memberRef(dim, f));
+            continue;
+        }
+        if (Array.isArray(f) && f.length > 0) {
+            rowDims.push(dim);
+            rowSets.push(`{${f.map((e) => memberRef(dim, e)).join(",")}}`);
+            continue;
+        }
+        rowDims.push(dim);
+        // String values can sit on consolidations and do not roll up, so includeStrings
+        // must scan all members (incl. C), overriding the leaf-only restriction.
+        rowSets.push(leavesOnly && !includeStrings
+            ? `TM1FILTERBYLEVEL({TM1SUBSETALL([${escapeMdxName(dim)}])},0)`
+            : `{TM1SUBSETALL([${escapeMdxName(dim)}])}`);
+    }
+    const colFilter = filters[columnDim];
+    let columnMembers;
+    if (typeof colFilter === "string") {
+        columnMembers = [memberRef(columnDim, colFilter)];
+    }
+    else if (Array.isArray(colFilter) && colFilter.length > 0) {
+        columnMembers = colFilter.map((e) => memberRef(columnDim, e));
+    }
+    else {
+        columnMembers = [`[${escapeMdxName(columnDim)}].DefaultMember`];
+    }
+    const columnSet = `{${columnMembers.join(",")}}`;
+    let rowExpr;
+    if (rowSets.length === 0) {
+        rowExpr = `{[${escapeMdxName(columnDim)}].DefaultMember}`;
+    }
+    else if (rowSets.length === 1) {
+        rowExpr = rowSets[0];
+    }
+    else {
+        rowExpr = rowSets.reduce((acc, s) => `CROSSJOIN(${acc},${s})`);
+    }
+    let rowAxisExpr;
+    if (includeStrings) {
+        // NON EMPTY suppression can hide string cells on some TM1 versions, and never
+        // surfaces strings on consolidations. Filter on a non-blank string value
+        // instead. Needs a single measure cell to reference.
+        if (columnMembers.length !== 1) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `includeStrings requires the column/measure to resolve to a single element; ` +
+                    `pin it via filters['${columnDim}']='<element>' or axisDimension (got ${columnMembers.length} members).`,
+            });
+        }
+        const filterExpr = `FILTER(${rowExpr},[${escapeMdxName(cubeName)}].(${columnMembers[0]})<>"")`;
+        rowAxisExpr = maxCells > 0 ? `HEAD(${filterExpr},${maxCells})` : filterExpr;
+    }
+    else {
+        // TM1's NONEMPTY(set, filterSet) is a set function. Plain "NON EMPTY <set>"
+        // is an axis modifier and is rejected as a syntax error inside HEAD().
+        const nonEmptyExpr = `NONEMPTY(${rowExpr},${columnSet})`;
+        rowAxisExpr =
+            maxCells > 0 ? `HEAD(${nonEmptyExpr},${maxCells})` : nonEmptyExpr;
+    }
+    const whereClause = whereParts.length > 0 ? ` WHERE (${whereParts.join(",")})` : "";
+    const mdx = `SELECT ${columnSet} ON COLUMNS, ${rowAxisExpr} ON ROWS FROM [${escapeMdxName(cubeName)}]${whereClause}`;
+    return { mdx, whereDims, rowDims, columnDim };
+}
+/**
+ * Convert flat MdxResult cells into self-describing {coordinates,value,formattedValue}.
+ * Assumes axes[0] = COLUMNS, axes[1] = ROWS (TM1 default ordering).
+ */
+export function transformSampleCells(args) {
+    const { result, whereCoords } = args;
+    const axes = result.axes;
+    if (axes.length === 0)
+        return [];
+    const colAxis = axes[0];
+    const rowAxis = axes[1] ?? { tuples: [{ members: [] }] };
+    const colCount = colAxis.tuples.length;
+    if (colCount === 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < result.cells.length; i++) {
+        const colIdx = i % colCount;
+        const rowIdx = Math.floor(i / colCount);
+        const colTuple = colAxis.tuples[colIdx];
+        const rowTuple = rowAxis.tuples[rowIdx];
+        if (!colTuple || !rowTuple)
+            continue;
+        const coords = { ...whereCoords };
+        for (const m of colTuple.members)
+            coords[m.hierarchyName] = m.name;
+        for (const m of rowTuple.members)
+            coords[m.hierarchyName] = m.name;
+        const c = result.cells[i];
+        if (!c)
+            continue;
+        out.push({
+            coordinates: coords,
+            value: c.value,
+            formattedValue: c.formattedValue,
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=sample-cells.js.map

package/dist/lib/slim-json-schema.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Strip information-free noise from a serialized JSON Schema.
+ *
+ * Zod's JSON-Schema emitter spells `.int()` out as the JS safe-integer range
+ * (`minimum: -9007199254740991` / `maximum: 9007199254740991`) and stamps a
+ * `$schema` dialect header onto every root. Both ship on every `tools/list`
+ * response and tell a model exactly nothing — together they account for ~25KB
+ * across the tool surface. Removing them is lossless: runtime validation still
+ * happens against the Zod objects server-side, which are untouched.
+ *
+ * The strip is deliberately narrow. A `minimum`/`maximum` is dropped ONLY when
+ * its value is the exact sentinel, so real bounds (`limit` max 500, `offset`
+ * min 0) survive. And keyword rules are suspended inside name-keyed containers
+ * (`properties` & friends), where the keys are user-chosen field names — a tool
+ * with a field literally called `$schema` keeps its subschema.
+ *
+ * Pure: the input is never mutated, the result is a fresh deep clone.
+ */
+export declare function slimJsonSchema(schema: unknown): unknown;
+//# sourceMappingURL=slim-json-schema.d.ts.map

package/dist/lib/slim-json-schema.js

@@ -0,0 +1,68 @@
+/**
+ * Strip information-free noise from a serialized JSON Schema.
+ *
+ * Zod's JSON-Schema emitter spells `.int()` out as the JS safe-integer range
+ * (`minimum: -9007199254740991` / `maximum: 9007199254740991`) and stamps a
+ * `$schema` dialect header onto every root. Both ship on every `tools/list`
+ * response and tell a model exactly nothing — together they account for ~25KB
+ * across the tool surface. Removing them is lossless: runtime validation still
+ * happens against the Zod objects server-side, which are untouched.
+ *
+ * The strip is deliberately narrow. A `minimum`/`maximum` is dropped ONLY when
+ * its value is the exact sentinel, so real bounds (`limit` max 500, `offset`
+ * min 0) survive. And keyword rules are suspended inside name-keyed containers
+ * (`properties` & friends), where the keys are user-chosen field names — a tool
+ * with a field literally called `$schema` keeps its subschema.
+ *
+ * Pure: the input is never mutated, the result is a fresh deep clone.
+ */
+// Zod serializes `.int()` to the JS safe-integer range; these two exact values
+// are the sentinel, anything else is a real, author-chosen bound.
+const SAFE_INT_MIN = -9007199254740991; // Number.MIN_SAFE_INTEGER
+const SAFE_INT_MAX = 9007199254740991; // Number.MAX_SAFE_INTEGER
+// JSON-Schema containers whose immediate keys are field names, not keywords.
+// Recursion must not apply the strip rules one level below these.
+const NAME_KEYED_CONTAINERS = new Set([
+    "properties",
+    "patternProperties",
+    "definitions",
+    "$defs",
+    "dependentSchemas",
+]);
+export function slimJsonSchema(schema) {
+    return slimNode(schema, false);
+}
+// `nameKeyed` = this node is a map of field-name → subschema, so its own keys
+// carry no keyword meaning and must be preserved verbatim.
+function slimNode(node, nameKeyed) {
+    if (Array.isArray(node))
+        return node.map((entry) => slimNode(entry, false));
+    if (node === null || typeof node !== "object")
+        return node;
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (!nameKeyed) {
+            if (key === "$schema")
+                continue;
+            if (key === "minimum" && value === SAFE_INT_MIN)
+                continue;
+            if (key === "maximum" && value === SAFE_INT_MAX)
+                continue;
+        }
+        const slimmed = slimNode(value, !nameKeyed && NAME_KEYED_CONTAINERS.has(key));
+        // A field named `__proto__` would otherwise mutate the prototype chain
+        // instead of becoming an own property.
+        if (key === "__proto__") {
+            Object.defineProperty(out, key, {
+                value: slimmed,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            continue;
+        }
+        out[key] = slimmed;
+    }
+    return out;
+}
+//# sourceMappingURL=slim-json-schema.js.map

package/dist/lib/strip-comments.d.ts

@@ -0,0 +1,23 @@
+/** Runs of this many or more consecutive full-comment lines are collapsed. */
+export declare const COLLAPSE_MIN = 4;
+export interface CommentStats {
+    totalLines: number;
+    commentLines: number;
+}
+/** Count total lines and full-line comments (non-destructive). */
+export declare function commentStats(src: string): CommentStats;
+export interface StripResult {
+    code: string;
+    /** Original comment lines removed (sum of collapsed run lengths). */
+    removedLines: number;
+    /** Number of collapsed blocks. */
+    collapsedBlocks: number;
+}
+/**
+ * Collapse runs of >= COLLAPSE_MIN consecutive full-line comments into a single
+ * `# [... N lines commented out ...]` marker. Shorter comment runs and inline
+ * trailing comments are kept verbatim (they are usually documentation, not dead
+ * code). Line endings are normalized to `\n` (read-only display).
+ */
+export declare function stripCommentBlocks(src: string, minRun?: number): StripResult;
+//# sourceMappingURL=strip-comments.d.ts.map

package/dist/lib/strip-comments.js

@@ -0,0 +1,61 @@
+// Pure helpers for tm1_get_process_code's stripComments mode. No I/O.
+//
+// TM1 TI code uses only `#` line comments (no block comments); `#` starts a
+// comment that runs to end of line. Grown models accumulate large blocks of
+// commented-out dead code that waste an agent's context. These helpers collapse
+// long runs of full-line comments and report comment density for discoverability.
+/** A full-line comment is a line that is only a comment (optional indent + `#`). */
+const isFullCommentLine = (line) => /^\s*#/.test(line);
+/** Runs of this many or more consecutive full-comment lines are collapsed. */
+export const COLLAPSE_MIN = 4;
+/** Count total lines and full-line comments (non-destructive). */
+export function commentStats(src) {
+    if (src === "")
+        return { totalLines: 0, commentLines: 0 };
+    const lines = src.split(/\r?\n/);
+    let commentLines = 0;
+    for (const line of lines) {
+        if (isFullCommentLine(line))
+            commentLines++;
+    }
+    return { totalLines: lines.length, commentLines };
+}
+/**
+ * Collapse runs of >= COLLAPSE_MIN consecutive full-line comments into a single
+ * `# [... N lines commented out ...]` marker. Shorter comment runs and inline
+ * trailing comments are kept verbatim (they are usually documentation, not dead
+ * code). Line endings are normalized to `\n` (read-only display).
+ */
+export function stripCommentBlocks(src, minRun = COLLAPSE_MIN) {
+    if (src === "")
+        return { code: "", removedLines: 0, collapsedBlocks: 0 };
+    const lines = src.split(/\r?\n/);
+    const out = [];
+    let removedLines = 0;
+    let collapsedBlocks = 0;
+    let i = 0;
+    while (i < lines.length) {
+        if (isFullCommentLine(lines[i])) {
+            let j = i;
+            while (j < lines.length && isFullCommentLine(lines[j]))
+                j++;
+            const runLength = j - i;
+            if (runLength >= minRun) {
+                out.push(`# [... ${runLength} lines commented out ...]`);
+                removedLines += runLength;
+                collapsedBlocks++;
+            }
+            else {
+                for (let k = i; k < j; k++)
+                    out.push(lines[k]);
+            }
+            i = j;
+        }
+        else {
+            out.push(lines[i]);
+            i++;
+        }
+    }
+    return { code: out.join("\n"), removedLines, collapsedBlocks };
+}
+//# sourceMappingURL=strip-comments.js.map

package/dist/lib/tm1-events.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "node:events";
+export interface Tm1MutationEvent {
+    method: string;
+    path: string;
+}
+interface Tm1Events {
+    mutation: (e: Tm1MutationEvent) => void;
+}
+declare class TypedEmitter extends EventEmitter {
+    on<K extends keyof Tm1Events>(event: K, listener: Tm1Events[K]): this;
+    off<K extends keyof Tm1Events>(event: K, listener: Tm1Events[K]): this;
+    emit<K extends keyof Tm1Events>(event: K, ...args: Parameters<Tm1Events[K]>): boolean;
+}
+export declare const tm1Events: TypedEmitter;
+export {};
+//# sourceMappingURL=tm1-events.d.ts.map

package/dist/lib/tm1-events.js

@@ -0,0 +1,29 @@
+// In-process event bus for cross-cutting TM1 events.
+//
+// Currently emits only `mutation` after any successful non-safe HTTP request
+// (POST/PUT/PATCH/DELETE), used by R2-05 resource-subscription notifications
+// and as a future hook for cache layers.
+//
+// Decoupled from the HTTP layer so the MCP-side subscription registry can
+// listen without HTTP needing a reference to the MCP server.
+import { EventEmitter } from "node:events";
+// Typed event emitter via thin wrapper. Listeners registered for events
+// outside this map are silently allowed by Node's EventEmitter but won't
+// receive emit calls from this module.
+class TypedEmitter extends EventEmitter {
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+}
+export const tm1Events = new TypedEmitter();
+// Set a generous listener cap. Subscriptions are server-scoped (one listener
+// per running server process), so the default 10 is fine for now; raise only
+// if a workload registers many per-resource listeners.
+tm1Events.setMaxListeners(20);
+//# sourceMappingURL=tm1-events.js.map

package/dist/lib/v12-compat/deprecated-ti.d.ts

@@ -0,0 +1,17 @@
+export interface DeprecatedTiEntry {
+    /** Canonical name, original casing (e.g. "SaveDataAll"). */
+    name: string;
+    /** Short rationale — surfaced as `issue` in findings. */
+    issue: string;
+    /** Migration hint or "remove without replacement" when no replacement exists. */
+    suggestion: string;
+    /** Severity bucket. "error" = removed, "warning" = behavior-changed/cloud-only. */
+    severity: "error" | "warning";
+}
+export declare const V12_DEPRECATED_TI: ReadonlyMap<string, DeprecatedTiEntry>;
+/**
+ * Combined case-insensitive regex matching any deprecated function name
+ * followed by `(`. Used by the scanner for a single-pass-per-line match.
+ */
+export declare const V12_DEPRECATED_TI_REGEX: RegExp;
+//# sourceMappingURL=deprecated-ti.d.ts.map