oh-my-openagent (omo) is a massive, actively-developed TypeScript monorepo that ships as a multi-harness AI-agent orchestration plugin. Its production function is to instrument coding-agent runtimes (OpenCode, OpenAI Codex CLI, and adapters for Claude Code and other harnesses) with a rich layer of lifecycle hooks, background agents, multi-model routing, LSP/AST tooling, team-mode parallelism, and a curated prompt system — all installable via a single `bunx oh-my-openagent install` or `npx lazycodex-ai install` command. The architecture is a workspace of 20+ pure-TypeScript core packages (model-core, rules-engine, skills-loader-core, team-core, tmux-core, delegate-core, hashline-core, lsp-core, mcp-client-core, etc.) that are consumed by two main adapter packages: `omo-opencode` (the full-featured OpenCode plugin with 11 agents, 54+ hooks, team mode, ultrawork/ULW loop, background agents, Codegraph MCP, etc.) and `omo-codex` (a lightweight Codex CLI plugin that vendories a subset of components — rules, comment-checker, LSP, git-bash, ultrawork, ulw-loop, telemetry — as isolated Codex components). A large shared-skills layer provides cross-harness SKILL.md files for programming languages, frontend design, ultimate browsing, debugging, and more. The codebase is notable for its aggressive package layering refactor (documented in ROADMAP.md), its strict no-excuse TypeScript policy, extensive automated QA evidence (.omo/evidence/), and its depth of agent-facing features like hash-anchored edits, prompt-async-gate, runtime fallback with model-suggestion retry, and the start-work/ULW-loop goal orchestration systems. With 64K stars, daily commits, 790 open issues, and a sprawling CI matrix, it is one of the most ambitious open-source agent-orchestration projects in maintenance today.
Headroom is a context optimization layer for LLM applications that reduces token usage by 50-90% through intelligent compression, caching, and memory systems. It provides a transparent proxy between LLM clients (like Claude Code, Cursor, etc.) and LLM providers (Anthropic, OpenAI, etc.), implementing CCR (Compress-Cache-Retrieve) for lossless compression with retrieval capability. The system features a hybrid polyglot architecture with a Rust-based high-performance proxy core, Python ecosystem for extensibility, and TypeScript SDK. Key capabilities include agent wrapping, cross-agent memory using Qdrant/Neo4j, observability through metrics and dashboard, and a learning system that analyzes interaction patterns to generate optimization rules. Deployment options include Docker, system services, and direct execution.
Humanizer is a skill (prompt) for AI agents that rewrites AI-generated text to sound human-written without altering factual content. It is built on Wikipedia's 'Signs of AI writing' guide and provides 26 numbered patterns grouped into six categories (staging, rhythm, inflation, formatting, leftovers, wrong reader). The skill is distributed as a single markdown file (SKILL.md) with YAML metadata, installable via plugin manifests for Claude Code, Cursor, and other agents through the Skills CLI. The repository also includes a validation script, issue templates, and CI workflows to maintain consistency across package files. While not a traditional software application, it functions as a tool that agents execute, with clear entry points (/humanizer command) and a well-defined workflow (mark tells, draft rewrite, check, finalize). The codebase is meticulously maintained with active issue triage, regular releases, and automated validation.
This repository is a production-grade meta-framework for building and managing AI agent plugins across multiple coding assistants (Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot). It establishes a single source of truth in Markdown (`plugins/`) that is compiled into harness-specific artifacts via Python adapters. Key features include a security layer using Cedar policies for tool-call authorization and signed audit receipts, a project management system (`conductor`) for track-based development, and a quality evaluation framework (`plugin-eval`) using static analysis and LLM-based scoring. It solves the fragmentation problem of AI agent ecosystems by enforcing portability and governance.
planning-with-files is a persistent, file-based task-planning system for AI coding agents. It maintains task_plan.md, findings.md, and progress.md on disk and wires into agent lifecycle hooks (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PreCompact, Stop) across Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, Pi, Hermes, and a dozen other assistants, re-injecting plan context into the model's context window on every turn. Plans survive context loss, /clear, compaction, and crashes; a session-catchup mechanism recovers prior transcripts. A v3 gated mode can block the agent from stopping until plan phases complete, backed by an append-only JSONL run ledger, stall detection, and SHA-256 plan attestation that makes hooks refuse to inject tampered content. Architecturally it is a distribution hub rather than a single application: a canonical skill under skills/planning-with-files is mirrored byte-identical into 15+ IDE-specific directories, with native TypeScript plugins (OpenCode, Pi, DSH), a Python plugin (Hermes), and shell/PowerShell hook dispatchers. Plan resolution is a fail-closed chain (PLAN_ID env → .active_plan pointer → newest plan dir → legacy root) guarded by slug validation, containment checks, symlink/junction rejection, and strict PWF_PLAN_ROOT pinning. The engineering is unusually rigorous for an agent-skill repo: 400+ pytest tests, byte-parity tests between shell/PowerShell/Python/TypeScript twins, a PATH-stub BSD userland simulation to catch GNU-only flags that silently fail on macOS, and heavy Windows PowerShell 5.1 / Git Bash portability hardening. Non-obvious patterns include KV-cache-stable injection output (no timestamps or free text in summaries, wall-clock normalization to T00:00:00Z) and an mtime-keyed attestation cache for performance. The repository is a developer tool, not a data/research project; although it ships benchmark and eval documentation (assertion pass rates, recovery-turn comparisons), those are verification evidence for the skill, not analysis artifacts. It is actively maintained at v3.24.0 with recent commits, 4 open issues, and 100+ releases; technical drift is low, with the main maintainability risk being deliberate duplication across 20+ canonical mirrors, mitigated by sync-ide-folders.py and parity tests but still a possible source of silent drift.
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.
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.
This is a monorepo for managing a curated catalog of 'skills'—packaged markdown instructions that extend AI coding agents (Cursor, Claude Code, Copilot). It provides three main surfaces: a CLI (Ink/React TUI) for installing/updating/removing skills, an MCP server (Model Context Protocol) for agent-native access, and a Next.js marketplace for browsing. The core library implements a clean port/adapter pattern for filesystem, HTTP, shell, and environment operations, with a robust lockfile system, content-hash verification, and CDN-based registry distribution. The codebase is well-structured, well-tested, and actively maintained, demonstrating high craftsmanship in dependency injection, state management, and progressive disclosure patterns.
This is a Neovim plugin that animates the cursor with a smear effect, inspired by Neovide's animated cursor. It works in any terminal by using floating windows and Unicode block characters to render a smooth, physics-based trailing cursor. The plugin listens to cursor movement events and interpolates the cursor position using a spring-damper system, drawing the smear as a quad with sub-cell precision. It supports configurable stiffness, damping, particles, and various rendering modes (vertical bar, horizontal bar, diagonal blocks, braille). The codebase is modular, with clear separation between animation logic, drawing, color management, and event handling. The drawing module is particularly noteworthy for its sophisticated use of Unicode symbols to achieve anti-aliased-like rendering in a terminal environment.
This repository implements a 'Repository Harness'—a Rust-based CLI framework designed to make software codebases legible and operable for AI agents. It functions as a control plane for agent-assisted development, managing project state (stories, decisions, traces) through a combination of Git-native documents and a durable SQLite layer. The system enforces architectural rules and invariants via mechanical validation rather than process bureaucracy, distinguishing between a generic 'Core' payload and product-specific 'Consumer' work (e.g., Symphony). Key capabilities include self-updating binaries, semantic changeset replay for auditability, and explicit agent skills for onboarding and auditing. Architecturally, the codebase follows a clean separation of concerns with a Rust workspace containing `harness` (core logic) and `harness-cli` (interface). It utilizes a repository pattern to decouple business logic from database access, implementing transactional logging via JSONL changesets that support idempotent replay. The tool manages its own lifecycle through a robust installer that supports cross-platform profiles (Core vs. Core+CLI) and handles file conflicts via deterministic three-way merges. Evidence capsules and epoch fencing ensure data integrity during agent interactions and state transitions. The project demonstrates a high level of engineering maturity through its focus on reproducibility and trust boundaries. It includes extensive documentation (ADRs, execution plans, stories) and a comprehensive test suite covering installer contracts, changeset rebuilds, and boundary checks. The separation of the 'Symphony' product into a distinct repository while retaining protocol primitives in the core highlights a mature approach to library vs. application boundaries.
Graphify is a CLI tool and library that extracts structural and semantic knowledge graphs from source code across 36+ programming languages. It parses files using tree-sitter grammars, builds a graph of nodes (functions, classes, modules, etc.) and edges (calls, imports, inheritance, etc.), performs community detection via Leiden/Louvain, and generates reports, wikis, and exports to formats like Obsidian, Neo4j, and FalkorDB. The system integrates with AI coding assistants through an MCP server (stdio/HTTP), skill files (SKILL.md, CLAUDE.md), and git hooks for automatic graph updates. Key entry points include `graphify extract`, `graphify query`, `graphify serve`, and `graphify install`. External dependencies include tree-sitter grammars, LLM APIs (OpenAI, Anthropic, Gemini, Ollama), and optional databases. The architecture is modular: per-language extractors in `graphify/extractors/`, graph assembly in `build.py`, clustering in `cluster.py`, and export in `export.py`. The codebase demonstrates strong engineering practices with extensive tests, atomic file writes, security validation (SSRF, path traversal), and cross-platform support.
Patina is a deterministic, pattern-based AI text detection and humanization tool, primarily targeting Korean but supporting English, Chinese, and Japanese. It operates as a Node.js CLI (`patina-cli`), a web API (Vercel serverless), and an agent skill (Claude Code, Codex, Cursor). The core workflow: analyze source text for AI-typical patterns (stylometry, lexicon, discourse tells), build a structured prompt, invoke an LLM backend (OpenAI, Claude, Gemini, Kimi, etc.), verify meaning preservation (MPS/fidelity), and output a humanized rewrite with a deterministic audit trail. It enforces strict meaning guards (number safety, polarity, causation) and provides scoring, diff, and verification modes. The architecture is modular: a shared deterministic analysis core (`src/features/`) runs identically in Node and browser; a prompt builder assembles context from pattern packs, document types, and personas; multiple backend adapters abstract LLM invocation; and a verification pipeline ensures fidelity. The project includes extensive research infrastructure (benchmarking, human evaluation panels, corpus management) and a commercial Pro tier with Polar license validation. It is well-tested with over 200 unit/e2e tests, CI/CD, and security hardening (SSRF guards, input fencing, atomic writes).
Agent Reach is a Python CLI tool that serves as a capability layer for AI agents, giving them one-click access to ~15 internet platforms (Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu, LinkedIn, etc.) without requiring manual setup. It does not wrap these platforms itself; instead, it selects, installs, health-checks, and routes to the most reliable upstream CLI tools (e.g., twitter-cli, yt-dlp, gh CLI, OpenCLI, mcporter) for each platform. The architecture is built around a multi-backend channel pattern: each platform has an ordered list of backends (primary + fallbacks), and the `doctor` command probes each candidate in order to determine the active backend. This design handles upstream tool instability gracefully by allowing fallback routing without code changes. The codebase demonstrates strong engineering practices: a clean Channel ABC with `check()` and `can_handle()` contracts, a robust probe system that distinguishes missing/broken/timeout/error by actual execution, security-hardened file operations (atomic private writes, symlink rejection, bounded reads), and SSRF protection in URL normalization. The CLI provides commands for installation (safe-by-default, read-only mode), diagnostics, configuration, and skill registration for agent environments (Claude Code, OpenClaw, Cursor, OpenCode). An optional MCP server exposes read-only status. Agent Reach is purely an application — there are no notebooks, data pipelines, or ML components. Its value lies in reducing the friction of giving agents internet access, with a focus on zero-config defaults for public platforms and cookie-based auth for login-required ones. The project is actively maintained, with documented responses to upstream API changes (e.g., Bilibili blocking yt-dlp, Twitter API pay-per-use).
The agent-skills repository provides a framework for enhancing AI coding agents with structured engineering workflows called 'skills'. Each skill encodes senior engineer best practices across the software development lifecycle (Define → Plan → Build → Verify → Review → Ship) through opinionated, process-driven guidelines. Skills are invoked automatically based on context or via slash commands and integrate with multiple AI agent tools (Claude Code, Gemini CLI, Antigravity, Codex, etc.) through tool-specific adapters. The system includes a meta-skill for dynamic skill routing, reusable agent personas for specialized tasks, and validation infrastructure to ensure consistency and prevent drift. It is designed to prevent agents from skipping critical steps by mandating concrete evidence (tests, build output) rather than relying on subjective assessments.
This repository implements an MCP (Model Context Protocol) server that bridges AI assistants with SearXNG, a privacy-respecting metasearch engine. It exposes four primary tools: `searxng_web_search` for web queries, `searxng_search_suggestions` for autocomplete, `searxng_instance_info` for capability discovery, and `web_url_read` for fetching and converting web pages to markdown. The server runs in two transport modes: STDIO (default) for simple MCP integration, and HTTP for stateful/stateless remote access with optional OAuth and static bearer authentication. The architecture is modular and security-focused. Core modules include a proxy layer with per-type agent selection, SSRF protection via private IP blocking and DNS rebinding detection, a browser solver chain (FlareSolverr/Byparr) for challenge solving, worker-threaded PDF extraction, and multi-instance failover/fanout for SearXNG replicas. All credential-bearing output (logs, errors, MCP resources) is redacted by a centralized sanitizer. Extensive environment-variable configuration (~40+ knobs) controls caching, timeouts, rate limiting, TLS, and result formatting. Highlights include a strict integer parser that rejects unsafe or malformed values, an LFU cache with age tie-breakers and configurable TTL, and a comprehensive URL security module covering both IPv4 and IPv6 private ranges. The test suite achieves over 90% line coverage and includes integration, unit, fuzz, and e2e tests, with documentation tests that verify README and configuration docs match source contracts. The project is actively maintained with frequent releases, pinned dependencies, and a verification gate that enforces zero-vulnerability audits before publishing.
Branchlet is an interactive CLI tool for creating and managing Git worktrees. It provides both a Terminal User Interface (TUI) built with Ink/React and a scriptable command-line interface for automating worktree operations. The tool simplifies Git worktree management by offering features like intelligent branch handling, automatic file copying to new worktrees based on configurable patterns, post-creation command execution, and shell integration for quick directory switching. It supports project-specific and global configuration through JSON files and includes robust error handling with user-friendly messages.
Mac Messages MCP is a Python application that provides an MCP (Model Context Protocol) server for interacting with macOS Messages. It enables AI assistants like Claude Desktop, Cursor, and others to read, search, and send messages through the native Messages app using standard input/output communication. The application directly accesses the macOS Messages and AddressBook SQLite databases, uses AppleScript for sending messages with automatic SMS/RCS fallback, and provides tools for message retrieval, contact search, fuzzy message search, attachment handling, and permission diagnostics. The architecture follows a clean separation of concerns with the MCP server handling protocol communication, and the messages module containing all core business logic for interacting with macOS systems.
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.
This repository, named 'AI Short' (ChatGPT-Shortcut), is a production-grade Docusaurus-based web application that serves as a curated, multilingual library of over 5,000 AI prompts for ChatGPT, Gemini, Claude, and similar tools. The application provides a searchable, tag-filterable interface with prompt cards, copy-with-tracking, and detailed pages featuring FAQs and related prompts. It supports 18 languages via separate Docusaurus builds and includes a browser extension (Chrome/Firefox) for quick access. Beyond the static prompt data, it offers a community platform with user accounts (OAuth), favorites, custom prompt creation, voting, comments, and a level system. The frontend is a React 19 SPA with Ant Design 6, featuring client-side caching, optimistic UI updates, and lazy-loaded components. The backend (Strapi) is not open-sourced but the API contracts are fully defined. Deployment options include standard (shared backend), offline (localStorage), and full self-hosted setups. The code demonstrates strong engineering practices: clean component decomposition, custom hooks for data management, a two-tier cache system with ETag support, and thoughtful accessibility patterns. The prompt data itself is static JSON, generated from a master file via a Python pipeline, and includes rich metadata for SEO and cross-referencing.
This repository implements an MCP (Model Context Protocol) server that serves as a bridge between MCP clients (like Claude Code) and OpenAI's Codex CLI. It exposes Codex CLI functionality as MCP tools, enabling AI-powered code analysis, generation, and review within editor environments. The server handles stdio communication, manages conversational sessions, spawns Codex CLI processes with appropriate arguments, and processes their output to provide structured responses to clients. The architecture follows a modular design with clear separation between server setup, tool definitions, handlers, session management, and command execution utilities.