Checkstyle is a production-grade Java static analysis library and CLI tool that enforces configurable coding standards. In operation, it reads Java source files (and related resources like property files, package-info, and HTML docs), parses them with an ANTLR-based Java and Javadoc grammar, builds a concrete syntax tree, and traverses it through a Checker/TreeWalker pipeline. Individual checks are modular and validate naming, whitespace, imports, Javadoc, coding practices, design, metrics, and more. Violations flow through configurable filters - including comment-based suppression, @SuppressWarnings, and XPath-based suppression - and are emitted by pluggable loggers for plain text, XML, or SARIF output. The project also ships a CLI for AST printing, XPath query generation, and suppression file generation, plus an Ant task integration.
ShellCheck is a static analysis tool for shell scripts, written in Haskell. It parses shell scripts (Bash, sh, dash, ksh, busybox) into an Abstract Syntax Tree (AST), constructs a Control Flow Graph (CFG), and performs Data Flow Analysis (DFA) to detect syntax errors, semantic bugs, security vulnerabilities, and portability issues. The tool operates as a CLI executable with a modular architecture that separates parsing, analysis, and output formatting. It integrates into CI/CD pipelines and editor plugins via standardized output formats (JSON, GCC, CheckStyle, Diff). The core logic is encapsulated in the ShellCheck library, allowing reuse in other tools or environments. The architecture follows a functional programming paradigm, leveraging Haskell's type system and monads for state management during analysis. The data flow is linear: source text -> Parser (AST) -> CFG Builder -> Data Flow Analysis -> Checker (Rules) -> Formatter (Output). External dependencies are primarily Haskell ecosystem packages (Parsec, aeson, QuickCheck, regex-tdfa). The tool supports configuration via `.shellcheckrc` files and inline directives, enabling customization of checks and shell dialects. ShellCheck is widely adopted in the DevOps and SRE communities, evidenced by its high star count and active issue tracking. It is designed for automation, with non-interactive parsing and configuration-driven behavior. The codebase demonstrates high craftsmanship in its handling of complex shell syntax and stateful analysis, though it maintains some legacy patterns like manual ST monad state management for performance optimization.
Vulture is a fast static analysis tool for finding unused code in Python programs. It uses the AST module to scan Python files, recording definitions and usages of functions, classes, variables, imports, and attributes, then reports those that are defined but never used. It also detects unreachable code after return, break, continue, raise, and unsatisfiable if/while conditions. The tool is implemented as a library (Vulture class) and a CLI entry point. It supports configuration via pyproject.toml, whitelists to suppress false positives, and noqa comment support. The architecture is modular with separate modules for reachability analysis, noqa parsing, line number utilities, and configuration handling. The codebase is well-tested, with near 100% coverage, and is actively maintained.
This repository provides a collection of shared configurations and tools for web development at Shopify. It is structured as a monorepo containing multiple npm packages, including ESLint and Stylelint plugins with custom rules, Babel presets, TypeScript configurations, Prettier settings, and utilities for image optimization. The project enforces consistent coding standards across Shopify's web applications and is used in their build and development pipelines. The architecture is modular, with each package providing a specific tool or configuration that can be extended by consumers.
This is an ESLint plugin (`eslint-plugin-functional`) that enforces functional programming patterns in JavaScript and TypeScript code. It provides 20 actively maintained rules targeting immutability, functional parameters, no classes, no exceptions, no statements, and other FP principles. The plugin deeply integrates with TypeScript's type system via `@typescript-eslint/utils` and libraries like `is-immutable-type` for type-aware immutability checks. It offers multiple configuration presets (strict, recommended, lite, etc.) and supports ESLint 9 and 10 flat configs. The codebase is well-structured with a consistent rule factory (`createRule`), shared utilities (type guards, option overrides), and an extensive test suite using snapshot testing. It is actively maintained with frequent releases, a comprehensive CI pipeline, and semantic versioning.
autopep8 is a production-grade Python code formatter that automatically modifies source code to conform to the PEP 8 style guide. It operates as both a CLI tool and a library, using pycodestyle to detect violations and applying targeted fixes for most reported error codes (E1xx, E2xx, E3xx, E4xx, E5xx, E7xx, E9xx, and W6xx). The tool supports incremental formatting, aggressive mode, configuration file inheritance (pyproject.toml, setup.cfg, tox.ini, .pep8, .flake8), and integration with pre-commit hooks and editors like Vim. The entire logic is contained in a single monolithic module (autopep8.py), which includes a complex line-wrapping system for long lines, a reindentation engine, and token-based heuristics. The test suite is exceptionally thorough, with fixture-based regression tests and an 'acid test' framework that validates correctness on arbitrary Python files (including live PyPI packages). While the single-file architecture limits modularity, the internal components are well-factored and demonstrate strong engineering practice.
This repository is an ESLint plugin for the Vitest testing framework, providing over 60 lint rules to enforce best practices, catch common errors, and maintain code style in test files. It is a library consumed by ESLint, not a standalone application. The plugin exports a flat config (recommended, all) and an environment configuration for Vitest globals. The codebase is well-structured with a consistent rule creation pattern using a factory utility (`createEslintRule`), centralized Vitest function call parsing (`parseVitestFnCall`), and a reusable padding rule factory (`createPaddingRule`). It relies on `@typescript-eslint/utils` for AST analysis and is designed for ESLint v9+ with flat config. The project is actively maintained with CI/CD, automated releases, and comprehensive test coverage for each rule.
This repository is the `eslint-plugin-react` package, a widely-used ESLint plugin that provides over 100 lint rules for React and JSX codebases. It is not a standalone application but a library consumed by ESLint to enforce best practices, prevent common errors, and maintain code style in React projects. The plugin supports both legacy `.eslintrc` and modern flat config (`eslint.config.js`) formats, and works with multiple parsers including babel-eslint and TypeScript-ESLint. The architecture is modular: each rule is a self-contained module in `lib/rules/`, sharing common utilities from `lib/util/` for component detection, AST traversal, version checking, and error reporting. The codebase is well-tested with a comprehensive test suite that runs across parser versions and ESLint versions. It is actively maintained with frequent releases and community contributions.
This repository is an IntelliJ Platform plugin that integrates ktlint, the Kotlin linter, into JetBrains IDEs. It runs ktlint automatically on Kotlin files, highlights violations in the editor, provides quick fixes, and supports custom rulesets and baseline files. The plugin is built as a Gradle multi-module project with a dedicated ktlint-lib module that bundles the ktlint engine, and a ktlint-plugin module containing the IntelliJ-specific integration. It uses the IntelliJ Platform Gradle Plugin, convention plugins in build-logic, and a set of shell scripts for release and IDE compatibility checks. Architecturally, the plugin is a standard IntelliJ plugin: it registers an external annotator for real-time diagnostics, a local inspection for batch analysis, and persistent settings components for application and project configuration. It caches baseline violations to avoid re-reporting known issues and loads external ruleset JARs at runtime. The build is automated with GitHub Actions for build verification, UI tests, IDE release checks, and Gradle wrapper updates. The code is written in Kotlin and follows IntelliJ plugin best practices, with JUnit4 tests and a release pipeline that generates plugin descriptions from the README.
This repository implements `@google/design.md`, a CLI tool and programmatic library for a design token format called DESIGN.md. The format pairs YAML frontmatter (tokens) with Markdown prose (rationale). The tool provides validation (lint), diffing, multi-format export (Tailwind v3 JSON, Tailwind v4 CSS, DTCG JSON, CSS custom properties), and spec generation. It is published as an npm package and is designed to be consumed by both human designers and AI coding agents. The architecture is a monorepo with a single CLI package (`packages/cli`) that uses `citty` for command routing. The core pipeline parses DESIGN.md files, builds a token model with reference resolution and color parsing, runs 11 lint rules (including WCAG contrast ratio checks), and emits results via stateless handler functions. A separate spec generation pipeline compiles `spec.mdx` with a custom MDX compiler to produce `docs/spec.md`. The codebase is well-tested with unit tests for each component. Key entry points include the CLI binary (`packages/cli/src/index.ts`), the programmatic `lint()` function (`packages/cli/src/linter/index.ts`), and the spec generator (`packages/cli/src/linter/spec-gen/`). External dependencies are minimal: `citty` for CLI, `zod` for validation, `consola` for logging, and `bun` for build/test. The repository also includes three complete example design systems and a set of agent skills for development workflow.
This is an ESLint plugin that provides three formatting rules (`format/prettier`, `format/dprint`, `format/oxfmt`) to format code using Prettier, dprint, and oxfmt respectively. It is designed to be used with ESLint's flat config and treats formatters as side-effects-free tools, giving users full control over which formatter to apply to which file types. The plugin uses `synckit` to run formatters synchronously in worker threads, and `eslint-formatting-reporter` to generate fix suggestions. The architecture is clean: each rule is a standard ESLint rule that lazily loads a synchronous wrapper around the actual formatter library. The codebase is well-structured, with comprehensive tests and CI. It is actively maintained and uses modern JavaScript/TypeScript practices.
This repository is a curated 'awesome list' for ESLint, not a software application or data pipeline. Its core is a single, extensively organized README.md that catalogs ESLint configurations, plugins, parsers, formatters, globals, tools, tutorials, and setup resources. The only functional code is a package.json declaring the `awesome-lint` dev dependency and a GitHub Actions workflow that runs this linter against the README on every push and pull request to ensure list quality and formatting consistency. The architecture is intentionally static—no runtime services, APIs, or data processing exist. The repo's production value is purely informational: it serves as the de facto community reference for discovering and choosing ESLint-related tooling. It is actively maintained with recent commits, high visibility, and a clear contribution guide. Technical drift is limited to outdated CI details (e.g., actions/checkout@v3) and a broad dev-dependency range, but the content itself stays current with the ESLint ecosystem. While not a codebase in the traditional sense, the curation quality, categorization, and maintenance discipline are strong, making it a reliable resource for developers evaluating ESLint tools.
This is an ESLint plugin that provides a single rule, `ban-dependencies`, which flags usage of npm packages that have better alternatives or are redundant. It uses presets (e.g., native, microutilities, preferred) from the `module-replacements` package to suggest replacements. The plugin also supports user-defined module bans and allowlists, and can lint `package.json` files to detect banned dependencies. The codebase is written in TypeScript, well-tested, and follows modern ESLint plugin conventions. The repository appears to be superseded by `@e18e/eslint-plugin` as noted in the README, and is likely no longer actively developed.