@psnext/lscg 0.1.1

package/dist/src/view/model.d.ts

@@ -0,0 +1,64 @@
+import type { GraphEdgeRow, GraphNodeRow, RepositoryRecord, StorageScope } from '../types.js';
+import { type GraphLike, type LayoutBounds } from './layout.js';
+export interface ViewSnapshot {
+    repository: RepositoryRecord;
+    scope: StorageScope;
+    nodes: ViewNode[];
+    edges: ViewEdge[];
+}
+export interface ViewNode extends GraphNodeRow {
+    label: string;
+    degree: number;
+    x: number;
+    y: number;
+}
+export interface ViewEdge extends GraphEdgeRow {
+}
+export interface ViewBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ViewNeighborhood {
+    nodeIds: string[];
+    edgeIds: string[];
+}
+export interface ViewModel extends ViewSnapshot {
+    graph: GraphLike;
+    fullNodes: ViewNode[];
+    fullEdges: ViewEdge[];
+    fullVisibleNodeIds: string[];
+    fullVisibleEdgeIds: string[];
+    fullNeighborhoods: Record<string, ViewNeighborhood>;
+    fullInitialViewBox: ViewBox;
+    search: string | null;
+    initialVisibleNodeIds: string[];
+    initialVisibleEdgeIds: string[];
+    anchorNodeId: string | null;
+    initialHighlightedNodeIds: string[];
+    initialHighlightedEdgeIds: string[];
+    neighborhoods: Record<string, ViewNeighborhood>;
+    initialViewBox: ViewBox;
+    graphBounds: LayoutBounds;
+    startWithFullGraph: boolean;
+}
+export interface ViewModelOptions {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    anchor?: string | undefined;
+    search?: string | undefined;
+}
+export declare function loadViewSnapshot({ root, scope }?: ViewModelOptions): ViewSnapshot;
+export declare function buildViewModel(snapshot: ViewSnapshot, { anchor, search }?: ViewModelOptions): ViewModel;
+export declare function normalizeViewScope(scope: StorageScope | 'both' | undefined): StorageScope;
+export declare function filterNodeNames(nodes: ViewNode[], search: string | undefined): ViewNode[];
+export declare function selectAnchorNodeId({ nodes, search, anchor }: {
+    nodes: ViewNode[];
+    search: string | null;
+    anchor: string | undefined;
+}): string | null;
+export declare function selectVisibleNodeIds(nodes: ViewNode[], search: string | null): string[];
+export declare function selectVisibleEdgeIds(edges: ViewEdge[], visibleNodeIds: Set<string>): string[];
+export declare function computeInitialViewBox(nodes: ViewNode[], visibleNodeIds: string[], anchorNodeId: string | null): ViewBox;
+//# sourceMappingURL=model.d.ts.map

package/dist/src/view/model.js

@@ -0,0 +1,396 @@
+import Graphology from 'graphology';
+import { existsSync } from 'node:fs';
+import { databasePathForScope } from '../config/paths.js';
+import { closeDatabase, openReadOnlyGraphDatabase, selectAllEdges, selectAllNodes } from '../storage/database.js';
+import { repositoryForRoot } from '../graph/repository.js';
+import { assignDeterministicLayout } from './layout.js';
+export function loadViewSnapshot({ root = process.cwd(), scope = 'repo' } = {}) {
+    const repository = repositoryForRoot(root);
+    const storageScope = normalizeViewScope(scope);
+    const databasePath = databasePathForScope(storageScope, repository.root);
+    if (!existsSync(databasePath)) {
+        return {
+            repository,
+            scope: storageScope,
+            nodes: [],
+            edges: []
+        };
+    }
+    const db = openReadOnlyGraphDatabase(databasePath);
+    try {
+        const nodes = selectAllNodes(db, repository.id);
+        const edges = selectAllEdges(db, repository.id);
+        return {
+            repository,
+            scope: storageScope,
+            nodes: decorateNodes(nodes, edges),
+            edges: [...edges]
+        };
+    }
+    finally {
+        closeDatabase(db);
+    }
+}
+export function buildViewModel(snapshot, { anchor, search } = {}) {
+    const normalizedGraph = collapseEquivalentNodesAndEdges(snapshot.nodes, snapshot.edges);
+    const normalizedSearch = normalizeSearch(search);
+    const explicitAnchor = normalizeSearch(anchor);
+    const startWithFullGraph = !explicitAnchor;
+    const anchorNodeId = selectAnchorNodeId({
+        nodes: normalizedGraph.nodes,
+        search: normalizedSearch,
+        anchor
+    });
+    const graph = buildGraph(normalizedGraph.nodes, normalizedGraph.edges);
+    const graphBounds = assignDeterministicLayout(graph);
+    const fullNodes = normalizedGraph.nodes.map((node) => {
+        const attributes = graph.getNodeAttributes(node.id);
+        return {
+            ...node,
+            x: Number(attributes.x ?? 0),
+            y: Number(attributes.y ?? 0)
+        };
+    });
+    const fullEdges = [...normalizedGraph.edges];
+    const fullVisibleNodeIds = fullNodes.map((node) => node.id);
+    const fullVisibleEdgeIds = fullEdges.map((edge) => edge.id);
+    const fullNeighborhoods = buildNeighborhoods(fullNodes, fullEdges);
+    const visibleNodeIds = startWithFullGraph
+        ? fullVisibleNodeIds
+        : selectVisibleNodeIds(fullNodes, normalizedSearch);
+    const visibleEdgeIds = startWithFullGraph
+        ? fullVisibleEdgeIds
+        : selectVisibleEdgeIds(fullEdges, new Set(visibleNodeIds));
+    const highlighted = anchorNodeId ? fullNeighborhoods[anchorNodeId] : { nodeIds: [], edgeIds: [] };
+    const initialHighlightedNodeIds = highlighted?.nodeIds ?? [];
+    const initialHighlightedEdgeIds = highlighted?.edgeIds ?? [];
+    const initialViewBox = computeInitialViewBox(fullNodes, visibleNodeIds, startWithFullGraph ? null : anchorNodeId);
+    const fullInitialViewBox = computeInitialViewBox(fullNodes, fullVisibleNodeIds, null);
+    return {
+        ...snapshot,
+        nodes: fullNodes,
+        edges: fullEdges,
+        graph,
+        fullNodes,
+        fullEdges,
+        fullVisibleNodeIds,
+        fullVisibleEdgeIds,
+        fullNeighborhoods,
+        fullInitialViewBox,
+        search: normalizedSearch,
+        initialVisibleNodeIds: visibleNodeIds,
+        initialVisibleEdgeIds: visibleEdgeIds,
+        anchorNodeId: startWithFullGraph ? null : anchorNodeId,
+        initialHighlightedNodeIds,
+        initialHighlightedEdgeIds,
+        neighborhoods: fullNeighborhoods,
+        initialViewBox,
+        graphBounds,
+        startWithFullGraph
+    };
+}
+export function normalizeViewScope(scope) {
+    if (scope === 'repo' || scope === 'home')
+        return scope;
+    if (scope === 'both') {
+        throw new Error('view supports repo or home scope only');
+    }
+    return 'repo';
+}
+export function filterNodeNames(nodes, search) {
+    const normalizedSearch = normalizeSearch(search);
+    if (!normalizedSearch)
+        return [...nodes];
+    return nodes.filter((node) => nodeMatchesSearch(node, normalizedSearch));
+}
+export function selectAnchorNodeId({ nodes, search, anchor }) {
+    if (nodes.length === 0)
+        return null;
+    const anchorTarget = normalizeSearch(anchor);
+    if (!anchorTarget) {
+        return null;
+    }
+    const visibleNodes = search ? nodes.filter((node) => nodeMatchesSearch(node, search)) : nodes;
+    const rankingSource = visibleNodes.length > 0 ? visibleNodes : nodes;
+    const exactMatches = rankingSource.filter((node) => node.label.toLowerCase() === anchorTarget);
+    if (exactMatches.length > 0) {
+        return highestDegreeNode(exactMatches)?.id ?? null;
+    }
+    return highestDegreeNode(rankingSource)?.id ?? null;
+}
+export function selectVisibleNodeIds(nodes, search) {
+    if (!search)
+        return nodes.map((node) => node.id);
+    return nodes.filter((node) => nodeMatchesSearch(node, search)).map((node) => node.id);
+}
+export function selectVisibleEdgeIds(edges, visibleNodeIds) {
+    if (visibleNodeIds.size === 0)
+        return [];
+    return edges
+        .filter((edge) => visibleNodeIds.has(edge.sourceId) && visibleNodeIds.has(edge.targetId))
+        .map((edge) => edge.id);
+}
+function buildAdaptiveSlice(nodes, edges, anchorNodeId) {
+    if (nodes.length === 0 || !anchorNodeId) {
+        return { nodes: [], edges: [] };
+    }
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    const adjacency = buildAdjacency(nodes, edges);
+    const distances = bfsDistances(anchorNodeId, adjacency);
+    const reachableNodes = nodes.filter((node) => distances.has(node.id));
+    const cap = determineReadabilityCap(reachableNodes.length);
+    const rankedNodes = [...reachableNodes].sort((left, right) => compareSlicePriority(left, right, distances));
+    const selectedIds = new Set();
+    for (const node of rankedNodes) {
+        selectedIds.add(node.id);
+        if (selectedIds.size >= cap)
+            break;
+    }
+    if (!selectedIds.has(anchorNodeId) && nodeById.has(anchorNodeId)) {
+        selectedIds.add(anchorNodeId);
+    }
+    const selectedNodes = rankedNodes.filter((node) => selectedIds.has(node.id));
+    const selectedEdges = [...edges]
+        .filter((edge) => selectedIds.has(edge.sourceId) && selectedIds.has(edge.targetId))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return { nodes: selectedNodes, edges: selectedEdges };
+}
+function determineReadabilityCap(nodeCount) {
+    if (nodeCount <= 0)
+        return 0;
+    if (nodeCount <= 8)
+        return nodeCount;
+    return Math.min(nodeCount, Math.max(8, Math.min(35, Math.ceil(nodeCount * 0.35))));
+}
+function compareSlicePriority(left, right, distances) {
+    const leftDistance = distances.get(left.id) ?? Number.POSITIVE_INFINITY;
+    const rightDistance = distances.get(right.id) ?? Number.POSITIVE_INFINITY;
+    if (leftDistance !== rightDistance)
+        return leftDistance - rightDistance;
+    if (right.degree !== left.degree)
+        return right.degree - left.degree;
+    const labelComparison = left.label.localeCompare(right.label);
+    if (labelComparison !== 0)
+        return labelComparison;
+    return left.id.localeCompare(right.id);
+}
+function buildAdjacency(nodes, edges) {
+    const adjacency = new Map();
+    for (const node of nodes) {
+        adjacency.set(node.id, []);
+    }
+    for (const edge of [...edges].sort((left, right) => left.id.localeCompare(right.id))) {
+        const source = adjacency.get(edge.sourceId);
+        const target = adjacency.get(edge.targetId);
+        if (!source || !target)
+            continue;
+        source.push({ nodeId: edge.targetId, edgeId: edge.id });
+        target.push({ nodeId: edge.sourceId, edgeId: edge.id });
+    }
+    return adjacency;
+}
+function bfsDistances(anchorNodeId, adjacency) {
+    const distances = new Map([[anchorNodeId, 0]]);
+    const queue = [anchorNodeId];
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        const nextDistance = (distances.get(nodeId) ?? 0) + 1;
+        for (const neighbor of adjacency.get(nodeId) ?? []) {
+            if (distances.has(neighbor.nodeId))
+                continue;
+            distances.set(neighbor.nodeId, nextDistance);
+            queue.push(neighbor.nodeId);
+        }
+    }
+    return distances;
+}
+function buildNeighborhoods(nodes, edges) {
+    const neighborhoods = new Map();
+    for (const node of nodes) {
+        neighborhoods.set(node.id, {
+            nodeIds: new Set([node.id]),
+            edgeIds: new Set()
+        });
+    }
+    for (const edge of edges) {
+        const source = neighborhoods.get(edge.sourceId);
+        const target = neighborhoods.get(edge.targetId);
+        if (source) {
+            source.nodeIds.add(edge.targetId);
+            source.edgeIds.add(edge.id);
+        }
+        if (target) {
+            target.nodeIds.add(edge.sourceId);
+            target.edgeIds.add(edge.id);
+        }
+    }
+    const entries = {};
+    for (const [nodeId, neighborhood] of neighborhoods) {
+        entries[nodeId] = {
+            nodeIds: [...neighborhood.nodeIds],
+            edgeIds: [...neighborhood.edgeIds]
+        };
+    }
+    return entries;
+}
+export function computeInitialViewBox(nodes, visibleNodeIds, anchorNodeId) {
+    if (nodes.length === 0) {
+        return { x: 0, y: 0, width: 1000, height: 800 };
+    }
+    const bounds = boundsForNodes(nodes);
+    const width = Math.max(bounds.width * 1.35, 900);
+    const height = Math.max(bounds.height * 1.35, 650);
+    const centerX = bounds.minX + bounds.width / 2;
+    const centerY = bounds.minY + bounds.height / 2;
+    return {
+        x: centerX - width / 2,
+        y: centerY - height / 2,
+        width,
+        height
+    };
+}
+function collapseEquivalentNodesAndEdges(nodes, edges) {
+    if (nodes.length === 0) {
+        return { nodes: [], edges: [] };
+    }
+    const degreeByNodeId = new Map();
+    for (const edge of edges) {
+        degreeByNodeId.set(edge.sourceId, (degreeByNodeId.get(edge.sourceId) ?? 0) + 1);
+        degreeByNodeId.set(edge.targetId, (degreeByNodeId.get(edge.targetId) ?? 0) + 1);
+    }
+    const groups = new Map();
+    for (const node of nodes) {
+        const key = collapseKey(node);
+        const group = groups.get(key) ?? [];
+        group.push(node);
+        groups.set(key, group);
+    }
+    const canonicalByNodeId = new Map();
+    const collapsedNodes = [];
+    const sortedGroups = [...groups.entries()].sort((left, right) => left[0].localeCompare(right[0]));
+    for (const [, group] of sortedGroups) {
+        const representative = [...group].sort((left, right) => {
+            const leftDegree = degreeByNodeId.get(left.id) ?? 0;
+            const rightDegree = degreeByNodeId.get(right.id) ?? 0;
+            if (rightDegree !== leftDegree)
+                return rightDegree - leftDegree;
+            return left.id.localeCompare(right.id);
+        })[0] ?? group[0];
+        if (!representative)
+            continue;
+        for (const node of group) {
+            canonicalByNodeId.set(node.id, representative.id);
+        }
+        collapsedNodes.push(representative);
+    }
+    const collapsedEdgesMap = new Map();
+    for (const edge of edges) {
+        const sourceId = canonicalByNodeId.get(edge.sourceId) ?? edge.sourceId;
+        const targetId = canonicalByNodeId.get(edge.targetId) ?? edge.targetId;
+        const key = [sourceId, targetId, edge.kind, edge.metadataJson].join('\u0000');
+        if (collapsedEdgesMap.has(key))
+            continue;
+        collapsedEdgesMap.set(key, {
+            ...edge,
+            sourceId,
+            targetId
+        });
+    }
+    const collapsedEdges = [...collapsedEdgesMap.values()].sort((left, right) => left.id.localeCompare(right.id));
+    const collapsedDegreeByNodeId = new Map();
+    for (const edge of collapsedEdges) {
+        collapsedDegreeByNodeId.set(edge.sourceId, (collapsedDegreeByNodeId.get(edge.sourceId) ?? 0) + 1);
+        collapsedDegreeByNodeId.set(edge.targetId, (collapsedDegreeByNodeId.get(edge.targetId) ?? 0) + 1);
+    }
+    return {
+        nodes: collapsedNodes.map((node) => ({
+            ...node,
+            degree: collapsedDegreeByNodeId.get(node.id) ?? 0
+        })),
+        edges: collapsedEdges
+    };
+}
+function collapseKey(node) {
+    return [node.kind, node.type, node.name ?? ''].join('\u0000');
+}
+function buildGraph(nodes, edges) {
+    const GraphConstructor = Graphology;
+    const graph = new GraphConstructor({ type: 'directed', multi: true });
+    for (const node of nodes) {
+        graph.addNode(node.id, {
+            ...node,
+            x: 0,
+            y: 0
+        });
+    }
+    for (const edge of edges) {
+        if (!graph.hasNode(edge.sourceId) || !graph.hasNode(edge.targetId))
+            continue;
+        graph.addEdgeWithKey(edge.id, edge.sourceId, edge.targetId, {
+            kind: edge.kind,
+            confidence: edge.confidence,
+            metadataJson: edge.metadataJson
+        });
+    }
+    return graph;
+}
+function decorateNodes(nodes, edges) {
+    const degreeByNodeId = new Map();
+    for (const edge of edges) {
+        degreeByNodeId.set(edge.sourceId, (degreeByNodeId.get(edge.sourceId) ?? 0) + 1);
+        degreeByNodeId.set(edge.targetId, (degreeByNodeId.get(edge.targetId) ?? 0) + 1);
+    }
+    return nodes.map((node) => ({
+        ...node,
+        label: node.name?.trim() || node.type,
+        degree: degreeByNodeId.get(node.id) ?? 0,
+        x: 0,
+        y: 0
+    }));
+}
+function highestDegreeNode(nodes) {
+    if (nodes.length === 0)
+        return null;
+    return [...nodes].sort((left, right) => {
+        if (right.degree !== left.degree)
+            return right.degree - left.degree;
+        const labelComparison = left.label.localeCompare(right.label);
+        if (labelComparison !== 0)
+            return labelComparison;
+        return left.id.localeCompare(right.id);
+    })[0] ?? null;
+}
+function nodeMatchesSearch(node, search) {
+    return node.name?.toLowerCase().includes(search) ?? false;
+}
+function normalizeSearch(value) {
+    const trimmed = value?.trim().toLowerCase() ?? '';
+    return trimmed ? trimmed : null;
+}
+function boundsForNodes(nodes) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const node of nodes) {
+        if (node.x < minX)
+            minX = node.x;
+        if (node.x > maxX)
+            maxX = node.x;
+        if (node.y < minY)
+            minY = node.y;
+        if (node.y > maxY)
+            maxY = node.y;
+    }
+    if (!Number.isFinite(minX))
+        return { minX: 0, maxX: 0, minY: 0, maxY: 0, width: 0, height: 0 };
+    return {
+        minX,
+        maxX,
+        minY,
+        maxY,
+        width: maxX - minX,
+        height: maxY - minY
+    };
+}
+//# sourceMappingURL=model.js.map

package/dist/src/view/open.d.ts

@@ -0,0 +1,15 @@
+export interface TempHtmlArtifact {
+    directoryPath: string;
+    htmlPath: string;
+}
+export interface BrowserOpenResult {
+    opened: boolean;
+    command?: string | undefined;
+    error?: string | undefined;
+}
+export interface TempHtmlOpenResult extends TempHtmlArtifact, BrowserOpenResult {
+}
+export declare function writeTemporaryHtmlArtifact(html: string, prefix?: string): TempHtmlArtifact;
+export declare function openHtmlArtifactInBrowser(html: string, opener?: (htmlPath: string) => BrowserOpenResult): TempHtmlOpenResult;
+export declare function openInDefaultBrowser(targetPath: string): BrowserOpenResult;
+//# sourceMappingURL=open.d.ts.map

package/dist/src/view/open.js

@@ -0,0 +1,37 @@
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export function writeTemporaryHtmlArtifact(html, prefix = 'lscg-view-') {
+    const directoryPath = mkdtempSync(path.join(os.tmpdir(), prefix));
+    const htmlPath = path.join(directoryPath, 'view.html');
+    writeFileSync(htmlPath, html, 'utf8');
+    return { directoryPath, htmlPath };
+}
+export function openHtmlArtifactInBrowser(html, opener = openInDefaultBrowser) {
+    const artifact = writeTemporaryHtmlArtifact(html);
+    const result = opener(artifact.htmlPath);
+    return { ...artifact, ...result };
+}
+export function openInDefaultBrowser(targetPath) {
+    const commands = process.platform === 'darwin'
+        ? [['open', [targetPath]]]
+        : process.platform === 'win32'
+            ? [['cmd', ['/c', 'start', '', targetPath]]]
+            : [
+                ['xdg-open', [targetPath]],
+                ['gio', ['open', targetPath]],
+                ['gnome-open', [targetPath]]
+            ];
+    for (const [command, args] of commands) {
+        const result = spawnSync(command, args, { stdio: 'ignore', windowsHide: true });
+        if (!result.error && result.status === 0) {
+            return { opened: true, command };
+        }
+    }
+    return {
+        opened: false,
+        error: `Unable to open ${targetPath} in a browser`
+    };
+}
+//# sourceMappingURL=open.js.map

package/dist/src/view/render.d.ts

@@ -0,0 +1,9 @@
+import type { ViewModel } from './model.js';
+export interface RenderSvgOptions {
+    includeHiddenNodes?: boolean | undefined;
+    interactive?: boolean | undefined;
+}
+export declare function renderSvgMarkup(model: ViewModel, options?: RenderSvgOptions): string;
+export declare function renderInteractiveHtml(model: ViewModel): string;
+export declare function writeSvgSnapshot(filePath: string, svgMarkup: string): void;
+//# sourceMappingURL=render.d.ts.map