eslint-plugin-vue is an ESLint plugin specifically designed for linting Vue.js single-file components (SFCs). It provides over 100 rules covering template syntax, script setup, Options API, Composition API, and Vue-specific best practices. The architecture follows standard ESLint plugin patterns with rule implementations in lib/rules/, shareable configurations in lib/configs/ (both legacy and Flat Config formats), and a processor for handling .vue files. Key entry points include the main plugin export (lib/index.ts), the processor (lib/processor.ts), and utility modules (lib/utils/) that provide AST traversal helpers, scope analysis, and component introspection. The plugin relies on peer dependencies eslint and vue-eslint-parser, with optional TypeScript support via @typescript-eslint/parser. It demonstrates strong craftsmanship through well-tested rules, comprehensive documentation, and active maintenance for both Vue 2 and Vue 3 ecosystems.
Understand Anything is a developer tool that analyzes codebases to create interactive knowledge graphs for code comprehension and onboarding. It combines deterministic static analysis (using tree-sitter) with LLM-powered semantic understanding to build explorable graphs of files, functions, classes, dependencies, and business domains. The system features a multi-agent pipeline for analysis, incremental updates via fingerprinting, and a React/Vite dashboard for visualization with guided tours, semantic search, and diff impact analysis. The architecture follows a monorepo structure with pnpm workspaces separating core analysis engine, dashboard UI, and plugin interface. Key capabilities include language-agnostic structural analysis across 30+ programming languages, business domain extraction, knowledge base analysis (Obsidian/Logseq-style wikis), and multi-platform support for AI coding assistants (Claude Code, Codex, Cursor, Copilot). The system operates offline for structural analysis while optionally leveraging LLMs for enrichment, with persistence to a .ua/ directory for team collaboration via version control.
SwiftFormat is a mature, rule-based Swift source code formatter and linter. It operates as a command-line tool, an Xcode source editor extension, and a Swift Package Manager plugin. The core engine tokenizes Swift source code and applies a configurable set of formatting rules, each defined as a static `FormatRule` with help text, options, and a closure that manipulates the token stream via a `Formatter` API. The architecture is modular: rules are isolated in individual files under `Sources/Rules/`, the formatter provides reusable token manipulation primitives, and reporters (JSON, XML, SARIF, GitHub Actions) handle output. Configuration is hierarchical via `.swiftformat` files, inline directives, and command-line options. The system's primary data flow is: source file → tokenization → rule application (ordered by dependencies) → token stream mutation → output. Rules can be disabled, version-gated, or run once. The test suite uses a shared `testFormatting` helper that verifies formatting output, lint idempotency, and change tracking. The project also includes an Xcode extension with a preferences UI and an SPM plugin for build-time formatting. External dependencies are minimal (Foundation, XcodeKit for the extension, and git for header metadata). Key entry points include `CommandLineTool/main.swift` (CLI), `EditorExtension/Extension/FormatFileCommand.swift` (Xcode), and `Plugins/SwiftFormatPlugin/SwiftFormatPlugin.swift` (SPM). The library target `SwiftFormat` exposes `format()` and `lint()` APIs for programmatic use. The codebase demonstrates high craftsmanship with a declarative rule DSL, auto-updating declaration tracking, and a comprehensive test infrastructure that catches regressions across real-world Swift projects (vendored as snapshot fixtures).
peon-ping is a cross-platform sound and notification system for AI coding assistants, intercepting lifecycle events from tools like Claude Code, Cursor, Copilot, and Gemini to play contextual audio feedback (e.g., Warcraft Peon voice lines) and show desktop notifications. The architecture consists of a core hook script (`peon.sh` on Unix, `peon.ps1` embedded in `install.ps1` on Windows), a set of thin adapter scripts that translate each IDE's native event format into a canonical CESP JSON schema, and an MCP server (`mcp/peon-mcp.js`) enabling agents to trigger sounds programmatically. Key data flows: adapter receives an event → pipes JSON to peon.sh → parses config/state → resolves sound pack via override hierarchy → plays audio via platform-appropriate backend → shows notification via overlay or toast. External dependencies include system audio players (afplay, pw-play, ffplay, etc.), ElevenLabs/MiniMax TTS APIs, ntfy.sh/Pushover/Telegram for mobile notifications, and a remote pack registry. The project also includes a trainer mode for exercise reminders, structured debug logging (ADR-002), and an automated agent-driven project management system (gitban) for its own development. Reusable components include the MCP server (can be extracted as a standalone tool), the Windows audio playback module with fallback chain (`scripts/win-play.ps1`), and the TypeScript utilities for debounce/spam detection (`peon-ping-internals.ts`). The adapter pattern is well-documented and could be replicated for new IDEs. The project is actively maintained with frequent commits, comprehensive multi-language tests (BATS, Pester, Vitest), and clear separation of concerns despite the complexity of supporting 20+ IDE integrations.
mcporter is a portable Model Context Protocol (MCP) runtime, CLI, and code-generation toolkit. It connects to configured MCP servers—over stdio, HTTP/SSE, or Chrome DevTools relay—and exposes their tools via a rich command-line interface (subcommands: list, call, resource, auth, config, serve, daemon, generate-cli, emit-ts, record, replay) and a programmatic API (createRuntime, createServerProxy). The architecture is modular: a config layer merges JSON/JSONC files and imports from common editor configs (Cursor, Claude, VS Code); a runtime layer manages transport connections with OAuth support, record/replay, and error classification; a daemon process pools keep-alive servers for low-latency reuse; and a codegen subsystem produces standalone CLIs or typed TypeScript clients from server schemas. The codebase is heavily tested (~150 test files, coverage ≥89.6%), follows modern TypeScript patterns, and supports protocol versions from 2024-10-07 to 2026-07-28. It is not a data pipeline or research project—it is a production-grade developer tool for integrating MCP-powered agents and workflows.
grug-far.nvim is a Neovim plugin providing an interactive find-and-replace workflow using ripgrep and ast-grep as search backends. It presents a dedicated buffer with editable input fields (search pattern, replacement, files filter, flags, paths) and renders results with highlighting, folding, and line-level diff markers. The plugin supports multiple search engines and replacement interpreters (Lua, Vimscript), history persistence, preview, quickfix integration, and instance-level API for programmatic control. The architecture is modular: an engine abstraction layer, async job processing with libuv, a rendering system using Neovim extmarks, and a task lifecycle manager. It includes a comprehensive screenshot-based test suite and CI workflows. The codebase demonstrates strong software craftsmanship with clean abstractions, reusable patterns, and extensive documentation.
Rust Quiz is a monolith application that hosts a collection of medium-to-hard Rust quiz questions. The core function is to parse Markdown question files and corresponding Rust source files, compile and execute the Rust code to verify correct answers, and generate a JavaScript bundle for a static website. It uses a parallel worker pool (rayon) for efficient validation and includes a local HTTP server based on hyper for development. The codebase is well-structured with clean error handling (thiserror) and modern Rust practices. While the primary value is the question content, the build tooling is a robust example of a Rust code snippet tester with output validation and warning checking.
Agent Flow is a real-time visualization tool for monitoring AI agent orchestration, specifically designed for Claude Code and Codex sessions. It captures agent events via hook scripts and file tailing, processes them through a simulation layer, and renders an interactive node graph showing agent relationships, tool calls, discoveries, and performance metrics. The system comprises three main components: a VS Code extension for editor integration, a standalone Node.js server for direct use, and a Next.js-based web application serving as the core visualization frontend. Events are transmitted via Server-Sent Events (SSE) from a relay server to the frontend, which uses React with Tailwind CSS and d3-force for physics-based layout. Key features include live monitoring, timeline scrubbing, session replay, file attention tracking, token usage visualization, and stress testing scenarios. The architecture emphasizes performance through ref-based state management, memoized computations, and virtualized lists for handling large event logs.
Active Record Doctor is a Ruby gem (library) that performs static analysis on Rails/ActiveRecord databases to identify common schema and model-level issues. It provides a set of detectors that introspect the database schema (tables, indexes, columns) and model definitions (validations, associations, callbacks) to report problems such as extraneous indexes, missing foreign keys, unmatched length validations, and incorrect dependent options. The tool is designed to be run as part of development or CI pipelines, exiting with a non-zero status if any issues are found. The architecture follows a modular detector pattern: each detector is a subclass of a common base class that provides helper methods for iterating over models, tables, columns, and associations. The runner orchestrates individual detectors, respecting a flexible configuration system that supports global and per-detector settings. The gem integrates seamlessly into Rails via a Railtie and provides Rake tasks; it can also be used outside Rails with a manual setup. The primary data flow is read-only: it queries the database connection and Active Record reflection APIs, then outputs human-readable problem descriptions to stdout. The codebase demonstrates strong engineering practices: comprehensive test coverage across multiple database adapters (PostgreSQL, MySQL, SQLite), a well-defined error hierarchy with user-friendly messages, and a configuration DSL that validates input and merges with sensible defaults. The gem is actively maintained, supports recent Rails versions (7.0–8.0), and has a dedicated community (1900+ stars, 31 open issues, 68 forks).
curlconverter is a command-line tool and library that converts curl commands into equivalent code snippets in over 30 programming languages and HTTP libraries. It features a modular architecture with a tree-sitter based Bash parser for robust curl command parsing, language-specific generators for target code production, and extensive test coverage. The tool handles complex curl features including authentication, headers, data uploads, multipart forms, proxies, and SSL options, producing runnable code in languages ranging from Python and JavaScript to Rust, Go, and specialized tools like Ansible and HTTPie.
JSON Server v1 (beta) is a CLI tool and library that spins up a fully functional REST API from a JSON or JSON5 file. It is built on top of lowdb for data persistence and @tinyhttp/app for HTTP handling. The architecture is a clean three-layer design: a CLI entry point (bin.ts) that wires file watching and server startup, an Express-like app layer (app.ts) that defines routes and parses query parameters, and a service layer (service.ts) that encapsulates all data access, filtering, pagination, and relationship embedding. The system supports advanced query capabilities including field operators (gt, lt, in, contains, etc.), JSON-based _where queries, sorting, pagination with navigation metadata, and resource embedding via _embed. It also handles referential integrity on deletes by nullifying foreign keys or cascading dependent deletions. The codebase demonstrates solid TypeScript craftsmanship with strict mode enabled, modern ESM modules, and a clear separation of concerns. Notable engineering patterns include the NormalizedAdapter wrapper that enforces string IDs and strips $schema on read while re-injecting it on write, and the Observer adapter that intercepts lowdb read/write lifecycle events to enable file-watch reloading without feedback loops. The query parsing layer cleanly separates URLSearchParams-based operator syntax from raw JSON _where objects, with proper type coercion for booleans, null, and numbers. The project is in active beta (v1.0.0-beta.15) with recent commits, CI via GitHub Actions, and a pre-commit hook running tests. It targets Node.js >=22.12 and leverages experimental TypeScript stripping for development. Dependencies are current and well-chosen (lowdb v7, @tinyhttp v3, eta v4). The test suite uses Node's built-in test runner and covers the service layer, query parsing, pagination, and full HTTP integration tests.
lolcommits is a Ruby gem that captures a webcam snapshot (or video) every time you git commit, creating a 'lolcat' style image with the commit message overlaid. It installs a post-commit hook in Git (or Mercurial) repositories, runs a platform-specific capturer (macOS, Linux, Windows, Cygwin), optionally creates animated GIFs or videos via ffmpeg, and stores results in `~/.lolcommits/<repo-name>/`. The CLI provides commands for enabling/disabling hooks, viewing last capture, browsing captures, generating timelapse GIFs, and configuring plugins (e.g., the default loltext plugin for text overlay). The architecture is a monolith with a plugin system, using MiniMagick for image processing and Launchy for file opening. It is well-maintained, with recent updates for Ruby 3.x compatibility and modern gem dependencies.
This repository contains a tool named `xcdiff` for comparing two Xcode project files (.xcodeproj) and outputting their differences in multiple formats. It is designed as both a command-line utility and a reusable Swift library (XCDiffCore). The tool analyzes structural and configuration differences between projects, including targets, sources, headers, resources, build settings, and dependencies. The architecture follows a modular, plugin-like design where each aspect of the project comparison is handled by a separate comparator implementing a common protocol. This allows for easy extension with new comparison types. Results are rendered through a similarly abstracted renderer system, supporting output formats such as plain text, JSON, markdown, and HTML. The tool is actively maintained and keeps pace with evolving Xcode project formats, as evidenced by fixtures for recent Xcode features like synchronized groups.
PortKiller is a cross-platform desktop application for developers to monitor, manage, and kill processes listening on TCP ports. It provides a unified interface across macOS (SwiftUI), Windows (.NET 9 / WinUI 3), and Linux (Python GTK3 + Rust core) with features including real-time port scanning, process type detection, favorites and watched ports with notifications, two-stage process termination (SIGTERM → SIGKILL), Kubernetes port-forward management with auto-reconnect, and Cloudflare tunnel integration (quick and named tunnels). The application also includes an onboarding wizard, sponsor/contributor display, Sparkle-based auto-updates (macOS), and extensive keyboard shortcut support. The architecture is platform-native with shared patterns: each platform implements its own UI layer, port scanner, and process killer, while a Rust core library (`portkiller-core`) provides scanning and process termination for Linux. The macOS version uses an actor-based `PortScanner` and observable state management (`AppState`), the Windows version follows MVVM with a system tray mini-window, and the Linux version uses a GTK3 system tray indicator. All platforms share a common feature set but with varying completeness (macOS is the most feature-rich). External dependencies include `lsof`/`ss` (Linux), `kubectl`, `cloudflared`, `socat`, and system utilities for process enumeration. Key data flows: port scanning via platform-specific commands (lsof, ss, GetExtendedTcpTable) → parsing into `PortInfo` models → filtering/searching → display in tree/table views → user actions (kill, watch, favorite, forward, tunnel). Kubernetes port-forwards and Cloudflare tunnels are managed as subprocesses with monitoring loops for reconnection and log streaming. The application persists user preferences (favorites, watched ports, customizations) using platform-native storage (Defaults on macOS, JSON on Windows/Linux).
Electron Router DOM is a library that facilitates the integration of react-router-dom with Electron applications, enabling window-based routing where each Electron window can have its own routing configuration. The library handles the complexities of loading URLs in development versus files in production, provides type-safe APIs for passing data between main and renderer processes via query parameters, and abstracts away the low-level Electron window management details. It follows a clean architecture with clear separation between main process utilities (registerRoute function) and renderer process components (Router component), supported by shared TypeScript types and utility functions. The library is designed to improve developer experience by eliminating manual management of Electron's loadURL and loadFile methods while maintaining compatibility with react-router-dom's routing patterns.
This repository implements an MCP (Model Context Protocol) server that provides semantic code search capabilities for AI assistants. It enables developers to search their codebases by meaning rather than just keywords, using local AI models to ensure privacy and avoid external API calls. The system features semantic code search using embeddings (nomic-embed-text-v1.5 with MRL), incremental indexing with file watching, efficient SQLite-based caching of embeddings, cross-platform package version checking across 20+ ecosystems, workspace switching capabilities, and resource throttling to prevent system overload during indexing. The codebase demonstrates strong engineering practices with proper error handling, modular design, and attention to user experience.
This repository provides syntax highlighting for GraphQL files in Xcode. It consists of an Xcode plugin that defines a file type for .graphql files and a language specification that provides syntax coloring. The plugin adapts to the deprecation of the Xcode plugin mechanism by focusing on the file type and language specification components, which still work in recent Xcode versions. The core component, GraphQL.xclangspec, is a well-crafted language definition that covers the full GraphQL syntax.
Code Thesaurus is a Django-based web application that serves as a polyglot developer reference, allowing users to compare programming language and database syntax side-by-side. The system reads a curated filesystem-based JSON data store organized by language/version/structure, renders comparison and reference pages via Django templates with syntax highlighting (Pygments), and provides REST API endpoints. It also logs analytics (visits, lookups, missing items) to a relational database. The architecture is a monolithic Django app with a clean separation between data (JSON files), models (abstractions for loading and querying data), views, and middleware. The repository also includes management commands for generating template JSON files and validating the data structure, along with a comprehensive test suite and CI/CD pipelines. While primarily an application, it has a significant data curation component, with the thesaurus JSON files being the core asset that is community-maintained and validated.
gpt-review is a Python CLI tool that integrates OpenAI/Azure OpenAI models to assist with software development workflows. It provides three main functionalities: asking questions to GPT models (with optional file/context), reviewing GitHub pull requests and posting AI-generated comments, and generating git commit messages based on staged changes. The application uses a modular architecture with separate components for different functionalities: question answering (_ask.py), PR review (_review.py), git operations (_git.py), document indexing (_llama_index.py), and API wrappers (_openai.py). It leverages the knack library for CLI structure, GitPython for git operations, Requests for GitHub API calls, and LlamaIndex for context-aware queries. The tool supports both direct OpenAI API and Azure OpenAI with automatic fallback to Azure Key Vault for credentials.