@slicedearth/whoisleuth-cli 1.36.1 → 1.43.0

package/frontend/src/lib/analysis/visualization-force-graph.js

@@ -0,0 +1,352 @@
+import { forceCenter, forceCollide, forceLink, forceManyBody, forceSimulation, forceX, forceY, } from 'd3-force';
+import { boundedVisualizationId as boundedId, boundedVisualizationText as boundedText, } from "./visualization-bounds.js";
+export const MAX_FORCE_GRAPH_NODES = 48;
+export const MAX_FORCE_GRAPH_LINKS = 80;
+export const FORCE_GRAPH_LINK_KINDS = [
+    'observed',
+    'partial',
+    'unknown',
+    'derived',
+    'summary',
+];
+function forceGraphLinkKind(value) {
+    const normalized = boundedId(value);
+    if (!normalized)
+        return 'observed';
+    return FORCE_GRAPH_LINK_KINDS.includes(normalized)
+        ? normalized
+        : 'unknown';
+}
+const FORCE_GRAPH_GROUPS = {
+    address: { id: 'network', label: 'Network' },
+    certificate: { id: 'certificate', label: 'Certificates' },
+    domain: { id: 'hosts', label: 'Domains and hosts' },
+    hostname: { id: 'hosts', label: 'Domains and hosts' },
+    identity: { id: 'identity', label: 'Identity' },
+    issuer: { id: 'certificate', label: 'Certificates' },
+    key: { id: 'certificate', label: 'Certificates' },
+    network: { id: 'network', label: 'Network' },
+    observation: { id: 'observations', label: 'Source observations' },
+    origin: { id: 'identity', label: 'Identity' },
+    prefix: { id: 'network', label: 'Network' },
+    registrar: { id: 'registration', label: 'Registration' },
+    relationship: { id: 'relationships', label: 'Shared evidence' },
+    service: { id: 'services', label: 'Services' },
+    summary: { id: 'summary', label: 'Grouped evidence' },
+    target: { id: 'focus', label: 'Lookup target' },
+    technology: { id: 'technology', label: 'Technology' },
+    tracker: { id: 'identity', label: 'Identity' },
+};
+const FORCE_GRAPH_CLUSTER_INDEX = {
+    certificate: 0,
+    hosts: 1,
+    identity: 2,
+    network: 3,
+    observations: 4,
+    registration: 5,
+    relationships: 6,
+    services: 7,
+    summary: 6,
+    technology: 7,
+};
+function forceGraphClusterIndex(group) {
+    const assigned = FORCE_GRAPH_CLUSTER_INDEX[group];
+    if (assigned !== undefined)
+        return assigned;
+    let hash = 0;
+    for (const [index, character] of [...group].entries()) {
+        hash = (hash + (character.codePointAt(0) ?? 0) * (index + 1)) % 8;
+    }
+    return hash;
+}
+function forceGraphGroup(kind, rawGroup, rawGroupLabel) {
+    const requested = boundedId(rawGroup);
+    const requestedLabel = boundedText(rawGroupLabel, 40);
+    if (requested) {
+        return {
+            id: requested,
+            label: requestedLabel || requested.replaceAll('-', ' ').replace(/\b\w/gu, (character) => character.toUpperCase()),
+        };
+    }
+    return FORCE_GRAPH_GROUPS[kind] ?? {
+        id: kind || 'evidence',
+        label: (kind || 'evidence').replaceAll('-', ' ').replace(/\b\w/gu, (character) => character.toUpperCase()),
+    };
+}
+function wrapForceGraphLabel(value, maximumLineLength = 20) {
+    const lines = [];
+    for (const word of value.split(/\s+/u).filter(Boolean)) {
+        const pieces = [];
+        let remaining = word;
+        while (remaining.length > maximumLineLength) {
+            let splitAt = maximumLineLength;
+            for (let index = maximumLineLength; index >= Math.floor(maximumLineLength * 0.55); index -= 1) {
+                if (/[./:_-]/u.test(remaining[index - 1] ?? '')) {
+                    splitAt = index;
+                    break;
+                }
+            }
+            pieces.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt);
+        }
+        if (remaining)
+            pieces.push(remaining);
+        for (const [pieceIndex, piece] of pieces.entries()) {
+            const current = lines.at(-1);
+            if (pieceIndex === 0 && current && current.length + piece.length + 1 <= maximumLineLength) {
+                lines[lines.length - 1] = `${current} ${piece}`;
+            }
+            else {
+                lines.push(piece);
+            }
+        }
+    }
+    return lines.length ? lines : [value];
+}
+function forceGraphClusterCenters(groups, width, height, hasFocus) {
+    const centerX = width / 2;
+    const centerY = height / 2;
+    const centers = new Map();
+    if (!groups.length)
+        return centers;
+    if (!hasFocus && groups.length === 1) {
+        centers.set(groups[0] ?? '', { x: centerX, y: centerY });
+        return centers;
+    }
+    if (!hasFocus && groups.length === 2) {
+        centers.set(groups[0] ?? '', { x: width * 0.29, y: centerY });
+        centers.set(groups[1] ?? '', { x: width * 0.71, y: centerY });
+        return centers;
+    }
+    if (hasFocus && groups.length === 1) {
+        centers.set(groups[0] ?? '', { x: width * 0.72, y: centerY });
+        return centers;
+    }
+    if (hasFocus && groups.length === 2) {
+        centers.set(groups[0] ?? '', { x: width * 0.25, y: centerY });
+        centers.set(groups[1] ?? '', { x: width * 0.75, y: centerY });
+        return centers;
+    }
+    const radiusX = hasFocus ? width * 0.33 : width * 0.27;
+    const radiusY = hasFocus ? Math.max(150, height * 0.36) : Math.max(125, height * 0.3);
+    for (const [index, group] of groups.entries()) {
+        const angle = -Math.PI / 2 + index * Math.PI * 2 / groups.length;
+        centers.set(group, {
+            x: centerX + Math.cos(angle) * radiusX,
+            y: centerY + Math.sin(angle) * radiusY,
+        });
+    }
+    return centers;
+}
+function forceGraphNodeBounds(node) {
+    if (node.kind === 'target') {
+        const halfWidth = (node.labelWidth + 20) / 2;
+        const halfHeight = (node.labelLines.length * 13 + 17) / 2;
+        return { halfWidth, above: halfHeight, below: halfHeight };
+    }
+    return {
+        halfWidth: Math.max(20, node.labelWidth / 2),
+        above: 22,
+        below: 33 + node.labelLines.length * 13,
+    };
+}
+function resolveForceGraphLabelCollisions(nodes, width, height, focusNodeId) {
+    const margin = 7;
+    for (let iteration = 0; iteration < 120; iteration += 1) {
+        let moved = false;
+        for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
+            const left = nodes[leftIndex];
+            if (!left)
+                continue;
+            const leftBounds = forceGraphNodeBounds(left);
+            for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
+                const right = nodes[rightIndex];
+                if (!right)
+                    continue;
+                const rightBounds = forceGraphNodeBounds(right);
+                const overlapX = leftBounds.halfWidth + rightBounds.halfWidth + margin - Math.abs(left.x - right.x);
+                const overlapY = Math.min(left.y + leftBounds.below, right.y + rightBounds.below) - Math.max(left.y - leftBounds.above, right.y - rightBounds.above) + margin;
+                if (overlapX <= 0 || overlapY <= 0)
+                    continue;
+                moved = true;
+                const leftFixed = left.id === focusNodeId;
+                const rightFixed = right.id === focusNodeId;
+                if (overlapX / (leftBounds.halfWidth + rightBounds.halfWidth) < overlapY / Math.max(leftBounds.above + leftBounds.below, rightBounds.above + rightBounds.below)) {
+                    const direction = left.x <= right.x ? -1 : 1;
+                    const shift = overlapX / (leftFixed || rightFixed ? 1 : 2) + 0.5;
+                    if (!leftFixed)
+                        left.x += direction * shift;
+                    if (!rightFixed)
+                        right.x -= direction * shift;
+                }
+                else {
+                    const direction = left.y <= right.y ? -1 : 1;
+                    const shift = overlapY / (leftFixed || rightFixed ? 1 : 2) + 0.5;
+                    if (!leftFixed)
+                        left.y += direction * shift;
+                    if (!rightFixed)
+                        right.y -= direction * shift;
+                }
+            }
+        }
+        for (const node of nodes) {
+            const bounds = forceGraphNodeBounds(node);
+            node.x = Math.max(bounds.halfWidth + margin, Math.min(width - bounds.halfWidth - margin, node.x));
+            node.y = Math.max(bounds.above + margin, Math.min(height - bounds.below - margin, node.y));
+        }
+        if (!moved)
+            break;
+    }
+}
+export function projectBoundedForceGraph(rawNodes, rawLinks, options = {}) {
+    const rawNodeCount = Array.isArray(rawNodes) ? rawNodes.length : 0;
+    const rawLinkCount = Array.isArray(rawLinks) ? rawLinks.length : 0;
+    const seen = new Set();
+    const candidates = (Array.isArray(rawNodes) ? rawNodes : [])
+        .slice(0, MAX_FORCE_GRAPH_NODES * 2)
+        .map((node) => {
+        const id = boundedText(node?.id, 80);
+        const label = boundedText(node?.label, 64);
+        if (!id || !label || seen.has(id))
+            return null;
+        seen.add(id);
+        const kind = boundedId(node?.kind) || 'evidence';
+        const group = forceGraphGroup(kind, node?.group, node?.groupLabel);
+        const labelLines = wrapForceGraphLabel(label);
+        const labelWidth = Math.max(54, Math.min(142, Math.max(...labelLines.map((line) => line.length)) * 6.2 + 16));
+        return {
+            id,
+            label,
+            labelLines,
+            labelWidth,
+            kind,
+            detail: boundedText(node?.detail, 100),
+            group: group.id,
+            groupLabel: group.label,
+            clusterIndex: 0,
+            collisionRadius: Math.max(38, labelWidth / 2 + 8, 30 + labelLines.length * 6),
+            x: 0,
+            y: 0,
+        };
+    })
+        .filter((node) => Boolean(node))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const nodes = candidates.slice(0, MAX_FORCE_GRAPH_NODES);
+    const nodeIds = new Set(nodes.map((node) => node.id));
+    const seenLinks = new Set();
+    const links = (Array.isArray(rawLinks) ? rawLinks : [])
+        .slice(0, MAX_FORCE_GRAPH_LINKS * 2)
+        .map((link, index) => ({
+        id: boundedText(link?.id, 80) || `link-${index}`,
+        source: boundedText(link?.source, 80),
+        target: boundedText(link?.target, 80),
+        kind: forceGraphLinkKind(link?.kind),
+        detail: boundedText(link?.detail, 100),
+    }))
+        .filter((link) => {
+        if (link.source === link.target
+            || !nodeIds.has(link.source)
+            || !nodeIds.has(link.target)
+            || seenLinks.has(link.id)) {
+            return false;
+        }
+        seenLinks.add(link.id);
+        return true;
+    })
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .slice(0, MAX_FORCE_GRAPH_LINKS);
+    const requestedFocusId = boundedText(options.focusNodeId, 80);
+    const focusNode = nodes.find((node) => node.id === requestedFocusId)
+        ?? nodes.find((node) => node.kind === 'target');
+    const groupLabels = new Map();
+    for (const node of nodes) {
+        if (node.id !== focusNode?.id && !groupLabels.has(node.group))
+            groupLabels.set(node.group, node.groupLabel);
+    }
+    const groupIds = [...groupLabels.keys()].sort((left, right) => {
+        const leftLabel = groupLabels.get(left) ?? left;
+        const rightLabel = groupLabels.get(right) ?? right;
+        return leftLabel.localeCompare(rightLabel) || left.localeCompare(right);
+    });
+    const height = Math.max(500, Math.min(700, 450 + Math.max(0, nodes.length - 14) * 16));
+    const width = 900;
+    const centerX = width / 2;
+    const centerY = height / 2;
+    const clusterCenters = forceGraphClusterCenters(groupIds, width, height, Boolean(focusNode));
+    const clusterIndex = new Map(groupIds.map((group) => [group, forceGraphClusterIndex(group)]));
+    for (const node of nodes)
+        node.clusterIndex = clusterIndex.get(node.group) ?? 0;
+    if (nodes.length) {
+        if (focusNode) {
+            focusNode.fx = centerX;
+            focusNode.fy = centerY;
+        }
+        const simulation = forceSimulation(nodes)
+            .force('link', forceLink(links)
+            .id((node) => node.id)
+            .distance((link) => link.kind === 'derived' ? 145 : 125)
+            .strength(0.22))
+            .force('charge', forceManyBody().strength(-330))
+            .force('center', forceCenter(centerX, centerY))
+            .force('cluster-x', forceX((node) => node.id === focusNode?.id ? centerX : clusterCenters.get(node.group)?.x ?? centerX).strength(0.3))
+            .force('cluster-y', forceY((node) => node.id === focusNode?.id ? centerY : clusterCenters.get(node.group)?.y ?? centerY).strength(0.3))
+            .force('collide', forceCollide()
+            .radius((node) => node.kind === 'target' ? Math.max(66, node.collisionRadius) : node.collisionRadius)
+            .strength(1)
+            .iterations(5))
+            .stop();
+        simulation.tick(360);
+        for (const node of nodes) {
+            const horizontalInset = Math.max(38, Math.min(82, node.collisionRadius));
+            const topInset = node.kind === 'target' ? 28 : 34;
+            const bottomInset = Math.max(52, 34 + node.labelLines.length * 13);
+            node.x = Math.max(horizontalInset, Math.min(width - horizontalInset, Number(node.x) || centerX));
+            node.y = Math.max(topInset, Math.min(height - bottomInset, Number(node.y) || centerY));
+        }
+        resolveForceGraphLabelCollisions(nodes, width, height, focusNode?.id);
+    }
+    const projectedLinks = links.flatMap((link) => {
+        const source = typeof link.source === 'string' ? nodes.find((node) => node.id === link.source) : link.source;
+        const target = typeof link.target === 'string' ? nodes.find((node) => node.id === link.target) : link.target;
+        return source && target ? [{
+                id: link.id,
+                sourceId: source.id,
+                targetId: target.id,
+                sourceX: source.x,
+                sourceY: source.y,
+                targetX: target.x,
+                targetY: target.y,
+                kind: link.kind,
+                detail: link.detail,
+            }] : [];
+    });
+    const omittedNodeInputs = Math.max(0, rawNodeCount - nodes.length);
+    const omittedLinkInputs = Math.max(0, rawLinkCount - projectedLinks.length);
+    return {
+        width,
+        height,
+        nodes: nodes.map(({ id, label, labelLines, labelWidth, kind, detail, group, groupLabel, clusterIndex, x, y }) => ({
+            id,
+            label,
+            labelLines,
+            labelWidth,
+            kind,
+            detail,
+            group,
+            groupLabel,
+            clusterIndex,
+            x,
+            y,
+        })),
+        links: projectedLinks,
+        clusters: groupIds.map((group) => ({
+            id: group,
+            label: groupLabels.get(group) ?? group,
+            count: nodes.filter((node) => node.id !== focusNode?.id && node.group === group).length,
+            index: clusterIndex.get(group) ?? 0,
+        })),
+        omittedNodeInputs,
+        omittedLinkInputs,
+        truncated: omittedNodeInputs > 0 || omittedLinkInputs > 0,
+    };
+}

package/frontend/src/lib/analysis/visualization-matrix.js

@@ -0,0 +1,88 @@
+import { scaleBand } from 'd3-scale';
+import { boundedVisualizationId as boundedId, boundedVisualizationText as boundedText, } from "./visualization-bounds.js";
+export const MAX_VISUAL_MATRIX_ROWS = 24;
+export const MAX_VISUAL_MATRIX_COLUMNS = 6;
+function normalizedMatrixState(value) {
+    const state = boundedText(value, 30).toLowerCase();
+    if (state === 'equal' || state === 'equivalent' || state === 'same')
+        return 'equal';
+    if (state === 'different')
+        return 'different';
+    if (state === 'conflict' || state === 'conflicting')
+        return 'conflict';
+    if (state === 'observed' || state === 'complete' || state === 'success')
+        return 'observed';
+    if (state === 'partial' || state === 'inconclusive' || state === 'rate_limited' || state === 'missing')
+        return 'partial';
+    if (state === 'unavailable' || state === 'error' || state === 'failed')
+        return 'unavailable';
+    if (state === 'not_collected' || state === 'skipped' || state === 'disabled' || state === 'not_recorded') {
+        return 'not_collected';
+    }
+    return 'unknown';
+}
+export function projectEvidenceMatrix(rawColumns, rawRows) {
+    const columns = [...new Set((Array.isArray(rawColumns) ? rawColumns : [])
+            .map((column) => boundedText(column, 40))
+            .filter(Boolean))]
+        .slice(0, MAX_VISUAL_MATRIX_COLUMNS);
+    const columnSet = new Set(columns);
+    const seenRows = new Set();
+    const candidates = (Array.isArray(rawRows) ? rawRows : [])
+        .map((row, index) => {
+        const id = boundedId(row?.id) || `row-${index}`;
+        const label = boundedText(row?.label, 56);
+        if (!label || seenRows.has(id))
+            return null;
+        seenRows.add(id);
+        const rowCells = (Array.isArray(row.cells) ? row.cells : []);
+        const byColumn = new Map(rowCells
+            .map((cell) => {
+            const column = boundedText(cell?.column, 40);
+            return [column, {
+                    state: normalizedMatrixState(cell?.state),
+                    detail: boundedText(cell?.detail, 120),
+                }];
+        })
+            .filter(([column]) => columnSet.has(column)));
+        return {
+            id,
+            label,
+            cells: columns.map((column) => ({
+                column,
+                state: byColumn.get(column)?.state ?? 'not_collected',
+                detail: byColumn.get(column)?.detail ?? '',
+            })),
+        };
+    })
+        .filter((row) => Boolean(row));
+    const rows = candidates.slice(0, MAX_VISUAL_MATRIX_ROWS);
+    const width = 900;
+    const top = 54;
+    const left = 210;
+    const rowHeight = 30;
+    const x = scaleBand().domain(columns).range([left, 870]).padding(0.12);
+    const y = scaleBand().domain(rows.map((row) => row.id))
+        .range([top, top + Math.max(1, rows.length) * rowHeight])
+        .padding(0.12);
+    return {
+        width,
+        height: Math.max(104, top + rows.length * rowHeight + 22),
+        columns: columns.map((column) => ({
+            label: column,
+            x: x(column) ?? left,
+            width: x.bandwidth(),
+        })),
+        rows: rows.map((row) => ({
+            ...row,
+            y: y(row.id) ?? top,
+            height: y.bandwidth(),
+            cells: row.cells.map((cell) => ({
+                ...cell,
+                x: x(cell.column) ?? left,
+                width: x.bandwidth(),
+            })),
+        })),
+        truncated: candidates.length > rows.length || rawColumns.length > columns.length,
+    };
+}