@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,26 @@
+export interface ParsedRulesLine {
+    lineIndex: number;
+    raw: string;
+    trimmed: string;
+    isComment: boolean;
+    isBlank: boolean;
+    isSkipcheck: boolean;
+    isFeedstrings: boolean;
+    isFeedersMarker: boolean;
+    /** `STET` keyword present outside string literals / comments (rules side). */
+    hasStet: boolean;
+    /** `IF(` call present outside string literals / comments (rule RHS or feeder LHS guard). */
+    hasIfGuard: boolean;
+    section: "rules" | "feeders";
+}
+export interface RulesAst {
+    lines: ParsedRulesLine[];
+    hasSkipcheck: boolean;
+    skipcheckLine: number;
+    hasFeedstrings: boolean;
+    feedstringsLine: number;
+    feedersLineIndex: number;
+    feedersCount: number;
+}
+export declare function parseRules(text: string): RulesAst;
+//# sourceMappingURL=rulesParser.d.ts.map

package/dist/lib/callgraph/rulesParser.js

@@ -0,0 +1,71 @@
+/** Replace quoted strings with same-length spaces and strip trailing `#…` comment. */
+function neutralize(line) {
+    return line
+        .replace(/'[^']*'/g, (s) => " ".repeat(s.length))
+        .replace(/#.*$/, "");
+}
+export function parseRules(text) {
+    const rawLines = text.split("\n");
+    let feedersCount = 0;
+    let feedersLineIndex = -1;
+    let hasSkipcheck = false;
+    let skipcheckLine = -1;
+    let hasFeedstrings = false;
+    let feedstringsLine = -1;
+    let inFeeders = false;
+    const lines = rawLines.map((raw, lineIndex) => {
+        const trimmed = raw.replace(/\r$/, "").trim();
+        const isComment = trimmed.startsWith("#");
+        const isBlank = trimmed === "";
+        const isSkipcheck = /^skipcheck\s*;?\s*$/i.test(trimmed);
+        const isFeedstrings = /^feedstrings\s*;?\s*$/i.test(trimmed);
+        const isFeedersMarker = /^feeders\s*;?\s*$/i.test(trimmed);
+        const neutralized = isComment || isBlank ? "" : neutralize(trimmed);
+        const hasStet = /\bstet\b/i.test(neutralized);
+        const hasIfGuard = /\bif\s*\(/i.test(neutralized);
+        if (isSkipcheck && !hasSkipcheck) {
+            hasSkipcheck = true;
+            skipcheckLine = lineIndex;
+        }
+        if (isFeedstrings && !hasFeedstrings) {
+            hasFeedstrings = true;
+            feedstringsLine = lineIndex;
+        }
+        // Capture section BEFORE the marker flips state: the `FEEDERS;` marker
+        // line itself belongs to the rules section it closes — only the lines
+        // that follow it carry `section: 'feeders'`. Otherwise consumers that
+        // iterate `section === 'feeders'` would sweep the marker too unless
+        // they also test `isFeedersMarker`.
+        const section = inFeeders ? "feeders" : "rules";
+        if (isFeedersMarker) {
+            feedersCount++;
+            if (feedersCount === 1) {
+                feedersLineIndex = lineIndex;
+            }
+            inFeeders = true;
+        }
+        return {
+            lineIndex,
+            raw,
+            trimmed,
+            isComment,
+            isBlank,
+            isSkipcheck,
+            isFeedstrings,
+            isFeedersMarker,
+            hasStet,
+            hasIfGuard,
+            section,
+        };
+    });
+    return {
+        lines,
+        hasSkipcheck,
+        skipcheckLine,
+        hasFeedstrings,
+        feedstringsLine,
+        feedersLineIndex,
+        feedersCount,
+    };
+}
+//# sourceMappingURL=rulesParser.js.map

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

@@ -0,0 +1,16 @@
+import { type ProcessEnv } from "./variableEnv.js";
+export interface ViewUsage {
+    view?: string | undefined;
+    cube?: string | undefined;
+    zeroOut: boolean;
+}
+export interface SubsetUsage {
+    subset: string;
+    resolved: boolean;
+    views: ViewUsage[];
+    loopRead: boolean;
+    loopWrite: boolean;
+    loopZero: boolean;
+}
+export declare function extractSubsetUsage(text: string, env?: ProcessEnv): Map<string, SubsetUsage>;
+//# sourceMappingURL=subsetUsage.d.ts.map

package/dist/lib/callgraph/subsetUsage.js

@@ -0,0 +1,134 @@
+// Pure per-process scan classifying how each subset handle is USED in a process's TI.
+// Feeds element usage classification (source / write / zero-out / indeterminate).
+// NOT a datasource check — the process datasource lives in dsList and is joined at
+// query time in traceDataFlow.
+import { buildProcessEnv, resolveExpression, } from "./variableEnv.js";
+import { splitArgs, extractStringLiteral } from "./referenceIndex.js";
+import { classifyAccess } from "./callGraph.js";
+const CALL_RE = /\b([A-Za-z_]\w*)\s*\(/gi;
+function resolveArg(raw, env) {
+    if (raw === undefined)
+        return { resolved: false };
+    const lit = extractStringLiteral(raw);
+    if (lit !== null)
+        return { value: lit, resolved: true };
+    const b = resolveExpression(raw, env);
+    if (b.kind === "literal")
+        return { value: b.value, resolved: true };
+    return { resolved: false };
+}
+export function extractSubsetUsage(text, env) {
+    const baseEnv = env ?? buildProcessEnv(text, []);
+    const usage = new Map();
+    const viewToSubsets = new Map(); // lc "cube view" -> subset lc keys
+    let synth = 0;
+    const getBucket = (subLc, subName, resolved) => {
+        let u = usage.get(subLc);
+        if (!u) {
+            u = {
+                subset: subName ?? "",
+                resolved,
+                views: [],
+                loopRead: false,
+                loopWrite: false,
+                loopZero: false,
+            };
+            usage.set(subLc, u);
+        }
+        if (!resolved)
+            u.resolved = false;
+        return u;
+    };
+    // Process-wide read/write presence (loose loop-body heuristic — see plan note).
+    let hasCellRead = false;
+    let hasCellWrite = false;
+    let hasZeroWrite = false;
+    const iteratedSubsets = new Set();
+    const lines = text.split("\n");
+    for (const line of lines) {
+        let m;
+        CALL_RE.lastIndex = 0;
+        while ((m = CALL_RE.exec(line)) !== null) {
+            const fn = m[1].toLowerCase();
+            const open = m.index + m[0].length - 1;
+            const argStr = sliceArgs(line, open);
+            const args = argStr === null ? [] : splitArgs(argStr);
+            if (fn === "viewsubsetassign") {
+                const cube = resolveArg(args[0], baseEnv);
+                const view = resolveArg(args[1], baseEnv);
+                const sub = resolveArg(args[3], baseEnv);
+                const subLc = sub.value?.toLowerCase() ?? `__unresolved_${synth++}`;
+                const u = getBucket(subLc, sub.value, sub.resolved && view.resolved);
+                u.views.push({ view: view.value, cube: cube.value, zeroOut: false });
+                if (view.resolved && cube.value !== undefined) {
+                    const vk = `${cube.value.toLowerCase()} ${view.value.toLowerCase()}`;
+                    const arr = viewToSubsets.get(vk) ?? [];
+                    arr.push(subLc);
+                    viewToSubsets.set(vk, arr);
+                }
+            }
+            else if (fn === "viewzeroout") {
+                const cube = resolveArg(args[0], baseEnv);
+                const view = resolveArg(args[1], baseEnv);
+                if (cube.resolved && view.resolved) {
+                    const vk = `${cube.value.toLowerCase()} ${view.value.toLowerCase()}`;
+                    for (const subLc of viewToSubsets.get(vk) ?? []) {
+                        const u = usage.get(subLc);
+                        if (u)
+                            for (const v of u.views) {
+                                if (v.cube?.toLowerCase() === cube.value.toLowerCase() &&
+                                    v.view?.toLowerCase() === view.value.toLowerCase())
+                                    v.zeroOut = true;
+                            }
+                    }
+                }
+            }
+            else if (fn === "subsetgetelementname" || fn === "subsetgetsize") {
+                const sub = resolveArg(args[0], baseEnv);
+                if (sub.resolved)
+                    iteratedSubsets.add(sub.value.toLowerCase());
+            }
+            else {
+                const access = classifyAccess(fn, "process");
+                if (access === "read")
+                    hasCellRead = true;
+                else if (access === "write") {
+                    hasCellWrite = true;
+                    if ((fn === "cellputn" || fn === "cellincrementn") &&
+                        isLiteralZero(args[0]))
+                        hasZeroWrite = true;
+                }
+            }
+        }
+    }
+    // Attribute the process-wide loop read/write to each iterated subset (loose heuristic).
+    for (const subLc of iteratedSubsets) {
+        const u = getBucket(subLc, subLc, true);
+        if (hasCellRead)
+            u.loopRead = true;
+        if (hasCellWrite)
+            u.loopWrite = true;
+        if (hasZeroWrite)
+            u.loopZero = true;
+    }
+    return usage;
+}
+function isLiteralZero(raw) {
+    return raw !== undefined && raw.trim() === "0";
+}
+// Extract the substring between the '(' at openIdx and its matching ')' on the same line.
+function sliceArgs(line, openIdx) {
+    let depth = 0;
+    for (let i = openIdx; i < line.length; i++) {
+        const c = line[i];
+        if (c === "(")
+            depth++;
+        else if (c === ")") {
+            depth--;
+            if (depth === 0)
+                return line.slice(openIdx + 1, i);
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=subsetUsage.js.map

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

@@ -0,0 +1,21 @@
+import { type TiParseResult } from "./types.js";
+/**
+ * Parses TI (TurboIntegrator) source code into an AST.
+ *
+ * Handles:
+ * - Assignments: `variable = expression;`
+ * - IF/ELSEIF/ELSE/ENDIF blocks (nested)
+ * - WHILE/END loops (nested)
+ * - Function calls as statements: `FunctionName(args...);`
+ * - CellGetN/CellGetS detection in assignment expressions
+ * - Comment lines (starting with #) and blank lines are skipped
+ */
+export declare function parseTiCode(code: string): TiParseResult;
+/**
+ * Joins continuation lines into single logical lines to handle multi-line statements.
+ * A line is a continuation when prior lines have left parentheses open (depth > 0).
+ * Preserves the total line count so error line numbers remain accurate:
+ * the joined content is placed on the FIRST line; continuation lines become empty.
+ */
+export declare function joinContinuationLines(lines: string[]): string[];
+//# sourceMappingURL=tiParser.d.ts.map