@aiready/visualizer 0.7.3 → 0.7.5

package/dist/index.js

@@ -1,6 +1,79 @@
 import fs from 'fs';
-import path from 'path';
-import { UnifiedReportSchema, ToolName, Severity } from '@aiready/core';
+import path2 from 'path';
+import { Severity, UnifiedReportSchema, ToolName, normalizeAnalysisResult } from '@aiready/core';
+
+// src/graph/builder.ts
+var GRAPH_CONSTANTS = {
+  DEFAULT_NODE_SIZE: 1,
+  DEFAULT_REFERENCE_SIZE: 5,
+  DEFAULT_DEPENDENCY_SIZE: 2,
+  DEFAULT_CONTEXT_SIZE: 10,
+  FUZZY_MATCH_THRESHOLD: 50,
+  FUZZY_MATCH_HIGH_THRESHOLD: 80,
+  COLORS: {
+    CRITICAL: "#ff4d4f",
+    MAJOR: "#ff9900",
+    MINOR: "#ffd666",
+    INFO: "#91d5ff",
+    DEFAULT: "#97c2fc"
+  },
+  SEVERITY_ORDER: {
+    [Severity.Critical]: 3,
+    [Severity.Major]: 2,
+    [Severity.Minor]: 1,
+    [Severity.Info]: 0
+  }
+};
+function normalizeLabel(filePath, rootDir) {
+  try {
+    return path2.relative(rootDir, filePath);
+  } catch {
+    return filePath;
+  }
+}
+function extractReferencedPaths(message) {
+  if (!message || typeof message !== "string") return [];
+  const reAbs = /\/(?:[\w\-.]+\/)+[\w\-.]+\.(?:ts|tsx|js|jsx|py|java|go)/g;
+  const reRel = /(?:\.\/|\.\.\/)(?:[\w\-.]+\/)+[\w\-.]+\.(?:ts|tsx|js|jsx|py|java|go)/g;
+  const abs = message.match(reAbs) ?? [];
+  const rel = message.match(reRel) ?? [];
+  return abs.concat(rel);
+}
+function getPackageGroup(fp) {
+  if (!fp) return void 0;
+  const parts = fp.split(path2.sep);
+  const pkgIdx = parts.indexOf("packages");
+  if (pkgIdx >= 0 && parts.length > pkgIdx + 1)
+    return `packages/${parts[pkgIdx + 1]}`;
+  const landingIdx = parts.indexOf("landing");
+  if (landingIdx >= 0) return "landing";
+  const scriptsIdx = parts.indexOf("scripts");
+  if (scriptsIdx >= 0) return "scripts";
+  return parts.length > 1 ? parts[1] : parts[0];
+}
+function rankSeverity(s) {
+  if (!s) return null;
+  const ss = String(s).toLowerCase();
+  if (ss.includes("critical")) return Severity.Critical;
+  if (ss.includes("major")) return Severity.Major;
+  if (ss.includes("minor")) return Severity.Minor;
+  if (ss.includes("info")) return Severity.Info;
+  return null;
+}
+function getColorForSeverity(sev) {
+  switch (sev) {
+    case Severity.Critical:
+      return GRAPH_CONSTANTS.COLORS.CRITICAL;
+    case Severity.Major:
+      return GRAPH_CONSTANTS.COLORS.MAJOR;
+    case Severity.Minor:
+      return GRAPH_CONSTANTS.COLORS.MINOR;
+    case Severity.Info:
+      return GRAPH_CONSTANTS.COLORS.INFO;
+    default:
+      return GRAPH_CONSTANTS.COLORS.DEFAULT;
+  }
+}
 
 // src/graph/builder.ts
 var GraphBuilder = class _GraphBuilder {
@@ -10,97 +83,59 @@ var GraphBuilder = class _GraphBuilder {
     this.edges = [];
     this.edgesSet = /* @__PURE__ */ new Set();
   }
-  normalizeLabel(filePath) {
-    try {
-      return path.relative(this.rootDir, filePath);
-    } catch {
-      return filePath;
-    }
-  }
-  extractReferencedPaths(message) {
-    if (!message || typeof message !== "string") return [];
-    const reAbs = /\/(?:[\w\-.]+\/)+[\w\-.]+\.(?:ts|tsx|js|jsx|py|java|go)/g;
-    const reRel = /(?:\.\/|\.\.\/)(?:[\w\-.]+\/)+[\w\-.]+\.(?:ts|tsx|js|jsx|py|java|go)/g;
-    const abs = message.match(reAbs) ?? [];
-    const rel = message.match(reRel) ?? [];
-    return abs.concat(rel);
-  }
-  getPackageGroup(fp) {
-    if (!fp) return null;
-    const parts = fp.split(path.sep);
-    const pkgIdx = parts.indexOf("packages");
-    if (pkgIdx >= 0 && parts.length > pkgIdx + 1)
-      return `packages/${parts[pkgIdx + 1]}`;
-    const landingIdx = parts.indexOf("landing");
-    if (landingIdx >= 0) return "landing";
-    const scriptsIdx = parts.indexOf("scripts");
-    if (scriptsIdx >= 0) return "scripts";
-    return parts.length > 1 ? parts[1] : parts[0];
-  }
   /**
    * Add a new node to the graph or update an existing one.
-   *
-   * @param file - Unique identifier for the file (node ID).
-   * @param title - Optional title or description for the node.
-   * @param value - Numerical value representing the node size/weight.
    */
-  addNode(file, title = "", value = 1) {
+  addNode(file, title = "", size = GRAPH_CONSTANTS.DEFAULT_NODE_SIZE) {
     if (!file) return;
-    const id = path.resolve(this.rootDir, file);
-    if (!this.nodesMap.has(id)) {
+    const id = path2.resolve(this.rootDir, file);
+    const existingNode = this.nodesMap.get(id);
+    if (!existingNode) {
       const node = {
         id,
         path: id,
-        label: this.normalizeLabel(id),
+        label: normalizeLabel(id, this.rootDir),
         title,
-        size: value ?? 1
+        size
       };
       this.nodesMap.set(id, node);
     } else {
-      const node = this.nodesMap.get(id);
-      if (title && (!node.title || !node.title.includes(title))) {
-        node.title = (node.title ? node.title + "\n" : "") + title;
+      if (title && (!existingNode.title || !existingNode.title.includes(title))) {
+        existingNode.title = (existingNode.title ? existingNode.title + "\n" : "") + title;
+      }
+      if (size > (existingNode.size ?? 0)) {
+        existingNode.size = size;
       }
-      if (value > (node.size ?? 0)) node.size = value;
     }
   }
   /**
    * Add a directed edge between two nodes in the graph.
-   *
-   * @param from - Source node ID (file path).
-   * @param to - Target node ID (file path).
-   * @param type - Type of relationship (e.g., 'dependency', 'reference').
    */
   addEdge(from, to, type = "link") {
     if (!from || !to) return;
-    const a = path.resolve(this.rootDir, from);
-    const b = path.resolve(this.rootDir, to);
-    if (a === b) return;
-    const key = `${a}->${b}`;
+    const source = path2.resolve(this.rootDir, from);
+    const target = path2.resolve(this.rootDir, to);
+    if (source === target) return;
+    const key = `${source}->${target}`;
     if (!this.edgesSet.has(key)) {
-      this.edges.push({ source: a, target: b, type });
+      this.edges.push({ source, target, type });
       this.edgesSet.add(key);
     }
   }
   /**
    * Build the final GraphData object from collected nodes and edges.
-   *
-   * @returns Consolidated graph data structure.
    */
   build() {
     const nodes = Array.from(this.nodesMap.values());
-    const edges = this.edges.map(
-      (e) => ({ source: e.source, target: e.target, type: e.type })
-    );
     return {
       nodes,
-      edges,
+      edges: [...this.edges],
       clusters: [],
       issues: [],
       metadata: {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         totalFiles: nodes.length,
-        totalDependencies: edges.length,
+        totalDependencies: this.edges.length,
         analysisTypes: [],
         criticalIssues: 0,
         majorIssues: 0,
@@ -115,10 +150,6 @@ var GraphBuilder = class _GraphBuilder {
   }
   /**
    * Static helper to build graph from an AIReady report JSON.
-   *
-   * @param report - Unified AIReady report object.
-   * @param rootDir - Root directory for path resolution.
-   * @returns Fully populated GraphData for visualization.
    */
   static buildFromReport(report, rootDir = process.cwd()) {
     const validation = UnifiedReportSchema.safeParse(report);
@@ -129,31 +160,18 @@ var GraphBuilder = class _GraphBuilder {
     }
     const builder = new _GraphBuilder(rootDir);
     const fileIssues = /* @__PURE__ */ new Map();
-    const rankSeverity = (s) => {
-      if (!s) return null;
-      const ss = String(s).toLowerCase();
-      if (ss.includes("critical")) return Severity.Critical;
-      if (ss.includes("major")) return Severity.Major;
-      if (ss.includes("minor")) return Severity.Minor;
-      if (ss.includes("info")) return Severity.Info;
-      return null;
-    };
-    const bumpIssue = (file, sev) => {
+    const bumpIssue = (file, severity) => {
       if (!file) return;
-      const id = path.resolve(rootDir, file);
-      if (!fileIssues.has(id))
+      const id = path2.resolve(rootDir, file);
+      if (!fileIssues.has(id)) {
         fileIssues.set(id, { count: 0, maxSeverity: null, duplicates: 0 });
-      const rec = fileIssues.get(id);
-      rec.count += 1;
-      if (sev) {
-        const order = {
-          [Severity.Critical]: 3,
-          [Severity.Major]: 2,
-          [Severity.Minor]: 1,
-          [Severity.Info]: 0
-        };
-        if (!rec.maxSeverity || order[sev] > order[rec.maxSeverity])
-          rec.maxSeverity = sev;
+      }
+      const record = fileIssues.get(id);
+      record.count += 1;
+      if (severity) {
+        if (!record.maxSeverity || GRAPH_CONSTANTS.SEVERITY_ORDER[severity] > GRAPH_CONSTANTS.SEVERITY_ORDER[record.maxSeverity]) {
+          record.maxSeverity = severity;
+        }
       }
     };
     const getResults = (toolKey, legacyKey) => {
@@ -163,120 +181,183 @@ var GraphBuilder = class _GraphBuilder {
       if (Array.isArray(toolData)) return toolData;
       return toolData.results ?? toolData.issues ?? [];
     };
+    this.processPatterns(
+      builder,
+      getResults(ToolName.PatternDetect, "patterns"),
+      rootDir,
+      bumpIssue
+    );
+    this.processDuplicates(builder, report, rootDir, fileIssues);
+    this.processContext(
+      builder,
+      getResults(ToolName.ContextAnalyzer, "context"),
+      rootDir,
+      bumpIssue
+    );
+    this.processToolResults(
+      builder,
+      ToolName.DocDrift,
+      "docDrift",
+      report,
+      bumpIssue,
+      "Doc-Drift Issue"
+    );
+    this.processToolResults(
+      builder,
+      ToolName.DependencyHealth,
+      "dependencyHealth",
+      report,
+      bumpIssue,
+      "Dependency Issue"
+    );
+    this.processToolResults(
+      builder,
+      ToolName.ContractEnforcement,
+      "contractEnforcement",
+      report,
+      bumpIssue,
+      "Contract Gap"
+    );
+    return this.finalizeGraph(builder, fileIssues, report);
+  }
+  static processPatterns(builder, results, rootDir, bumpIssue) {
     const basenameMap = /* @__PURE__ */ new Map();
-    const patternResults = getResults(ToolName.PatternDetect, "patterns");
-    patternResults.forEach((p) => {
+    results.forEach((p) => {
       const fileName = p.fileName ?? p.file;
       if (fileName) {
-        const base = path.basename(fileName);
+        const base = path2.basename(fileName);
         if (!basenameMap.has(base)) basenameMap.set(base, /* @__PURE__ */ new Set());
         basenameMap.get(base).add(fileName);
       }
     });
-    patternResults.forEach((entry) => {
-      const file = entry.fileName ?? entry.file;
+    results.forEach((entry) => {
+      const normalized = normalizeAnalysisResult(entry);
+      const file = normalized.fileName;
       if (!file) return;
       builder.addNode(
         file,
-        `Issues: ${(entry.issues ?? []).length}`,
-        entry.metrics?.tokenCost ?? 5
+        `Issues: ${normalized.issues.length}`,
+        normalized.metrics.tokenCost || GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE
       );
-      if ((entry.issues ?? []).length > 0) {
-        (entry.issues ?? []).forEach((issue) => {
-          const sev = rankSeverity(
-            issue.severity ?? issue.severityLevel ?? null
-          );
-          bumpIssue(file, sev);
+      const rawIssues = Array.isArray(entry.issues) ? entry.issues : [];
+      if (rawIssues.length > 0) {
+        rawIssues.forEach((issue) => {
+          bumpIssue(file, rankSeverity(issue.severity));
+        });
+      } else {
+        normalized.issues.forEach((issue) => {
+          bumpIssue(file, issue.severity);
         });
       }
-      (entry.issues ?? []).forEach((issue) => {
-        const message = issue.message || "";
-        const refs = builder.extractReferencedPaths(message);
+      normalized.issues.forEach((issue) => {
+        const refs = extractReferencedPaths(issue.message);
         refs.forEach((ref) => {
-          let target = ref;
-          if (!path.isAbsolute(ref)) {
-            target = path.resolve(path.dirname(file), ref);
-          }
-          builder.addNode(target, "Referenced file", 5);
+          const target = path2.isAbsolute(ref) ? ref : path2.resolve(path2.dirname(file), ref);
+          builder.addNode(
+            target,
+            "Referenced file",
+            GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE
+          );
           builder.addEdge(file, target, "reference");
         });
-        const percMatch = (message.match(/(\d+)%/) || [])[1];
+        const percMatch = (issue.message.match(/(\d+)%/) || [])[1];
         const perc = percMatch ? parseInt(percMatch, 10) : null;
-        const wantFuzzy = issue.type === "duplicate-pattern" || /similar/i.test(message) || perc && perc >= 50;
+        const wantFuzzy = issue.type === "duplicate-pattern" || /similar/i.test(issue.message) || perc !== null && perc >= GRAPH_CONSTANTS.FUZZY_MATCH_THRESHOLD;
         if (wantFuzzy) {
-          const fileGroup = builder.getPackageGroup(file);
+          const fileGroup = getPackageGroup(file);
           for (const [base, pathsSet] of basenameMap.entries()) {
-            if (!message.includes(base) || base === path.basename(file))
+            if (!issue.message.includes(base) || base === path2.basename(file))
               continue;
             for (const target of pathsSet) {
-              const targetGroup = builder.getPackageGroup(target);
-              if (fileGroup !== targetGroup && !(perc && perc >= 80)) continue;
-              builder.addNode(target, "Fuzzy match", 5);
+              const targetGroup = getPackageGroup(target);
+              if (fileGroup !== targetGroup && !(perc !== null && perc >= GRAPH_CONSTANTS.FUZZY_MATCH_HIGH_THRESHOLD))
+                continue;
+              builder.addNode(
+                target,
+                "Fuzzy match",
+                GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE
+              );
               builder.addEdge(file, target, "similarity");
             }
           }
         }
       });
     });
+  }
+  static processDuplicates(builder, report, rootDir, fileIssues) {
     const patternData = report[ToolName.PatternDetect] || report.patternDetect || report.patterns || {};
     const duplicates = (Array.isArray(patternData.duplicates) ? patternData.duplicates : null) || (patternData.summary && Array.isArray(patternData.summary.duplicates) ? patternData.summary.duplicates : null) || (Array.isArray(report.duplicates) ? report.duplicates : []);
     duplicates.forEach((dup) => {
-      builder.addNode(dup.file1, "Similarity target", 5);
-      builder.addNode(dup.file2, "Similarity target", 5);
+      builder.addNode(
+        dup.file1,
+        "Similarity target",
+        GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE
+      );
+      builder.addNode(
+        dup.file2,
+        "Similarity target",
+        GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE
+      );
       builder.addEdge(dup.file1, dup.file2, "similarity");
-      const f1 = path.resolve(rootDir, dup.file1);
-      const f2 = path.resolve(rootDir, dup.file2);
-      if (!fileIssues.has(f1))
-        fileIssues.set(f1, { count: 0, maxSeverity: null, duplicates: 0 });
-      if (!fileIssues.has(f2))
-        fileIssues.set(f2, { count: 0, maxSeverity: null, duplicates: 0 });
-      fileIssues.get(f1).duplicates += 1;
-      fileIssues.get(f2).duplicates += 1;
+      [dup.file1, dup.file2].forEach((file) => {
+        const id = path2.resolve(rootDir, file);
+        if (!fileIssues.has(id)) {
+          fileIssues.set(id, { count: 0, maxSeverity: null, duplicates: 0 });
+        }
+        fileIssues.get(id).duplicates += 1;
+      });
     });
-    const contextResults = getResults(ToolName.ContextAnalyzer, "context");
-    contextResults.forEach((ctx) => {
-      const file = ctx.fileName ?? ctx.file;
+  }
+  static processContext(builder, results, rootDir, bumpIssue) {
+    results.forEach((ctx) => {
+      const normalized = normalizeAnalysisResult(ctx);
+      const file = normalized.fileName;
       if (!file) return;
-      builder.addNode(file, `Deps: ${ctx.dependencyCount || 0}`, 10);
-      if (ctx.issues && Array.isArray(ctx.issues)) {
-        ctx.issues.forEach((issue) => {
-          const sev = rankSeverity(
-            typeof issue === "string" ? ctx.severity : issue.severity ?? issue.severityLevel ?? null
-          );
-          bumpIssue(file, sev);
-        });
-      }
+      builder.addNode(
+        file,
+        `Deps: ${ctx.dependencyCount || 0}`,
+        GRAPH_CONSTANTS.DEFAULT_CONTEXT_SIZE
+      );
+      normalized.issues.forEach((issue) => {
+        bumpIssue(file, issue.severity);
+      });
       (ctx.relatedFiles ?? []).forEach((rel) => {
-        const resolvedRel = path.isAbsolute(rel) ? rel : path.resolve(path.dirname(file), rel);
-        const keyA = `${path.resolve(builder.rootDir, file)}->${path.resolve(builder.rootDir, resolvedRel)}`;
-        const keyB = `${path.resolve(builder.rootDir, resolvedRel)}->${path.resolve(builder.rootDir, file)}`;
-        if (builder.edgesSet.has(keyA) || builder.edgesSet.has(keyB))
+        const resolvedRel = path2.isAbsolute(rel) ? rel : path2.resolve(path2.dirname(file), rel);
+        const resolvedFile = path2.resolve(builder.rootDir, file);
+        const resolvedTarget = path2.resolve(builder.rootDir, resolvedRel);
+        const keyA = `${resolvedFile}->${resolvedTarget}`;
+        const keyB = `${resolvedTarget}->${resolvedFile}`;
+        if (builder["edgesSet"].has(keyA) || builder["edgesSet"].has(keyB))
           return;
-        builder.addNode(resolvedRel, "Related file", 5);
-        const n = builder.nodesMap.get(
-          path.resolve(builder.rootDir, resolvedRel)
+        builder.addNode(
+          resolvedRel,
+          "Related file",
+          GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE
         );
-        if (n) n.size = (n.size || 1) + 2;
-        try {
-          builder.addEdge(file, resolvedRel, "related");
-        } catch {
+        const node = builder["nodesMap"].get(resolvedTarget);
+        if (node) {
+          node.size = (node.size || 1) + 2;
         }
+        builder.addEdge(file, resolvedRel, "related");
       });
-      const absoluteFile = path.resolve(builder.rootDir, file);
-      const fileDir = path.dirname(absoluteFile);
+      const fileDir = path2.dirname(path2.resolve(builder.rootDir, file));
       (ctx.dependencyList ?? []).forEach((dep) => {
         if (dep.startsWith(".") || dep.startsWith("/")) {
           const possiblePaths = [
-            path.resolve(fileDir, dep),
-            path.resolve(fileDir, dep + ".ts"),
-            path.resolve(fileDir, dep + ".tsx"),
-            path.resolve(fileDir, dep + ".js"),
-            path.resolve(fileDir, dep, "index.ts"),
-            path.resolve(fileDir, dep, "index.tsx")
+            path2.resolve(fileDir, dep),
+            path2.resolve(fileDir, dep + ".ts"),
+            path2.resolve(fileDir, dep + ".tsx"),
+            path2.resolve(fileDir, dep + ".js"),
+            path2.resolve(fileDir, dep, "index.ts"),
+            path2.resolve(fileDir, dep, "index.tsx")
           ];
           for (const p of possiblePaths) {
             if (fs.existsSync(p)) {
-              builder.addNode(p, "Dependency", 2);
+              builder.addNode(
+                p,
+                "Dependency",
+                GRAPH_CONSTANTS.DEFAULT_DEPENDENCY_SIZE
+              );
               builder.addEdge(file, p, "dependency");
               break;
             }
@@ -284,100 +365,64 @@ var GraphBuilder = class _GraphBuilder {
         }
       });
     });
-    const docDriftResults = getResults(ToolName.DocDrift, "docDrift");
-    docDriftResults.forEach((issue) => {
-      const file = issue.fileName ?? issue.location?.file;
-      if (file) {
-        builder.addNode(file, "Doc-Drift Issue", 5);
-        const sev = rankSeverity(issue.severity ?? null);
-        bumpIssue(file, sev);
-      }
-    });
-    const depsResults = getResults(
-      ToolName.DependencyHealth,
-      "dependencyHealth"
-    );
-    depsResults.forEach((issue) => {
-      const file = issue.fileName ?? issue.location?.file;
-      if (file) {
-        builder.addNode(file, "Dependency Issue", 5);
-        const sev = rankSeverity(issue.severity ?? null);
-        bumpIssue(file, sev);
+  }
+  static processToolResults(builder, toolName, legacyKey, report, bumpIssue, title) {
+    const camelKey = toolName.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+    const toolData = report[toolName] ?? report[camelKey] ?? report[legacyKey];
+    if (!toolData) return;
+    const results = Array.isArray(toolData) ? toolData : toolData.results ?? toolData.issues ?? [];
+    results.forEach((item) => {
+      if (!Array.isArray(item.issues) && (item.severity || item.message)) {
+        const file2 = item.fileName ?? item.file ?? item.location?.file;
+        if (file2) {
+          builder.addNode(file2, title, GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE);
+          bumpIssue(file2, rankSeverity(item.severity));
+        }
+        return;
       }
-    });
-    const contractEnforcementResults = getResults(
-      ToolName.ContractEnforcement,
-      "contractEnforcement"
-    );
-    contractEnforcementResults.forEach((issue) => {
-      const file = issue.fileName ?? issue.location?.file;
+      const normalized = normalizeAnalysisResult(item);
+      const file = normalized.fileName;
       if (file) {
-        builder.addNode(file, "Contract Gap", 5);
-        const sev = rankSeverity(issue.severity ?? null);
-        bumpIssue(file, sev);
+        builder.addNode(file, title, GRAPH_CONSTANTS.DEFAULT_REFERENCE_SIZE);
+        normalized.issues.forEach((issue) => {
+          bumpIssue(file, issue.severity);
+        });
       }
     });
-    const nodes = Array.from(builder.nodesMap.values());
-    const edges = builder.edges;
-    const colorFor = (sev) => {
-      switch (sev) {
-        case Severity.Critical:
-          return "#ff4d4f";
-        // red
-        case Severity.Major:
-          return "#ff9900";
-        // orange
-        case Severity.Minor:
-          return "#ffd666";
-        // yellow
-        case Severity.Info:
-          return "#91d5ff";
-        // light blue
-        default:
-          return "#97c2fc";
-      }
-    };
+  }
+  static finalizeGraph(builder, fileIssues, report) {
+    const graph = builder.build();
     let criticalIssues = 0;
     let majorIssues = 0;
     let minorIssues = 0;
     let infoIssues = 0;
-    for (const node of nodes) {
-      const n = node;
-      const rec = fileIssues.get(n.id);
-      if (rec) {
-        n.duplicates = rec.duplicates || 0;
-        n.color = colorFor(rec.maxSeverity);
-        n.group = builder.getPackageGroup(n.id) || void 0;
-        if (rec.maxSeverity === Severity.Critical) criticalIssues += rec.count;
-        else if (rec.maxSeverity === Severity.Major) majorIssues += rec.count;
-        else if (rec.maxSeverity === Severity.Minor) minorIssues += rec.count;
-        else if (rec.maxSeverity === Severity.Info) infoIssues += rec.count;
+    graph.nodes.forEach((node) => {
+      const record = fileIssues.get(node.id);
+      if (record) {
+        node.duplicates = record.duplicates || 0;
+        node.color = getColorForSeverity(record.maxSeverity);
+        node.group = getPackageGroup(node.id);
+        if (record.maxSeverity === Severity.Critical)
+          criticalIssues += record.count;
+        else if (record.maxSeverity === Severity.Major)
+          majorIssues += record.count;
+        else if (record.maxSeverity === Severity.Minor)
+          minorIssues += record.count;
+        else if (record.maxSeverity === Severity.Info)
+          infoIssues += record.count;
       } else {
-        n.color = colorFor(null);
-        n.group = builder.getPackageGroup(n.id) || void 0;
-        n.duplicates = 0;
-      }
-    }
-    const graph = {
-      nodes,
-      edges,
-      clusters: [],
-      issues: [],
-      metadata: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        totalFiles: nodes.length,
-        totalDependencies: edges.length,
-        analysisTypes: [],
-        criticalIssues,
-        majorIssues,
-        minorIssues,
-        infoIssues,
-        tokenBudget: report.scoring?.tokenBudget
-      },
-      truncated: {
-        nodes: false,
-        edges: false
+        node.color = getColorForSeverity(null);
+        node.group = getPackageGroup(node.id);
+        node.duplicates = 0;
       }
+    });
+    graph.metadata = {
+      ...graph.metadata,
+      criticalIssues,
+      majorIssues,
+      minorIssues,
+      infoIssues,
+      tokenBudget: report.scoring?.tokenBudget
     };
     return graph;
   }