This is a Python application for migrating playlists and liked songs from Spotify to YouTube Music. It provides both a command-line interface (CLI) and a graphical user interface (GUI) built with Tkinter. The tool first backs up Spotify data (playlists, liked songs, liked albums) into a local JSON file using a modified version of the spotify-backup script. Then it reads that JSON and uses ytmusicapi to add or like songs on YouTube Music, employing a multi-algorithm search strategy to match tracks. The architecture is monolithic: a single package with CLI entry points defined in pyproject.toml and a GUI module. Key external dependencies are ytmusicapi, tkinter, and the Spotify Web API. The code is well-structured with clear separation of concerns (backend logic, CLI, GUI, backup) and includes retry logic for API rate limits. The search algorithm supports exact matching, extended matching, and fuzzy matching with video fallback, demonstrating thoughtful design for cross-platform music identification.
Gear Lever is a GNOME desktop application for managing AppImage files on Linux. Its core function is integrating AppImages into the desktop environment by extracting them, generating .desktop entries with metadata and icons, and keeping them updated. It supports one-click install from downloaded AppImages, drag-and-drop integration, in-place version updates from multiple sources (GitHub releases, GitLab, Codeberg, Forgejo, FTP, and static URLs), side-by-side version retention, per-app environment variables and exec arguments, and bulk update operations. The application is distributed primarily as a Flatpak on Flathub and also ships a headless CLI (src/Cli.py) matching most GUI operations such as integrate, update, remove, list, and fetch-updates. Architecturally, this is an event-driven GTK4/Adwaita desktop application written in Python. The main window (GearleverWindow) uses Adw.Leaflet navigation with a drag-and-drop overlay, and views communicate through custom GObject signals. The core lifecycle logic lives in AppImageProvider, which handles download, extraction, desktop-entry generation, and launch. Extraction uses a fallback chain (dwarfs → 7zz → unsquashfs → appimage-extract) to handle the fragmented AppImage format landscape. Update sources are abstracted behind an UpdateManager ABC with separate backend classes per hosting platform. Configuration is split between a global JSON settings store and per-app INI files, with a migration path from an older JSON schema. Background work is managed through custom async/idle/debounce decorators that marshal tasks onto worker threads and safely return results to the GTK main loop. The system relies on external runtime binaries (7zz, dwarfsck, dwarfsextract, unsquashfs, readelf, strings, file, get_appimage_offset) in addition to Python packages (dbus-python, pyxdg, ftputil, requests, desktop-entry-lib). Notably, the repo embeds a demo.AppImage binary used as a test fixture, illustrating the extraction pipeline against a real-world AppImage. Test coverage is thin — only CLI integration tests that download actual AppImages — and the codebase shows some legacy baggage (ftputil, direct D-Bus usage, fragile external-tool version assumptions). Nonetheless, the code is modular, actively maintained with nightly builds, well-internationalized (16 languages), and demonstrates real craftsmanship in its abstraction layers.
Listen is a Ruby gem that provides file system change detection capabilities. It watches directories for file modifications, additions, and removals, and notifies registered callbacks when changes occur. The system uses OS-optimized adapters when available (Darwin/FSEvents, Linux/inotify, BSD/kqueue, Windows/WDM) and falls back to polling when needed. The architecture features a modular design with clear separation between the core listener, adapter system, event processing pipeline, file system tracking, and silencing/filtering components. Key entry points include the Listen.to() method and the bin/listen executable.
This repository is the official CLI tool for Firecrawl, a web scraping, crawling, and structured data extraction platform. Built with Node.js and TypeScript, it provides a comprehensive command-line interface (CLI) using the Commander framework. In production, it allows users to scrape individual URLs, perform multi-page crawls, search the web (text, images, news), map site structures, interact with cloud browser sessions, create recurring content monitors, and use AI agents for complex extraction tasks. It also includes a research paper search feature covering ~43 million abstracts from PubMed, bioRxiv, medRxiv, and arXiv, as well as a developer index for searching GitHub issues, PRs, and READMEs. The CLI is designed for both direct human use and integration with AI coding agents via MCP (Model Context Protocol) and a skills system. Architecturally, it follows a command-per-file pattern in src/commands/, with shared utilities in src/utils/ for API client management, configuration/credential handling, output formatting, authentication (PKCE OAuth, API key, keyless free tier), and job polling. The core data flow is: user input -> command handler -> Firecrawl REST API (cloud or self-hosted) -> formatted output to stdout or file. External dependencies include the firecrawl SDK, commander, @inquirer/prompts, yaml, and zod-to-json-schema. The tool supports binary builds via Bun compile and is distributed via npm, Homebrew, and GitHub Releases with .deb/.rpm packages. It also includes interactive setup wizards, MCP server installation for coding agents, and a native skill installer. While primarily an application, the research paper search feature gives it a hybrid data-access character, but it does not contain data pipelines, notebooks, or analytical models. The codebase is well-tested (Vitest) and actively maintained, with CI/CD workflows for testing, npm publishing, and binary releases. However, the large command surface and agent-specific integrations introduce some maintenance complexity, and the reliance on the firecrawl SDK and external APIs means changes upstream could require updates.
OASIS is a CLI-first security analysis tool written in Python. It orchestrates a multi-phase LangGraph pipeline (Discover → Scan → Expand → Deep → Verify → Report) to detect vulnerabilities in source code using local LLMs via Ollama or OpenAI-compatible servers. The tool supports 25+ vulnerability types across multiple languages, produces deterministic verdicts without LLM reliance, and integrates with CI via severity-gated exit codes, suppression registries, and report diffing. It is installed via pipx or Docker and run as `oasis -i /path --models ...`.
CellTypist is a Python library and command-line tool for cell type classification in single-cell RNA-seq (scRNA-seq) data. It implements a complete annotation workflow: training logistic regression classifiers on labeled expression matrices (with optional SGD mini-batching and GPU-accelerated cuML backends), annotating query cells using either custom-trained or pre-trained models, and visualizing marker gene expression via dotplots. The package is architected as a conventional Python library with a click-based CLI (entry point: celltypist.command_line:main), a models submodule that manages remote pre-trained artifacts, and a samples module for loading bundled example data. The primary data flow starts with an AnnData object containing raw counts, which is normalized, scaled, and filtered through feature selection before being passed to the classifier. For annotation, the trained model (or a downloaded pre-trained model) is applied to query cells, producing cell type labels and confidence scores. Models are fetched on-demand from celltypist.cog.sanger.ac.uk and cached locally, with a force_update flag to bypass the cache. External dependencies include scanpy, anndata, scikit-learn, click, numpy, scipy, pandas, and matplotlib. The repository is hybrid in nature: while the core deliverable is a software library, it also ships pre-trained models, a cross-species gene mapping reference (Cynomolgus/Rhesus orthologs), and tutorial Jupyter notebooks that demonstrate the API. These data assets make it a valuable resource for bioinformatics researchers even beyond the code itself. The tutorial notebook (docs/notebook/celltypist_tutorial_ml.ipynb) is a usage guide rather than a research artifact, relying on 12 built-in pre-trained models and demo data fetched from the same remote server. The project is maintained but not rapidly evolving; the last significant release was January 2025, and the codebase shows signs of technical drift. The pickle-based model format could break across Python or scikit-learn versions, and the tutorial notebook may produce different outputs with newer versions of scanpy or CellTypist. The force_update mechanism and backup_url fallback in the data-loading code indicate awareness of external data unavailability, but these fallbacks could themselves become stale.
A comprehensive, isomorphic JavaScript audio processing library engineered for editing, analysis, playback, and encoding. It is non-destructive and stream-first, utilizing a paged in-memory architecture with optional OPFS caching and a Web Worker facade for off-main-thread execution. The library exposes a declarative operation (op) and statistics (stat) plugin system, enabling custom DSP atoms to be composed into serializable edit plans with undo/redo support. It includes a CLI for batch processing and a hand-rolled MCP server for AI-agent integration, plus a polished web demo and workshop pages. The codebase spans core engine modules, 50+ built-in operations (gain, fade, filters, reverb, pitch, stretch, loudness normalization, denoising, etc.), and a large ecosystem of @audio/* dependencies for codecs and advanced effects. It is tested across browser (Playwright) and Node, with benchmark comparisons against SoX, FFmpeg, librosa, and Pedalboard. While the architecture is sophisticated and well-documented, the repository exhibits some over-engineering, a very large test suite that is brittle, and identified production defects (e.g., loudness normalization clipping) that undermine its polish.
Open CAS Linux is a production-grade block-layer cache acceleration solution for Linux. It consists of a kernel module (`cas_cache`) implementing caching logic on top of the OCF (Open Cache Framework), a block device module (`cas_bd`), and a user-space management CLI (`casadm`). The system accelerates block I/O by caching hot data on fast storage (e.g., NVMe/Optane) while using slower backing storage, with support for multiple cache modes, cleaning policies, I/O classes, and statistics reporting. Management is performed via ioctls through `/dev/cas_ctrl` and netlink-based communication, with a comprehensive CLI (`casadm`) for cache/core lifecycle operations and statistics output in text, CSV, and raw CSV formats.
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.
AppImageLauncher is a Linux desktop integration utility for AppImage portable applications. It intercepts AppImage launches (via binfmt_misc and an LD_PRELOAD-based bypass), prompts users to move AppImages into a central applications directory, registers them with the system launcher by installing desktop files and icons, and provides context-menu actions to remove or update integrated AppImages. A background daemon watches watched directories via inotify and automatically integrates newly added AppImages and unintegrates removed ones. The project includes a main Qt GUI, a settings dialog, first-run wizard, CLI tool (`ail-cli`), daemon, and remove/update helper binaries.
MediaInfo is a mature, cross-platform application for extracting and displaying technical and tag metadata from audio and video files. It provides a command-line interface (CLI) and multiple graphical front-ends (Qt, wxWidgets, Cocoa, VCL, UWP, Android, iOS) all sharing a common core library (MediaInfoLib). The repository contains the full source for the CLI, all GUIs, Windows shell extension, installers, and build/packaging scripts. The architecture is a classic layered design: a central Core class wraps MediaInfoLib and is consumed by each GUI via platform-specific adapters. The codebase is functional and widely used, but suffers from significant fragmentation across GUI frameworks and build systems, with legacy components (VCL, UWP) and conditional compilation adding maintenance overhead. The translation system using CSV files is well-designed and the command-line parser is robust, but most components are tightly coupled to the MediaInfo domain and not easily reusable outside the project.
Agentic Security is an open-source LLM vulnerability scanner that probes AI endpoints for security weaknesses such as jailbreaks, prompt injection, data leakage, and sandbox escapes. It provides both a FastAPI web server (port 8718) with a Vue.js frontend and a Fire-based CLI (server, ci, init, ls, scan). The core scan engine sends adversarial prompts (text, image, audio) to target LLMs via configurable HTTP specs, classifies responses using a multi-layered refusal detection system (phrase-based, OneClassSVM, PII detector, LLM-as-judge, hybrid voting), and generates detailed reports with failure rates and cost metrics. The architecture is modular: LLM provider abstraction (OpenAI, Anthropic, LiteLLM), resilience primitives (rate limiter, circuit breaker, concurrent executor), plugin-based refusal classifiers, and a dataset registry supporting HuggingFace, CSV, Google Sheets, and dynamic transformations (stenography, encoding). It also integrates external red-teaming tools (Garak, Inspect AI) and includes reinforcement learning and Bayesian optimization for adaptive prompt selection. While primarily an application, it contains significant data/research components (ML models, datasets, refusal classification research) that support its scanning mission.
Maid is a Ruby command-line tool and library that automates file organization and cleanup based on user-defined rules expressed in a Ruby DSL. It provides a suite of operations (move, trash, copy, rename, etc.) that can be combined with file metadata predicates (age, size, content type, download source, etc.) to systematically manage filesystems. The architecture is a traditional Ruby gem with a Thor-based CLI (bin/maid), a central Maid::Maid class that orchestrates rule loading and execution, and a set of tool methods mixed into the Maid instance for use in rule blocks. It also supports daemon mode using Listen (file system watcher) and rufus-scheduler (timed repeats). The code is well-structured with modular components, extensive test coverage, and modern Ruby practices, though it carries some legacy from supporting older Ruby versions. There is no data research or analytic component; it is purely an application for file automation.
ttab is a single-file Bash CLI that programmatically opens new terminal tabs and windows on macOS (Terminal.app and iTerm2) and Linux (gnome-terminal). It supports running startup commands in the new tab, setting working directory, title, and profile, creating iTerm2 horizontal/vertical splits (-v/-h), creating tabs without stealing focus (-g/-G), delaying command submission (-l), and clearing the screen (-q). The entire application is bin/ttab: a ~700-line Bash script with zero runtime dependencies that parses options via getopts, detects the calling terminal through TERM_PROGRAM / GNOME_TERMINAL_SCREEN or an explicit -a flag, synthesizes backend-specific automation (AppleScript for Terminal.app and iTerm2, with distinct v2/v3 syntax paths, and a CLI argument string for gnome-terminal), and executes it via 'exec osascript' on macOS or eval on Linux. It embeds its full Markdown man page as a here-doc extracted by sed, so --help, --man, and --man-source all work from the single distributed file.
This repository contains a build toolchain for compiling tree-sitter grammar dynamic libraries (.so/.dylib/.dll) for use with Emacs 29+. The core is a Python CLI (`langman.py`) that wraps shell scripts (`build.sh` and `batch.sh`) to clone, compile, and install tree-sitter grammars from GitHub. It supports versioned builds (via git tags) with caching, cross-platform extended attribute versioning, and parallel builds. The architecture is a simple CLI application with separate commands for building, installing, and querying versions. The codebase is well-structured, includes unit and end-to-end tests, and demonstrates clean separation of concerns between the Python frontend and the shell-based build logic. The tool is practical for Emacs users who need a streamlined way to manage tree-sitter language grammars.
yewtube is a terminal-based YouTube player and downloader, forked from mps-youtube. It provides a full-featured CLI for searching, streaming, downloading, and managing YouTube content without requiring a YouTube API key. The application uses yt-dlp and youtube-search-python as backends for video extraction and search. It supports multiple media players (mpv, mplayer, VLC), MPRIS integration for desktop media control, Last.fm scrobbling, playlist management (local and YouTube), and various download/transcoding options. The architecture is a monolithic Python application with a command-loop pattern, global state management via a dedicated module, and a plugin-like player abstraction. While the codebase shows its age with some tightly coupled modules and global variables, it contains well-designed components such as a config system with validation, an abstract player interface, and a command registration decorator. The project is actively maintained with recent commits and releases.
This repository provides the `starred` Python CLI tool, which generates and maintains an Awesome-style Markdown list from a GitHub user's starred repositories. The tool queries the GitHub GraphQL API to fetch all starred repos (with pagination), groups them by programming language or repository topic, and outputs a formatted Markdown document. It can optionally sort categories alphabetically, filter by topic popularity, include private repositories, and directly push the generated file to a target GitHub repository using the GitHub REST API. The architecture is a simple single-command CLI with two source modules: `starred/starred.py` (Click CLI entry point and Markdown generation) and `starred/githubgql.py` (a self-contained GraphQL client for fetching starred repos). External dependencies include `click`, `requests`, `github3.py`, `gql`, and `aiohttp`. The code is clean, follows a straightforward functional design, and integrates well with GitHub's APIs. While it lacks unit tests, the CI runs an integration test against the real GitHub API.
Bash-my-AWS is a CLI toolset designed to manage AWS resources using Bash functions and aliases. It wraps the AWS CLI with convenience functions for listing, filtering, and manipulating resources like EC2, S3, and CloudFormation. The architecture is a monolithic Bash library sourced into the user's shell environment, with modularized logic in `lib/*-functions`. It relies heavily on `awscli`, `jq`, and standard Unix utilities. The tool implements a pipe-skimming pattern (`skim-stdin`) that allows chaining commands (e.g., `instances | instance-stop`), enhancing usability for shell scripting. It includes a Python-based caching proxy (`bin/cachews`) to reduce API latency. While well-structured for Bash, it carries inherent risks due to the language's limitations, including security vulnerabilities in SSH handling and reliance on `eval` for argument inference. The repository is actively maintained with recent commits and a comprehensive test suite using a custom BDD-style framework. However, technical drift is moderate due to the rapid evolution of AWS APIs and Bash-specific security concerns. The codebase is suitable for engineers comfortable with Bash scripting who need a robust set of AWS management utilities.
Handwrite is a CLI application that converts a scanned handwriting sample into a TrueType font. The pipeline consists of three stages: SHEETtoPNG uses OpenCV to detect and extract individual character images from a grid-based form; PNGtoSVG uses Potrace to convert the PNG images to SVG vector outlines; and SVGtoTTF uses FontForge to compile the SVGs into a font file with configurable metrics, kerning, and bearings. The architecture is a simple sequential pipeline orchestrated by the CLI entry point. External dependencies include OpenCV, Pillow, Potrace, and FontForge. The codebase is well-structured with unit tests, CI, and modern Python packaging (uv, Python 3.14). The character detection module in `sheettopng.py` demonstrates reusable grid-based contour extraction logic.
git-log-tree is a single-file Bash CLI tool that renders a fancy, colored git log graph in the terminal. It wraps `git log` with `--topo-order`, `--parents`, and a custom pretty format, then parses the output to draw a tree using Unicode box-drawing characters and ANSI colors. The script handles complex branching, merges, and orphan commits, assigning colors to branches with an algorithm that minimizes reuse and ensures contrast. It respects the `NO_COLOR` environment variable and auto-detects color support. The tool pipes output through `less -F -R -S -X` for paging. The repository includes a comprehensive BATS test that creates a synthetic git history via fast-import and verifies the exact rendered output, along with a GitHub Actions workflow for coverage via kcov. The code is well-structured for a Bash script, using associative arrays and bit manipulation for efficient color sorting, but is monolithic with global state, limiting component reusability.