CommandKit Meta-Framework for discord.js

The commandkit-plugin-development skill provides the necessary tools and documentation for developers to extend CommandKit by creating custom plugins. It is designed for users who need to hook into the CommandKit lifecycle at either the runtime or compile-time stages.

Use this skill to accomplish the following tasks:

• Implement RuntimePlugin hooks to modify behavior during execution.
• Implement CompilerPlugin transforms to manipulate code during the build process.
• Extend the commandkit create templates to customize project scaffolding.
• Wire rolldownPlugins for advanced compile-time customization.

The commandkit-analytics skill provides integration for adding analytics to a CommandKit bot. It supports two primary providers: PostHog and Umami.

Use this skill to:

• Add analytics tracking to your bot.
• Instrument specific command or plugin events.
• Implement telemetry reduction or no-op operations for specific tasks to respect privacy or reduce noise.

Use @commandkit/redis to add Redis-backed shared infrastructure to your CommandKit application. This is specifically intended for multi-instance or distributed coordination scenarios where you need to share state across different runtime processes.

Common use cases include:

• Caching: Shared cache across multiple instances.
• Mutex: Distributed locking to prevent race conditions.
• Semaphore: Distributed concurrency control.
• Distributed State: Managing state that must be consistent across a cluster.

The commandkit-redis skill provides the necessary configuration and integration logic for implementing Redis-backed distributed infrastructure within CommandKit ecosystems. Use this skill when your application needs to scale beyond a single process or requires shared state across multiple instances.

Use cases

• Scaling: Moving beyond a single process to a multi-instance deployment.
• State Sharing: Sharing cache, locks, or rate-limit state across different service instances.
• Integration: Connecting Redis providers with existing CommandKit plugins or utilities.

The Agent example demonstrates several advanced AI-driven capabilities using CommandKit:

• Natural Language Commands: Interacting with the bot using everyday language instead of strict command syntax.
• Natural Language Poll Creation: Creating and managing polls through conversational inputs.
• AI Image Generation: Generating images from text descriptions via the Clipdrop API.
• Context-Aware Chatbot: Engaging in natural conversations where the bot maintains context for relevant responses.
• Channel Management: Effortless creation and management of Discord channels.

The commandkit-queue skill is designed to help developers implement queue-based architectures using the @commandkit/queue package. Use this skill when you need to decouple message processing from command execution or implement publish/subscribe workflows for bots.

Key use cases:

• Implementing publish/subscribe bot workflows.
• Configuring queue drivers (such as Redis-backed drivers).
• Decoupling message processing from command execution to improve system responsiveness and reliability.

When applying this skill, consider:

• The producer/consumer flow.
• Transport and driver constraints.
• Delivery reliability requirements.

Use the @commandkit/cache plugin to implement deterministic caching for read-heavy workloads. This plugin supports 'use cache' directives, cacheTag/cacheLife strategies, and revalidateTag invalidation. You can choose between a memory provider or a Redis provider depending on your deployment topology.

// Implementation overview:
// 1. Register cache() plugin
// 2. Add 'use cache' to deterministic async functions
// 3. Design tags and TTLs
// 4. Use revalidateTag for invalidation

The @commandkit/tasks plugin allows you to implement recurring jobs (cron), delayed reminders, and background processing flows. It supports both static task definitions and dynamic task creation using a driver-based architecture.

Execution Workflow

To implement tasks correctly, follow these steps:

1. Register the tasks plugin in your configuration.
2. Configure and initialize a driver (e.g., Redis or a local driver).
3. Add static tasks for predefined jobs and implement dynamic creation APIs for jobs created at runtime.
4. Implement resilience by adding idempotency, error handling, and cancellation support.

The commandkit-workflow skill is designed for implementing workflow orchestration patterns using the @commandkit/workflow package. Use this skill when you need to:

• Implement durable, long-running bot flows.
• Decompose complex logic into discrete, manageable workflow steps.
• Wire together a workflow runtime with specific triggers.

When applying this skill, you should define your target multi-step processes, establish expectations for durability and restarts, and identify integration points with existing commands or events. The goal is to produce a workflow plugin integration, a structured step orchestration, and a reliability-oriented implementation.