Harp is a zero-configuration static web server and static site generator. It serves Jade, Markdown, EJS, Less, Stylus, Sass, and CoffeeScript files as HTML, CSS, and JavaScript without any build step. The architecture is a Connect-based middleware stack with a CLI wrapper. Key entry points are the `harp` CLI (bin/harp) and the library API (lib/index.js) which exposes `server()`, `compile()`, `mount()`, and `pipeline()`. The system reads project configuration from `harp.json` or `_harp.json`, supports layouts and partials via `_layout.jade` and `_data.json` files, and provides fallback 200/404 handling. It can compile projects to static assets for deployment. The codebase is well-structured with comprehensive tests and a smoke test for release validation. Dependencies are pinned, and the code uses modern JavaScript. It is a mature, stable project suitable for rapid prototyping and static site hosting.
GritQL is a declarative query language and CLI tool for searching, linting, and transforming source code across many programming languages (JS/TS, Python, Java, Go, Rust, Ruby, PHP, SQL, etc.). The repository implements a Rust workspace comprising a pattern-matching engine (grit-pattern-matcher) that compiles GritQL patterns into executable AST-based matchers, a CLI client (grit) with commands like `apply`, `check`, `list`, `patterns`, and `lsp`, an LSP server for IDE integration, WebAssembly bindings for browser use (playground), and Node.js NAPI bindings for programmatic access. Patterns are authored in `.grit` files or embedded in Markdown with sample-based testing. The system uses tree-sitter parsers (vendored grammars) to parse source files, supports pattern caching for performance, and includes authentication, analytics, and remote module resolution. The architecture is modular: core pattern matching is isolated in `crates/grit-pattern-matcher`, pattern compilation in `crates/core`, language support in `crates/language`, and UX in `crates/cli`. The documentation site (Next.js with Markdoc) provides an interactive playground. External dependencies include tree-sitter parsers, NAPI-RS, WebAssembly tooling, and optional LLM APIs for AI-assisted patterns.
This repository provides a lightweight CLI tool (`vision.js`) that enables text-only AI models (like Claude Code without native vision) to 'see' images by converting them to text via an external vision API. The core script reads images from local files, URLs, or the system clipboard (via platform-specific helpers for macOS and Windows), encodes them as base64, and sends them to any OpenAI-compatible vision API (defaulting to Alibaba Cloud's DashScope). It features automatic clipboard fallback, configurable API credentials via environment variables, and clear error handling. The repo also includes documentation files (`AGENTS.md`, `CLAUDE.md`, `SKILL.md`) that instruct AI agents on when and how to invoke the script, plus integration instructions for the cyberboss chatbot framework. It is a practical, well-structured utility that solves a common limitation of text-only AI models.
OpenAPI Generator CLI is a Node.js/TypeScript command-line wrapper around the Java-based OpenAPITools/openapi-generator JAR. Despite using NestJS, it is not a server: NestJS provides a DI application context that wires a Commander CLI. On every invocation (main.ts → AppModule.onApplicationBootstrap), it reads openapitools.json, resolves a generator version (querying Sonatype's Solr search for the latest stable when unset), writes it back to config, downloads and caches the JAR — atomically, via temp file + rename — then asks the Java CLI itself (via `help` and `completion` output) what commands it exposes, registers them dynamically, and spawns `java -jar ... <command>` with inherited stdio. It supports HTTP(S) proxies, JAVA_OPTS, custom generator JARs (classpath merge), and a Docker execution mode. Beyond pass-through, the CLI adds value the raw Java tool lacks: a `version-manager` subcommand (list/set/remove tagged versions backed by an interactive table picker) and a config-driven batch generator in openapitools.json where named generators map glob patterns to invocations with placeholder tokens (#{name}, #{cwd}, #{relPath}, #{ext}, ...), executed concurrently (max 10 processes). The repo is an Nx single-app monorepo bundled into a shebang'd main.js and released via semantic-release; GitHub Actions CI runs lint, unit tests, and real Java-based E2E on Ubuntu and macOS. Unit test coverage is thorough across config, version management, command pass-through, and command construction. Genuinely clever parts: dynamic discovery of an external CLI's command surface, atomic binary caching, and a table-to-interactive-select UI. The warts: a ~100-entry hardcoded fallback version list embedded in source, a legacy root lib/index.js publishing script superseded by the webpack package plugin, leftover NestJS scaffolding (environment stubs, 'not a production server' comment), deprecated RxJS toPromise() usage, an ESLint root config that effectively ignores all files, and a Nix flake pinned to Node 18 while the package requires Node 22. It does what it claims and is actively maintained, but the residue keeps it from being exemplary.
Scaphandre is a Rust-based CLI tool for monitoring electric power and energy consumption of hosts and processes. It reads RAPL (Running Average Power Limit) energy counters from Linux sysfs or Windows MSR, computes per-process power attribution using CPU usage ratios, and exports metrics via multiple backends: Prometheus (HTTP scrape or push gateway), JSON, stdout, Riemann, Warp10, and QEMU for virtual machines. The architecture is modular, built on `Sensor` and `Exporter` traits, allowing easy extension. It is packaged for Docker, Kubernetes (Helm chart), Linux (RPM/DEB), and Windows (installer with custom driver). The project is production-ready, actively maintained, and backed by extensive documentation and CI/CD pipelines. It is intended for infrastructure sustainability monitoring and carbon footprint tracking.
Laravel Sail is a command-line package that provides a Docker-powered local development environment for Laravel applications. It generates a Docker Compose file with a PHP application container and optional services such as MySQL, PostgreSQL, Redis, Meilisearch, Mailpit, and many more. The package includes console commands (`sail:install`, `sail:add`, `sail:publish`) that scaffold the Docker configuration and update the application's `.env` file with appropriate host and credential settings. It also publishes Dockerfiles for multiple PHP versions (8.0 through 8.5) and database initialization scripts. The architecture is a simple Laravel package consisting of a service provider, three console commands, and a trait for reusable Docker Compose interaction logic. The `bin/sail` bash script acts as a CLI wrapper that proxies commands (like `artisan`, `composer`, `node`, `npm`, `mysql`, etc.) into the running Docker container. Sail does not run a persistent service itself; it is purely a scaffolding and management tool executed during development setup. The codebase is well-structured, follows Laravel conventions, and is actively maintained with frequent releases. It demonstrates strong engineering practices for a development tool, though its primary value lies in configuration generation rather than novel algorithmic work.
This repository contains a minimal coding agent designed to work with local Ollama models. The agent operates in a loop, processing user requests by inspecting and modifying the workspace through a set of structured tools (file operations, shell commands, etc.). It implements six core components: live repo context collection, prompt shaping with cache reuse, structured tools with validation and permissions, context reduction and output management, transcript and memory persistence, and bounded delegation to subagents. The agent is implemented in a single Python file (`mini_coding_agent.py`) and is intended to be run via a CLI entry point. It requires an Ollama server running with a compatible model (default: qwen3.5:4b). The code is clean, well-structured, and demonstrates thoughtful agent design patterns, making it a useful reference for building similar agents.
Linkook is a Python CLI tool for OSINT-driven discovery of linked social media accounts and associated emails across multiple platforms. It takes a single username as input, scans a configurable set of websites (defined in a provider.json file), and recursively extracts linked accounts, usernames, and emails from discovered profiles. The tool supports breach checking via HudsonRock's database or Have I Been Pwned, and can export results to a Neo4j-compatible JSON format for graph visualization. The architecture is modular: a Provider class handles URL templates and regex extraction, a SiteScanner performs HTTP requests and keyword-based existence checks, and a ScannerManager manages concurrent scanning via a thread pool with a queue. The code is well-structured, includes unit tests, and demonstrates solid engineering practices with clean separation of concerns, error handling, and logging.
GNews is a Python package that provides an API to search and retrieve news articles from Google News. It features a modular architecture with a core GNews class, backend abstraction (RSS and SearchApi), async support, URL resolution via Playwright, full-text extraction, and export capabilities. The package includes a command-line interface and handles common challenges like rate limiting with exponential backoff, proxy support, and graceful fallbacks. The codebase is actively maintained with regular updates and follows modern Python practices.
enject is a security-focused CLI tool that prevents AI agents and other processes from reading secrets out of `.env` files. It stores secrets in an encrypted local store (AES-256-GCM with Argon2id key derivation) and injects them into subprocess environments at runtime. The `.env` file on disk contains only `en://` symbolic references, never plaintext values. The tool provides commands to initialize a store, add/update/list/delete secrets, import a plaintext `.env` file (encrypting all values and rewriting it as a template), rotate the master password, and run a subprocess with resolved environment variables. The architecture is a single Rust binary with a clean `Store` trait abstraction separating the encryption backend from command logic. The codebase demonstrates strong security practices: secrets never touch disk as plaintext, nonces are freshly generated on every write, key material is zeroized immediately after use, and unresolved references cause hard errors. It includes comprehensive unit tests and a CI pipeline with linting, formatting, and security auditing.
This repository is a Python library and CLI application for parsing, compiling, and calculating Excel formulas and workbooks entirely outside Microsoft Excel. It loads .xlsx, .ods, and JSON model files, builds a directed acyclic computation graph with the schedula library, and evaluates formulas cell-by-cell with support for array formulas, circular references, custom functions, LAMBDA/LET, unit conversions, and sub-model extraction. Primary APIs include ExcelModel, Parser, Ranges, and get_functions(), with additional entry points through a Click CLI (calc, build, test, serve) and a Flask-based web application. Architecturally, the project is a library with CLI and web wrappers. Formula text is tokenized and parsed into an AST, then compiled by AstBuilder into a schedula dispatch pipeline. Workbook loading, reference resolution, and cyclic reference handling are coordinated in the excel package, while hundreds of Excel function implementations are organized in categories such as math, statistics, financial, text, lookup, engineering, and date/time. The function layer relies heavily on numpy, scipy, pandas, statsmodels, and numpy-financial, and uses standardized wrappers to convert Python functions into Excel-compatible array functions with proper error propagation. Strengths include a broad data-driven test suite, an elegant range algebra class, Tarjan-based cycle detection, and a mature parser design. Weaknesses include very large function modules that mix many edge cases, incomplete Excel function categories (Automation, Cube, Database, Web), legacy Python-version conditionals, and heavy external dependencies that may lag behind current Excel behavior. Although the repo contains curated data files and spreadsheet fixtures, its dominant character is a software application rather than a data pipeline or research repository.
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.
wp2hugo is a Go-based CLI tool for migrating WordPress XML exports to Hugo static sites. It processes WordPress content (posts, pages, custom post types) converting them to Hugo Markdown with appropriate front matter, handles media downloads, converts WordPress shortcodes and Gutenberg blocks to Hugo shortcodes, preserves metadata like GUID and taxonomies, and generates Hugo configuration files. The tool also includes a companion utility 'hugomanager' for site management tasks like backlink analysis, image optimization, and URL suggestions. The architecture is modular with clear separation between WordPress parsing, Hugo generation, media handling, and utility functions.
Fpart is a high-performance C CLI tool that partitions filesystem trees into balanced subsets (called partitions) based on file count, size, or a fixed number of partitions. It uses a bin-packing algorithm to optimize space utilization. The tool supports live mode, where partitions are generated during filesystem crawling and hooks can trigger immediate actions (e.g., starting rsync transfers). Fpsync, a companion shell script, leverages fpart to parallelize data migrations using rsync, cpio, pax, or tar, with support for SSH workers, job queues, resume/replay, and email reports. The codebase is mature, well-structured, and portable across FreeBSD, Linux, Solaris, and macOS. It demonstrates strong C craftsmanship with careful memory management, error handling, and portability workarounds (e.g., embedded fts). The fpsync script is a sophisticated example of shell-based job scheduling and distributed synchronization.
feishu-pages is a monorepo application that exports Feishu (Lark) wiki knowledge base to Markdown for static site generators. It consists of three workspaces: feishu-docx (a library for converting Feishu Docx documents to Markdown), feishu-pages (the main CLI tool that orchestrates the export process), and website (a VitePress documentation site). The CLI authenticates with the Feishu Open API, fetches wiki space structure, converts document blocks to Markdown, downloads and rewrites asset URLs, generates YAML frontmatter for static site generators, and outputs a structured directory of Markdown files with SUMMARY.md and docs.json for navigation. The architecture features clear separation of concerns with dedicated modules for API interactions, document processing, asset handling, and summary generation.
This repository provides a collection of Claude Code plugins designed to enhance AI-assisted development workflows. It consists of four specialized utilities: deslop for removing AI-generated code artifacts, dig for conducting deep exploratory interviews to clarify plans, fix-ci for automatically diagnosing and resolving CI failures, and decomposition for breaking down complex tasks into detailed, actionable todos. Each plugin implements sophisticated patterns for improving developer productivity when working with AI assistants. The system follows a modular architecture where each plugin is self-contained with its own command implementation, skill definitions, and metadata. Plugins can be installed via Claude Code's plugin marketplace system and integrate directly into the AI assistant's workflow. The plugins leverage Claude Code's built-in tools (Read, Edit, Write, Bash, etc.) to interact with the development environment, analyze code, and make targeted improvements. Rather than being a monolithic application, it offers composable tools that address specific pain points in AI-assisted development.
Ansible Development Tools (ADT) is an installable Python package and CLI wrapper that bundles the official Ansible content-creation toolchain—ansible-builder, ansible-core, ansible-creator, ansible-dev-environment, ansible-lint, ansible-navigator, ansible-sign, molecule, pytest-ansible, and tox-ansible—behind a single `adt` command. The package's own Python code is deliberately small: `adt --version` enumerates versions of the bundled tools via importlib.metadata, and `adt server` starts an embedded Django WSGI application served by Gunicorn. The repository also contains build definitions for the `community-ansible-dev-tools` execution environment and an OpenShift Dev Spaces image, including podman-in-container support. The production behavior of the original code is a machine-facing REST API, not a user interface. Endpoints under `/v1/creator` and `/v2/creator` invoke ansible-creator's Python API to scaffold playbook, collection, devfile, and execution-environment projects and return them as tar archives. The server additionally exposes `/metadata`, `/v2/creator/capabilities`, `/v2/creator/schema`, and `/v2/creator/scaffold` for backend discovery and dynamic command execution. Every request and response is validated against a bundled OpenAPI 3.1 schema using openapi-core, with validation failures returned as HTTP 400 responses. Outside the Python package, the repo contains substantial container engineering: multi-architecture image builds with buildx, GHCR manifest publishing, rootless podman setup, and an entrypoint that dynamically allocates subuid/subgid ranges for OpenShift's random-UID model. CI is comprehensive, with tox-based linting, unit/integration/container tests, CodeQL, nightly devel image builds, and automated dependency updates. Minor blemishes exist—duplication between the v1/v2 creator handlers, a deprecated `MIDDLEWARE_CLASSES` Django setting, and docs that still mention Python 3.10 while the package requires 3.11+—but the codebase is current, well-tested, and actively maintained.
MSIX Hero is a comprehensive MSIX/AppX package management toolkit providing both WPF GUI and CLI interfaces for creating, editing, signing, packaging, and deploying Windows applications. The application follows a modular architecture using Prism for MVVM and dependency injection, with separate modules for package management, volume management, event viewing, system status, and various dialogs. Core functionality includes MSIX package reading/editing via Appx.Reader and Appx.Editor, signing via Appx.Signing, dependency analysis, AppAttach volume management for Windows Virtual Desktop, Winget manifest handling, and system diagnostics. The codebase demonstrates strong separation of concerns, extensive use of interfaces for testability, and reusable patterns in IPC, progress handling, and MVVM property implementations.
This repository contains a CLI tool for interacting with SoloKeys Solo 2 security keys. The application enables users to list connected devices, interact with various onboard applications (Admin, FIDO2, NDEF, OATH, PIV, Provision, QA), update firmware, and switch between regular and bootloader modes. The architecture features a clean separation of concerns with distinct layers for CLI parsing, library functionality, transport abstraction (CTAP/PCSC), device management, and application-specific implementations. The code demonstrates solid Rust engineering practices with proper error handling, user experience considerations, and adherence to security best practices.
Favicorn is a command-line OSINT tool that searches for websites by their favicon hashes. It accepts input via favicon URL, file, or domain, computes multiple cryptographic and perceptual hashes (MMH3, MD5, SHA256, etc.), and generates search URLs for 11 security/search platforms (Shodan, ZoomEye, Censys, etc.). Optionally, it fetches and displays preview results from Shodan, ZoomEye, and Netlas using API keys. The architecture features a modular design: the Favicon class handles hash computation and platform-specific URL generation, while specialized Fetcher classes (Shodan, ZoomEye, Netlas) encapsulate API interactions, caching, and response parsing. The CLI orchestrates workflow, parallel execution, and output formatting. Key dependencies include requests, mmh3, dnspython, and platform-specific SDKs.