symbiote-ui 0.3.0-alpha.4

package/graph/canvas-adapter.js

@@ -0,0 +1,223 @@
+import { normalizeGraphEdge, normalizeGraphModel } from './model.js';
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function copyObject(value) {
+  return { ...asObject(value) };
+}
+
+function normalizeId(value, fieldName) {
+  const id = String(value ?? '').trim();
+  if (!id) throw new Error(`${fieldName} is required`);
+  return id;
+}
+
+function normalizeCanvasNode(rawNode) {
+  const data = asObject(rawNode);
+  const id = normalizeId(data.id, 'canvas node.id');
+  const children = Array.isArray(data.children) ? data.children.map((childId) => normalizeId(childId, 'canvas node.children')) : [];
+  const node = {
+    ...data,
+    id,
+    label: data.label == null ? id : String(data.label),
+    type: String(data.type ?? data.kind ?? 'data'),
+    isGroup: Boolean(data.isGroup),
+    children,
+  };
+
+  if (data.parentId != null) node.parentId = normalizeId(data.parentId, 'canvas node.parentId');
+  return node;
+}
+
+function normalizeCanvasEdge(rawEdge) {
+  const data = asObject(rawEdge);
+  const from = normalizeId(data.from ?? data.source?.nodeId ?? data.source?.node ?? data.source?.id, 'canvas edge.from');
+  const to = normalizeId(data.to ?? data.target?.nodeId ?? data.target?.node ?? data.target?.id, 'canvas edge.to');
+  return {
+    ...data,
+    from,
+    to,
+    out: data.out == null ? 'default' : String(data.out),
+    in: data.in == null ? 'default' : String(data.in),
+  };
+}
+
+function resolveView(graph, view) {
+  if (!view) return null;
+  if (typeof view === 'string') return graph.views[view] || null;
+  return asObject(view);
+}
+
+function visibleNodeIdsForView(graph, view) {
+  const rootIds = Array.isArray(view?.roots) ? view.roots : [];
+  if (rootIds.length === 0) return null;
+
+  const visible = new Set();
+  const visit = (id) => {
+    if (visible.has(id)) return;
+    const node = graph.nodesById.get(id);
+    if (!node) return;
+    visible.add(id);
+    for (const childId of node.children || []) visit(childId);
+  };
+  for (const id of rootIds) visit(id);
+  return visible;
+}
+
+function canvasNodeFromGraphNode(node) {
+  const design = asObject(node.design);
+  const canvas = asObject(design.canvas);
+  const canvasNode = {
+    ...canvas,
+    id: node.id,
+    label: node.label,
+    type: String(design.variant ?? node.kind),
+    kind: node.kind,
+    parentId: node.parentId ?? null,
+    isGroup: Boolean(design.isGroup ?? node.children.length > 0),
+    children: [...node.children],
+    flow: copyObject(node.flow),
+    params: copyObject(node.params),
+    design: copyObject(node.design),
+    state: copyObject(node.state),
+  };
+
+  if (design.width != null) canvasNode.w = design.width;
+  if (design.height != null) canvasNode.h = design.height;
+  if (design.color != null) canvasNode.color = String(design.color);
+  if (node.themeScope != null) canvasNode.themeScope = node.themeScope;
+  if (node.metadata != null) canvasNode.metadata = copyObject(node.metadata);
+
+  return canvasNode;
+}
+
+function rootNodesForCanvas(graph, visibleNodeIds, view) {
+  const explicitRoots = Array.isArray(view?.roots) ? view.roots : [];
+  const roots = [];
+
+  for (const id of explicitRoots) {
+    if (graph.nodesById.has(id) && (!visibleNodeIds || visibleNodeIds.has(id))) roots.push(id);
+  }
+  if (roots.length > 0) return roots;
+
+  for (const node of graph.nodes) {
+    if (visibleNodeIds && !visibleNodeIds.has(node.id)) continue;
+    if (!node.parentId || !graph.nodesById.has(node.parentId) || (visibleNodeIds && !visibleNodeIds.has(node.parentId))) {
+      roots.push(node.id);
+    }
+  }
+  return roots;
+}
+
+export function graphModelToCanvasGraphModel(rawModel, options = {}) {
+  const graph = normalizeGraphModel(rawModel);
+  const view = resolveView(graph, options.view);
+  const visibleNodeIds = visibleNodeIdsForView(graph, view);
+  const nodes = graph.nodes
+    .filter((node) => !visibleNodeIds || visibleNodeIds.has(node.id))
+    .map(canvasNodeFromGraphNode);
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  const edges = graph.edges
+    .filter((edge) => nodeIds.has(edge.source.nodeId) && nodeIds.has(edge.target.nodeId))
+    .map((edge) => ({
+      id: edge.id,
+      from: edge.source.nodeId,
+      to: edge.target.nodeId,
+      out: edge.source.port,
+      in: edge.target.port,
+      type: edge.kind,
+      label: edge.label,
+      params: copyObject(edge.params),
+      metadata: copyObject(edge.metadata),
+    }));
+
+  return {
+    nodes,
+    edges,
+    rootNodes: rootNodesForCanvas(graph, visibleNodeIds, view),
+  };
+}
+
+export function canvasGraphModelToGraphModel(rawCanvasModel = {}, options = {}) {
+  const data = asObject(rawCanvasModel);
+  const nodes = (data.nodes || []).map(normalizeCanvasNode);
+  const nodesById = new Set(nodes.map((node) => node.id));
+  const edges = (data.edges ?? data.connections ?? []).map(normalizeCanvasEdge);
+  const rootNodes = Array.isArray(data.rootNodes)
+    ? data.rootNodes.map((id) => normalizeId(id, 'canvas rootNodes')).filter((id) => nodesById.has(id))
+    : [];
+
+  return normalizeGraphModel({
+    version: 'graph-model-v1',
+    metadata: copyObject(options.metadata),
+    nodes: nodes.map((node) => {
+      const design = {
+        ...copyObject(node.design),
+        component: node.design?.component ?? options.component ?? (node.isGroup ? 'graph-group' : 'graph-node'),
+      };
+      if (node.w != null) design.width = node.w;
+      if (node.h != null) design.height = node.h;
+      if (node.color != null) design.color = node.color;
+      design.canvas = {
+        ...copyObject(design.canvas),
+        ...copyCanvasData(node),
+      };
+
+      const graphNode = {
+        id: node.id,
+        kind: String(node.kind ?? node.type ?? 'ui.node'),
+        label: node.label,
+        flow: copyObject(node.flow),
+        params: copyObject(node.params),
+        design,
+        children: node.children,
+        state: copyObject(node.state),
+      };
+      if (node.parentId != null) graphNode.parentId = node.parentId;
+      if (node.themeScope != null) graphNode.themeScope = node.themeScope;
+      if (node.metadata != null) graphNode.metadata = copyObject(node.metadata);
+      return graphNode;
+    }),
+    edges: edges.map((edge) => normalizeGraphEdge({
+      id: edge.id,
+      kind: edge.kind ?? edge.type,
+      label: edge.label,
+      source: { nodeId: edge.from, port: edge.out },
+      target: { nodeId: edge.to, port: edge.in },
+      params: edge.params,
+      metadata: edge.metadata,
+    })),
+    views: {
+      canvas: {
+        kind: 'canvas-graph',
+        roots: rootNodes,
+      },
+    },
+  });
+}
+
+function copyCanvasData(node) {
+  const skip = new Set([
+    'id',
+    'label',
+    'type',
+    'kind',
+    'parentId',
+    'isGroup',
+    'children',
+    'flow',
+    'params',
+    'design',
+    'state',
+    'w',
+    'h',
+    'color',
+    'themeScope',
+    'metadata',
+  ]);
+  return Object.fromEntries(
+    Object.entries(node).filter(([key, value]) => !skip.has(key) && value !== undefined)
+  );
+}

package/graph/graph-algorithms.js

@@ -0,0 +1,31 @@
+export function resolveSymbolFile(skeleton, symbol) {
+  if (!skeleton || !symbol) return null;
+  const entry = (skeleton.n || {})[symbol];
+  return entry?.f || null;
+}
+
+export function findConnectionPath(connections, fromId, toId) {
+  if (!fromId || !toId || fromId === toId) return [];
+
+  const adjacency = new Map();
+  for (const connection of connections || []) {
+    if (!adjacency.has(connection.from)) adjacency.set(connection.from, []);
+    adjacency.get(connection.from).push({ to: connection.to, id: connection.id });
+  }
+
+  const visited = new Set([fromId]);
+  const queue = [[fromId, []]];
+
+  while (queue.length > 0) {
+    const [current, path] = queue.shift();
+    if (current === toId) return path;
+
+    for (const edge of adjacency.get(current) || []) {
+      if (visited.has(edge.to)) continue;
+      visited.add(edge.to);
+      queue.push([edge.to, [...path, edge.id]]);
+    }
+  }
+
+  return [];
+}

package/graph/index.js

@@ -0,0 +1,46 @@
+export {
+  normalizeGraphEndpoint,
+  normalizeGraphNode,
+  normalizeGraphEdge,
+  normalizeGraphModel,
+} from './model.js';
+export {
+  canvasGraphModelToGraphModel,
+  graphModelToCanvasGraphModel,
+} from './canvas-adapter.js';
+export { normalizeProjectPackage } from './project-package.js';
+export {
+  applyProjectTransaction,
+  updateLayoutNode,
+  normalizeProjectTransaction,
+} from './project-transaction.js';
+export { createProjectRuntime } from './project-runtime.js';
+export {
+  GRAPH_CLUSTER_COLOR_TOKENS,
+  GRAPH_TYPE_COLOR_TOKENS,
+  getGraphClusterColorToken,
+  isGraphColorReference,
+  normalizeGraphColorReference,
+} from './theme-contract.js'
+export { dirOf, baseName, resolveImport, collectSkeletonFiles } from './skeleton-utils.js'
+export {
+  EMPTY_PROJECT_GRAPH_METADATA,
+  normalizeProjectGraphMetadata,
+  validateProjectGraphMetadata,
+  pathMatchesPattern,
+  findClusterForPath,
+  buildSemanticGroups,
+  parseHexColor,
+} from './project-graph-metadata.js'
+export { resolveSymbolFile, findConnectionPath } from './graph-algorithms.js'
+export { extractProjectTransactionsFromMessages } from './transaction-parser.js'
+export {
+  buildFlatGroups,
+  buildGraphStatItems,
+  prepareGraphBuild,
+} from './project-graph-build.js'
+export {
+  buildCanvasGraphModelFromSkeleton,
+  buildGraphModelFromSkeleton,
+} from '../canvas/project-graph-model.js'
+export { buildFileGraph, buildStructuredGraph } from '../canvas/project-graph-builder.js'

package/graph/model.js

@@ -0,0 +1,176 @@
+const DEFAULT_PORT = 'default';
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function normalizeId(value, fieldName) {
+  const id = String(value ?? '').trim();
+  if (!id) throw new Error(`${fieldName} is required`);
+  return id;
+}
+
+function normalizePort(port) {
+  const normalized = String(port ?? DEFAULT_PORT).trim();
+  return normalized || DEFAULT_PORT;
+}
+
+function normalizeEndpointPort(port) {
+  const normalized = String(port ?? '').trim();
+  if (!normalized) throw new Error('endpoint.port is required');
+  return normalized;
+}
+
+function normalizePorts(ports) {
+  if (!Array.isArray(ports)) return [];
+  return ports.map((port) => {
+    if (typeof port === 'string') return { name: port, type: 'any' };
+    const data = asObject(port);
+    return {
+      ...data,
+      name: normalizeId(data.name, 'port.name'),
+      type: String(data.type ?? 'any'),
+    };
+  });
+}
+
+function normalizeFlow(flow = {}) {
+  const data = asObject(flow);
+  return {
+    ...data,
+    inputs: normalizePorts(data.inputs),
+    outputs: normalizePorts(data.outputs),
+  };
+}
+
+function normalizeDesign(design = {}) {
+  const data = asObject(design);
+  return {
+    ...data,
+    component: String(data.component ?? 'graph-node'),
+  };
+}
+
+function endpointFromObject(endpoint, fallbackPort) {
+  const data = asObject(endpoint);
+  return {
+    nodeId: normalizeId(data.nodeId, 'endpoint.nodeId'),
+    port: fallbackPort == null ? normalizeEndpointPort(data.port) : normalizePort(data.port ?? fallbackPort),
+  };
+}
+
+export function normalizeGraphEndpoint(endpoint, fallbackPort) {
+  return endpointFromObject(endpoint, fallbackPort);
+}
+
+export function normalizeGraphNode(rawNode) {
+  const data = asObject(rawNode);
+  const id = normalizeId(data.id, 'node.id');
+  const kind = normalizeId(data.kind, 'node.kind');
+  const node = {
+    id,
+    kind,
+    label: data.label == null ? id : String(data.label),
+    flow: normalizeFlow(data.flow),
+    params: asObject(data.params),
+    design: normalizeDesign(data.design),
+    children: Array.isArray(data.children) ? data.children.map((childId) => normalizeId(childId, 'node.children')) : [],
+    state: asObject(data.state),
+  };
+
+  if (data.parentId != null) node.parentId = normalizeId(data.parentId, 'node.parentId');
+  if (data.themeScope != null) node.themeScope = normalizeId(data.themeScope, 'node.themeScope');
+  if (data.metadata != null) node.metadata = asObject(data.metadata);
+
+  return node;
+}
+
+export function normalizeGraphEdge(rawEdge) {
+  const data = asObject(rawEdge);
+  const source = normalizeGraphEndpoint(data.source);
+  const target = normalizeGraphEndpoint(data.target);
+  const kind = String(data.kind ?? 'dataflow');
+  const id = data.id == null
+    ? `${source.nodeId}:${source.port}->${target.nodeId}:${target.port}`
+    : normalizeId(data.id, 'edge.id');
+
+  const edge = {
+    id,
+    kind,
+    source,
+    target,
+    params: asObject(data.params),
+  };
+
+  if (data.label != null) edge.label = String(data.label);
+  if (data.metadata != null) edge.metadata = asObject(data.metadata);
+
+  return edge;
+}
+
+function normalizeView(view) {
+  const data = asObject(view);
+  return {
+    ...data,
+    kind: String(data.kind ?? 'graph-canvas'),
+    roots: Array.isArray(data.roots) ? data.roots.map((id) => normalizeId(id, 'view.roots')) : [],
+    groups: Array.isArray(data.groups) ? data.groups.map((group) => ({
+      ...asObject(group),
+      id: normalizeId(asObject(group).id, 'view.group.id'),
+      nodeIds: Array.isArray(asObject(group).nodeIds)
+        ? asObject(group).nodeIds.map((id) => normalizeId(id, 'view.group.nodeIds'))
+        : [],
+    })) : [],
+  };
+}
+
+function normalizeViews(views) {
+  const data = asObject(views);
+  return Object.fromEntries(
+    Object.entries(data).map(([name, view]) => [name, normalizeView(view)])
+  );
+}
+
+export function normalizeGraphModel(rawModel = {}) {
+  const data = asObject(rawModel);
+  const nodes = [];
+  const nodesById = new Map();
+
+  for (const rawNode of data.nodes || []) {
+    const node = normalizeGraphNode(rawNode);
+    if (nodesById.has(node.id)) throw new Error(`node "${node.id}" is already defined`);
+    nodes.push(node);
+    nodesById.set(node.id, node);
+  }
+
+  const rawEdges = data.edges ?? [];
+  const edges = rawEdges.map(normalizeGraphEdge);
+  const edgesById = new Map();
+  for (const edge of edges) {
+    if (edgesById.has(edge.id)) throw new Error(`edge "${edge.id}" is already defined`);
+    if (!nodesById.has(edge.source.nodeId)) {
+      throw new Error(`source node "${edge.source.nodeId}" is not defined`);
+    }
+    if (!nodesById.has(edge.target.nodeId)) {
+      throw new Error(`target node "${edge.target.nodeId}" is not defined`);
+    }
+    edgesById.set(edge.id, edge);
+  }
+
+  for (const node of nodes) {
+    for (const childId of node.children) {
+      if (!nodesById.has(childId)) throw new Error(`child node "${childId}" is not defined`);
+    }
+  }
+
+  return {
+    version: 'graph-model-v1',
+    metadata: asObject(data.metadata),
+    nodes,
+    edges,
+    views: normalizeViews(data.views),
+    theme: data.theme == null ? null : asObject(data.theme),
+    nodesById,
+    edgesById,
+  };
+}

package/graph/project-graph-build.js

@@ -0,0 +1,66 @@
+import { buildSemanticGroups } from './project-graph-metadata.js';
+
+export function buildFlatGroups(dirFiles, fileMap, projectGraphMetadata = null) {
+  let semanticGroups = buildSemanticGroups(fileMap, projectGraphMetadata);
+  let groups = { ...semanticGroups };
+  let assignedNodeIds = new Set(Object.values(semanticGroups).flat());
+
+  if (!dirFiles) return groups;
+
+  for (let [dir, files] of dirFiles.entries()) {
+    let nodeIds = [];
+    for (let file of files) {
+      let nodeId = fileMap.get(file);
+      if (nodeId && !assignedNodeIds.has(nodeId)) nodeIds.push(nodeId);
+    }
+    if (nodeIds.length > 0) groups[dir] = nodeIds;
+  }
+  return groups;
+}
+
+export function prepareGraphBuild({
+  cache,
+  skeleton,
+  isStructured,
+  projectGraphMetadata,
+  getOrBuildGraphFn,
+  getDrillableFilesFn,
+  buildStructuredGraphFn,
+  buildFileGraphFn,
+}) {
+  let { graph, cached } = getOrBuildGraphFn({
+    cache,
+    skeleton,
+    isStructured,
+    buildStructuredGraphFn,
+    buildFileGraphFn,
+  });
+  let { dirFiles, fileMap, symbolMap } = graph;
+
+  return {
+    graph,
+    cached,
+    groups: isStructured ? {} : buildFlatGroups(dirFiles, fileMap, projectGraphMetadata),
+    drillableFiles: getDrillableFilesFn(symbolMap),
+  };
+}
+
+export function buildGraphStatItems({
+  skeletonStats = {},
+  fileCount,
+  edgeCount,
+  viaCount,
+}) {
+  let items = [
+    [fileCount, 'files'],
+    [skeletonStats.functions || 0, 'fn'],
+    [skeletonStats.classes || 0, 'cls'],
+    [edgeCount, 'edges'],
+  ];
+
+  if (viaCount > 0) {
+    items.push([viaCount, 'vias']);
+  }
+
+  return items;
+}