plankit-cli 1.4.0 → 1.6.0

package/src/analyzer/vueScanner.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Fast static analyzer for Vue SFC (.vue) and JS/TS files.
+ * Uses lightweight block extraction and heuristic parsing without external dependencies.
+ */
+
+export function analyzeVueFile(filePath, content = null) {
+  const code = content !== null ? content : fs.readFileSync(filePath, 'utf8');
+  const lines = code.split(/\r?\n/);
+  const lineCount = lines.length;
+
+  const templateBlock = extractBlock(code, 'template');
+  const scriptBlock = extractBlock(code, 'script');
+  const styleBlocks = extractAllBlocks(code, 'style');
+
+  const isScriptSetup = /<script\s+[^>]*setup/i.test(code);
+  const hasScript = scriptBlock !== null || isScriptSetup;
+  const scriptContent = scriptBlock ? scriptBlock.content : '';
+  const scriptAttributes = scriptBlock ? scriptBlock.attributes : '';
+
+  // Language detection
+  const isTs = /lang=["'](?:ts|typescript)["']/i.test(code) ||
+    filePath.endsWith('.ts') ||
+    filePath.endsWith('.tsx');
+  const language = isTs ? 'ts' : 'js';
+
+  // Vue style detection (Options API, Composition API, or <script setup>)
+  let vueStyle = 'unknown';
+  if (isScriptSetup) {
+    vueStyle = 'script_setup';
+  } else if (hasScript) {
+    if (/\bsetup\s*\([^)]*\)\s*\{/i.test(scriptContent) || /\bdefineComponent\s*\(/i.test(scriptContent)) {
+      vueStyle = 'composition';
+    } else if (/\b(?:data\s*\(\)|methods\s*:|computed\s*:|watch\s*:)/i.test(scriptContent)) {
+      vueStyle = 'options';
+    } else {
+      vueStyle = 'transitional';
+    }
+  }
+
+  // State detection
+  const hasPinia = /\b(?:use\w+Store|defineStore)\b/i.test(code);
+  const hasVuex = /\b(?:this\.\$store|mapState|mapGetters|mapActions|mapMutations|createNamespacedHelpers)\b/i.test(code);
+  const hasComposable = /\buse(?!Store\b)\w+\s*\(/i.test(code);
+  const hasLocal = /\b(?:ref|reactive|shallowRef)\s*\(/i.test(code);
+
+  let state = 'local';
+  if (hasPinia && hasVuex) {
+    state = 'mixed';
+  } else if (hasPinia) {
+    state = 'pinia';
+  } else if (hasVuex) {
+    state = 'vuex';
+  } else if (hasComposable) {
+    state = 'composable';
+  } else if (hasLocal) {
+    state = 'local';
+  }
+
+  // Data access detection
+  let dataAccess = 'unknown';
+  if (/\baxios\.(?:get|post|put|delete|patch)\b/i.test(code)) {
+    dataAccess = 'axios_component';
+  } else if (/\buseQuery\b|\buseMutation\b/i.test(code)) {
+    dataAccess = 'query_library';
+  } else if (/\b(?:useFetch|\$fetch)\b/i.test(code)) {
+    dataAccess = 'fetch_composable';
+  } else if (/\b(?:api|service|client)\.\w+\b/i.test(code)) {
+    dataAccess = 'api_service';
+  }
+
+  // Styling analysis
+  const stylingTypes = new Set();
+  let hasScoped = false;
+  let hasGlobal = false;
+  for (const style of styleBlocks) {
+    const isScoped = /\bscoped\b/i.test(style.attributes);
+    const isModule = /\bmodule\b/i.test(style.attributes);
+    const isScss = /lang=["'](?:scss|sass)["']/i.test(style.attributes);
+
+    if (isModule) stylingTypes.add('modules');
+    if (isScoped) {
+      hasScoped = true;
+      stylingTypes.add(isScss ? 'scoped_scss' : 'scoped_css');
+    } else {
+      hasGlobal = true;
+      stylingTypes.add(isScss ? 'global_scss' : 'global_css');
+    }
+  }
+  if (templateBlock && /\bclass=["'][^"']*\b(?:flex|grid|p-|m-|text-|bg-|w-|h-)\b/i.test(templateBlock.content)) {
+    stylingTypes.add('utility');
+  }
+  const styling = stylingTypes.size > 0 ? Array.from(stylingTypes) : ['scoped_css'];
+
+  // Design token discovery (hex colors, font sizes, margins, padding)
+  const tokens = extractTokens(code);
+
+  // Anti-patterns and hotspots
+  const hotspots = [];
+  if (lineCount > 400) {
+    hotspots.push({ type: 'god_component', message: `Large SFC (${lineCount} lines)` });
+  }
+  if (/\b(?:this\.\$)/.test(code)) {
+    hotspots.push({ type: 'deprecated_global_property', message: 'Uses legacy this.$ properties' });
+  }
+  if (/::v-deep|>>>|\/deep\//.test(code)) {
+    hotspots.push({ type: 'deprecated_deep_selector', message: 'Uses deprecated deep CSS selector (::v-deep or /deep/)' });
+  }
+  if (/\bmixins\s*:\s*\[/i.test(code)) {
+    hotspots.push({ type: 'vue_mixins', message: 'Uses Vue mixins (replace with composables)' });
+  }
+  if (/\bfilters\s*:\s*\{/i.test(code)) {
+    hotspots.push({ type: 'vue_filters', message: 'Uses Vue 2 filters (not supported in Vue 3)' });
+  }
+  if (/\b\$on\b|\b\$emit\b.*eventBus|new\s+Vue\(\)/i.test(code)) {
+    hotspots.push({ type: 'event_bus', message: 'Uses global event bus' });
+  }
+
+  // Maturity classification
+  let maturity = 'preferred';
+  if (vueStyle === 'options' || hotspots.some((h) => h.type === 'vue_mixins' || h.type === 'vue_filters')) {
+    maturity = 'legacy';
+  } else if (vueStyle === 'composition' || language === 'js' || state === 'vuex' || hasGlobal) {
+    maturity = 'transitional';
+  } else if (vueStyle === 'script_setup' && language === 'ts') {
+    maturity = 'preferred';
+  }
+
+  return {
+    filePath,
+    fileName: path.basename(filePath),
+    lineCount,
+    language,
+    vueStyle,
+    state,
+    dataAccess,
+    styling,
+    hasScoped,
+    hasGlobal,
+    tokens,
+    hotspots,
+    maturity
+  };
+}
+
+function extractBlock(code, tag) {
+  const openRegex = new RegExp(`<${tag}(\\s+[^>]*)?>`, 'i');
+  const match = openRegex.exec(code);
+  if (!match) return null;
+
+  const startIndex = match.index + match[0].length;
+  const closeTag = `</${tag}>`;
+  const endIndex = code.indexOf(closeTag, startIndex);
+  if (endIndex === -1) {
+    return {
+      attributes: match[1] || '',
+      content: code.slice(startIndex)
+    };
+  }
+
+  return {
+    attributes: match[1] || '',
+    content: code.slice(startIndex, endIndex)
+  };
+}
+
+function extractAllBlocks(code, tag) {
+  const blocks = [];
+  const regex = new RegExp(`<${tag}(\\s+[^>]*)?>([\\s\\S]*?)<\\/${tag}>`, 'gi');
+  let match;
+  while ((match = regex.exec(code)) !== null) {
+    blocks.push({
+      attributes: match[1] || '',
+      content: match[2]
+    });
+  }
+  return blocks;
+}
+
+function extractTokens(code) {
+  const hexColors = new Set();
+  const hexRegex = /#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b/g;
+  let match;
+  while ((match = hexRegex.exec(code)) !== null) {
+    hexColors.add(match[0].toLowerCase());
+  }
+
+  const spacingValues = new Set();
+  const spacingRegex = /(?:margin|padding|gap|top|bottom|left|right):\s*([0-9]+(?:px|rem|em))/gi;
+  while ((match = spacingRegex.exec(code)) !== null) {
+    spacingValues.add(match[1].toLowerCase());
+  }
+
+  return {
+    hexColors: Array.from(hexColors),
+    spacing: Array.from(spacingValues)
+  };
+}

package/src/cli.js

@@ -23,6 +23,9 @@ import {
   normalizeFramework,
   parseFrameworksInput
 } from './commandBundles.js';
+import { runAnalysis, formatReport } from './analyzer/engine.js';
+import { loadDashboardData, renderStaticDashboard, runInteractiveDashboard } from './dashboard/dashboard.js';
+import { startServer } from './server/server.js';
 
 export async function runCli(args, context = {}) {
   const io = createIo(context);
@@ -50,6 +53,19 @@ export async function runCli(args, context = {}) {
       case 'status':
         showStatus(parsed, io);
         break;
+      case 'scan':
+      case 'health':
+      case 'audit':
+        await scanRepository(parsed, io);
+        break;
+      case 'ui':
+      case 'dashboard':
+        await showDashboard(parsed, io);
+        break;
+      case 'serve':
+      case 'web':
+        await startWebServer(parsed, io);
+        break;
       case 'archive':
         archiveFeature(parsed, io);
         break;
@@ -365,6 +381,99 @@ function archiveFeature(parsed, io) {
   io.stdout(`Feature "${featureName}" archived.`);
 }
 
+async function scanRepository(parsed, io) {
+  const { config } = loadConfig(io.cwd);
+  const targetDir = parsed.positionals[0] ? path.resolve(io.cwd, parsed.positionals[0]) : io.cwd;
+  const report = await runAnalysis(targetDir, {
+    artifactsDir: config.artifactsDir
+  });
+
+  if (parsed.flags.json) {
+    io.stdout(JSON.stringify(report, null, 2));
+  } else {
+    io.stdout(formatReport(report, io.isTTY));
+  }
+
+  if (parsed.flags.threshold) {
+    const threshold = Number.parseInt(parsed.flags.threshold, 10);
+    if (Number.isInteger(threshold) && report.score.total < threshold) {
+      throw new Error(`Health score ${report.score.total} is below required threshold ${threshold}`);
+    }
+  }
+}
+
+async function showDashboard(parsed, io) {
+  const { config } = loadConfig(io.cwd);
+  const data = loadDashboardData(io.cwd, config);
+
+  if (!io.isTTY || parsed.flags['no-tui']) {
+    renderStaticDashboard(data, io);
+    return;
+  }
+
+  await runInteractiveDashboard(io.cwd, io, config, {
+    implement: async (featureName, phaseNum) => {
+      prepareImplementation({ positionals: [featureName, String(phaseNum)], flags: {} }, io);
+    },
+    clarify: async (featureName) => {
+      clarifyFeature({ positionals: [featureName], flags: {} }, io);
+    },
+    review: async (featureName) => {
+      reviewFeature({ positionals: [featureName], flags: { 'skip-test': true, 'skip-build': true } }, io);
+    }
+  });
+}
+
+async function startWebServer(parsed, io) {
+  const { config } = loadConfig(io.cwd);
+  let port = null;
+
+  const rawPort = parsed.flags.port || parsed.flags.p;
+  if (rawPort !== undefined) {
+    const parsedNum = Number.parseInt(rawPort, 10);
+    if (!Number.isInteger(parsedNum) || parsedNum < 0 || parsedNum > 65535) {
+      throw new Error(`Invalid port "${rawPort}". Please provide a valid port between 1 and 65535.`);
+    }
+    port = parsedNum;
+  } else if (io.isTTY && io.promptChoice) {
+    const answer = await io.promptChoice('Enter port for PlanKit Web Dashboard (default: 4200): ', ['4200']);
+    if (answer && answer.trim()) {
+      const parsedNum = Number.parseInt(answer.trim(), 10);
+      if (!Number.isInteger(parsedNum) || parsedNum < 0 || parsedNum > 65535) {
+        throw new Error(`Invalid port "${answer}". Please provide a valid port between 1 and 65535.`);
+      }
+      port = parsedNum;
+    } else {
+      port = 4200;
+    }
+  } else {
+    port = 4200;
+  }
+
+  io.stdout(`Starting PlanKit Web Dashboard on port ${port}...`);
+
+  const { server, port: actualPort } = await startServer({
+    cwd: io.cwd,
+    config,
+    port,
+    io
+  });
+
+  const url = `http://localhost:${actualPort}`;
+  io.stdout('');
+  io.stdout('======================================================');
+  io.stdout(`  PlanKit Web Dashboard running at: ${url}`);
+  io.stdout('======================================================');
+  io.stdout('Press Ctrl+C to stop.');
+
+  // Keep process alive if interactive/standalone
+  if (!parsed.flags['no-keep-alive'] && parsed.flags['keep-alive'] !== false) {
+    await new Promise(() => {});
+  } else {
+    server.close();
+  }
+}
+
 function moveFeatureToArchive(cwd, config, featureName, dryRun = false) {
   const sourceDir = requireFeatureDir(cwd, config, featureName);
   const targetDir = safeJoin(cwd, config.artifactsDir, 'archived', featureName);
@@ -734,6 +843,9 @@ Commands:
   implement <feature> <phase>       Validate phase context and prepare phase output artifact
   review <feature>                  Run verification and archive a completed feature
   status [--json]                   Show active and archived features
+  scan [dir]                        Run static analysis and generate artifacts/.plankit-index.json
+  ui                                Launch interactive feature progress dashboard
+  serve [--port <n>]                Launch visual local web dashboard companion (alias: web)
   archive <feature>                 Move a feature to archived without running verification
   version                          Show the installed PlankKit CLI version
   help                              Show this help message
@@ -746,6 +858,10 @@ Options:
   --framework <name>                Select framework command suite during init
                                     (angular, vue, dotnet, none, all; default: none)
   --frameworks <list>               Comma-separated list of framework suites during init
+  --port <number>                   Specify port for web dashboard (default: 4200)
+  --threshold <score>               Fail scan if health score is below threshold
+  --json                            Output scan report or status as JSON
+  --no-tui                          Render static summary table instead of interactive dashboard
   --global-gemini-skills            Also install Gemini skills under the user profile
   --phases 3                        Generate N default phases during plan
   --phases "Design,Build,Test"      Generate named phases during plan

package/src/dashboard/dashboard.js

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { listDirectories, safeJoin } from '../config.js';
+import { runAnalysis, formatReport } from '../analyzer/engine.js';
+
+export function loadDashboardData(cwd, config) {
+  const artifactsDir = safeJoin(cwd, config.artifactsDir || 'artifacts');
+  const currentDir = path.join(artifactsDir, 'current');
+  const archivedDir = path.join(artifactsDir, 'archived');
+
+  const activeNames = listDirectories(currentDir);
+  const archivedNames = listDirectories(archivedDir);
+
+  const activeFeatures = activeNames.map((name) => {
+    const featureDir = path.join(currentDir, name);
+    const phasesDir = path.join(featureDir, 'phases');
+    const outputsDir = path.join(featureDir, 'outputs');
+
+    const phaseFiles = fs.existsSync(phasesDir)
+      ? fs.readdirSync(phasesDir).filter((f) => f.startsWith('phase-') && f.endsWith('.md')).sort()
+      : [];
+    const outputFiles = fs.existsSync(outputsDir)
+      ? fs.readdirSync(outputsDir).filter((f) => f.startsWith('phase-') && f.endsWith('.md')).sort()
+      : [];
+
+    let state = null;
+    const stateFile = path.join(featureDir, 'plankit.json');
+    if (fs.existsSync(stateFile)) {
+      try {
+        state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      } catch {
+        state = null;
+      }
+    }
+
+    const phases = phaseFiles.map((pf, idx) => {
+      const num = idx + 1;
+      const expectedOutput = `phase-${num}-output.md`;
+      const hasOutput = outputFiles.includes(expectedOutput);
+      return {
+        number: num,
+        specFile: pf,
+        hasOutput,
+        status: hasOutput ? 'DONE' : (num === outputFiles.length + 1 ? 'IN_PROGRESS' : 'PENDING')
+      };
+    });
+
+    const completedCount = phases.filter((p) => p.hasOutput).length;
+    const totalCount = phases.length || 1;
+    const progressPercent = Math.round((completedCount / totalCount) * 100);
+
+    return {
+      name,
+      phases,
+      phaseCount: phases.length,
+      completedCount,
+      progressPercent,
+      state
+    };
+  });
+
+  return {
+    activeFeatures,
+    archivedCount: archivedNames.length,
+    archivedNames
+  };
+}
+
+export function renderStaticDashboard(data, io) {
+  io.stdout('================================================================');
+  io.stdout('               PlanKit Feature Management Matrix               ');
+  io.stdout('================================================================');
+  io.stdout(`Active Features: ${data.activeFeatures.length} | Archived Features: ${data.archivedCount}`);
+  io.stdout('');
+
+  if (data.activeFeatures.length === 0) {
+    io.stdout('  No active features found in artifacts/current/.');
+    io.stdout('  Run "plankit plan <feature-name>" to start a feature.');
+    io.stdout('================================================================');
+    return;
+  }
+
+  io.stdout(padRight('Feature Name', 25) + padRight('Phases', 12) + padRight('Progress', 20) + 'Status');
+  io.stdout('-'.repeat(64));
+
+  data.activeFeatures.forEach((feat) => {
+    const progressText = `${progressBar(feat.progressPercent, 10)} ${feat.progressPercent}%`;
+    const statusText = feat.completedCount === feat.phaseCount ? 'READY_FOR_REVIEW' : `PHASE_${feat.completedCount + 1}`;
+    io.stdout(padRight(feat.name, 25) + padRight(`${feat.completedCount}/${feat.phaseCount}`, 12) + padRight(progressText, 20) + statusText);
+
+    feat.phases.forEach((p) => {
+      const check = p.hasOutput ? '[x]' : '[ ]';
+      io.stdout(`    ${check} Phase ${p.number}: ${p.specFile} (${p.status})`);
+    });
+    io.stdout('');
+  });
+
+  io.stdout('================================================================');
+}
+
+export async function runInteractiveDashboard(cwd, io, config, handlers = {}) {
+  const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const data = loadDashboardData(cwd, config);
+
+  if (!isTTY) {
+    renderStaticDashboard(data, io);
+    return;
+  }
+
+  let selectedIndex = 0;
+  let statusMessage = 'Use [↑/↓] or [j/k] to navigate. Press [q] to exit.';
+
+  function refresh() {
+    const freshData = loadDashboardData(cwd, config);
+    console.clear();
+    console.log('\x1b[1m================================================================\x1b[0m');
+    console.log('\x1b[1m\x1b[36m             PlanKit Interactive Feature Dashboard             \x1b[0m');
+    console.log('\x1b[1m================================================================\x1b[0m');
+    console.log(`Active Features: \x1b[32m${freshData.activeFeatures.length}\x1b[0m | Archived Features: \x1b[33m${freshData.archivedCount}\x1b[0m`);
+    console.log('');
+
+    if (freshData.activeFeatures.length === 0) {
+      console.log('  No active features in artifacts/current/.');
+      console.log('  Press [p] to plan a new feature, or [q] to exit.');
+      console.log('\x1b[1m================================================================\x1b[0m');
+      console.log(`Status: ${statusMessage}`);
+      return;
+    }
+
+    if (selectedIndex >= freshData.activeFeatures.length) {
+      selectedIndex = freshData.activeFeatures.length - 1;
+    }
+
+    freshData.activeFeatures.forEach((feat, index) => {
+      const isSelected = index === selectedIndex;
+      const pointer = isSelected ? '\x1b[36m▶ \x1b[0m' : '  ';
+      const nameFmt = isSelected ? `\x1b[1m\x1b[36m${padRight(feat.name, 22)}\x1b[0m` : padRight(feat.name, 22);
+      const progress = `${progressBar(feat.progressPercent, 10)} ${feat.progressPercent}%`;
+      console.log(`${pointer}${nameFmt} ${padRight(progress, 18)} (${feat.completedCount}/${feat.phaseCount} phases)`);
+    });
+
+    console.log('');
+    const selectedFeature = freshData.activeFeatures[selectedIndex];
+    if (selectedFeature) {
+      console.log(`\x1b[1mPhase Breakdown for "${selectedFeature.name}":\x1b[0m`);
+      selectedFeature.phases.forEach((p) => {
+        const badge = p.hasOutput ? '\x1b[32m[COMPLETED]\x1b[0m' : '\x1b[33m[PENDING]\x1b[0m';
+        console.log(`  Phase ${p.number}: ${padRight(p.specFile, 32)} ${badge}`);
+      });
+    }
+
+    console.log('');
+    console.log('\x1b[1m----------------------------------------------------------------\x1b[0m');
+    console.log('\x1b[2mActions: [i] Implement Next Phase | [c] Clarify | [r] Review | [s] Scan | [q] Quit\x1b[0m');
+    console.log(`\x1b[33m${statusMessage}\x1b[0m`);
+  }
+
+  return new Promise((resolve) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    refresh();
+
+    const onKeypress = async (str, key) => {
+      if ((key && key.ctrl && key.name === 'c') || (key && key.name === 'q')) {
+        cleanup();
+        console.clear();
+        io.stdout('Exited PlanKit Dashboard.');
+        resolve();
+        return;
+      }
+
+      const freshData = loadDashboardData(cwd, config);
+      const currentFeature = freshData.activeFeatures[selectedIndex];
+
+      if (key && (key.name === 'up' || key.name === 'k')) {
+        if (selectedIndex > 0) selectedIndex -= 1;
+        statusMessage = `Selected ${freshData.activeFeatures[selectedIndex]?.name || ''}`;
+        refresh();
+      } else if (key && (key.name === 'down' || key.name === 'j')) {
+        if (selectedIndex < freshData.activeFeatures.length - 1) selectedIndex += 1;
+        statusMessage = `Selected ${freshData.activeFeatures[selectedIndex]?.name || ''}`;
+        refresh();
+      } else if (str === 's') {
+        cleanup();
+        console.clear();
+        io.stdout('Running PlanKit Static Analysis...\n');
+        const report = await runAnalysis(cwd, { artifactsDir: config.artifactsDir });
+        io.stdout(formatReport(report, true));
+        io.stdout('\nPress any key to return to dashboard...');
+        process.stdin.once('data', () => {
+          readline.emitKeypressEvents(process.stdin);
+          if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+          process.stdin.resume();
+          process.stdin.on('keypress', onKeypress);
+          statusMessage = 'Completed static analysis scan.';
+          refresh();
+        });
+      } else if (str === 'i' && currentFeature && handlers.implement) {
+        const nextPhase = currentFeature.completedCount + 1;
+        if (nextPhase > currentFeature.phaseCount) {
+          statusMessage = `Feature "${currentFeature.name}" has completed all phases! Press [r] to review.`;
+          refresh();
+        } else {
+          cleanup();
+          console.clear();
+          io.stdout(`Preparing Phase ${nextPhase} for "${currentFeature.name}"...\n`);
+          try {
+            await handlers.implement(currentFeature.name, nextPhase);
+            statusMessage = `Phase ${nextPhase} prepared successfully for "${currentFeature.name}".`;
+          } catch (err) {
+            statusMessage = `Error: ${err.message}`;
+          }
+          resume();
+        }
+      } else if (str === 'c' && currentFeature && handlers.clarify) {
+        cleanup();
+        console.clear();
+        try {
+          await handlers.clarify(currentFeature.name);
+          statusMessage = `Clarifications prepared for "${currentFeature.name}".`;
+        } catch (err) {
+          statusMessage = `Error: ${err.message}`;
+        }
+        resume();
+      } else if (str === 'r' && currentFeature && handlers.review) {
+        cleanup();
+        console.clear();
+        try {
+          await handlers.review(currentFeature.name);
+          statusMessage = `Feature "${currentFeature.name}" reviewed and archived.`;
+        } catch (err) {
+          statusMessage = `Review error: ${err.message}`;
+        }
+        resume();
+      }
+    };
+
+    function cleanup() {
+      process.stdin.removeListener('keypress', onKeypress);
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+    }
+
+    function resume() {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+      process.stdin.on('keypress', onKeypress);
+      refresh();
+    }
+
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+function progressBar(percent, length = 10) {
+  const filled = Math.round((percent / 100) * length);
+  const empty = length - filled;
+  return `[${'='.repeat(filled)}${'-'.repeat(empty)}]`;
+}
+
+function padRight(str, len) {
+  return String(str).padEnd(len, ' ');
+}