SPAG4D is a production-grade tool that converts 360° equirectangular panoramic photos into explorable 3D Gaussian Splat (3DGS) scenes. It integrates multiple depth estimation backends (DA360, DAP, PaGeR, SHARP, UniSHARP) to generate depth maps from a single panorama, then projects the points into standard 3DGS PLY format. The system provides a CLI, a FastAPI web server with a JavaScript frontend, and a Python API for programmatic use. Beyond the core conversion, it includes optional refinement pipelines to fill holes and improve scene quality: OmniRoam (WSL2-based video generation and distillation), ArtiFixer3D (Docker-based diffusion refinement), and a lighter geometric refinement pipeline using depth alignment and voxel aggregation. The architecture is modular with pluggable generators, comprehensive configuration dataclasses, and provenance tracking. While the tool is primarily an application, it leans heavily on research-grade depth models and refinement techniques, giving it a hybrid character. The codebase is well-structured with clear separation of concerns, reusable utilities (spherical projection, depth blending, scene filtering, geometric alignment), and extensive tests. It is actively maintained with recent commits, though it carries complexity from multiple backends and platform-specific dependencies (WSL2, Docker, CUDA).
vexctl is a command-line tool for creating, applying, and attesting VEX (Vulnerability Exploitability eXchange) data. It is built as a single binary using Cobra for CLI, with subcommands for creating VEX documents, merging them, filtering SARIF scanner results, generating attestations, and validating documents against the OpenVEX specification. The tool integrates with Sigstore for keyless signing and supports multiple VEX formats (OpenVEX native, CSAF, CycloneDX). It can attach VEX attestations to container images via OCI referrers API or legacy tag layout. The architecture follows a clean separation of concerns: CLI handlers in `internal/cmd/` delegate to a core library in `pkg/ctl/`, which uses an interface (`Implementation`) for testability. The `pkg/attestation/` package handles in-toto attestations and Sigstore signing independently. The codebase demonstrates strong engineering practices with dependency injection, options struct patterns, and comprehensive test data. While primarily an application, it also processes vulnerability data (SARIF, VEX documents) and includes validation logic that could be reused in other security tooling.
This is a well-crafted Go CLI application for interacting with the Clockify time-tracking API. It provides a comprehensive set of commands for managing time entries, projects, tasks, clients, tags, workspaces, and users. The architecture follows the GitHub CLI pattern with Cobra commands, Viper configuration, and dependency injection via a Factory interface. The application supports both interactive and non-interactive modes, multiple output formats (table, JSON, CSV, Markdown, Go templates), and name-to-ID resolution for convenience. Key features include a step-pipeline pattern for composable time entry modifications, a generic pagination helper for API list endpoints, and a search package with approximate matching. The codebase is well-tested with extensive unit tests using generated mocks, and the project is actively maintained with a robust CI/CD pipeline (GoReleaser, GitHub Actions, Netlify docs site).
notcrawl is a production-grade CLI tool for mirroring a Notion workspace into a local SQLite database and normalized Markdown files. It ingests data from three sources: the official Notion API, the local Notion Desktop cache (macOS), and an experimental Notion MCP gateway (via ChatGPT). The core architecture is a Go CLI with a unified SQLite store that tracks record provenance (source, sync timestamps, tombstones) and supports full-text search via FTS5. Key commands include `sync` (multi-source ingestion), `search`, `export-md` (Markdown tree), `export-db` (CSV/TSV for databases), `tui` (terminal browser), and `publish`/`subscribe` (git-backed snapshot sharing). The system emphasizes data completeness, deterministic rendering, and offline durability. External dependencies include the Notion API, local SQLite (desktop cache), and a git binary for share operations. The codebase is well-tested with extensive unit and integration tests, and follows clean separation of concerns across store, API, desktop, MCP, markdown, and share modules.
Crawlkit is a shared Go library and CLI tool (crawlctl) for building local-first crawler archives. It provides provider-neutral building blocks including SQLite stores with FTS5, snapshot/export to gzipped JSONL shards, Git-based mirroring with immutable tags, encrypted backup with age/gzip and SHA-256 deduplication, sync state management with legacy adapters, vector search (exact cosine similarity and optional turbovec Python bridge), embedding providers (OpenAI, Ollama, llama.cpp), a terminal UI (Bubble Tea) for browsing archive rows, and a remote archive client for Cloudflare Workers. The CLI discovers installed crawl apps (e.g., gitcrawl, discrawl) and runs configured refresh jobs under a single-process lock. The architecture is modular and composable, with clear ownership boundaries documented in docs/boundary.md. The repository also includes agent skills (autoreview, crabbox) for automated code review and remote validation, reflecting heavy agent-driven development. It is not a generic web crawler but a mechanics layer that makes each crawl app smaller and more uniform.
wttr.in is a production-grade weather forecast service accessible via HTTP, designed primarily for terminal use with `curl`. It provides weather reports in multiple formats: ANSI-colored text (v1 and v2 views), plain text, JSON (j1/j2), Prometheus metrics (p1), HTML, and PNG images. The service automatically detects the user's location via IP geolocation (MaxMind GeoIP2) or explicit city/airport/coordinate queries, then fetches weather data from WorldWeatherOnline (the only actively configured data source). The architecture is a single Go binary with embedded assets (fonts, translations, templates) and a pipeline of interfaces: query parsing, location resolution, weather fetching, caching, rendering, and formatting. It supports 74 languages with per-language translation files and a rule-based routing system for selecting views and output types. The codebase demonstrates solid engineering with interface-based design, multiple caching layers (LRU in-memory, disk-based, SQLite-backed location cache), and request coalescing to prevent thundering herd on upstream APIs. However, it shows signs of technical drift: reliance on a single external weather API, hardcoded paths in configuration, disabled linters, and incomplete translations. The project is actively maintained with a large user base and extensive integration documentation for tools like tmux, Waybar, Emacs, and Google Sheets.
Cookiecutter Data Science (CCDS) is a CLI tool that generates standardized, opinionated project scaffolds for data science work. It wraps the cookiecutter templating engine with custom prompting logic that supports nested configuration choices (e.g., cloud storage options with sub-fields for bucket names), and post-generation hooks that dynamically write dependency files in multiple formats (requirements.txt, pyproject.toml, environment.yml, Pipfile, pixi.toml), configure linting/formatting tools (ruff or flake8+black+isort), set up testing frameworks (pytest/unittest), and scaffold code modules with boilerplate for data processing, feature engineering, modeling, and visualization. The tool is designed to be run via the `ccds` command, which defaults to the DrivenData template repository and the installed version of the template. The codebase demonstrates solid software engineering: it monkey-patches cookiecutter's internals in a controlled way to add functionality (prompting with sub-options, custom context file selection), provides a suite of reusable hook utilities for dependency management and custom config injection, and maintains extensive test coverage across multiple operating systems and environment managers (conda, virtualenv, pipenv, uv, pixi, poetry). The architecture is a thin CLI application that delegates to cookiecutter while extending it through monkey-patching and post-generation hooks. It is not a data research project itself but a tool for creating such projects.
m-cli is a macOS command-line utility that provides a unified interface for managing system settings, preferences, and services. It consists of a main dispatcher script (`m`) and over 40 plugin scripts, each handling a specific macOS subsystem (e.g., Wi-Fi, Bluetooth, display, dock, permissions). The architecture is a simple plugin-based monolith: the main script resolves the plugin path and delegates execution. Plugins follow a consistent pattern with `--help` output that is parsed by shell completion scripts to dynamically generate completions for bash, zsh, and fish. The codebase is entirely written in Bash (with one Python plugin for screen lock) and relies on macOS native commands (`defaults`, `osascript`, `systemsetup`, `diskutil`, etc.). It is well-structured, with clear separation of concerns, standardized option parsing, and a small test suite using Bats. While the plugins are tightly coupled to macOS, the overall architecture and the dynamic completion generation pattern are reusable concepts.
ncc (Node.js Compiler Collection) is a CLI tool and programmatic library that compiles a Node.js module along with all its dependencies into a single file, similar to gcc for C. It uses Webpack internally with custom loaders for TypeScript, asset relocation, shebang handling, and more. The output can be minified, source-mapped, and optimized with V8 compile cache. It is designed for serverless environments and npm package publishing. The codebase is well-structured with a clear separation between CLI (src/cli.js) and core API (src/index.js). It includes extensive integration tests covering dozens of popular npm packages (Express, React, Apollo, etc.). While the core logic is tightly coupled to Webpack, several utility functions are independently reusable.
EvoMap Evolver is a self-evolving AI agent engine built as a Node.js >=22.12 CLI daemon. It runs a genome-evolution loop: scans session memory/logs, extracts signals, selects 'Genes' (prompt/strategy patches) and 'Capsules' (validated skill bundles) from a local JSON/JSONL asset store, generates GEP-framed prompts for coding agents (Claude Code, Codex, Cursor, Gemini CLI, opencode, Kiro), executes those sessions, and records outcomes in a memory graph to adapt future selections. The system solidifies successful patterns into new reusable assets, auto-distills failure patterns and SKILL.md files into Genes/Capsules, and can open PRs or run validation sandboxes against candidate changes. It also ships an LLM proxy (Anthropic/OpenAI/Gemini/Vertex/Ollama routes with trace encryption and token-savings attribution), an ATP (Agent Transaction Protocol) marketplace for buying/completing agent tasks with auto-buyer and auto-deliver, a validation daemon for decentralized task verification, a local Web UI dashboard, and an experiment runner for A/B comparing evolution strategies. Hub synchronization (SSE event delivery, mailbox sync, OAuth device login) connects nodes to the evomap.ai network, but the system is designed to degrade gracefully into fully offline solo mode.
trash-cli is a command-line interface implementing the FreeDesktop.org Trash specification. It provides five primary commands: trash-put (move files to trash), trash-list (list trashed files), trash-restore (interactively restore files), trash-empty (empty trash directories), and trash-rm (remove specific trashed files). The architecture is modular, with separate packages for each command (trashcli/put/, trashcli/list/, trashcli/restore/, trashcli/empty/, trashcli/rm/) sharing common utilities from trashcli/lib/, trashcli/fslib/, and trashcli/fstab/. Key entry points are the main() functions in each command's main.py module, invoked via shell scripts (trash, trash-put, etc.). Data flows involve reading trash directories (per the spec's rules for $XDG_DATA_HOME/Trash, .Trash/$uid, .Trash-$uid), parsing .trashinfo files, and performing file operations (move, delete, restore) with security checks (sticky bits, symlinks, world-writable directories). External dependencies include psutil (for volume detection), six (Python 2/3 compatibility), and optionally shtab (shell completion). The codebase is well-tested with a comprehensive fake filesystem for unit tests and integration tests covering edge cases.
Nextron is a CLI tool and scaffolding system that integrates Next.js with Electron for building cross-platform desktop applications using web technologies. It provides a streamlined development experience by orchestrating Next.js dev server, webpack bundling for Electron main and preload scripts, and optional production packaging with electron-builder. The repository contains the core library (CLI, build helpers, webpack configurations) and a rich set of example projects demonstrating integrations with UI frameworks (Ant Design, Chakra UI, Material UI, Tailwind CSS, Emotion, i18next) and features like window state persistence, static export, and custom build options. The architecture is monolithic, centered around a command-line interface with `dev` and `build` commands, and the codebase shows disciplined engineering with TypeScript, ESLint, Prettier, and lefthook. While primarily a development tool, its examples serve as practical templates for Electron+Next.js application patterns.
Dura is a background process (daemon) that automatically snapshots uncommitted changes in Git repositories. It runs as a CLI tool with subcommands: `serve` (daemon loop), `watch`/`unwatch` (manage watched repos), `capture` (one-shot snapshot), `status` (daemon state), `kill` (stop daemon), and `metrics` (post-process logs with git diff stats). The architecture is a single Rust binary. On every polling cycle (5 seconds), it iterates watched repos, uses an optimized file-timestamp check (`PollGuard`) to detect changes efficiently, then creates a commit on a separate `dura/<HEAD_hash>` branch without modifying the working tree or HEAD. Snapshots include all tracked and untracked files. Configuration is stored as TOML in the user's config directory; runtime state (PID) is stored as JSON. Logging is structured JSON via a custom tracing layer. The design emphasizes non-disruptive operation and data safety.
UndertaleModTool is a comprehensive, open-source modding and reverse-engineering tool for GameMaker games, specifically Undertale and Deltarune. It provides a full suite of functionality: reading/writing GameMaker data files (.win, .unx, etc.) with byte-for-byte accuracy, decompiling GML VM bytecode back into human-readable GameMaker Language (GML), compiling modified GML back into bytecode, and editing all game assets (sprites, sounds, rooms, code, textures, shaders, fonts, etc.) through a Windows-only WPF GUI or a cross-platform CLI. The tool also includes a project system for exporting/importing assets as JSON and PNG, a built-in C# scripting engine for automation, and game-specific definitions that tailor decompilation and modding to Undertale and Deltarune. The architecture is a classic library-plus-front-end pattern: the core library `UndertaleModLib` handles all binary serialization, decompilation, compilation, and project management. The GUI application `UndertaleModTool` and CLI `UndertaleModCli` are thin layers that use this library. The library itself is heavily version-aware, supporting multiple GameMaker versions (GMS1, GMS2, 2022-2024) with hundreds of conditional checks. The decompiler integrates with the external `Underanalyzer` submodule for advanced GML compilation and decompilation. A large collection of built-in C# scripts covers common modding tasks (resource export/import, technical utilities, game-specific modifications). While primarily an application, the repository also serves as a living document of GameMaker's internal data format—a significant reverse-engineering effort. The code is rich with comments explaining undocumented structures, version differences, and workarounds for engine bugs. This hybrid nature makes it both a practical modding tool and a valuable research resource for understanding GameMaker internals.
Certify is a monolithic C# CLI tool for enumerating and attacking misconfigurations in Active Directory Certificate Services (AD CS). It provides over a dozen verbs covering discovery (enum-cas, enum-templates, enum-pkiobjects), certificate request (request, request-agent, request-download, request-renew), certificate forging (forge), and CA/template management (manage-ca, manage-template, manage-self). The architecture is a single .NET 4.7.2 console application using CommandLineParser for argument handling and COM interop (CERTENROLLLib, ICertAdminD2) for enrollment and CA administration. It queries Active Directory via LDAP (System.DirectoryServices) and uses BouncyCastle for cryptographic operations. The codebase is well-structured, with clear separation of concerns into commands, domain models, libraries, and utilities, and demonstrates deep knowledge of Windows PKI internals, including DCOM communication, remote registry access, and certificate chain manipulation.
This repository is a CLI tool and Python library that generates modern, typed Python HTTP client libraries from OpenAPI 3.0 and 3.1 specifications. The system parses an OpenAPI document (YAML or JSON), validates it against Pydantic models of the OpenAPI schema, and then converts the parsed structure into an internal representation of endpoints, models, and properties. Using Jinja2 templates, it generates a complete Python package with attrs-based model classes, httpx-based sync/async endpoint functions, a Client class with authentication support, and packaging metadata (Poetry, PDM, uv, or setup.py). The generated code is fully typed and includes serialization/deserialization methods, error handling, and support for complex OpenAPI features like allOf, oneOf, discriminated unions, enums, circular references, and custom content types. The architecture is a monolithic Python package with clear separation of concerns: a CLI entry point (typer), a configuration system (YAML/JSON config files with class overrides), a parser module that converts OpenAPI schemas into a property type hierarchy (StringProperty, IntProperty, UnionProperty, ModelProperty, etc.), and a template rendering engine. The parser uses a protocol-based design for property types, making it extensible. The system also includes a vendored copy of the openapi-schema-pydantic library for schema validation. Security is a key concern, with features like UntrustedString to prevent code injection in generated output and fuzz testing that generates random OpenAPI documents with dangerous strings. The project has extensive testing: unit tests for all parser components, end-to-end snapshot tests using golden records, functional tests that execute the generated code, integration tests against a live test server, and property-based fuzz testing. The generated client libraries are production-ready, using modern Python features like `from __future__ import annotations`, `|` union syntax, StrEnum/IntEnum, and the UNSET sentinel for optional fields. The tool is configurable via CLI flags and config files, supporting custom templates, post-generation hooks, and various packaging backends.
dotdrop is a command-line tool for managing dotfiles across multiple hosts using profiles, Jinja2 templating, actions, and transformations. It stores dotfiles in a Git repository and deploys them to target systems, allowing different configurations per host or environment. The architecture is modular: separate Python modules handle each operation (install, compare, update, import, remove, uninstall), with a central dispatcher in `dotdrop.py`. Configuration is defined in YAML (or optionally TOML) files that specify dotfiles, profiles, variables, actions, and transformations. Key entry points are the CLI subcommands invoked via `dotdrop <command>`. Data flows involve parsing the config, aggregating imported configs and variables, then executing file operations (copy, symlink, diff) with optional template rendering and shell commands. External dependencies include Jinja2, docopt, PyYAML, and optional libraries for TOML support and system detection. The codebase is well-tested with both Python unit tests and a large suite of Bash integration tests, and it is distributed via PyPI, Homebrew, AUR, Snap, and other channels.
Updo is a production-grade CLI tool for multi-target website uptime and performance monitoring. It continuously checks HTTP endpoints from the command line or a TOML configuration file, displaying real-time results in an interactive TUI or simple text output. The core monitoring engine performs configurable HTTP requests (GET/POST/PUT, custom headers, assertion text, redirect handling, SSL verification) and captures detailed timing breakdowns (DNS, TCP, TTFB, download). It can also deploy and invoke AWS Lambda functions across 13 global regions for geographically distributed probing, aggregating results from multiple vantage points. The tool integrates with Prometheus via Remote Write for long-term metric storage and visualization, and supports desktop alerts via beeep plus webhook notifications to Slack, Discord, or custom endpoints with auto-detected formatting. Architecture is a monolith Go application built on cobra for CLI management, termui for the TUI, and AWS SDK v2 for Lambda operations. Key entry points are the `updo monitor` and `updo aws` subcommands. Data flows from config or CLI flags through a monitoring loop that calls the HTTP checker or Lambda invoker, accumulates stats (t-digest for percentiles, rolling uptime), and pushes structured logs or Prometheus time series.
Proxelar is a high-performance, scriptable local traffic workbench for HTTP, HTTPS, and WebSocket debugging. It functions as a man-in-the-middle (MITM) proxy that can capture, inspect, intercept, modify, replay, and export traffic across multiple protocols (HTTP/1.1, HTTP/2, HTTP/3, WebSocket, SOCKS5, DNS, UDP, and WireGuard). The system is built as a Rust workspace with four crates: `proxelar-cli` (binary with TUI, terminal, and web GUI interfaces), `proxyapi` (core proxy engine with TLS interception, Lua scripting, addon system, route rules, and session export/import), `proxelar-proto` (transport-neutral HTTP core with sans-I/O parsers for HTTP/1 and HTTP/2), and `proxyapi_models` (shared data types for headers, sessions, and captured exchanges). It supports forward and reverse proxy modes, declarative JSON routing rules, Lua addons with SHA-256 verification, and exports to HAR, curl, and raw formats. The architecture is modular with clean dependency direction, extensive integration tests, performance benchmarks, and property-based testing. It is a production-quality developer tool comparable to mitmproxy or Charles Proxy, with a focus on performance, correctness, and extensibility.
Dataform is an open-source data transformation and workflow orchestration tool focused on BigQuery. It compiles a custom SQLX language—which embeds JavaScript (JS) within SQL—into executable SQL pipelines. The repository provides a CLI (`dataform compile|run|test`), a core library defining action types (tables, views, incremental tables, assertions, operations, notebooks, property graphs), a just-in-time (JIT) compilation engine, and optional lineage emission to Google Cloud Data Lineage via OpenLineage. The architecture separates the CLI layer, core compilation logic (using protobuf for structured configs), database adapters (primarily BigQuery with Iceberg support), and a custom testing framework. Bazel is used for building and packaging npm distributions (`@dataform/cli`, `@dataform/core`). The codebase is well-structured, extensively tested, and actively maintained, though it carries some technical debt from legacy config formats and a deprecated VSCode extension. Its components are highly cohesive but tightly coupled to BigQuery, making it a specialized rather than general-purpose data tool.