@reshotdev/screenshot 0.0.1-beta.0

package/src/commands/ci-setup.js

@@ -0,0 +1,288 @@
+// ci-setup.js - Set up CI/CD integration
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+const GITHUB_ACTIONS_WORKFLOW = (secretNames) => `name: Reshot Visual Documentation
+
+on:
+  push:
+    branches:
+      - main
+      - master
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+      
+      - name: Install dependencies
+        run: npm install
+      
+      - name: Install Reshot CLI
+        run: npm install -g @reshot/cli
+      
+      - name: Install Playwright browsers
+        run: npx playwright install chromium
+      
+      - name: Install ffmpeg
+        run: sudo apt-get update && sudo apt-get install -y ffmpeg
+      
+      # Generate visual assets from docsync.config.json blueprint
+      # Only runs if features.visuals is enabled for the project
+      - name: Run Reshot scenarios
+        env:
+          RESHOT_API_KEY: \${{ secrets.${secretNames.apiKey} }}
+          RESHOT_PROJECT_ID: \${{ secrets.${secretNames.projectId} }}
+          RESHOT_API_BASE_URL: \${{ secrets.${secretNames.baseUrl} }}
+          TEST_PASSWORD: \${{ secrets.${secretNames.testPassword} }}
+        run: reshot run
+      
+      # Publish three streams to Reshot (respects project feature toggles):
+      # Stream A: Visual assets (screenshots/videos) - always enabled
+      # Stream B: Documentation files (if docs feature enabled + configured)
+      # Stream C: Changelog drafts from commit messages (if changelog feature enabled)
+      - name: Publish assets to Reshot
+        env:
+          RESHOT_API_KEY: \${{ secrets.${secretNames.apiKey} }}
+          RESHOT_PROJECT_ID: \${{ secrets.${secretNames.projectId} }}
+          RESHOT_API_BASE_URL: \${{ secrets.${secretNames.baseUrl} }}
+          TEST_PASSWORD: \${{ secrets.${secretNames.testPassword} }}
+        run: reshot publish
+      
+      - name: Upload artifacts (optional)
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: reshot-output
+          path: .reshot/output/
+`;
+
+const CIRCLECI_CONFIG = (secretNames) => `version: 2.1
+
+jobs:
+  docs:
+    docker:
+      - image: cimg/node:18.0-browsers
+    environment:
+      RESHOT_API_KEY: \${${secretNames.apiKey}}
+      RESHOT_PROJECT_ID: \${${secretNames.projectId}}
+      RESHOT_API_BASE_URL: \${${secretNames.baseUrl}}
+      TEST_PASSWORD: \${${secretNames.testPassword}}
+    steps:
+      - checkout
+      
+      - run:
+          name: Install dependencies
+          command: |
+            npm install
+            npm install -g @reshot/cli
+      
+      - run:
+          name: Install Playwright browsers
+          command: npx playwright install chromium
+      
+      - run:
+          name: Install ffmpeg
+          command: sudo apt-get update && sudo apt-get install -y ffmpeg
+      
+      - run:
+          name: Run Reshot scenarios
+          command: reshot run
+      
+      - run:
+          name: Publish assets to Reshot
+          command: reshot publish
+      
+      - store_artifacts:
+          path: .reshot/output
+
+workflows:
+  version: 2
+  docs:
+    jobs:
+      - docs
+`;
+
+const GITLAB_CI_CONFIG = (secretNames) => `stages:
+  - docs
+
+docs:
+  stage: docs
+  image: node:18
+  
+  variables:
+    RESHOT_API_KEY: \$${secretNames.apiKey}
+    RESHOT_PROJECT_ID: \$${secretNames.projectId}
+    RESHOT_API_BASE_URL: \$${secretNames.baseUrl}
+    TEST_PASSWORD: \$${secretNames.testPassword}
+  
+  before_script:
+    - apt-get update && apt-get install -y ffmpeg
+    - npm install
+    - npx playwright install chromium
+    - npm install -g @reshot/cli
+  
+  script:
+    - reshot run
+    - reshot publish
+  
+  artifacts:
+    paths:
+      - .reshot/output/
+    expire_in: 1 week
+  
+  only:
+    - main
+    - master
+`;
+
+async function ciSetupCommand() {
+  console.log(chalk.cyan('🔧 Setting up CI/CD integration...\n'));
+
+  // Prompt for CI provider
+  const { provider } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Select your CI/CD provider:',
+      choices: [
+        { name: 'GitHub Actions', value: 'github' },
+        { name: 'CircleCI', value: 'circleci' },
+        { name: 'GitLab CI', value: 'gitlab' }
+      ]
+    }
+  ]);
+
+  // Prompt for secret names
+  console.log(chalk.cyan('\nEnter the names for your CI secrets:'));
+  const { apiKeySecret, projectIdSecret, baseUrlSecret, testPasswordSecret } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'apiKeySecret',
+      message: 'API Key secret name:',
+        default: 'RESHOT_API_KEY'
+    },
+    {
+      type: 'input',
+      name: 'projectIdSecret',
+      message: 'Project ID secret name:',
+      default: 'RESHOT_PROJECT_ID'
+    },
+    {
+      type: 'input',
+      name: 'baseUrlSecret',
+      message: 'Base URL secret name:',
+        default: 'RESHOT_API_BASE_URL'
+    },
+    {
+      type: 'input',
+      name: 'testPasswordSecret',
+      message: 'Test password secret name:',
+      default: 'TEST_PASSWORD'
+    }
+  ]);
+
+  const secretNames = {
+    apiKey: apiKeySecret,
+    projectId: projectIdSecret,
+    baseUrl: baseUrlSecret,
+    testPassword: testPasswordSecret
+  };
+
+  // Generate workflow file based on provider
+  let workflowPath;
+  let workflowContent;
+
+  switch (provider) {
+    case 'github':
+      workflowPath = path.join(process.cwd(), '.github', 'workflows', 'docsync.yml');
+      workflowContent = GITHUB_ACTIONS_WORKFLOW(secretNames);
+      break;
+    
+    case 'circleci':
+      workflowPath = path.join(process.cwd(), '.circleci', 'config.yml');
+      workflowContent = CIRCLECI_CONFIG(secretNames);
+      break;
+    
+    case 'gitlab':
+      workflowPath = path.join(process.cwd(), '.gitlab-ci.yml');
+      workflowContent = GITLAB_CI_CONFIG(secretNames);
+      break;
+  }
+
+  // Check if file already exists
+  if (fs.existsSync(workflowPath)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `${workflowPath} already exists. Overwrite?`,
+        default: false
+      }
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow('\n⚠ Setup cancelled. Existing workflow file was not modified.'));
+      return;
+    }
+  }
+
+  // Write workflow file
+  fs.ensureDirSync(path.dirname(workflowPath));
+  fs.writeFileSync(workflowPath, workflowContent);
+
+  console.log(chalk.green(`\n✔ Workflow file created: ${workflowPath}`));
+
+  // Print instructions
+  console.log(chalk.cyan('\n📋 Next Steps:\n'));
+  
+  switch (provider) {
+    case 'github':
+      console.log('1. Go to your GitHub repository settings');
+      console.log('2. Navigate to ' + chalk.bold('Secrets and variables > Actions'));
+      console.log('3. Add the following secrets:\n');
+      console.log(`   ${chalk.bold(secretNames.apiKey)} (Project API key for CLI uploads)`);
+      console.log(`   ${chalk.bold(secretNames.projectId)} (Project ID for metadata)`);
+      console.log(`   ${chalk.bold(secretNames.baseUrl)} (API base URL, e.g. https://api.reshot.dev/api)`);
+      console.log(`   ${chalk.bold(secretNames.testPassword)} (Any additional test credential you reference)`);
+      console.log('\n4. Commit and push the workflow file to trigger the action');
+      break;
+    
+    case 'circleci':
+      console.log('1. Go to your CircleCI project settings');
+      console.log('2. Navigate to ' + chalk.bold('Environment Variables'));
+      console.log('3. Add the following variables:\n');
+      console.log(`   ${chalk.bold(secretNames.apiKey)}`);
+      console.log(`   ${chalk.bold(secretNames.projectId)}`);
+      console.log(`   ${chalk.bold(secretNames.baseUrl)}`);
+      console.log(`   ${chalk.bold(secretNames.testPassword)}`);
+      console.log('\n4. Commit and push the config file to trigger the pipeline');
+      break;
+    
+    case 'gitlab':
+      console.log('1. Go to your GitLab project settings');
+      console.log('2. Navigate to ' + chalk.bold('CI/CD > Variables'));
+      console.log('3. Add the following variables:\n');
+      console.log(`   ${chalk.bold(secretNames.apiKey)}`);
+      console.log(`   ${chalk.bold(secretNames.projectId)}`);
+      console.log(`   ${chalk.bold(secretNames.baseUrl)}`);
+      console.log(`   ${chalk.bold(secretNames.testPassword)}`);
+      console.log('\n4. Commit and push the config file to trigger the pipeline');
+      break;
+  }
+
+  console.log();
+}
+
+module.exports = ciSetupCommand;
+

package/src/commands/drifts.js

@@ -0,0 +1,423 @@
+#!/usr/bin/env node
+/**
+ * drifts - View and resolve documentation drifts
+ *
+ * Commands:
+ * - reshot drifts               List pending drifts
+ * - reshot drifts list          List drifts with filters
+ * - reshot drifts show <id>     Show drift details
+ * - reshot drifts approve <id>  Approve a drift
+ * - reshot drifts reject <id>   Reject a drift
+ * - reshot drifts ignore <id>   Mark drift as ignored
+ * - reshot drifts sync <id>     Mark as manually synced (external_host)
+ * - reshot drifts approve-all   Approve all pending drifts
+ * - reshot drifts reject-all    Reject all pending drifts
+ * - reshot drifts validate      Validate journey bindings against visual inventory
+ */
+
+const chalk = require("chalk");
+const config = require("../lib/config");
+const apiClient = require("../lib/api-client");
+
+/**
+ * Format drift for display
+ */
+function formatDrift(drift, verbose = false) {
+  const typeIcon = {
+    VISUAL: "🖼",
+    SEMANTIC: "📝",
+    BOTH: "⚡",
+  }[drift.driftType] || "?";
+
+  const statusColor = {
+    PENDING: chalk.yellow,
+    APPROVED: chalk.green,
+    REJECTED: chalk.red,
+    IGNORED: chalk.gray,
+  }[drift.status] || chalk.white;
+
+  let output = `${typeIcon} ${statusColor(drift.status.padEnd(8))} `;
+  output += chalk.white(drift.journeyKey || drift.docPath || "Unknown");
+  output += chalk.gray(` (${Math.round(drift.confidenceScore * 100)}%)`);
+
+  if (verbose && drift.docPath) {
+    output += `\n   ${chalk.gray("File:")} ${drift.docPath}`;
+  }
+  if (verbose && drift.id) {
+    output += `\n   ${chalk.gray("ID:")} ${drift.id}`;
+  }
+
+  return output;
+}
+
+/**
+ * List drifts with optional filters
+ */
+async function listDrifts(apiKey, projectId, options = {}) {
+  console.log(chalk.blue("\n🔄 Documentation Drifts\n"));
+
+  try {
+    const response = await apiClient.getDrifts(apiKey, projectId, {
+      status: options.status,
+      journeyKey: options.journey,
+    });
+
+    const drifts = response.drifts || [];
+    const stats = response.stats || {};
+
+    // Show stats
+    console.log(
+      chalk.gray("Total: ") +
+        chalk.white(stats.total || drifts.length) +
+        chalk.gray(" │ ") +
+        chalk.yellow(`Pending: ${stats.pending || 0}`) +
+        chalk.gray(" │ ") +
+        chalk.green(`Approved: ${stats.approved || 0}`) +
+        chalk.gray(" │ ") +
+        chalk.red(`Rejected: ${stats.rejected || 0}`)
+    );
+    console.log();
+
+    if (drifts.length === 0) {
+      if (options.status) {
+        console.log(chalk.gray(`  No drifts with status: ${options.status}`));
+      } else {
+        console.log(chalk.green("  ✓ No pending drifts!"));
+      }
+      return;
+    }
+
+    // List drifts
+    for (const drift of drifts) {
+      console.log("  " + formatDrift(drift, options.verbose));
+    }
+
+    console.log();
+    console.log(
+      chalk.gray("  Use ") +
+        chalk.white("reshot drifts show <id>") +
+        chalk.gray(" to see details")
+    );
+    console.log(
+      chalk.gray("  Use ") +
+        chalk.white("reshot drifts approve <id>") +
+        chalk.gray(" to approve changes")
+    );
+  } catch (error) {
+    console.error(chalk.red("Error:"), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show drift details
+ */
+async function showDrift(apiKey, projectId, driftId) {
+  console.log(chalk.blue("\n📋 Drift Details\n"));
+
+  try {
+    const response = await apiClient.post(
+      `/v1/projects/${projectId}/drifts/${driftId}`,
+      {},
+      { headers: { Authorization: `Bearer ${apiKey}` } }
+    ).catch(async () => {
+      // Fallback: get from list
+      const listResp = await apiClient.getDrifts(apiKey, projectId);
+      const drift = listResp.drifts?.find((d) => d.id === driftId);
+      if (drift) return { drift };
+      throw new Error(`Drift ${driftId} not found`);
+    });
+
+    const drift = response.drift;
+    if (!drift) {
+      console.error(chalk.red("Error:"), `Drift ${driftId} not found`);
+      process.exit(1);
+    }
+
+    // Display drift details
+    console.log(chalk.gray("  ID:         ") + chalk.white(drift.id));
+    console.log(chalk.gray("  Status:     ") + chalk.white(drift.status));
+    console.log(chalk.gray("  Type:       ") + chalk.white(drift.driftType));
+    console.log(chalk.gray("  Journey:    ") + chalk.white(drift.journeyKey || "N/A"));
+    console.log(chalk.gray("  File:       ") + chalk.white(drift.docPath || "N/A"));
+    console.log(chalk.gray("  Confidence: ") + chalk.white(`${Math.round(drift.confidenceScore * 100)}%`));
+
+    // Visual diff info
+    if (drift.hasVisualDrift) {
+      console.log();
+      console.log(chalk.cyan("  🖼 Visual Changes Detected"));
+      if (drift.visualDiff?.diffPercentage) {
+        console.log(chalk.gray(`     Diff: ${drift.visualDiff.diffPercentage.toFixed(2)}% changed`));
+      }
+      if (drift.newScreenshotUrl) {
+        console.log(chalk.gray(`     New:  ${drift.newScreenshotUrl}`));
+      }
+    }
+
+    // Semantic diff info
+    if (drift.hasSemanticDrift) {
+      console.log();
+      console.log(chalk.magenta("  📝 Text Changes Detected"));
+      
+      if (drift.originalContent) {
+        console.log(chalk.gray("\n  Current Content:"));
+        console.log(chalk.red("  - " + drift.originalContent.slice(0, 200).replace(/\n/g, "\n  - ")));
+      }
+      
+      if (drift.proposedContent) {
+        console.log(chalk.gray("\n  Proposed Content:"));
+        console.log(chalk.green("  + " + drift.proposedContent.slice(0, 200).replace(/\n/g, "\n  + ")));
+      }
+    }
+
+    console.log();
+    console.log(chalk.gray("  Actions:"));
+    console.log(chalk.white(`    reshot drifts approve ${driftId}`));
+    console.log(chalk.white(`    reshot drifts reject ${driftId}`));
+    console.log(chalk.white(`    reshot drifts ignore ${driftId}`));
+  } catch (error) {
+    console.error(chalk.red("Error:"), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Perform action on a drift
+ */
+async function performDriftAction(apiKey, projectId, driftId, action) {
+  const actionMap = {
+    approve: { label: "Approving", status: "APPROVED", emoji: "✓", apiAction: "approve" },
+    reject: { label: "Rejecting", status: "REJECTED", emoji: "✗", apiAction: "reject" },
+    ignore: { label: "Ignoring", status: "IGNORED", emoji: "○", apiAction: "ignore" },
+    sync: { label: "Marking as synced", status: "APPROVED", emoji: "✓", apiAction: "mark_synced" },
+  };
+
+  const actionInfo = actionMap[action];
+  if (!actionInfo) {
+    console.error(chalk.red("Error:"), `Unknown action: ${action}`);
+    process.exit(1);
+  }
+
+  console.log(chalk.blue(`\n${actionInfo.emoji} ${actionInfo.label} drift...\n`));
+
+  try {
+    const response = await apiClient.driftAction(apiKey, projectId, driftId, actionInfo.apiAction);
+
+    if (response.success) {
+      console.log(chalk.green(`  ✓ Drift ${driftId} ${action}ed successfully`));
+      
+      if (response.prUrl) {
+        console.log(chalk.gray("\n  Pull Request created:"));
+        console.log(chalk.blue(`  ${response.prUrl}`));
+      }
+      
+      if (action === "sync") {
+        console.log(chalk.gray("\n  The visual assets have been promoted to 'approved' status."));
+      }
+    } else {
+      console.log(chalk.yellow(`  ⚠ Action completed with warnings: ${response.message || "Unknown"}`));
+    }
+  } catch (error) {
+    console.error(chalk.red("Error:"), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Batch approve or reject all pending drifts
+ */
+async function batchDriftAction(apiKey, projectId, action, options = {}) {
+  const actionLabel = action === "approve" ? "Approving" : "Rejecting";
+  const actionVerb = action === "approve" ? "approved" : "rejected";
+  
+  console.log(chalk.blue(`\n🔄 ${actionLabel} all pending drifts...\n`));
+
+  try {
+    // Fetch all pending drifts
+    const response = await apiClient.getDrifts(apiKey, projectId, { status: "PENDING" });
+    const drifts = response.drifts || [];
+
+    if (drifts.length === 0) {
+      console.log(chalk.green("  ✓ No pending drifts to process"));
+      return;
+    }
+
+    console.log(chalk.gray(`  Found ${drifts.length} pending drift(s)\n`));
+
+    let succeeded = 0;
+    let failed = 0;
+    const errors = [];
+
+    for (const drift of drifts) {
+      try {
+        const apiAction = action === "approve" ? "approve" : "reject";
+        await apiClient.driftAction(apiKey, projectId, drift.id, apiAction);
+        succeeded++;
+        console.log(chalk.green(`  ✓ ${drift.journeyKey || drift.id} ${actionVerb}`));
+      } catch (err) {
+        failed++;
+        errors.push({ drift, error: err.message });
+        console.log(chalk.red(`  ✗ ${drift.journeyKey || drift.id} failed: ${err.message}`));
+      }
+    }
+
+    console.log();
+    console.log(chalk.gray("─".repeat(40)));
+    console.log(chalk.green(`  ${succeeded} drift(s) ${actionVerb}`));
+    if (failed > 0) {
+      console.log(chalk.red(`  ${failed} drift(s) failed`));
+    }
+  } catch (error) {
+    console.error(chalk.red("Error:"), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Validate journey bindings against visual inventory
+ */
+async function validateBindings(apiKey, projectId, options = {}) {
+  console.log(chalk.blue("\n🔍 Validating Journey Bindings\n"));
+
+  try {
+    // Fetch visual keys from server
+    const visualKeys = await apiClient.getVisualKeys(projectId, apiKey);
+    console.log(chalk.green(`  ✓ Fetched ${visualKeys.size} visual keys from project`));
+
+    // Read docsync config
+    const docSyncConfig = config.readDocSyncConfig();
+    const docConfig = docSyncConfig.documentation;
+
+    if (!docConfig || !docConfig.root) {
+      console.log(chalk.yellow("  ⚠ No documentation.root configured"));
+      return;
+    }
+
+    // Use the validate-docs module for full validation
+    const validateDocs = require("./validate-docs");
+    const result = await validateDocs.validateDocSync({
+      strict: options.strict,
+      verbose: options.verbose,
+    });
+
+    // Additional server-side validation: check if any journey keys in the project
+    // are not bound to any documentation
+    const mappings = docConfig.mappings || {};
+    const boundKeys = new Set(Object.values(mappings));
+
+    const orphanedVisuals = [];
+    for (const key of visualKeys) {
+      if (!boundKeys.has(key)) {
+        orphanedVisuals.push(key);
+      }
+    }
+
+    if (orphanedVisuals.length > 0) {
+      console.log(chalk.yellow(`\n  ⚠ ${orphanedVisuals.length} visual(s) not bound to documentation:`));
+      if (options.verbose) {
+        orphanedVisuals.slice(0, 10).forEach((key) => {
+          console.log(chalk.gray(`      - ${key}`));
+        });
+        if (orphanedVisuals.length > 10) {
+          console.log(chalk.gray(`      ... and ${orphanedVisuals.length - 10} more`));
+        }
+      }
+    }
+
+    if (!result.valid) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk.red("Error:"), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main drifts command handler
+ */
+async function driftsCommand(subcommand, args = [], options = {}) {
+  // Read configuration
+  let docSyncConfig;
+  try {
+    docSyncConfig = config.readDocSyncConfig();
+  } catch (error) {
+    console.error(chalk.red("Error:"), "docsync.config.json not found. Run `reshot init` first.");
+    process.exit(1);
+  }
+
+  // Get API key and project ID
+  const settings = config.readSettings();
+  const apiKey = process.env.RESHOT_API_KEY || settings?.apiKey;
+  const projectId =
+    process.env.RESHOT_PROJECT_ID ||
+    settings?.projectId ||
+    docSyncConfig._metadata?.projectId;
+
+  if (!apiKey) {
+    console.error(chalk.red("Error:"), "API key not found. Set RESHOT_API_KEY or run `reshot auth`.");
+    process.exit(1);
+  }
+
+  if (!projectId) {
+    console.error(chalk.red("Error:"), "Project ID not found. Set RESHOT_PROJECT_ID or run `reshot init`.");
+    process.exit(1);
+  }
+
+  // Route to appropriate handler
+  switch (subcommand) {
+    case undefined:
+    case "list":
+      await listDrifts(apiKey, projectId, options);
+      break;
+
+    case "show":
+      if (!args[0]) {
+        console.error(chalk.red("Error:"), "Drift ID required. Usage: reshot drifts show <id>");
+        process.exit(1);
+      }
+      await showDrift(apiKey, projectId, args[0]);
+      break;
+
+    case "approve":
+    case "reject":
+    case "ignore":
+    case "sync":
+      if (!args[0]) {
+        console.error(chalk.red("Error:"), `Drift ID required. Usage: reshot drifts ${subcommand} <id>`);
+        process.exit(1);
+      }
+      await performDriftAction(apiKey, projectId, args[0], subcommand);
+      break;
+
+    case "approve-all":
+      await batchDriftAction(apiKey, projectId, "approve", options);
+      break;
+
+    case "reject-all":
+      await batchDriftAction(apiKey, projectId, "reject", options);
+      break;
+
+    case "validate":
+      await validateBindings(apiKey, projectId, options);
+      break;
+
+    default:
+      console.error(chalk.red("Error:"), `Unknown subcommand: ${subcommand}`);
+      console.log(chalk.gray("\nAvailable subcommands:"));
+      console.log(chalk.white("  list        ") + chalk.gray("List drifts (default)"));
+      console.log(chalk.white("  show        ") + chalk.gray("Show drift details"));
+      console.log(chalk.white("  approve     ") + chalk.gray("Approve a drift"));
+      console.log(chalk.white("  reject      ") + chalk.gray("Reject a drift"));
+      console.log(chalk.white("  ignore      ") + chalk.gray("Ignore a drift"));
+      console.log(chalk.white("  sync        ") + chalk.gray("Mark as manually synced"));
+      console.log(chalk.white("  approve-all ") + chalk.gray("Approve all pending drifts"));
+      console.log(chalk.white("  reject-all  ") + chalk.gray("Reject all pending drifts"));
+      console.log(chalk.white("  validate    ") + chalk.gray("Validate journey bindings"));
+      process.exit(1);
+  }
+
+  console.log();
+}
+
+module.exports = driftsCommand;