@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,179 @@
+import { type ProcessEnv, type VarBinding } from "./variableEnv.js";
+import { type SubsetUsage } from "./subsetUsage.js";
+export type RefTargetKind = "cube" | "dimension" | "process" | "element";
+export type RefSourceKind = "process" | "rule";
+export type RefSection = "prolog" | "metadata" | "data" | "epilog" | "rules" | "feeders";
+/**
+ * How a value argument in an ExecuteProcess/RunProcess call-site resolves
+ * based on the caller's code (literals + local var tracking, no chain resolution).
+ */
+export type CallParamResolution = {
+    kind: "literal";
+    value: string;
+} | {
+    kind: "passthrough";
+    paramName: string;
+} | {
+    kind: "dynamic";
+};
+/**
+ * One param pair (name + value) in an ExecuteProcess/RunProcess call.
+ * `valueRaw` is the original argument text for display/debugging.
+ */
+export interface CallParam {
+    name: string;
+    resolution: CallParamResolution;
+    valueRaw: string;
+}
+export interface TmReference {
+    sourceKind: RefSourceKind;
+    sourceName: string;
+    section: RefSection;
+    line: number;
+    snippet: string;
+    funcName?: string | undefined;
+    targetKind: RefTargetKind;
+    targetName: string;
+    /** Only set for ExecuteProcess/RunProcess references (targetKind = 'process'). */
+    params?: CallParam[] | undefined;
+    /** Owning dimension — only set when targetKind === 'element'. */
+    dimension?: string | undefined;
+    /** Subset the element was inserted into — only set when targetKind === 'element'. */
+    subset?: string | undefined;
+}
+/** One task inside a chore: the scheduled process plus its fixed call-site params. */
+export interface ChoreTaskRef {
+    step: number;
+    processName: string;
+    params: Array<{
+        name: string;
+        value: string;
+        type: "string" | "numeric";
+    }>;
+}
+/** An ExecuteProcess/RunProcess call-site whose target could not be resolved to a literal process name. */
+export interface UnresolvedCall {
+    section: RefSection;
+    line: number;
+    funcName: string;
+    expr: string;
+    snippet: string;
+    reason: "dynamic" | "param";
+}
+/** A subset-membership element arg (SubsetElementInsert/Add/Delete) whose element name could not be resolved to a literal. */
+export interface UnresolvedElementRef {
+    section: RefSection;
+    line: number;
+    funcName: string;
+    dimension?: string | undefined;
+    expr: string;
+    snippet: string;
+    reason: "dynamic" | "param";
+}
+export interface ReferenceIndex {
+    all: TmReference[];
+    byCube: Map<string, TmReference[]>;
+    byDim: Map<string, TmReference[]>;
+    byProcess: Map<string, TmReference[]>;
+    /** Process name (lowercased) → refs originating FROM that process (for call-graph downstream traversal). */
+    bySourceProcess: Map<string, TmReference[]>;
+    /** Process name (lowercased) → unresolved ExecuteProcess/RunProcess call sites (dynamic/param target). */
+    unresolvedCallsBySourceProcess: Map<string, UnresolvedCall[]>;
+    /** elementKey(dim, element) → element references (subset-membership calls). */
+    byElement: Map<string, TmReference[]>;
+    /** Process name (lowercased) → element args that could not be resolved to a literal. */
+    unresolvedElementRefsBySourceProcess: Map<string, UnresolvedElementRef[]>;
+    /** Process (lc) → subset (lc) → how that subset is used in the process (view assign / zero-out / loop). */
+    subsetUsageByProcess: Map<string, Map<string, SubsetUsage>>;
+    /** Process name (lowercased) → declared param names (original casing). */
+    processParams: Map<string, string[]>;
+    /** Process name (lowercased) → param-name → default value (string form), for root-env seeding. */
+    processDefaults: Map<string, Map<string, string>>;
+    /** Chore name (lowercased) → ordered task list. */
+    choreTasks: Map<string, ChoreTaskRef[]>;
+}
+export declare function splitArgs(argsStr: string): string[];
+/** Composite key for the byElement index: dimension + element, both lowercased. */
+export declare function elementKey(dimension: string, element: string): string;
+export declare function extractStringLiteral(arg: string): string | null;
+interface RawTiRef {
+    line: number;
+    funcName: string;
+    targetKind: RefTargetKind;
+    targetName: string;
+    snippet: string;
+    params?: CallParam[] | undefined;
+    dimension?: string | undefined;
+    subset?: string | undefined;
+}
+interface RawUnresolvedCall {
+    line: number;
+    funcName: string;
+    expr: string;
+    snippet: string;
+    reason: "dynamic" | "param";
+}
+/** A subset-membership element arg that could not be resolved to a literal (raw, pre-section). */
+interface RawUnresolvedElementRef {
+    line: number;
+    funcName: string;
+    dimension?: string | undefined;
+    expr: string;
+    snippet: string;
+    reason: "dynamic" | "param";
+}
+/**
+ * Extracts cube/dimension/process references from a single TI text (one section).
+ * Pure function — no network, no vscode.
+ *
+ * @param text       TI source (prolog/metadata/data/epilog)
+ * @param env        Process environment for variable resolution in ExecuteProcess args.
+ *                   Defaults to an empty env (no param refs, no local vars) if omitted.
+ */
+export declare function extractTiReferences(text: string, env?: ProcessEnv, sharedLiveVars?: Map<string, VarBinding>, unresolvedOut?: RawUnresolvedCall[], unresolvedElemOut?: RawUnresolvedElementRef[]): RawTiRef[];
+interface RawRuleRef {
+    line: number;
+    section: "rules" | "feeders";
+    funcName?: string | undefined;
+    targetKind: "cube" | "dimension";
+    targetName: string;
+    snippet: string;
+}
+/**
+ * Extracts cube (from DB()) and dimension (from [...] refs) references
+ * from a rules/feeders text. Pure function.
+ */
+export declare function extractRulesReferences(text: string): RawRuleRef[];
+export interface ProcessFetchResult {
+    name: string;
+    prolog: string;
+    metadata: string;
+    data: string;
+    epilog: string;
+    /** Parameter names declared on this process (used for pass-through resolution). */
+    parameters?: string[];
+    /** Default values (string form) by param name, if known. Used as root-env when graph starts here. */
+    parameterDefaults?: Map<string, string>;
+}
+export interface CubeRulesFetchResult {
+    cubeName: string;
+    rulesText: string;
+}
+export interface ChoreFetchResult {
+    name: string;
+    tasks: ChoreTaskRef[];
+}
+export interface BuildIndexDeps {
+    fetchProcesses: () => Promise<ProcessFetchResult[]>;
+    fetchCubesWithRules: () => Promise<CubeRulesFetchResult[]>;
+    fetchChores?: () => Promise<ChoreFetchResult[]>;
+}
+/**
+ * Builds a complete reference index from processes + cube rules.
+ * Pure function — dependencies are injected to allow testing without network.
+ */
+export declare function buildReferenceIndex(deps: BuildIndexDeps): Promise<ReferenceIndex>;
+/** Convenience lookup — returns [] if target is not indexed. */
+export declare function lookupReferences(idx: ReferenceIndex, targetKind: RefTargetKind, targetName: string): TmReference[];
+export {};
+//# sourceMappingURL=referenceIndex.d.ts.map