universal-dev-standards 3.0.0

package/src/commands/list.js

@@ -0,0 +1,100 @@
+import chalk from 'chalk';
+import {
+  getAllStandards,
+  getStandardsByLevel,
+  getStandardsByCategory,
+  getLevelInfo,
+  getCategoryInfo,
+  getRepositoryInfo
+} from '../utils/registry.js';
+
+/**
+ * List command - displays available standards
+ * @param {Object} options - Command options
+ */
+export function listCommand(options) {
+  const { level, category } = options;
+
+  console.log();
+  console.log(chalk.bold('Universal Development Standards'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  const repoInfo = getRepositoryInfo();
+  console.log(chalk.gray(`Version: ${repoInfo.standards.version}`));
+  console.log();
+
+  let standards;
+
+  if (level) {
+    const levelNum = parseInt(level, 10);
+    if (![1, 2, 3].includes(levelNum)) {
+      console.log(chalk.red('Error: Level must be 1, 2, or 3'));
+      process.exit(1);
+    }
+    standards = getStandardsByLevel(levelNum);
+    const levelInfo = getLevelInfo(levelNum);
+    console.log(chalk.cyan(`Showing Level ${levelNum}: ${levelInfo.name} (${levelInfo.nameZh})`));
+    console.log(chalk.gray(levelInfo.description));
+    console.log();
+  } else if (category) {
+    const categoryInfo = getCategoryInfo(category);
+    if (!categoryInfo) {
+      console.log(chalk.red(`Error: Unknown category '${category}'`));
+      console.log(chalk.gray('Valid categories: skill, reference, extension, integration, template'));
+      process.exit(1);
+    }
+    standards = getStandardsByCategory(category);
+    console.log(chalk.cyan(`Category: ${categoryInfo.name}`));
+    console.log(chalk.gray(categoryInfo.description));
+    console.log();
+  } else {
+    standards = getAllStandards();
+  }
+
+  // Group by category
+  const grouped = {};
+  for (const std of standards) {
+    if (!grouped[std.category]) {
+      grouped[std.category] = [];
+    }
+    grouped[std.category].push(std);
+  }
+
+  // Display each category
+  const categoryOrder = ['skill', 'reference', 'extension', 'integration', 'template'];
+
+  for (const cat of categoryOrder) {
+    if (!grouped[cat] || grouped[cat].length === 0) continue;
+
+    const catInfo = getCategoryInfo(cat);
+    console.log(chalk.yellow.bold(`${catInfo.name} (${grouped[cat].length})`));
+
+    for (const std of grouped[cat]) {
+      const levelBadge = chalk.gray(`[L${std.level}]`);
+      const name = std.skillName
+        ? chalk.green(`${std.name}`) + chalk.gray(` → ${std.skillName}`)
+        : chalk.white(std.name);
+
+      console.log(`  ${levelBadge} ${name}`);
+      // Handle source being an object with human/ai paths
+      const sourceDisplay = typeof std.source === 'object'
+        ? std.source.human || std.source.ai
+        : std.source;
+      console.log(chalk.gray(`       ${sourceDisplay}`));
+
+      if (std.applicability) {
+        console.log(chalk.gray(`       Applies to: ${std.applicability}`));
+      }
+    }
+    console.log();
+  }
+
+  // Summary
+  console.log(chalk.gray('─'.repeat(50)));
+  const skillCount = standards.filter(s => s.skillName).length;
+  const refCount = standards.filter(s => !s.skillName).length;
+  console.log(chalk.gray(`Total: ${standards.length} standards (${skillCount} with Skills, ${refCount} reference-only)`));
+  console.log();
+  console.log(chalk.gray('Run `uds init` to adopt standards in your project.'));
+  console.log(chalk.gray('See: https://github.com/AsiaOstrich/universal-dev-standards/blob/main/adoption/ADOPTION-GUIDE.md'));
+}

package/src/commands/update.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { readManifest, writeManifest, copyStandard, copyIntegration, isInitialized } from '../utils/copier.js';
+import { getRepositoryInfo } from '../utils/registry.js';
+
+// Integration file mappings (same as init.js)
+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'
+  }
+};
+
+/**
+ * Update command - update standards to latest version
+ * @param {Object} options - Command options
+ */
+export async function updateCommand(options) {
+  const projectPath = process.cwd();
+
+  console.log();
+  console.log(chalk.bold('Universal Documentation Standards - Update'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  // Check if initialized
+  if (!isInitialized(projectPath)) {
+    console.log(chalk.red('✗ Standards not initialized in this project.'));
+    console.log(chalk.gray('  Run `uds init` to initialize first.'));
+    console.log();
+    return;
+  }
+
+  // Read manifest
+  const manifest = readManifest(projectPath);
+  if (!manifest) {
+    console.log(chalk.red('✗ Could not read manifest file.'));
+    console.log();
+    return;
+  }
+
+  // Check versions
+  const repoInfo = getRepositoryInfo();
+  const currentVersion = manifest.upstream.version;
+  const latestVersion = repoInfo.standards.version;
+
+  console.log(chalk.gray(`Current version: ${currentVersion}`));
+  console.log(chalk.gray(`Latest version:  ${latestVersion}`));
+  console.log();
+
+  if (currentVersion === latestVersion) {
+    console.log(chalk.green('✓ Standards are up to date.'));
+    console.log();
+    return;
+  }
+
+  console.log(chalk.cyan(`Update available: ${currentVersion} → ${latestVersion}`));
+  console.log();
+
+  // List files to update
+  console.log(chalk.gray('Files to update:'));
+  for (const std of manifest.standards) {
+    console.log(chalk.gray(`  .standards/${std.split('/').pop()}`));
+  }
+  for (const ext of manifest.extensions) {
+    console.log(chalk.gray(`  .standards/${ext.split('/').pop()}`));
+  }
+  for (const int of manifest.integrations) {
+    console.log(chalk.gray(`  ${int}`));
+  }
+  console.log();
+
+  // Confirm
+  if (!options.yes) {
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Proceed with update? This will overwrite existing files.',
+        default: true
+      }
+    ]);
+
+    if (!confirmed) {
+      console.log(chalk.yellow('Update cancelled.'));
+      return;
+    }
+  }
+
+  // Perform update
+  console.log();
+  const spinner = ora('Updating standards...').start();
+
+  const results = {
+    updated: [],
+    errors: []
+  };
+
+  // Update standards
+  for (const std of manifest.standards) {
+    const result = copyStandard(std, '.standards', projectPath);
+    if (result.success) {
+      results.updated.push(std);
+    } else {
+      results.errors.push(`${std}: ${result.error}`);
+    }
+  }
+
+  // Update extensions
+  for (const ext of manifest.extensions) {
+    const result = copyStandard(ext, '.standards', projectPath);
+    if (result.success) {
+      results.updated.push(ext);
+    } else {
+      results.errors.push(`${ext}: ${result.error}`);
+    }
+  }
+
+  // Update integrations
+  for (const int of manifest.integrations) {
+    // Find the mapping for this integration
+    let mapping = null;
+    for (const [, m] of Object.entries(INTEGRATION_MAPPINGS)) {
+      if (m.target === int) {
+        mapping = m;
+        break;
+      }
+    }
+
+    if (mapping) {
+      const result = copyIntegration(mapping.source, mapping.target, projectPath);
+      if (result.success) {
+        results.updated.push(int);
+      } else {
+        results.errors.push(`${int}: ${result.error}`);
+      }
+    }
+  }
+
+  spinner.succeed(`Updated ${results.updated.length} files`);
+
+  // Update manifest
+  manifest.upstream.version = latestVersion;
+  manifest.upstream.installed = new Date().toISOString().split('T')[0];
+  writeManifest(manifest, projectPath);
+
+  // Summary
+  console.log();
+  console.log(chalk.green('✓ Standards updated successfully!'));
+  console.log(chalk.gray(`  Version: ${currentVersion} → ${latestVersion}`));
+
+  if (results.errors.length > 0) {
+    console.log();
+    console.log(chalk.yellow(`⚠ ${results.errors.length} file(s) could not be updated:`));
+    for (const err of results.errors) {
+      console.log(chalk.gray(`    ${err}`));
+    }
+  }
+
+  // Skills update reminder
+  if (manifest.skills.installed) {
+    const skillsVersion = repoInfo.skills.version;
+    if (manifest.skills.version !== skillsVersion) {
+      console.log();
+      console.log(chalk.cyan('Skills update available:'));
+      console.log(chalk.gray(`  Current: ${manifest.skills.version || 'unknown'}`));
+      console.log(chalk.gray(`  Latest:  ${skillsVersion}`));
+      console.log(chalk.gray('  Run the following to update:'));
+      console.log(chalk.gray('    cd path/to/universal-dev-skills && git pull && ./install.sh'));
+    }
+  }
+
+  console.log();
+}

package/src/index.js

@@ -0,0 +1,7 @@
+// Universal Documentation Standards CLI
+// Main entry point
+
+export { listCommand } from './commands/list.js';
+export { initCommand } from './commands/init.js';
+export { checkCommand } from './commands/check.js';
+export { updateCommand } from './commands/update.js';