@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/complexity/antipatterns.js

@@ -0,0 +1,302 @@
+/**
+ * TI anti-pattern lint engine.
+ *
+ * Walks the parsed AST of each process tab and emits a flat list of findings —
+ * a different shape from the metrics ranking in {@link ./process-metrics}, kept
+ * separate on purpose (rule violations, not a score). The same engine is meant
+ * to be reusable later from a single-process pre-commit lint entry point.
+ */
+import { parseTiCode } from "../callgraph/tiParser.js";
+const TABS = ["prolog", "metadata", "data", "epilog"];
+/**
+ * Destructive ops that wipe data/objects. Unconditional use (no enclosing If)
+ * is treated as an error — a guard expresses deliberate intent. Lowercased.
+ */
+const DESTRUCTIVE = new Set([
+    "cubecleardata",
+    "dimensiondeleteallelements",
+    "processdestroy",
+]);
+/**
+ * A destructive op is by-design (not a bug) when the process is a dedicated
+ * clear/init/reset/test proc — those exist to wipe data. Matching the name
+ * downgrades destructive-unguarded from error to warn (still surfaced, not
+ * silenced). Substring match on the lowercased process name.
+ */
+const CLEAR_PROC_TOKENS = [
+    "init",
+    "zeroout",
+    "zero_out",
+    "clear",
+    "reset",
+    "test",
+    "wipe",
+];
+function isClearProc(name) {
+    const n = name.toLowerCase();
+    return CLEAR_PROC_TOKENS.some((t) => n.includes(t));
+}
+/** Process-invocation calls; in a loop they recurse/serialize. Lowercased. */
+const PROCESS_CALLS = new Set(["executeprocess", "runprocess"]);
+const DEFAULT_CELLGET_DIM_THRESHOLD = 12;
+// ---- dead-assignment helpers ----
+/** TI implicit / datasource variables — never flagged as dead assignments. */
+const IMPLICIT_VARS = new Set([
+    "value_is_string",
+    "nvalue",
+    "svalue",
+    "datasourcenamescript",
+    "datasourceasciidelimiter",
+    "datasourceasciiquotecharacter",
+    "datasourceasciithousandseparator",
+    "datasourceasciiheaderrecords",
+    "datasourceasciiDecimalseparator",
+    "datasourceasciidecimalseparator",
+    "datasourceview",
+    "datasourcecube",
+    "datasourcedimension",
+    "datasourcedimensionsubset",
+    "datasourcetype",
+    "datasourcenameforserver",
+    "datasourcenameforserverisoctet",
+]);
+function isImplicitVar(name) {
+    const n = name.toLowerCase();
+    if (IMPLICIT_VARS.has(n))
+        return true;
+    // V1, V2, ..., Vn  (datasource column vars)
+    if (/^v\d+$/.test(n))
+        return true;
+    return false;
+}
+/** RHS functions whose capture is idiomatically a return-code — skip dead check on the LHS. */
+const SIDE_EFFECT_RHS = new Set([
+    "executeprocess",
+    "runprocess",
+    "fileop",
+    "executeview",
+]);
+function hasSideEffectRhs(expr) {
+    const lo = expr.toLowerCase();
+    for (const fn of SIDE_EFFECT_RHS) {
+        if (lo.includes(fn + "("))
+            return true;
+    }
+    return false;
+}
+const IDENTIFIER_RE = /\b([A-Za-z_]\w*)\b/g;
+const EXPAND_VAR_RE = /%([A-Za-z_]\w*)%/g;
+/** Extract all potential variable-read tokens from a raw TI expression/arg/condition string. */
+function collectReads(text, out) {
+    // %varName% inside Expand calls
+    for (const m of text.matchAll(EXPAND_VAR_RE)) {
+        if (m[1])
+            out.add(m[1].toLowerCase());
+    }
+    // Strip string literals so identifiers inside them don't pollute the read-set
+    const stripped = text.replace(/'(?:[^']|'')*'/g, "''");
+    for (const m of stripped.matchAll(IDENTIFIER_RE)) {
+        if (m[1])
+            out.add(m[1].toLowerCase());
+    }
+}
+function collectReadsFromStmts(stmts, out) {
+    for (const s of stmts) {
+        if (s.type === "assignment") {
+            collectReads(s.expression, out);
+        }
+        else if (s.type === "if") {
+            const blk = s;
+            collectReads(blk.condition, out);
+            collectReadsFromStmts(blk.thenBody, out);
+            for (const c of blk.elseIfClauses) {
+                collectReads(c.condition, out);
+                collectReadsFromStmts(c.body, out);
+            }
+            collectReadsFromStmts(blk.elseBody, out);
+        }
+        else if (s.type === "while") {
+            const blk = s;
+            collectReads(blk.condition, out);
+            collectReadsFromStmts(blk.body, out);
+        }
+        else if (s.type === "functionCall") {
+            for (const arg of s.args) {
+                collectReads(arg, out);
+            }
+        }
+    }
+}
+function collectDeadCandidates(stmts, tab, out) {
+    for (const s of stmts) {
+        if (s.type === "assignment") {
+            if (!isImplicitVar(s.variable) && !hasSideEffectRhs(s.expression)) {
+                out.push({
+                    variable: s.variable.toLowerCase(),
+                    originalVar: s.variable,
+                    tab,
+                    line: s.line,
+                });
+            }
+        }
+        else if (s.type === "if") {
+            const blk = s;
+            collectDeadCandidates(blk.thenBody, tab, out);
+            for (const c of blk.elseIfClauses) {
+                collectDeadCandidates(c.body, tab, out);
+            }
+            collectDeadCandidates(blk.elseBody, tab, out);
+        }
+        else if (s.type === "while") {
+            const blk = s;
+            collectDeadCandidates(blk.body, tab, out);
+        }
+    }
+}
+/**
+ * Strip a TI single-quoted string literal to its inner value, or return null if
+ * the arg is not a string literal (e.g. a variable or number).
+ */
+function stringLiteralValue(arg) {
+    const t = arg.trim();
+    if (t.length < 2 || t[0] !== "'" || t[t.length - 1] !== "'")
+        return null;
+    return t.slice(1, -1).replace(/''/g, "'");
+}
+/** UNC (`\\srv\…`) or drive-letter (`C:\…`) absolute path. */
+const PATH_LITERAL = /^(?:\\\\|[A-Za-z]:[\\/])/;
+function walk(stmts, loopDepth, ifDepth, ctx) {
+    for (const s of stmts) {
+        if (s.type === "assignment") {
+            const cg = s.cellGetInfo;
+            if (cg) {
+                // params[0] is the cube; remaining args are one element ref per
+                // dimension, so dimCount = params.length - 1.
+                const dimCount = Math.max(cg.params.length - 1, 0);
+                if (dimCount >= ctx.cellGetDimThreshold) {
+                    const inLoop = loopDepth > 0;
+                    ctx.findings.push({
+                        process: ctx.process,
+                        tab: ctx.tab,
+                        line: s.line,
+                        rule: "cellget-perf",
+                        severity: inLoop ? "warn" : "info",
+                        snippet: `${s.variable} = ${cg.fn}(${cg.params.join(", ")})`,
+                        hint: `${cg.fn} on a ${dimCount}-dimension cube` +
+                            (inLoop ? ` inside a loop (depth ${loopDepth})` : "") +
+                            ` can be a perf hot path on large cubes — worse when many consolidated (C) elements are addressed (not statically detectable here). Consider an MDX/view read or caching.`,
+                    });
+                }
+            }
+        }
+        else if (s.type === "if") {
+            const blk = s;
+            walk(blk.thenBody, loopDepth, ifDepth + 1, ctx);
+            for (const c of blk.elseIfClauses)
+                walk(c.body, loopDepth, ifDepth + 1, ctx);
+            walk(blk.elseBody, loopDepth, ifDepth + 1, ctx);
+        }
+        else if (s.type === "while") {
+            const blk = s;
+            walk(blk.body, loopDepth + 1, ifDepth, ctx);
+        }
+        else if (s.type === "functionCall") {
+            const name = s.name.toLowerCase();
+            const snippet = `${s.name}(${s.args.join(", ")})`;
+            if (ifDepth === 0 && DESTRUCTIVE.has(name)) {
+                ctx.findings.push({
+                    process: ctx.process,
+                    tab: ctx.tab,
+                    line: s.line,
+                    rule: "destructive-unguarded",
+                    severity: ctx.clearProc ? "warn" : "error",
+                    snippet,
+                    hint: ctx.clearProc
+                        ? `${s.name} wipes data/objects unconditionally. The process name marks it a clear/init proc, so this is likely by-design — confirm it can only target the intended cube.`
+                        : `${s.name} wipes data/objects unconditionally — wrap in an If guard so it cannot run by accident.`,
+                });
+            }
+            if (loopDepth > 0 && PROCESS_CALLS.has(name)) {
+                const isAsync = name === "runprocess";
+                ctx.findings.push({
+                    process: ctx.process,
+                    tab: ctx.tab,
+                    line: s.line,
+                    rule: "exec-in-loop",
+                    severity: "warn",
+                    snippet,
+                    hint: isAsync
+                        ? `RunProcess in a loop runs async — you lose control over timing and persistence (when each child commits). Prefer a single child that loops internally.`
+                        : `ExecuteProcess in a loop runs sync per iteration — adds compounding complexity and overhead. Consider pushing the loop into the child.`,
+                });
+            }
+            for (const arg of s.args) {
+                const val = stringLiteralValue(arg);
+                if (val && PATH_LITERAL.test(val)) {
+                    ctx.findings.push({
+                        process: ctx.process,
+                        tab: ctx.tab,
+                        line: s.line,
+                        rule: "hardcoded-path",
+                        severity: "warn",
+                        snippet: `${s.name}(… ${arg} …)`,
+                        hint: `Hardcoded path '${val}' in ${s.name} — move it to a process parameter or a config cube so it survives environment moves.`,
+                    });
+                }
+            }
+        }
+    }
+}
+export function lintProcess(process, code, opts) {
+    const cellGetDimThreshold = opts?.cellGetDimThreshold ?? DEFAULT_CELLGET_DIM_THRESHOLD;
+    const clearProc = isClearProc(process);
+    const findings = [];
+    // Parse all tabs once; reuse for both walk and dead-assignment passes.
+    const parsedTabs = new Map();
+    for (const tab of TABS) {
+        const src = code[tab] ?? "";
+        if (src.trim() === "")
+            continue;
+        const parsed = parseTiCode(src);
+        if (!parsed.ok)
+            continue;
+        parsedTabs.set(tab, parsed.ast);
+    }
+    // Existing per-tab rules
+    for (const [tab, ast] of parsedTabs) {
+        walk(ast, 0, 0, { process, tab, cellGetDimThreshold, clearProc, findings });
+    }
+    // dead-assignment: two-pass over all parsed tabs
+    const readSet = new Set();
+    for (const ast of parsedTabs.values()) {
+        collectReadsFromStmts(ast, readSet);
+    }
+    const excludeSet = new Set((opts?.excludeVarsFromDeadCheck ?? []).map((v) => v.toLowerCase()));
+    const deadCandidates = [];
+    for (const tab of ["metadata", "data"]) {
+        const ast = parsedTabs.get(tab);
+        if (ast)
+            collectDeadCandidates(ast, tab, deadCandidates);
+    }
+    const reported = new Set();
+    for (const c of deadCandidates) {
+        if (reported.has(c.variable))
+            continue;
+        if (excludeSet.has(c.variable))
+            continue;
+        if (!readSet.has(c.variable)) {
+            reported.add(c.variable);
+            findings.push({
+                process,
+                tab: c.tab,
+                line: c.line,
+                rule: "dead-assignment",
+                severity: "info",
+                snippet: `${c.originalVar} = ...`,
+                hint: `'${c.originalVar}' is assigned in the ${c.tab} tab but never read — remove or use it.`,
+            });
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=antipatterns.js.map

package/dist/lib/complexity/comment-classifier.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Heuristic split of `#`-comment lines into real comments (natural-language
+ * documentation) vs commented-out code (disabled TM1 rule/TI statements).
+ *
+ * In TM1 the `#` prefix serves both roles, so a naive "starts with #" comment
+ * count conflates the two. That matters because the complexity scorer can
+ * *discount* a score by its comment ratio (commentDiscountMax): disabled dead
+ * code masquerading as documentation would make a complex object look simpler,
+ * and inflate "well-documented" signals. This classifier lets callers count the
+ * two separately.
+ *
+ * The heuristic favours low false positives on prose: the dominant signal is a
+ * trailing `;` (almost every active TM1 statement ends with one; prose rarely
+ * does), backed by structural signals (rule-area assignment, variable
+ * assignment, known function calls, control-flow keywords with a paren, bare
+ * directives). It is intentionally fuzzy — there is no parser that can tell a
+ * disabled statement from prose with certainty.
+ */
+/**
+ * True when a `#`-prefixed comment line looks like disabled TM1 code rather
+ * than prose. Accepts the trimmed line with or without its leading `#`.
+ */
+export declare function isCommentedOutCode(commentLine: string): boolean;
+//# sourceMappingURL=comment-classifier.d.ts.map

package/dist/lib/complexity/comment-classifier.js

@@ -0,0 +1,43 @@
+/**
+ * Heuristic split of `#`-comment lines into real comments (natural-language
+ * documentation) vs commented-out code (disabled TM1 rule/TI statements).
+ *
+ * In TM1 the `#` prefix serves both roles, so a naive "starts with #" comment
+ * count conflates the two. That matters because the complexity scorer can
+ * *discount* a score by its comment ratio (commentDiscountMax): disabled dead
+ * code masquerading as documentation would make a complex object look simpler,
+ * and inflate "well-documented" signals. This classifier lets callers count the
+ * two separately.
+ *
+ * The heuristic favours low false positives on prose: the dominant signal is a
+ * trailing `;` (almost every active TM1 statement ends with one; prose rarely
+ * does), backed by structural signals (rule-area assignment, variable
+ * assignment, known function calls, control-flow keywords with a paren, bare
+ * directives). It is intentionally fuzzy — there is no parser that can tell a
+ * disabled statement from prose with certainty.
+ */
+const CODE_SIGNALS = [
+    // Statement terminator at end of line — the strongest TM1 signal.
+    /;\s*$/,
+    // Rule-area assignment: `['Sales'] = ...`
+    /^\[[^\]]*\]\s*=/,
+    // Variable / cube-cell assignment: `vX = ...` or `nResult=...` (not `==`).
+    /^[A-Za-z_]\w*\s*=(?!=)/,
+    // Known TM1 function call: `Name(` (case-insensitive — TM1 is).
+    /\b(?:CellPutN|CellPutS|CellGetN|CellGetS|CellIsUpdateable|DB|DBRW|DBRA|DBSW|DBSS|AttrPutN|AttrPutS|AttrN|AttrS|ElementName|ElementIndex|DimensionElementInsert|DimensionElementComponentAdd|HierarchyElementInsert|ExecuteProcess|ExecuteCommand|RunProcess|ProcessQuit|ProcessBreak|ItemSkip|ItemReject|ViewZeroOut|CubeClearData|CubeSetLogChanges|ASCIIOutput|TextOutput|SubsetCreate|NumberToString|StringToNumber)\s*\(/i,
+    // Control-flow keyword immediately followed by a paren: `IF(`, `WHILE (`.
+    /^(?:IF|WHILE|ELSEIF)\s*\(/i,
+    // Bare block directives / keywords on their own line.
+    /^(?:SKIPCHECK|FEEDERS|FEEDSTRINGS|ENDIF|ELSE|END|PROCESSBREAK|PROCESSQUIT|ITEMSKIP)\s*;?\s*$/i,
+];
+/**
+ * True when a `#`-prefixed comment line looks like disabled TM1 code rather
+ * than prose. Accepts the trimmed line with or without its leading `#`.
+ */
+export function isCommentedOutCode(commentLine) {
+    const body = commentLine.replace(/^#+/, "").trim();
+    if (body === "")
+        return false;
+    return CODE_SIGNALS.some((re) => re.test(body));
+}
+//# sourceMappingURL=comment-classifier.js.map

package/dist/lib/complexity/cross-process.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cross-process consistency metrics. Focus: naming + structure coherence
+ * across many TI processes, not per-process micro-metrics.
+ *
+ * Premise: variability across processes is the maintenance cost driver, not
+ * raw counts. A 200-line process with idiosyncratic naming hurts more than a
+ * 1000-line process that follows the same patterns as its 50 siblings.
+ */
+import type { TiTab } from "./process-metrics.js";
+export type VarType = "String" | "Numeric";
+export interface ProcessVarInput {
+    process: string;
+    variables: Array<{
+        name: string;
+        type: VarType;
+    }>;
+}
+/** ── 1) Variable-name clusters ──────────────────────────────────────────── */
+export interface NameCluster {
+    /** Canonical key (prefix-stripped, lowercased). */
+    normalized: string;
+    /** Original distinct variants encountered across processes. */
+    variants: string[];
+    /** Process names that contain at least one of the variants. */
+    processes: string[];
+}
+/**
+ * Normalize: strip a single leading [pvns] when followed by uppercase/underscore,
+ * strip underscores, lowercase. So `pYear`, `vYear`, `Year`, `p_year` all map
+ * to `year`. Names like `p` or `value` stay as-is (no prefix match).
+ */
+export declare function normalizeVarName(raw: string): string;
+export declare function clusterVariableNames(processes: ProcessVarInput[]): NameCluster[];
+/** ── 2) Type inconsistencies ─────────────────────────────────────────────── */
+export interface TypeConflict {
+    variable: string;
+    /** Per-type list of processes declaring that name with that type. */
+    occurrences: Array<{
+        type: VarType;
+        processes: string[];
+    }>;
+}
+export declare function findTypeInconsistencies(processes: ProcessVarInput[]): TypeConflict[];
+/** ── 3) Prefix-convention adherence ─────────────────────────────────────── */
+export type PrefixClass = "p" | "v" | "n" | "s" | "none";
+export interface PrefixConventionReport {
+    /** All non-"none" prefixes ranked by frequency. */
+    distribution: Array<{
+        prefix: PrefixClass;
+        count: number;
+    }>;
+    /** Adherence to convention `[pvns]` followed by upper/underscore. 0..1. */
+    adherence: number;
+    /** Total variables sampled. */
+    total: number;
+    /** Variables that don't fit any [pvns] prefix. */
+    unprefixed: number;
+}
+export declare function reportPrefixConvention(processes: ProcessVarInput[]): PrefixConventionReport;
+/** ── 4) Cohort grouping by name suffix ──────────────────────────────────── */
+export interface CohortInput {
+    process: string;
+    /** Optional pre-computed per-tab LOC for structural comparison (future use). */
+    tabLoc?: Record<TiTab, number>;
+}
+export interface Cohort {
+    key: string;
+    members: string[];
+}
+/**
+ * Group processes by trailing alpha token after `_` or `-`. So `Load_Sales`
+ * and `Aggregate_Sales` cohort as `Sales`; `Daily_Load` and `Weekly_Load`
+ * cohort as `Load`. Singleton cohorts are omitted.
+ */
+export declare function groupByCohort(processes: Array<{
+    process: string;
+}>): Cohort[];
+//# sourceMappingURL=cross-process.d.ts.map

package/dist/lib/complexity/cross-process.js

@@ -0,0 +1,114 @@
+const PREFIX_RE = /^[pvns](?=[A-Z_])/;
+/**
+ * Normalize: strip a single leading [pvns] when followed by uppercase/underscore,
+ * strip underscores, lowercase. So `pYear`, `vYear`, `Year`, `p_year` all map
+ * to `year`. Names like `p` or `value` stay as-is (no prefix match).
+ */
+export function normalizeVarName(raw) {
+    const stripped = raw.replace(PREFIX_RE, "");
+    return stripped.replace(/_/g, "").toLowerCase();
+}
+export function clusterVariableNames(processes) {
+    const byKey = new Map();
+    for (const p of processes) {
+        for (const v of p.variables) {
+            const key = normalizeVarName(v.name);
+            let bucket = byKey.get(key);
+            if (!bucket) {
+                bucket = { variants: new Set(), processes: new Set() };
+                byKey.set(key, bucket);
+            }
+            bucket.variants.add(v.name);
+            bucket.processes.add(p.process);
+        }
+    }
+    const out = [];
+    for (const [normalized, b] of byKey) {
+        if (b.variants.size > 1) {
+            out.push({
+                normalized,
+                variants: [...b.variants].sort(),
+                processes: [...b.processes].sort(),
+            });
+        }
+    }
+    return out.sort((a, b) => b.variants.length - a.variants.length);
+}
+export function findTypeInconsistencies(processes) {
+    const byName = new Map();
+    for (const p of processes) {
+        for (const v of p.variables) {
+            let typeMap = byName.get(v.name);
+            if (!typeMap) {
+                typeMap = new Map();
+                byName.set(v.name, typeMap);
+            }
+            let procSet = typeMap.get(v.type);
+            if (!procSet) {
+                procSet = new Set();
+                typeMap.set(v.type, procSet);
+            }
+            procSet.add(p.process);
+        }
+    }
+    const out = [];
+    for (const [variable, typeMap] of byName) {
+        if (typeMap.size > 1) {
+            const occurrences = [...typeMap.entries()]
+                .map(([type, procSet]) => ({ type, processes: [...procSet].sort() }))
+                .sort((a, b) => a.type.localeCompare(b.type));
+            out.push({ variable, occurrences });
+        }
+    }
+    return out.sort((a, b) => a.variable.localeCompare(b.variable));
+}
+function classifyPrefix(name) {
+    const m = PREFIX_RE.exec(name);
+    return m ? m[0] : "none";
+}
+export function reportPrefixConvention(processes) {
+    const counts = {
+        p: 0,
+        v: 0,
+        n: 0,
+        s: 0,
+        none: 0,
+    };
+    let total = 0;
+    for (const p of processes) {
+        for (const v of p.variables) {
+            counts[classifyPrefix(v.name)]++;
+            total++;
+        }
+    }
+    const distribution = ["p", "v", "n", "s"]
+        .map((prefix) => ({ prefix, count: counts[prefix] }))
+        .filter((d) => d.count > 0)
+        .sort((a, b) => b.count - a.count);
+    const prefixed = total - counts.none;
+    const adherence = total === 0 ? 0 : prefixed / total;
+    return { distribution, adherence, total, unprefixed: counts.none };
+}
+const COHORT_SUFFIX_RE = /[_-]([A-Za-z]+)$/;
+/**
+ * Group processes by trailing alpha token after `_` or `-`. So `Load_Sales`
+ * and `Aggregate_Sales` cohort as `Sales`; `Daily_Load` and `Weekly_Load`
+ * cohort as `Load`. Singleton cohorts are omitted.
+ */
+export function groupByCohort(processes) {
+    const map = new Map();
+    for (const p of processes) {
+        const m = COHORT_SUFFIX_RE.exec(p.process);
+        const key = m ? m[1].toLowerCase() : "_other";
+        const arr = map.get(key) ?? [];
+        arr.push(p.process);
+        map.set(key, arr);
+    }
+    const out = [];
+    for (const [key, members] of map) {
+        if (members.length >= 2)
+            out.push({ key, members: members.sort() });
+    }
+    return out.sort((a, b) => b.members.length - a.members.length);
+}
+//# sourceMappingURL=cross-process.js.map

package/dist/lib/complexity/process-metrics.d.ts

@@ -0,0 +1,78 @@
+export type TiTab = "prolog" | "metadata" | "data" | "epilog";
+/**
+ * Tunable weights for the v2 cognitive-style score. All optional; unset fields
+ * fall back to the defaults below. Exposed so callers (e.g. tm1_audit_complexity)
+ * can recalibrate without recompiling.
+ */
+export interface ScoreWeights {
+    /** Base cost of a single while loop (multiplied by nestMult^loopDepth). */
+    loopBase: number;
+    /** Geometric factor applied per enclosing loop — this is the "multiplication". */
+    nestMult: number;
+    /** Base cost of an if/elseif, scaled by condition complexity and if-depth. */
+    ifBase: number;
+    /** Penalty per hot op (CellPutN, ASCIIOutput, ExecuteProcess, …) per loop depth. */
+    hotPenalty: number;
+    /** Max fraction (0..1) of scoreV2 discounted by commentRatio. 0 = off (default). */
+    commentDiscountMax: number;
+}
+/** Partial override accepted from callers; undefined fields fall back to defaults. */
+export type ScoreWeightsInput = {
+    [K in keyof ScoreWeights]?: ScoreWeights[K] | undefined;
+};
+export interface TabMetrics {
+    /** Non-blank, non-comment source lines. */
+    loc: number;
+    /** `#` lines that are real comments (prose), not disabled code. */
+    commentLines: number;
+    /** `#` lines that look like commented-out TI code (disabled statements). */
+    deadCodeLines: number;
+    /** Lines that are purely whitespace. */
+    blankLines: number;
+    /** if + elseIf + while statements (recursive). */
+    branches: number;
+    /** Deepest control-flow nesting reached (0 = no control flow). */
+    maxNesting: number;
+    /** v2: Σ loopBase * nestMult^loopDepth over every while (multiplicative nesting). */
+    loopCost: number;
+    /** v2: Σ ifBase * conditionComplexity * (1 + ifDepth) over every if/elseif. */
+    ifCost: number;
+    /** v2: Σ hotPenalty * loopDepth over hot ops executed inside loops. */
+    hotInLoop: number;
+    /** True if the parser rejected this tab — metrics still emitted for raw lines. */
+    parseError: boolean;
+}
+export interface ProcessMetrics {
+    name: string;
+    tabs: Record<TiTab, TabMetrics>;
+    totals: {
+        loc: number;
+        commentLines: number;
+        deadCodeLines: number;
+        branches: number;
+        maxNesting: number;
+        /** Heuristic (v1): loc + 2*branches + 3*maxNesting. Unchanged for compatibility. */
+        score: number;
+        /** v2: Σ loopCost across tabs (loop nesting multiplies). */
+        loopCost: number;
+        /** v2: Σ ifCost across tabs (condition complexity × if-depth). */
+        ifCost: number;
+        /** v2: Σ hotInLoop across tabs (hot ops penalised by loop depth). */
+        hotInLoop: number;
+        /** v2: loc + ifCost + loopCost + hotInLoop, optionally discounted by comments. */
+        scoreV2: number;
+        /** commentLines / max(loc + commentLines + deadCodeLines, 1). 0..1. Real comments only. */
+        commentRatio: number;
+        /** deadCodeLines / max(loc + commentLines + deadCodeLines, 1). 0..1. */
+        deadCodeRatio: number;
+    };
+}
+export interface ProcessCodeInput {
+    prolog: string;
+    metadata: string;
+    data: string;
+    epilog: string;
+}
+export declare function computeTabMetrics(src: string, weights?: ScoreWeightsInput): TabMetrics;
+export declare function computeProcessMetrics(name: string, code: ProcessCodeInput, weights?: ScoreWeightsInput): ProcessMetrics;
+//# sourceMappingURL=process-metrics.d.ts.map