CPANscan

DBIx::RunSQL is a lightweight helper for running SQL from files, strings, or STDIN through DBI so you can initialize or reset databases from scripts or tests without writing boilerplate. It can create and return a DBI handle for in-memory SQLite, run SQL files or arrays of statements on an existing handle, continue on errors with a force mode, and emit verbose output via callbacks or custom filehandles. Select results can be formatted as tab-delimited output or via Text::Table and you can tweak behavior with options like rotating output, substituting a string for NULL, or returning a nonzero exit code when rows are found. The module also provides utilities to split SQL into statements and to parse or handle command line options for simple run-sql scripts. It is intentionally simple and does not implement a full SQL parser so multi-line constructs like triggers are handled heuristically, but recent releases improved trigger boundary detection and comment handling and switched split_sql to an iterator API so very large SQL files can be streamed without loading them entirely into memory.

Rose::DB is a focused DBI wrapper that gives Perl applications a logical data source abstraction and consistent connection and transaction management. You register named data sources by domain and type and Rose::DB returns driver-specific objects for Postgres, MySQL/MariaDB, SQLite, Oracle and Informix so connection details, connect options, and lifecycle handling are centralized and reusable. It manages DBI handles with retain and release semantics, provides high level transaction helpers like do_transaction, and includes vendor-aware parsing and formatting for dates, times, booleans and bitfields so your code can work with Perl objects instead of raw DB strings. The module is designed to be subclassed and integrates with registry, caching and config hooks for environment-specific setup. Note that Rose::DB is a data source abstraction layer and not an ORM, so pair it with Rose::DB::Object if you need object-relational mapping.

Archive::Libarchive::Peek lets you inspect the contents of archive files without extracting them to disk. Built on libarchive, it understands many formats such as compressed tar, zip, RAR and ISO images and can handle encrypted zip entries via a passphrase or callback and multi-file RAR sets. You can open an archive from a filename or from memory and then list entries, read a single entry's contents, iterate entries with a callback that receives filename, content and an Archive::Libarchive::Entry with metadata, or convert the archive into a hash of paths to contents. It is a simple, high-level convenience wrapper around Archive::Libarchive for scripts and tools that need quick, read-only access to archive contents. Recent releases added in-memory reading and an as_hash method, fixed a content truncation bug, and the current version raises the minimum Perl requirement to 5.22 while removing a dependency on Alias::Any.

Catalyst::Plugin::Static::Simple is a lightweight plugin for the Catalyst web framework that automatically serves static files from your application's root during development, mapping file extensions to correct MIME types so CSS, images, JavaScript and similar assets are returned directly without writing code. It uses MIME::Types for content-type detection and by default ignores template and HTML extensions so your view templates are still processed by Catalyst, though you can override that with configuration. You can tune behavior with options like include_path to search multiple directories, dirs to force entire directories to be static, ignore_extensions and ignore_dirs to block files or folders, custom mime_types, expires to control caching, and logging which is off by default. For production the module recommends letting your webserver serve static content for better performance and provides guidance for an Apache setup. There is also a serve_static_file method you can call from controllers to return dynamically generated or model-stored files as static responses. The module is mature and well maintained, and recent updates include moving the canonical repository to GitHub.

NepaliDateTime provides Bikram Sambat (B.S.) date and datetime support for Perl, giving you BS date objects and BS datetime objects with time, conversion routines to and from the Gregorian (AD) calendar, basic arithmetic like add_days and date difference, and formatting helpers including Devanagari output and strftime variants. It covers BS dates from 1975-01-01 to 2100-12-30 and uses AD 1918-04-13 = BS 1975-01-01 as its reference anchor while observing Nepal Standard Time (UTC+05:45). The API mirrors the Python nepali_datetime project and also provides convenience features such as fiscal year calculation for Nepal. The distribution is split into NepaliDateTime::Date and NepaliDateTime::DateTime and is released under the MIT license.

CPAN::Maker::Bootstrapper is a command line tool that scaffolds a complete, production-ready Perl distribution so you can go from idea to a buildable CPAN tarball with a single command. It creates a managed Makefile, a prefilled buildspec.yml, editable ".pm.in" and ".pl.in" sources, a minimal test, and an upgrade-safe .includes build system that runs dependency scanning, syntax checks, perltidy and perlcritic gates, and produces a distributable tarball via make. The tool can import existing projects into the scaffold, generate CLI stubs, install CI workflow helpers, and provides an extension point (project.mk) so your custom rules survive upgrades. It also includes optional AI-assisted workflows that use the Anthropic Claude API to run structured code and POD reviews, generate release notes, and support an annotate-and-resubmit review loop, with prompts and cost estimates to help manage token usage. Note the importer and stub options are mutually exclusive, imported files are copied as ".in" sources and not auto-tidied, and you may need to declare inter-module build dependencies in project.mk to avoid syntax-check ordering issues.

CPAN::Maker is a command line tool for Perl authors that turns a simple YAML "buildspec" into a complete CPAN distribution tarball, handling file staging, dependency resolution, Makefile.PL generation and the standard build steps so you do not need external bash scripts. It can validate buildspec files against a JSON schema for CI, preview or emit a Makefile.PL, and generate cpanfile dependency manifests from plain text lists, and it exposes options to control version pinning, test execution, cleanup of the temporary build area and output location. The workflow is declarative and reproducible, making CPAN::Maker a good fit for module maintainers who want an automated, schema-validated way to package and publish Perl distributions.

MooX::Role::SEOTags is a lightweight Moo role that helps Perl classes representing web pages generate standard SEO meta and social metadata such as OpenGraph and Twitter card tags. It expects your class to supply core attributes like og_title, og_type, og_description, and og_url and it supports optional attributes such as og_image, og_image_alt, and og_site_name. The role provides methods to render individual tags like title, canonical, description, OpenGraph fields, and Twitter fields, plus convenience methods to return all OpenGraph, all Twitter, or all tags at once for easy insertion into templates. Use it when you want consistent, reusable meta tag output for pages without handcrafting each tag.

App::GHGen is a command line tool for generating, auditing, and automatically improving GitHub Actions workflows so your CI runs faster, safer, and cheaper. It auto-detects project type or accepts an explicit language, creates ready-to-run workflows with sensible defaults for caching, concurrency, permissions, and matrix testing, analyzes existing workflows for performance, security and cost issues, and can apply safe fixes or open fix pull requests. It integrates as a GitHub Action to comment on PRs, create auto-fix PRs, or act as a CI quality gate, and supports a range of ecosystems including Perl, Node, Python, Rust, Go, Ruby, Docker and static sites. The recent 0.06 release adds built-in cross-platform Perl syntax linting, optional unused-variable checks and an import-hygiene lint, fixes several bugs, and updates the default Perl test matrix and gating so Perl workflows are more thorough out of the box. If you maintain one or many repositories and want to reduce manual CI maintenance while keeping workflows up to date and cost effective, App::GHGen is worth trying.

CLI::Simple is a lightweight, object-oriented base class for building modulino-style command line Perl tools that need options, subcommands and positional arguments. It uses Getopt::Long parsing and auto-generates getters for options and extra properties, integrates with Log::Log4perl including per-command log levels, and supports an optional role-based architecture driven by a YAML manifest so you can split commands into Role::Tiny roles and scaffold a CPAN-ready project. The module ships useful internal commands and helpers such as -dump-spec, -scaffold and -generate-completion for bash completions, a create-modulino helper, customizable help sections and optional pager output, and it keeps lifecycle and validation explicit via a simple init/run flow so you stay in control. The design favors minimal dependencies and pragmatic features like option and command aliases, custom error handlers and easy defaults. Recent updates add an automatic color appender for logging and make Term::ANSIColor an optional recommended dependency so you can get colored log output without forcing a hard dependency.

App::HTTPThis is the small engine behind the http_this command that makes it trivial to run a local HTTP server to serve a directory and optional directory indexes. It is essentially a thin wrapper around Plack::App::DirectoryIndex and exposes command line and config-file options to control host, port, whether autoindexing is enabled, prettier listings, Bonjour name publishing, and special handling for Windows Subsystem for Linux networking. The module defaults to binding to localhost for safety but you can restore all-interfaces behavior with a flag, and recent releases added a --host option and a --wsl mode plus improved config handling so command-line options take precedence. If you need a quick, no-friction way to share files, preview static sites, or run a tiny local web server, App::HTTPThis via the http_this command is a convenient choice.

lazy is a tiny convenience module that automatically installs missing Perl modules at runtime by delegating to App::cpm, so you can run one-off scripts without manually resolving dependencies. You can enable it on the command line with -Mlazy, in code with use lazy, or globally for test runs via PERL5OPT, and it supports installing into a local::lib directory with -L or passing extra App::cpm options through the import. By default it installs modules globally unless local::lib is already in use, making it handy for quick development and ad hoc testing but not intended to be left enabled in production. The recent 1.000002 release adds compatibility safeguards for older Perls by capping the App::cpm version on Perl < 5.24 and improves CI and test coverage to avoid breakage from newer cpm releases.

SimpleFlow is a compact, pure-Perl workflow helper that makes long shell pipelines easier to run, debug and reproduce by turning each step into a single task() call that cheks inputs, runs your shell command, times it, captures stdout and stderr, records exit status and signal, and verifies the declared outputs. It returns a simple hashref describing what happened so your script can log, fail fast or continue, and it skips steps whose outputs already exist to make pipelines restartable while offering a dry-run mode for inspection. A helper say2 prints messages both to STDOUT and a supplied log file with file/line provenance, and task() accepts options to control failure behavior and overwriting. Because it runs the command with Perl's system() you are responsible for supplying cross-platform commands, but SimpleFlow itself includes portable status decoding and logging. Recent updates added a single-file convenience option output.file and removed the Term::ANSIColor dependency to simplify deployment.

Catalyst::Plugin::Static::File is a minimal Catalyst plugin that gives your application a simple serve_static_file method to send one specific static file from a controller. It will set Last-Modified and Content-Length headers, determine the MIME type with Plack::MIME unless you override it, and attach the file path to the filehandle so Plack middleware like XSendfile and ETag can optimize delivery. This plugin intentionally only handles a single file and will throw a fatal error if the file does not exist, it does not validate filenames and it does not log, so you must validate any external input and use middleware such as Plack::Middleware::ConditionalGET for conditional requests. Use it when you need a lightweight, explicit way to return a known static asset from application code rather than serving a whole static directory.

WebService::Fastly is a Perl client for Fastly's REST API that lets you automate and script almost everything you can do in the Fastly control panel, from creating and configuring services, domains, backends, logging endpoints, and VCL or Compute code to managing users, billing, WAF rules, observability metrics, KV stores, and notification integrations. The client is generated from Fastly's OpenAPI spec and kept up to date with the platform, so it is useful for CI/CD pipelines, operational tooling, and programmatic reporting. It is maintained by Fastly, licensed under MIT, and links back to Fastly's Developer Hub for the authoritative API reference. Recent updates add new notification integrations (Datadog, Jira, OpsGenie, Splunk On-Call), improved Next‑Gen WAF simulation and workspace/account search, expanded observability and Compute metrics, and new routing and event-mapping APIs, but note that releases sometimes include breaking changes such as defaults or removed metrics, so review the changelog before upgrading.

File::Unpack2 is a Perl library and command line unpacker that identifies files by MIME type rather than filename and recursively extracts a wide range of archive and wrapped formats such as bz2, gz, zip, tar, cpio, rpm, deb, cab, lzma, 7z, rar and many common document payloads, exposing all unpackable contents even through multiple nested layers. It relies on libmagic and the shared-mime-info database to recognize multi-level types and chooses either built-in handlers or external shell-script helpers to unpack efficiently while recording every extracted item in a JSON-formatted logfile. The module provides safety and configuration options for destination layout, maximum unpacked file size, filesystem free-space checks, permission modes, symlink handling and one-shot or dry-run modes, and it is easy to extend by adding custom helper scripts. The author notes the MIME recognition code has to work around competing magic databases and that the shipped helper list is not exhaustive, but the plugin model makes adding missing handlers straightforward.

POE::Component::Metabase::Relay::Server is a POE component that accepts CPAN Testers reports sent via Test::Reporter::Transport::Socket, deserializes the Storable payloads, queues them in a local DB and forwards them to a Metabase server for storage and analysis. It runs as a POE session, can create a SQLite queue automatically, binds to one or more addresses and ports, and uses an HTTP client or libcurl for submissions when available. You can control parallel submissions, disable automatic curl usage or disable relaying entirely, and register hooks so your session receives an event whenever a report arrives or the queue changes. Use this module when you need a lightweight, configurable relay to collect test reports locally and reliably submit them into a Metabase instance.

App::ZofCMS is a lightweight, plugin-based Perl web framework and templating system designed for small to medium sites and very limited hosting environments where installing CPAN modules, using SSH, or running SQL is not possible. It uses a single index.pl dispatcher, page templates expressed as Perl hashrefs that fill an HTML::Template base, and page-specific plugins so you only load the functionality you need. A helper script can build a ready-to-upload site bundle so you can deploy without installing extra modules on the server. The author warns they no longer intend to maintain ZofCMS and recommends modern alternatives like Mojolicious, Catalyst, Dancer or Dancer2 for new projects, but recent updates have kept the distribution working and a 2026 change removed the App::ZofCMS::Plugin::GoogleTime plugin after its upstream dependency disappeared from CPAN.

Perl::Critic::PolicyBundle::LoopsAndLabels is a convenience bundle of Perl::Critic policies that help keep loop control flow and label usage safe and readable. Install this bundle to enable checks that require explicit labels on loops that use next, last, or redo, that forbid those loop-control keywords inside non-loop constructs like bare blocks, do{}, eval{}, anonymous subs and map/grep, and that flag goto LABEL when the target label is inside a loop or block. These policies are configurable via your perlcriticrc so you can tune when labels are required or when particular keywords are allowed, and they help catch both surprising runtime behavior and patterns deprecated by modern Perl. Recent releases converted the distribution into this policy bundle, merged the bare-block controls policy, and added the check against goto into constructs which is deprecated and due to become a fatal error in Perl 5.44.

MIDI::RtMidi::FFI is a lightweight Perl binding to the RtMidi C library that lets Perl programs talk to realtime MIDI devices and virtual ports across platforms such as ALSA, JACK, CoreMIDI and Windows Multimedia. It exposes a near-direct FFI interface for creating input and output devices, enumerating and naming ports, opening and closing ports, sending messages and installing callbacks for incoming events, and it can create virtual ports where supported. You will need librtmidi version 4.0.0 or later and the module pairs well with Alien::RtMidi for installing the native library, while MIDI::RtMidi::FFI::Device offers a higher level object interface if you prefer OO usage. This release is alpha quality so expect possible crashes, memory issues and API changes while the interface stabilizes, but it is useful now for developers who need low-level, realtime MIDI access from Perl.

Sereal::Encoder is a high-performance binary serializer for Perl that turns complex Perl data structures into compact Sereal-format byte strings for fast storage or transport and works together with Sereal::Decoder to rehydrate them. It provides both an OO interface (recommended for speed) and functional wrappers and offers built‑in support for optional compression (Snappy, Zlib, Zstd), string deduplication, control over how blessed objects are handled, and a FREEZE/THAW callback mechanism so classes can customize how they are serialized. Advanced options let you trade CPU, memory, and output size, enable a best‑effort canonical representation for repeatable encodings, control recursion depth, and tune numeric and floating point handling; note that Perl’s fuzzy string/number semantics and aliasing mean canonicalization has caveats. The encoder is thread-safe, supports protocol versioning (protocol 5 adds better float handling and Perl 5.36 boolean support), and for best results you should upgrade Sereal::Decoder before upgrading to encoder protocol 5.

Sereal::Decoder is a high-performance Perl module for deserializing data encoded in the compact Sereal binary format, supporting protocol versions 1 through 4 and designed for speed and small output size. It provides an object-oriented decoder with functional wrappers for extra speed, can extract optional per-document headers, supports incremental parsing from strings or files, and exposes bytes_consumed so you can detect trailing data. The constructor accepts many safety and tuning options such as refusing or not blessing objects, disabling automatic THAW calls, restricting which classes may be thawed, UTF-8 validation, limits on recursion depth and maximum array, hash or string sizes, and options to share small integers or make results readonly. The module implements a FREEZE/THAW callback mechanism for custom object serialization and documents how thawing is ordered and controlled, and it aims to be robust to invalid input by throwing Perl exceptions rather than crashing while noting that Snappy decompression can still cause issues on corrupted compressed data. Thread safe on modern Perls, Sereal::Decoder is a good choice when you need a fast, feature rich and configurable binary deserializer for interoperable Perl data exchange.

Sereal is a high-performance, compact binary serialization system for Perl that makes it easy to encode and decode complex Perl data structures quickly and with small output size. The top-level Sereal module is a thin wrapper that ensures both Sereal::Encoder and Sereal::Decoder are loaded and gives you convenience helpers such as shared encoder/decoder objects via get_sereal_encoder and get_sereal_decoder, simple file read/write helpers, and optional functional interfaces for one-off encode/decode calls. It supports compression backends and is designed for speed, so the object-oriented interfaces or the sereal_encode_with_object and sereal_decode_with_object functions are recommended for best throughput. Encoder and decoder are released separately so you can upgrade the decoder first to avoid compatibility problems, which makes Sereal a good choice for Perl developers who need fast, compact, and reliable binary serialization for network transfer or persistent storage.

WebService::Ollama is a Perl client for the Ollama API that makes it simple to run and interact with local large language models. It offers an object oriented interface plus an exportable ollama() functional call and supports chat, completion, embeddings, multimodal image input, streaming responses with callbacks, and structured JSON or JSON-schema outputs. You can manage models locally by creating, copying, deleting, loading and unloading them, and you can register tools for function calling or let the client drive automatic tool execution via chat_with_tools. The module uses OLLAMA_URL and OLLAMA_MODEL environment variables by default and the recent 0.08 release added the functional API and tool registration/chat_with_tools support while making async dependencies required for async operation.

Sisimai is a Perl library that parses and normalizes email bounce messages into structured Perl objects or JSON so you can automatically extract who bounced, why, and when. It reads mailboxes, Maildir folders, individual eml files or raw input from STDIN and exposes a simple API where rise() returns decoded objects with fields like recipient, addresser, delivery status, reply code, reason, timestamp and origin, and dump() returns JSON. You can enable options to include successful deliveries or vacation autoresponses, add callback hooks to inspect or augment headers and per-message processing, and use helper methods to list supported decoding engines, map error text to a canonical reason, or get the module version. Sisimai is aimed at anyone who needs reliable, machine-readable bounce analysis for mail operations, reporting, or automated handling.

Perl::Critic::Policy::Performance::ProhibitRegexForSimpleSubstring is a Perl::Critic rule that detects uses of plain regular expression matches when a simple literal substring check would do and recommends using index() instead for better performance. It flags m// or bare // matches that contain only literal characters and no modifiers, while intentionally ignoring cases that require real regex features such as modifiers, character classes, quantifiers, anchors, groups, interpolation, alternation, substitutions or qr//; it also does not flag grouped expressions even if the group body is purely literal. The policy has no extra configuration, is part of the Perl-Critic-Policy-Performance-ProhibitRegexForSimpleSubstring distribution, and this 0.01 initial release was contributed by Dean Hamstead under the MIT license.

Encode::Wide is a lightweight Perl utility for turning non-ASCII text into plain 7-bit ASCII safe for HTML or XML by replacing wide characters with entity references. It provides two functions: wide_to_html emits named HTML entities when available and also escapes ampersands, angle brackets and quotes for safe embedding in HTML fragments, while wide_to_xml always emits hexadecimal numeric entities and folds en/em dashes to a simple hyphen so the output is valid XML. The functions accept Perl Unicode strings, raw UTF-8 byte strings or scalar references and by default normalize existing entities to avoid double-encoding. Optional flags let you preserve trusted markup (keep_hrefs) or keep apostrophes literal for JavaScript contexts (keep_apos for HTML only), and a complain callback lets you log unexpected characters. Be aware that keep_hrefs shifts trust to the caller and can create XSS risks if used on untrusted input, and the module is designed for text fragments not whole HTML documents. The recent 0.07 release tightened security by suppressing entity decode when keep_hrefs is set, fixed a ReDoS risk in the ampersand-handling regex, removed unsafe eval-style replacements, and added tests, command-line helper scripts and a few additional character mappings including the trade mark (TM) symbol.

App::GrepUtils is a tiny toolkit of command-line helpers that extend the familiar Unix grep for common small tasks, making grep workflows simpler and more convenient. The distribution provides three utilities: grep-nonblank to filter matches while skipping blank lines, grep-nonblank-clipboard to produce similar filtered output and place it on the system clipboard, and grep-terms to search for one or more terms with optional highlighting. If you often run quick ad-hoc text searches, copy matched results to the clipboard, or need multi-term highlighting without building complex grep pipelines, these lightweight wrappers save keystrokes and reduce boilerplate. The current release is 0.007 and newly adds grep-nonblank and grep-nonblank-clipboard.

Concierge::Users is a user-record manager that gives your app a simple CRUD API for user profiles and lets you choose how data is stored, with backends for SQLite, flat files, or per-user YAML so you can pick production-ready database storage or lightweight file formats. You run a one-time setup to define the storage location and the field schema, including built-in core and standard fields plus custom application fields, then load the generated config at runtime to register, fetch, update, list, and delete users. The module validates input with a variety of validator types and will either reject bad data or warn and drop invalid fields depending on configuration, and it supports skipping validation for bulk imports. It also auto-manages system timestamps, archives existing data on schema changes to avoid accidental loss, and integrates with the rest of the Concierge suite while remaining usable on its own.

Concierge::Sessions is a lightweight session manager for Perl that gives your application a simple, consistent service layer for creating, retrieving, deleting and cleaning up user sessions. It supports a production-ready SQLite backend via DBI and a file-based JSON backend for testing and small deployments, stores any JSON-serializable data, enforces one active session per user, and implements sliding-window expiration plus optional indefinite sessions for application-wide state. The API returns uniform hashrefs so callers can check success and get either a session object or a descriptive error message, and session objects expose methods to read, modify and save data which extends the timeout. The module is written for modern Perl and emphasizes performance and predictable behavior, and the latest release fixes a crash during program shutdown by guarding the SQLite handle in DESTROY.