universal-dev-standards 4.2.0 → 5.0.0-beta.10

package/src/index.js

@@ -6,3 +6,4 @@ export { initCommand } from './commands/init.js';
 export { checkCommand } from './commands/check.js';
 export { updateCommand } from './commands/update.js';
 export { skillsCommand } from './commands/skills.js';
+export { configCommand } from './commands/config.js';

package/src/installers/integration-installer.js

@@ -0,0 +1,237 @@
+import ora from 'ora';
+import { copyIntegration } from '../utils/copier.js';
+import {
+  writeIntegrationFile,
+  integrationFileExists,
+  getToolFilePath
+} from '../utils/integration-generator.js';
+import { calculateCategoriesFromStandards } from '../utils/reference-sync.js';
+import { t } from '../i18n/messages.js';
+
+/**
+ * Integration file mappings (legacy - for fallback)
+ * Maps AI tool names to their source and target file paths
+ */
+export const INTEGRATION_MAPPINGS = {
+  cursor: {
+    source: 'integrations/cursor/.cursorrules',
+    target: '.cursorrules'
+  },
+  windsurf: {
+    source: 'integrations/windsurf/.windsurfrules',
+    target: '.windsurfrules'
+  },
+  cline: {
+    source: 'integrations/cline/.clinerules',
+    target: '.clinerules'
+  },
+  copilot: {
+    source: 'integrations/github-copilot/copilot-instructions.md',
+    target: '.github/copilot-instructions.md'
+  },
+  antigravity: {
+    source: 'integrations/google-antigravity/INSTRUCTIONS.md',
+    target: 'INSTRUCTIONS.md'
+  },
+  codex: {
+    source: 'integrations/openai-codex/AGENTS.md',
+    target: 'AGENTS.md'
+  },
+  'gemini-cli': {
+    source: 'integrations/gemini-cli/GEMINI.md',
+    target: 'GEMINI.md'
+  },
+  opencode: {
+    source: 'integrations/opencode/AGENTS.md',
+    target: 'AGENTS.md'
+  }
+};
+
+/**
+ * Install integration files for selected AI tools
+ *
+ * @param {Object} config - Integration installation configuration
+ * @param {Array<string>} config.integrations - List of AI tool names (e.g., ['cursor', 'windsurf'])
+ * @param {Object} config.integrationConfigs - Tool-specific configurations
+ * @param {Array<string>} config.installedStandards - List of installed standard file names
+ * @param {string} config.contentMode - Content mode ('minimal', 'index', 'full')
+ * @param {number} config.level - Adoption level (1-3)
+ * @param {string} config.commonLanguage - Language setting ('en', 'zh-tw', 'zh-cn', 'bilingual')
+ * @param {string} config.commitLanguage - Commit message language preference
+ * @param {string} projectPath - Absolute path to the project directory
+ * @returns {Promise<Object>} Installation results
+ * @returns {Array<string>} .integrations - List of successfully installed integration file paths
+ * @returns {Array<string>} .errors - List of error messages
+ * @returns {Object} .integrationBlockHashes - Hash information for UDS content blocks
+ */
+export async function installIntegrations(config, projectPath) {
+  const {
+    integrations = [],
+    installedStandards = [],
+    contentMode = 'minimal',
+    level = 2,
+  } = config;
+
+  // Resolve parameters (support both naming conventions from different callers)
+  const integrationConfigs = config.integrationConfigs || config.skillsConfig?.integrationConfigs || {};
+  const commonLanguage = config.commonLanguage || config.displayLanguage || 'en';
+  const commitLanguage = config.commitLanguage || config.standardOptions?.commit_language || 'english';
+
+  const msg = t().commands.init;
+
+  // Track results
+  const results = {
+    integrations: [],
+    errors: [],
+    integrationBlockHashes: {}
+  };
+
+  // Early return if no integrations to install
+  if (integrations.length === 0) {
+    return results;
+  }
+
+  // Start installation spinner
+  const intSpinner = ora(msg.generatingIntegrations).start();
+
+  // Track generated files to handle AGENTS.md sharing (codex + opencode)
+  const generatedFiles = new Set();
+
+  for (const tool of integrations) {
+    // Check if this file was already generated (for AGENTS.md sharing)
+    const targetFile = getToolFilePath(tool);
+    if (generatedFiles.has(targetFile)) {
+      // Skip - file already generated by another tool (e.g., codex generated AGENTS.md, skip opencode)
+      continue;
+    }
+
+    // Build enhanced config with installed standards
+    // Filter categories to only those backed by installed standards to avoid orphaned references
+    const requestedCategories = integrationConfigs[tool]?.categories || ['anti-hallucination', 'commit-standards', 'code-review'];
+    const validCategories = installedStandards.length > 0
+      ? requestedCategories.filter(cat => calculateCategoriesFromStandards(installedStandards).includes(cat))
+      : requestedCategories;
+    const enhancedConfig = {
+      ...integrationConfigs[tool],
+      tool,
+      categories: validCategories,
+      language: integrationConfigs[tool]?.language || commonLanguage,
+      installedStandards,
+      contentMode,
+      level,
+      // Pass commit_language for dynamic commit standards generation
+      commitLanguage
+    };
+
+    // Use dynamic generator
+    const result = writeIntegrationFile(tool, enhancedConfig, projectPath);
+    if (result.success) {
+      results.integrations.push(result.path);
+      generatedFiles.add(targetFile);
+
+      // Capture integration block hash for tracking UDS content
+      if (result.blockHashInfo) {
+        results.integrationBlockHashes[result.path] = {
+          ...result.blockHashInfo,
+          installedAt: new Date().toISOString()
+        };
+      }
+    } else {
+      // Fall back to legacy static file copy
+      const mapping = INTEGRATION_MAPPINGS[tool];
+      if (mapping) {
+        const copyResult = await copyIntegration(mapping.source, mapping.target, projectPath);
+        if (copyResult.success) {
+          results.integrations.push(mapping.target);
+          generatedFiles.add(targetFile);
+        } else {
+          results.errors.push(`${tool}: ${result.error || copyResult.error}`);
+        }
+      } else {
+        results.errors.push(`${tool}: ${result.error}`);
+      }
+    }
+  }
+
+  // Update spinner with result
+  const successCount = results.integrations.length;
+  if (successCount > 0) {
+    intSpinner.succeed(msg.generatedIntegrations.replace('{count}', successCount));
+  } else {
+    // intSpinner.fail(msg.failedToGenerateIntegrations || 'Failed to generate integration files');
+    // Using warn instead of fail to match original behavior if at least some files failed but loop finished
+    // But original code used succeed even if errors occurred, just logged errors.
+    // Let's stick to succeed if loop finished, but maybe warn if 0 files generated?
+    // The original code: intSpinner.succeed(msg.generatedIntegrations.replace('{count}', results.integrations.length));
+    intSpinner.succeed(msg.generatedIntegrations.replace('{count}', successCount));
+  }
+
+  return results;
+}
+
+/**
+ * Generate CLAUDE.md for Claude Code if selected and not already existing
+ *
+ * @param {Object} config - Claude Code configuration
+ * @param {Array<string>} config.aiTools - List of selected AI tools
+ * @param {Array<string>} config.installedStandards - List of installed standard file names
+ * @param {string} config.contentMode - Content mode ('minimal', 'index', 'full')
+ * @param {number} config.level - Adoption level (1-3)
+ * @param {string} config.commonLanguage - Language setting ('en', 'zh-tw', 'zh-cn', 'bilingual')
+ * @param {string} config.commitLanguage - Commit message language preference
+ * @param {string} projectPath - Absolute path to the project directory
+ * @returns {Promise<Object>} Generation results
+ * @returns {string|null} .path - Path to CLAUDE.md if generated, null if skipped
+ * @returns {string|null} .error - Error message if generation failed
+ */
+export async function generateClaudeMd(config, projectPath) {
+  const {
+    aiTools = [],
+    installedStandards = [],
+    contentMode = 'minimal',
+    level = 2,
+  } = config;
+
+  // Resolve parameters (support both naming conventions from different callers)
+  const commonLanguage = config.commonLanguage || config.displayLanguage || 'en';
+  const commitLanguage = config.commitLanguage || config.standardOptions?.commit_language || 'english';
+
+  const msg = t().commands.init;
+
+  // Check if Claude Code is selected and CLAUDE.md doesn't exist
+  const claudeCodeSelected = aiTools.includes('claude-code');
+  if (!claudeCodeSelected || integrationFileExists('claude-code', projectPath)) {
+    return { path: null, error: null };
+  }
+
+  const claudeSpinner = ora(msg.generatingClaudeMd).start();
+
+  // Derive categories from installedStandards to avoid referencing non-installed standards
+  const categories = installedStandards.length > 0
+    ? calculateCategoriesFromStandards(installedStandards)
+    : ['anti-hallucination', 'commit-standards', 'code-review'];
+  const claudeConfig = {
+    tool: 'claude-code',
+    categories,
+    languages: [],
+    exclusions: [],
+    customRules: [],
+    detailLevel: 'standard',
+    language: commonLanguage,
+    // Enhanced standards compliance fields
+    installedStandards,
+    contentMode,
+    level,
+    // Pass commit_language for dynamic commit standards generation
+    commitLanguage
+  };
+
+  const result = writeIntegrationFile('claude-code', claudeConfig, projectPath);
+  if (result.success) {
+    claudeSpinner.succeed(msg.generatedClaudeMd);
+    return { path: result.path, error: null };
+  } else {
+    claudeSpinner.warn(msg.couldNotGenerateClaudeMd);
+    return { path: null, error: result.error };
+  }
+}

package/src/installers/manifest-installer.js

@@ -0,0 +1,131 @@
+import chalk from 'chalk';
+import { getRepositoryInfo } from '../utils/registry.js';
+import { writeManifest } from '../core/manifest.js';
+import { t } from '../i18n/messages.js';
+import { getAgentDisplayName, getSkillsDirForAgent, getCommandsDirForAgent } from '../config/ai-agent-paths.js';
+
+/**
+ * Create and write the final manifest file, and display installation summary
+ *
+ * @param {Object} config - Installation configuration
+ * @param {Object} results - Combined results from all installers
+ * @param {string} projectPath - Project directory path
+ */
+export function writeFinalManifest(config, results, projectPath) {
+  const msg = t().commands.init;
+  const repoInfo = getRepositoryInfo();
+
+  // Construct manifest object
+  const manifest = {
+    version: '3.3.0',
+    upstream: {
+      repo: 'AsiaOstrich/universal-dev-standards',
+      version: repoInfo.standards.version,
+      installed: new Date().toISOString().split('T')[0]
+    },
+    level: config.level,
+    format: config.format,
+    standardsScope: config.standardsScope || 'full',
+    contentMode: config.contentMode || 'minimal',
+    standards: results.standards || [],
+    extensions: results.extensions || [],
+    integrations: results.integrations || [],
+    integrationConfigs: results.manifestIntegrationConfigs || {},
+    options: {
+      display_language: config.displayLanguage || 'en',
+      workflow: config.standardOptions?.workflow || null,
+      merge_strategy: config.standardOptions?.merge_strategy || null,
+      commit_language: config.standardOptions?.commit_language || null,
+      test_levels: config.standardOptions?.test_levels || []
+    },
+    aiTools: config.aiTools || [],
+    skills: {
+      installed: config.skillsConfig?.installed || false,
+      location: config.skillsConfig?.location || null,
+      names: config.skillsConfig?.location === 'marketplace' ? ['all-via-plugin'] : (results.skills || []),
+      version: config.skillsConfig?.installed ? repoInfo.skills.version : null,
+      installations: config.skillsConfig?.skillsInstallations || []
+    },
+    commands: {
+      installed: config.skillsConfig?.commandsInstallations?.length > 0,
+      names: results.commands || [],
+      version: config.skillsConfig?.commandsInstallations?.length > 0 ? repoInfo.skills.version : null,
+      installations: config.skillsConfig?.commandsInstallations || []
+    },
+    methodology: config.methodology ? {
+      active: config.methodology,
+      available: ['tdd', 'bdd', 'sdd', 'atdd'],
+      config: {
+        checkpointsEnabled: true,
+        reminderIntensity: 'suggest',
+        skipLimit: 3
+      }
+    } : null,
+    fileHashes: results.fileHashes || {},
+    skillHashes: results.skillHashes || {},
+    commandHashes: results.commandHashes || {},
+    integrationBlockHashes: results.integrationBlockHashes || {}
+  };
+
+  // Write file
+  writeManifest(manifest, projectPath);
+
+  // --- Display Summary ---
+  console.log();
+  console.log(chalk.green(msg.initializedSuccess));
+  console.log();
+
+  const totalFiles = (results.standards?.length || 0) + (results.extensions?.length || 0) + (results.integrations?.length || 0);
+  console.log(chalk.gray(`  ${msg.filesCopied.replace('{count}', totalFiles)}`));
+
+  if (config.skillsConfig?.installed) {
+    if (config.skillsConfig.location === 'marketplace') {
+      console.log(chalk.gray(`  ${msg.skillsUsingMarketplace}`));
+    } else if (results.skills?.length > 0) {
+      const skillLocations = (config.skillsConfig.skillsInstallations || []).map(inst => {
+        const displayName = getAgentDisplayName(inst.agent);
+        const dir = getSkillsDirForAgent(inst.agent, inst.level, projectPath);
+        return `${displayName}: ${dir}`;
+      }).join(' and ');
+      console.log(chalk.gray(`  ${msg.skillsInstalledTo.replace('{count}', results.skills.length).replace('{locations}', skillLocations)}`));
+    }
+  }
+
+  if (results.commands?.length > 0) {
+    const cmdLocations = (config.skillsConfig.commandsInstallations || []).map(item => {
+      const agent = typeof item === 'string' ? item : item.agent;
+      const level = typeof item === 'string' ? 'project' : (item.level || 'project');
+      const displayName = getAgentDisplayName(agent);
+      const dir = getCommandsDirForAgent(agent, level, projectPath);
+      return `${displayName}: ${dir}`;
+    }).join(' and ');
+
+    console.log(chalk.gray(`  ${(msg.commandsInstalledTo || 'Commands ({count}): {locations}').replace('{count}', results.commands.length).replace('{locations}', cmdLocations)}`));
+  }
+  
+  console.log(chalk.gray(`  ${msg.manifestCreated}`));
+
+  if (results.errors?.length > 0) {
+    console.log();
+    console.log(chalk.yellow(msg.errorsOccurred.replace('{count}', results.errors.length)));
+    for (const err of results.errors) {
+      console.log(chalk.gray(`    ${err}`));
+    }
+  }
+
+  console.log();
+  console.log(chalk.gray(msg.nextSteps));
+  console.log(chalk.gray(`  ${msg.reviewDirectory}`));
+  console.log(chalk.gray(`  ${msg.addToVcs}`));
+  
+  if (config.skillsConfig?.installed) {
+    const toolNames = config.skillsConfig.skillsInstallations?.length > 0
+      ? [...new Set(config.skillsConfig.skillsInstallations.map(inst => getAgentDisplayName(inst.agent)))].join(' / ')
+      : 'Claude Code';
+    console.log(chalk.gray(`  ${msg.restartAgent.replace('{tools}', toolNames)}`));
+    console.log(chalk.gray(`  4. ${msg.runCheck}`));
+  } else {
+    console.log(chalk.gray(`  3. ${msg.runCheck}`));
+  }
+  console.log();
+}

package/src/installers/skills-installer.js

@@ -0,0 +1,286 @@
+/**
+ * Skills and Commands Installer
+ *
+ * High-level orchestration layer for installing Skills and slash commands
+ * across multiple AI agents (Claude Code, OpenCode, Cursor, etc.).
+ *
+ * Architecture:
+ * - Coordinates between low-level installers (utils/skills-installer.js)
+ * - Handles remote downloads (utils/github.js)
+ * - Aggregates results from multiple agent installations
+ * - Provides user feedback via ora spinners
+ *
+ * @version 1.0.0
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import {
+  installSkillsToMultipleAgents,
+  installCommandsToMultipleAgents,
+  getAvailableSkillNames,
+  getAvailableCommandNames
+} from '../utils/skills-installer.js';
+import {
+  downloadSkillToLocation,
+  getSkillsDir,
+  getProjectSkillsDir,
+  writeSkillsManifest
+} from '../utils/github.js';
+import {
+  getAgentDisplayName,
+  getSkillsDirForAgent,
+  getCommandsDirForAgent
+} from '../config/ai-agent-paths.js';
+import { getRepositoryInfo } from '../utils/registry.js';
+
+/**
+ * Get all skill files mapping (skill name -> file paths)
+ * Used for remote download fallback
+ * @returns {Object} Mapping of skill names to file paths
+ */
+function getSkillFiles() {
+  const skills = getAvailableSkillNames();
+  const mapping = {};
+
+  for (const skillName of skills) {
+    // Default files in each skill directory
+    mapping[skillName] = [
+      `skills/claude-code/${skillName}/SKILL.md`,
+      `skills/claude-code/${skillName}/README.md`
+    ];
+  }
+
+  return mapping;
+}
+
+/**
+ * Install Skills to multiple AI agents
+ *
+ * Unified installation flow:
+ * 1. Determines installation targets (agents + levels)
+ * 2. Calls unified installer for local/bundled skills
+ * 3. Falls back to remote download if needed
+ * 4. Aggregates results and provides user feedback
+ *
+ * @param {Object} skillsConfig - Skills configuration
+ * @param {boolean} skillsConfig.needsInstall - Whether skills installation is needed
+ * @param {Array} skillsConfig.skillsInstallations - Array of {agent, level} objects
+ * @param {Array} skillsConfig.updateTargets - Legacy: array of 'user'/'project' strings
+ * @param {string} projectPath - Project root path
+ * @param {Object} messages - i18n messages object
+ * @param {Object} results - Results object to populate
+ * @returns {Promise<void>}
+ */
+export async function installSkills(skillsConfig, projectPath, messages, results) {
+  // Modern unified multi-agent installation
+  if (skillsConfig.needsInstall && skillsConfig.skillsInstallations?.length > 0) {
+    const skillSpinner = ora(messages.installingSkills).start();
+
+    // Use new unified installer for multi-agent support
+    const installResult = await installSkillsToMultipleAgents(
+      skillsConfig.skillsInstallations,
+      null, // Install all skills
+      projectPath
+    );
+
+    // Collect results
+    for (const agentResult of installResult.installations) {
+      if (agentResult.installed.length > 0) {
+        for (const skillName of agentResult.installed) {
+          if (!results.skills.includes(skillName)) {
+            results.skills.push(skillName);
+          }
+        }
+      }
+      for (const err of agentResult.errors) {
+        results.errors.push(`${agentResult.agent} - ${err.skill}: ${err.error}`);
+      }
+    }
+
+    // Collect skill file hashes for integrity tracking
+    if (installResult.allFileHashes) {
+      Object.assign(results.skillHashes, installResult.allFileHashes);
+    }
+
+    // Build location summary for display
+    const targetLocations = (skillsConfig.skillsInstallations || []).map(inst => {
+      const displayName = getAgentDisplayName(inst.agent);
+      const dir = getSkillsDirForAgent(inst.agent, inst.level, projectPath);
+      return `${displayName} (${dir})`;
+    }).join(', ');
+
+    if (installResult.totalErrors === 0) {
+      skillSpinner.succeed(messages.installedSkills
+        .replace('{count}', installResult.totalInstalled)
+        .replace('{locations}', targetLocations));
+    } else {
+      skillSpinner.warn(messages.installedSkillsWithErrors
+        .replace('{count}', installResult.totalInstalled)
+        .replace('{errors}', installResult.totalErrors));
+    }
+  } else if (skillsConfig.needsInstall && skillsConfig.updateTargets?.length > 0) {
+    // Legacy fallback for backward compatibility (remote download)
+    await installSkillsLegacy(skillsConfig, projectPath, messages, results);
+  }
+}
+
+/**
+ * Legacy skills installation (remote download)
+ * Used for backward compatibility with older configurations
+ *
+ * @param {Object} skillsConfig - Skills configuration
+ * @param {string} projectPath - Project root path
+ * @param {Object} messages - i18n messages object
+ * @param {Object} results - Results object to populate
+ * @returns {Promise<void>}
+ */
+async function installSkillsLegacy(skillsConfig, projectPath, messages, results) {
+  const skillSpinner = ora(messages.installingSkills).start();
+
+  const skillFiles = getSkillFiles();
+  let successCount = 0;
+  let errorCount = 0;
+
+  const repoInfo = getRepositoryInfo();
+
+  for (const target of skillsConfig.updateTargets) {
+    for (const [skillName, files] of Object.entries(skillFiles)) {
+      const result = await downloadSkillToLocation(
+        skillName,
+        files,
+        target,
+        target === 'project' ? projectPath : null
+      );
+
+      if (result.success) {
+        successCount++;
+        if (!results.skills.includes(skillName)) {
+          results.skills.push(skillName);
+        }
+      } else {
+        errorCount++;
+        const failedFiles = (result.files || []).filter(f => !f.success).map(f => f.file).join(', ');
+        results.errors.push(`Skill ${skillName} (${target}): failed to install ${failedFiles}`);
+      }
+    }
+
+    // Write manifest for each target location
+    const targetDir = target === 'project'
+      ? getProjectSkillsDir(projectPath)
+      : getSkillsDir();
+    writeSkillsManifest(repoInfo.skills.version, targetDir);
+  }
+
+  const targetLocations = skillsConfig.updateTargets.map(t =>
+    t === 'project' ? getProjectSkillsDir(projectPath) : getSkillsDir()
+  ).join(', ');
+
+  if (errorCount === 0) {
+    skillSpinner.succeed(messages.installedSkills
+      .replace('{count}', successCount)
+      .replace('{locations}', targetLocations));
+  } else {
+    skillSpinner.warn(messages.installedSkillsWithErrors
+      .replace('{count}', successCount)
+      .replace('{errors}', errorCount));
+  }
+}
+
+/**
+ * Install slash commands to multiple AI agents
+ *
+ * Supports agents that have separate command directories (OpenCode, Cursor, etc.)
+ * Claude Code merged commands into Skills in v2.1.3+
+ *
+ * @param {Object} skillsConfig - Skills configuration
+ * @param {Array} skillsConfig.commandsInstallations - Array of {agent, level} or agent strings
+ * @param {string} projectPath - Project root path
+ * @param {Object} messages - i18n messages object
+ * @param {Object} results - Results object to populate
+ * @returns {Promise<void>}
+ */
+export async function installCommands(skillsConfig, projectPath, messages, results) {
+  if (!skillsConfig.commandsInstallations || skillsConfig.commandsInstallations.length === 0) {
+    return;
+  }
+
+  const cmdSpinner = ora(messages.installingCommands || 'Installing slash commands...').start();
+
+  const cmdResult = await installCommandsToMultipleAgents(
+    skillsConfig.commandsInstallations,
+    null, // Install all commands
+    projectPath
+  );
+
+  // Initialize commands results array if not exists
+  results.commands = results.commands || [];
+
+  // Collect results
+  for (const agentResult of cmdResult.installations) {
+    if (agentResult.installed.length > 0) {
+      for (const cmdName of agentResult.installed) {
+        if (!results.commands.includes(cmdName)) {
+          results.commands.push(cmdName);
+        }
+      }
+    }
+    for (const err of agentResult.errors) {
+      results.errors.push(`${agentResult.agent} command - ${err.command}: ${err.error}`);
+    }
+  }
+
+  // Collect command file hashes for integrity tracking
+  if (cmdResult.allFileHashes) {
+    Object.assign(results.commandHashes, cmdResult.allFileHashes);
+  }
+
+  // Build location summary
+  const cmdLocations = (skillsConfig.commandsInstallations || []).map(item => {
+    // Support both {agent, level} objects and simple agent strings (backward compatibility)
+    const agent = typeof item === 'string' ? item : item.agent;
+    const level = typeof item === 'string' ? 'project' : (item.level || 'project');
+    const displayName = getAgentDisplayName(agent);
+    const dir = getCommandsDirForAgent(agent, level, projectPath);
+    return `${displayName} (${dir})`;
+  }).join(', ');
+
+  if (cmdResult.totalErrors === 0) {
+    cmdSpinner.succeed((messages.installedCommands || 'Installed {count} commands to: {locations}')
+      .replace('{count}', cmdResult.totalInstalled)
+      .replace('{locations}', cmdLocations));
+  } else {
+    cmdSpinner.warn((messages.installedCommandsWithErrors || 'Installed {count} commands with {errors} errors')
+      .replace('{count}', cmdResult.totalInstalled)
+      .replace('{errors}', cmdResult.totalErrors));
+  }
+}
+
+/**
+ * Get summary of installed skills and commands
+ *
+ * @param {Object} results - Installation results
+ * @returns {Object} Summary object
+ */
+export function getInstallationSummary(results) {
+  return {
+    skills: {
+      count: results.skills?.length || 0,
+      names: results.skills || []
+    },
+    commands: {
+      count: results.commands?.length || 0,
+      names: results.commands || []
+    },
+    errors: {
+      count: results.errors?.length || 0,
+      messages: results.errors || []
+    }
+  };
+}
+
+export default {
+  installSkills,
+  installCommands,
+  getInstallationSummary
+};