CPANscan

Tickit is a high-level Perl toolkit for building full-screen terminal user interfaces using a tree of widget objects to describe layout and behavior. It provides rich rendering attributes like bold, underline, italic and 256 colors, mouse support including wheel and high-column position reporting, and advanced key handling via libtermkey, though those features depend on terminal support. Tickit includes a built-in event loop with non-blocking IO watches, timers, deferred callbacks, signal and child-process watches, and convenient key binding utilities with Ctrl-C bound to stop by default. You set a root widget, call run to enter the UI loop and stop to exit, and the library also exposes terminal size queries, UTF-8 locale handling and an option to avoid using the alternate screen. If you need to build interactive, asynchronous terminal apps in Perl with a widget-based API, Tickit gives a modern, feature-rich foundation.

Net::FullAuto is a Perl module that lets you script and automate operations across many machines by keeping persistent SSH and SFTP sessions open and exposing each remote host as a handle you can call cmd, put, get and cwd on just like a local object, so you can drive multi‑host workflows, file transfers, builds and deployments from a single script. It is agentless and works with standard ssh/sftp (and older telnet/ftp modes if needed), supports proxy‑chaining through intermediate hosts, returns stdout/stderr/exit codes for robust error handling, and includes features for locking, packaged "Instruction Sets" for common tasks and an optional Term::Menus text UI. Net::FullAuto is aimed at administrators and DevOps engineers who need interactive, real‑time control of many systems without installing agents, but be aware installs can update many CPAN dependencies and the docs warn against supplying cleartext passwords instead prefer identity files or key‑based login. The project is actively maintained and the latest release adds improved logout pattern matching and other stability tweaks.

Perl500503Syntax::OrDie is a lightweight guard you can drop into the top of a script to detect syntax and runtime uses that did not exist in Perl 5.005_03, so you can catch incompatibilities before deploying to legacy systems. When used it locates and scans the calling file, flags a long list of post‑5.005_03 language constructs and regex features, and installs CORE::GLOBAL overrides to prevent unsupported open and mkdir call patterns at runtime. You can also call the API directly with check_source or check_file to get a list of violations or die on error, and the scanner intentionally ignores literal string and regex contents so runtime data does not trigger false alarms. The module strives to run on every Perl from 5.005_03 onward and the latest 0.03 release cleaned up documentation and cheatsheets, fixed many masker false positives, and added regression tests to improve accuracy. Note that the masker is not a full Perl lexer so very odd quoting can still confuse it, dynamically generated code is not statically checked, and the CORE::GLOBAL overrides affect the whole interpreter so this is best used as a development or predeploy tool rather than in production.

Dist::Zilla::Plugin::UsefulReadme is a Dist::Zilla plugin that builds a focused README from your main module POD so you can choose which top level sections to include instead of dumping the entire documentation. It understands Pod::Weaver conventions and Pod::Readme style regions, can generate fallback content for common items like recent changes, requirements and installation instructions, and can emit README files in plain text, POD, Markdown or GitHub flavored Markdown or a custom format. You control the source module, output filename and location, which sections or regexes to include, how to handle readme-only regions and whether to add developer prereqs, and there are options for encoding and for appending or prepending extra content to generated sections. This is a practical successor to Pod::Readme for Dist::Zilla users who want concise, configurable readmes that play nicely with Pod::Weaver, and it requires Perl 5.20 or later. Recent maintenance updates refreshed metadata and packaging details and stopped signing distributions with Module::Signature.

Dist::Zilla::Plugin::AutomationPolicy is a Dist::Zilla plugin that creates a CPAN-META/automation-policy.json file for your distribution, letting you declare how automation is used and what automated contributions you accept. You configure it in dist.ini with options like template (for common presets such as no_automation, human_supervised, data_driven_updates, and full_automation), models, code_generation, automated_contributions, automated_actions, description, and an optional document name for a human-readable AI_POLICY.md that you must supply yourself. The plugin relies on Dist::AutomationPolicy and requires Perl 5.24 or later. The recent 0.1.1 release specifies the minimum Dist::AutomationPolicy version, added the metadata link, and includes the generated automation-policy.json in the distribution. Use this plugin when you want to ship a clear, machine-readable statement of your project’s automation practices alongside your CPAN release.

Mo::utils::Hash is a tiny utility module that provides three simple validators for Perl hash data: check_hash confirms a value is a hash reference, check_hash_keys verifies that a given nested set of keys exists, and check_hash_optional_keys ensures a hash contains only an allowed set of keys. Each function is called with your object or parameter hash and a key name and reports problems through Error::Pure while returning undef on success. The module is lightweight and handy for Mo-based classes or any code that needs concise, consistent runtime checks of hash parameters to catch bad or missing input early.

CPAN::MetaCurator is a toolkit for collecting, curating and publishing CPAN metadata in a small SQLite database and for turning Perl.Wiki content into navigable web trees. It reads Perl.Wiki exports (tiddlers.json) and 02packages data, populates a cpan.metacurator.sqlite database with modules and topics, and can produce HTML/jsTree output so you can browse topics and modules on a website. The distribution also includes utilities and scripts for checking module names, exporting module tables, adding clickable nodes and hover text, and optionally reading the CPAN::MetaPackager database to supplement its data. It is actively maintained and geared toward authors and site maintainers who want an offline, curated view of CPAN documentation and a simple pipeline to generate site content from Perl.Wiki. Recent work reworks the jsTree generation and fixes edge cases around “See Also” entries to make the generated tree cleaner and more reliable.

Sah::SchemaBundle::KDEActivity is a tiny collection of Sah schemas for working with KDE "activity" data in Perl, providing ready-made validators for activity GUIDs and activity names. It is useful if your Perl app needs to validate, document, or transform KDE activity identifiers and labels using the Data::Sah/Sah ecosystem. The bundle is deliberately small and focused, easy to drop into projects that already use Sah, and the source and documentation are available on MetaCPAN and GitHub if you want to inspect or contribute.

WWW::YaCyBlacklist is a small Perl utility for reading, parsing and applying YaCy-format blacklist patterns so you can test or filter URLs the same way a YaCy node would. It accepts patterns from files or arrays, optionally treats host parts as regular expressions, and provides convenient methods to check a single URL, return matching or non-matching lists, remove patterns, sort the list and write it back to a .black file. Note that check_url treats any non-http/ftp protocol as a match and the module does not enforce YaCy’s limitation on multiple wildcard stars in host patterns, which the author calls a YaCy quirk rather than a module bug. The 1.00 release improves regexp performance and adds parser error reporting, making URL checks both faster and more robust.

PAUSE::Users is a lightweight Perl module for reading PAUSE's 00whois.xml and presenting PAUSE account records as simple, iterable user objects. It automatically fetches and caches the central 00whois.xml file so your code only hits PAUSE at most once per default day, and you can tune caching with max_age expressed in Time::Duration::Parse notation or point the module at a local file or cache_path. The module exposes an iterator that yields PAUSE::Users::User objects with convenient accessors such as id, fullname, asciiname, email (or CENSORED), has_cpandir, homepage and introduced, and recent versions also include nologin, deleted and type slots. Mailing-list entries in the source file are ignored and the parser uses a pragmatic line-based approach for speed against the stable, machine-generated XML. Use PAUSE::Users when you need to script or display author metadata from PAUSE without manually downloading or parsing 00whois.xml.

Hypersonic is a performance-first micro HTTP server for Perl that JIT-compiles a native C event loop and request handling via XS::JIT so the hot path runs in C rather than Perl. You register routes in Perl, call compile to generate and load C code that bakes static responses and headers into the binary, and then run a lightweight server that supports TLS, streaming and SSE, WebSockets with optional rooms, gzip compression, sessions, async thread pools and static files preloaded into C for minimal runtime overhead. Dynamic routes still invoke Perl per request and you can inject custom C helpers or write route handlers that emit XS code for the absolute lowest latency. The module is aimed at people who need very high throughput APIs and real-time features and who are comfortable with a buildable C toolchain and optional libs like zlib and OpenSSL. Recent updates improved test robustness for slow debugging Perls by extending compile timeouts and made compile diagnostics quieter during JIT builds.

OpenAPI::Modern is a Perl tool for checking that HTTP requests and responses match an OpenAPI specification (v3.0, v3.1 or v3.2). You give it your OpenAPI document when you create the object and then pass HTTP messages to validate_request and validate_response; it converts many common request/response types to Mojolicious messages, deserializes parameters and bodies, applies JSON Schema validation and returns a detailed JSON::Schema::Modern::Result with errors, absolute locations and the deserialized data. The distribution bundles up-to-date OpenAPI metaschemas, supports schema dialects, type coercion and common media-type matching rules, and includes helpers like recursive_get and find_path_item for locating operations in the spec. It also offers caching guidance for large documents and options to populate defaults into deserialized data. There are some current gaps to be aware of such as multipart bodies, application/x-www-form-urlencoded encoding and automatic checking of Authorization headers as security schemes, but recent releases have expanded support for OpenAPI 3.2 and added correct handling of $ref targets inside media-type objects and the new itemSchema keyword.

JSON::Schema::Modern is a Perl evaluator and validator for JSON Schema that implements drafts 4, 6, 7, 2019-09 and the current 2020-12 specification. You give it either Perl data structures or JSON strings plus a schema or schema URI and it returns a Result object describing validation success, errors, annotations and defaults. The module is highly configurable with options such as specification version, output format, short-circuiting, format validation, stringy number handling and default collection, and it supports adding schemas or document objects to an internal cache, custom format validators, vocabularies, media type decoders and encodings. It also exposes helpers to traverse schemas and to validate schemas against their metaschemas. Limitations to be aware of are that it will not automatically load schema documents from disk or the network and some format checks require optional CPAN modules, and you should avoid running untrusted schemas because embedded regular expressions and numeric operations can be expensive or unsafe.

exact is a compact Perl pseudo-pragma that replaces a common pile of boilerplate with a single use statement, enabling strict and warnings, turning on modern feature bundles, handling UTF-8 for source and standard filehandles, setting C3 method resolution order, enabling filehandle methods, importing useful Carp helpers, providing try/catch/finally support, bringing in PerlX::Maybe helpers and autocleaning your namespace by default. It is highly configurable so you can opt out of any piece with simple flags, request specific feature bundles or Perl versions, load extensions under exact::* for context-specific behavior, and even declare parents or export methods via helper APIs like monkey_patch, add_isa, export and exportable. The module also exposes small utilities such as deat to clean up error messages and deattry to run a block and re-throw simplified errors. Recent updates added support for a defer block on older Perls and improved error and Carp helper handling, making exact a convenient choice for developers who want consistent, sensible defaults and easy extension without fighting repetitive header code.

Weenect::API is a lightweight Perl client for the Weenect GPS-tracking service that lets you log in to a Weenect account, retrieve the list of trackers, manage account preferences, and list animals associated with a tracker, all using simple method calls that return user, tracker, preferences, and animal objects for easy inspection and iteration. It is aimed at developers who want to automate account management, integrate Weenect devices into backend scripts or monitoring tools, or build custom reporting around tracker data. The initial release adds support for an enhanced live mode (super_live) and the new get_animals and get_preferences/set_preferences methods, so you can both read and update account settings and access animal associations directly from Perl.

Net::RCON::Minecraft is a lightweight Perl client for Minecraft's RCON remote console that lets you script server administration by sending commands and receiving their text responses. It manages TCP connection and authentication, handles fragmented replies, and returns a Response object with methods to get the raw text, a version with Minecraft color codes removed, or an ANSI-converted form for terminals. The API is simple: you can let it auto-connect on first command or explicitly connect and disconnect, set read timeouts, and handle errors via eval. Be aware that RCON grants operator-level access so you should use a strong password and firewall rules, and avoid RCON on unpatched vanilla servers older than 1.14.3 because of a known crash bug. As of version 0.04 the project now uses GitHub for issue tracking.

Spreadsheet::Edit is a Perl toolkit for loading, inspecting and transforming tabular data from CSV files or spreadsheet formats and for building sheets in memory. It makes columns easy to address by title, letter or automatic aliases and can tie package variables to columns so that inside an apply block you can read and write cells as ordinary scalars while rows behave as either arrays or hashes for flexible random or sequential access. You can insert, delete, move, split and join columns, sort or transpose rows, perform row-wise processing with handy magic variables, and write results back to CSV or create new spreadsheet files. The module auto-detects title rows, CSV encodings and separators and recent releases improved CSV import and spreadsheet conversion to preserve text, dates and leading-zero values when round-tripping to spreadsheet formats. It does not preserve cell formatting and reading spreadsheet files can fail if LibreOffice/OpenOffice is running, and thread safety is unknown.

Date::Find is a compact Perl utility for locating and extracting year, month and day sequences from filenames or other short strings, useful for organizing files by date or parsing timestamps embedded in names. It supports common date orders like ymd and dmy, returns matches as simple hashrefs via find_ymd, can report all found date patterns with find_all_ymd, and can group or guess the dominant format across many items with guess_date_format and guess_ymd. You can control behavior with options such as mode (strict or lax), a preference order for ambiguous formats, and which components to extract, and the module accepts dots or dashes as date separators. Recent updates fixed strict-mode extraction and added a few usability improvements, so it should behave robustly when deciding which date to prefer. For broader text extraction or timestamp-with-timezone needs consider Date::Extract or Filename::Timestamp.

Net::Async::Crawl4AI is an IO::Async-compatible, non-blocking client for the Crawl4AI service that wraps the synchronous WWW::Crawl4AI orchestrator and exposes the same high-level crawl and markdown workflows as Future-returning methods. It runs the Crawl4AI strategy chain asynchronously so you get the same WWW::Crawl4AI::Result objects without blocking an event loop. You can perform single-shot requests like crawl_once, md, screenshot, pdf, html, execute_js, llm and token, submit and poll crawl jobs with job_submit and job_status, or run the full async strategy via crawl or markdown. It also offers an asynchronous breadth-first deep_crawl that follows links with configurable concurrency and preserves per-page result objects. The module integrates with Net::Async::HTTP, honors the underlying client's retry policy, supports async callbacks that may return Futures, and requires adding the watcher to an IO::Async::Loop before use. This initial release focuses on providing the non-blocking client surface, job polling helpers, and concurrency-aware deep crawling for existing Crawl4AI deployments.

WWW::Crawl4AI is a Perl client and orchestrator for a self-hosted Crawl4AI service that runs a configurable chain of crawling strategies and returns a normalized, agent-friendly result object. It escalates from cheap headless fetches to full browser renders and stealth modes, with optional CloakBrowser attachment, proxy runs, or a user callback, and stops as soon as its classifier deems a page acceptable. Every attempt is modeled and recorded so you can see which backend produced the final page, the cost class, the final URL, and a complete attempt history with failure reasons. The module offers single-action methods for screenshots, PDF, preprocessed HTML, JS execution, LLM queries and JWT tokens, a health check, and a breadth-first deep_crawl that follows extracted links with options for max pages, depth, host restriction, URL filtering and per-page callbacks. Configure it with base_url, api_token, optional cloakbrowser or proxy endpoints or a callback coderef, fallback policies, timeouts and other tuning, or inject your own low-level client for raw REST use. Use WWW::Crawl4AI when you operate a Crawl4AI server and want cost-aware progressive crawling with transparent fallbacks and per-request diagnostics.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that gives you familiar dot-notation, filters, piping, and a large set of built-in functions for extracting, transforming, aggregating, and filtering JSON without needing the external jq binary or any compiled modules. It works as a library and as the jq-lite command line tool, supports optional safe key access and array helpers, returns native Perl scalars and references, and can use JSON::PP by default or alternate JSON decoders if available. The module is designed for minimal, restricted, or air-gapped environments such as lightweight containers, CI systems, legacy servers, and places where installing jq is not possible. It also includes an interactive REPL for experimenting with queries and many of jq's common helpers like map, select, walk, sort_by, group_by, and tojson/fromjson so you can port many jq workflows into Perl code or scripts.

Encode::Bijou64 provides simple, easy-to-use routines to convert non-negative integers to and from the Bijou64 variable-length byte encoding developed by Ink & Switch. It exports two functions, encode_bijou64 and decode_bijou64, so you can turn integers into compact byte strings and recover them later, with small values using fewer bytes and the format designed for fast decoding. Use this module when you need space-efficient storage or transmission of integers in Perl programs, for example in custom protocols or compact file formats.

Crypt::SMIME is a Perl class for handling S/MIME email tasks using OpenSSL's libcrypto, letting you sign, verify, encrypt and decrypt MIME messages from your Perl code. You create an object, load private keys and certificates from PEM or PKCS#12 and place trusted cert stores for verification, then call sign to make a detached S/MIME signature or encrypt to produce an S/MIME-encrypted message, and use check and decrypt to verify signatures or recover the original MIME content. The module can also detect whether a message is signed or encrypted, extract included certificates and signer certificates, report S/MIME capabilities, and lets you adjust verification time and CRL-checking behavior with flags. Defaults are sensible, for example AES-128-CBC is the default cipher, and the API will die on failures so errors are surfaced immediately, making this a practical choice when you need straightforward S/MIME support in Perl.

Lemonldap::NG::Portal is the portal component of the Lemonldap::NG Web Single Sign-On system that lets you add centralized authentication, authorization and accounting headers to protect web applications with minimal changes. It runs as a PSGI/Plack application and wires together modular plugins for authentication, user databases, second factors and issuers so you can mix and match LDAP, CAS, Apache-based auth and other backends. The portal handles full login flows, Ajax JSON and HTML responses, redirections and template rendering, and supports features like single logout, notification, password management and a double session mechanism. Configuration is reloadable at runtime and plugins are initialized from that configuration, so extensions must follow the portal plugin rules and treat configuration as read-only during requests. If a plugin fails initialization the portal will respond with an error, but the plugin model makes it straightforward to add custom auth or userDB modules. For more details and downloads see the Lemonldap::NG project site.

Lemonldap::NG::Manager is the web-based administration component for the Lemonldap::NG Web Single Sign-On system that exposes a REST API and ships a JavaScript (AngularJS) frontend so administrators can manage configurations, sessions, notifications and second-factor settings from a browser. It runs as a PSGI/Plack application so it is compatible with CGI, FastCGI and similar environments and includes tools for building the configuration UI and static assets. You can point it at your lemonldap-ng.ini or override options programmatically and control behavior such as access protection, enabled modules, logging level, language and template locations. The project is mature and historically moved away from a SOAP server toward a REST/portal approach, and documentation and the REST-API.md file in the source tree describe the available endpoints and UI structure. If you operate a Lemonldap::NG deployment and need a ready-made management console with a CLI and REST backend, this module is directly relevant.

Lemonldap::NG::Handler is the Apache protection module for the Lemonldap::NG Web‑SSO system and in this distribution acts as an alias for Lemonldap::NG::Handler::ApacheMP2. It sits in front of web applications served by Apache and enforces single sign‑on, session management and access rules, handling authentication, redirects, logout and header injection so protected sites do not need to implement their own SSO logic. It supports Apache 1 and 2 usage patterns, can protect CGI apps, work with shared configuration backends and cross‑domain setups, and includes helpers such as auto‑login for Sympa and proxy/POST login options for non‑compatible apps. Recent releases added CDA support in core, moved basic auth to SOAP, improved logging and introduced a double‑session mechanism. If you need to add centralized SSO and request‑level protection to sites served by Apache, this module is the appropriate component of the Lemonldap::NG stack.

Lemonldap::NG::Common provides the shared utilities and building blocks used across the LemonLDAP::NG Web single sign‑on suite, consolidating common configuration and runtime helpers for the Manager, Portal and Handler components. It collects reusable code such as SOAP wrappers and a WSDL builder, logging adapters for Apache2::Log and syslog, LDAP-backed storage for sessions and configuration, a cryptography object, a setApacheUser helper and a small safelib of rule utility functions so developers can extend or deploy LemonLDAP::NG without duplicating infrastructure code. Recent releases notably added SOAP/WSDL support, LDAP storage backends and improved logging wrappers. The module is part of the LemonLDAP::NG project, distributed under the GPL, with source, downloads and bug reporting available via the project website and OW2 GitLab.

Time::Str is a Perl module that makes it easy to parse and format date and time strings across a wide range of standards, turning human-readable timestamps into Unix epoch numbers or into detailed date components and turning epochs back into standard-formatted strings. Its three main routines are str2time to produce numeric timestamps with optional fractional seconds, str2date to return parsed components without forcing a timezone conversion, and time2str to format epochs with control over timezone offset, precision, and explicit nanosecond output. It understands ISO 8601 and its profiles such as RFC 3339 and RFC 4287, common Internet formats like RFC 2822 and HTTP dates, SQL and ASN.1 forms, iCalendar, ECMAScript, Common Log Format and several Unix/Git/Ruby styles, and it includes a permissive DateTime parser for many real-world variations. Timezone handling requires either a UTC designator or a numeric offset to produce an epoch, while timezone abbreviations are captured but intentionally not resolved by the module so you can handle ambiguous zones yourself. Fractional seconds are handled carefully with truncation on parse, rounding on format, and a nanosecond parameter for exact subsecond control, and the module interoperates cleanly with DateTime, Time::Moment and Time::HiRes. An optional XS (C) backend is used when available for performance with a Pure-Perl fallback, and you should be aware of a few limits such as English-only month and day names, no ISO week or ordinal dates, a supported year range of 0001 to 9999, and the deliberate choice not to map ambiguous timezone abbreviations to offsets.

Class::Utils is a tiny toolkit for Perl classes that makes handling hashref-based object parameters safe and predictable. It provides simple routines to apply key/value argument lists to an object, to fail fast on unknown keys, to ignore private keys that begin with an underscore, and to split incoming arguments into those that belong to the object and those that should be passed on unchanged. Use set_params to enforce allowed keys, set_params_pub to set only public (non-underscored) keys, set_split_params to assign known keys while returning the rest, and split_params to separate a specified set of object keys from other arguments. This module is useful when writing constructors or methods that accept mixed parameter lists and you want clear, defensive parameter handling. The most recent release focuses on documentation and metadata updates.

Graphics::Framebuffer is a pure-Perl graphics library for drawing directly to a Linux console framebuffer, offering a simple, immediate API for pixels, lines, shapes, filled primitives, gradients, TrueType text, image loading, animated GIF playback, blitting and basic transforms. It is aimed at developers who want lightweight, console-only graphics without X or a full GUI stack and exposes dozens of easy methods that take hashref parameters for speed. The module can use Imager and optional Inline::C acceleration to speed costly operations, supports multiple draw modes like normal, XOR, mask and alpha, and includes an emulation mode so you can develop offscreen on systems without a framebuffer. Important caveats are that it only works on framebuffer-capable drivers in a real console session, proprietary GPU drivers that do not expose a framebuffer will not work, and 24/32 bit modes are strongly recommended over 16 bit for correctness and performance. The package is mature and actively maintained; the current 7.03 release mainly updates documentation and adds a small Easter egg while recent releases improved testing, vsync handling, and added features like a pseudo 3D "ball" primitive and better handling of VirtualBox quirks.