@mgamil/mapx 0.2.4

package/dist/exporters/dot-exporter.js

@@ -0,0 +1,179 @@
+class DotExporter {
+  store;
+  graph;
+  constructor(store, graph) {
+    this.store = store;
+    this.graph = graph;
+  }
+  export(repo, filesFilter, opts) {
+    const clusterMode = opts?.cluster ?? "none";
+    const maxClusterDepth = opts?.depth ?? Infinity;
+    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 lines = [];
+    lines.push("digraph Mapx {");
+    lines.push("  newrank=true;");
+    lines.push("  rankdir=LR;");
+    lines.push("  node [shape=box, style=filled];");
+    lines.push("");
+    const langColors = {
+      php: "#8892BF",
+      javascript: "#F7DF1E",
+      typescript: "#3178C6",
+      python: "#3776AB",
+      go: "#00ADD8",
+      rust: "#DEA584",
+      java: "#ED8B00"
+    };
+    const rankMap = new Map(rankedFiles.map((f) => [f.path, f.pagerank]));
+    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 roots = [];
+    const childrenMap = /* @__PURE__ */ new Map();
+    const clusterFilesMap = /* @__PURE__ */ new Map();
+    for (const c of clusters) {
+      if (!c.parent_name) {
+        roots.push(c);
+      } else {
+        const parentName = c.parent_name;
+        if (!childrenMap.has(parentName)) {
+          childrenMap.set(parentName, []);
+        }
+        childrenMap.get(parentName).push(c);
+      }
+    }
+    for (const file of files) {
+      const path = file.path;
+      const clusterName = primaryMemberships.get(path);
+      if (clusterName) {
+        if (!clusterFilesMap.has(clusterName)) {
+          clusterFilesMap.set(clusterName, []);
+        }
+        clusterFilesMap.get(clusterName).push(path);
+      }
+    }
+    const outputCluster = (node, indent, currentDepth) => {
+      const pad = "  ".repeat(indent);
+      const subLines = [];
+      const safeId = "cluster_" + node.name.replace(/[^a-zA-Z0-9]/g, "_");
+      subLines.push(`${pad}subgraph "${safeId}" {`);
+      subLines.push(`${pad}  label="${node.label}";`);
+      subLines.push(`${pad}  color=gray;`);
+      subLines.push(`${pad}  style=dashed;`);
+      const fList = clusterFilesMap.get(node.name) || [];
+      for (const f of fList) {
+        const lang = files.find((file) => file.path === f)?.language;
+        const color = langColors[lang] || "#CCCCCC";
+        const label = f.split("/").pop() || f;
+        subLines.push(`${pad}  "${f}" [label="${label}", fillcolor="${color}", fontcolor="white"];`);
+      }
+      const children = childrenMap.get(node.name) || [];
+      if (currentDepth < maxClusterDepth) {
+        for (const child of children) {
+          subLines.push(...outputCluster(child, indent + 1, currentDepth + 1));
+        }
+      } else {
+        const flattenFiles = (c) => {
+          const fList2 = clusterFilesMap.get(c.name) || [];
+          for (const f2 of fList2) {
+            const lang2 = files.find((file) => file.path === f2)?.language;
+            const color2 = langColors[lang2] || "#CCCCCC";
+            const label2 = f2.split("/").pop() || f2;
+            subLines.push(`${pad}  "${f2}" [label="${label2}", fillcolor="${color2}", fontcolor="white"];`);
+          }
+          for (const gc of childrenMap.get(c.name) || []) {
+            flattenFiles(gc);
+          }
+        };
+        for (const child of children) {
+          flattenFiles(child);
+        }
+      }
+      subLines.push(`${pad}}`);
+      return subLines;
+    };
+    if (clusterMode === "none") {
+      for (const file of files) {
+        const path = file.path;
+        const lang = file.language;
+        const color = langColors[lang] || "#CCCCCC";
+        const label = path.split("/").pop() || path;
+        lines.push(`  "${path}" [label="${label}", fillcolor="${color}", fontcolor="white"];`);
+      }
+    } else {
+      for (const file of files) {
+        const path = file.path;
+        if (!primaryMemberships.has(path)) {
+          const lang = file.language;
+          const color = langColors[lang] || "#CCCCCC";
+          const label = path.split("/").pop() || path;
+          lines.push(`  "${path}" [label="${label}", fillcolor="${color}", fontcolor="white"];`);
+        }
+      }
+      for (const root of roots) {
+        lines.push(...outputCluster(root, 1, 1));
+      }
+    }
+    lines.push("");
+    const edgeStyles = {
+      import: "solid",
+      require: "solid",
+      extends: "bold",
+      implements: "dashed",
+      call: "dotted",
+      instantiation: "dotted",
+      relation: "bold",
+      route: "solid",
+      binding: "dashed",
+      middleware: "dotted",
+      dispatch: "dashed",
+      notify: "dotted"
+    };
+    const seen = /* @__PURE__ */ new Set();
+    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);
+      let style = edgeStyles[type] || "solid";
+      if (edge.verifiability === "inferred") {
+        style = "dashed";
+      }
+      let colorAttr = "";
+      if (type === "relation") {
+        colorAttr = ', color="blue"';
+      } else if (type === "route") {
+        colorAttr = ', color="green"';
+      } else if (type === "binding") {
+        colorAttr = ', color="purple"';
+      } else if (type === "middleware") {
+        colorAttr = ', color="orange"';
+      } else if (type === "dispatch") {
+        colorAttr = ', color="magenta"';
+      } else if (type === "notify") {
+        colorAttr = ', color="pink"';
+      }
+      lines.push(`  "${src}" -> "${tgt}" [label="${type}", style=${style}${colorAttr}];`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+}
+export {
+  DotExporter
+};

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

@@ -0,0 +1,14 @@
+import { Store } from '../core/store.js';
+import { MapxGraph } from '../core/graph.js';
+import '../core/store-interface.js';
+import '../types.js';
+
+declare class GraphExporter {
+    private store;
+    private graph;
+    constructor(store: Store, graph: MapxGraph);
+    exportAsJSON(repo?: string, filesFilter?: string[]): object;
+    exportAsJSONString(repo?: string, filesFilter?: string[]): string;
+}
+
+export { GraphExporter };

package/dist/exporters/graph-exporter.js

@@ -0,0 +1,85 @@
+class GraphExporter {
+  store;
+  graph;
+  constructor(store, graph) {
+    this.store = store;
+    this.graph = graph;
+  }
+  exportAsJSON(repo, filesFilter) {
+    let files = this.store.getAllFiles(repo);
+    let symbols = this.store.getAllSymbols(repo);
+    let edges = this.store.getAllEdges(repo);
+    if (filesFilter) {
+      const allowed = new Set(filesFilter);
+      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));
+    }
+    const graphData = this.graph.toJSON();
+    if (filesFilter) {
+      const allowed = new Set(filesFilter);
+      graphData.nodes = graphData.nodes.filter((n) => allowed.has(n.key));
+      graphData.edges = graphData.edges.filter((e) => allowed.has(e.source) && allowed.has(e.target));
+    }
+    const clusters = this.store.getClusters(repo);
+    const memberships = this.store.getClusterMemberships(repo);
+    return {
+      version: "1.0.0",
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      repo: repo || "all",
+      summary: {
+        totalFiles: files.length,
+        totalSymbols: symbols.length,
+        totalEdges: edges.length,
+        languages: this.store.getLanguageBreakdown(repo),
+        totalClusters: clusters.length
+      },
+      files: files.map((f) => ({
+        path: f.path,
+        language: f.language,
+        sizeBytes: f.size_bytes,
+        lines: f.lines,
+        lastScanned: f.last_scanned,
+        metadata: f.metadata ? JSON.parse(f.metadata) : void 0
+      })),
+      symbols: symbols.map((s) => ({
+        name: s.name,
+        kind: s.kind,
+        scope: s.scope || void 0,
+        signature: s.signature,
+        file: s.file_path,
+        line: s.start_line,
+        endLine: s.end_line
+      })),
+      edges: edges.map((e) => ({
+        source: e.source_file,
+        target: e.target_file,
+        type: e.edge_type,
+        sourceSymbol: e.source_symbol || void 0,
+        targetSymbol: e.target_symbol || void 0,
+        verifiability: e.verifiability || "verified",
+        metadata: e.metadata ? JSON.parse(e.metadata) : void 0
+      })),
+      clusters: clusters.map((c) => ({
+        name: c.name,
+        label: c.label,
+        source: c.source,
+        parentName: c.parent_name || void 0,
+        depth: c.depth,
+        fileCount: c.file_count
+      })),
+      memberships: memberships.map((m) => ({
+        filePath: m.file_path,
+        clusterName: m.cluster_name,
+        isPrimary: m.is_primary === 1
+      })),
+      graph: graphData
+    };
+  }
+  exportAsJSONString(repo, filesFilter) {
+    return JSON.stringify(this.exportAsJSON(repo, filesFilter), null, 2);
+  }
+}
+export {
+  GraphExporter
+};

package/dist/exporters/index.d.ts

@@ -0,0 +1,9 @@
+export { LLMExporter } from './llm-exporter.js';
+export { GraphExporter } from './graph-exporter.js';
+export { DotExporter } from './dot-exporter.js';
+export { SvgExporter } from './svg-exporter.js';
+export { ToonExporter } from './toon-exporter.js';
+import '../core/store.js';
+import '../core/store-interface.js';
+import '../core/graph.js';
+import '../types.js';

package/dist/exporters/index.js

@@ -0,0 +1,12 @@
+import { LLMExporter } from "./llm-exporter.js";
+import { GraphExporter } from "./graph-exporter.js";
+import { DotExporter } from "./dot-exporter.js";
+import { SvgExporter } from "./svg-exporter.js";
+import { ToonExporter } from "./toon-exporter.js";
+export {
+  DotExporter,
+  GraphExporter,
+  LLMExporter,
+  SvgExporter,
+  ToonExporter
+};

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

@@ -0,0 +1,18 @@
+import { Store } from '../core/store.js';
+import { MapxGraph } from '../core/graph.js';
+import { ExportOptions } from '../types.js';
+import '../core/store-interface.js';
+
+declare class LLMExporter {
+    private store;
+    private graph;
+    constructor(store: Store, graph: MapxGraph);
+    export(options?: Partial<ExportOptions>): string;
+    private buildStructureSection;
+    private buildFileSection;
+    private buildSymbolSection;
+    private buildDependencySection;
+    private truncateToFit;
+}
+
+export { LLMExporter };

package/dist/exporters/llm-exporter.js

@@ -0,0 +1,224 @@
+const TOKEN_CHARS_PER_LINE = 4;
+class LLMExporter {
+  store;
+  graph;
+  constructor(store, graph) {
+    this.store = store;
+    this.graph = graph;
+  }
+  export(options) {
+    const opt = options || {};
+    const budget = opt.tokenBudget || 8192;
+    const parts = [];
+    let files = this.store.getAllFiles(opt.repo);
+    let symbols = this.store.getAllSymbols(opt.repo);
+    let edges = this.store.getAllEdges(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));
+    }
+    const repoName = opt.repo || "project";
+    parts.push(`# Mapx: ${repoName}`);
+    parts.push("");
+    const structureSection = this.buildStructureSection(opt.repo);
+    if (structureSection) {
+      parts.push(structureSection);
+    }
+    const fileSection = this.buildFileSection(files, rankedFiles, edges);
+    parts.push(fileSection);
+    const symbolSection = this.buildSymbolSection(rankedSymbols, budget);
+    parts.push(symbolSection);
+    if (edges.length > 0) {
+      const depSection = this.buildDependencySection(edges);
+      parts.push(depSection);
+    }
+    let result = parts.join("\n");
+    const estimatedTokens = Math.ceil(result.length / TOKEN_CHARS_PER_LINE);
+    if (estimatedTokens > budget) {
+      result = this.truncateToFit(result, budget);
+    }
+    return result;
+  }
+  buildStructureSection(repo) {
+    const clusters = this.store.getClusters(repo);
+    if (clusters.length === 0) return "";
+    const lines = [];
+    lines.push("## Structure");
+    const roots = [];
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const c of clusters) {
+      if (!c.parent_name) {
+        roots.push(c);
+      } else {
+        const parentName = c.parent_name;
+        if (!childrenMap.has(parentName)) {
+          childrenMap.set(parentName, []);
+        }
+        childrenMap.get(parentName).push(c);
+      }
+    }
+    for (const list of childrenMap.values()) {
+      list.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    roots.sort((a, b) => a.name.localeCompare(b.name));
+    const printTree = (node, indent) => {
+      const padding = "  ".repeat(indent);
+      const namePart = node.name;
+      const sourcePart = `(${node.source})`;
+      const filesPart = `[${node.file_count} files]`;
+      lines.push(`${padding}${namePart} ${sourcePart} ${filesPart}`);
+      const children = childrenMap.get(node.name) || [];
+      for (const child of children) {
+        printTree(child, indent + 1);
+      }
+    };
+    for (const root of roots) {
+      printTree(root, 0);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  buildFileSection(files, rankedFiles, edges) {
+    const lines = [];
+    lines.push(`## Files (${files.length})`);
+    const rankMap = new Map(rankedFiles.map((f) => [f.path, f.pagerank]));
+    const depMap = /* @__PURE__ */ new Map();
+    for (const edge of edges) {
+      const src = edge.source_file;
+      const tgt = edge.target_file;
+      const type = edge.edge_type;
+      if (!depMap.has(src)) depMap.set(src, []);
+      const infSuffix = edge.verifiability === "inferred" ? " [inferred]" : "";
+      depMap.get(src).push(`${tgt} (${type})${infSuffix}`);
+    }
+    const sorted = [...files].sort((a, b) => {
+      const ra = rankMap.get(a.path) || 0;
+      const rb = rankMap.get(b.path) || 0;
+      return rb - ra;
+    });
+    for (const file of sorted) {
+      const path = file.path;
+      const lang = file.language;
+      const deps = depMap.get(path);
+      const depStr = deps ? ` \u2192 ${deps.join(", ")}` : "";
+      lines.push(`- ${path} [${lang}]${depStr}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  buildSymbolSection(rankedSymbols, budget) {
+    const lines = [];
+    lines.push(`## Symbols (${rankedSymbols.length})`);
+    const byFile = /* @__PURE__ */ new Map();
+    for (const sym of rankedSymbols) {
+      if (!byFile.has(sym.filePath)) byFile.set(sym.filePath, []);
+      byFile.get(sym.filePath).push(sym);
+    }
+    const dbSymbols = this.store.getAllSymbols();
+    const sigMap = /* @__PURE__ */ new Map();
+    for (const s of dbSymbols) {
+      const key = `${s.file_path}::${s.name}`;
+      sigMap.set(key, s.signature);
+    }
+    const maxLines = Math.floor(budget * TOKEN_CHARS_PER_LINE / 40);
+    let lineCount = 0;
+    for (const [filePath, syms] of byFile) {
+      if (lineCount > maxLines) break;
+      const topLevel = syms.filter((s) => !s.scope);
+      for (const sym of topLevel) {
+        if (lineCount > maxLines) break;
+        const sig = sigMap.get(`${sym.filePath}::${sym.name}`) || sym.name;
+        lines.push(`- ${sym.kind} ${sig} @ ${sym.filePath}:${sym.startLine}`);
+        const children = syms.filter((s) => s.scope === sym.name);
+        for (const child of children) {
+          if (lineCount > maxLines) break;
+          const childSig = sigMap.get(`${child.filePath}::${child.name}`) || child.name;
+          lines.push(`  - ${child.kind} ${childSig} @ :${child.startLine}`);
+          lineCount++;
+        }
+        lineCount++;
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  buildDependencySection(edges) {
+    const lines = [];
+    lines.push("## Dependencies");
+    const routeGroups = /* @__PURE__ */ new Map();
+    const otherEdges = [];
+    for (const edge of edges) {
+      if (edge.edge_type === "route") {
+        const src = edge.source_file;
+        const controller = edge.target_symbol || edge.target_file.split("/").pop() || "Controller";
+        const key = `${src}->${controller}`;
+        let meta = {};
+        if (edge.metadata) {
+          try {
+            meta = typeof edge.metadata === "string" ? JSON.parse(edge.metadata) : edge.metadata;
+          } catch {
+          }
+        }
+        const verb = meta.httpVerb || "GET";
+        const uri = meta.uri || "/";
+        if (!routeGroups.has(key)) {
+          routeGroups.set(key, { source: src, controller, routes: [] });
+        }
+        routeGroups.get(key).routes.push({ verb, uri });
+      } else {
+        otherEdges.push(edge);
+      }
+    }
+    for (const group of routeGroups.values()) {
+      const uriToVerbs = /* @__PURE__ */ new Map();
+      for (const r of group.routes) {
+        if (!uriToVerbs.has(r.uri)) {
+          uriToVerbs.set(r.uri, /* @__PURE__ */ new Set());
+        }
+        uriToVerbs.get(r.uri).add(r.verb);
+      }
+      const descParts = [];
+      for (const [uri, verbs] of uriToVerbs.entries()) {
+        const verbsStr = Array.from(verbs).sort().join("/");
+        descParts.push(`${verbsStr} ${uri}`);
+      }
+      lines.push(`- ${group.source} \u2192 ${group.controller} (${group.routes.length} routes: ${descParts.join(", ")})`);
+    }
+    const unique = /* @__PURE__ */ new Map();
+    for (const edge of otherEdges) {
+      const key = `${edge.source_file}->${edge.target_file}:${edge.edge_type}`;
+      if (!unique.has(key)) {
+        unique.set(key, {
+          source: edge.source_file,
+          target: edge.target_file,
+          type: edge.edge_type,
+          verifiability: edge.verifiability || "verified",
+          targetRepo: edge.target_repo
+        });
+      }
+    }
+    for (const dep of unique.values()) {
+      const infSuffix = dep.verifiability === "inferred" ? " [inferred]" : "";
+      const targetRepoSuffix = dep.targetRepo ? ` [repo: ${dep.targetRepo}]` : "";
+      lines.push(`- ${dep.source} \u2192 ${dep.target}${targetRepoSuffix} (${dep.type})${infSuffix}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  truncateToFit(output, budget) {
+    const maxChars = budget * TOKEN_CHARS_PER_LINE;
+    if (output.length <= maxChars) return output;
+    const truncated = output.substring(0, maxChars);
+    const lastNewline = truncated.lastIndexOf("\n");
+    return truncated.substring(0, lastNewline) + "\n\n[... truncated to fit token budget]\n";
+  }
+}
+export {
+  LLMExporter
+};

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

@@ -0,0 +1,19 @@
+import { Store } from '../core/store.js';
+import { MapxGraph } from '../core/graph.js';
+import '../core/store-interface.js';
+import '../types.js';
+
+declare class SvgExporter {
+    private store;
+    private graph;
+    constructor(store: Store, graph: MapxGraph);
+    export(repo?: string, filesFilter?: string[], opts?: {
+        cluster?: 'none' | 'auto';
+        depth?: number;
+        forceFallback?: boolean;
+    }): string;
+    private renderFallback;
+    private escXml;
+}
+
+export { SvgExporter };