Finch is a Swift CLI tool that generates well-formatted changelogs by comparing two Git versions (tags or branches). It parses commit messages using a configurable tag convention (e.g., `[feature]`) and groups commits into sections (Features, Bug Fixes, etc.) based on user-defined YAML configuration. The tool supports custom format strings with placeholders for tags, messages, contributor handles, and commit hyperlinks, as well as cascading configuration merging from multiple file locations. It is built with SwiftCLI for command routing, Yams for YAML parsing, and the Version library for semantic versioning. The architecture is modular with separate targets for core models, app logic, and utilities, and includes comprehensive unit and snapshot tests.
ClawBands is a security middleware for OpenClaw AI agents that provides runtime interception with human-in-the-loop approval. It hooks into OpenClaw's plugin system to intercept tool executions (file operations, shell commands, network requests) and enforces policy-based decisions before allowing potentially dangerous actions. The system operates in two modes: terminal mode with interactive prompts, and channel mode (WhatsApp/Telegram) using a special response tool. Every decision is logged to an immutable JSON Lines audit trail, and statistics are tracked. The architecture features clean separation of concerns with distinct modules for policy interception, decision arbitration, approval queuing, logging, and storage.
Kova is a validation lab for the OpenClaw runtime, designed to run release-shaped scenarios on real machines and collect structured evidence. It is a CLI tool written in Node.js (ESM) that orchestrates testing via the OpenClaw Control Manager (OCM), provisioning disposable environments, installing runtimes, and managing services. The system executes scenarios defined in declarative JSON contracts (surfaces, states, scenarios, profiles), collects performance metrics (RSS, CPU, latency, event-loop delays), and evaluates them against configurable thresholds. Results are produced as JSON reports, Markdown summaries, and a web dashboard built with Astro. The architecture is modular: a command dispatcher (src/main.mjs) routes to subcommands (run, matrix, report, setup, publish, self-check). The runner (src/runner.mjs) executes scenarios in phases, with collectors (src/collectors/) gathering evidence from processes, logs, timelines, and system state. An evaluator (src/evaluator.mjs) checks evidence against thresholds and produces violations. The reporting layer (src/reporting/) renders output in multiple formats. The system includes extensive self-checks (src/selfcheck/) that validate internal contracts and fixture behavior. Key external dependencies include Node.js, the OCM CLI, the OpenClaw runtime under test, and channel adapters (Telegram, Discord) for conformance testing. The codebase is well-structured with clear separation of concerns, reusable patterns (UI toolkit, evidence ledger, baseline management, channel conformance framework), and comprehensive validation of its own contracts.
Yarn v1 (Classic) is a Node.js package manager CLI tool that handles dependency resolution, installation, and locking for JavaScript projects. The codebase implements a monolithic architecture with modular components for package resolution, fetching, linking, and reporting. Entry points include bin/yarn.js which routes through src/cli/index.js to command implementations in src/cli/commands/. Primary data flows involve parsing package.json, resolving dependencies through the resolver hierarchy, generating yarn.lock files, and installing packages into node_modules with hoisting logic. External dependencies include npm/yarn registries, git repositories, and offline mirrors for caching. This repository is in maintenance mode per the README - new features are developed in yarnpkg/berry (Yarn 2.x/3.x). The codebase demonstrates solid engineering with extensive test coverage (Jest/Jasmine), Flow type annotations, and well-defined patterns (Resolver, Fetcher, Reporter). However, it uses legacy tooling (Webpack 2, Babel 6, Flow 0.66) and supports EOL Node versions. The dependency management logic is complex and production-tested across millions of projects, making it genuinely reusable despite its age.
xtool is a cross-platform CLI tool and Swift library that enables building, signing, and deploying iOS applications without requiring Xcode. It serves as a replacement for Xcode's build-and-deploy pipeline, supporting macOS and Linux (via Docker). The core library, XKit, provides modules for interacting with Apple Developer Services (certificates, provisioning profiles, devices), implementing Apple's GrandSlam authentication protocol (including Anisette data), code signing via zsign, and device installation via libimobiledevice. The tool also includes a packaging subsystem (PackLib) that resolves SwiftPM dependencies, builds the app, signs it, and bundles it into an .app or .ipa. It supports both free and paid developer accounts and can automatically manage capabilities and provisioning profiles. The architecture is modular, with clear separation between CLI commands (XToolSupport), core library (XKit), and packaging logic (PackLib). It uses modern Swift concurrency (async/await, actors) and dependency injection via swift-dependencies. The codebase includes generated OpenAPI client for Apple's REST API, cross-platform HTTP client abstraction, and utilities for ZIP compression, temporary files, and key-value storage. Examples and integration tests verify functionality. While primarily a developer tool for side-loading and CI/CD for iOS apps, it also exposes the underlying libraries as SwiftPM dependencies for programmatic use. The codebase demonstrates good engineering practices with protocol-oriented design, clean abstractions, and testability. However, it relies on private Apple APIs and a large number of external dependencies, which introduce maintenance risks. The generated OpenAPI client and platform-specific device interactions add fragility, but the core patterns are well-implemented.
This is a CLI-based web scraper for Sina Weibo (微博) user data and posts. It scrapes user profiles, weibo contents, images, and videos from the mobile version of Weibo (weibo.cn) using a combination of synchronous (requests, lxml) and asynchronous (aiohttp) HTTP requests. The architecture is a pipeline: parsers extract structured data from HTML, downloaders asynchronously fetch media files, and writers persist results to multiple formats (CSV, TXT, JSON, MySQL, MongoDB, SQLite, Kafka, HTTP POST). The spider is driven by a config file (config.json) that controls user id lists, date ranges, filtering, and download options. It supports retry logic, random delays, and global wait periods to avoid rate limiting. External dependencies include requests, lxml, aiohttp, browser_cookie3, and absl-py; optional dependencies add database and message queue support. The codebase is modular with clear separation of concerns, includes unit tests with mocked HTML fixtures, and demonstrates solid engineering practices for a data collection tool.
spank is a macOS CLI tool that detects physical hits/slaps on Apple Silicon MacBooks via the accelerometer and plays audio responses. It requires sudo for IOKit HID access to the accelerometer and is built as a single-file Go application. The tool reads raw accelerometer data, runs vibration detection algorithms (STA/LTA, CUSUM, kurtosis, peak/MAD), and triggers audio playback when impacts exceed a configurable amplitude threshold. It offers multiple modes: pain (random 'ow!' sounds), sexy (escalating responses based on slap frequency), halo (Halo death sounds), lizard (similar to sexy but with lizard sounds), and custom (user-specified MP3 directory). Audio playback uses the beep package with resampling to a fixed sample rate, optional volume scaling based on impact force, and adjustable playback speed. The application uses Cobra for CLI parsing and Fang for command execution, with audio assets embedded via go:embed. Key reusable components include the audio resampling function that handles sample rate conversion and speed adjustment, and the amplitude-to-volume mapping function that applies a logarithmic curve for natural volume scaling.
YouPlot is a command-line tool for creating plots in the terminal using Unicode characters. It reads delimited data from stdin or files, parses it into headers and series, and generates various plot types (barplot, histogram, lineplot, scatter, density, boxplot, count) using the UnicodePlot backend. The tool follows Unix conventions, designed for use in data pipelines with options to pass through input data and output plots to stderr/stdout. It features progressive mode for real-time data visualization and supports configuration via CLI flags, config files, and sensible defaults.
ROPgadget is a Python CLI security tool that statically scans executable binaries for ROP, JOP, and SYS gadgets. It discovers architecture-specific byte patterns (x86/x64, ARM/ARM64, MIPS, PowerPC, SPARC, RISC-V), disassembles candidate regions with Capstone, and outputs address/instruction listings. It supports ELF, PE, Mach-O, raw, and universal/fat binaries, and offers filtering by mnemonic, regex, bad bytes, address ranges, and call-preceded gadgets. For x86/x64 ELF targets it can also generate a Python exploit script that chains gadgets into a ROP payload.
Pentest-Swarm-AI is an open-source autonomous penetration testing tool built on a stigmergic swarm architecture. It coordinates multiple LLM-driven specialist agents (recon, classifier, exploit, report) via a shared blackboard with pheromone decay, enabling emergent attack paths without a central planner. The system integrates 30+ external security tools (nmap, nuclei, sqlmap, etc.), multiple LLM providers (Claude, OpenAI, Ollama, Gemini, LM Studio), and bug bounty platforms (HackerOne, Bugcrowd, Intigriti) for automated scope import and report submission. The architecture is a multi-agent system with a scheduler that dispatches agents based on blackboard predicates and pheromone levels. Key entry points include a CLI (Cobra commands: scan, init, playbook, submit, etc.), an API server (Fiber), a WebSocket hub for live streaming, a Next.js web dashboard, and an MCP server for IDE integration. Data flows: agents write findings to the blackboard with pheromone weights; the scheduler reads the blackboard and triggers agents whose predicates match; agents read findings, process them, and write new findings, creating a stigmergic feedback loop. External dependencies include PostgreSQL with pgvector for durable blackboard storage, LLM API endpoints, and the installed security tool binaries. The codebase demonstrates high craftsmanship with clean abstractions (tool adapter pattern, LLM provider interface, blackboard interface), extensive testing (unit, integration, e2e, benchmarks, LLM eval), and safety features (scope enforcement, provenance signing, rate limiting, false-positive caching). It is actively maintained with recent commits, CI/CD pipelines, and community engagement.
Roswell is a command-line tool for managing Common Lisp implementations, scripting, and building executables. It provides a unified interface to install, switch between, and run multiple Lisp implementations (SBCL, CCL, Clasp, ECL, ABCL, etc.), and supports shebang-style scripts with a `ros` interpreter. The architecture is a hybrid: a C binary handles low-level system operations (download, extraction, process management, configuration), while Lisp scripts implement higher-level logic (installation recipes, version detection, image dumping, Quicklisp integration). Key entry points are `src/main.c` (C) and `lisp/init.lisp` (Lisp, invoked by the C binary). External dependencies include curl/libcurl, git, make, and patch. The codebase is well-structured with cross-platform abstractions (Unix/Windows), a custom cons-cell type for dynamic data, and a consistent command dispatch pattern. It is actively maintained with CI across Linux, macOS, and Windows, but relies on web scraping for version detection and uses autotools for build, which introduces some fragility.
BoltzGen is a deep learning pipeline for computational protein and peptide binder design. It provides a command-line interface (boltzgen) that orchestrates a multi-step workflow: diffusion-based backbone generation, inverse folding (sequence design given structure), folding with Boltz-2, affinity prediction, analysis, and filtering/ranking of designs. The system supports diverse protocols including protein, peptide, nanobody, antibody, and small-molecule targeting, with extensive conditioning options like binding sites, disulfide bonds, cyclization, and per-residue constraints. The codebase is structured as a Python package with modular components for data parsing (YAML design specs, mmCIF/PDB), featurization, tokenization, cropping, and model layers (pairformer, attention, diffusion, inverse folding). It includes training pipelines with Hydra configuration, PyTorch Lightning, and validation splits. While primarily an application, it also contains research-grade example datasets and a Jupyter notebook for filtering, reflecting its origin in a bioRxiv publication. The architecture is well-organized but shows some technical drift (hardcoded paths, print statements, broad exception handling) and dependency on specific CUDA versions.
Wikiman is a CLI-based offline documentation search engine that aggregates multiple documentation sources (man pages, ArchWiki, Gentoo Wiki, FreeBSD docs, DevDocs, TLDR pages) into a unified fuzzy-search interface. The architecture is a monolithic shell script with a modular source handler pattern - each documentation source is implemented as an independent shell script in the sources/ directory that implements a consistent interface (available, describe, info, list, search functions). The main script (wikiman.sh) orchestrates parallel searches across sources, combines results, and presents them through a fuzzy finder (fzf/skim) with preview capability. Shell integration is provided via key-binding widgets for bash, fish, and zsh. The codebase demonstrates solid shell engineering practices: POSIX compatibility checks, clear function separation, proper error handling, and a clean extensible architecture for adding new documentation sources. The source module pattern is particularly well-designed - any new documentation source can be added by implementing the standard interface. The Makefile handles comprehensive packaging for multiple distributions (Arch, Debian, RPM, FreeBSD) and manages source database downloads. CI/CD pipelines automate package building and source database updates. The heavy reliance on awk for text processing is a double-edged sword - it enables powerful data manipulation in pure shell but creates maintenance complexity. The main script is monolithic (~500 lines) and could benefit from further modularization. However, the code is functional, well-structured, and demonstrates genuine craftsmanship in shell scripting.
A Python CLI tool for searching, downloading, and organizing doujinshi (self-published manga) from configurable mirror sites. The architecture uses a plugin system defined via abstract base classes (BaseParser, BaseModel, BaseSerializer, BasePlugin) and discovered through Python entry points, allowing support for multiple sites (e.g., nhentai) without modifying the core code. The core package handles CLI argument parsing, asynchronous image downloading via httpx/asyncio with retry and proxy support, export to CBZ/PDF/ZIP, generation of HTML viewers for local browsing, and SQLite-based download history tracking. The codebase is well-structured with clear separation between core utilities and plugin-specific logic, though it contains duplicated viewer template files that indicate incomplete cleanup.
Sopel is an IRC bot framework written in Python designed for extensibility through plugins. It provides core IRC protocol handling, plugin management, configuration systems, and utilities for time, calculation, and web interactions. The architecture centers around a plugin system where functionality is added via decorators (@command, @rule, etc.) and plugins can access bot state, configuration, and persistent storage. Key entry points include the `sopel` CLI for running the bot, `sopel-config` for configuration management, and `sopel-plugins` for plugin operations. The system supports IRCv3 features like SASL authentication and capability negotiation, uses SQLAlchemy for persistent storage of nick/channel data, and includes numerous built-in plugins for utilities such as calculations, URL title fetching, and user tracking. While actively maintained with recent commits, the codebase shows ongoing evolution with deprecated APIs marked for removal (e.g., sopel.loader, sopel.module) indicating moderate technical drift.
gimme-aws-creds is a Python CLI tool for obtaining temporary AWS and Alibaba Cloud credentials via Okta SAML authentication. It supports both Okta Classic and Identity Engine flows, handles multiple MFA methods (push, TOTP, hardware tokens, SMS, email, FIDO2/WebAuthn, Duo), and exchanges SAML assertions for temporary cloud credentials. The tool outputs credentials in various formats (export, JSON, Windows PowerShell) or writes them to standard credential files (~/.aws/credentials, ~/.aliyun/config.json). The application features a modular architecture with separate modules for Okta authentication (okta_classic.py, okta_identity_engine.py), cloud provider resolution (aws.py, alibaba_cloud.py), configuration management (config.py), MFA handling (duo.py, u2f.py, webauthn.py), and shared utilities (common.py, ui.py, debug_formatter.py). Key entry points include bin/gimme-aws-creds (main executable) and platform-specific wrappers. Data flows involve parsing configuration/authentication options, performing Okta authentication with MFA, extracting SAML assertions, assuming cloud roles via STS APIs, and formatting output. Notable reusable components include a flexible configuration system with inheritance and source tracking (config.py), isolated SAML parsing utilities (common.py), a UI abstraction layer for testability (ui.py), and a secure HTTP logging formatter that automatically redacts sensitive data (debug_formatter.py). The project is actively maintained but shows medium technical drift due to platform-specific WebAuthn dependencies requiring older Python versions on Windows and the complexity of maintaining compatibility with multiple authentication systems and cloud providers.
The Go vulnerability management tool is a command-line application designed to analyze Go code and binaries for known vulnerabilities. It uses a vulnerability database curated by the Go security team to identify vulnerabilities in dependencies. The tool provides features such as JSON and SARIF output formats for reporting vulnerabilities.
Hawk-Eye is a command-line application designed to scan various data sources for Personally Identifiable Information (PII) and secrets. It supports cloud storage (S3, GCS, Firebase), databases (MySQL, PostgreSQL, MongoDB, Redis), file systems, and collaboration platforms (Slack, Google Drive). The tool uses regex pattern matching and OCR to detect sensitive data in multiple file formats including images, PDFs, Office documents, and videos. The architecture is modular with a central dispatcher in main.py that routes commands to specific implementations in the commands/ directory. Shared functionality like file reading, OCR, and pattern matching is encapsulated in internals/system.py. This design allows easy extension to new data sources by adding new command modules. The tool is intended for security auditing and can be run standalone or integrated into scripts/CI/CD pipelines. Features include alert deduplication, severity-based reporting, and Slack/Jira integrations. Despite its comprehensive feature set, the tool maintains separation of concerns, making it maintainable and extensible. The use of third-party libraries for specific data sources keeps core logic focused on scanning and reporting.
Globstar is a static analysis toolkit that enables developers to write custom checkers in YAML or Go and run them via a single portable binary. It uses tree-sitter for AST-based analysis, supporting multiple languages (Go, Java, JavaScript, Python, Ruby, etc.). The tool is designed to be fast, dependency-free, and CI-friendly, with a focus on enforcing learned patterns such as security vulnerabilities and code quality issues. The architecture consists of a CLI layer, an analysis engine for parsing and scope resolution, and a checker system with built-in and custom checker support.
GraXpert is a desktop application (with CLI support) for astronomical image processing, specifically for removing background gradients from astrophotos. It provides multiple interpolation methods (RBF, Splines, Kriging) that require manual selection of background sample points, as well as an AI-based method that automatically extracts the background using ONNX Runtime models. The application also includes AI-powered denoising and deconvolution (object-only and stars-only) features. The architecture is a monolithic Python application using customtkinter for the GUI, with multiprocessing for parallel interpolation and onnxruntime for AI inference. It supports common astronomical image formats (FITS, XISF, TIFF) and includes a command-line interface for batch processing. The codebase is well-structured with design patterns (command, repository, event bus), localization, and CI/CD pipelines for cross-platform builds.