Beads (bd) is a CLI-based issue tracking system designed for AI agents and developers, using Dolt as a version-controlled SQL database backend. It provides persistent, structured memory for coding agents through features like dependency tracking, workflow automation (molecules/formulas), and JSON output for scripting. The architecture features a modular Go design with clear separation between CLI, storage abstraction (supporting both embedded and server Dolt modes), workflow APIs, and extensibility systems. Key capabilities include issue lifecycle management, dependency graphs, blocking detection, telemetry, hook-based extensibility, and integrations with external trackers like Jira, GitHub, and Notion. The system emphasizes correctness through extensive conformance testing, transactional operations, and merge-safety mechanisms for distributed clones.
Oh-My-ClaudeCode (OMC) is a multi-agent orchestration layer for Claude Code, Anthropic's AI coding assistant. It extends Claude Code with a plugin system, custom MCP tools, a team collaboration engine, a real-time HUD, and a rich hook system. The system is implemented in TypeScript and runs as a CLI tool (`omc`), an npm package (`oh-my-claude-sisyphus`), and a Claude Code plugin. It manages autonomous coding pipelines (autopilot, ralph), multi-worker team sessions via tmux, skill learning and injection, and provides extensive tooling including LSP integration, AST analysis, Python REPL, and git-based checkpoints. Architecturally, OMC is a modular monolith with clear separation: a CLI entry point (Commander-based), a hook registry with ~20+ lifecycle hooks (session-end, pre-tool-use, persistent-mode, etc.), a team subsystem with state machines and tmux-based worker management, a HUD rendering engine, and a standalone MCP server exposing 33+ tools. The system integrates with multiple AI providers (Claude, Codex, Gemini, Grok, Cursor) and git hosting providers (GitHub, GitLab, Azure DevOps, Bitbucket, Gitea). External dependencies include `@anthropic-ai/claude-agent-sdk`, `@modelcontextprotocol/sdk`, `better-sqlite3`, `zod`, and `commander`. Key data flows include: user input → CLI or Claude Code hook → hook dispatcher → feature modules (autopilot, team, skills) → tool execution → state persistence (filesystem, SQLite). The system maintains extensive state on disk (`.omc/state/`, session transcripts, team events, skill files) and uses file-based locking for concurrency safety. The JEV shadow judgment system provides non-blocking evaluation of heuristic decisions against an external API for quality monitoring. The codebase demonstrates strong engineering practices: extensive test coverage (~3000+ tests), modular architecture with clear interfaces, atomic file operations, and security-conscious utilities (SSRF guard, token redaction, path traversal prevention). It is actively maintained with frequent releases and responsive issue triage.
Cookiecutter is a command-line utility for creating projects from templates (cookiecutters). It uses Jinja2 to templatize file and directory names, prompts users for input, and generates a customized project structure. The tool supports local and remote templates (via Git/Hg), includes a hook system for customizing the generation process, and provides a Python API for programmatic use. Architecture-wise, it is a modular Python package with distinct components for CLI, configuration, environment setup, template discovery, generation, hooks, prompting, replay, VCS operations, and utilities. Key entry points are the `cookiecutter` CLI command and the `cookiecutter.main.cookiecutter()` function. The system follows a data flow where template location is resolved, context is gathered (from defaults, user config, and prompts), templates are rendered with Jinja2, and output is written to a directory, optionally executing user-defined hooks at various stages.
Pixel Agents is a developer tool that visualizes AI coding agents (primarily Claude Code) as animated pixel-art characters in a virtual office environment. It ships as both a VS Code extension and a standalone CLI (`npx pixel-agents`), sharing a common runtime. The system monitors agent sessions in real-time via HTTP hooks (preferred) or JSONL file polling (fallback), normalizes events through a provider abstraction, and renders agent state (tool usage, context tokens, team structures, permissions) on a Canvas-based pixel-art office map. The architecture follows a hub-and-spoke pattern: a Fastify HTTP/WebSocket server aggregates agent activity, an AgentRuntime manages lifecycle and state, and a MessageTransport abstraction (PostMessage for VS Code, WebSocket for standalone) broadcasts updates to the React 19 + Canvas webview UI. The codebase is well-structured with clean interfaces (HookProvider, TeamProvider, StateAdapter), extensive test coverage (unit, integration, and Playwright e2e with a mock Claude CLI), and CI-enforced contract drift detection (AsyncAPI spec ↔ generated TypeScript, e2e inventory). While only the Claude provider ships, the provider registry is designed for multi-CLI support. The project demonstrates strong engineering practices with some complexity risks in dual-mode detection, consent flow edge cases, and cross-platform path handling.
AgentMemory is a persistent memory system designed for AI coding agents (Claude Code, Cursor, Codex, etc.) that captures agent observations via hooks, compresses and stores them, and enables semantic/recall search across sessions. Built on the iii-engine framework, it provides a modular architecture with CLI, REST API, MCP server, and web viewer interfaces. The system eliminates repetitive context re-explanation by automatically injecting relevant memories into agent sessions, implements memory consolidation to extract stable facts, and includes features like working memory management, audit trails, and health monitoring. Agent integrations occur through platform-specific hooks and MCP tools, allowing agents to store observations and retrieve context without manual intervention.
REPENTOGON is a comprehensive modding framework for the game The Binding of Isaac: Repentance. It extends the game's Lua API with hundreds of new functions, provides low-level hooking and assembly patching capabilities, integrates ImGui for developer tools, and adds features like custom item pools, save syncing, virtual room management, and achievement tracking. The architecture is a hybrid of a C++ DLL that injects into the game process and a set of Lua scripts that run in the game's Lua environment. Key entry points include the DLL main (dllmain.cpp) which initializes hooks and patches, and the Lua registration system (LuaInit.cpp) which exposes new classes and callbacks. The framework relies on reverse-engineered game structures, signature scanning, and runtime code modification to achieve deep integration. External dependencies include the game itself, Lua 5.4, ImGui, and several bundled libraries (glad, rapidxml, rapidjson, mINI). The codebase is large and actively maintained, with a strong focus on modder extensibility and bug fixing.
This repository is a comprehensive tutorial on building AI agent harnesses, structured as 17 progressive lessons. Each lesson introduces a single mechanism (tool use, permissions, hooks, planning, subagents, skill loading, context compaction, memory, task system, background tasks, cron scheduler, agent teams, MCP integration, workflow runtime, and goal loop) that extends a core agent loop without modifying it. The harness enables a language model (Claude) to perceive, reason, and act through tool interactions while managing context, permissions, and collaboration. The repository includes runnable Python implementations for each lesson and an interactive Next.js web application with visualizations for learning and experimentation.
This repository is a comprehensive configuration and extension set for Anthropic's Claude Code AI coding assistant. It enhances Claude Code with a sophisticated hook system for event-driven automation, a specialized agent delegation system for task-specific AI assistants, and an activity tracking mechanism that injects context-aware guidance based on user behavior. The system also includes templates for generating project documentation and integrates with external services like Pushover for notifications. While it contains example documentation for a game project (likely 'Mystica'), its primary purpose is to provide a customizable development environment for AI-assisted software engineering.
Notion is an X11 window manager with tiling, tabbing, and floating layout capabilities. It features a modular architecture where core functionality resides in ioncore/ and extends via loadable modules (mod_tiling, mod_menu, mod_statusbar, etc.). Configuration and extensibility are driven by Lua scripts, allowing deep customization of key bindings, layouts, and status bar elements. The system handles X11 events, manages window geometry and focus, and provides session saving/restoring. Key components include a reference-counted object system (libtu/obj), Lua-C binding layer (libextl), hook system (libmainloop/hooks), and binding maps for contextual input handling. Despite its age, the codebase shows recent activity and maintains compatibility with modern X11 environments.
BeikeShop is a production-ready, open-source cross-border e-commerce platform built on Laravel 12 (PHP 8.2+). It provides a full-featured online store with admin panel, shop frontend, multi-language (10+ languages), multi-currency, and a plugin system for extensibility. The codebase is a Laravel monolith with separate `Beike\Admin`, `Beike\Shop`, and `Beike\AdminAPI` namespaces, using Blade templates, Vue 2 (Element UI) for admin, and jQuery for the shop frontend. Key features include product/category management, shopping cart, checkout with multiple payment gateways (Stripe, PayPal, etc.), order state machine, RMA (returns), tax calculation, a drag-and-drop page builder for home pages, and a comprehensive installer. The architecture follows repository and service patterns, with a custom hook system for plugin extensibility. While the codebase is functional and actively maintained, it shows signs of technical drift (Vue 2, older JavaScript libraries, hardcoded strings, and some poor machine translations) and the plugin system adds complexity. The highlight is a well-designed, reusable Hook system and a clean StateMachineService for order workflows.
This repository implements the Adaptive Query Optimization (AQO) extension for PostgreSQL, a machine learning-based system that improves query planning by learning from historical query execution statistics. The extension integrates with PostgreSQL's planner and executor via hook mechanisms to override cardinality estimation with predictions from per-query-class k-nearest neighbors regression models. It features a multi-layer architecture: preprocessing (query classification and mode handling), cardinality estimation (ML-based prediction), postprocessing (statistics collection and model updates), and shared memory persistence for query statistics and ML models. Key operational modes include disabled, learn, intelligent, controlled, and forced, controlled via GUCs. The system automatically tunes learning/usage flags based on prediction stability and includes background workers for maintenance. The extension requires patching PostgreSQL source and rebuilding, with tight coupling to internal planner structures (e.g., RelOptInfo, Plan nodes) and executor functions. Deployment involves setting shared_preload_libraries, configuring GUCs like AQO.mode, and managing memory limits for query classes and feature subspaces. It provides SQL interfaces for managing query classes (enable/disable, status checks) and EXPLAIN integration for runtime visibility. The test suite includes pgbench integration, SQL scripts for feature validation, and Perl scripts for pg_stat_statements compatibility. While the core AQO logic is highly specialized to PostgreSQL, two components demonstrate extractable excellence: the hash function for query normalization (ignoring constants/whitespace) and the standalone k-NN regression implementation with linear smoothing. These show non-obvious skill in handling SQL variability and efficient online learning. However, the deep integration with PostgreSQL internals, version-specific patching requirements, and complex state management introduce maintenance challenges and technical debt risks, particularly during PostgreSQL version upgrades.
Open-Pomodoro CLI is a command-line Pomodoro technique tracker built with Go and Cobra. It implements the Open Pomodoro Format for data storage, allowing users to start work sessions, take breaks, track completed pomodoros, view history, configure settings, and execute hooks at state transitions. The application features a modular architecture with separate packages for command handling (cmd/), output formatting (format/), and hook execution (hook/). It stores data in ~/.pomodoro/ as text files and supports multiple output formats including human-readable, JSON, and iCal. The tool integrates with tmux for status display and provides a comprehensive set of subcommands for managing the Pomodoro workflow.