CPANscan

Test::IsAny supplies a tiny testing helper called is_any that lets you assert that a scalar result matches any value in a supplied list and integrates directly with Test::More. It is intended primarily as a teaching example showing how to write your own test function, so it is intentionally lightweight and easy to read rather than a full-featured matcher framework. Use it when you want a simple, readable way to check that a result is one of several acceptable values in your unit tests.

WWW::OpenBao is a compact Perl HTTP client for OpenBao and HashiCorp Vault that gives application code a straightforward way to talk to Vault's KV v2 secrets engine and a few basic sys endpoints. It supports reading, writing, listing and deleting KV v2 secrets, checking metadata existence, Kubernetes ServiceAccount login (it will store the returned token), and simple sys helpers like health, init, unseal and enable_engine. The module intentionally stays minimal with no caching, lease renewal or policy management, so it is a good fit if you just need to perform day-to-day secret operations from Perl rather than full Vault administration. Configure it with an endpoint, token and a KV mount (defaults to "secret"), and note that most methods croak on non-2xx responses while read_secret returns undef on a 404 to make "not found" easy to handle. This initial release was extracted from HI::Daemon and focuses on providing a tiny, pragmatic client surface.

Module::Generic is a highly practical base class for building Perl objects quickly by providing a large toolbox of ready made helpers for common tasks such as automatic getters and setters, typed accessors for numbers, booleans, datetimes, UUIDs, IPs, URIs, files and more, dynamic class and method generation via create_class, and an AUTOLOAD that maps hash keys to methods. It includes utilities for serialization and deserialization using CBOR, Sereal, Storable or JSON when those modules are installed, portable error and exception handling that prefers returning errors over dying, flexible logging and colored terminal output with TTY awareness, and a suite of object construction helpers that make nested objects and arrays easy to declare and use. Performance sensitive routines are implemented in XS when available with transparent pure Perl fallbacks so you can install without a C compiler, and the distribution also contains null objects and helpers to keep method chaining safe on error. The module aims to speed development and enforce consistent patterns, and it is conscious of threaded and mod_perl environments with global storage safeguards, however some dynamic features such as runtime symbol injection and on the fly class creation are not safe to use after threads are started so they should be performed at initialization time. If you want a single, feature rich superclass to avoid writing repetitive accessor and serialization code and to rapidly prototype structured object APIs, Module::Generic is likely to be very useful.

JQ::Lite is a pure-Perl, jq-compatible JSON query engine that gives you familiar jq-style filters and helpers without needing the jq binary or any XS compilation, making it ideal for minimal containers, CI systems, restricted servers, or air-gapped environments. You can traverse and transform JSON with dot-notation, safe optional access, array indexing and flattening, boolean filters like select(), pipe-style chaining, map/reduce/foreach helpers, and a large library of jq-like built-ins for strings, arrays, objects, and statistics, and it ships with a jq-lite CLI and an interactive REPL. The module is usable as a library via JQ::Lite->new and run_query($json, $filter), defaults to core JSON::PP but can opt into faster JSON XS modules, and exposes CLI options for decoder selection, debug logging, and function listings. If you need jq-style querying where installing native binaries is not possible, this module gives a compatible, well-tested alternative in pure Perl with stable CLI packaging. The latest 2.44 release mainly refactors path traversal helpers to centralize array index normalization and bumps the version.

RT::Extension::FormTools is an add-on for Request Tracker that lets administrators build multi-page, wizard-style ticket creation forms using a browser-based drag-and-drop UI, so users can submit structured tickets without custom coding. You pick the target queue and available custom fields, add core fields or freeform HTML blocks, and include non-persistent ShowQuestion controls to drive conditional display or requirements. The extension supports alternate routing to different queues based on form answers, optional grouping of forms, per-user and per-group visibility rights, and simple JSON export/import for moving forms between systems. Forms created with FormTools appear in RT's main and self-service interfaces and will create normal tickets, and the package also exposes Mason components and helper functions for developers who need to extend or embed forms. It is maintained by Best Practical, works with RT 6 and newer, and is distributed under the GNU GPL v2.

MCP::Run is a small base class for building MCP servers that expose a "run" tool so remote clients can execute shell commands and receive exit code, stdout, and stderr in a standardized MCP response. Subclasses implement an execute method to run the command and the base class handles tool registration, per-call overrides for working directory and timeout, optional command whitelisting, and customizable result formatting. The distribution includes a ready-made MCP::Run::Bash implementation, a Compress helper that runs a filter pipeline to trim and compress noisy command output for LLM efficiency, and convenience entry points for running as a stdio tool or installing command hooks. Recent work adds a Docker image for the compression tool so the Claude Code hook can be installed and used without a local Perl toolchain, with environment variables to select native or docker mode and to override the image, making it easy to enable output compression in environments that lack a Perl runtime.

YAML::PP is a modern, modular YAML processor for Perl that aims to fully support the YAML 1.2 spec while also offering YAML 1.1 compatibility, letting you load and dump YAML streams with one or more documents and choose schemas like Core, JSON or Failsafe. It is schema aware so it resolves types such as booleans and numbers in a standards-compliant way, can serialize Perl-specific types via a Perl schema, and offers options for handling cyclic references, duplicate keys and document headers, plus experimental preservation of key order, scalar styles and flow styles. The module exposes a friendly API and drop-in Load/Dump functions for scripts, includes utility CLI tools for debugging and highlighting, and supports plugins including a libyaml-backed parser for better performance. YAML::PP emphasizes correctness and interoperability with other languages, but the author notes that some inner APIs and preservation features remain experimental, a few rare YAML syntax cases are not yet supported, and it is generally slower than XS-based bindings.

Business::ISBN::Data is a companion data module for Business::ISBN that supplies the ISBN group and prefix ranges published by the ISBN Agency in RangeMessage.xml so your application can validate and classify ISBNs without parsing that file yourself. Business::ISBN will load this module automatically and it includes a bundled RangeMessage.xml and a built-in fallback dataset, but you can point to a different RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or placing the file in the current directory; note you must use Business::ISBN 3.005 or later because the data structure changed to address an ISBN-13 issue. The package includes tooling and instructions for regenerating the embedded data from the official RangeMessage.xml and the source is on GitHub so you can update or contribute newer range data when accuracy is important.

HTTP::Promise is a Perl client library that makes true asynchronous HTTP requests by forking and using Promise::Me, returning promise objects you can chain with then and catch or resolve synchronously if you prefer. It supports all common HTTP methods and features like redirects, cookie jar integration, configurable SSL options, and sensible header handling while streaming large request or response bodies to memory or temporary files so you can work with very large payloads without blowing memory. The module provides helpers to build form-encoded and multipart requests, automatic content encoding negotiation, threshold and max size controls, and utilities such as prepare, simple_request, mirror, fetch, and promise combinators like all and race. It is optimized for performance with XS components, implements robust parsing and multipart support, reports errors as HTTP::Promise::Exception objects, and is thread-safe, so it is a good fit for applications that need high-throughput nonblocking HTTP interactions in Perl.

Changes is a Perl module for reading and updating "Changes" or "CHANGES" files that hold release notes and changelogs. It lets you parse an existing file or string, add, edit or remove releases and individual change lines, and write the result back to disk while preserving the original formatting of any sections you do not modify. You can customize date formatting, time zone, line wrapping, and other defaults or provide your own wrapper callback for text formatting. Errors are returned as objects rather than causing the program to die. This module is useful for module authors, packagers, and automation scripts that need reliable, programmatic editing of change logs for CPAN or other distributions without wrecking the file layout.

Parse::LocalDistribution scans a local Perl distribution directory and reports what packages and versions it "provides" in a PAUSE-compatible way, returning a hashref of provides metadata constructed from .pm files and any META file found. It is essentially the PAUSE parsing logic repackaged for local use so it is the tool of choice when you need results that match PAUSE behavior rather than the more general or safer Module::Metadata output. You can configure it to include developer underscore versions, enable verbose output or forking, apply PAUSE permission checks, or supply pre-parsed META_CONTENT to avoid re-reading META files. It does not extract distributions and is not intended as a high-performance replacement for Module::Metadata, but recent updates added the META_CONTENT option to skip reevaluation and now ignore META files that are symlinks to better match PAUSE.

DateTime::Format::Lite is a compact parser and formatter that uses strptime-style patterns to convert between text and DateTime::Lite objects. It is built as a lightweight alternative for projects that use DateTime::Lite, avoiding heavy dependencies while still supporting locale-aware tokens, ISO 8601 durations, and duration formatting. Timezone abbreviations are resolved dynamically against up-to-date IANA tzdata via the bundled DateTime::Lite::TimeZone database, and common parsing and formatting paths are XS-accelerated when a C compiler is available. The module exposes a flexible constructor with options for locale, time zone, strict matching, abbreviation overrides, and error-handling modes, and it also provides convenience strptime/strftime functions that die on error. Serialization hooks for Storable, Sereal, CBOR::XS, and JSON make it easy to persist formatter state. If you need a small, dependency-light strptime-style formatter that integrates with the DateTime::Lite ecosystem and keeps timezone resolution current, this module is a good fit.

App::perlimports is a small command line tool that helps Perl developers tidy and maintain import statements by making implicit imports explicit. The perlimports command scans your code and automates the cleanup of use and import lines so you can see exactly which symbols each module brings into a package, which makes refactoring safer and code easier to audit. It is aimed at anyone maintaining or modernizing Perl code who wants an automated way to keep import lists clear and consistent.

Perl::Version::Bumper is a maintenance utility that updates Perl source to declare a newer "use VERSION" and tidies up the related feature pragmas and compatibility modules so your code reflects the semantics of the target Perl release. It can operate on strings of code, files in place, or PPI::Document objects and provides safe variants that try to compile the bumped code and step the version down to the highest compatible release when a direct upgrade would break things. The constructor validates and normalizes target versions and will only raise an existing declaration, and the module also exposes helpers for formatting and computing stable version boundaries. When bumping it will remove or adjust "use feature", "no feature" and "use experimental" lines and replace legacy compatibility CPAN modules when the feature bundle makes them unnecessary, with special handling for constructs like signatures, bitwise changes, fc and apostrophe package separators. Recent releases added support for the 5.042 feature bundle and improved detection of lexically enabled or disabled features plus more accurate code edits for fc, bitwise, signatures and apostrophe_as_package_separator, making it more reliable for modern Perl upgrades.

Alien::cmake4 is an Alien distribution that makes the CMake 4.x build tool available to Perl builds by finding a system installation or downloading and installing a binary or building from source when necessary. It exposes simple helpers so you can add the CMake bin directory to PATH and get the executable name for invoking CMake from Perl code, and it integrates with the Alien::Build ecosystem for automated dependency management. By default it will try a binary share install on common platforms like Windows, macOS and mainstream Linux and will fall back to a source build on other systems, and you can control behavior with the ALIEN_INSTALL_TYPE environment variable or force a source build with ALIEN_CMAKE_FROM_SOURCE. This is useful if your project or an Alien plugin requires a consistent CMake 4.x runtime across machines or CI, and it aims to be the preferred, up to date way to supply CMake to Perl-based build workflows.

SPVM is a statically typed programming language that uses a Perl-like syntax to give Perl programmers a familiar look and feel while adding static typing and performance features. It supports ahead-of-time and just-in-time compilation, can produce standalone executables, and exposes C and C++ bindings so you can integrate native libraries. You can call SPVM methods directly from Perl and reuse many Perl standard functions and modules, and the language includes features such as native threads, goroutines, type inference and static analysis to help build high performance software. The project is still pre-1.0 and does not yet promise backward compatibility, but documentation, tutorials and examples are available on GitHub for learning and adoption.

YAML::LibYAML is a Perl interface to the libyaml C library that gives you fast, reliable YAML parsing and serialization through an XS binding. The CPAN distribution is called YAML-LibYAML but the module is available and documented as YAML::XS, so check YAML::XS for usage details and examples. Written by Ingy and released under the same license as Perl, this module is a good choice when you need efficient YAML input and output in Perl applications.

Time::Moment is an immutable Perl class for representing an ISO 8601 date and time with an offset from UTC and nanosecond resolution across the range 0001-01-01 to 9999-12-31. It provides multiple constructors (new, now, now_utc, from_epoch, from_string, from_rd/jd/mjd and from_object), rich accessors and "with_" modifiers for every component, calendar-aware arithmetic and delta calculations, precision trimming, ISO-style parsing and strftime-style formatting, and built‑in serializers for Storable, JSON, CBOR and Sereal. The module is thread safe, interoperates with DateTime and Time::Piece for time zone handling, and explicitly does not account for leap seconds so each day is treated as exactly 86,400 seconds. Recent fixes include normalization of edge-case fractional seconds when creating from floating epoch values and a Year 2038 safety fix in now() by switching to 64-bit second calculations, making it robust for high-precision and long-range date/time work.

DateTime::Format::JP is a lightweight Perl formatter and parser for Japanese dates and times that makes it easy to read and print dates in Japanese styles, including era names, kanji numerals, full- and half-width digits, and a traditional time wording option. It offers two core methods, parse_datetime and format_datetime, accepts or returns decoded UTF‑8 strings, and uses a strftime-like pattern system with tokens for common Japanese formats such as era (%E), era year (%y), standard date/time (%c, %x, %X) and full Gregorian dates (%F). The module also provides helpers to convert between kanji, roman and zenkaku digits and to look up or select Japanese era objects, and it integrates with DateTime or DateTime::Lite so you can set it as a formatter for stringification. If you need to present or accept Japanese-formatted dates in a Perl program this module is a compact, purpose-built choice, and as of v0.1.7 the distribution now depends on DateTime::Lite.

Geo::IP2Proxy is a pure-Perl library for doing fast reverse lookups of IP addresses against IP2Proxy BIN databases to detect VPNs, open and web proxies, Tor exit nodes, search engine robots, data center ranges, residential proxies and other privacy or enterprise networks while returning useful metadata like proxy type, country, region, city, ISP, domain, usage type, ASN and AS name, threat tags, provider name and a numerical fraud score. It works from a local BIN file so you can open the database and call simple methods such as isProxy, getProxyType or getAll to get a one-shot report for IPv4 or IPv6 addresses. The underlying IP2Proxy database is updated daily and full datasets require a subscription, though IP2Proxy publishes sample BIN files and a limited free monthly LITE database for basic open-proxy detection. If you need to gate access, reduce fraud risk or add proxy-aware logic to authentication and logging flows, this module provides a lightweight, dependency-free way to integrate that intelligence into Perl applications.

Text::Treesitter::Bash is a Perl helper that uses the Text::Treesitter infrastructure to parse Bash sources and pull out the executable commands and call sites you care about, making it easy to locate what a shell script will actually run. It ships with the tree-sitter-bash 0.20.5 grammar and includes a built-in Security::Checker that flags common issues such as path traversal, dangerous flags, sensitive file access, risky environment variables, unquoted expansions, and missing absolute paths. If you need to build static analysis, linters, audit tools, or automation that reasons about shell behavior from Perl, this module gives you a focused, ready-made way to extract commands and surface likely security problems. This is the initial release and is intended to be extended and contributed to on its public repository.

Plack::Middleware::BlockHeaderInjection is a lightweight Plack middleware that defends PSGI applications from HTTP header injection by scanning response headers for disallowed control characters (ASCII 0-31), removing any offending headers and returning an error status (500 by default) when a problem is detected. It is especially useful if your app builds headers from user input, for example redirection locations or cookie values, and helps prevent attackers from forging headers such as referrer or cookie to bypass security checks. Configuration is minimal — you can change the status code returned — and the module requires Perl 5.24 or later.

Hash::SharedMem provides a fast, file-backed key/value store that multiple processes on the same host can map into memory and update without blocking one another, presenting an interface much like a Perl hash but restricted to octet (Latin-1) strings for keys and values and allowing complex structures only if you serialize them first (for example with Sereal). It stores its data in a directory of files that are mmap(2)-ed so readers and writers share memory and you get persistence while the OS is up, atomic single-key operations including an atomic compare-and-set, and snapshot handles that give a stable read-only view of the hash state. The module includes utilities to open handles with read/write control, enumerate keys or the whole hash, query sizes and counts, perform maintenance (idle and tidy) to limit resource use, and read per-handle event tallies for profiling. It is optimized for workloads where the whole dataset fits in RAM and will suffer if the filesystem is swapping heavily, and creation and on-disk consistency across OS crashes are not fully transactional so you should be cautious about ownership, permissions, and copying while writers are active. Recent releases mainly improve compatibility with newer Perl releases, refine behavior of tied-hash operations and counters, and include various robustness and test-suite enhancements.

Net::LibIDN2 is a Perl wrapper around the GNU libidn2 C library that makes it easy to handle internationalized domain names (IDNA2008), Punycode and TR46 rules from Perl code. It provides simple functions to convert domain names and labels between UTF-8, the local charset and ACE/Punycode, perform lookup and register-style conversions, and to decode ACE-encoded names back to Unicode. The module exposes flags for NFC normalization and TR46 transitional or non-transitional processing, returns libidn2 result codes for detailed error handling, and includes helpers to translate those codes to readable messages. If your application needs reliable IDN conversion or validation in line with modern IDNA standards this module is directly relevant, but note it requires the libidn2 library to be available at runtime and offers a version-check function to detect compatibility.

CPAN::Maker is a command-line tool and small toolchain for turning a Perl project into a CPAN-style distribution by locating your modules, scripts and tests, resolving dependencies, generating a Makefile.PL and assembling a tarball ready for upload. It prefers a YAML buildspec that describes paths, dependency files, extra files and metadata and can run the supplied make-cpan-dist bash wrapper to clone git repos, run dependency scanners (scandeps or Module::ScanDeps::Static), copy test and executable files and build the final tarball, while direct invocation will at minimum emit a Makefile.PL for you to tweak. The tool supports fine-grained options for dependency lists, min Perl version, inclusion of extra files, and logging, and environment variables let you preserve the generated Makefile.PL, skip tests or enable debug output for troubleshooting. In the recent 1.8.0 release the utility gained support for creating man-links so executables can point to a module's man page and fixed how script man pages are generated, making it a good fit if you want a repeatable, configurable way to prepare and package Perl modules for CPAN.

DateTime::Lite is a lightweight, drop-in replacement for DateTime that gives you the same public API while trimming dependencies and improving some performance and memory characteristics. It keeps accurate timezone handling by reading TZif binaries compiled with the official zic tool and storing zone data in a bundled SQLite database, offers an XS-accelerated core for the CPU-heavy calendar math, and supports full Unicode CLDR and BCP 47 locale tags so you can use complex locale strings and even infer an IANA zone from a "-u-tz-" extension. Error handling follows a no-die philosophy by returning exception objects and undef on failure, and the TimeZone subsystem includes optional process-level caching and GPS coordinate or abbreviation resolution for convenient timezone lookups. If you need a faster, lower-dependency DateTime replacement for scripts, CLIs, or services that still require correct DST and leap-second behavior, DateTime::Lite is a strong choice. The recent v0.6.4 update refreshes the bundled IANA data, adds an extended option that lets TimeZone->new accept common abbreviations like JST or EST and allows passing a hashref to new()/set_time_zone() for advanced options, and includes thread-safety and correctness fixes for tricky DST edge cases.

Astro::SpaceTrack is a Perl client for fetching orbital element sets and related satellite data from Space‑Track.org and several public repositories such as Celestrak and Mike McCants' site, letting you retrieve TLEs, catalog/search results, box scores and other satellite lists programmatically or from an interactive shell. It wraps requests in HTTP::Response objects, supports JSON and legacy TLE formats, can read credentials from an identity file or environment variables, and offers convenience features like local caching and an included SpaceTrack command script. Note that a registered Space Track username is required for most Space Track queries and usage should be throttled (daily or at most every few hours is usually sufficient). Version 0.180 was an emergency update to restore operation after Space Track removed the old 'tle' and 'tle_latest' classes; it now uses the newer 'gp' and 'gp_history' classes but also documents a few current limitations such as the deprecated --last5 option, the removal of the OBJECT_NUMBER datum (use NORAD_CAT_ID), and some Space‑Track favorites that were reported 404.

Developer::Dashboard provides a single local home for day-to-day development by combining a lightweight browser UI, shell prompt integration, and a CLI that share the same runtime state. It lets you keep bookmark-style pages, notes, and executable helpers in one place, run repeatable collectors that cache command output for cheap live indicators, and surface those indicators in both the web UI and your prompt so health checks and status are fast and consistent. The distribution also includes file-opening helpers that understand Perl modules and Java classes, small data-query tools for JSON, YAML, TOML and properties, and a project-aware Docker Compose resolver, while layered runtime roots let project-local ./.developer-dashboard overrides sit above a shared ~/.developer-dashboard fallback. It is written in Perl but is language-agnostic in practice, installs via cpanm or the provided install script, and is extensible through isolated skills and user CLI hooks. The runtime is file-backed, shipped with sensible defaults and owner-only file permissions, and transient browser execution of arbitrary token payloads is disabled by default unless you opt in.

DateTime::TimeZone is the DateTime ecosystem's central time zone factory and base class that provides named and offset-based time zone objects you can use to get correct UTC offsets, Daylight Saving flags, and short display names for specific datetimes. It is mainly used through DateTime rather than directly, but it handles the heavy lifting of historical and future zone rules, floating and UTC zones, local zone detection on many platforms, and utilities for validating and listing IANA/Olson names and zones by country. The module includes helpers to convert between human offset strings and seconds, integrates with Storable to avoid bloating serialized data, and documents platform-specific addons for better local-zone detection on Windows and HPUX. If you run a pre-forking server it is a good idea to load needed zones in the parent process to save memory. This release follows the IANA/Olson 2026b database and includes up-to-date changes affecting British Columbia, Canada.

TOON::XS is a fast, XS (C) implementation of the TOON data format for Perl that handles both line-style and brace-style syntaxes and provides both functional and object oriented APIs for encoding, decoding, and validating Perl data structures. It exposes dedicated functions like encode_line_toon/decode_line_toon and encode_brace_toon/decode_brace_toon plus generic encode_toon/decode_toon that require an explicit syntax parameter, and it also offers a TOON::XS->new(...) object with persistent options such as syntax, pretty, canonical and indent along with setter methods for convenient reuse. The module focuses on performance and benchmarks show large speedups over pure-Perl TOON and Data::TOON, particularly for decoding, while only requiring Perl 5.10. Decoders will throw on invalid input and validators return boolean results, and the current release is the initial 0.001 publication.