CPANscan

Nice::Try brings a familiar try, catch and finally syntax to Perl by transforming your source at compile time so you can write nested exception blocks, assign the caught value to a variable, filter catches by exception class or condition, and return values from try blocks while preserving correct line numbers and the usual $@ behavior. It integrates with the Want module to provide richer context-aware returns such as object, arrayref or coderef results and it supports flow control keywords inside loops, works with __DATA__ and __END__ sections, and is thread-safe while disabling Want where unsafe. Because it is a source filter that uses PPI it avoids brittle regex parsing but does add some compile-time overhead for large codebases and lvalues are not yet implemented. If you need a compact, feature-rich try/catch implementation that supports finally blocks and class filtering beyond Perl's experimental try feature, Nice::Try is a practical and well‑documented option.

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.

JSON::API is a small, practical Perl helper for talking to JSON-based HTTP APIs that wraps JSON and LWP::UserAgent so you can create a client with a base URL and send GET, POST, PUT, PATCH and DELETE requests with automatic JSON encoding and decoding. It accepts the usual LWP options such as authentication, custom agent, SSL and cookie handling, and it returns decoded Perl data (or an HTTP status plus data in list context) while also exposing the raw HTTP::Response and response headers when you need low-level details. A useful predecode hook added in 2019 lets you preprocess raw response text before JSON is parsed, which helps with APIs that prefix responses to prevent CSRF. The module is aimed at scripts and automation that need a simple, configurable JSON HTTP client, and the changelog notes that maintenance and release notes are now tracked on the project’s GitHub releases.

Finance::Tiller2QIF converts Tiller Money CSV exports into QIF files you can import into desktop finance programs like GnuCash, KMyMoney, Quicken, HomeBank and Money Manager Ex. It stages work in three simple phases: ingest parses the Tiller CSV into a SQLite database, map applies a user-supplied, regex-based mapping file to translate categories, assign destination accounts and suppress duplicates, and emit writes the final QIF for import. You can run it from the command line or call its functions from Perl, use a config file, checkpoint the database, and pause between stages to tweak data or run ad hoc SQL. The mapping format is expressive yet easy to read, with account scoping, alternation, literal-pipe escaping, options to omit categories or skip transactions, and a configurable default rule. Licensed under GPLv3, this tool is a practical choice if you use Tiller and need a reproducible way to export clean, mapped QIF data for other financial software.

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.

DarkPAN::Utils is a lightweight toolkit for interacting with a private CPAN mirror served from S3/CloudFront, making it easy to fetch and parse the standard CPAN package index, locate distributions that contain a given module, download distribution tarballs, and extract individual files or Perl module source for tasks like documentation generation. It works over the network using a configurable base URL or directly against a supplied Archive::Tar object so you can operate without network access when a tarball is already available. The module exports a small helper to parse distribution filenames, exposes methods to fetch and cache the 02packages index, search for modules, pull and unpack packages, and retrieve files or lib/Module/Name.pm sources, and it includes a simple command line interface and configurable Log::Log4perl logging. Recent changes focus on build and packaging updates in the 1.1.0 release, refactoring the CPAN::Maker bootstrap and project metadata and tests, with no major API changes to the runtime behavior.

CPAN::Maker::Bootstrapper is a command line tool that scaffolds a complete, ready-to-build CPAN distribution in one step, creating a managed Makefile, buildspec.yml, VERSION file, stub source (.pm.in/.pl.in) and test skeletons so you can run make to produce a distributable tarball immediately. It embeds a portable build system based on GNU make, bash and Perl that automatically scans dependencies, enforces optional quality gates like perl -wc, perltidy and perlcritic, supports modulino wrappers, and provides a safe extension point (project.mk) so you can add project-specific rules without touching the managed files. You can import an existing project into the scaffold, choose different stub types, customize behavior via a git-based or .ini config, and use built-in LLM-powered commands (code-review, pod-review, release-notes) that integrate with Anthropic Claude for iterative, annotated reviews and AI-assisted release notes. Be aware that imported files become .in sources and generated .pm/.pl files are overwritten by the build, and that the importer and stub options are mutually exclusive. Notable in the recent 2.0.0 release are refactors and new LLM role modules, improved prompts and release-notes support, and updates to the managed Makefile and .includes files to streamline the AI and build workflows.

OrePAN2::S3 is a Perl utility for running a private DarkPAN, letting you host a CPAN-style archive on Amazon S3 and optionally serve it through CloudFront. It provides commands to inject and delete distributions, build and upload an index.html from the CPAN manifest, generate simple docs from README or POD, and push additional static artifacts to your S3 bucket, and it can be used either via a provided bash wrapper or directly as a modulino. Configuration is done with a JSON file that can hold multiple profiles specifying AWS credentials, region, bucket and prefix, CloudFront distribution and invalidation paths, and a Template::Toolkit template for the index so you can customize how packages are presented. The tool automates common mirror tasks like uploading files, reindexing, and optionally invalidating CloudFront caches, so it is a good fit for Perl developers or ops teams who want a lightweight, static private CPAN repository backed by S3. You will need an AWS profile with S3 and CloudFront permissions, and the author provides examples and a default template to get started quickly.

Amazon::S3::Lite is a compact, no-frills Amazon S3 client designed for AWS Lambda functions and small scripts that need the common object storage operations without the bulk of LWP-based libraries. It lets you list buckets and objects with pagination, fetch objects (with optional streaming to a file to avoid large memory use), read object metadata, upload objects from scalars or filehandles with metadata and ACLs, copy objects server-side, and delete objects or specific versions. The client uses HTTP::Tiny and AWS::Signature4 so its dependency footprint is small, it returns parsed Perl hashrefs for results, and it supports credential discovery from constructor args, environment variables, or a credentials provider object for IAM roles and rotating credentials. It is intentionally not a full S3 implementation and does not provide multipart uploads, presigned URLs, advanced bucket management, or raw HTTP response access. Error handling is simple and predictable with croaks for network and 5xx errors and undef for 404s where appropriate. In the recent 1.0.1 release the module added the x-amz-content-sha256 header, smoothed logger initialization, and formalized TLS requirements by adding IO::Socket::SSL and Net::SSLeay to the prerequisites.

MetaCPAN::Client is a polished Perl interface to the MetaCPAN API that makes it easy to find and inspect CPAN authors, distributions, releases, modules, files and other MetaCPAN resources while often doing "what you mean" for common queries. It supports both simple lookups and rich, nested search specs for AND/OR/NOT-style queries and can return single entity objects or iterable result sets for large searches, including a scroller for pulling all matches. You can fetch POD, download URLs, autocomplete suggestions, recent releases and reverse dependencies, and plug in a custom HTTP user agent to add caching or other behavior, so it works well in scripts, services and tools. The module aims to track the MetaCPAN API closely and is actively maintained; recent updates add a count method, clean up type handling and fix author field handling.

EV::Etcd is a high-performance, asynchronous etcd v3 client for Perl that plugs the native gRPC Core C API into the EV/libev event loop, giving you nonblocking, callback-driven access to etcd from evented Perl programs. It exposes the full etcd feature set including key/value operations, watches with automatic reconnect and progress notifications, leases and keepalives, distributed locks, leader election, atomic transactions, cluster membership and maintenance tools, and the auth system with user and role management. Errors are returned as structured hashrefs that include gRPC status and a retryable flag so you can implement appropriate retry logic, and streaming operations handle transient failures automatically according to configurable retry and reconnect options. Keys and values are treated as raw bytes so you must encode and decode character data yourself, and EV::Etcd clients are not safe to reuse after fork because the underlying gRPC thread does not survive into child processes. The most recent release fixes several robustness issues including use-after-free and memory-leak bugs and corrects 32-bit integer truncation, making the client safer and more reliable for production use. If you need low-latency, fully featured etcd access from an evented Perl application, EV::Etcd is a practical, production-ready choice.

PAX is a tool that compiles a Perl program and its repeatable inputs into a single standalone executable that carries compiled code units, dependency payloads, embedded assets, and optional native artifacts so you can deploy a Perl app without the original source tree or a host CPAN install. You drive it with the public pax command set using pax build and pax run and a declarative paxfile.yml or inline entrypoints, and it supports packaging web apps with templates and static assets, self-hosting builds, and Docker-friendly multi-stage deployment. Recent updates added inline -I, -M and -e support so you can build or run one-off entrypoints from the command line and hardened build timeouts for more robust behavior on platforms like Alpine, but dynamic runtime loading still falls back to noncompiled paths, bundled-perl binaries are larger than thin wrappers, and cross-distro native portability is not guaranteed.

RT::Extension::AttachmentViewer is a lightweight plugin for Request Tracker 6 that converts the dropzone thumbnails into clickable previews so you can open attachments at full size in a popup rather than downloading them. It supports images, PDFs, audio, HTML and text files and will fall back to a browser download for types the viewer cannot render. Installation is straightforward: add the plugin to your RT_SiteConfig, clear the Mason cache and restart your webserver, and the source code is available on GitHub. If you use RT for ticketing and want faster inline inspection of attached files, this extension removes an extra step and speeds up review. Initial release 0.01 published 2026-04-29 by Gerald Sedrati.

Text::CSV_XS is a fast, production‑quality Perl module for reading and writing comma separated value data that gives you both a low level object API and a convenient high level csv function for common tasks. It parses CSV into arrays or hashes, writes arrays or arrayrefs directly to files or scalars, and supports flexible separators, quoting and escaping rules, header detection and munging, fragment selection, and streaming for large datasets. It handles embedded newlines and binary data when run in binary mode, offers UTF‑8 and BOM support, provides hooks and callbacks for filtering or transforming rows, and exposes detailed error diagnostics so you can validate and recover from malformed input. The module is mature and actively maintained and the latest release includes a security fix for a possible stack corruption issue, addressing CVE-2026-7111.

App::PerlGlue supplies a small command-line tool called perlglue that makes common text tasks easy by letting you use Perl expressions to filter, transform, and shape line-based text, CSV-ish files, and JSON Lines in a consistent way. You can do things like uppercase or lowercase streams, print or filter lines, run regex replacements on each line, pick CSV columns by header, convert CSV rows to JSON Lines, apply simple "{{field}}" templates per CSV row, and safely rename files with Perl substitutions. It is designed for developers and ops people who find ad hoc one-liners getting hard to maintain and want a readable, scriptable interface for everyday munging. Be aware that CSV parsing is intentionally simple and uses a basic comma/quote parser, conversion currently only supports JSONL output, and filter or replacement expressions are evaluated as Perl code so you should only run them on trusted input.

Email::Sender::Transport::Mailgun is a drop-in transport for the Email::Sender framework that sends MIME messages through Mailgun's messages.mime API, exposing Mailgun options like API key, domain, delivery time, DKIM and tracking controls as simple attributes you can set in code or via environment variables. It is ideal when you want to send well-formed MIME emails through Mailgun without using SMTP headers, and it supports region selection, retrying on 5xx API errors, and reading an API key from a file for containerized deployments. This module does not implement Mailgun's full messages API features such as templated batch sends or mailing lists, so if you need those advanced capabilities consider WebService::Mailgun or WWW::Mailgun instead. Recent updates added a convenient api_key_path option to load the key from a file and automatic retries for server errors.

App::Yath::Script is the lightweight entry point used by the "yath" test-harness script to bootstrap execution, load project and user configuration, pick a harness version, and hand off control to a version-specific script module (App::Yath::Script::V{X}). It provides the two main hooks the script uses, do_begin() for BEGIN-phase setup and do_runtime() for runtime delegation, and a handful of small utilities you can call from the script such as re-execing with preserved includes, normalizing paths, finding files up the directory tree, and converting module names to file paths. The module implements a practical version-detection policy so you can select a harness version via the first CLI argument, via versioned rc files or a symlinked .yath.rc, a local checkout in ./lib, or by falling back to the highest installed V# in @INC while keeping V0 reserved for explicit validation. Recent updates improved how the version is discovered by reading versioned rc filenames and honoring user-level rc overrides, making it easier to pin or override the harness version per project or developer.

Dist::Zilla::Plugin::Docker::API is a Dist::Zilla plugin that builds and optionally publishes Docker images from the files Dist::Zilla generates so you can produce container images alongside your Perl distribution releases. You can run it during the build or release lifecycle, choose whether to build from the build tree, the project source, or the release archive, and configure repository, Dockerfile, tags, push/load behavior, build arguments and OCI labels. The plugin supports template-driven tags and metadata, can push images to a registry or load them into the local Docker daemon, uses Docker daemon or environment credentials for registry access, and streams Docker build progress to your logs. This initial release offers tag templates, multiple context modes, configurable build options and real-time progress output, making it a straightforward choice for Perl authors who want automated Docker image creation and publication as part of their release workflow.

Test2::Harness is the backend test harness for Perl that runs and collects Test2 events, manages test processes, and provides the heavy lifting behind the user-facing App::Yath tool. It handles parallel and persistent runners, preload and reload support, resource management and timeouts, rerun and retry logic, coverage integration and a plugin system for things like git and system info. The module is aimed at projects with complex test workflows where you need scheduling, resource coordination, interactive inspection or advanced reporting rather than a simple one-off test run. You will normally use App::Yath for command line interaction, but Test2::Harness supplies the runner API, logging and orchestration that make features like shared job slots, persistent runners, and coverage aggregation possible. The project is actively maintained by Chad Granum on GitHub and recent releases have focused on scheduler resilience, resource-timeout and fail-on-resource-skip options, and fixes for encoding and flaky tests to improve stability. Choose Test2::Harness when you need a robust, extensible harness with deep Test2 integration and advanced test orchestration capabilities.

API::Docker is a Perl client for the Docker Engine API that provides a clean, object-oriented way to manage containers, images, networks, volumes, and to query daemon/system information. It connects to a local Docker daemon over a Unix socket or to a remote daemon over TCP and can automatically negotiate the highest API version supported by the server. The module is a pure-Perl implementation with minimal dependencies and uses Log::Any for logging. High-level API modules and entity classes let you list, create, start, stop, and remove containers, pull and push images, manage networks and volumes, and run exec commands inside containers. TLS support and certificate paths are available but currently marked experimental. This initial release was renamed from WWW::Docker and includes an HTTP/1.1 transport with chunked transfer support, making it a lightweight choice for programmatic Docker control from Perl.

MCP::Wiki is a small server library that turns a directory of Markdown files into a manageable, editable wiki. It extracts document structure for table of contents navigation, supports fine-grained paragraph-level edits, and can record changes using a git history so you keep versioned audit trails. You run it by pointing the server at a wiki root directory and optionally enabling git, and it is useful when you need a lightweight, file-backed documentation or wiki layer that can be integrated into other tools or workflows.

Developer::Dashboard is a Perl-based local “home” for day-to-day development that centralizes bookmarks, notes, small helper actions, repeatable checks, path and file shortcuts, and Docker Compose workflows behind one browser, prompt, and CLI entrypoint. It provides a lightweight web UI (default localhost:7890), a single dashboard command with many built-in helpers for querying JSON/YAML/TOML and opening files, a prompt integration that shows cached indicator status, and a collector system that prepares background health or status checks for fast prompt and UI rendering. The runtime is layered so a project-local ./.developer-dashboard can override a shared ~/.developer-dashboard while still inheriting defaults. There is a pluginable skills system for sharing command sets and pages, safe helper staging so global PATH is not polluted, and a deliberate access model that treats loopback requests as local admin while requiring helper accounts for remote access. Although implemented in Perl, the tool is language-agnostic and useful in polyglot repositories whenever you want a single, configurable place to keep links, repeatable tasks, status probes, and developer utilities.

RT::Extension::EmailReplyDelimiter is a small Request Tracker plugin that strips quoted content and any image attachments that follow a reply delimiter when mail is received, so only the user's actual reply is stored in the ticket. You enable it by adding the plugin and a list of delimiters to RT_SiteConfig.pm; delimiters may be literal strings or regular expressions, and recent updates add robust handling for quoted-printable and base64 encoded messages and better examples for removing Outlook-generated quoted text. It is useful for administrators who want to keep ticket histories clean and avoid duplicated quoted messages, but be aware that aggressive delimiter rules can remove forwarded content in some cases; the project and issue tracker are hosted on Codeberg and it is known to work with RT 4.2.16, 4.4.4, 5.0.1, and 6.0.2.

App::ClusterSSH is the internal core library that powers the ClusterSSH family of tools which open and control many terminal sessions at once. It provides the shared plumbing for parsing configuration, resolving and managing hosts and clusters, creating and tiling client windows, handling keyboard and paste events, macro substitution, sending text or commands to multiple sessions, and other cross-cutting features used by the user-facing scripts cssh, crsh, ctel, ccon and cscp. This module is not intended to be used directly by end users or applications; use the command-line utilities instead. Recent releases have added conveniences such as an external host_sort_command for custom window ordering, options to preserve host order and accept multiple config files, a configurable main window font, and improved clipboard behavior and release tooling.

OSLV::Monitor is a Perl module that adds OS-level virtualization monitoring to LibreNMS by loading a platform-appropriate backend such as FreeBSD or Linux cgroups and polling containers or jails for status and metrics. It provides a simple API where new constructs the monitor with options to choose the backend, set a cache and output directory (default /var/cache/oslv_monitor), filter which containers to include or exclude with regex lists, and adjust timing resolution, load initializes the chosen backend, and run performs the poll and returns structured results commonly emitted as JSON. This module is useful for LibreNMS administrators and system operators who want automated, configurable collection of per-container resource and status data across FreeBSD and Linux hosts.

Data::Path::XS provides fast, C-backed routines to read, write, delete and test values deep inside Perl nested hash and array structures using simple slash-separated paths. It offers four parallel APIs: a string-path API for convenience, an array-path API for binary-safe keys or empty components, a compiled-path API for reusing parsed paths in hot loops, and a keywords API that compiles to inline ops for near-native speed. path_set will autovivify intermediate containers and key semantics follow the parent container type so numeric pieces index arrays while other pieces act as hash keys, negative indices behave like Perl arrays, and UTF-8 flags are preserved. The string syntax does not escape slashes so use the array API when keys contain "/" or are empty. Note that write operations do not invoke tied STORE methods and will croak on tied containers, and compiled path objects should not be shared across threads. If you work with JSON-like nested data and need ergonomic access with options to optimize for repeated lookups or maximum throughput, this module is a strong choice.

This Perl module is a placeholder that exists only so CPAN will index the distribution and is not normally installed on a user system. The distribution itself is a command line tool for managing SlackBuilds from SlackBuilds.org, offering commands to search, query, build, install, remove and sync package repositories, and it has seen many usability and performance improvements over time. Recent changes include a new query option to list installed SBo packages that are not in the current repo and improved verbosity around git system calls. If you expected a reusable library this module is not relevant, but consult the distribution's scripts and documentation for the actual tool.

MARC::Validator is a compact Perl toolkit for validating MARC bibliographic records by discovering and running field-specific plugins. It provides a simple API to list available validators and ships plugins that spot common cataloging issues such as malformed ISBNs, duplicate control numbers, mismatches between leader/008 and field content, missing index or illustration indicators, genre tags like comics or manga, and UDC syntax in field 080. The module uses Module::Pluggable to find plugins, produces readable reports and recommendations from each check, and is aimed at library developers and cataloguers who need automated, field-level validation of MARC data. The project is actively maintained and the recent 0.18 release tightened UDC (080) checking and fixed a plugin detection bug.

Business::UDC is a lightweight Perl class for parsing, tokenizing and validating Universal Decimal Classification (UDC) strings, returning an abstract syntax tree, a list of tokens, the original source string and any parsing error. Instantiate it with a UDC string and then call is_valid to check syntax or ast and tokens to inspect the parsed structure, which makes it handy for library cataloging tools, import/validation pipelines and any system that needs to interpret UDC notations. The module focuses on syntax-level processing rather than classification logic, and the recent 0.04 release added detection of embedded spaces that are not allowed in UDC input and expanded tests for invalid strings.

MARC::Leader is a small utility for working with the leader portion of MARC bibliographic records. It converts a 24-character MARC leader string into a Data::MARC::Leader object and can serialize that object back into a leader string, so you can parse, inspect and rebuild record leaders in scripts and data pipelines. The module validates leader length and numeric fields and reports errors for malformed values, and it offers an optional verbose mode and integration with Data::MARC::Leader and helper printers for readable output. Recent updates added stricter numeric error reporting and a few robustness fixes, making it a reliable choice when you need programmatic access to MARC leader data.