@route-intelligence/core 2.1.0

package/dist/chunk-56XSRN7B.js

@@ -0,0 +1,163 @@
+// src/graph/algorithms.ts
+import { hasCycle, willCreateCycle } from "graphology-dag";
+import { bidirectional } from "graphology-shortest-path";
+import { bfsFromNode } from "graphology-traversal";
+function findCycles(graph) {
+  const underlying = graph.getUnderlyingGraph();
+  const cycles = [];
+  if (!hasCycle(underlying)) return cycles;
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(nodeId) {
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    path.push(nodeId);
+    for (const neighbor of underlying.outNeighbors(nodeId)) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      } else if (recursionStack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        if (cycleStart >= 0) {
+          cycles.push({ nodes: path.slice(cycleStart), edges: [] });
+        }
+      }
+    }
+    path.pop();
+    recursionStack.delete(nodeId);
+  }
+  for (const nodeId of graph.getAllNodeIds()) {
+    if (!visited.has(nodeId)) {
+      dfs(nodeId);
+    }
+  }
+  return cycles;
+}
+function findDeadRoutes(graph) {
+  const entryTypes = ["route", "layout", "middleware"];
+  const entryNodes = graph.getAllNodeIds().filter((id) => {
+    const node = graph.getNode(id);
+    return node && entryTypes.includes(node.type);
+  });
+  const reachable = /* @__PURE__ */ new Set();
+  const underlying = graph.getUnderlyingGraph();
+  for (const entry of entryNodes) {
+    bfsFromNode(underlying, entry, (node) => {
+      reachable.add(node);
+    });
+  }
+  return graph.getAllNodeIds().filter((id) => {
+    const node = graph.getNode(id);
+    if (!node || node.type !== "route") return false;
+    const incoming = graph.getIncomingEdges(id);
+    const hasNavIncoming = incoming.some(
+      (e) => e.attributes.type === "navigation" || e.attributes.type === "redirect" || e.attributes.type === "conditional-navigation"
+    );
+    return !reachable.has(id) && !hasNavIncoming && node.path !== "/";
+  }).map((id) => id);
+}
+function findShortestPath(graph, sourceId, targetId) {
+  const underlying = graph.getUnderlyingGraph();
+  if (!underlying.hasNode(sourceId) || !underlying.hasNode(targetId)) return null;
+  try {
+    return bidirectional(underlying, sourceId, targetId);
+  } catch {
+    return null;
+  }
+}
+function detectInfiniteRedirects(graph) {
+  const redirectEdges = graph.getAllEdges().filter((e) => {
+    const attrs = graph.getUnderlyingGraph().getEdgeAttributes(e.id);
+    return attrs.type === "redirect" || attrs.type === "permanent-redirect" || attrs.type === "rewrite";
+  });
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const edge of redirectEdges) {
+    const key = `${edge.source}->${edge.target}`;
+    if (visited.has(key)) continue;
+    visited.add(key);
+    const path = [edge.source];
+    let current = edge.target;
+    const seen = /* @__PURE__ */ new Set([edge.source]);
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      path.push(current);
+      const nextEdge = redirectEdges.find((e) => e.source === current);
+      if (!nextEdge) break;
+      current = nextEdge.target;
+    }
+    if (current && seen.has(current)) {
+      const cycleStart = path.indexOf(current);
+      cycles.push({ nodes: path.slice(cycleStart), edges: [] });
+    }
+  }
+  return cycles;
+}
+function getMostConnected(graph, n = 10) {
+  const underlying = graph.getUnderlyingGraph();
+  const degrees = graph.getAllNodeIds().map((id) => ({
+    id,
+    degree: underlying.degree(id)
+  }));
+  return degrees.sort((a, b) => b.degree - a.degree).slice(0, n);
+}
+
+// src/graph/metrics.ts
+function computeMetrics(graph) {
+  const routeNodes = graph.findNodesByType("route");
+  const layoutNodes = graph.findNodesByType("layout");
+  const apiNodes = graph.findNodesByType("api-route");
+  const deadRoutes = findDeadRoutes(graph);
+  const cycles = findCycles(graph);
+  const redirectCycles = detectInfiniteRedirects(graph);
+  const mostConnected = getMostConnected(graph, 5);
+  const depths = routeNodes.map((id) => graph.getNode(id)?.depth ?? 0);
+  const maxDepth = depths.length > 0 ? Math.max(...depths) : 0;
+  const averageDepth = depths.length > 0 ? depths.reduce((a, b) => a + b, 0) / depths.length : 0;
+  const deadRoutePct = routeNodes.length > 0 ? deadRoutes.length / routeNodes.length : 0;
+  const cyclePenalty = (cycles.length + redirectCycles.length) * 5;
+  const depthPenalty = maxDepth > 10 ? (maxDepth - 10) * 2 : 0;
+  const maintainabilityScore = Math.max(
+    0,
+    Math.min(100, 100 - deadRoutePct * 40 - cyclePenalty - depthPenalty)
+  );
+  const riskScore = Math.max(0, Math.min(100, deadRoutePct * 30 + cyclePenalty * 2 + depthPenalty));
+  return {
+    totalRoutes: routeNodes.length,
+    totalLayouts: layoutNodes.length,
+    totalApiRoutes: apiNodes.length,
+    deadRouteCount: deadRoutes.length,
+    cycleCount: cycles.length + redirectCycles.length,
+    maxDepth,
+    averageDepth,
+    mostConnected: mostConnected.map((m) => ({
+      ...m,
+      path: graph.getNodePath(m.id) ?? m.id
+    })),
+    maintainabilityScore,
+    riskScore
+  };
+}
+function metricsToMetadata(graph, pluginIds) {
+  const metrics = computeMetrics(graph);
+  return {
+    pluginIds,
+    totalRoutes: metrics.totalRoutes,
+    totalLayouts: metrics.totalLayouts,
+    totalApiRoutes: metrics.totalApiRoutes,
+    deadRouteCount: metrics.deadRouteCount,
+    cycleCount: metrics.cycleCount,
+    maintainabilityScore: metrics.maintainabilityScore,
+    riskScore: metrics.riskScore
+  };
+}
+
+export {
+  findCycles,
+  findDeadRoutes,
+  findShortestPath,
+  detectInfiniteRedirects,
+  getMostConnected,
+  computeMetrics,
+  metricsToMetadata
+};

package/dist/index.d.ts

@@ -0,0 +1,158 @@
+import { EventEmitter } from 'node:events';
+import * as _route_intelligence_shared from '@route-intelligence/shared';
+import { RouteGraphLike, NodeAttributes, EdgeAttributes, GraphMetadata, SerializedGraph, SemanticFile, InvalidationSet, GraphPatch, FileChangeEvent, FrameworkPlugin, AnalysisResult, AnalyzerConfig, RawRoute, Diagnostic } from '@route-intelligence/shared';
+export { AnalysisResult, AnalyzerConfig, Diagnostic, FrameworkPlugin, GraphMetadata, GraphPatch, defineConfig } from '@route-intelligence/shared';
+import { SourceFile } from 'ts-morph';
+import { MultiDirectedGraph } from 'graphology';
+
+declare class RouteGraph implements RouteGraphLike {
+    private readonly graph;
+    constructor();
+    hasNode(id: string): boolean;
+    getNode(id: string): NodeAttributes | undefined;
+    getNodePath(id: string): string | undefined;
+    findNodeByPath(path: string): string | undefined;
+    findNodesByType(type: NodeAttributes['type']): string[];
+    addNode(id: string, attributes: NodeAttributes): void;
+    removeNode(id: string): void;
+    addEdge(id: string, source: string, target: string, attributes: EdgeAttributes): void;
+    removeEdge(id: string): void;
+    getAllNodeIds(): string[];
+    getAllEdges(): Array<{
+        id: string;
+        source: string;
+        target: string;
+    }>;
+    getIncomingEdges(nodeId: string): Array<{
+        id: string;
+        source: string;
+        attributes: EdgeAttributes;
+    }>;
+    getOutgoingEdges(nodeId: string): Array<{
+        id: string;
+        target: string;
+        attributes: EdgeAttributes;
+    }>;
+    getUnderlyingGraph(): MultiDirectedGraph<NodeAttributes, EdgeAttributes>;
+    toJSON(root: string, metadata?: Partial<GraphMetadata>): SerializedGraph;
+    static fromJSON(data: SerializedGraph): RouteGraph;
+}
+
+declare function exportDot(graph: RouteGraph): string;
+
+declare function exportHtml(graph: RouteGraph, root: string): string;
+declare function exportMarkdown(graph: RouteGraph, root: string): string;
+
+declare function exportJson(graph: RouteGraph, root: string): string;
+
+declare function exportMermaid(graph: RouteGraph): string;
+
+declare function exportPlantUML(graph: RouteGraph): string;
+
+interface CycleResult {
+    nodes: string[];
+    edges: string[];
+}
+declare function findCycles(graph: RouteGraph): CycleResult[];
+declare function findDeadRoutes(graph: RouteGraph): string[];
+declare function findShortestPath(graph: RouteGraph, sourceId: string, targetId: string): string[] | null;
+declare function detectInfiniteRedirects(graph: RouteGraph): CycleResult[];
+declare function getMostConnected(graph: RouteGraph, n?: number): Array<{
+    id: string;
+    degree: number;
+}>;
+
+declare class IncrementalCache {
+    private fileHashes;
+    private fileDependencies;
+    private parsedFiles;
+    private graphSnapshot;
+    private readonly cacheDir;
+    constructor(cacheDir: string);
+    hashFile(content: string): string;
+    getFileHash(filePath: string): string | undefined;
+    setFileHash(filePath: string, hash: string): void;
+    getDependencies(filePath: string): Set<string>;
+    setDependencies(filePath: string, nodeIds: Set<string>): void;
+    getParsedFile(filePath: string): SemanticFile | undefined;
+    setParsedFile(filePath: string, file: SemanticFile): void;
+    getGraphSnapshot(): SerializedGraph | null;
+    setGraphSnapshot(snapshot: SerializedGraph): void;
+    invalidate(filePath: string): InvalidationSet;
+    save(): void;
+    private load;
+}
+declare function computeGraphPatch(before: SerializedGraph, after: SerializedGraph): GraphPatch;
+
+declare class Invalidator {
+    private readonly cache;
+    constructor(cache: IncrementalCache);
+    computeInvalidation(event: FileChangeEvent): InvalidationSet;
+    getAffectedFiles(invalidation: InvalidationSet): string[];
+}
+
+declare class PluginRegistry {
+    private plugins;
+    register(plugin: FrameworkPlugin): void;
+    registerAll(plugins: FrameworkPlugin[]): void;
+    getAll(): FrameworkPlugin[];
+    detectActive(root: string, config: _route_intelligence_shared.AnalyzerConfig): Promise<FrameworkPlugin[]>;
+}
+
+interface Analyzer {
+    analyze(): Promise<AnalysisResult>;
+    watch(): GraphWatcher;
+}
+interface GraphWatcher extends EventEmitter {
+    on(event: 'update', listener: (patch: GraphPatch) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    stop(): Promise<void>;
+}
+declare function createAnalyzer(config: AnalyzerConfig): Analyzer;
+
+declare function createSemanticFile(sourceFile: SourceFile, filePath: string, customNavigationWrappers?: string[]): SemanticFile;
+
+interface PipelineContext {
+    root: string;
+    config: AnalyzerConfig;
+    graph: RouteGraph;
+    plugins: FrameworkPlugin[];
+    files: string[];
+    semanticFiles: Map<string, SemanticFile>;
+    routes: Map<string, RawRoute>;
+    pluginConfigs: Map<string, Record<string, unknown>>;
+}
+interface PipelineStage {
+    readonly name: string;
+    run(ctx: PipelineContext): Promise<void>;
+}
+
+declare class Pipeline {
+    private readonly stages;
+    constructor(stages?: PipelineStage[]);
+    run(ctx: PipelineContext): Promise<{
+        diagnostics: Diagnostic[];
+        metadata: GraphMetadata;
+    }>;
+}
+
+interface GraphMetrics {
+    totalRoutes: number;
+    totalLayouts: number;
+    totalApiRoutes: number;
+    deadRouteCount: number;
+    cycleCount: number;
+    maxDepth: number;
+    averageDepth: number;
+    mostConnected: Array<{
+        id: string;
+        degree: number;
+        path: string;
+    }>;
+    maintainabilityScore: number;
+    riskScore: number;
+}
+declare function computeMetrics(graph: RouteGraph): GraphMetrics;
+declare function metricsToMetadata(graph: RouteGraph, pluginIds: string[]): GraphMetadata;
+
+export { type Analyzer, type GraphWatcher, IncrementalCache, Invalidator, Pipeline, PluginRegistry, RouteGraph, computeGraphPatch, computeMetrics, createAnalyzer, createSemanticFile, detectInfiniteRedirects, exportDot, exportHtml, exportJson, exportMarkdown, exportMermaid, exportPlantUML, findCycles, findDeadRoutes, findShortestPath, getMostConnected, metricsToMetadata };