CLI: Command-Line Interface

Overview

The Packmind CLI provides the following commands:

init - Initialize Packmind in your project (configure agents + install skills)
config agents setup - Configure which AI coding agents to generate artifacts for (interactive)
config agents list - List configured agents across packmind.json files
config agents add - Add coding agents to packmind.json files
config agents rm - Remove coding agents from packmind.json files
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
lint - Run detection programs (Enterprise only)
playbook diff - Show differences between local files and Packmind artefacts
playbook add - Stage a change between local files and Packmind artefacts
playbook submit - Submit local changes to Packmind
skills init - Install default Packmind skills locally
skills list - List all skills in your organization
standards list - List all standards in your organization
commands list - List all commands in your organization
packages create - Create a new package
packages add - Add standards, commands, or skills to a package
packages list - List all packages in your organization
update - Update the CLI to the latest version

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: Homebrew

Available on macOS and Linux.

brew tap PackmindHub/cli
brew install packmind-cli

After installation, the packmind-cli command will be available globally.

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 Homebrew if you prefer managing packages through your system package manager (macOS/Linux). 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

Manage AI coding agents configured in your packmind.json files. The config agents command provides subcommands for interactive setup, listing, adding, and removing agents.

Config Agents Setup

Configure which AI coding agents to generate artifacts for via an interactive prompt:

packmind-cli config agents setup

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/duo/ directory
OpenCode - Artifacts in .opencode/ directory
Codex - Artifacts in .agents/ 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.

Config Agents List

Display all configured coding agents across packmind.json files in a matrix view:

packmind-cli config agents list

The output shows a matrix with file paths as rows and agent names as columns, using checkmarks (✓) and dashes (-) to indicate which agents are configured in each file. Each file also shows its source — whether agents are configured locally (via the agents property in packmind.json) or inherited from organization settings. Use --path to scope the listing to a specific directory:

packmind-cli config agents list --path ./apps/api

Config Agents Add

Add one or more coding agents to all packmind.json files:

packmind-cli config agents add claude cursor

Use --path to target a specific directory:

packmind-cli config agents add --path ./packages/core claude

If the targeted files currently inherit agent configuration from organization settings, a confirmation prompt warns that adding local agents will override the organization-level defaults.

Config Agents Remove

Remove one or more coding agents from all packmind.json files:

packmind-cli config agents rm cursor copilot

Use --path to target a specific directory:

packmind-cli config agents rm --path ./apps/frontend claude

When all agents are removed from a file, the agents property is deleted entirely and the file reverts to organization-level defaults.

Supported Agents

Identifier	Agent
`claude`	Claude Code
`cursor`	Cursor
`copilot`	GitHub Copilot
`continue`	Continue.dev
`junie`	Junie
`agents_md`	AGENTS.md
`gitlab_duo`	GitLab Duo
`opencode`	OpenCode
`codex`	Codex

After adding or removing agents, run packmind-cli install to deploy or clean up the corresponding agent artifact files in your repository.

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-update-playbook skill) are automatically installed alongside your package contents.

Lock File (`packmind-lock.json`)

When you install or uninstall packages, the CLI generates a packmind-lock.json file alongside your packmind.json. This file records the exact versions of all installed artifacts.

Recursive Install (Monorepos)

By default, packmind-cli install (with no package slugs) 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.

packmind-cli install

To scope the recursive install to a specific directory, use the --path option:

packmind-cli install --path apps/frontend

The -r / --recursive flag is deprecated. Install is now recursive by default. Using the flag still works but will print a deprecation warning.

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:

packmind-cli lint src/

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

Lint a single file:

packmind-cli lint src/components/Button.tsx

When a single file is passed:

The CLI verifies the file exists and exits with an error if not
.packmindignore patterns are checked — if the file matches, it is skipped and the command exits with code 0
If the file is not in scope for the requested rule or standard (i.e. its extension doesn’t match the rule’s configured languages), an informational message is logged and no violations are reported

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 require 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.

Filtering by Severity

Use the --level flag to filter which violations are displayed based on their severity:

# Show only errors (suppress warnings)
packmind-cli lint . --level error

# Show warnings and errors (everything)
packmind-cli lint . --level warning

Value	What is displayed
`error`	Only error-level violations
`warning`	All violations (warnings and errors)

Without the --level flag, all violations are displayed regardless of severity.

CI/CD usage — Use --level error in your CI pipeline to focus on blocking violations only, while still running --level warning (or no flag) during local development to see all feedback. See Rule Severity for details on how severity affects exit codes.

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-onboard — A skill for initializing Packmind in projects
packmind-update-playbook - A skill to manage your playbook: create skills, commands and standards or update the existing ones.

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:

- 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 playbook add <path>
packmind-cli playbook submit --no-review

Arguments:

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

Example:

packmind-cli playbook add ./my-skill
packmind-cli playbook submit --no-review

Use --no-review to trigger a direct update. Omit --no-review to use the change proposals system and get validation of your changes.

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

See create a standard from the CLI to discover how you can create standards using the CLI.

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

packmind-cli playbook add path/to-command.md
packmind-cli playbook submit

The markdown file content will be used as the command’s prompt. The name of the command will be deduced from the file path.

The command markdown should be located in a directory where commands are available.Such directories include:

.packmind/commands
.cursor/commands
.github/prompts

Packages Command

Create and manage packages from the command line.

List Packages

packmind-cli packages list

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

Slug — The package identifier
Name — The display name

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.

Playbook Command

Manage local artifact changes and propose them to your team using a git-like staging workflow. The playbook command groups six subcommands: diff, status, add, rm, unstage, and submit.

View Differences

packmind-cli playbook diff

Compares your local artifact files (standards, commands, skills) against the versions published in Packmind. No changes are submitted. Example output:

Standard: Error Handling

  Rule (update)
  - Validate inputs at system boundaries and fail fast
  + Validate inputs at system boundaries, fail fast, and log the context

  Rule (add)
  + Preserve context when rethrowing errors

  Rule (delete)
  - Avoid swallowing exceptions silently

For each standard, the diff shows:

Rule (update) — a rule that was modified (Packmind detects this automatically using similarity matching)
Rule (add) — a new rule added locally
Rule (delete) — a rule removed locally

Options:

Flag	Short	Description
`--include-submitted`		Include already-submitted changes in the output
`--path <path>`	`-p`	Limit analysis to a specific path

Check Status

packmind-cli playbook status

Shows staged changes ready for submission and untracked local modifications. Example output:

Changes to be submitted:
  - Standard "Error Handling" (updated)
    .claude/rules/error-handling.md

Changes not tracked:
  - Command "Deploy" (modified)
    .claude/commands/deploy.md

Use `packmind playbook add <path>` to track them

Stage Changes

packmind-cli playbook add <path>

Stages a local artifact change for submission. The change type (created or updated) is detected automatically by comparing with the deployed version.

Stage Removal

packmind-cli playbook rm <path>

Stages an artifact for removal from the playbook. The artifact must have been distributed by Packmind. Alias: remove.

Unstage Changes

packmind-cli playbook unstage <path>

Removes a previously staged change from the playbook without submitting it.

Submit Proposals

packmind-cli playbook submit -m "Improve error handling rules for better observability"

Submits all staged changes as change proposals for team review in the Packmind web app.

Flag	Short	Description
`--message <text>`	`-m`	Message describing the intent behind the changes (max 1024 chars)

If you omit -m, Packmind opens your default editor so you can write the message interactively.

How Rule Updates Are Detected

When you modify a rule in a standard file, Packmind automatically determines whether the change is a rule update (the same rule was edited) or a separate deletion and addition (two unrelated rules). This keeps your change proposals clean and meaningful, showing reviewers exactly what was changed rather than an unrelated delete + add pair.

Requires a git repository — The playbook command requires your project to be in a git repository with a configured remote. Make sure you have run packmind-cli install to set up your packmind.json before using playbook.

Update Command

Update the Packmind CLI to the latest version.

packmind-cli update

This checks for a newer version and updates the CLI in place:

Standalone executable — Downloads the latest binary from GitHub and replaces the current executable automatically.
npm global install — Runs npm install -g @packmind/cli@latest to update through npm.

Example output:

Current version: 1.2.0 (standalone executable)
New version available: 1.2.0 -> 1.3.0
Downloading packmind-cli-macos-arm64...
Downloaded successfully (12.4 MB)

Updated to v1.3.0
Binary location: /usr/local/bin/packmind-cli

If you are already on the latest version:

Already up to date (v1.3.0)

Permission error on Linux/macOS — If you see a permission denied error, run the command with sudo:

sudo packmind-cli update

Check for Updates Without Installing

Use the --check flag to see if a newer version is available without performing the update:

packmind-cli update --check

This is useful in CI/CD pipelines or scripts where you want to detect outdated CLI versions without automatically upgrading. The command exits with code 1 if a newer version is available, and code 0 if already up to date. Example:

if ! packmind-cli update --check; then
  echo "A new version of packmind-cli is available. Run 'packmind-cli update' to upgrade."
fi

The update command is available for standalone executables and npm global installs only. If you manage the CLI through a local package.json, update it with npm update @packmind/cli instead.

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

Playbook Maintenance

Tools & Integrations

Governance

Linter

Administration

Security & Privacy

​Overview

​Installation

​One-click install (Recommended)

​Alternative: npm Package

​Alternative: Homebrew

​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

​Config Agents Setup

​Config Agents List

​Config Agents Add

​Config Agents Remove

​Supported Agents

​Setup MCP Command

​Supported Agents

​Interactive Mode

​Direct Mode

​Install Command

​List Available Packages

​View Package Details

​View Workspace Status

​Install Packages

​Lock File (packmind-lock.json)

​Recursive Install (Monorepos)

​Lint Command

​How Lint Works

​Basic Usage

​Specify a Path

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

​Output Formats

​Filtering by Severity

​Skills Command

​Initialize Default Skills

​List Skills

​Add a Skill

​Standards Command

​List Standards

​Create a Standard

​Commands Command

​List Commands

​Create a Command

​Packages Command

​List Packages

​Create a Package

​Package Identification

​Add Items to a Package

​Playbook Command

​View Differences

​Check Status

​Stage Changes

​Stage Removal

​Unstage Changes

​Submit Proposals

​How Rule Updates Are Detected

​Update Command

​Check for Updates Without Installing

​Related Documentation

Overview

Installation

One-click install (Recommended)

Alternative: npm Package

Alternative: Homebrew

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

Config Agents Setup

Config Agents List

Config Agents Add

Config Agents Remove

Supported Agents

Setup MCP Command

Supported Agents

Interactive Mode

Direct Mode

Install Command

List Available Packages

View Package Details

View Workspace Status

Install Packages

Lock File (`packmind-lock.json`)

Recursive Install (Monorepos)

Lint Command

How Lint Works

Basic Usage

Specify a Path

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

Output Formats

Filtering by Severity

Skills Command

Initialize Default Skills

List Skills

Add a Skill

Standards Command

List Standards

Create a Standard

Commands Command

List Commands

Create a Command

Packages Command

List Packages

Create a Package

Package Identification

Add Items to a Package

Playbook Command

View Differences

Check Status

Stage Changes

Stage Removal

Unstage Changes

Submit Proposals

How Rule Updates Are Detected

Update Command

Check for Updates Without Installing

Related Documentation