Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
import type { ContainerTopology } from './container-topology';
import type { SemanticGraph } from './semantic-graph';
import { SCENE_PALETTE } from './scene-palette';
/** Condense cycles before layering. Direction describes callers, not data movement. */
export function layoutContainers(topology: ContainerTopology): { graph: SemanticGraph; cycles: string[][] } {
const services = [...topology.services].sort((a, b) => a.id.localeCompare(b.id));
const ids = new Set(services.map(service => service.id));
const adjacent = new Map(services.map(service => [service.id, new Set<string>()]));
for (const edge of topology.connections) if (edge.kind !== 'startup' && ids.has(edge.source) && ids.has(edge.target)) adjacent.get(edge.source)!.add(edge.target);
const numbers = new Map<string, number>(), low = new Map<string, number>();
const stack: string[] = [], active = new Set<string>(), groups: string[][] = [];
const visit = (id: string) => {
numbers.set(id, numbers.size); low.set(id, numbers.get(id)!); stack.push(id); active.add(id);
for (const target of [...adjacent.get(id)!].sort()) {
if (!numbers.has(target)) { visit(target); low.set(id, Math.min(low.get(id)!, low.get(target)!)); }
else if (active.has(target)) low.set(id, Math.min(low.get(id)!, numbers.get(target)!));
}
if (low.get(id) === numbers.get(id)) {
const group: string[] = []; let next: string;
do { next = stack.pop()!; active.delete(next); group.push(next); } while (next !== id);
groups.push(group.sort());
}
};
services.forEach(service => { if (!numbers.has(service.id)) visit(service.id); });
const membership = new Map(groups.flatMap((group, index) => group.map(id => [id, index] as const)));
const outgoing = groups.map(() => new Set<number>()), incoming = groups.map(() => 0), layers = groups.map(() => 0);
for (const [source, targets] of adjacent) for (const target of targets) {
const a = membership.get(source)!, b = membership.get(target)!;
if (a !== b && !outgoing[a].has(b)) { outgoing[a].add(b); incoming[b]++; }
}
const queue = incoming.flatMap((count, index) => count ? [] : [index]);
for (let index = 0; index < queue.length; index++) for (const next of outgoing[queue[index]]) {
layers[next] = Math.max(layers[next], layers[queue[index]] + 1);
if (--incoming[next] === 0) queue.push(next);
}
const rows = new Map<number, typeof services>();
services.forEach(service => { const layer = layers[membership.get(service.id)!]; rows.set(layer, [...(rows.get(layer) ?? []), service]); });
const positions = new Map<string, [number, number, number]>();
let offsetX = 0;
for (const [, row] of [...rows].sort(([a], [b]) => a - b)) {
const columns = Math.ceil(Math.sqrt(row.length)), rowCount = Math.ceil(row.length / columns);
// Pack peers in two dimensions, reserving the whole region before the next
// layer so every dependency between condensed cycles still points right.
row.forEach((service, index) => positions.set(service.id, [offsetX + (index % columns) * 28, 0,
(Math.floor(index / columns) - (rowCount - 1) / 2) * 28]));
offsetX += (columns - 1) * 28 + 34;
}
const graph: SemanticGraph = {
view: 'routes', scopeKey: services.map(service => service.id).join('|'), title: 'Container service map',
positionMeaning: 'Squares represent declared services. Dependency layers advance left to right; peers and cycles share compact regions.',
nodes: services.map(service => ({ id: service.id, kind: 'area', label: service.name,
detail: `${service.project} · ${service.image ?? 'built from source'}`, position: positions.get(service.id)!,
count: service.sourcePaths.length, members: [], footprint: [18, 18],
tint: service.sourcePaths.length ? SCENE_PALETTE.serviceSource : SCENE_PALETTE.serviceImage, kindLabel: 'Declared service' })),
edges: [...topology.connections].sort((a, b) => a.id.localeCompare(b.id)).map(edge => {
const type = edge.kind === 'startup' ? 'STARTUP_DEPENDENCY' : edge.kind === 'configuration' ? 'CONFIGURES'
: /redis|postgres|mysql|database|sql/i.test(edge.protocol) ? 'SERVICE_CALLS'
: /grpc/i.test(edge.protocol) ? 'GRPC_CALLS' : /http/i.test(edge.protocol) ? 'HTTP_CALLS' : 'SERVICE_CALLS';
// A plain service link is the line of this map: the green of the scheme, as in the "Calls" key.
return { id: edge.id, source: edge.source, target: edge.target, type, count: edge.evidence.length, evidence: [],
...(type === 'SERVICE_CALLS' ? { tint: SCENE_PALETTE.call } : {}) };
}),
totalNodes: services.length, totalEdges: topology.connections.length, omittedNodes: 0, omittedEdges: 0, warnings: [],
};
return { graph, cycles: groups.filter(group => group.length > 1 || adjacent.get(group[0])!.has(group[0])) };
}