thehardwarestore.ai

This repository is a community distribution and feature-extension framework for OpenAI's ChatGPT desktop application on Linux. It does not contain the core ChatGPT application itself; instead, it verifies, repackages, and patches the official signed upstream .deb package to produce customized builds for multiple Linux package formats (deb, RPM, pacman, AppImage, Nix, Gentoo ebuild). The system adds over 40 optional Linux-specific features—such as system tray integration, global dictation, computer-use automation (window management, accessibility, screenshots), desktop recording/replay, text-to-speech, proxy authentication, and UI tweaks—each gated behind a declarative feature manifest and applied via a sophisticated patch engine that modifies the Electron app bundle at build time. Architecturally, the project is a build/packaging/update framework. The core is a patch engine (scripts/patches/) that applies declarative descriptors to the upstream app.asar in phases (main-bundle, webview-asset, extracted-app). Features live under linux-features/ with standardized manifests (feature.json), patch scripts (patch.js), stage hooks, and tests. Performance-critical subsystems are implemented in Rust: a computer-use backend (window management, input simulation, accessibility tree), a record-replay backend (desktop session capture, timeline events, skill drafting), a text-to-speech MCP server, a global dictation helper, and a self-updating package manager daemon. The launcher (start.sh.template) orchestrates environment setup, feature hooks, and CLI dispatch. Key entry points include the installer (install.sh), the feature picker GUI (scripts/feature-picker.py), the patch runner (scripts/patches/runner.js), and the updater daemon (updater/src/main.rs). Data flows are primarily build-time: the upstream .deb is downloaded, verified via GPG/SHA256, extracted, patched, and repackaged. At runtime, features like computer-use and record-replay communicate with native Rust backends over MCP/JSON-RPC. The updater daemon runs as a systemd user service, polling signed APT metadata and performing transactional rebuilds with rollback support. External dependencies include the upstream OpenAI .deb package (the sole ground-truth source), Node.js for patching, Rust for native components, and various Linux system tools (systemd, D-Bus, GNOME Shell, X11/Wayland utilities, ydotool, wmctrl, xdotool, secret-tool). The build system uses Make, Docker for CI, and supports multiple package managers. The project is heavily dependent on the upstream bundle's minified JavaScript structure, which it manages through contract-based patching with drift detection.

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.

PiDeck is an open-source Electron desktop application that serves as a comprehensive workbench for AI coding agents, primarily wrapping the `pi` coding agent and the DeepSeek Harness (DSH) backend. It provides a rich session-centric chat workspace with features including multi-project management, Git integration, a built-in terminal, voice transcription, image generation, scheduled automation tasks, a desktop pet companion, and extensive configuration options. The application supports importing sessions from other tools like Claude, Codex, Cursor, and OpenCode, and offers a web service variant for remote access. Architecturally, PiDeck follows the standard Electron pattern with a main process (Node.js services, IPC handlers, filesystem operations), a preload script for secure IPC bridging, and a renderer process built with React 19, TypeScript, Jotai for state management, and Tailwind CSS v4 with shadcn/ui-style components. The codebase is organized into `src/main/` for backend services, `src/renderer/` for the UI, and `src/shared/` for cross-process types and utilities. Key entry points include the main process index, renderer bootstrap, and numerous IPC modules that validate inputs and delegate to domain services. Data flows center on session files stored in JSONL format (for pi) or compressed JSONL (for DSH), with model catalogs, usage statistics, and configuration persisted in user data directories. The application manages multiple backends through a unified session catalog, with runtime state synchronized via IPC events and Jotai atoms. External dependencies include the pi-coding-agent CLI, DSH runtime packages, node-pty for terminal emulation, whisper.cpp for local speech-to-text, and electron-updater for cross-platform updates. The codebase demonstrates strong engineering practices with extensive unit tests (node:test), Playwright E2E tests, pure-function modules extracted for testability, and consistent IPC boundary validation patterns.

CC Switch is a desktop application built with Tauri (Rust backend + React/TypeScript frontend) that serves as a unified management hub for multiple AI coding assistants, including Claude Code, Claude Desktop, Codex, Gemini CLI, Grok Build, OpenCode, OpenClaw, and Hermes Agent. Its core function is provider switching: it manages configurations, API keys, OAuth tokens, and MCP servers across these tools, and provides a local HTTP proxy that routes API requests to different AI providers with failover, circuit breaking, and usage tracking. The application also includes session management, skills/prompts synchronization, cloud sync (S3/WebDAV), deep link import/export, and a usage dashboard with cost tracking. The architecture follows a command-service-DAO pattern in Rust, with a React frontend using TanStack Query for state management, react-hook-form for forms, and shadcn/ui components. The proxy subsystem is particularly sophisticated, implementing format conversion bridges between different AI API protocols (Anthropic Messages, OpenAI Chat/Responses, Gemini), streaming transforms, thinking budget optimization, cache injection, and content encoding handling with bomb protection. The frontend is organized around per-app provider forms, a universal provider panel, and settings pages for proxy, MCP, skills, and usage. Key features include: 50+ provider presets for third-party API relay services, one-click provider switching with live config backup/restore, a local proxy with auto-failover and circuit breaker, session history browsing across supported apps, skills installation from GitHub repos, prompt management with per-app sync, and usage statistics with custom pricing. The application supports i18n (English, Japanese, Chinese) and runs on Windows, macOS, and Linux.

Taste-skill is not a software application in the traditional sense; it is a portable library of AI-agent 'skills' - extremely detailed Markdown instruction files (SKILL.md) distributed via the `npx skills add` CLI (Vercel agent-skills spec) and a .claude-plugin marketplace. The repo's product is the prompt content itself: 13 frontend design-direction skills that agents like Claude Code, Codex, and ChatGPT load to avoid generic 'AI slop' output. The flagship is `taste-skill` v2 (`design-taste-frontend`), a ~5000-line instruction document that codifies anti-pattern bans (zero em-dashes, no section-number eyebrows, no three-equal-card rows), a brief-inference protocol, design-system mapping to official packages (Fluent, Carbon, Polaris, GOV.UK), canonical GSAP/scroll-reactive code skeletons, and a hard pre-flight checklist with mechanical pass/fail criteria. It is complemented by image-generation-only skills (brandkit, imagegen-frontend-web/mobile) that produce reference comps for downstream coding agents, plus variant skills (brutalist, minimalist, soft, stitch, output-enforcement). The repository also contains a `research/laziness/` folder documenting LLM output-truncation causes and remediation, and a small set of Node/Sharp image-processing scripts used to build the README assets. Those scripts contain one genuinely valuable, extractable algorithm: a flood-fill outer-background removal with auto-cropping to content bounds. The scripts are one-off (hardcoded `C:/Users/User/Downloads` source paths, tightly coupled to specific sponsor assets), so they are not drop-in reusable without adaptation, but the background-removal technique itself is portable. This is a content/instruction repository rather than a codebase; software-engineering quality bars (tests, CI) do not apply. Its craftsmanship lives in the rigor, specificity, and mechanical enforcement of the prompt files, which is exceptional for the prompt-engineering domain. The active development cadence, current dependency references (Tailwind v4, Motion/react, React Server Components), and 92k-star traction confirm it is the leading project in its niche.

CherryStudio is a cross-platform desktop AI assistant built with Electron and React. It provides a unified chat interface that supports dozens of LLM providers (OpenAI, Anthropic, Google, Groq, local models via Ollama, etc.) through a pluggable provider registry and the Vercel AI SDK. Beyond chat, it offers knowledge base management with RAG (vector indexing via sqlite-vec, chunking, embedding), file processing (OCR with Tesseract/PaddleOCR, document parsing), web search, image generation, MCP (Model Context Protocol) tool integration, and code CLI management (Claude Code, OpenAI Codex). The application is organized as a pnpm monorepo with separate packages for the UI component library, AI core runtime, provider registry, and tracing infrastructure. Architecturally, the app follows an Electron main/renderer process split with typed IPC communication using Zod schemas. The main process handles AI inference, database operations (SQLite via Drizzle ORM), file management, and native integrations. The renderer is a React SPA using TanStack Router, SWR for data fetching, and a custom UI component library with extensive icon sets for providers and models. The AI runtime layer abstracts provider-specific details through adapters and supports streaming, tool calls, agent sessions, and context compaction. Key data flows include: user input → composer → IPC → AI runtime → provider API → streaming response → renderer. Knowledge base ingestion follows: file upload → OCR/parsing → chunking → embedding → vector store. The application also supports offline usage with local embedding models and ONNX runtime. External dependencies include native binaries for OCR and vector search, and the AI SDK ecosystem.

JeecgBoot is an enterprise-grade low-code development platform that accelerates application delivery through AI-powered code generation, online form/report builders, and workflow integration. The backend is built on Spring Boot 3 with MyBatis-Plus, Shiro, and JWT, supporting both monolithic and microservice architectures (Spring Cloud, Nacos, Sentinel, XXL-Job). The frontend uses Vue 3 + TypeScript + Ant Design Vue with a rich component library including JVxeTable for editable grids and schema-driven forms. The platform provides comprehensive RBAC, multi-tenancy, dynamic data sources, data dictionaries, and third-party integrations (DingTalk, WeChat, Feishu). A dedicated AI module (airag) offers RAG knowledge bases, LLM chat, voice/image generation, and MCP plugin support. The codebase is actively maintained with frequent commits and a large community, though it contains some commented-out legacy code and hardcoded security values that represent minor technical debt.

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 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.

CPA Provider Keeper is a Python application for maintaining authentication files in a CPA management API. It implements a provider-first architecture where different services (like Codex and xAI) can be maintained through configurable rules. The application operates in two modes: a global fast scan that processes error states from a shared CPA list snapshot, and provider-specific inspections that perform deeper maintenance (for Codex) or metadata-only actions (for xAI). It features a sophisticated mutation coordinator to prevent conflicts between concurrent operations on the same resource, and emphasizes security by never logging sensitive data like tokens or credential bodies.

Clawd on Desk is a cross-platform Electron desktop companion application that visually reflects the real-time activity of AI coding agents (Claude Code, Codex, Cursor, Gemini, Kimi, Qwen, and 18+ others) as an animated pet on the user's screen. The application integrates with each agent via hook scripts that intercept lifecycle events (thinking, working, idle, error, etc.) and post state to a local HTTP server, which drives the pet's animations, permission bubbles, and system tray presence. It provides a sophisticated permission management system with local bubble UI, remote approval via Telegram/Feishu/Slack, and session automation policies, all while supporting custom themes, Discord Rich Presence, and a mobile companion PWA. The architecture is an Electron main process orchestrating multiple renderer windows (pet, bubble, settings, dashboard, quota ring, session HUD) with IPC bridges. The state machine resolves session states from multiple agents into a single dominant visual state using priority-based resolution. The codebase is modular with factory functions, dependency injection, and pure math modules that are testable in isolation. It includes a comprehensive theme system with SVG/GIF/APNG support, a doctor/health check system, remote SSH deployment of hooks, and a recap feature for local activity tracking. The project has over 1000 test files and extensive CI/CD pipelines for Windows, macOS, and Linux packaging.

CowAgent is a production-grade multi-agent AI assistant platform that routes messages from 12+ IM channels (WeChat, Feishu, Telegram, DingTalk, Slack, Discord, QQ, WeCom, web console, desktop Electron app) through a modular agent core. The core implements planning, tool use (bash, file editing, browser, web search, MCP, sub-agent delegation, scheduler, memory, vision), three-tier memory with vector embeddings and markdown-aware chunking, knowledge base management, skill system with SKILL.md manifests and a skill hub, self-evolution (idle-conversation review loop), and multi-agent team orchestration with peer transport. The architecture is a modular monolith: channel adapters normalize messages into a unified ChatMessage, the Bridge dispatches to per-agent/session model resolution, the Agent protocol (Task/AgentResult/AgentAction) drives the execution loop with streaming, cancellation, and steering, and all state persists to SQLite with incremental migration. Key entry points are app.py (startup orchestration), cli/cli.py (daemon lifecycle), channel/web/web_channel.py (HTTP API and SSE streaming), and the desktop Electron client (React/TypeScript with Zustand stores). External dependencies include LLM APIs (OpenAI, Claude, Gemini, DeepSeek, etc.), IM platform webhooks/SDKs, optional voice TTS/ASR providers, and MCP servers. The codebase demonstrates strong engineering practices with extensive regression tests (200+ test files), atomic file writes, thread-safe context propagation via ContextVar, and security guards for credential paths and SSRF.

Onlook is a browser-based visual editor for building and modifying Next.js + Tailwind CSS websites. It provides a Figma-like canvas where users can directly manipulate React components, with changes written back to source code via AST-based transformation. The application integrates an AI chat assistant that can generate code, edit files, and run terminal commands through a set of well-defined tools (e.g., search-replace, file edit, bash). The monorepo architecture separates concerns into packages for AI agents, code parsing, font management, UI components, database access (Drizzle + Supabase), git operations, and sandbox management (CodeSandbox). It also includes a complete billing system (Stripe), GitHub integration for project import, custom domain management, and a publish/deployment pipeline. The codebase demonstrates strong engineering practices with type-safe tRPC APIs, MobX state management in the editor, extensive use of Radix UI primitives, and a consistent monorepo toolchain (Bun workspaces, ESLint, Prettier). While the editor engine is somewhat monolithic, individual packages like the AST parser, font helpers, and utility library are well-isolated and testable.

This is a Rust CLI tool called `facts` that implements a fact-driven development workflow. It manages a `.facts` file containing atomic, verifiable claims about a project, each with lifecycle tags (`@draft` → `@spec` → `@implemented`) and optional shell commands for automated verification. The tool provides a rich set of subcommands for listing, adding, editing, removing, linting, and checking facts, along with a terminal UI (TUI) built with Ratatui and Crossterm. It integrates with AI coding agents (Claude, Codex) to verify manual facts via an XML-based verdict protocol, and ships with bundled agent skills for discovery, refinement, and implementation. The project is self-hosting—it uses its own `.facts` file to describe itself—and is distributed via npm, PyPI, and direct install. The architecture is a monolith with clearly separated modules for parsing, writing, ID generation, tag filtering, file locking, and agent communication. The codebase demonstrates strong engineering practices: deterministic round-trip serialization, atomic file writes, advisory locking with stale detection, and a boolean expression evaluator for tag filters. It is actively maintained with a comprehensive test suite and CI/CD pipeline.

This repository is a full-stack, multi-tenant AI API gateway platform (named 'sub2api') that proxies requests to a wide range of AI model providers including OpenAI, Anthropic, Gemini, Grok, DeepSeek, and many others. It provides authentication (JWT, OAuth, API keys), rate limiting, token-level billing, subscription management, user and admin management, payment processing (Alipay, WeChat Pay, Stripe, Airwallex, EasyPay), content moderation, channel monitoring, and operational dashboards. The backend is written in Go using the Gin framework and Ent ORM, with PostgreSQL and Redis for data storage and caching. The frontend is built with Vue 3, TypeScript, and Pinia stores, offering both admin and user interfaces. The system is designed for production deployment with Docker, includes extensive unit and integration tests, and supports a plugin architecture for extensible OAuth transport. Despite its large codebase and many features, the architecture follows a clear service-repository pattern with well-isolated packages, making it a solid example of a complex API gateway implementation.

Serena is a production-grade MCP (Model Context Protocol) server that provides AI coding agents with deep code intelligence across 40+ programming languages. It acts as an 'IDE for your agent', offering symbol-level retrieval, editing, refactoring, and debugging capabilities by orchestrating Language Server Protocol (LSP) backends. The system is designed to integrate with AI clients like Claude Code, Codex, Copilot, and Grok, exposing a rich set of tools for file manipulation, symbol navigation, memory persistence, and project configuration. Architecturally, Serena is a Python application with a CLI entry point that starts an MCP server, a Flask-based web dashboard for monitoring and configuration, and a hooks system for client-side pre-tool-use events. Its core is the `solidlsp` package, a custom synchronous LSP abstraction layer that manages the lifecycle of 40+ language servers (Python, TypeScript, Rust, Go, Java, etc.), handling initialization, capability negotiation, and request/response framing. The `interprompt` library provides a sandboxed Jinja templating engine for prompt generation, and the memory manager persists project-specific context across sessions. Key features include: multi-language symbol search, references, definitions, hover, rename, and diagnostics; a code editor abstraction supporting both LSP and JetBrains backends; a configurable tool registry with automatic discovery; and a comprehensive test suite with per-language integration tests. The project emphasizes reproducibility through pinned dependency versions and SHA256 verification for downloaded language server binaries, though this creates a maintenance burden as versions must be manually updated.

Commonly is an open-source multi-agent collaboration platform where humans and AI agents work together in shared workspaces called 'pods'. The system provides real-time messaging, task management, agent runtime (native, hosted, or bring-your-own), marketplace for agent skills, and integrations with external chat platforms like Discord, Slack, Telegram, and GroupMe. The architecture is a full-stack monolith with separate external agent bridge services and a Cloudflare Workers-based agent runtime. The backend (Node.js/Express) uses a dual-database design (MongoDB for primary data, PostgreSQL for messages/tasks) with automatic sync. The frontend is a React SPA with a v2 design system. The CLI allows local agents to participate via device-code auth and polling. The MCP server provides standard tools for agents to interact with the platform. The codebase is well-structured with extensive test coverage (unit, integration, E2E), Architecture Decision Records (ADRs), and reusable packages for types, integration SDK, and MCP tools. Notable craftsmanship includes pluggable storage drivers, deterministic agent wake targeting, and a test utility that replicates the production PostgreSQL schema to catch DDL drift.

OpenTeams is a multi-agent AI coding assistant platform that enables users to collaborate with multiple AI coding agents (Claude Code, Codex, Gemini CLI, etc.) in a single shared session. The system provides a local-first desktop application built with Tauri (Rust backend + React/TypeScript frontend), a standalone CLI tool (`openteams-cli`) written in TypeScript with Bun, and a web frontend. The backend is an Axum HTTP server in Rust with SQLite persistence managed via SQLx, supporting chat sessions, workflow orchestration, source control integration, approval systems, and a skill registry. The architecture is modular: a `crates` workspace separates database models, services, executors, deployment, and utilities, while the CLI uses Effect-TS for dependency injection and includes a TUI built with SolidJS. In production, the system orchestrates AI agents through the Agent Client Protocol (ACP) and provider-specific SDKs, managing execution processes, worktrees, and chat message queues. Key data flows include: user input → chat runner → agent execution (with tool calls, file edits, git operations) → event streaming back to frontend/CLI. The platform integrates with GitHub for PR review, issue tracking, and work item management, and supports custom MCP servers and skill plugins. External dependencies include SQLite, Tauri, Bun, various AI provider APIs (Anthropic, OpenAI, Gemini, Copilot), and GitHub CLI for certain operations.

FigMirror is a reference-conditioned scientific figure style transfer system that iteratively generates matplotlib scripts matching the visual style of a reference figure. It operates as a multi-agent loop (Drawer/Reviewer) orchestrated by a runner backend (Codex, Claude, or Mock), with a local web UI for upload, iteration browsing, and refinement. The system is packaged as skills for both Claude Code and Codex, plus a standalone web server. While primarily an application, it has a strong research component: the prompts, aesthetic library, and evaluation benchmarks (PlotTwin-Bench) are the result of extensive empirical iteration. The codebase demonstrates high craftsmanship in its runner architecture, atomic file operations, SSE streaming, and deterministic review gates. However, it suffers from dual skill bundles (Claude/Codex) that must stay synchronized, retired artifacts, and some incomplete features (ClaudeRunner, SSE integration).