@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/analysis/audit-naming.d.ts

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

package/dist/tools/analysis/audit-naming.js

@@ -0,0 +1,379 @@
+import { z } from "zod";
+import { checkName, parseMajorVersion, } from "../../lib/naming/rules.js";
+import { elementViolationFilter } from "../../lib/naming/odata-filter.js";
+import { isControlName } from "../../lib/control-name.js";
+import { AuditNamingResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+const SCOPE_VALUES = [
+    "cubes",
+    "dimensions",
+    "hierarchies",
+    "elements",
+    "processes",
+    "processVariables",
+    "chores",
+    "views",
+    "subsets",
+];
+const SCOPE_DEFAULT = [
+    "cubes",
+    "dimensions",
+    "hierarchies",
+    "elements",
+    "processes",
+    "chores",
+];
+export const registerAuditNaming = defineTool({
+    name: "tm1_audit_naming",
+    description: "Bulk-scan TM1 objects against IBM PA 2.0/3.1 naming conventions; reports hard violations only " +
+        "(reserved chars, control-prefix misuse, 256-char limit, element leading +/-, TAB in element names, " +
+        "invalid process-variable identifiers). Auto-detects TM1 version; element scan paginated per hierarchy " +
+        "(default cap 100k, oversized hierarchies reported in elementsTruncated).",
+    annotations: READ_ONLY,
+    output: AuditNamingResultSchema,
+    input: {
+        scope: z
+            .array(z.enum(SCOPE_VALUES))
+            .optional()
+            .describe("Object kinds to audit. Default: cubes, dimensions, hierarchies, elements, " +
+            "processes, chores. Element scan is per (dimension, hierarchy), paginated via " +
+            "$top/$skip; oversized hierarchies are truncated at maxElementsPerDim and " +
+            "reported in elementsTruncated. 'processVariables' triggers per-process variable " +
+            "scans; 'views'/'subsets' do per-cube/per-hier listings."),
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include control objects ('}'-prefix). Default false."),
+        maxFindings: z
+            .number()
+            .int()
+            .min(1)
+            .max(10000)
+            .optional()
+            .default(500)
+            .describe("Cap on returned findings (default 500). Summary counters reflect the full scan."),
+        versionOverride: z
+            .enum(["11", "12"])
+            .optional()
+            .describe("Override the auto-detected TM1 major version in the report (detectedMajor stays as " +
+            "found, appliedMajor follows this). No naming rule currently differs by version, so " +
+            "this does not change which names are flagged."),
+        elementsPageSize: z
+            .number()
+            .int()
+            .min(1000)
+            .max(100000)
+            .optional()
+            .default(25000)
+            .describe("Page size for paging through violating elements. Bounded to keep each response " +
+            "well below the V8 string limit (~512 MB). Default 25000."),
+        maxElementsPerDim: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .default(100000)
+            .describe("Per-(dimension, hierarchy) cap on VIOLATING elements returned. The server checks " +
+            "every element against the rules, so the whole hierarchy is always examined; this " +
+            "bounds how many offenders come back. A hit of the cap is reported under " +
+            "`elementsTruncated`. Default 100000."),
+        summary: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Aggregate findings instead of returning per-object detail. When true, " +
+            "swaps the `findings` array for `findingsByGroup` — one entry per " +
+            "(objectKind, parent) group with `ruleBreakdown`, `sampleNames` (up to 3), " +
+            "and `totalCount`. Recommended for audit reports on large models (e.g. dims " +
+            "with thousands of element findings) where per-object detail is not needed " +
+            "and `maxFindings`-capped output would be misleading. `truncated` is " +
+            "always false in summary mode since no findings are dropped."),
+    },
+    handler: async ({ scope, includeControl, maxFindings, versionOverride, elementsPageSize, maxElementsPerDim, summary, }, tm1Client) => {
+        const activeScope = scope && scope.length > 0 ? scope : SCOPE_DEFAULT;
+        const want = (s) => activeScope.includes(s);
+        const serverInfo = await tm1Client.server.getInfo();
+        const detectedMajor = parseMajorVersion(serverInfo.productVersion);
+        const major = versionOverride
+            ? Number(versionOverride)
+            : detectedMajor;
+        const findings = [];
+        const scanned = {
+            cubes: 0,
+            dimensions: 0,
+            hierarchies: 0,
+            elements: 0,
+            processes: 0,
+            processVariables: 0,
+            chores: 0,
+            views: 0,
+            subsets: 0,
+        };
+        const addIfInvalid = (name, kind, parent) => {
+            const violations = checkName(name, kind);
+            if (violations.length === 0)
+                return;
+            const f = { objectKind: kind, objectName: name, violations };
+            if (parent !== undefined)
+                f.parent = parent;
+            findings.push(f);
+        };
+        // ── Cubes ──────────────────────────────────────────────────────────
+        if (want("cubes")) {
+            const cubes = await tm1Client.cubes.list();
+            const filtered = includeControl
+                ? cubes
+                : cubes.filter((c) => !isControlName(c.name));
+            scanned.cubes = filtered.length;
+            for (const c of filtered)
+                addIfInvalid(c.name, "cube");
+        }
+        // ── Dimensions + Hierarchies + (later) Elements/Subsets ───────────
+        const needDims = want("dimensions") ||
+            want("hierarchies") ||
+            want("elements") ||
+            want("subsets");
+        let dimensionsForChildren;
+        if (needDims) {
+            // With elements in scope, ask for the per-hierarchy element totals in
+            // this same request. TM1 answers a nested $count without listing the
+            // elements, so the scope figures cost nothing here — versus one probe
+            // request per hierarchy, which on a 107-hierarchy model was 107 round
+            // trips for a number the list could have carried.
+            const dims = await tm1Client.dimensions.list(want("elements") ? { includeElementCount: true } : {});
+            const filtered = includeControl
+                ? dims
+                : dims.filter((d) => !isControlName(d.name));
+            // Always reflect dims we fetched/traversed — even when "dimensions" is
+            // not in scope, the hierarchy / element / subset walk visited them, so
+            // reporting 0 would understate the scan footprint.
+            scanned.dimensions = filtered.length;
+            if (want("dimensions")) {
+                for (const d of filtered)
+                    addIfInvalid(d.name, "dimension");
+            }
+            if (want("hierarchies")) {
+                let hierCount = 0;
+                for (const d of filtered) {
+                    for (const h of d.hierarchies) {
+                        hierCount++;
+                        addIfInvalid(h, "hierarchy", d.name);
+                    }
+                }
+                scanned.hierarchies = hierCount;
+            }
+            dimensionsForChildren = filtered.map((d) => ({
+                name: d.name,
+                hierarchies: d.hierarchies,
+                elementCounts: d.elementCounts,
+            }));
+        }
+        // ── Elements (per-dim/per-hierarchy, filtered server-side) ─────────
+        // Every element rule is character-based, so TM1 evaluates them: the
+        // scan asks for the names that MIGHT violate one and checks only those
+        // (see src/lib/naming/odata-filter.ts). Downloading every name cost
+        // 15.2 MB on a single 171k-element dimension and 66 MB across a real
+        // model, and capped the audit at maxElementsPerDim — beyond which it
+        // examined a prefix of the dimension and said so. Now the server looks
+        // at all of them, and the cap bounds the number of REPORTED violations
+        // instead of the number examined.
+        //
+        // The filter is a prefilter, never the verdict: checkName still decides
+        // on every candidate, so an over-wide filter costs rows and nothing
+        // more. Its soundness — never omitting a name checkName would flag — is
+        // pinned by tests/unit/naming-odata-filter.test.ts and by the live
+        // suite, which plants a violating element and expects it back.
+        const elementsTruncated = [];
+        let totalElementsInScope = 0;
+        if (want("elements") && dimensionsForChildren) {
+            let elemCount = 0;
+            for (const d of dimensionsForChildren) {
+                for (const h of d.hierarchies) {
+                    const { names, total, scanned: scannedHere, truncated, } = await tm1Client.elements.scanElementNames(d.name, h, {
+                        pageSize: elementsPageSize,
+                        maxScan: maxElementsPerDim,
+                        filter: elementViolationFilter(),
+                        ...(d.elementCounts?.[h] !== undefined
+                            ? { scopeTotal: d.elementCounts[h] }
+                            : {}),
+                    });
+                    totalElementsInScope += total;
+                    // `scanned` counts what was EXAMINED, which is now the whole
+                    // hierarchy — the server applied the rules to every element and
+                    // returned the candidates. Counting the candidates instead would
+                    // report "5 elements scanned" for a 171k dimension with 5
+                    // offenders.
+                    elemCount += scannedHere;
+                    for (const name of names) {
+                        addIfInvalid(name, "element", `${d.name} / ${h}`);
+                    }
+                    if (truncated) {
+                        elementsTruncated.push({
+                            dimension: d.name,
+                            hierarchy: h,
+                            elementCount: total,
+                            scannedCount: scannedHere,
+                        });
+                    }
+                }
+            }
+            scanned.elements = elemCount;
+        }
+        // ── Subsets (per dim/hier list) ────────────────────────────────────
+        if (want("subsets") && dimensionsForChildren) {
+            let count = 0;
+            for (const d of dimensionsForChildren) {
+                for (const h of d.hierarchies) {
+                    const subs = await tm1Client.subsets.list(d.name, h);
+                    for (const s of subs) {
+                        if (!includeControl && isControlName(s.name))
+                            continue;
+                        count++;
+                        addIfInvalid(s.name, "subset", `${d.name} / ${h}`);
+                    }
+                }
+            }
+            scanned.subsets = count;
+        }
+        // ── Processes + (optional) variables ───────────────────────────────
+        let processNames = [];
+        if (want("processes") || want("processVariables")) {
+            const procs = await tm1Client.processes.list();
+            processNames = (includeControl ? procs : procs.filter((p) => !isControlName(p.name))).map((p) => p.name);
+        }
+        if (want("processes")) {
+            scanned.processes = processNames.length;
+            for (const p of processNames)
+                addIfInvalid(p, "process");
+        }
+        if (want("processVariables")) {
+            let count = 0;
+            for (const p of processNames) {
+                const vars = await tm1Client.processes.getVariables(p);
+                for (const v of vars) {
+                    count++;
+                    addIfInvalid(v.name, "processVariable", p);
+                }
+            }
+            scanned.processVariables = count;
+        }
+        // ── Chores ─────────────────────────────────────────────────────────
+        if (want("chores")) {
+            const chores = await tm1Client.chores.list();
+            const filtered = includeControl
+                ? chores
+                : chores.filter((c) => !isControlName(c.name));
+            scanned.chores = filtered.length;
+            for (const c of filtered)
+                addIfInvalid(c.name, "chore");
+        }
+        // ── Views (per-cube) ───────────────────────────────────────────────
+        if (want("views")) {
+            const cubes = await tm1Client.cubes.list();
+            const filteredCubes = includeControl
+                ? cubes
+                : cubes.filter((c) => !isControlName(c.name));
+            let count = 0;
+            for (const c of filteredCubes) {
+                const views = await tm1Client.views.list(c.name);
+                for (const v of views) {
+                    if (!includeControl && isControlName(v.name))
+                        continue;
+                    count++;
+                    addIfInvalid(v.name, "view", c.name);
+                }
+            }
+            scanned.views = count;
+        }
+        // ── Aggregate + sort ───────────────────────────────────────────────
+        const byKind = {};
+        const byRule = {};
+        for (const f of findings) {
+            byKind[f.objectKind] = (byKind[f.objectKind] ?? 0) + 1;
+            for (const v of f.violations)
+                byRule[v.rule] = (byRule[v.rule] ?? 0) + 1;
+        }
+        findings.sort((a, b) => {
+            if (a.objectKind !== b.objectKind)
+                return a.objectKind.localeCompare(b.objectKind);
+            return a.objectName.localeCompare(b.objectName);
+        });
+        const truncated = !summary && findings.length > maxFindings;
+        const trimmed = findings.slice(0, maxFindings);
+        const totalScanned = Object.values(scanned).reduce((a, b) => a + b, 0);
+        const status = findings.length === 0 ? "pass" : "fail";
+        const findingsByGroup = summary
+            ? buildFindingsByGroup(findings)
+            : undefined;
+        const payload = {
+            status,
+            productVersion: serverInfo.productVersion,
+            detectedMajor,
+            appliedMajor: major,
+            scope: activeScope,
+            includeControl,
+            scanned,
+            totalScanned,
+            invalidCount: findings.length,
+            summary: { byKind, byRule },
+            truncated,
+            elementsTruncated,
+            totalElementsInScope,
+            rulesetSource: "IBM PA naming-conventions (2.0 + 3.1) — hard rules only (server-reserved chars, control prefix, length 256, element leading +/-, TAB in element names, process-var identifier).",
+        };
+        if (summary) {
+            payload.findingsByGroup = findingsByGroup;
+        }
+        else {
+            payload.findings = trimmed;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(payload),
+                },
+            ],
+        };
+    },
+});
+const SAMPLE_SIZE = 3;
+function buildFindingsByGroup(findings) {
+    const groups = new Map();
+    for (const f of findings) {
+        const key = `${f.objectKind}\0${f.parent ?? ""}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = {
+                objectKind: f.objectKind,
+                ruleBreakdown: {},
+                sampleNames: [],
+                totalCount: 0,
+            };
+            if (f.parent !== undefined) {
+                g.parent = f.parent;
+                // Element/subset parent format is "Dim / Hier"; split for caller convenience.
+                const split = f.parent.split(" / ");
+                if (split.length === 2) {
+                    g.dimension = split[0];
+                    g.hierarchy = split[1];
+                }
+            }
+            groups.set(key, g);
+        }
+        g.totalCount++;
+        for (const v of f.violations) {
+            g.ruleBreakdown[v.rule] = (g.ruleBreakdown[v.rule] ?? 0) + 1;
+        }
+        if (g.sampleNames.length < SAMPLE_SIZE)
+            g.sampleNames.push(f.objectName);
+    }
+    return Array.from(groups.values()).sort((a, b) => {
+        if (a.objectKind !== b.objectKind)
+            return a.objectKind.localeCompare(b.objectKind);
+        return (a.parent ?? "").localeCompare(b.parent ?? "");
+    });
+}
+//# sourceMappingURL=audit-naming.js.map

package/dist/tools/analysis/check-v12-readiness.d.ts

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

package/dist/tools/analysis/check-v12-readiness.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { scanForDeprecatedTi, } from "../../lib/v12-compat/scanner.js";
+import { READ_ONLY, withVersion } from "../annotations.js";
+import { V12ReadinessResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+const RULESET_SOURCE = "vscode-tm1-ti@cf73b93 / tiSignatures.ts (synced 2026-05-12)";
+function toFinding(hit, objectKind, objectName, section) {
+    return {
+        severity: hit.severity,
+        category: "deprecated_ti_function",
+        objectKind,
+        objectName,
+        section,
+        line: hit.line,
+        function: hit.function,
+        snippet: hit.snippet,
+        issue: hit.issue,
+        suggestion: hit.suggestion,
+    };
+}
+export const registerCheckV12Readiness = defineTool({
+    name: "tm1_check_v12_readiness",
+    description: [
+        "Static gap-analysis against the TM1 / Planning Analytics v12 (Cloud Native) deprecation list.",
+        "Scans every TI process section (prolog/metadata/data/epilog) and every cube rule for functions removed in v12, returning findings with severity, location, and migration hint per occurrence.",
+        "Read-only, two bulk REST calls. Not exhaustive: covers syntactic deprecations only (runtime/semantic differences require manual review).",
+    ],
+    annotations: withVersion(READ_ONLY, "v11"),
+    output: V12ReadinessResultSchema,
+    input: {
+        scope: z
+            .enum(["processes", "rules", "all"])
+            .optional()
+            .default("all")
+            .describe("Restrict scan to TI processes, cube rules, or both (default 'all')."),
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include control objects ('}'-prefix names). Default false."),
+        maxFindings: z
+            .number()
+            .int()
+            .min(1)
+            .max(5000)
+            .optional()
+            .default(500)
+            .describe("Cap on returned findings (default 500). Summary counters still reflect the full scan."),
+    },
+    handler: async ({ scope, includeControl, maxFindings }, tm1Client) => {
+        const findings = [];
+        let scannedProcesses = 0;
+        let scannedCubes = 0;
+        const wantProcesses = scope === "all" || scope === "processes";
+        const wantRules = scope === "all" || scope === "rules";
+        const [procCodes, cubeRules] = await Promise.all([
+            wantProcesses
+                ? tm1Client.processes.getAllCode(includeControl)
+                : Promise.resolve([]),
+            wantRules
+                ? tm1Client.cubes.getAllRules(includeControl)
+                : Promise.resolve([]),
+        ]);
+        if (wantProcesses) {
+            scannedProcesses = procCodes.length;
+            for (const p of procCodes) {
+                const sections = [
+                    ["prolog", p.prolog],
+                    ["metadata", p.metadata],
+                    ["data", p.data],
+                    ["epilog", p.epilog],
+                ];
+                for (const [section, body] of sections) {
+                    for (const hit of scanForDeprecatedTi(body)) {
+                        findings.push(toFinding(hit, "process", p.name, section));
+                    }
+                }
+            }
+        }
+        if (wantRules) {
+            scannedCubes = cubeRules.length;
+            for (const r of cubeRules) {
+                for (const hit of scanForDeprecatedTi(r.rulesText)) {
+                    findings.push(toFinding(hit, "cube", r.cubeName, "rules"));
+                }
+            }
+        }
+        // Aggregations across the FULL finding set, before truncation.
+        const bySeverity = {};
+        const byCategory = {};
+        const fnCounts = new Map();
+        for (const f of findings) {
+            bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1;
+            byCategory[f.category] = (byCategory[f.category] ?? 0) + 1;
+            fnCounts.set(f.function, (fnCounts.get(f.function) ?? 0) + 1);
+        }
+        const topFunctions = Array.from(fnCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([fn, count]) => ({ function: fn, count }));
+        const errorCount = bySeverity.error ?? 0;
+        const warningCount = bySeverity.warning ?? 0;
+        const readinessScore = errorCount === 0 && warningCount === 0
+            ? "ready"
+            : errorCount > 0
+                ? "blocked"
+                : "needs-work";
+        findings.sort((a, b) => {
+            if (a.severity !== b.severity)
+                return a.severity === "error" ? -1 : 1;
+            if (a.objectName !== b.objectName)
+                return a.objectName.localeCompare(b.objectName);
+            return a.line - b.line;
+        });
+        const trimmed = findings.slice(0, maxFindings);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        scope,
+                        includeControl,
+                        scannedProcesses,
+                        scannedCubes,
+                        findingsCount: findings.length,
+                        readinessScore,
+                        summary: { byCategory, bySeverity, topFunctions },
+                        findings: trimmed,
+                        rulesetSource: RULESET_SOURCE,
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+});
+//# sourceMappingURL=check-v12-readiness.js.map

package/dist/tools/analysis/find-orphan-dimensions.d.ts

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

package/dist/tools/analysis/find-orphan-dimensions.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, wrappedPageResponse, columnsOf } from "../format.js";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FindOrphanDimensionsResultSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerFindOrphanDimensions = defineTool({
+    name: "tm1_find_orphan_dimensions",
+    description: [
+        "Identify dimensions not referenced by any cube — a model-hygiene check. Computes the used-dimension set across all cubes (one OData call) and diffs against the full dimension list.",
+        "Control dimensions ('}'-prefixed) excluded unless includeControl=true. Paginated (default 50/page). Inspect a hit with tm1_get_hierarchy or remove via tm1_delete_dimension.",
+    ],
+    annotations: READ_ONLY,
+    output: FindOrphanDimensionsResultSchema,
+    input: {
+        includeControl: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include control dimensions whose names start with '}' (default: false)."),
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ includeControl, limit, offset, fetchAll, format }, tm1Client) => {
+        const [cubes, dimensions] = await Promise.all([
+            tm1Client.cubes.list(),
+            tm1Client.dimensions.list(),
+        ]);
+        const usedDims = new Set();
+        for (const c of cubes) {
+            for (const d of c.dimensions ?? [])
+                usedDims.add(d);
+        }
+        const candidates = includeControl
+            ? dimensions
+            : dimensions.filter((d) => !d.name.startsWith("}"));
+        const orphans = candidates
+            .filter((d) => !usedDims.has(d.name))
+            .map((d) => ({ name: d.name, hierarchies: d.hierarchies }));
+        const page = paginate(orphans, limit, offset, fetchAll);
+        const wrapper = {
+            totalDimensions: candidates.length,
+            totalCubes: cubes.length,
+            orphanCount: orphans.length,
+            includeControl,
+            ...page,
+        };
+        const columns = columnsOf(["name", "hierarchies"]);
+        return wrappedPageResponse(wrapper, page, format, {
+            title: "Orphan dimensions",
+            columns,
+        });
+    },
+});
+//# sourceMappingURL=find-orphan-dimensions.js.map

package/dist/tools/analysis/invalidate-callgraph-cache.d.ts

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

package/dist/tools/analysis/invalidate-callgraph-cache.js

@@ -0,0 +1,40 @@
+import { defineTool } from "../define-tool.js";
+import { READ_ONLY } from "../annotations.js";
+import { InvalidateCallgraphCacheResultSchema } from "../schemas/items.js";
+import { invalidateCallgraphCache, getCallgraphCacheStats, } from "../../lib/callgraph/tm1-adapter.js";
+export const registerInvalidateCallgraphCache = defineTool({
+    name: "tm1_invalidate_callgraph_cache",
+    description: "Drop the in-memory ReferenceIndex cache used by tm1_analyze_callgraph / tm1_analyze_object_usage / tm1_analyze_chore_graph. Rarely needed: every successful mutating call through this server already drops it. Use it only after changes made outside this server (Workspace, TI, another client). The next analysis call rebuilds the index (single bulk fetch). Touches no TM1 object, so it is available in readonly mode.",
+    annotations: READ_ONLY,
+    output: InvalidateCallgraphCacheResultSchema,
+    // Takes no arguments: the cache is process-wide.
+    input: {},
+    handler: () => {
+        try {
+            const before = getCallgraphCacheStats();
+            const { cleared } = invalidateCallgraphCache();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ cleared, entriesBefore: before }),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message ?? String(error),
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+});
+//# sourceMappingURL=invalidate-callgraph-cache.js.map

package/dist/tools/analysis/trace-data-flow.d.ts

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