Dotpack CLI

Dotpack is a model-agnostic CLI tool designed to install and manage AI coding assistant configurations. It helps streamline the setup and usage of various AI agents, commands, and skills within your projects.

🚀 Getting Started

Installation

To install the Dotpack CLI globally, run the following command:

npm install -g dotpack
# or
pnpm install -g dotpack
# or
yarn global add dotpack

Authentication (License Activation)

Dotpack requires a license key for full functionality. Once installed, activate your license using the activate command:

dotpack activate <YOUR_LICENSE_KEY>

Replace <YOUR_LICENSE_KEY> with the license key you received after purchase.

Checking License Status

You can check the status of your license at any time:

dotpack status

Deactivating Your License

If you need to use your license on a different machine or simply want to deactivate it from the current one:

dotpack deactivate

✨ Usage

Initialize Dotpack in Your Project

To set up Dotpack in a new or existing project, navigate to your project's root directory and run:

dotpack init

This command will guide you through:

1. Pack Selection - Choose from available packs (Engineer, Marketing, Test)
2. Adapter Selection - Select which AI coding assistants to configure:
   • Gemini CLI - AI assistant for Google Gemini CLI
   • Cursor Rules - AI rules for Cursor editor
   • Claude Code - Anthropic's Claude Code assistant
   • Multiple - Configure multiple adapters simultaneously

Adapter Selection Options

# Interactive selection (default - all adapters checked)
dotpack init

# Auto-select all adapters 
dotpack init --yes

# Legacy single adapter selection
dotpack init -a cursor
dotpack init -a gemini
dotpack init -a claude-code

For a custom selection of agents, commands, and skills:

dotpack customize

Adding Components

You can add individual agents, commands, or skills to your existing Dotpack configuration:

dotpack add

Listing Installed Components

To see what agents, commands, and skills are currently installed:

dotpack list

Building / Regenerating Adapter Output

If you've made changes to your Dotpack configuration or need to regenerate the output for your AI coding assistant adapter:

dotpack build

Supported Adapters

Cursor Rules Adapter

• Output: .cursor/rules/ directory with YAML frontmatter rules
• Features: Migrates legacy .cursorrules files, generates agent/command/skill rules
• Usage: Open project in Cursor Editor and use @ rules like @engineer or @build in chat

Gemini CLI Adapter

• Output: .gemini/ directory with CLI configuration
• Features: Full CLI integration with specialized commands
• Usage: Start Gemini CLI in your project directory

Claude Code Adapter

• Output: .claude/ directory with Claude Code configuration
• Features: Slash commands, subagents with auto-delegation, context-based skill discovery
• Usage: Open project in Claude Code and use / commands like /build or /fix in chat

📚 Commands

CLI Commands

• dotpack init: Initialize Dotpack in the current directory.
• dotpack customize: Initialize Dotpack with a custom selection of components.
• dotpack add: Add agent, command, or skill.
• dotpack list: List installed components.
• dotpack build: Regenerate adapter output.
• dotpack activate <key>: Activate your license key.
• dotpack deactivate: Deactivate your license.
• dotpack status: Show your license status.
• dotpack license: Manage your license key.

AI Assistant Commands

Once initialized, your AI coding assistant will have access to specialized build commands:

Core Commands

• /build - Implement a feature with planning and testing
• /plan - Create a detailed implementation plan
• /fix - Debug and fix an issue
• /test - Run tests and report results
• /review - Review code for quality and issues

Specialized Build Commands

Frontend Development

/build:page /dashboard/users          # Build Next.js pages with App Router
/build:ui Button --variant=primary    # Create reusable UI components
/build:form UserProfile --validation  # Build forms with React Hook Form + Zod
/build:table Users --sortable         # Build data tables with sorting/filtering

Backend Development

/build:api /users --crud              # Create API endpoints with validation
/build:db users table                 # Generate Drizzle schemas and migrations
/build:auth login-flow                # Implement authentication flows

Full-Stack Development

/build:crud Product --admin-panel     # Generate complete CRUD operations

Each specialized command includes:

• Domain-specific constraints - Tailored to specific development patterns
• Technology integration - Works with your existing stack (Next.js, React, Drizzle, etc.)
• Best practices - Follows established conventions and security patterns
• Examples and guidance - Built-in help for common use cases

For more details on any command, use the --help flag:

dotpack <command> --help

🏗️ Project Structure

After initializing Dotpack, your project will have the following structure:

your-project/
├── .dotpack/                 # Dotpack configuration
│   ├── config.json          # Project configuration
│   ├── agents/               # AI agent definitions
│   ├── commands/             # Command workflows
│   └── skills/               # Technology-specific knowledge
├── .cursor/rules/            # Cursor editor rules (if selected)
│   ├── README.md
│   ├── planner/RULE.md
│   ├── engineer/RULE.md
│   ├── build/RULE.md
│   ├── build-api/RULE.md
│   └── ...
└── .gemini/                  # Gemini CLI config (if selected)
    ├── config.json
    └── ...

How Adapters Work

Cursor Rules Adapter:

• Converts agents, commands, and skills into individual rule files
• Each rule has YAML frontmatter with description, globs, and metadata
• Rules can be invoked in Cursor using @rulename syntax
• Automatically migrates legacy .cursorrules files

Gemini CLI Adapter:

• Creates a comprehensive CLI configuration
• Integrates all agents and commands into the Gemini workflow
• Supports the full command ecosystem with context-aware responses

🎯 Specialized Build Commands

The Engineer pack includes 8 specialized build subcommands designed for modern full-stack development:

Each command includes detailed workflows, technology constraints, and example usage patterns tailored to modern development practices.