Danger Js

danger-js is an automated code review tool and CI pipeline plugin that functions as a pull request linter. It verifies commit messages, tracks dependency changes, and ensures pull requests meet project standards by posting automated feedback and comments directly into the version control interface.

The system integrates with various Git providers, including GitHub, GitLab, and BitBucket, to retrieve pull request metadata and execute custom review rules. It allows teams to package and distribute review conventions as shareable modules and supports the execution of rules written in transpiled languages through runtime configuration.

The project covers a wide range of automation capabilities, including code quality governance, dependency management audits, and the enforcement of pull request etiquette. It can parse results from external linters, test runners, and coverage tools to report failures, monitor bundle sizes, and detect anti-patterns or prohibited words within the codebase.

The tool can be executed as a build step within a continuous integration pipeline or locally via git-hooks.

Features

CI Pipeline Integrations - Executes automated code review checks by adding a CLI command to the continuous integration build pipeline.
Automated Code Review - Provides an automated system to analyze source code and enforce team conventions and etiquette via CI pipelines.
VCS Metadata Abstraction - Fetches pull request and commit data by abstracting different version control APIs into a common interface.
Quality Governance Systems - Enforces organizational quality standards by detecting debug statements and missing type annotations before code is merged.
Commit Message Validation - Validates that commit messages adhere to specific formats and alerts users when standards are not met.
Dependency Tracking - Tracks and validates dependency changes to maintain project health and keep packages updated.
GitLab Integrations - TypeTalk connects to GitLab instances via API or OAuth tokens to automate code review conventions on open pull requests.
Bitbucket Sync Filters - Connects to BitBucket Server instances to enforce code review conventions and provide automated feedback.
Pull Request Review Interfaces - Reports failures and warnings directly into pull requests using inline comments and formatted tables.
Policy Enforcement Rules - Automates checks for missing issue references, debug logs, and insufficient test coverage against team policies.
Pull Request Linters - Scans code changes for problematic patterns and style violations specifically during the pull request review process.
Version Control Provider Integrations - Establishes authenticated connections to BitBucket Cloud to automate review checks and post comments.
CI Review Automations - Executes as a build step within a continuous integration pipeline to enforce team conventions.
Pull Request Automation Tools - Automates repetitive pull request tasks such as linking Jira issues and validating PR descriptions.
Code Review Bots - Functions as an automated agent that verifies commit messages and ensures pull requests meet project standards.
Git Provider Connections - Authenticates requests to Git hosting providers using environment variables to access private repository data.
Metadata Extraction - Retrieves pull request details, commit history, and reviewer activities from VCS providers for analysis.
Automated Code Review Tools - Automatically inspects code changes and provides feedback on team conventions and etiquette within pull requests.
Git - Abstracts GitHub, GitLab, and BitBucket APIs to retrieve pull request metadata and post automated comments.
CI Pipeline Summaries - Posts test results, linting errors, and code coverage summaries as automated comments directly in the version control interface.
Code Task Tracking - Lists all TODO or FIXME markers added or removed within a pull request to ensure resolution.
Analysis File Filters - Groups specific files from a pull request to target analysis rules to a relevant subset.
Analysis Report Aggregators - Parses structured JSON output from external linters and test runners to generate unified feedback summaries.
Change Prohibitions - Flags specific code changes that should be avoided and notifies the developer.
Source-to-Source Analysis - Analyzes original source code instead of compiled output by integrating with TypeScript and Babel.
Custom Lint Rule Plugins - Packages common code review rules into shareable modules that other teams can install.
Markdown Comment Rendering - Transforms analyzed metadata and tool results into formatted markdown tables and comments for VCS interfaces.
Dependency Auditing - Scans lockfiles and manifests during review to detect outdated, duplicate, or insecure dependencies.
Version Evolution Tracking - Tracks the evolution of project dependencies to ensure consumers are aware of version shifts.
Change Set Size Limits - Checks the number of changed files against a maximum limit to keep reviews manageable.
Metadata Validations - Verifies that pull requests include assignees and follow specific title patterns.
Team Norm Validations - Executes common validations and utility checks on pull requests to ensure they adhere to team norms.
PR Change Auditing - Scans modified files and commit messages to ensure required updates like changelogs are included.
Git Hooks - Executes code review conventions via git-hooks to provide instant feedback before pushing code.
Issue Tracking Integrations - Integrates external issue tracking systems directly into the development workflow by analyzing commit and PR metadata.
Linter Result Aggregators - Analyzes ESLint output to integrate linting errors into a review aggregator for automated feedback.
Polyglot Rule Runners - Uses a processing engine to execute review rules for any programming language.
PR Metadata Validation - Verifies pull request bodies and labels to ensure team contribution norms are followed.
PR Netiquette Enforcement - Inspects the pull request body for required content such as issue references or minimum character counts.
VCS-Issue Linking - Provides bidirectional linking between Jira project issues and version control entities like pull requests.
Dependency Addition Alerts - Notifies reviewers when new dependencies are added to the project configuration.
Lint Result Commenting - Converts static analysis and linting reports into actionable inline comments within the pull request.
Self-Hosted Git Services - Supports connectivity to self-hosted enterprise Git instances via custom API base URLs.
Webhook Event Receivers - Receives and processes webhook events from external hosting platforms to trigger real-time automation tasks.
Linter Rule Extensions - Imports shared community rules or custom logic to standardize checks across multiple projects.
Runtime Configuration Transpilers - Uses TypeScript or Babel at runtime to execute code review rules written in transpiled languages.
Anti-Pattern Detection - Scans code changes for problematic patterns or structural flaws and triggers warnings.
Standardized Changelog Structures - Validates that changelog modifications follow a specific structural format including version lines and headers.
Plugin-Based Rule Engines - Packages custom review conventions into shareable modules that can be imported across multiple projects.
Annotation Scanning - Scans the codebase for FIXME and TODO markers and triggers failures if they are detected.
Prohibited Pattern Scanners - Checks source code for suspicious words or patterns defined in a text file and alerts the user.
PR Documentation Standards - Checks pull requests against predefined digital standards to ensure consistency and adherence to team norms.
Annotation Verifiers - Checks that new JavaScript files include type annotations to maintain static type safety and codebase consistency.
Pull Request - Analyzes TSLint JSON output files to automatically post warnings and failures to pull requests.
Code Coverage Analysis - Posts a comment on a pull request displaying code coverage metrics generated during continuous integration.
Debugger Statement Detection - Performs static analysis to detect console logging statements and prevent debug code from being merged.
CI Log Parsing - Parses logs or JSON output from external CI processes to post failure details into the review.

qodo-ai/qodo-cover

5,444View on GitHub

Qodo Cover is an engineering governance platform and AI-powered assistant designed for automated code review and unit test generation. It utilizes an abstract syntax tree codebase knowledge graph to map dependencies and architectural relationships, allowing it to analyze pull requests and enforce organizational coding standards. The system distinguishes itself through a multi-agent analysis pipeline that performs architectural reasoning and identifies bugs beyond the immediate diff. It features a model context protocol server to expose codebase intelligence to external tools and can automatic

anc95/ChatGPT-CodeReview

4,445View on GitHub

ChatGPT-CodeReview is an AI-driven code analysis tool and bot that uses a large language model to automatically review pull request diffs and post feedback on code changes. It functions as a system for detecting bugs and suggesting improvements in source code. The tool provides a containerized runtime for deployment as a background process or through a GitHub Action. Users can customize the analysis behavior, style, and technical depth by adjusting model parameters and system prompts. The system handles automated code review workflows by triggering analysis via webhooks and CI pipelines, upd

OneRedOak/claude-code-workflows

3,636View on GitHub

This project is a suite of automated tools and an LLM code review framework designed for design auditing, security scanning, and AI-driven code analysis. It functions as a developer workflow orchestrator that uses static analysis agents and agent-based workflows to automate pull request analysis and security audits. The system employs a dual-loop agent architecture to coordinate primary analysis and secondary verification, reducing false positives. It distinguishes itself through the use of browser automation to perform live UI component testing and verify frontend changes against accessibili

awesome-skills/code-review-skill

1,043View on GitHub

This project is a specialized instruction set for AI coding agents designed to perform structured, language-specific code reviews. It functions as an automated tool that evaluates source code against predefined checklists to identify security, performance, and architectural inconsistencies across diverse technology stacks. The system distinguishes itself by employing a multi-phase analysis pipeline that moves from high-level architectural assessments to granular, line-by-line inspections. It utilizes a severity-based taxonomy to categorize findings, clearly separating blocking security issues

dangerdanger-js

Features