@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/callgraph/referenceIndex.js

@@ -0,0 +1,584 @@
+import { KNOWN_SIGNATURES } from "./tiSignatures.js";
+import { extractDbCalls, extractBracketRefs, parseBracketDimRefs, validateBracketRefSyntax, } from "./rulesLinter.js";
+import { joinContinuationLines } from "./tiParser.js";
+import { buildProcessEnv, resolveExpression, } from "./variableEnv.js";
+import { rethrowIfSystemic } from "../../tm1-client/services/fallback.js";
+import { extractSubsetUsage } from "./subsetUsage.js";
+function buildArgIdxMap(paramName) {
+    const map = new Map();
+    for (const [key, sig] of KNOWN_SIGNATURES.entries()) {
+        for (let i = 0; i < sig.params.length; i++) {
+            if (sig.params[i].name.toLowerCase() === paramName && !map.has(key)) {
+                map.set(key, i);
+                break;
+            }
+        }
+    }
+    return map;
+}
+const CUBE_ARG_IDX = buildArgIdxMap("cubename");
+const DIM_ARG_IDX = buildArgIdxMap("dimensionname");
+const PROCESS_ARG_IDX = buildArgIdxMap("processname");
+const ELEM_ARG_IDX = buildArgIdxMap("elementname");
+const SUBSET_ARG_IDX = buildArgIdxMap("subsetname");
+/** Subset-membership calls whose ElementName arg is a real element-data-flow reference. */
+const SUBSET_ELEM_FUNCS = new Set([
+    "subsetelementinsert",
+    "subsetelementadd",
+    "subsetelementdelete",
+]);
+const TRACKED_FUNCS = [
+    ...new Set([
+        ...CUBE_ARG_IDX.keys(),
+        ...DIM_ARG_IDX.keys(),
+        ...PROCESS_ARG_IDX.keys(),
+    ]),
+];
+const FUNC_RE = new RegExp(`\\b(${TRACKED_FUNCS.join("|")})\\s*\\(`, "gi");
+const SKIP_VALIDATION_FUNCS = new Set([
+    "dimensioncreate",
+    "cubecreate",
+    "hierarchycreate",
+    "subsetcreate",
+    "subsetcreatebymdx",
+    "viewcreate",
+    "viewcreatebymdx",
+]);
+// ─── Helpers (subset of rulesLinter/tiServerLinter internals) ────────────────
+function neutralizeLine(line) {
+    return line
+        .replace(/'[^']*'/g, (s) => " ".repeat(s.length))
+        .replace(/#.*$/, "");
+}
+export function splitArgs(argsStr) {
+    if (!argsStr.trim()) {
+        return [];
+    }
+    const args = [];
+    let depth = 0;
+    let inStr = false;
+    let cur = "";
+    for (const ch of argsStr) {
+        if (ch === "'" && !inStr) {
+            inStr = true;
+            cur += ch;
+        }
+        else if (ch === "'" && inStr) {
+            inStr = false;
+            cur += ch;
+        }
+        else if (!inStr && ch === "(") {
+            depth++;
+            cur += ch;
+        }
+        else if (!inStr && ch === ")") {
+            depth--;
+            cur += ch;
+        }
+        else if (!inStr && depth === 0 && ch === ",") {
+            args.push(cur.trim());
+            cur = "";
+        }
+        else {
+            cur += ch;
+        }
+    }
+    args.push(cur.trim());
+    return args.filter((a) => a !== "");
+}
+/** Composite key for the byElement index: dimension + element, both lowercased. */
+export function elementKey(dimension, element) {
+    return `${dimension.toLowerCase()} ${element.toLowerCase()}`;
+}
+export function extractStringLiteral(arg) {
+    const t = arg.trim();
+    if (t.startsWith("'") && t.endsWith("'") && t.length >= 3) {
+        const inner = t.slice(1, -1);
+        if (!inner.includes("'")) {
+            return inner;
+        }
+    }
+    return null;
+}
+const SECTION_MARKER_RE = /^57[2345],\d*$/;
+function truncateSnippet(line) {
+    const t = line.trim();
+    return t.length > 200 ? t.slice(0, 197) + "…" : t;
+}
+/**
+ * Resolve a single value-arg of an ExecuteProcess param-value pair.
+ * Uses the caller's ProcessEnv to resolve bare variables to literals or
+ * caller-param references.
+ */
+function resolveValueArg(arg, env) {
+    const valueRaw = arg.trim();
+    const binding = resolveExpression(valueRaw, env);
+    if (binding.kind === "literal") {
+        return { resolution: { kind: "literal", value: binding.value }, valueRaw };
+    }
+    if (binding.kind === "param") {
+        return {
+            resolution: { kind: "passthrough", paramName: binding.paramName },
+            valueRaw,
+        };
+    }
+    return { resolution: { kind: "dynamic" }, valueRaw };
+}
+/**
+ * For ExecuteProcess/RunProcess: parse param pairs starting at arg index 1.
+ * Dangling single args (odd count) and pairs with a dynamic param-name arg
+ * are skipped.
+ */
+function extractCallParams(args, env) {
+    const params = [];
+    for (let i = 1; i + 1 < args.length; i += 2) {
+        const nameLit = extractStringLiteral(args[i]);
+        if (nameLit === null) {
+            continue;
+        }
+        const { resolution, valueRaw } = resolveValueArg(args[i + 1], env);
+        params.push({ name: nameLit, resolution, valueRaw });
+    }
+    return params;
+}
+const PROCESS_CALL_FUNCS = new Set(["executeprocess", "runprocess"]);
+/**
+ * Extracts cube/dimension/process references from a single TI text (one section).
+ * Pure function — no network, no vscode.
+ *
+ * @param text       TI source (prolog/metadata/data/epilog)
+ * @param env        Process environment for variable resolution in ExecuteProcess args.
+ *                   Defaults to an empty env (no param refs, no local vars) if omitted.
+ */
+export function extractTiReferences(text, env, sharedLiveVars, unresolvedOut, unresolvedElemOut) {
+    const baseEnv = env ?? {
+        paramsLc: new Set(),
+        paramOriginal: new Map(),
+        paramTypes: new Map(),
+        datasourceVars: new Map(),
+        vars: new Map(),
+    };
+    // Flow-sensitive Var-Tracking: Basis-Env (Params/DS-Vars/cross-section-Vars) + live
+    // aktualisierte lokale Vars. Jede Zuweisung überschreibt (last-assignment-wins), so dass
+    // Orchestrator-Muster wie `sProc='A'; RUNPROCESS(sProc,…); sProc='B'; RUNPROCESS(sProc,…);`
+    // beide Calls als eigene Refs auflösen statt auf `dynamic` zu demovieren.
+    // sharedLiveVars wird über Sections hinweg durchgereicht (Prolog-Zuweisung sichtbar in Data/Epilog).
+    const liveVars = sharedLiveVars ?? new Map(baseEnv.vars);
+    const callerEnv = { ...baseEnv, vars: liveVars };
+    const refs = [];
+    // Multi-line-Calls auf ihre Startzeile zusammenfassen — Continuation-Zeilen werden leer.
+    const lines = joinContinuationLines(text.split("\n").map((l) => l.replace(/\r$/, "")));
+    const assignRe = /^\s*([A-Za-z_]\w*)\s*=\s*(.+?)\s*;?\s*(?:#.*)?$/;
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        if (SECTION_MARKER_RE.test(line.trim()) || line.trim() === "") {
+            continue;
+        }
+        const neutralized = neutralizeLine(line);
+        if (neutralized.trim() === "") {
+            continue;
+        }
+        // Vor der Call-Erkennung: Zuweisungen in liveVars eintragen (last-assignment-wins).
+        const aM = assignRe.exec(line);
+        if (aM && !aM[2].startsWith("=")) {
+            const varLc = aM[1].toLowerCase();
+            if (!baseEnv.paramsLc.has(varLc) && !baseEnv.datasourceVars.has(varLc)) {
+                liveVars.set(varLc, resolveExpression(aM[2], callerEnv));
+            }
+        }
+        FUNC_RE.lastIndex = 0;
+        let m;
+        while ((m = FUNC_RE.exec(neutralized)) !== null) {
+            const funcLower = m[1].toLowerCase();
+            const openParen = m.index + m[0].length - 1;
+            let depth = 1;
+            let i = openParen + 1;
+            while (i < neutralized.length && depth > 0) {
+                if (neutralized[i] === "(") {
+                    depth++;
+                }
+                else if (neutralized[i] === ")") {
+                    depth--;
+                }
+                i++;
+            }
+            if (depth !== 0) {
+                continue;
+            }
+            const argsStr = line.slice(openParen + 1, i - 1);
+            const args = splitArgs(argsStr);
+            if (SKIP_VALIDATION_FUNCS.has(funcLower)) {
+                continue;
+            }
+            const snippet = truncateSnippet(line);
+            const pushRef = (kind, argIdx) => {
+                if (argIdx === undefined || argIdx >= args.length) {
+                    return;
+                }
+                const argVal = args[argIdx];
+                let targetName = extractStringLiteral(argVal);
+                if (targetName === null) {
+                    const binding = resolveExpression(argVal, callerEnv);
+                    if (binding.kind !== "literal") {
+                        // Surface (do not resolve) a process-call target that isn't a literal —
+                        // it's still a real call edge, just one we can't name statically.
+                        if (unresolvedOut &&
+                            kind === "process" &&
+                            PROCESS_CALL_FUNCS.has(funcLower)) {
+                            unresolvedOut.push({
+                                line: lineIdx,
+                                funcName: m[1],
+                                expr: argVal.trim(),
+                                snippet,
+                                reason: binding.kind === "param" ? "param" : "dynamic",
+                            });
+                        }
+                        return;
+                    }
+                    targetName = binding.value;
+                }
+                const params = kind === "process" && PROCESS_CALL_FUNCS.has(funcLower)
+                    ? extractCallParams(args, callerEnv)
+                    : undefined;
+                refs.push({
+                    line: lineIdx,
+                    funcName: m[1],
+                    targetKind: kind,
+                    targetName,
+                    snippet,
+                    params,
+                });
+            };
+            pushRef("cube", CUBE_ARG_IDX.get(funcLower));
+            pushRef("dimension", DIM_ARG_IDX.get(funcLower));
+            pushRef("process", PROCESS_ARG_IDX.get(funcLower));
+            // Element refs need BOTH the element name and its owning dimension resolved
+            // together, so use a dedicated block instead of the single-arg pushRef.
+            if (SUBSET_ELEM_FUNCS.has(funcLower)) {
+                const elemIdx = ELEM_ARG_IDX.get(funcLower);
+                const dimIdx = DIM_ARG_IDX.get(funcLower);
+                if (elemIdx !== undefined && elemIdx < args.length) {
+                    const elemArg = args[elemIdx];
+                    // Resolve the owning dimension (literal or var); undefined if unresolvable.
+                    let dimName;
+                    if (dimIdx !== undefined && dimIdx < args.length) {
+                        const dimArg = args[dimIdx];
+                        dimName = extractStringLiteral(dimArg) ?? undefined;
+                        if (dimName === undefined) {
+                            const db = resolveExpression(dimArg, callerEnv);
+                            if (db.kind === "literal") {
+                                dimName = db.value;
+                            }
+                        }
+                    }
+                    // Resolve the subset the element was inserted into (literal or var);
+                    // arg position varies per func (Insert@1, Add/Delete@0) — SUBSET_ARG_IDX handles that.
+                    let subName;
+                    const subIdx = SUBSET_ARG_IDX.get(funcLower);
+                    if (subIdx !== undefined && subIdx < args.length) {
+                        const subArg = args[subIdx];
+                        subName = extractStringLiteral(subArg) ?? undefined;
+                        if (subName === undefined) {
+                            const sb = resolveExpression(subArg, callerEnv);
+                            if (sb.kind === "literal") {
+                                subName = sb.value;
+                            }
+                        }
+                    }
+                    let elemName = extractStringLiteral(elemArg);
+                    if (elemName === null) {
+                        const eb = resolveExpression(elemArg, callerEnv);
+                        if (eb.kind === "literal") {
+                            elemName = eb.value;
+                        }
+                        else {
+                            if (unresolvedElemOut) {
+                                unresolvedElemOut.push({
+                                    line: lineIdx,
+                                    funcName: m[1],
+                                    dimension: dimName,
+                                    expr: elemArg.trim(),
+                                    snippet,
+                                    reason: eb.kind === "param" ? "param" : "dynamic",
+                                });
+                            }
+                            elemName = null;
+                        }
+                    }
+                    if (elemName !== null) {
+                        // Known edge: elemName resolved but dimName did NOT (e.g. dimension is an
+                        // unresolved param). The ref is still pushed here (and surfaces in this
+                        // process's per-row `elements` list via elementsForProcess), but with
+                        // dimension:undefined it is skipped by the byElement bucketing below
+                        // (elementKey needs both dim+element) and is NOT recorded in
+                        // unresolvedElementRefsBySourceProcess either (that bucket is for
+                        // unresolved ELEMENT args, not unresolved DIMENSION args). So this element
+                        // is reverse-queryable by name via bySourceProcess but not via the
+                        // element/dimension filter. A future "unresolved dimension" bucket could
+                        // close this gap.
+                        refs.push({
+                            line: lineIdx,
+                            funcName: m[1],
+                            targetKind: "element",
+                            targetName: elemName,
+                            dimension: dimName,
+                            subset: subName,
+                            snippet,
+                            params: undefined,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return refs;
+}
+const FEEDERS_MARKER_RE = /^\s*FEEDERS\s*;/i;
+/**
+ * Extracts cube (from DB()) and dimension (from [...] refs) references
+ * from a rules/feeders text. Pure function.
+ */
+export function extractRulesReferences(text) {
+    const refs = [];
+    const lines = text.split("\n");
+    let section = "rules";
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx].replace(/\r$/, "");
+        const trimmed = line.trim();
+        if (FEEDERS_MARKER_RE.test(trimmed)) {
+            section = "feeders";
+            continue;
+        }
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            continue;
+        }
+        const snippet = truncateSnippet(line);
+        // DB(...) → cube reference
+        for (const call of extractDbCalls(line)) {
+            if (call.cubeName !== null) {
+                refs.push({
+                    line: lineIdx,
+                    section,
+                    funcName: "DB",
+                    targetKind: "cube",
+                    targetName: call.cubeName,
+                    snippet,
+                });
+            }
+        }
+        // [...] → dimension references (only valid syntactic refs)
+        for (const bracket of extractBracketRefs(line)) {
+            if (validateBracketRefSyntax(bracket) !== null) {
+                continue;
+            }
+            if (!bracket.includes("'")) {
+                continue;
+            }
+            for (const { dim } of parseBracketDimRefs(bracket)) {
+                refs.push({
+                    line: lineIdx,
+                    section,
+                    targetKind: "dimension",
+                    targetName: dim,
+                    snippet,
+                });
+            }
+        }
+    }
+    return refs;
+}
+/**
+ * Builds a complete reference index from processes + cube rules.
+ * Pure function — dependencies are injected to allow testing without network.
+ */
+export async function buildReferenceIndex(deps) {
+    // Per-source tolerance: a NOT_FOUND / PERMISSION_DENIED on one domain
+    // degrades to an empty slice. But a systemic failure (auth expired, server
+    // unreachable, lock timeout) must propagate — otherwise an outage builds an
+    // empty index that looks like an empty server and gets cached as truth.
+    const [processes, cubes, chores] = await Promise.all([
+        deps.fetchProcesses().catch((e) => {
+            rethrowIfSystemic(e);
+            return [];
+        }),
+        deps.fetchCubesWithRules().catch((e) => {
+            rethrowIfSystemic(e);
+            return [];
+        }),
+        deps.fetchChores?.().catch((e) => {
+            rethrowIfSystemic(e);
+            return [];
+        }) ?? Promise.resolve([]),
+    ]);
+    const all = [];
+    const unresolvedCallsBySourceProcess = new Map();
+    const unresolvedElementRefsBySourceProcess = new Map();
+    const subsetUsageByProcess = new Map();
+    const pushTi = (sourceName, section, text, env, sharedLiveVars) => {
+        if (!text) {
+            return;
+        }
+        const unresolvedOut = [];
+        const unresolvedElemOut = [];
+        for (const r of extractTiReferences(text, env, sharedLiveVars, unresolvedOut, unresolvedElemOut)) {
+            all.push({
+                sourceKind: "process",
+                sourceName,
+                section,
+                line: r.line,
+                snippet: r.snippet,
+                funcName: r.funcName,
+                targetKind: r.targetKind,
+                targetName: r.targetName,
+                dimension: r.dimension, // ← forward element owner
+                subset: r.subset, // ← forward subset the element was inserted into
+                params: r.params,
+            });
+        }
+        if (unresolvedOut.length > 0) {
+            const key = sourceName.toLowerCase();
+            const bucket = unresolvedCallsBySourceProcess.get(key) ?? [];
+            for (const u of unresolvedOut) {
+                bucket.push({
+                    section,
+                    line: u.line,
+                    funcName: u.funcName,
+                    expr: u.expr,
+                    snippet: u.snippet,
+                    reason: u.reason,
+                });
+            }
+            unresolvedCallsBySourceProcess.set(key, bucket);
+        }
+        if (unresolvedElemOut.length > 0) {
+            const key = sourceName.toLowerCase();
+            const arr = unresolvedElementRefsBySourceProcess.get(key) ?? [];
+            for (const u of unresolvedElemOut) {
+                arr.push({
+                    section,
+                    line: u.line,
+                    funcName: u.funcName,
+                    dimension: u.dimension,
+                    expr: u.expr,
+                    snippet: u.snippet,
+                    reason: u.reason,
+                });
+            }
+            unresolvedElementRefsBySourceProcess.set(key, arr);
+        }
+    };
+    for (const p of processes) {
+        // Build env once from *all* sections concatenated so var assignments made in
+        // Prolog are visible to ExecuteProcess calls in Data/Epilog (mirrors TI runtime behavior).
+        const combinedText = [p.prolog, p.metadata, p.data, p.epilog].join("\n");
+        const env = buildProcessEnv(combinedText, p.parameters ?? []);
+        // Shared liveVars über alle 4 Sections — Prolog-Zuweisungen bleiben in Data/Epilog sichtbar
+        // und die flow-sensitive Auswertung funktioniert auch über Section-Grenzen hinweg.
+        const sharedLiveVars = new Map(env.vars);
+        pushTi(p.name, "prolog", p.prolog, env, sharedLiveVars);
+        pushTi(p.name, "metadata", p.metadata, env, sharedLiveVars);
+        pushTi(p.name, "data", p.data, env, sharedLiveVars);
+        pushTi(p.name, "epilog", p.epilog, env, sharedLiveVars);
+        subsetUsageByProcess.set(p.name.toLowerCase(), extractSubsetUsage(combinedText, env));
+    }
+    for (const c of cubes) {
+        if (!c.rulesText) {
+            continue;
+        }
+        for (const r of extractRulesReferences(c.rulesText)) {
+            all.push({
+                sourceKind: "rule",
+                sourceName: c.cubeName,
+                section: r.section,
+                line: r.line,
+                snippet: r.snippet,
+                funcName: r.funcName,
+                targetKind: r.targetKind,
+                targetName: r.targetName,
+            });
+        }
+    }
+    const byCube = new Map();
+    const byDim = new Map();
+    const byProcess = new Map();
+    const byElement = new Map();
+    const bySourceProcess = new Map();
+    const bucket = (m, key, ref) => {
+        const lc = key.toLowerCase();
+        const arr = m.get(lc) ?? [];
+        arr.push(ref);
+        m.set(lc, arr);
+    };
+    for (const ref of all) {
+        switch (ref.targetKind) {
+            case "cube":
+                bucket(byCube, ref.targetName, ref);
+                break;
+            case "dimension":
+                bucket(byDim, ref.targetName, ref);
+                break;
+            case "process":
+                bucket(byProcess, ref.targetName, ref);
+                break;
+            case "element":
+                if (ref.dimension) {
+                    const k = elementKey(ref.dimension, ref.targetName);
+                    const arr = byElement.get(k) ?? [];
+                    arr.push(ref);
+                    byElement.set(k, arr);
+                }
+                break;
+        }
+        if (ref.sourceKind === "process") {
+            bucket(bySourceProcess, ref.sourceName, ref);
+        }
+    }
+    const processParams = new Map();
+    const processDefaults = new Map();
+    for (const p of processes) {
+        if (p.parameters && p.parameters.length > 0) {
+            processParams.set(p.name.toLowerCase(), p.parameters);
+        }
+        if (p.parameterDefaults && p.parameterDefaults.size > 0) {
+            processDefaults.set(p.name.toLowerCase(), p.parameterDefaults);
+        }
+    }
+    const choreTasks = new Map();
+    for (const c of chores) {
+        if (!c.name) {
+            continue;
+        }
+        choreTasks.set(c.name.toLowerCase(), c.tasks);
+    }
+    return {
+        all,
+        byCube,
+        byDim,
+        byProcess,
+        byElement,
+        bySourceProcess,
+        unresolvedCallsBySourceProcess,
+        unresolvedElementRefsBySourceProcess,
+        subsetUsageByProcess,
+        processParams,
+        processDefaults,
+        choreTasks,
+    };
+}
+/** Convenience lookup — returns [] if target is not indexed. */
+export function lookupReferences(idx, targetKind, targetName) {
+    const lc = targetName.toLowerCase();
+    switch (targetKind) {
+        case "cube":
+            return idx.byCube.get(lc) ?? [];
+        case "dimension":
+            return idx.byDim.get(lc) ?? [];
+        case "process":
+            return idx.byProcess.get(lc) ?? [];
+        // byElement is keyed by elementKey(dim, element), a composite key this single-name
+        // lookup can't build — callers needing element refs use idx.byElement directly.
+        case "element":
+            return [];
+    }
+}
+//# sourceMappingURL=referenceIndex.js.map

package/dist/lib/callgraph/rulesLinter.d.ts

@@ -0,0 +1,55 @@
+export interface RulesLintDiagnose {
+    line: number;
+    message: string;
+    severity: "error" | "warning" | "hint";
+    ruleId: string;
+}
+export type ApiRequestFn = (method: string, path: string) => Promise<{
+    statusCode: number;
+    body: string;
+}>;
+/**
+ * Extracts all [...] block contents from a line (from original, not neutralized).
+ * Uses neutralized positions to avoid false positives inside strings/comments.
+ */
+export declare function extractBracketRefs(line: string): string[];
+/**
+ * Validates the syntax of a [...] cell reference content (without outer brackets).
+ * Returns an error message or null if valid.
+ *
+ * Valid forms:
+ *   'DimName':'ElemName'
+ *   'DimName':{'E1','E2',...}
+ *   Multiple of the above separated by commas
+ */
+export declare function validateBracketRefSyntax(content: string): string | null;
+/** Parsed dimension + element(s) from a single [...] spec. */
+export interface BracketDimRef {
+    dim: string;
+    elems: string[];
+}
+/**
+ * Parses 'DimName':'ElemName' pairs from a bracket ref content.
+ * Only handles quoted string literals — dynamic refs are ignored.
+ */
+export declare function parseBracketDimRefs(content: string): BracketDimRef[];
+interface DbCall {
+    args: string[];
+    cubeName: string | null;
+}
+/**
+ * Extracts all DB(...) calls from a line with their parsed arguments.
+ * Uses neutralized positions to skip DB() inside strings/comments.
+ */
+export declare function extractDbCalls(line: string): DbCall[];
+export declare function lintRules(text: string): RulesLintDiagnose[];
+/**
+ * Runs server-side lint checks against an active TM1 connection:
+ * - DB() argument count vs. actual cube dimension count
+ * - Element existence within the referenced dimension
+ *
+ * Silently returns [] if the server is unreachable or no relevant refs are found.
+ */
+export declare function lintRulesServer(text: string, api: ApiRequestFn): Promise<RulesLintDiagnose[]>;
+export {};
+//# sourceMappingURL=rulesLinter.d.ts.map