skillmeat-cli

Original source / Raw SKILL.md

---
name: skillmeat-cli
description: |
  Manage Claude Code environments using natural language. Use this skill when:
  - User wants to add, deploy, or manage Claude Code artifacts (skills, commands, agents, MCP servers)
  - User asks about available skills or capabilities ("what skills exist for X?")
  - User wants to search for artifacts to solve a problem ("I need something for PDF processing")
  - Agent needs to discover or deploy capabilities for a development task
  - User wants to create, import, or share artifact bundles
  - User mentions "skillmeat", "claudectl", or managing their Claude Code setup
  Supports conversational requests and the claudectl power-user alias.
---

# SkillMeat CLI Skill

Natural language interface for managing Claude Code artifacts and environments.

## Quick Start

### Common Operations

| User Says | What Happens |
|-----------|--------------|
| "Add the PDF skill" | Adds `ms-office-suite:pdf` to collection |
| "Deploy canvas to this project" | Deploys canvas-design skill to `.claude/skills/` |
| "What skills do I have?" | Lists artifacts in current collection |
| "Search for database skills" | Searches all sources for database-related skills |
| "Update all my skills" | Syncs collection with upstream sources |
| "Remove the xlsx skill" | Removes artifact from collection |

### For AI Agents

When you identify a capability gap during development:

1. **Search** for relevant artifacts (don't announce this)
2. **Suggest** to user: "This task would benefit from the X skill. Would you like me to add it?"
3. **Wait** for explicit permission before deploying
4. **Deploy** only what was approved

**Never auto-deploy artifacts without user permission.**

---

## Workflows

### Discovery: Finding Artifacts

When user needs a capability or asks what's available:

```bash
# Search all sources
skillmeat search "<query>" --type skill

# Search with JSON output (for parsing)
skillmeat search "<query>" --type skill --json

# List what's in collection
skillmeat list --type skill

# Show artifact details
skillmeat show <artifact-name>
```

**Artifact Types**: `skill`, `command`, `agent`, `mcp`, `hook`

**Common Sources**:
- `anthropics/skills/*` - Official Anthropic skills
- `anthropics/example-skills/*` - Example/template skills
- Community sources (user-configured)

### Deployment: Adding Artifacts

When user wants to add or deploy an artifact:

**Step 1: Add to Collection**
```bash
# Add from official source
skillmeat add skill anthropics/skills/canvas-design

# Add specific version
skillmeat add skill anthropics/skills/[email protected]

# Add from any GitHub repo
skillmeat add skill username/repo/path/to/skill
```

**Step 2: Deploy to Project**
```bash
# Deploy to current project
skillmeat deploy <artifact-name>

# Deploy to specific project
skillmeat deploy <artifact-name> --project /path/to/project

# Check what's deployed
skillmeat list --project .
```

### Management: Updating & Removing

```bash
# Check for updates
skillmeat diff <artifact-name>

# Update specific artifact
skillmeat update <artifact-name>

# Update all artifacts
skillmeat sync --all

# Remove from collection
skillmeat remove <artifact-name>

# Undeploy from project
skillmeat undeploy <artifact-name> --project .
```

### Bundles: Sharing Setups

```bash
# Create bundle from current collection
skillmeat bundle create my-setup

# Sign bundle for distribution
skillmeat sign create my-setup.zip

# Import bundle
skillmeat bundle import setup.zip

# Verify bundle signature
skillmeat sign verify setup.zip
```

---

## claudectl Alias

Power users can use `claudectl` for simplified commands with smart defaults:

```bash
claudectl add pdf              # → skillmeat add skill anthropics/skills/pdf
claudectl deploy pdf           # → skillmeat deploy pdf --project .
claudectl search database      # → skillmeat search database --type skill
claudectl status               # → skillmeat list --project . --json
claudectl sync                 # → skillmeat sync --all
claudectl bundle my-setup      # → skillmeat bundle create my-setup
```

### Setup claudectl

Add to `~/.bashrc` or `~/.zshrc`:
```bash
alias claudectl='skillmeat'
```

Or for smart defaults wrapper, see [claudectl-setup.md](./references/claudectl-setup.md).

---

## AI Agent Guidelines

### When to Suggest Artifacts

**DO suggest** when:
- User explicitly asks about capabilities
- Clear capability gap identified (e.g., "process this PDF" but no PDF skill)
- User asks for help with a task that has a well-known skill

**DON'T suggest** when:
- Task can be completed without additional skills
- User is in the middle of focused work
- Suggestion would be redundant (skill already deployed)

### Suggestion Format

```
I notice this task involves [capability]. The [artifact-name] skill
could help with this. Would you like me to add it to the project?

It provides: [brief description]
Source: [source path]
```

### Permission Protocol

1. **Always ask** before deploying
2. **Show what will change** (files to be created)
3. **Confirm success** after deployment
4. **Suggest related artifacts** only if relevant

---

## Command Reference

For complete command documentation, see [command-quick-reference.md](./references/command-quick-reference.md).

### Most Used Commands

| Command | Purpose |
|---------|---------|
| `skillmeat search <query>` | Find artifacts |
| `skillmeat add <type> <source>` | Add to collection |
| `skillmeat deploy <name>` | Deploy to project |
| `skillmeat list` | List in collection |
| `skillmeat list --project .` | List deployed in project |
| `skillmeat show <name>` | Show artifact details |
| `skillmeat sync` | Sync with upstream |
| `skillmeat remove <name>` | Remove from collection |

### Artifact Resolution

The skill resolves fuzzy names to full identifiers:

| User Says | Resolves To |
|-----------|-------------|
| "pdf" | `ms-office-suite:pdf` or `example-skills:pdf` |
| "canvas" | `canvas-design` |
| "xlsx" | `ms-office-suite:xlsx` |
| "docx" | `ms-office-suite:docx` |

When ambiguous, present options and ask user to choose.

---

## Project Context Analysis

When recommending artifacts, analyze project context:

| Project Indicator | Recommended Artifacts |
|-------------------|----------------------|
| `package.json` with React | `frontend-design`, `webapp-testing` |
| `pyproject.toml` | Python-related skills |
| FastAPI imports | `openapi-expert`, backend skills |
| `.claude/` directory | Check what's already deployed |
| `tests/` directory | Testing-related skills |

See [analyze-project.js](./scripts/analyze-project.js) for analysis script.

---

## Error Handling

### Common Issues

| Error | Solution |
|-------|----------|
| "Artifact not found" | Check spelling, try `search` first |
| "Already in collection" | Use `deploy` to deploy existing artifact |
| "Permission denied" | Check directory permissions |
| "Rate limited" | Set GitHub token: `skillmeat config set github-token <token>` |

### Getting Help

```bash
skillmeat --help              # General help
skillmeat <command> --help    # Command-specific help
skillmeat web doctor          # Diagnose environment issues
```

---

## Related Skills

- **skill-builder**: Create new skills
- **skill-creator**: Design skill workflows
- **chrome-devtools**: Browser automation (example of CLI wrapper skill)


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### references/claudectl-setup.md

```markdown
# claudectl Setup Guide

`claudectl` is a simplified alias for SkillMeat with smart defaults for power users.

---

## Quick Setup

### Option 1: Simple Alias (Recommended)

Add to your shell configuration (`~/.bashrc`, `~/.zshrc`, or `~/.config/fish/config.fish`):

**Bash/Zsh:**
```bash
alias claudectl='skillmeat'
```

**Fish:**
```fish
alias claudectl 'skillmeat'
```

After adding, reload your shell:
```bash
source ~/.bashrc  # or ~/.zshrc
```

### Option 2: Wrapper Script with Smart Defaults

Create `~/.local/bin/claudectl`:

```bash
#!/bin/bash
# claudectl - SkillMeat with smart defaults
#
# Smart defaults:
# - --type skill (when not specified)
# - --project . (current directory)
# - --format json (when piped) or table (when tty)

set -e

# Detect if output is piped
if [ -t 1 ]; then
    FORMAT_FLAG=""
else
    FORMAT_FLAG="--json"
fi

# Map simplified commands to full commands
case "$1" in
    add)
        # claudectl add pdf → skillmeat add skill anthropics/skills/pdf
        shift
        ARTIFACT="$1"
        shift
        if [[ "$ARTIFACT" != */* ]]; then
            # Assume official source if no path
            ARTIFACT="anthropics/skills/$ARTIFACT"
        fi
        exec skillmeat add skill "$ARTIFACT" "$@"
        ;;
    deploy)
        # claudectl deploy pdf → skillmeat deploy pdf --project .
        shift
        exec skillmeat deploy "$@" --project .
        ;;
    search)
        # claudectl search query → skillmeat search query --type skill
        shift
        exec skillmeat search "$@" --type skill $FORMAT_FLAG
        ;;
    status)
        # claudectl status → skillmeat list --project . --json
        exec skillmeat list --project . --json
        ;;
    sync)
        # claudectl sync → skillmeat sync --all
        exec skillmeat sync --all
        ;;
    bundle)
        # claudectl bundle name → skillmeat bundle create name
        shift
        exec skillmeat bundle create "$@"
        ;;
    import)
        # claudectl import file → skillmeat bundle import file
        shift
        exec skillmeat bundle import "$@"
        ;;
    *)
        # Pass through all other commands
        exec skillmeat "$@"
        ;;
esac
```

Make it executable:
```bash
chmod +x ~/.local/bin/claudectl
```

Ensure `~/.local/bin` is in your PATH:
```bash
export PATH="$HOME/.local/bin:$PATH"
```

---

## Command Mappings

| claudectl | Full Command |
|-----------|--------------|
| `claudectl add pdf` | `skillmeat add skill anthropics/skills/pdf` |
| `claudectl add user/repo/skill` | `skillmeat add skill user/repo/skill` |
| `claudectl deploy pdf` | `skillmeat deploy pdf --project .` |
| `claudectl search database` | `skillmeat search database --type skill` |
| `claudectl status` | `skillmeat list --project . --json` |
| `claudectl sync` | `skillmeat sync --all` |
| `claudectl bundle my-setup` | `skillmeat bundle create my-setup` |
| `claudectl import setup.zip` | `skillmeat bundle import setup.zip` |
| `claudectl <anything-else>` | `skillmeat <anything-else>` |

---

## Tab Completion

### Bash Completion

Add to `~/.bashrc`:

```bash
_claudectl_completions() {
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prev="${COMP_WORDS[COMP_CWORD-1]}"

    case "$prev" in
        claudectl)
            COMPREPLY=($(compgen -W "add deploy search status sync bundle import list show remove undeploy diff update config collection mcp web" -- "$cur"))
            ;;
        add|deploy|remove|undeploy|show|diff|update)
            # Complete with artifact names from collection
            local artifacts=$(skillmeat list --json 2>/dev/null | jq -r '.[].name' 2>/dev/null)
            COMPREPLY=($(compgen -W "$artifacts" -- "$cur"))
            ;;
        collection)
            COMPREPLY=($(compgen -W "create list use delete" -- "$cur"))
            ;;
        *)
            COMPREPLY=()
            ;;
    esac
}

complete -F _claudectl_completions claudectl
```

### Zsh Completion

Add to `~/.zshrc`:

```zsh
_claudectl() {
    local -a commands
    commands=(
        'add:Add artifact to collection'
        'deploy:Deploy artifact to project'
        'search:Search for artifacts'
        'status:Show project status'
        'sync:Sync collection with upstream'
        'bundle:Create artifact bundle'
        'import:Import artifact bundle'
        'list:List artifacts'
        'show:Show artifact details'
        'remove:Remove artifact from collection'
        'undeploy:Remove artifact from project'
    )

    _describe 'command' commands
}

compdef _claudectl claudectl
```

### Fish Completion

Create `~/.config/fish/completions/claudectl.fish`:

```fish
complete -c claudectl -n __fish_use_subcommand -a add -d 'Add artifact to collection'
complete -c claudectl -n __fish_use_subcommand -a deploy -d 'Deploy artifact to project'
complete -c claudectl -n __fish_use_subcommand -a search -d 'Search for artifacts'
complete -c claudectl -n __fish_use_subcommand -a status -d 'Show project status'
complete -c claudectl -n __fish_use_subcommand -a sync -d 'Sync collection with upstream'
complete -c claudectl -n __fish_use_subcommand -a bundle -d 'Create artifact bundle'
complete -c claudectl -n __fish_use_subcommand -a import -d 'Import artifact bundle'
```

---

## Usage Examples

### Daily Workflow

```bash
# Start of day - sync everything
claudectl sync

# Find a skill
claudectl search "pdf processing"

# Add and deploy
claudectl add pdf
claudectl deploy pdf

# Check what's deployed
claudectl status
```

### Sharing Setup

```bash
# Create bundle of current collection
claudectl bundle team-setup

# Share the file, colleague imports:
claudectl import team-setup.zip
```

### Quick Status Check

```bash
# JSON output for scripting
claudectl status | jq '.[] | .name'

# Count deployed artifacts
claudectl status | jq 'length'
```

---

## Troubleshooting

### Command Not Found

Ensure `~/.local/bin` is in PATH:
```bash
echo $PATH | tr ':' '\n' | grep local
```

If not present, add to shell config:
```bash
export PATH="$HOME/.local/bin:$PATH"
```

### Permission Denied

Make script executable:
```bash
chmod +x ~/.local/bin/claudectl
```

### SkillMeat Not Found

Ensure SkillMeat is installed:
```bash
which skillmeat
# Should show: /path/to/skillmeat

# If not installed:
pip install skillmeat
# or
uv tool install skillmeat
```

---

## Customization

### Change Default Source

Edit the wrapper script to use a different default source:

```bash
# Change this line:
ARTIFACT="anthropics/skills/$ARTIFACT"

# To your preferred source:
ARTIFACT="your-org/skills/$ARTIFACT"
```

### Add Custom Commands

Add new cases to the wrapper script:

```bash
    my-command)
        # claudectl my-command → custom behavior
        shift
        exec skillmeat some-complex-command --with --flags "$@"
        ;;
```

---

## Comparison: claudectl vs skillmeat

| Aspect | claudectl | skillmeat |
|--------|-----------|-----------|
| Target user | Power users | All users |
| Defaults | Smart (current project, skill type) | Explicit |
| Output | Auto-detect JSON/table | Explicit flag |
| Commands | Simplified | Full |
| Use case | Quick operations | Full control |

```

### references/command-quick-reference.md

```markdown
# SkillMeat CLI Quick Reference

Condensed command reference for the skillmeat-cli skill.

---

## Command Groups Overview

| Group | Purpose | Key Commands |
|-------|---------|--------------|
| (root) | Core operations | `add`, `deploy`, `list`, `show`, `search` |
| `collection` | Multi-collection | `create`, `list`, `use` |
| `mcp` | MCP servers | `add`, `remove`, `list`, `enable`, `disable` |
| `bundle` | Sharing | `create`, `import`, `list` |
| `sign` | Security | `create`, `verify`, `list-keys` |
| `sync` | Updates | `(default)`, `--all`, `--dry-run` |
| `diff` | Changes | `artifact`, `collection`, `project` |
| `config` | Settings | `get`, `set`, `list` |
| `web` | Web UI | `dev`, `build`, `start`, `doctor` |
| `analytics` | Usage | `summary`, `trends`, `export` |
| `cache` | Performance | `clear`, `stats`, `config` |
| `vault` | Team sharing | `create`, `add`, `pull`, `push` |
| `context` | Context entities | `add`, `remove`, `list`, `show`, `sync` |

---

## Core Commands

### Search & Discovery

```bash
# Search all sources
skillmeat search "<query>"
skillmeat search "pdf" --type skill
skillmeat search "database" --type agent

# List artifacts
skillmeat list                    # All in collection
skillmeat list --type skill       # Filter by type
skillmeat list --project .        # Deployed in project
skillmeat list --json             # JSON output

# Show details
skillmeat show <artifact-name>
skillmeat show canvas-design --full
```

### Adding Artifacts

```bash
# Add skill
skillmeat add skill <source>
skillmeat add skill anthropics/skills/canvas-design
skillmeat add skill anthropics/skills/[email protected]
skillmeat add skill user/repo/path/to/skill

# Add other types
skillmeat add command <source>
skillmeat add agent <source>
skillmeat add mcp <source>

# Options
--collection <name>    # Target collection
--alias <name>         # Local alias
--force                # Overwrite existing
```

### Deploying Artifacts

```bash
# Deploy to project
skillmeat deploy <artifact-name>
skillmeat deploy canvas-design
skillmeat deploy pdf --project /path/to/project

# Options
--project <path>       # Target project (default: .)
--force                # Overwrite existing
--dry-run              # Preview changes
```

### Updating & Syncing

```bash
# Check for updates
skillmeat diff <artifact-name>
skillmeat diff --all

# Update
skillmeat update <artifact-name>
skillmeat sync                    # Sync collection
skillmeat sync --all              # Sync everything

# Options
--dry-run              # Preview changes
--force                # Force update
```

### Removing Artifacts

```bash
# Remove from collection
skillmeat remove <artifact-name>
skillmeat remove canvas-design

# Undeploy from project
skillmeat undeploy <artifact-name>
skillmeat undeploy canvas-design --project .

# Options
--force                # Skip confirmation
--keep-data            # Keep local data
```

---

## Collection Management

```bash
# List collections
skillmeat collection list

# Create collection
skillmeat collection create <name>
skillmeat collection create work --description "Work artifacts"

# Switch collection
skillmeat collection use <name>
skillmeat collection use personal

# Delete collection
skillmeat collection delete <name> --force
```

---

## Bundle Operations

```bash
# Create bundle
skillmeat bundle create <name>
skillmeat bundle create my-setup
skillmeat bundle create my-setup --include skill,command

# Import bundle
skillmeat bundle import <file>
skillmeat bundle import setup.zip
skillmeat bundle import setup.zip --dry-run

# List bundles
skillmeat bundle list

# Sign bundle
skillmeat sign create <bundle>
skillmeat sign verify <bundle>
```

---

## MCP Server Management

```bash
# Add MCP server
skillmeat mcp add <name> <command>
skillmeat mcp add sqlite "uvx mcp-server-sqlite"

# List MCP servers
skillmeat mcp list

# Enable/disable
skillmeat mcp enable <name>
skillmeat mcp disable <name>

# Remove
skillmeat mcp remove <name>
```

---

## Configuration

```bash
# View config
skillmeat config list
skillmeat config get <key>

# Set config
skillmeat config set <key> <value>
skillmeat config set github-token ghp_xxxxx
skillmeat config set default-collection work

# Common settings
github-token           # GitHub API token
default-collection     # Default collection name
auto-sync              # Auto-sync on start
```

---

## Web Interface

```bash
# Development
skillmeat web dev              # Start dev servers
skillmeat web dev --api-only   # API only
skillmeat web dev --web-only   # Frontend only

# Production
skillmeat web build            # Build for production
skillmeat web start            # Start production servers

# Diagnostics
skillmeat web doctor           # Check environment
```

---

## Output Formats

Most commands support `--json` for machine-readable output:

```bash
skillmeat list --json
skillmeat search "pdf" --json
skillmeat show canvas-design --json
```

---

## Common Workflows

### Set Up New Project

```bash
skillmeat init                           # Initialize in project
skillmeat search "react"                 # Find relevant skills
skillmeat add skill anthropics/skills/frontend-design
skillmeat deploy frontend-design
```

### Share Your Setup

```bash
skillmeat bundle create my-team-setup    # Create bundle
skillmeat sign create my-team-setup.zip  # Sign it
# Share the .zip file
```

### Import Colleague's Setup

```bash
skillmeat bundle import colleague-setup.zip
skillmeat sign verify colleague-setup.zip  # Verify signature
skillmeat deploy --all                     # Deploy everything
```

### Keep Everything Updated

```bash
skillmeat diff --all                     # Check for updates
skillmeat sync --all                     # Update everything
```

---

## Error Codes

| Code | Meaning | Solution |
|------|---------|----------|
| 1 | General error | Check error message |
| 2 | Not found | Verify artifact name |
| 3 | Permission denied | Check file permissions |
| 4 | Rate limited | Set GitHub token |
| 5 | Network error | Check connectivity |

---

## Environment Variables

| Variable | Purpose |
|----------|---------|
| `SKILLMEAT_HOME` | Collection directory (default: `~/.skillmeat`) |
| `SKILLMEAT_CONFIG` | Config file path |
| `GITHUB_TOKEN` | GitHub API token |
| `NO_COLOR` | Disable colored output |

```

### scripts/analyze-project.js

```javascript
#!/usr/bin/env node
/**
 * Project Analysis Script for SkillMeat CLI Skill
 *
 * Analyzes a project directory to recommend relevant artifacts.
 *
 * Usage:
 *   node analyze-project.js [project-path]
 *   node analyze-project.js .
 *
 * Output: JSON with project type, indicators found, and recommendations
 */

import { readFile, readdir, stat } from 'fs/promises';
import { join, basename } from 'path';

// Artifact recommendations by project indicator
const RECOMMENDATIONS = {
  react: {
    artifacts: ['frontend-design', 'webapp-testing'],
    description: 'React project detected',
  },
  nextjs: {
    artifacts: ['frontend-design', 'webapp-testing'],
    description: 'Next.js project detected',
  },
  python: {
    artifacts: [],
    description: 'Python project detected',
  },
  fastapi: {
    artifacts: ['openapi-expert'],
    description: 'FastAPI project detected',
  },
  typescript: {
    artifacts: [],
    description: 'TypeScript project detected',
  },
  documentation: {
    artifacts: ['pdf', 'docx', 'xlsx'],
    description: 'Documentation needs detected',
  },
};

// File indicators for project types
const INDICATORS = {
  'package.json': ['react', 'nextjs', 'typescript'],
  'pyproject.toml': ['python'],
  'requirements.txt': ['python'],
  'next.config.js': ['nextjs'],
  'next.config.ts': ['nextjs'],
  'next.config.mjs': ['nextjs'],
  'tsconfig.json': ['typescript'],
  'fastapi': ['fastapi'],
  '.claude': ['claude-code'],
};

async function fileExists(path) {
  try {
    await stat(path);
    return true;
  } catch {
    return false;
  }
}

async function detectProjectTypes(projectPath) {
  const detected = new Set();
  const indicators = [];

  // Check for indicator files
  for (const [file, types] of Object.entries(INDICATORS)) {
    const filePath = join(projectPath, file);
    if (await fileExists(filePath)) {
      indicators.push(file);
      types.forEach(t => detected.add(t));
    }
  }

  // Check package.json for specific dependencies
  const packageJsonPath = join(projectPath, 'package.json');
  if (await fileExists(packageJsonPath)) {
    try {
      const content = await readFile(packageJsonPath, 'utf-8');
      const pkg = JSON.parse(content);
      const deps = {
        ...pkg.dependencies,
        ...pkg.devDependencies,
      };

      if (deps.react || deps['react-dom']) {
        detected.add('react');
      }
      if (deps.next) {
        detected.add('nextjs');
      }
      if (deps.typescript) {
        detected.add('typescript');
      }
    } catch {
      // Ignore parse errors
    }
  }

  // Check pyproject.toml for FastAPI
  const pyprojectPath = join(projectPath, 'pyproject.toml');
  if (await fileExists(pyprojectPath)) {
    try {
      const content = await readFile(pyprojectPath, 'utf-8');
      if (content.includes('fastapi')) {
        detected.add('fastapi');
      }
    } catch {
      // Ignore read errors
    }
  }

  return {
    types: Array.from(detected),
    indicators,
  };
}

async function getDeployedArtifacts(projectPath) {
  const skillsPath = join(projectPath, '.claude', 'skills');
  const deployed = [];

  try {
    const entries = await readdir(skillsPath, { withFileTypes: true });
    for (const entry of entries) {
      if (entry.isDirectory()) {
        deployed.push(entry.name);
      }
    }
  } catch {
    // .claude/skills doesn't exist
  }

  return deployed;
}

async function analyzeProject(projectPath) {
  const { types, indicators } = await detectProjectTypes(projectPath);
  const deployed = await getDeployedArtifacts(projectPath);

  // Collect recommendations
  const recommendations = [];
  const seen = new Set(deployed);

  for (const type of types) {
    const rec = RECOMMENDATIONS[type];
    if (rec) {
      for (const artifact of rec.artifacts) {
        if (!seen.has(artifact)) {
          recommendations.push({
            artifact,
            reason: rec.description,
          });
          seen.add(artifact);
        }
      }
    }
  }

  return {
    projectPath,
    projectTypes: types,
    indicators,
    deployed,
    recommendations,
    summary: recommendations.length > 0
      ? `Found ${recommendations.length} artifact(s) that could help with this project`
      : 'No additional artifacts recommended',
  };
}

// Main execution
const projectPath = process.argv[2] || '.';

analyzeProject(projectPath)
  .then(result => {
    console.log(JSON.stringify(result, null, 2));
  })
  .catch(error => {
    console.error(JSON.stringify({
      error: error.message,
      projectPath,
    }));
    process.exit(1);
  });

```