CPANscan

ClamAV::Clamd is a lightweight Perl client for talking to a clamd antivirus daemon so your app can ask a local scanner to check uploads without linking libclamav or carrying the signature database. It supports scanning raw bytes, file paths, or open file descriptors and can hand a descriptor to clamd so the scanner reads a file without needing filesystem permission to the path. The module provides both blocking convenience methods and a small non‑blocking state machine you can drive from an event loop, and every scan returns a Verdict object with four distinct outcomes: clean, infected, unscannable, or error, which helps you avoid treating failures as safe. It prefers UNIX domain sockets for descriptor passing, exposes useful controls for timeouts and size limits, reports structured error codes when things fail, and can tell you whether fd‑passing actually works on the platform. Recent fixes make live test runs opt‑in to avoid talking to someone else’s daemon and ensure commands disabled in clamd (version, stats, reload) return a proper ERR_UNAVAILABLE response rather than being misinterpreted as data.

Hyperman is a production-focused PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with low overhead. Handlers can return Hyperman::Future objects so you can await timers or IO without blocking the worker, and the server exposes timers, readiness watchers, and a C ABI so other XS modules can integrate directly. It includes built-in features you expect from a modern server: fast C-side access logging, optional gzip compression with tunable level and thresholds, TLS with SNI and client certs plus kernel TLS when available, HTTP/2 support, multiple listeners and redirect helpers, and a safe spill-to-temp-file strategy for large request bodies. For pool-wide coordination it provides a shared memory pub/sub message bus and a fork-shared denylist and fixed-window rate limiter so limits and blocks are consistent across workers. The implementation is intentionally XS-heavy for performance and exposes hooks for per-worker startup and in-place TLS reloads. If you need a high-throughput PSGI server with async-friendly primitives, per-worker isolation, and low-latency inter-worker messaging, Hyperman is highly relevant; note that some backends such as io_uring have platform tradeoffs and compression costs CPU so they are opt-in or conservative by default.

App::GHGen is a command line tool that generates, analyzes, and optimizes GitHub Actions workflows so you can keep CI fast, secure, and up to date with minimal manual work. It can auto-detect your project type or let you choose and customize templates, then produce ready-to-run workflows that include caching, concurrency, appropriate permissions, and sensible test matrices. The built-in analyzer scans existing workflows for performance, security, cost, and maintenance issues, provides CI minute cost estimates, and can apply safe automatic fixes or open pull requests with the suggested changes. It also runs as a GitHub Action to comment on PRs, create fix PRs on a schedule, or enforce workflow quality as a CI gate. Targeted at maintainers of single repositories or many projects, it supports Perl and other common ecosystems and requires Perl 5.36 or later. Auto-fix is conservative and will skip complex project-specific logic, so reviewing changes before merging is recommended. The tool is open source and available on GitHub under the GPL2 license.

Punk is a batteries-included MVC web framework for Perl that provides a compact DSL to declare routes, controllers, static mounts, websockets, server-sent events and OpenAPI-mounted APIs, together with built-in support for sessions, CSRF, CORS, headers, caching, auth, named routes and testing. The application is compiled and frozen at to_app time so routing, guard chains and handlers run very cheaply and many configuration errors are caught at boot, and the supplied CLI can scaffold a working app, mount OpenAPI specs, run a dev server and exercise the app with an in-process test client. It also offers async-friendly primitives so handlers can return futures without pinning workers on compatible servers, a simple key/value cache with compute-if-miss, a cross-worker publish/subscribe bus for ephemeral notifications, and a C ABI for low-level observers. Punk intentionally delegates compression and some transport details to the PSGI server and validates options aggressively at boot to fail early. Be aware that the pub/sub bus is at-most-once and not durable, max_body enforces a request-length policy rather than providing memory isolation, and static file stat caching uses a short TTL that can delay noticing rapid edits. If you need an opinionated, production-ready Perl framework that favors fast, predictable dispatch and rich built-in features for web apps and APIs, Punk is a strong candidate.

Cron::Toolkit is a Perl module for parsing, describing and evaluating cron schedules with full Quartz 7-field support plus handy extensions like combined day-of-month and day-of-week logic, wrapped weekday ranges, and an internal Monday=1 weekday convention. It understands time zones and handles DST exactly like Quartz, produces human-readable English descriptions, can parse whole crontab files with environment expansion, and provides methods to get the next or previous occurrence, test a timestamp, dump the parsed abstract syntax tree for debugging, and convert between normalized and Quartz strings. The distribution ships with over 400 data-driven tests covering leap years, DST transitions and many edge cases, so it is a reliable choice when you need production-grade scheduling, accurate date calculations across time zones, or tools to inspect and reason about complex cron expressions. If you work with scheduled tasks or need precise control and debugging of cron rules, this module is likely relevant.

Alien::TALib is a helper module that downloads, builds and exposes the native TA‑Lib technical analysis C library so other Perl modules can find and link against it. It follows the Alien::Base/Alien::Build approach and provides simple methods like cflags and libs that you call from Build.PL or Makefile.PL to add the right compiler and linker flags when building Perl bindings such as PDL::Finance::TA. The distribution targets Unix‑like systems and is not supported on native Windows except under Cygwin or MSYS. Recent updates improve download reliability for the upstream zip and avoid probing older TA‑Lib installs on BSDs, making installation more robust across platforms.

Cavil::CLI is a command-line tool that checks your git change set or a directory against Cavil's indexed corpus of open source and commercial code to identify known files, report their licenses, and flag provenance or licensing risk. It is designed for use on a developer laptop and in CI pipelines, supports saving or sourcing a server URL and API token, and can output human readable text or machine readable JSON. The tool scans the current diff by default or an entire tree on demand, can limit checks to staged changes or a specific ref, and offers options to exclude packages or paths, skip hidden files, and control when the command should fail based on a configurable risk threshold. Use Cavil::CLI to catch reused code and licensing concerns early in development and automation workflows.

Plack::Middleware::OpenTelemetry is a Plack/PSGI middleware that adds OpenTelemetry tracing to your Perl web application by automatically creating spans for incoming HTTP requests. It extracts W3C trace context, records standard HTTP attributes such as method, status code, client and server addresses, full URL, user agent and response size, and it supports both synchronous and streaming responses while recording exceptions and setting span status. You can configure whether client errors (400–499) count as errors and supply custom resource attributes like service version or deployment environment. The middleware honors standard OTEL environment variables for exporter and service name and integrates with your OpenTelemetry SDK and exporters. Use it to get standards-compliant, out-of-the-box distributed tracing for Plack-based apps.

XS::Tutorial is a compact, example-driven guide for learning Perl XS that helps Perl programmers bridge Perl and C code. It is organized into three parts that walk you through passing and returning basic C values, handling multiple return values and arguments, and using common utility routines you will need when writing xsubs. The distribution also points to essential further reading and tools, including online XS guides, the Manning book "Extending and Embedding Perl", perldoc pages for perlxs, perlapi, perlguts and related topics, ExtUtils::MakeMaker for build options, Devel::PPPort/ppport.h for compatibility, and the Perl source for deeper investigation. If you need practical, hands-on examples to get started extending or embedding Perl with C, this tutorial is a useful starting place.

Business::ISBN::Data is a data-only companion for Business::ISBN that packages the ISBN Agency's RangeMessage.xml publisher and group ranges so Business::ISBN can validate, split, and format ISBN-10 and ISBN-13 values. You normally do not load it directly because Business::ISBN loads it for you, but the distribution also embeds default data and ships a copy of RangeMessage.xml. If you need newer data you can point the module at an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or dropping the file in the current directory, and if no file is found it falls back to the built-in data. The lookup data live in %Business::ISBN::country_data and include a _source entry showing where they came from. This module requires Business::ISBN 3.005 or later to accommodate an ISBN-13 data-structure fix, the project is hosted on GitHub for updates and contributions, and the data are refreshed regularly with recent maintenance including a fix to avoid unintended autovivification when reading the environment variable.

App::pod2gfm is the backend for the pod2gfm command line tool that converts Perl POD documentation into GitHub Flavored Markdown using Pod::Markdown::Githubert. It handles parsing command-line options and setting up input and output filehandles, supports writing to multiple output files without overwriting existing files, and defaults to UTF-8 rather than handling various encodings. Errors are reported to STDERR and the run method returns a nonzero exit status on failure. The latest fixes ensure that reading from standard input with the automatic output option writes to STDOUT instead of creating a file named "-.md" and add robust error handling so conversion errors are caught and reported cleanly.

Math::Histo::PDL bridges the Perl Data Language (PDL) and Math::Histo so you can build, fill and export 1D and 2D histograms directly from PDL piddles with minimal overhead. It provides convenient functions like hist1d and hist2d and attaches methods such as fill_pdl, to_pdl, counts_pdl and axis/center exporters onto Math::Histo objects, supports optional weights and error tracking, and exports counts, edges, centers and error arrays back to PDL. The module is tuned for throughput and can perform zero-copy ingestion of contiguous double piddles by passing their native C buffers into Math::Histo’s optimized core, while automatically coercing or materializing non-double or non-contiguous slices when needed. If you work with large numeric arrays in PDL and need fast histogramming or easy round trips between PDL and Math::Histo, this module will be very relevant, just ensure your hot-path piddles are double and physical to get maximum performance.

Math::Histo is a high-performance Perl XS wrapper around the libhisto C library that gives you fast, memory-safe 1D and 2D histogramming, streaming quantile sketches (DDSketch), online Welford moments, and non-linear curve fitting via Levenberg-Marquardt. It supports uniform and variable-width bins, weighted fills with optional sum-of-weights-squared bookkeeping, and very fast batch ingestion from Perl arrays or zero-copy packed 64-bit float buffers to exploit SIMD acceleration. The module exposes a rich set of statistical tools and convenience features including mean, variance, median and quantiles, mode and peak properties, skewness and kurtosis, rebinning and arithmetic operators, two-sample distances and hypothesis tests, and model fitting, plus compact binary and JSON serialization for storage or transport. If you need production-grade histogramming or summary statistics in Perl with C-level throughput and interoperability with native numeric buffers, Math::Histo is a solid choice.

Alien::libhisto makes the C libhisto histogramming, curve‑fitting and streaming quantile sketch library easy to use from Perl by locating a system install via pkg-config or building and installing a bundled copy with CMake into Perl's shared distribution directory. It is intended for Perl modules that call libhisto from XS or via FFI and integrates with common build systems so your Makefile.PL can pull in the library and your FFI::Platypus scripts can load it with dynamic_libs. Installation is automatic and portable across platforms, and recent updates synchronize the bundled libhisto to v0.3.0 while improving cross‑platform builds with fixes for Windows/MSVC, AArch64/ARM compilation, FreeBSD Clang issues, and support for the CMake NMake generator.

Typesense::Client is a lightweight Perl client for the Typesense search engine (v28 and later) that wraps the REST API so you can manage collections, index documents (including JSONL bulk import/export), run single and multi-search queries, use aliases and synonyms, apply curation overrides, work with analytics, and create scoped API keys. The module is a thin transport layer: it builds requests, applies your API key, decodes JSON and turns HTTP failures into exception objects by default, with an optional fail_open mode that returns undef and stores the error in last_error for graceful degradation. It does not model or validate schemas because Typesense performs that validation server-side, and note that Perl booleans must be passed as scalar references like \1 to be encoded as JSON true. This initial release provides full coverage of the Typesense v28+ API in a dependency-light package suitable for embedding search functionality into web apps and scripts.

PAGI::Server is a reference Perl HTTP server that implements the PAGI application protocol and provides HTTP/1.1, WebSocket, and Server-Sent Events with experimental HTTP/2 support, making it a good choice when you need a canonical, spec-compliant server for development, testing, or as a backend behind a reverse proxy. It focuses on clarity and correctness rather than microbenchmarks and includes production-oriented features such as optional TLS, Unix domain socket support, multi-listener and systemd socket activation, a prefork worker model with hot restart, per-connection limits and timeouts, streaming file responses, and IO::Async integration for embedding in an event loop. Experimental features and tunables are well documented and most work out of the box, but HTTP/2, Unix socket and multi-listener modes are still labeled experimental and Windows is not supported. The recent 0.002007 release tightens PAGI conformance by advertising PAGI 0.4, makes outbound event validation and strict send sequencing mandatory, and delivers a number of important HTTP/2 fixes and improvements including trailers support, safer per-stream backpressure and more reliable WebSocket-over-HTTP/2 framing, plus a raised nghttp2 dependency floor and the removal of the deprecated lifespan_mode 'off', so be sure to read the notes before enabling experimental features.

Markdown::Perl is a pure-Perl Markdown-to-HTML converter that aims to be flexible and configurable while following the CommonMark spec and many popular extensions. You can use it as an object or as simple functional calls, set named modes to mimic other processors, and tweak many options to control syntax and output. The module exposes hooks so you can resolve unresolved link references or receive parsed YAML front matter, and recent releases added support for directive container blocks and improved YAML parsing options. It is the engine behind the pmarkdown tool, so if you want a portable, Perl-native renderer with extension points for custom link or metadata handling, this module is a strong choice.

Database::Abstraction is a read-only ORM for Perl that presents a uniform, SQL-free interface to many backends such as CSV and PSV files, XML, SQLite, DBM::Deep, BerkeleyDB, remote HTML tables, or any DBI database via a DSN. You use plain Perl method calls or a chained query builder to do lookups, filtered scans, counts and joins, and you can pass rich criteria including comparison, pattern and set operators as well as logical groupings, with convenient AUTOLOAD column shortcuts for quick access. Small files can be slurped into memory for very fast lookups and there is optional CHI-compatible caching to speed repeated queries while schema introspection helps you inspect columns and types. It is ideal when you want to swap storage formats or avoid writing SQL, but note it is read only, the default CSV separator is nonstandard so set sep_char for RFC CSVs, slurp mode assumes a unique key and XML slurp is limited, and BerkeleyDB lacks joins and the chained query features.

PAGI is a modern specification for writing asynchronous web applications in Perl that extends the familiar PSGI idea to support long‑lived connections like WebSocket and Server‑Sent Events, making it a better fit for real time and streaming use cases. Instead of a single synchronous request/response function, a PAGI app is an async coderef that receives a scope describing the connection and two async callbacks, receive and send, that exchange messages via Futures so you can handle many incoming and outgoing events per connection. The PAGI distribution provides the stable specification and documentation, while a reference server and an application toolkit live in separate distributions, PAGI::Server and PAGI::Tools, which are currently beta, and there are migration guides and examples to help you bring existing PSGI code to PAGI. If you need to build or run async Perl web services, PAGI gives you a simple, standardized interface and an evolving ecosystem of frameworks and helpers to get started.

Map::Tube::Plugin::Graph is a Moo role that plugs into Map::Tube to turn a subway network into a proper graph object and into ready-made images for visualization or embedding. It can produce a multiedged, directed Graph you can analyze or hand to GraphViz2 for layout and export, and it can render whole maps or individual line maps to PNG, SVG, PDF, DOT and other formats with options for layout driver, overlap handling, file output or base64 encoding for web use. The API is simple: as_graph gives you the Graph for programmatic work, render lets you control format, driver and output, and convenience methods as_png and as_image return PNG bytes or a base64 string. You will need the GraphViz2 Perl interface and the GraphViz binary installed and GraphViz2 requires Perl 5.8.8 or newer. This module is useful when you want attractive, configurable tube-network diagrams or to combine network analysis with polished visual output.

Physics::CPD is a lightweight, pure-Perl toolkit for computing the standard parameters of a quasineutral, magnetised plasma from a small set of state variables such as density, electron and ion temperatures, magnetic field and ion species. Temperatures are provided in electron‑volts and other units are SI, and the module exposes simple read/write attributes plus methods that return commonly used diagnostics like Debye length, plasma and cyclotron frequencies, gyroradii, thermal and Alfven speeds, plasma beta, collision frequencies, Coulomb logarithm, mean free path and Spitzer resistivity. It is written with Moo so derived quantities are available as ordinary methods and convenience helpers like as_hash and report make it easy to inspect or print a plasma state. If you work on magnetic confinement fusion or space plasma problems the package gives quick, reliable estimates of the characteristic scales you need. The distribution also includes Physics::CPD::Stellarator, a submodule that adds stellarator geometry, Wendelstein 7‑X defaults, confinement scalings and theoretical D‑T fusion power estimates. The recent release renamed the CPAN distribution to Physics-CPD to align the upload identity with the primary module and clarified the Stellarator component as a modelling submodule.

AmberDB is a compact, high-performance flat-file database engine for Perl that uses DB_File to provide structured record storage, automatic primary keys, on-disk indexes and an ACID-like undo-journal transaction system. It exposes a simple CRUD API plus list, field, filtered and full-text search operations with packed 8-byte binary indexing for very fast ID handling, multi-dimensional facet indexing, tiered Active/Archived query modes, and record- or table-level locking for concurrent access. The module includes language-aware normalization for search (including Turkish-specific rules), runtime schema attribute overrides, and low-level table access for bulk read/write cases, but note that bulk batch operations bypass the transaction journal so single-record methods must be used when rollback safety is required. The recent 5.02 release is the initial public CPAN/GitHub release and highlights include the packed binary indexing pipeline, index-assisted full-text search with phonetic and locale normalization, facet bitset indexing, and a multi-granularity concurrency and transaction engine, making AmberDB a good fit when you want a fast, file-backed store without running a full RDBMS.

Music::CreatingRhythms implements the combinatorial algorithms from Hollos's book "Creating Rhythms" and provides a toolbox for generating and transforming rhythmic sequences. It can produce Euclidean rhythms that distribute onsets across beats, de Bruijn sequences, Christoffel words, paper-folding crease sequences, and common combinatorial families such as compositions, partitions, necklaces and permutations, plus helpers to convert between interval lists and binary on/off sequences. Many routines are direct, efficient ports of the original C implementations and the module also includes small utilities for counting, rotating, reversing and inverting sequence fragments. There are continued fraction utilities including a convergent calculator and an optional sqrt continued fraction routine that uses Math::NumSeq::SqrtContinued when available. Arguments sometimes differ from the book and the most recent release added an edge-case pfold test and documentation fixes. The module is lightweight, practical for algorithmic rhythm generation and is distributed under the Artistic License 2.0.

App::File::Grepper is a small Perl utility for recursively searching files in one or more directories for a text string or regular expression and optionally opening matching files in an editor or pager. You give it a pattern and it will treat leading slashes as Perl regexes while otherwise treating the input as literal text, apply case insensitivity by default when there are no uppercase letters or according to an ignorecase option, and let you further restrict which files are inspected with filter and exclude patterns that match basenames. It can automatically pass matching files to Emacs, vi or less, and it always skips common version control directories and editor backup files. This module is useful when you want a quick, scriptable search across a tree that can jump straight to matches in your editor, and you invoke it by calling App::File::Grepper->main with an options hash and a list of directories.

MCP::Server::KnowledgeStore::Tools::Agent is a small plugin that adds basic agent management commands to an MCP server backed by a KnowledgeStore. It exposes list_agents, get_agent, save_agent, tag_agent and untag_agent so you can store and retrieve agent definitions centrally, with the data kept as opaque blobs identified globally by name rather than being copied per project. Which projects an agent applies to is controlled by tags, allowing many projects to share an agent without duplication. The plugin is registered via its register method during the MCP::Server::KnowledgeStore::Tools build process, so you only need it if you want simple, tag-based, centralized storage and discovery of agent definitions.

Config::Model::TkUI is a Perl/Tk front end for Config::Model that gives you a graphical tree view and editors to inspect and change structured configuration data such as /etc/X11/xorg.conf using existing Config::Model classes. The left pane shows a navigable tree of nodes, lists and hashes while the right pane presents context aware viewers and editors with support for copy and paste, a searchable tree, an edit wizard that walks important or broken items, external editor integration, annotations and a review of unsaved changes before committing. It remembers font and UI settings, can show diffs for string values when available, and offers filtering options like hiding empty values or showing only custom values to reduce clutter in large configs. Recent releases added a history menu with previous and next location navigation and fixed several corner cases such as hash keys containing literal newlines and a garbled history path. If you already use Config::Model and want a friendly GUI to explore and edit complex configuration trees this module is directly relevant, though the author notes the Tk look and feel could still be improved and welcomes feedback.

MCP::Server::KnowledgeStore::Tools::Spec is a plugin for the MCP knowledge-store tooling that adds document-management commands for project-bound specifications, including listing, searching, fetching, saving, revision listing, marking specs as useful, and archival operations such as archive, restore, purge, and archived-list. It treats each spec as belonging to exactly one required project rather than using tag/untag semantics, so it is a good fit when you need strict project-scoped spec storage and lifecycle operations. You install it by calling its register method from MCP::Server::KnowledgeStore::Tools during server build, and it delegates the actual storage work to the provided store backend. This is the initial release of the module.

This module is a small plugin for the MCP::Server knowledge-store toolkit that adds a ready-made set of CRUD and maintenance tools for managing "skill" records. When registered with an MCP::Server and a backing store it exposes operations to list, search, fetch, save and revision-manage skills, plus tagging, marking a skill as useful, and the usual archive, restore, purge and archived-list actions. It builds on the generic revision-aware toolset and is pre-configured for searchable skill entries that do not use a separate "type" field. Use the register($server, $store) method to attach the tools to your server or let MCP::Server::KnowledgeStore::Tools call it during its normal build process.

MCP::Server::KnowledgeStore::Tools::Memory is a small plugin that wires a set of memory-management tools into an MCP::Server using a KnowledgeStore::Store. It registers commands like list_memories, search_memories, get_memory, save_memory, list_memory_revisions, mark_memory_useful, tag_memory, untag_memory and the archive, restore, purge and archived-list helpers so your server can store, search and manage revisioned memories. The module simply configures the generic Revisioned toolset for searchable memories that include a type field. You normally invoke it via MCP::Server::KnowledgeStore::Tools during server build, but you can also call register($server, $store) directly when integrating memory support into an MCP-based service.

MCP::Server::KnowledgeStore is a lightweight Mojolicious service that gives a network of MCP agents a single shared, append-only store for memories, skills, specs, and agents backed by PostgreSQL, so every agent reads and writes the same canonical data with full revision history preserved. It exposes an authenticated /mcp endpoint and a /health check, uses simple bearer-token authentication where each token name is recorded as the author, and offers environment-driven configuration including a one-time bootstrap token and options to skip migrations or disable irreversible purge operations. There is no user interface bundled; administration or UIs are expected to talk to the store like any other agent, which makes this a focused backend for projects that need a central, auditable knowledge store for cooperating MCP agents.