Word-Formatter-Pro is a cross-platform desktop application and CLI tool for automatically formatting Word documents (.docx, .doc, .wps, .txt, .md) into a consistent Chinese government/official document style. It is built with Python, uses Tkinter for the GUI, python-docx for document manipulation, and integrates with WPS/Word COM on Windows or LibreOffice on macOS/Linux for legacy format conversion. The application features intelligent detection of headings (four levels), title/subtitle, figure/table captions, attachments, and can perform conservative symbol normalization, table auto-formatting, and blank line compression for text sources. The architecture is well-separated: a core formatting engine independent of GUI, a CLI interface, a configuration module, and a bundled Agent Skill. The code is actively maintained, with regular version releases and built-in unit tests covering critical logic.
wthrr-the-weathercrab is a terminal-based weather companion written in Rust. It fetches current weather, hourly/daily/weekly forecasts, and historical data from the Open-Meteo API. The application supports configurable units, localization (via Google Translate API), and multiple display styles (border styles, graph types, color themes). It uses a modular architecture with clear separation of concerns: API abstraction, CLI argument parsing, configuration management, weather data fetching, and terminal rendering. The codebase demonstrates solid Rust practices including async/await, derive macros, and comprehensive testing. Notable features include a sophisticated Unicode graph renderer for temperature trends and a flexible localization system that can auto-translate strings. The project is actively maintained with recent commits and a responsive issue tracker.
This repository implements the Ghost CLI, a command-line tool for installing, configuring, updating, and managing Ghost CMS instances on Linux servers (Ubuntu). The system is a monolithic Node.js application with a plugin architecture. Its core responsibilities include: (1) resolving and downloading Ghost versions from the npm registry, (2) setting up required infrastructure (MySQL, nginx, systemd), (3) managing instance lifecycle (start/stop/restart), (4) handling content migration and import/export via the Ghost Admin API, (5) running health checks via the doctor command, and (6) handling major version upgrades with rollback support. Architecturally, the CLI is composed of a Command base class with yargs integration, a layered task system using listr2 for sequential/parallel operations, and an extension system that allows built-in plugins (nginx, systemd, MySQL) to inject commands, setup steps, doctor checks, and custom process managers. Configuration is managed via JSON files, and dependencies are installed using either yarn or pnpm. The codebase is well-structured with clear separation of concerns: commands in lib/commands/, tasks in lib/tasks/, utilities in lib/utils/, and extensions in extensions/. The tool depends on external services: npm registry for version resolution, Ghost Admin API for import/export, system tools (nginx, systemd, MySQL) for production setups, and acme.sh for SSL certificate management. It supports local development (direct node process) and production (systemd service). The codebase is actively maintained, with support for Ghost versions 1.x through 6.x, Node.js 22/24, and MySQL 5.6 through 9.4. While there is some legacy code for older Ghost versions, the overall architecture is modern, testable, and modular.
Memo is a Python CLI tool for managing Apple Notes and Apple Reminders directly from the terminal. It uses Click for command-line interface and AppleScript (via osascript) to interact with macOS's Notes and Reminders applications. The application provides commands to list, view, add, edit, delete, move, search, and export notes, as well as manage reminders (list, complete, add, delete, edit). Notes are fetched as HTML from Apple Notes, converted to Markdown for display and editing, and images are handled via a placeholder mechanism to preserve inline images through edit cycles. The architecture is a standard CLI application with helper modules for each operation, caching for notes, and validation for flag combinations. It is well-tested with pytest, uses modern Python 3.13, and has a professional CI/CD pipeline and documentation site.
Luet is a container-native package manager for building, installing, and managing software packages. It uses Docker/buildah as build backends, treats packages as container images, and employs SAT solving (with optional Q-learning) for dependency resolution. The application features a CLI-driven architecture with commands for package operations, repository management, and system maintenance. Key architectural elements include a modular design with pluggable solvers, compiler backends, and repository clients, plus a context-based dependency injection system for logging, configuration, and garbage collection. The system stores package metadata in BoltDB or in-memory databases and supports templating via Sprig for dynamic package definitions.
GistPad MCP is a Model Context Protocol (MCP) server that provides a comprehensive interface for managing GitHub Gists through AI assistants like GitHub Copilot and Claude Desktop. It exposes tools for CRUD operations on gists, file management within gists, comments, daily notes, archiving, starring, and reusable prompts. The server runs over stdio and uses the GitHub REST API via a custom typed fetch client. It features a caching layer with hourly refresh, resource subscriptions, and change notifications. The codebase is written in modern TypeScript (ES2024, Node.js 22+) with strict type safety, comprehensive tests for the file editing tool, and a clean modular architecture separating concerns into tools, server, store, and utilities. It demonstrates strong engineering practices including abstract base classes for stores, automatic tool annotation derivation, and careful error handling.
OpenBB is an open-source financial data platform that provides a unified, multi-interface access layer to over 20 data providers (FMP, FRED, CBOE, Yahoo Finance, Intrinio, etc.) through a modular provider-extension architecture. The core library (`openbb_core`) defines a standardized Fetcher pattern (transform_query -> extract_data -> transform_data), Pydantic-based standard models for equities, derivatives, fixed income, economics, and more, and a command routing system exposed via a Python SDK (OBBject), a REST API (FastAPI), a CLI (argparse translator), a desktop app (Tauri + React), and an MCP (Model Context Protocol) server for AI agents. The platform includes domain-specific extensions (equity, crypto, economy, quantitative, technical analysis, charting) and a cookiecutter template for scaffolding new providers or OBBject extensions. While the codebase is large and actively maintained, there is notable technical drift in the form of hardcoded API URLs, mixed sync/async extraction, deprecated endpoints, and code duplication across many provider implementations. The charting extension's plugin-based technical indicator system, the country/exchange validation utilities, and the LRU cache with TTL are high-craftsmanship, reusable components that demonstrate non-obvious software engineering skill.
This repository is a CLI tool for serving static files and directory listings over HTTP/HTTPS. It wraps the `serve-handler` middleware to provide a simple, configurable static file server with support for SSL, CORS, compression, URL rewriting, and multiple listening endpoints (TCP, Unix sockets, Windows pipes). The architecture is a single Node.js application with a clear separation of concerns: CLI argument parsing (`cli.ts`), configuration loading with JSON schema validation (`config.ts`), server creation with HTTP/HTTPS support (`server.ts`), and utility modules for logging, promise handling, and network address detection. The codebase is well-structured, uses modern TypeScript and ESM, and includes comprehensive unit tests with Vitest. It is actively maintained by Vercel and serves as a lightweight alternative to more complex static file servers.
js-beautify is a production-grade code formatter for JavaScript, CSS, and HTML, available as both a Node.js library/CLI and a Python package. The core architecture is a tokenizer-pipeline: source text is scanned by an InputScanner, tokenized by language-specific tokenizers (JavaScript, CSS, HTML), and then processed by a Beautifier that manages indentation, line wrapping, brace styles, and operator positioning via a stateful flag system. The Output class provides efficient indentation caching and wrap-point management. The tool supports a wide range of configuration options (indent size, brace style, attribute wrapping, template languages) and includes built-in unpackers for obfuscated scripts (P.A.C.K.E.R, JavascriptObfuscator, etc.). A web interface is also provided, built with CodeMirror and RequireJS. The project maintains near-identical JavaScript and Python implementations, sharing test data generated from Mustache templates to ensure parity. The codebase is well-structured with clear separation of concerns (core, language-specific, CLI, web), extensive test coverage (including regression tests for hundreds of GitHub issues), and a mature build/release pipeline. However, the dual-codebase requirement increases maintenance burden, and some parts (e.g., the web UI, Debian packaging) show signs of drift. The large test data files and complex matrix-based test generation add brittleness.
Nue is a monorepo for a standards-first web framework ecosystem, designed as a minimalist alternative to React/Next.js. It provides a complete toolchain for building content-driven websites and single-page applications using semantic HTML, CSS, and JavaScript with minimal abstraction. The core packages include Nuekit (CLI and build system), Nuedom (UI assembly with server-side rendering via a fake DOM), Nuemark (a Markdown flavor), Nueserver (edge-first HTTP server), Nueglow (syntax highlighting), Nuestate (URL-first reactive state management), and Nueyaml (predictable YAML parser). The framework emphasizes separation of concerns, design systems, and the UNIX philosophy of small composable tools. It is built on the Bun runtime and targets developers frustrated with heavy JavaScript frameworks, offering instant startup, universal hot reload, and a 1MB global install size. The repository also includes production templates (blog, SPA, full-stack) and the official Nue website (nuejs.org) with documentation, blog, and interactive examples.
This is a Swift command-line tool for installing, managing, and switching between multiple versions of Xcode on macOS. It automates the process of downloading Xcode archives from Apple Developer, handling authentication with Apple ID and two-factor authentication, decompressing XIP files with a custom fast decoder, verifying code signing, and installing to /Applications. It also manages simulator runtimes. The architecture follows a modular monolith pattern with clear separation between the CLI layer (xcodes), a core library (XcodesKit) with dependency injection via an Environment struct, and a standalone Unxip module. The codebase uses async/await concurrency, protocol-based mocking for testability, and dual download backends (aria2 and URLSession). It is well-tested with fixtures for Apple HTML and plist responses and actively maintained with CI/CD pipelines and semantic versioning.
This repository contains the `jx` CLI, the primary command-line interface for the JayeX (Jenkins X) 3.x platform. It is a Go application that provides a modular command tree for managing Kubernetes-native CI/CD pipelines, including commands for namespace switching, dashboard access, version management, and self-upgrade. The CLI acts as a launcher for external plugin binaries (e.g., jx-gitops, jx-secret) that are discovered and executed dynamically, with built-in shell completion delegation. The architecture is centered around the Cobra command-line framework and integrates with Kubernetes APIs, GitHub releases for plugin distribution, and the local filesystem for configuration and binary caching. While the core is tightly coupled to the JayeX ecosystem, the plugin management and self-update subsystems exhibit patterns that could be extracted for use in other CLI tools.
Mods is a CLI tool that pipes command output to large language models (LLMs) for AI-powered processing. It reads stdin, prepends a user prompt, sends the combined text to an LLM (OpenAI, Anthropic, Cohere, Google, Ollama, etc.), and streams the response to stdout. The architecture is a single Go binary using Bubble Tea for TUI (spinner, viewport) and a plugin-like provider system via the `internal/stream` interface. Key entry points are `main.go` (cobra CLI) and `mods.go` (Bubble Tea model). Data flows: stdin -> prompt assembly -> provider API call -> streaming output -> optional conversation caching (SQLite + gob files). External dependencies include multiple AI SDKs, Bubble Tea, Glamour for Markdown rendering, and SQLite for conversation storage. The repository is now archived as of March 2026, with the team focusing on a successor tool (Crush). Despite being archived, the codebase is well-structured, cleanly separated, and demonstrates strong Go engineering practices with a focus on testability and modularity.
This is a monorepo housing two terminal-based Instagram clients: a modern TypeScript client using React Ink for a rich Terminal User Interface (TUI) and a legacy Python client using curses. The system provides a full-featured Instagram experience entirely within the terminal, including real-time messaging via MQTT, feed and story browsing, profile viewing, multi-account management, authentication (with 2FA/challenge support), and one-turn CLI commands for AI agent integration. It also incorporates LLM-based chat summarization (OpenAI compatible) and basic analytics in the Python client. Architecture is straightforward: a CLI entry point (Pastel for TS, Typer for Python) dispatches commands, with the TUI built from reusable Ink components (ScrollView, MessageList, InputBox, etc.) that manage state via React hooks and contexts. A mock system enables offline UI development. External dependencies include reverse-engineered Instagram APIs (instagram-private-api, instagram_mqtt) and multiple utility libraries. The dual-client structure and reliance on patched, unofficial APIs introduce maintenance risks, but the TypeScript client is well-crafted with clear separation of concerns, thorough component reuse, and thoughtful UX design for keyboard-driven terminal use.
Safety is a commercial CLI tool for software supply chain security, primarily scanning Python (and limited npm) dependencies for known vulnerabilities. It operates as a multi-command CLI built with Click and Typer, offering commands such as `scan`, `check`, `auth`, `firewall`, `init`, and `codebase`. The architecture is modular: a core scanning engine (`safety/scan/`) discovers dependency files (requirements.txt, pyproject.toml, Pipfile.lock, etc.), resolves packages, and matches them against a proprietary vulnerability database fetched from the Safety platform. Results are formatted via a pluggable formatter system (JSON, HTML, screen, text, SPDX) and can be uploaded to the platform for reporting. The tool also includes a firewall mode that intercepts pip/poetry/uv/npm install commands to block malicious packages in real time, using shell aliases (Unix) or registry/autorun (Windows). Authentication is multi-modal: OAuth2 (browser-based), API keys, and machine tokens, with a complex enrollment flow for enterprise MDM. An internal event bus (`safety/events/event_bus/bus.py`) provides async telemetry and audit trail emission, used throughout auth, init, and scan workflows. The codebase demonstrates strong engineering practices: layered configuration resolution (CLI > env > config file > default), a command wrapper pattern for package managers, and a policy file system (YAML) for ignoring vulnerabilities by severity, CVSS score, or expiration. However, there is notable technical drift: the legacy `check` and `license` commands are deprecated but still present, typing is incomplete in several modules, and the Windows firewall interceptor relies on fragile registry manipulation. The test suite is extensive but heavily mocks external services, making integration tests brittle. External dependencies include `httpx`, `authlib`, `tenacity`, `rich`, `pydantic`, `dparse`, `packaging`, `certifi`, `filelock`, and the proprietary `safety-schemas` package. The tool is distributed as a PyPI package and as a GitHub Action, with CI/CD pipelines building platform-specific binaries via PyInstaller and PyApp. Overall, Safety is a mature, feature-rich security tool with a well-architected core, though some areas show signs of rapid feature growth and legacy debt.
This is a comprehensive command-line tool and self-hosted web server for network reconnaissance, written entirely in Bash. It performs ASN lookups, BGP statistics, RPKI validation, IP geolocation, IP reputation checks (via StopForumSpam, IPQualityScore, GreyNoise), Shodan InternetDB scanning for open ports and vulnerabilities, AS path tracing with detailed hop information, and more. The architecture is a monolithic Bash script (~7000 lines) that integrates numerous public APIs (RIPEStat, Team Cymru, pWhois, PeeringDB, CAIDA, ipinfo.io, ip-api, Cloudflare Radar, etc.) and command-line tools (mtr, whois, jq, curl, ncat). It can run in interactive mode, JSON output mode (as an API), or as an HTTP server (using ncat) that generates HTML reports with clickable links and a bookmarklet for browser integration. The code is well-structured for a shell script, with extensive error handling, caching of API responses, and support for API tokens to enhance functionality. While it is not modular in a traditional sense (everything is in one file), it demonstrates high craftsmanship in Bash and is actively maintained.
DeepTide is a cross-platform terminal AI coding agent. The Rust workspace (deeptide-core, deeptide-host, deeptide-cli, deeptide-gui) implements the production agent engine: an interactive REPL session with an agent loop, tool dispatch (bash, edit, web, git, memory, MCP, LSP, vision, cron, planning), cross-provider model routing with local-first/cloud-escalation policies, cost tracking, tokens-per-second telemetry, tool usage observability, durable memory with BM25 retrieval ranking, session import/checkpoint/rewind, sensitive-file read protection, and a theme system for syntax highlighting and diffs. The CLI and GUI share a common host layer, and the npm package downloads prebuilt Rust binaries. Architecturally it is a multi-crate Rust workspace plus supporting native components: native/ds4 is a hard-forked DeepSeek V4 Flash Metal inference engine for local LLM execution, and native/dsgo is a Swift gateway that translates between Anthropic and OpenAI protocols with SSE streaming. Primary entry points are crates/deeptide-cli/src/main.rs (CLI), crates/deeptide-gui/src/main.rs (eframe/egui GUI), and bin.js (Bun launcher that delegates to @paean-ai/zero-cli). External dependencies include DeepSeek/Anthropic/OpenAI-compatible APIs, local Metal GPU inference, and GitHub Releases for binary distribution. The repo also contains 50+ self-contained HTML5 Canvas pixel-art games and Three.js showcases under samples/, which appear to be AI-generated demo content demonstrating agent output quality rather than core product code. These share heavily duplicated boilerplate (seeded RNG, localStorage save/load, bilingual i18n, screen state machines). The core Rust code is well-tested with integration tests covering routing, cost tracking, memory ranking, tool result summarization, and slash commands; live API tests are marked #[ignore]. Hybrid note: while primarily an application, it contains research-oriented elements such as memory capture benchmarks (benchmarks/auto_capture_bench.py), prompt cache layout benchmarks (benchmarks/cache_memory_bench.py), and deterministic puzzle generation algorithms with uniqueness verification.
Pydoc-Markdown is a Python library and CLI tool for generating API documentation in Markdown format from Python source code. Unlike many documentation tools, it does not execute the code but instead parses it using the docspec library, making it safe for use with untrusted code. The system features a plugin architecture with loaders (currently only Python), processors (for converting docstrings from Google, Sphinx, Pydoc-Markdown formats to Markdown), renderers (for outputting to Markdown files, MkDocs, Hugo, Docusaurus, or Jinja2 templates), and source linkers (for generating links to source code on GitHub, GitLab, etc.). It can be configured via YAML, TOML, or used programmatically. The project also integrates with Novella for Markdown preprocessing, allowing inline @pydoc tags in documentation files. The codebase is well-structured with clean interfaces, comprehensive test coverage, and a well-defined plugin system. It demonstrates solid software engineering practices including dependency injection, configuration via dataclasses, and entry-point-based plugin discovery. The project has been actively maintained with regular releases and community contributions, though the maintainer has noted limited time for development. The architecture supports extensibility, making it suitable for integration into documentation pipelines for Python projects.
rnsec is a zero-configuration static analysis security scanner for React Native and Expo applications. It scans JavaScript/TypeScript, XML, plist, and JSON files for over 85 security rules covering storage, network, authentication, cryptography, logging, Android/iOS platform issues, and supply chain risks. The tool uses Babel AST parsing and regex pattern matching to detect hardcoded secrets, insecure configurations, and common vulnerabilities. It generates HTML, JSON, and Markdown reports, supports CI/CD integration with changed-files scanning, and can post results as GitHub PR comments. The architecture is a monolith CLI application built with Commander, with a modular rule engine that registers scanner groups. The codebase is well-structured, TypeScript strict, and includes comprehensive tests for all rules.
heh (HEx Helper) is a cross-platform terminal hex editor written in Rust. It provides a TUI for viewing and editing binary files in both hexadecimal and ASCII representations, with features like search (hex/ASCII), jump-to-byte, undo, clipboard integration, and configurable endianness. The architecture follows a clean separation of concerns: `app.rs` orchestrates state and event handling, `screen.rs` manages rendering via ratatui, `input.rs` dispatches keyboard/mouse events to pluggable `KeyHandler` implementations (editor, popups), and `buffer.rs` implements an asynchronous memory-mapped buffer for responsive editing of large files. The codebase demonstrates strong Rust practices, including use of traits for extensibility, iterator patterns for decoding, and a custom `OverlappingChunks` iterator for handling UTF-8 boundary issues. It is primarily an application but includes a library interface for embedding as a ratatui widget.