The Front-End Checklist is a comprehensive, open-source platform for front-end quality assurance, targeting both human developers and AI agents. It delivers a curated corpus of 386+ best-practice rules across 11 categories (HTML, CSS, JavaScript, Performance, Accessibility, SEO, Security, Images, Testing, Privacy, i18n) via a Next.js web application, a Model Context Protocol (MCP) server, and a standalone CLI. The architecture is a pnpm monorepo with shared packages for authentication (Better Auth + Prisma), design system (Radix UI), analytics (OpenPanel), state management (Zustand), search (FlexSearch), storage (IndexedDB), and validation. The MCP server exposes 11 tools (audit_url, review_code, search_rules, etc.) for AI-assisted code review and URL auditing, while the CLI provides offline audit capabilities. The web app offers rule browsing, user checklists with progress tracking, guides, and public profiles. The system is production-deployed on Vercel with PostgreSQL, Sentry error tracking, and Upstash rate limiting.
Gentle-AI is a CLI-driven application that manages AI coding agents through installation, configuration, and review workflows. It provides a deterministic engineering environment with features like persistent memory (Engramâ„¢), receipt-driven development (RDD) for verifiable code reviews, and telemetry collection. The architecture is modular, separating concerns into CLI commands, agent adapters, components (like Skills and Context7), review transaction logic, state management, and a text-based user interface. The system interacts with external AI agents (Claude Code, OpenCode, Cursor, etc.) via adapter patterns, manages state in $HOME/.gentle-ai, and supports cross-platform operation (Linux, macOS, Windows). Key entry points include the gentle-ai CLI command and TUI screens for interactive workflows.
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 repository implements an AI-powered code review CLI tool (`ocr`) that analyzes Git diffs or full file contents using configurable Large Language Models (LLMs) such as Anthropic, OpenAI, and AWS Bedrock. It originates from Alibaba Group's internal code review assistant, validated at massive scale (tens of thousands of developers, millions of code defects). The core workflow involves loading a diff or file set, dispatching review tasks to an LLM agent with tool-use capabilities (file reading, code search, comment posting), and collecting structured review comments with line-level precision. It supports multiple review modes (workspace changes, single commit, branch range), full-file scanning, session persistence with resume capability, token budget management, and output in text, JSON, and SARIF formats. The architecture is a Go CLI with a Cobra command tree, complemented by a VS Code extension (TypeScript/Preact), plugins for Claude Code, OpenCode, and other coding agents, and CI/CD integration examples for GitHub Actions, GitLab, Bitbucket, Gerrit, GitFlic, and Alibaba CodeUp. A local web viewer (`ocr viewer`) and a public documentation/marketing website (React) are also part of the repository. The codebase exhibits strong engineering practices: extensive test coverage (unit, integration, manual e2e), clean package separation, thread-safe components, and careful error handling (retry observers, host guard for the viewer). Key reusable patterns include a retry collector for LLM API calls, a state-machine-based run manifest builder for coverage tracking, an abstract file reader for workspace vs git-ref reads, and a worker pool with per-key async processing.
This repository is the official open-source companion to Anthropic's Claude Code—an agentic AI coding assistant that operates in the terminal. It is not the core Claude Code binary (distributed separately via npm/brew/install scripts), but rather the plugin ecosystem, example configurations, CI automation scripts, and infrastructure-as-code templates that extend and support the tool. The repo contains 13 first-party plugins (e.g., security-guidance, code-review, feature-dev, commit-commands, pr-review-toolkit, hookify, plugin-dev), each defining hooks, commands, agents, and skills that integrate with Claude Code's extensibility framework. It also provides production-grade Terraform modules for deploying a Claude Code Gateway on AWS (ECS Fargate + RDS + Bedrock) and GCP (Cloud Run + Cloud SQL + Vertex AI), along with enterprise MDM settings (macOS plist/mobileconfig, Windows ADMX, Intune scripts) and managed settings templates. A suite of GitHub Actions workflows handles automated issue triage, duplicate detection, lifecycle management, and code review, all using Claude Code itself as the automation engine. The repository is primarily a configuration and extension catalog rather than a standalone application; its value lies in demonstrating the plugin architecture and providing reusable patterns for AI-assisted development workflows.
The Entire CLI (`entire`) is a production-grade command-line tool that integrates AI coding agents (Claude Code, Codex, Gemini CLI, Cursor, Copilot, OpenCode, Factory AI Droid, Pi) with Git workflows. It captures session transcripts, token usage, file changes, and agent prompts as git-backed checkpoints, enabling traceability, review, and collaboration on AI-assisted development. The CLI provides commands for session management (`session`, `resume`, `clean`), checkpoint inspection (`checkpoint list`, `checkpoint policy`), multi-agent code review (`review`, `investigate`), authentication (`auth`, `login`), and project management (`project`, `grant`). It operates as a git remote helper (`git-remote-entire`) for pushing/pulling checkpoint data via the Entire data plane. Architecturally, the system is a modular Go CLI built on Cobra, with pluggable backends for checkpoint storage (git-refs and git-branch) and agent integration. Each agent has a dedicated package under `cmd/entire/cli/agent/` that implements hooks, transcript parsing, and lifecycle management. Security is a first-class concern: file operations use `os.Root` to prevent symlink escapes (`osroot`), session IDs are validated against path traversal (`validation`), and a configurable redaction pipeline strips secrets from transcripts (`redact`). The system uses OpenAPI-generated client code (`internal/coreapi`) for control plane communication and supports multi-region deployment via cross-jurisdictional HTTP clients. The codebase demonstrates high craftsmanship with clean package boundaries, extensive test coverage (unit, integration, e2e, and benchmarks), and well-documented interfaces for extensibility. Reusable components include atomic JSON file writing, cross-platform process management (`execx`), advisory file locking (`flock`), and process liveness detection (`proclive`). The review subsystem provides a framework for multi-agent code review with structured findings, which could be adapted for other automated review workflows. While the codebase is well-maintained and actively developed, the tight coupling to many agent-specific formats and the dual checkpoint backend add maintenance surface area and complexity.
This repository is the canonical source for **OpenClaw Agent Skills**, a collection of portable, reusable agent workflows (skills) for coding agents such as Claude Code, Codex, Pi, and OpenClaw. The primary deliverable is not a standalone application but a set of self-contained skills that provide automated code review (autoreview), redacted session publication (beam), session transcript provenance (agent-transcript), local session viewing (session-viewer), behavior validation (behavior-validator), and remote test orchestration (crabbox). Each skill lives under `skills/<name>/` with a required `SKILL.md` file and auxiliary scripts, tests, and references. The repository also includes cross-platform installer (`scripts/install-skills`) and validator (`scripts/validate-skills`) scripts that support symlink or copy installation into agent skill directories. Architecturally, the skills are independent of each other and are consumed by agents via direct symlink/copy. The most complex skill is `autoreview`, which performs a full AI-driven code review pipeline: capture git diff/commit/working-tree state, build a review prompt with evidence, invoke one of several engines (Codex, Claude, Amp, Pi) via subprocess, parse structured JSON reports, and produce a final review result with security hardening (isolation probes, credential scanning, terminal escape prevention). The `autoreview` script is monolithic (~80k tokens) but contains reusable patterns for safe subprocess environment sanitization, git diff collection, JSON extraction from noisy output, and engine isolation verification. The `session-viewer` skill provides a polished local HTML renderer for agent session JSONL files, with importers for multiple session formats. The `beam` skill focuses on redacted publication of coding sessions to a read-only catalog. The codebase demonstrates high engineering craftsmanship: extensive test coverage (Python unittest, Jest for TypeScript, shell-based harness), security-conscious patterns (symlink validation, stat-preserving writes, process group signal handling, environment sanitization), and cross-platform support (Windows, macOS, Linux via CI). The test suite is especially thorough for `autoreview`, covering edge cases like CRLF handling, binary files, merge commits, worktrees, shallow clones, and sensitive path patterns. The installer pattern (symlink for development, copy for vendored snapshots) is designed to minimize drift while allowing zero-setup downstream usage. Overall, the repository is actively maintained, uses modern tooling (Python 3.14, Node 26, TypeScript 7), and is well-suited for teams adopting agent-assisted development workflows who need reusable, vetted skill definitions.
Clawpatch is an automated code review and repair CLI tool that maps a repository into bounded semantic feature slices, invokes external AI coding agents (Codex, Claude, ACPX, Grok, etc.) to review each slice for bugs and quality issues, and supports explicit fix workflows with validation. The architecture is a modular TypeScript application with a provider abstraction layer, language-specific feature mappers (Node, Python, Ruby, Go, Rust, C/C++, .NET, Java/Kotlin, Swift, Elixir, PHP/Laravel), state persistence via JSON files in a `.clawpatch` directory, and a safety-first design (read-only reviews, explicit fix commands, clean worktree checks, change auditing). Key entry points are the CLI (`src/cli.ts`) and application orchestrator (`src/app.ts`), with data flowing from project detection to feature mapping to provider-based review to optional fix/revalidation/PR creation. External dependencies include git, gh CLI, various AI coding CLIs, and the npm registry (optional). The tool is well-tested with Vitest, has extensive CI/CD, and demonstrates high craftsmanship in its provider abstraction, state management with locking, prompt building with provenance tracking, and review validation pipeline.
This is a production-grade, AI-powered code review automation tool that integrates with multiple version control systems (GitHub, GitLab, Bitbucket Cloud/Server, Azure DevOps, Gitea) and multiple LLM providers (OpenAI, Claude, Gemini, Ollama, Bedrock, OpenRouter, Azure OpenAI). The system is implemented as a Python async CLI application, packaged as a Docker image, and includes CI/CD integration templates for GitHub Actions, GitLab CI, Jenkins, Bitbucket Pipelines, and Azure Pipelines. Architecturally, it follows a clean layered design: a CLI layer (Typer) drives commands; a configuration layer (Pydantic Settings with multiple file/env sources) manages nested settings for LLM, VCS, agent, review, artifacts, and logging; a service layer orchestrates the review process through runners, gateways, and internal services (prompt building, diff analysis, policy enforcement, cost tracking, artifact persistence); and a client layer provides unified abstractions for VCS and LLM providers with provider-specific implementations. The tool supports multiple review modes: inline comments on specific code lines, summary comments on the entire PR, context review (full repository exploration via an optional agent loop), and reply to existing comments. The agent loop uses a ReAct pattern with tool execution (shell commands like `rg`, `cat`, `git`) to gather deeper context, with duplicate detection and context limits. A dry-run mode allows testing without posting to VCS. The system also includes a hook service for lifecycle events, cost tracking per request, and optional artifact saving of LLM interactions. Key strengths include extensive test coverage (unit tests with fake clients and fixtures), generic reusable components (HTTP client with retry, pagination helpers, diff parser, LLM output JSON parser, cost service), and a well-structured configuration system that supports discriminated unions for provider-specific settings. The codebase is actively maintained, uses modern Python async patterns, and demonstrates high craftsmanship in its abstraction layers and separation of concerns.
This repository is SAP's official, community-driven collection of coding style guides, focused on ABAP development within the SAP ecosystem. The centerpiece is Clean ABAP (clean-abap/CleanABAP.md), a comprehensive adaptation of Robert C. Martin's Clean Code for the ABAP language, covering naming conventions, language constructs, variables, internal tables, conditions, classes, methods, error handling, comments, formatting, and testing - with each rule paired as good and anti-pattern code examples. A companion guide (abap-code-review/ABAPCodeReview.md) defines a pragmatic, checklist-based ABAP code-review process tied to the Clean ABAP rules. The repo is documentation-only; it is not a runnable application, service, or data pipeline. Its only executable surface is a GitHub Actions workflow (build.yml) that validates markdown links via markdown-link-check, plus an automated issue labeler. Content is organized as a single large primary document (~10,000+ lines) with modular deep-dive sub-sections (clean-abap/sub-sections/), a print-optimized cheat sheet, and full translations into eight languages (English, Chinese, German, Spanish, French, Japanese, Korean, Russian). The project is actively maintained - last commit April 2026, 79 open issues triaged through structured templates (propose new rule, clarification, adjust existing rule) - and uses a formal governance model requiring consensus and quarterly review for significant changes. The guides are opinionated by design and openly acknowledge tensions with legacy code, performance, and official SAP guidelines; enforcement is delegated to companion tools such as abaplint and code pal for ABAP. Primary drift risk is translation lag - several translations are based on English versions from 2019-2022 - and evolution of the ABAP language beyond the NetWeaver releases referenced in the text.
GitSavvy is a full-featured Git plugin for Sublime Text, providing an extensive keyboard-driven interface for common Git operations. It includes a status dashboard, diff viewer, inline diff, commit view, log graph with interactive rebase, blame, branch/tag management, stash management, and integrations with GitHub and GitLab for pull/merge requests and remote operations. The architecture is built on a mixin-based command system, an asynchronous runtime for UI/worker thread management, and a reactive UI framework for dashboard views. It leverages custom Sublime Text syntax highlighting for Git-specific views and is highly configurable via settings. The codebase demonstrates strong engineering practices with well-structured modules, caching patterns, and extensive test coverage, though it is tightly coupled to the Sublime Text API and has some legacy dependencies (e.g., Python 3.8 requirement, deprecated `imp` module usage).
Codiff is a desktop code review tool (Electron + React) that visualizes Git diffs, supports AI-generated narrative walkthroughs, and integrates with GitHub/GitLab pull requests. It also provides a web sharing service for walkthroughs and plans, allowing users to share review snapshots publicly. The architecture is a monorepo with three packages: `core` (React UI library), `service` (Cloudflare Workers sharing API), and `web` (Cloudflare Workers frontend for shared content). The Electron main process handles Git state reading, AI agent orchestration, configuration, and window management, while the renderer uses React with custom hooks for review state, comments, walkthrough navigation, and diff search. Key entry points include `bin/codiff.js` (CLI), `electron/main.cjs` (Electron main), `core/index.tsx` (renderer), and `web/src/App.tsx` (web app). Data flows: Git diff data is parsed in `electron/git-state/` and sent to the renderer via IPC for display. AI walkthroughs are generated by calling external agent CLIs (Codex, Claude, OpenCode, Pi) from the main process, with output parsed and cached locally. Sharing involves uploading walkthrough/plan manifests to a Cloudflare Workers API backed by D1 and R2. External dependencies include Git, `gh`/`glab` CLIs, multiple AI agent CLIs, and Cloudflare infrastructure. The codebase is well-tested with extensive unit and integration tests, and includes an evaluation framework for walkthrough quality.
discrawl is a Go CLI application for archiving and searching Discord data. It syncs messages from the Discord API, imports Discord desktop cache, stores raw JSON in SQLite via sqlc-generated code, and provides subcommands for sync, publish, subscribe, share import, and remote status. It also exports/imports compressed JSONL snapshots with manifests and commits them to a Git snapshot repo using NUL-delimited path-only commits to preserve unrelated staged work. The repository is primarily an application, but it also vendors agent skills (autoreview, crabbox, discrawl) under .agents/skills, making it a hybrid monorepo.
SuperCoder is a local-first, open-source AI coding agent with a desktop application (Tauri + Rust + React) and a suite of backend services. The core agent (Rust crate) provides an LLM-driven loop with tool execution (file editing, bash, git, code search), subagent spawning, and an 'Auto' mode where an orchestrator LLM generates plans executed by worker agents. The desktop app offers a rich UI for agent interaction, diff review, file exploration, and permission management. A separate Go-based 'Context Engine' service indexes codebases into vector (Qdrant), graph (FalkorDB), and text stores, enabling semantic code search, dependency analysis, and automated PR review with risk scoring. The repository also includes a legacy v1 backend (Go) with workflow executors for Django/Flask/Next.js code generation and a workspace service for managing isolated development environments. While primarily an application, the context engine introduces data/research elements through its indexing pipelines, retrieval strategies, and code review analytics.
This repository is the full-stack implementation of Mega, a large-monorepo Git hosting and code collaboration platform with a Rust backend and a large React/Next.js frontend. The backend is split into several crates: mono provides the HTTP/SSH API server, ceres contains application services for Git operations, change lists (CLs), code review, build triggers, webhooks and notifications, jupiter handles persistence through SeaORM entities and storage services, jupiter-migrate manages a large sequence of database migrations, and orion/orion-server implement a Buck2-based distributed build orchestration system. The frontend in moon/apps/web is a feature-rich collaboration application with posts, notes, chat, notifications, project management, diff viewing, CL/merge-queue review, admin groups, OAuth integrations, and editor support. The core operational flow is: git push/import -> ceres transport and jupiter storage -> change list and merge-queue workflows -> build triggers sent to Orion -> build events/checks streamed back to the UI.
This repository implements an AI-powered code review bot for GitHub. It listens for pull request events (opened, synchronize) and uses OpenAI's language models (or Azure OpenAI, GitHub Models) to automatically review code diffs and post inline comments and summary reviews. The system supports multiple deployment modes: a Probot-based GitHub App, a GitHub Action, an AWS Lambda function, and a Vercel serverless function. The core logic is in `src/bot.ts` (event handling, file filtering, review creation) and `src/chat.ts` (LLM API abstraction). The architecture is a monolith with adapter layers for each platform. External dependencies include the OpenAI/LLM API, GitHub API via Octokit, and minimatch for glob-based file filtering. The bot is configurable via environment variables for model selection, prompt customization, language, and file inclusion/exclusion patterns. It also implements an incremental review feature to reduce API costs by only re-reviewing files changed since the last bot review.
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.
The repo is a monorepo with the TypeScript library in the root and the autoreview skill duplicated across `.agents`, `.claude`, `skills`, and `$AGENTS_HOME`. Entry points include `test/protocol.test.ts`, `.agents/skills/autoreview/SKILL.md`, and `scripts/check-pack.mjs`. External dependencies include Node.js, pnpm, git, and external AI CLIs. The codebase has strong security hardening but also a monolithic autoreview script (~80k tokens), tight coupling between tests and internal helper names, and platform-specific skips that create drift risk.
This repository contains no application source code. The only substantive file is a GitHub Actions workflow (clawsweeper-dispatch.yml) that acts as a dispatch router for the ClawSweeper bot, forwarding GitHub events (issues, issue comments, pull requests) to the openclaw/clawsweeper repository. The workflow uses a GitHub App token for authentication and includes debouncing, comment filtering, and acknowledgment logic. The repository itself is essentially a configuration stub—there are no scripts, binaries, or libraries. The bot's actual logic resides elsewhere. The repo appears to be a placeholder or thin integration layer, with no functional code to evaluate for craftsmanship or reusability.