Dependency And Import Graph Extraction

via “dependency parsing and syntactic analysis”

Industrial-strength NLP library for production use.

Unique: Implements transition-based neural dependency parsing (not graph-based) with efficient Cython implementation, enabling fast parsing on CPU. Integrates parsing directly into the pipeline, making syntactic information available to downstream components without separate model loading.

vs others: Faster than Stanford CoreNLP or UDPipe for CPU-based parsing; more integrated than standalone parsers; supports custom dependency labels via training.

via “dependency graph and import relationship mapping”

MCP server for Context7

Unique: Context7 pre-computes dependency graphs during indexing, allowing the MCP server to serve dependency queries instantly without re-analyzing imports on each request — this is more efficient than on-demand static analysis

vs others: Faster and more comprehensive than running ad-hoc dependency analysis tools because dependencies are pre-indexed; provides unified interface across multiple languages

via “dependency-graph-visualization-with-security-and-version-status”

The official Mermaid Editor plugin by the Mermaid open source team, now with AI-powered diagramming! Create, edit and preview diagrams seamlessly within VS Code

Unique: Integrates package manifest parsing with security vulnerability database lookups to generate dependency diagrams with real-time security status indicators. The extension color-codes dependencies by vulnerability severity and update availability, providing actionable security insights directly in the diagram.

vs others: More comprehensive than package manager built-in tools because it visualizes transitive dependencies and security status in a single diagram, and more accessible than command-line dependency auditors because it integrates visual representation into the editor.

via “dependency analysis and relationship traversal”

An MCP server plus a CLI tool that indexes local code into a graph database to provide context to AI assistants.

Unique: Implements graph traversal algorithms (BFS, DFS) on the pre-indexed code graph to compute transitive relationships and impact analysis. Supports cycle detection and configurable depth limits to handle circular dependencies without infinite loops.

vs others: More efficient than runtime dependency analysis because relationships are pre-computed; more comprehensive than IDE-based refactoring tools because it includes indirect/transitive relationships.

via “dependency graph visualization and analysis”

A Model Context Protocol server implementation for Nx

Unique: Exposes Nx's internal project graph computation as queryable MCP tools, providing direct access to the same dependency data used for task scheduling and affected detection. Supports multiple output formats (adjacency lists, edge lists, matrix representations) for different analysis use cases.

vs others: More accurate than parsing package.json files because it understands Nx's implicit dependencies and path mappings, whereas generic dependency analyzers would miss monorepo-specific relationships.

via “dependency graph extraction and relationship analysis”

A Model Context Protocol (MCP) server that helps large language models index, search, and analyze code repositories with minimal setup

Unique: Extracts dependency relationships from indexed import statements without executing code or resolving external packages. Supports language-specific import syntax and can compute transitive dependencies efficiently.

vs others: More practical than runtime dependency analysis because it works without executing code; more accurate than static analysis tools because it uses parsed AST instead of regex.

via “dependency management and architecture visualization tool reference”

🦩 Tools for Go projects

Unique: Combines dependency management tools (go mod commands) with visualization utilities and architecture enforcement tools in a single reference, showing how to use them together to maintain architectural health. Includes both built-in Go tooling (go mod graph) and third-party visualization tools (modgraph, depcheck).

vs others: More actionable than raw 'go mod graph' output because it includes visualization tools and architecture enforcement patterns; more comprehensive than individual tool documentation because it shows the complete workflow from dependency analysis to architectural enforcement.

via “dependency-and-import-governance”

ai-rules is a governance framework designed to solve "Architectural Decay" in AI-driven development. It forces AI Agents (Cursor, Windsurf, Copilot) to respect your project's boundaries, UI libraries, and design patterns.

Unique: Specifically targets AI agents' tendency to import unauthorized or heavy dependencies by validating imports against project-defined whitelists. Combines import analysis with governance rules to prevent dependency bloat and security issues.

vs others: More proactive than dependency auditing tools like npm audit; prevents unauthorized imports at generation time rather than detecting them after the fact.

via “codebase dependency graph visualization with module classification”

Real-time interactive flowcharts for your code

Unique: Combines static import/require analysis with automatic semantic classification (Core, Report, Config, Tool, Entry) to produce architecture-aware dependency graphs that highlight structural patterns without requiring manual annotation or configuration

vs others: More accessible than command-line tools like Madge or Depcheck because it integrates directly into VS Code with interactive navigation and real-time updates, and provides semantic classification that helps developers understand architectural intent

via “dependency graph and module relationship discovery”

Docfork - Up-to-date Docs for AI Agents.

Unique: Builds queryable dependency graphs from static import analysis, allowing agents to understand module relationships and impact chains. Enables agents to make informed decisions about code generation based on existing architecture.

vs others: More efficient than agents reading entire codebase to understand relationships; more accurate than heuristic-based approaches because it analyzes actual import statements.

via “dependency graph and import relationship mapping”

npx agentseed initAGENTS.md (https://agents.md) is a standard file used by AI coding agents to understand a repo (stack, commands, conventions).Agentseed generates it directly from the codebase using static analysis. Optional LLM augmentation is supported by bringing your own API key.Extra

Unique: Builds a static dependency graph from import analysis rather than runtime introspection, enabling agents to understand code organization without executing code

vs others: More comprehensive than simple import listing because it shows relationships between modules; more reliable than runtime analysis because it doesn't require code execution

via “dependency tree visualization and conflict detection”

** - Enhanced Maven Central integration with intelligent caching, bulk operations, and version classification

Unique: Analyzes full transitive dependency trees with conflict detection and optimization recommendations, integrating Maven Central metadata to flag vulnerable or outdated transitive dependencies. Generates structured graph representations for visualization.

vs others: Provides integrated transitive dependency analysis with vulnerability detection, whereas Maven's native tree command lacks security context and optimization recommendations.

via “import and dependency extraction with relationship mapping”

Condense source code for LLM analysis by extracting essential highlights, utilizing a simplified version of Paul Gauthier's repomap technique from Aider Chat.

Unique: Extracts and maps import/require relationships across source files to build a lightweight dependency graph, enabling LLMs to understand module structure without processing full file contents

vs others: Faster and more token-efficient than sending full code to LLMs for dependency analysis, while remaining simpler than heavyweight dependency analysis tools like Madge or Webpack

via “dependency tree visualization”

A powerful MCP (Model Context Protocol) Server that audits npm package dependencies for security vulnerabilities. Built with remote npm registry integration for real-time security checks.

Unique: Utilizes advanced graph visualization techniques to provide an interactive view of dependencies, which is often lacking in standard audit tools.

vs others: Offers a more intuitive and interactive way to explore dependencies compared to static reports from other auditing tools.

Compact, language-agnostic codebase mapper for LLM token efficiency.

Unique: Uses multi-pattern regex matching and heuristic fallback strategies to handle import syntax variations across languages, combined with optional path resolution configuration, enabling accurate dependency mapping even in polyglot codebases without language-specific tooling

vs others: Faster and more portable than language-specific tools (like npm audit or Python import analysis) because it avoids installing language runtimes and dependencies, while remaining accurate enough for architectural analysis and refactoring planning

via “dependency graph visualization and analysis for ai reasoning”

A Model Context Protocol server implementation for Nx

Unique: Exposes Nx's pre-computed dependency graph in multiple formats optimized for LLM reasoning, allowing AI to analyze monorepo architecture without recalculating dependencies

vs others: More efficient than runtime graph analysis because it uses Nx's cached graph computation rather than traversing the filesystem or parsing imports

via “dependency-and-import-management-automation”

An autonomous agent designed to navigate the complexities of software engineering. #opensource

Unique: Maintains a dependency graph and checks for conflicts before installing packages, rather than blindly installing everything; also updates lock files (poetry.lock, package-lock.json) to ensure reproducible builds

vs others: More robust than manual dependency management because it prevents version conflicts and keeps lock files in sync

via “dependency-and-import-management”

Your own junior AI developer, deployed via E2B UI

Unique: Integrates dependency management into the code generation pipeline, ensuring that generated code includes all necessary imports and configuration rather than producing code that references undefined packages

vs others: Manual code generation requires separate dependency management; Smol Developer handles both in a unified pipeline

via “dependency relationship mapping”

Show HN: DeepRepo – AI architecture diagrams from GitHub repos

Unique: Employs real-time analysis of code to dynamically generate dependency maps, unlike static tools that require manual updates.

vs others: More dynamic and responsive than tools like Graphviz, which require manual input for updates.

via “package dependency graph extraction”

** - Search and get up-to-date information about NPM, Cargo, PyPi, and NuGet packages.

Unique: Parses and normalizes dependency manifests from four distinct package manager formats (package.json, Cargo.toml, PyPI metadata, NuGet packages.config) into a unified dependency schema without requiring local package installation or manifest downloads

vs others: Avoids the overhead of npm install or pip install by reading metadata directly from registries, making it 10-100x faster than local dependency resolution for quick audits