thehardwarestore.ai

Field Theory CLI is a local-first TypeScript application for managing X/Twitter bookmarks and building personal knowledge bases. It provides a comprehensive CLI interface for syncing bookmarks from Twitter/X (via OAuth API or browser session extraction), classifying content, exporting to markdown with wikilinks, generating interconnected wikis, and enabling agent workflows through skill installation for AI coding agents like Claude Code and Codex. The application features a 'Possible' idea generation pipeline that applies bookmark collections to repositories for innovation planning, with local data storage in ~/.fieldtheory/ using SQLite FTS5 for full-text search. Built with modular architecture separating concerns into bookmarks, ideas, agent context, and document operations modules.

This repository is a curated, open-source catalog of AI agent design patterns. It functions primarily as a documentation website (built with Astro, deployed to Vercel) that indexes ~200+ patterns across categories like orchestration, memory, security, and tool use. Patterns follow a strict template with YAML frontmatter, evidence grading, and cross-references. The codebase includes a static site generator, automated research pipelines (arXiv scanning, similarity checking), and CI/CD for pattern validation. While the core deliverable is a web application, the repository also contains significant research infrastructure (scripts for paper discovery, reference verification, and pattern quality fixing), making it a hybrid between an application and a research data project. The source of truth is markdown files in `patterns/`; the build pipeline generates JSON, graph data, and site assets. The project is actively maintained with community contribution guidelines and automated PR review workflows.

This repository is a comprehensive knowledge base and reference implementation for Claude Code best practices, curated by Shayan Rais. It is not a standalone application but rather a living documentation and configuration library that demonstrates how to effectively use Claude Code CLI through agents, skills, commands, hooks, and workflows. The core architecture follows a Command → Agent → Skill orchestration pattern, with working examples such as a weather reporter system and a structured RPI (Research-Plan-Implement) development workflow. The repository includes reusable configuration patterns (YAML frontmatter schemas for agents and skills), a cross-platform Python hook script for lifecycle events, detailed changelogs that track drift against official Claude Code documentation, and extensive reference guides covering settings, environment variables, MCP servers, and startup flags. While primarily a documentation and reference project, it contains runnable Claude Code configurations that can be directly adopted or adapted by other projects.

chubbyskills is a personal knowledge management CLI toolkit that ingests content from over a dozen platforms (YouTube, Bilibili, X, Xiaohongshu, WeChat, Douyin, Podcasts, etc.), transcribes audio/video locally or via cloud providers, and outputs structured Markdown notes with YAML frontmatter (schema v1). The system is architected as a collection of modular "skills" (one per platform) orchestrated by a unified CLI (`tools/chubby.py`), with shared utilities in `chubby_common/`. It includes an incremental knowledge base indexer using SQLite FTS5 and optional semantic embeddings, an MCP server exposing six tools for AI agent integration, and a deterministic evidence brief generator with integrity validation. Operation is local-first: transcription uses SenseVoice and faster-whisper, video downloading uses yt-dlp, and all processing is designed to work offline. Cloud transcription (Atlas/MuAPI) and LLM enrichment (DeepSeek) are optional extensions. The repository also provides a skill installer, platform smoke testing, output validation, and retry mechanisms with credential redaction. Despite the breadth, the codebase maintains clean separation of concerns, with the shared library standing out as a reusable zero-dependency core.

This repository is the personal blog and knowledge base of digoal, a prominent PostgreSQL DBA and database expert. It contains over a decade of blog posts (2010–2026) covering PostgreSQL internals, performance tuning, database architecture, and related topics, along with a large collection of images, PDFs, and other attachments. The blog is organized by year and month, with each post as a markdown file. The repository also includes a 'skills' directory that defines reusable AI agent skill definitions (SKILL.md files) for various tasks such as fact-checking, stock prediction, bug hunting, and course writing. These skills are structured with agent prompts, reference materials, and supporting scripts, making them extractable and reusable in AI-assisted workflows. The repo is actively maintained and serves as both a reference for database professionals and a library of AI agent capabilities.

Outline is a collaborative knowledge base platform built with React and Node.js. It provides real-time document editing via ProseMirror/Yjs, team workspaces with granular permissions, and extensibility through a plugin system. The application features rich text editing, document organization into collections, search functionality, notifications, and integrations with services like Slack, GitHub, and Notion. Architecture follows a monorepo structure with frontend (React/MobX/Styled Components), backend (Node.js/Koa/Sequelize), and shared utilities. Key entry points include the React root (app/index.tsx), Koa server (server/index.ts), and API routes (server/routes/api/). The system relies on PostgreSQL for primary data storage, Redis for caching and job queues, and S3/local storage for file attachments.

This repository provides a server application for interacting with COMSOL Multiphysics models via a programmable interface. It features a modular architecture separating concerns into COMSOL model manipulation tools (geometry, mesh, physics, etc.), a knowledge base built from COMSOL documentation PDFs for retrieval-augmented generation, and utility functions for versioning and async handling. The system enables users to load, modify, and simulate COMSOL models through a server interface (likely MCP - Model Context Protocol), while leveraging a vector database of processed PDF documentation to provide contextual assistance. Key entry points include src/server.py and various domain-specific scripts in comsol_models/ directories for building and simulating specific models (e.g., solenoids, micromixers).

weDocs is a WordPress plugin that adds comprehensive documentation and knowledge base management to any WordPress site. It registers a hierarchical 'docs' custom post type with a parent-section-article structure, allowing users to create, organize, and display documentation with modern editor blocks (search, grid, sidebar, table of contents, breadcrumbs, reading progress, etc.) and Elementor widgets. The plugin provides a full-featured React-based admin dashboard for managing docs, FAQs, and settings, including drag-and-drop reordering, inline editing, migration from BetterDocs, AI-powered content generation (via OpenAI, Anthropic, Google Gemini), and analytics (view counting, helpfulness votes). It follows a freemium model with pro features gated behind license checks and preview overlays. The codebase demonstrates strong engineering practices: extensive E2E tests with Playwright, modular PHP classes, reusable block controls and shared UI components, and efficient REST API endpoints with aggregate SQL queries. However, it has some code duplication (e.g., duplicate commonControls in two directories), reliance on experimental WordPress APIs, and large inline CSS/JS in PHP render outputs, which prevent it from being exceptional. Overall, it is a well-maintained, production-ready plugin with reusable patterns suitable for other WordPress block plugins.

This repository provides a comprehensive AI-assisted UI/UX design system toolkit, primarily packaged as a skill for AI coding assistants (Claude Code, Cursor, Windsurf, Copilot, etc.) and distributed via the 'ui-ux-pro-max-cli' npm package. Its core functionality includes a curated knowledge base of 79 UI styles, 192 product color palettes, 74 font pairings, 119 UX guidelines, 22 tech stacks, and 192 reasoning rules – all stored as structured CSV files. A BM25 search engine (implemented in Python) enables domain‑aware retrieval, while a design system generator aggregates search results and applies reasoning rules to output complete design system recommendations (colors, typography, style, layout patterns, motion, anti‑patterns). The gallery Next.js app provides a browsable, filterable interface for the style catalog. Architecturally, the project is a hybrid of data curation and application delivery. The canonical source of truth lives in `src/ui-ux-pro-max/`, which is synchronised to `cli/assets/` and `.claude/skills/` via a CI‑enforced sync script. It includes sub‑skills for brand management, slide/presentation generation, banner design, icon/logo generation, and UI styling (with shadcn/ui and Tailwind integration). The CLI tool installs these skills into the appropriate AI assistant configuration directories, with platform‑specific templates for 20+ assistants. Automated workflows refresh Google Fonts and Phosphor icon catalogs weekly, and a suite of Python tests validates data contracts, stack freshness, and search relevance. Despite its active maintenance and rich functionality, the codebase suffers from significant file duplication across three directory trees, hardcoded version pins for frameworks, and test brittleness tied to exact data row counts. The design system generator and search engine are well‑crafted and reusable, but the overall project is tightly coupled to its curated CSV schema and the ecosystem of AI coding assistants. It represents a mature, production‑grade toolkit for developers who want AI‑assisted design generation, but the heavy duplication and external API dependencies (Gemini, Atlas Cloud, MuAPI) introduce moderate technical drift risk.

This repository is a curated, community-maintained knowledge base of laws, theories, principles, and patterns relevant to software developers and technology leaders. The primary artifact is a very large, well-structured README.md covering topics such as Amdahl's Law, Conway's Law, the CAP Theorem, SOLID, DRY, and many management and organizational heuristics. Each entry typically includes a definition, a quote, links to authoritative sources, and real-world examples. The repository does not contain an application runtime, API, or service; its 'application' character comes from the supporting static website generator and release automation that turn the markdown content into a browsable site at hackerlaws.dev.

Magic is a large, polyglot enterprise AI-agent and collaboration platform. The production core is a PHP Hyperf backend (`backend/magic-service`) with strict DDD layering, a Python agent runtime (`backend/super-magic`) for tools/skills/browser automation, a Go engine for knowledge processing/embedding, and a React/TypeScript frontend (`frontend/magic-web`) that spans desktop, mobile, admin, and a visual flow editor. The platform delivers chat/messaging, AI agents, workflow automation (MagicFlow), knowledge bases with vector search, an LLM/model gateway, file storage, low-code data tables (MagicBase), MCP integration, and multi-channel bot deployment (DingTalk, Feishu, WeCom). It is fundamentally an application rather than a research repository; the knowledge-base and data-processing subsystems serve product features, not analysis. Architecturally, the strongest parts are the PHP library packages — async-event, cloudfile, flow-expr-engine, code-executor, and easy-dingtalk — which are cleanly separated and demonstrate genuine, extractable craftsmanship. The frontend likewise includes reusable packages for flow editing, HTML-to-PPTX conversion, and UI components. However, the repository is physically enormous and shows maintenance risk: substantial code duplication exists between `backend/magic-service` and `backend/super-magic-module`, several enterprise features are intentionally stubbed out with open-source no-ops, migration rollback methods are frequently empty, and the mix of PHP, Python, Go, and TypeScript adds integration complexity. The codebase is actively developed, but quality is uneven across the many modules.

KnowFlow (forked from RAGFlow) is a full-stack enterprise Retrieval-Augmented Generation (RAG) platform. It ingests documents (PDF, DOCX, Excel, images, etc.) via multiple parsing engines (DeepDOC, MinerU, PaddleOCR, DOTS), chunks them using configurable strategies (naive, smart, title, regex, parent-child, etc.), embeds them via LLM providers, and stores vectors in Elasticsearch/OpenSearch/Infinity. The platform provides a visual agent builder (React Flow canvas) where users compose workflows from nodes (retrieval, generate, categorize, iterate, code execution, etc.) and tools (web search, email, SQL, financial data, etc.). It also offers chat interfaces with SSE streaming, knowledge base management with RBAC, team sharing, and a Python SDK. The architecture is a Flask backend with separate task executors and a sandboxed code execution service, deployed via Docker Compose with MinIO, MySQL, Redis, and optional OCR microservices. The frontend is primarily React (with a legacy Vue codebase), using Ant Design and shadcn/ui components.

Colanode is a local-first collaboration workspace platform designed for self-hosting. It provides real-time editing of rich-text documents, customizable databases (table, board, calendar views), threaded chats, file management, and user roles. The architecture is a monorepo with separate packages for core types, client-side local persistence and sync, CRDT conflict resolution, and a shared UI library. The server runs on Fastify with PostgreSQL and Redis, exposing REST APIs and WebSocket connections for real-time synchronization. All data mutations are first applied locally in SQLite (via Kysely) and then synced to the server, enabling offline-first operation. Clients include a web application (React, Vite, service worker), a desktop app (Electron), and an experimental mobile app (Expo). The editor is built on TipTap/ProseMirror with custom extensions for blocks, mentions, files, and database nodes. External dependencies include PostgreSQL (with pgvector extension for optional vector search), Redis (for rate limiting and job queues), object storage (local filesystem, S3, GCS, or Azure), and optional AI/LLM providers for semantic search and assistant features. Many AI features are commented out or in development, indicating an incomplete experimental layer. The codebase is actively maintained with CI/CD pipelines, Docker images, Helm charts, and automated tests for critical server and web components.

This is a comprehensive Chinese-language technical knowledge base and interview preparation guide for Java backend engineers. It covers Java core, JVM, concurrency, databases, distributed systems, system design, and increasingly AI/Agent engineering. The site is built with VuePress 2 and includes custom components for lazy-loading Mermaid diagrams, content unlocking, and image preview. While primarily a documentation site, it contains reusable Vue components and a DocSearch indexing script. The content is well-structured with consistent frontmatter, cross-references, and version-aware updates. However, the massive scope and fast-moving AI topics present maintenance challenges.

NetCoreKevin is an enterprise-level AI middleware platform built on .NET 9 with a Vue 3 frontend. It provides a multi-tenant SaaS backend with AI agent capabilities, RAG knowledge base, permission management, file storage, messaging, and code generation. The architecture follows Domain-Driven Design with modular plug-ins, featuring a generic repository pattern, base service classes, and extensive cross-cutting concerns (caching, logging, transaction management, distributed locks). The AI agent framework supports tool calling, skill management, memory, safety layers, and streaming responses. The frontend uses Ant Design Vue with multi-theme support. While the codebase is well-structured and feature-rich, it exhibits some technical debt such as static service locators, large helper classes, and raw SQL usage in places. Overall, it is a solid, production-ready application with reusable components.

This repository is a collection of Agent Skills for AI coding assistants (Claude Code, Codex, OpenCode) that enables them to interact with Obsidian vaults. It contains six skill definitions: obsidian-markdown (creating Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties), obsidian-bases (creating database-like .base files with views, filters, formulas), json-canvas (creating visual .canvas files with nodes and edges), obsidian-cli (interacting with Obsidian via CLI for note management and plugin development), defuddle (extracting clean markdown from web pages), and knap (rendering Markdown templates from structured data). Each skill is a self-contained markdown file following the Agent Skills specification, providing detailed syntax, examples, and validation steps. The repository is purely documentation with no executable code, serving as a knowledge base that AI agents use to perform Obsidian-related tasks on behalf of users.

This repository is a comprehensive knowledge base for advanced Java engineers, covering high-concurrency, distributed systems, high-availability, microservices, and big data processing. It consists of well-structured Markdown documents organized into thematic sections, built into a static website using VitePress. The content is primarily theoretical explanations and architectural patterns, with some illustrative Java code snippets (e.g., Hystrix command examples, snowflake ID generator). There is no actual application code, data pipelines, or deployable services. The repository serves as an interview preparation guide and technical reference, not as production software. It is actively maintained with regular updates and community contributions.

PandaWiki is a production-ready, self-hosted AI knowledge base and wiki platform. The actual codebase implements document management with versioned releases, RAG-based Q&A and search, AI-assisted document summarization and editing, multi-source content ingestion (URL, RSS, Sitemap, Notion, Feishu, DingTalk, Confluence, EPUB, Wiki.js, Yuque, Siyuan, etc.), a customizable public landing page builder, analytics, comments, contribution review, and multi-channel bot integrations for WeChat, WeCom, DingTalk, Feishu/Lark, and Discord. It is not a data research repository, but it contains substantial document-ingestion and analytics pipelines that feed the RAG system. The architecture is a full-stack monolith-style application split across a Go backend (Echo + GORM + PostgreSQL + Redis + MinIO/S3 + NATS JetStream), a React admin panel (Vite/MUI/Redux), a Next.js public site, and a pnpm workspace of shared UI/icon/theme packages. The Go backend follows a layered design with handlers, use cases, repositories, middleware, and dependency injection via generated Wire code. A standalone MQ consumer process handles async RAG document updates, crawler exports, and cron-driven statistics aggregation. The public app is served separately from the admin panel, with an embeddable widget and an H5 chat interface. In production, documents are imported through crawler tasks or direct upload, converted to HTML/Markdown, chunked, and upserted into a configurable vector/RAG service. User chat requests rewrite the query, retrieve ranked chunks, and stream LLM responses via SSE with citations. Statistics are rolled up hourly into PostgreSQL. Authentication supports local accounts, JWT sessions, GitHub OAuth, LDAP, CAS, and enterprise SSO. Feature availability is gated by commercial license editions, with a private pro submodule adding enterprise functionality.

This repository serves as the source for a GitHub Pages site that publishes technical notes and learning resources under the 'Today I Learned' (TIL) format. It contains organized markdown files covering a wide range of software development topics, with particular emphasis on Apple platforms (iOS, macOS, etc.), but also including general programming, software practices, and other technical subjects. The site is built and deployed using GitHub Actions, with a simple Makefile automating the commit and push process for updating notes. The architecture is a straightforward static site where markdown content is converted to HTML by GitHub Pages. While primarily a content repository, it does contain reusable components such as a specific iOS universal links handling code snippet and automation patterns for repository maintenance.