@zoldia/omnigraph 1.0.0 → 1.1.0

package/README.md

@@ -8,10 +8,11 @@ OmniGraph is a free, local developer tool that statically analyzes full-stack mo
 
 | Language | Extensions | Framework Detection |
 |----------|-----------|-------------------|
-| **TypeScript** | `.ts`, `.tsx` | NestJS (`@Controller`, `@Injectable`, `@Module`) |
+| **TypeScript** | `.ts`, `.tsx` | NestJS (`@Controller`, `@Injectable`, `@Module`), Next.js (App Router, Pages Router) |
 | **JavaScript** | `.js`, `.jsx` | CommonJS and ES module imports |
 | **Python** | `.py` | FastAPI (`@router.get`, `@app.post`), Flask (`@app.route`), Django (Views, Models) |
 | **PHP** | `.php` | Laravel (Controllers, Models, Middleware, Route definitions) |
+| **Markdown** | `.md`, `.mdx` | Obsidian wiki-links (`[[Page]]`), embeds (`![[Page]]`), frontmatter tags/aliases |
 
 ## Quick Start
 
@@ -44,28 +45,38 @@ omnigraph --path <repo-path> --port 4000  # Optional: custom port (default 3000)
 ## Features
 
 ### Multi-Language Dependency Graph
-Point OmniGraph at any project containing TypeScript, JavaScript, Python, or PHP files. It recursively walks the directory, respects `.gitignore`, and builds a dependency graph from import/require statements.
+Point OmniGraph at any project containing TypeScript, JavaScript, Python, PHP, or Markdown files. It recursively walks the directory, respects `.gitignore`, and builds a dependency graph from import/require statements and wiki-links.
 
 ### Framework-Aware Parsing
 OmniGraph doesn't just find imports — it understands framework patterns:
 - **NestJS**: Detects `@Controller`, `@Injectable`, `@Module` decorators with route metadata
+- **Next.js**: Detects App Router (`route.ts`, `page.tsx`, `layout.tsx`) and Pages Router (`pages/api/`)
 - **FastAPI/Flask**: Detects route decorators (`@router.get("/users")`) with HTTP methods and paths
 - **Django**: Detects class-based views (`APIView`, `ViewSet`) and models
 - **Laravel**: Detects controllers, models, middleware, and `Route::get()` definitions
+- **Obsidian/Markdown**: Detects wiki-links (`[[Page]]`), embeds (`![[Page]]`), YAML frontmatter (tags, aliases), and classifies MOC/daily/readme note types
 
 ### Interactive Visualization
 - **5 Layout Presets**: Directory (grouped by folder), Hierarchical, Force-Directed, Grid, Mind Map (LR/RL)
 - **Live Force Simulation**: In force-directed mode, dragging a node causes nearby nodes to push and pull reactively via d3-force physics
-- **Search & Filter**: Search nodes by name, filter by type with color-coded toggle chips
+- **Search & Filter with BFS Expansion**: Search nodes by name, filter by type with color-coded toggle chips. Hide or dim non-matching nodes. Connected nodes expand via BFS depth slider to reveal full data flow paths.
+- **Hub-Centric Compaction**: After filtering, compact visible nodes around the most-connected hub node(s) using d3-force. Single hub stays pinned; multiple hubs meet at their average position.
 - **Node Inspector**: Click any node to see its file path, type, route metadata, and ID in the sidebar
-- **Color-Coded Types**: Each node type has a distinct color — controllers (red), injectables (blue), modules (orange), Python files (blue), FastAPI routes (teal), Laravel controllers (red), and more
-
-### Sidebar Controls
-All controls live in a clean right sidebar:
-- Layout preset selector with mind map direction toggle
-- Real-time search with match count
-- Type filter chips with color legend
-- Node inspector panel below a divider
+- **Color-Coded Types**: Each node type has a distinct color — controllers (red), injectables (blue), modules (orange), Python files (blue), FastAPI routes (teal), Laravel controllers (red), markdown (purple), and more
+- **Clickable Minimap**: Zoom and pan directly on the minimap for faster navigation
+
+### Export
+- **PNG** — 2x resolution raster image
+- **SVG** — Scalable vector graphic
+- **JSON** — Raw OmniGraph data
+- **GIF** — 1-second animated GIF (30fps) showing edge flow direction with a progress overlay
+
+### Sidebar Tabs
+The right sidebar has four tabs:
+- **Graph** — Layout selector, search/filter with depth slider, type chips, node inspector, export dropdown, compact button
+- **API** — Postman-style API debugger (auto-fills from cross-network edges)
+- **Trace** — Step-through flow tracer with Back/Next navigation and animated highlighting
+- **Settings** — Configurable edge labels (show/hide per type, color, font size), graph options (minimap, animations), search defaults, with per-category reset and localStorage persistence
 
 ## Technology Stack
 
@@ -77,9 +88,11 @@ All controls live in a clean right sidebar:
 | TypeScript/JS Parser | `@typescript-eslint/typescript-estree` |
 | Python Parser | Regex-based AST extraction |
 | PHP Parser | Regex-based AST extraction |
+| Markdown Parser | Regex-based wiki-link/embed/frontmatter extraction |
 | Frontend | React 18 + Vite |
 | Graph Engine | React Flow |
-| Layout Engines | dagre (hierarchical/mind map), d3-force (force-directed) |
+| Layout Engines | dagre (hierarchical/mind map), d3-force (force-directed, compaction) |
+| GIF Export | gif.js (web worker encoding) |
 | Testing | Vitest |
 
 ## Architecture
@@ -152,7 +165,7 @@ All parsers produce a standardized graph format regardless of source language:
 ## Running Tests
 
 ```bash
-npx vitest run       # Run all tests (56 tests across 6 files)
+npx vitest run       # Run all tests (132 tests across 9 files)
 npx vitest --watch   # Watch mode
 ```
 
@@ -169,9 +182,9 @@ Contributions are welcome! Here's how to get started:
 ### Good First Issues
 
 - Add a new language parser (Go, Rust, Java, C#, Ruby)
-- Add export functionality (SVG, PNG, JSON)
 - Improve import resolution for edge cases (barrel exports, dynamic imports)
 - Add dark/light theme toggle
+- WebSocket connection tracing
 
 ## Project Documentation
 
@@ -181,6 +194,7 @@ Contributions are welcome! Here's how to get started:
 | [SAD](docs/SAD.md) | Software architecture, data flow, and design decisions |
 | [ADR-001](docs/adr/ADR-001-parsing-engine.md) | Why typescript-estree for Phase 1 |
 | [ADR-002](docs/adr/ADR-002-phase2-multi-language-parsing.md) | Why regex-based parsing for Phase 2 Python/PHP |
+| [ADR-003](docs/adr/ADR-003-markdown-obsidian-parser.md) | Markdown/Obsidian wiki-link parser design |
 | [API Spec](docs/API-SPEC.md) | HTTP endpoint and CLI interface documentation |
 
 ## License

package/dist/cli.js

@@ -259851,6 +259851,89 @@ var require_typescript_parser = __commonJS({
       }
       return null;
     }
+    var NEXTJS_HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+    function detectNextJSAppRoute(filePath, exportedNames) {
+      const normalized = filePath.replace(/\\/g, "/");
+      const basename = path2.basename(normalized, path2.extname(normalized));
+      if (basename !== "route")
+        return null;
+      const appMatch = normalized.match(/(?:^|\/)(src\/)?app\/(.*?)\/route\.\w+$/);
+      if (!appMatch)
+        return null;
+      const routeDir = appMatch[2];
+      const routePath = "/" + routeDir.split("/").map((segment) => {
+        if (/^\[\[?\.\.\.\w+\]?\]$/.test(segment)) {
+          const name = segment.replace(/[\[\]\.]/g, "");
+          return `:${name}*`;
+        }
+        if (/^\[\w+\]$/.test(segment)) {
+          return ":" + segment.slice(1, -1);
+        }
+        return segment;
+      }).join("/");
+      const methods = exportedNames.filter((n) => NEXTJS_HTTP_METHODS.includes(n));
+      if (methods.length === 0) {
+        return { nodeType: "nextjs-api-route", route: routePath };
+      }
+      const routeEntries = methods.map((m) => `${m} ${routePath}`).join(", ");
+      return { nodeType: "nextjs-api-route", route: routeEntries };
+    }
+    function detectNextJSPagesApiRoute(filePath, hasDefaultExport) {
+      if (!hasDefaultExport)
+        return null;
+      const normalized = filePath.replace(/\\/g, "/");
+      const basename = path2.basename(normalized, path2.extname(normalized));
+      const pagesMatch = normalized.match(/(?:^|\/)(src\/)?pages\/api\/(.*?)(\.\w+)$/);
+      if (!pagesMatch)
+        return null;
+      let routeSegments = pagesMatch[2];
+      if (basename === "index") {
+        routeSegments = routeSegments.replace(/\/?index$/, "");
+      }
+      const segments = routeSegments.split("/").filter(Boolean).map((segment) => {
+        if (/^\[\[?\.\.\.\w+\]?\]$/.test(segment)) {
+          const name = segment.replace(/[\[\]\.]/g, "");
+          return `:${name}*`;
+        }
+        if (/^\[\w+\]$/.test(segment)) {
+          return ":" + segment.slice(1, -1);
+        }
+        return segment;
+      });
+      const routePath = segments.length > 0 ? "/api/" + segments.join("/") : "/api";
+      return { nodeType: "nextjs-api-route", route: routePath };
+    }
+    function detectNextJSPage(filePath) {
+      const normalized = filePath.replace(/\\/g, "/");
+      const basename = path2.basename(normalized, path2.extname(normalized));
+      if (basename !== "page")
+        return null;
+      const appMatch = normalized.match(/(?:^|\/)(src\/)?app\/(.*?)\/page\.\w+$/);
+      if (!appMatch)
+        return null;
+      const routeDir = appMatch[2];
+      const routePath = "/" + routeDir.split("/").map((segment) => {
+        if (/^\[\[?\.\.\.\w+\]?\]$/.test(segment)) {
+          const name = segment.replace(/[\[\]\.]/g, "");
+          return `:${name}*`;
+        }
+        if (/^\[\w+\]$/.test(segment)) {
+          return ":" + segment.slice(1, -1);
+        }
+        return segment;
+      }).join("/");
+      return { nodeType: "nextjs-page", route: routePath };
+    }
+    function detectNextJSLayout(filePath) {
+      const normalized = filePath.replace(/\\/g, "/");
+      const basename = path2.basename(normalized, path2.extname(normalized));
+      if (basename !== "layout")
+        return null;
+      const appMatch = normalized.match(/(?:^|\/)(src\/)?app\/(.+\/)?layout\.\w+$/);
+      if (!appMatch)
+        return null;
+      return { nodeType: "nextjs-layout", route: "" };
+    }
     var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
     function resolveImport(fromFile, importPath) {
       const base = path2.normalize(path2.join(path2.dirname(fromFile), importPath));
@@ -259888,6 +259971,8 @@ var require_typescript_parser = __commonJS({
         const isJS = /\.(js|jsx)$/.test(filePath);
         let nodeType = isJS ? "javascript-file" : "typescript-file";
         let route = "";
+        const exportedNames = [];
+        let hasDefaultExport = false;
         for (const stmt of ast.body) {
           if (stmt.type === "ImportDeclaration") {
             const src = stmt.source.value;
@@ -259904,6 +259989,31 @@ var require_typescript_parser = __commonJS({
               }
             }
           }
+          if (stmt.type === "ExportNamedDeclaration") {
+            if (stmt.declaration) {
+              const decl = stmt.declaration;
+              if (decl.type === "FunctionDeclaration" && decl.id && typeof decl.id.name === "string") {
+                exportedNames.push(decl.id.name);
+              }
+              if (decl.type === "VariableDeclaration" && Array.isArray(decl.declarations)) {
+                for (const d of decl.declarations) {
+                  if (d.id && typeof d.id.name === "string") {
+                    exportedNames.push(d.id.name);
+                  }
+                }
+              }
+            }
+            if (stmt.specifiers) {
+              for (const spec of stmt.specifiers) {
+                if (spec.exported && typeof spec.exported.name === "string") {
+                  exportedNames.push(spec.exported.name);
+                }
+              }
+            }
+          }
+          if (stmt.type === "ExportDefaultDeclaration") {
+            hasDefaultExport = true;
+          }
           let classNode = null;
           if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "ClassDeclaration") {
             classNode = stmt.declaration;
@@ -259919,6 +260029,13 @@ var require_typescript_parser = __commonJS({
             }
           }
         }
+        if (nodeType === "typescript-file" || nodeType === "javascript-file") {
+          const nextResult = detectNextJSAppRoute(filePath, exportedNames) ?? detectNextJSPagesApiRoute(filePath, hasDefaultExport) ?? detectNextJSPage(filePath) ?? detectNextJSLayout(filePath);
+          if (nextResult) {
+            nodeType = nextResult.nodeType;
+            route = nextResult.route;
+          }
+        }
         const node = {
           id: fileId,
           type: nodeType,
@@ -260433,6 +260550,281 @@ var require_php_parser = __commonJS({
   }
 });
 
+// packages/parsers/dist/markdown/markdown-parser.js
+var require_markdown_parser = __commonJS({
+  "packages/parsers/dist/markdown/markdown-parser.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MarkdownParser = void 0;
+    var path2 = __importStar(require("path"));
+    var fs = __importStar(require("fs"));
+    var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
+    var YAML_TAGS_INLINE = /^tags:\s*\[([^\]]*)\]/m;
+    var YAML_TAGS_KEY = /^tags:\s*$/m;
+    var YAML_ALIASES = /^aliases:\s*\[([^\]]*)\]/m;
+    var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".bmp"]);
+    var MarkdownParser = class {
+      constructor() {
+        this.rootDir = "";
+      }
+      setRootDir(dir) {
+        this.rootDir = dir;
+      }
+      canHandle(filePath) {
+        const ext = path2.extname(filePath).toLowerCase();
+        return ext === ".md" || ext === ".mdx";
+      }
+      parse(filePath, source) {
+        const nodes = [];
+        const edges = [];
+        const fileId = filePath.replace(/\\/g, "/");
+        const fileName = path2.basename(filePath, path2.extname(filePath));
+        const frontmatter = this.parseFrontmatter(source);
+        const headings = [];
+        let headingMatch;
+        const headingRegex = /^(#{1,6})\s+(.+)$/gm;
+        while ((headingMatch = headingRegex.exec(source)) !== null) {
+          headings.push(headingMatch[2].trim());
+        }
+        let nodeType = "markdown-file";
+        if (frontmatter.tags.some((t) => t.toLowerCase() === "moc" || t.toLowerCase() === "index")) {
+          nodeType = "markdown-moc";
+        } else if (frontmatter.tags.some((t) => t.toLowerCase() === "daily" || t.toLowerCase() === "journal")) {
+          nodeType = "markdown-daily";
+        } else if (filePath.toLowerCase().includes("readme")) {
+          nodeType = "markdown-readme";
+        }
+        const metadata = {
+          filePath,
+          language: "markdown"
+        };
+        if (headings.length > 0) {
+          metadata.headings = headings.slice(0, 8).join(", ");
+        }
+        if (frontmatter.tags.length > 0) {
+          metadata.tags = frontmatter.tags.join(", ");
+        }
+        if (frontmatter.aliases.length > 0) {
+          metadata.aliases = frontmatter.aliases.join(", ");
+        }
+        nodes.push({
+          id: fileId,
+          type: nodeType,
+          label: fileName,
+          metadata
+        });
+        const body = this.stripFrontmatterAndCode(source);
+        const linkedTargets = /* @__PURE__ */ new Set();
+        let match;
+        const wikiRegex = /\[\[([^\]|#]+)(?:#[^\]|]*)?\|?[^\]]*\]\]/g;
+        while ((match = wikiRegex.exec(body)) !== null) {
+          const target = match[1].trim();
+          if (!target)
+            continue;
+          const ext = path2.extname(target).toLowerCase();
+          if (IMAGE_EXTENSIONS.has(ext))
+            continue;
+          const resolved = this.resolveWikiLink(filePath, target);
+          if (resolved && !linkedTargets.has(resolved)) {
+            linkedTargets.add(resolved);
+            edges.push({
+              id: `e-${fileId}->${resolved}`,
+              source: fileId,
+              target: resolved,
+              label: "links to"
+            });
+          }
+        }
+        const embedRegex = /!\[\[([^\]|#]+)(?:#[^\]|]*)?\|?[^\]]*\]\]/g;
+        while ((match = embedRegex.exec(body)) !== null) {
+          const target = match[1].trim();
+          if (!target)
+            continue;
+          const ext = path2.extname(target).toLowerCase();
+          if (IMAGE_EXTENSIONS.has(ext))
+            continue;
+          const resolved = this.resolveWikiLink(filePath, target);
+          if (resolved && !linkedTargets.has(resolved)) {
+            linkedTargets.add(resolved);
+            edges.push({
+              id: `e-${fileId}->embed-${resolved}`,
+              source: fileId,
+              target: resolved,
+              label: "embeds"
+            });
+          }
+        }
+        const mdLinkRegex = /\[(?:[^\]]*)\]\((?!https?:\/\/|mailto:|#)([^)]+\.(?:md|mdx))\)/g;
+        while ((match = mdLinkRegex.exec(body)) !== null) {
+          const linkPath = match[1].trim();
+          if (!linkPath)
+            continue;
+          const resolved = this.resolveRelativeLink(filePath, linkPath);
+          if (resolved && !linkedTargets.has(resolved)) {
+            linkedTargets.add(resolved);
+            edges.push({
+              id: `e-${fileId}->${resolved}`,
+              source: fileId,
+              target: resolved,
+              label: "links to"
+            });
+          }
+        }
+        return { nodes, edges };
+      }
+      // ─── Frontmatter Parsing ─────────────────────────────────────────
+      parseFrontmatter(source) {
+        const tags = [];
+        const aliases = [];
+        const fmMatch = FRONTMATTER.exec(source);
+        if (!fmMatch)
+          return { tags, aliases };
+        const fmBlock = fmMatch[1];
+        const tagsInline = YAML_TAGS_INLINE.exec(fmBlock);
+        if (tagsInline) {
+          tags.push(...tagsInline[1].split(",").map((t) => t.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean));
+        } else if (YAML_TAGS_KEY.test(fmBlock)) {
+          let itemMatch;
+          const itemRegex = /^\s+-\s+(.+)$/gm;
+          const tagsSection = fmBlock.slice(fmBlock.indexOf("tags:"));
+          while ((itemMatch = itemRegex.exec(tagsSection)) !== null) {
+            tags.push(itemMatch[1].trim().replace(/^['"]|['"]$/g, ""));
+          }
+        }
+        const aliasMatch = YAML_ALIASES.exec(fmBlock);
+        if (aliasMatch) {
+          aliases.push(...aliasMatch[1].split(",").map((a) => a.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean));
+        }
+        return { tags, aliases };
+      }
+      // ─── Link Resolution ─────────────────────────────────────────────
+      /**
+       * Resolve an Obsidian wiki-link target to a file path.
+       * Obsidian uses "shortest path when possible" — [[Page]] matches
+       * any file named Page.md anywhere in the vault.
+       */
+      resolveWikiLink(fromFile, target) {
+        const dir = path2.dirname(fromFile);
+        if (path2.extname(target)) {
+          return this.tryResolve(dir, target);
+        }
+        const resolved = this.tryResolve(dir, target + ".md") ?? this.tryResolve(dir, target + ".mdx");
+        if (resolved)
+          return resolved;
+        if (this.rootDir) {
+          const found = this.findFileInVault(target);
+          if (found)
+            return found;
+        }
+        return null;
+      }
+      /** Resolve a standard relative markdown link */
+      resolveRelativeLink(fromFile, linkPath) {
+        const dir = path2.dirname(fromFile);
+        const candidate = path2.resolve(dir, linkPath);
+        if (fs.existsSync(candidate)) {
+          return candidate.replace(/\\/g, "/");
+        }
+        return null;
+      }
+      /** Try resolving a path relative to the current directory or as absolute */
+      tryResolve(dir, target) {
+        const relative = path2.resolve(dir, target);
+        if (fs.existsSync(relative)) {
+          return relative.replace(/\\/g, "/");
+        }
+        if (this.rootDir) {
+          const fromRoot = path2.resolve(this.rootDir, target);
+          if (fs.existsSync(fromRoot)) {
+            return fromRoot.replace(/\\/g, "/");
+          }
+        }
+        return null;
+      }
+      /**
+       * Search the vault (rootDir) recursively for a file matching the target name.
+       * This implements Obsidian's "shortest path" resolution for [[Page]] links.
+       */
+      findFileInVault(target) {
+        if (!this.rootDir)
+          return null;
+        const targetLower = target.toLowerCase();
+        const extensions = [".md", ".mdx"];
+        const queue = [this.rootDir];
+        const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "build", ".obsidian"]);
+        while (queue.length > 0) {
+          const dir = queue.shift();
+          let entries;
+          try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+          } catch {
+            continue;
+          }
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              if (!skip.has(entry.name)) {
+                queue.push(path2.join(dir, entry.name));
+              }
+            } else if (entry.isFile()) {
+              const name = path2.basename(entry.name, path2.extname(entry.name));
+              const ext = path2.extname(entry.name).toLowerCase();
+              if (name.toLowerCase() === targetLower && extensions.includes(ext)) {
+                return path2.join(dir, entry.name).replace(/\\/g, "/");
+              }
+            }
+          }
+        }
+        return null;
+      }
+      /** Strip frontmatter and fenced code blocks so link regexes don't match inside them */
+      stripFrontmatterAndCode(source) {
+        let body = source.replace(FRONTMATTER, "");
+        body = body.replace(/```[\s\S]*?```/g, "");
+        body = body.replace(/`[^`]*`/g, "");
+        return body;
+      }
+    };
+    exports2.MarkdownParser = MarkdownParser;
+  }
+});
+
 // packages/parsers/dist/cross-network/http-call-detector.js
 var require_http_call_detector = __commonJS({
   "packages/parsers/dist/cross-network/http-call-detector.js"(exports2) {
@@ -260795,13 +261187,15 @@ var require_parser_registry = __commonJS({
     var typescript_parser_1 = require_typescript_parser();
     var python_parser_1 = require_python_parser();
     var php_parser_1 = require_php_parser();
+    var markdown_parser_1 = require_markdown_parser();
     var cross_network_1 = require_cross_network();
     var fs = __importStar(require("fs"));
     var path2 = __importStar(require("path"));
     var ignore_1 = __importDefault(require_ignore());
     var pythonParser = new python_parser_1.PythonParser();
     var phpParser = new php_parser_1.PhpParser();
-    var parsers = [new typescript_parser_1.TypeScriptParser(), pythonParser, phpParser];
+    var markdownParser = new markdown_parser_1.MarkdownParser();
+    var parsers = [new typescript_parser_1.TypeScriptParser(), pythonParser, phpParser, markdownParser];
     var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "build"]);
     function loadGitignore(rootDir) {
       const ig = (0, ignore_1.default)();
@@ -260820,6 +261214,7 @@ var require_parser_registry = __commonJS({
       const sourceByFileId = /* @__PURE__ */ new Map();
       pythonParser.setRootDir(dirPath);
       phpParser.setRootDir(dirPath);
+      markdownParser.setRootDir(dirPath);
       function walk(dir) {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zoldia/omnigraph",
-  "version": "1.0.0",
-  "description": "A multi-language, AST-driven dependency visualizer for complex codebases. Parses TypeScript/NestJS, Python/FastAPI/Django, and PHP/Laravel and renders an interactive dependency graph.",
+  "version": "1.1.0",
+  "description": "A multi-language, AST-driven dependency visualizer for complex codebases. Parses TypeScript/NestJS/Next.js, Python/FastAPI/Django, PHP/Laravel, and Markdown/Obsidian and renders an interactive dependency graph.",
   "bin": {
     "omnigraph": "dist/cli.js"
   },
@@ -19,12 +19,16 @@
     "typescript",
     "python",
     "php",
+    "markdown",
     "nestjs",
+    "nextjs",
     "fastapi",
     "django",
     "laravel",
+    "obsidian",
+    "wiki-links",
     "react-flow",
-    "obsidian"
+    "gif-export"
   ],
   "repository": {
     "type": "git",