@aaronshaf/confluence-cli 0.1.15

package/src/cli/commands/doctor.ts

@@ -0,0 +1,161 @@
+/**
+ * cn doctor - Health check command for detecting issues in synced spaces
+ */
+
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  findBestDuplicate,
+  findStaleDuplicates,
+  runHealthCheck,
+  type DuplicatePageId,
+} from '../../lib/health-check.js';
+import { hasSpaceConfig, readSpaceConfig } from '../../lib/space-config.js';
+
+export interface DoctorOptions {
+  fix?: boolean;
+  xml?: boolean;
+}
+
+function formatDate(dateStr?: string): string {
+  if (!dateStr) return 'never';
+  const date = new Date(dateStr);
+  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+}
+
+/**
+ * Escape special XML characters for attribute values
+ */
+function escapeXmlAttr(str: string): string {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function printDuplicateInfo(duplicate: DuplicatePageId): void {
+  const best = findBestDuplicate(duplicate.files);
+  const stale = findStaleDuplicates(duplicate);
+
+  console.log(chalk.yellow(`\n  Duplicate page_id: ${duplicate.pageId}`));
+
+  for (const file of duplicate.files) {
+    const isBest = file.path === best.path;
+    const marker = isBest ? chalk.green(' (keep)') : chalk.red(' (stale)');
+    const version = file.version ? `v${file.version}` : 'v?';
+    const synced = formatDate(file.syncedAt);
+
+    console.log(`    ${isBest ? chalk.green('*') : chalk.red('x')} ${file.path}${marker}`);
+    console.log(chalk.gray(`      ${version}, synced ${synced}`));
+  }
+
+  if (stale.length > 0) {
+    console.log(chalk.gray(`    Recommendation: Delete ${stale.map((f) => f.path).join(', ')}`));
+  }
+}
+
+function printXmlOutput(result: ReturnType<typeof runHealthCheck>): void {
+  console.log('<health-check>');
+  console.log(
+    `  <summary files="${result.files.length}" tracked="${result.trackedFiles.length}" new="${result.newFiles.length}" duplicates="${result.duplicates.length}" />`,
+  );
+
+  if (result.duplicates.length > 0) {
+    console.log('  <duplicates>');
+    for (const dup of result.duplicates) {
+      const best = findBestDuplicate(dup.files);
+      console.log(`    <duplicate page-id="${escapeXmlAttr(dup.pageId)}">`);
+      for (const file of dup.files) {
+        const isBest = file.path === best.path;
+        console.log(
+          `      <file path="${escapeXmlAttr(file.path)}" version="${file.version || '?'}" synced="${file.syncedAt || 'never'}" status="${isBest ? 'keep' : 'stale'}" />`,
+        );
+      }
+      console.log('    </duplicate>');
+    }
+    console.log('  </duplicates>');
+  }
+
+  console.log('</health-check>');
+}
+
+export async function doctorCommand(options: DoctorOptions = {}): Promise<void> {
+  const directory = process.cwd();
+
+  // Check for space config
+  if (!hasSpaceConfig(directory)) {
+    console.log(chalk.yellow('Not in a Confluence-synced directory.'));
+    console.log(chalk.gray('Run "cn clone <SPACE_KEY>" to initialize a space.'));
+    return;
+  }
+
+  const config = readSpaceConfig(directory);
+  if (!config) {
+    console.log(chalk.red('Failed to read space configuration.'));
+    return;
+  }
+
+  console.log(chalk.bold(`Running health check for ${config.spaceName || config.spaceKey}...\n`));
+
+  const result = runHealthCheck(directory);
+
+  // XML output mode
+  if (options.xml) {
+    printXmlOutput(result);
+    return;
+  }
+
+  // Summary
+  console.log(chalk.bold('Summary:'));
+  console.log(`  Total files: ${result.files.length}`);
+  console.log(`  Tracked (with page_id): ${result.trackedFiles.length}`);
+  console.log(`  New (no page_id): ${result.newFiles.length}`);
+
+  // Check for issues
+  let hasIssues = false;
+
+  // Duplicate page_ids
+  if (result.duplicates.length > 0) {
+    hasIssues = true;
+    console.log(chalk.red(`\n  Duplicate page_ids found: ${result.duplicates.length}`));
+
+    for (const duplicate of result.duplicates) {
+      printDuplicateInfo(duplicate);
+    }
+  }
+
+  if (!hasIssues) {
+    console.log(chalk.green('\n  No issues found.'));
+    return;
+  }
+
+  // Offer to fix issues
+  if (options.fix || result.duplicates.length > 0) {
+    console.log('');
+
+    for (const duplicate of result.duplicates) {
+      const stale = findStaleDuplicates(duplicate);
+      if (stale.length === 0) continue;
+
+      for (const file of stale) {
+        const shouldDelete =
+          options.fix ||
+          (await confirm({
+            message: `Delete stale file ${file.path}?`,
+            default: true,
+          }));
+
+        if (shouldDelete) {
+          const fullPath = join(directory, file.path);
+          try {
+            unlinkSync(fullPath);
+            console.log(chalk.green(`  Deleted: ${file.path}`));
+          } catch (error) {
+            console.log(
+              chalk.red(`  Failed to delete ${file.path}: ${error instanceof Error ? error.message : 'Unknown error'}`),
+            );
+          }
+        }
+      }
+    }
+  }
+}

package/src/cli/commands/duplicate-check.ts

@@ -0,0 +1,89 @@
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import {
+  checkFileForDuplicates,
+  findBestDuplicate,
+  findDuplicatePageIds,
+  scanFilesForHealthCheck,
+  type DuplicatePageId,
+} from '../../lib/health-check.js';
+
+/**
+ * Display duplicate page_id information
+ */
+export function displayDuplicates(duplicates: DuplicatePageId[]): void {
+  console.log(chalk.red('Duplicate page_ids detected:'));
+  for (const dup of duplicates) {
+    const best = findBestDuplicate(dup.files);
+    console.log(chalk.yellow(`\n  page_id: ${dup.pageId}`));
+    for (const file of dup.files) {
+      const isBest = file.path === best.path;
+      const marker = isBest ? chalk.green(' (keep)') : chalk.red(' (stale)');
+      const version = file.version ? `v${file.version}` : 'v?';
+      console.log(`    ${isBest ? chalk.green('*') : chalk.red('x')} ${file.path}${marker} - ${version}`);
+    }
+  }
+  console.log('');
+}
+
+/**
+ * Check for duplicate page_ids before push and prompt for confirmation
+ * Returns true if push should continue, false if user cancelled
+ */
+export async function checkDuplicatesBeforePush(directory: string): Promise<boolean> {
+  const allFiles = scanFilesForHealthCheck(directory);
+  const duplicates = findDuplicatePageIds(allFiles);
+
+  if (duplicates.length === 0) {
+    return true;
+  }
+
+  displayDuplicates(duplicates);
+
+  const shouldContinue = await confirm({
+    message: 'Continue with push? (Stale files may cause version conflicts)',
+    default: false,
+  });
+
+  if (!shouldContinue) {
+    console.log(chalk.gray('Run "cn doctor" to fix duplicate page_ids.'));
+    return false;
+  }
+  console.log('');
+  return true;
+}
+
+/**
+ * Display version conflict guidance, checking for duplicates that may explain the conflict
+ * This is called when a version mismatch is detected during push
+ */
+export function displayVersionConflictGuidance(directory: string, relativePath: string, remoteVersion: number): void {
+  const { hasDuplicates, duplicates } = checkFileForDuplicates(directory, relativePath);
+
+  if (hasDuplicates) {
+    const newerDuplicate = duplicates.find((d) => (d.version || 0) >= remoteVersion);
+    if (newerDuplicate) {
+      console.log(chalk.yellow('Found another file with the same page_id:'));
+      console.log(chalk.yellow(`  ${newerDuplicate.path} (v${newerDuplicate.version || '?'})`));
+      console.log('');
+      console.log(chalk.gray('This usually happens when a page was moved on Confluence.'));
+      console.log(chalk.gray(`The file at ${relativePath} appears to be stale.`));
+      console.log('');
+      console.log(chalk.gray('Recommended actions:'));
+      console.log(chalk.gray(`  1. Delete the stale file: rm "${relativePath}"`));
+      console.log(chalk.gray(`  2. Or run "cn doctor" to fix all duplicates`));
+    } else {
+      console.log(chalk.yellow('Found duplicate files with the same page_id:'));
+      for (const dup of duplicates) {
+        console.log(chalk.yellow(`  ${dup.path} (v${dup.version || '?'})`));
+      }
+      console.log('');
+      console.log(chalk.gray('Run "cn doctor" to identify and fix duplicates.'));
+    }
+  } else {
+    console.log(chalk.yellow('The page has been modified on Confluence since your last pull.'));
+    console.log(chalk.gray('Options:'));
+    console.log(chalk.gray(`  - Run "cn pull --page ${relativePath}" to get the latest version`));
+    console.log(chalk.gray(`  - Run "cn push ${relativePath} --force" to overwrite remote changes`));
+  }
+}

package/src/cli/commands/file-rename.ts

@@ -0,0 +1,113 @@
+/**
+ * File rename utilities for push operations
+ */
+
+import { existsSync, mkdtempSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import chalk from 'chalk';
+import { slugify, updateReferencesAfterRename } from '../../lib/markdown/index.js';
+
+// Index files that should not be renamed based on title (case-insensitive check)
+const INDEX_FILES = new Set(['index.md', 'readme.md']);
+
+/**
+ * Result of file rename operation
+ */
+export interface RenameResult {
+  finalPath: string;
+  wasRenamed: boolean;
+}
+
+/**
+ * Handle file renaming when title changes
+ * Returns the final local path for updating sync state
+ * Uses atomic operations: writes to temp file first, then renames
+ * Also updates references in other markdown files when a rename occurs
+ */
+export function handleFileRename(
+  filePath: string,
+  originalRelativePath: string,
+  expectedTitle: string,
+  updatedMarkdown: string,
+  spaceRoot?: string,
+): RenameResult {
+  const currentFilename = basename(filePath);
+  const currentDir = dirname(filePath);
+  const expectedSlug = slugify(expectedTitle);
+  const expectedFilename = `${expectedSlug}.md`;
+  // Track the current relative path (will be updated if file is renamed)
+  const currentRelativePath = originalRelativePath.replace(/^\.\//, '');
+  let finalLocalPath = currentRelativePath;
+
+  const isIndexFile = INDEX_FILES.has(currentFilename.toLowerCase());
+
+  // Write to temp file first for atomicity
+  const tempDir = mkdtempSync(join(tmpdir(), 'cn-push-'));
+  const tempFile = join(tempDir, 'temp.md');
+  writeFileSync(tempFile, updatedMarkdown, 'utf-8');
+
+  try {
+    if (!isIndexFile && expectedFilename !== currentFilename && expectedSlug) {
+      const newFilePath = join(currentDir, expectedFilename);
+
+      if (existsSync(newFilePath)) {
+        console.log(chalk.yellow(`  Note: Keeping filename "${currentFilename}" (${expectedFilename} already exists)`));
+        // Atomic rename: temp file -> original file
+        renameSync(tempFile, filePath);
+        return { finalPath: finalLocalPath, wasRenamed: false };
+      }
+
+      // Warn user about automatic rename
+      console.log(chalk.cyan(`  Note: File will be renamed to match page title`));
+
+      // Atomic operations: remove old file, move temp to new location
+      const backupPath = `${filePath}.bak`;
+      renameSync(filePath, backupPath);
+      try {
+        renameSync(tempFile, newFilePath);
+        // Clean up backup only after successful rename
+        try {
+          unlinkSync(backupPath);
+        } catch {
+          // Ignore cleanup errors
+        }
+      } catch (error) {
+        // Restore from backup if rename fails
+        try {
+          renameSync(backupPath, filePath);
+        } catch {
+          // If restore fails, log the backup location
+          console.error(chalk.red(`  Error: Failed to rename file. Backup available at: ${backupPath}`));
+        }
+        throw error;
+      }
+
+      const relativeDir = dirname(currentRelativePath);
+      const newRelativePath = relativeDir === '.' ? expectedFilename : join(relativeDir, expectedFilename);
+      finalLocalPath = newRelativePath;
+      console.log(chalk.cyan(`  Renamed: ${currentFilename} → ${expectedFilename}`));
+
+      // Update references in other markdown files that link to the old filename
+      if (spaceRoot) {
+        const updatedFiles = updateReferencesAfterRename(spaceRoot, currentRelativePath, newRelativePath);
+        if (updatedFiles.length > 0) {
+          console.log(chalk.cyan(`  Updated ${updatedFiles.length} file(s) with new link path`));
+        }
+      }
+
+      return { finalPath: finalLocalPath, wasRenamed: true };
+    }
+
+    // Atomic rename: temp file -> original file
+    renameSync(tempFile, filePath);
+    return { finalPath: finalLocalPath, wasRenamed: false };
+  } finally {
+    // Always clean up temp directory
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}

package/src/cli/commands/folder-hierarchy.ts

@@ -0,0 +1,241 @@
+/**
+ * Folder hierarchy management for push operations
+ * Per ADR-0023: Folder push workflow support
+ */
+
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { dirname } from 'node:path';
+import type { ConfluenceClient, CreateFolderRequest } from '../../lib/confluence-client/index.js';
+import { ApiError, EXIT_CODES } from '../../lib/errors.js';
+import {
+  getFolderByPath,
+  updateFolderSyncInfo,
+  writeSpaceConfig,
+  type FolderSyncInfo,
+  type SpaceConfigWithState,
+} from '../../lib/space-config.js';
+
+/**
+ * Result of ensureFolderHierarchy operation
+ */
+export interface FolderHierarchyResult {
+  parentId: string | undefined;
+  updatedConfig: SpaceConfigWithState;
+}
+
+// Maximum folder hierarchy depth to prevent hitting Confluence limits
+const MAX_FOLDER_DEPTH = 10;
+
+// Characters not allowed in Confluence page/folder titles
+const INVALID_TITLE_CHARS = /[|\\/:*?"<>]/g;
+
+/**
+ * Error thrown during folder hierarchy operations
+ */
+export class FolderHierarchyError extends Error {
+  constructor(
+    message: string,
+    public readonly exitCode: number,
+  ) {
+    super(message);
+    this.name = 'FolderHierarchyError';
+  }
+}
+
+/**
+ * Sanitize folder title for Confluence
+ * Removes invalid characters and returns sanitized title
+ */
+export function sanitizeFolderTitle(title: string): { sanitized: string; wasModified: boolean } {
+  const sanitized = title.replace(INVALID_TITLE_CHARS, '-').trim();
+  return { sanitized, wasModified: sanitized !== title };
+}
+
+/**
+ * Ensure folder hierarchy exists for a file path
+ * Per ADR-0023: Creates Confluence folders matching local directory structure
+ *
+ * @param client - Confluence client
+ * @param spaceConfig - Current space configuration
+ * @param directory - Base directory of the space
+ * @param filePath - Relative path to the file (e.g., "docs/api/endpoints.md")
+ * @param dryRun - If true, don't actually create folders
+ * @returns The leaf folder ID as parentId and updated config
+ */
+export async function ensureFolderHierarchy(
+  client: ConfluenceClient,
+  spaceConfig: SpaceConfigWithState,
+  directory: string,
+  filePath: string,
+  dryRun = false,
+): Promise<FolderHierarchyResult> {
+  // Extract directory path from file path
+  const normalizedPath = filePath.replace(/^\.\//, '');
+  const dirPath = dirname(normalizedPath);
+
+  // Root level file - no folder needed
+  if (dirPath === '.') {
+    return { parentId: undefined, updatedConfig: spaceConfig };
+  }
+
+  // Split directory path into segments
+  const segments = dirPath.split('/').filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    return { parentId: undefined, updatedConfig: spaceConfig };
+  }
+
+  // Path traversal validation - reject paths with ..
+  if (segments.some((s) => s === '..')) {
+    throw new FolderHierarchyError(
+      `Invalid path: "${dirPath}" contains path traversal sequences`,
+      EXIT_CODES.INVALID_ARGUMENTS,
+    );
+  }
+
+  // Folder depth guard - prevent hitting Confluence hierarchy limits
+  if (segments.length > MAX_FOLDER_DEPTH) {
+    throw new FolderHierarchyError(
+      `Folder hierarchy too deep: ${segments.length} levels (max: ${MAX_FOLDER_DEPTH})`,
+      EXIT_CODES.INVALID_ARGUMENTS,
+    );
+  }
+
+  let config = spaceConfig;
+  let currentParentId: string | undefined;
+  let currentPath = '';
+
+  // Iterate through each directory segment
+  for (const segment of segments) {
+    currentPath = currentPath ? `${currentPath}/${segment}` : segment;
+
+    // Check if folder already exists in local config
+    const existingLocalFolder = getFolderByPath(config, currentPath);
+    if (existingLocalFolder) {
+      currentParentId = existingLocalFolder.folderId;
+      continue;
+    }
+
+    // Sanitize folder title for Confluence
+    const { sanitized: folderTitle, wasModified } = sanitizeFolderTitle(segment);
+    if (wasModified) {
+      console.log(chalk.yellow(`  Note: Folder title sanitized: "${segment}" → "${folderTitle}"`));
+    }
+
+    // Check if folder already exists on Confluence (not in local config)
+    const existingRemoteFolder = await client.findFolderByTitle(config.spaceKey, folderTitle, currentParentId);
+    if (existingRemoteFolder) {
+      console.log(
+        chalk.gray(
+          `  Found existing folder on Confluence: ${existingRemoteFolder.title} (id: ${existingRemoteFolder.id})`,
+        ),
+      );
+
+      // Track folder in config
+      const folderInfo: FolderSyncInfo = {
+        folderId: existingRemoteFolder.id,
+        title: existingRemoteFolder.title,
+        parentId: currentParentId,
+        localPath: currentPath,
+      };
+      config = updateFolderSyncInfo(config, folderInfo);
+      writeSpaceConfig(directory, config);
+
+      currentParentId = existingRemoteFolder.id;
+      continue;
+    }
+
+    if (dryRun) {
+      console.log(chalk.gray(`  Would create folder: ${currentPath}`));
+      // In dry run, we can't continue because we don't have a real folder ID
+      return { parentId: undefined, updatedConfig: config };
+    }
+
+    // Prompt user for confirmation before creating folder
+    const shouldCreate = await confirm({
+      message: `Create folder "${folderTitle}" on Confluence?`,
+      default: true,
+    });
+
+    if (!shouldCreate) {
+      console.log(chalk.yellow(`  Skipping folder creation for "${folderTitle}"`));
+      throw new FolderHierarchyError(
+        `Cannot push to subdirectory without creating folder hierarchy`,
+        EXIT_CODES.GENERAL_ERROR,
+      );
+    }
+
+    console.log(chalk.gray(`  Creating folder: ${folderTitle}...`));
+
+    // Create folder on Confluence
+    const createRequest: CreateFolderRequest = {
+      spaceId: config.spaceId,
+      title: folderTitle,
+      parentId: currentParentId,
+    };
+
+    try {
+      const folder = await client.createFolder(createRequest);
+      console.log(chalk.green(`  Created folder: ${folder.title} (id: ${folder.id})`));
+
+      // Track folder in config
+      const folderInfo: FolderSyncInfo = {
+        folderId: folder.id,
+        title: folder.title,
+        parentId: currentParentId,
+        localPath: currentPath,
+      };
+      config = updateFolderSyncInfo(config, folderInfo);
+
+      // Save config immediately so we don't lose folder tracking on failure
+      writeSpaceConfig(directory, config);
+
+      currentParentId = folder.id;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(chalk.red(`  Failed to create folder "${folderTitle}": ${message}`));
+      throw new FolderHierarchyError(`Failed to create folder: ${folderTitle}`, EXIT_CODES.GENERAL_ERROR);
+    }
+  }
+
+  // Return the leaf folder ID - page will be created with this as parentId
+  // The v2 API supports creating pages directly under folders
+  return { parentId: currentParentId, updatedConfig: config };
+}
+
+/**
+ * Determine expected parent ID based on file's folder location.
+ *
+ * This is a semantic wrapper around ensureFolderHierarchy for use when updating
+ * existing pages. It answers: "What parent should this page have based on its
+ * current local file path?" - creating any missing folders in the process.
+ *
+ * For new pages, use ensureFolderHierarchy directly.
+ * For existing pages being moved, use this function to determine target parent.
+ *
+ * @param client - Confluence client
+ * @param spaceConfig - Current space configuration
+ * @param directory - Base directory of the space
+ * @param filePath - Relative path to the file
+ * @param dryRun - If true, don't create folders
+ * @returns The expected parent ID and updated config
+ */
+export async function determineExpectedParent(
+  client: ConfluenceClient,
+  spaceConfig: SpaceConfigWithState,
+  directory: string,
+  filePath: string,
+  dryRun = false,
+): Promise<FolderHierarchyResult> {
+  // Get directory path
+  const normalizedPath = filePath.replace(/^\.\//, '');
+  const dirPath = dirname(normalizedPath);
+
+  // Root level file - no parent
+  if (dirPath === '.') {
+    return { parentId: undefined, updatedConfig: spaceConfig };
+  }
+
+  // Use ensureFolderHierarchy to determine (and create if needed) the parent
+  return ensureFolderHierarchy(client, spaceConfig, directory, filePath, dryRun);
+}

package/src/cli/commands/info.ts

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { ConfluenceClient } from '../../lib/confluence-client/index.js';
+import { ConfigManager } from '../../lib/config.js';
+import { EXIT_CODES } from '../../lib/errors.js';
+import { escapeXml } from '../../lib/formatters.js';
+import { resolvePageTarget } from '../../lib/resolve-page-target.js';
+
+export interface InfoCommandOptions {
+  xml?: boolean;
+}
+
+export async function infoCommand(target: string, options: InfoCommandOptions = {}): Promise<void> {
+  const configManager = new ConfigManager();
+  const config = await configManager.getConfig();
+
+  if (!config) {
+    console.error(chalk.red('Not configured. Run: cn setup'));
+    process.exit(EXIT_CODES.CONFIG_ERROR);
+  }
+
+  const pageId = resolvePageTarget(target);
+  const client = new ConfluenceClient(config);
+
+  const [page, labels] = await Promise.all([client.getPage(pageId, false), client.getAllLabels(pageId)]);
+
+  if (options.xml) {
+    console.log('<page>');
+    console.log(`  <id>${escapeXml(page.id)}</id>`);
+    console.log(`  <title>${escapeXml(page.title)}</title>`);
+    console.log(`  <spaceId>${escapeXml(page.spaceId)}</spaceId>`);
+    if (page.status) console.log(`  <status>${escapeXml(page.status)}</status>`);
+    if (page.parentId) console.log(`  <parentId>${escapeXml(page.parentId)}</parentId>`);
+    if (page.version) console.log(`  <version>${page.version.number}</version>`);
+    if (page._links?.webui)
+      console.log(`  <url>${escapeXml(`${config.confluenceUrl}/wiki${page._links.webui}`)}</url>`);
+    if (labels.length > 0) {
+      console.log('  <labels>');
+      for (const label of labels) {
+        console.log(`    <label>${escapeXml(label.name)}</label>`);
+      }
+      console.log('  </labels>');
+    }
+    console.log('</page>');
+    return;
+  }
+
+  console.log(`${chalk.bold(page.title)}  ${chalk.gray(page.id)}`);
+  console.log(`Space: ${page.spaceId}`);
+  if (page.status) console.log(`Status: ${page.status}`);
+  if (page.parentId) console.log(`Parent: ${page.parentId}`);
+  if (page.version) console.log(`Version: ${page.version.number}`);
+  if (page._links?.webui) console.log(`URL: ${config.confluenceUrl}/wiki${page._links.webui}`);
+  if (labels.length > 0) {
+    console.log(`Labels: ${labels.map((l) => chalk.cyan(l.name)).join(', ')}`);
+  }
+}