CPANscan

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.

Amazon::Signature4::Lite is a compact, dependency-free Perl module that generates AWS Signature Version 4 headers for S3 and other AWS API requests. It is designed to work with plain scalars and header hashrefs used by HTTP::Tiny instead of requiring LWP or HTTP::Request. You create a signer with your access_key, secret_key and region, optionally supply a session_token or service name, and call sign with method, url, headers and payload to receive a hashref of headers such as Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token when applicable. A parse_service_url helper can extract service and region from common S3/AWS endpoint hosts but it is focused on AWS patterns rather than general URL parsing. This module is a good fit for small scripts and minimal-dependency environments where you need straightforward v4 signing without pulling in larger HTTP libraries.

Test::Most is a convenience wrapper for Perl testing that bundles the most commonly used testing modules so you can write tests with far less boilerplate while automatically enabling strict and warnings by default. It imports Test::More plus Test::Exception, Test::Differences, Test::Deep and Test::Warn and adds handy utilities such as die_on_fail and bail_on_fail to stop a suite on the first failure, set_failure_handler to customize that behavior, explain and show for nicely dumping data structures and trying to display lexical variable names, and an optional timeit helper for simple timing of code. You can selectively exclude problematic modules or individual symbols from the bundle and you can restore normal failure behavior at runtime. A few legacy features like deferred plans and all_done are deprecated in favor of Test::More's done_testing, and recent maintenance releases improved compatibility with Test::Builder and stopped permanently altering Test::More's export list so it plays nicely with other test tooling. If you want a one-stop way to get a rich set of test helpers without managing many separate imports, Test::Most is likely relevant to your Perl test suites.

Atomic::Pipe lets multiple processes or threads write discrete messages into a POSIX pipe without their outputs getting mangled by splitting each message into atomic chunks that fit under PIPE_BUF and reassembling them on the read side so readers always receive complete messages. It exposes reader and writer objects you can create from a new pipe, an existing filehandle, fd, or FIFO and supports blocking or nonblocking I/O, one-shot atomic bursts for short writes, a mixed-data mode that interleaves framed messages with ordinary stdout/stderr output, and tools to clone or split ends and tune pipe buffer behavior. Recent releases added optional Zstandard compression with optional shared dictionaries so large messages often compress into a single atomic chunk and can dramatically improve throughput, and compression is only enabled and loaded when requested. The module is POSIX-specific, does not guarantee global ordering across different writers, and mixed-data mode depends on a few control characters that could be confused by raw binary noise, but for Unix-like systems that need reliable, atomic message delivery from many writers Atomic::Pipe is a practical, well-tested choice.

DBD::Pg is the official PostgreSQL driver for Perl's DBI that lets Perl programs connect to and work with Postgres databases in a DBI-compatible way. It handles connection details including service files and SSL modes, supports server-side prepared statements and multiple placeholder styles, and gives fine grained control over data types and quoting so you can bind integers, bytea, booleans, arrays and Postgres-specific types safely. The driver also supports bulk COPY operations, large object access, asynchronous queries and asynchronous connects, notification listening, and useful DBI extensions such as last_insert_id, table and column metadata, and handy attributes like AutoCommit, RaiseError and pg_enable_utf8 for Unicode handling. DBD::Pg is mature and actively maintained with a long track record of fixes and improvements. The recent 3.20.1 release tightened up asynchronous prepare handling, fixed a hang with COPY TO STDOUT in async mode, and improved documentation for SSL connection options, making async and secure connections more reliable.

Net::Z3950::FOLIO is a small Perl module that provides a Z39.50 server front end for searching and retrieving bibliographic records from the FOLIO inventory module. It is the application core used by the z2folio script and exposes just two public actions: new(configBase) to create an instance from a JSON configuration file and launch_server(label, @ARGV) to start a YAZ-backed Z39.50 server that runs until stopped, using the provided label for logging and interpreting command-line options for the YAZ backend. If you need Z39.50 access to FOLIO data this module does the heavy lifting and is intended to be used via the included tooling rather than as a general-purpose library.

Number::ZipCode::JP is a compact Perl module for validating Japanese postal codes against the official formats used by Japan Post. It accepts codes as separate area and suffix parts or as a single string with or without a hyphen, and you can limit validation to specific categories such as area-specific or company-specific codes by importing the matching table. You create an instance with new, set or change the code with set_number, and call is_valid_number to get a true or false answer. It is handy for input validation, batch checks, and cleaning address data in scripts and applications.