CPANscan

Dist::Zilla::PluginBundle::Author::GETTY is an opinionated, ready-made Dist::Zilla bundle that packages the tools and sensible defaults the CPAN author GETTY uses to build, document and release Perl distributions. It wires together versioning (Git::VersionManager or AutoVersion for task releases), PodWeaver, metadata helpers, Git checks and a post-release installer so you can release to CPAN with minimal configuration while still overriding details like author/authority, release_branch, or disabling CPAN uploads. The bundle also adds conveniences for XS and Alien-based modules, supports running scripts at various build and release points, and exposes flags such as no_install, no_makemaker, include_readme and adoptme plus IRC/contact metadata for generated SUPPORT sections. Recent updates made README.md excluded from release tarballs by default with an opt-in include_readme option and forward the commit_files_after_release setting to the version manager so files modified during run_before_release actually end up in the release commit. If you use Dist::Zilla and want a tested, configurable shortcut for packaging and releasing Perl distributions, this bundle is a practical starting point.

Music::Interval::Barycentric implements barycentric chord analysis for Perl, mapping chords expressed as pitch-class vectors into a geometric interval space so you can compare, transform and quantify them. It gives straightforward functions to compute a chord barycenter for a given chord size and scale, measure Euclidean-style distances between chords as well as cyclic and inversion-aware variants (orbit_distance and forte_distance), generate cyclic permutations, compute an evenness (consonance) index, and produce chord inversions. The API works with array references of pitch classes and defaults to three-note chords on a 12‑note scale, making the module useful for music theorists, algorithmic composers, visualization tools and any project that needs programmatic measures of chord similarity and balance. The recent 0.0402 release improves documentation and tests and updates the example evolve program.

Async::Redis is an asynchronous Redis client for Perl that uses Future::IO and Future::AsyncAwait to provide a modern non-blocking, async/await API. It is event loop agnostic so it will run with IO::Async, AnyEvent, UV or the built-in poll implementation in recent Future::IO, and it supports pipelining, auto-pipelining, connection pooling, automatic reconnection with exponential backoff, Pub/Sub with automatic subscription replay, transactions, TLS, Lua scripting with EVALSHA optimization, and OpenTelemetry tracing and metrics. The module safely handles concurrent commands on a single connection, is fork safe for pre-fork servers, and exposes convenient helpers like pipeline, subscribe, multi, watch, script registration and scan iterators. Errors are raised as typed exception classes so you can distinguish timeouts, connection failures and Redis errors, and the library leaves event loop selection to the application entry point rather than forcing a backend. Use Async::Redis when you need high throughput, low latency, non-blocking Redis access from Perl applications that integrate with an async event loop.

Unicode::Japanese is a Perl library for converting Japanese text among a wide range of encodings and for normalizing common Japanese forms. It keeps text internally as UTF-8 and can read and emit legacy encodings such as Shift_JIS (using Microsoft CP932 mappings), EUC-JP, ISO-2022-JP, various UTF-16/32 forms, and many mobile carrier variants including DoCoMo, au and J-SKY. The module also handles character transformations like zenkaku to hankaku, hiragana to katakana, splitting by display width, and special handling and mapping of mobile emoji into the Unicode Private Use Area so they survive round trips through Unicode-aware software. You can run the faster XS implementation when you have a C compiler or fall back to a pure Perl implementation without compilation. It can try to auto-detect input encodings but the guesser has known pitfalls such as confusing some UTF-8 sequences for Shift_JIS and limitations when converting to EUC-JP or ISO-2022-JP because those conversions go via Shift_JIS which can force unrepresentable characters into numeric references or question marks. This module is a practical choice if you need robust, carrier-aware Japanese text transcoding and normalization in Perl.

App::Test::Generator is a toolkit that automatically produces robust test harnesses for Perl modules from concise input/output schemas, letting you add extensive black‑box fuzzing and property tests without hand writing every case. You describe a routine in a YAML or Perl-backed schema and the tool emits Test::Most-based .t files that combine randomized fuzz inputs, deterministic edge cases derived from min/max/len constraints, static corpus tests, and optional property-based transforms powered by Test::LectroTest. It understands common types and semantic generators like emails, UUIDs and timestamps, supports functional and OO calls, can seed runs for reproducibility and control iteration counts, and validates inputs and outputs with Params::Validate::Strict and Return::Set. The distribution also includes a mutation-guided pipeline that links mutation testing, schema extraction and fuzz generation so surviving mutants can be used to create TODO stubs or runnable augmented schemas written into t/conf for subsequent fuzz runs, and it ships a test dashboard with LCSAJ/TER metrics to help prioritize gaps. Command line tools integrate with make test and GitHub Actions for scheduled fuzzing, and generated tests aim to be safe and reproducible for CI. In the 0.33 release a numeric mutation bug that produced invalid mutants was fixed and several dashboard, extraction and template improvements were added, including better handling of relationship metadata and additional edge cases for floating values.

ChordPro is a mature tool for turning plain-text song files marked up with lyrics and chord annotations into professional, print-ready song sheets and songbooks, typically producing PDFs but also textual and ChordPro-format outputs. It reads the ChordPro markup used to label titles, verses, choruses, chords and images and can generate chord diagrams, CSV indexes for apps like MobileSheets, transposed copies for capos or different keys, and cover or front/back matter pages while supporting custom TrueType/OpenType fonts and Unicode. The program is highly configurable via JSON-style config files and offers a GUI for building and previewing songbooks, plus experimental backends for HTML, LilyPond and LaTeX. Recent releases improved key and transposition handling, added options to prefer common keys and sharps, expanded the built-in chord library with many new and jazzy chord names, and introduced configurable automatic line wrapping and transposable chords in defines, along with better image file handling. If you maintain collections of songs or need to produce neat, customizable chord-and-lyric sheets with flexible transposition and diagram support, ChordPro is directly relevant.

MARC::Leader::Print is a small formatter for turning a Data::MARC::Leader object into a readable, line-oriented report of MARC leader fields. It returns either a single string or a list of lines depending on context and supports localized labels via an ISO 639-1 lang option, descriptive text vs raw values via mode_desc, and optional ANSI color output controlled by mode_ansi or environment variables when Term::ANSIColor is available. You can set the scalar output separator and the module is aimed at simple diagnostics, logging, or human-friendly display of MARC leader metadata. It relies on a few utility modules, validates parameters, and will raise errors for unknown options, invalid language codes, or missing color support when requested.

XML::Chain gives you a concise, chainable API for building and editing XML in Perl so you can create documents with readable, jQuery-like calls instead of wrestling the raw DOM. You start with the xc() factory to create a document or wrap existing XML, then chain methods to add elements, attributes, text, traverse up and down, run XPath queries, and read or write files via IO::Any, which makes tasks like generating sitemaps or simple XML transforms very straightforward. The module integrates XML::LibXML under the hood and includes conveniences such as a "-" attribute shortcut for element text, safe default parsing, namespace support, and selector-style methods for filtering and mapping nodes. Recent updates improved namespace handling, added functional helpers (map_selection and grep_selection) and per-element metadata storage with data(), made formatting non-destructive, and sped up internals for much better performance, so it is a good fit when you want expressive, easy XML construction and light DOM manipulation without low-level boilerplate.

App::DrivePlayer is a GTK3 desktop music player that streams audio files directly from your Google Drive while keeping a local SQLite library of scanned folders and tracks for fast browsing and playback. It can sync and share track metadata across devices using a Google Spreadsheet, fetch metadata automatically from services like AcoustID, MusicBrainz and iTunes, and optionally read embedded FLAC tags, all while performing long-running metadata work in the background so the UI stays responsive. Playback is handled via mpv and the interface offers folder-scoped browsing, live row updates as metadata arrives, editable metadata that can auto-sync to the sheet, and conveniences like an A–Z sidebar and a Year column with a new convention that extracts year prefixes from filenames or folders. Recent updates focus on safer, unified two-way sheet sync and merge behavior to avoid overwriting useful data, fixes to playback auto-advance and list scrolling, and other UI improvements that make syncing and streaming more reliable across intermittent network conditions.

Check::Term::Color is a tiny, single-purpose Perl module that decides whether your program should emit colored terminal output by examining environment variables. It provides check_term_color($env_hr) which returns true or false based on the current %ENV or on a hashref you pass for testing, honoring the NO_COLOR convention from no-color.org and recognizing COLOR settings like GNU's --color option. Use it to gate colored output in scripts and to make color behavior easy to test. The module is dependency-light and straightforward to drop into existing code. This is the initial 0.01 release.

Hash::Util::Pick is a tiny Perl utility for non-destructively extracting or removing entries from a hash reference and returning a new hash reference. It gives a simple API: pick and omit to copy or drop specific keys, and pick_by and omit_by to select or exclude entries using a user-supplied predicate. The module is useful when you need to create trimmed or sanitized versions of data structures without mutating the original, and its minimal, Lodash-inspired interface makes it easy to drop into scripts or larger applications. The code is lightweight, MIT licensed, and aimed at straightforward, readable hash transformations.

Text::Names::Abbreviate is a lightweight Perl module for turning full personal names into concise, configurable abbreviations. It understands both "First Middle Last" and "Last, First Middle" input forms and can emit several styles such as initials, compact (no punctuation), shortlast (initials followed by the full last name) and last-first ordering, with a customizable separator between initials. Single-word names are left unchanged and the routine will croak on missing, empty, or invalid parameters. Be aware that formats like compact and initials are lossy and initials are taken verbatim so punctuation or digits will be preserved. The 0.02 release tightens argument handling by using Params::Get, fixes edge cases (including correctly handling "0"), and adds fuzz testing and a more complete test suite.

Langertha is a Perl toolkit that gives you a single, consistent API for talking to many large language models and local inference servers, so you can switch between providers like OpenAI, Anthropic, Google Gemini, Ollama and others without rewriting your code. It supports chat, streaming, embeddings, transcription and image generation, exposes rich response metadata and rate limit info, and offers both synchronous and async usage patterns. Built-in features include automatic tool calling, a stateful autonomous agent called Raider with plugin support, dynamic model discovery and optional Langfuse observability. If you need a unified Perl layer to prototype or deploy LLM-driven features and agents across multiple providers this module is likely relevant, but be aware the API is a work in progress.

JSON::LINQ provides a LINQ-style, method-chained query API for working with JSON and JSONL files in Perl, letting you filter, project, group, sort and aggregate JSON data in a readable, fluent way. It brings the 60-method LINQ surface from LTSV::LINQ plus JSON-specific I/O helpers (FromJSON, FromJSONL, FromJSONString, ToJSON, ToJSONL) and boolean singletons JSON::LINQ::true and ::false, and supports streaming JSONL with O(1) memory while FromJSON loads a top-level array once and then iterates lazily. The module includes a pure-Perl built-in JSON encoder/decoder so no CPAN JSON module or XS is required and it even runs on very old Perls back to 5.005_03. The bundled parser has a few documented limitations such as no surrogate pair support, possible infinite recursion on circular references during encoding, and stringification of non-ARRAY/HASH references. This initial release is a convenient choice for querying, transforming and streaming JSON data in Perl, especially for log processing, ETL and quick data analysis without adding external dependencies.

LMDB_File is a Perl interface to the Lightning Memory-Mapped Database (LMDB) that lets Perl programs use a tiny, extremely fast embedded B-tree key/value store with full transactional semantics. It exposes LMDB concepts as Perl classes such as LMDB::Env to open an environment, LMDB::Txn for transactions, LMDB::Cursor for iteration and a convenience LMDB_File object that pairs a transaction with a database so you can use familiar put, get and delete calls or even tie a hash to a database for simple use. The module supports LMDB features like named databases, duplicate keys, custom key comparators, and a zero-copy read mode to avoid memory copies when you need maximum throughput. It also provides UTF-8 mode to automatically encode and decode text, configurable error handling, and a rich set of flags to tune durability and performance. Recent updates keep compatibility with modern Perl releases and add support for transaction identifiers and other maintenance fixes, so this module is a good choice if you need a lightweight, high-performance embedded database from Perl.

App::Raider is a compact CLI wrapper around Langertha::Raider that gives you an autonomous coding and system agent able to inspect a project tree, read and edit files, run bash commands, and fetch web content while being confined to a configurable project root. It ships with filesystem and shell tools, web search and fetch, automatic engine selection from *_API_KEY environment variables with sensible per-engine defaults, and flexible skill loading from Claude/OpenAI-style skill files or plain markdown directories. Configuration is straightforward via a .raider.yml file plus command line overrides and engine options, and the tool includes a REPL with persistent history, live trace and situation-injection plugins, on-the-fly skill documentation export, and session token reporting. The initial release emphasizes a small, practical toolbox and an almost unlimited tool-calling loop by default while exposing safety caps and tuning parameters for developers who want an interactive autonomous agent to explore, summarize, and modify repositories from the command line.

Mojolicious::Plugin::OpenAPI::Modern makes it easy to wire an OpenAPI::Modern document into a Mojolicious app so you can validate requests and responses against your OpenAPI schema. You register the plugin with a schema, a filename or URI for the document, or pass an existing OpenAPI::Modern object, and the plugin provides a shared openapi helper plus validate_request and validate_response helpers that return JSON::Schema::Modern::Result objects. You can also supply an after_response callback for post‑response checks or logging, and the plugin stores useful operation metadata under stash->{openapi} for controllers and templates. Matching is done from the request URI itself rather than Mojolicious route objects and the shared OpenAPI::Modern instance is reused across requests. Recent updates keep the plugin compatible with changes in the OpenAPI::Modern error handling and test behaviors.

SQL::Wizard is a Perl library for programmatically building SQL using composable expression trees so you can construct SELECT, INSERT, UPDATE, DELETE and compound queries as nested, immutable objects and only render SQL with placeholders and bind values when you call ->to_sql. It treats everything as an expression so columns, functions, CASE, subqueries, joins, window functions, CTEs and arithmetic can be nested naturally, it defaults to safe bind-parameterization and automatic identifier quoting to reduce injection risk, and it produces ANSI SQL by default with optional MySQL quoting. The API is designed for developers who want fine-grained control without hand-crafting SQL strings and it integrates with DBI by returning a SQL string and ordered bind values ready for execute. Note that recent releases introduced an important behavior change: as of 0.10 a hashref value that is an arrayref now generates OR conditions for each element rather than an IN list, so use the explicit -in form for IN clauses; 0.11 relaxed alias validation to allow dotted aliases in ->as().

LRU::Cache is a compact, C-backed Least Recently Used cache for Perl that delivers constant-time operations for common cache tasks. It stores key/value pairs up to a fixed capacity and automatically evicts the least recently used entry when space is needed. The module provides a simple object-oriented API for set, get, peek, exists, delete, size, capacity, clear, keys, oldest, and newest operations and also offers a function-style API you can import for even lower call overhead. The function-style calls avoid method dispatch and yield substantially higher throughput for get and set, making this a good choice when you need a fast in-memory LRU cache with minimal latency.

DBIx::Wizard is a lightweight, chainable database toolkit for Perl that sits between raw DBI and heavy ORMs like DBIx::Class. Point it at a DSN and table and you can build queries with a fluent API like ->find->sort->limit->all without defining schemas or result classes. It uses SQL::Wizard to generate safe, composable SQL expressions so you can use column and function expressions, joins, subqueries, window functions and arithmetic in queries. Rows come back as plain hashrefs and the module supports inserts, updates, deletes, aggregates, streaming cursors, automatic DateTime inflation with configurable classes, transactions with nested savepoints, and environment-driven database registration for twelve-factor style deployments. Debug logging is available via environment variables. If you want an ergonomic, minimal ORM for straightforward SQL work in Perl, DBIx::Wizard gives you fast, zero-configuration access to powerful SQL features.

Google::ProtocolBuffers::Dynamic is a Perl runtime that parses .proto definitions and produces fast, native Perl classes for encoding and decoding Protocol Buffer messages. It leverages Google"s C++ protobuf parser and the upb library to generate blessed-hash message objects with auto-generated accessors, supports JSON input and output, and can produce gRPC clients using Grpc::XS. You control how proto packages and messages map to Perl packages and can tune behavior for booleans, big integers, default encoding, map emulation and enum checking, and every mapped type exposes runtime introspection. The module also documents an ahead-of-time generator if you prefer precompiled code. Known limitations include partial proto3 coverage, discarded unknown fields on decode and occasional inconsistent handling of invalid field values.

Module::CoreList lets you discover which Perl modules and versions were bundled with each Perl release, either from a command line tool called corelist or from a simple programming API. You can ask when a module first appeared in core, whether a given module version is part of a particular Perl, which modules match a pattern, what changed between two Perl releases, and whether modules were deprecated or removed, and the module exposes data hashes with per-release module lists, release dates, deprecation info, upstreams and bug tracker pointers for automation. It is handy for packaging, compatibility checks, and deciding whether to rely on a core module or vendor a dependency. Coverage includes the main Perl 5 series with all stable releases since 5.6.0 and development releases since 5.9.0, and the module is maintained by the Perl 5 Porters.

CPAN::Perl::Releases is a compact, data-only module that maps Perl release numbers to the relative CPAN "authors/id/" paths where the release tarballs live. Its main function perl_tarballs($version) returns a hashref keyed by archive type like "tar.gz", "tar.bz2" or "tar.xz" with the corresponding authors/id path for that tarball, while perl_versions lists the supported release strings and perl_pumpkins returns the PAUSE IDs of Perl maintainers. The information is static but maintained and republished whenever new perl releases appear on CPAN, and it accounts for historical differences such as releases that lack certain archive formats or tarballs that have been removed. Recent updates include support for v5.43.10 and the removal of v5.41.10 from the data set.

MooseX::Params gives Perl subroutines and methods a clear, attribute-driven way to declare and validate parameters using a signature syntax, so you can write readable declarations like ":Args(Int x, :y = 'foo')" and access processed values via a read-only %_ hash instead of manually unpacking @_. It integrates with Moose type constraints and coercions, supports positional and named parameters, required and optional flags, slurpy rest arguments, simple defaults and lazy builders, plus hooks to preprocess arguments or run custom checks with BuildArgs and CheckArgs. It also offers basic return-value validation and a small set of options to control scalar versus list return behavior, and it provides a concise invocant notation for methods. The module is experimental and actively limited in testing and performance, so expect some rough edges and possible incompatibilities, but if you use Moose types and want more declarative, self-documenting parameter handling it can significantly simplify your argument processing.

Lemonldap::NG::Portal is the authentication portal component of the Lemonldap::NG Web-SSO system that lets you protect web applications with minimal changes. It is a PSGI/Plack-compatible portal that manages authentication, authorization and accounting headers so you get full AAA coverage for a web space. The portal is modular and loads authentication backends, user databases and other features as plugins at configuration reload, provides JSON responses for AJAX and template rendering for normal requests, and exposes a clear API for writing custom plugins. Configuration is centralized and treated as read-only at runtime and plugin initialization failures will cause requests to return a 500 error, so it is best suited to projects that need a flexible, extensible single sign-on gateway integrated into a PSGI deployment.

Lemonldap::NG::Handler is the Apache protection module for the Lemonldap::NG Web Single Sign‑On system that enforces access control and session management at the web server level. It is provided as an alias to Lemonldap::NG::Handler::ApacheMP2 and supplies Apache handlers to protect web applications, integrate with centralized Lemonldap policies, handle logouts and session sharing, and support CGI and proxy scenarios. Over its lifecycle it has gained features like shared configuration, cross‑domain authentication, custom functions and improved virtual host handling. Recent updates added POST-based login for nonstandard clients, moved basic authentication to a SOAP backend, improved logging through PerlLogHandler and introduced a double-session option for better session isolation. Choose this module when you need an Apache-integrated SSO protection layer that works with the Lemonldap::NG ecosystem.

Lemonldap::NG::Common is a support library that bundles shared functionality used across the Lemonldap::NG Web single sign-on suite, providing the building blocks for its Manager, Portal and Handler components. It is not an application itself but supplies common utilities such as SOAP and WSDL helpers, logging and syslog wrappers, session and configuration storage backends (including LDAP support), a Crypt object for configuration, and small helpers like setApacheUser and a safe library for custom rules. If you are deploying or extending Lemonldap::NG this module is where reusable infrastructure code lives, so it is relevant when you need consistent logging, session handling, remote API support or central configuration for the suite. Recent releases added SOAP/WSDL tooling, improved logging wrappers and LDAP storage, reflecting its role as a consolidation point for shared features.

Mojo::DOM::Role::Style is a lightweight role that adds a convenient style() method to Mojo::DOM elements for reading and manipulating an element's inline CSS. Calling style with no arguments returns a Style::Value object that stringifies to the CSS text and can be used like a hash to read individual properties, while calling it with a single property name returns that property's value. You can replace the whole style by passing a raw CSS string or an even length list of property/value pairs, merge new properties by passing a hash reference, or remove the style attribute by passing undef. Setter calls return the element for method chaining which makes it handy in DOM transformations, scraping, or server side HTML generation. If you work with Mojo::DOM and need simple programmatic control over inline styles this role makes those operations concise and predictable.

Git::Server is a drop‑in replacement for a plain Git SSH server that gives repository hosts far more control over access and automation by adding granular ACLs, richer server hooks and built‑in deployment and webhook features. It is aimed at sysadmins and teams who want to enforce fine‑grained rules such as read/write restrictions, restricted branches and files, IP or author‑email whitelists, push‑force protections and automatic post‑push deployment or notification workflows without adding heavy external tooling. The distribution also includes helper tools like a git-client wrapper and git-deploy, supports proxy syncing to external remotes and provides configurable webhook callbacks for push and pull events. The project is actively maintained on GitHub and recent updates have improved proxy syncing reliability and caching of remote failures, fixed identity and portability issues for git-deploy, added webhookcallback.cgi support and tightened various security and compatibility behaviors, so it is a good fit if you need a more policy‑driven, hookable Git server than stock git-shell.