CPANscan

App::CdUtils is a small collection of command line helpers that make navigating the filesystem from your shell easier. It provides backend programs such as cdtree-backend, cdtarget-backend, cdsibling-backend, cdnextsibling-backend, cdprevsibling-backend and cdpart-backend that are meant to be wired into shell scripts or cd wrappers so you can jump to parent path parts, find directory targets, move to sibling directories or step to the next or previous sibling without typing long paths. The tools are lightweight, intended for integration with custom shell tooling, and the distribution is available on CPAN with source hosted on GitHub.

SPVM::Sys is a comprehensive, cross-platform system-call wrapper that exposes low-level OS services to SPVM programs, including file and directory operations, buffered and unbuffered I/O, sockets and networking, time and timer utilities, process control and signals, and user/group lookups. It packages familiar primitives like open/sysopen, read/write, stat/lstat, mkdir/rmdir, socket/connect/listen/accept, select/ioctl, fork/exec, wait/waitpid, env manipulation, and many POSIX-style file tests into a single, consistent API and provides helper classes for streams, dir handles, socket addresses, time structs, constants, and errno handling. The module emphasizes portability and Windows Unicode support by automatically converting between UTF-8 and wide strings and includes many platform-specific fixes and fallbacks so the same code works on Linux, macOS, and Windows. If you need system-level control from SPVM or are porting Perl-style system code to SPVM, SPVM::Sys gives you a ready-made, tested interface; recent releases notably improved Windows support by adding waitpid on Windows, a nonblocking spawnvp_nowait helper, and updated networking helpers that use inet_pton for address handling.

Algorithm::Classifier::IsolationForest provides an easy-to-use implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection on numerical datasets. It builds an ensemble of random isolation trees and scores points by their average isolation depth so that outliers are isolated quickly and receive high scores near 1 while normal points score well below 0.5. You can choose classic axis-aligned splits or extended oblique hyperplane splits to reduce axis bias, and tune ensemble size, sample size, tree depth, random seed, and an optional contamination parameter so the model can learn a threshold for flagging anomalies. The module exposes fit, score_samples, predict and path_lengths helpers and supports JSON save/load for model persistence and reproducible results, making it a practical choice for detecting outliers in exploratory data analysis, monitoring, and preprocessing pipelines.

Net::IMAP::Client is a Perl library that gives you a simple, scriptable API for talking to IMAP servers while doing rigorous parsing of server responses so you get useful Perl data structures rather than raw text. It supports plain or TLS/SSL connections, UID mode, SEARCH and SORT, fast multi‑folder STATUS queries, folder listing and management, fetching message summaries (parsed into Net::IMAP::Client::MsgSummary objects), downloading full RFC822 bodies or individual MIME parts as scalar references for efficiency, flag management, copy/append/expunge operations, threading and server notifications. The module returns undef on failure and exposes last_error for diagnostics, and it deliberately returns message data undecoded so you can decode attachments or transfer encodings with Email::MIME::Encodings or similar. Note that only cleartext login is supported out of the box and the author lists stronger authentication schemes as a TODO item. Recent maintenance updated the IMAP atom parsing to better match RFC3501 and fix a parsing bug, making the client more robust with a wider range of servers.

App::karr is the core library behind karr, a Git-native kanban tool that keeps tasks as Markdown payloads and board configuration as sparse YAML stored in Git refs under refs/karr, so your repository remains the single source of truth without introducing a persistent board tree or file-level merge conflicts. It powers the karr CLI, which materializes a temporary board view for each command and then writes changes back into refs, and it exposes lower-level modules for programmatic access when you need to automate or inspect board state from Perl. The project includes a first-class Docker runtime for easy embedding in other environments and supports common workflows like creating, listing, claiming, and snapshotting tasks from the command line or from scripts. If you want a lightweight, Git-centric way to track work where history and synchronization are handled by Git itself, this module and its CLI are a good fit. Recent releases improved the karr-foundation runner to stream agent output to the terminal, made the foundation a multi-board coordinator, introduced role-qualified activity logs to separate human and agent actions, and added usability enhancements to commands such as show and board while surfacing clearer Git errors during sync.

Module::Extract::VERSION is a small utility for safely pulling the $VERSION out of a Perl module source file without running the module itself, so it is useful for packaging, indexing, or automation tools that need to know a module version. You give it a file and it finds the single $VERSION line, extracts and evaluates the value in a Safe compartment, and returns either the version string or, in list context, extra details such as the sigil, fully qualified variable name, version value, file name and line number. It assumes there is only one $VERSION declaration in the file and that the declaration is all on one line, and recent updates add compatibility for older qv() syntax from version.pm so more version formats are recognized.

Syntax::Infix::EqualityInsensitive adds two lexically scoped infix operators, eqi and nei, so you can write case-insensitive string comparisons that use proper Unicode case folding rather than ASCII lowercasing. Use if ($input eqi 'yes') to match YES, Yes, yes, and odd Unicode cases like the German sharp-s with correct behavior. The operators live at relational precedence alongside eq and ne, are non-associative, and compile down to custom BINOPs via Infix::Custom for efficient runtime behavior. They only affect the file or block that uses the module and can be undone with no Syntax::Infix::EqualityInsensitive. Note that the module requires Perl 5.38 or newer.

Identifier::PL::PESEL is a compact Perl module for validating Polish PESEL national identification numbers. It provides a simple object interface: instantiate with new and call validate($number) to receive 1 for a valid PESEL or undef for an invalid one, and validate will Carp::confess if you omit the argument. The module is intentionally lightweight and focused on format and checksum checking, making it a good choice when you need a minimal, dependency-free way to verify Polish IDs. The 0.3 release only updates package metadata.

Finance::Quote is a Perl toolkit for fetching stock, mutual fund and bond quotes from a wide range of internet sources and exchanges, exposing a simple object API where you create a quoter, call fetch with one or more methods and symbols, and receive a hash keyed by symbol and label (price, bid, volume, date, currency and many other fields). It bundles many exchange‑specific modules, supports configurable timeouts, optional failover between providers, and on‑the‑fly currency conversion via pluggable CurrencyRates modules (some require API keys), and it includes handy utilities for parsing dates, CSVs and scaled numeric values. The module is actively maintained to adapt scrapers and add API sources, most recently adding a Finnhub backend for API-based quotes and updating Google Finance parsing while introducing additional currency rate providers. You can install it from CPAN, it respects your HTTP proxy settings, and a small anonymous usage counter is enabled by default but can be disabled with the FQ_NOCOUNT environment variable.

Amazon::API is a lightweight, generic Perl base class for invoking AWS services that you can use directly for ad hoc requests or as the parent for service-specific modules generated from Botocore metadata with the included amazon-api tool. It handles credential discovery and signing, negotiates content types, decodes JSON or XML responses, supports pagination, and provides helpers for formatting complex AWS request shapes so you can build small, focused clients without pulling in a full SDK. If you use it raw you should be familiar with the target AWS API because some services have protocol quirks, and the author notes S3 is better served by dedicated modules or Paws for broad coverage. The project is mature and production ready for many services and recent 2.2.x updates improved Botocore-based serialization and fixed several payload edge cases including rest-xml and map/list serialization and an uninitialized payload error.

CPANSA::DB provides the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single method, db, which returns a hashref of all advisory reports so you can programmatically inspect, audit, or integrate CPAN security information. The module is primarily consumed by CPAN::Audit but can be used by any tool that needs the advisories. Each release includes a GPG signature and a GitHub attestation so you can verify the archive came from the official repository, and a JSON export of the same data is available if you prefer non-Perl formats. If you need a simple, verifiable source of CPAN security advisories for auditing, monitoring, or tooling, this module provides that in a minimal, dependable package.

Business::ISBN::Data is a data-only companion to Business::ISBN that supplies the official ISBN registration-group and publisher-range information used to parse, validate, and split ISBNs. You normally do not load it directly because Business::ISBN will load it for you, and the module ships with a copy of the ISBN Agency's RangeMessage.xml so you get authoritative ranges out of the box. If you need newer or alternate data you can point Business::ISBN at another RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading the module, and if no file is available it falls back to built-in data or looks in the current directory to help bundled apps. Note that it requires Business::ISBN 3.005 or later to match the updated data structures addressing ISBN-13 handling. The project is actively updated with frequent data refreshes through June 2026, includes a recent fix to avoid unintended autovivification when reading ISBN_RANGE_MESSAGE, and is maintained on GitHub under the Artistic License 2.0.

Time::Str is a compact, standards-focused toolkit for parsing and formatting date/time strings into Unix epoch values or precise component hashes, handling ISO 8601 and many internet and legacy formats such as RFC3339, RFC2822, HTTP, ASN.1, SQL, ECMAScript, Common Log Format and more, plus a permissive "DateTime" parser for real-world variants. Its API centers on str2time to produce numeric timestamps (including fractional seconds), str2date to return validated components with nanosecond precision preserved, and time2str to render timestamps with configurable precision or exact nanosecond output and either fixed offsets or DST-aware timezone objects. Time zone abbreviations are captured but not resolved automatically unless you provide a timezone_map or a timezone object, and the module interoperates cleanly with DateTime, Time::Moment and Time::HiRes. It ships with both a Pure-Perl implementation and an optional C/XS backend for speed, and the latest release adds a native Ragel-based C parser for the DateTime format that yields roughly a 20x performance improvement over the regexp parser. The module documents strict validation and precision behavior and exposes helpful constants, while noting some limitations such as English-only month and weekday names, no ISO week or ordinal-date support, and a supported year range of 0001–9999.

Mail::DMARC is a mature Perl toolkit that implements the DMARC email authentication and reporting standard so mail servers, spam filters, and senders can check whether incoming messages are legitimately aligned with a domain's policy and generate or consume DMARC reports. You give it basic envelope and header metadata plus SPF and DKIM results and it evaluates policy conformance, returns a structured Result object, and can persist aggregate reports to a configurable SQL-backed store tested with SQLite, MySQL and PostgreSQL. The distribution includes a PurePerl engine and an optional libopendmarc XS backend, command line and web utilities for viewing, sending and receiving reports, and flexible report storage and delivery mechanisms over SMTP or HTTP. Recent releases add support for newer DMARC-related RFCs including RFC 9989 and RFC 9990 with agreement reporting, improved handling of messages with multiple From addresses, and better IDN conversion, making it a practical choice for operators who need full DMARC validation and reporting in Perl.

CPAN::FindDependencies lets you discover the dependency tree for any CPAN module by consulting the CPAN package index and fetching distribution metadata or Makefile.PL files from a mirror, then returning a list of Dependency objects that include each module's name, distribution, required version and depth in the tree. It supports options to limit depth, add recommended or suggested modules, cache fetched metadata, specify one or more mirrors or an alternate perl core version, and choose whether missing Makefile.PL files should be executed to infer dynamic deps. The module prunes duplicates and automatically omits modules that are already in the specified perl core, so the output is focused and easy to reconstruct into a tree. You must have network access to CPAN or a local cache and startup can be slow when the index is fetched, and dynamic or platform‑specific requirements cannot always be resolved reliably. Be aware that enabling the Makefile.PL feature downloads and may run remote code so it should only be used when you accept that security risk.

Catalyst::Plugin::OpenIDConnect turns a Catalyst web app into an OpenID Connect provider by adding the standard OIDC endpoints, JWT handling, state and code storage, and a reusable controller you extend in your app. It is not an OIDC client and is intended for applications that issue ID and access tokens to relying parties; configuration covers issuer metadata, RSA keys, and client registrations including redirect URIs and allowed scopes. The plugin mounts discovery, authorize, token, userinfo, JWKS and logout endpoints under a configurable namespace and can use either an in-memory store or a Redis backend for multi-process deployments, with built‑in PKCE, refresh token rotation, and many hardening fixes to address common security issues. Recent releases added extension points for custom user claims and scope handlers and fixed JWT signature compatibility with OpenSSL 3, making it easier to integrate with external JWT libraries and to extend claim behavior for specialized deployments. If you need to implement an authorization server inside a Catalyst application and want a tested, security-focused OIDC implementation you can configure and extend, this plugin is a strong fit.

This module is a Perl client for the Aspose.Cells Cloud service that lets Perl programs work with spreadsheets in the cloud rather than handling files locally. It gives you a central configuration object for API credentials and endpoints and a simple factory-style helper to create API clients, so you can authenticate, call the REST endpoints and perform tasks like creating, reading, converting and manipulating Excel workbooks from Perl code. The package is aimed at developers who want to integrate cloud-based spreadsheet processing into Perl applications without implementing the HTTP and authentication plumbing themselves.

App::plockf is a tiny CPAN placeholder package that makes the plockf utility available; plockf runs another command while holding a file lock so you can serialize access to a resource or prevent multiple instances of a script or cron job from running concurrently. The App::plockf distribution itself is just a CPAN packaging wrapper and does not add new functionality beyond exposing plockf, which is a compact, well maintained tool with only minor fixes over time and a recent test fix for Windows.

Text::Names::Abbreviate provides a small, easy way to turn full personal names into common abbreviated forms such as initials, compact strings, or initials plus the full last name, and supports both "First Middle Last" and "Last, First Middle" input styles with options for output order, format and the separator between initials. Single-word names are returned unchanged and initials are derived verbatim from each component so punctuation or digits are preserved. The module validates input and croaks on missing or invalid parameters, and warns that formats like "compact" or "initials" are lossy so feeding their output back in will not recover the original structure. The recent 0.02 release improved robustness and testing by adopting Params::Get, adding fuzz testing in GitHub Actions, fixing edge cases including a bug where abbreviate('0') failed, and expanding the documentation and test suite.

DBIx::Class::MockData is a utility for quickly populating DBIx::Class schemas with realistic, randomized test data so you can exercise queries, relationships and fixtures without handcrafting rows. You give it a connected schema and the module introspects your result sources, figures out foreign key insertion order, and inserts values matched to each column's declared data_type while salting unique keys to avoid collisions. It supports targeted generation via only or exclude lists, per-table row counts, custom column generators, a dry-run mode for previewing output, and safe operations to deploy or truncate tables with an explicit wipe option for destructive resets. A command line tool is included for one-off runs and recent releases focused on speed and usability, adding bulk insert mode for up to 10x faster population and a truncate operation for fast refreshes, making it a practical choice whenever you need dependable test data for DBIx::Class-based applications.

POE::Component::Server::JSONUnix is a lightweight, event-driven JSON-over-Unix-socket server built on POE that provides a simple RPC-style interface for local control and interprocess communication. Clients send newline-delimited JSON objects containing a command, optional args, and an optional id, and handlers return JSON envelopes with status and results or errors, so malformed requests and handler failures are reported without disturbing other clients. You add commands at startup via a commands hash, at runtime with register, or by subclassing cmd_* methods, and handlers may reply synchronously or keep a context object to respond asynchronously later. The server includes handy built-ins like ping and commands, removes stale socket files but will not clobber an active listener, lets you set socket permissions, and defaults to line-based framing while allowing POE::Filter::JSON for pretty-printed input. It depends on POE and JSON::MaybeXS and is aimed at daemons, command-line tools, and other local processes that need a simple, extensible control or RPC endpoint.

oEdtk is the main module of an open source toolkit for industrial printing processing that provides a simple, documented framework to parse fixed-width record files and build formatted outputs. It opens and closes job filehandles, lets you declare record templates that map fixed-length fields into a global data array, and lets you attach user callbacks to run before, during, and after record extraction. You can also define sprintf-style output templates, and dynamically erase or redefine record types at runtime, so it is useful for automating batch jobs that transform legacy or production print/data streams into composed documents. The module is presented primarily as the documented entry point for the oEdtk toolkit and is distributed under the GNU GPL with no warranty.

HTTP::Request::FromCurl converts curl command lines into Perl HTTP::Request objects so you can turn examples copied from documentation or browser developer tools into code for LWP, HTTP::Tiny or similar clients. You pass a curl-style command or argv array and the module returns one or more HTTP::Request::CurlParameters objects that encapsulate the request parameters and can produce an HTTP::Request for your user agent. It recognizes many common curl options, supports multiple URL expansion and optional inlining of file contents, and can regenerate curl or other client snippets for round‑tripping. There are some limitations to be aware of such as incompatible curl cookie file formats, file uploads and body files being slurped into memory, certain curl features like --next being unsupported and a small set of options intentionally ignored, but these are documented. The latest release fixes handling of empty passwords in Authorization headers and adds support for the commonly used --follow option.

DesktopWorkspaceRoles::Standard provides a ready-made collection of roles for use with the DesktopWorkspace framework, offering common behaviors and interfaces you can compose into workspace objects so you do not have to recreate basic functionality. It is aimed at developers building or extending DesktopWorkspace-based applications or plugins who want consistent, tested building blocks to speed development and reduce boilerplate. The module is lightweight, maintained on GitHub, and welcomes contributions and bug reports.

YAML::LibYAML is the Perl binding (distributed as YAML-LibYAML and better known as YAML::XS) that gives you fast, robust YAML parsing and generation by wrapping the libyaml C library with XS. It provides familiar Load and Dump routines and file helpers so Perl programs can read and write YAML efficiently while handling anchors, aliases, tags, regexps, tied variables, Unicode, and various Perl types including blessed references when explicitly allowed. The module is actively maintained with security-conscious defaults such as disabling automatic loading of blessed objects and recent fixes for YAML 1.2 compatibility, boolean handling, and several memory and parsing bugs. Use it when you need a high-performance, well-tested way to serialize or parse YAML from Perl and when you want explicit control over object loading and the latest libyaml behavior.

Weasel::Driver::Selenium4 is a lightweight adapter that lets the Weasel browser-automation framework drive real browsers via Selenium WebDriver 4 by wrapping Selenium::Client, providing the standard Weasel driver operations like navigating pages, finding elements, clicking, double-clicking, typing, executing scripts, taking screenshots and waiting for conditions. It exposes simple configuration for Selenium capabilities, window_size and a millisecond wait_timeout and includes helpers to update the timeout and window size on a running session, while capability changes take effect after restarting the session. Use this module when you are working with the Weasel test framework and need a ready-made Selenium 4 backend for browser-based tests.

Syntax::Infix::ConditionalSplice provides a lexically scoped infix operator ?| that makes it trivial to conditionally splice elements into a list, so you can write things like $verbose ?| '--verbose' inside an argument list instead of the noisier COND ? LIST : (). The operator short-circuits so the right-hand expression is only evaluated when the condition is true, and it is context-aware so in list context it flattens the supplied list into the surrounding list while in scalar context it returns the list's last value or undef when false. The operator has sensible precedence relative to commas and logical operators and you can parenthesize the right side to include multiple elements. Note that it relies on Perl 5.38 or newer and will not install on older Perl releases.

Syntax::Infix::OptionalChain provides a lexically scoped infix operator "?->" that implements safe navigation in Perl so you can walk into objects, hashes and arrays and get undef instead of a fatal error when a link in the chain is missing. The right-hand bareword is resolved at runtime so if the left value is a blessed object with that method it calls the method, if it is a HASH reference it performs a key lookup, and if it is an ARRAY reference it treats the bareword as a numeric index; an undef left-hand operand causes an immediate undef result and no autovivification happens. Blessed hashrefs or arrayrefs fall through to structural access when the method does not exist, defined but non-navigable values croak, and the operator pairs naturally with // for defaults. Note that the right-hand side must be a compile-time bareword so you cannot pass arguments, compute keys, or use negative indices. The module is implemented on top of Infix::Custom with an XS navigator, requires Perl 5.38 or newer, and this release is the initial 0.01.

Infix::Custom lets you declare your own binary infix operators in Perl so expressions like "a OP b" can be made to call a Perl sub, act as a native binary operator, or be handled by a C-level builder, and those operators are recognized and lowered at compile time so there is no added runtime parsing cost beyond the work of the operation itself. You register a glyph and choose a lowering mode: call mode maps the infix to a Perl sub, method mode treats the right hand side as a bareword to enable natural looking safe-navigation like "?->", and binop mode maps directly to a built-in operator for zero call overhead. Declarations are lexical so operators only apply where imported and can be rebound or removed in nested scopes. There is also an escape hatch for XS authors to build custom optrees at C level. This requires Perl 5.38 or newer because it relies on the core infix plugin hook, so use it when you want readable, compile-time custom operators with predictable performance.

Perl::Critic::Policy::ControlStructures::LoopsRequireLabels is a Perl::Critic policy that enforces explicit labels on loops and on loop-control keywords like next, last, and redo so the target of a break is always obvious and less likely to break during refactoring. It offers three modes: always, which requires labeled loops and labeled break keywords everywhere; nested, the default, which requires labels for loops that are nested or whose body exceeds a configurable max_lines threshold; and max_lines, which only enforces labels when a loop body is longer than the configured line count. The policy also treats continue blocks as part of their loop and flags bare breaks when any ancestor loop carries a label to avoid ambiguous targets. Configure it in your perlcriticrc to tighten control-flow clarity in codebases where nested loops or long loop bodies make break targets hard to track.