CPANscan

Net::CalDAVTalk (v0.16) is a Perl client library that talks to CalDAV calendar servers and presents calendars and events through a simple JSON-style interface, building on Net::DAVTalk and including CalDAV and Cyrus-specific XML namespaces. It is the FastMail implementation used by tests and mail services, and it provides high-level operations to list, create, update and delete calendars and events, fetch event links or full event data, perform sync-token based incremental syncs, run free/busy queries, move or annotate events, and export calendar data as iCalendar; it also caches timezones and offers a pluggable logger callback. The module delegates iCalendar↔JSCalendar conversion to Text::JSCalendar and supports useful CalDAV features such as multi-get and sync reporting, and the recent 0.16 release adds support for sending Schedule-Reply: false via the _no_schedule flag to suppress iTIP scheduling replies while 0.15 fixed a serious UpdateEvent merge bug. Net::CalDAVTalk is practical for integrating CalDAV into Perl services, though it was written around an early FastMail API and some extended properties are not fully parsed.

Dist::Zilla::Plugin::SigStore::SignRelease is a Dist::Zilla plugin that automates signing your CPAN distribution with SigStore via the cosign tool and can attach and upload the resulting signature bundle to CPAN alongside your tarball. It runs automatically after a release, lets you choose the signature file extension and whether the bundle is uploaded, and can auto-answer cosign prompts for unattended CI-friendly operation. You must have the cosign application installed to use it, and note that PAUSE and CPAN clients do not currently perform sigstore verification automatically so consumers will need to verify signatures manually with cosign if desired.

Permute::Unnamed is a tiny Perl utility for producing the Cartesian product of multiple input lists and returning every combination as array references. It offers a minimal, unnamed API that is easier to use when you only need raw tuples rather than named parameters, so it is handy for generating parameter grids, test cases, or any situation where you must iterate all possible pairings or combinations of list elements. The module is lightweight, complements modules like Set::CrossProduct and Permute::Named, and is available on MetaCPAN from the author perlancar.

JSON::LINQ provides a fluent, LINQ-style query interface for JSON, newline-delimited JSON (JSONL) and LTSV files so you can filter, project, group, sort, join and aggregate data with readable method chaining instead of hand-rolled loops. It supports streaming access for JSONL and LTSV with O(1) memory usage, offers a small DSL for simple key/value filters, and implements about 65 LINQ methods including JSON and LTSV I/O helpers so you can read files, join against lookup tables, and write results back as JSON, JSONL or LTSV. The module is pure Perl with a built-in JSON encoder/decoder so it has no XS or CPAN dependencies and runs even on very old Perls. Common uses include processing large log streams, transforming JSON data sets, joining JSON records to small LTSV lookup tables, and performing aggregations and sorts in concise code. Be aware of a few documented limitations of the bundled JSON parser such as lack of surrogate pair support, potential infinite recursion when encoding circular references, and an iterator design quirk where a top-level JSON null becomes indistinguishable from end-of-sequence. If you need a compact, dependency-free way to query and stream JSON and LTSV data inside Perl scripts, JSON::LINQ is a practical choice.

DateTime::Format::RelativeTime is a Perl port of the JavaScript Intl.RelativeTimeFormat API that produces localized human‑friendly relative time strings like "in 3 days" or "yesterday". It uses Unicode CLDR data via Locale::Unicode::Data and Locale::Intl to support locales, numbering systems, styles (long, short, narrow) and numeric modes (always or auto). You can format simple value/unit pairs or pass one or two DateTime or DateTime::Lite objects to have the module compute the largest time difference, and it offers both format and formatToParts for full strings or componentized output. The module mirrors browser behavior so results may vary by locale and can include non‑breaking spaces or bidi markers, and it formats numeric output with up to 15 significant digits. Because initialization performs CLDR lookups you should create and cache a formatter for reuse rather than instantiating one per call. It requires Perl 5.10.1 or newer and the latest release updates a dependency to match the current Locale::Unicode::Data.

EV::Kafka is a high-performance asynchronous Kafka client for Perl that plugs into the EV event loop and implements the Kafka binary protocol in XS so you do not need librdkafka. It exposes a low-level EV::Kafka::Conn for single-broker protocol operations and a higher-level EV::Kafka::Client for cluster management, metadata discovery, producer and consumer workflows including key-based partitioning, acks, idempotent and transactional production, consumer groups, manual assignment, and offset management. The module supports pipelined requests, optional compression and TLS, SASL PLAIN and SCRAM authentication, and integrates with AnyEvent when EV is used as the backend. Note that it treats all message data as raw bytes so you must encode UTF-8 yourself, DNS lookups for hostnames are blocking which can stall the EV loop, and it does not provide GSSAPI, OAUTHBEARER or the Kafka flexible APIs. Choose EV::Kafka when you need low-latency, high-throughput Kafka or Redpanda access from Perl and want a direct, protocol-level client with advanced producer and consumer features.

RT::Extension::HistoryFilter is a lightweight plugin for Best Practical's Request Tracker that trims the ticket display history to only the transaction types you care about, making ticket pages easier to scan by hiding routine or verbose events. Administrators pick which transaction types are shown via configuration and user preferences and the module ships with sensible defaults such as create, correspond and comment. The detailed history view is left intact so no data is lost, and the extension is an enhanced take on RT::Extension::BriefHistory. Installation is simple for modern RT releases by enabling the plugin and clearing Mason cache, though very old RT 4.2.3 and earlier installations require an additional patch.

RT-Extension-MandatoryOnTransition is a plugin for Request Tracker that prevents tickets from being moved to or from specified statuses or queues until required core fields, custom fields, or roles have been set, so you can make sure items are resolved only after required information like a reply, time worked, a resolution field, or a particular role is assigned. It integrates with RT lifecycles and is configured in RT_SiteConfig.pm using the %MandatoryOnTransition structure to declare which fields are mandatory for particular status or queue transitions, and it supports value checks (must_be and must_not_be) and optional group membership checks for role assignments. The extension works with RT 6 and has a 0.x branch for RT 5, it exposes only the needed fields on the update page to make completion easier and enforces standard RT validation patterns for custom fields. Note that enforcement is not available on every update path yet, for example SelfService and some quick-create pages are not supported, and multi-valued custom fields have limited handling for must_be and must_not_be rules.

EV::Websockets is a Perl binding that embeds the libwebsockets C library into the EV event loop to provide high-performance WebSocket client and server functionality. It gives you a Context object to manage the loop, create outgoing connections or listeners, handle TLS and proxy settings, and adopt existing sockets. Connections use simple callbacks for connect, message, close, error, pong and drain, support automatic reassembly of fragmented messages, allow streaming fragments for large sends, and expose backpressure controls like send_queue_size and on_drain plus a per-connection stash for metadata. Because it is backed by libwebsockets it is tuned for low-latency, high-throughput scenarios. One caveat is that a Context with no active listeners or connections can spin an internal idle watcher and interfere with other EV watchers, so create a listener or connection before calling EV::run or destroy the context when idle. It also includes helpers for integrating with PSGI servers such as Feersum.

RT::Extension::MergeUsers is an add-on for Request Tracker that lets administrators consolidate two accounts so one becomes the primary and the other is treated as a secondary, making mail and activity from the secondary appear as if sent by the primary. It adds a Merge Users box to the User Administration page and provides programmatic methods on RT::User, a command line tool and a cleanup utility, plus REST2 API endpoints for authenticated, permission-checked merging and unmerging. The extension also supplies a canonicalize-email routine so messages from merged accounts show the primary identity. Be aware that merges are single-level only, the extension is not compatible with rt-serializer, and there are special considerations when using RT::Shredder or upgrading from very old versions where a migration script must be run. The module targets RT 5.0 and 6.0 and is published by Best Practical Solutions under the GPLv2 license.

RT::Extension::FormTools is a plugin for Best Practical’s RT that gives admins a visual builder to create multi‑page, wizard-style ticket submission forms without coding. You design pages with a drag-and-drop palette of core fields, queue-specific custom fields, HTML blocks and helper components, set conditional display and required rules, route submissions to different queues, group forms for organization, and control who can see or use each form. The extension validates custom field input, supports attachments and localized text, lets you include ticket variables in HTML result pages, and can export or import form definitions as JSON for migration. It works with RT 6 and newer and installs as a standard RT plugin. The recent 2.05 release adds a ShowQuestion component for non-ticket dropdowns used in conditional logic, improves conditional validation and feedback, and includes a few robustness and localization fixes to make forms more reliable.

Plack::Middleware::Text::Minify is a Plack middleware that uses Text::Minify::XS to strip indentation and trailing whitespace from text responses on the fly, helping shrink HTML, CSS and JS served by your PSGI app. You enable it in a Plack builder and scope it by path or content type using a regex or callback so it only touches the responses you want, and by default it targets text/* responses while skipping methods or status codes that do not have bodies. The middleware can be disabled at runtime via the psgix.no-minify environment flag and requires Perl 5.14 or newer. Note that the minifier does not understand markup so it can collapse newlines inside elements where whitespace matters such as pre or textarea and it may interact with templating directives that already collapse whitespace.

Apache::Session::Generate::Random is a lightweight extension for Apache::Session that produces cryptographically strong session identifiers by using the operating system's randomness source. It is designed to be used as the Generate component with Apache::Session::Flex so you can replace the default id generator with a more secure, unpredictable id for web sessions. The module is simple, portable and works on very old Perl versions while the author only provides active support for recent releases. Recent updates added a companion adapter for Apache::SessionX and refreshed the distribution metadata and packaging.

Plack::Middleware::BlockHeaderInjection is a lightweight Plack middleware that protects PSGI web applications from HTTP header injection by scanning response headers for control characters (ASCII 0 through 31), including newlines, and removing offending headers while setting the response status to a configurable code (500 by default). It is useful when headers may include unchecked user input, for example in Location or Cookie values, because attackers can exploit injected headers to bypass security checks. There is a clean mode that converts null bytes, newlines and carriage returns into whitespace instead of rejecting the response when legitimate multi-line headers must be tolerated. The module is simple to enable in a Plack::Builder pipeline and requires Perl 5.24 or later.

App::cpm is a fast, command line CPAN installer for Perl that focuses on stable and predictable installs by preparing all dependencies first and doing the final installation in a separate step. It installs requested distributions and their runtime dependency closure by default and provides clear terminal progress so you can see what is happening during large or parallel installs. Over time cpm added features like cpanfile support, prebuilt build caching, mirror and resolver options, and various install and timeout controls. Version 1.0 formalized the prepare-then-finalize workflow and raised the minimum Perl requirement to v5.24, and the current maintenance release 1.0.3 fixes reinstall handling for dependency files and refines environment handling during installs. If you frequently fetch and install CPAN modules, especially in complex dependency scenarios or automated workflows, cpm is a compact, performant alternative to tools like cpanminus.

OpenAPI::Modern is a Perl library for validating HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 specifications. It loads an OpenAPI document and uses a standards-compliant JSON Schema evaluator to deserialize and validate path, query, header, cookie and body data, returning detailed JSON::Schema::Modern::Result objects that include both errors and the parsed data. The module prefers Mojolicious request and response objects, supports jsonSchemaDialect and bundled metaschemas, follows $ref chains to fetch components, and provides helpers to locate the correct path item or operation for a given request, with options for caching and preloading large documents for performance. A few OpenAPI features are not implemented yet, for example multipart bodies and form-urlencoded encoding, and the Authorization header is not checked against security schemes, but otherwise this is a mature, spec-aware tool for adding runtime request and response validation to Perl services.

App::MARC::List is a compact Perl base class for building a marc-list command-line utility that reads MARC XML files and prints values from specified MARC fields and subfields, including control fields and the record leader. It validates field/subfield arguments and returns simple exit codes so you can script it into pipelines or tools, and recent releases added support for compressed input files and a -s option to skip the field/subfield check, with earlier additions including a frequency print mode (-f) and broader field support. If you need a small, scriptable way to extract specific MARC data for reporting or automation, this module gives a minimal, ready-to-use foundation.

Sys::Async::Virt is an asynchronous Perl client for the libvirt remote protocol that exposes the hypervisor RPC API as object oriented methods which return Futures that can be awaited with Future::AsyncAwait. It lets Perl code manage domains, networks, storage pools, volumes, node devices and secrets over SSH, TCP or external-process transports and supports event subscriptions, streaming operations (for uploads/downloads), migrations and SASL authentication while handling keepalive and connection lifecycle for you. The module mirrors the libvirt protocol (implemented to the v12.3.0 protocol) and translates C-style outputs into Perl-friendly return values such as boolean cpu maps and typed-parameter hashes so you can call libvirt entry points idiomatically from async Perl. It is designed for concurrent RPCs and out-of-order replies so long-running server operations resolve as results arrive and domain lifecycle events are provided via callback objects. The distribution is still marked experimental so the API may evolve, some protocol entrypoints and FD-related operations remain unimplemented, and older libvirt servers that lack particular features may not be supported. Recent updates include syncing to libvirt v12.3.0 and a few new constants and packaging fixes.

Protocol::Sys::Virt is a low-level Perl implementation of the LibVirt RPC protocol that exposes the message encoding, decoding and transport mechanics needed to build LibVirt-compatible clients and transports. It is aimed at developers who need a genuinely asynchronous interface to libvirt rather than the blocking behavior of higher-level bindings like Sys::Virt, and it provides serializers, deserializers, transport and stream handling and helpers for typed parameters so you can plug in event loops or custom IO backends. The distribution follows libvirt's protocol stability guarantees and is kept in step with upstream releases, most recently updated to the libvirt v12.3.0 tag. This module focuses on protocol plumbing rather than a ready-made user-facing client, so it is most useful when you need fine-grained or asynchronous control of libvirt communication rather than simple synchronous management.

MCP::Run is a lightweight base class for building MCP servers that expose a "run" tool to execute shell commands remotely. It registers a run tool for you and expects subclasses to implement execute, which returns an exit_code, stdout, stderr and an optional error string, while MCP::Run handles argument parsing, result formatting and MCP protocol plumbing. You can lock down what may run with an allowed_commands whitelist or a custom validator coderef, set a default working_directory and timeout, and enable optional output compression to trim and summarize noisy command output for better LLM efficiency. A convenience run_stdio entrypoint and a ready-to-use MCP::Run::Bash subclass are provided, and the companion MCP::Run::Compress plus helper scripts and a Docker image supply many command-specific filters and installation helpers. Recent changes make the original command available to the compressor so command-specific filters match reliably and require subclasses overriding format_result to accept the new fourth argument, and the docs were updated to position mcp-run-bash and the Claude hook as primary use cases.

Text::CSV::Simple is a lightweight wrapper around Text::CSV_XS that makes common CSV tasks easy in Perl by returning each row as an arrayref and hiding most of the X S complexity. It provides a read_file method to load a file, want_fields to pick only specific columns, field_map to convert columns into a hash with named keys, and trigger hooks such as before_parse, after_parse and on_failure so you can inject custom behavior without modifying the core code. The focus is simplicity and quick scripting rather than covering every CSV edge case and the author explicitly notes it does not handle multi line fields, a limitation documented in the 1.00 release. If you work with straightforward CSV files and want concise, readable code this module is convenient, but for full CSV edge case support you should use Text::CSV_XS directly.

EV::Future is a tiny, XS-implemented toolkit for orchestrating asynchronous tasks on the EV event loop. It exports three simple primitives named parallel, parallel_limit, and series that accept an array of task coderefs where each task gets a single done callback and a final callback is invoked when all work completes. The implementation is tuned for minimal overhead so it excels with large numbers of short tasks and includes an optional unsafe mode that roughly doubles throughput by reusing internal structures at the cost of skipping exception safety and making double-calling done dangerous. Series supports early cancellation by passing a true value to done while parallel_limit dispatches tasks up to a specified concurrency and has no cancellation once tasks are started. If you already use EV and need a compact, high-performance way to run tasks concurrently or in sequence, EV::Future is a lightweight, pragmatic choice.

EV::ClickHouse is an asynchronous ClickHouse client for Perl that plugs into the EV event loop and speaks both the HTTP and native TCP protocols with a single, callback-driven API. It supports parameterized queries, per-query and connection-level settings, streaming results via on_data for large native results, INSERT with either TSV strings or Perl arrayrefs, gzip and optional LZ4 compression, and optional TLS via OpenSSL while implementing the protocols in XS with only zlib required at build time. The client provides conveniences such as auto-reconnect with exponential backoff, keepalive pings for native connections, raw HTTP response mode for CSV or Parquet, and opt-in decoding for Date, Decimal and Enum types, plus metadata accessors like column_names, last_query_id and last_error_code to help with error handling and diagnostics. Recent 0.02 fixes corrected keepalive PING/PONG callback routing, ensured last_error_code reports the top-level exception, added IPv6 URI literal support, improved skip_pending socket teardown, and made HTTP arrayref inserts croak on nested refs to avoid malformed data.

Future::Uring is an experimental, user-friendly Perl wrapper around Linux io_uring that exposes common file and socket operations as Future-returning calls so you can use them with Future::AsyncAwait or other Future-based code. It mirrors familiar system calls like open, read/write via handles, socket, mkdir, rename, unlink and waitpid while providing helpers such as to_handle, ring and nop, and it lets you tweak submission behavior with named options for async offload, links, hardlinks, drain and timeouts. The module hides low-level ring management and returns objects that behave like ordinary Perl file/socket handles while performing the actual IO through io_uring, making it easy to add low-latency asynchronous IO to existing code without touching C APIs. Note that this is an early release and the API is not yet stable, and it depends on a recent IO::Uring implementation; recent changes added statx support and moved to a singleton IO::Uring instance while the latest release explicitly enabled lexical subs. If you want to prototype or incrementally add io_uring-based async IO to a Future-based Perl application, this module makes that straightforward, but evaluate stability before using it in production.

Pheno::Ranker is a Perl toolkit for comparing phenotypic records by computing semantic similarity across GA4GH PXF/BFF data structures and common formats like JSON or YAML. It produces plain text similarity outputs such as pairwise matrices, and exposes a simple API with a single run method while also providing a command line interface for most workflows. The module is aimed at bioinformaticians and researchers who need to quantify phenotype similarity across individuals or datasets and it is documented alongside a published paper describing its methods and use. If you work with phenotype data and need straightforward similarity scoring and exportable text results, Pheno::Ranker is likely relevant to your project.

File::Information is a Perl toolkit for reading and managing metadata about files, links, and other filesystem objects in a portable and compact way. It collects attributes from the operating system and from auxiliary sources such as .comments directories, tagpools, tag databases and file stores, and exposes a simple API to obtain objects for a path, an open handle, or a stored identifier so you can query properties, compute digests, or run a verification check for corruption. The module also introduces lifecycle states to track an object from initial through current to final, which helps with auditing and integrity checks. It is configurable so you can plug in tag databases, data extractors, and stores, control digest algorithms and size limits, and list available tagpools and supported digests. A provided example program shows how to dump everything the module can read for a file, making it easy to evaluate for indexing, archiving, or integrity workflows.

DBIx::Class::Async is an experimental library that makes DBIx::Class calls non‑blocking by sending queries to a pool of background worker processes and returning Futures to your main program so the event loop stays responsive. It preserves the familiar DBIC resultset interface while adding support for parallel execution, transactions, relationship inflation, deterministic SQL generation for safer caching, optional CHI-based caching, automatic retries for transient failures, and optional metrics via Metrics::Any. The module is built on IO::Async but is loop agnostic and includes examples for integration with frameworks like Mojolicious. It has been tested with SQLite, PostgreSQL and Oracle for common CRUD and transaction patterns, and it requires you to manage worker lifecycle and ensure any data sent between processes is serialisable. Since the author marks it as pure experimental, try it in staging, read the docs for disconnect and timeout guidance, and report feedback or issues on the project GitHub.

Test::MockModule lets you temporarily replace or stub out subroutines in another Perl package so you can isolate code paths for unit testing. You create a Test::MockModule object for a target package and use mock, redefine, or define to install replacements or new subs, then use original, unmock, or unmock_all to restore the real implementations automatically when the object goes out of scope. It works with object methods, preserves originals so you can wrap or forward to them, can mock all methods at once or install no-op handlers, and integrates with Moose and Mouse metaclasses so mocked methods participate in role checks and method modifier resolution. The module also provides a lexically scoped strict mode and a global-strict option to prevent accidental, out-of-date mocks by requiring explicit redefine or define calls. Bear in mind that mocking an exported function may need to be done in the importing package to affect callers. Recent maintenance added lexically scoped strictness and improved MOP handling and project releases are tracked on the module's GitHub releases page.

SPVM::Sys is a comprehensive system interface for SPVM that gives you direct, portable access to OS services such as file and directory operations, buffered and unbuffered file I/O, sockets and networking, time and timezone utilities, process control and signals, environment and user/group lookups, and the familiar Perl-style file tests. It wraps common system calls (open, sysread, syswrite, socket, bind, accept, send, recv, fork, exec, wait, utime, stat, and many more) and provides higher-level helpers like setsockopt, a portable set_tcp_keepalive, and Perl-style -X methods so you can write cross-platform system code without dropping into C. Windows filename handling is automatically translated between UTF-8 and UTF-16LE, and the module includes helpers for directory streaming, globbing, and socket address manipulation to simplify common tasks. Recent updates added a bsd_glob-compatible Sys->glob method and expanded portable TCP keep-alive configuration, making it a good choice when you need robust, low-level OS functionality from SPVM.

Markdown::Render converts Markdown into HTML either by calling the GitHub Markdown API or by using a local engine (Text::Markdown::Discount). It can read Markdown from a file or a string, interpolate custom tags and metadata, build a table of contents, and produce a complete HTML page with configurable title and CSS, and it also provides a command line tool (md-utils.pl) for batch or in-place processing. The module favors Text::Markdown::Discount over Text::Markdown for better speed and closer GitHub Flavored Markdown compatibility and the author maintains an updated Discount variant for some missing features. Recent updates replaced LWP::UserAgent with HTTP::Tiny for GitHub rendering and tightened packaging and SSL-related dependencies to simplify installation and improve robustness. Use Markdown::Render when you want a simple, scriptable way to generate polished HTML from Markdown with optional tag interpolation and TOC generation.