thehardwarestore.ai

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.

Task Master is a monorepo providing an AI-driven task management system designed for integration with AI coding assistants (Claude Code, Cursor, Windsurf, etc.). It consists of a CLI tool (`task-master`), an MCP server, a VS Code extension, and core library packages. The system manages tasks with statuses, priorities, dependencies, tags, and subtasks, and offers AI-assisted operations like PRD parsing, task expansion, complexity analysis, and TDD workflow automation (autopilot). It supports multiple storage backends (local JSON files, remote Hamster API via Supabase) and 15+ AI providers. The architecture follows a clean layered pattern with domain modules in `@tm/core` consumed by CLI and MCP interfaces, though a legacy `scripts/` directory still contains overlapping logic being gradually migrated. The codebase demonstrates strong engineering practices including factory patterns, abstract base classes, dependency injection, atomic file operations, and extensive test coverage. Some technical drift is present due to the ongoing migration from JavaScript to TypeScript and duplicated MCP server implementations.

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 monorepo (Nx) implements a complete ecosystem for managing and distributing 'skills'—curated, structured instructions for AI coding agents. The codebase reveals a production CLI (`agent-skills`) built with Ink/React for interactive terminal UI, an MCP server (`agent-skills-mcp`) for agent-in-context skill lookup via FastMCP, a Next.js marketplace website for browsing, and a skills catalog with over 150 skill definitions across architecture, cloud, development, quality, security, and other domains. The core library (`@tech-leads-club/core`) uses a clean hexagonal architecture with port/adapter separation for file system, HTTP, environment, logging, and shell operations, enabling testability and future portability. The CLI supports interactive and non-interactive install/remove/update workflows with atomic lockfile writes, append-only audit logging, and content-hash integrity verification. The MCP server implements a progressive disclosure pattern (search → read → fetch/prepare) to minimize token usage, with registry caching and ETag revalidation. The marketplace is highly SEO-optimized with JSON-LD structured data, breadcrumbs, and static generation. Property-based tests (fast-check) for UI components and cache boundaries demonstrate strong engineering discipline. The skills catalog itself is the core product—each skill is a markdown file with YAML frontmatter, optional scripts/references, and trigger phrases, all validated by a custom validation tool and security-scanned in CI. While the architecture is solid and the codebase is actively maintained with frequent releases, some areas show drift risk: duplicate validation scripts across skills, hardcoded benchmark data in the marketplace, and tight coupling to external CDN availability for registry downloads. The cloud-deploy skill references an enormous set of Cloudflare product docs that will inevitably become outdated. Overall, this is a well-crafted, modern TypeScript monorepo that effectively solves the problem of giving AI agents reusable, safe, and discoverable instructions.

Packmind is a developer productivity platform that centralizes engineering standards and distributes them to AI coding agents. It solves the problem of scattered standards (in Slack, Notion, PR comments) that AI agents can't access and the manual copy-pasting of standards across repositories. The platform provides organization/space-based collaboration, Git provider integrations, LLM/AI service abstraction, marketplace for sharing components, deployment/target management, and change proposal workflows. It features a hexagonal architecture with clear separation of concerns across domains (accounts, organizations, spaces, standards, skills, commands, deployments), using NestJS for the backend, React for the frontend, and a separate CLI tool for local artifact management.

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.

nedb-promises is a lightweight Node.js library that wraps the @seald-io/nedb embedded database (a fork of nedb) with a promise-based API. It provides a Datastore class that extends EventEmitter, offering methods like find, insert, update, remove, and count that return Promises or thenable Cursor objects. The Cursor class supports fluent chaining (sort, skip, limit, project) and can be awaited directly. The library also includes MongoDB-compatible aliases (insertOne, updateMany, deleteOne, etc.) and a static `create()` method that returns a Proxy to access the underlying nedb instance's properties. The codebase is clean, well-tested, and leverages modern JavaScript features (async/await, Proxy, EventEmitter). It is a classic promise wrapper with a thoughtful event system for operation success and error broadcasting.

Agent OS is a framework for AI coding assistants to establish, discover, and inject project standards and shape specifications. It provides a set of markdown commands (commands/agent-os/) that define workflows for common tasks like discovering codebase patterns, maintaining an index of standards, injecting relevant standards into context, planning product vision, and shaping feature specs. These commands are designed to be consumed by tools like Claude Code and Cursor. The repository also includes bash scripts for installing Agent OS into a project, syncing standards back to a base profile, and shared utility functions. The core value is not executable code but a methodology encoded in instructions and shell scripts that enforce a disciplined approach to spec-driven development with AI agents. The codebase is lean, well-structured, and focused on solving the problem of keeping AI agents aligned with team conventions without heavy tooling overhead.

This repository is a comprehensive, tool-agnostic skills and steering pack that teaches AI coding agents to perform AWS Well-Architected Framework reviews. It contains a curated reference corpus of over 2,000 markdown files (6 pillars, 307 best practices, 27 industry lenses) derived from official AWS documentation, plus per-tool adapters for 15 AI coding assistants (Claude Code, Cursor, Codex, GitHub Copilot, etc.). The repo also ships production-grade supporting tooling: a CI gating tool (wa-ci) that diffs structured review JSON against a baseline and blocks PRs on regressed gaps; an evaluation harness with blind multi-reviewer adversarial adjudication; a crawler to regenerate the reference corpus from AWS docs; and one-command installers. The core skill dispatches six parallel subagents (one per pillar) to keep the 2.2 MB corpus out of any single context window. Despite the extensive content, the repository has notable maintenance challenges: the reference snapshot will drift as AWS documentation evolves (users are responsible for regeneration); lens files are duplicated across `powers/` and `skills/` directories creating a sync hazard; and the flagship skill is explicitly deprecated in favor of a successor in Agent Toolkit for AWS. The evaluation harnesses and CI tooling are well-crafted and reusable, but the sheer scale of markdown files and platform-specific adapters makes ongoing synchronization complex.

Agentic Awesome Skills is a curated marketplace infrastructure for AI coding agent skills—instructional playbooks (SKILL.md files) with accompanying scripts and assets. The repository provides a multi-platform distribution system supporting Claude Code, Cursor, Gemini CLI, Codex CLI, Kiro, and others. It includes a React+Vite web application for browsing, searching, and installing skills; a CLI and MCP server for local agent integration; and a comprehensive validation, security scanning, and release pipeline. The codebase implements a transaction engine with deterministic content addressing (canonical JSON + SHA-256), durable state management, and schema-validated skill installation, forming a robust foundation for agent-owned tool selection and workflow planning. While the core infrastructure (AAS v1 library, MCP server, catalog search) demonstrates high craftsmanship and reusability, the repository is hampered by massive file duplication: identical skill scripts and governance modules appear under `skills/`, `plugins/agentic-awesome-skills/`, and `plugins/agentic-awesome-skills-claude/`, creating synchronization risk. Some skills contain hardcoded paths or incomplete boilerplate. The repository is actively maintained with CI/CD, automated audits, and security scrutiny, though the sheer volume of 2,474+ skills imposes ongoing maintenance burden. Overall, it is a well-engineered, production-quality skill distribution platform with notable reusable design patterns.

MCPM (Model Context Protocol Manager) is a production-grade CLI tool for managing Model Context Protocol (MCP) servers. It provides a centralized server registry, global configuration, virtual profile system (tags), multi-client integration (Claude Desktop, Cursor, Windsurf, VSCode, Cline, Goose, and 10+ more), direct server execution via stdio/HTTP/SSE, secure public sharing via tunnels, and usage monitoring/analytics. The tool is designed for both interactive use and AI-agent automation (non-interactive mode with environment variables). The repository also contains a curated registry of 400+ MCP server definitions (JSON manifests) with metadata and installation instructions. While primarily a Python CLI application, the registry component adds a hybrid data/configuration dimension. The architecture follows a monolith command pattern with modular command implementations, client adapters using base class inheritance, and optional FastMCP proxy for server aggregation.

This repository is a Cursor IDE trial reset tool that modifies system configurations to generate new unique identifiers for Cursor's telemetry fields. It consists of platform-specific scripts (shell for Linux/macOS, PowerShell for Windows) that stop Cursor processes, modify configuration files and registry entries, inject JavaScript hooks into Cursor's main.js files to intercept device identifier generation at runtime, and disable auto-update features. The tool works by creating persistent fake identifiers for telemetry.machineId, telemetry.macMachineId, telemetry.devDeviceId, and telemetry.sqmId, effectively resetting Cursor's trial period detection mechanisms.

GitMCP is a remote Model Context Protocol (MCP) server running on Cloudflare Workers that turns any public GitHub repository (or GitHub Pages site) into live, searchable documentation for AI tools. AI clients like Claude Desktop, Cursor, and MCP Inspector connect to gitmcp.io/{owner}/{repo} over SSE with OAuth and receive repo-specific MCP tools: fetch_<repo>_documentation, search_<repo>_documentation, search_<repo>_code, and fetch_url_content. The ingestion pipeline fetches llms.txt first (falling back to README.md, then landing-page HTML converted via html-to-md), chunks it with markdown-aware chunkers (heading-context-preserving, code-block and list aware), and indexes it into Cloudflare Vectorize using a dependency-free deterministic embedder built from hashing plus term-frequency/keyword extraction, with a hybrid ranking that blends normalized vector similarity (60%) with keyword/proximity/heading heuristics (40%). Robots.txt is parsed, cached, and respected before external fetches - an uncommon discipline for doc scrapers. The codebase also ships a full web chat application (React Router v7, Tailwind, shadcn/ui, AI SDK) with model selection across OpenAI/Anthropic/Groq/XAI, MCP server management, and a streaming chat API endpoint. Architecturally, the MCP server itself is implemented as a Cloudflare Durable Object (MyMCP), with KV caching (TTL with jitter to prevent cache stampedes), R2 storage for pre-generated docs, a queue for background ingestion, Vectorize for semantic search, Analytics Engine for usage metrics, and GitHub API integration with rate-limit tracking and retry/backoff. A notable design pattern is the RepoHandler strategy interface: per-repo families (three.js, react-router) provide customized tool sets, doc-fetch strategies, and search behavior while the generic handler covers all other repos, including a static mapping of library names to their canonical doc repos. Testing is solid: Vitest unit tests cover tool registration, repo handlers, URL parsing, caching, and three.js utilities (with snapshots), and Playwright e2e tests run against a locally-provisioned R2 environment; CI runs both on push/PR. Weaknesses and drift: the embedding layer is explicitly a prototype-grade stand-in ('In a production environment, you would use a proper embedding service like OpenAI') and will produce weak semantic results; badge.ts contains ~96k tokens of hardcoded escaped SVG logo paths (extreme maintenance fragility); several hardcoded host URLs (git-mcp.idosalomon.workers.dev, CHAT_API_URL) baked into source; a generated-type mismatch where Vectorize metadata filters use $gt at runtime but generated types only declare $eq/$ne; vector re-ingestion only deletes the first 100 stale chunks (repos with more chunks accumulate orphans); and the frontend uses React Router v7's unstable_viteEnvironmentApi. These are prototype-velocity marks rather than architectural rot - the core strategy/caching/testing structure is genuinely well-built.

This is a collection of 12 lessons on effective AI-assisted software development, derived from real-world experience with tools like Cursor, Windsurf, Cline, and Claude. It is not a software application or data research project—it is pure documentation. The lessons cover project structure, planning, problem decomposition, test writing, commit discipline, and prompt engineering. The content is clear, concise, and immediately applicable. No code or data pipelines are present; the value lies in the reusable practices and mental models it teaches.

This repository is a curated collection of Claude skills—markdown instructions and supporting scripts that enable Claude (or any MCP-compatible agent) to perform a wide range of tasks, from document manipulation (DOCX, PPTX, PDF, XLSX) and GIF animation to web testing, MCP server building, and automation of hundreds of third-party SaaS services via Composio's Rube MCP. The repo is primarily a skill library with a standardized template for each skill, but it also contains several well-crafted Python libraries (e.g., easing functions, particle systems, OOXML validation frameworks) that are genuinely reusable. The architecture is modular: each skill lives in its own directory with a SKILL.md and optional scripts. The heavy reliance on external services (Composio, Rube MCP) and the massive duplication of templated skill documentation introduce maintenance risks, but the core utility scripts demonstrate solid engineering craftsmanship.

This is a curated collection repository of Cursor AI editor rules (.mdc files), not a traditional software application. It functions as an awesome-list style repository that aggregates project-specific configuration files for the Cursor AI code editor. The repository contains over 200 rule files covering various programming languages, frameworks, testing methodologies, and development workflows. The architecture is straightforward: a flat collection of .mdc files in the rules/ directory, with a README.md serving as the index and discovery mechanism. The repository includes Node tooling for maintaining quality and consistency: scripts for checking repository hygiene, validating awesome-list format, converting README links between relative and absolute forms, checking PR author age policies, and cleaning up legacy artifacts. The CI/CD pipeline uses GitHub Actions with a main workflow file. The key value proposition is providing reusable Cursor AI configuration files that developers can drop into their .cursor/rules/ directories. Each rule file contains frontmatter metadata (description, globs pattern, alwaysApply flag) followed by instructions that guide Cursor AI's behavior for specific technology stacks or development patterns. The rules range from framework-specific guidance (React, Vue, Next.js, Svelte) to language best practices (TypeScript, Python, Go, Rust) to specialized domains (embedded systems, blockchain, machine learning workflows). The repository demonstrates moderate engineering quality in its maintenance tooling, with centralized configuration, test coverage for scripts, and automated quality checks. However, the rule files themselves vary significantly in quality and depth - some are comprehensive and well-structured while others are minimal or boilerplate.

Gitlantis is a VS Code extension that turns the traditional file explorer into an interactive 3D ocean world. Users control a boat to navigate a seascape where directories appear as lighthouses and files as buoys, making code exploration more engaging. The extension communicates via webview with a React Three Fiber interface, offering features like branch switching, file opening, and settings customization. It also supports a standalone browser mode for demo purposes using sample data. Architecturally, the extension consists of a VS Code extension host that handles workspace and Git operations, and a rich webview application built with React 18, Three.js, React Three Fiber/Drei, and Zustand for state management. The 3D scene includes dynamic ocean tiling, boat physics (using React Three Cannon), collision-based node interaction, a compass, minimap, and ambient audio. The UI layer provides splash screens, loading states, settings modals with multiple tabs, and mobile joystick support. The codebase demonstrates modern frontend practices and creative use of 3D in a developer tool. However, it has several maintainability concerns: many @ts-expect-error comments for Three.js types, hardcoded demo data for browser mode, a complex dual-build setup, and no automated tests. Some components, like the settings modal and the dynamic backdrop, are well-abstracted and potentially reusable in other Three.js projects.

This repository is Visual Studio Code Void, a deprecated fork of VS Code focused on AI-enhanced desktop editing. While the project is no longer accepting contributions per its README, it contains the core VS Code architecture with additional AI-oriented features in the `src/vs/workbench/contrib/void/` directory. The application provides a code editor experience with syntax highlighting, IntelliSense, debugging, and extension support, built on Electron for desktop with web fallback capabilities. It features a modular architecture with core editor (Monaco), workbench/UI framework, platform services, and extension system, along with a Rust-based CLI for code and tunnel management.