CPANscan

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.

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.

App::MARC::Filter is a lightweight Perl application class that powers a command line tool for selecting and emitting MARC bibliographic records. You create an instance with new and call run to read MARCXML, USMARC or compressed MARC inputs and filter records by leader, control fields, data fields and subfields or by material type, with options for invert matching, limiting output count and verbose or ASCII output. It is aimed at developers and catalogers who need a simple programmable filter for MARC data rather than a full MARC toolkit. Recent releases added support for compressed input files and improved detection of XML input files.

Time::OlsonTZ::Data packages a specific release of the Olson/IANA timezone database for Perl so you can ship and query authoritative timezone data without relying on the host system files. It exposes the database version, lists of canonical zone names and aliases, a mapping of alias-to-canonical names, a country-to-region map to help users pick a geographic timezone, and a function that returns the pathname of the compiled binary tzfile for any named zone. The module is meant to be updated regularly to follow real-world rule changes, so you should refresh installs from CPAN to stay current, and be aware that long-running programs may see tzfiles change if the module is updated while they run.

FB3::Convert is a small Perl toolkit from Litres.ru that supplies both ready-to-run scripts and a programming API for converting FB3 electronic book files to and from other formats. If you work with FB3 ebooks and need a straightforward way to automate format conversions or to embed conversion logic in a Perl application, this module gives you that capability without forcing you to reimplement parsing or export routines. It is distributed as free software under the GNU Lesser General Public License version 3 and comes with the usual no-warranty terms.

Test::Smoke is a utility for automating the Perl core "smoke" testing workflow, letting you configure, build, and run the core test suite across multiple build configurations and platforms. It exports a configuration variable and a read_config helper by default and provides convenient high level routines to prepare a build environment, run the smoke runs, perform MANIFEST checks against the source tree, detect Windows builds, and mark patchlevels as smoke-tested. The module is aimed at core developers and release engineers or anyone who needs repeatable, automated testing of different Perl builds. It is free software distributed under the same terms as Perl.

FastGlob provides a pure-Perl implementation of filename globbing that you can export as glob to replace Perl's built-in glob. Because it avoids forking a csh it runs faster and is more robust on systems where a shell-based glob can fail with very large directories. It auto-detects platform conventions and exposes a few module variables you can adjust such as $FastGlob::dirsep, $FastGlob::rootpat, $FastGlob::curdir, $FastGlob::parentdir and $FastGlob::hidedotfiles so you can adapt behavior for Windows, Unix or classic Mac OS. Tilde expansion uses the system password database on Unix and falls back to HOME or USERPROFILE on Windows. If you want a lightweight, configurable, drop-in glob replacement that avoids spawning a shell, FastGlob is a practical choice.

PPI is a Perl library for parsing Perl source as a document rather than executing it, so you can safely read, analyze and transform code without running it. It tokenizes files and builds a Perl Document Object Model that preserves whitespace, comments and POD so modifications can be made and written back exactly as they were, making it ideal for tasks like documentation extraction, static analysis, automated refactoring, code formatting and tools such as Perl::Critic. The module is pure Perl, widely used and available on CPAN and GitHub, and exposes a rich API for querying and manipulating statements, structures and tokens. There are some limits you should know about: PPI does not attempt to fully parse Perl as running code so constructs that rely on runtime or external context, source filters or certain lexical extensions can confuse it, and Unicode support is limited to Latin-1. Performance can be slower on very large files, though an XS accelerator exists as a work-in-progress. If you need to inspect or change Perl source safely without executing it, PPI is a mature and practical choice.