awesome-repositories.com
博客
awesome-repositories.com

通过 AI 驱动的搜索,发现最优秀的开源仓库。

探索精选搜索开源替代品自托管软件博客网站地图
项目关于排名机制媒体报道MCP 服务器
法律隐私政策服务条款
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

34 个仓库

Awesome GitHub RepositoriesCode Dependency Analysis

Extracts and lists project dependencies for further analysis.

Distinct from Dependency Analysis Tools: Distinct from Dependency Analysis Tools: focuses on extracting code dependencies, not just analyzing dependencies.

Explore 34 awesome GitHub repositories matching development tools & productivity · Code Dependency Analysis. Refine with filters or upvote what's useful.

Awesome Code Dependency Analysis GitHub Repositories

用 AI 发现最棒的仓库。我们将通过 AI 为您搜索最匹配的仓库。
  • substack/node-browserifysubstack 的头像

    substack/node-browserify

    14,707在 GitHub 上查看↗

    This project is a CommonJS module bundler and resolver designed to combine interdependent JavaScript files into a single script for execution in web browsers. It functions as a Node.js JavaScript bundler that emulates server-side core modules and resolves dependencies to ensure compatibility between server-side logic and browser environments. The system features an extensible bundling pipeline and a browser-side module resolver. It provides a plugin architecture for transforming source code and a source map generator to correlate bundled output back to original files for debugging. The proje

    Recursively scans source code for import statements to build a complete dependency graph.

    JavaScript
    在 GitHub 上查看↗14,707
  • google/wiregoogle 的头像

    google/wire

    14,403在 GitHub 上查看↗

    Wire is a compile-time dependency injection framework for Go that generates code to wire application components together. It analyzes function signatures at compile time to build an explicit initialization graph, removing the need for runtime reflection or manual wiring code. The framework operates as a Go code generator and static analysis tool, transforming annotated source code into generated wire files that compile alongside the original project. It connects dependencies by matching function parameters and return types, producing a directed acyclic graph of component dependencies that is

    Analyzes Go function signatures and types at compile time to determine the complete dependency graph.

    Gocodegendependency-injectiongo
    在 GitHub 上查看↗14,403
  • webpro-nl/knipwebpro-nl 的头像

    webpro-nl/knip

    11,560在 GitHub 上查看↗

    Knip is a static analysis project cleaner and dead code analyzer for JavaScript and TypeScript projects. It identifies and removes unused files, dependencies, and exports to maintain a lean codebase and reduce bundle size. The tool functions as a monorepo dependency auditor, tracking exports and dependencies across multiple workspaces to find dead code in large multi-package projects. It specifically targets the removal of unused packages from project manifests and the deletion of unreferenced exports. Its capabilities cover dead code elimination, JavaScript dependency management, and TypeSc

    Identifies packages used in the source code that are missing from the manifest to prevent transitive dependency reliance.

    TypeScriptdeadcodedependency-analysisdependency-management
    在 GitHub 上查看↗11,560
  • pahen/madgepahen 的头像

    pahen/madge

    10,117在 GitHub 上查看↗

    Madge is a JavaScript module dependency visualizer and architecture mapper. It analyzes source code to create graphs and diagrams of module relationships, supporting CommonJS, AMD, and ES6 standards. The tool functions as a circular dependency detector to identify recursive import loops and a dependency graph generator that exports relationship maps into image and vector formats. It provides utilities for auditing project structure, including the identification of orphaned modules and leaf modules. Its broader capabilities include dead code identification, module impact analysis through depe

    Provides a scanner that identifies recursive module import loops to help developers break dependency chains.

    JavaScriptamdcommonjsdependencies
    在 GitHub 上查看↗10,117
  • mamedev/mamemamedev 的头像

    mamedev/mame

    9,929在 GitHub 上查看↗

    MAME is a vintage hardware emulation platform designed to recreate the circuitry of arcade games, computers, and consoles to run original software on modern devices. It functions as a retro gaming preservation framework for managing, verifying, and archiving ROM sets and disk images to ensure long-term software accessibility. The project features a system debugging tool for inspecting emulated memory, CPU registers, and execution flow via breakpoints and disassembly. It also includes a Lua-based automation layer that exposes core system state and hardware controls for custom behavior and anal

    MAME lists missing ROM dumps and disk images and displays the search paths attempted.

    C++
    在 GitHub 上查看↗9,929
  • npm/clinpm 的头像

    npm/cli

    9,846在 GitHub 上查看↗

    This project is a command line interface for managing, installing, and publishing JavaScript packages to a remote registry. It serves as a dependency resolution tool, a software registry publishing client, and a security auditor for Node.js development workflows. The tool distinguishes itself by providing integrated monorepo workspace management and a comprehensive registry authentication client that supports multi-factor authentication. It enables detailed control over the software supply chain through provenance attestations, package signature verification, and the generation of a Software

    Provides a utility to list duplicated packages within the dependency tree to analyze redundancy.

    JavaScriptjavascriptnodejsnpm
    在 GitHub 上查看↗9,846
  • github/semanticgithub 的头像

    github/semantic

    9,041在 GitHub 上查看↗

    Semantic 是一个基于 Haskell 的库和命令行工具,专为多语言源代码分析而设计。它作为一个静态程序分析框架和多语言抽象语法树解析器,能够根据语法定义将多种编程语言转换为结构化的语法树。 该系统通过一个语义代码比较引擎脱颖而出,该引擎检测代码版本之间的结构和意义变化,而不是依赖文本差异。它进一步通过将表面语言转换为统一的多语言中间表示,实现了跨不同编程语法的分析。 该框架为解析 Rust、Go、Python、Ruby、PHP、TypeScript 和 TSX 等语言提供了广泛的功能。它涵盖了通过代码作用域映射、符号提取和语义图生成的语义分析,以及用于模式分析和程序行为评估的工具。 该工具集还包括用于标准化 Haskell 源代码文件布局的命令行实用程序。

    Analyzes identifier visibility and accessibility to construct graphs mapping the relationships and meanings within a codebase.

    Haskell
    在 GitHub 上查看↗9,041
  • kreuzberg-dev/kreuzbergkreuzberg-dev 的头像

    kreuzberg-dev/kreuzberg

    8,527在 GitHub 上查看↗

    Kreuzberg is a document extraction engine that converts PDFs, Office files, images, and over 90 other formats into clean, structured text and metadata. It is built around a compiled Rust core that can be used as a native library, a command-line tool, a REST API server, or a WebAssembly module for browser-based processing. The system is designed to run entirely on self-hosted infrastructure, with no data leaving the user's environment. What distinguishes Kreuzberg is its breadth of integration surfaces and its pipeline architecture. It exposes extraction capabilities through native bindings fo

    Report when an optional system dependency like Tesseract is missing so callers can install it before retrying.

    Rustdocument-intelligenceelixirffi
    在 GitHub 上查看↗8,527
  • bndr/pipreqsbndr 的头像

    bndr/pipreqs

    7,454在 GitHub 上查看↗

    pipreqs 是一个 Python 依赖生成和发现工具。它扫描项目导入以识别运行项目所需的第三方库,并自动生成仅包含源代码中实际使用包的 requirements 文件。 该实用程序通过比较已安装的包与实际导入来充当 requirements 文件管理器。它提供了修剪未使用的依赖项和审计项目以识别缺失或过时包的能力。 该工具采用静态分析和抽象语法树 (AST) 来隔离导入语句,而无需执行代码。它使用本地元数据或自定义服务器解析包版本,并递归遍历目录结构以定位所有相关的源文件。

    Identifies packages declared in the requirements file that are not actually imported in the source code.

    Python
    在 GitHub 上查看↗7,454
  • square/daggersquare 的头像

    square/dagger

    7,281在 GitHub 上查看↗

    Dagger is a compile-time dependency injection framework for Java and Android that automates object creation and lifecycle management. It functions as a static dependency injector and graph validator, resolving object requirements during the build process to avoid runtime reflection and prevent crashes caused by missing bindings. The framework distinguishes itself by using static analysis and code generation to produce factory classes at build time. It employs qualifier-based type differentiation to manage multiple implementations of the same type and provides scope-based lifecycle management

    Determines object requirements by analyzing source code at build time instead of searching memory at runtime.

    Java
    在 GitHub 上查看↗7,281
  • ai/size-limitai 的头像

    ai/size-limit

    6,911在 GitHub 上查看↗

    size-limit is a set of specialized tools for measuring JavaScript bundle sizes and enforcing performance budgets within continuous integration pipelines. It functions as a bundle size monitor and budget enforcer that can reject pull requests when JavaScript bundles exceed predefined size thresholds. The project distinguishes itself by providing a browser-based execution profiler that calculates the time required to compile and execute JavaScript on simulated low-end hardware. It also includes a tree-shaking validator that analyzes partial import bundle sizes to verify that unused code is corr

    Extracts and analyzes which external libraries contribute most to the total bundle size.

    JavaScript
    在 GitHub 上查看↗6,911
  • assetripper/assetripperAssetRipper 的头像

    AssetRipper/AssetRipper

    6,935在 GitHub 上查看↗

    AssetRipper is a suite of tools designed for the recovery and analysis of Unity game projects. It functions as an asset extractor, project reconstructor, shader decompiler, binary analysis tool, and dependency auditor. The project specializes in recovering high-level structures from compiled binaries. It reconstructs prefabs from inlined scene instances, reverses static batching to separate merged meshes, and translates compiled shader code from multiple platforms back into a readable format. Its broader capabilities include converting serialized files and bundles back into native engine for

    Identifies missing binary assets and broken dependency chains within compiled game builds.

    C#csharpdecompilergames
    在 GitHub 上查看↗6,935
  • sverweij/dependency-cruisersverweij 的头像

    sverweij/dependency-cruiser

    6,804在 GitHub 上查看↗

    Dependency-cruiser 是一个 JavaScript 和 TypeScript 依赖分析器及架构检查工具。它作为一种静态分析工具,用于在无需执行代码的情况下映射、可视化和验证代码库中的模块关系。 该项目的特色在于能够通过基于规则的系统强制执行架构边界。它能检测循环依赖、识别孤立模块和死代码,并使用允许和禁止关系规则来验证依赖约束。它还通过计算传入和传出耦合来提供定量稳定性分析,以识别项目中的脆弱区域。 该工具涵盖了广泛的功能,包括针对 ES6、CommonJS 和 TypeScript 的多标准模块解析,以及带有文件夹级聚合的依赖图可视化。它为持续集成提供了自动化功能,例如违规基准测试以及 JSON 或 CSV 格式的结构化数据导出。 该系统包含一个交互式项目配置引导程序,可根据本地环境生成定制的配置文件。

    Finds and eliminates recursive module import loops in JavaScript and TypeScript projects to avoid runtime errors.

    JavaScript
    在 GitHub 上查看↗6,804
  • dylang/npm-checkdylang 的头像

    dylang/npm-check

    6,643在 GitHub 上查看↗

    npm-check is a command-line tool that audits a project's npm dependencies, comparing local package versions against the npm registry to identify outdated, unused, or incorrect entries. It scans both package.json and node_modules, and can also inspect globally installed npm packages for the same issues. The tool distinguishes itself by offering multiple modes of operation. It can automatically update all outdated dependencies to their latest versions without interaction, suitable for automated scripts. Alternatively, it provides an interactive terminal interface that lets users review and

    Analyzes source code imports to flag packages listed in the manifest that are never referenced.

    JavaScript
    在 GitHub 上查看↗6,643
  • provenance-emu/provenanceProvenance-Emu 的头像

    Provenance-Emu/Provenance

    6,332在 GitHub 上查看↗

    iOS & tvOS multi-emulator frontend, supporting various Atari, Bandai, NEC, Nintendo, Sega, SNK and Sony console systems… Get Started: https://wiki.provenance-emu.com |

    Imports and verifies system BIOS files by MD5 hash, renaming them automatically on import.

    Cataricatalystemulation
    在 GitHub 上查看↗6,332
  • peripheryapp/peripheryperipheryapp 的头像

    peripheryapp/periphery

    6,145在 GitHub 上查看↗

    Periphery is a static analysis tool and dead code detector for Swift projects. It identifies unreferenced classes, structs, functions, and properties, and serves as an API surface optimizer to find public declarations that can be restricted to internal access. The tool includes specialized scanning for Interface Builder files, such as storyboards and XIBs, to ensure UI-connected members are not incorrectly flagged as unused. It also provides automated code removal to eliminate identified dead code and unused parameters directly from source files. Its analysis capabilities cover the detection

    Uses binary index store data to identify unused code without requiring a full project rebuild.

    Swift
    在 GitHub 上查看↗6,145
  • crytic/slithercrytic 的头像

    crytic/slither

    6,141在 GitHub 上查看↗

    Trail of Bits warns when msg.sender is not used as the from parameter in transferFrom, allowing an attacker to drain another user's approved tokens.

    Pythonethereumsoliditystatic-analysis
    在 GitHub 上查看↗6,141
  • google/j2objcgoogle 的头像

    google/j2objc

    6,041在 GitHub 上查看↗

    j2objc 是一个源到源编译器和转译器,将 Java 源代码转换为 Objective-C。它作为一个跨平台逻辑移植工具,允许在 Java 中编写的应用程序逻辑和数据模型在 iOS 上共享和执行。为了支持这种转换,该项目提供了核心 Java 类和 API 的 Objective-C 实现,以模拟 Java 运行时环境。 该系统包括针对 Java 库的专门转换,并提供对依赖注入和静态分析注解的映射以保留元数据。它还支持将 JUnit 测试转换为可执行二进制文件,以验证移动硬件上的逻辑一致性。 为了优化生成的 iOS 应用程序,该项目提供了用于检测未使用代码和消除死代码的工具。它还允许用手写的原生实现替换自动转换的类,以提高执行速度。

    Analyzes source files to identify classes and methods that are unreachable from defined public entry points.

    Java
    在 GitHub 上查看↗6,041
  • benmosher/eslint-plugin-importbenmosher 的头像

    benmosher/eslint-plugin-import

    5,922在 GitHub 上查看↗

    eslint-plugin-import 是一个 ESLint 静态分析插件,提供了一套规则和解析器来验证 import 语句,并强制执行关于文件如何导入和导出代码的架构约束。它作为一个模块验证器和解析器,确保 import 声明指向有效文件且引用的符号存在。 该项目识别递归导入链以防止循环依赖,并利用可配置的解析系统来映射别名和非标准文件路径。它还可以通过路径和文件夹模式匹配来区分内部项目文件和外部库依赖项。 该插件涵盖了更广泛的代码质量领域,包括强制执行导入样式的排序和分组、限制特定模块系统以及验证导出可用性以防止运行时错误。它还可以根据文件夹位置限制导入源或禁止特定路径类型。

    Scans for recursive import loops in module graphs to identify circular dependencies.

    JavaScript
    在 GitHub 上查看↗5,922
  • rhaiscript/rhairhaiscript 的头像

    rhaiscript/rhai

    5,453在 GitHub 上查看↗

    Rhai is an embedded scripting engine and dynamically typed language designed for integration into Rust applications. It functions as an abstract syntax tree compiler and native interop layer, allowing developers to map Rust types and functions into a scripting environment for bidirectional communication. The project serves as a framework for creating customizable domain-specific languages. It allows for the definition of custom operators, syntax, and restricted execution environments, enabling the creation of specialized languages with tailored functional sets. The engine covers a broad rang

    Removes unreachable code blocks and propagates constants within the compiled AST before evaluation.

    Rustembeddedembedded-scripting-languageno-std
    在 GitHub 上查看↗5,453
上一个12下一个
  1. Home
  2. Development Tools & Productivity
  3. Dependency Analysis Tools
  4. Code Dependency Analysis

探索子标签

  • Analysis Depth LimitingLimits the recursive traversal of the dependency graph to a maximum number of levels. **Distinct from Code Dependency Analysis:** Applies depth limiting specifically to the module dependency graph rather than general search algorithms or ASTs.
  • Dependency-Aware Code Analysis1 个子标签Static analysis that incorporates the resolution of external dependencies to provide full visibility of the codebase. **Distinct from Code Dependency Analysis:** Distinct from Code Dependency Analysis: not just listing dependencies, but using them to enrich the analysis of the target code.
  • Missing Dependency Detection5 个子标签Analysis that finds packages used in code but missing from the project manifest. **Distinct from Code Dependency Analysis:** Focuses on identifying omissions in the manifest rather than just listing existing dependencies.
  • Static Dependency Resolution1 个子标签Resolving the full chain of object requirements through static analysis of source code. **Distinct from Code Dependency Analysis:** Focuses on resolving the DI graph via static analysis rather than just extracting a list of dependencies for analysis.
  • Unused Code Identification1 个子标签Static analysis that identifies unreferenced declarations, functions, and classes within source code. **Distinct from Unused Dependency Identification:** Distinct from unused dependency identification which focuses on external packages rather than internal source declarations.
  • Unused Dependency Identification2 个子标签Analysis that finds packages declared in the manifest that are not actually imported in the code. **Distinct from Code Dependency Analysis:** Specifically identifies redundancies in the manifest, whereas general code dependency analysis lists all dependencies.