@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/schemas/common.js

@@ -0,0 +1,23 @@
+// Reusable Zod schema fragments for MCP tool outputSchema declarations.
+// Centralized so every paginated list_* tool emits the same wire shape and
+// the SDK can validate `structuredContent` for clients that consume it.
+import { z } from "zod";
+// Returns the raw shape (`{ key: ZodType, ... }`) of a Page<T> envelope so it
+// can be passed straight to `server.registerTool({ outputSchema })`. The SDK
+// accepts either a ZodRawShape or an AnySchema — raw shape gives the cleanest
+// inferred type at the registration site.
+export function pageShapeFor(itemSchema) {
+    return {
+        total: z.number().int().describe("Total items available across all pages"),
+        count: z.number().int().describe("Number of items in this page"),
+        offset: z.number().int().describe("Offset of the first item in this page"),
+        has_more: z.boolean().describe("True if more items exist after this page"),
+        next_offset: z
+            .number()
+            .int()
+            .nullable()
+            .describe("Offset to pass for the next page, or null when has_more=false"),
+        items: z.array(itemSchema).describe("Items in this page"),
+    };
+}
+//# sourceMappingURL=common.js.map

package/dist/tools/schemas/items-analysis.d.ts

@@ -0,0 +1,394 @@
+import { z } from "zod";
+export { FedCellDescriptorSchema } from "../../schemas/cells.js";
+export declare const InvalidateCallgraphCacheResultSchema: z.ZodObject<{
+    cleared: z.ZodNumber;
+    entriesBefore: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        ageMs: z.ZodNumber;
+        ttlRemainingMs: z.ZodNumber;
+        buildMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CheckFeedersResultSchema: z.ZodObject<{
+    count: z.ZodNumber;
+    unfedCount: z.ZodNumber;
+    fedCells: z.ZodArray<z.ZodObject<{
+        cube: z.ZodString;
+        tuple: z.ZodArray<z.ZodString>;
+        fed: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TraceFeedersResultSchema: z.ZodObject<{
+    count: z.ZodNumber;
+    fedCells: z.ZodArray<z.ZodObject<{
+        cube: z.ZodString;
+        tuple: z.ZodArray<z.ZodString>;
+        fed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    statements: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const CalculationTraceResultSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    cube: z.ZodOptional<z.ZodString>;
+    tuple: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    statements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    components: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+declare const FullNodeBase: z.ZodObject<{
+    process: z.ZodString;
+    cycle: z.ZodBoolean;
+    depthLimitReached: z.ZodOptional<z.ZodBoolean>;
+    incomingEdge: z.ZodNullable<z.ZodObject<{
+        caller: z.ZodString;
+        callee: z.ZodString;
+        section: z.ZodString;
+        line: z.ZodNumber;
+        funcName: z.ZodString;
+        snippet: z.ZodString;
+        params: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"literal">;
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"passthrough">;
+                paramName: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"dynamic">;
+            }, z.core.$strip>], "kind">;
+            valueRaw: z.ZodString;
+        }, z.core.$strip>>;
+        effectiveParams: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            effective: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"literal">;
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+                viaParam: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"dynamic">;
+            }, z.core.$strip>], "kind">;
+            valueRaw: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"literal">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        viaParam: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"dynamic">;
+    }, z.core.$strip>], "kind">>>;
+    unresolvedCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        section: z.ZodString;
+        line: z.ZodNumber;
+        funcName: z.ZodString;
+        expr: z.ZodString;
+        snippet: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type FullNode = z.infer<typeof FullNodeBase> & {
+    children: FullNode[];
+};
+declare const CompactNodeBase: z.ZodObject<{
+    process: z.ZodString;
+    cycle: z.ZodOptional<z.ZodBoolean>;
+    depthLimitReached: z.ZodOptional<z.ZodBoolean>;
+    unresolvedCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        section: z.ZodString;
+        line: z.ZodNumber;
+        funcName: z.ZodString;
+        expr: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CompactNode = z.infer<typeof CompactNodeBase> & {
+    children: CompactNode[];
+};
+export declare const CallgraphResultSchema: z.ZodObject<{
+    warning: z.ZodOptional<z.ZodString>;
+    indexedProcessCount: z.ZodOptional<z.ZodNumber>;
+    start: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    maskSecrets: z.ZodOptional<z.ZodBoolean>;
+    summary: z.ZodOptional<z.ZodObject<{
+        root: z.ZodString;
+        totalNodes: z.ZodNumber;
+        uniqueProcesses: z.ZodNumber;
+        maxDepth: z.ZodNumber;
+        cyclesDetected: z.ZodNumber;
+        depthLimitsHit: z.ZodNumber;
+        processes: z.ZodArray<z.ZodObject<{
+            process: z.ZodString;
+            depthMin: z.ZodNumber;
+            depthMax: z.ZodNumber;
+            occurrences: z.ZodNumber;
+            cycle: z.ZodBoolean;
+            depthLimitReached: z.ZodBoolean;
+            unresolvedCount: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tree: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<FullNode, unknown, z.core.$ZodTypeInternals<FullNode, unknown>>, z.ZodType<CompactNode, unknown, z.core.$ZodTypeInternals<CompactNode, unknown>>]>>;
+    rankBy: z.ZodOptional<z.ZodString>;
+    totalProcessesIndexed: z.ZodOptional<z.ZodNumber>;
+    processesWithEdges: z.ZodOptional<z.ZodNumber>;
+    totalCallEdges: z.ZodOptional<z.ZodNumber>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    ranking: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        process: z.ZodString;
+        outgoingCalls: z.ZodNumber;
+        outgoingDistinct: z.ZodNumber;
+        incomingCalls: z.ZodNumber;
+        incomingDistinct: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ChoreGraphResultSchema: z.ZodObject<{
+    choreName: z.ZodString;
+    maskSecrets: z.ZodOptional<z.ZodBoolean>;
+    tasks: z.ZodArray<z.ZodObject<{
+        step: z.ZodNumber;
+        processName: z.ZodString;
+        choreParams: z.ZodUnknown;
+        tree: z.ZodUnknown;
+    }, z.core.$loose>>;
+    warning: z.ZodOptional<z.ZodString>;
+    indexedChoreCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ObjectUsageResultSchema: z.ZodObject<{
+    kind: z.ZodString;
+    name: z.ZodString;
+    accessMode: z.ZodString;
+    count: z.ZodNumber;
+    returned: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    usages: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    mode: z.ZodOptional<z.ZodString>;
+    sourceCount: z.ZodOptional<z.ZodNumber>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const DataFlowResultSchema: z.ZodObject<{
+    cube: z.ZodString;
+    direction: z.ZodEnum<{
+        downstream: "downstream";
+        upstream: "upstream";
+        both: "both";
+    }>;
+    upstream: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        process: z.ZodString;
+        sourceCubes: z.ZodArray<z.ZodString>;
+        datasourceType: z.ZodString;
+        externalSource: z.ZodOptional<z.ZodString>;
+        elements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    downstream: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        process: z.ZodString;
+        targetCubes: z.ZodArray<z.ZodString>;
+        readsVia: z.ZodEnum<{
+            code: "code";
+            datasource: "datasource";
+            both: "both";
+        }>;
+        elements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    counts: z.ZodObject<{
+        upstream: z.ZodOptional<z.ZodNumber>;
+        downstream: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    element: z.ZodOptional<z.ZodObject<{
+        dimension: z.ZodString;
+        name: z.ZodString;
+        processes: z.ZodArray<z.ZodObject<{
+            process: z.ZodString;
+            funcNames: z.ZodArray<z.ZodString>;
+            access: z.ZodArray<z.ZodEnum<{
+                indeterminate: "indeterminate";
+                source: "source";
+                write: "write";
+                "zero-out": "zero-out";
+            }>>;
+            via: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        unresolvedInProcesses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        suppressedIndeterminate: z.ZodOptional<z.ZodNumber>;
+        computedInProcesses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        resolution: z.ZodString;
+    }, z.core.$strip>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SearchCodeMatchSchema: z.ZodObject<{
+    process: z.ZodString;
+    tab: z.ZodString;
+    line: z.ZodNumber;
+    text: z.ZodString;
+    alsoFoundIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const SearchCodeGroupSchema: z.ZodObject<{
+    process: z.ZodOptional<z.ZodString>;
+    tab: z.ZodOptional<z.ZodString>;
+    matchCount: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SearchCodeResultSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    caseSensitive: z.ZodBoolean;
+    tabsSearched: z.ZodArray<z.ZodString>;
+    processesScanned: z.ZodNumber;
+    matchCount: z.ZodNumber;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    maskSecrets: z.ZodOptional<z.ZodBoolean>;
+    excludeCommented: z.ZodOptional<z.ZodBoolean>;
+    groupBy: z.ZodOptional<z.ZodEnum<{
+        process: "process";
+        tab: "tab";
+    }>>;
+    groupCount: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodNumber;
+    count: z.ZodNumber;
+    offset: z.ZodNumber;
+    has_more: z.ZodBoolean;
+    next_offset: z.ZodNullable<z.ZodNumber>;
+    items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        process: z.ZodString;
+        tab: z.ZodString;
+        line: z.ZodNumber;
+        text: z.ZodString;
+        alsoFoundIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        process: z.ZodOptional<z.ZodString>;
+        tab: z.ZodOptional<z.ZodString>;
+        matchCount: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    rawMatchCount: z.ZodOptional<z.ZodNumber>;
+    deduplicated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AuditComplexityResultSchema: z.ZodObject<{
+    status: z.ZodString;
+    productVersion: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodUnknown>;
+    scanned: z.ZodOptional<z.ZodUnknown>;
+    summary: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export declare const AuditFeedersResultSchema: z.ZodObject<{
+    status: z.ZodString;
+    productVersion: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    scanned: z.ZodOptional<z.ZodUnknown>;
+    runtimeUnavailable: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<{
+            absent: "absent";
+            denied: "denied";
+        }>;
+        message: z.ZodString;
+        cubes: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export declare const AuditNamingResultSchema: z.ZodObject<{
+    status: z.ZodString;
+    productVersion: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodUnknown>;
+    scanned: z.ZodOptional<z.ZodUnknown>;
+    summary: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export declare const SearchRulesResultSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    caseSensitive: z.ZodBoolean;
+    cubesScanned: z.ZodNumber;
+    matchCount: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    includeFeeders: z.ZodBoolean;
+    total: z.ZodNumber;
+    count: z.ZodNumber;
+    offset: z.ZodNumber;
+    has_more: z.ZodBoolean;
+    next_offset: z.ZodNullable<z.ZodNumber>;
+    items: z.ZodArray<z.ZodObject<{
+        cube: z.ZodString;
+        line: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const V12FindingSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    category: z.ZodEnum<{
+        deprecated_ti_function: "deprecated_ti_function";
+    }>;
+    objectKind: z.ZodEnum<{
+        cube: "cube";
+        process: "process";
+    }>;
+    objectName: z.ZodString;
+    section: z.ZodEnum<{
+        prolog: "prolog";
+        metadata: "metadata";
+        data: "data";
+        epilog: "epilog";
+        rules: "rules";
+    }>;
+    line: z.ZodNumber;
+    function: z.ZodString;
+    snippet: z.ZodString;
+    issue: z.ZodString;
+    suggestion: z.ZodString;
+}, z.core.$strip>;
+export declare const V12ReadinessResultSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        processes: "processes";
+        rules: "rules";
+        all: "all";
+    }>;
+    includeControl: z.ZodBoolean;
+    scannedProcesses: z.ZodNumber;
+    scannedCubes: z.ZodNumber;
+    findingsCount: z.ZodNumber;
+    readinessScore: z.ZodEnum<{
+        ready: "ready";
+        "needs-work": "needs-work";
+        blocked: "blocked";
+    }>;
+    summary: z.ZodObject<{
+        byCategory: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        bySeverity: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        topFunctions: z.ZodArray<z.ZodObject<{
+            function: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    findings: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>;
+        category: z.ZodEnum<{
+            deprecated_ti_function: "deprecated_ti_function";
+        }>;
+        objectKind: z.ZodEnum<{
+            cube: "cube";
+            process: "process";
+        }>;
+        objectName: z.ZodString;
+        section: z.ZodEnum<{
+            prolog: "prolog";
+            metadata: "metadata";
+            data: "data";
+            epilog: "epilog";
+            rules: "rules";
+        }>;
+        line: z.ZodNumber;
+        function: z.ZodString;
+        snippet: z.ZodString;
+        issue: z.ZodString;
+        suggestion: z.ZodString;
+    }, z.core.$strip>>;
+    rulesetSource: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=items-analysis.d.ts.map