@danielblomma/cortex-mcp 0.4.2 → 0.6.4

package/scaffold/mcp/src/presets.ts

@@ -0,0 +1,137 @@
+import type { ImpactParams, RelatedParams, SearchParams } from "./types.js";
+
+export type ResponsePreset = "full" | "compact" | "minimal";
+
+type ImpactPresetOptions = {
+  includeScores: boolean;
+  includeReasons: boolean;
+  verbosePaths: boolean;
+  maxPathHopsShown: number;
+};
+
+type SearchPresetOptions = {
+  includeScores: boolean;
+  includeMatchedRules: boolean;
+  includeContent: boolean;
+};
+
+type RelatedPresetOptions = {
+  includeEdges: boolean;
+  includeEntityMetadata: boolean;
+};
+
+function resolvePresetOptions<TDefaults extends Record<string, boolean | number | string>>(
+  responsePreset: ResponsePreset | undefined,
+  presetDefaultsByMode: Record<ResponsePreset, TDefaults>,
+  explicitOverrides: Partial<TDefaults>
+): TDefaults & { responsePreset: ResponsePreset } {
+  const resolvedPreset = responsePreset ?? "full";
+  const presetDefaults = presetDefaultsByMode[resolvedPreset];
+
+  return {
+    responsePreset: resolvedPreset,
+    ...presetDefaults,
+    ...Object.fromEntries(
+      Object.entries(explicitOverrides).filter(([, value]) => value !== undefined)
+    )
+  } as TDefaults & { responsePreset: ResponsePreset };
+}
+
+export function resolveImpactResponsePreset(parsed: ImpactParams): {
+  responsePreset: ResponsePreset;
+  includeScores: boolean;
+  includeReasons: boolean;
+  verbosePaths: boolean;
+  maxPathHopsShown: number;
+} {
+  return resolvePresetOptions<ImpactPresetOptions>(
+    parsed.response_preset,
+    {
+      full: {
+        includeScores: true,
+        includeReasons: true,
+        verbosePaths: true,
+        maxPathHopsShown: 2
+      },
+      compact: {
+        includeScores: false,
+        includeReasons: true,
+        verbosePaths: false,
+        maxPathHopsShown: 2
+      },
+      minimal: {
+        includeScores: false,
+        includeReasons: false,
+        verbosePaths: false,
+        maxPathHopsShown: 1
+      }
+    },
+    {
+      includeScores: parsed.include_scores,
+      includeReasons: parsed.include_reasons,
+      verbosePaths: parsed.verbose_paths,
+      maxPathHopsShown: parsed.max_path_hops_shown
+    }
+  );
+}
+
+export function resolveSearchResponsePreset(parsed: SearchParams): {
+  responsePreset: ResponsePreset;
+  includeScores: boolean;
+  includeMatchedRules: boolean;
+  includeContent: boolean;
+} {
+  return resolvePresetOptions<SearchPresetOptions>(
+    parsed.response_preset,
+    {
+      full: {
+        includeScores: true,
+        includeMatchedRules: true,
+        includeContent: false
+      },
+      compact: {
+        includeScores: false,
+        includeMatchedRules: true,
+        includeContent: false
+      },
+      minimal: {
+        includeScores: false,
+        includeMatchedRules: false,
+        includeContent: false
+      }
+    },
+    {
+      includeScores: parsed.include_scores,
+      includeMatchedRules: parsed.include_matched_rules,
+      includeContent: parsed.include_content
+    }
+  );
+}
+
+export function resolveRelatedResponsePreset(parsed: RelatedParams): {
+  responsePreset: ResponsePreset;
+  includeEdges: boolean;
+  includeEntityMetadata: boolean;
+} {
+  return resolvePresetOptions<RelatedPresetOptions>(
+    parsed.response_preset,
+    {
+      full: {
+        includeEdges: true,
+        includeEntityMetadata: true
+      },
+      compact: {
+        includeEdges: false,
+        includeEntityMetadata: true
+      },
+      minimal: {
+        includeEdges: false,
+        includeEntityMetadata: false
+      }
+    },
+    {
+      includeEdges: parsed.include_edges,
+      includeEntityMetadata: parsed.include_entity_metadata
+    }
+  );
+}

package/scaffold/mcp/src/relatedResponse.ts

@@ -0,0 +1,30 @@
+import type { RelatedParams, ToolPayload } from "./types.js";
+
+export function buildRelatedResponseMeta(params: {
+  parsed: RelatedParams;
+  responsePreset: "full" | "compact" | "minimal";
+  includeEdges: boolean;
+  includeEntityMetadata: boolean;
+  contextSource: string;
+}): ToolPayload {
+  return {
+    entity_id: params.parsed.entity_id,
+    depth: params.parsed.depth,
+    response_preset: params.responsePreset,
+    include_edges: params.includeEdges,
+    include_entity_metadata: params.includeEntityMetadata,
+    context_source: params.contextSource
+  };
+}
+
+export function buildEmptyRelatedResponse(params: {
+  meta: ToolPayload;
+  warning: string;
+}): ToolPayload {
+  return {
+    ...params.meta,
+    related: [],
+    edges: [],
+    warning: params.warning
+  };
+}

package/scaffold/mcp/src/relatedTraversal.ts

@@ -0,0 +1,101 @@
+import type { JsonObject, RelationRecord } from "./types.js";
+
+export function traverseRelatedGraph(params: {
+  entityId: string;
+  relations: RelationRecord[];
+  depth: number;
+  catalog: Map<string, JsonObject>;
+  includeEntityMetadata: boolean;
+}): {
+  related: JsonObject[];
+  traversedEdges: JsonObject[];
+} {
+  const outgoing = new Map<string, RelationRecord[]>();
+  const incoming = new Map<string, RelationRecord[]>();
+
+  for (const relation of params.relations) {
+    const outList = outgoing.get(relation.from) ?? [];
+    outList.push(relation);
+    outgoing.set(relation.from, outList);
+
+    const inList = incoming.get(relation.to) ?? [];
+    inList.push(relation);
+    incoming.set(relation.to, inList);
+  }
+
+  const seen = new Set<string>([params.entityId]);
+  const queue: Array<{ id: string; hop: number }> = [{ id: params.entityId, hop: 0 }];
+  const related: JsonObject[] = [];
+  const traversedEdges: JsonObject[] = [];
+  const traversedEdgeKeys = new Set<string>();
+
+  while (queue.length > 0) {
+    const current = queue.shift() as { id: string; hop: number };
+    if (current.hop >= params.depth) {
+      continue;
+    }
+
+    const neighbors = [
+      ...(outgoing.get(current.id) ?? []).map((edge) => ({
+        edge,
+        next: edge.to,
+        direction: "outgoing"
+      })),
+      ...(incoming.get(current.id) ?? []).map((edge) => ({
+        edge,
+        next: edge.from,
+        direction: "incoming"
+      }))
+    ];
+
+    for (const neighbor of neighbors) {
+      const target = neighbor.next;
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push({ id: target, hop: current.hop + 1 });
+
+        const entity = params.catalog.get(target) ?? {
+          id: target,
+          type: "Unknown",
+          label: target,
+          status: "unknown",
+          source_of_truth: false
+        };
+
+        related.push(
+          params.includeEntityMetadata
+            ? {
+                ...entity,
+                hops: current.hop + 1,
+                via_relation: neighbor.edge.relation,
+                direction: neighbor.direction
+              }
+            : {
+                id: entity.id,
+                type: entity.type,
+                label: entity.label,
+                hops: current.hop + 1,
+                via_relation: neighbor.edge.relation,
+                direction: neighbor.direction
+              }
+        );
+      }
+
+      const edgeKey = `${neighbor.edge.from}|${neighbor.edge.relation}|${neighbor.edge.to}|${neighbor.edge.note}`;
+      if (!traversedEdgeKeys.has(edgeKey)) {
+        traversedEdgeKeys.add(edgeKey);
+        traversedEdges.push({
+          from: neighbor.edge.from,
+          to: neighbor.edge.to,
+          relation: neighbor.edge.relation,
+          note: neighbor.edge.note
+        });
+      }
+    }
+  }
+
+  return {
+    related,
+    traversedEdges
+  };
+}

package/scaffold/mcp/src/rules.ts

@@ -0,0 +1,27 @@
+import { loadContextData } from "./graph.js";
+import type { RulesParams, ToolPayload } from "./types.js";
+
+export async function runContextRules(parsed: RulesParams): Promise<ToolPayload> {
+  const data = await loadContextData();
+
+  const rules = data.rules
+    .filter((rule) => parsed.include_inactive || rule.status === "active")
+    .filter((rule) => !parsed.scope || rule.scope === parsed.scope || rule.scope === "global")
+    .sort((a, b) => b.priority - a.priority)
+    .map((rule) => ({
+      id: rule.id,
+      title: rule.title,
+      description: rule.body,
+      priority: rule.priority,
+      scope: rule.scope,
+      status: rule.status
+    }));
+
+  return {
+    scope: parsed.scope ?? "global",
+    count: rules.length,
+    context_source: data.source,
+    warning: data.warning,
+    rules
+  };
+}