CLI: Command-Line Interface

Overview

The Packmind CLI provides the following commands:

init - Initialize Packmind in your project (configure agents + install skills)
config agents - Configure which AI coding agents to generate artifacts for
login - Authenticate with your Packmind instance
logout - Clear stored credentials
whoami - Show current authentication status
setup-mcp - Configure MCP for AI coding agents
install - Download packages locally
uninstall - Remove packages from your project
onboard - Scan project and generate standards/commands/skills
lint - Run detection programs (Enterprise only)
skills add - Import skills into Packmind
skills init - Install default Packmind skills locally
skills list - List all skills in your organization
standards create - Create a coding standard from a playbook file
standards list - List all standards in your organization
commands create - Create a reusable command from a playbook file
commands list - List all commands in your organization
packages create - Create a new package
packages add - Add standards, commands, or skills to a package

Installation

One-click install (Recommended)

The easiest way to install and configure the Packmind CLI is using the one-click install available in the Packmind web interface. Where to find it:

During your first onboarding after creating an account
Anytime in your Account Settings page

What it does:

Downloads and installs the Packmind CLI binary for your platform
Authenticates you automatically with your Packmind account
Configures the Packmind MCP servers for AI coding agents detected on your machine (Claude Code, Cursor, VS Code/GitHub Copilot)
Sets up your PATH environment variable

Simply copy the provided command and paste it into your terminal. The script handles everything automatically.

Why this is recommended — The one-click install eliminates manual steps by combining installation, authentication, and MCP configuration in a single command. It also detects which AI coding agents you have installed and configures them automatically.

Alternative: npm Package

Node.js 22 or higher required.

Global Installation:

npm install -g @packmind/cli

After installation, the packmind-cli command will be available globally. npx (no installation required):

npx @packmind/cli install --list

This runs the CLI directly without installing it, always using the latest version.

Alternative: Standalone Executables

Download the appropriate pre-built executable for your platform from the GitHub Releases page. Available platforms:

Linux x64: packmind-cli-linux-x64-{version}
Linux arm64: packmind-cli-linux-arm64-{version}
macOS arm64: packmind-cli-macos-arm64-{version} (signed and notarized)
Windows x64: packmind-cli-windows-x64-{version}.exe

For Linux/macOS, make the executable runnable:

chmod +x packmind-cli-*-{version}

Optional: Move to a directory in your PATH for easy access:

# Linux/macOS
sudo mv packmind-cli-*-{version} /usr/local/bin/packmind-cli

# Windows: Move to a directory in your PATH or run directly

Choosing an Installation Method — Use one-click install for the simplest experience with automatic authentication and MCP setup. Use npm global if you want packmind-cli always available system-wide. Use npx for project-specific usage or testing without installation. Use standalone executables if you don’t have Node.js installed or need a specific binary for your environment.

Authentication

The CLI requires authentication to communicate with your Packmind instance. The easiest way to authenticate is using the login command:

packmind-cli login

This will:

Open your browser to the Packmind login page
After you authenticate, automatically receive credentials
Store credentials securely in ~/.packmind/credentials.json

For self-hosted instances, specify your host:

packmind-cli login --host https://your-packmind-instance.com

Manual code entry (if browser flow doesn’t work): You can also enter a login code manually from the web interface:

packmind-cli login --code YOUR_CODE_HERE

Logout Command

To clear stored credentials:

packmind-cli logout

This removes the credentials file. If you also have PACKMIND_API_KEY_V3 set as an environment variable, you’ll need to unset it separately:

unset PACKMIND_API_KEY_V3

Whoami Command

Check your current authentication status:

packmind-cli whoami

This displays:

Your API key (masked)
Connected host
Organization name
User name
Credential expiration status

API Key Authentication (PACKMIND_API_KEY_V3)

You can authenticate using the PACKMIND_API_KEY_V3 environment variable instead of the interactive login flow. This is the recommended approach for:

CI/CD pipelines — Automated environments where interactive login isn’t possible
Docker containers — Pass the API key as an environment variable
Scripted workflows — When you need non-interactive authentication

Getting Your API Key

Log in to your Packmind instance (Cloud or self-hosted)
Navigate to Settings (click your profile icon in the top right)
Scroll to the CLI Authentication section
Go to the Environment Variable tab
Click Generate New Key to create an API key (valid for 90 days)
Copy the generated key

Setting the Environment Variable

Set the PACKMIND_API_KEY_V3 environment variable with your API key:

export PACKMIND_API_KEY_V3="your-api-key-here"

To make this permanent, add it to your shell configuration file (~/.bashrc, ~/.zshrc, etc.):

echo 'export PACKMIND_API_KEY_V3="your-api-key-here"' >> ~/.zshrc
source ~/.zshrc

CI/CD Example (GitHub Actions)

- name: Install Packmind packages
  env:
    PACKMIND_API_KEY_V3: ${{ secrets.PACKMIND_API_KEY_V3 }}
  run: packmind-cli install -r

Credential Priority — When both a credentials file and the PACKMIND_API_KEY_V3 environment variable exist, the environment variable takes precedence.

Init Command

Initialize Packmind in your project. This is the recommended first command to run when setting up Packmind in a new project.

What Init Does

The init command performs two main actions:

Configures AI agents - Interactively select which AI coding agents to generate artifacts for
Installs default skills - Including skill creator, standard creator, and onboarding skills

Basic Usage

packmind-cli init

This will:

Present an interactive prompt to select which AI agents you use (Claude Code, Cursor, GitHub Copilot, etc.)
Save your agent configuration to packmind.json
Install Packmind’s default skills to the appropriate locations for your selected agents
Display a success message with next steps

Example output:

Select coding agents to generate artifacts for:

  1. [*] Claude Code
  2. [ ] Cursor
  3. [ ] GitHub Copilot
  ...

Enter numbers separated by commas (default: 1,2,3): 1,2

Configuration saved. Artifacts will be generated for: Claude Code, Cursor

Installing default skills...
Default skills installed successfully!
  Files created: 5

Packmind initialized successfully!
Next step: Run /packmind-onboard in your AI agent to onboard the project

First-time setup — Run packmind-cli init after installing the CLI and logging in. It’s the quickest way to get Packmind configured for your project. After initialization, use the /packmind-onboard skill in your AI agent to scan your project and generate project-specific standards and commands.

Config Command

Configure Packmind settings.

Config Agents

Configure which AI coding agents to generate artifacts for:

packmind-cli config agents

This presents an interactive prompt where you can select from supported AI coding agents:

Claude Code - Artifacts in .claude/ directory
Cursor - Artifacts in .cursor/rules/ directory
GitHub Copilot - Artifacts in .github/copilot-instructions.md
Continue.dev - Artifacts in .continue/ directory
Junie - Artifacts in .junie/ directory
AGENTS.md - Single AGENTS.md file at project root
GitLab Duo - Artifacts in .gitlab/ directory

The command auto-detects existing agent configurations in your project and pre-selects them. Your selection is saved to packmind.json.

Auto-detection — If you already have agent configuration files (like .cursor/ or .claude/), they will be automatically pre-selected when you run this command.

Onboard Command

Scan your project and generate standards, commands, and skills based on detected patterns.

When to Use Onboard

Use the onboard command when:

You want to scan your project after running init
You want to re-scan after project changes
You want to regenerate project-specific content
You want to scan a different directory

Basic Usage

packmind-cli onboard

Flags

Flag	Short	Description
`--path <dir>`	`-p`	Specify a different project path to scan
`--dry-run`	`-d`	Preview without writing files
`--yes`	`-y`	Skip confirmation prompts
`--push`		Push generated standards and commands to Packmind backend

Examples:

# Scan a different directory
packmind-cli onboard --path ./other-project

# Preview what would be generated
packmind-cli onboard --dry-run

Setup MCP Command

Configure MCP (Model Context Protocol) for your AI coding agents. This command automatically sets up the Packmind MCP server in your agents’ configuration.

Supported Agents

Claude Code (claude)
Cursor (cursor)
VS Code / GitHub Copilot (copilot)

Interactive Mode

Run without arguments to use interactive mode:

packmind-cli setup-mcp

This will:

Detect which AI agents are installed on your system
Present a selection prompt with detected agents pre-selected
Configure MCP for all selected agents

Direct Mode

Specify target agents directly using the --target (or -t) flag:

packmind-cli setup-mcp --target claude

Configure multiple agents at once:

packmind-cli setup-mcp --target claude --target cursor

Or using the short form:

packmind-cli setup-mcp -t claude -t cursor -t copilot

Automatic Setup — When you run packmind-cli login, the setup-mcp command runs automatically after successful authentication.

Install Command

Download commands, standards, and skills from packages to your local machine.

List Available Packages

packmind-cli install --list

View Package Details

packmind-cli install --show <package-slug>

View Workspace Status

See an overview of all packmind.json files and their installed packages across your workspace:

packmind-cli install --status

Example output:

Workspace packages status

packmind.json                        Packages
-----------------------------------------------------------------
./packmind.json                      generic
./apps/api/packmind.json             nestjs
./apps/frontend/packmind.json        frontend

3 unique packages currently installed.

This is useful for:

Understanding what packages are installed across a monorepo
Identifying empty or misconfigured packmind.json files (shown as <no packages>)
Getting a quick summary of unique packages in your workspace

Install Packages

packmind-cli install <package-slug> [additional-package-slugs...]

Example:

packmind-cli install backend frontend

This downloads all commands, standards, and skills from the specified packages and creates the appropriate files for your AI coding assistant.

Default skills included — When you install packages, Packmind’s default skills (including the packmind-create-skill skill) are automatically installed alongside your package contents.

Recursive Install (Monorepos)

For monorepos or projects with multiple packmind.json files, use the recursive flag to install packages across all locations:

packmind-cli install -r

Or the long form:

packmind-cli install --recursive

This finds all packmind.json files in your git repository and installs their configured packages. After installation, a summary shows how many distributions were notified to Packmind.

AI Agent Rendering — The files created by the install command depend on which AI agents are enabled in your organization settings. The CLI respects your organization’s configured agents and creates instruction files accordingly (e.g., AGENTS.md, .cursor/rules/, .github/copilot-instructions.md). The .packmind/ directory is always created regardless of your configuration. To configure which agents are enabled, see Manage AI Agent Rendering.

Lint Command

Enterprise Feature — The lint command is only available in the Enterprise edition.

Run detection programs against your codebase from the command line. This is useful for testing draft detection programs, verifying active programs, and integrating linting into your development workflow or CI/CD pipelines.

How Lint Works

The CLI supports two linting modes: Local Mode (recommended): When you have packmind.json files in your project, the CLI uses them to determine which standards to check against. The CLI automatically searches for all packmind.json files in your project tree:

Ancestor configs: Searches parent directories up to the Git repository root
Descendant configs: Searches subdirectories from your current location

All standards from packages defined in these packmind.json files are included in the analysis scope. This allows different parts of your codebase to have different standards while inheriting common standards from parent directories. To set up local linting, install packages using the install command. See Distribute Standards and Commands for details. Deployment Mode: If no packmind.json files are found, the CLI falls back to using standards that have been deployed to your Git repository through the web interface. See Deployment to learn about this approach.

Priority — When both local packmind.json files and deployments exist, the local configuration takes priority.

Basic Usage

packmind-cli lint .

This command:

Searches for packmind.json files in your project tree
Loads detection programs from the standards defined in your packages
Scans all files in the current directory (excluding node_modules, dist, and other common build folders)
Runs all active detection programs
Reports any violations found

Specify a Path

Lint a specific directory or file:

packmind-cli lint src/

packmind-cli lint /path/to/your/project

Limiting Scope with `--changed-files` and `--changed-lines`

When working on large codebases, you can focus the lint check on only the files or lines you’ve modified using the --changed-files and --changed-lines flags.

Git Repository Required — The --changed-files and --changed-lines flags requires your project to be in a Git repository.

Deprecated Option — The --diff option is deprecated. Use --changed-files (equivalent to --diff=files) or --changed-lines (equivalent to --diff=lines) instead.

Check modified lines only:

packmind-cli lint . --changed-lines

This analyzes only the specific lines you’ve changed, making it ideal for pre-commit hooks or reviewing your work before pushing. Check modified files only:

packmind-cli lint . --changed-files

This analyzes all content in files you’ve modified, useful when you want full context but don’t want to scan the entire codebase. Example workflow:

# Make some changes to your code
git add .

# Check only what you changed
packmind-cli lint . --changed-lines

# If clean, commit
git commit -m "Your changes"

Output Formats

Choose between human-readable and IDE-friendly output:

packmind-cli lint . --logger=ide

Human-readable format (default) shows:

File paths with violations
Line and character positions
Rule identifiers
Summary of total violations found

IDE format provides structured output that can be parsed by editors and CI/CD tools.

Skills Command

Manage skills in your Packmind organization. Skills are reusable knowledge packages that AI coding assistants can discover and use.

Initialize Default Skills

packmind-cli skills init

This command installs Packmind’s default skills locally, including:

packmind-create-skill — A skill that guides you through creating new skills with AI assistance
packmind-create-command — A skill that guides you through creating reusable commands with AI assistance
packmind-create-standard — A skill for creating coding standards
packmind-onboard — A skill for initializing Packmind in projects

After running this command, you can use these skills in your AI coding assistant:

/packmind-create-skill - Create new skills
/packmind-create-command - Create new commands
/packmind-create-standard - Create new standards
/packmind-onboard - Initialize Packmind in projects

Automatic installation — Default skills are also installed automatically when you run packmind-cli init, install a package with packmind-cli install, or when packages are distributed to your repository via the web app.

List Skills

packmind-cli skills list

This command displays all skills in your Packmind organization, showing:

Slug — The skill identifier
Name — The display name
URL — Direct link to view the skill in the web app
Description — What the skill does

Example output:

Available skills:

- packmind-create-skill
    Name: Create Skill
    URL: https://app.packmind.com/org/my-org/space/global/skills/packmind-create-skill/files
    Description: Guide for creating effective skills...

- my-custom-skill
    Name: My Custom Skill
    URL: https://app.packmind.com/org/my-org/space/global/skills/my-custom-skill/files
    Description: Custom skill for my project...

Add a Skill

packmind-cli skills add <path>

Arguments:

<path> - Path to the skill directory containing skill files

Example:

packmind-cli skills add ./my-skill

This uploads the skill to your Packmind organization, making it available for distribution to repositories. When uploading a skill that already exists, Packmind automatically compares the content:

If changes are detected, a new version is created
If the content is identical, no new version is created

See Skills Management for details on versioning.

Standards Command

Create and manage coding standards from the command line.

List Standards

packmind-cli standards list

This command displays all standards in your Packmind organization, showing:

Slug — The standard identifier
Name — The display name
URL — Direct link to view the standard in the web app
Description — What the standard covers

Example output:

Available standards:

- error-handling
    Name: Error Handling
    URL: https://app.packmind.com/org/my-org/space/global/standards/abc123/summary
    Description: Ensure errors are handled predictably...

- typescript-conventions
    Name: TypeScript Conventions
    URL: https://app.packmind.com/org/my-org/space/global/standards/def456/summary
    Description: TypeScript coding conventions...

Create a Standard from a Playbook File

packmind-cli standards create <file>

Arguments:

<file> - Path to a JSON playbook file containing the standard definition

Example:

packmind-cli standards create ./my-standard.json

This creates a new coding standard in your Packmind organization based on the playbook file.

Playbook File Format

The standard-playbook file is a JSON file with the following structure:

{
  "name": "Error Handling",
  "description": "Ensure errors are handled predictably with context and actionable feedback.",
  "scope": "Applies to all services and applications",
  "rules": [
    {
      "content": "Validate inputs at boundaries and fail fast"
    },
    {
      "content": "Preserve context when rethrowing errors",
      "examples": {
        "positive": "throw new PersistenceError('Save failed', { cause: e });",
        "negative": "throw new Error('Save failed');",
        "language": "TYPESCRIPT"
      }
    }
  ]
}

Required fields:

Field	Description
`name`	Standard name (displayed in the web app)
`description`	Context and purpose of the standard
`scope`	Where the standard applies
`rules`	Array of rules (at least one required)

Rule fields:

Field	Required	Description
`content`	Yes	Rule description (max ~25 words, starts with action verb like “Use”, “Avoid”, “Prefer”)
`examples`	No	Code examples showing correct and incorrect usage

Example fields (when provided):

Field	Description
`positive`	Code snippet showing correct implementation
`negative`	Code snippet showing incorrect implementation
`language`	Programming language (e.g., `TYPESCRIPT`, `JAVASCRIPT`, `PYTHON`)

Workflow tip — Use this command when you have standards defined as files in your repository or want to create standards without the MCP server.

Commands Command

Create and manage reusable, multi-step workflow commands from the command line.

List Commands

packmind-cli commands list

This command displays all commands in your Packmind organization, showing:

Slug — The command identifier
Name — The display name
URL — Direct link to view the command in the web app

Example output:

Available commands:

- add-a-new-rest-endpoint
    Name: Add a New REST Endpoint
    URL: https://app.packmind.com/org/my-org/space/global/commands/abc123

- setup-database-migration
    Name: Setup Database Migration
    URL: https://app.packmind.com/org/my-org/space/global/commands/def456

Create a Command from a Playbook File

packmind-cli commands create <file>

Arguments:

<file> - Path to a JSON playbook file containing the command definition

Example:

packmind-cli commands create ./setup-api-endpoint.json

This creates a new command in your Packmind organization based on the playbook file.

Playbook File Format

The command playbook file is a JSON file with the following structure:

{
  "name": "Add a New REST Endpoint",
  "summary": "Step-by-step guide for adding a new REST endpoint with validation, tests, and documentation",
  "whenToUse": [
    "When adding a new API endpoint to the backend service",
    "When extending existing API functionality",
    "When creating endpoints for frontend integration"
  ],
  "contextValidationCheckpoints": [
    "Do you understand the business requirement for this endpoint?",
    "Do you know the request and response data structures?",
    "Is the endpoint's purpose clear to all team members?"
  ],
  "steps": [
    {
      "name": "Define the Route",
      "description": "Create the HTTP route with appropriate method (GET, POST, PUT, DELETE) and path in your API configuration"
    },
    {
      "name": "Implement the Handler",
      "description": "Write the handler function that processes the request and calls the appropriate use case or service",
      "codeSnippet": "// Example Express handler\napp.post('/api/users', async (req, res) => {\n  const user = await userService.create(req.body);\n  res.status(201).json(user);\n});"
    },
    {
      "name": "Add Input Validation",
      "description": "Validate request parameters and body data before processing"
    },
    {
      "name": "Write Tests",
      "description": "Create unit and integration tests covering success and error scenarios"
    },
    {
      "name": "Update API Documentation",
      "description": "Document the endpoint with request/response examples and parameter descriptions"
    }
  ]
}

Command Identification

When you create a command, Packmind automatically generates a slug from the command name:

Name (provided by you): "Add a New REST Endpoint"
Slug (auto-generated): "add-a-new-rest-endpoint"

The slug is used for:

File naming: .claude/commands/packmind/add-a-new-rest-endpoint.md
AI agent invocation: /add-a-new-rest-endpoint
Command identification and distribution

If a command with the same slug already exists in your space, Packmind appends a counter (e.g., add-a-new-rest-endpoint-1) to ensure uniqueness. Required fields:

Field	Description
`name`	Command name (displayed in the web app)
`summary`	What the command does and why it’s useful
`whenToUse`	Array of scenarios when this command applies
`contextValidationCheckpoints`	Array of validation questions to clarify before starting
`steps`	Array of step objects (at least one required)

Step fields:

Field	Required	Description
`name`	Yes	Step title (e.g., “Define the Route”)
`description`	Yes	Clear instructions for what to do in this step
`codeSnippet`	No	Optional code example demonstrating the step

Workflow tip — Use this command when you have commands defined as files in your repository or want to create commands without the MCP server. Commands are particularly useful for capturing multi-step development workflows that your team performs regularly.

Packages Command

Create and manage packages from the command line.

Create a Package

packmind-cli packages create <name>

Arguments:

<name> - Name of the package to create

Options:

Flag	Short	Description
`--description`	`-d`	Description of the package

Example:

packmind-cli packages create "Backend Standards"

With a description:

packmind-cli packages create "Backend Standards" -d "Standards and commands for backend development"

This creates a new empty package in your Packmind organization. After creation, you can add commands, standards, and skills to the package through the web interface or by using the packageSlugs parameter when creating items via MCP.

Package Identification

When you create a package, Packmind automatically generates a slug from the package name:

Name (provided by you): "Backend Standards"
Slug (auto-generated): "backend-standards"

The slug is used for:

Package installation: packmind-cli install backend-standards
Package identification and distribution

If a package with the same slug already exists in your space, Packmind appends a counter (e.g., backend-standards-1) to ensure uniqueness.

Add Items to a Package

packmind-cli packages add --to <package-slug> --standard <standard-slug>
packmind-cli packages add --to <package-slug> --command <command-slug>
packmind-cli packages add --to <package-slug> --skill <skill-slug>

Options:

Flag	Description
`--to`	Target package slug (required)
`--standard`	Slug of the standard to add to the package
`--command`	Slug of the command to add to the package
`--skill`	Slug of the skill to add to the package

Examples: Add a standard to a package:

packmind-cli packages add --to backend --standard error-handling

Add a command to a package:

packmind-cli packages add --to backend --command create-api-endpoint

Add a skill to a package:

packmind-cli packages add --to backend --skill debugging-workflow

Workflow tip — Use this command after creating standards, commands, or skills via CLI to organize them into packages. This is particularly useful when automating package management in scripts or CI/CD pipelines.

Create your first command: Learn how to create commands with AI assistance
Packages Management: Learn about organizing commands, standards, and skills into packages
Linter: Automated Detection: Learn about how detection programs work
Standards Management: Create rules and add code examples
Skills Management: Create and manage reusable skills

Getting Started

Concepts

Tools & Integrations

Governance

Linter

Administration

Security & Privacy

​Overview

​Installation

​One-click install (Recommended)

​Alternative: npm Package

​Alternative: Standalone Executables

​Authentication

​Login Command (Recommended)

​Logout Command

​Whoami Command

​API Key Authentication (PACKMIND_API_KEY_V3)

​Getting Your API Key

​Setting the Environment Variable

​CI/CD Example (GitHub Actions)

​Init Command

​What Init Does

​Basic Usage

​Config Command

​Config Agents

​Onboard Command

​When to Use Onboard

​Basic Usage

​Flags

​Setup MCP Command

​Supported Agents

​Interactive Mode

​Direct Mode

​Install Command

​List Available Packages

​View Package Details

​View Workspace Status

​Install Packages

​Recursive Install (Monorepos)

​Lint Command

​How Lint Works

​Basic Usage

​Specify a Path

​Limiting Scope with --changed-files and --changed-lines

​Output Formats

​Skills Command

​Initialize Default Skills

​List Skills

​Add a Skill

​Standards Command

​List Standards

​Create a Standard from a Playbook File

​Playbook File Format

​Commands Command

​List Commands

​Create a Command from a Playbook File

​Playbook File Format

​Command Identification

​Packages Command

​Create a Package

​Package Identification

​Add Items to a Package

​Related Documentation

Overview

Installation

One-click install (Recommended)

Alternative: npm Package

Alternative: Standalone Executables

Authentication

Login Command (Recommended)

Logout Command

Whoami Command

API Key Authentication (PACKMIND_API_KEY_V3)

Getting Your API Key

Setting the Environment Variable

CI/CD Example (GitHub Actions)

Init Command

What Init Does

Basic Usage

Config Command

Config Agents

Onboard Command

When to Use Onboard

Basic Usage

Flags

Setup MCP Command

Supported Agents

Interactive Mode

Direct Mode

Install Command

List Available Packages

View Package Details

View Workspace Status

Install Packages

Recursive Install (Monorepos)

Lint Command

How Lint Works

Basic Usage

Specify a Path

Limiting Scope with `--changed-files` and `--changed-lines`

Output Formats

Skills Command

Initialize Default Skills

List Skills

Add a Skill

Standards Command

List Standards

Create a Standard from a Playbook File

Playbook File Format

Commands Command

List Commands

Create a Command from a Playbook File

Playbook File Format

Command Identification

Packages Command

Create a Package

Package Identification

Add Items to a Package

Related Documentation