@mrclrchtr/supi-code-intelligence 6.4.0 → 7.0.1

package/src/tool/code_graph/read-next.ts

@@ -0,0 +1,65 @@
+import { type ReadNextItem, readNextRange } from "../../analysis/read-next.ts";
+import type { GraphSection } from "../../session/graph-types.ts";
+
+/** Prefer the known enclosing scope, then alternate relation sites before the display cap. */
+export function graphReadNext(sections: readonly GraphSection[]): ReadNextItem[] {
+  const calls = sections.find((section) => section.kind === "ok" && section.rel === "callees");
+  const scopeReads =
+    calls?.kind === "ok"
+      ? calls.readNext.map((item) => ({ ...item, reason: "inspect the enclosing scope" }))
+      : [];
+  const queues = sections.flatMap((section) => {
+    if (section.kind !== "ok" || section.rel === "callees") return [];
+    // Reference collection puts the approximate target range first. The known scope replaces it.
+    return [
+      section.rel === "references" && scopeReads.length > 0
+        ? section.readNext.slice(1)
+        : section.readNext,
+    ];
+  });
+  const candidates = [...scopeReads];
+  const maxLength = Math.max(0, ...queues.map((queue) => queue.length));
+  for (let index = 0; index < maxLength; index++) {
+    for (const queue of queues) {
+      const item = queue[index];
+      if (item) candidates.push(item);
+    }
+  }
+  return mergeRanges(candidates)
+    .slice(0, 3)
+    .map((item) => readNextRange(item));
+}
+
+/** Merge connected ranges before bounding them, including ranges that bridge two earlier reads. */
+function mergeRanges(items: readonly ReadNextItem[]): ReadNextItem[] {
+  const result: ReadNextItem[] = [];
+  for (const item of items) {
+    const merged = { ...item };
+    let firstIndex = result.length;
+    let index = 0;
+    while (index < result.length) {
+      const other = result[index];
+      if (
+        other.file === merged.file &&
+        other.startLine <= merged.endLine &&
+        merged.startLine <= other.endLine
+      ) {
+        firstIndex = Math.min(firstIndex, index);
+        if (
+          merged.reason !== other.reason ||
+          merged.startLine !== other.startLine ||
+          merged.endLine !== other.endLine
+        )
+          merged.reason = "inspect related source ranges";
+        merged.startLine = Math.min(merged.startLine, other.startLine);
+        merged.endLine = Math.max(merged.endLine, other.endLine);
+        result.splice(index, 1);
+        index = 0;
+      } else {
+        index++;
+      }
+    }
+    result.splice(firstIndex, 0, merged);
+  }
+  return result;
+}

package/src/tool/code_graph/result.ts

@@ -1,5 +1,10 @@
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
-import { createEvidenceList, type EvidenceList } from "../../analysis/evidence.ts";
+import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
+import {
+  createEvidenceList,
+  createPartialEvidenceList,
+  type EvidenceList,
+} from "../../analysis/evidence.ts";
 import type { RelationLocationPartialReason } from "../../analysis/relations/provider-locations.ts";
 import type {
   CallEntry,
@@ -9,13 +14,18 @@ import type {
 import { toDisplayPath } from "../../analysis/search/paths.ts";
 import type { GraphSection } from "../../session/graph-types.ts";
 import {
-  assembledNextQueries,
+  assembledReadNext,
   assembleToolResult,
   type ResultProvenance,
   type ToolResultAssembly,
 } from "../result/assembly.ts";
+import { formatCandidateRow } from "../result/candidate-row.ts";
 import { createToolDisplaySection } from "../result/display.ts";
-import type { SearchDetails, ToolDisplaySection } from "../result/types.ts";
+import type { ToolDisplaySection } from "../result/types.ts";
+import type { GraphDetails, GraphFileGroup, GraphSectionDetails } from "./details.ts";
+import { graphDisplaySection } from "./display.ts";
+import { formatGraphEvidence } from "./format.ts";
+import { graphReadNext } from "./read-next.ts";
 
 export type { GraphRelationKind, GraphSection } from "../../session/graph-types.ts";
 
@@ -40,7 +50,7 @@ export interface GraphResultAssembly {
   resolvedDisplayFile: string;
   cwd: string;
   assembled: ToolResultAssembly<{ readonly sections: readonly AssembledGraphSection[] }>;
-  details: SearchDetails;
+  details: GraphDetails;
   displaySections: readonly ToolDisplaySection[];
 }
 
@@ -74,13 +84,14 @@ export function assembleGraphResult(input: {
     })),
     evidenceLists,
     nextQueries: [],
-    readNext: sections.flatMap((section) => (section.kind === "ok" ? section.readNext : [])),
+    readNext: graphReadNext(sections),
     candidateCount,
     confidence,
     provenance,
   });
 
-  const displaySections = sections.map((section) => graphDisplaySection(section, input.cwd));
+  const displays = sections.map((section) => graphDisplaySection(section, input.cwd));
+  const displaySections = displays.map(({ display }) => display);
 
   return {
     displayName: input.displayName,
@@ -90,51 +101,36 @@ export function assembleGraphResult(input: {
     assembled,
     displaySections,
     details: {
-      confidence,
-      scope: null,
-      candidateCount,
-      omittedCount: assembled.totals.omittedCount,
+      targetName: input.displayName,
+      targetFile: input.resolvedDisplayFile,
+      sections: sections.map((section, index) =>
+        graphSectionDetails(section, input.cwd, displays[index].fileGroups),
+      ),
+      readNext: assembledReadNext(assembled),
       evidenceLists: [...assembled.evidenceLists],
-      nextQueries: assembledNextQueries(assembled),
     },
   };
 }
 
-function graphDisplaySection(section: AssembledGraphSection, cwd: string): ToolDisplaySection {
-  if (section.kind === "unavailable") {
-    return createToolDisplaySection({
-      key: `graph.${section.rel}`,
-      title: section.rel,
-      items: [section.message],
-      format: (message) => `Unavailable — ${message}`,
-      totalCount: 1,
-    });
-  }
-
-  return createToolDisplaySection({
-    key: `graph.${section.rel}`,
-    title: section.rel,
-    items: section.evidence.items as readonly unknown[],
-    totalCount: section.evidence.metadata.totalCount,
-    omittedCount: section.evidence.metadata.omittedCount,
-    partialReason: section.evidence.metadata.partialReason,
-    format: (item) => formatGraphDisplayItem(section.rel, item, cwd),
-  });
-}
-
-function formatGraphDisplayItem(
-  relation: "references" | "callees" | "implements",
-  item: unknown,
+function graphSectionDetails(
+  section: AssembledGraphSection,
   cwd: string,
-): string {
-  if (relation === "callees") {
-    const call = item as { name: string; file: string; line: number };
-    return `${call.name} — ${toDisplayPath(cwd, call.file)}:L${call.line}`;
-  }
-
-  const location = item as { name: string | null; file: string; line: number; character: number };
-  const name = location.name ? `${location.name} — ` : "";
-  return `${name}${toDisplayPath(cwd, location.file)}:L${location.line}:${location.character}`;
+  fileGroups: GraphFileGroup[],
+): GraphSectionDetails {
+  const calls = section.kind === "ok" && section.rel === "callees" ? section.data : null;
+  return {
+    rel: section.rel,
+    source: section.rel === "callees" ? "structural" : "semantic",
+    status: section.kind === "ok" ? evidenceStatus(section.evidence) : "unavailable",
+    message: section.kind === "unavailable" ? section.message : null,
+    externalCount:
+      section.kind === "ok" && section.rel !== "callees" ? section.data.externalCount : 0,
+    enclosingScope: calls
+      ? { ...calls.enclosingScope, file: toDisplayPath(cwd, calls.enclosingScope.file) }
+      : null,
+    depth: calls?.depth ?? null,
+    fileGroups,
+  };
 }
 
 function assembleGraphSection(section: GraphSection, maxResults: number): AssembledGraphSection {
@@ -181,11 +177,10 @@ function createRelationEvidenceList<T>(params: {
   invalidLocationCount: number;
   partialReason: RelationLocationPartialReason | null;
 }): EvidenceList<T> {
-  const evidence = createEvidenceList({
-    key: params.key,
-    items: params.items,
-    maxResults: params.maxResults,
-  });
+  const evidence =
+    params.partialReason === "provider-limited"
+      ? createPartialEvidenceList({ ...params, partialReason: params.partialReason })
+      : createEvidenceList(params);
   if (params.partialReason === null) return evidence;
   return {
     ...evidence,
@@ -247,38 +242,7 @@ export function finishGraphResult(outcome: GraphOutcome, cwd: string): CodeIntel
     return searchErrorResult(`**Error:** ${outcome.message}`, { message: outcome.message });
   }
   if (outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch") {
-    const lines = [
-      outcome.kind === "kind-mismatch"
-        ? `**No target matched provider kind \`${outcome.requestedKind}\`. Near matches:**`
-        : "**Target is ambiguous. Choose one candidate handle:**",
-      "",
-    ];
-    for (const candidate of outcome.candidates) {
-      lines.push(
-        `- \`${candidate.targetId}\` — ${candidate.name} (\`${candidate.kind ?? "unknown"}\`) at ${candidate.file}:${candidate.line}:${candidate.character}`,
-      );
-    }
-    if (outcome.kind === "kind-mismatch") {
-      lines.push(
-        "",
-        "Retry without `symbolKind`, use an observed provider kind, or choose a handle.",
-      );
-    }
-    return searchErrorResult(lines.join("\n"), {
-      message:
-        outcome.kind === "kind-mismatch"
-          ? `No target matched provider kind ${outcome.requestedKind}.`
-          : "The target is ambiguous.",
-      displaySections: [
-        createToolDisplaySection({
-          key: "graph.candidates",
-          title: "Candidates",
-          items: outcome.candidates,
-          format: (candidate) =>
-            `${candidate.targetId} — ${candidate.name} (${candidate.kind ?? "unknown"}) at ${candidate.file}:${candidate.line}:${candidate.character}`,
-        }),
-      ],
-    });
+    return finishGraphCandidates(outcome);
   }
 
   const assembly = assembleGraphResult({
@@ -288,13 +252,84 @@ export function finishGraphResult(outcome: GraphOutcome, cwd: string): CodeIntel
     maxResults: outcome.maxResults,
     cwd,
   });
+  const displayTruncated = hasHiddenDisplayEvidence(assembly);
   return {
     content: renderGraphResult(assembly),
     details: {
-      type: "search",
+      type: "graph",
       data: assembly.details,
       status: "completed",
       displaySections: assembly.displaySections,
+      ...(displayTruncated ? { truncation: { truncated: false, displayTruncated: true } } : {}),
     },
   };
 }
+
+function finishGraphCandidates(
+  outcome: Extract<GraphOutcome, { kind: "disambiguation" | "kind-mismatch" }>,
+): CodeIntelResult {
+  const lines = [
+    outcome.kind === "kind-mismatch"
+      ? `**No target matched provider kind \`${outcome.requestedKind}\`. Near matches:**`
+      : "**Target is ambiguous. Choose one candidate handle:**",
+    "",
+  ];
+  for (const candidate of outcome.candidates) {
+    lines.push(
+      `- \`${candidate.targetId}\` — ${candidate.name} (\`${candidate.kind ?? "unknown"}\`) at ${candidate.file}:${candidate.line}:${candidate.character}`,
+    );
+  }
+  const evidence = graphCandidateEvidence(outcome);
+  lines.push("", formatGraphEvidence(evidence, "candidates"));
+  if (outcome.kind === "kind-mismatch") {
+    lines.push(
+      "",
+      "Retry without `symbolKind`, use an observed provider kind, or choose a handle.",
+    );
+  }
+  const displaySections = [
+    createToolDisplaySection({
+      key: "graph.candidates",
+      title: "Candidates",
+      items: outcome.candidates,
+      totalCount: evidence.totalCount,
+      omittedCount: evidence.omittedCount,
+      partialReason: evidence.partialReason,
+      format: (candidate) => formatCandidateRow(candidate, "handle-first"),
+    }),
+  ];
+  return searchErrorResult(lines.join("\n"), {
+    confidence: "semantic",
+    evidenceLists: [evidence],
+    nextQueries:
+      outcome.kind === "kind-mismatch"
+        ? ["Retry without symbolKind, use an observed provider kind, or choose a near-match handle"]
+        : ["Choose one candidate handle, or narrow the symbol selector with scope or symbolKind"],
+    status: outcome.kind === "disambiguation" ? "disambiguation" : "invalid-input",
+    message:
+      outcome.kind === "kind-mismatch"
+        ? `No target matched provider kind ${outcome.requestedKind}.`
+        : "The target is ambiguous.",
+    displaySections,
+  });
+}
+
+function graphCandidateEvidence(
+  outcome: Extract<GraphOutcome, { kind: "disambiguation" | "kind-mismatch" }>,
+): EvidenceListMetadata {
+  return {
+    key: "graph.candidates",
+    totalCount: outcome.totalCount,
+    shownCount: outcome.candidates.length,
+    omittedCount: outcome.omittedCount,
+    partialReason: outcome.partialReason,
+  };
+}
+
+function hasHiddenDisplayEvidence(assembly: GraphResultAssembly): boolean {
+  return assembly.sections.some(
+    (section, index) =>
+      section.kind === "ok" &&
+      assembly.displaySections[index].shownCount < section.evidence.items.length,
+  );
+}

package/src/tool/code_graph/tui.ts

@@ -1,28 +1,34 @@
-/** TUI renderer for code_graph. */
+/** Human transcript renderer for code_graph. */
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { type Component, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { renderCandidateSelection } from "../../ui/tui/candidate-selection.ts";
 import {
   buildSimpleCompact,
-  buildSimpleHeader,
   type EvidenceEntry,
   formatCallPath,
   formatCallValue,
   type ResultOptios,
+  readEvidenceEntries,
   renderDomainError,
-  renderDomainResult,
-  renderEvidenceLines,
   renderExecutionError,
   renderMarkdownDetail,
   renderPartial,
-  renderStructuredDetailBody,
   renderToolDisplaySections,
   renderTruncationDisclosure,
   type ToolRendererContext,
   type ToolResult,
 } from "../../ui/tui/common.ts";
+import {
+  MAX_TUI_DISPLAY_ITEMS,
+  readToolDisplaySections,
+  truncateDisplayText,
+} from "../result/display.ts";
+import type { ToolDisplaySection } from "../result/types.ts";
+import type { GraphFileGroup } from "./details.ts";
 import type { CodeGraphToolParams, GraphRelation } from "./execute.ts";
+import { compactGraphLabel, formatGraphEvidence, formatGraphRange } from "./format.ts";
 
-/** Render the compact code_graph call header. */
+/** Render the compact call header from the requested selector. */
 export function renderGraphCall(
   args: unknown,
   theme: Theme,
@@ -30,84 +36,240 @@ export function renderGraphCall(
 ): Text {
   const params = (args ?? {}) as Partial<CodeGraphToolParams>;
   const relations: GraphRelation[] = Array.isArray(params.relations)
-    ? (params.relations as GraphRelation[])
+    ? params.relations
     : ["references"];
-  const relationLabel = formatRelations(relations);
-
-  let content = theme.fg("toolTitle", "code_graph");
-  if (relationLabel) content += ` ${theme.fg("accent", relationLabel)}`;
-
+  const label = formatRelations(relations);
   const target = formatTarget(params.target);
-  if (target) content += ` ${theme.fg("muted", target)}`;
-
-  return new Text(content, 0, 0);
+  return new Text(
+    theme.fg("toolTitle", "code_graph") +
+      (label ? ` ${theme.fg("accent", label)}` : "") +
+      (target ? ` ${theme.fg("muted", target)}` : ""),
+    0,
+    0,
+  );
 }
 
-/** Render code_graph progress, status, and structured result details. */
+/** Render one structured body, with no duplicate agent Markdown. */
 export function renderGraphResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
   context: ToolRendererContext | undefined,
-): Container | Text {
+): Component {
   if (options.isPartial) return renderPartial("Collecting relations…", theme);
-
-  const details =
-    result.details?.type === "search" ? (result.details.data as Record<string, unknown>) : null;
-  const executionError = renderExecutionError(context, "code_graph failed", theme);
+  const executionError = renderExecutionError(
+    result,
+    { isError: context?.isError, expanded: options.expanded, label: "code_graph failed" },
+    theme,
+  );
   if (executionError) return executionError;
+  const candidateSelection = renderCandidateSelection(result, options, theme, "graph.candidates");
+  if (candidateSelection) return candidateSelection;
   const domainError = renderDomainError(result, theme);
-  if (domainError) return renderDomainResult(result, options, theme, domainError);
+  if (domainError) return renderGraphDomainError(result, options.expanded, domainError, theme);
 
-  if (!options.expanded) {
-    const compact = buildSimpleCompact(details ?? undefined, theme);
-    const truncation = renderTruncationDisclosure(result, theme);
-    if (!truncation) return compact;
-    const container = new Container();
-    container.addChild(compact);
+  const data = asRecord(result.details?.data);
+  const container = new Container();
+  if (result.details?.type === "graph" && data) {
+    renderGraphBody(data, result, { container, expanded: options.expanded, theme });
+  } else {
+    // Older persisted results have only generic search details.
+    container.addChild(buildSimpleCompact(data ?? undefined, theme));
+    if (options.expanded)
+      renderToolDisplaySections(container, result.details?.displaySections, theme);
+  }
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (truncation) {
     container.addChild(new Spacer(1));
     container.addChild(truncation);
-    return container;
   }
+  return container;
+}
 
-  const container = new Container();
-  const header = buildSimpleHeader(details ?? undefined, theme);
-  if (header) container.addChild(header);
+interface SectionView {
+  rel: string;
+  label: string;
+  unavailable: boolean;
+  message: string | null;
+  externalCount: number;
+  scope: Record<string, unknown> | null;
+  fileGroups: GraphFileGroup[];
+}
 
-  const evidenceLists = details?.evidenceLists as EvidenceEntry[] | undefined;
-  if (evidenceLists && evidenceLists.length > 0) {
+function renderGraphBody(
+  data: Record<string, unknown>,
+  result: ToolResult,
+  options: { container: Container; expanded: boolean; theme: Theme },
+): void {
+  const { container, expanded, theme } = options;
+  const target =
+    typeof data.targetName === "string" ? compactGraphLabel(data.targetName) : "Target";
+  const file = typeof data.targetFile === "string" ? truncateDisplayText(data.targetFile) : "";
+  container.addChild(new Text(theme.fg("accent", `${target}${file ? ` — ${file}` : ""}`), 0, 0));
+  const evidence = readEvidenceEntries(data.evidenceLists);
+  const displays = readToolDisplaySections(result.details?.displaySections);
+  const sections = readSections(data.sections);
+  const summaries: string[] = [];
+  for (const section of sections) {
+    const display = displays.find((entry) => entry.key === `graph.${section.rel}`);
+    const metadata = evidence.find((entry) => entry.key.startsWith(`${section.rel}.`));
+    const summary = sectionSummary(section, metadata, display);
+    if (!expanded) {
+      summaries.push(summary);
+      continue;
+    }
     container.addChild(new Spacer(1));
-    renderEvidenceLines(container, evidenceLists, theme);
+    container.addChild(
+      new Text(theme.fg(section.unavailable ? "warning" : "accent", summary), 0, 0),
+    );
+    renderRelationBody(container, { section, display, targetName: data.targetName }, theme);
   }
+  if (!expanded)
+    container.addChild(
+      new Text(theme.fg("muted", summaries.join(" · ") || "No graph sections"), 0, 0),
+    );
+}
 
-  renderToolDisplaySections(container, result.details?.displaySections, theme);
-  renderStructuredDetailBody(container, details ?? undefined, theme);
-  const truncation = renderTruncationDisclosure(result, theme);
-  if (truncation) {
-    container.addChild(new Spacer(1));
-    container.addChild(truncation);
+function renderRelationBody(
+  container: Container,
+  input: { section: SectionView; display: ToolDisplaySection | undefined; targetName: unknown },
+  theme: Theme,
+): void {
+  const { section, display, targetName } = input;
+  if (section.unavailable) {
+    if (section.message)
+      container.addChild(new Text(theme.fg("warning", truncateDisplayText(section.message)), 0, 0));
+    return;
+  }
+  const scope = scopeLabel(section.scope, targetName);
+  if (scope) container.addChild(new Text(theme.fg("dim", scope), 0, 0));
+  const rows = display?.lines ?? [];
+  let index = 0;
+  const groups =
+    section.fileGroups.reduce((sum, group) => sum + group.count, 0) === rows.length
+      ? section.fileGroups
+      : [];
+  for (const group of groups) {
+    if (index >= rows.length) break;
+    container.addChild(new Text(theme.fg("dim", group.file), 0, 0));
+    for (const row of rows.slice(index, index + group.count))
+      container.addChild(new Text(theme.fg("muted", `  ${row}`), 0, 0));
+    index += group.count;
   }
-  renderMarkdownDetail(container, result, theme);
+  // Older results contain full paths in each row and have no file groups.
+  for (const row of rows.slice(index)) container.addChild(new Text(theme.fg("muted", row), 0, 0));
+}
+
+function renderGraphDomainError(
+  result: ToolResult,
+  expanded: boolean,
+  domainError: Text,
+  theme: Theme,
+): Container | Text {
+  if (!expanded) return domainError;
+  const container = new Container();
+  container.addChild(domainError);
+  const displays = readToolDisplaySections(result.details?.displaySections);
+  renderToolDisplaySections(container, displays, theme);
+  if (displays.length === 0) renderMarkdownDetail(container, result, theme);
   return container;
 }
 
+function sectionSummary(
+  section: SectionView,
+  metadata: EvidenceEntry | undefined,
+  display: ToolDisplaySection | undefined,
+): string {
+  if (section.unavailable) return `${section.label}: unavailable`;
+  if (!metadata) return `${section.label}: evidence unavailable`;
+  // The display has its own bounded row count; the underlying evidence total is unchanged.
+  const shown = display
+    ? { ...metadata, shownCount: display.shownCount, omittedCount: display.omittedCount }
+    : metadata;
+  return `${section.label}: ${formatGraphEvidence(shown, section.rel === "callees" ? "call sites" : "locations", section.externalCount)}`;
+}
+
+function readSections(value: unknown): SectionView[] {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 3).flatMap((item) => {
+    const section = asRecord(item);
+    if (
+      !section ||
+      typeof section.rel !== "string" ||
+      !["references", "callees", "implements"].includes(section.rel) ||
+      (section.source !== "structural" && section.source !== "semantic")
+    )
+      return [];
+    const rel = section.rel;
+    const source = section.source;
+    const depth =
+      rel === "callees" && (section.depth === "direct" || section.depth === "deep")
+        ? `, ${section.depth}`
+        : "";
+    return [
+      {
+        rel,
+        label: `${rel} (${source}${depth})`,
+        unavailable: section.status === "unavailable",
+        message: typeof section.message === "string" ? section.message : null,
+        externalCount: typeof section.externalCount === "number" ? section.externalCount : 0,
+        scope: asRecord(section.enclosingScope),
+        fileGroups: readFileGroups(section.fileGroups),
+      },
+    ];
+  });
+}
+
+function readFileGroups(value: unknown): GraphFileGroup[] {
+  if (!Array.isArray(value)) return [];
+  const groups: GraphFileGroup[] = [];
+  for (const entry of value.slice(0, MAX_TUI_DISPLAY_ITEMS)) {
+    const group = asRecord(entry);
+    if (
+      !group ||
+      typeof group.file !== "string" ||
+      typeof group.count !== "number" ||
+      !Number.isInteger(group.count) ||
+      group.count < 1 ||
+      group.count > MAX_TUI_DISPLAY_ITEMS
+    )
+      return [];
+    groups.push({ file: truncateDisplayText(group.file), count: group.count });
+  }
+  return groups;
+}
+
+function scopeLabel(scope: Record<string, unknown> | null, targetName: unknown): string | null {
+  if (!scope || typeof scope.startLine !== "number" || typeof scope.endLine !== "number")
+    return null;
+  const name =
+    typeof scope.name === "string" && scope.name !== targetName
+      ? `${compactGraphLabel(scope.name)} — `
+      : "";
+  const range = formatGraphRange({ startLine: scope.startLine, endLine: scope.endLine });
+  return `Scope: ${name}${range}; source expressions, not resolved symbols`;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
 function formatRelations(relations: readonly GraphRelation[]): string {
-  if (relations.length === 0) return "";
-  if (relations.length === 1) return `→ ${relations[0]}`;
-  if (relations.length <= 3) return `→ ${relations.join(", ")}`;
-  return `→ ${relations.slice(0, 2).join(", ")} +${relations.length - 2}`;
+  return relations.length ? `→ ${relations.slice(0, 3).join(", ")}` : "";
 }
 
 function formatTarget(target: unknown): string {
-  if (!target || typeof target !== "object") return "";
-  const record = target as Record<string, unknown>;
-
-  if (record.symbol && typeof record.symbol === "object") {
-    const query = formatCallValue((record.symbol as Record<string, unknown>).query);
+  const record = asRecord(target);
+  if (!record) return "";
+  const symbol = asRecord(record.symbol);
+  if (symbol) {
+    const query = formatCallValue(symbol.query);
     return query ? `of ${query}` : "";
   }
-  if (record.anchor && typeof record.anchor === "object") {
-    const anchor = record.anchor as Record<string, unknown>;
+  const anchor = asRecord(record.anchor);
+  if (anchor) {
     const file = formatCallPath(anchor.file);
     const line = typeof anchor.line === "number" ? `:${anchor.line}` : "";
     return file ? `at ${file}${line}` : "";