@usefragments/core 1.0.0

package/dist/chunk-SH4KPIYH.js

@@ -0,0 +1,393 @@
+// src/graph/types.ts
+var GRAPH_EDGE_TYPES = [
+  "imports",
+  "hook-depends",
+  "renders",
+  "composes",
+  "parent-of",
+  "alternative-to",
+  "sibling-of"
+];
+var EDGE_TYPE_WEIGHTS = {
+  "imports": 1,
+  "hook-depends": 0.75,
+  "renders": 0.5,
+  "composes": 0.5,
+  "parent-of": 1,
+  "alternative-to": 1,
+  "sibling-of": 0.75
+};
+
+// src/graph/engine.ts
+var ComponentGraphEngine = class {
+  nodes;
+  outgoing;
+  incoming;
+  edges;
+  blockIndex;
+  health;
+  constructor(graph, blocks) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.outgoing = /* @__PURE__ */ new Map();
+    this.incoming = /* @__PURE__ */ new Map();
+    this.edges = graph.edges;
+    this.health = graph.health;
+    this.blockIndex = /* @__PURE__ */ new Map();
+    for (const node of graph.nodes) {
+      this.nodes.set(node.name, node);
+      this.outgoing.set(node.name, []);
+      this.incoming.set(node.name, []);
+    }
+    for (const edge of graph.edges) {
+      const out = this.outgoing.get(edge.source);
+      if (out) out.push(edge);
+      else this.outgoing.set(edge.source, [edge]);
+      const inc = this.incoming.get(edge.target);
+      if (inc) inc.push(edge);
+      else this.incoming.set(edge.target, [edge]);
+    }
+    if (blocks) {
+      for (const [blockName, block] of Object.entries(blocks)) {
+        for (const comp of block.components) {
+          const existing = this.blockIndex.get(comp);
+          if (existing) existing.push(blockName);
+          else this.blockIndex.set(comp, [blockName]);
+        }
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Core queries
+  // -------------------------------------------------------------------------
+  /** Get outgoing edges from a component, optionally filtered by edge type */
+  dependencies(component, edgeTypes) {
+    const edges = this.outgoing.get(component) ?? [];
+    if (!edgeTypes || edgeTypes.length === 0) return edges;
+    return edges.filter((e) => edgeTypes.includes(e.type));
+  }
+  /** Get incoming edges to a component, optionally filtered by edge type */
+  dependents(component, edgeTypes) {
+    const edges = this.incoming.get(component) ?? [];
+    if (!edgeTypes || edgeTypes.length === 0) return edges;
+    return edges.filter((e) => edgeTypes.includes(e.type));
+  }
+  /** BFS transitive closure — what's affected if this component changes */
+  impact(component, maxDepth = 3) {
+    const affected = [];
+    const visited = /* @__PURE__ */ new Set([component]);
+    const queue = [
+      { name: component, depth: 0, path: [component] }
+    ];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.depth >= maxDepth) continue;
+      const deps = this.incoming.get(current.name) ?? [];
+      for (const edge of deps) {
+        if (visited.has(edge.source)) continue;
+        visited.add(edge.source);
+        const newPath = [...current.path, edge.source];
+        affected.push({
+          component: edge.source,
+          depth: current.depth + 1,
+          path: newPath,
+          edgeType: edge.type
+        });
+        queue.push({ name: edge.source, depth: current.depth + 1, path: newPath });
+      }
+    }
+    const affectedComponents = /* @__PURE__ */ new Set([component, ...affected.map((a) => a.component)]);
+    const affectedBlocks = /* @__PURE__ */ new Set();
+    for (const comp of affectedComponents) {
+      const blocks = this.blockIndex.get(comp);
+      if (blocks) {
+        for (const b of blocks) affectedBlocks.add(b);
+      }
+    }
+    return {
+      component,
+      affected,
+      affectedBlocks: [...affectedBlocks],
+      totalAffected: affected.length
+    };
+  }
+  /** BFS shortest path between two components (undirected) */
+  path(from, to) {
+    if (from === to) {
+      return { found: true, path: [from], edges: [] };
+    }
+    const visited = /* @__PURE__ */ new Set([from]);
+    const queue = [
+      { name: from, path: [from], edges: [] }
+    ];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const allEdges = [
+        ...this.outgoing.get(current.name) ?? [],
+        ...this.incoming.get(current.name) ?? []
+      ];
+      for (const edge of allEdges) {
+        const neighbor = edge.source === current.name ? edge.target : edge.source;
+        if (visited.has(neighbor)) continue;
+        visited.add(neighbor);
+        const newPath = [...current.path, neighbor];
+        const newEdges = [...current.edges, edge];
+        if (neighbor === to) {
+          return { found: true, path: newPath, edges: newEdges };
+        }
+        queue.push({ name: neighbor, path: newPath, edges: newEdges });
+      }
+    }
+    return { found: false, path: [], edges: [] };
+  }
+  /** Connected components via BFS on undirected projection */
+  islands() {
+    const visited = /* @__PURE__ */ new Set();
+    const components = [];
+    for (const nodeName of this.nodes.keys()) {
+      if (visited.has(nodeName)) continue;
+      const island = [];
+      const queue = [nodeName];
+      visited.add(nodeName);
+      while (queue.length > 0) {
+        const current = queue.shift();
+        island.push(current);
+        const allEdges = [
+          ...this.outgoing.get(current) ?? [],
+          ...this.incoming.get(current) ?? []
+        ];
+        for (const edge of allEdges) {
+          const neighbor = edge.source === current ? edge.target : edge.source;
+          if (!visited.has(neighbor) && this.nodes.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      components.push(island.sort());
+    }
+    return components.sort((a, b) => b.length - a.length);
+  }
+  /** All components reachable within N hops (undirected) */
+  neighbors(component, maxHops = 1) {
+    const neighbors = [];
+    const visited = /* @__PURE__ */ new Set([component]);
+    const queue = [
+      { name: component, hops: 0 }
+    ];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.hops >= maxHops) continue;
+      const allEdges = [
+        ...this.outgoing.get(current.name) ?? [],
+        ...this.incoming.get(current.name) ?? []
+      ];
+      for (const edge of allEdges) {
+        const neighbor = edge.source === current.name ? edge.target : edge.source;
+        if (visited.has(neighbor)) continue;
+        visited.add(neighbor);
+        neighbors.push({
+          component: neighbor,
+          hops: current.hops + 1,
+          edgeType: edge.type
+        });
+        queue.push({ name: neighbor, hops: current.hops + 1 });
+      }
+    }
+    return { component, neighbors };
+  }
+  // -------------------------------------------------------------------------
+  // Design-system queries
+  // -------------------------------------------------------------------------
+  /** Get the composition tree for a compound component */
+  composition(component) {
+    const node = this.nodes.get(component);
+    const subComponents = node?.subComponents ?? [];
+    const parentEdges = (this.outgoing.get(component) ?? []).filter((e) => e.type === "parent-of");
+    const children = parentEdges.map((e) => e.target);
+    const childEdges = (this.incoming.get(component) ?? []).filter((e) => e.type === "parent-of");
+    const parent = childEdges.length > 0 ? childEdges[0].source : void 0;
+    const siblings = [];
+    if (parent) {
+      const parentOut = (this.outgoing.get(parent) ?? []).filter((e) => e.type === "parent-of");
+      for (const edge of parentOut) {
+        if (edge.target !== component) {
+          siblings.push(edge.target);
+        }
+      }
+    }
+    const siblingEdges = [
+      ...(this.outgoing.get(component) ?? []).filter((e) => e.type === "sibling-of"),
+      ...(this.incoming.get(component) ?? []).filter((e) => e.type === "sibling-of")
+    ];
+    for (const edge of siblingEdges) {
+      const sib = edge.source === component ? edge.target : edge.source;
+      if (!siblings.includes(sib)) siblings.push(sib);
+    }
+    return {
+      component,
+      compositionPattern: node?.compositionPattern,
+      subComponents,
+      children,
+      parent,
+      siblings,
+      blocks: this.blockIndex.get(component) ?? []
+    };
+  }
+  /** Get alternative components (deduplicated for bidirectional edges) */
+  alternatives(component) {
+    const seen = /* @__PURE__ */ new Set();
+    const alts = [];
+    for (const edge of this.outgoing.get(component) ?? []) {
+      if (edge.type === "alternative-to" && !seen.has(edge.target)) {
+        seen.add(edge.target);
+        alts.push({ component: edge.target, note: edge.note });
+      }
+    }
+    for (const edge of this.incoming.get(component) ?? []) {
+      if (edge.type === "alternative-to" && !seen.has(edge.source)) {
+        seen.add(edge.source);
+        alts.push({ component: edge.source, note: edge.note });
+      }
+    }
+    return alts;
+  }
+  /** Get blocks that use a component */
+  blocksUsing(component) {
+    return this.blockIndex.get(component) ?? [];
+  }
+  /** Extract an induced subgraph for a set of components */
+  subgraph(components) {
+    const componentSet = new Set(components);
+    const nodes = components.map((name) => this.nodes.get(name)).filter((n) => n !== void 0);
+    const edges = this.edges.filter(
+      (e) => componentSet.has(e.source) && componentSet.has(e.target)
+    );
+    return {
+      nodes,
+      edges,
+      health: computeHealthFromData(nodes, edges, this.blockIndex)
+    };
+  }
+  /** Return precomputed health metrics */
+  getHealth() {
+    return this.health;
+  }
+  /** Get a single node by name */
+  getNode(name) {
+    return this.nodes.get(name);
+  }
+  /** Check if a component exists in the graph */
+  hasNode(name) {
+    return this.nodes.has(name);
+  }
+};
+function computeHealthFromData(nodes, edges, blockIndex) {
+  const nodeNames = new Set(nodes.map((n) => n.name));
+  const degreeMap = /* @__PURE__ */ new Map();
+  for (const name of nodeNames) {
+    degreeMap.set(name, 0);
+  }
+  for (const edge of edges) {
+    degreeMap.set(edge.source, (degreeMap.get(edge.source) ?? 0) + 1);
+    degreeMap.set(edge.target, (degreeMap.get(edge.target) ?? 0) + 1);
+  }
+  const orphans = [];
+  for (const [name, degree] of degreeMap) {
+    if (degree === 0) orphans.push(name);
+  }
+  const hubs = [...degreeMap.entries()].map(([name, degree]) => ({ name, degree })).sort((a, b) => b.degree - a.degree).slice(0, 10);
+  let inBlock = 0;
+  if (blockIndex) {
+    for (const name of nodeNames) {
+      if ((blockIndex.get(name) ?? []).length > 0) inBlock++;
+    }
+  }
+  const compositionCoverage = nodeNames.size > 0 ? Math.round(inBlock / nodeNames.size * 100) : 0;
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const name of nodeNames) {
+    adjacency.set(name, /* @__PURE__ */ new Set());
+  }
+  for (const edge of edges) {
+    adjacency.get(edge.source)?.add(edge.target);
+    adjacency.get(edge.target)?.add(edge.source);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const connectedComponents = [];
+  for (const name of nodeNames) {
+    if (visited.has(name)) continue;
+    const island = [];
+    const queue = [name];
+    visited.add(name);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      island.push(current);
+      for (const neighbor of adjacency.get(current) ?? []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    connectedComponents.push(island.sort());
+  }
+  connectedComponents.sort((a, b) => b.length - a.length);
+  const totalDegree = [...degreeMap.values()].reduce((sum, d) => sum + d, 0);
+  const averageDegree = nodeNames.size > 0 ? Math.round(totalDegree / nodeNames.size * 100) / 100 : 0;
+  return {
+    orphans: orphans.sort(),
+    hubs,
+    compositionCoverage,
+    connectedComponents,
+    averageDegree,
+    nodeCount: nodeNames.size,
+    edgeCount: edges.length
+  };
+}
+
+// src/graph/serialization.ts
+function serializeGraph(graph) {
+  return {
+    nodes: graph.nodes,
+    edges: graph.edges.map(serializeEdge),
+    health: graph.health
+  };
+}
+function deserializeGraph(serialized) {
+  return {
+    nodes: serialized.nodes,
+    edges: serialized.edges.map(deserializeEdge),
+    health: serialized.health
+  };
+}
+function serializeEdge(edge) {
+  const result = {
+    s: edge.source,
+    t: edge.target,
+    ty: edge.type,
+    w: edge.weight,
+    p: edge.provenance
+  };
+  if (edge.note) result.no = edge.note;
+  return result;
+}
+function deserializeEdge(edge) {
+  const result = {
+    source: edge.s,
+    target: edge.t,
+    type: edge.ty,
+    weight: edge.w,
+    provenance: edge.p
+  };
+  if (edge.no) result.note = edge.no;
+  return result;
+}
+
+export {
+  GRAPH_EDGE_TYPES,
+  EDGE_TYPE_WEIGHTS,
+  ComponentGraphEngine,
+  computeHealthFromData,
+  serializeGraph,
+  deserializeGraph
+};
+//# sourceMappingURL=chunk-SH4KPIYH.js.map

package/dist/chunk-SH4KPIYH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph/types.ts","../src/graph/engine.ts","../src/graph/serialization.ts"],"sourcesContent":["/**\n * Component Graph data model — types for the design-system-semantic relationship graph.\n *\n * These types describe nodes (components), edges (relationships), and health\n * metrics that together give AI agents structural understanding of a design system.\n */\n\n// ---------------------------------------------------------------------------\n// Edge types — design-system-semantic\n// ---------------------------------------------------------------------------\n\nexport type GraphEdgeType =\n  | 'imports'           // A imports B in source code\n  | 'hook-depends'      // A calls useB() from B\n  | 'renders'           // A renders <B> in examples\n  | 'composes'          // A and B co-occur in a block\n  | 'parent-of'         // A should wrap B\n  | 'alternative-to'    // A can replace B\n  | 'sibling-of';       // A and B at same level\n\nexport const GRAPH_EDGE_TYPES: readonly GraphEdgeType[] = [\n  'imports',\n  'hook-depends',\n  'renders',\n  'composes',\n  'parent-of',\n  'alternative-to',\n  'sibling-of',\n];\n\n/** Default weight for each edge type */\nexport const EDGE_TYPE_WEIGHTS: Record<GraphEdgeType, number> = {\n  'imports': 1.0,\n  'hook-depends': 0.75,\n  'renders': 0.5,\n  'composes': 0.5,\n  'parent-of': 1.0,\n  'alternative-to': 1.0,\n  'sibling-of': 0.75,\n};\n\n// ---------------------------------------------------------------------------\n// Nodes\n// ---------------------------------------------------------------------------\n\nexport interface ComponentNode {\n  name: string;\n  category: string;\n  status: string;\n  compositionPattern?: 'compound' | 'simple' | 'controlled' | 'wrapper';\n  subComponents?: string[];\n}\n\n// ---------------------------------------------------------------------------\n// Edges\n// ---------------------------------------------------------------------------\n\nexport interface GraphEdge {\n  source: string;\n  target: string;\n  type: GraphEdgeType;\n  weight: number;\n  note?: string;\n  /** Where this edge was detected from */\n  provenance: string;\n}\n\n// ---------------------------------------------------------------------------\n// Health metrics\n// ---------------------------------------------------------------------------\n\nexport interface GraphHealth {\n  /** Components with zero edges */\n  orphans: string[];\n  /** Top components by total degree (in + out) */\n  hubs: Array<{ name: string; degree: number }>;\n  /** Percentage of components appearing in at least one block */\n  compositionCoverage: number;\n  /** Disconnected groups (BFS on undirected projection) */\n  connectedComponents: string[][];\n  /** Average degree across all nodes */\n  averageDegree: number;\n  /** Total node and edge counts */\n  nodeCount: number;\n  edgeCount: number;\n}\n\n// ---------------------------------------------------------------------------\n// Full graph\n// ---------------------------------------------------------------------------\n\nexport interface ComponentGraph {\n  nodes: ComponentNode[];\n  edges: GraphEdge[];\n  health: GraphHealth;\n}\n\n// ---------------------------------------------------------------------------\n// Query results\n// ---------------------------------------------------------------------------\n\nexport interface ImpactResult {\n  /** The component that was changed */\n  component: string;\n  /** Components affected at each depth level */\n  affected: Array<{\n    component: string;\n    depth: number;\n    path: string[];\n    edgeType: GraphEdgeType;\n  }>;\n  /** Blocks that use the changed component or any affected component */\n  affectedBlocks: string[];\n  /** Total count of affected components */\n  totalAffected: number;\n}\n\nexport interface PathResult {\n  /** Whether a path exists */\n  found: boolean;\n  /** Nodes along the shortest path (including source and target) */\n  path: string[];\n  /** Edges along the shortest path */\n  edges: GraphEdge[];\n}\n\nexport interface NeighborResult {\n  /** The center component */\n  component: string;\n  /** All components reachable within maxHops */\n  neighbors: Array<{\n    component: string;\n    hops: number;\n    edgeType: GraphEdgeType;\n  }>;\n}\n\nexport interface CompositionTree {\n  /** The root component */\n  component: string;\n  /** Composition pattern */\n  compositionPattern?: 'compound' | 'simple' | 'controlled' | 'wrapper';\n  /** Direct sub-components */\n  subComponents: string[];\n  /** Components that declare this component as their parent */\n  children: string[];\n  /** Parent component (if this is a sub-component) */\n  parent?: string;\n  /** Sibling components at the same level */\n  siblings: string[];\n  /** Blocks that use this component */\n  blocks: string[];\n}\n\n// ---------------------------------------------------------------------------\n// Serialization (compact keys for JSON size)\n// ---------------------------------------------------------------------------\n\nexport interface SerializedEdge {\n  /** source */\n  s: string;\n  /** target */\n  t: string;\n  /** type */\n  ty: GraphEdgeType;\n  /** weight */\n  w: number;\n  /** note (optional) */\n  no?: string;\n  /** provenance */\n  p: string;\n}\n\nexport interface SerializedComponentGraph {\n  nodes: ComponentNode[];\n  edges: SerializedEdge[];\n  health: GraphHealth;\n}\n","/**\n * ComponentGraphEngine — query engine for the design-system relationship graph.\n *\n * Provides BFS-based traversal, impact analysis, composition trees,\n * alternative discovery, and health metrics. Operates on an in-memory\n * adjacency list built from GraphEdge[].\n */\n\nimport type {\n  ComponentNode,\n  GraphEdge,\n  GraphEdgeType,\n  GraphHealth,\n  ComponentGraph,\n  ImpactResult,\n  PathResult,\n  NeighborResult,\n  CompositionTree,\n} from './types.js';\n\nexport class ComponentGraphEngine {\n  private nodes: Map<string, ComponentNode>;\n  private outgoing: Map<string, GraphEdge[]>;\n  private incoming: Map<string, GraphEdge[]>;\n  private edges: GraphEdge[];\n  private blockIndex: Map<string, string[]>;\n  private health: GraphHealth;\n\n  constructor(graph: ComponentGraph, blocks?: Record<string, { components: string[] }>) {\n    this.nodes = new Map();\n    this.outgoing = new Map();\n    this.incoming = new Map();\n    this.edges = graph.edges;\n    this.health = graph.health;\n    this.blockIndex = new Map();\n\n    for (const node of graph.nodes) {\n      this.nodes.set(node.name, node);\n      this.outgoing.set(node.name, []);\n      this.incoming.set(node.name, []);\n    }\n\n    for (const edge of graph.edges) {\n      const out = this.outgoing.get(edge.source);\n      if (out) out.push(edge);\n      else this.outgoing.set(edge.source, [edge]);\n\n      const inc = this.incoming.get(edge.target);\n      if (inc) inc.push(edge);\n      else this.incoming.set(edge.target, [edge]);\n    }\n\n    // Build block index: component → block names\n    if (blocks) {\n      for (const [blockName, block] of Object.entries(blocks)) {\n        for (const comp of block.components) {\n          const existing = this.blockIndex.get(comp);\n          if (existing) existing.push(blockName);\n          else this.blockIndex.set(comp, [blockName]);\n        }\n      }\n    }\n  }\n\n  // -------------------------------------------------------------------------\n  // Core queries\n  // -------------------------------------------------------------------------\n\n  /** Get outgoing edges from a component, optionally filtered by edge type */\n  dependencies(component: string, edgeTypes?: GraphEdgeType[]): GraphEdge[] {\n    const edges = this.outgoing.get(component) ?? [];\n    if (!edgeTypes || edgeTypes.length === 0) return edges;\n    return edges.filter(e => edgeTypes.includes(e.type));\n  }\n\n  /** Get incoming edges to a component, optionally filtered by edge type */\n  dependents(component: string, edgeTypes?: GraphEdgeType[]): GraphEdge[] {\n    const edges = this.incoming.get(component) ?? [];\n    if (!edgeTypes || edgeTypes.length === 0) return edges;\n    return edges.filter(e => edgeTypes.includes(e.type));\n  }\n\n  /** BFS transitive closure — what's affected if this component changes */\n  impact(component: string, maxDepth = 3): ImpactResult {\n    const affected: ImpactResult['affected'] = [];\n    const visited = new Set<string>([component]);\n    const queue: Array<{ name: string; depth: number; path: string[] }> = [\n      { name: component, depth: 0, path: [component] },\n    ];\n\n    while (queue.length > 0) {\n      const current = queue.shift()!;\n      if (current.depth >= maxDepth) continue;\n\n      // Components that depend on current (incoming edges = dependents)\n      const deps = this.incoming.get(current.name) ?? [];\n      for (const edge of deps) {\n        if (visited.has(edge.source)) continue;\n        visited.add(edge.source);\n        const newPath = [...current.path, edge.source];\n        affected.push({\n          component: edge.source,\n          depth: current.depth + 1,\n          path: newPath,\n          edgeType: edge.type,\n        });\n        queue.push({ name: edge.source, depth: current.depth + 1, path: newPath });\n      }\n    }\n\n    // Find affected blocks\n    const affectedComponents = new Set([component, ...affected.map(a => a.component)]);\n    const affectedBlocks = new Set<string>();\n    for (const comp of affectedComponents) {\n      const blocks = this.blockIndex.get(comp);\n      if (blocks) {\n        for (const b of blocks) affectedBlocks.add(b);\n      }\n    }\n\n    return {\n      component,\n      affected,\n      affectedBlocks: [...affectedBlocks],\n      totalAffected: affected.length,\n    };\n  }\n\n  /** BFS shortest path between two components (undirected) */\n  path(from: string, to: string): PathResult {\n    if (from === to) {\n      return { found: true, path: [from], edges: [] };\n    }\n\n    const visited = new Set<string>([from]);\n    const queue: Array<{ name: string; path: string[]; edges: GraphEdge[] }> = [\n      { name: from, path: [from], edges: [] },\n    ];\n\n    while (queue.length > 0) {\n      const current = queue.shift()!;\n\n      // Check both outgoing and incoming edges (undirected traversal)\n      const allEdges = [\n        ...(this.outgoing.get(current.name) ?? []),\n        ...(this.incoming.get(current.name) ?? []),\n      ];\n\n      for (const edge of allEdges) {\n        const neighbor = edge.source === current.name ? edge.target : edge.source;\n        if (visited.has(neighbor)) continue;\n        visited.add(neighbor);\n\n        const newPath = [...current.path, neighbor];\n        const newEdges = [...current.edges, edge];\n\n        if (neighbor === to) {\n          return { found: true, path: newPath, edges: newEdges };\n        }\n\n        queue.push({ name: neighbor, path: newPath, edges: newEdges });\n      }\n    }\n\n    return { found: false, path: [], edges: [] };\n  }\n\n  /** Connected components via BFS on undirected projection */\n  islands(): string[][] {\n    const visited = new Set<string>();\n    const components: string[][] = [];\n\n    for (const nodeName of this.nodes.keys()) {\n      if (visited.has(nodeName)) continue;\n\n      const island: string[] = [];\n      const queue = [nodeName];\n      visited.add(nodeName);\n\n      while (queue.length > 0) {\n        const current = queue.shift()!;\n        island.push(current);\n\n        const allEdges = [\n          ...(this.outgoing.get(current) ?? []),\n          ...(this.incoming.get(current) ?? []),\n        ];\n\n        for (const edge of allEdges) {\n          const neighbor = edge.source === current ? edge.target : edge.source;\n          if (!visited.has(neighbor) && this.nodes.has(neighbor)) {\n            visited.add(neighbor);\n            queue.push(neighbor);\n          }\n        }\n      }\n\n      components.push(island.sort());\n    }\n\n    return components.sort((a, b) => b.length - a.length);\n  }\n\n  /** All components reachable within N hops (undirected) */\n  neighbors(component: string, maxHops = 1): NeighborResult {\n    const neighbors: NeighborResult['neighbors'] = [];\n    const visited = new Set<string>([component]);\n    const queue: Array<{ name: string; hops: number }> = [\n      { name: component, hops: 0 },\n    ];\n\n    while (queue.length > 0) {\n      const current = queue.shift()!;\n      if (current.hops >= maxHops) continue;\n\n      const allEdges = [\n        ...(this.outgoing.get(current.name) ?? []),\n        ...(this.incoming.get(current.name) ?? []),\n      ];\n\n      for (const edge of allEdges) {\n        const neighbor = edge.source === current.name ? edge.target : edge.source;\n        if (visited.has(neighbor)) continue;\n        visited.add(neighbor);\n\n        neighbors.push({\n          component: neighbor,\n          hops: current.hops + 1,\n          edgeType: edge.type,\n        });\n\n        queue.push({ name: neighbor, hops: current.hops + 1 });\n      }\n    }\n\n    return { component, neighbors };\n  }\n\n  // -------------------------------------------------------------------------\n  // Design-system queries\n  // -------------------------------------------------------------------------\n\n  /** Get the composition tree for a compound component */\n  composition(component: string): CompositionTree {\n    const node = this.nodes.get(component);\n\n    // Find sub-components from node data\n    const subComponents = node?.subComponents ?? [];\n\n    // Find children from outgoing parent-of edges\n    const parentEdges = (this.outgoing.get(component) ?? [])\n      .filter(e => e.type === 'parent-of');\n    const children = parentEdges.map(e => e.target);\n\n    // Find parent (incoming parent-of edges)\n    const childEdges = (this.incoming.get(component) ?? [])\n      .filter(e => e.type === 'parent-of');\n    const parent = childEdges.length > 0 ? childEdges[0].source : undefined;\n\n    // Find siblings (other targets of the same parent)\n    const siblings: string[] = [];\n    if (parent) {\n      const parentOut = (this.outgoing.get(parent) ?? [])\n        .filter(e => e.type === 'parent-of');\n      for (const edge of parentOut) {\n        if (edge.target !== component) {\n          siblings.push(edge.target);\n        }\n      }\n    }\n\n    // Also check sibling-of edges\n    const siblingEdges = [\n      ...(this.outgoing.get(component) ?? []).filter(e => e.type === 'sibling-of'),\n      ...(this.incoming.get(component) ?? []).filter(e => e.type === 'sibling-of'),\n    ];\n    for (const edge of siblingEdges) {\n      const sib = edge.source === component ? edge.target : edge.source;\n      if (!siblings.includes(sib)) siblings.push(sib);\n    }\n\n    return {\n      component,\n      compositionPattern: node?.compositionPattern,\n      subComponents,\n      children,\n      parent,\n      siblings,\n      blocks: this.blockIndex.get(component) ?? [],\n    };\n  }\n\n  /** Get alternative components (deduplicated for bidirectional edges) */\n  alternatives(component: string): Array<{ component: string; note?: string }> {\n    const seen = new Set<string>();\n    const alts: Array<{ component: string; note?: string }> = [];\n\n    // Outgoing alternative-to edges\n    for (const edge of this.outgoing.get(component) ?? []) {\n      if (edge.type === 'alternative-to' && !seen.has(edge.target)) {\n        seen.add(edge.target);\n        alts.push({ component: edge.target, note: edge.note });\n      }\n    }\n\n    // Incoming alternative-to edges (skip if already seen from outgoing)\n    for (const edge of this.incoming.get(component) ?? []) {\n      if (edge.type === 'alternative-to' && !seen.has(edge.source)) {\n        seen.add(edge.source);\n        alts.push({ component: edge.source, note: edge.note });\n      }\n    }\n\n    return alts;\n  }\n\n  /** Get blocks that use a component */\n  blocksUsing(component: string): string[] {\n    return this.blockIndex.get(component) ?? [];\n  }\n\n  /** Extract an induced subgraph for a set of components */\n  subgraph(components: string[]): ComponentGraph {\n    const componentSet = new Set(components);\n    const nodes = components\n      .map(name => this.nodes.get(name))\n      .filter((n): n is ComponentNode => n !== undefined);\n\n    const edges = this.edges.filter(\n      e => componentSet.has(e.source) && componentSet.has(e.target)\n    );\n\n    return {\n      nodes,\n      edges,\n      health: computeHealthFromData(nodes, edges, this.blockIndex),\n    };\n  }\n\n  /** Return precomputed health metrics */\n  getHealth(): GraphHealth {\n    return this.health;\n  }\n\n  /** Get a single node by name */\n  getNode(name: string): ComponentNode | undefined {\n    return this.nodes.get(name);\n  }\n\n  /** Check if a component exists in the graph */\n  hasNode(name: string): boolean {\n    return this.nodes.has(name);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Health computation helper (also used by graph-extractor)\n// ---------------------------------------------------------------------------\n\nexport function computeHealthFromData(\n  nodes: ComponentNode[],\n  edges: GraphEdge[],\n  blockIndex?: Map<string, string[]>\n): GraphHealth {\n  const nodeNames = new Set(nodes.map(n => n.name));\n  const degreeMap = new Map<string, number>();\n\n  for (const name of nodeNames) {\n    degreeMap.set(name, 0);\n  }\n\n  for (const edge of edges) {\n    degreeMap.set(edge.source, (degreeMap.get(edge.source) ?? 0) + 1);\n    degreeMap.set(edge.target, (degreeMap.get(edge.target) ?? 0) + 1);\n  }\n\n  // Orphans: zero degree\n  const orphans: string[] = [];\n  for (const [name, degree] of degreeMap) {\n    if (degree === 0) orphans.push(name);\n  }\n\n  // Hubs: top 10 by degree\n  const hubs = [...degreeMap.entries()]\n    .map(([name, degree]) => ({ name, degree }))\n    .sort((a, b) => b.degree - a.degree)\n    .slice(0, 10);\n\n  // Composition coverage\n  let inBlock = 0;\n  if (blockIndex) {\n    for (const name of nodeNames) {\n      if ((blockIndex.get(name) ?? []).length > 0) inBlock++;\n    }\n  }\n  const compositionCoverage = nodeNames.size > 0\n    ? Math.round((inBlock / nodeNames.size) * 100)\n    : 0;\n\n  // Connected components (BFS on undirected projection)\n  const adjacency = new Map<string, Set<string>>();\n  for (const name of nodeNames) {\n    adjacency.set(name, new Set());\n  }\n  for (const edge of edges) {\n    adjacency.get(edge.source)?.add(edge.target);\n    adjacency.get(edge.target)?.add(edge.source);\n  }\n\n  const visited = new Set<string>();\n  const connectedComponents: string[][] = [];\n  for (const name of nodeNames) {\n    if (visited.has(name)) continue;\n    const island: string[] = [];\n    const queue = [name];\n    visited.add(name);\n    while (queue.length > 0) {\n      const current = queue.shift()!;\n      island.push(current);\n      for (const neighbor of adjacency.get(current) ?? []) {\n        if (!visited.has(neighbor)) {\n          visited.add(neighbor);\n          queue.push(neighbor);\n        }\n      }\n    }\n    connectedComponents.push(island.sort());\n  }\n  connectedComponents.sort((a, b) => b.length - a.length);\n\n  // Average degree\n  const totalDegree = [...degreeMap.values()].reduce((sum, d) => sum + d, 0);\n  const averageDegree = nodeNames.size > 0\n    ? Math.round((totalDegree / nodeNames.size) * 100) / 100\n    : 0;\n\n  return {\n    orphans: orphans.sort(),\n    hubs,\n    compositionCoverage,\n    connectedComponents,\n    averageDegree,\n    nodeCount: nodeNames.size,\n    edgeCount: edges.length,\n  };\n}\n","/**\n * Graph serialization — compact JSON format for fragments.json embedding.\n *\n * Edges use short keys (s, t, ty, w, no, p) to reduce JSON size.\n * Round-trips through serialize → deserialize preserve all data.\n */\n\nimport type {\n  ComponentGraph,\n  GraphEdge,\n  SerializedComponentGraph,\n  SerializedEdge,\n} from './types.js';\n\n/** Serialize a ComponentGraph to compact JSON format */\nexport function serializeGraph(graph: ComponentGraph): SerializedComponentGraph {\n  return {\n    nodes: graph.nodes,\n    edges: graph.edges.map(serializeEdge),\n    health: graph.health,\n  };\n}\n\n/** Deserialize a compact JSON graph back to full ComponentGraph */\nexport function deserializeGraph(serialized: SerializedComponentGraph): ComponentGraph {\n  return {\n    nodes: serialized.nodes,\n    edges: serialized.edges.map(deserializeEdge),\n    health: serialized.health,\n  };\n}\n\nfunction serializeEdge(edge: GraphEdge): SerializedEdge {\n  const result: SerializedEdge = {\n    s: edge.source,\n    t: edge.target,\n    ty: edge.type,\n    w: edge.weight,\n    p: edge.provenance,\n  };\n  if (edge.note) result.no = edge.note;\n  return result;\n}\n\nfunction deserializeEdge(edge: SerializedEdge): GraphEdge {\n  const result: GraphEdge = {\n    source: edge.s,\n    target: edge.t,\n    type: edge.ty,\n    weight: edge.w,\n    provenance: edge.p,\n  };\n  if (edge.no) result.note = edge.no;\n  return result;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-V4VQB57N.js

@@ -0,0 +1,56 @@
+// src/severity.ts
+import { z } from "zod";
+var severitySchema = z.enum(["critical", "serious", "moderate", "minor"]);
+var severityLevelSchema = z.enum(["error", "warn"]);
+var legacySeverityLevelSchema = z.enum(["error", "warn", "info", "warning"]);
+var SEVERITIES = severitySchema.options;
+var SEVERITY_WEIGHTS = {
+  critical: 10,
+  serious: 5,
+  moderate: 2,
+  minor: 1
+};
+var SEVERITY_RANK = {
+  critical: 4,
+  serious: 3,
+  moderate: 2,
+  minor: 1
+};
+function severityLevel(severity) {
+  return severity === "critical" || severity === "serious" ? "error" : "warn";
+}
+function severityFromLevel(level) {
+  switch (level) {
+    case "error":
+      return "serious";
+    case "warn":
+    case "warning":
+      return "moderate";
+    case "info":
+      return "minor";
+  }
+}
+function compareSeverity(a, b) {
+  return SEVERITY_RANK[b] - SEVERITY_RANK[a];
+}
+function maxSeverity(a, b) {
+  return SEVERITY_RANK[a] >= SEVERITY_RANK[b] ? a : b;
+}
+function sortBySeverity(items, getSeverity) {
+  return items.slice().sort((a, b) => compareSeverity(getSeverity(a), getSeverity(b)));
+}
+
+export {
+  severitySchema,
+  severityLevelSchema,
+  legacySeverityLevelSchema,
+  SEVERITIES,
+  SEVERITY_WEIGHTS,
+  SEVERITY_RANK,
+  severityLevel,
+  severityFromLevel,
+  compareSeverity,
+  maxSeverity,
+  sortBySeverity
+};
+//# sourceMappingURL=chunk-V4VQB57N.js.map

package/dist/chunk-V4VQB57N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/severity.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const severitySchema = z.enum([\"critical\", \"serious\", \"moderate\", \"minor\"]);\nexport type Severity = z.infer<typeof severitySchema>;\n\nexport const severityLevelSchema = z.enum([\"error\", \"warn\"]);\nexport type SeverityLevel = z.infer<typeof severityLevelSchema>;\n\nexport const legacySeverityLevelSchema = z.enum([\"error\", \"warn\", \"info\", \"warning\"]);\nexport type LegacySeverityLevel = z.infer<typeof legacySeverityLevelSchema>;\n\nexport const SEVERITIES = severitySchema.options;\n\nexport const SEVERITY_WEIGHTS: Record<Severity, number> = {\n  critical: 10,\n  serious: 5,\n  moderate: 2,\n  minor: 1,\n};\n\nexport const SEVERITY_RANK: Record<Severity, number> = {\n  critical: 4,\n  serious: 3,\n  moderate: 2,\n  minor: 1,\n};\n\nexport function severityLevel(severity: Severity): SeverityLevel {\n  return severity === \"critical\" || severity === \"serious\" ? \"error\" : \"warn\";\n}\n\nexport function severityFromLevel(level: LegacySeverityLevel): Severity {\n  switch (level) {\n    case \"error\":\n      return \"serious\";\n    case \"warn\":\n    case \"warning\":\n      return \"moderate\";\n    case \"info\":\n      return \"minor\";\n  }\n}\n\nexport function compareSeverity(a: Severity, b: Severity): number {\n  return SEVERITY_RANK[b] - SEVERITY_RANK[a];\n}\n\nexport function maxSeverity(a: Severity, b: Severity): Severity {\n  return SEVERITY_RANK[a] >= SEVERITY_RANK[b] ? a : b;\n}\n\nexport function sortBySeverity<T>(items: readonly T[], getSeverity: (item: T) => Severity): T[] {\n  return items.slice().sort((a, b) => compareSeverity(getSeverity(a), getSeverity(b)));\n}\n"],"mappings":";AAAA,SAAS,SAAS;AAEX,IAAM,iBAAiB,EAAE,KAAK,CAAC,YAAY,WAAW,YAAY,OAAO,CAAC;AAG1E,IAAM,sBAAsB,EAAE,KAAK,CAAC,SAAS,MAAM,CAAC;AAGpD,IAAM,4BAA4B,EAAE,KAAK,CAAC,SAAS,QAAQ,QAAQ,SAAS,CAAC;AAG7E,IAAM,aAAa,eAAe;AAElC,IAAM,mBAA6C;AAAA,EACxD,UAAU;AAAA,EACV,SAAS;AAAA,EACT,UAAU;AAAA,EACV,OAAO;AACT;AAEO,IAAM,gBAA0C;AAAA,EACrD,UAAU;AAAA,EACV,SAAS;AAAA,EACT,UAAU;AAAA,EACV,OAAO;AACT;AAEO,SAAS,cAAc,UAAmC;AAC/D,SAAO,aAAa,cAAc,aAAa,YAAY,UAAU;AACvE;AAEO,SAAS,kBAAkB,OAAsC;AACtE,UAAQ,OAAO;AAAA,IACb,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,EACX;AACF;AAEO,SAAS,gBAAgB,GAAa,GAAqB;AAChE,SAAO,cAAc,CAAC,IAAI,cAAc,CAAC;AAC3C;AAEO,SAAS,YAAY,GAAa,GAAuB;AAC9D,SAAO,cAAc,CAAC,KAAK,cAAc,CAAC,IAAI,IAAI;AACpD;AAEO,SAAS,eAAkB,OAAqB,aAAyC;AAC9F,SAAO,MAAM,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,gBAAgB,YAAY,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;AACrF;","names":[]}