@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/subsets/update-subset.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { IDEMPOTENT_WRITE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+export const registerUpdateSubset = defineTool({
+    name: "tm1_update_subset",
+    description: "Update a public TM1 subset (partial). Pass expression to replace the MDX, or elements to switch the subset to a static list (resets Expression to ''). Pass alias to change the alias attribute.",
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        subsetName: z.string().describe("Existing subset name"),
+        expression: z.string().optional().describe("New MDX expression"),
+        elements: z
+            .array(z.string())
+            .optional()
+            .describe("New static element list (clears MDX)"),
+        alias: z.string().optional().describe("New alias attribute"),
+    },
+    handler: async ({ dimensionName, hierarchyName, subsetName, expression, elements, alias }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        await tm1Client.subsets.update(dimensionName, hierarchy, subsetName, {
+            expression,
+            elements,
+            alias,
+        });
+        return actionResponse({ success: true, subsetName });
+    },
+});
+//# sourceMappingURL=update-subset.js.map

package/dist/tools/ti-development/check-process-code.d.ts

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

package/dist/tools/ti-development/check-process-code.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { TM1ErrorCode } from "../../types.js";
+import { parameterSchema, variableSchema, dataSourceSchema, } from "../../lib/process-parts-schema.js";
+import { CompileErrorSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerCheckProcessCode = defineTool({
+    name: "tm1_check_process_code",
+    description: [
+        "Validate TI process code WITHOUT saving it on the server (POST /api/v1/CompileProcess unbound).",
+        "Pre-flight check before tm1_upsert_process to avoid create-with-rollback patterns.",
+        "Returns 'valid' or a list of syntax errors with procedure (Prolog/Metadata/Data/Epilog) and line number.",
+        "Omitted tabs are validated as EMPTY: the result covers only tabsChecked, and partial=true says the check did not see a whole process — validate every tab you will install.",
+    ],
+    annotations: READ_ONLY,
+    output: {
+        ok: z.boolean(),
+        processName: z.string(),
+        errorCount: z.number().int(),
+        errors: z.array(CompileErrorSchema),
+        tabsChecked: z.array(z.string()),
+        partial: z.boolean(),
+    },
+    input: {
+        processName: z
+            .string()
+            .optional()
+            .describe("Process name used in the synthetic body (no save). Default '_compile_check'."),
+        prolog: z.string().optional().describe("Prolog tab TI code"),
+        metadata: z.string().optional().describe("Metadata tab TI code"),
+        data: z.string().optional().describe("Data tab TI code"),
+        epilog: z.string().optional().describe("Epilog tab TI code"),
+        parameters: z
+            .array(parameterSchema)
+            .optional()
+            .describe("TI parameters (Name, Type, defaultValue, optional Prompt). When omitted and baseProcess is set, inherited from baseProcess."),
+        variables: z
+            .array(variableSchema)
+            .optional()
+            .describe("TI variables (column mapping for ASCII/ODBC). When omitted and baseProcess is set, inherited from baseProcess."),
+        dataSource: dataSourceSchema
+            .optional()
+            .describe("DataSource config — defaults to { type: 'None' } when omitted"),
+        baseProcess: z
+            .string()
+            .optional()
+            .describe("Existing process name to inherit parameters and variables from. Prevents 'undefined parameter' compile errors when validating code that references params defined on the saved process. Explicit parameters/variables override the inherited values."),
+    },
+    handler: async ({ processName, prolog, metadata, data, epilog, parameters, variables, dataSource, baseProcess, }, tm1Client) => {
+        let resolvedParams = parameters;
+        let resolvedVars = variables;
+        if (baseProcess) {
+            if (!resolvedParams)
+                resolvedParams = await tm1Client.processes.getParameters(baseProcess);
+            if (!resolvedVars)
+                resolvedVars = await tm1Client.processes.getVariables(baseProcess);
+        }
+        const result = await tm1Client.processes.check({
+            ...(processName !== undefined ? { name: processName } : {}),
+            ...(prolog !== undefined ? { prolog } : {}),
+            ...(metadata !== undefined ? { metadata } : {}),
+            ...(data !== undefined ? { data } : {}),
+            ...(epilog !== undefined ? { epilog } : {}),
+            ...(resolvedParams !== undefined ? { parameters: resolvedParams } : {}),
+            ...(resolvedVars !== undefined ? { variables: resolvedVars } : {}),
+            ...(dataSource !== undefined ? { dataSource: dataSource } : {}),
+        });
+        // Syntax errors are the expected output of a validator, so the failure
+        // payload carries its own code/message/hint — otherwise the isError
+        // normalizer stamps a generic TM1_ERROR envelope over it.
+        // Omitted tabs compile as empty, so a clean result on a fragment says
+        // nothing about the tabs that were left out — report what was covered.
+        const provided = { prolog, metadata, data, epilog };
+        const tabsChecked = Object.keys(provided).filter((t) => provided[t] !== undefined);
+        const payload = {
+            ok: result.success,
+            processName: processName ?? "_compile_check",
+            errorCount: result.errors.length,
+            errors: result.errors,
+            tabsChecked,
+            partial: tabsChecked.length < 4,
+            ...(result.success
+                ? {}
+                : {
+                    code: TM1ErrorCode.VALIDATION_ERROR,
+                    message: `TI syntax check failed: ${result.errors.length} error(s)`,
+                    hint: "Nothing was saved. Fix the lines listed in errors[] (procedure + lineNumber) and re-run tm1_check_process_code before tm1_upsert_process.",
+                }),
+        };
+        return {
+            isError: !result.success || undefined,
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+        };
+    },
+});
+//# sourceMappingURL=check-process-code.js.map

package/dist/tools/ti-development/compile-process.d.ts

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

package/dist/tools/ti-development/compile-process.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { CompileErrorSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerCompileProcess = defineTool({
+    name: "tm1_compile_process",
+    description: "Compile a TI process to validate its syntax without executing it. Returns compile errors with line numbers and procedure (Prolog/Metadata/Data/Epilog) when present.",
+    annotations: READ_ONLY,
+    output: {
+        ok: z.boolean(),
+        processName: z.string(),
+        errorCount: z.number().int(),
+        errors: z.array(CompileErrorSchema),
+    },
+    input: {
+        processName: z.string().describe("TI process name to compile"),
+    },
+    handler: async ({ processName }, tm1Client) => {
+        const result = await tm1Client.processes.compile(processName);
+        const payload = {
+            ok: result.success,
+            processName,
+            errorCount: result.errors.length,
+            errors: result.errors,
+        };
+        return {
+            isError: !result.success || undefined,
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+        };
+    },
+});
+//# sourceMappingURL=compile-process.js.map

package/dist/tools/ti-development/copy-process.d.ts

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

package/dist/tools/ti-development/copy-process.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { CopyProcessResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+export const registerCopyProcess = defineTool({
+    name: "tm1_copy_process",
+    description: "Copy a TI process to a new name. Carries over code, parameters, variables, datasource and the " +
+        "UI-only state — including which datasource columns are set to Ignore. Never overwrites: an existing targetName fails with CONFLICT.",
+    annotations: WRITE,
+    output: CopyProcessResultSchema,
+    input: {
+        sourceName: z.string().describe("Name of the source TI process"),
+        targetName: z.string().describe("Name for the new copy"),
+    },
+    handler: async ({ sourceName, targetName }, tm1Client) => {
+        // TM1 refuses the POST itself ("already exists", 400) and leaves the
+        // target untouched — verified live on 11.8. Checking first turns that
+        // generic 400 into a CONFLICT that says what to do.
+        if (await tm1Client.processes.exists(targetName)) {
+            throw new TM1Error({
+                code: TM1ErrorCode.CONFLICT,
+                message: `Process '${targetName}' already exists; copy_process never overwrites.`,
+                hint: "Pick a new targetName, or deploy onto the existing process with tm1_upsert_process.",
+            });
+        }
+        await tm1Client.processes.copy(sourceName, targetName);
+        return actionResponse({ success: true, sourceName, targetName });
+    },
+});
+//# sourceMappingURL=copy-process.js.map

package/dist/tools/ti-development/delete-process.d.ts

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

package/dist/tools/ti-development/delete-process.js

@@ -0,0 +1,26 @@
+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 registerDeleteProcess = defineTool({
+    name: "tm1_delete_process",
+    description: [
+        "Delete a TurboIntegrator process from the TM1 server.",
+        "Irreversible. Safety: pass confirm=<process name verbatim>. Mismatched confirm rejects the call.",
+        "Before: tm1_analyze_object_usage to find chores or other processes that reference it; tm1_analyze_chore_graph to confirm no chore depends on it.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        processName: z.string().describe("Name of the TI process to delete"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ processName, confirm }, tm1Client) => {
+        requireConfirm(confirm, processName, "process");
+        await tm1Client.processes.delete(processName);
+        return actionResponse({ success: true, processName });
+    },
+});
+//# sourceMappingURL=delete-process.js.map

package/dist/tools/ti-development/diff-process-with-file.d.ts

@@ -0,0 +1,2 @@
+export declare const registerDiffProcessWithFile: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=diff-process-with-file.d.ts.map

package/dist/tools/ti-development/diff-process-with-file.js

@@ -0,0 +1,208 @@
+import { promises as fs } from "node:fs";
+import { resolveLocalPath } from "../local-file.js";
+import { z } from "zod";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { parseProFile } from "../../lib/pro-parser.js";
+import { ignoredColumnsOf } from "../../lib/variables-ui-data.js";
+import { maskCode, resolveMaskSecrets } from "../../lib/mask-secrets.js";
+import { DiffProcessResultSchema } from "../schemas/items.js";
+import { READ_ONLY, withVersion } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+function tabDiff(name, installed, file) {
+    const norm = (s) => s.replace(/\r\n/g, "\n").trimEnd();
+    return {
+        tab: name,
+        installedLines: norm(installed).split("\n").length,
+        fileLines: norm(file).split("\n").length,
+        identical: norm(installed) === norm(file),
+    };
+}
+function diffParams(installed, file) {
+    const map = (arr) => new Map(arr.map((p) => [p.name, p]));
+    const a = map(installed);
+    const b = map(file);
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [name, fp] of b) {
+        const ip = a.get(name);
+        if (!ip) {
+            added.push(name);
+        }
+        else if (ip.type !== fp.type ||
+            String(ip.defaultValue ?? "") !== String(fp.defaultValue ?? "") ||
+            (ip.prompt ?? "") !== (fp.prompt ?? "")) {
+            changed.push({ name, installed: ip, file: fp });
+        }
+    }
+    for (const name of a.keys()) {
+        if (!b.has(name))
+            removed.push(name);
+    }
+    return { added, removed, changed };
+}
+function diffVars(installed, file) {
+    const map = (arr) => new Map(arr.map((v) => [v.name, v]));
+    const a = map(installed);
+    const b = map(file);
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [name, fv] of b) {
+        const iv = a.get(name);
+        if (!iv)
+            added.push(name);
+        else if (iv.type !== fv.type || iv.position !== fv.position) {
+            changed.push({ name, installed: iv, file: fv });
+        }
+    }
+    for (const name of a.keys())
+        if (!b.has(name))
+            removed.push(name);
+    return { added, removed, changed };
+}
+// A column set to "Ignore" has no variable, so diffVars cannot see it: without
+// this the .pro and the installed process look identical even when they skip
+// different columns.
+function diffIgnoredColumns(installed, file) {
+    const a = new Map(installed.map((c) => [c.position, c]));
+    const b = new Map(file.map((c) => [c.position, c]));
+    const added = [];
+    const removed = [];
+    const renamed = [];
+    for (const [position, fc] of b) {
+        const ic = a.get(position);
+        if (!ic) {
+            added.push(position);
+            continue;
+        }
+        if (ic.name !== fc.name)
+            renamed.push({
+                position,
+                ...(ic.name !== undefined ? { installed: ic.name } : {}),
+                ...(fc.name !== undefined ? { file: fc.name } : {}),
+            });
+    }
+    for (const position of a.keys())
+        if (!b.has(position))
+            removed.push(position);
+    return {
+        identical: added.length === 0 && removed.length === 0 && renamed.length === 0,
+        added,
+        removed,
+        renamed,
+    };
+}
+function diffDataSource(installed, file) {
+    const diffs = [];
+    if (installed.type !== file.type)
+        diffs.push(`type: ${installed.type} → ${file.type}`);
+    const fields = [
+        "dataSourceNameForServer",
+        "dataSourceNameForClient",
+        "asciiDelimiterChar",
+        "asciiQuoteCharacter",
+        "asciiDecimalSeparator",
+        "asciiThousandSeparator",
+        "asciiHeaderRecords",
+        "view",
+        "subset",
+        "userName",
+        // See diff-processes.ts: the ODBC query is substance, the password is noise.
+        "query",
+    ];
+    for (const f of fields) {
+        const a = installed[f];
+        const b = file[f];
+        if ((a ?? "") !== (b ?? ""))
+            diffs.push(`${String(f)}: ${JSON.stringify(a)} → ${JSON.stringify(b)}`);
+    }
+    return { identical: diffs.length === 0, differences: diffs };
+}
+export const registerDiffProcessWithFile = defineTool({
+    name: "tm1_diff_process_with_file",
+    description: "Compare an installed TI process on the server against a local .pro file. Returns per-tab identical flags + line counts, parameter diff (added/removed/changed), variable diff, and datasource diff. Use before tm1_import_pro_file to preview what will change.",
+    annotations: withVersion(READ_ONLY, "v11"),
+    output: DiffProcessResultSchema,
+    input: {
+        filePath: z
+            .string()
+            .optional()
+            .describe("Absolute path to the .pro file on the MCP server host. Disabled unless TM1_LOCAL_FILE_ROOT is set; the path must resolve within that directory. Otherwise pass 'content' inline."),
+        content: z.string().optional().describe("Raw .pro file content as string"),
+        processName: z
+            .string()
+            .optional()
+            .describe("Override process name. Default: from .pro 602 line."),
+        maskSecrets: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Redact credential literals on BOTH sides before diffing (so a cred present on only one side can't leak via the diff). " +
+            "Masks the password arg of ODBCOpen() and quoted values assigned to credential-named identifiers (pPwd, sToken, …). " +
+            "Default: true. Set false only when explicitly auditing credentials."),
+    },
+    handler: async ({ filePath, content, processName, maskSecrets }, tm1Client) => {
+        if (!filePath && !content) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Provide filePath or content",
+            });
+        }
+        let body = content ?? "";
+        if (!body && filePath) {
+            body = await fs.readFile(resolveLocalPath(filePath), "utf8");
+        }
+        const parsed = parseProFile(body);
+        const name = processName ?? parsed.name;
+        if (!name) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Process name not found in .pro and no override provided",
+            });
+        }
+        const [installedCode, installedParams, installedLayout, installedDs] = await Promise.all([
+            tm1Client.processes.getCode(name),
+            tm1Client.processes.getParameters(name),
+            tm1Client.processes.getVariableLayout(name),
+            tm1Client.processes.getDataSource(name),
+        ]);
+        const mask = resolveMaskSecrets(maskSecrets) ? maskCode : (s) => s;
+        const tabs = [
+            tabDiff("prolog", mask(installedCode.prolog), mask(parsed.prolog)),
+            tabDiff("metadata", mask(installedCode.metadata), mask(parsed.metadata)),
+            tabDiff("data", mask(installedCode.data), mask(parsed.data)),
+            tabDiff("epilog", mask(installedCode.epilog), mask(parsed.epilog)),
+        ];
+        const params = diffParams(installedParams, parsed.parameters);
+        const variables = diffVars(installedLayout.variables, parsed.variables);
+        const ignoredColumns = diffIgnoredColumns(installedLayout.ignoredColumns, ignoredColumnsOf(parsed.variablesUIData));
+        const dataSource = diffDataSource(installedDs, parsed.dataSource);
+        const allIdentical = tabs.every((t) => t.identical) &&
+            params.added.length === 0 &&
+            params.removed.length === 0 &&
+            params.changed.length === 0 &&
+            variables.added.length === 0 &&
+            variables.removed.length === 0 &&
+            variables.changed.length === 0 &&
+            ignoredColumns.identical &&
+            dataSource.identical;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        processName: name,
+                        identical: allIdentical,
+                        tabs,
+                        parameters: params,
+                        variables,
+                        ignoredColumns,
+                        dataSource,
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=diff-process-with-file.js.map

package/dist/tools/ti-development/diff-processes.d.ts

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