### Initial Setup Commands (Bash)

Source: https://buildwithclaude.com/command/bidirectional-sync

Bash commands for initializing and configuring the bidirectional synchronization. Includes commands to add the marketplace plugin, install integration commands, and set up sync parameters.

```bash
# Initialize bidirectional sync
claude bidirectional-sync --init --repo="owner/repo" --team="ENG"

# Configure sync options
claude bidirectional-sync --config \
--conflict-strategy="NEWER_WINS" \
--sync-interval="5m" \
--webhook-secret="your-secret"

```

--------------------------------

### Agent Analytics CLI: First-time Setup

Source: https://buildwithclaude.com/skill/agent-analytics

Guides through the initial setup for Agent Analytics CLI, including logging in with an API token, creating a new project, and verifying events.

```bash
# 1. Login (one time — uses your API key)
npx @agent-analytics/cli login --token aak_YOUR_API_KEY

# 2. Create the project (returns a project write token)
npx @agent-analytics/cli create my-site --domain https://mysite.com

# 3. Add the snippet using the returned token
# 4. Deploy, click around, verify:
npx @agent-analytics/cli events my-site
```

--------------------------------

### Install Utilities & Debugging Commands

Source: https://buildwithclaude.com/command/all-tools

Instructions for installing the Utilities & Debugging commands plugin, including adding the marketplace and installing the specific command package. This is a prerequisite for using the /all_tools command.

```bash
/plugin marketplace add davepoon/buildwithclaude
/plugin install commands-utilities-debugging@buildwithclaude
```

--------------------------------

### Optimize Build Caching

Source: https://buildwithclaude.com/command/ci-setup

Implements dependency caching in GitHub Actions to reduce build times by reusing previously installed node_modules.

```yaml
- name: Cache node modules
  uses: actions/cache@v3
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-node-
```

--------------------------------

### Configure CI/CD Build Pipelines

Source: https://buildwithclaude.com/command/ci-setup

Examples of basic CI/CD pipeline configurations for GitHub Actions and GitLab CI. These pipelines automate the testing and build processes for Node.js applications.

```yaml
name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      - run: npm ci
      - run: npm run test
      - run: npm run build
```

```yaml
stages:
  - test
  - build
  - deploy

test:
  stage: test
  script:
    - npm ci
    - npm run test
  cache:
    paths:
      - node_modules/
```

--------------------------------

### Install Pg Aiguide via Claude Code CLI

Source: https://buildwithclaude.com/mcp-server/official-mcp-pg-aiguide

This command installs the Pg Aiguide MCP server into the Claude Code configuration. It requires several environment variables for database connectivity and OpenAI API access.

```bash
claude mcp add pg-aiguide -e OPENAI_API_KEY=<value> -e PGHOST=<value> -e PGPORT=<value> -e PGUSER=<value> -e PGPASSWORD=<value> -e PGDATABASE=<value> -e DB_SCHEMA=<value> -- npx -y @tigerdata/pg-aiguide
```

--------------------------------

### Manual Installation of Agent Analytics Skill

Source: https://buildwithclaude.com/skill/agent-analytics

Provides steps for manual installation of the agent-analytics skill by downloading a zip file and extracting it to the specified directory.

```bash
unzip agent-analytics.zip -d ~/.claude/skills/
```

--------------------------------

### Install CI & Deployment Commands

Source: https://buildwithclaude.com/command/add-changelog

Installs the CI & Deployment commands plugin for BuildWithClaude. This is a prerequisite for using commands like `/add_changelog`.

```bash
/plugin marketplace add davepoon/buildwithclaude
/plugin install commands-ci-deployment@buildwithclaude
```

--------------------------------

### Bulk Import CLI Commands

Source: https://buildwithclaude.com/command/bulk-import-issues

Command-line interface examples for performing bulk imports, including basic usage, advanced batch configuration, and recovery workflows.

```bash
# Basic usage
claude bulk-import-issues --state="open" --label="bug"

# Advanced batching
claude bulk-import-issues --batch-size=50 --delay=1000 --max-concurrent=10

# Recovery
claude bulk-import-issues --dry-run
claude bulk-import-issues --resume-from="import-12345.json"
```

--------------------------------

### Format for Displaying Development Tools

Source: https://buildwithclaude.com/command/all-tools

Example format for displaying available development tools. Each tool is listed as a bullet point with its TypeScript function signature and a brief description of its purpose. This format aids in understanding tool capabilities.

```typescript
• functionName(parameters: Type): ReturnType - Purpose of the tool

• anotherFunction(params: ParamType): ResultType - What this tool does
```

--------------------------------

### Format Basecamp Content with HTML

Source: https://buildwithclaude.com/skill/basecamp-automation

Illustrates the correct way to format content for Basecamp, which exclusively uses HTML. This example shows how to wrap text in `<div>` tags and use common HTML elements like `<strong>` for emphasis.

```html
<div><strong>Important:</strong> Complete by Friday</div>
```

--------------------------------

### Full CI/CD Pipeline Configuration

Source: https://buildwithclaude.com/command/ci-setup

A comprehensive GitHub Actions workflow that integrates linting, testing, security auditing, and conditional deployments to staging and production environments.

```yaml
name: Full CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      - run: npm ci
      - run: npm run lint
      - run: npm run test:coverage
      - run: npm run build

  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Security scan
        run: npm audit --audit-level=high

  deploy-staging:
    needs: [lint-and-test, security-scan]
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to staging
        run: echo "Deploying to staging"

  deploy-production:
    needs: [lint-and-test, security-scan]
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to production
        run: echo "Deploying to production"
```

--------------------------------

### Create Multi-stage Dockerfile

Source: https://buildwithclaude.com/command/ci-setup

Defines a multi-stage Docker build to minimize image size by separating the build environment from the runtime environment.

```dockerfile
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
EXPOSE 3000
CMD ["npm", "start"]
```

--------------------------------

### Implement Multi-stage Testing Strategy

Source: https://buildwithclaude.com/command/ci-setup

Configures a matrix-based testing strategy in GitHub Actions to validate application compatibility across multiple Node.js versions.

```yaml
test:
  strategy:
    matrix:
      node-version: [16, 18, 20]
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v3
    - uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
    - run: npm ci
    - run: npm test
```

--------------------------------

### Install Agent Analytics Skill using npx

Source: https://buildwithclaude.com/skill/agent-analytics

Installs the agent-analytics skill using the 'npx skills' command. This is a quick method compatible with various Claude-based agents.

```bash
npx skills add davepoon/buildwithclaude -s agent-analytics
```

--------------------------------

### Deploy to Production GitHub Action

Source: https://buildwithclaude.com/command/ci-setup

A snippet demonstrating a conditional deployment job for a production environment. It requires successful completion of testing jobs and restricts execution to the main branch.

```yaml
deploy-production:
  needs: test
  if: github.ref == 'refs/heads/main'
  runs-on: ubuntu-latest
  environment: production
  steps:
    - name: Deploy to production
      run: echo "Deploying to production"
```

--------------------------------

### Get Basecamp Project Details by ID (Alternative)

Source: https://buildwithclaude.com/skill/basecamp-automation

An alternative method to retrieve detailed information about a specific Basecamp project using its ID. This tool serves the same purpose as `BASECAMP_GET_PROJECT`.

```bash
BASECAMP_GET_PROJECTS_BY_PROJECT_ID(project_id=123)
```

--------------------------------

### Configure Environment Deployment

Source: https://buildwithclaude.com/command/ci-setup

Sets up conditional deployment logic in GitHub Actions to ensure code is only deployed to staging from the develop branch.

```yaml
deploy-staging:
  needs: test
  if: github.ref == 'refs/heads/develop'
  runs-on: ubuntu-latest
  steps:
    - name: Deploy to staging
      run: |
```

--------------------------------

### Node.js APM with Datadog Custom Instrumentation

Source: https://buildwithclaude.com/command/add-performance-monitoring

Provides a utility class for custom instrumentation with Datadog APM in Node.js. It includes methods to start spans, trace asynchronous functions with error handling, and track database query performance. Requires the 'dd-trace' package.

```javascript
// Custom instrumentation
class PerformanceTracker {
static startSpan(operationName, options = {}) {
return tracer.startSpan(operationName, {
tags: {
'service.name': 'my-application',
...options.tags
},
...options
});
}

static async traceAsync(operationName, asyncFn, tags = {}) {
const span = this.startSpan(operationName, { tags });

try {
const result = await asyncFn(span);
span.setTag('operation.success', true);
return result;
} catch (error) {
span.setTag('operation.success', false);
span.setTag('error.message', error.message);
span.setTag('error.stack', error.stack);
throw error;
} finally {
span.finish();
}
}

static trackDatabaseQuery(query, duration, success) {
tracer.startSpan('database.query', {
tags: {
'db.statement': query,
'db.duration': duration,
'db.success': success
}
}).finish();
}
}

```

--------------------------------

### Conventional Commit Examples

Source: https://buildwithclaude.com/command/add-changelog

Examples of commit messages following the conventional commits specification. This format is used by tools like conventional-changelog-cli for automated changelog generation.

```bash
# Conventional commits for auto-generation
feat: add user authentication
fix: resolve memory leak in tasks
docs: update API documentation
style: format code with prettier
refactor: reorganize user service
test: add unit tests for auth
chore: update dependencies
```

--------------------------------

### Install Bitbucket Automation Skill

Source: https://buildwithclaude.com/skill/bitbucket-automation

Commands to install the Bitbucket automation skill via CLI or manual extraction. Supports standard agent environments and OpenClaw.

```bash
npx skills add davepoon/buildwithclaude -s bitbucket-automation
```

```bash
unzip bitbucket-automation.zip -d ~/.claude/skills/
```

```bash
curl -sL https://buildwithclaude.com/api/skills/bitbucket-automation/download -o /tmp/bitbucket-automation.zip && unzip -o /tmp/bitbucket-automation.zip -d ~/.claude/skills/ && rm /tmp/bitbucket-automation.zip
```

--------------------------------

### OpenClaw Installation of Agent Analytics Skill

Source: https://buildwithclaude.com/skill/agent-analytics

Installs the agent-analytics skill for OpenClaw using a curl command to download and unzip the skill, or by manually extracting the zip file.

```bash
curl -sL https://buildwithclaude.com/api/skills/agent-analytics/download -o /tmp/agent-analytics.zip && unzip -o /tmp/agent-analytics.zip -d ~/.claude/skills/ && rm /tmp/agent-analytics.zip
```

--------------------------------

### Run and Analyze Load Tests with System Metrics (JavaScript)

Source: https://buildwithclaude.com/command/add-performance-monitoring

Executes performance load tests using configurable settings and captures system metrics (CPU, memory, processes) before and after the test. It analyzes results for performance regressions and provides recommendations based on predefined thresholds. Dependencies include OS module and potentially external load testing tools.

```javascript
// load-test-monitor.js
class LoadTestMonitor {
constructor() {
this.testResults = [];
this.baselineMetrics = null;
}
  
async runPerformanceTest(testConfig) {
console.log('Starting performance test...', testConfig);
  
const startMetrics = await this.captureSystemMetrics();
const startTime = Date.now();
  
try {
// Run the actual load test (using k6, artillery, etc.)
const testResults = await this.executeLoadTest(testConfig);
  
const endTime = Date.now();
const endMetrics = await this.captureSystemMetrics();
  
const result = {
testId: this.generateTestId(),
config: testConfig,
duration: endTime - startTime,
startMetrics,
endMetrics,
testResults,
timestamp: new Date().toISOString()
};
  
this.testResults.push(result);
await this.analyzeResults(result);
  
return result;
} catch (error) {
console.error('Load test failed:', error);
throw error;
}
}
  
async captureSystemMetrics() {
return {
cpu: os.loadavg(),
memory: {
total: os.totalmem(),
free: os.freemem(),
used: os.totalmem() - os.freemem()
},
processes: await this.getProcessMetrics()
};
}
  
async analyzeResults(result) {
const analysis = {
performanceRegression: false,
recommendations: []
};
  
// Compare with baseline
if (this.baselineMetrics) {
const responseTimeIncrease = (result.testResults.averageResponseTime - this.baselineMetrics.averageResponseTime) / this.baselineMetrics.averageResponseTime;
  
if (responseTimeIncrease > 0.2) { // 20% increase
analysis.performanceRegression = true;
analysis.recommendations.push(`Response time increased by ${(responseTimeIncrease * 100).toFixed(1)}%`);
}
}
  
// Resource utilization analysis
const maxCpuUsage = Math.max(...result.endMetrics.cpu);
if (maxCpuUsage > 0.8) {
analysis.recommendations.push('High CPU usage detected - consider scaling');
}
  
const memoryUsagePercent = result.endMetrics.memory.used / result.endMetrics.memory.total;
if (memoryUsagePercent > 0.9) {
analysis.recommendations.push('High memory usage detected - check for memory leaks');
}
  
console.log('Performance test analysis:', analysis);
return analysis;
}
  
setBaseline(testResult) {
this.baselineMetrics = testResult.testResults;
console.log('Baseline metrics set:', this.baselineMetrics);
}
  
generateTestId() {
return `test_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}
}

```

--------------------------------

### Get Specific Basecamp Project Details

Source: https://buildwithclaude.com/skill/basecamp-automation

Retrieves comprehensive details for a single Basecamp project using its ID. This is an optional step after listing projects to get more in-depth information. An alternative tool, `BASECAMP_GET_PROJECTS_BY_PROJECT_ID`, can also be used for this purpose.

```bash
BASECAMP_GET_PROJECT(project_id=123)
```

--------------------------------

### Analyze Performance Metrics and Generate Recommendations (JavaScript)

Source: https://buildwithclaude.com/command/add-performance-monitoring

Analyzes performance metrics against predefined thresholds for response time, memory usage, CPU usage, and error rates. It generates actionable recommendations for performance optimization. This class maintains a set of thresholds and can be extended to include more complex analysis logic.

```javascript
// performance-analyzer.js
class PerformanceAnalyzer {
constructor() {
this.metrics = [];
this.thresholds = {
responseTime: { good: 200, warning: 1000, critical: 3000 },
memoryUsage: { good: 0.6, warning: 0.8, critical: 0.9 },
cpuUsage: { good: 0.5, warning: 0.7, critical: 0.85 },
errorRate: { good: 0.01, warning: 0.05, critical: 0.1 }
};
}
  
analyzePerformance(metrics) {
const recommendations = [];
const scores = {};
  

```

--------------------------------

### GET /circleci/job-details

Source: https://buildwithclaude.com/skill/circleci-automation

Retrieves detailed execution information for a specific job.

```APIDOC
## GET CIRCLECI_GET_JOB_DETAILS

### Description
Fetches detailed information about a specific job, including executor type, timing, and status.

### Method
GET

### Parameters
#### Query Parameters
- **project_slug** (string) - Required - Project identifier
- **job_number** (integer) - Required - Numeric job number

### Request Example
{
  "project_slug": "gh/myorg/myrepo",
  "job_number": 1024
}

### Response
#### Success Response (200)
- **status** (string) - Current job status (e.g., success, failed, running)
- **started_at** (string) - ISO timestamp
- **stopped_at** (string) - ISO timestamp

#### Response Example
{
  "status": "success",
  "job_number": 1024
}
```

--------------------------------

### GET /circleci/list-pipelines

Source: https://buildwithclaude.com/skill/circleci-automation

Retrieves a list of recent pipelines for a project to monitor progress.

```APIDOC
## GET CIRCLECI_LIST_PIPELINES_FOR_PROJECT

### Description
Lists recent pipelines for a project, allowing users to track status and identify pipeline IDs.

### Method
GET

### Parameters
#### Query Parameters
- **project_slug** (string) - Required - Project identifier in {vcs}/{org}/{repo} format
- **branch** (string) - Optional - Filter pipelines by branch name
- **page_token** (string) - Optional - Pagination cursor

### Request Example
{
  "project_slug": "gh/myorg/myrepo",
  "branch": "main"
}

### Response
#### Success Response (200)
- **items** (array) - List of pipeline objects
- **next_page_token** (string) - Token for the next page of results

#### Response Example
{
  "items": [ { "id": "uuid-123", "status": "success" } ]
}
```

--------------------------------

### GET /asana/tasks

Source: https://buildwithclaude.com/skill/asana-automation

Retrieve tasks from a specific project or search within a workspace.

```APIDOC
## GET ASANA_GET_TASKS_FROM_A_PROJECT

### Description
Retrieves a list of tasks associated with a specific project GID.

### Method
GET

### Endpoint
ASANA_GET_TASKS_FROM_A_PROJECT

### Parameters
#### Query Parameters
- **project_gid** (string) - Required - The unique identifier of the project.

### Request Example
{
  "project_gid": "123456789"
}

### Response
#### Success Response (200)
- **data** (Array) - List of task objects.

#### Response Example
{
  "data": [
    { "gid": "98765", "name": "Complete documentation" }
  ]
}
```

--------------------------------

### GET /dependents

Source: https://buildwithclaude.com/skill/bamboohr-automation

Retrieve a list of dependents associated with employees, optionally filtered by employee ID.

```APIDOC
## GET /dependents

### Description
Fetches dependent information. Handle this data with care as it contains sensitive PII.

### Method
GET

### Endpoint
/dependents

### Parameters
#### Query Parameters
- **employeeId** (integer) - Optional - Filter results by specific employee

### Response Example
{
  "dependents": [
    {
      "id": 99,
      "name": "Jane Doe",
      "relationship": "Spouse"
    }
  ]
}
```

--------------------------------

### Handle Basecamp API Pagination

Source: https://buildwithclaude.com/skill/basecamp-automation

Demonstrates the concept of page-based pagination used in Basecamp API list endpoints. This pattern is crucial for fetching results that span multiple pages, ensuring all data is retrieved by continuing requests until no more results are available.

```bash
# Example: Fetching paginated results
# Assume initial request returns results and a 'next_page_url' header
# Subsequent requests would use the 'next_page_url' until it's no longer provided.
```

--------------------------------

### GET /canva/designs

Source: https://buildwithclaude.com/skill/canva-automation

Lists designs in the user's Canva library with support for filtering and pagination.

```APIDOC
## GET CANVA_LIST_USER_DESIGNS

### Description
Retrieves a list of designs from the user's Canva account. Supports filtering by query, ownership, and sorting.

### Method
GET

### Parameters
#### Query Parameters
- **query** (string) - Optional - Search term to filter designs by name
- **continuation** (string) - Optional - Pagination token for fetching subsequent pages
- **ownership** (string) - Optional - Filter by 'owned', 'shared', or 'any'
- **sort_by** (string) - Optional - Field to sort by (e.g., 'modified_at', 'title')

### Response
#### Success Response (200)
- **designs** (array) - List of design objects
- **continuation** (string) - Token for the next page of results

### Response Example
{
  "designs": [{"id": "123", "title": "Project Alpha"}],
  "continuation": "abc-789"
}
```

--------------------------------

### Configure Sync Rules via YAML

Source: https://buildwithclaude.com/command/bidirectional-sync

Configuration file for defining sync behavior, including direction, interval, conditional rules, conflict resolution strategies, and webhook security settings.

```yaml
version: 1.0
sync:
  enabled: true
  direction: bidirectional
  interval: 5m

rules:
  - name: "Bug Priority Sync"
    condition:
      github:
        labels: ["bug"]
    action:
      linear:
        priority: 1

  - name: "Skip Draft Issues"
    condition:
      github:
        labels: ["draft"]
    action:
      skip: true

conflicts:
  strategy: NEWER_WINS
  manual_review:
    - title
    - milestone

webhooks:
  github:
    secret: ${GITHUB_WEBHOOK_SECRET}
  linear:
    secret: ${LINEAR_WEBHOOK_SECRET}
```

--------------------------------

### GET /brevo/campaigns

Source: https://buildwithclaude.com/skill/brevo-automation

Lists email campaigns from Brevo with support for filtering by status, type, and date ranges.

```APIDOC
## GET /brevo/campaigns

### Description
Retrieves a list of email campaigns based on specified filters such as status, type, and date range.

### Method
GET

### Endpoint
BREVO_LIST_EMAIL_CAMPAIGNS

### Parameters
#### Query Parameters
- **type** (string) - Optional - Campaign type ('classic' or 'trigger')
- **status** (string) - Optional - Campaign status ('suspended', 'archive', 'sent', 'queued', 'draft', 'inProcess', 'inReview')
- **startDate** (string) - Optional - Start date filter (YYYY-MM-DDTHH:mm:ss.SSSZ)
- **endDate** (string) - Optional - End date filter (YYYY-MM-DDTHH:mm:ss.SSSZ)
- **limit** (integer) - Optional - Results per page (max 100, default 50)
- **offset** (integer) - Optional - Pagination offset

### Request Example
{
  "status": "sent",
  "limit": 20
}

### Response
#### Success Response (200)
- **campaigns** (array) - List of campaign objects

#### Response Example
{
  "campaigns": [
    {
      "id": 123,
      "name": "Newsletter Q1",
      "status": "sent"
    }
  ]
}
```

--------------------------------

### POST /folders

Source: https://buildwithclaude.com/skill/canva-automation

Creates a new folder for organizing designs and assets within the user's account.

```APIDOC
## POST /folders

### Description
Creates a new folder. Folder names must be unique within the same parent directory.

### Method
POST

### Endpoint
/v1/folders

### Request Body
- **name** (string) - Required - Folder name
- **parent_folder_id** (string) - Optional - Parent folder for nested organization

### Response
#### Success Response (200)
- **folder_id** (string) - The ID of the created folder

### Response Example
{
  "folder_id": "folder_xyz789"
}
```