This repository contains the Ruff Python linter and formatter, along with the Ty Python type checker, both written in Rust. It is a monolith of several dozen crates assembled into a workspace, delivering a CLI tool, a Language Server Protocol (LSP) server, and a web playground. In production, Ruff analyzes Python source files against hundreds of lint rules from flake8, pylint, pyupgrade, and other plugins, formats code to be compatible with Black, and provides IDE features via LSP. Ty adds type checking and advanced IDE features like goto-definition and workspace symbols. The architecture is modular: a parser produces an AST, semantic analysis operates on that AST, lint rules are checked via pluggable visitors, formatting is done through an IR-based printer, and diagnostics are rendered in multiple formats (JSON, JUnit, SARIF, etc.). The LSP server reuses many of these components through a Salsa-based incremental database for caching. The repository is a model of how to structure a high-performance developer tool in Rust, with extensive test fixtures, fuzzing, and benchmarks. While primarily an application, it includes some data-like assets (test fixture corpora, ecosystem check scripts) but nothing that would classify it as a data research project.
Black is the uncompromising Python code formatter. It is a CLI tool that automatically reformats Python source code to a consistent style, with a focus on determinism and minimal configuration. The repository contains the core formatting engine, a HTTP server (blackd) for on-demand formatting, a GitHub Action for CI integration, and a Vim plugin. The architecture is modular: parsing uses a forked lib2to3 parser (blib2to3) for lenient syntax handling, then a visitor-based line generator produces formatted lines, with specialized transformers for strings, brackets, and comments. It supports Jupyter notebooks, line-range formatting, caching, and parallel execution. The codebase is exceptionally well-tested with hundreds of edge-case test files and a comprehensive test suite. It demonstrates high craftsmanship in areas like tree manipulation, concurrency patterns, and string normalization.
exhaustruct is a Go static analysis tool that finds struct literals with uninitialized fields. It operates as a standalone CLI tool or as an integrated linter within golangci-lint. The analyzer inspects all composite literals in Go source code, resolves their types using go/types, and reports missing field initializations based on configurable rules: comment directives (//exhaustruct:optional, :ignore, :enforce), regex patterns for type inclusion/exclusion, and various flags for allowing empty literals in specific contexts (returns, declarations, blank assignments). It supports both implicit (check all) and explicit (opt-in) modes, and provides automatic migration from deprecated struct tags to comment directives. The architecture is modular and highly crafted: the analyzer package orchestrates inspection, while internal packages handle caching, pattern matching, directive scanning, AST file parsing with correct handling of //line directives, and struct metadata resolution with promotion indexing for composite literals that name promoted fields (Go 1.27+). The codebase demonstrates exceptional attention to edge cases: concurrent access to shared caches, type parameter constraint resolution for generic structs, proper handling of embedded fields across packages, version-gated promotion resolution, and robust diagnostic generation with suggested fixes for tag migration. The implementation is production-ready with comprehensive test coverage including benchmarks, race detection, and dogfooding (running exhaustruct on its own code). The internal cache package provides a generic GetOrSet with once-only computation semantics that could be reused in other projects, and the pattern list offers full-string matching with alternation-aware longest match. The code is well-documented, with clear separation of concerns and thorough testing of all directive combinations and edge cases.
ESLint is a mature, widely-used static analysis tool for JavaScript and TypeScript. It operates as both a CLI tool and a programmatic library, parsing source code into an AST and applying a configurable set of lint rules to detect and fix code quality, style, and correctness issues. The architecture is modular: a core linter (`lib/linter/linter.js`) orchestrates parsing (via espree or custom parsers), rule execution, and fix application; a configuration system (`lib/config/`) resolves flat config files; and a CLI engine (`lib/cli.js`) handles command-line invocation, file globbing, and result formatting. Key entry points include `bin/eslint.js` (CLI), `lib/api.js` (public API exposing `ESLint`, `Linter`, `RuleTester`, `SourceCode`), and `lib/universal.js` (browser-compatible Linter). Data flows: source files are read, parsed into ASTs, traversed by rule visitors, and lint messages are collected, filtered, and formatted. External dependencies include espree (parser), eslint-scope (scope analysis), eslint-visitor-keys, and various community utilities. The codebase is self-hosting, using its own rules and config for development, and includes extensive test suites, fuzzing tools, and ecosystem regression testing.
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.
Bandit is a well-established Python security linter that performs static analysis by parsing source code into ASTs and running a configurable set of plugins against AST nodes. It is primarily a CLI tool, but also exposes a plugin architecture for custom checks and formatters via setuptools entry points. Key entry points include the main CLI (bandit.cli.main), baseline comparison utility (bandit.cli.baseline), and config generator (bandit.cli.config_generator). The core engine (bandit/core/manager.py, node_visitor.py, context.py) orchestrates file discovery, AST traversal, test execution, and result aggregation. It supports multiple output formats (JSON, SARIF, CSV, HTML, XML, YAML, text, screen) and integrates with CI/CD pipelines, pre-commit hooks, and Git via .bandit files. The project is actively maintained, supports Python 3.10+, and has extensive test coverage, though some legacy config conversion code and removed test IDs (e.g., B309, B320) indicate minor drift. Bandit is a reference implementation for a plugin-based security linter with a clean separation between core, plugins, and formatters.
reviewdog is a Go CLI that bridges linter output to code review platforms. It consumes diagnostic output from any linter or compiler via stdin in multiple formats — Vim errorformat, SARIF 2.1.0, Checkstyle XML, the project's own RDJSON/RDJSONL protobuf-defined format, or raw unified diff — parses it, filters findings against a code diff so only issues on changed lines get posted, and reports them to GitHub (check runs, PR reviews, annotations), GitLab MRs, Bitbucket, Gerrit, or Gitea, or writes them locally in text, RDJSON, or SARIF form. The core architecture is a set of loosely coupled Go packages: parser/ for format decoders, diff/ for unified diff parsing, filter/ for diff-aware result filtering, service/ for per-platform comment and diff API clients, cienv/ for CI context detection, and project/ for executing multi-runner .reviewdog.yml configs. The CLI entry point is cmd/reviewdog/main.go, with orchestration in reviewdog.go around the CommentService and DiffService interfaces; command flow is: subprocess or stdin -> parser -> ResultMap -> diff filter -> reporter service -> host-platform API.
This is an Obsidian plugin that provides a highly configurable markdown linter and formatter. It implements over 50 individual rules organized by type (YAML, headings, content, spacing, footnotes, paste) using a clean rule-builder pattern with decorators. The plugin integrates deeply with the Obsidian editor, supporting lint-on-save, paste transformations, custom commands, regex replacements, and a comprehensive settings UI with tabs and search. It includes an extensive test suite (unit and integration) and auto-generates documentation from rule definitions. The architecture is modular: each rule is a self-registering class with typed options, examples, and option builders that also drive the settings UI. Shared utilities for YAML manipulation, markdown AST transformations, and ignore-type masking are well-isolated and reusable. The codebase is actively maintained with frequent commits and responsive issue triage.
Sqlvet is a static analysis CLI tool for Go projects that scans raw SQL queries embedded in Go source code to detect potential runtime errors at build time. It uses Go's SSA (Static Single Assignment) representation and call graph analysis to trace SQL query strings through function calls, handling common patterns like string concatenation, functions returning query strings, and pass-through functions like sqlx.Rebind. Extracted queries are parsed with a PostgreSQL grammar (via pg_query_go) to validate syntax, table/column names against a schema, and detect unsafe dynamic SQL that could lead to injection. The tool supports custom SQL function matchers via TOML configuration, allowing users to extend analysis to their own wrapper libraries. The architecture is a single Go binary with modular packages for configuration, schema parsing, query extraction, and SQL validation, with comprehensive test coverage including integration tests using real Go packages.
This repository implements the official VS Code ESLint extension, which integrates ESLint into the editor via the Language Server Protocol (LSP). The extension is structured as a client-server architecture: the client (`client/`) handles VS Code activation, settings, and UI interactions, while the server (`server/`) runs the actual ESLint validation, computes diagnostics, code actions, and formatting. The shared module (`$shared/`) defines protocol messages and settings types used by both sides. The system dynamically loads the ESLint library from the user's workspace and supports both legacy ESLintrc and modern flat config formats. It provides real-time linting on type or save, auto-fix on save, formatting, rule customization, bulk suppression, and workspace-level task integration. The codebase is well-engineered with clean abstractions for settings resolution, module loading, error handling, and diff computation. It includes standalone reusable components such as an LCS diff algorithm, a linked map with LRU cache, and path normalization utilities.
GPTLint is a linting tool that uses Large Language Models (LLMs) to enforce code quality rules. It employs a two-pass approach: a faster, cheaper LLM model identifies potential violations, and a more accurate, expensive model validates them to reduce false positives. The tool supports both built-in and custom rules defined in markdown files, caches results to avoid reprocessing unchanged files, and provides both a CLI and programmatic API. The architecture is modular, with separate components for configuration, rule parsing, linting, caching, and LLM abstraction.
pg-index-health is an embeddable Java library and schema linter for PostgreSQL that detects common database anti-patterns and promotes best practices. It provides over 40 diagnostic checks covering duplicated/intersected indexes, bloat, missing indexes, inappropriate column types, naming violations, unlogged tables, sequence overflow, and many more. The library is designed for integration into applications (via Spring Boot starter) or use in CI pipelines to enforce schema quality. It supports both single-host and high-availability PostgreSQL clusters, with checks that can run statically (against schema only) or require accumulated statistics. The architecture is a multi-module Gradle project: `pg-index-health-model` defines immutable domain objects (Table, Index, Column, ForeignKey, etc.) with validation and composable predicates; `pg-index-health-core` implements host-level checks using a template pattern (`AbstractCheckOnHost`) with SQL queries loaded from a separate submodule; `pg-index-health` wraps these into cluster-level checks (`AbstractCheckOnCluster`) that aggregate results across primary and standby nodes; `pg-index-health-jdbc-connection` provides connection factories with primary host detection and multi-host URL parsing; `pg-index-health-generator` produces corrective SQL migrations; `pg-index-health-logger` formats results; and `pg-index-health-testing` offers Testcontainers-based test fixtures. Optional Jackson 2/3 modules enable JSON serialization of results. Key entry points include `StandardChecksOnHost` and `StandardChecksOnCluster` which enumerate all available checks, and the Spring Boot auto-configuration (`DatabaseStructureHealthAutoConfiguration`) that registers check beans. Data flows involve querying PostgreSQL system catalogs (`pg_catalog`, `pg_stat_*`), mapping result sets to domain objects via `ResultSetExtractor` implementations, applying exclusion predicates (e.g., skip Flyway/Liquibase tables, small tables, named objects), and returning lists of deviations. External dependencies are minimal: PostgreSQL JDBC driver, Apache DBCP2 connection pool, and Testcontainers for testing. The library is published to Maven Central and includes a BOM for dependency management.
GritQL is a declarative query language and CLI tool for searching, linting, and transforming source code across many programming languages (JS/TS, Python, Java, Go, Rust, Ruby, PHP, SQL, etc.). The repository implements a Rust workspace comprising a pattern-matching engine (grit-pattern-matcher) that compiles GritQL patterns into executable AST-based matchers, a CLI client (grit) with commands like `apply`, `check`, `list`, `patterns`, and `lsp`, an LSP server for IDE integration, WebAssembly bindings for browser use (playground), and Node.js NAPI bindings for programmatic access. Patterns are authored in `.grit` files or embedded in Markdown with sample-based testing. The system uses tree-sitter parsers (vendored grammars) to parse source files, supports pattern caching for performance, and includes authentication, analytics, and remote module resolution. The architecture is modular: core pattern matching is isolated in `crates/grit-pattern-matcher`, pattern compilation in `crates/core`, language support in `crates/language`, and UX in `crates/cli`. The documentation site (Next.js with Markdoc) provides an interactive playground. External dependencies include tree-sitter parsers, NAPI-RS, WebAssembly tooling, and optional LLM APIs for AI-assisted patterns.
The Nu Html Checker (vnu) is a production-grade, multi-format web standards validator that checks HTML, CSS, SVG, and other document types for conformance to W3C specifications. It operates as a Java library, command-line tool, HTTP server (servlet), or Docker container. The codebase integrates several independently developed modules: an HTML5 parser (based on Mozilla's parser), a CSS validation engine (W3C CSS Validator), a RELAX NG schema validator (jing-trang), a URL canonicalization library (galimatias), and a language detection component. Validation is driven by a combination of RELAX NG schemas, DTDs, XSD datatypes, and hardcoded CSS property rules. The system is actively maintained and widely used, with a strong focus on correctness and standards compliance. Its architecture is modular but tightly coupled internally, reflecting its evolution from multiple W3C projects.
This repository provides a comprehensive VHDL language toolchain written in Rust, centered around a Language Server Protocol (LSP) implementation. It includes a lossless concrete syntax tree (CST) parser (`vhdl_syntax`), a semantic analysis library (`vhdl_lang`) with name resolution, type checking, and overload resolution, a standalone linter (`vhdl-lint`) with rule selection and auto-fix, a formatter, and a CLI for AST dumping. The architecture is modular, with separate crates for parsing, analysis, linting, and the LSP server, enabling reuse of components like the CST framework and diagnostic system. The codebase demonstrates high craftsmanship with extensive test coverage (including fuzzing and snapshot tests), code generation from a grammar model, and careful handling of VHDL's Latin-1 encoding and source positions. However, it suffers from a dual-parser architecture (the older hand-written parser in `vhdl_lang` coexists with the newer CST parser in `vhdl_syntax`), which introduces duplication and potential drift. Some VHDL-2019 features are partially supported, and the project tracks the latest Rust stable, imposing a high maintenance burden. Overall, it is a production-quality tool for VHDL developers, with several reusable components that could be extracted for other VHDL tooling projects.
This repository contains a Zotero plugin for formatting item metadata, specifically designed to ensure the existence, correctness, and accuracy of all items and fields in a Zotero library. The plugin includes a rule system with core abstractions expressed as rules, and uses large reference datasets bundled as assets. It is built on the zotero-plugin-template and zotero-plugin-scaffold toolchain and is designed to work with Zotero 8 & 9.
This repository is a monorepo implementing a Language Server Protocol (LSP) integration for JupyterLab, consisting of a Python backend (`jupyter-lsp`) and a TypeScript frontend (`jupyterlab-lsp`). The backend manages multiple language server processes (Python, R, Julia, bash, SQL, etc.) via WebSocket proxying, file system shadowing for disk-based servers, and configurable spec discovery. The frontend provides LSP features (autocompletion, diagnostics, hover, jump-to-definition, rename, signature help, syntax highlighting) as JupyterLab plugins, with custom CodeMirror 6 extensions, a diagnostics panel, and a status bar. The architecture includes virtual documents for notebook cells with IPython magic handling, foreign code extraction (e.g., `%%R`, `%%sql`), and a settings schema system that dynamically populates language server configuration UIs. The codebase is well-tested with Python unit tests, TypeScript unit tests, and Robot Framework acceptance tests running in CI. While the core functionality is robust, there is moderate technical drift due to reliance on undocumented JupyterLab internal APIs, fragile regex-based magic parsing, and some deprecated language server specifications.
proselint is a linter for English prose that checks style, usage, and common writing errors based on authoritative references like Garner's Modern American Usage. It operates as a Python library with a command-line interface (CLI) and a FastAPI web service. The architecture is a monolith: text input is tokenized and matched against a registry of checks (existence, preferred forms, consistency, etc.) using a pluggable regex engine (RE2 or Python re). Results are output as structured JSON or formatted text. The project also includes editor plugins (Sublime Text, CodeMirror), a pre-commit hook, and a Jekyll-based documentation site. While the core linting logic is well-architected with a clean check type system and configurable thresholds, the repository carries significant technical debt from vendored third-party code (an old CodeMirror distribution) and several unmaintained editor plugins. The codebase is actively maintained with CI/CD across platforms and Python versions, but the outdated dependencies and legacy components introduce medium technical drift.
Eslint Watch is a command-line tool that wraps ESLint to add file watching capabilities. It provides a CLI interface that forwards most options to ESLint while adding its own options like --watch, --changed, and --clear. The architecture is modular, with separate modules for option parsing, command handling, ESLint interaction, and file watching. The tool uses chokidar for file system events and keypress for keyboard input to trigger manual re-lints. It demonstrates solid engineering practices with a clear separation of concerns and a reusable option merging pattern.
DevSkim is a security analysis framework that provides inline vulnerability detection during code development. It consists of a core .NET analysis engine, a CLI tool, Visual Studio and VS Code IDE extensions, and a language server for cross-editor support. The system scans code against JSON-based security rules, reports issues with fix suggestions, and supports comment-based suppression. Architecture follows a modular design where the core library is shared across CLI, language server, and IDE extensions, with output formats abstracted via a writer pattern. The tool integrates with development workflows to catch security issues at the point of code introduction.