@luquimbo/bi-superpowers 4.1.6 → 5.0.1

package/bin/commands/install.js

@@ -18,10 +18,8 @@
  * expected config file in the format that agent requires (JSON for
  * most, TOML for Codex) — see `lib/mcp-config.js` for details.
  *
- * Fully open source (MIT). The user-facing messages are in Spanish to
- * match the primary Spanish-speaking audience of the project; code
- * comments and JSDoc stay in English so contributors from any language
- * can work on the source.
+ * Fully open source (MIT). CLI copy, comments, and JSDoc stay in English
+ * so contributors from any language can work on the source.
  *
  * Usage:
  *   npx @luquimbo/bi-superpowers install
@@ -89,8 +87,8 @@ async function selectMultiple(rl, items, preselected = []) {
     console.log(`  ${i + 1}) ${marker} ${item.name}`);
   });
   console.log();
-  console.log('  Ingresá números separados por comas (ej: 1,2,3)');
-  console.log('  Presioná Enter para los detectados, o "a" para todos');
+  console.log('  Enter numbers separated by commas (for example: 1,2,3)');
+  console.log('  Press Enter for detected agents, or "a" for all agents');
 
   const answer = await prompt(rl, '\n  > ');
 
@@ -161,11 +159,11 @@ function copySkillDir(srcDir, destDir) {
  */
 function formatFsError(err, context) {
   const codeHints = {
-    EACCES: 'Permiso denegado. Revisá los permisos del directorio.',
-    EPERM: 'Operación no permitida. En Windows, probá ejecutar como Administrador.',
-    ENOSPC: 'No hay espacio en disco.',
-    ENOENT: 'Archivo o directorio no existe.',
-    EROFS: 'Sistema de archivos en solo lectura.',
+    EACCES: 'Permission denied. Check the directory permissions.',
+    EPERM: 'Operation not permitted. On Windows, try running as Administrator.',
+    ENOSPC: 'No disk space left.',
+    ENOENT: 'File or directory does not exist.',
+    EROFS: 'Read-only filesystem.',
   };
   const hint = codeHints[err.code] || '';
   return `${context}: ${err.message}${hint ? `\n  ${hint}` : ''}`;
@@ -188,7 +186,9 @@ function parseArgs(args) {
       const next = args[i + 1];
       if (next === undefined || next.startsWith('-')) {
         // Missing value — warn and skip this flag instead of crashing.
-        console.warn(`⚠ Flag ${args[i]} sin valor. Uso: ${args[i]} <agente-id>. Ignorando.`);
+        console.warn(
+          `⚠ Flag ${args[i]} is missing a value. Usage: ${args[i]} <agent-id>. Ignoring.`
+        );
         continue;
       }
       opts.agentFlags.push(next);
@@ -212,8 +212,8 @@ async function resolveSelectedAgents(opts, baseDir, chalk) {
     const known = opts.agentFlags.filter((a) => AGENTS[a]);
     const unknown = opts.agentFlags.filter((a) => !AGENTS[a]);
     if (unknown.length > 0) {
-      console.log(chalk.yellow(`  Agentes desconocidos: ${unknown.join(', ')}`));
-      console.log(chalk.gray(`  Disponibles: ${Object.keys(AGENTS).join(', ')}\n`));
+      console.log(chalk.yellow(`  Unknown agents: ${unknown.join(', ')}`));
+      console.log(chalk.gray(`  Available agents: ${Object.keys(AGENTS).join(', ')}\n`));
     }
     return known;
   }
@@ -224,11 +224,11 @@ async function resolveSelectedAgents(opts, baseDir, chalk) {
 
   // Interactive mode — detect installed agents and prompt the user.
   const detected = detectAgents(baseDir);
-  console.log(chalk.cyan('  Seleccioná los agentes donde querés instalar:\n'));
+  console.log(chalk.cyan('  Select the agents where you want to install:\n'));
 
   const items = Object.entries(AGENTS).map(([id, agent]) => ({
     id,
-    name: detected.includes(id) ? `${agent.name} ${chalk.green('(detectado)')}` : agent.name,
+    name: detected.includes(id) ? `${agent.name} ${chalk.green('(detected)')}` : agent.name,
   }));
 
   const rl = createReadline();
@@ -330,9 +330,7 @@ function performInstall(skillsSourceDir, skillDirs, selectedAgents, baseDir) {
  * @returns {Array<{agent: string, success: boolean, configPath?: string, error?: string}>}
  */
 function configureMcpsForAgents(selectedAgents, packageDir, baseDir, chalk) {
-  console.log(
-    chalk.cyan('\n  Configurando MCP servers (Power BI Modeling + Microsoft Learn)...\n')
-  );
+  console.log(chalk.cyan('\n  Configuring MCP servers (Power BI Modeling + Microsoft Learn)...\n'));
 
   const results = [];
   for (const agentId of selectedAgents) {
@@ -374,7 +372,7 @@ async function installCommand(args, config) {
   if (!fs.existsSync(skillsSourceDir)) {
     console.error(
       chalk.red(
-        'Directorio de skills no encontrado. Reinstalá el paquete con: npm install -g @luquimbo/bi-superpowers'
+        'Skills directory not found. Reinstall the package with: npm install -g @luquimbo/bi-superpowers'
       )
     );
     process.exit(1);
@@ -390,7 +388,7 @@ async function installCommand(args, config) {
       )
       .map((d) => d.name);
   } catch (err) {
-    console.error(chalk.red(formatFsError(err, 'No pude leer los skills')));
+    console.error(chalk.red(formatFsError(err, 'Could not read skills')));
     process.exit(1);
   }
 
@@ -400,7 +398,7 @@ async function installCommand(args, config) {
       chalk.bold.cyan('BI Agent Superpowers') +
         chalk.gray(` v${config.version}`) +
         '\n' +
-        chalk.gray('Instalador multi-agente'),
+        chalk.gray('Multi-agent installer'),
       {
         padding: 1,
         borderStyle: 'round',
@@ -409,21 +407,19 @@ async function installCommand(args, config) {
     )
   );
 
-  console.log(chalk.gray(`  Ruta de instalación: ~/${UNIVERSAL_DIR}/`));
-  console.log(chalk.gray(`  Skills: ${skillDirs.length} disponibles\n`));
+  console.log(chalk.gray(`  Install path: ~/${UNIVERSAL_DIR}/`));
+  console.log(chalk.gray(`  Skills available: ${skillDirs.length}\n`));
 
   // Resolve which agents to configure.
   const selectedAgents = await resolveSelectedAgents(opts, baseDir, chalk);
 
   if (selectedAgents.length === 0) {
-    console.log(chalk.yellow('\n  Ningún agente seleccionado. Nada que instalar.'));
+    console.log(chalk.yellow('\n  No agent selected. Nothing to install.'));
     return;
   }
 
   console.log(
-    chalk.cyan(
-      `\n  Instalando ${skillDirs.length} skills para ${selectedAgents.length} agentes...\n`
-    )
+    chalk.cyan(`\n  Installing ${skillDirs.length} skills for ${selectedAgents.length} agents...\n`)
   );
 
   // Phase 1: copy skills and create symlinks per agent.
@@ -434,7 +430,7 @@ async function installCommand(args, config) {
     agentResults = result.agentResults;
     copyFallbacks = result.copyFallbacks;
   } catch (err) {
-    console.error(chalk.red(formatFsError(err, 'Falló la instalación de skills')));
+    console.error(chalk.red(formatFsError(err, 'Skill installation failed')));
     process.exit(1);
   }
 
@@ -455,9 +451,9 @@ async function installCommand(args, config) {
   if (copyFallbacks > 0) {
     console.log(
       chalk.yellow(
-        `\n  ⚠ ${copyFallbacks} agente(s) usaron copia en vez de symlink ` +
-          '(probable Windows sin permisos de admin).\n' +
-          "    Re-ejecutá 'super install' tras cada upgrade; la copia se espeja y elimina runtimes viejos."
+        `\n  ⚠ ${copyFallbacks} agent(s) used copy fallback instead of symlink ` +
+          '(probably Windows without admin permissions).\n' +
+          "    Re-run 'super install' after each upgrade; copied installs are mirrored and stale runtimes are removed."
       )
     );
   }
@@ -471,36 +467,34 @@ async function installCommand(args, config) {
   const mcpFailures = mcpResults.filter((r) => !r.success);
   const hasFailures = mcpFailures.length > 0;
 
-  const successMsg = `Instalados ${skillDirs.length} skills + 2 MCPs para ${totalAgents} agentes`;
-  const failureMsg = `Instalados ${skillDirs.length} skills. MCPs: ${mcpSuccess}/${mcpResults.length} agentes ✓, ${mcpFailures.length} con errores.`;
+  const successMsg = `Installed ${skillDirs.length} skills + 2 MCPs for ${totalAgents} agents`;
+  const failureMsg = `Installed ${skillDirs.length} skills. MCPs: ${mcpSuccess}/${mcpResults.length} agents ok, ${mcpFailures.length} failed.`;
   const headerLine = hasFailures ? chalk.yellow.bold(failureMsg) : chalk.green.bold(successMsg);
 
   const failureDetail = hasFailures
     ? '\n' +
-      chalk.red('Agentes con errores en MCP:') +
+      chalk.red('Agents with MCP errors:') +
       '\n' +
       mcpFailures.map((r) => chalk.red(`  ✗ ${r.agent}: ${r.error}`)).join('\n') +
       '\n'
     : '';
 
+  const skillSummary = skillDirs
+    .map((skillName) => `  /${skillName.padEnd(15)} — ${describeSkill(skillName)}`)
+    .join('\n');
+
   console.log(
     boxen(
       headerLine +
         failureDetail +
         '\n\n' +
-        chalk.gray(`MCPs configurados en ${mcpSuccess}/${mcpResults.length} agentes.`) +
+        chalk.gray(`MCPs configured in ${mcpSuccess}/${mcpResults.length} agents.`) +
         '\n' +
-        chalk.gray('Reiniciá tu agente AI para que tome los MCPs nuevos.') +
+        chalk.gray('Restart your AI agent so it loads the new MCP configuration.') +
         '\n\n' +
-        chalk.gray('Los 4 skills disponibles:') +
-        '\n' +
-        chalk.gray('  /bi-start         — Arrancar una sesión: menú + update + conexión') +
+        chalk.gray(`Skills available (${skillDirs.length}):`) +
         '\n' +
-        chalk.gray('  /project-kickoff  — Analizá tu proyecto BI (proyecto nuevo)') +
-        '\n' +
-        chalk.gray('  /pbi-connect      — Conectá tu agente a Power BI Desktop') +
-        '\n' +
-        chalk.gray('  /report-design    — Generá reportes PBIR para Power BI Desktop (Windows)'),
+        chalk.gray(skillSummary),
       {
         padding: 1,
         margin: { top: 1 },
@@ -526,3 +520,22 @@ module.exports.copySkillDir = copySkillDir;
 module.exports.formatFsError = formatFsError;
 module.exports.AGENTS = AGENTS;
 module.exports.UNIVERSAL_DIR = UNIVERSAL_DIR;
+
+function describeSkill(skillName) {
+  switch (skillName) {
+    case 'bi-start':
+      return 'Session opener, update check, and routing';
+    case 'bi-kickoff':
+      return 'Analyze or start a new BI project';
+    case 'bi-modeling':
+      return 'Design and audit semantic models';
+    case 'bi-dax':
+      return 'Write, debug, and optimize DAX';
+    case 'bi-performance':
+      return 'Performance profiling, VertiPaq, and BPA';
+    case 'bi-connect':
+      return 'Connect Power BI Desktop and guide DAX UDF work';
+    default:
+      return 'Specialized BI skill';
+  }
+}

package/bin/commands/lint.js

@@ -366,7 +366,7 @@ function lintCommand(args, config) {
   // Determine which files to lint. Use the shared skill loader so we
   // catch both flat (`<name>.md`) and folder-based (`<name>/SKILL.md`)
   // skills — a previous version filtered with `f.endsWith('.md')` and
-  // silently skipped every folder-based skill (e.g. `report-design`).
+  // silently skipped every folder-based skill.
   const allSkills = readSkillDirectory(skillsDir);
   const skillsByName = new Map(allSkills.map((s) => [s.name, s]));
   let filesToLint = [];
@@ -379,7 +379,7 @@ function lintCommand(args, config) {
           return f;
         }
         // Look up by skill name. normalizeSkillName accepts `dax`,
-        // `dax.md`, `report-design`, or `report-design/SKILL.md`.
+        // `dax.md`, `folder-skill`, or `folder-skill/SKILL.md`.
         const skill = skillsByName.get(normalizeSkillName(f));
         if (skill) return skill.path;
 

package/bin/commands/validate-projects.js

@@ -0,0 +1,425 @@
+/**
+ * Project Validation Command
+ * ==========================
+ *
+ * Validates public fixtures and private project references without copying
+ * customer repositories into this repo. Versioned descriptors live under
+ * validation/projects/*.json; private paths live in validation.local.json,
+ * which is intentionally ignored by git.
+ *
+ * Usage:
+ *   super validate-projects
+ *   super validate-projects --project template
+ *   super validate-projects --root C:\path\to\bi-superpowers
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_VALIDATION_DIR = 'validation';
+const DEFAULT_LOCAL_CONFIG = 'validation.local.json';
+
+function parseArgs(args) {
+  const options = {
+    rootDir: process.cwd(),
+    localConfigPath: null,
+    projectIds: [],
+    json: false,
+    list: false,
+    strict: false,
+  };
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+
+    if (arg === '--root') {
+      options.rootDir = readValue(args, ++index, arg);
+    } else if (arg === '--local') {
+      options.localConfigPath = readValue(args, ++index, arg);
+    } else if (arg === '--project' || arg === '-p') {
+      options.projectIds.push(readValue(args, ++index, arg));
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--list') {
+      options.list = true;
+    } else if (arg === '--strict') {
+      options.strict = true;
+    }
+  }
+
+  options.rootDir = path.resolve(options.rootDir);
+  if (options.localConfigPath) {
+    options.localConfigPath = path.resolve(options.localConfigPath);
+  }
+  return options;
+}
+
+function readValue(args, index, flag) {
+  const value = args[index];
+  if (!value || value.startsWith('-')) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+
+function readJsonStrict(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    throw new Error(`Cannot read JSON at ${filePath}: ${err.message}`);
+  }
+}
+
+function getValidationProjectsDir(rootDir) {
+  return path.join(rootDir, DEFAULT_VALIDATION_DIR, 'projects');
+}
+
+function getLocalConfigPath(rootDir, overridePath) {
+  return overridePath || path.join(rootDir, DEFAULT_LOCAL_CONFIG);
+}
+
+function loadProjectDescriptors(rootDir) {
+  const projectsDir = getValidationProjectsDir(rootDir);
+  if (!fs.existsSync(projectsDir)) {
+    throw new Error(
+      `Validation project descriptors not found at ${projectsDir}. ` +
+        'Run this command from the bi-superpowers source checkout or pass --root <repo>.'
+    );
+  }
+
+  const descriptorFiles = fs
+    .readdirSync(projectsDir)
+    .filter((file) => file.endsWith('.json'))
+    .sort();
+
+  if (descriptorFiles.length === 0) {
+    throw new Error(`No validation project descriptors found in ${projectsDir}.`);
+  }
+
+  return descriptorFiles.map((file) => {
+    const filePath = path.join(projectsDir, file);
+    const descriptor = readJsonStrict(filePath);
+    validateDescriptor(descriptor, filePath);
+    return { ...descriptor, descriptorPath: filePath };
+  });
+}
+
+function validateDescriptor(descriptor, filePath) {
+  if (!descriptor || typeof descriptor !== 'object' || Array.isArray(descriptor)) {
+    throw new Error(`Project descriptor must be an object: ${filePath}`);
+  }
+  if (!isValidProjectId(descriptor.id)) {
+    throw new Error(`Project descriptor has invalid id at ${filePath}`);
+  }
+  if (!descriptor.name || typeof descriptor.name !== 'string') {
+    throw new Error(`Project descriptor ${descriptor.id} must include a name`);
+  }
+  if (descriptor.path != null && typeof descriptor.path !== 'string') {
+    throw new Error(`Project descriptor ${descriptor.id} path must be a string`);
+  }
+  if (descriptor.path != null && path.isAbsolute(descriptor.path)) {
+    throw new Error(
+      `Project descriptor ${descriptor.id} path must be relative. Put private absolute paths in validation.local.json.`
+    );
+  }
+  if (descriptor.skills != null && !isStringArray(descriptor.skills)) {
+    throw new Error(`Project descriptor ${descriptor.id} skills must be an array of strings`);
+  }
+  if (descriptor.checks != null && !Array.isArray(descriptor.checks)) {
+    throw new Error(`Project descriptor ${descriptor.id} checks must be an array`);
+  }
+  for (const check of descriptor.checks || []) {
+    if (!check || typeof check !== 'object' || Array.isArray(check)) {
+      throw new Error(`Project descriptor ${descriptor.id} has an invalid check`);
+    }
+    if (!check.name || typeof check.name !== 'string') {
+      throw new Error(`Project descriptor ${descriptor.id} has a check without a name`);
+    }
+    if (!check.path || typeof check.path !== 'string') {
+      throw new Error(`Project descriptor ${descriptor.id} check ${check.name} needs a path`);
+    }
+    if (path.isAbsolute(check.path)) {
+      throw new Error(`Project descriptor ${descriptor.id} check ${check.name} must be relative`);
+    }
+  }
+}
+
+function isValidProjectId(value) {
+  return typeof value === 'string' && /^[a-z0-9][a-z0-9-]*$/.test(value);
+}
+
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+
+function loadLocalConfig(rootDir, overridePath) {
+  const localPath = getLocalConfigPath(rootDir, overridePath);
+  if (!fs.existsSync(localPath)) {
+    return { path: localPath, projects: {} };
+  }
+
+  const config = readJsonStrict(localPath);
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`Local validation config must be an object: ${localPath}`);
+  }
+  if (config.projects == null) {
+    return { path: localPath, projects: {} };
+  }
+  if (typeof config.projects !== 'object' || Array.isArray(config.projects)) {
+    throw new Error(`Local validation config projects must be an object: ${localPath}`);
+  }
+
+  for (const [projectId, project] of Object.entries(config.projects)) {
+    if (!isValidProjectId(projectId)) {
+      throw new Error(`Local validation config has invalid project id: ${projectId}`);
+    }
+    if (!project || typeof project !== 'object' || Array.isArray(project)) {
+      throw new Error(`Local validation project ${projectId} must be an object`);
+    }
+    if (!project.path || typeof project.path !== 'string') {
+      throw new Error(`Local validation project ${projectId} must include a path`);
+    }
+  }
+
+  return { path: localPath, projects: config.projects };
+}
+
+function mergeProjects(descriptors, localProjects) {
+  const merged = new Map();
+
+  for (const descriptor of descriptors) {
+    const local = localProjects[descriptor.id] || {};
+    merged.set(descriptor.id, {
+      ...descriptor,
+      path: local.path || descriptor.path,
+      localOnly: false,
+      localNotes: local.notes,
+    });
+  }
+
+  for (const [id, local] of Object.entries(localProjects)) {
+    if (merged.has(id)) {
+      continue;
+    }
+    merged.set(id, {
+      id,
+      name: local.name || id,
+      privacy: 'private-local',
+      path: local.path,
+      skills: local.skills || [],
+      checks: local.checks || [],
+      localOnly: true,
+      localNotes: local.notes,
+    });
+  }
+
+  return Array.from(merged.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function resolveProjectPath(rootDir, projectPath) {
+  if (!projectPath) {
+    return null;
+  }
+  return path.isAbsolute(projectPath)
+    ? path.normalize(projectPath)
+    : path.resolve(rootDir, projectPath);
+}
+
+function validateProject(project, rootDir) {
+  const resolvedPath = resolveProjectPath(rootDir, project.path);
+  const result = {
+    id: project.id,
+    name: project.name,
+    privacy: project.privacy || 'unspecified',
+    path: resolvedPath,
+    status: 'passed',
+    reason: null,
+    checks: [],
+  };
+
+  if (!resolvedPath) {
+    result.status = 'skipped';
+    result.reason = 'No path configured. Add this project to validation.local.json.';
+    return result;
+  }
+
+  if (!fs.existsSync(resolvedPath)) {
+    result.status = 'failed';
+    result.reason = `Project path does not exist: ${resolvedPath}`;
+    return result;
+  }
+
+  for (const check of project.checks || []) {
+    const checkPath = path.resolve(resolvedPath, check.path);
+    if (!isPathInside(resolvedPath, checkPath)) {
+      result.checks.push({
+        name: check.name,
+        path: checkPath,
+        passed: false,
+        reason: 'Check path escapes the project root.',
+      });
+      continue;
+    }
+    const passed = fs.existsSync(checkPath);
+    result.checks.push({
+      name: check.name,
+      path: checkPath,
+      passed,
+    });
+  }
+
+  if (result.checks.some((check) => !check.passed)) {
+    result.status = 'failed';
+    result.reason = 'One or more required project files are missing.';
+  }
+
+  return result;
+}
+
+function isPathInside(parentPath, childPath) {
+  const relative = path.relative(parentPath, childPath);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function runValidation(options) {
+  const descriptors = loadProjectDescriptors(options.rootDir);
+  const localConfig = loadLocalConfig(options.rootDir, options.localConfigPath);
+  const projects = mergeProjects(descriptors, localConfig.projects);
+  const selected = filterProjects(projects, options.projectIds);
+  const results = selected.projects.map((project) => validateProject(project, options.rootDir));
+
+  if (options.strict) {
+    for (const result of results) {
+      if (result.status === 'skipped') {
+        result.status = 'failed';
+        result.reason = `${result.reason} Strict mode treats skipped projects as failures.`;
+      }
+    }
+  }
+
+  return {
+    rootDir: options.rootDir,
+    localConfigPath: localConfig.path,
+    missingProjectIds: selected.missingProjectIds,
+    results,
+    summary: summarizeResults(results, selected.missingProjectIds),
+  };
+}
+
+function filterProjects(projects, ids) {
+  if (ids.length === 0) {
+    return { projects, missingProjectIds: [] };
+  }
+
+  const byId = new Map(projects.map((project) => [project.id, project]));
+  const selected = [];
+  const missingProjectIds = [];
+
+  for (const id of ids) {
+    if (byId.has(id)) {
+      selected.push(byId.get(id));
+    } else {
+      missingProjectIds.push(id);
+    }
+  }
+
+  return { projects: selected, missingProjectIds };
+}
+
+function summarizeResults(results, missingProjectIds = []) {
+  return {
+    total: results.length,
+    passed: results.filter((result) => result.status === 'passed').length,
+    failed:
+      results.filter((result) => result.status === 'failed').length + missingProjectIds.length,
+    skipped: results.filter((result) => result.status === 'skipped').length,
+  };
+}
+
+function printList(report) {
+  console.log('BI Agent Superpowers — Validation Projects');
+  console.log('==========================================\n');
+
+  if (report.results.length === 0) {
+    console.log('No project descriptors found.');
+    return;
+  }
+
+  for (const result of report.results) {
+    console.log(`- ${result.id}: ${result.name} (${result.privacy})`);
+  }
+}
+
+function printReport(report) {
+  console.log('BI Agent Superpowers — Project Validation');
+  console.log('=========================================\n');
+  console.log(`Root: ${report.rootDir}`);
+  console.log(`Local config: ${report.localConfigPath}`);
+  console.log('');
+
+  for (const missingId of report.missingProjectIds) {
+    console.log(`FAIL ${missingId}`);
+    console.log('  Project id was requested but no descriptor or local config exists.\n');
+  }
+
+  for (const result of report.results) {
+    const label = result.status.toUpperCase();
+    console.log(`${label} ${result.id} — ${result.name}`);
+    if (result.path) {
+      console.log(`  Path: ${result.path}`);
+    }
+    if (result.reason) {
+      console.log(`  ${result.reason}`);
+    }
+    for (const check of result.checks) {
+      const checkLabel = check.passed ? 'OK' : 'MISS';
+      console.log(`  ${checkLabel} ${check.name}: ${check.path}`);
+    }
+    console.log('');
+  }
+
+  const summary = report.summary;
+  console.log(
+    `Summary: ${summary.passed} passed, ${summary.failed} failed, ${summary.skipped} skipped (${summary.total} checked)`
+  );
+}
+
+function validateProjectsCommand(args) {
+  let options;
+  try {
+    options = parseArgs(args || []);
+    const report = runValidation(options);
+
+    if (options.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else if (options.list) {
+      printList(report);
+    } else {
+      printReport(report);
+    }
+
+    if (report.summary.failed > 0) {
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    if (options && options.json) {
+      console.log(JSON.stringify({ error: err.message }, null, 2));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exitCode = 1;
+  }
+}
+
+module.exports = Object.assign(validateProjectsCommand, {
+  parseArgs,
+  readJsonStrict,
+  loadProjectDescriptors,
+  loadLocalConfig,
+  mergeProjects,
+  resolveProjectPath,
+  validateProject,
+  isPathInside,
+  runValidation,
+  summarizeResults,
+});