@mgamil/mapx 0.2.4

package/dist/exporters/svg-exporter.js

@@ -0,0 +1,319 @@
+import { execSync } from "node:child_process";
+import { DotExporter } from "./dot-exporter.js";
+class SvgExporter {
+  store;
+  graph;
+  constructor(store, graph) {
+    this.store = store;
+    this.graph = graph;
+  }
+  export(repo, filesFilter, opts) {
+    if (opts?.forceFallback) {
+      return this.renderFallback(repo, filesFilter, opts);
+    }
+    const dotExporter = new DotExporter(this.store, this.graph);
+    const dot = dotExporter.export(repo, filesFilter, opts);
+    try {
+      return execSync("dot -Tsvg", {
+        input: dot,
+        encoding: "utf-8",
+        maxBuffer: 50 * 1024 * 1024,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      return this.renderFallback(repo, filesFilter, opts);
+    }
+  }
+  renderFallback(repo, filesFilter, opts) {
+    const clusterMode = opts?.cluster ?? "none";
+    let files = this.store.getAllFiles(repo);
+    let edges = this.store.getAllEdges(repo);
+    let rankedFiles = this.graph.getRankedFiles();
+    if (filesFilter) {
+      const allowed = new Set(filesFilter);
+      files = files.filter((f) => allowed.has(f.path));
+      edges = edges.filter((e) => allowed.has(e.source_file) && allowed.has(e.target_file));
+      rankedFiles = rankedFiles.filter((f) => allowed.has(f.path));
+    }
+    const langColors = {
+      php: "#4f5b93",
+      javascript: "#eab308",
+      typescript: "#2563eb",
+      python: "#3b82f6",
+      go: "#06b6d4",
+      rust: "#f97316",
+      java: "#ea580c",
+      c: "#0284c7",
+      cpp: "#0284c7",
+      csharp: "#0891b2",
+      ruby: "#dc2626",
+      swift: "#f97316",
+      kotlin: "#7c3aed",
+      scala: "#dc2626",
+      shell: "#10b981",
+      html: "#f97316",
+      css: "#2563eb",
+      sql: "#005b96",
+      yaml: "#78716c",
+      json: "#78716c",
+      markdown: "#0f172a"
+    };
+    const maxPr = Math.max(...rankedFiles.map((f) => f.pagerank), 1e-3);
+    const rankMap = new Map(rankedFiles.map((f) => [f.path, f.pagerank]));
+    const TARGET_WIDTH = 1200;
+    const MARGIN = 40;
+    const CARD_PADDING = 16;
+    const TITLE_HEIGHT = 28;
+    const CARD_GAP = 24;
+    const ITEM_W = 160;
+    const ITEM_H = 32;
+    const ITEM_GAP_X = 12;
+    const ITEM_GAP_Y = 8;
+    const nodePositions = /* @__PURE__ */ new Map();
+    let svgW = TARGET_WIDTH;
+    let svgH = 0;
+    const cardLines = [];
+    if (clusterMode !== "none") {
+      const clusters = this.store.getClusters(repo);
+      const memberships = this.store.getClusterMemberships(repo);
+      const primaryMemberships = /* @__PURE__ */ new Map();
+      for (const m of memberships) {
+        if (m.is_primary === 1) {
+          primaryMemberships.set(m.file_path, m.cluster_name);
+        }
+      }
+      const clusterMap = /* @__PURE__ */ new Map();
+      const unclustered = [];
+      for (const f of files) {
+        const cName = primaryMemberships.get(f.path);
+        if (cName) {
+          if (!clusterMap.has(cName)) {
+            clusterMap.set(cName, []);
+          }
+          clusterMap.get(cName).push(f);
+        } else {
+          unclustered.push(f);
+        }
+      }
+      const getCols = (N) => {
+        if (N <= 3) return 1;
+        if (N <= 8) return 2;
+        if (N <= 15) return 3;
+        if (N <= 30) return 4;
+        return 5;
+      };
+      const groups = [];
+      for (const [cName, fList] of clusterMap.entries()) {
+        const clusterInfo = clusters.find((c) => c.name === cName);
+        const label = String(clusterInfo?.label || cName);
+        fList.sort((a, b) => {
+          const prA = rankMap.get(a.path) || 0;
+          const prB = rankMap.get(b.path) || 0;
+          return prB - prA;
+        });
+        const N = fList.length;
+        const cols = getCols(N);
+        const width = CARD_PADDING * 2 + cols * ITEM_W + (cols - 1) * ITEM_GAP_X;
+        const rows = Math.ceil(N / cols);
+        const height = CARD_PADDING * 2 + TITLE_HEIGHT + rows * ITEM_H + (rows - 1) * ITEM_GAP_Y;
+        groups.push({
+          name: cName,
+          label,
+          files: fList,
+          cols,
+          width,
+          height
+        });
+      }
+      if (unclustered.length > 0) {
+        unclustered.sort((a, b) => {
+          const prA = rankMap.get(a.path) || 0;
+          const prB = rankMap.get(b.path) || 0;
+          return prB - prA;
+        });
+        const N = unclustered.length;
+        const cols = getCols(N);
+        const width = CARD_PADDING * 2 + cols * ITEM_W + (cols - 1) * ITEM_GAP_X;
+        const rows = Math.ceil(N / cols);
+        const height = CARD_PADDING * 2 + TITLE_HEIGHT + rows * ITEM_H + (rows - 1) * ITEM_GAP_Y;
+        groups.push({
+          name: "__unclustered__",
+          label: "Other Files",
+          files: unclustered,
+          cols,
+          width,
+          height
+        });
+      }
+      groups.sort((a, b) => b.files.length - a.files.length);
+      let currentX = MARGIN;
+      let currentY = MARGIN;
+      let rowMaxHeight = 0;
+      for (const group of groups) {
+        if (currentX + group.width > TARGET_WIDTH - MARGIN && currentX > MARGIN) {
+          currentX = MARGIN;
+          currentY += rowMaxHeight + CARD_GAP;
+          rowMaxHeight = 0;
+        }
+        group.x = currentX;
+        group.y = currentY;
+        cardLines.push(
+          `  <!-- Cluster Group: ${this.escXml(group.name)} -->`,
+          `  <rect x="${group.x}" y="${group.y}" width="${group.width}" height="${group.height}" rx="12" fill="#131b2e" stroke="#1e293b" stroke-width="1.5" class="cluster-card"/>`,
+          `  <text x="${group.x + CARD_PADDING}" y="${group.y + CARD_PADDING + 14}" fill="#94a3b8" font-family="system-ui, -apple-system, sans-serif" font-size="12" font-weight="600" letter-spacing="0.5">${this.escXml(group.label.toUpperCase())}</text>`
+        );
+        const gX = group.x;
+        const gY = group.y;
+        const cols = group.cols;
+        for (let idx = 0; idx < group.files.length; idx++) {
+          const file = group.files[idx];
+          const col = idx % cols;
+          const row = Math.floor(idx / cols);
+          const nodeX = gX + CARD_PADDING + col * (ITEM_W + ITEM_GAP_X);
+          const nodeY = gY + CARD_PADDING + TITLE_HEIGHT + row * (ITEM_H + ITEM_GAP_Y);
+          nodePositions.set(file.path, {
+            x: nodeX,
+            y: nodeY,
+            w: ITEM_W,
+            h: ITEM_H,
+            file
+          });
+        }
+        currentX += group.width + CARD_GAP;
+        if (group.height > rowMaxHeight) {
+          rowMaxHeight = group.height;
+        }
+      }
+      svgH = currentY + rowMaxHeight + MARGIN;
+    } else {
+      const GAP_X = 16;
+      const GAP_Y = 12;
+      const cols = Math.max(1, Math.floor((TARGET_WIDTH - MARGIN * 2 + GAP_X) / (ITEM_W + GAP_X)));
+      files.sort((a, b) => {
+        const prA = rankMap.get(a.path) || 0;
+        const prB = rankMap.get(b.path) || 0;
+        return prB - prA;
+      });
+      for (let i = 0; i < files.length; i++) {
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        const nodeX = MARGIN + col * (ITEM_W + GAP_X);
+        const nodeY = MARGIN + row * (ITEM_H + GAP_Y);
+        nodePositions.set(files[i].path, {
+          x: nodeX,
+          y: nodeY,
+          w: ITEM_W,
+          h: ITEM_H,
+          file: files[i]
+        });
+      }
+      const rows = Math.ceil(files.length / cols);
+      svgH = MARGIN * 2 + rows * ITEM_H + (rows - 1) * GAP_Y;
+    }
+    const edgeStyles = {
+      import: { stroke: "#64748b", dash: "" },
+      require: { stroke: "#64748b", dash: "" },
+      extends: { stroke: "#3b82f6", dash: "" },
+      implements: { stroke: "#10b981", dash: "4,4" },
+      call: { stroke: "#f59e0b", dash: "3,3" },
+      instantiation: { stroke: "#8b5cf6", dash: "3,3" },
+      relation: { stroke: "#3b82f6", dash: "" },
+      route: { stroke: "#10b981", dash: "" },
+      binding: { stroke: "#8b5cf6", dash: "4,4" },
+      middleware: { stroke: "#f97316", dash: "2,2" }
+    };
+    const seen = /* @__PURE__ */ new Set();
+    const edgeLines = [];
+    for (const edge of edges) {
+      const src = edge.source_file;
+      const tgt = edge.target_file;
+      const type = edge.edge_type;
+      const key = `${src}->${tgt}:${type}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const srcNode = nodePositions.get(src);
+      const tgtNode = nodePositions.get(tgt);
+      if (!srcNode || !tgtNode) continue;
+      const sx = srcNode.x + srcNode.w / 2;
+      const sy = srcNode.y + ITEM_H;
+      const tx = tgtNode.x + tgtNode.w / 2;
+      const ty = tgtNode.y;
+      const style = edgeStyles[type] || { stroke: "#64748b", dash: "" };
+      const dash = edge.verifiability === "inferred" ? "5,5" : style.dash;
+      const dashAttr = dash ? ` stroke-dasharray="${dash}"` : "";
+      const midY = (sy + ty) / 2;
+      edgeLines.push(
+        `  <path d="M${sx},${sy} C${sx},${midY} ${tx},${midY} ${tx},${ty}" fill="none" stroke="${style.stroke}" stroke-width="1.2"${dashAttr} opacity="0.35" class="edge-path" marker-end="url(#arrow)"/>`
+      );
+    }
+    const nodeLines = [];
+    for (const [path, n] of nodePositions.entries()) {
+      const pr = rankMap.get(path) || 0;
+      const opacity = 0.7 + 0.3 * (pr / maxPr);
+      const textY = n.y + ITEM_H / 2 + 4.5;
+      const color = langColors[n.file.language] || "#CCCCCC";
+      const textColor = "#ffffff";
+      const isHighRank = pr > maxPr * 0.5;
+      const strokeAttr = isHighRank ? ` stroke="#60a5fa" stroke-width="1.5"` : ` stroke="#1e293b" stroke-width="1"`;
+      const filePath = String(n.file.path || "");
+      nodeLines.push(
+        `  <g class="node-group">`,
+        `    <rect x="${n.x}" y="${n.y}" width="${n.w}" height="${ITEM_H}" rx="6" fill="${color}" opacity="${opacity.toFixed(2)}"${strokeAttr} class="node-rect"/>`,
+        `    <text x="${n.x + n.w / 2}" y="${textY}" text-anchor="middle" fill="${textColor}" font-family="system-ui, -apple-system, sans-serif" font-size="11" font-weight="500">${this.escXml(filePath.split("/").pop() || filePath)}</text>`,
+        `    <title>${this.escXml(filePath)} (PageRank: ${pr.toFixed(4)})</title>`,
+        `  </g>`
+      );
+    }
+    const styleBlock = [
+      "  <style>",
+      "    .cluster-card {",
+      "      transition: stroke 0.2s ease, fill 0.2s ease;",
+      "    }",
+      "    .cluster-card:hover {",
+      "      stroke: #475569;",
+      "      fill: #1e293b;",
+      "    }",
+      "    .node-rect {",
+      "      transition: filter 0.2s ease, stroke 0.2s ease;",
+      "    }",
+      "    .node-rect:hover {",
+      "      filter: brightness(1.2);",
+      "      stroke: #60a5fa;",
+      "      stroke-width: 1.5px;",
+      "      cursor: pointer;",
+      "    }",
+      "    .edge-path {",
+      "      transition: opacity 0.2s ease, stroke-width 0.2s ease;",
+      "    }",
+      "    .edge-path:hover {",
+      "      opacity: 0.85;",
+      "      stroke-width: 2px;",
+      "    }",
+      "  </style>"
+    ].join("\n");
+    const defs = [
+      "  <defs>",
+      '    <marker id="arrow" viewBox="0 0 10 10" refX="6" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">',
+      '      <path d="M 0 2 L 8 5 L 0 8 z" fill="#64748b"/>',
+      "    </marker>",
+      "  </defs>"
+    ].join("\n");
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${svgW} ${svgH}" width="${svgW}" height="${svgH}">`,
+      styleBlock,
+      defs,
+      '  <rect width="100%" height="100%" fill="#0b0f19"/>',
+      ...cardLines,
+      ...edgeLines,
+      ...nodeLines,
+      "</svg>"
+    ].join("\n");
+  }
+  escXml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+}
+export {
+  SvgExporter
+};

package/dist/exporters/toon-exporter.d.ts

@@ -0,0 +1,16 @@
+import { Store } from '../core/store.js';
+import { MapxGraph } from '../core/graph.js';
+import { ExportOptions } from '../types.js';
+import '../core/store-interface.js';
+
+declare function toonQuote(value: string, activeDelimiter?: ',' | '\t' | '|'): string;
+declare function formatNumber(n: number): string;
+declare class ToonExporter {
+    private store;
+    private graph;
+    constructor(store: Store, graph: MapxGraph);
+    export(options?: Partial<ExportOptions>): string;
+    private generateDocument;
+}
+
+export { ToonExporter, formatNumber, toonQuote };

package/dist/exporters/toon-exporter.js

@@ -0,0 +1,246 @@
+function toonQuote(value, activeDelimiter = ",") {
+  const needsQuoting = value === "" || /^\s|\s$/.test(value) || value === "true" || value === "false" || value === "null" || /^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(value) || /[:"\\\[\]{}\u0000-\u001F\u007F-\u009F]/.test(value) || value === "-" || /^-\S/.test(value) || value.includes(activeDelimiter);
+  if (!needsQuoting) return value;
+  return '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\u0000-\u001F\u007F-\u009F]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`) + '"';
+}
+function formatNumber(n) {
+  if (Object.is(n, -0)) return "0";
+  if (isNaN(n) || !isFinite(n)) return "null";
+  if (n === 0) return "0";
+  const abs = Math.abs(n);
+  if (abs >= 1e-6 && abs < 1e21) {
+    let s = n.toString();
+    if (s.includes("e") || s.includes("E")) {
+      s = n.toFixed(20).replace(/\.?0+$/, "");
+    }
+    return s;
+  } else {
+    return n.toString().toLowerCase();
+  }
+}
+class ToonExporter {
+  store;
+  graph;
+  constructor(store, graph) {
+    this.store = store;
+    this.graph = graph;
+  }
+  export(options) {
+    const opt = options || {};
+    const budget = opt.tokenBudget || 8192;
+    const delimiterName = opt.delimiter || "comma";
+    const delimiterMap = { comma: ",", tab: "	", pipe: "|" };
+    const delim = delimiterMap[delimiterName];
+    let files = this.store.getAllFiles(opt.repo);
+    let symbols = this.store.getAllSymbols(opt.repo);
+    let edges = this.store.getAllEdges(opt.repo);
+    const clusters = this.store.getClusters(opt.repo);
+    let rankedFiles = this.graph.getRankedFiles();
+    let rankedSymbols = this.graph.getRankedSymbols();
+    if (opt.files) {
+      const allowed = new Set(opt.files);
+      files = files.filter((f) => allowed.has(f.path));
+      symbols = symbols.filter((s) => allowed.has(s.file_path));
+      edges = edges.filter((e) => allowed.has(e.source_file) && allowed.has(e.target_file));
+      rankedFiles = rankedFiles.filter((f) => allowed.has(f.path));
+      rankedSymbols = rankedSymbols.filter((s) => allowed.has(s.filePath));
+    }
+    let low = 0;
+    let high = symbols.length;
+    let bestOutput = "";
+    const sortedSymbols = [...symbols].sort((a, b) => {
+      const rankA = rankedSymbols.find((rs) => rs.name === a.name && rs.filePath === a.file_path)?.pagerank || 0;
+      const rankB = rankedSymbols.find((rs) => rs.name === b.name && rs.filePath === b.file_path)?.pagerank || 0;
+      return rankB - rankA;
+    });
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const output = this.generateDocument({
+        opt,
+        delim,
+        files,
+        rankedFiles,
+        symbols: sortedSymbols.slice(0, mid),
+        rankedSymbols,
+        edges,
+        clusters,
+        isTruncated: mid < symbols.length,
+        truncatedCount: symbols.length - mid,
+        originalSymbolsCount: symbols.length
+      });
+      const estimatedTokens = Math.ceil(Buffer.byteLength(output, "utf8") / 4);
+      if (estimatedTokens <= budget) {
+        bestOutput = output;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    if (!bestOutput || Math.ceil(Buffer.byteLength(bestOutput, "utf8") / 4) > budget) {
+      let lowEdge = 0;
+      let highEdge = edges.length;
+      let bestEdgeOutput = "";
+      while (lowEdge <= highEdge) {
+        const midEdge = Math.floor((lowEdge + highEdge) / 2);
+        const output = this.generateDocument({
+          opt,
+          delim,
+          files,
+          rankedFiles,
+          symbols: [],
+          rankedSymbols,
+          edges: edges.slice(0, midEdge),
+          clusters,
+          isTruncated: true,
+          truncatedCount: symbols.length,
+          originalSymbolsCount: symbols.length,
+          isEdgesTruncated: midEdge < edges.length,
+          edgesTruncatedCount: edges.length - midEdge
+        });
+        const estimatedTokens = Math.ceil(Buffer.byteLength(output, "utf8") / 4);
+        if (estimatedTokens <= budget) {
+          bestEdgeOutput = output;
+          lowEdge = midEdge + 1;
+        } else {
+          highEdge = midEdge - 1;
+        }
+      }
+      if (bestEdgeOutput) {
+        bestOutput = bestEdgeOutput;
+      } else {
+        bestOutput = this.generateDocument({
+          opt,
+          delim,
+          files: [],
+          rankedFiles: [],
+          symbols: [],
+          rankedSymbols: [],
+          edges: [],
+          clusters: [],
+          isTruncated: true,
+          truncatedCount: symbols.length,
+          originalSymbolsCount: symbols.length
+        });
+      }
+    }
+    return bestOutput.endsWith("\n") ? bestOutput.slice(0, -1) : bestOutput;
+  }
+  generateDocument(params) {
+    const {
+      opt,
+      delim,
+      files,
+      rankedFiles,
+      symbols,
+      rankedSymbols,
+      edges,
+      clusters,
+      isTruncated,
+      truncatedCount,
+      originalSymbolsCount,
+      isEdgesTruncated,
+      edgesTruncatedCount
+    } = params;
+    const parts = [];
+    parts.push("version: 1");
+    parts.push(`generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    parts.push(`repo: ${opt.repo || "all"}`);
+    parts.push(`tokenBudget: ${opt.tokenBudget || 8192}`);
+    parts.push("");
+    parts.push("summary:");
+    parts.push(`  files: ${files.length}`);
+    parts.push(`  symbols: ${originalSymbolsCount}`);
+    parts.push(`  edges: ${edges.length}`);
+    const languages = Array.from(new Set(files.map((f) => f.language))).filter(Boolean).sort();
+    if (languages.length > 0) {
+      const escapedLangs = languages.map((l) => toonQuote(l, delim)).join(delim);
+      parts.push(`  languages[${languages.length}]: ${escapedLangs}`);
+    }
+    parts.push("");
+    const fileRankMap = new Map(rankedFiles.map((f) => [f.path, f.pagerank]));
+    const symbolRankMap = new Map(rankedSymbols.map((s) => [`${s.filePath}::${s.name}`, s.pagerank]));
+    if (files.length > 0) {
+      const sortedFiles = [...files].sort((a, b) => {
+        const rA = fileRankMap.get(a.path) || 0;
+        const rB = fileRankMap.get(b.path) || 0;
+        return rB - rA;
+      });
+      parts.push(`files[${files.length}]{path,language,symbols,pagerank}:`);
+      for (const f of sortedFiles) {
+        const path = toonQuote(f.path, delim);
+        const language = toonQuote(f.language, delim);
+        const symbolsCount = f.lines ? this.store.getSymbolsForFile(f.path).length : 0;
+        const rank = formatNumber(parseFloat((fileRankMap.get(f.path) || 0).toFixed(6)));
+        parts.push(`  ${path}${delim}${language}${delim}${symbolsCount}${delim}${rank}`);
+      }
+      parts.push("");
+    }
+    if (symbols.length > 0) {
+      parts.push(`symbols[${symbols.length}]{name,kind,file,scope,pagerank}:`);
+      for (const s of symbols) {
+        const name = toonQuote(s.name, delim);
+        const kind = toonQuote(s.kind, delim);
+        const file = toonQuote(s.file_path, delim);
+        const scope = toonQuote(s.scope || "", delim);
+        const rankKey = `${s.file_path}::${s.name}`;
+        const rank = formatNumber(parseFloat((symbolRankMap.get(rankKey) || 0).toFixed(6)));
+        parts.push(`  ${name}${delim}${kind}${delim}${file}${delim}${scope}${delim}${rank}`);
+      }
+      parts.push("");
+    }
+    const keptSymbolsSet = new Set(symbols.map((s) => `${s.file_path}::${s.name}`));
+    const filteredEdges = edges.filter((e) => {
+      if (e.source_symbol) {
+        const srcKey = `${e.source_file}::${e.source_symbol}`;
+        if (!keptSymbolsSet.has(srcKey)) return false;
+      }
+      if (e.target_symbol) {
+        const tgtKey = `${e.target_file}::${e.target_symbol}`;
+        if (!keptSymbolsSet.has(tgtKey)) return false;
+      }
+      return true;
+    });
+    if (filteredEdges.length > 0) {
+      parts.push(`edges[${filteredEdges.length}]{sourceFile,targetFile,edgeType,sourceSymbol,targetSymbol,weight}:`);
+      for (const e of filteredEdges) {
+        const sourceFile = toonQuote(e.source_file, delim);
+        const targetFile = toonQuote(e.target_file || "", delim);
+        const edgeType = toonQuote(e.edge_type, delim);
+        const sourceSymbol = toonQuote(e.source_symbol || "", delim);
+        const targetSymbol = toonQuote(e.target_symbol || "", delim);
+        const weight = formatNumber(e.weight || 1);
+        parts.push(`  ${sourceFile}${delim}${targetFile}${delim}${edgeType}${delim}${sourceSymbol}${delim}${targetSymbol}${delim}${weight}`);
+      }
+      parts.push("");
+    }
+    if (clusters.length > 0) {
+      parts.push(`clusters[${clusters.length}]{name,source,parentName,depth,fileCount}:`);
+      for (const c of clusters) {
+        const name = toonQuote(c.name, delim);
+        const source = toonQuote(c.source, delim);
+        const parentName = toonQuote(c.parent_name || "", delim);
+        const depth = formatNumber(c.depth || 0);
+        const fileCount = formatNumber(c.file_count || 0);
+        parts.push(`  ${name}${delim}${source}${delim}${parentName}${delim}${depth}${delim}${fileCount}`);
+      }
+      parts.push("");
+    }
+    if (isTruncated) {
+      parts.push("truncated: true");
+      parts.push("truncatedAt: symbols");
+      parts.push(`includedSymbols: ${symbols.length}`);
+      parts.push(`totalSymbols: ${originalSymbolsCount}`);
+      if (isEdgesTruncated) {
+        parts.push("edgesTruncated: true");
+        parts.push(`includedEdges: ${filteredEdges.length}`);
+        parts.push(`totalEdges: ${edges.length}`);
+      }
+    }
+    return parts.join("\n");
+  }
+}
+export {
+  ToonExporter,
+  formatNumber,
+  toonQuote
+};

package/dist/frameworks/detectors/aspnet.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class AspNetDetector implements FrameworkDetector {
+    readonly name = "aspnet";
+    readonly language = "csharp";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { AspNetDetector };

package/dist/frameworks/detectors/aspnet.js

@@ -0,0 +1,52 @@
+class AspNetDetector {
+  name = "aspnet";
+  language = "csharp";
+  filePattern = /\.cs$/;
+  async detect(projectRoot, files) {
+    const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
+    if (hasCsproj) return true;
+    return files.some((f) => f.endsWith(".cs"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("Controller") && !content.includes("Route") && !content.includes("Http")) {
+      return [];
+    }
+    const classMatch = content.match(/\bclass\s+([a-zA-Z0-9_]+)\b/);
+    if (!classMatch) return [];
+    const className = classMatch[1];
+    const controllerName = className.endsWith("Controller") ? className.substring(0, className.length - 10).toLowerCase() : className.toLowerCase();
+    let classRoutePrefix = "";
+    const classRouteMatch = content.match(/\[Route\s*\(\s*['"]([^'"]+)['"]\s*\)\]/);
+    if (classRouteMatch) {
+      classRoutePrefix = classRouteMatch[1];
+      classRoutePrefix = classRoutePrefix.replace(/\[controller\]/gi, controllerName);
+    }
+    const methodRouteRegex = /\[Http(Get|Post|Put|Delete|Patch)(?:\s*\(\s*['"]([^'"]+)['"]\s*\))?\][^({]*?\b([a-zA-Z0-9_]+)\s*\(/g;
+    let match;
+    while ((match = methodRouteRegex.exec(content)) !== null) {
+      const verb = match[1].toUpperCase();
+      const methodTemplate = match[2] || "";
+      const methodName = match[3];
+      const cleanClassPrefix = classRoutePrefix.replace(/^\/|\/$/g, "");
+      const cleanMethodTemplate = methodTemplate.replace(/^\/|\/$/g, "");
+      let combinedPath = "/" + [cleanClassPrefix, cleanMethodTemplate].filter(Boolean).join("/");
+      combinedPath = combinedPath.replace(/\{([a-zA-Z0-9_?*]+)(?::[a-zA-Z0-9_]+)?\}/g, "{$1}");
+      routes.push({
+        framework: this.name,
+        method: verb,
+        path: combinedPath,
+        handlerFile: filePath,
+        handlerSymbol: `${className}.${methodName}`,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    return routes;
+  }
+}
+export {
+  AspNetDetector
+};

package/dist/frameworks/detectors/django.d.ts

@@ -0,0 +1,14 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class DjangoDetector implements FrameworkDetector {
+    readonly name = "django";
+    readonly language = "python";
+    readonly filePattern: RegExp;
+    private projectFiles;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+    private parseUrlsFile;
+    private resolveModulePath;
+}
+
+export { DjangoDetector };