Function formatNodeTree

src/context/formatter.ts:166–232

* Format a single node and its relationships

(
  node: Node,
  subgraph: Subgraph,
  outgoing: Map<string, Edge[]>,
  printed: Set<string>,
  lines: string[],
  depth: number,
  prefix: string
)

 * Format a single node and its relationships
 */
function formatNodeTree(
  node: Node,
  subgraph: Subgraph,
  outgoing: Map<string, Edge[]>,
  printed: Set<string>,
  lines: string[],
  depth: number,
  prefix: string
): void {
  if (printed.has(node.id)) {
    return;
  }
  printed.add(node.id);

  // Node header
  const location = node.startLine ? `:${node.startLine}` : '';
  const signature = node.signature ? ` - ${truncate(node.signature, 50)}` : '';
  lines.push(`${prefix}${node.kind}: ${node.name} (${node.filePath}${location})${signature}`);

  // Outgoing edges
  const edges = outgoing.get(node.id) ?? [];
  const significantEdges = edges.filter((e) =>
    ['calls', 'extends', 'implements', 'imports', 'references'].includes(e.kind)
  );

  // Group by kind
  const edgesByKind = new Map<string, Edge[]>();
  for (const edge of significantEdges) {
    const existing = edgesByKind.get(edge.kind) ?? [];
    existing.push(edge);
    edgesByKind.set(edge.kind, existing);
  }

  // Print edges grouped by kind
  const newPrefix = prefix + '  ';
  for (const [kind, kindEdges] of edgesByKind) {
    if (kindEdges.length > 3) {
      // Summarize if too many
      const names = kindEdges
        .slice(0, 3)
        .map((e) => {
          const target = subgraph.nodes.get(e.target);
          return target?.name ?? 'unknown';
        })
        .join(', ');
      lines.push(`${newPrefix}├── ${kind}: ${names} and ${kindEdges.length - 3} more`);
    } else {
      for (let i = 0; i < kindEdges.length; i++) {
        const edge = kindEdges[i]!;
        const target = subgraph.nodes.get(edge.target);
        const targetName = target?.name ?? 'unknown';
        const connector = i === kindEdges.length - 1 ? '└──' : '├──';
        lines.push(`${newPrefix}${connector} ${kind} → ${targetName}`);
      }
    }
  }

  // Recurse for directly connected nodes (limited depth)