@ffschrattenecker/tm1-mcp-server 6.0.0 → 7.0.0

package/dist/resources/index.js

@@ -7,6 +7,7 @@
 // Each resource maps to an existing TM1 service call — same backend logic
 // as the get_* tools, different MCP entry point.
 import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { asRegistry } from "../tools/define-tool.js";
 import { maskCode } from "../lib/mask-secrets.js";
 function asJsonContent(uri, payload) {
     return {
@@ -19,15 +20,41 @@ function asJsonContent(uri, payload) {
         ],
     };
 }
-export function registerAllResources(server, tm1) {
+export function registerAllResources(server, source) {
     // Build a parallel catalog as we go so installPaginatedListHandler can
     // override SDK's default ListResourcesRequestSchema with cursor support.
     // registerResource still wires the read callbacks; we just keep our own
     // listing source of truth.
     const entries = [];
+    const registry = asRegistry(source);
+    for (const name of registry.usableNames) {
+        const single = registry.isSingle;
+        registerConnectionResources(server, entries, {
+            base: single ? "tm1://" : `tm1://${name}/`,
+            key: single ? "" : `${name}:`,
+            titlePrefix: single ? "" : `${name}: `,
+            client: () => registry.get(name),
+            enumerate: () => single || registry.isConnected(name),
+        });
+    }
+    return { entries };
+}
+/** URIs of every connection's server-state resource, keyed by connectionId. */
+export function stateResourceUris(source) {
+    const registry = asRegistry(source);
+    const uris = new Map();
+    for (const name of registry.usableNames) {
+        const uri = registry.isSingle
+            ? "tm1://server/state"
+            : `tm1://${name}/server/state`;
+        uris.set(uri, registry.info(name)?.connectionId ?? "");
+    }
+    return uris;
+}
+function registerConnectionResources(server, entries, ctx) {
     // ── Static endpoints ────────────────────────────────────────────────
-    server.registerResource("server-info", "tm1://server/info", {
-        title: "TM1 Server Info",
+    server.registerResource(`${ctx.key}server-info`, `${ctx.base}server/info`, {
+        title: `${ctx.titlePrefix}TM1 Server Info`,
         description: "TM1 server configuration snapshot: name, version, data directory, timezone, integrated security mode.",
         mimeType: "application/json",
     }, async (uri) => {
@@ -35,7 +62,7 @@ export function registerAllResources(server, tm1) {
         // carries the full merged /Configuration body, which can include
         // sensitive settings — resources have no params, so unlike the
         // curated tm1_get_server_info tool there is no place to opt in.
-        const info = await tm1.server.getInfo();
+        const info = await (await ctx.client()).server.getInfo();
         return asJsonContent(uri, {
             serverName: info.serverName,
             productVersion: info.productVersion,
@@ -49,28 +76,28 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "static",
         resource: {
-            uri: "tm1://server/info",
-            name: "server-info",
-            title: "TM1 Server Info",
+            uri: `${ctx.base}server/info`,
+            name: `${ctx.key}server-info`,
+            title: `${ctx.titlePrefix}TM1 Server Info`,
             description: "TM1 server configuration snapshot: name, version, data directory, timezone, integrated security mode.",
             mimeType: "application/json",
         },
     });
-    server.registerResource("server-state", "tm1://server/state", {
-        title: "TM1 Server State",
+    server.registerResource(`${ctx.key}server-state`, `${ctx.base}server/state`, {
+        title: `${ctx.titlePrefix}TM1 Server State`,
         description: "Health-check snapshot: connection state, version, capability flags, object counts (cubes/dimensions/processes/chores/clients).",
         mimeType: "application/json",
     }, async (uri) => {
         const [info, cubes, dims, procs, chores, clients] = await Promise.all([
-            tm1.server.getInfo(),
-            tm1.cubes.list(),
-            tm1.dimensions.list(),
-            tm1.processes.list(),
-            tm1.chores.list(),
-            tm1.security.listClients(),
+            (await ctx.client()).server.getInfo(),
+            (await ctx.client()).cubes.list(),
+            (await ctx.client()).dimensions.list(),
+            (await ctx.client()).processes.list({ namesOnly: true }),
+            (await ctx.client()).chores.list(),
+            (await ctx.client()).security.listClients(),
         ]);
         return asJsonContent(uri, {
-            connected: tm1.isConnected(),
+            connected: (await ctx.client()).isConnected(),
             server: {
                 name: info.serverName,
                 productVersion: info.productVersion,
@@ -89,25 +116,29 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "static",
         resource: {
-            uri: "tm1://server/state",
-            name: "server-state",
-            title: "TM1 Server State",
+            uri: `${ctx.base}server/state`,
+            name: `${ctx.key}server-state`,
+            title: `${ctx.titlePrefix}TM1 Server State`,
             description: "Health-check snapshot: connection state, version, capability flags, object counts (cubes/dimensions/processes/chores/clients).",
             mimeType: "application/json",
         },
     });
     // ── Resource templates ──────────────────────────────────────────────
-    // Process source code — `tm1://process/{name}/code`
-    server.registerResource("process-code", new ResourceTemplate("tm1://process/{name}/code", {
+    // Process source code — `tm1://[<connection>/]process/{name}/code`
+    server.registerResource(`${ctx.key}process-code`, new ResourceTemplate(`${ctx.base}process/{name}/code`, {
         list: async () => {
-            const procs = await tm1.processes.list();
+            if (!ctx.enumerate())
+                return { resources: [] };
+            const procs = await (await ctx.client()).processes.list({
+                namesOnly: true,
+            });
             return {
                 resources: procs
                     .filter((p) => !p.name.startsWith("}"))
                     .map((p) => ({
-                    name: `process-code-${p.name}`,
-                    uri: `tm1://process/${encodeURIComponent(p.name)}/code`,
-                    title: `TI: ${p.name}`,
+                    name: `${ctx.key}process-code-${p.name}`,
+                    uri: `${ctx.base}process/${encodeURIComponent(p.name)}/code`,
+                    title: `${ctx.titlePrefix}TI: ${p.name}`,
                     description: `Source code (Prolog/Metadata/Data/Epilog) of TI process '${p.name}'.`,
                     mimeType: "application/json",
                 })),
@@ -115,7 +146,9 @@ export function registerAllResources(server, tm1) {
         },
         complete: {
             name: async (value) => {
-                const procs = await tm1.processes.list();
+                const procs = await (await ctx.client()).processes.list({
+                    namesOnly: true,
+                });
                 const lower = value.toLowerCase();
                 return procs
                     .filter((p) => !p.name.startsWith("}") && p.name.toLowerCase().includes(lower))
@@ -124,15 +157,15 @@ export function registerAllResources(server, tm1) {
             },
         },
     }), {
-        title: "TI Process Source Code",
-        description: "Source code of any TurboIntegrator process by name. URI: tm1://process/{name}/code.",
+        title: `${ctx.titlePrefix}TI Process Source Code`,
+        description: `Source code of any TurboIntegrator process by name. URI: ${ctx.base}process/{name}/code.`,
         mimeType: "application/json",
     }, async (uri, vars) => {
         const raw = vars.name;
         const name = decodeURIComponent(Array.isArray(raw) ? raw[0] : (raw ?? ""));
-        const code = await tm1.processes.getCode(name);
+        const code = await (await ctx.client()).processes.getCode(name);
         // Hard-mask credential literals unconditionally: resources take no
-        // parameters, so unlike tm1_get_process_code there is no maskSecrets
+        // parameters, so unlike tm1_get_process there is no maskSecrets
         // opt-out — returning the code verbatim would bypass the tool-path
         // redaction (ODBCOpen passwords, credential assignments).
         return asJsonContent(uri, {
@@ -145,38 +178,44 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "template",
         templateMetadata: {
-            title: "TI Process Source Code",
-            description: "Source code of any TurboIntegrator process by name. URI: tm1://process/{name}/code.",
+            title: `${ctx.titlePrefix}TI Process Source Code`,
+            description: `Source code of any TurboIntegrator process by name. URI: ${ctx.base}process/{name}/code.`,
             mimeType: "application/json",
         },
         list: async () => {
-            const procs = await tm1.processes.list();
+            if (!ctx.enumerate())
+                return { resources: [] };
+            const procs = await (await ctx.client()).processes.list({
+                namesOnly: true,
+            });
             return {
                 resources: procs
                     .filter((p) => !p.name.startsWith("}"))
                     .map((p) => ({
-                    name: `process-code-${p.name}`,
-                    uri: `tm1://process/${encodeURIComponent(p.name)}/code`,
-                    title: `TI: ${p.name}`,
+                    name: `${ctx.key}process-code-${p.name}`,
+                    uri: `${ctx.base}process/${encodeURIComponent(p.name)}/code`,
+                    title: `${ctx.titlePrefix}TI: ${p.name}`,
                     description: `Source code (Prolog/Metadata/Data/Epilog) of TI process '${p.name}'.`,
                     mimeType: "application/json",
                 })),
             };
         },
     });
-    // Cube rules — `tm1://cube/{name}/rules`
-    server.registerResource("cube-rules", new ResourceTemplate("tm1://cube/{name}/rules", {
+    // Cube rules — `tm1://[<connection>/]cube/{name}/rules`
+    server.registerResource(`${ctx.key}cube-rules`, new ResourceTemplate(`${ctx.base}cube/{name}/rules`, {
         list: async () => {
+            if (!ctx.enumerate())
+                return { resources: [] };
             // Filter to cubes that actually carry rules — avoids cluttering
             // the resource tree with rule-less cubes whose body is "".
-            const cubes = await tm1.cubes.list({ includeRules: true });
+            const cubes = await (await ctx.client()).cubes.list({ includeRules: true });
             return {
                 resources: cubes
                     .filter((c) => !c.name.startsWith("}") && c.hasRules)
                     .map((c) => ({
-                    name: `cube-rules-${c.name}`,
-                    uri: `tm1://cube/${encodeURIComponent(c.name)}/rules`,
-                    title: `Rules: ${c.name}`,
+                    name: `${ctx.key}cube-rules-${c.name}`,
+                    uri: `${ctx.base}cube/${encodeURIComponent(c.name)}/rules`,
+                    title: `${ctx.titlePrefix}Rules: ${c.name}`,
                     description: `Rules text of cube '${c.name}' (SKIPCHECK + FEEDERS sections).`,
                     mimeType: "text/plain",
                 })),
@@ -184,7 +223,7 @@ export function registerAllResources(server, tm1) {
         },
         complete: {
             name: async (value) => {
-                const cubes = await tm1.cubes.list();
+                const cubes = await (await ctx.client()).cubes.list();
                 const lower = value.toLowerCase();
                 return cubes
                     .filter((c) => !c.name.startsWith("}") && c.name.toLowerCase().includes(lower))
@@ -193,13 +232,13 @@ export function registerAllResources(server, tm1) {
             },
         },
     }), {
-        title: "Cube Rules Text",
-        description: "Rules text of any TM1 cube by name. URI: tm1://cube/{name}/rules. Returns plain text.",
+        title: `${ctx.titlePrefix}Cube Rules Text`,
+        description: `Rules text of any TM1 cube by name. URI: ${ctx.base}cube/{name}/rules. Returns plain text.`,
         mimeType: "text/plain",
     }, async (uri, vars) => {
         const raw = vars.name;
         const name = decodeURIComponent(Array.isArray(raw) ? raw[0] : (raw ?? ""));
-        const rules = await tm1.cubes.getRules(name);
+        const rules = await (await ctx.client()).cubes.getRules(name);
         return {
             contents: [
                 {
@@ -213,25 +252,26 @@ export function registerAllResources(server, tm1) {
     entries.push({
         kind: "template",
         templateMetadata: {
-            title: "Cube Rules Text",
-            description: "Rules text of any TM1 cube by name. URI: tm1://cube/{name}/rules. Returns plain text.",
+            title: `${ctx.titlePrefix}Cube Rules Text`,
+            description: `Rules text of any TM1 cube by name. URI: ${ctx.base}cube/{name}/rules. Returns plain text.`,
             mimeType: "text/plain",
         },
         list: async () => {
-            const cubes = await tm1.cubes.list({ includeRules: true });
+            if (!ctx.enumerate())
+                return { resources: [] };
+            const cubes = await (await ctx.client()).cubes.list({ includeRules: true });
             return {
                 resources: cubes
                     .filter((c) => !c.name.startsWith("}") && c.hasRules)
                     .map((c) => ({
-                    name: `cube-rules-${c.name}`,
-                    uri: `tm1://cube/${encodeURIComponent(c.name)}/rules`,
-                    title: `Rules: ${c.name}`,
+                    name: `${ctx.key}cube-rules-${c.name}`,
+                    uri: `${ctx.base}cube/${encodeURIComponent(c.name)}/rules`,
+                    title: `${ctx.titlePrefix}Rules: ${c.name}`,
                     description: `Rules text of cube '${c.name}' (SKIPCHECK + FEEDERS sections).`,
                     mimeType: "text/plain",
                 })),
             };
         },
     });
-    return { entries };
 }
 //# sourceMappingURL=index.js.map

package/dist/resources/subscriptions.d.ts

@@ -3,9 +3,10 @@ import type pino from "pino";
 export declare class SubscriptionRegistry {
     private readonly server;
     private readonly logger;
+    private readonly stateUris;
     private readonly subscribed;
     private mutationListener?;
-    constructor(server: McpServer, logger: pino.Logger);
+    constructor(server: McpServer, logger: pino.Logger, stateUris?: ReadonlyMap<string, string>);
     /** Install subscribe/unsubscribe request handlers + mutation listener. */
     install(): void;
     /** Detach listener — used for shutdown / tests. */

package/dist/resources/subscriptions.js

@@ -14,19 +14,24 @@
 // resources/unsubscribe, notifications/resources/updated).
 import { SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { tm1Events } from "../lib/tm1-events.js";
-// URIs whose contents are sensitive to *any* mutation. The server-state
-// resource aggregates counts across cubes/dims/processes/chores/clients —
-// almost any non-safe call can change it.
-const STATE_SENSITIVE_URIS = new Set(["tm1://server/state"]);
+// The server-state resource aggregates counts across cubes/dims/processes/
+// chores/clients — almost any non-safe call can change it. With several
+// connections there is one such resource per connection; stateUris maps each
+// to the connectionId whose mutations affect it.
+const SINGLE_STATE_URIS = new Map([
+    ["tm1://server/state", ""],
+]);
 export class SubscriptionRegistry {
     server;
     logger;
+    stateUris;
     // URIs the client has asked us to push updates for.
     subscribed = new Set();
     mutationListener;
-    constructor(server, logger) {
+    constructor(server, logger, stateUris = SINGLE_STATE_URIS) {
         this.server = server;
         this.logger = logger;
+        this.stateUris = stateUris;
     }
     /** Install subscribe/unsubscribe request handlers + mutation listener. */
     install() {
@@ -62,13 +67,17 @@ export class SubscriptionRegistry {
     size() {
         return this.subscribed.size;
     }
-    onMutation(_e) {
+    onMutation(e) {
         // Iterate subscribed URIs and notify those affected by this mutation.
         // Currently only the aggregate state resource is mutation-sensitive;
         // future entries can branch on e.path / e.method for finer-grained
         // notifications (e.g. tm1://process/{name}/code on /Processes mutations).
         for (const uri of this.subscribed) {
-            if (!STATE_SENSITIVE_URIS.has(uri))
+            const target = this.stateUris.get(uri);
+            if (target === undefined)
+                continue;
+            // An empty target or an untagged event matches any connection.
+            if (target && e.connectionId && target !== e.connectionId)
                 continue;
             // Fire-and-forget; missing transport (server not connected) throws.
             this.server.server.sendResourceUpdated({ uri }).catch((err) => {

package/dist/server-instructions.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectionRegistry } from "./connections.js";
+export declare function serverInstructions(registry: ConnectionRegistry): string;
+//# sourceMappingURL=server-instructions.d.ts.map

package/dist/server-instructions.js

@@ -0,0 +1,12 @@
+// Sent once per session (MCP `instructions`), so every sentence here is paid
+// for by every conversation — keep it to what a model cannot infer from the
+// tool list itself.
+export function serverInstructions(registry) {
+    const lines = ["TM1 / IBM Planning Analytics server."];
+    if (!registry.isSingle) {
+        lines.push("Every tool except tm1_list_connections takes a `connection`; if the target is unclear, call tm1_list_connections and ask. Never write to a connection the user did not name.");
+    }
+    lines.push("Keep results small: filter by name, use projections (fields, include* flags, compact) and countOnly before paging.");
+    return lines.join(" ");
+}
+//# sourceMappingURL=server-instructions.js.map

package/dist/tm1-client/http.d.ts

@@ -1,5 +1,5 @@
 import type pino from "pino";
-import type { TM1Config } from "../config.js";
+import { type TM1Config } from "../config.js";
 import type { SessionManager } from "../session-manager.js";
 import { TM1Error } from "../types.js";
 export interface RequestOptions {

package/dist/tm1-client/http.js

@@ -1,3 +1,4 @@
+import { connectionIdOf } from "../config.js";
 import { createConnectionProfile, } from "./connection/profile.js";
 import { TM1Error, TM1ErrorCode } from "../types.js";
 import { PRODUCT, VERSION } from "../version.js";
@@ -110,13 +111,21 @@ export class TM1HttpClient {
                     }
                     const retryResult = await this.handleResponse(retryResponse, path);
                     if (!isSafeMethod) {
-                        tm1Events.emit("mutation", { method, path });
+                        tm1Events.emit("mutation", {
+                            method,
+                            path,
+                            connectionId: connectionIdOf(this.config),
+                        });
                     }
                     return retryResult;
                 }
                 const result = await this.handleResponse(response, path);
                 if (!isSafeMethod) {
-                    tm1Events.emit("mutation", { method, path });
+                    tm1Events.emit("mutation", {
+                        method,
+                        path,
+                        connectionId: connectionIdOf(this.config),
+                    });
                 }
                 return result;
             }
@@ -191,7 +200,11 @@ export class TM1HttpClient {
         }
         const text = await response.text();
         if (!isSafeHttpMethod(method)) {
-            tm1Events.emit("mutation", { method, path });
+            tm1Events.emit("mutation", {
+                method,
+                path,
+                connectionId: connectionIdOf(this.config),
+            });
         }
         return text;
     }
@@ -225,7 +238,11 @@ export class TM1HttpClient {
             throw this.classifyHttpError(response.status, path, errBody || undefined);
         }
         if (!isSafeHttpMethod(method)) {
-            tm1Events.emit("mutation", { method, path });
+            tm1Events.emit("mutation", {
+                method,
+                path,
+                connectionId: connectionIdOf(this.config),
+            });
         }
     }
     /**

package/dist/tm1-client/services/process-service.d.ts

@@ -12,6 +12,12 @@ export interface ProcessVariableLayout {
 export interface ProcessListOpts extends NameFilterOpts {
     /** Set to slice server-side. Only legal when every active filter is in NameFilterOpts. */
     page?: PageOpts;
+    /**
+     * Select Name only; every process comes back with `parameters: []`. TM1
+     * then serializes no parameter blocks at all — for callers that only need
+     * names (counts, existence checks, listings) this is the cheap query.
+     */
+    namesOnly?: boolean;
 }
 export declare class ProcessService {
     private readonly http;
@@ -29,7 +35,7 @@ export declare class ProcessService {
      * Name-only when v11 rejects the inline Parameters select.
      * GET /api/v1/Processes?$select=Name,Parameters
      */
-    list(): Promise<Process[]>;
+    list(opts?: Pick<ProcessListOpts, "namesOnly">): Promise<Process[]>;
     /**
      * Paged variant: with `page` set the slice happens server-side
      * (`$orderby=Name&$top&$skip&$count=true`) and the return carries the

package/dist/tm1-client/services/process-service.js

@@ -85,6 +85,12 @@ export class ProcessService {
         // — TM1 v11 rejects $expand=Parameters with a syntax error. Use $select
         // instead, which returns Parameters inline. Param.Type comes back as the
         // already-decoded string "Numeric" / "String" (not the legacy int code).
+        const namesOnly = async () => {
+            const response = await this.http.request("GET", `/api/v1/Processes?$select=Name${query}`);
+            return wrap(response.value.map((p) => ({ name: p.Name, parameters: [] })), readCount(response));
+        };
+        if (opts.namesOnly)
+            return namesOnly();
         try {
             const response = await this.http.request("GET", `/api/v1/Processes?$select=Name,Parameters${query}`);
             return wrap(response.value.map((p) => ({
@@ -99,11 +105,7 @@ export class ProcessService {
         }
         catch (e) {
             rethrowIfSystemic(e);
-            const response = await this.http.request("GET", `/api/v1/Processes?$select=Name${query}`);
-            return wrap(response.value.map((p) => ({
-                name: p.Name,
-                parameters: [],
-            })), readCount(response));
+            return namesOnly();
         }
     }
     /**

package/dist/tm1-client.d.ts

@@ -1,5 +1,5 @@
 import type pino from "pino";
-import type { TM1Config } from "./config.js";
+import { type TM1Config } from "./config.js";
 import type { SessionManager } from "./session-manager.js";
 import { BatchService } from "./tm1-client/services/batch-service.js";
 import { CubeService } from "./tm1-client/services/cube-service.js";
@@ -38,6 +38,12 @@ export declare class TM1Client {
     constructor(config: TM1Config, sessionManager: SessionManager, logger: pino.Logger);
     /** The configured TM1 major version (11 or 12). Fixed for this connection. */
     get version(): 11 | 12;
+    /** Effective tool mode, the environment label, and why mode was forced. */
+    get access(): {
+        mode: TM1Config["mode"];
+        environment: TM1Config["environment"];
+        modeReason: string | undefined;
+    };
     /**
      * Stable label for this connection, used to keep per-connection files (the
      * process backups) apart: host and port, plus the v12 instance/database.

package/dist/tm1-client.js

@@ -1,3 +1,4 @@
+import { connectionIdOf } from "./config.js";
 import { TM1HttpClient } from "./tm1-client/http.js";
 import { BatchService } from "./tm1-client/services/batch-service.js";
 import { CubeService } from "./tm1-client/services/cube-service.js";
@@ -82,22 +83,20 @@ export class TM1Client {
     get version() {
         return this.config.version;
     }
+    /** Effective tool mode, the environment label, and why mode was forced. */
+    get access() {
+        return {
+            mode: this.config.mode,
+            environment: this.config.environment,
+            modeReason: this.config.modeReason,
+        };
+    }
     /**
      * Stable label for this connection, used to keep per-connection files (the
      * process backups) apart: host and port, plus the v12 instance/database.
      */
     get connectionId() {
-        let host;
-        try {
-            const url = new URL(this.config.baseUrl);
-            host = url.port ? `${url.hostname}_${url.port}` : url.hostname;
-        }
-        catch {
-            host = this.config.baseUrl;
-        }
-        return [host, this.config.instance, this.config.database]
-            .filter((part) => Boolean(part))
-            .join("_");
+        return connectionIdOf(this.config);
     }
     /**
      * Authenticate and start the keep-alive timer.

package/dist/tools/analysis/analyze-object-usage.d.ts

@@ -1,2 +1,12 @@
+import { buildCubeOrDimUsages } from "../../lib/callgraph/callGraph.js";
 export declare const registerAnalyzeObjectUsage: import("../define-tool.js").ToolRegistrar;
+/** One row per referencing process or rule, most references first. */
+export declare function summarizeBySource(all: ReturnType<typeof buildCubeOrDimUsages>): {
+    sourceKind: "process" | "rule";
+    sourceName: string;
+    accessTypes: string[];
+    sections: string[];
+    funcNames: string[];
+    count: number;
+}[];
 //# sourceMappingURL=analyze-object-usage.d.ts.map

package/dist/tools/analysis/analyze-object-usage.js

@@ -64,39 +64,7 @@ export const registerAnalyzeObjectUsage = defineTool({
             accessMode,
         });
         if (mode === "summary") {
-            // Aggregate per source (process or rule). Key by kind+name so a process
-            // and a cube-rule sharing a name don't collapse into one row.
-            const bySource = new Map();
-            for (const u of all) {
-                const key = `${u.sourceKind}\x00${u.sourceName}`;
-                let s = bySource.get(key);
-                if (!s) {
-                    s = {
-                        sourceKind: u.sourceKind,
-                        sourceName: u.sourceName,
-                        accessTypes: new Set(),
-                        sections: new Set(),
-                        funcNames: new Set(),
-                        count: 0,
-                    };
-                    bySource.set(key, s);
-                }
-                s.accessTypes.add(u.accessType);
-                s.sections.add(u.section);
-                if (u.funcName)
-                    s.funcNames.add(u.funcName);
-                s.count++;
-            }
-            const allSources = [...bySource.values()]
-                .map((s) => ({
-                sourceKind: s.sourceKind,
-                sourceName: s.sourceName,
-                accessTypes: [...s.accessTypes].sort(),
-                sections: [...s.sections].sort(),
-                funcNames: [...s.funcNames].sort(),
-                count: s.count,
-            }))
-                .sort((a, b) => b.count - a.count || a.sourceName.localeCompare(b.sourceName));
+            const allSources = summarizeBySource(all);
             const sumTruncated = allSources.length > effectiveLimit;
             const sources = sumTruncated
                 ? allSources.slice(0, effectiveLimit)
@@ -140,4 +108,40 @@ export const registerAnalyzeObjectUsage = defineTool({
         };
     },
 });
+/** One row per referencing process or rule, most references first. */
+export function summarizeBySource(all) {
+    // Aggregate per source (process or rule). Key by kind+name so a process
+    // and a cube-rule sharing a name don't collapse into one row.
+    const bySource = new Map();
+    for (const u of all) {
+        const key = `${u.sourceKind}\x00${u.sourceName}`;
+        let s = bySource.get(key);
+        if (!s) {
+            s = {
+                sourceKind: u.sourceKind,
+                sourceName: u.sourceName,
+                accessTypes: new Set(),
+                sections: new Set(),
+                funcNames: new Set(),
+                count: 0,
+            };
+            bySource.set(key, s);
+        }
+        s.accessTypes.add(u.accessType);
+        s.sections.add(u.section);
+        if (u.funcName)
+            s.funcNames.add(u.funcName);
+        s.count++;
+    }
+    return [...bySource.values()]
+        .map((s) => ({
+        sourceKind: s.sourceKind,
+        sourceName: s.sourceName,
+        accessTypes: [...s.accessTypes].sort(),
+        sections: [...s.sections].sort(),
+        funcNames: [...s.funcNames].sort(),
+        count: s.count,
+    }))
+        .sort((a, b) => b.count - a.count || a.sourceName.localeCompare(b.sourceName));
+}
 //# sourceMappingURL=analyze-object-usage.js.map

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

@@ -240,7 +240,7 @@ export const registerAuditNaming = defineTool({
         // ── Processes + (optional) variables ───────────────────────────────
         let processNames = [];
         if (want("processes") || want("processVariables")) {
-            const procs = await tm1Client.processes.list();
+            const procs = await tm1Client.processes.list({ namesOnly: true });
             processNames = (includeControl ? procs : procs.filter((p) => !isControlName(p.name))).map((p) => p.name);
         }
         if (want("processes")) {