ccraft 1.0.0

package/src/generators/metadata.js

@@ -0,0 +1,57 @@
+import { join } from 'path';
+import { ensureDir } from 'fs-extra/esm';
+import { safeWriteFile } from '../utils/file-writer.js';
+import { VERSION } from '../constants.js';
+
+/**
+ * Generate .claude/.claude-craft.json — single metadata + project index file.
+ * Combines installation metadata with the project snapshot (previously PROJECT_INDEX.json).
+ */
+export async function generate(config, targetDir, opts = {}) {
+  const claudeDir = join(targetDir, '.claude');
+  await ensureDir(claudeDir);
+
+  const metadata = {
+    version: VERSION,
+    generatedAt: new Date().toISOString(),
+    preset: config._presetAlias || null,
+    role: config.role || null,
+    intents: config.intents || [],
+    components: config.components || [],
+    agents: (config._selectedAgents || []).map((a) => a.id),
+    skills: (config._selectedSkills || []).map((s) => s.id),
+    rules: (config._selectedRules || []).map((r) => r.id),
+    mcps: (config._selectedMcps || []).map((m) => m.id),
+    workflows: (config._selectedWorkflows || []).map((w) => w.id),
+    project: {
+      name: config.name || null,
+      description: config.description || null,
+      type: config.projectType || null,
+      complexity: config.complexity ?? 0.5,
+    },
+    stack: {
+      languages: config.languages || [],
+      frameworks: config.frameworks || [],
+      codeStyle: config.codeStyle || [],
+      testFramework: config.testFramework || null,
+      packageManager: config.packageManager || null,
+      cicd: config.cicd || [],
+    },
+    architecture: config.architecture || null,
+    entryPoints: config.entryPoints || [],
+    coreModules: config.coreModules || [],
+    subprojects: config.subprojects || [],
+    buildCommands: config.buildCommands || {},
+    metrics: config.metrics || null,
+    stacks: (config._resolvedStacks || []).map(s => ({
+      id: s.id, name: s.name, impactScore: s.impactScore,
+    })),
+  };
+
+  const result = await safeWriteFile(
+    join(claudeDir, '.claude-craft.json'),
+    JSON.stringify(metadata, null, 2) + '\n',
+    { force: opts.force }
+  );
+  return [result];
+}

package/src/generators/security.js

@@ -0,0 +1,39 @@
+import { join } from 'path';
+import { pathExists, outputFile } from 'fs-extra/esm';
+import { readFileSync } from 'fs';
+import { generateSecurityGitignore } from '../utils/security.js';
+
+export async function generate(config, targetDir, opts = {}) {
+  const results = [];
+
+  if (!config.addSecurityGitignore) return results;
+
+  const gitignorePath = join(targetDir, '.gitignore');
+  const securityBlock = generateSecurityGitignore(config._detected || {});
+  const marker = '# ── Security: sensitive files (added by claude-craft) ──';
+
+  let content = '';
+  let exists = false;
+
+  if (await pathExists(gitignorePath)) {
+    exists = true;
+    content = readFileSync(gitignorePath, 'utf8');
+
+    // Don't add if already present
+    if (content.includes(marker)) {
+      results.push({ path: gitignorePath, status: 'skipped' });
+      return results;
+    }
+
+    // Append to existing
+    if (!content.endsWith('\n')) content += '\n';
+    content += '\n' + securityBlock;
+  } else {
+    content = securityBlock;
+  }
+
+  await outputFile(gitignorePath, content, 'utf8');
+  results.push({ path: gitignorePath, status: exists ? 'updated' : 'created' });
+
+  return results;
+}

package/src/prompts/gather.js

@@ -0,0 +1,308 @@
+import { resolve } from 'path';
+import { existsSync, statSync } from 'fs';
+import chalk from 'chalk';
+import {
+  ROLES,
+  INTENTS,
+  COMPONENTS,
+  PROJECT_TYPES,
+  SOURCE_CONTROLS,
+  DOCUMENT_TOOLS,
+} from '../constants.js';
+import { validateApiKeyFormat } from '../utils/mcp-setup.js';
+import { themedSelect, themedCheckbox, themedConfirm, themedPassword, themedInput } from '../ui/prompts.js';
+import { renderSummaryCard, renderWarningCard } from '../ui/cards.js';
+import { colors } from '../ui/theme.js';
+
+// ── Project path ────────────────────────────────────────────────────────
+
+export async function gatherProjectPath() {
+  const projectPath = await themedInput({
+    message: 'Project path:',
+    hint: 'Enter the path to the project you want to configure.',
+    default: process.cwd(),
+    validate: (v) => {
+      const p = resolve(v.trim());
+      if (!existsSync(p)) return 'Path does not exist.';
+      if (!statSync(p).isDirectory()) return 'Path is not a directory.';
+      return true;
+    },
+  });
+  return resolve(projectPath.trim());
+}
+
+// ── Create profile (new project from scratch) ─────────────────────────
+
+export async function gatherCreateProfile() {
+  console.log(colors.muted('\n  Let\'s set up your new project.\n'));
+
+  // Project name
+  const name = await themedInput({
+    message: 'Project name:',
+    hint: 'Leave empty to use the current directory. Letters, numbers, dots, hyphens, underscores only.',
+    validate: (v) => {
+      const t = v.trim();
+      if (!t) return true; // empty = use current directory
+      if (!/^[a-zA-Z0-9._-]+$/.test(t)) return 'Only letters, numbers, dots, hyphens, and underscores allowed.';
+      return true;
+    },
+  });
+
+  // Description (free text)
+  const description = await themedInput({
+    message: 'Describe what you want to build:',
+    hint: 'Be specific — this drives tech stack selection and project scaffolding.',
+    validate: (v) => (v.trim().length > 0 ? true : 'Please describe your project.'),
+  });
+
+  // Dev-only role (filtered from ROLES → developer children)
+  const devParent = ROLES.find((r) => r.value === 'developer');
+  const roleChoices = devParent.children.map((c) => ({
+    name: c.name,
+    value: c.value,
+    description: c.description,
+  }));
+
+  const role = await themedSelect({
+    message: 'What type of developer are you?',
+    hint: 'This tailors which agents and rules are installed.',
+    choices: roleChoices,
+  });
+
+  // Project type
+  const projectType = await themedSelect({
+    message: 'What kind of project is this?',
+    hint: 'Affects architecture-level agents and rules.',
+    choices: PROJECT_TYPES.map((pt) => ({
+      name: pt.name,
+      value: pt.value,
+    })),
+  });
+
+  return { name: name.trim(), description: description.trim(), role, projectType };
+}
+
+// ── Phase 1: User profile ──────────────────────────────────────────────
+
+export async function gatherUserProfile() {
+  console.log(colors.muted('\n  Let\'s personalize your Claude Code environment.\n'));
+
+  // Role category
+
+  const categoryChoices = ROLES.map((r) => ({
+    name: r.name,
+    value: r.value,
+    description: r.description,
+  }));
+  const category = await themedSelect({
+    message: 'What best describes your role?',
+    hint: 'A few agents and rules will be tailored to match your specialty.',
+    choices: categoryChoices,
+  });
+
+  // Sub-role if category has children
+  let role;
+  const parent = ROLES.find((r) => r.value === category);
+  if (parent && parent.children) {
+  
+    role = await themedSelect({
+      message: `Which ${parent.name.toLowerCase()} specialty fits best?`,
+      hint: 'This fine-tunes which agents and rules are installed.',
+      choices: parent.children.map((c) => ({
+        name: c.name,
+        value: c.value,
+        description: c.description,
+      })),
+    });
+  } else {
+    role = category;
+  }
+
+  // Intents
+
+  const intents = await themedCheckbox({
+    message: 'What will you use Claude Code for?',
+    hint: 'Select everything that applies. This determines which skills and workflows we install.',
+    choices: INTENTS.map((i) => ({
+      ...i,
+      checked: true,
+    })),
+    validate: (selected) => selected.length > 0 || 'Select at least one intent',
+  });
+
+  // Source control
+
+  const sourceControl = await themedSelect({
+    message: 'Where do you host your code?',
+    hint: 'We\'ll configure source-control integrations accordingly.',
+    choices: SOURCE_CONTROLS.map((sc) => ({
+      name: sc.name,
+      value: sc.value,
+      description: sc.description,
+    })),
+  });
+
+  // Document tools
+
+  const documentTools = await themedCheckbox({
+    message: 'Which project management tools do you use?',
+    hint: 'We can install MCP servers for these to give Claude context from your docs and tickets.',
+    choices: DOCUMENT_TOOLS.map((dt) => ({ ...dt, checked: false })),
+    required: true,
+  });
+
+  // If "None" was selected, clear all selections
+  if (documentTools.includes('none')) {
+    documentTools.length = 0;
+  }
+
+  // If "Other" was selected, prompt for the tool name
+  const otherIndex = documentTools.indexOf('other');
+  if (otherIndex !== -1) {
+    const otherTool = await themedInput({
+      message: 'Enter the name of your tool:',
+      validate: (v) => (v.trim() ? true : 'Please enter a tool name.'),
+    });
+    documentTools[otherIndex] = otherTool.trim();
+  }
+
+  return { role, intents, sourceControl, documentTools };
+}
+
+// ── MCP selection + credential setup ──────────────────────────────────
+
+export async function gatherMcpConfig(scoredMcps) {
+  console.log(chalk.bold('\n  MCP Servers\n'));
+
+  // Split into guaranteed and optional
+  const GUARANTEED_TIERS = new Set(['core', 'role', 'stack', 'auto']);
+  const guaranteedMcps = scoredMcps.filter((m) => GUARANTEED_TIERS.has(m.tier));
+  const optionalMcps = scoredMcps.filter((m) => !GUARANTEED_TIERS.has(m.tier));
+
+  // Display guaranteed MCPs
+  if (guaranteedMcps.length > 0) {
+    console.log(chalk.dim('  Auto-installed (core/role/stack):'));
+    for (const mcp of guaranteedMcps) {
+      const keyTag = mcp.requiresKey ? chalk.yellow(' [key required]') : '';
+      const tokenTag = mcp.tokenSaving ? colors.success(' [saves tokens]') : '';
+      console.log(colors.success(`    ✔ ${mcp.id}`) + chalk.dim(` — ${mcp.description}${keyTag}${tokenTag}`));
+    }
+    console.log();
+  }
+
+  // Show optional MCPs as checkbox
+  let selectedOptionalMcps = [];
+  if (optionalMcps.length > 0) {
+    const choices = optionalMcps.map((mcp) => {
+      const tags = [];
+      if (mcp.requiresKey) tags.push(chalk.yellow('[key required]'));
+      if (mcp.tokenSaving) tags.push(colors.success('[saves tokens]'));
+      if (mcp.score != null) tags.push(chalk.dim(`(${Math.round(mcp.score * 100)}%)`));
+      const suffix = tags.length ? ' ' + tags.join(' ') : '';
+      return {
+        name: `${mcp.id}${suffix}`,
+        value: mcp.id,
+        description: mcp.description,
+        checked: mcp.recommended || false,
+      };
+    });
+
+  
+    const selectedOptionalIds = await themedCheckbox({
+      message: 'Select additional MCP servers',
+      hint: 'Sorted by relevance to your project. Recommended ones are pre-selected.',
+      choices,
+    });
+
+    selectedOptionalMcps = optionalMcps.filter((m) => selectedOptionalIds.includes(m.id));
+  }
+
+  const selectedMcps = [...guaranteedMcps, ...selectedOptionalMcps];
+
+  // Collect API keys
+  const mcpKeys = {};
+  const needKeys = selectedMcps.filter((m) => m.requiresKey);
+
+  if (needKeys.length > 0) {
+    console.log(chalk.dim('\n  Configure API keys\n'));
+
+    for (const mcp of needKeys) {
+      const keyDefs = mcp.keyNames || [{ name: mcp.keyName, description: mcp.keyDescription }];
+      const collected = {};
+
+      for (const keyDef of keyDefs) {
+        const key = await themedPassword({
+          message: `${mcp.id} — ${keyDef.description}:`,
+          hint: `Press Enter to skip. You can set ${keyDef.name} as an env variable later.`,
+          mask: '*',
+        });
+        if (key && key.trim()) {
+          const { warning } = validateApiKeyFormat(mcp.id, keyDef.name, key.trim());
+          if (warning) {
+            console.log(chalk.yellow(`    ⚠ ${warning}`));
+          }
+          collected[keyDef.name] = key.trim();
+        } else {
+          console.log(chalk.dim(`    Skipped — set ${keyDef.name} env var later`));
+        }
+      }
+
+      if (Object.keys(collected).length > 0) {
+        mcpKeys[mcp.id] = collected;
+      }
+    }
+  }
+
+  return { selectedMcps, mcpKeys };
+}
+
+// ── Security configuration ────────────────────────────────────────────
+
+export function gatherSecurityConfig(detected) {
+  if (detected.sensitiveFiles.found.length > 0) {
+    const items = [...detected.sensitiveFiles.found];
+    if (!detected.sensitiveFiles.gitignoreCovers) {
+      items.push('These may not be covered by .gitignore!');
+    }
+    renderWarningCard('Sensitive files detected:', items);
+    console.log();
+  }
+
+  // Always add security patterns — no prompt needed
+  return { addSecurityGitignore: true };
+}
+
+// ── Confirm installation ──────────────────────────────────────────────
+
+export async function confirmInstallation(summary) {
+  renderSummaryCard(summary);
+  console.log();
+
+
+  const proceed = await themedConfirm({
+    message: 'Ready to install?',
+    hint: 'This will create files in .claude/ and update .gitignore and settings.json.',
+    default: true,
+  });
+
+  return proceed;
+}
+
+// ── Defaults (non-interactive mode) ───────────────────────────────────
+
+export function getDefaults(detected) {
+  return {
+    role: 'web',
+    intents: ['implementing', 'debugging', 'refactoring', 'testing', 'reviewing'],
+    sourceControl: 'github',
+    documentTools: [],
+    name: detected.name || 'my-project',
+    description: detected.description || '',
+    projectType: detected.projectType || 'monolith',
+    languages: detected.languages.length ? detected.languages : ['JavaScript'],
+    frameworks: detected.frameworks,
+    components: COMPONENTS.map((c) => c.value),
+    addSecurityGitignore: true,
+    mcpKeys: {},
+  };
+}

package/src/ui/brand.js

@@ -0,0 +1,62 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import { isNarrow, isTTY, colors } from './theme.js';
+
+const LOGO_TEXT = 'Claude Craft';
+
+const OVERVIEW_LINES = [
+  '  What we\'ll do:',
+  '',
+  '  1. Learn about you     Your role and preferences',
+  '  2. Analyze project     Deep-scan your codebase',
+  '  3. Configure           Pick servers and settings',
+  '  4. Install             Write optimized config',
+  '  5. Finalize            Polish and verify',
+];
+
+/**
+ * Render the ASCII logo with gradient coloring.
+ * Falls back to plain text on narrow terminals or non-TTY.
+ */
+export function renderLogo() {
+  if (isNarrow() || !isTTY()) {
+    return chalk.bold.cyan('  Claude Craft');
+  }
+
+  try {
+    const raw = figlet.textSync(LOGO_TEXT, { font: 'Small' });
+    const colored = gradient(['#6EC1E4', '#8B5CF6']).multiline(raw);
+    return colored
+      .split('\n')
+      .map((line) => '  ' + line)
+      .join('\n');
+  } catch {
+    return chalk.bold.cyan('  Claude Craft');
+  }
+}
+
+/**
+ * Render the full welcome banner: logo + version + overview card.
+ */
+export function renderBanner(version) {
+  console.log();
+  console.log(renderLogo());
+  console.log(colors.muted(`  v${version}  Intelligent Claude Code Configurator`));
+  console.log();
+
+  if (!isNarrow()) {
+    const overviewContent = OVERVIEW_LINES.join('\n');
+    const box = boxen(overviewContent, {
+      padding: { top: 0, bottom: 0, left: 0, right: 1 },
+      margin: { top: 0, bottom: 0, left: 2, right: 0 },
+      borderStyle: 'round',
+      borderColor: 'cyan',
+      dimBorder: true,
+    });
+    console.log(box);
+  }
+
+  console.log();
+}

package/src/ui/cards.js

@@ -0,0 +1,179 @@
+import boxen from 'boxen';
+import chalk from 'chalk';
+import { boxStyles, isNarrow, isTTY, colors } from './theme.js';
+
+/**
+ * Render project analysis as a styled card.
+ */
+export function renderProjectCard(projectInfo) {
+  const lines = [];
+
+  lines.push(chalk.bold('  Project Analysis'));
+  lines.push('');
+
+  const row = (label, value) => {
+    if (!value) return;
+    const padded = label.padEnd(16);
+    lines.push(`  ${chalk.dim(padded)}${colors.success(value)}`);
+  };
+
+  row('Name', projectInfo.name + (projectInfo.description ? chalk.dim(` — ${projectInfo.description}`) : ''));
+  row('Type', projectInfo.projectType);
+
+  if (projectInfo.languageDistribution) {
+    const distStr = Object.entries(projectInfo.languageDistribution)
+      .sort(([, a], [, b]) => b - a)
+      .map(([lang, pct]) => `${lang} (${pct}%)`)
+      .join(', ');
+    row('Languages', distStr);
+  } else if (projectInfo.languages?.length) {
+    row('Languages', projectInfo.languages.join(', '));
+  }
+
+  if (projectInfo.frameworks?.length) row('Frameworks', projectInfo.frameworks.join(', '));
+  if (projectInfo.codeStyle?.length) row('Code style', projectInfo.codeStyle.join(', '));
+  if (projectInfo.cicd?.length) row('CI/CD', projectInfo.cicd.join(', '));
+  if (projectInfo.architecture) row('Architecture', projectInfo.architecture);
+
+  if (typeof projectInfo.complexity === 'number') {
+    const cl = projectInfo.complexity;
+    const label = cl >= 0.7 ? 'complex' : cl >= 0.4 ? 'moderate' : 'simple';
+    row('Complexity', `${cl.toFixed(2)} (${label})`);
+  }
+
+  if (projectInfo.metrics) {
+    const m = projectInfo.metrics;
+    const parts = [];
+    if (m.totalFiles) parts.push(`${m.totalFiles} files`);
+    if (m.dependencyCount) parts.push(`${m.dependencyCount} deps`);
+    if (m.testFileCount) parts.push(`${m.testFileCount} tests`);
+    if (m.estimatedTestCoverage && m.estimatedTestCoverage !== 'unknown') parts.push(`~${m.estimatedTestCoverage} coverage`);
+    if (parts.length) row('Metrics', parts.join(', '));
+  }
+
+  if (projectInfo.entryPoints?.length > 0) {
+    row('Entry points', projectInfo.entryPoints.map((e) => e.path).join(', '));
+  }
+
+  if (projectInfo.subprojects?.length > 0) {
+    lines.push(chalk.dim('  Subprojects:'));
+    for (const sub of projectInfo.subprojects) {
+      const fws = sub.frameworks?.length ? ` (${sub.frameworks.join(', ')})` : '';
+      lines.push(chalk.dim(`    ${chalk.green('•')} ${sub.path}: ${sub.languages.join(', ')}${fws}`));
+    }
+  }
+
+  if (projectInfo.buildCommands) {
+    const defined = Object.entries(projectInfo.buildCommands).filter(([, v]) => v);
+    if (defined.length > 0) {
+      row('Commands', defined.map(([k, v]) => `${k}: ${v}`).join(', '));
+    }
+  }
+
+  const content = lines.join('\n');
+
+  if (isNarrow() || !isTTY()) {
+    console.log(content);
+    return;
+  }
+
+  console.log(boxen(content, {
+    ...boxStyles.info,
+    title: 'Analysis',
+    titleAlignment: 'left',
+  }));
+}
+
+/**
+ * Render the installation summary card before confirmation.
+ */
+export function renderSummaryCard(summary) {
+  const lines = [];
+  lines.push(chalk.bold('  Installation Summary'));
+  lines.push('');
+
+  const countItems = (bucket) => {
+    if (!bucket) return 0;
+    return Object.values(bucket).reduce((sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0), 0);
+  };
+
+  const guaranteedCount = countItems(summary.guaranteed);
+  const candidateCount = countItems(summary.candidates);
+  const mcpCount = summary.mcps ? summary.mcps.length : 0;
+
+  lines.push(`  ${chalk.dim('Guaranteed components'.padEnd(24))}${colors.success(String(guaranteedCount))}`);
+  if (candidateCount > 0) {
+    lines.push(`  ${chalk.dim('Candidates for scoring'.padEnd(24))}${colors.primary(String(candidateCount))}`);
+  }
+  lines.push(`  ${chalk.dim('MCP servers'.padEnd(24))}${colors.success(String(mcpCount))}`);
+
+  const content = lines.join('\n');
+
+  if (isNarrow() || !isTTY()) {
+    console.log(content);
+    return;
+  }
+
+  console.log(boxen(content, boxStyles.info));
+}
+
+/**
+ * Render the final success card.
+ */
+export function renderSuccessCard({ totalItems, mcpCount, mcpsNeedingKeys }) {
+  const lines = [];
+  lines.push(chalk.bold.green('  Installation complete!'));
+  lines.push('');
+  lines.push(`  ${chalk.dim('Settings installed'.padEnd(22))}${colors.success(String(totalItems))} ${chalk.dim('(guaranteed + selected)')}`);
+  lines.push(`  ${chalk.dim('MCP servers'.padEnd(22))}${colors.success(String(mcpCount))}`);
+
+  if (mcpsNeedingKeys.length > 0) {
+    lines.push('');
+    lines.push(chalk.yellow('  MCP servers needing API keys:'));
+    for (const r of mcpsNeedingKeys) {
+      lines.push(chalk.yellow(`    ${chalk.dim('•')} ${r.id}: set ${r.apiKey.keyName}`));
+    }
+  }
+
+  lines.push('');
+  lines.push(chalk.dim('  Next steps:'));
+  lines.push(chalk.dim(`    1. Read ${chalk.underline('USER_GUIDE.md')} for a full feature overview`));
+
+  let step = 2;
+  if (mcpsNeedingKeys.length > 0) {
+    lines.push(chalk.dim(`    ${step}. Set missing API keys for MCP servers (see above)`));
+    step++;
+  }
+  lines.push(chalk.dim(`    ${step}. Start Claude Code and try out some commands!`));
+  step++;
+  lines.push(chalk.dim(`    ${step}. Customize .claude/ to your needs`));
+
+  const content = lines.join('\n');
+
+  if (isNarrow() || !isTTY()) {
+    console.log('\n' + content);
+    return;
+  }
+
+  console.log(boxen(content, boxStyles.success));
+}
+
+/**
+ * Render a warning card (e.g., sensitive files detected).
+ */
+export function renderWarningCard(title, items) {
+  const lines = [];
+  lines.push(chalk.yellow(`  ${title}`));
+  for (const item of items) {
+    lines.push(chalk.yellow(`    ${chalk.dim('•')} ${item}`));
+  }
+
+  const content = lines.join('\n');
+
+  if (isNarrow() || !isTTY()) {
+    console.log(content);
+    return;
+  }
+
+  console.log(boxen(content, boxStyles.warning));
+}

package/src/ui/format.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import { getTerminalWidth } from './theme.js';
+
+/**
+ * Indent every line of text by N spaces.
+ */
+export function indent(text, spaces = 2) {
+  const pad = ' '.repeat(spaces);
+  return text
+    .split('\n')
+    .map((line) => pad + line)
+    .join('\n');
+}
+
+/**
+ * Horizontal divider line.
+ */
+export function divider(width) {
+  const w = width || Math.min(getTerminalWidth() - 4, 56);
+  return chalk.dim('  ' + '─'.repeat(w));
+}
+
+/**
+ * Pluralize a word based on count.
+ */
+export function pluralize(count, singular, plural) {
+  return count === 1 ? `${count} ${singular}` : `${count} ${plural || singular + 's'}`;
+}
+
+/**
+ * Truncate text with ellipsis if too long.
+ */
+export function truncate(text, maxLen = 60) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 1) + '…';
+}
+
+/**
+ * Format milliseconds as human-readable duration.
+ */
+export function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+/**
+ * Dot-padded label + value (e.g., "Node.js v20.11.0 ............ ok").
+ */
+export function dotPad(label, value, totalWidth) {
+  const w = totalWidth || Math.min(getTerminalWidth() - 8, 48);
+  const stripped = label.replace(/\x1b\[[0-9;]*m/g, '');
+  const valStripped = value.replace(/\x1b\[[0-9;]*m/g, '');
+  const dotsNeeded = Math.max(2, w - stripped.length - valStripped.length);
+  return label + chalk.dim(' ' + '.'.repeat(dotsNeeded) + ' ') + value;
+}